TransformerFinetune.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# IndoML 2023 Tuturial: Part 2\n",
    "## At Sesame street\n",
    "\n",
    "### Plan:\n",
    "\n",
    "1. We will use Huggingface transformers for finetuning pretrained models.\n",
    "2. This will allow us to easily swap out models to find the most suitable one.\n",
    "    * This is achieved using the `AutoModel*` and `AutoTokenizer` classes.\n",
    "3. It also comes with various new libraries integrated for efficient fine-tuning, \n",
    "multi-gpu or distributed training, and more.\n",
    "\n",
    "### Models that you can try with this script\n",
    "\n",
    "1. DistilBERT\n",
    "2. bert-base-multilingual-cased\n",
    "3. XLM-RoBERTa\n",
    "etc.\n",
    "\n",
    "### Efficient Training\n",
    "\n",
    "Full finetuning can be often slow and expensive. So, some alternative methods for efficient training are:\n",
    "\n",
    "1. Linear Probing\n",
    "2. PEFT + Low-Rank Adaptation\n",
    "3. Distilled Models\n",
    "4. **Use models finetuned on MASSIVE as your starting point.** You can search for such models on Huggingface  ([List1](https://huggingface.co/models?dataset=dataset:AmazonScience%2Fmassive&sort=downloads), [List2](https://huggingface.co/models?sort=downloads&search=massive-intent))\n",
    "\n",
    "### Libraries explored\n",
    "\n",
    "1. 🤗 Transfomers > Trainer\n",
    "2. 🤗 Evaluate\n",
    "2. wandb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: CUDA_VISIBLE_DEVICES=4\n"
     ]
    }
   ],
   "source": [
    "%env CUDA_VISIBLE_DEVICES=4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load `dataset`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/nlsasfs/home/ttbhashini/arroy/anaconda3/envs/py38-new/lib/python3.8/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "from datasets import load_dataset\n",
    "from transformers import AutoTokenizer, DataCollatorWithPadding\n",
    "\n",
    "tqdm.pandas()\n",
    "\n",
    "dataset = load_dataset(\"AmazonScience/massive\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load `AutoTokenizer`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "checkpoint = \"bert-base-multilingual-cased\"\n",
    "tokenizer = AutoTokenizer.from_pretrained(checkpoint)\n",
    "\n",
    "\n",
    "def tokenize_function(example):\n",
    "    return tokenizer(example[\"utt\"], truncation=True)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing\n",
    "\n",
    "### Using the Trainer class\n",
    "\n",
    "We will be using the HF Trainer class to handle a lot of the boilerplate tasks. This Trainer class expects certain format for the dataset.\n",
    "\n",
    "1. Tokenize the dataset\n",
    "2. A \"labels\" column should exits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Map: 100%|██████████| 587214/587214 [00:19<00:00, 29489.37 examples/s]\n",
      "Map: 100%|██████████| 103683/103683 [00:03<00:00, 27914.97 examples/s]\n",
      "Map: 100%|██████████| 151674/151674 [00:05<00:00, 27216.33 examples/s]\n"
     ]
    }
   ],
   "source": [
    "tokenized_datasets = dataset.map(tokenize_function, batched=True)\n",
    "data_collator = DataCollatorWithPadding(tokenizer=tokenizer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['id', 'locale', 'partition', 'scenario', 'intent', 'utt', 'annot_utt', 'worker_id', 'slot_method', 'judgments', 'input_ids', 'token_type_ids', 'attention_mask'])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenized_datasets['train'][0].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove columns that are not needed\n",
    "to_remove = list(tokenized_datasets['train'][0].keys())\n",
    "\n",
    "# Don't remove these columns\n",
    "to_remove.remove('input_ids')\n",
    "to_remove.remove('attention_mask')\n",
    "to_remove.remove('intent')\n",
    "\n",
    "# tokenized_datasets = tokenized_datasets.remove_columns(to_remove)\n",
    "tokenized_datasets = tokenized_datasets.rename_column('intent', 'labels')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'id': Value(dtype='string', id=None),\n",
       " 'locale': Value(dtype='string', id=None),\n",
       " 'partition': Value(dtype='string', id=None),\n",
       " 'scenario': ClassLabel(names=['social', 'transport', 'calendar', 'play', 'news', 'datetime', 'recommendation', 'email', 'iot', 'general', 'audio', 'lists', 'qa', 'cooking', 'takeaway', 'music', 'alarm', 'weather'], id=None),\n",
       " 'labels': ClassLabel(names=['datetime_query', 'iot_hue_lightchange', 'transport_ticket', 'takeaway_query', 'qa_stock', 'general_greet', 'recommendation_events', 'music_dislikeness', 'iot_wemo_off', 'cooking_recipe', 'qa_currency', 'transport_traffic', 'general_quirky', 'weather_query', 'audio_volume_up', 'email_addcontact', 'takeaway_order', 'email_querycontact', 'iot_hue_lightup', 'recommendation_locations', 'play_audiobook', 'lists_createoradd', 'news_query', 'alarm_query', 'iot_wemo_on', 'general_joke', 'qa_definition', 'social_query', 'music_settings', 'audio_volume_other', 'calendar_remove', 'iot_hue_lightdim', 'calendar_query', 'email_sendemail', 'iot_cleaning', 'audio_volume_down', 'play_radio', 'cooking_query', 'datetime_convert', 'qa_maths', 'iot_hue_lightoff', 'iot_hue_lighton', 'transport_query', 'music_likeness', 'email_query', 'play_music', 'audio_volume_mute', 'social_post', 'alarm_set', 'qa_factoid', 'calendar_set', 'play_game', 'alarm_remove', 'lists_remove', 'transport_taxi', 'recommendation_movies', 'iot_coffee', 'music_query', 'play_podcasts', 'lists_query'], id=None),\n",
       " 'utt': Value(dtype='string', id=None),\n",
       " 'annot_utt': Value(dtype='string', id=None),\n",
       " 'worker_id': Value(dtype='string', id=None),\n",
       " 'slot_method': Sequence(feature={'slot': Value(dtype='string', id=None), 'method': Value(dtype='string', id=None)}, length=-1, id=None),\n",
       " 'judgments': Sequence(feature={'worker_id': Value(dtype='string', id=None), 'intent_score': Value(dtype='int8', id=None), 'slots_score': Value(dtype='int8', id=None), 'grammar_score': Value(dtype='int8', id=None), 'spelling_score': Value(dtype='int8', id=None), 'language_identification': Value(dtype='string', id=None)}, length=-1, id=None),\n",
       " 'input_ids': Sequence(feature=Value(dtype='int32', id=None), length=-1, id=None),\n",
       " 'token_type_ids': Sequence(feature=Value(dtype='int8', id=None), length=-1, id=None),\n",
       " 'attention_mask': Sequence(feature=Value(dtype='int8', id=None), length=-1, id=None)}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokenized_datasets['train'].features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataloaders [Optional]\n",
    "\n",
    "- Instead of going through individual samples in the dataset, we would like to \n",
    "batches of samples to train our model. \n",
    "- Dataloader\n",
    "    1. Creates an \"iterator\" over the dataset, which returns a batch of samples every turn\n",
    "    2. Handles shuffling\n",
    "    3. Collates samples into batches, by padding the input sequences to the maximum length in the batch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from torch.utils.data import DataLoader\n",
    "\n",
    "# train_dataloader = DataLoader(\n",
    "#     tokenized_datasets[\"train\"], shuffle=True, batch_size=8, collate_fn=data_collator\n",
    "# )\n",
    "# eval_dataloader = DataLoader(\n",
    "#     tokenized_datasets[\"validation\"], batch_size=8, collate_fn=data_collator\n",
    "# )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check the shape of the tensors\n",
    "# for batch in tqdm(train_dataloader):\n",
    "#     break\n",
    "# {k: v.shape for k, v in batch.items()}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "{'labels': torch.Size([8]),\n",
    " 'input_ids': torch.Size([8, 25]),\n",
    " 'attention_mask': torch.Size([8, 25])}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load model using an `AutoModel`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
      "To disable this warning, you can either:\n",
      "\t- Avoid using `tokenizers` before the fork if possible\n",
      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
      "To disable this warning, you can either:\n",
      "\t- Avoid using `tokenizers` before the fork if possible\n",
      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
      "To disable this warning, you can either:\n",
      "\t- Avoid using `tokenizers` before the fork if possible\n",
      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n",
      "huggingface/tokenizers: The current process just got forked, after parallelism has already been used. Disabling parallelism to avoid deadlocks...\n",
      "To disable this warning, you can either:\n",
      "\t- Avoid using `tokenizers` before the fork if possible\n",
      "\t- Explicitly set the environment variable TOKENIZERS_PARALLELISM=(true | false)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading model.safetensors: 100%|██████████| 714M/714M [00:14<00:00, 49.3MB/s] \n",
      "Some weights of BertForSequenceClassification were not initialized from the model checkpoint at bert-base-multilingual-cased and are newly initialized: ['classifier.bias', 'classifier.weight']\n",
      "You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.\n"
     ]
    }
   ],
   "source": [
    "from transformers import AutoModelForSequenceClassification\n",
    "\n",
    "model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=tokenized_datasets['train'].features['labels'].num_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Let's check the output of a single forward pass\n",
    "# outputs = model(**batch)\n",
    "# print(outputs.loss, outputs.logits.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup Evaluation Metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Downloading builder script: 100%|██████████| 4.20k/4.20k [00:00<00:00, 6.36MB/s]\n",
      "Downloading builder script: 100%|██████████| 6.77k/6.77k [00:00<00:00, 8.13MB/s]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import evaluate\n",
    "\n",
    "metric_acc = evaluate.load(\"accuracy\")\n",
    "metric_f1 = evaluate.load(\"f1\")\n",
    "\n",
    "# We need to define a compute_metric function that is supported by the Trainer output\n",
    "# It basically converts the logits to predictions and then calls the metric\n",
    "def compute_metrics(eval_pred):\n",
    "    logits, labels = eval_pred\n",
    "    predictions = np.argmax(logits, axis=-1)\n",
    "    # print(\"Predictions: \", predictions)\n",
    "    # print(\"Labels: \", labels)\n",
    "    return metric_f1.compute(predictions=predictions, references=labels, average=\"macro\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tweak the data distribution!\n",
    "\n",
    "- We are changing the training set distribution.\n",
    "- But keeping the validation set distribution the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All the langauges in the dataset\n",
    "# ['mn-MN', 'af-ZA', 'el-GR', 'ta-IN', 'ar-SA', 'ur-PK', 'pl-PL',\n",
    "#        'ko-KR', 'az-AZ', 'da-DK', 'kn-IN', 'tl-PH', 'is-IS', 'lv-LV',\n",
    "#        'it-IT', 'es-ES', 'fr-FR', 'ml-IN', 'km-KH', 'fa-IR', 'sw-KE',\n",
    "#        'en-US', 'tr-TR', 'bn-BD', 'he-IL', 'te-IN', 'pt-PT', 'ka-GE',\n",
    "#        'ja-JP', 'id-ID', 'ru-RU', 'hy-AM', 'nb-NO', 'ms-MY', 'sq-AL',\n",
    "#        'sv-SE', 'fi-FI', 'th-TH', 'de-DE', 'vi-VN', 'my-MM', 'jv-ID',\n",
    "#        'sl-SL', 'hi-IN', 'nl-NL', 'zh-CN', 'hu-HU', 'ro-RO', 'zh-TW',\n",
    "#        'cy-GB', 'am-ET']\n",
    "\n",
    "# Create dataframe of id and locale\n",
    "df_train = dataset['train'].to_pandas()\n",
    "df_eval = dataset['validation'].to_pandas()\n",
    "\n",
    "selected_languages = [\"en-US\", \"de-DE\", \"bn-BD\", \"hi-IN\"]\n",
    "\n",
    "df_train = df_train[df_train['locale'].isin(selected_languages)]\n",
    "# df_eval = df_eval[df_eval['locale'].isin(selected_languages)] \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "# Select random samples from above subsets\n",
    "n_train = 40960\n",
    "n_eval = 2096\n",
    "train_indices = random.sample(df_train.index.tolist(), n_train)\n",
    "eval_indices = random.sample(range(len(tokenized_datasets['validation'])), n_eval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data_subset = tokenized_datasets[\"train\"].select(train_indices)\n",
    "eval_data_subset = tokenized_datasets[\"validation\"].select(eval_indices)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup Trainer and Finetuning\n",
    "\n",
    "1. When testing your code for the first time, it is a better idea to use a smaller dataset,\n",
    "so that you can quickly iterate over your code.\n",
    "2. We have done the same here by using 128 + 32 samples from the dataset, for training and validation respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import TrainingArguments\n",
    "\n",
    "eval_steps = 1000\n",
    "\n",
    "training_args = TrainingArguments(\n",
    "    output_dir=\"./results/stage1/\",\n",
    "    num_train_epochs=2,\n",
    "    per_device_train_batch_size=32,\n",
    "    per_device_eval_batch_size=32,\n",
    "    fp16=True,\n",
    "    # warmup_steps=500,\n",
    "    # weight_decay=0.01,\n",
    "    logging_dir=\"./logs\",\n",
    "    logging_steps=10,\n",
    "    evaluation_strategy=\"steps\",\n",
    "    save_strategy=\"steps\",\n",
    "    save_steps=eval_steps,\n",
    "    eval_steps=eval_steps,\n",
    "    load_best_model_at_end=True,\n",
    "    metric_for_best_model=\"f1\",\n",
    "    greater_is_better=True,\n",
    "    report_to=\"none\" # set \"wandb\" here to log to wandb\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Wandb Logging**\n",
    "\n",
    "When training ML models, keeping track of various hyperparameters, the training and validation losses, and evaluation metrics is very important.\n",
    "`wandb` can help you here.\n",
    "\n",
    "To install wandb, run following commands in your terminal:\n",
    "\n",
    "```bash\n",
    "pip install wandb\n",
    "# Then login to your wandb account\n",
    "wandb login\n",
    "```\n",
    "\n",
    "Once, that is done, in TrainingArguments, set the `report_to` argument to `wandb`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import Trainer\n",
    "\n",
    "trainer = Trainer(\n",
    "    model,\n",
    "    training_args,\n",
    "    # train_dataset=tokenized_datasets[\"train\"],\n",
    "    # eval_dataset=tokenized_datasets[\"validation\"],\n",
    "    train_dataset=train_data_subset, # Using the smaller subsets\n",
    "    eval_dataset=eval_data_subset,\n",
    "    data_collator=data_collator,\n",
    "    tokenizer=tokenizer,\n",
    "    compute_metrics=compute_metrics,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='2560' max='2560' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [2560/2560 03:01, Epoch 2/2]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Step</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "      <th>F1</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>1000</td>\n",
       "      <td>0.560800</td>\n",
       "      <td>2.389601</td>\n",
       "      <td>0.404910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2000</td>\n",
       "      <td>0.377600</td>\n",
       "      <td>2.343635</td>\n",
       "      <td>0.401373</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "stats = trainer.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'epoch': 2.0,\n",
      " 'eval_f1': 0.40490950899244466,\n",
      " 'eval_loss': 2.3896007537841797,\n",
      " 'eval_runtime': 22.1973,\n",
      " 'eval_samples_per_second': 94.426,\n",
      " 'eval_steps_per_second': 2.973}\n"
     ]
    }
   ],
   "source": [
    "# Print Stats\n",
    "# trainer.compute_metrics = compute_metrics\n",
    "from pprint import pprint\n",
    "pprint(trainer.evaluate())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Back to the full evaluation set\n",
    "\n",
    "Now we will test the model on full evaluation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Extract predictions on validation set\n",
    "eval_data_subset = tokenized_datasets[\"validation\"]\n",
    "preds = trainer.predict(eval_data_subset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a dataframe with the predictions, targets and locale\n",
    "import pandas as pd\n",
    "df = pd.DataFrame({\n",
    "    \"id\": eval_data_subset['id'],\n",
    "    \"predictions\": preds.predictions.argmax(-1),\n",
    "    \"targets\": preds.label_ids,\n",
    "    \"locale\": eval_data_subset['locale']\n",
    "})\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute f1 for each locale and plot f1 scores vs locales\n",
    "from sklearn.metrics import f1_score, accuracy_score\n",
    "import seaborn as sns\n",
    "sns.set(rc={'figure.figsize':(11, 8)}) # Setting some matplotlib configs\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Print histogram of locale, y-axis normalized to 1\n",
    "P = sns.histplot(df['locale'], stat=\"probability\")\n",
    "\n",
    "P.set_xlabel(\"Locale\")\n",
    "P.set_ylabel(\"Probability\")\n",
    "P.set_title(\"Locale histogram\")\n",
    "\n",
    "# Rotate x labels by 90 degrees\n",
    "for item in P.get_xticklabels():\n",
    "    item.set_rotation(90)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1100x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def compute_f1(df):\n",
    "    return f1_score(df['targets'], df['predictions'], average='macro')\n",
    "\n",
    "def compute_acc(df):\n",
    "    return accuracy_score(df['targets'], df['predictions'])\n",
    "\n",
    "df_f1 = df.groupby('locale').apply(compute_f1)\n",
    "P = sns.barplot(x=df_f1.index, y=df_f1.values)\n",
    "# df_acc = df.groupby('locale').apply(compute_acc)\n",
    "# P = sns.barplot(x=df_acc.index, y=df_acc.values)\n",
    "\n",
    "P.set_title(\"Locale vs Performance\")\n",
    "P.set_xlabel(\"Locale\")\n",
    "P.set_ylabel(\"Performance\")\n",
    "\n",
    "# Rotate x labels by 90 degrees\n",
    "for item in P.get_xticklabels():\n",
    "    item.set_rotation(90)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Full macro f1 score\n",
    "compute_f1(df)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py38",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}