Wassa_2023_Shared_Task_EMO_EDA.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#Exploratory Data Analysis for EMO Shared Task, WASSA 2023"
      ],
      "metadata": {
        "id": "XXroCCXdd-EW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#import necessary libraries\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.feature_extraction.text import CountVectorizer\n",
        "import nltk\n",
        "from nltk.corpus import stopwords\n",
        "import spacy\n",
        "\n",
        "#settings\n",
        "nlp = spacy.load('en_core_web_sm')\n",
        "nltk.download('stopwords')\n",
        "stop_words = list(set(stopwords.words('english')))\n",
        "sns.set_style('whitegrid')"
      ],
      "metadata": {
        "id": "YfbUua8-eL1J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sJl0Dbknd7C7"
      },
      "outputs": [],
      "source": [
        "#get training and development data\n",
        "train_data =pd.read_csv('/content/WASSA23_essay_level_with_labels_train.tsv', sep=\"\\t\")\n",
        "train_data = train_data[['emotion', 'essay']]\n",
        "dev_data = pd.read_csv(\"WASSA23_essay_level_dev.tsv\", sep=\"\\t\")\n",
        "df = pd.read_csv('/content/goldstandard_dev.tsv', sep=\"\\t\", names=['1', '2', 'emotion',1,2,3,4,5,6,7,8,9])\n",
        "dev_data['emotion'] = df['emotion']\n",
        "dev_data = dev_data[['emotion', 'essay']]"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Number of essays per emotion"
      ],
      "metadata": {
        "id": "l9ebAnX_emV7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#plot a bar chart of number of essays per emotion for training data\n",
        "train_data['emotion'].value_counts().plot(kind='bar', title='Number of essays per emotion for training data', xlabel='Emotion', ylabel='Number of essays')"
      ],
      "metadata": {
        "id": "2YFvjybwevEx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#plot a bar chart of number of essays per emotion for development data\n",
        "dev_data['emotion'].value_counts().plot(kind='bar', title='Number of essays per emotion for development data', xlabel='Emotion', ylabel='Number of essays')"
      ],
      "metadata": {
        "id": "4YeTZPrZfPkd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## How many essays have multiple emotions?"
      ],
      "metadata": {
        "id": "bxZZNxBafk6T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#apply a function that checks if multiple emotions exist to each row\n",
        "train_data['multiple_emotions'] = train_data['emotion'].apply(lambda x: \"Yes\" if len(x.split(\"/\")) > 1 else \"No\")\n",
        "\n",
        "#plot\n",
        "train_data['multiple_emotions'].value_counts().plot(kind='bar', title='Number of essays with multiple emotions (training data)', xlabel='Multiple emotions', ylabel='Number of essays')"
      ],
      "metadata": {
        "id": "nS-nCs9LfpAJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#apply a function that checks if multiple emotions exist to each row\n",
        "dev_data['multiple_emotions'] = dev_data['emotion'].apply(lambda x: \"Yes\" if len(x.split(\"/\")) > 1 else \"No\")\n",
        "\n",
        "#plot\n",
        "dev_data['multiple_emotions'].value_counts().plot(kind='bar', title='Number of essays with multiple emotions (development data)', xlabel='Multiple emotions', ylabel='Number of essays')"
      ],
      "metadata": {
        "id": "fmI_XvBuf5b6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Number of words in each essay"
      ],
      "metadata": {
        "id": "3h9-r1_EgCHh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#get word count for each essay\n",
        "train_data['essay_word_count'] = train_data['essay'].apply(lambda x: len(x.split()))\n",
        "\n",
        "#plot a histogram\n",
        "sns.distplot(train_data['essay_word_count'], kde=False, bins=50)\n",
        "\n",
        "#add a vertical line to the plot to show the mean\n",
        "plt.axvline(train_data['essay_word_count'].mean(), color='k', linestyle='dashed', linewidth=1)\n",
        "\n",
        "#add title and labels\n",
        "plt.title('Number of words in each essay (training data)')\n",
        "plt.xlabel('Number of words')\n",
        "plt.ylabel('Number of essays')\n",
        "\n",
        "#add legend\n",
        "plt.legend({'Mean':train_data['essay_word_count'].mean()})"
      ],
      "metadata": {
        "id": "i3ghuU2QgFLr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#get word count for each essay\n",
        "dev_data['essay_word_count'] = dev_data['essay'].apply(lambda x: len(x.split()))\n",
        "\n",
        "#plot a histogram\n",
        "sns.distplot(dev_data['essay_word_count'], kde=False, bins=50)\n",
        "\n",
        "#add a vertical line to the plot to show the mean\n",
        "plt.axvline(dev_data['essay_word_count'].mean(), color='k', linestyle='dashed', linewidth=1)\n",
        "\n",
        "#add title and labels\n",
        "plt.title('Number of words in each essay (development data)')\n",
        "plt.xlabel('Number of words')\n",
        "plt.ylabel('Number of essays')\n",
        "\n",
        "#add legend\n",
        "plt.legend({'Mean':dev_data['essay_word_count'].mean()})"
      ],
      "metadata": {
        "id": "kFQQmPZ4hmsz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Words with highest frequency"
      ],
      "metadata": {
        "id": "4pB49H4ih_3o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "#create a function to get top n words\n",
        "def get_top_n_words(corpus, n=None, remove_stopwords=True, verb_only=False, obj_only= False):\n",
        "    '''\n",
        "    List the top n words in a vocabulary according to occurrence in a text corpus.\n",
        "    '''\n",
        "\n",
        "    #error handling\n",
        "    if verb_only and obj_only:\n",
        "        print(\"Both verb_only and obj_only cannot be true, setting verb_only to False\")\n",
        "        verb_only=False\n",
        "    \n",
        "    #remove stopwords\n",
        "    if remove_stopwords:\n",
        "\n",
        "        #get only the verbs using spacy\n",
        "        if verb_only:\n",
        "            vec = CountVectorizer(tokenizer=lambda doc: [token.lemma_ for token in nlp(doc) if token.pos_ == \"VERB\"], stop_words=stop_words).fit(corpus)\n",
        "        \n",
        "        #get only objects using spacy\n",
        "        elif obj_only:  \n",
        "            vec = CountVectorizer(tokenizer=lambda doc: [token.lemma_ for token in nlp(doc) if token.dep_ == \"dobj\"], stop_words=stop_words).fit(corpus)\n",
        "        \n",
        "        #keep all the remaining words\n",
        "        else: \n",
        "            vec = CountVectorizer(stop_words=stop_words).fit(corpus)\n",
        "    \n",
        "    #don't remove stopwords\n",
        "    else:\n",
        "\n",
        "        #get only the verbs using spacy\n",
        "        if verb_only:\n",
        "            vec = CountVectorizer(tokenizer=lambda doc: [token.lemma_ for token in nlp(doc) if token.pos_ == \"VERB\"], stop_words=stop_words).fit(corpus)\n",
        "        \n",
        "        #get only the objects using spacy\n",
        "        elif obj_only:\n",
        "            vec = CountVectorizer(tokenizer=lambda doc: [token.lemma_ for token in nlp(doc) if token.dep_ == \"dobj\"]).fit(corpus)\n",
        "        \n",
        "        #keep all words\n",
        "        else:\n",
        "            vec = CountVectorizer().fit(corpus)\n",
        "    \n",
        "    #create bag of words\n",
        "    bag_of_words = vec.transform(corpus)\n",
        "    sum_words = bag_of_words.sum(axis=0) \n",
        "    \n",
        "    #create a list of frequency of each words\n",
        "    words_freq = [(word, sum_words[0, idx]) for word, idx in     \n",
        "                  vec.vocabulary_.items()]\n",
        "    \n",
        "    #sort\n",
        "    words_freq =sorted(words_freq, key = lambda x: x[1], \n",
        "                       reverse=True)\n",
        "    \n",
        "    #return\n",
        "    return words_freq[:n]"
      ],
      "metadata": {
        "id": "dJ-2wLn3iANw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#get top n words\n",
        "top_words = get_top_n_words(train_data['essay'], n=20)\n",
        "x,y = map(list, zip(*top_words))\n",
        "\n",
        "\n",
        "#plot\n",
        "plt.figure(figsize=(15,10))\n",
        "plt.bar(x,y)\n",
        "plt.title('Words with highest frequency (training data)')\n",
        "plt.xlabel('Word')\n",
        "plt.ylabel('Frequency')\n"
      ],
      "metadata": {
        "id": "aahgj0MQiDNc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#get top n words\n",
        "top_words = get_top_n_words(dev_data['essay'], n=20)\n",
        "x,y = map(list, zip(*top_words))\n",
        "\n",
        "#plot\n",
        "plt.figure(figsize=(15,10))\n",
        "plt.bar(x,y)\n",
        "plt.title('Words with highest frequency (development data)')\n",
        "plt.xlabel('Word')\n",
        "plt.ylabel('Frequency')\n"
      ],
      "metadata": {
        "id": "r6n8FVMmib8u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#removing stopwords\n",
        "top_words = get_top_n_words(train_data['essay'], n=20, remove_stopwords=True)\n",
        "x,y = map(list, zip(*top_words))\n",
        "\n",
        "plt.figure(figsize=(15,10))\n",
        "plt.bar(x,y)\n",
        "plt.title('Words with highest frequency without stopwords(training data)')\n",
        "plt.xlabel('Word')\n",
        "plt.ylabel('Frequency')\n"
      ],
      "metadata": {
        "id": "MIYCNllDijTR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#removing stopwords, dev data\n",
        "top_words = get_top_n_words(dev_data['essay'], n=20, remove_stopwords=True)\n",
        "x,y = map(list, zip(*top_words))\n",
        "\n",
        "plt.figure(figsize=(15,10))\n",
        "plt.bar(x,y)\n",
        "plt.title('Words with highest frequency without stopwords (development data)')\n",
        "plt.xlabel('Word')\n",
        "plt.ylabel('Frequency')\n"
      ],
      "metadata": {
        "id": "tSNw4eX_i_PM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Top words per emotion"
      ],
      "metadata": {
        "id": "DSOjTzWkjFIG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#getting top words per emotion\n",
        "def get_top_n_words_per_emotion(data, n=None, remove_stopwords=False, verb_only = False, obj_only=False):\n",
        "    '''\n",
        "    List the top n words per emotion.\n",
        "    '''\n",
        "    emotion_dict = {}\n",
        "    \n",
        "    #apply get_top_n_words to a subset of the dataset for each emotion\n",
        "    for emotion in data['emotion'].unique():\n",
        "        emotion_dict[emotion] = get_top_n_words(data[data['emotion'] == emotion]['essay'], n, remove_stopwords, verb_only=verb_only, obj_only=obj_only)\n",
        "    return emotion_dict\n",
        "\n",
        "#plotting the top 20 words per emotion\n",
        "top_words_per_emotion = get_top_n_words_per_emotion(train_data, n=5, remove_stopwords=True)\n",
        "\n",
        "#get number of emotions\n",
        "num_plots = len(top_words_per_emotion)\n",
        "#3 columns\n",
        "num_cols = 3\n",
        "#calculate number of rows\n",
        "num_rows = num_plots // num_cols\n",
        "\n",
        "#plot\n",
        "fig, axes = plt.subplots(num_rows, num_cols, figsize=(15, 50), sharey=True)\n",
        "for idx, emotion in enumerate(top_words_per_emotion):\n",
        "    x,y = map(list, zip(*top_words_per_emotion[emotion]))\n",
        "    axes[idx // num_cols, idx % num_cols].bar(x,y)\n",
        "    axes[idx // num_cols, idx % num_cols].set_title(f\" Top words for {emotion}\")\n",
        "    axes[idx // num_cols, idx % num_cols].set_xlabel('Words')\n",
        "    axes[idx // num_cols, idx % num_cols].set_ylabel('Frequency')\n",
        "    axes[idx // num_cols, idx % num_cols].tick_params(axis='x', labelrotation=90)\n",
        "fig.tight_layout()\n",
        "    "
      ],
      "metadata": {
        "id": "ucBi7QN_j20n"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Top verbs per emotion"
      ],
      "metadata": {
        "id": "t7j-qk0apsha"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#similar to above but only verbs\n",
        "top_words_per_emotion = get_top_n_words_per_emotion(train_data, n=5, remove_stopwords=True, verb_only=True, obj_only=False)\n",
        "\n",
        "num_plots = len(top_words_per_emotion)\n",
        "num_cols = 3\n",
        "num_rows = num_plots // num_cols\n",
        "\n",
        "fig, axes = plt.subplots(num_rows, num_cols, figsize=(15, 50), sharey=True)\n",
        "for idx, emotion in enumerate(top_words_per_emotion):\n",
        "    x,y = map(list, zip(*top_words_per_emotion[emotion]))\n",
        "    axes[idx // num_cols, idx % num_cols].bar(x,y)\n",
        "    axes[idx // num_cols, idx % num_cols].set_title(f\" Top verbs for {emotion}\")\n",
        "    axes[idx // num_cols, idx % num_cols].set_xlabel('Words')\n",
        "    axes[idx // num_cols, idx % num_cols].set_ylabel('Frequency')\n",
        "    axes[idx // num_cols, idx % num_cols].tick_params(axis='x', labelrotation=90)\n",
        "fig.tight_layout()"
      ],
      "metadata": {
        "id": "t3XWrAu0pqAQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Top objects per emotion"
      ],
      "metadata": {
        "id": "TaldJgE8l68O"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#similar to above but only objects\n",
        "top_words_per_emotion = get_top_n_words_per_emotion(train_data, n=5, remove_stopwords=True, verb_only=False, obj_only=True)\n",
        "\n",
        "num_plots = len(top_words_per_emotion)\n",
        "num_cols = 3\n",
        "num_rows = num_plots // num_cols\n",
        "\n",
        "fig, axes = plt.subplots(num_rows, num_cols, figsize=(15, 50), sharey=True)\n",
        "for idx, emotion in enumerate(top_words_per_emotion):\n",
        "    x,y = map(list, zip(*top_words_per_emotion[emotion]))\n",
        "    axes[idx // num_cols, idx % num_cols].bar(x,y)\n",
        "    axes[idx // num_cols, idx % num_cols].set_title(f\" Top objects for {emotion}\")\n",
        "    axes[idx // num_cols, idx % num_cols].set_xlabel('Words')\n",
        "    axes[idx // num_cols, idx % num_cols].set_ylabel('Frequency')\n",
        "    axes[idx // num_cols, idx % num_cols].tick_params(axis='x', labelrotation=90)\n",
        "fig.tight_layout()"
      ],
      "metadata": {
        "id": "SNh4STXYl6N4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Baseline Bert Model for EMO Shared Task, WASSA 2023"
      ],
      "metadata": {
        "id": "xl_JIPSfqAXr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#import libraries\n",
        "!pip install transformers\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import torch\n",
        "import tensorflow as tf\n",
        "import matplotlib.pyplot as plt\n",
        "from tensorflow.keras.callbacks import EarlyStopping\n",
        "from tensorflow.keras.optimizers.schedules import PolynomialDecay\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import f1_score\n",
        "from sklearn.utils.class_weight import compute_class_weight, compute_sample_weight\n",
        "from transformers import AutoTokenizer, TFAutoModelForSequenceClassification, BartForConditionalGeneration, BartTokenizer, pipeline\n",
        "from huggingface_hub import notebook_login\n",
        "from tqdm.notebook import tqdm\n",
        "tqdm.pandas()"
      ],
      "metadata": {
        "id": "L3t0-jK8p_ui"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Load data\n",
        "\n",
        "#training data\n",
        "data = pd.read_csv(\"WASSA23_essay_level_with_labels_train.tsv\", sep=\"\\t\")\n",
        "data = data[['emotion', 'essay']]\n",
        "\n",
        "#development data\n",
        "dev_data = pd.read_csv(\"WASSA23_essay_level_dev.tsv\", sep=\"\\t\")\n",
        "\n",
        "#gold standard dev labels\n",
        "df = pd.read_csv('/content/goldstandard_dev.tsv', sep=\"\\t\", names=['1', '2', 'emotion',1,2,3,4,5,6,7,8,9])\n",
        "dev_data['emotion'] = df['emotion']"
      ],
      "metadata": {
        "id": "AsUJ8rBn_N4G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Parameters for easy toggling\n",
        "model_name='bert-base-uncased'\n",
        "tokenizer_name = 'bert-base-uncased'\n",
        "epochs=25"
      ],
      "metadata": {
        "id": "-IZFuUFu_Wii"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#create a list of unique emotions\n",
        "#unique_emotions = list(set(data[\"emotion\"].str.split(\"/\").explode().unique())) #uncomment to create a new sequence\n",
        "\n",
        "#fixed sequence to account for saved model\n",
        "unique_emotions = ['Disgust', 'Hope', 'Fear', 'Anger', 'Sadness', 'Joy', 'Surprise', 'Neutral']\n",
        "\n",
        "unique_emotions"
      ],
      "metadata": {
        "id": "Gb8hMwTV_Pvn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#One Hot Encode the labels\n",
        "num_classes = len(unique_emotions)\n",
        "for emotion in unique_emotions:\n",
        "    data[emotion] = data[\"emotion\"].str.contains(emotion).astype(int)\n",
        "    dev_data[emotion] = dev_data[\"emotion\"].str.contains(emotion).astype(int)\n",
        "\n",
        "#drop string emotion column\n",
        "data = data.drop(columns=[\"emotion\"])\n"
      ],
      "metadata": {
        "id": "Y6pWao_h_Q5o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#get training and testing texts and labels\n",
        "train_texts= data['essay'] \n",
        "train_labels = data[unique_emotions]\n",
        "test_texts = dev_data['essay']\n",
        "test_labels= dev_data[unique_emotions]\n",
        "\n",
        "# Load tokenizer and pre-trained model\n",
        "tokenizer = AutoTokenizer.from_pretrained(tokenizer_name)\n",
        "model = TFAutoModelForSequenceClassification.from_pretrained(model_name, num_labels=num_classes)"
      ],
      "metadata": {
        "id": "ZVig7ZXA_SOf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Tokenize train and test texts\n",
        "train_encodings = tokenizer(train_texts.to_list(), truncation=True, padding=True)\n",
        "test_encodings = tokenizer(test_texts.to_list(), truncation=True, padding=True)\n",
        "\n",
        "train_dataset = tf.data.Dataset.from_tensor_slices((\n",
        "    dict(train_encodings),\n",
        "    train_labels.astype(np.float32)\n",
        "))\n",
        "\n",
        "test_dataset = tf.data.Dataset.from_tensor_slices((\n",
        "    dict(test_encodings),\n",
        "    test_labels.astype(np.float32)\n",
        "))"
      ],
      "metadata": {
        "id": "lJ9mzamG_aWC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "optimizer = tf.keras.optimizers.AdamW(learning_rate=2e-05)\n",
        "loss = tf.keras.losses.BinaryCrossentropy(from_logits=True)\n",
        "metric = tf.keras.metrics.BinaryAccuracy('accuracy')\n",
        "\n",
        "# Compile model\n",
        "model.compile(optimizer=optimizer, loss=loss, metrics=[metric])\n",
        "\n",
        "#fit the model wit early stopping\n",
        "early_stopping_callback = EarlyStopping(\n",
        "      monitor=\"val_loss\",\n",
        "      patience=10,\n",
        "      restore_best_weights=True\n",
        "  )\n",
        "\n",
        "#fit the model\n",
        "history = model.fit(train_dataset.shuffle(len(train_labels)).batch(16), epochs=25, batch_size=16, validation_data=test_dataset.shuffle(len(test_labels)).batch(16), callbacks=[early_stopping_callback])"
      ],
      "metadata": {
        "id": "JUk8k1mU_gx7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#plot loss \n",
        "plt.plot(history.history['loss'], label='train loss')\n",
        "plt.plot(history.history['val_loss'], label='val loss')\n",
        "\n",
        "#plot a line at the best loss\n",
        "plt.axhline(np.min(history.history['val_loss']), linestyle='--', color='r', label='best val loss')\n",
        "plt.title(\"BERT Loss\")\n",
        "plt.legend()\n"
      ],
      "metadata": {
        "id": "m3JlLXgK_pK6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#plot accuracy\n",
        "plt.plot(history.history['accuracy'], label='train accuracy')\n",
        "plt.plot(history.history['val_accuracy'], label='val accuracy')\n",
        "plt.title(\"BERT Accuracy\")\n",
        "plt.legend()"
      ],
      "metadata": {
        "id": "_1t-Y4le_q_U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#finding the best threshold\n",
        "def predict_on_test_dataset(test_dataset, thresholds):\n",
        "  '''\n",
        "    This function takes in the test dataset (here, dev data) and calculates F1 and accuracy. \n",
        "    Test different thresholds for logits\n",
        "  '''\n",
        "\n",
        "  #iterate over thresholds\n",
        "  for threshold in thresholds:\n",
        "\n",
        "    #predict using trained model\n",
        "    y_pred = model.predict(test_dataset.batch(16))\n",
        "\n",
        "    #based on threshold, convert logits to 1\n",
        "    y_pred = tf.where(np.array(list(y_pred.logits)) > threshold, 1,0)\n",
        "    y_pred = y_pred.numpy()\n",
        "    y_true = test_labels.to_numpy()\n",
        "\n",
        "    #calculate accuracy\n",
        "    accuracy = np.sum(y_pred == y_true) / y_true.size\n",
        "\n",
        "    #print accuracy and F1 macro\n",
        "    print(threshold, f1_score(y_true, y_pred, average=\"macro\",zero_division=1), accuracy)\n",
        "\n",
        "#instantiate a list of thresholds\n",
        "#thresholds = [i/80 for i in range(-6,0)]\n",
        "thresholds = [-2]\n",
        "\n",
        "#call the function\n",
        "predict_on_test_dataset(test_dataset, thresholds)"
      ],
      "metadata": {
        "id": "xThPWwPi_s-I"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "70RY2FBM7drh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Get the string version of predictions\n",
        "def get_predicted_emotions(data, threshold=-2):\n",
        "    '''\n",
        "      This function takes in the data and finds the emotion of the essay using the trained model\n",
        "    '''\n",
        "\n",
        "    #get the essay column\n",
        "    essays = data['essay']\n",
        "\n",
        "    #get the encodings\n",
        "    encodings = tokenizer(essays.tolist(), truncation=True, padding=True)\n",
        "\n",
        "    #create tensorflow dataset\n",
        "    dataset = tf.data.Dataset.from_tensor_slices(dict(encodings))\n",
        "\n",
        "    #get predictions\n",
        "    y_pred = model.predict(dataset.batch(16))\n",
        "    \n",
        "    #create matrix based on threshold\n",
        "    matrix = tf.where(y_pred.logits>threshold, 1, 0)\n",
        "    y_pred = []\n",
        "\n",
        "    #iterate over rows and find corresponding emotions\n",
        "    for row in matrix:\n",
        "      emotions = []\n",
        "      for i in range(len(row)):\n",
        "        if row[i] == 1:\n",
        "          emotions.append(unique_emotions[i])\n",
        "          emotions.sort()\n",
        "      y_pred.append(\"/\".join(emotions))\n",
        "\n",
        "    #create a dataframe with the essays and the predicted emotions\n",
        "    df = pd.DataFrame({'essay': essays, 'emotion': y_pred})\n",
        "\n",
        "    #return the dataframe\n",
        "    return df"
      ],
      "metadata": {
        "id": "At4rgiTU_uuY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "test_mode = True\n",
        "if test_mode:\n",
        "  dev_data = pd.read_csv(\"WASSA23_essay_level_test.tsv\", sep=\"\\t\")\n"
      ],
      "metadata": {
        "id": "I5c_B8Bzr-22"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#get predictions on the dev data\n",
        "dev_predictions = get_predicted_emotions(dev_data)\n",
        "dev_predictions"
      ],
      "metadata": {
        "id": "p9_SG-rO_yXL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#if no emotion is assigned, assign neutral to that row\n",
        "dev_predictions['emotion'] = dev_predictions['emotion'].replace('', 'Neutral')"
      ],
      "metadata": {
        "id": "zzWYTxKf_zpM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#save to csv\n",
        "dev_predictions['emotion'].to_csv('predictions_EMO.tsv', sep=\"\\t\", header=False, index=False)"
      ],
      "metadata": {
        "id": "eUGKA_sU_0kI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Macro F1-Score: 0.4409 \\\n",
        "Micro Recall: 0.6829 \\\n",
        "Micro Precision: 0.6774 \\\n",
        "Micro F1-Score: 0.6802 \\\n",
        "Macro Recall: 0.4458 \\\n",
        "Macro Precision: 0.4835 \\\n",
        "Micro Jaccard: 0.5153 \\"
      ],
      "metadata": {
        "id": "5kpCFdwmJaLa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# GoEmotions"
      ],
      "metadata": {
        "id": "emepL5hScsVe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install datasets\n",
        "from datasets import load_dataset\n",
        "import pandas as pd\n",
        "dataset = load_dataset(\"go_emotions\",\"raw\")\n",
        "df = pd.DataFrame(dataset['train'])\n",
        "unique_emotions = ['text','disgust', 'optimism', 'fear', 'anger', 'sadness', 'joy', 'surprise', 'neutral']\n",
        "df = df[unique_emotions]\n",
        "\n",
        "df1 = df.rename({'text':'essay','disgust':'Disgust', 'optimism':'Hope', 'fear':'Fear', 'anger':'Anger', 'sadness':'Sadness', 'joy':\"Joy\", 'surprise':'Surprise', 'neutral':'Neutral'}, axis=1)"
      ],
      "metadata": {
        "id": "203gfZ3wcr2P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "unique_emotions = ['Disgust', 'Hope', 'Fear', 'Anger', 'Sadness', 'Joy', 'Surprise', 'Neutral']\n",
        "unique_emotions\n",
        "df2 = df1[df1[unique_emotions].sum(axis=1) != 0]"
      ],
      "metadata": {
        "id": "97ZhnSz_c69b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df2.to_csv('goemotions.csv', index=False)"
      ],
      "metadata": {
        "id": "neAoRkpBkLip"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Final Evaluation"
      ],
      "metadata": {
        "id": "5fNFGy1g8N7R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "from sklearn.metrics import precision_recall_fscore_support\n",
        "\n",
        "def multi_label_metrics(y_true, y_pred, unique_labels):\n",
        "    num_labels = len(unique_labels)\n",
        "    \n",
        "    # Calculate accuracy\n",
        "    accuracy = np.sum(y_pred == y_true) / y_true.size\n",
        "\n",
        "    # Calculate macro f1, macro precision, and macro recall\n",
        "    macro_f1, macro_precision, macro_recall, _ = precision_recall_fscore_support(y_true, y_pred, average='macro')\n",
        "\n",
        "    # Initialize dictionaries for individual label metrics\n",
        "    label_accuracy = {}\n",
        "    label_f1 = {}\n",
        "    label_precision = {}\n",
        "    label_recall = {}\n",
        "\n",
        "    # Calculate metrics for each individual label\n",
        "    for i, label in enumerate(unique_labels):\n",
        "        label_y_true = y_true[:, i]\n",
        "        label_y_pred = y_pred[:, i]\n",
        "\n",
        "        # Calculate label accuracy\n",
        "        label_accuracy[label] = accuracy_score(label_y_true, label_y_pred)\n",
        "\n",
        "        # Calculate label f1, precision, and recall\n",
        "        label_f1[label], label_precision[label], label_recall[label], _ = precision_recall_fscore_support(label_y_true, label_y_pred, average='binary')\n",
        "\n",
        "    # Create pandas DataFrame for individual label metrics\n",
        "    df_label_metrics = pd.DataFrame({'Accuracy': label_accuracy,\n",
        "                                     'F1': label_f1,\n",
        "                                     'Precision': label_precision,\n",
        "                                     'Recall': label_recall})\n",
        "\n",
        "    return accuracy, macro_f1, macro_precision, macro_recall, df_label_metrics\n"
      ],
      "metadata": {
        "id": "QJUrmfwJ7O9E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "threshold = -2\n",
        "y_pred = model.predict(test_dataset.batch(16))\n",
        "y_pred = tf.where(np.array(list(y_pred.logits)) > threshold, 1,0)\n",
        "y_pred = y_pred.numpy()\n",
        "y_true = test_labels.to_numpy()"
      ],
      "metadata": {
        "id": "1C56BNH376PZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy, macro_f1, macro_precision, macro_recall, df_label_metrics = multi_label_metrics(y_true, y_pred, unique_emotions)"
      ],
      "metadata": {
        "id": "NsTsSnJP8YKd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df_label_metrics"
      ],
      "metadata": {
        "id": "pYmC9xqY-v9E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "accuracy"
      ],
      "metadata": {
        "id": "wrC9I9WsAr3x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "macro_f1"
      ],
      "metadata": {
        "id": "aZFfDMo-AssH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "macro_precision"
      ],
      "metadata": {
        "id": "17kdSvKuAuWY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "macro_recall"
      ],
      "metadata": {
        "id": "UR793P1HAwaa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "sns.heatmap(df_label_metrics, annot=True, cmap='Blues')\n",
        "plt.title('Individual Label Metrics')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "q-sMyDKuBPIT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# RoBERTa metrics\n",
        "\n",
        "Accuracy: 0.9194 \\\n",
        "F1:0.571 \\\n",
        "Precision: 0.6112\\\n",
        "Recall: 0.5726 \\\n",
        "![roberta_metrics_emo.png](data:image/png;base64,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)\n"
      ],
      "metadata": {
        "id": "gP1UEzCmCn0V"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# BERT Metrics\n",
        "\n",
        "![bert_emo.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "dlniaAGVDeDb"
      }
    }
  ]
}