notebooks/target_space.ipynb

{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  }
 },
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "! wget https://zenodo.org/records/8230057/files/TomatenMarc/TACO-Public-Data.zip\n",
    "! unzip TACO-Public-Data.zip"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "7sxpF95DZtzr"
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from google.colab import drive\n",
    "drive.mount('/content/drive')\n",
    "%cd /content/drive/MyDrive/Colab Notebooks/Feger/twitter-taco-fiesta"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "8kd6RAqPZtzs"
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Prerequisite"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "McwMTtLjZtzt"
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.preprocessing import normalize\n",
    "from tqdm import tqdm\n",
    "\n",
    "# Initialize tqdm for monitoring progress\n",
    "tqdm.pandas()\n",
    "# Initialize plt for dark background\n",
    "plt.style.use(\"classic\")"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "esWoX11K50zP"
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "NONE = \"None\"\n",
    "NOTIFICATION = \"Notification\"\n",
    "STATEMENT = \"Statement\"\n",
    "REASON = \"Reason\"\n",
    "UNDECIDED = \"Undecided\"\n",
    "\n",
    "random_seed = 123456789"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "7Ox4zUrX50zQ"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "# Read the CSV file \"backup_tweets.csv\" into a DataFrame.\n",
    "# The tweet_id column is used as the index, and the lineterminator is set to \"\\n\" to avoid issues with line endings.\n",
    "backup_tweets = pd.read_csv(\"./data/backup_tweets.csv\", index_col=\"tweet_id\", lineterminator=\"\\n\")\n",
    "\n",
    "# Read the CSV file \"majority_votes.csv\" into another DataFrame.\n",
    "# The tweet_id column is used as the index.\n",
    "df_majority_votes = pd.read_csv(\"/content/TomatenMarc-TACO-aa2c0cc/data/majority_votes.csv\", index_col=\"tweet_id\")\n",
    "\n",
    "# Filter out rows where the class is UNDECIDED from df_majority_votes.\n",
    "df_majority_votes = df_majority_votes[df_majority_votes[\"class\"] != UNDECIDED]\n",
    "\n",
    "# This operation adds the \"text\" information from backup_tweets to df_majority_votes, based on the common \"tweet_id\".\n",
    "df_majority_votes = df_majority_votes.merge(backup_tweets.text, on=\"tweet_id\")"
   ],
   "metadata": {
    "id": "iLToqmOW-_-Y",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def load_embeddings(df_, embeddings_save_path):\n",
    "    # Load the embeddings\n",
    "    embeddings_dict = np.load(embeddings_save_path, allow_pickle=True).item()\n",
    "    assert all(df_.index.isin(embeddings_dict.keys()))\n",
    "    assert sorted(df_.index) == sorted(embeddings_dict.keys())\n",
    "\n",
    "    # Extract the embeddings and tweet IDs from the filtered embeddings_dict\n",
    "    embeddings = list(embeddings_dict.values())\n",
    "    tweet_ids = list(embeddings_dict.keys())\n",
    "\n",
    "    # Create a DataFrame from the embeddings\n",
    "    df_embeddings = pd.DataFrame(embeddings)\n",
    "\n",
    "    # Add the tweet IDs, labels, and topics as columns in the DataFrame\n",
    "    df_embeddings[\"tweet_id\"] = tweet_ids\n",
    "\n",
    "    # Set the tweet_id as the index\n",
    "    df_embeddings.set_index(\"tweet_id\", inplace=True)\n",
    "\n",
    "    # Add the true class labels\n",
    "    df_embeddings = df_embeddings.merge(df_[\"class\"], on=\"tweet_id\")\n",
    "    assert all(~df_embeddings[\"class\"].isna())\n",
    "\n",
    "    # Add the preprocessed text as required by BERTweet\n",
    "    df_embeddings = df_embeddings.merge(df_[\"text\"], on=\"tweet_id\")\n",
    "    assert all(~df_embeddings[\"text\"].isna())\n",
    "\n",
    "    return df_embeddings"
   ],
   "metadata": {
    "id": "ZNOVSkAUUe-K",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "df_bertweet_embeddings = load_embeddings(df_majority_votes, \"./data/bertweet-base-embeddings-cls.npy\")\n",
    "df_taco_augm_embeddings = load_embeddings(df_majority_votes, \"./data/augmented-taco-embeddings-cls.npy\")\n",
    "df_wrapresentations_embeddings = load_embeddings(df_majority_votes, \"./data/wrapresentations-embeddings-cls.npy\")"
   ],
   "metadata": {
    "id": "vJuaLxonatqZ",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# TSNE Visualization"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    },
    "id": "Ll48_TcN50zU"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def mirror_point_along_first_bisection(point):\n",
    "    # Calculate the mirrored point along the first bisector\n",
    "    mirrored_x = point[1]\n",
    "    mirrored_y = point[0]\n",
    "\n",
    "    return pd.Series({'information': mirrored_x, 'inference': mirrored_y})\n",
    "\n",
    "def perform_tsne_rotation(df_, rotation_sectors=0, mirror_first_bisector=True):\n",
    "    # Extract the feature matrix (X) and the target vector (y) from df_ (last two columns are class and text)\n",
    "    X = df_.iloc[:, :-2].values\n",
    "    y = df_.iloc[:, -2].values\n",
    "\n",
    "    # Perform t-SNE dimensionality reduction on the feature matrix X\n",
    "    tsne = TSNE(random_state=random_seed,\n",
    "                init=\"pca\",  # Use PCA initialization (default in version 1.2)\n",
    "                metric=\"cosine\")  # Use cosine distance metric\n",
    "    df_manifold = pd.DataFrame(normalize(tsne.fit_transform(X)), columns=['information', 'inference'])\n",
    "\n",
    "    # Add a 'class' column to df_manifold to represent the target variable\n",
    "    df_manifold[\"class\"] = y\n",
    "\n",
    "    # Add the 'text' column to df_manifold to keep the text\n",
    "    df_manifold[\"text\"] = df_[\"text\"].values\n",
    "\n",
    "    # Set the 'tweet_id' column as the index\n",
    "    df_manifold[\"tweet_id\"] = df_.index.values\n",
    "    df_manifold.set_index(\"tweet_id\", inplace=True)\n",
    "\n",
    "    # Convert rotation angle to radians\n",
    "    rotation_angle_rad = np.radians(rotation_sectors * 45)\n",
    "\n",
    "    # Perform rotation transformation\n",
    "    rotation_matrix = np.array([[np.cos(rotation_angle_rad), -np.sin(rotation_angle_rad)],\n",
    "                                [np.sin(rotation_angle_rad), np.cos(rotation_angle_rad)]])\n",
    "\n",
    "    rotated_coordinates = np.dot(df_manifold[[\"information\", \"inference\"]], rotation_matrix)\n",
    "\n",
    "    # Update the rotated coordinates in the DataFrame\n",
    "    df_manifold[\"information\"] = rotated_coordinates[:, 0]\n",
    "    df_manifold[\"inference\"] = rotated_coordinates[:, 1]\n",
    "\n",
    "    if mirror_first_bisector:\n",
    "        # Mirror the 'information' and 'inference' columns along the first bisector\n",
    "        df_manifold[[\"information\", \"inference\"]] = df_manifold[[\"information\", \"inference\"]].apply(mirror_point_along_first_bisection, axis=1)\n",
    "\n",
    "    return df_manifold"
   ],
   "metadata": {
    "id": "UBKBOlDOVe9t",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def plot_density(df_, class_name=\"All\", ax=None, cbar=False):\n",
    "    if class_name != \"All\" and (class_name in df_[\"class\"].unique()):\n",
    "        df_ = df_[df_[\"class\"]==class_name]\n",
    "    assert len(df_[\"class\"].unique()) > 0\n",
    "\n",
    "    # Set the number of x and y bins\n",
    "    num_x_bins = 20\n",
    "    num_y_bins = 20\n",
    "\n",
    "    # Extract relevant data for histogram creation\n",
    "    x = df_[\"information\"]\n",
    "    y = df_[\"inference\"]\n",
    "\n",
    "    # Compute the 2D histogram\n",
    "    hist, x_edges, y_edges = np.histogram2d(x, y, bins=[num_x_bins, num_y_bins], range=[[-1.2, 1.2], [-1.2, 1.2]])\n",
    "\n",
    "    # Create the plot\n",
    "    ax.imshow(hist.T, # todo: is this necessary?\n",
    "              origin=\"lower\",\n",
    "              cmap=\"turbo\",\n",
    "              interpolation=\"hanning\",\n",
    "              extent=[x_edges[0], x_edges[-1], y_edges[0], y_edges[-1]])\n",
    "\n",
    "    if cbar:\n",
    "        ax.figure.colorbar(ax.images[0], ax=ax, label=\"Density\")\n",
    "\n",
    "    return ax\n",
    "\n",
    "def plot_target_space(ax, fontsize=6, show_ax_labels=False):\n",
    "    # Plotting\n",
    "    ax.axhline(0, color=\"white\", linestyle=\"--\", linewidth=0.5)  # Vertical line for x-axis\n",
    "    ax.axvline(0, color=\"white\", linestyle=\"--\", linewidth=0.5)  # Vertical line for y-axis\n",
    "    ax.plot([-1, 1], [-1, 1], color=\"white\", linestyle=\"--\", linewidth=0.5)  # Diagonal line 1\n",
    "    ax.plot([-1, 1], [1, -1], color=\"white\", linestyle=\"--\", linewidth=0.5)  # Diagonal line 2\n",
    "\n",
    "    # Add a circle with radius 1\n",
    "    circle = plt.Circle((0, 0), radius=1, color=\"white\", fill=False, linestyle=\"--\", linewidth=0.5)\n",
    "    ax.add_artist(circle)\n",
    "\n",
    "    # Add texts\n",
    "    ax.text(-0.93, 1.1, \"Statement\", color=\"white\", fontsize=fontsize, ha=\"center\", va=\"center\")\n",
    "    ax.text(1, 1.1, \"Reason\", color=\"white\", fontsize=fontsize, ha=\"center\", va=\"center\")\n",
    "    ax.text(-1.03, -1.1, \"None\", color=\"white\", fontsize=fontsize, ha=\"center\", va=\"center\")\n",
    "    ax.text(0.93, -1.1, \"Notification\", color=\"white\", fontsize=fontsize, ha=\"center\", va=\"center\")\n",
    "    if show_ax_labels:\n",
    "        ax.text(-0.05, 0.5, \"inference\", color=\"white\", fontsize=fontsize*0.8, ha=\"center\", va=\"center\", rotation=90)\n",
    "        ax.text(-0.05, -0.5, \"no-inference\", color=\"white\", fontsize=fontsize*0.8, ha=\"center\", va=\"center\", rotation=90)\n",
    "        ax.text(0.5, 0.05, \"information\", color=\"white\", fontsize=fontsize*0.8, ha=\"center\", va=\"center\")\n",
    "        ax.text(-0.5, 0.05, \"no-information\", color=\"white\", fontsize=fontsize*0.8, ha=\"center\", va=\"center\")"
   ],
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "id": "cvKRvSJN50zU"
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def filter_points_by_sector(df_, sector):\n",
    "    if sector == \"Reason\":\n",
    "        return df_[(df_[\"information\"] >= 0) & (df_[\"inference\"] >= 0)]\n",
    "    elif sector == \"Statement\":\n",
    "        return df_[(df_[\"information\"] <= 0) & (df_[\"inference\"] >= 0)]\n",
    "    elif sector == \"Notification\":\n",
    "        return df_[(df_[\"information\"] >= 0) & (df_[\"inference\"] <= 0)]\n",
    "    elif sector == \"None\":\n",
    "        return df_[(df_[\"information\"] <= 0) & (df_[\"inference\"] <= 0)]\n",
    "    return df_"
   ],
   "metadata": {
    "id": "5CQacL-HPfBu",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# The independence in applying rotations to separate datasets comes from the fact that the rotation matrix is a linear transformation.\n",
    "# Linear transformations satisfy the properties of associativity and distributivity in matrix multiplication, which allows to apply rotations separately to each dataset.\n",
    "# This provides the flexibility to compare and visualize the datasets from different perspectives by applying different rotation angles independently.\n",
    "df_bertweet_manifold = perform_tsne_rotation(df_bertweet_embeddings, rotation_sectors=3.5, mirror_first_bisector=True)\n",
    "df_taco_augm_manifold = perform_tsne_rotation(df_taco_augm_embeddings, rotation_sectors=3.5, mirror_first_bisector=True)\n",
    "df_wrapresentations_manifold = perform_tsne_rotation(df_wrapresentations_embeddings, rotation_sectors=2.25, mirror_first_bisector=False)"
   ],
   "metadata": {
    "id": "KFrnOjoBbb9F",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def plot_subplots_with_dataframes(dataframes, plot_title=None, pdf_filename=None):\n",
    "    # Create a 2x4 grid of subplots with a figure size of 12x6\n",
    "    fig, axes = plt.subplots(2, 4, figsize=(12, 6))\n",
    "\n",
    "    for row, df in enumerate(dataframes):\n",
    "        for col, var in enumerate([REASON, STATEMENT, NOTIFICATION, NONE]):\n",
    "            # Plot the target space in the current subplot\n",
    "            plot_target_space(axes[row, col])\n",
    "            # Plot the density for the specific class in the current subplot\n",
    "            plot_density(df, var, axes[row, col], cbar=False)\n",
    "            # Set the title for the subplot based on the class variable\n",
    "            if row == 0:\n",
    "                axes[row, col].set_title(f\"{var}\")\n",
    "            # Set the ylabel for the first row of subplots\n",
    "            if row == 0 and col == 0:\n",
    "                axes[row, col].set_ylabel(\"Vanilla BERTweet\")\n",
    "            # Set the ylabel for the second row of subplots\n",
    "            if row == 1 and col == 0:\n",
    "                axes[row, col].set_ylabel(\"WRAPresentations\")\n",
    "            # Remove x and y ticks from all subplots\n",
    "            axes[row, col].set_xticks([])\n",
    "            axes[row, col].set_yticks([])\n",
    "\n",
    "    # Add a title to the entire plot\n",
    "    if plot_title:\n",
    "        fig.suptitle(plot_title, fontsize=16)\n",
    "\n",
    "    # Adjust spacing between subplots\n",
    "    plt.tight_layout()\n",
    "\n",
    "     # Check if the plot should be saved as a PDF\n",
    "    if pdf_filename:\n",
    "        plt.savefig(pdf_filename, format='pdf', bbox_inches='tight')\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()"
   ],
   "metadata": {
    "id": "M_4dTP7BebZW",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# plot the example target space\n",
    "examples = []\n",
    "for coordinates, var in zip(normalize([[1, 1], [1, 2], [1, -1], [-1, 1], [-1, -1]]), [\"Reason\", \"Reason\", \"Statement\", \"Notification\", \"None\"]):\n",
    "    examples.append({\"inference\": coordinates[0], \"information\": coordinates[1], \"class\": var})\n",
    "examples = pd.DataFrame.from_dict(examples)\n",
    "\n",
    "fig, axes = plt.subplots()\n",
    "plot_target_space(axes, fontsize=14, show_ax_labels=True)\n",
    "axes.set_xticks([])\n",
    "axes.set_yticks([])\n",
    "plot_density(examples, \"All\", axes, cbar=False)\n",
    "plt.savefig(\"./outputs/target_space.pdf\", format='pdf', bbox_inches='tight')\n",
    "plt.savefig(\"./outputs/target_space.svg\", format='svg', bbox_inches='tight')"
   ],
   "metadata": {
    "id": "DNiA2ug6_oIs",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# plot overall embedding space\n",
    "dataframes = [df_bertweet_manifold, df_wrapresentations_manifold]\n",
    "plot_subplots_with_dataframes(dataframes, pdf_filename=\"./outputs/sector_purity_coordinates.pdf\")"
   ],
   "metadata": {
    "id": "dg0mDpZX1XC9",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Class distribution in sectors"
   ],
   "metadata": {
    "id": "fdy_Z2aaHxWN",
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "source": [
    "def calculate_class_counts_ratio(df, ratio=False):\n",
    "    # Calculate the original counts of each class in the dataframe\n",
    "    df_original = pd.DataFrame(df.groupby(\"class\").size())\n",
    "    df_original = df_original.rename(columns={0: \"count\"})\n",
    "    df_original = df_original.reindex([REASON, STATEMENT, NOTIFICATION, NONE])\n",
    "    count = {}\n",
    "    for cls in df[\"class\"].unique():\n",
    "        # Filter the dataframe to get points only for the current class\n",
    "        df_tmp = filter_points_by_sector(df, cls)\n",
    "        # Calculate the counts for the current class and reindex to match the order of the original classes\n",
    "        df_tmp = pd.DataFrame(df_tmp.groupby(\"class\").size())\n",
    "        df_tmp = df_tmp.reindex(df_original.index)\n",
    "        df_tmp = df_tmp.rename(columns={0: \"count\"})\n",
    "        # Store the counts for the current class in the 'count' dictionary\n",
    "        count[cls] = df_tmp[\"count\"]\n",
    "        # Calculate the total count of points for the current class and add it as a column 'Size'\n",
    "        count[cls][\"Size\"] = round(df_tmp[\"count\"].sum())\n",
    "    # Create a DataFrame 'df_count' with the counts for each class and the total count for each sector\n",
    "    df_count = pd.DataFrame(count)\n",
    "    df_count = df_count.reindex(columns=df_original.index)\n",
    "    df_count = df_count.rename_axis(\"sector\")\n",
    "    df_count[\"Total\"] = df_count.sum(axis=1)\n",
    "    # Check if the calculated totals match the original counts of each class\n",
    "    assert all(df_count[\"Total\"][[REASON, STATEMENT, NOTIFICATION, NONE]] == df_original[\"count\"].values)\n",
    "    # If 'ratio' is True, calculate the ratio of counts for each class in a specific sector\n",
    "    if ratio:\n",
    "        for cls in [REASON, STATEMENT, NOTIFICATION, NONE]:\n",
    "            df_count.loc[cls] /= df_count.loc[cls]['Total']\n",
    "    df_count = df_count.where(pd.notna(df_count), 0)\n",
    "    return df_count.round(4)"
   ],
   "metadata": {
    "id": "upOunx7sF8hr",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# show class distribution for entire embeddings space\n",
    "print('Class distribution in percent of all 1734 tweets:')\n",
    "df_entire_count_base = calculate_class_counts_ratio(df_bertweet_manifold, ratio=True)\n",
    "print(df_entire_count_base)\n",
    "print('+++++++++++++')\n",
    "df_entire_count_augm = calculate_class_counts_ratio(df_taco_augm_manifold, ratio=True)\n",
    "print(df_entire_count_augm)\n",
    "print('+++++++++++++')\n",
    "df_entire_count_wrap = calculate_class_counts_ratio(df_wrapresentations_manifold, ratio=True)\n",
    "print(df_entire_count_wrap)"
   ],
   "metadata": {
    "id": "_ekUQT9QMd_L",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "def plot_class_counts_comparison(df_a, name_a, df_b, name_b, df_c, name_c, class_names, plot_title=None, pdf_filename=None):\n",
    "    # Create a 1x4 plot\n",
    "    fig, axes = plt.subplots(1, 4, figsize=(12, 3))  # Adjust figsize to fit the 4 subplots\n",
    "\n",
    "    # Loop over class names and create bar plots in each subplot\n",
    "    for i, class_name in enumerate(class_names):\n",
    "        counts_a = df_a.loc[class_name][:-1]\n",
    "        counts_b = df_b.loc[class_name][:-1]\n",
    "        counts_c = df_c.loc[class_name][:-1]\n",
    "        total_count = sum(counts_a)  # Assuming counts are the same for class_a, class_b, and class_c\n",
    "        bins = range(len(class_names))\n",
    "\n",
    "        axes[i].bar(bins, counts_a / total_count * 100, width=0.25, edgecolor=\"black\", color='white', hatch='\\\\\\\\\\\\', label=name_a)\n",
    "        axes[i].bar([x + 0.25 for x in bins], counts_b / total_count * 100, width=0.25, edgecolor=\"black\", color='white', hatch='///', label=name_b)\n",
    "        axes[i].bar([x + 0.5 for x in bins], counts_c / total_count * 100, width=0.25, edgecolor=\"black\", color='white', hatch='...', label=name_c)\n",
    "\n",
    "        # Set x-axis tick positions and labels\n",
    "        axes[i].set_xticks([x + 0.25 for x in bins])\n",
    "        axes[i].set_xticklabels(class_names, rotation=25)\n",
    "        axes[i].set_ylim(0, 100)  # Set the y-axis limit to percentages\n",
    "\n",
    "        axes[i].set_title(class_name)\n",
    "\n",
    "        # Remove y axis labels for all subplots except the first one (index 0)\n",
    "        if i > 0:\n",
    "            axes[i].set_yticklabels([])\n",
    "\n",
    "        # Add percentage values centered and rotated over the bars with smaller font size\n",
    "        for x, count in zip(bins, counts_a):\n",
    "            axes[i].text(x, count / total_count * 100 + 8, f\"{count / total_count * 100:.0f}%\", ha='center', fontsize=5, rotation=0)\n",
    "        for x, count in zip(bins, counts_b):\n",
    "            axes[i].text(x + 0.28, count / total_count * 100 + 8, f\"{count / total_count * 100:.0f}%\", ha='center', fontsize=5, rotation=0)\n",
    "        for x, count in zip(bins, counts_c):\n",
    "            axes[i].text(x + 0.55, count / total_count * 100 + 8, f\"{count / total_count * 100:.0f}%\", ha='center', fontsize=5, rotation=0)\n",
    "\n",
    "    # Add a legend to the first subplot (index 0)\n",
    "    axes[0].legend(loc='upper right', prop={'size': 6})\n",
    "\n",
    "    # Add a title to the entire plot\n",
    "    if plot_title:\n",
    "        fig.suptitle(plot_title, fontsize=16)\n",
    "\n",
    "    # Adjust spacing between subplots and title\n",
    "    plt.tight_layout(rect=[0, 0.03, 1, 0.95])\n",
    "\n",
    "    # Check if the plot should be saved as a PDF\n",
    "    if pdf_filename:\n",
    "        plt.savefig(pdf_filename, format='pdf', bbox_inches='tight')\n",
    "\n",
    "    # Show the plot\n",
    "    plt.show()\n"
   ],
   "metadata": {
    "id": "zdh9z1XKxdWq",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "source": [
    "# List of class names\n",
    "class_names = [\"Reason\", \"Statement\", \"Notification\", \"None\"]\n",
    "\n",
    "# plot the sector distribution for the entire dataset\n",
    "plot_class_counts_comparison(df_entire_count_base, \"Vanilla BERTweet\", df_entire_count_augm, \"Augmented BERTweet\", df_entire_count_wrap, \"WRAPresentations\", class_names, pdf_filename=\"./outputs/sector_purity_boxblot.pdf\")"
   ],
   "metadata": {
    "id": "CqHkGlLZxuqk",
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "execution_count": null,
   "outputs": []
  }
 ]
}