Training in progress, step 1000

.gitignore

@@ -0,0 +1 @@
+checkpoint-*/

.ipynb_checkpoints/fine-tune-whisper-non-streaming-checkpoint.ipynb

@@ -0,0 +1,1225 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "75b58048-7d14-4fc6-8085-1fc08c81b4a6",
+   "metadata": {
+    "id": "75b58048-7d14-4fc6-8085-1fc08c81b4a6"
+   },
+   "source": [
+    "# Fine-Tune Whisper For Multilingual ASR with 🤗 Transformers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbfa8ad5-4cdc-4512-9058-836cbbf65e1a",
+   "metadata": {
+    "id": "fbfa8ad5-4cdc-4512-9058-836cbbf65e1a"
+   },
+   "source": [
+    "In this Colab, we present a step-by-step guide on how to fine-tune Whisper \n",
+    "for any multilingual ASR dataset using Hugging Face 🤗 Transformers. This is a \n",
+    "more \"hands-on\" version of the accompanying [blog post](https://huggingface.co/blog/fine-tune-whisper). \n",
+    "For a more in-depth explanation of Whisper, the Common Voice dataset and the theory behind fine-tuning, the reader is advised to refer to the blog post."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afe0d503-ae4e-4aa7-9af4-dbcba52db41e",
+   "metadata": {
+    "id": "afe0d503-ae4e-4aa7-9af4-dbcba52db41e"
+   },
+   "source": [
+    "## Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ae91ed4-9c3e-4ade-938e-f4c2dcfbfdc0",
+   "metadata": {
+    "id": "9ae91ed4-9c3e-4ade-938e-f4c2dcfbfdc0"
+   },
+   "source": [
+    "Whisper is a pre-trained model for automatic speech recognition (ASR) \n",
+    "published in [September 2022](https://openai.com/blog/whisper/) by the authors \n",
+    "Alec Radford et al. from OpenAI. Unlike many of its predecessors, such as \n",
+    "[Wav2Vec 2.0](https://arxiv.org/abs/2006.11477), which are pre-trained \n",
+    "on un-labelled audio data, Whisper is pre-trained on a vast quantity of \n",
+    "**labelled** audio-transcription data, 680,000 hours to be precise. \n",
+    "This is an order of magnitude more data than the un-labelled audio data used \n",
+    "to train Wav2Vec 2.0 (60,000 hours). What is more, 117,000 hours of this \n",
+    "pre-training data is multilingual ASR data. This results in checkpoints \n",
+    "that can be applied to over 96 languages, many of which are considered \n",
+    "_low-resource_.\n",
+    "\n",
+    "When scaled to 680,000 hours of labelled pre-training data, Whisper models \n",
+    "demonstrate a strong ability to generalise to many datasets and domains.\n",
+    "The pre-trained checkpoints achieve competitive results to state-of-the-art \n",
+    "ASR systems, with near 3% word error rate (WER) on the test-clean subset of \n",
+    "LibriSpeech ASR and a new state-of-the-art on TED-LIUM with 4.7% WER (_c.f._ \n",
+    "Table 8 of the [Whisper paper](https://cdn.openai.com/papers/whisper.pdf)).\n",
+    "The extensive multilingual ASR knowledge acquired by Whisper during pre-training \n",
+    "can be leveraged for other low-resource languages; through fine-tuning, the \n",
+    "pre-trained checkpoints can be adapted for specific datasets and languages \n",
+    "to further improve upon these results. We'll show just how Whisper can be fine-tuned \n",
+    "for low-resource languages in this Colab."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e59b91d6-be24-4b5e-bb38-4977ea143a72",
+   "metadata": {
+    "id": "e59b91d6-be24-4b5e-bb38-4977ea143a72"
+   },
+   "source": [
+    "<figure>\n",
+    "<img src=\"https://raw.githubusercontent.com/sanchit-gandhi/notebooks/main/whisper_architecture.svg\" alt=\"Trulli\" style=\"width:100%\">\n",
+    "<figcaption align = \"center\"><b>Figure 1:</b> Whisper model. The architecture \n",
+    "follows the standard Transformer-based encoder-decoder model. A \n",
+    "log-Mel spectrogram is input to the encoder. The last encoder \n",
+    "hidden states are input to the decoder via cross-attention mechanisms. The \n",
+    "decoder autoregressively predicts text tokens, jointly conditional on the \n",
+    "encoder hidden states and previously predicted tokens. Figure source: \n",
+    "<a href=\"https://openai.com/blog/whisper/\">OpenAI Whisper Blog</a>.</figcaption>\n",
+    "</figure>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21b6316e-8a55-4549-a154-66d3da2ab74a",
+   "metadata": {
+    "id": "21b6316e-8a55-4549-a154-66d3da2ab74a"
+   },
+   "source": [
+    "The Whisper checkpoints come in five configurations of varying model sizes.\n",
+    "The smallest four are trained on either English-only or multilingual data.\n",
+    "The largest checkpoint is multilingual only. All nine of the pre-trained checkpoints \n",
+    "are available on the [Hugging Face Hub](https://huggingface.co/models?search=openai/whisper). The \n",
+    "checkpoints are summarised in the following table with links to the models on the Hub:\n",
+    "\n",
+    "| Size   | Layers | Width | Heads | Parameters | English-only                                         | Multilingual                                      |\n",
+    "|--------|--------|-------|-------|------------|------------------------------------------------------|---------------------------------------------------|\n",
+    "| tiny   | 4      | 384   | 6     | 39 M       | [✓](https://huggingface.co/openai/whisper-tiny.en)   | [✓](https://huggingface.co/openai/whisper-tiny.)  |\n",
+    "| base   | 6      | 512   | 8     | 74 M       | [✓](https://huggingface.co/openai/whisper-base.en)   | [✓](https://huggingface.co/openai/whisper-base)   |\n",
+    "| small  | 12     | 768   | 12    | 244 M      | [✓](https://huggingface.co/openai/whisper-small.en)  | [✓](https://huggingface.co/openai/whisper-small)  |\n",
+    "| medium | 24     | 1024  | 16    | 769 M      | [✓](https://huggingface.co/openai/whisper-medium.en) | [✓](https://huggingface.co/openai/whisper-medium) |\n",
+    "| large  | 32     | 1280  | 20    | 1550 M     | x                                                    | [✓](https://huggingface.co/openai/whisper-large)  |\n",
+    "\n",
+    "For demonstration purposes, we'll fine-tune the multilingual version of the \n",
+    "[`\"small\"`](https://huggingface.co/openai/whisper-small) checkpoint with 244M params (~= 1GB). \n",
+    "As for our data, we'll train and evaluate our system on a low-resource language \n",
+    "taken from the [Common Voice](https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0)\n",
+    "dataset. We'll show that with as little as 8 hours of fine-tuning data, we can achieve \n",
+    "strong performance in this language."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a680dfc-cbba-4f6c-8a1f-e1a5ff3f123a",
+   "metadata": {
+    "id": "3a680dfc-cbba-4f6c-8a1f-e1a5ff3f123a"
+   },
+   "source": [
+    "------------------------------------------------------------------------\n",
+    "\n",
+    "\\\\({}^1\\\\) The name Whisper follows from the acronym “WSPSR”, which stands for “Web-scale Supervised Pre-training for Speech Recognition”."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b219c9dd-39b6-4a95-b2a1-3f547a1e7bc0",
+   "metadata": {
+    "id": "b219c9dd-39b6-4a95-b2a1-3f547a1e7bc0"
+   },
+   "source": [
+    "## Load Dataset"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "674429c5-0ab4-4adf-975b-621bb69eca38",
+   "metadata": {
+    "id": "674429c5-0ab4-4adf-975b-621bb69eca38"
+   },
+   "source": [
+    "Using 🤗 Datasets, downloading and preparing data is extremely simple. \n",
+    "We can download and prepare the Common Voice splits in just one line of code. \n",
+    "\n",
+    "First, ensure you have accepted the terms of use on the Hugging Face Hub: [mozilla-foundation/common_voice_11_0](https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0). Once you have accepted the terms, you will have full access to the dataset and be able to download the data locally.\n",
+    "\n",
+    "Since Arabic is very low-resource, we'll combine the `train` and `validation` \n",
+    "splits to give approximately 8 hours of training data. We'll use the 4 hours \n",
+    "of `test` data as our held-out test set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5de15d70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_name = \"openai/whisper-small\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2787582-554f-44ce-9f38-4180a5ed6b44",
+   "metadata": {
+    "id": "a2787582-554f-44ce-9f38-4180a5ed6b44"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset, DatasetDict\n",
+    "\n",
+    "common_voice = DatasetDict()\n",
+    "\n",
+    "common_voice[\"train\"] = load_dataset(\"mozilla-foundation/common_voice_11_0\", \"ar\", split=\"train+validation\", use_auth_token=True)\n",
+    "common_voice[\"test\"] = load_dataset(\"mozilla-foundation/common_voice_11_0\", \"ar\", split=\"test\", use_auth_token=True)\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5c7c3d6-7197-41e7-a088-49b753c1681f",
+   "metadata": {
+    "id": "d5c7c3d6-7197-41e7-a088-49b753c1681f"
+   },
+   "source": [
+    "Most ASR datasets only provide input audio samples (`audio`) and the \n",
+    "corresponding transcribed text (`sentence`). Common Voice contains additional \n",
+    "metadata information, such as `accent` and `locale`, which we can disregard for ASR.\n",
+    "Keeping the notebook as general as possible, we only consider the input audio and\n",
+    "transcribed text for fine-tuning, discarding the additional metadata information:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce",
+   "metadata": {
+    "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce"
+   },
+   "outputs": [],
+   "source": [
+    "common_voice = common_voice.remove_columns([\"accent\", \"age\", \"client_id\", \"down_votes\", \"gender\", \"locale\", \"path\", \"segment\", \"up_votes\"])\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605",
+   "metadata": {
+    "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605"
+   },
+   "source": [
+    "## Prepare Feature Extractor, Tokenizer and Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "601c3099-1026-439e-93e2-5635b3ba5a73",
+   "metadata": {
+    "id": "601c3099-1026-439e-93e2-5635b3ba5a73"
+   },
+   "source": [
+    "The ASR pipeline can be de-composed into three stages: \n",
+    "1) A feature extractor which pre-processes the raw audio-inputs\n",
+    "2) The model which performs the sequence-to-sequence mapping \n",
+    "3) A tokenizer which post-processes the model outputs to text format\n",
+    "\n",
+    "In 🤗 Transformers, the Whisper model has an associated feature extractor and tokenizer, \n",
+    "called [WhisperFeatureExtractor](https://huggingface.co/docs/transformers/main/model_doc/whisper#transformers.WhisperFeatureExtractor)\n",
+    "and [WhisperTokenizer](https://huggingface.co/docs/transformers/main/model_doc/whisper#transformers.WhisperTokenizer) \n",
+    "respectively.\n",
+    "\n",
+    "We'll go through details for setting-up the feature extractor and tokenizer one-by-one!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "560332eb-3558-41a1-b500-e83a9f695f84",
+   "metadata": {
+    "id": "560332eb-3558-41a1-b500-e83a9f695f84"
+   },
+   "source": [
+    "### Load WhisperFeatureExtractor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32ec8068-0bd7-412d-b662-0edb9d1e7365",
+   "metadata": {
+    "id": "32ec8068-0bd7-412d-b662-0edb9d1e7365"
+   },
+   "source": [
+    "The Whisper feature extractor performs two operations:\n",
+    "1. Pads / truncates the audio inputs to 30s: any audio inputs shorter than 30s are padded to 30s with silence (zeros), and those longer that 30s are truncated to 30s\n",
+    "2. Converts the audio inputs to _log-Mel spectrogram_ input features, a visual representation of the audio and the form of the input expected by the Whisper model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "589d9ec1-d12b-4b64-93f7-04c63997da19",
+   "metadata": {
+    "id": "589d9ec1-d12b-4b64-93f7-04c63997da19"
+   },
+   "source": [
+    "<figure>\n",
+    "<img src=\"https://raw.githubusercontent.com/sanchit-gandhi/notebooks/main/spectrogram.jpg\" alt=\"Trulli\" style=\"width:100%\">\n",
+    "<figcaption align = \"center\"><b>Figure 2:</b> Conversion of sampled audio array to log-Mel spectrogram.\n",
+    "Left: sampled 1-dimensional audio signal. Right: corresponding log-Mel spectrogram. Figure source:\n",
+    "<a href=\"https://ai.googleblog.com/2019/04/specaugment-new-data-augmentation.html\">Google SpecAugment Blog</a>.\n",
+    "</figcaption>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2ef54d5-b946-4c1d-9fdc-adc5d01b46aa",
+   "metadata": {
+    "id": "b2ef54d5-b946-4c1d-9fdc-adc5d01b46aa"
+   },
+   "source": [
+    "We'll load the feature extractor from the pre-trained checkpoint with the default values:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5",
+   "metadata": {
+    "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperFeatureExtractor\n",
+    "\n",
+    "feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93748af7-b917-4ecf-a0c8-7d89077ff9cb",
+   "metadata": {
+    "id": "93748af7-b917-4ecf-a0c8-7d89077ff9cb"
+   },
+   "source": [
+    "### Load WhisperTokenizer"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "2bc82609-a9fb-447a-a2af-99597c864029",
+   "metadata": {
+    "id": "2bc82609-a9fb-447a-a2af-99597c864029"
+   },
+   "source": [
+    "The Whisper model outputs a sequence of _token ids_. The tokenizer maps each of these token ids to their corresponding text string. For Arabic, we can load the pre-trained tokenizer and use it for fine-tuning without any further modifications. We simply have to \n",
+    "specify the target language and the task. These arguments inform the \n",
+    "tokenizer to prefix the language and task tokens to the start of encoded \n",
+    "label sequences:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+   "metadata": {
+    "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+    "outputId": "5c004b44-86e7-4e00-88be-39e0af5eed69"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "90d056e20b3e4f14ae0199a1a4ab1bb0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/829 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d82a88daec0e4f14add691b7b903064c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/1.04M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "350acdb0f40e454099fa901e66de55f0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/494k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2e6a82a462cc411d90fa1bea4ee60790",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/52.7k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c74bfee0198b4817832ea86e8e88d96c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/2.11k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "04fb2d81eff646068e10475a08ae42f4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/2.06k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from transformers import WhisperTokenizer\n",
+    "\n",
+    "tokenizer = WhisperTokenizer.from_pretrained(\"openai/whisper-small\", language=\"Arabic\", task=\"transcribe\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2ef23f3-f4a8-483a-a2dc-080a7496cb1b",
+   "metadata": {
+    "id": "d2ef23f3-f4a8-483a-a2dc-080a7496cb1b"
+   },
+   "source": [
+    "### Combine To Create A WhisperProcessor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ff67654-5a29-4bb8-a69d-0228946c6f8d",
+   "metadata": {
+    "id": "5ff67654-5a29-4bb8-a69d-0228946c6f8d"
+   },
+   "source": [
+    "To simplify using the feature extractor and tokenizer, we can _wrap_ \n",
+    "both into a single `WhisperProcessor` class. This processor object \n",
+    "inherits from the `WhisperFeatureExtractor` and `WhisperProcessor`, \n",
+    "and can be used on the audio inputs and model predictions as required. \n",
+    "In doing so, we only need to keep track of two objects during training: \n",
+    "the `processor` and the `model`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6",
+   "metadata": {
+    "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperProcessor\n",
+    "\n",
+    "processor = WhisperProcessor.from_pretrained(model_name, language=\"Arabic\", task=\"transcribe\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c",
+   "metadata": {
+    "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c"
+   },
+   "source": [
+    "### Prepare Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9649bf01-2e8a-45e5-8fca-441c13637b8f",
+   "metadata": {
+    "id": "9649bf01-2e8a-45e5-8fca-441c13637b8f"
+   },
+   "source": [
+    "Let's print the first example of the Common Voice dataset to see \n",
+    "what form the data is in:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255",
+   "metadata": {
+    "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255"
+   },
+   "outputs": [],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd",
+   "metadata": {
+    "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd"
+   },
+   "source": [
+    "Since \n",
+    "our input audio is sampled at 48kHz, we need to _downsample_ it to \n",
+    "16kHz prior to passing it to the Whisper feature extractor, 16kHz being the sampling rate expected by the Whisper model. \n",
+    "\n",
+    "We'll set the audio inputs to the correct sampling rate using dataset's \n",
+    "[`cast_column`](https://huggingface.co/docs/datasets/package_reference/main_classes.html?highlight=cast_column#datasets.DatasetDict.cast_column)\n",
+    "method. This operation does not change the audio in-place, \n",
+    "but rather signals to `datasets` to resample audio samples _on the fly_ the \n",
+    "first time that they are loaded:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f12e2e57-156f-417b-8cfb-69221cc198e8",
+   "metadata": {
+    "id": "f12e2e57-156f-417b-8cfb-69221cc198e8"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import Audio\n",
+    "\n",
+    "common_voice = common_voice.cast_column(\"audio\", Audio(sampling_rate=16000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707",
+   "metadata": {
+    "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707"
+   },
+   "source": [
+    "Re-loading the first audio sample in the Common Voice dataset will resample \n",
+    "it to the desired sampling rate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87122d71-289a-466a-afcf-fa354b18946b",
+   "metadata": {
+    "id": "87122d71-289a-466a-afcf-fa354b18946b"
+   },
+   "outputs": [],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3df7378a-a4c0-45d7-8d07-defbd1062ab6",
+   "metadata": {},
+   "source": [
+    "We'll define our pre-processing strategy. We advise that you **do not** lower-case the transcriptions or remove punctuation unless mixing different datasets. This will enable you to fine-tune Whisper models that can predict punctuation and casing. Later, you will see how we can evaluate the predictions without punctuation or casing, so that the models benefit from the WER improvement obtained by normalising the transcriptions while still predicting fully formatted transcriptions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d041650e-1c48-4439-87b3-5b6f4a514107",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers.models.whisper.english_normalizer import BasicTextNormalizer\n",
+    "\n",
+    "do_lower_case = False\n",
+    "do_remove_punctuation = False\n",
+    "\n",
+    "normalizer = BasicTextNormalizer()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89e12c2e-2f14-479b-987b-f0c75c881095",
+   "metadata": {},
+   "source": [
+    "Now we can write a function to prepare our data ready for the model:\n",
+    "1. We load and resample the audio data by calling `batch[\"audio\"]`. As explained above, 🤗 Datasets performs any necessary resampling operations on the fly.\n",
+    "2. We use the feature extractor to compute the log-Mel spectrogram input features from our 1-dimensional audio array.\n",
+    "3. We perform any optional pre-processing (lower-case or remove punctuation).\n",
+    "4. We encode the transcriptions to label ids through the use of the tokenizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c085911c-a10a-41ef-8874-306e0503e9bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def prepare_dataset(batch):\n",
+    "    # load and (possibly) resample audio data to 16kHz\n",
+    "    audio = batch[\"audio\"]\n",
+    "\n",
+    "    # compute log-Mel input features from input audio array \n",
+    "    batch[\"input_features\"] = processor.feature_extractor(audio[\"array\"], sampling_rate=audio[\"sampling_rate\"]).input_features[0]\n",
+    "    # compute input length of audio sample in seconds\n",
+    "    batch[\"input_length\"] = len(audio[\"array\"]) / audio[\"sampling_rate\"]\n",
+    "    \n",
+    "    # optional pre-processing steps\n",
+    "    transcription = batch[\"sentence\"]\n",
+    "    if do_lower_case:\n",
+    "        transcription = transcription.lower()\n",
+    "    if do_remove_punctuation:\n",
+    "        transcription = normalizer(transcription).strip()\n",
+    "    \n",
+    "    # encode target text to label ids\n",
+    "    batch[\"labels\"] = processor.tokenizer(transcription).input_ids\n",
+    "    return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c960965-9fb6-466f-9dbd-c9d43e71d9d0",
+   "metadata": {
+    "id": "70b319fb-2439-4ef6-a70d-a47bf41c4a13"
+   },
+   "source": [
+    "We can apply the data preparation function to all of our training examples using dataset's `.map` method. The argument `num_proc` specifies how many CPU cores to use. Setting `num_proc` > 1 will enable multiprocessing. If the `.map` method hangs with multiprocessing, set `num_proc=1` and process the dataset sequentially."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b",
+   "metadata": {
+    "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b"
+   },
+   "outputs": [],
+   "source": [
+    "common_voice = common_voice.map(prepare_dataset, remove_columns=common_voice.column_names[\"train\"], num_proc=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54ce0fdb-7218-4a4d-b175-383980fec0df",
+   "metadata": {},
+   "source": [
+    "Finally, we filter any training data with audio samples longer than 30s. These samples would otherwise be truncated by the Whisper feature-extractor which could affect the stability of training. We define a function that returns `True` for samples that are less than 30s, and `False` for those that are longer:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "01cb25ef-4bb0-4325-9461-f59198acadf6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "max_input_length = 30.0\n",
+    "\n",
+    "def is_audio_in_length_range(length):\n",
+    "    return length < max_input_length"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30e676a8-7ca8-4850-8c5d-5b2b00d13fba",
+   "metadata": {},
+   "source": [
+    "We apply our filter function to all samples of our training dataset through 🤗 Datasets' `.filter` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "333f7f6e-6053-4d3b-8924-c733c79b82ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "common_voice[\"train\"] = common_voice[\"train\"].filter(\n",
+    "    is_audio_in_length_range,\n",
+    "    input_columns=[\"input_length\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "263a5a58-0239-4a25-b0df-c625fc9c5810",
+   "metadata": {
+    "id": "263a5a58-0239-4a25-b0df-c625fc9c5810"
+   },
+   "source": [
+    "## Training and Evaluation"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "id": "a693e768-c5a6-453f-89a1-b601dcf7daf7",
+   "metadata": {
+    "id": "a693e768-c5a6-453f-89a1-b601dcf7daf7"
+   },
+   "source": [
+    "Now that we've prepared our data, we're ready to dive into the training pipeline. \n",
+    "The [🤗 Trainer](https://huggingface.co/transformers/master/main_classes/trainer.html?highlight=trainer)\n",
+    "will do much of the heavy lifting for us. All we have to do is:\n",
+    "\n",
+    "- Define a data collator: the data collator takes our pre-processed data and prepares PyTorch tensors ready for the model.\n",
+    "\n",
+    "- Evaluation metrics: during evaluation, we want to evaluate the model using the [word error rate (WER)](https://huggingface.co/metrics/wer) metric. We need to define a `compute_metrics` function that handles this computation.\n",
+    "\n",
+    "- Load a pre-trained checkpoint: we need to load a pre-trained checkpoint and configure it correctly for training.\n",
+    "\n",
+    "- Define the training configuration: this will be used by the 🤗 Trainer to define the training schedule.\n",
+    "\n",
+    "Once we've fine-tuned the model, we will evaluate it on the test data to verify that we have correctly trained it \n",
+    "to transcribe speech in Arabic."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d230e6d-624c-400a-bbf5-fa660881df25",
+   "metadata": {
+    "id": "8d230e6d-624c-400a-bbf5-fa660881df25"
+   },
+   "source": [
+    "### Define a Data Collator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04def221-0637-4a69-b242-d3f0c1d0ee78",
+   "metadata": {
+    "id": "04def221-0637-4a69-b242-d3f0c1d0ee78"
+   },
+   "source": [
+    "The data collator for a sequence-to-sequence speech model is unique in the sense that it \n",
+    "treats the `input_features` and `labels` independently: the  `input_features` must be \n",
+    "handled by the feature extractor and the `labels` by the tokenizer.\n",
+    "\n",
+    "The `input_features` are already padded to 30s and converted to a log-Mel spectrogram \n",
+    "of fixed dimension by action of the feature extractor, so all we have to do is convert the `input_features`\n",
+    "to batched PyTorch tensors. We do this using the feature extractor's `.pad` method with `return_tensors=pt`.\n",
+    "\n",
+    "The `labels` on the other hand are un-padded. We first pad the sequences\n",
+    "to the maximum length in the batch using the tokenizer's `.pad` method. The padding tokens \n",
+    "are then replaced by `-100` so that these tokens are **not** taken into account when \n",
+    "computing the loss. We then cut the BOS token from the start of the label sequence as we \n",
+    "append it later during training.\n",
+    "\n",
+    "We can leverage the `WhisperProcessor` we defined earlier to perform both the \n",
+    "feature extractor and the tokenizer operations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5",
+   "metadata": {
+    "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "from dataclasses import dataclass\n",
+    "from typing import Any, Dict, List, Union\n",
+    "\n",
+    "@dataclass\n",
+    "class DataCollatorSpeechSeq2SeqWithPadding:\n",
+    "    processor: Any\n",
+    "\n",
+    "    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n",
+    "        # split inputs and labels since they have to be of different lengths and need different padding methods\n",
+    "        # first treat the audio inputs by simply returning torch tensors\n",
+    "        input_features = [{\"input_features\": feature[\"input_features\"]} for feature in features]\n",
+    "        batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # get the tokenized label sequences\n",
+    "        label_features = [{\"input_ids\": feature[\"labels\"]} for feature in features]\n",
+    "        # pad the labels to max length\n",
+    "        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # replace padding with -100 to ignore loss correctly\n",
+    "        labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n",
+    "\n",
+    "        # if bos token is appended in previous tokenization step,\n",
+    "        # cut bos token here as it's append later anyways\n",
+    "        if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item():\n",
+    "            labels = labels[:, 1:]\n",
+    "\n",
+    "        batch[\"labels\"] = labels\n",
+    "\n",
+    "        return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86",
+   "metadata": {
+    "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86"
+   },
+   "source": [
+    "Let's initialise the data collator we've just defined:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc834702-c0d3-4a96-b101-7b87be32bf42",
+   "metadata": {
+    "id": "fc834702-c0d3-4a96-b101-7b87be32bf42"
+   },
+   "outputs": [],
+   "source": [
+    "data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698",
+   "metadata": {
+    "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698"
+   },
+   "source": [
+    "### Evaluation Metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66fee1a7-a44c-461e-b047-c3917221572e",
+   "metadata": {
+    "id": "66fee1a7-a44c-461e-b047-c3917221572e"
+   },
+   "source": [
+    "We'll use the word error rate (WER) metric, the 'de-facto' metric for assessing \n",
+    "ASR systems. For more information, refer to the WER [docs](https://huggingface.co/metrics/wer). We'll load the WER metric from 🤗 Evaluate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b22b4011-f31f-4b57-b684-c52332f92890",
+   "metadata": {
+    "id": "b22b4011-f31f-4b57-b684-c52332f92890"
+   },
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "\n",
+    "metric = evaluate.load(\"wer\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508",
+   "metadata": {
+    "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508"
+   },
+   "source": [
+    "We then simply have to define a function that takes our model \n",
+    "predictions and returns the WER metric. This function, called\n",
+    "`compute_metrics`, first replaces `-100` with the `pad_token_id`\n",
+    "in the `label_ids` (undoing the step we applied in the \n",
+    "data collator to ignore padded tokens correctly in the loss).\n",
+    "It then decodes the predicted and label ids to strings. Finally,\n",
+    "it computes the WER between the predictions and reference labels. \n",
+    "Here, we have the option of evaluating with the 'normalised' transcriptions \n",
+    "and predictions. We recommend you set this to `True` to benefit from the WER \n",
+    "improvement obtained by normalising the transcriptions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52",
+   "metadata": {
+    "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52"
+   },
+   "outputs": [],
+   "source": [
+    "# evaluate with the 'normalised' WER\n",
+    "do_normalize_eval = True\n",
+    "\n",
+    "def compute_metrics(pred):\n",
+    "    pred_ids = pred.predictions\n",
+    "    label_ids = pred.label_ids\n",
+    "\n",
+    "    # replace -100 with the pad_token_id\n",
+    "    label_ids[label_ids == -100] = processor.tokenizer.pad_token_id\n",
+    "\n",
+    "    # we do not want to group tokens when computing the metrics\n",
+    "    pred_str = processor.tokenizer.batch_decode(pred_ids, skip_special_tokens=True)\n",
+    "    label_str = processor.tokenizer.batch_decode(label_ids, skip_special_tokens=True)\n",
+    "\n",
+    "    if do_normalize_eval:\n",
+    "        pred_str = [normalizer(pred) for pred in pred_str]\n",
+    "        label_str = [normalizer(label) for label in label_str]\n",
+    "\n",
+    "    wer = 100 * metric.compute(predictions=pred_str, references=label_str)\n",
+    "\n",
+    "    return {\"wer\": wer}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "daf2a825-6d9f-4a23-b145-c37c0039075b",
+   "metadata": {
+    "id": "daf2a825-6d9f-4a23-b145-c37c0039075b"
+   },
+   "source": [
+    "### Load a Pre-Trained Checkpoint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "437a97fa-4864-476b-8abc-f28b8166cfa5",
+   "metadata": {
+    "id": "437a97fa-4864-476b-8abc-f28b8166cfa5"
+   },
+   "source": [
+    "Now let's load the pre-trained Whisper `small` checkpoint. Again, this \n",
+    "is trivial through use of 🤗 Transformers!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f",
+   "metadata": {
+    "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperForConditionalGeneration\n",
+    "\n",
+    "model = WhisperForConditionalGeneration.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a15ead5f-2277-4a39-937b-585c2497b2df",
+   "metadata": {
+    "id": "a15ead5f-2277-4a39-937b-585c2497b2df"
+   },
+   "source": [
+    "Override generation arguments - no tokens are forced as decoder outputs (see [`forced_decoder_ids`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.forced_decoder_ids)), no tokens are suppressed during generation (see [`suppress_tokens`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.suppress_tokens)). Set `use_cache` to False since we're using gradient checkpointing, and the two are incompatible:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62038ba3-88ed-4fce-84db-338f50dcd04f",
+   "metadata": {
+    "id": "62038ba3-88ed-4fce-84db-338f50dcd04f"
+   },
+   "outputs": [],
+   "source": [
+    "model.config.forced_decoder_ids = None\n",
+    "model.config.suppress_tokens = []\n",
+    "model.config.use_cache = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06",
+   "metadata": {
+    "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06"
+   },
+   "source": [
+    "### Define the Training Configuration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c21af1e9-0188-4134-ac82-defc7bdcc436",
+   "metadata": {
+    "id": "c21af1e9-0188-4134-ac82-defc7bdcc436"
+   },
+   "source": [
+    "In the final step, we define all the parameters related to training. For more detail on the training arguments, refer to the Seq2SeqTrainingArguments [docs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a",
+   "metadata": {
+    "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainingArguments\n",
+    "\n",
+    "training_args = Seq2SeqTrainingArguments(\n",
+    "    output_dir=\"./\",\n",
+    "    per_device_train_batch_size=64,\n",
+    "    gradient_accumulation_steps=1,  # increase by 2x for every 2x decrease in batch size\n",
+    "    learning_rate=1e-5,\n",
+    "    warmup_steps=500,\n",
+    "    max_steps=5000,\n",
+    "    gradient_checkpointing=True,\n",
+    "    fp16=True,\n",
+    "    evaluation_strategy=\"steps\",\n",
+    "    per_device_eval_batch_size=8,\n",
+    "    predict_with_generate=True,\n",
+    "    generation_max_length=225,\n",
+    "    save_steps=1000,\n",
+    "    eval_steps=1000,\n",
+    "    logging_steps=25,\n",
+    "    report_to=[\"tensorboard\"],\n",
+    "    load_best_model_at_end=True,\n",
+    "    metric_for_best_model=\"wer\",\n",
+    "    greater_is_better=False,\n",
+    "    push_to_hub=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3a944d8-3112-4552-82a0-be25988b3857",
+   "metadata": {
+    "id": "b3a944d8-3112-4552-82a0-be25988b3857"
+   },
+   "source": [
+    "**Note**: if one does not want to upload the model checkpoints to the Hub, \n",
+    "set `push_to_hub=False`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bac29114-d226-4f54-97cf-8718c9f94e1e",
+   "metadata": {
+    "id": "bac29114-d226-4f54-97cf-8718c9f94e1e"
+   },
+   "source": [
+    "We can forward the training arguments to the 🤗 Trainer along with our model,\n",
+    "dataset, data collator and `compute_metrics` function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d546d7fe-0543-479a-b708-2ebabec19493",
+   "metadata": {
+    "id": "d546d7fe-0543-479a-b708-2ebabec19493"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainer\n",
+    "\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    args=training_args,\n",
+    "    model=model,\n",
+    "    train_dataset=common_voice[\"train\"],\n",
+    "    eval_dataset=common_voice[\"test\"],\n",
+    "    data_collator=data_collator,\n",
+    "    compute_metrics=compute_metrics,\n",
+    "    tokenizer=processor.feature_extractor,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "uOrRhDGtN5S4",
+   "metadata": {
+    "id": "uOrRhDGtN5S4"
+   },
+   "source": [
+    "We'll save the processor object once before starting training. Since the processor is not trainable, it won't change over the course of training:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "-2zQwMfEOBJq",
+   "metadata": {
+    "id": "-2zQwMfEOBJq"
+   },
+   "outputs": [],
+   "source": [
+    "processor.save_pretrained(training_args.output_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f404cf9-4345-468c-8196-4bd101d9bd51",
+   "metadata": {
+    "id": "7f404cf9-4345-468c-8196-4bd101d9bd51"
+   },
+   "source": [
+    "### Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e8b8d56-5a70-4f68-bd2e-f0752d0bd112",
+   "metadata": {
+    "id": "5e8b8d56-5a70-4f68-bd2e-f0752d0bd112"
+   },
+   "source": [
+    "Training will take approximately 5-10 hours depending on your GPU. The peak GPU memory for the given training configuration is approximately 36GB. \n",
+    "Depending on your GPU, it is possible that you will encounter a CUDA `\"out-of-memory\"` error when you launch training. \n",
+    "In this case, you can reduce the `per_device_train_batch_size` incrementally by factors of 2 \n",
+    "and employ [`gradient_accumulation_steps`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments.gradient_accumulation_steps)\n",
+    "to compensate.\n",
+    "\n",
+    "To launch training, simply execute:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de",
+   "metadata": {
+    "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de"
+   },
+   "outputs": [],
+   "source": [
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "810ced54-7187-4a06-b2fe-ba6dcca94dc3",
+   "metadata": {
+    "id": "810ced54-7187-4a06-b2fe-ba6dcca94dc3"
+   },
+   "source": [
+    "We can label our checkpoint with the `whisper-event` tag on push by setting the appropriate key-word arguments (kwargs):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c704f91e-241b-48c9-b8e0-f0da396a9663",
+   "metadata": {
+    "id": "c704f91e-241b-48c9-b8e0-f0da396a9663"
+   },
+   "outputs": [],
+   "source": [
+    "kwargs = {\n",
+    "    \"dataset_tags\": \"mozilla-foundation/common_voice_11_0\",\n",
+    "    \"dataset\": \"Common Voice 11.0\",  # a 'pretty' name for the training dataset\n",
+    "    \"language\": \"ar\",\n",
+    "    \"model_name\": \"Whisper Small ar - Zaid Alyafeai\",  # a 'pretty' name for your model\n",
+    "    \"finetuned_from\": model_name,\n",
+    "    \"tasks\": \"automatic-speech-recognition\",\n",
+    "    \"tags\": \"whisper-event\",\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "090d676a-f944-4297-a938-a40eda0b2b68",
+   "metadata": {
+    "id": "090d676a-f944-4297-a938-a40eda0b2b68"
+   },
+   "source": [
+    "The training results can now be uploaded to the Hub. To do so, execute the `push_to_hub` command and save the preprocessor object we created:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d7030622-caf7-4039-939b-6195cdaa2585",
+   "metadata": {
+    "id": "d7030622-caf7-4039-939b-6195cdaa2585"
+   },
+   "outputs": [],
+   "source": [
+    "trainer.push_to_hub(**kwargs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca743fbd-602c-48d4-ba8d-a2fe60af64ba",
+   "metadata": {
+    "id": "ca743fbd-602c-48d4-ba8d-a2fe60af64ba"
+   },
+   "source": [
+    "## Closing Remarks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f737783-2870-4e35-aa11-86a42d7d997a",
+   "metadata": {
+    "id": "7f737783-2870-4e35-aa11-86a42d7d997a"
+   },
+   "source": [
+    "In this blog, we covered a step-by-step guide on fine-tuning Whisper for multilingual ASR \n",
+    "using 🤗 Datasets, Transformers and the Hugging Face Hub. For more details on the Whisper model, the Common Voice dataset and the theory behind fine-tuning, refere to the accompanying [blog post](https://huggingface.co/blog/fine-tune-whisper). If you're interested in fine-tuning other \n",
+    "Transformers models, both for English and multilingual ASR, be sure to check out the \n",
+    "examples scripts at [examples/pytorch/speech-recognition](https://github.com/huggingface/transformers/tree/main/examples/pytorch/speech-recognition)."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "include_colab_link": true,
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.5 (default, Nov 23 2021, 15:27:38) \n[GCC 9.3.0]"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "f9f85f796d01129d0dd105a088854619f454435301f6ffec2fea96ecbd9be4ac"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

.ipynb_checkpoints/mgb2_speech-checkpoint.py

@@ -0,0 +1,169 @@
+import datasets
+import os
+
+
+_DESCRIPTION = "MGB2 speech recognition dataset AR"
+_HOMEPAGE = "https://arabicspeech.org/mgb2/"
+_LICENSE = "MGB-2 License agreement"
+_CITATION = """@misc{https://doi.org/10.48550/arxiv.1609.05625,
+  doi = {10.48550/ARXIV.1609.05625},
+  
+  url = {https://arxiv.org/abs/1609.05625},
+  
+  author = {Ali, Ahmed and Bell, Peter and Glass, James and Messaoui, Yacine and Mubarak, Hamdy and Renals, Steve and Zhang, Yifan},
+  
+  keywords = {Computation and Language (cs.CL), FOS: Computer and information sciences, FOS: Computer and information sciences},
+  
+  title = {The MGB-2 Challenge: Arabic Multi-Dialect Broadcast Media Recognition},
+  
+  publisher = {arXiv},
+  
+  year = {2016},
+  
+  copyright = {arXiv.org perpetual, non-exclusive license}
+}
+"""
+_DATA_ARCHIVE_ROOT = "archives/"
+_DATA_URL = {
+    "test": _DATA_ARCHIVE_ROOT + "mgb2_wav.test.tar.gz",
+    "dev": _DATA_ARCHIVE_ROOT + "mgb2_wav.dev.tar.gz",
+    "train": [_DATA_ARCHIVE_ROOT + f"mgb2_wav_{x}.train.tar.gz" for x in range(48)], # we have 48 archives
+}
+_TEXT_URL = {
+    "test": _DATA_ARCHIVE_ROOT + "mgb2_txt.test.tar.gz",
+    "dev": _DATA_ARCHIVE_ROOT + "mgb2_txt.dev.tar.gz",
+    "train": _DATA_ARCHIVE_ROOT + "mgb2_txt.train.tar.gz",
+}
+
+class MGDB2Dataset(datasets.GeneratorBasedBuilder):
+    def _info(self):
+        return datasets.DatasetInfo(
+        description=_DESCRIPTION,
+        features=datasets.Features(
+            {
+                "path": datasets.Value("string"),
+                "audio": datasets.Audio(sampling_rate=16_000),
+                "text": datasets.Value("string"),
+            }
+        ),
+        supervised_keys=None,
+        homepage=_HOMEPAGE,
+        license=_LICENSE,
+        citation=_CITATION,
+    )
+
+    def _split_generators(self, dl_manager):
+        wav_archive = dl_manager.download(_DATA_URL)
+        txt_archive = dl_manager.download(_TEXT_URL)
+        test_dir = "dataset/test"
+        dev_dir = "dataset/dev"
+        train_dir = "dataset/train"
+
+        if dl_manager.is_streaming:
+    
+            return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "path_to_txt": test_dir + "/txt",
+                    "path_to_wav": test_dir + "/wav",
+                    "wav_files": [dl_manager.iter_archive(wav_archive['test'])],
+                    "txt_files": dl_manager.iter_archive(txt_archive['test']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "path_to_txt": dev_dir + "/txt",
+                    "path_to_wav": dev_dir + "/wav",
+                    "wav_files": [dl_manager.iter_archive(wav_archive['dev'])],
+                    "txt_files": dl_manager.iter_archive(txt_archive['dev']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "path_to_txt": train_dir + "/txt",
+                    "path_to_wav": train_dir + "/wav",
+                    "wav_files": [dl_manager.iter_archive(a) for a in wav_archive['train']],
+                    "txt_files": dl_manager.iter_archive(txt_archive['train']),
+                },
+            ),
+        ]
+        else:
+            return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "path_to_txt": test_dir + "/txt",
+                    "path_to_wav": test_dir + "/wav",
+                    "wav_files": [dl_manager.extract(wav_archive['test'])],
+                    "txt_files": dl_manager.extract(txt_archive['test']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "path_to_txt": dev_dir + "/txt",
+                    "path_to_wav": dev_dir + "/wav",
+                    "wav_files": [dl_manager.extract(wav_archive['dev'])],
+                    "txt_files": dl_manager.extract(txt_archive['dev']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "path_to_txt": train_dir + "/txt",
+                    "path_to_wav": train_dir + "/wav",
+                    "wav_files": [dl_manager.extract(a) for a in wav_archive['train']],
+                    "txt_files": dl_manager.extract(txt_archive['train']),
+                },
+            ),
+        ]
+
+
+    
+    def _generate_examples(self, path_to_txt, path_to_wav, wav_files, txt_files):
+        """ 
+        This assumes that the text directory alphabetically precedes the wav dir
+        The file names for wav and text seem to match and are unique
+        We can use them for the dictionary matching them
+        """
+        examples = {}
+        id_ = 0
+        # need to prepare the transcript - wave map
+        for item in txt_files:
+            if type(item) is tuple:
+                # iter_archive will return path and file
+                path, f = item
+                txt = f.read().decode(encoding="utf-8").strip()
+            else:
+                # extract will return path only
+                path = item
+                with open(path, encoding="utf-8") as f:
+                    txt = f.read().strip()
+
+            if path.find(path_to_txt) > -1:
+                # construct the wav path
+                # which is used as an identifier
+                wav_path = os.path.split(path)[1].replace("_utf8", "").replace(".txt", ".wav").strip()
+                
+                examples[wav_path] = {
+                    "text": txt,
+                    "path": wav_path,
+                }
+
+        for wf in wav_files:
+            for item in wf:
+                if type(item) is tuple:
+                    path, f = item
+                    wav_data = f.read()
+                else:
+                    path = item
+                    with open(path, "rb") as f:
+                        wav_data = f.read()
+                if path.find(path_to_wav) > -1:
+                    wav_path = os.path.split(path)[1].strip()
+                    audio = {"path": path, "bytes": wav_data}
+                    yield id_, {**examples[wav_path], "audio": audio}
+                    id_ += 1

.ipynb_checkpoints/run_mgb2-checkpoint.sh

@@ -0,0 +1,38 @@
+python run_speech_recognition_seq2seq_mixed_mgb2-cv1.py \
+--model_name_or_path="openai/whisper-small" \
+--dataset_name="arbml/mgb2_speech" \
+--dataset_config_name="ar" \
+--language="Arabic" \
+--train_split_name="train" \
+--eval_split_name="test" \
+--model_index_name="Whisper Small Arabic" \
+--max_steps="5000" \
+--output_dir="./" \
+--per_device_train_batch_size="64" \
+--per_device_eval_batch_size="8" \
+--logging_steps="25" \
+--learning_rate="1e-5" \
+--warmup_steps="500" \
+--evaluation_strategy="steps" \
+--eval_steps="1000" \
+--save_strategy="steps" \
+--save_steps="1000" \
+--generation_max_length="225" \
+--length_column_name="input_length" \
+--max_duration_in_seconds="30" \
+--text_column_name="sentence" \
+--freeze_feature_encoder="False" \
+--report_to="tensorboard" \
+--metric_for_best_model="wer" \
+--greater_is_better="False" \
+--load_best_model_at_end \
+--gradient_checkpointing \
+--fp16 \
+--overwrite_output_dir \
+--optim="adamw_bnb_8bit" \
+--do_train \
+--do_eval \
+--predict_with_generate \
+--do_normalize_eval \
+--use_auth_token \
+--push_to_hub

.ipynb_checkpoints/run_speech_recognition_seq2seq_mixed_mgb2-checkpoint.py

@@ -0,0 +1,748 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for sequence to sequence speech recognition
+with 🤗 Datasets' streaming mode.
+"""
+# You can also adapt this script for your own sequence to sequence speech
+# recognition task. Pointers for this are left as comments.
+
+import logging
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+import datasets
+import torch
+from datasets import DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset
+from torch.utils.data import IterableDataset
+
+import evaluate
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoFeatureExtractor,
+    AutoModelForSpeechSeq2Seq,
+    AutoProcessor,
+    AutoTokenizer,
+    HfArgumentParser,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+    TrainerCallback,
+    set_seed,
+)
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+from transformers.trainer_pt_utils import IterableDatasetShard
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.25.0.dev0")
+
+require_version(
+    "datasets>=1.18.2",
+    "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt",
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={
+            "help": "Path to pretrained model or model identifier from huggingface.co/models"
+        }
+    )
+    config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained config name or path if not the same as model_name"
+        },
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained tokenizer name or path if not the same as model_name"
+        },
+    )
+    feature_extractor_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "feature extractor name or path if not the same as model_name"
+        },
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Where to store the pretrained models downloaded from huggingface.co"
+        },
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."
+        },
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={
+            "help": "The specific model version to use (can be a branch name, tag name or commit id)."
+        },
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+                "with private models)."
+            )
+        },
+    )
+    freeze_feature_encoder: bool = field(
+        default=True,
+        metadata={"help": "Whether to freeze the feature encoder layers of the model."},
+    )
+    freeze_encoder: bool = field(
+        default=False,
+        metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."},
+    )
+    forced_decoder_ids: List[List[int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "A list of pairs of integers which indicates a mapping from generation indices to token indices "
+                "that will be forced before sampling. For example, [[0, 123]] means the first generated token "
+                "will always be a token of index 123."
+            )
+        },
+    )
+    suppress_tokens: List[int] = field(
+        default=None,
+        metadata={"help": "A list of tokens that will be suppressed at generation."},
+    )
+    model_index_name: str = field(
+        default=None, metadata={"help": "Pretty name for the model card."}
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: str = field(
+        default=None,
+        metadata={"help": "The name of the dataset to use (via the datasets library)."},
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The configuration name of the dataset to use (via the datasets library)."
+        },
+    )
+    text_column: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The name of the column in the datasets containing the full texts (for summarization)."
+        },
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of training examples to this "
+                "value if set."
+            )
+        },
+    )
+    max_eval_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of evaluation examples to this "
+                "value if set."
+            )
+        },
+    )
+    audio_column_name: str = field(
+        default="audio",
+        metadata={
+            "help": "The name of the dataset column containing the audio data. Defaults to 'audio'"
+        },
+    )
+    text_column_name: str = field(
+        default="text",
+        metadata={
+            "help": "The name of the dataset column containing the text data. Defaults to 'text'"
+        },
+    )
+    max_duration_in_seconds: float = field(
+        default=20.0,
+        metadata={
+            "help": (
+                "Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
+                " 'max_duration_in_seconds`"
+            )
+        },
+    )
+    min_duration_in_seconds: float = field(
+        default=0.0,
+        metadata={
+            "help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"
+        },
+    )
+    train_split_name: str = field(
+        default="train",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    eval_split_name: str = field(
+        default="test",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    do_lower_case: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be lower cased."},
+    )
+    do_remove_punctuation: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be striped of punctuation."},
+    )
+    do_normalize_eval: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to normalise the references and predictions in the eval WER calculation."
+        },
+    )
+    language: str = field(
+        default=None,
+        metadata={
+            "help": (
+                "Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
+                "only. For English speech recognition, it should be set to `None`."
+            )
+        },
+    )
+    task: str = field(
+        default="transcribe",
+        metadata={
+            "help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."
+        },
+    )
+    shuffle_buffer_size: Optional[int] = field(
+        default=500,
+        metadata={
+            "help": (
+                "The number of streamed examples to download before shuffling them. The large the buffer, "
+                "the closer it is to real offline shuffling."
+            )
+        },
+    )
+    streaming: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use streaming mode to load and pre-process the data."
+        },
+    )
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor ([`WhisperProcessor`])
+            The processor used for processing the data.
+        decoder_start_token_id (`int`)
+            The begin-of-sentence of the decoder.
+    """
+
+    processor: Any
+    decoder_start_token_id: int
+
+    def __call__(
+        self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
+    ) -> Dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need
+        # different padding methods
+        model_input_name = self.processor.model_input_names[0]
+        input_features = [
+            {model_input_name: feature[model_input_name]} for feature in features
+        ]
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+
+        batch = self.processor.feature_extractor.pad(
+            input_features, return_tensors="pt"
+        )
+
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(
+            labels_batch.attention_mask.ne(1), -100
+        )
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def load_maybe_streaming_dataset(
+    dataset_name, dataset_config_name, split="train", streaming=True, **kwargs
+):
+    """
+    Utility function to load a dataset in streaming mode. For datasets with multiple splits,
+    each split is loaded individually and then splits combined by taking alternating examples from
+    each (interleaving).
+    """
+    if "+" in split:
+        # load multiple splits separated by the `+` symbol with streaming mode
+        dataset_splits = [
+            load_dataset(
+                dataset_name,
+                dataset_config_name,
+                split=split_name,
+                streaming=streaming,
+                **kwargs,
+            )
+            for split_name in split.split("+")
+        ]
+        # interleave multiple splits to form one dataset
+        interleaved_dataset = interleave_datasets(dataset_splits)
+        return interleaved_dataset
+    else:
+        # load a single split *with* streaming mode
+        dataset = load_dataset(
+            dataset_name,
+            dataset_config_name,
+            split=split,
+            streaming=streaming,
+            **kwargs,
+        )
+        return dataset
+
+
+def main():
+    # 1. Parse input arguments
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+    parser = HfArgumentParser(
+        (ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments)
+    )
+
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
+    # information sent is the one passed as arguments along with your Python/PyTorch versions.
+    send_example_telemetry(
+        "run_speech_recognition_seq2seq_streaming", model_args, data_args
+    )
+
+    # 2. Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    log_level = training_args.get_process_log_level()
+    logger.setLevel(log_level)
+    datasets.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.enable_default_handler()
+    transformers.utils.logging.enable_explicit_format()
+
+    logger.setLevel(
+        logging.INFO if is_main_process(training_args.local_rank) else logging.WARN
+    )
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # 3. Detecting last checkpoint and eventually continue from last checkpoint
+    last_checkpoint = None
+    if (
+        os.path.isdir(training_args.output_dir)
+        and training_args.do_train
+        and not training_args.overwrite_output_dir
+    ):
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif (
+            last_checkpoint is not None and training_args.resume_from_checkpoint is None
+        ):
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # 4. Load dataset
+    raw_datasets = IterableDatasetDict()
+
+    if training_args.do_train:
+        raw_datasets["train"] = load_maybe_streaming_dataset(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.train_split_name,
+            streaming=True,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    if training_args.do_eval:
+        raw_datasets["eval"] = load_maybe_streaming_dataset(
+            "arbml/mgb3",
+            data_args.dataset_config_name,
+            split="train",
+            streaming=False,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+
+    if data_args.audio_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--audio_column_name` to the correct audio column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    if data_args.text_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--text_column_name` to the correct text column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    # 5. Load pretrained model, tokenizer, and feature extractor
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    config = AutoConfig.from_pretrained(
+        model_args.config_name
+        if model_args.config_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    config.update(
+        {
+            "forced_decoder_ids": model_args.forced_decoder_ids,
+            "suppress_tokens": model_args.suppress_tokens,
+        }
+    )
+
+    if training_args.gradient_checkpointing:
+        config.update({"use_cache": False})
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        model_args.feature_extractor_name
+        if model_args.feature_extractor_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_args.tokenizer_name
+        if model_args.tokenizer_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        use_fast=model_args.use_fast_tokenizer,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        model_args.model_name_or_path,
+        config=config,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    if model.config.decoder_start_token_id is None:
+        raise ValueError(
+            "Make sure that `config.decoder_start_token_id` is correctly defined"
+        )
+
+    max_label_length = model.config.max_length
+
+    if model_args.freeze_feature_encoder:
+        model.freeze_feature_encoder()
+
+    if model_args.freeze_encoder:
+        model.freeze_encoder()
+        model.model.encoder.gradient_checkpointing = False
+
+    if data_args.language is not None:
+        # We only need to set the task id when the language is specified (i.e. in a multilingual setting)
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
+
+    # 6. Resample speech dataset if necessary
+    dataset_sampling_rate = (
+        next(iter(raw_datasets.values()))
+        .features[data_args.audio_column_name]
+        .sampling_rate
+    )
+    if dataset_sampling_rate != feature_extractor.sampling_rate:
+        raw_datasets = raw_datasets.cast_column(
+            data_args.audio_column_name,
+            datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate),
+        )
+
+    # 7. Preprocessing the datasets.
+    # We need to read the audio files as arrays and tokenize the targets.
+    max_input_length = (
+        data_args.max_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    min_input_length = (
+        data_args.min_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    audio_column_name = data_args.audio_column_name
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    do_lower_case = data_args.do_lower_case
+    do_remove_punctuation = data_args.do_remove_punctuation
+    normalizer = BasicTextNormalizer()  # 'official' text normalizer from OpenAI
+
+    if data_args.max_train_samples is not None:
+        raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
+
+    if data_args.max_eval_samples is not None:
+        raw_datasets["eval"] = raw_datasets["eval"].select(
+            range(data_args.max_eval_samples)
+        )
+
+    def prepare_dataset(batch):
+        # process audio
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(
+            sample["array"], sampling_rate=sample["sampling_rate"]
+        )
+        # process audio length
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch["input_length"] = len(sample["array"])
+
+        # process targets
+        input_str = (
+            batch[text_column_name].lower()
+            if do_lower_case
+            else batch[text_column_name]
+        )
+        if do_remove_punctuation:
+            input_str = normalizer(input_str).strip()
+        batch["labels"] = tokenizer(input_str).input_ids
+        return batch
+
+    with training_args.main_process_first(desc="dataset map pre-processing"):
+        vectorized_datasets = raw_datasets.map(
+            prepare_dataset,
+            remove_columns=raw_datasets_features,
+        ).with_format("torch")
+
+        if training_args.do_train:
+            vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
+                buffer_size=data_args.shuffle_buffer_size,
+                seed=training_args.seed,
+            )
+
+    # filter training data that is shorter than min_input_length or longer than
+    # max_input_length
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+
+    vectorized_datasets["train"] = vectorized_datasets["train"].filter(
+        is_audio_in_length_range,
+        input_columns=["input_length"],
+    )
+
+    def filter_labels(labels):
+        """Filter label sequences longer than max length"""
+        return len(labels) < max_label_length
+
+    vectorized_datasets = vectorized_datasets.filter(
+        filter_labels, input_columns=["labels"]
+    )
+
+    # 8. Load Metric
+    metric = evaluate.load("wer")
+    do_normalize_eval = data_args.do_normalize_eval
+
+    def compute_metrics(pred):
+        pred_ids = pred.predictions
+
+        pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
+
+        pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
+        # we do not want to group tokens when computing the metrics
+        label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
+
+        if do_normalize_eval:
+            pred_str = [normalizer(pred) for pred in pred_str]
+            label_str = [normalizer(label) for label in label_str]
+            # filtering step to only evaluate the samples that correspond to non-zero references:
+            pred_str = [
+                pred_str[i] for i in range(len(pred_str)) if len(label_str[i]) > 0
+            ]
+            label_str = [
+                label_str[i] for i in range(len(label_str)) if len(label_str[i]) > 0
+            ]
+
+        wer = 100 * metric.compute(predictions=pred_str, references=label_str)
+
+        return {"wer": wer}
+
+    # 9. Create a single speech processor
+    if is_main_process(training_args.local_rank):
+        # save feature extractor, tokenizer and config
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+
+    processor = AutoProcessor.from_pretrained(training_args.output_dir)
+
+    # 10. Define data collator
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(
+        processor=processor,
+        decoder_start_token_id=model.config.decoder_start_token_id,
+    )
+
+    # 11. Configure Trainer
+    # Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
+    # Only required for streaming: Trainer automatically shuffles non-streaming datasets
+    class ShuffleCallback(TrainerCallback):
+        def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
+            if isinstance(train_dataloader.dataset, IterableDatasetShard):
+                pass  # set_epoch() is handled by the Trainer
+            elif isinstance(train_dataloader.dataset, IterableDataset):
+                train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
+
+    # Initialize Trainer
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
+        eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
+        tokenizer=feature_extractor,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics
+        if training_args.predict_with_generate
+        else None,
+        callbacks=[ShuffleCallback()],
+    )
+
+    # 12. Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the feature extractor too for easy upload
+
+        metrics = train_result.metrics
+        if data_args.max_train_samples:
+            metrics["train_samples"] = data_args.max_train_samples
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # 13. Evaluation
+    results = {}
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+        metrics = trainer.evaluate(
+            metric_key_prefix="eval",
+            max_length=training_args.generation_max_length,
+            num_beams=training_args.generation_num_beams,
+        )
+        if data_args.max_eval_samples:
+            metrics["eval_samples"] = data_args.max_eval_samples
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+    # 14. Write Training Stats
+    kwargs = {
+        "finetuned_from": model_args.model_name_or_path,
+        "tasks": "automatic-speech-recognition",
+        "tags": "whisper-event",
+    }
+    if data_args.dataset_name is not None:
+        kwargs["dataset_tags"] = data_args.dataset_name
+        if data_args.dataset_config_name is not None:
+            kwargs[
+                "dataset"
+            ] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
+        else:
+            kwargs["dataset"] = data_args.dataset_name
+        if "common_voice" in data_args.dataset_name:
+            kwargs["language"] = data_args.dataset_config_name[:2]
+        if model_args.model_index_name is not None:
+            kwargs["model_name"] = model_args.model_index_name
+
+    if training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(**kwargs)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()

.ipynb_checkpoints/run_speech_recognition_seq2seq_mixed_mgb2-cv1-checkpoint.py

@@ -0,0 +1,802 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for sequence to sequence speech recognition
+with 🤗 Datasets' streaming mode.
+"""
+# You can also adapt this script for your own sequence to sequence speech
+# recognition task. Pointers for this are left as comments.
+
+import logging
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+import datasets
+import torch
+from datasets import DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset
+from datasets import Audio, interleave_datasets, IterableDataset
+from torch.utils.data import IterableDataset
+
+import evaluate
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoFeatureExtractor,
+    AutoModelForSpeechSeq2Seq,
+    AutoProcessor,
+    AutoTokenizer,
+    HfArgumentParser,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+    TrainerCallback,
+    set_seed,
+)
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+from transformers.trainer_pt_utils import IterableDatasetShard
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.25.0.dev0")
+
+require_version(
+    "datasets>=1.18.2",
+    "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt",
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={
+            "help": "Path to pretrained model or model identifier from huggingface.co/models"
+        }
+    )
+    config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained config name or path if not the same as model_name"
+        },
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained tokenizer name or path if not the same as model_name"
+        },
+    )
+    feature_extractor_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "feature extractor name or path if not the same as model_name"
+        },
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Where to store the pretrained models downloaded from huggingface.co"
+        },
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."
+        },
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={
+            "help": "The specific model version to use (can be a branch name, tag name or commit id)."
+        },
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+                "with private models)."
+            )
+        },
+    )
+    freeze_feature_encoder: bool = field(
+        default=True,
+        metadata={"help": "Whether to freeze the feature encoder layers of the model."},
+    )
+    freeze_encoder: bool = field(
+        default=False,
+        metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."},
+    )
+    forced_decoder_ids: List[List[int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "A list of pairs of integers which indicates a mapping from generation indices to token indices "
+                "that will be forced before sampling. For example, [[0, 123]] means the first generated token "
+                "will always be a token of index 123."
+            )
+        },
+    )
+    suppress_tokens: List[int] = field(
+        default=None,
+        metadata={"help": "A list of tokens that will be suppressed at generation."},
+    )
+    model_index_name: str = field(
+        default=None, metadata={"help": "Pretty name for the model card."}
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: str = field(
+        default=None,
+        metadata={"help": "The name of the dataset to use (via the datasets library)."},
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The configuration name of the dataset to use (via the datasets library)."
+        },
+    )
+    text_column: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The name of the column in the datasets containing the full texts (for summarization)."
+        },
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of training examples to this "
+                "value if set."
+            )
+        },
+    )
+    max_eval_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of evaluation examples to this "
+                "value if set."
+            )
+        },
+    )
+    audio_column_name: str = field(
+        default="audio",
+        metadata={
+            "help": "The name of the dataset column containing the audio data. Defaults to 'audio'"
+        },
+    )
+    text_column_name: str = field(
+        default="text",
+        metadata={
+            "help": "The name of the dataset column containing the text data. Defaults to 'text'"
+        },
+    )
+    max_duration_in_seconds: float = field(
+        default=20.0,
+        metadata={
+            "help": (
+                "Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
+                " 'max_duration_in_seconds`"
+            )
+        },
+    )
+    min_duration_in_seconds: float = field(
+        default=0.0,
+        metadata={
+            "help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"
+        },
+    )
+    train_split_name: str = field(
+        default="train",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    eval_split_name: str = field(
+        default="test",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    do_lower_case: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be lower cased."},
+    )
+    do_remove_punctuation: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be striped of punctuation."},
+    )
+    do_normalize_eval: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to normalise the references and predictions in the eval WER calculation."
+        },
+    )
+    language: str = field(
+        default=None,
+        metadata={
+            "help": (
+                "Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
+                "only. For English speech recognition, it should be set to `None`."
+            )
+        },
+    )
+    task: str = field(
+        default="transcribe",
+        metadata={
+            "help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."
+        },
+    )
+    shuffle_buffer_size: Optional[int] = field(
+        default=500,
+        metadata={
+            "help": (
+                "The number of streamed examples to download before shuffling them. The large the buffer, "
+                "the closer it is to real offline shuffling."
+            )
+        },
+    )
+    streaming: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use streaming mode to load and pre-process the data."
+        },
+    )
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor ([`WhisperProcessor`])
+            The processor used for processing the data.
+        decoder_start_token_id (`int`)
+            The begin-of-sentence of the decoder.
+    """
+
+    processor: Any
+    decoder_start_token_id: int
+
+    def __call__(
+        self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
+    ) -> Dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need
+        # different padding methods
+        model_input_name = self.processor.model_input_names[0]
+        input_features = [
+            {model_input_name: feature[model_input_name]} for feature in features
+        ]
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+
+        batch = self.processor.feature_extractor.pad(
+            input_features, return_tensors="pt"
+        )
+
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(
+            labels_batch.attention_mask.ne(1), -100
+        )
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def load_maybe_streaming_dataset(
+    dataset_name, dataset_config_name, split="train", streaming=True, **kwargs
+):
+    """
+    Utility function to load a dataset in streaming mode. For datasets with multiple splits,
+    each split is loaded individually and then splits combined by taking alternating examples from
+    each (interleaving).
+    """
+    if "+" in split:
+        # load multiple splits separated by the `+` symbol with streaming mode
+        dataset_splits = [
+            load_dataset(
+                dataset_name,
+                dataset_config_name,
+                split=split_name,
+                streaming=streaming,
+                **kwargs,
+            )
+            for split_name in split.split("+")
+        ]
+        # interleave multiple splits to form one dataset
+        interleaved_dataset = interleave_datasets(dataset_splits)
+        return interleaved_dataset
+    else:
+        # load a single split *with* streaming mode
+        dataset = load_dataset(
+            dataset_name,
+            dataset_config_name,
+            split=split,
+            streaming=streaming,
+            **kwargs,
+        )
+        return dataset
+
+def load_multiple_streaming_datasets(
+    dataset_names: List,
+    dataset_config_names: List,
+    splits: Optional[List] = None,
+    text_column_names: Optional[List] = None,
+    sampling_rate: Optional[int] = 16000,
+    stopping_strategy: Optional[str] = "first_exhausted",
+    **kwargs
+) -> IterableDataset:
+
+    if len(dataset_names) != len(dataset_config_names):
+        raise ValueError(
+            f"Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and"
+            f" {len(dataset_config_names)} configs."
+        )
+
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(
+            f"Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits."
+        )
+
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(
+            f"Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and"
+            f" {len(text_column_names)} text column names."
+        )
+
+    splits = splits if splits is not None else ["train" for i in range(len(dataset_names))]
+    text_column_names = (
+        text_column_names if text_column_names is not None else ["text" for i in range(len(dataset_names))]
+    )
+
+    all_datasets = []
+    # iterate over the datasets we want to interleave
+    for i, dataset_name in enumerate(dataset_names):
+        dataset = load_dataset(dataset_name, dataset_config_names[i], split=splits[i], streaming=True, **kwargs)
+        print(dataset)
+        # resample to specified sampling rate
+        dataset = dataset.cast_column("audio", Audio(sampling_rate))
+        #  normalise columns to ["audio", "sentence"]
+        if text_column_names[i] != "sentence":
+            dataset = dataset.rename_column(text_column_names[i], "sentence")
+        dataset = dataset.remove_columns(set(dataset.features.keys()) - set(["audio", "sentence"]))
+        all_datasets.append(dataset)
+        print("DATASET:",dataset.features.keys())
+    interleaved_dataset = interleave_datasets(all_datasets, stopping_strategy=stopping_strategy)
+    return interleaved_dataset
+
+    
+def main():
+    # 1. Parse input arguments
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+    parser = HfArgumentParser(
+        (ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments)
+    )
+
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
+    # information sent is the one passed as arguments along with your Python/PyTorch versions.
+    send_example_telemetry(
+        "run_speech_recognition_seq2seq_streaming", model_args, data_args
+    )
+
+    # 2. Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    log_level = training_args.get_process_log_level()
+    logger.setLevel(log_level)
+    datasets.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.enable_default_handler()
+    transformers.utils.logging.enable_explicit_format()
+
+    logger.setLevel(
+        logging.INFO if is_main_process(training_args.local_rank) else logging.WARN
+    )
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # 3. Detecting last checkpoint and eventually continue from last checkpoint
+    last_checkpoint = None
+    if (
+        os.path.isdir(training_args.output_dir)
+        and training_args.do_train
+        and not training_args.overwrite_output_dir
+    ):
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif (
+            last_checkpoint is not None and training_args.resume_from_checkpoint is None
+        ):
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # 4. Load dataset
+    raw_datasets = IterableDatasetDict()
+
+    dataset_names = ["mozilla-foundation/common_voice_11_0", "arbml/mgb2_speech", ]
+    dataset_config_names = ["ar", "ar", ]
+    text_column_names = ["sentence", "text",]
+
+    if training_args.do_train:
+        raw_datasets["train"] = load_multiple_streaming_datasets(
+            dataset_names,
+            dataset_config_names=dataset_config_names,
+            text_column_names=text_column_names,
+            splits=["train","train"],
+            use_auth_token=True
+        )
+        
+    if training_args.do_eval:
+        raw_datasets["eval"] = load_multiple_streaming_datasets(
+            dataset_names,
+            dataset_config_names=dataset_config_names,
+            text_column_names=text_column_names,
+            splits=["validation","validation"],
+            use_auth_token=True
+        )
+
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+    
+    if data_args.audio_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--audio_column_name` to the correct audio column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    # if data_args.text_column_name not in raw_datasets_features:
+    #     print("raw_datasets_features:",raw_datasets_features)
+    #     raise ValueError(
+    #         f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
+    #         "Make sure to set `--text_column_name` to the correct text column - one of "
+    #         f"{', '.join(raw_datasets_features)}."
+    #     )
+
+    # 5. Load pretrained model, tokenizer, and feature extractor
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    config = AutoConfig.from_pretrained(
+        model_args.config_name
+        if model_args.config_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    config.update(
+        {
+            "forced_decoder_ids": model_args.forced_decoder_ids,
+            "suppress_tokens": model_args.suppress_tokens,
+        }
+    )
+
+    if training_args.gradient_checkpointing:
+        config.update({"use_cache": False})
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        model_args.feature_extractor_name
+        if model_args.feature_extractor_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_args.tokenizer_name
+        if model_args.tokenizer_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        use_fast=model_args.use_fast_tokenizer,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        model_args.model_name_or_path,
+        config=config,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    if model.config.decoder_start_token_id is None:
+        raise ValueError(
+            "Make sure that `config.decoder_start_token_id` is correctly defined"
+        )
+
+    max_label_length = model.config.max_length
+
+    if model_args.freeze_feature_encoder:
+        model.freeze_feature_encoder()
+
+    if model_args.freeze_encoder:
+        model.freeze_encoder()
+        model.model.encoder.gradient_checkpointing = False
+
+    if data_args.language is not None:
+        # We only need to set the task id when the language is specified (i.e. in a multilingual setting)
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
+
+    # 6. Resample speech dataset if necessary
+    dataset_sampling_rate = (
+        next(iter(raw_datasets.values()))
+        .features[data_args.audio_column_name]
+        .sampling_rate
+    )
+    if dataset_sampling_rate != feature_extractor.sampling_rate:
+        raw_datasets = raw_datasets.cast_column(
+            data_args.audio_column_name,
+            datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate),
+        )
+
+    # 7. Preprocessing the datasets.
+    # We need to read the audio files as arrays and tokenize the targets.
+    max_input_length = (
+        data_args.max_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    min_input_length = (
+        data_args.min_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    audio_column_name = data_args.audio_column_name
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    do_lower_case = data_args.do_lower_case
+    do_remove_punctuation = data_args.do_remove_punctuation
+    normalizer = BasicTextNormalizer()  # 'official' text normalizer from OpenAI
+
+    if data_args.max_train_samples is not None:
+        raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
+
+    if data_args.max_eval_samples is not None:
+        raw_datasets["eval"] = raw_datasets["eval"].select(
+            range(data_args.max_eval_samples)
+        )
+
+    def prepare_dataset(batch):
+        # process audio
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(
+            sample["array"], sampling_rate=sample["sampling_rate"]
+        )
+        # process audio length
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch["input_length"] = len(sample["array"])
+
+        # process targets
+        input_str = (
+            batch[text_column_name].lower()
+            if do_lower_case
+            else batch[text_column_name]
+        )
+        if do_remove_punctuation:
+            input_str = normalizer(input_str).strip()
+        batch["labels"] = tokenizer(input_str).input_ids
+        return batch
+
+    with training_args.main_process_first(desc="dataset map pre-processing"):
+        vectorized_datasets = raw_datasets.map(
+            prepare_dataset,
+            remove_columns=raw_datasets_features,
+        ).with_format("torch")
+
+        if training_args.do_train:
+            vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
+                buffer_size=data_args.shuffle_buffer_size,
+                seed=training_args.seed,
+            )
+
+    # filter training data that is shorter than min_input_length or longer than
+    # max_input_length
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+
+    vectorized_datasets["train"] = vectorized_datasets["train"].filter(
+        is_audio_in_length_range,
+        input_columns=["input_length"],
+    )
+
+    def filter_labels(labels):
+        """Filter label sequences longer than max length"""
+        return len(labels) < max_label_length
+
+    vectorized_datasets = vectorized_datasets.filter(
+        filter_labels, input_columns=["labels"]
+    )
+
+    # 8. Load Metric
+    metric = evaluate.load("wer")
+    do_normalize_eval = data_args.do_normalize_eval
+
+    def compute_metrics(pred):
+        pred_ids = pred.predictions
+
+        pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
+
+        pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
+        # we do not want to group tokens when computing the metrics
+        label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
+
+        if do_normalize_eval:
+            pred_str = [normalizer(pred) for pred in pred_str]
+            label_str = [normalizer(label) for label in label_str]
+            # filtering step to only evaluate the samples that correspond to non-zero references:
+            pred_str = [
+                pred_str[i] for i in range(len(pred_str)) if len(label_str[i]) > 0
+            ]
+            label_str = [
+                label_str[i] for i in range(len(label_str)) if len(label_str[i]) > 0
+            ]
+
+        wer = 100 * metric.compute(predictions=pred_str, references=label_str)
+
+        return {"wer": wer}
+
+    # 9. Create a single speech processor
+    if is_main_process(training_args.local_rank):
+        # save feature extractor, tokenizer and config
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+
+    processor = AutoProcessor.from_pretrained(training_args.output_dir)
+
+    # 10. Define data collator
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(
+        processor=processor,
+        decoder_start_token_id=model.config.decoder_start_token_id,
+    )
+
+    # 11. Configure Trainer
+    # Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
+    # Only required for streaming: Trainer automatically shuffles non-streaming datasets
+    class ShuffleCallback(TrainerCallback):
+        def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
+            if isinstance(train_dataloader.dataset, IterableDatasetShard):
+                pass  # set_epoch() is handled by the Trainer
+            elif isinstance(train_dataloader.dataset, IterableDataset):
+                train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
+
+    # Initialize Trainer
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
+        eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
+        tokenizer=feature_extractor,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics
+        if training_args.predict_with_generate
+        else None,
+        callbacks=[ShuffleCallback()],
+    )
+
+    # 12. Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the feature extractor too for easy upload
+
+        metrics = train_result.metrics
+        if data_args.max_train_samples:
+            metrics["train_samples"] = data_args.max_train_samples
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # 13. Evaluation
+    results = {}
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+        metrics = trainer.evaluate(
+            metric_key_prefix="eval",
+            max_length=training_args.generation_max_length,
+            num_beams=training_args.generation_num_beams,
+        )
+        if data_args.max_eval_samples:
+            metrics["eval_samples"] = data_args.max_eval_samples
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+    # 14. Write Training Stats
+    kwargs = {
+        "finetuned_from": model_args.model_name_or_path,
+        "tasks": "automatic-speech-recognition",
+        "tags": "whisper-event",
+    }
+    if data_args.dataset_name is not None:
+        kwargs["dataset_tags"] = data_args.dataset_name
+        if data_args.dataset_config_name is not None:
+            kwargs[
+                "dataset"
+            ] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
+        else:
+            kwargs["dataset"] = data_args.dataset_name
+        if "common_voice" in data_args.dataset_name:
+            kwargs["language"] = data_args.dataset_config_name[:2]
+        if model_args.model_index_name is not None:
+            kwargs["model_name"] = model_args.model_index_name
+
+    if training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(**kwargs)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()

README.md

@@ -0,0 +1,104 @@
+# whisper_sprint
+
+## training 
+
+```bash
+git clone https://github.com/ARBML/whisper_sprint
+cd whisper_sprint
+```
+
+Then setup the enviornment 
+
+```bash
+bash setup_env.sh
+```
+
+Then setup the libraries, this will install transofrmers, etc. and create a directory in the hub for training the model ... 
+
+```bash
+bash setup_libs.sh HF_USER_NAME MODEL_NAME
+```
+
+After that, you can run training by 
+
+```
+cd MODEL_NAME
+bash run_mgb2.sh
+```
+
+You can also run with deepspeed wich allows running whisper-large v2 with batch size 32 on A100
+
+```
+bash run_mgb2_deepspeed.sh
+```
+
+## Evaluation
+
+### Evaluation on Fleurs
+
+```
+bash run_eval_fleurs.sh MODEL_NAME
+```
+
+### Evaluation on Common Voice 11
+
+```
+bash run_eval_cv_11.sh MODEL_NAME
+```
+
+
+
+evaluate on common voice 11 
+
+```bash
+bash run_eval_cv_11.sh HF_USER_NAME/MODEL_NAME
+```
+
+evaluate on Fleurs
+
+```bash
+bash run_eval_fleurs.sh HF_USER_NAME/MODEL_NAME
+```
+
+## Preparing the MGB2 data
+
+While MGB2 dataset contains a richly transcribed speech dataset, the wav files were too lengthy to be used to train the whisper model. Therefore, we had to split the wave file and still maintain the correct correspondence with the transcribed text.
+
+MGB2 provides and XML file corresponding to every wav file, which contains the transcribed sentences and the start and end time of each sentence in the recording. Using the `split_xml_mgb2.py`, we start with the xml file and split the lengthy wav files into smaller ones that are shorter than 30 seconds in length, as required to fine-tune whisper. The operation produced over 370K sentences with their corresponding wav files.
+
+## Hosting on HuggingFace (Privately)
+
+To host mgb2 at HF, at least 3 things need to happen:
+
+1. Create the dataset repository on HF. This was created privately at arbml/mgb2_speech for the dataset
+2. Data must be hosted somewhere or uploaded to HF repo
+3. HF loading script must be written so the data can be integrated into the HF hub.
+
+
+### Uploading the data
+
+The dataset was >100Gb in size. HF utilizes git lfs to host large files. However, git lfs has a max limit of 5gb size for any file. Uploading over 370K individual files was also not feasible and caused issues with git. 
+Therefore, the solution was to archive groups of wav files together into sequentially numbered archive files, such that the archive file is no bigger than 5GB. To achieve that, the wav files were grouped based on the first 2 letters of the file name. The naming scheme seems to use a base64 encoding. So, characters would be 0 to 9 or A to F. The files were grouped as follows:
+
+| First 2 Letters  | Archive Number  |
+|:-:|---|
+| 00-05  |  0 |
+|  06-09 |  1 |
+|  0A-0F |  2 |
+| 10-15  |  3 |
+|  16-19 |  4 |
+|  1A-1F |  5 |
+| ...  |  ... |
+| F0-F5  |  45 |
+|  F6-F9 |  46 |
+|  FA-FF |  47 |
+
+Only the training data was split using this scheme, the test and validation data was smaller than 5GB when archived.
+
+### HF Data Loading Script
+
+The loading script determines the features of the data based on split and selected configuration. We had test, dev, and train split with a single language configuration. Using the _generate_example function, the script is used by GH to correctly produce the associated transcript and wav files. The function works as follows:
+
+1. Go through all the entries in the archive containing the text transcripts and create a map where the name of the file (the 64base encoded one) is used as the key and the transcript at the value
+2. Iterate through all the wav files in all the archive, and for every wav file, get the corresponding transcript from the map constructed in previous step (using the file name) and yield the wav file, transcript, and path to the wav file
+

added_tokens.json

@@ -0,0 +1,109 @@
+{
+  "<|af|>": 50327,
+  "<|am|>": 50334,
+  "<|ar|>": 50272,
+  "<|as|>": 50350,
+  "<|az|>": 50304,
+  "<|ba|>": 50355,
+  "<|be|>": 50330,
+  "<|bg|>": 50292,
+  "<|bn|>": 50302,
+  "<|bo|>": 50347,
+  "<|br|>": 50309,
+  "<|bs|>": 50315,
+  "<|ca|>": 50270,
+  "<|cs|>": 50283,
+  "<|cy|>": 50297,
+  "<|da|>": 50285,
+  "<|de|>": 50261,
+  "<|el|>": 50281,
+  "<|endoftext|>": 50257,
+  "<|en|>": 50259,
+  "<|es|>": 50262,
+  "<|et|>": 50307,
+  "<|eu|>": 50310,
+  "<|fa|>": 50300,
+  "<|fi|>": 50277,
+  "<|fo|>": 50338,
+  "<|fr|>": 50265,
+  "<|gl|>": 50319,
+  "<|gu|>": 50333,
+  "<|haw|>": 50352,
+  "<|ha|>": 50354,
+  "<|hi|>": 50276,
+  "<|hr|>": 50291,
+  "<|ht|>": 50339,
+  "<|hu|>": 50286,
+  "<|hy|>": 50312,
+  "<|id|>": 50275,
+  "<|is|>": 50311,
+  "<|it|>": 50274,
+  "<|iw|>": 50279,
+  "<|ja|>": 50266,
+  "<|jw|>": 50356,
+  "<|ka|>": 50329,
+  "<|kk|>": 50316,
+  "<|km|>": 50323,
+  "<|kn|>": 50306,
+  "<|ko|>": 50264,
+  "<|la|>": 50294,
+  "<|lb|>": 50345,
+  "<|ln|>": 50353,
+  "<|lo|>": 50336,
+  "<|lt|>": 50293,
+  "<|lv|>": 50301,
+  "<|mg|>": 50349,
+  "<|mi|>": 50295,
+  "<|mk|>": 50308,
+  "<|ml|>": 50296,
+  "<|mn|>": 50314,
+  "<|mr|>": 50320,
+  "<|ms|>": 50282,
+  "<|mt|>": 50343,
+  "<|my|>": 50346,
+  "<|ne|>": 50313,
+  "<|nl|>": 50271,
+  "<|nn|>": 50342,
+  "<|nocaptions|>": 50362,
+  "<|notimestamps|>": 50363,
+  "<|no|>": 50288,
+  "<|oc|>": 50328,
+  "<|pa|>": 50321,
+  "<|pl|>": 50269,
+  "<|ps|>": 50340,
+  "<|pt|>": 50267,
+  "<|ro|>": 50284,
+  "<|ru|>": 50263,
+  "<|sa|>": 50344,
+  "<|sd|>": 50332,
+  "<|si|>": 50322,
+  "<|sk|>": 50298,
+  "<|sl|>": 50305,
+  "<|sn|>": 50324,
+  "<|so|>": 50326,
+  "<|sq|>": 50317,
+  "<|sr|>": 50303,
+  "<|startoflm|>": 50360,
+  "<|startofprev|>": 50361,
+  "<|startoftranscript|>": 50258,
+  "<|su|>": 50357,
+  "<|sv|>": 50273,
+  "<|sw|>": 50318,
+  "<|ta|>": 50287,
+  "<|te|>": 50299,
+  "<|tg|>": 50331,
+  "<|th|>": 50289,
+  "<|tk|>": 50341,
+  "<|tl|>": 50348,
+  "<|transcribe|>": 50359,
+  "<|translate|>": 50358,
+  "<|tr|>": 50268,
+  "<|tt|>": 50351,
+  "<|uk|>": 50280,
+  "<|ur|>": 50290,
+  "<|uz|>": 50337,
+  "<|vi|>": 50278,
+  "<|yi|>": 50335,
+  "<|yo|>": 50325,
+  "<|zh|>": 50260
+}

all_results.json

@@ -0,0 +1,12 @@
+{
+    "epoch": 1.44,
+    "eval_loss": 0.9784936308860779,
+    "eval_runtime": 1959.8449,
+    "eval_samples_per_second": 2.885,
+    "eval_steps_per_second": 0.361,
+    "eval_wer": 20.95505699346784,
+    "train_loss": 0.2953554097175598,
+    "train_runtime": 94208.4118,
+    "train_samples_per_second": 6.793,
+    "train_steps_per_second": 0.106
+}

bigram_count.txt

@@ -0,0 +1,3875 @@
+(('5', 'غ'), 1)
+(('ً', 'ط'), 1)
+(('ي', 'آ'), 1)
+(('ّ', '!'), 1)
+((',', 'ه'), 1)
+(('I', 'ه'), 1)
+(('6', '\\'), 1)
+(('7', 'ي'), 1)
+(('ن', '7'), 1)
+(('P', ','), 1)
+(('m', 'G'), 1)
+(('G', 'i'), 1)
+(('M', 'V'), 1)
+(('7', 'ه'), 1)
+(('ف', '9'), 1)
+(('ي', 'F'), 1)
+(('5', 'M'), 1)
+(('خ', '\\'), 1)
+(('ر', '+'), 1)
+(('م', '5'), 1)
+(('ة', '4'), 1)
+(('k', ','), 1)
+(('خ', '!'), 1)
+(('ِ', 'إ'), 1)
+(('ـ', 'V'), 1)
+(('2', 'س'), 1)
+(('e', "'"), 1)
+(('ـ', 'i'), 1)
+(('ى', 'T'), 1)
+(('s', 'أ'), 1)
+(('r', 'ع'), 1)
+(('ـ', 't'), 1)
+(('ذ', '2'), 1)
+((',', '1'), 1)
+(('7', 'ض'), 1)
+(('ٍ', 'ر'), 1)
+(('ل', 'C'), 1)
+(('ي', 't'), 1)
+(('S', 'K'), 1)
+(('n', 'أ'), 1)
+(('ز', 'ـ'), 1)
+(('و', 'F'), 1)
+(('<S>', '٥'), 1)
+(('غ', '!'), 1)
+(('ي', '9'), 1)
+(('8', 'ح'), 1)
+(('ا', '4'), 1)
+(('ـ', 'X'), 1)
+(('e', 'j'), 1)
+(('ﻹ', 'ل'), 1)
+(('S', 'Q'), 1)
+(('Q', '<E>'), 1)
+(('5', '؛'), 1)
+(('أ', ','), 1)
+(('س', ','), 1)
+(('h', ','), 1)
+(('ى', '9'), 1)
+(('5', 'ا'), 1)
+(('O', '2'), 1)
+(('3', 'أ'), 1)
+(('ٍ', 'خ'), 1)
+(('9', 'ل'), 1)
+(('ل', 'F'), 1)
+(('ي', 'W'), 1)
+(('I', 'X'), 1)
+(('X', 'I'), 1)
+(('ك', '1'), 1)
+(('3', 'س'), 1)
+(('1', 'م'), 1)
+(('%', '9'), 1)
+(('%', '3'), 1)
+(('ى', 'B'), 1)
+(('"', '3'), 1)
+(('K', 'D'), 1)
+(('L', 'T'), 1)
+(('.', ','), 1)
+(('T', 'y'), 1)
+(('f', 'P'), 1)
+(('0', 'غ'), 1)
+(('J', 'b'), 1)
+(('%', 'ه'), 1)
+(('ل', 'r'), 1)
+(('P', 'J'), 1)
+(('ﻻ', 'ه'), 1)
+(('ل', 'T'), 1)
+(('3', 'و'), 1)
+(('0', 'آ'), 1)
+(('<S>', '﴿'), 1)
+(('﴿', 'و'), 1)
+(('َ', '﴾'), 1)
+(('﴾', '<E>'), 1)
+(('ـ', 'ض'), 1)
+(('7', 'م'), 1)
+(('%', 'و'), 1)
+(('0', 'ض'), 1)
+(('ر', 'ظ'), 1)
+(('٦', '١'), 1)
+(('ْ', 'ظ'), 1)
+(('ة', 'p'), 1)
+(('r', 'f'), 1)
+(('L', 'K'), 1)
+(('ج', 'ً'), 1)
+(('ا', 'ى'), 1)
+(('9', 'ا'), 1)
+(('ٍ', 'ف'), 1)
+(('ً', 'ؤ'), 1)
+(('#', 'T'), 1)
+(('‘', 'm'), 1)
+(('ـ', 'U'), 1)
+(('u', 'u'), 1)
+(('O', 'v'), 1)
+(('t', 'ع'), 1)
+(('S', 'U'), 1)
+(('L', 'B'), 1)
+(('t', 'و'), 1)
+(('K', 'O'), 1)
+(('S', 'H'), 1)
+(('K', 'C'), 1)
+(('y', 'N'), 1)
+(('d', 'م'), 1)
+(('D', 'W'), 1)
+(('ي', '5'), 1)
+(('ث', 'C'), 1)
+(('ٌ', 'ك'), 1)
+(('%', '-'), 1)
+(('S', 'R'), 1)
+(('م', 'b'), 1)
+(('a', "'"), 1)
+(('V', 'R'), 1)
+(('ى', 'َ'), 1)
+(('٦', '٪'), 1)
+(('<S>', '٧'), 1)
+(('I', 'I'), 1)
+(('ب', 'D'), 1)
+(('t', '@'), 1)
+(('@', 't'), 1)
+(('ت', 'P'), 1)
+(('C', 'D'), 1)
+(('ُ', 'ٌ'), 1)
+(('*', 'ش'), 1)
+(('ـ', 'd'), 1)
+(('g', 'ي'), 1)
+(('c', 'C'), 1)
+(('ـ', 'u'), 1)
+(('t', 'ه'), 1)
+(('B', 'G'), 1)
+(('ـ', 'o'), 1)
+(('r', 'و'), 1)
+(('و', 'n'), 1)
+(('؛', 'ً'), 1)
+(('c', ','), 1)
+(('د', 'آ'), 1)
+(('ِ', 'ِ'), 1)
+(('E', 'F'), 1)
+(('6', 'آ'), 1)
+(('C', 'V'), 1)
+(('ح', '7'), 1)
+(('G', 'B'), 1)
+(('إ', 'ّ'), 1)
+(('ن', '3'), 1)
+(('ق', 'ئ'), 1)
+(('1', 'ب'), 1)
+(('-', ':'), 1)
+(('،', '-'), 1)
+(('%', '4'), 1)
+(('ة', '|'), 1)
+(('ـ', '٢'), 1)
+(('٢', '٩'), 1)
+(('ج', 'ص'), 1)
+(('ة', 'ت'), 1)
+(('آ', 'ء'), 1)
+(('3', '+'), 1)
+(('ث', 'ش'), 1)
+(('w', 'b'), 1)
+(('D', 'O'), 1)
+(('W', 'N'), 1)
+(('ﻻ', 'ّ'), 1)
+(('،', "'"), 1)
+(('<S>', 'ﺠ'), 1)
+(('ﺠ', 'ﻌ'), 1)
+(('ﻌ', 'ﻔ'), 1)
+(('ﻔ', 'ﺎ'), 1)
+(('ﺎ', 'ﺕ'), 1)
+(('ﺕ', '<E>'), 1)
+(('<S>', 'ﺯ'), 1)
+(('ﺯ', 'ﺌ'), 1)
+(('ﺌ', 'ﻴ'), 1)
+(('ﻴ', 'ﻑ'), 1)
+(('ﻑ', '<E>'), 1)
+(('s', 'A'), 1)
+(('#', 'C'), 1)
+(('l', 'H'), 1)
+(('l', 'S'), 1)
+(('ا', 'f'), 1)
+(('9', '\\'), 1)
+(('s', 'و'), 1)
+(('ً', 'د'), 1)
+(('D', 'é'), 1)
+(('é', 'g'), 1)
+(('٧', '٢'), 1)
+(('"', 'l'), 1)
+(('8', 'و'), 1)
+(('2', '='), 1)
+(('=', '1'), 1)
+(('ج', '!'), 1)
+(('O', 'A'), 1)
+(('E', 'y'), 1)
+(('C', 'ا'), 1)
+(('C', 'ل'), 1)
+(('l', 'و'), 1)
+(('C', 'ت'), 1)
+(('A', 'خ'), 1)
+(('ـ', 'h'), 1)
+(('e', 'إ'), 1)
+(('"', 'S'), 1)
+(('و', 'ـ'), 1)
+(('O', 'i'), 1)
+(('<S>', '؟'), 1)
+(('م', 'u'), 1)
+(('ة', 'R'), 1)
+(('ش', 'ز'), 1)
+(('ﻹ', 'ف'), 1)
+(('ح', 'أ'), 1)
+(('ة', '5'), 1)
+(('1', 'ي'), 1)
+((',', 'س'), 1)
+(('T', '6'), 1)
+(('K', 'G'), 1)
+(('I', 'V'), 1)
+(('،', '('), 1)
+(('ا', 'i'), 1)
+(('ِ', 'ؤ'), 1)
+(('ه', 'c'), 1)
+(('ﻻ', 'س'), 1)
+(('ﻵ', 'ب'), 1)
+(('K', ','), 1)
+(('و', 'S'), 1)
+(('2', 'ي'), 1)
+(('ئ', '!'), 1)
+(('ئ', '\\'), 1)
+(('ا', 'n'), 1)
+(('ي', '8'), 1)
+(('I', 'd'), 1)
+(('E', 'Q'), 1)
+(('Q', 'A'), 1)
+(('a', 'q'), 1)
+(('q', 'i'), 1)
+(('A', 'b'), 1)
+(('*', '3'), 1)
+(('*', '1'), 1)
+(('s', '3'), 1)
+(('J', 'N'), 1)
+(('N', 'Z'), 1)
+(('Z', '<E>'), 1)
+(('ل', 'c'), 1)
+(('o', 'q'), 1)
+(('N', '1'), 1)
+(('1', 'T'), 1)
+(('ج', 'T'), 1)
+(('ى', '4'), 1)
+(('"', 'p'), 1)
+(('،', ':'), 1)
+(('0', 'ق'), 1)
+(('"', 'H'), 1)
+(('h', '\\'), 1)
+(('H', 'Y'), 1)
+(('R', 'L'), 1)
+(('h', 'K'), 1)
+(('K', 'u'), 1)
+(('m', 'n'), 1)
+(('ت', ';'), 1)
+(('ٍ', 'د'), 1)
+(('ٌ', 'س'), 1)
+(('ٌ', 'ف'), 1)
+(('ر', '|'), 1)
+(('ب', '٦'), 1)
+(('غ', '؛'), 1)
+(('ة', '6'), 1)
+(('ة', '3'), 1)
+(('ة', '7'), 1)
+(('ز', '!'), 1)
+(('4', 'ع'), 1)
+(('0', 'ص'), 1)
+(('ُ', '\\'), 1)
+(('ِ', 'C'), 1)
+(('s', 'ف'), 1)
+(('3', 'D'), 1)
+(('@', 'm'), 1)
+(('ن', 'N'), 1)
+(('ب', 'N'), 1)
+(('ى', 'I'), 1)
+(('ى', 'R'), 1)
+(('r', 'ا'), 1)
+(('B', 'ف'), 1)
+(('G', '2'), 1)
+(('m', 'ه'), 1)
+(('G', 'G'), 1)
+(('d', 'v'), 1)
+(('*', 'ك'), 1)
+(('I', 'G'), 1)
+(('H', 'T'), 1)
+(('#', 'J'), 1)
+(('s', 'F'), 1)
+(('r', 'I'), 1)
+(('U', 's'), 1)
+(('D', 'ة'), 1)
+(('<S>', 'é'), 1)
+(('é', 'l'), 1)
+(('m', 'é'), 1)
+(('é', 'd'), 1)
+(('n', 'é'), 1)
+(('é', 'e'), 1)
+(('B', 'E'), 1)
+(('E', 'K'), 1)
+(('I', 'K'), 1)
+(('S', 'P'), 1)
+(('ط', ','), 1)
+(('M', '7'), 1)
+(('ﻷ', 'ل'), 1)
+(('I', '6'), 1)
+(('e', 'ف'), 1)
+(('.', '('), 1)
+(('P', 's'), 1)
+(('2', 'ا'), 1)
+(('Q', 'U'), 1)
+(('U', 'I'), 1)
+(('M', 'M'), 1)
+(('M', 'U'), 1)
+(('ّ', 'ْ'), 1)
+(('ى', 's'), 1)
+(('d', 'b'), 1)
+(('ً', 'ه'), 1)
+((')', '؟'), 1)
+(('9', 'م'), 1)
+(('Z', 'N'), 1)
+(('٢', '٪'), 1)
+(('ب', '٩'), 1)
+(('٧', '٥'), 1)
+(('<S>', 'ـ'), 1)
+(('س', '1'), 1)
+(('ل', 'u'), 1)
+(('w', 'd'), 1)
+(('ة', 'M'), 1)
+(('a', 'ق'), 1)
+(('<S>', 'X'), 1)
+(('X', 'ا'), 1)
+(('n', 'z'), 1)
+(('4', 'ر'), 1)
+(('A', 'j'), 1)
+(('g', 'p'), 1)
+(('4', '؛'), 1)
+(('5', 'و'), 1)
+(('ﻹ', 'ث'), 1)
+(('8', '!'), 1)
+(('0', '؛'), 1)
+(('و', '|'), 1)
+(('|', 'ا'), 1)
+(('ع', 'l'), 1)
+(('0', 'ح'), 1)
+(('c', "'"), 1)
+(("'", 'e'), 1)
+(('L', "'"), 1)
+(('p', 'é'), 1)
+(('K', 'و'), 1)
+(('ب', 'K'), 1)
+(('ْ', '\\'), 1)
+((',', 'ت'), 1)
+((',', 'د'), 1)
+(('ش', 'ً'), 1)
+(('5', 'ر'), 1)
+(('6', '!'), 1)
+(('ث', '\\'), 1)
+(('ـ', 'G'), 1)
+(('ه', 'p'), 1)
+(('ه', 'B'), 1)
+(('O', 't'), 1)
+(('،', '/'), 1)
+(('M', 'D'), 1)
+(('D', 'G'), 1)
+(('G', 's'), 1)
+(('"', 'P'), 1)
+(('S', '\\'), 1)
+(('k', 'h'), 1)
+(('e', 'z'), 1)
+(('l', 'O'), 1)
+(('ذ', '3'), 1)
+(('ً', '9'), 1)
+(('آ', 'َ'), 1)
+(('O', 's'), 1)
+(('ى', 'ْ'), 1)
+(('ل', ';'), 1)
+(('ي', ';'), 1)
+(('y', 'g'), 1)
+(('R', 'C'), 1)
+(('ٍ', 'أ'), 1)
+(('4', 'ا'), 1)
+(('3', '؛'), 1)
+(('b', 'g'), 1)
+(('g', 'v'), 1)
+(('v', 'b'), 1)
+(('y', 'y'), 1)
+(('5', 'ه'), 1)
+(('ِ', '\\'), 1)
+(('س', '3'), 1)
+(('ف', '3'), 1)
+(('0', '*'), 1)
+((',', 'ا'), 1)
+(('ر', '5'), 1)
+(('ـ', 'ة'), 1)
+(('ـ', '\\'), 1)
+(('c', '\\'), 1)
+(('V', 'H'), 1)
+(('ّ', 'ؤ'), 1)
+(('E', 'ا'), 1)
+(('e', 'م'), 1)
+(('O', 'D'), 1)
+(('أ', '؛'), 1)
+(('J', 'W'), 1)
+(('y', 'a'), 1)
+(('E', 'v'), 1)
+(('ٌ', 'ة'), 1)
+(('ء', 'ب'), 1)
+(('ج', 'ط'), 1)
+((',', 'م'), 1)
+(('g', 'ا'), 1)
+(('ز', '2'), 1)
+(('ى', 'ٍ'), 1)
+(('G', 'F'), 1)
+(('ـ', 'E'), 1)
+(('ل', 'e'), 1)
+(('ٌ', 'أ'), 1)
+((',', 'ن'), 1)
+(('k', 'g'), 1)
+(('M', 'F'), 1)
+(('e', 'ض'), 1)
+(('ا', 'S'), 1)
+(('ى', 'ي'), 1)
+(('3', 'ج'), 1)
+(('ى', '5'), 1)
+(('R', 'B'), 1)
+(('B', 'D'), 1)
+(('4', 'ج'), 1)
+(('k', 'L'), 1)
+(('ر', '6'), 1)
+(('*', 'ط'), 1)
+(('W', 'F'), 1)
+(('S', 'L'), 1)
+(('ط', 'ـ'), 1)
+(('ﻻ', 'ف'), 1)
+(('j', '1'), 1)
+(('ُ', 'آ'), 1)
+(('%', 'إ'), 1)
+(('"', 't'), 1)
+(('o', 'h'), 1)
+(('f', 'y'), 1)
+(('ض', 'ق'), 1)
+(('z', 'y'), 1)
+(('ت', '4'), 1)
+(('ً', 'ب'), 1)
+(('ﻻ', 'و'), 1)
+(('ء', '9'), 1)
+(('ِ', '؛'), 1)
+(('O', 'C'), 1)
+(('ي', 'M'), 1)
+(('*', 'ص'), 1)
+(('م', '6'), 1)
+(('n', 'ي'), 1)
+(('d', 'ا'), 1)
+(('1', 'ع'), 1)
+(('ـ', 'O'), 1)
+(('C', 'W'), 1)
+(('د', '4'), 1)
+(('ٍ', 'إ'), 1)
+(('ٍ', 'ط'), 1)
+(('%', 'أ'), 1)
+(('0', '!'), 1)
+(('d', 'و'), 1)
+(('ا', 'C'), 1)
+(('C', '3'), 1)
+(('"', 'c'), 1)
+(('d', ','), 1)
+(('l', ','), 1)
+(('f', 's'), 1)
+(('s', 'ا'), 1)
+(('َ', 'ـ'), 1)
+(('ت', '1'), 1)
+(('و', 'U'), 1)
+(('و', 'z'), 1)
+(('ً', 'ث'), 1)
+(('ن', '8'), 1)
+(('K', 'ع'), 1)
+(('i', 'H'), 1)
+(('l', 'A'), 1)
+(('M', 'X'), 1)
+(('و', 'R'), 1)
+(('ئ', '؛'), 1)
+(('ـ', 's'), 1)
+(('ة', 'H'), 1)
+(('2', 'ص'), 1)
+(('ش', '؛'), 1)
+(('d', 'j'), 1)
+(('ن', 't'), 1)
+(('ك', ','), 1)
+(('O', 'T'), 1)
+(('B', 'L'), 1)
+(('َ', '؛'), 1)
+(('ﺇ', 'ر'), 1)
+(('ْ', 'ز'), 1)
+(('M', '4'), 1)
+(('M', '5'), 1)
+(('ٌ', '*'), 1)
+(('ا', 'D'), 1)
+(('ة', 'ن'), 1)
+(('k', 'n'), 1)
+(('ل', 'b'), 1)
+(('l', 'p'), 1)
+(('g', 'ب'), 1)
+(('s', ','), 1)
+(('ٍ', 'ض'), 1)
+(('6', '؛'), 1)
+(('*', 'خ'), 1)
+(('7', '\\'), 1)
+(('D', 'Y'), 1)
+(('ع', '2'), 1)
+(('ء', '2'), 1)
+(('r', 'م'), 1)
+(('P', '1'), 1)
+(('ع', 'R'), 1)
+(('ـ', 'ف'), 1)
+(('ت', 'F'), 1)
+(('N', '6'), 1)
+(('ل', 's'), 1)
+(('e', 'ب'), 1)
+(('ق', 'أ'), 1)
+(('M', 'T'), 1)
+(('"', 'e'), 1)
+(('T', 'ا'), 1)
+(('و', 'p'), 1)
+(('ل', 'G'), 1)
+(('ت', 'M'), 1)
+(('S', 'و'), 1)
+(('s', 'ك'), 1)
+(('8', 'إ'), 1)
+(('<S>', 'ئ'), 1)
+(('ٍ', '!'), 1)
+(('ٍ', 'ء'), 1)
+(('ـ', 'ؤ'), 1)
+(('5', 'أ'), 1)
+(('7', 'و'), 1)
+(('5', 'ش'), 1)
+(('C', 'أ'), 1)
+(('ض', 'g'), 1)
+(('*', '5'), 1)
+(('٣', '٢'), 1)
+(('<S>', '٩'), 1)
+(('ذ', '\\'), 1)
+(('٦', '٩'), 1)
+(('o', 'ف'), 1)
+(('ع', 'G'), 1)
+(('4', 'k'), 1)
+(('ة', 'ع'), 1)
+(('2', 'O'), 1)
+(('ظ', '\\'), 1)
+(('َ', 'ٱ'), 1)
+(('ٱ', 'ع'), 1)
+(('<S>', 'ٱ'), 1)
+(('ٱ', 'ل'), 1)
+(('<S>', ']'), 1)
+(('1', 'ق'), 1)
+(('T', '7'), 1)
+(('P', '7'), 1)
+(('ذ', '؛'), 1)
+(('*', 'و'), 1)
+(('*', 'ح'), 1)
+(('ب', 'S'), 1)
+(('و', 'X'), 1)
+(('ﻷ', 'ش'), 1)
+(('ﻷ', 'غ'), 1)
+(('ص', 'أ'), 1)
+(('8', 'ق'), 1)
+(('ى', 'ّ'), 1)
+(('r', '3'), 1)
+(('3', 'ف'), 1)
+(('3', 'a'), 1)
+(('A', 'U'), 1)
+(('U', 'B'), 1)
+(('ل', 'U'), 1)
+(('6', 'J'), 1)
+(('H', 'W'), 1)
+(('b', '\\'), 1)
+(('0', 'ش'), 1)
+(('C', '4'), 1)
+(('ر', 'L'), 1)
+(('٨', '٥'), 1)
+(('G', '7'), 1)
+(('E', 'q'), 1)
+(('1', 'ك'), 1)
+(('r', ','), 1)
+(('g', ','), 1)
+(('R', 'U'), 1)
+(('.', '%'), 1)
+(('r', 'w'), 1)
+(('ز', '1'), 1)
+(('c', 'A'), 1)
+(('A', 'V'), 1)
+(('V', 'G'), 1)
+(('ا', 'c'), 1)
+(('ن', 'T'), 1)
+(('ح', 'R'), 1)
+(('<S>', '،'), 1)
+(('W', '3'), 1)
+(('3', 'C'), 1)
+(('R', 'N'), 1)
+(('ر', 'w'), 1)
+(('ا', 'l'), 1)
+(('h', 'b'), 1)
+(('h', '@'), 1)
+(('ـ', 'N'), 1)
+(('َ', '!'), 1)
+(('ة', 'm'), 1)
+(('G', 'm'), 1)
+(('.', '\\'), 1)
+(('\\', '<E>'), 1)
+(('O', 'r'), 1)
+(('8', 'ع'), 1)
+(('٤', '٩'), 1)
+(('٥', '٣'), 1)
+(('٩', '٣'), 1)
+(('٢', '٤'), 1)
+(('٣', '٩'), 1)
+(('٤', '٧'), 1)
+(('ى', 'D'), 1)
+(('u', 'q'), 1)
+(('ت', 'K'), 1)
+(('2', 'ع'), 1)
+(('d', 'è'), 1)
+(('è', 'l'), 1)
+(('l', 'é'), 1)
+(('é', 'r'), 1)
+(('n', 'ç'), 1)
+(('ç', ';'), 1)
+((';', 'a'), 1)
+(('i', 'é'), 1)
+(('t', 'é'), 1)
+(('é', 's'), 1)
+(('1', 'ف'), 1)
+(('N', 'Y'), 1)
+(('b', 't'), 1)
+(('3', 'ك'), 1)
+(('6', 'م'), 1)
+(('ه', 'A'), 1)
+(('و', 'H'), 1)
+(('P', 'T'), 1)
+(('ـ', 'د'), 1)
+(('t', 'b'), 1)
+(('0', '+'), 1)
+(('ة', 'g'), 1)
+(('Z', 'D'), 1)
+(('D', 'F'), 1)
+(('2', 'ل'), 1)
+(('.', '!'), 1)
+((',', 'أ'), 1)
+(('ٍ', 'ً'), 1)
+(('ً', '3'), 1)
+(('ـ', 'H'), 1)
+(('ل', 'L'), 1)
+(('A', '2'), 1)
+(('ا', 'L'), 1)
+(('ى', 'L'), 1)
+(('R', '5'), 1)
+(('ٌ', 'و'), 1)
+(('ل', 'E'), 1)
+(('و', 't'), 1)
+(('r', '@'), 1)
+(('O', 'c'), 1)
+(('ٍ', 'ك'), 1)
+(('U', 'p'), 1)
+(('ذ', 'ـ'), 1)
+(('ك', 'w'), 1)
+(('7', 'ح'), 1)
+(('ئ', 'ى'), 1)
+(('ْ', 'ص'), 1)
+(('9', '؛'), 1)
+(('ﻹ', 'م'), 1)
+(('F', 'R'), 1)
+(('أ', 'ـ'), 1)
+(('"', 'o'), 1)
+(('"', '\\'), 1)
+(('ا', ';'), 1)
+(('I', 'Z'), 1)
+(('ر', 'N'), 1)
+(('W', 'I'), 1)
+(('I', 'F'), 1)
+(('%', 'ا'), 1)
+(('7', 'ا'), 1)
+(('ه', '÷'), 1)
+(('÷', '<E>'), 1)
+(('f', '1'), 1)
+(('1', 'ت'), 1)
+(('C', 'M'), 1)
+(('U', 'D'), 1)
+(('I', 'ف'), 1)
+(('ل', 'P'), 1)
+(('ظ', 'ً'), 1)
+(('ء', 'ّ'), 1)
+(('n', 'ا'), 1)
+(('ة', 'W'), 1)
+(('خ', '2'), 1)
+(('l', 'ك'), 1)
+(('ـ', 'خ'), 1)
+(('ً', 'ك'), 1)
+(('7', 'أ'), 1)
+(('0', 'ك'), 1)
+(('ع', 'ع'), 1)
+(('K', 'j'), 1)
+(('j', 'k'), 1)
+(('4', 'ف'), 1)
+(('0', '_'), 1)
+(('_', '1'), 1)
+(('e', 'ي'), 1)
+(('٢', '٦'), 1)
+(('٢', '٧'), 1)
+(('M', 's'), 1)
+(('و', 'e'), 1)
+(('Z', 'e'), 1)
+(('ة', 'S'), 1)
+(('ع', 'B'), 1)
+(('P', 'L'), 1)
+(('ة', 'D'), 1)
+(('W', 'D'), 1)
+(('D', 'B'), 1)
+(('ر', 'ـ'), 1)
+(('ة', 'ـ'), 1)
+(('m', 'h'), 1)
+(('h', '3'), 1)
+(('B', 'U'), 1)
+(('b', 'j'), 1)
+(('و', '٦'), 1)
+(('ل', '١'), 1)
+(('٧', '٠'), 2)
+(('ً', 'ة'), 2)
+(('ﻻ', 'د'), 2)
+(('<S>', ','), 2)
+(('ٌ', 'خ'), 2)
+(('و', '٢'), 2)
+(('ط', 'ز'), 2)
+(('2', 'أ'), 2)
+(('6', 'ك'), 2)
+(('2', 'م'), 2)
+(('4', 'س'), 2)
+(('E', 'd'), 2)
+(('A', 'P'), 2)
+(('P', 'E'), 2)
+(('ت', '2'), 2)
+(('ن', '2'), 2)
+(('M', 'y'), 2)
+(('K', 'ي'), 2)
+(('3', 'ع'), 2)
+(('4', ','), 2)
+(('A', 'F'), 2)
+(('L', 'L'), 2)
+(('S', 'O'), 2)
+(('K', 'E'), 2)
+(('T', 'B'), 2)
+(('و', 'ﻹ'), 2)
+(('ﻹ', 'ق'), 2)
+(('ﻷ', 'ه'), 2)
+((',', 'ب'), 2)
+(('ً', 'ج'), 2)
+(('ﻷ', 'ع'), 2)
+(('G', 'H'), 2)
+(('C', 'y'), 2)
+(('ٍ', 'ه'), 2)
+(('"', 'آ'), 2)
+(('ٌ', 'ا'), 2)
+(('د', 'M'), 2)
+(('N', 'u'), 2)
+((',', '8'), 2)
+(('%', '2'), 2)
+(('%', '1'), 2)
+(('"', '4'), 2)
+(('U', 'P'), 2)
+(('٣', '٥'), 2)
+(('ر', '1'), 2)
+(('2', '\\'), 2)
+(('D', 'D'), 2)
+(('R', 'D'), 2)
+(('ٌ', 'ح'), 2)
+(('0', 'ه'), 2)
+(('s', 'q'), 2)
+(('ٍ', 'و'), 2)
+(('ص', 'ً'), 2)
+(('1', 'B'), 2)
+(('F', '5'), 2)
+(('2', 'ب'), 2)
+(('M', 'L'), 2)
+(('V', 'D'), 2)
+(('ح', 'ً'), 2)
+(('إ', 'ٍ'), 2)
+(('ذ', '!'), 2)
+(('ٍ', 'ة'), 2)
+(('1', '='), 2)
+(('=', '2'), 2)
+(('0', 'ف'), 2)
+(('D', 'N'), 2)
+(('H', 'O'), 2)
+(('H', 'I'), 2)
+(('J', '+'), 2)
+(('و', 'D'), 2)
+(('د', '2'), 2)
+(('l', 'c'), 2)
+(('p', 'd'), 2)
+(('٩', '٨'), 2)
+(('٧', '١'), 2)
+(('D', 'P'), 2)
+(('I', 'H'), 2)
+(('B', 'F'), 2)
+(('ص', '!'), 2)
+(('و', 's'), 2)
+(('0', 'إ'), 2)
+(('7', ','), 2)
+(('ش', '!'), 2)
+(('M', 'c'), 2)
+(('E', '1'), 2)
+(('<S>', ':'), 2)
+(('(', '<E>'), 2)
+(('2', 'ه'), 2)
+(('6', 'ل'), 2)
+(('F', 'L'), 2)
+(('4', 'و'), 2)
+(('0', 'ب'), 2)
+(('|', '<E>'), 2)
+(('s', 'é'), 2)
+(('é', '<E>'), 2)
+(('ً', 'ت'), 2)
+((',', '2'), 2)
+(('V', 'k'), 2)
+(('k', 't'), 2)
+(('"', 'ز'), 2)
+(('U', 'U'), 2)
+(('ر', '4'), 2)
+(('e', '\\'), 2)
+(('٠', '٩'), 2)
+(('٤', '١'), 2)
+(('y', '\\'), 2)
+(('ٌ', 'ب'), 2)
+(('k', 'j'), 2)
+(('و', 'l'), 2)
+(('V', 'O'), 2)
+(('k', 'f'), 2)
+(('L', 'u'), 2)
+(('y', 'd'), 2)
+(('<S>', '{'), 2)
+(('{', '.'), 2)
+(('F', '3'), 2)
+(('T', 'S'), 2)
+(('و', 'N'), 2)
+(('x', 'x'), 2)
+(('x', 'o'), 2)
+(('n', 'M'), 2)
+(('v', 'r'), 2)
+(('ل', 'A'), 2)
+(('َ', 'ؤ'), 2)
+(('ً', 'ى'), 2)
+(('T', '5'), 2)
+(('ث', '!'), 2)
+(('C', 'K'), 2)
+(('ه', 'ص'), 2)
+(('ﻻ', 'ً'), 2)
+(('ﻹ', 'غ'), 2)
+(('Y', 'P'), 2)
+(('ا', 'ِ'), 2)
+(('E', 't'), 2)
+(('*', '2'), 2)
+(('5', 'س'), 2)
+(('l', 'g'), 2)
+(('j', 'z'), 2)
+(('b', 'c'), 2)
+(('V', '2'), 2)
+(('a', 'a'), 2)
+(('م', ';'), 2)
+(('ن', ';'), 2)
+(('٥', '٦'), 2)
+(('V', 'a'), 2)
+(('ة', '2'), 2)
+(('H', 'B'), 2)
+(('س', 'ز'), 2)
+(('٨', '٧'), 2)
+(('H', 'D'), 2)
+(('e', 'و'), 2)
+(('ي', '*'), 2)
+(('ـ', 'R'), 2)
+(('ٍ', 'ل'), 2)
+(('O', 'X'), 2)
+(('ل', 'M'), 2)
+(('7', 'ع'), 2)
+(('A', 'd'), 2)
+(('G', '4'), 2)
+(('4', 'S'), 2)
+(('ة', 'G'), 2)
+(('y', 'P'), 2)
+(('أ', '\\'), 2)
+(('i', 'q'), 2)
+(('e', 'X'), 2)
+(('M', 'G'), 2)
+(('ذ', 'ش'), 2)
+(('ْ', 'غ'), 2)
+(('<S>', ')'), 2)
+(('L', 'C'), 2)
+(('J', 'U'), 2)
+(('V', 'E'), 2)
+(('N', 'M'), 2)
+(('H', 'A'), 2)
+(('ك', 'I'), 2)
+(('N', 'P'), 2)
+(('6', 'ع'), 2)
+(('S', '3'), 2)
+(('ْ', 'ط'), 2)
+(('خ', 'ً'), 2)
+(('O', 'E'), 2)
+(('P', '5'), 2)
+(('6', 'إ'), 2)
+(('a', '@'), 2)
+(('l', 'ل'), 2)
+(('U', 'C'), 2)
+(('ﻷ', 'ز'), 2)
+(('ُ', '؛'), 2)
+(('y', ','), 2)
+(('ِ', '!'), 2)
+(("'", 'a'), 2)
+(('é', 't'), 2)
+(('ئ', 'ً'), 2)
+(('ٍ', '*'), 2)
+(('و', 'P'), 2)
+(('F', 'N'), 2)
+(('ة', 'N'), 2)
+(('ض', 'آ'), 2)
+(('l', 'v'), 2)
+(('y', 'k'), 2)
+(('ط', 'ْ'), 2)
+(('x', 'c'), 2)
+(('I', 'm'), 2)
+(('إ', 'و'), 2)
+(('v', 'y'), 2)
+(('س', '2'), 2)
+(('ـ', 'D'), 2)
+(('٥', '٧'), 2)
+(('1', 'ه'), 2)
+(('ـ', 'ح'), 2)
+(('ﻹ', 'ج'), 2)
+(('ن', '5'), 2)
+(('O', 'u'), 2)
+(('F', 'M'), 2)
+(('ي', 'B'), 2)
+(('B', '5'), 2)
+(('F', '4'), 2)
+(('٠', '٤'), 2)
+(('ؤ', 'ِ'), 2)
+(('W', 'E'), 2)
+(('م', '3'), 2)
+(('<S>', 'k'), 2)
+(('ٍ', 'م'), 2)
+(('ـ', 'ك'), 2)
+(('و', 'o'), 2)
+(('ة', 'C'), 2)
+(('ى', 'ٌ'), 2)
+(('R', 'M'), 2)
+(('ّ', '\\'), 2)
+(('و', ','), 2)
+(('B', 'y'), 2)
+(('ه', 'خ'), 2)
+(('a', 'ا'), 2)
+(('E', 'U'), 2)
+(('s', '\\'), 2)
+(('*', '6'), 2)
+(('ـ', 'a'), 2)
+(('،', '؟'), 2)
+(('ﻷ', 'ث'), 2)
+(('J', 'S'), 2)
+(('"', 'ذ'), 2)
+(('Q', 'u'), 2)
+(('e', 'B'), 2)
+(('l', 'b'), 2)
+(('ا', '1'), 2)
+(('S', 'C'), 2)
+(('و', 'B'), 2)
+(('و', 'M'), 2)
+(('ً', ';'), 2)
+(('٤', '٨'), 2)
+(('٥', '٨'), 2)
+(('٩', '١'), 2)
+(('5', 'ي'), 2)
+(('Y', 'a'), 2)
+(('ٍ', 'غ'), 2)
+(('ٍ', 'ح'), 2)
+(('ٌ', 'ج'), 2)
+(('ً', 'ع'), 2)
+(('ٍ', 'ب'), 2)
+(('ت', '‘'), 2)
+(('‘', 'ب'), 2)
+(('٤', '٥'), 2)
+(('M', 'r'), 3)
+(('ﻻ', 'ﻻ'), 3)
+(('ي', '1'), 3)
+(('A', 'Y'), 3)
+(('ة', 'T'), 3)
+(('+', '<E>'), 3)
+(('1', 'س'), 3)
+(('0', 'س'), 3)
+(('V', 'X'), 3)
+(('r', 'b'), 3)
+(('g', 'g'), 3)
+(('m', 'q'), 3)
+(('ﺇ', 'س'), 3)
+(('ﺇ', 'ذ'), 3)
+(('u', 'y'), 3)
+(('E', 'B'), 3)
+(('E', 'A'), 3)
+(('ؤ', 'ٍ'), 3)
+(('5', 'م'), 3)
+(('ن', ','), 3)
+(('ً', 'أ'), 3)
+(('ش', 'ـ'), 3)
+(('ـ', 'ئ'), 3)
+(('ٌ', 'غ'), 3)
+(('ؤ', 'ُ'), 3)
+((',', '7'), 3)
+(('"', '7'), 3)
+(('0', '\\'), 3)
+(('ـ', 'ق'), 3)
+(('I', 'R'), 3)
+(('<S>', '|'), 3)
+(('|', 'أ'), 3)
+(('َ', '*'), 3)
+(('ْ', 'خ'), 3)
+(('G', 'I'), 3)
+(('ُ', 'ة'), 3)
+(('ـ', 'و'), 3)
+((',', '3'), 3)
+(('1', '\\'), 3)
+(('F', 'A'), 3)
+(('J', '<E>'), 3)
+(('ﻻ', 'ج'), 3)
+(('ٌ', 'ل'), 3)
+(('ه', 'ـ'), 3)
+(('A', 'u'), 3)
+(('t', '’'), 3)
+(('’', 's'), 3)
+(('٤', '٦'), 3)
+(('U', 'M'), 3)
+(('ه', 'ْ'), 3)
+(('م', '7'), 3)
+((']', '.'), 3)
+(('*', 'ه'), 3)
+(('*', 'س'), 3)
+(('o', 'K'), 3)
+(('u', 'T'), 3)
+(('D', 'V'), 3)
+(('ً', 'ف'), 3)
+(('1', '+'), 3)
+(('و', 'ﻷ'), 3)
+(('ﻹ', 'ب'), 3)
+(('N', 'K'), 3)
+(('D', 'E'), 3)
+(('T', 'C'), 3)
+(('ـ', 'A'), 3)
+(('١', '٪'), 3)
+(('t', 'n'), 3)
+(('F', 'C'), 3)
+(('خ', '؛'), 3)
+(('"', 'ث'), 3)
+(('n', '’'), 3)
+(('’', 't'), 3)
+(('*', 'ن'), 3)
+(('ً', 'خ'), 3)
+(('٣', '١'), 3)
+(('ـ', 'ج'), 3)
+(('ء', '!'), 3)
+(('L', 'A'), 3)
+(('ى', '3'), 3)
+(('A', 'O'), 3)
+(('ﻹ', 'ر'), 3)
+(('<S>', '٨'), 3)
+(('آ', '<E>'), 3)
+(('A', 'e'), 3)
+(('U', 'V'), 3)
+(('O', 'W'), 3)
+(('H', '2'), 3)
+(('٠', '٢'), 3)
+(('٩', '<E>'), 3)
+(('6', ','), 3)
+(('5', ','), 3)
+(('ط', 'آ'), 3)
+(('د', 'ـ'), 3)
+(('G', '8'), 3)
+(('أ', 'ا'), 3)
+(('z', '<E>'), 3)
+(('S', 'l'), 3)
+(('ة', '1'), 3)
+(('M', 'W'), 3)
+(('O', 'U'), 3)
+(('p', 'm'), 3)
+(('ﻷ', 'ُ'), 3)
+(('ﻹ', 'ت'), 3)
+(('G', 'C'), 3)
+(('7', '+'), 3)
+(('ب', '9'), 3)
+(('L', '1'), 3)
+(('B', 'J'), 3)
+(('l', 'm'), 3)
+(('@', '<E>'), 3)
+(('B', 'é'), 3)
+(('é', 'z'), 3)
+(('g', '\\'), 3)
+(('ٌ', 'د'), 3)
+((',', '6'), 3)
+(('ـ', 'إ'), 3)
+(('P', 'M'), 3)
+(('ل', 'N'), 3)
+(('ى', '2'), 3)
+(('O', 'L'), 3)
+(('F', 'O'), 3)
+(('l', 'k'), 3)
+(('م', '1'), 3)
+(('ّ', '؛'), 3)
+(('8', 'س'), 3)
+(('أ', 'ٍ'), 3)
+(('G', 'A'), 3)
+(('S', 'w'), 3)
+(('ﻷ', 'د'), 3)
+(('ه', ','), 3)
+(('٩', '٠'), 3)
+(('L', 'O'), 3)
+(('N', 'U'), 3)
+(('<S>', 'Q'), 3)
+(('ﻹ', 'د'), 3)
+(('U', 'X'), 3)
+(('X', 'N'), 3)
+(('O', 'O'), 3)
+(('O', 'G'), 3)
+(('G', 'L'), 3)
+(('o', 'P'), 3)
+(('ـ', 'ث'), 3)
+(('*', 'ر'), 3)
+(('*', 'ع'), 3)
+(('}', '{'), 3)
+(('و', 'W'), 3)
+(('1', 'و'), 3)
+(('ْ', 'ئ'), 3)
+(('A', 'v'), 3)
+(('ت', 'ـ'), 3)
+(('ْ', 'إ'), 3)
+(('e', 'q'), 3)
+(('a', 'w'), 3)
+(('K', 'a'), 3)
+(('K', 'i'), 3)
+(('2', 'و'), 3)
+(('O', 'l'), 3)
+(('ئ', 'ظ'), 3)
+(('ْ', 'ء'), 3)
+(('<S>', '}'), 3)
+(('A', '&'), 3)
+(('&', 'F'), 3)
+(('ـ', 'M'), 3)
+(('"', 's'), 3)
+(('ً', 'و'), 3)
+(('٦', '٦'), 3)
+(('٦', '٧'), 3)
+(('ن', '6'), 3)
+(('*', 'د'), 3)
+(('ﻻ', 'ء'), 3)
+(('n', '\\'), 3)
+(('ب', ','), 3)
+(('ى', ','), 3)
+(('L', 'S'), 3)
+(('8', 'م'), 3)
+(('U', 'T'), 3)
+(('<S>', 'ﻵ'), 3)
+(('T', 'P'), 3)
+(('<S>', 'ؤ'), 3)
+(('0', 'ا'), 4)
+(('ً', 'س'), 4)
+(('و', 'A'), 4)
+(('y', 'i'), 4)
+(('س', 'ش'), 4)
+(('N', 'i'), 4)
+(('Y', '<E>'), 4)
+(('t', 'p'), 4)
+(('ـ', 'س'), 4)
+(('ز', 'آ'), 4)
+(('ْ', 'ا'), 4)
+(('ْ', 'ث'), 4)
+(('S', 'n'), 4)
+(('a', 'o'), 4)
+(('ـ', 'c'), 4)
+(('آ', 'ح'), 4)
+(('ض', '!'), 4)
+(('q', '@'), 4)
+(('ص', 'ش'), 4)
+(('I', 'r'), 4)
+(('٨', '٦'), 4)
+(('ٌ', 'ن'), 4)
+(('غ', 'ْ'), 4)
+(('ﻹ', 'خ'), 4)
+(('H', 'S'), 4)
+(('ز', 'ط'), 4)
+(('ُ', '!'), 4)
+(('P', 'k'), 4)
+(('k', 'k'), 4)
+(('n', 'h'), 4)
+(('P', 'R'), 4)
+(('<S>', '٣'), 4)
+(('G', 'R'), 4)
+(('ى', '!'), 4)
+(('A', 'J'), 4)
+(('l', 'h'), 4)
+(('I', 't'), 4)
+(('ﻻ', 'ي'), 4)
+(('E', 's'), 4)
+(('L', 'N'), 4)
+(('M', 'C'), 4)
+(('<S>', 'ٌ'), 4)
+(('م', ','), 4)
+(('O', 'I'), 4)
+(('و', '!'), 4)
+(('َ', 'ئ'), 4)
+(('،', '.'), 4)
+(('d', 'n'), 4)
+(('3', ','), 4)
+(('O', 'M'), 4)
+(('E', 'W'), 4)
+(('W', 'S'), 4)
+(('C', 'T'), 4)
+(('ـ', 'I'), 4)
+(('G', 'M'), 4)
+(('n', 'q'), 4)
+(('C', 'P'), 4)
+(('ٌ', 'ت'), 4)
+(('0', 'ي'), 4)
+(('و', 'C'), 4)
+(('M', 'B'), 4)
+(('ؤ', 'َ'), 4)
+(('-', '-'), 4)
+(('٨', '٠'), 4)
+(('و', '؛'), 4)
+(('ز', 'ْ'), 4)
+(('ط', 'ً'), 4)
+(('<S>', '٦'), 4)
+(('V', 'o'), 4)
+(('I', 'M'), 4)
+(('A', 'K'), 4)
+(('C', 'u'), 4)
+(('غ', '\\'), 4)
+(('H', 'C'), 4)
+(('w', 'r'), 4)
+(('ج', '؛'), 4)
+(('+', '7'), 4)
+(('S', 'B'), 4)
+(('s', 'n'), 4)
+(('م', 'ـ'), 4)
+(('ة', ';'), 4)
+(('ل', '9'), 4)
+(('ـ', 'ع'), 4)
+(('٠', '٧'), 4)
+(('ـ', 'W'), 4)
+(('*', 'ق'), 4)
+(('ت', ','), 4)
+(('ٍ', 'س'), 4)
+(('A', 'G'), 4)
+(('E', 'L'), 4)
+(('A', 'A'), 4)
+(('ز', '؛'), 4)
+(('E', 'I'), 4)
+(('t', "'"), 4)
+(('ْ', 'ح'), 4)
+(('د', 'ﻻ'), 4)
+(('ْ', 'ة'), 4)
+(('S', 'M'), 4)
+(('C', 'U'), 4)
+(('ك', 'ً'), 4)
+(('E', 'O'), 4)
+(('ح', '!'), 4)
+(('z', 'l'), 4)
+(('،', '{'), 4)
+(('ض', 'ْ'), 4)
+(('P', 'H'), 4)
+(('ز', 'ؤ'), 5)
+(('L', 'U'), 5)
+(('٠', '٦'), 5)
+(('o', 'j'), 5)
+(('E', 'l'), 5)
+(('j', 'u'), 5)
+(('ب', '4'), 5)
+(('،', '،'), 5)
+(('ـ', 'S'), 5)
+(('ذ', 'ذ'), 5)
+(('ث', 'ْ'), 5)
+(('ن', 'ـ'), 5)
+(('P', 'i'), 5)
+(('R', 'u'), 5)
+(('ة', 'ّ'), 5)
+(('i', 'x'), 5)
+(('x', 'e'), 5)
+(('ي', ','), 5)
+(('ط', '!'), 5)
+(('E', 'g'), 5)
+(('*', 'ف'), 5)
+(('ً', 'ر'), 5)
+(('<S>', '%'), 5)
+(('N', 'O'), 5)
+(('R', 'I'), 5)
+(('"', 'ص'), 5)
+(('L', 'R'), 5)
+(('ق', 'ً'), 5)
+(('ً', 'ح'), 5)
+(('ٌ', 'ّ'), 5)
+(('٨', '٢'), 5)
+(('٩', '٢'), 5)
+(('٩', '٤'), 5)
+(('ج', 'ْ'), 5)
+(('َ', 'آ'), 5)
+(('K', 'B'), 5)
+(('e', 'ا'), 5)
+(('ـ', 'ي'), 5)
+(('O', 'B'), 5)
+(('B', 'O'), 5)
+(('ـ', 'P'), 5)
+(('W', '<E>'), 5)
+(('F', 'e'), 5)
+(('ب', '8'), 5)
+(('N', 'C'), 5)
+(('٣', '٠'), 5)
+(('ل', '8'), 5)
+(('ـ', 'p'), 5)
+(('ف', 'ً'), 5)
+(('٢', '٣'), 5)
+(('9', ','), 5)
+(('H', '1'), 5)
+(('ل', ','), 5)
+(('ؤ', 'ّ'), 5)
+(('L', 'a'), 5)
+(('ص', '؛'), 5)
+(('F', 'l'), 5)
+(('C', 'r'), 5)
+(('K', 'e'), 5)
+(('ٌ', 'م'), 5)
+(('ﻹ', 'ن'), 5)
+(('ط', '؛'), 5)
+(('ﻵ', 'خ'), 5)
+(('D', 'y'), 5)
+(('C', 'E'), 5)
+(('g', 'n'), 5)
+(('S', 'k'), 5)
+(('k', 'y'), 5)
+(('ص', 'ْ'), 5)
+(('ً', 'ش'), 5)
+(('T', 'A'), 5)
+(('ﻹ', 'ط'), 5)
+(('ي', '2'), 5)
+(('*', 'ي'), 5)
+(('3', 'م'), 5)
+(('.', '}'), 5)
+(('}', '<E>'), 5)
+(('٩', '٦'), 6)
+(('ً', 'م'), 6)
+(('ً', 'ص'), 6)
+(('U', '<E>'), 6)
+(('ـ', 'F'), 6)
+(('j', 'e'), 6)
+(('A', 'i'), 6)
+(('ن', '4'), 6)
+(('ه', 'ً'), 6)
+(('S', 'm'), 6)
+(('؟', '<E>'), 6)
+(("'", 's'), 6)
+(('س', 'ً'), 6)
+(('e', 'k'), 6)
+(('ﻷ', 'ح'), 6)
+(('B', 'e'), 6)
+(('ﻷ', 'ص'), 6)
+(('A', 'S'), 6)
+(('ن', '1'), 6)
+(('g', 's'), 6)
+(('p', 'y'), 6)
+(('y', 'b'), 6)
+(('ٍ', 'ن'), 6)
+(('ب', '6'), 6)
+(('ز', 'س'), 6)
+(('a', 'x'), 6)
+(('<S>', 'z'), 6)
+(('z', 'o'), 6)
+(('4', '\\'), 6)
+(('D', 'L'), 6)
+(('ْ', 'ش'), 6)
+(('E', 'G'), 6)
+(('%', 'م'), 6)
+(('١', '٧'), 6)
+(('2', ','), 6)
+(('I', 'B'), 6)
+(('%', '.'), 6)
+(('5', 'ع'), 6)
+(('٠', '٨'), 6)
+(('%', '،'), 6)
+(('ؤ', 'ْ'), 6)
+(('ح', '\\'), 6)
+((',', '9'), 6)
+(('A', 'E'), 6)
+(('R', 'T'), 6)
+(('N', 'D'), 6)
+(('A', 'g'), 6)
+(('س', 'ـ'), 6)
+(('G', 'l'), 6)
+(('ـ', 'T'), 6)
+(('٢', '٥'), 6)
+(('ق', '!'), 6)
+(('ـ', 'ب'), 6)
+(('m', 'y'), 6)
+(('٦', '٥'), 6)
+(('ء', 'ى'), 6)
+(('k', 'o'), 6)
+(('x', 'a'), 6)
+(('i', 'k'), 6)
+(('y', 'c'), 6)
+(('u', 'z'), 6)
+(('z', 'z'), 6)
+(('ر', ','), 6)
+(('M', '1'), 6)
+(('B', 'M'), 6)
+(('ﻹ', 'ي'), 6)
+(('٠', '٥'), 6)
+(('R', 'o'), 6)
+(('ث', '؛'), 6)
+(('ث', 'س'), 6)
+(('د', ','), 6)
+(('<S>', 'İ'), 6)
+(('İ', 'H'), 6)
+(('G', 'E'), 6)
+(('E', 'M'), 6)
+(('0', 'و'), 6)
+(('B', '2'), 6)
+(('U', 'R'), 6)
+(('O', 'P'), 6)
+(('h', 'f'), 6)
+(('a', 'e'), 6)
+(('K', 'I'), 6)
+(('٦', '٠'), 7)
+(('0', 'أ'), 7)
+(('M', 'P'), 7)
+(('C', 'l'), 7)
+(('A', 't'), 7)
+(('x', 't'), 7)
+(('S', 'N'), 7)
+(('م', '2'), 7)
+(('I', 'D'), 7)
+(('ج', 'ق'), 7)
+(('X', '<E>'), 7)
+(('ث', 'د'), 7)
+(('t', 'm'), 7)
+(('x', 'i'), 7)
+(('n', 'm'), 7)
+(('ب', '5'), 7)
+(('٢', '٢'), 7)
+(('O', 'f'), 7)
+(('H', 'i'), 7)
+(('s', 'f'), 7)
+(('V', 'I'), 7)
+(('P', 'S'), 7)
+(('y', 't'), 7)
+(('ض', '\\'), 7)
+(('S', 'i'), 7)
+(('B', 'i'), 7)
+(('P', 'Y'), 7)
+(('A', 'f'), 7)
+(('I', 'E'), 7)
+(('ا', 'أ'), 7)
+(('P', 'I'), 7)
+(('ﻻ', 'ح'), 7)
+(('ئ', 'ـ'), 7)
+(('F', 'D'), 7)
+(('D', 'R'), 7)
+(('ْ', 'ج'), 7)
+(('<S>', 'q'), 7)
+(('o', 'y'), 7)
+(('L', 'E'), 7)
+(('}', '،'), 7)
+(('H', 'H'), 7)
+(('P', 'P'), 7)
+(('ظ', 'ٍ'), 7)
+(('ـ', 'ه'), 7)
+(('ض', 'أ'), 7)
+(('D', 'u'), 7)
+(('E', 'P'), 7)
+(('ح', 'ؤ'), 7)
+(('n', 'u'), 7)
+(('h', 'u'), 7)
+(('ِ', 'خ'), 7)
+(('ى', 'ن'), 7)
+(('ل', '7'), 7)
+(('ٍ', 'ا'), 7)
+(('"', 'ق'), 7)
+(('O', 'b'), 7)
+(('M', '<E>'), 7)
+(('ً', 'ق'), 7)
+(('ـ', 'ا'), 7)
+(('j', 'j'), 7)
+(('٩', '٥'), 7)
+(('P', 'D'), 7)
+(('ـ', 'م'), 8)
+(('٩', '٩'), 8)
+(('A', 'C'), 8)
+(('D', 'C'), 8)
+(('ض', '؛'), 8)
+(('<S>', 'ّ'), 8)
+(('M', 'u'), 8)
+(('ْ', 'ق'), 8)
+(('n', 'v'), 8)
+(('y', 'm'), 8)
+(('٢', '١'), 8)
+(("'", 't'), 8)
+(('u', 'd'), 8)
+(('ـ', 'B'), 8)
+(('H', 'e'), 8)
+(('ش', 'ْ'), 8)
+(('N', 'S'), 8)
+(('n', 'l'), 8)
+(('ـ', 'ل'), 8)
+(('u', 'f'), 8)
+(('Y', 'D'), 8)
+(('ع', '!'), 8)
+(('k', 's'), 8)
+(('ر', 'إ'), 8)
+(('ف', '!'), 8)
+(('ص', '\\'), 8)
+(('ي', 'ـ'), 8)
+(('M', 'O'), 8)
+(('S', 'c'), 8)
+(('V', '<E>'), 8)
+(('A', 'c'), 8)
+((',', '5'), 8)
+(('T', 'U'), 8)
+(('P', 'C'), 8)
+(('T', 'I'), 8)
+(('*', 'ل'), 8)
+(('d', 'l'), 8)
+(('y', 'e'), 8)
+(('ـ', 'ن'), 8)
+(('P', 'G'), 8)
+(('s', 'r'), 8)
+(('B', 'o'), 8)
+(('*', 'م'), 8)
+(('t', 'f'), 8)
+(('D', 'S'), 8)
+(('O', 'n'), 8)
+(('b', 'y'), 9)
+(('(', '('), 9)
+((')', ')'), 9)
+(('y', 'r'), 9)
+(('ـ', 'C'), 9)
+(('b', 'b'), 9)
+(('؟', '،'), 9)
+(('A', 'M'), 9)
+(('ٌ', 'ع'), 9)
+(('"', 'خ'), 9)
+(('ط', '\\'), 9)
+(('T', 'N'), 9)
+(('A', 'I'), 9)
+(('ً', 'ّ'), 9)
+(('ى', 'ٰ'), 9)
+(('ٰ', '<E>'), 9)
+(('x', 'y'), 9)
+(('O', 'p'), 9)
+(('١', '٦'), 9)
+(('ﺇ', 'ل'), 9)
+(('ٍ', 'ي'), 9)
+(('n', "'"), 9)
+(('L', '<E>'), 9)
+(('٤', '٠'), 9)
+(('"', 'ش'), 9)
+(('ـ', 'ـ'), 9)
+(('ّ', 'ئ'), 9)
+(('e', 'h'), 9)
+(('ب', '7'), 9)
+(('C', 'O'), 9)
+(('*', '<E>'), 9)
+(('M', '2'), 9)
+(('F', '1'), 9)
+(('O', 'K'), 9)
+(('p', 's'), 9)
+(('I', 'L'), 9)
+(('س', '!'), 9)
+(('*', 'أ'), 9)
+(('T', 'u'), 9)
+(('}', '.'), 9)
+(('R', 'O'), 9)
+(('s', 'k'), 9)
+(('t', 'w'), 9)
+(('n', 'n'), 9)
+(('<S>', '٤'), 9)
+(('j', 'b'), 9)
+(('٥', '٢'), 9)
+(('h', 'n'), 9)
+(('v', '<E>'), 9)
+(('W', 'i'), 9)
+(('٠', '٣'), 9)
+(('ً', 'ن'), 9)
+(('J', 'e'), 9)
+(('ف', '\\'), 10)
+(('ظ', 'ٌ'), 10)
+(('خ', 'ك'), 10)
+(('٥', '٠'), 10)
+(('C', 'e'), 10)
+(('ش', 'ء'), 10)
+(('ﻷ', 'ي'), 10)
+(('ئ', 'ُ'), 10)
+(('C', 'A'), 10)
+(('ـ', 'ت'), 10)
+(('G', '<E>'), 10)
+(('و', 'T'), 10)
+(('.', '؟'), 10)
+(('ٌ', 'ر'), 10)
+(('ل', '3'), 10)
+(('e', 'y'), 10)
+(('ء', '\\'), 10)
+(('غ', 'ك'), 10)
+(('v', 'o'), 10)
+(('ذ', 'ً'), 10)
+(('W', 'h'), 10)
+(('<S>', 'ٍ'), 10)
+(('ﻷ', 'ب'), 10)
+(('ؤ', 'ص'), 10)
+(('س', '؛'), 10)
+(('T', 'R'), 10)
+(('ﻻ', 'ت'), 10)
+(('ع', 'ً'), 10)
+(('٨', '<E>'), 10)
+(('S', 'I'), 10)
+(('*', 'ب'), 10)
+(('*', 'إ'), 10)
+(('b', 's'), 10)
+(('ش', 'ش'), 10)
+(('N', 'A'), 10)
+(('C', 'H'), 10)
+(('I', 'O'), 10)
+(('G', 'O'), 10)
+(('M', 'S'), 10)
+(('ا', ','), 10)
+(('ه', 'أ'), 10)
+(('H', 'K'), 10)
+(('ا', 'ﻻ'), 10)
+(('٧', '<E>'), 10)
+(('E', 'C'), 10)
+(('ذ', 'ح'), 10)
+(('ﻹ', 'ع'), 11)
+(('١', '٥'), 11)
+(('P', 'h'), 11)
+(('m', 's'), 11)
+(('P', 'u'), 11)
+(('x', 'p'), 11)
+(('0', 'ع'), 11)
+(('H', 'a'), 11)
+(('ظ', 'ك'), 11)
+(('ً', 'ل'), 11)
+(('d', 'd'), 11)
+(('A', 'B'), 11)
+(('S', 'E'), 11)
+(('J', 'u'), 11)
+(('S', 'a'), 11)
+(('a', 'f'), 11)
+(('C', 'i'), 11)
+(('b', '<E>'), 11)
+(('w', 'h'), 11)
+(('ر', '2'), 11)
+(('1', ','), 11)
+(('ل', '6'), 11)
+(('خ', 'ْ'), 11)
+(('A', 'T'), 11)
+(('s', 'y'), 11)
+(('١', '٨'), 11)
+(('h', 'y'), 11)
+(('ً', '\\'), 11)
+(('D', 'A'), 11)
+(('*', 'ت'), 11)
+(('J', 'a'), 11)
+((')', '.'), 11)
+(('ز', '\\'), 11)
+(('h', 'r'), 11)
+(('أ', 'ّ'), 12)
+(('"', 'د'), 12)
+(('d', 's'), 12)
+(('ع', '؛'), 12)
+(('ﻷ', 'ج'), 12)
+(('G', 'e'), 12)
+(('w', 'n'), 12)
+(('o', 'a'), 12)
+(('l', 'r'), 12)
+((')', '،'), 12)
+(('ل', '5'), 12)
+(('ى', '\\'), 12)
+(('<S>', 'َ'), 12)
+(('َ', 'إ'), 12)
+(('p', 'u'), 12)
+(('T', 'a'), 12)
+(('G', 'P'), 12)
+(('y', 'p'), 12)
+(('G', 'T'), 12)
+(('E', 'S'), 12)
+(('ﻷ', 'ك'), 12)
+(('B', '<E>'), 12)
+(('T', 'V'), 12)
+(('ب', '!'), 12)
+(('ْ', 'و'), 12)
+(('y', 'n'), 12)
+(('F', 'u'), 12)
+(('ﻷ', 'ف'), 12)
+(('E', 'n'), 12)
+(('د', 'ْ'), 12)
+(('l', 'f'), 12)
+(('ا', 'إ'), 13)
+(('ء', '؛'), 13)
+(('A', 'l'), 13)
+(('ف', '1'), 13)
+(('ﻷ', 'خ'), 13)
+(('l', 's'), 13)
+(('r', 'p'), 13)
+(('L', 'o'), 13)
+(('ك', 'ْ'), 13)
+(('ح', '؛'), 13)
+(('z', 'i'), 13)
+(('F', '<E>'), 13)
+(('g', 't'), 13)
+(('c', 'c'), 13)
+(('أ', 'ْ'), 13)
+(('n', 'y'), 13)
+(('f', '<E>'), 13)
+(('I', 'P'), 13)
+(('A', 'r'), 13)
+(('u', 'g'), 13)
+(('O', 'R'), 13)
+(('C', 'S'), 13)
+(('ﻻ', 'ز'), 13)
+(('W', 'A'), 13)
+(('d', 'r'), 13)
+(('e', 'o'), 13)
+(('ا', 'ا'), 13)
+(('B', 'S'), 13)
+(('h', 'w'), 13)
+(('s', 'c'), 13)
+(('m', 'b'), 13)
+(('E', 'c'), 13)
+(('7', 'ف'), 13)
+(('١', '٢'), 14)
+(('d', 'm'), 14)
+(('d', 'u'), 14)
+(('0', 'م'), 14)
+(('S', 'h'), 14)
+(('E', 'x'), 14)
+(('ﻻ', 'ب'), 14)
+(('ب', 'ً'), 14)
+(('U', 'n'), 14)
+(('j', 'o'), 14)
+(('i', 'p'), 14)
+(('َ', 'ظ'), 14)
+(('ع', '\\'), 14)
+(('B', 'A'), 14)
+(('ئ', 'خ'), 14)
+(('J', 'o'), 14)
+(('D', 'o'), 14)
+(('ل', '4'), 14)
+(('g', 'y'), 14)
+(('ِ', 'ة'), 14)
+(('M', 'H'), 14)
+(('k', 'a'), 14)
+(('ِ', 'ظ'), 14)
+(('R', 'P'), 14)
+(('و', 'ؤ'), 14)
+(('ج', '\\'), 14)
+(('"', 'ط'), 14)
+(('B', 'l'), 14)
+(('C', 'R'), 14)
+(('٠', '٪'), 14)
+(('N', 'H'), 14)
+(('E', 'a'), 14)
+(('ْ', 'ف'), 14)
+(('٥', '<E>'), 14)
+(('N', 'R'), 14)
+((';', '<E>'), 14)
+(('h', 'm'), 15)
+(('د', '!'), 15)
+(('<S>', 'j'), 15)
+(('ف', '؛'), 15)
+(('ك', '؛'), 15)
+(('ا', 'ٌ'), 15)
+(('ِ', 'أ'), 15)
+(('ؤ', 'ز'), 15)
+(('ئ', 'َ'), 15)
+(('f', 't'), 15)
+(('f', 'l'), 15)
+(('T', 'o'), 15)
+(('س', 'غ'), 15)
+(('L', 'e'), 15)
+(('G', 'a'), 15)
+(('ه', 'ث'), 15)
+(('ش', '\\'), 15)
+(('ث', 'خ'), 15)
+(('W', 'o'), 15)
+(('c', 'l'), 16)
+(('٤', '<E>'), 16)
+(('غ', 'ٌ'), 16)
+(('ذ', 'ْ'), 16)
+(('ْ', 'ب'), 16)
+(('آ', 'ص'), 16)
+(('<S>', 'ﺇ'), 16)
+(('ئ', 'ٌ'), 16)
+(('Z', 'o'), 16)
+(('<S>', 'ً'), 16)
+(('T', 'e'), 16)
+(('z', 'a'), 16)
+(('أ', 'ِ'), 16)
+(('ق', '؛'), 16)
+(('W', 'e'), 16)
+(('e', 'f'), 16)
+(('ْ', 'أ'), 16)
+(('F', 'I'), 16)
+(('D', 'I'), 16)
+(('P', 'l'), 16)
+(('n', 'f'), 16)
+(('أ', 'ﻻ'), 16)
+(('b', 'r'), 16)
+(('C', 'C'), 16)
+(('A', 'N'), 16)
+(('E', 'N'), 16)
+(('<S>', '@'), 17)
+(('ﻷ', 'ق'), 17)
+(('م', 'ً'), 17)
+(('ي', 'ً'), 17)
+(('\\', '\\'), 17)
+(('ؤ', 'ة'), 17)
+(('s', 'l'), 17)
+(('ب', '3'), 17)
+(('آ', 'غ'), 17)
+(('O', 'N'), 17)
+(('ك', 'ظ'), 17)
+(('ِ', 'غ'), 17)
+(('ً', '!'), 17)
+(('a', 'u'), 17)
+((':', '('), 17)
+(('M', 'E'), 17)
+(('ف', '2'), 17)
+(('u', 'i'), 17)
+(('P', 'A'), 17)
+(('ض', 'ً'), 17)
+(('p', 'h'), 17)
+(('H', '<E>'), 17)
+(('ـ', 'أ'), 17)
+(('و', '\\'), 17)
+(('"', 'ج'), 17)
+(('H', 'E'), 17)
+(('ْ', 'ع'), 17)
+(('١', '٣'), 18)
+(('C', 'L'), 18)
+(('َ', 'غ'), 18)
+(('r', 'v'), 18)
+(('ت', 'ْ'), 18)
+(('b', 'u'), 18)
+(('ْ', 'ي'), 18)
+(('i', 'z'), 18)
+(('S', 'p'), 18)
+(('"', 'ر'), 18)
+(('V', 'i'), 18)
+(('U', 'F'), 18)
+(('A', 's'), 18)
+(('ك', '!'), 18)
+(('T', 'H'), 18)
+(('٪', '<E>'), 18)
+(('S', 'S'), 18)
+(('٦', '<E>'), 19)
+(('G', 'u'), 19)
+(('غ', 'ث'), 19)
+(('g', 'o'), 19)
+(('ُ', 'أ'), 19)
+(('C', 'B'), 19)
+(('M', 'I'), 19)
+(('ئ', 'ٍ'), 19)
+(('<S>', 'u'), 19)
+(('ﻹ', 'س'), 19)
+(('<S>', 'Z'), 19)
+(('ر', 'ً'), 19)
+(('D', 'a'), 19)
+(('ت', '!'), 19)
+(('H', 'U'), 19)
+(('T', 'O'), 19)
+(('a', 'k'), 19)
+(('D', 'r'), 19)
+(('L', 'I'), 19)
+(('١', '٤'), 20)
+(('N', 'a'), 20)
+(('t', 'l'), 20)
+(('"', 'ع'), 20)
+(('٢', '<E>'), 20)
+(('u', 'c'), 20)
+(('ٌ', 'ق'), 20)
+(('D', '<E>'), 20)
+(('B', 'u'), 20)
+(('ِ', 'ئ'), 20)
+(('I', 'S'), 20)
+(('f', 'f'), 20)
+(('#', 't'), 20)
+(('a', 'v'), 20)
+(('A', 'n'), 20)
+(('k', 'i'), 20)
+(('ا', 'ٍ'), 20)
+(('ف', 'ْ'), 20)
+(('F', 'F'), 20)
+(('T', 'E'), 20)
+(('E', 'D'), 20)
+(('f', 'u'), 20)
+(('q', 'u'), 20)
+(('ْ', 'ض'), 20)
+(('ْ', 'ك'), 20)
+(('"', 'ت'), 21)
+(('س', 'ْ'), 21)
+(('U', 'S'), 21)
+(('ْ', 'س'), 21)
+(('F', 'r'), 21)
+(('C', 'h'), 21)
+(('I', 's'), 21)
+(('ذ', 'ٌ'), 21)
+(('ة', ','), 21)
+(('ّ', 'ظ'), 21)
+(('ـ', '8'), 21)
+(('إ', 'ﻻ'), 21)
+(('ك', '\\'), 21)
+(('H', 'o'), 21)
+(('"', 'غ'), 21)
+(('ظ', 'ع'), 22)
+(('<S>', 'ﻹ'), 22)
+(('١', '٠'), 22)
+(('ه', 'ط'), 22)
+(('o', 'x'), 22)
+(('N', 'T'), 22)
+(('ض', 'ض'), 22)
+(('ح', 'ْ'), 22)
+(('ق', 'ْ'), 22)
+(('P', 'e'), 22)
+(('d', 'y'), 22)
+(('g', 'u'), 22)
+(('ئ', 'غ'), 22)
+(('ْ', 'ه'), 22)
+(('ب', 'ْ'), 22)
+(('ى', '؛'), 22)
+(('<S>', 'y'), 22)
+(('O', 'S'), 22)
+(('غ', 'ج'), 22)
+(('l', 'u'), 23)
+(('٣', '<E>'), 23)
+(('w', 's'), 23)
+(('p', 'i'), 23)
+(('M', 'e'), 23)
+(('ا', 'ْ'), 23)
+(('ِ', 'ث'), 23)
+(('ت', 'ً'), 23)
+(('s', 'm'), 23)
+(('<S>', '#'), 23)
+(('ً', '؛'), 23)
+(('P', 'O'), 23)
+(('a', 'h'), 24)
+(('D', 'i'), 24)
+(('ه', '!'), 24)
+(('s', 'u'), 24)
+(('<S>', 'K'), 24)
+(('ف', 'آ'), 24)
+(('"', 'ن'), 24)
+(('ه', '؛'), 24)
+(('y', 'o'), 24)
+(('R', '<E>'), 24)
+(('I', 'T'), 24)
+(('w', 'w'), 24)
+(('l', 't'), 25)
+(('غ', 'ٍ'), 25)
+(('x', '<E>'), 25)
+(('P', '<E>'), 25)
+(('r', 'l'), 25)
+(('v', 'a'), 25)
+(('ﻻ', 'ر'), 25)
+(('R', 'i'), 25)
+(('p', 'l'), 25)
+(('ل', '!'), 25)
+(('ت', '\\'), 25)
+(('S', 'T'), 25)
+(('D', 'e'), 25)
+(('c', 's'), 25)
+(('١', '٩'), 26)
+(('ق', '\\'), 26)
+(('N', 'G'), 26)
+(('w', 'o'), 26)
+(('m', 'p'), 26)
+(('S', 'u'), 26)
+(('F', 'i'), 26)
+(('N', 'B'), 26)
+(('ب', '2'), 27)
+(('w', 'e'), 27)
+(('f', 'r'), 27)
+(('ل', '2'), 27)
+(('u', '<E>'), 27)
+(('ب', '1'), 27)
+(('S', 'e'), 27)
+(('G', 'o'), 27)
+(('R', 'E'), 27)
+(('َ', 'خ'), 27)
+(('ف', 'ء'), 27)
+(('U', 'N'), 27)
+(('u', 'a'), 28)
+(('M', 'i'), 28)
+(('و', 'ٌ'), 28)
+(('B', 'a'), 28)
+(('e', 'x'), 28)
+(('t', 'c'), 28)
+(('و', '9'), 28)
+(('p', 't'), 28)
+(('ث', 'ى'), 28)
+(('ـ', '9'), 28)
+(('ذ', 'ئ'), 29)
+(('١', '١'), 29)
+(('ِ', 'ش'), 29)
+(('o', 'b'), 29)
+(('T', 'r'), 29)
+(('َ', 'ش'), 29)
+(('ُ', 'ئ'), 29)
+(('p', 'p'), 29)
+(('ل', 'ً'), 29)
+(('c', 'u'), 29)
+(('١', '<E>'), 30)
+(('ب', '\\'), 30)
+(('S', 'y'), 30)
+(('d', '@'), 30)
+(('T', 'w'), 30)
+(('ِ', 'ذ'), 30)
+(('ﻻ', '<E>'), 30)
+(('i', 'f'), 30)
+(('O', '<E>'), 30)
+(('"', 'ف'), 30)
+(('o', 'v'), 30)
+(('m', 'u'), 31)
+(('c', 'r'), 31)
+(('C', 'a'), 31)
+(('F', 'o'), 31)
+(('<S>', 'ِ'), 31)
+(('A', 'm'), 31)
+(('u', 'b'), 31)
+(('p', '<E>'), 31)
+(('y', 's'), 31)
+(('N', 'I'), 31)
+(('ج', 'ش'), 31)
+(('س', '\\'), 32)
+(('g', 'i'), 32)
+(('s', 'p'), 32)
+(('"', 'ك'), 32)
+(('r', 'g'), 32)
+(('k', 'e'), 32)
+(('u', 'p'), 32)
+(('E', '<E>'), 32)
+(('ء', 'ي'), 32)
+(('o', 'i'), 32)
+(('f', 'e'), 32)
+(('o', 'g'), 32)
+(('g', 'l'), 32)
+(('r', 'm'), 32)
+(('G', 'r'), 33)
+(('ت', '؛'), 33)
+(('ـ', '7'), 33)
+(('i', '<E>'), 33)
+(('g', 'a'), 33)
+(('أ', 'ٌ'), 33)
+(('a', 'b'), 33)
+(('r', 'u'), 33)
+(('I', 'C'), 33)
+(('٠', '<E>'), 34)
+(('"', 'ح'), 34)
+(('ك', 'ـ'), 34)
+(('َ', 'ص'), 34)
+(('e', 'v'), 34)
+(('ر', '!'), 34)
+(('آ', 'ة'), 34)
+(('e', 'p'), 34)
+(('m', 'm'), 34)
+(('"', 'ه'), 34)
+(('ل', '؛'), 35)
+(('ّ', 'أ'), 35)
+(('"', 'ي'), 35)
+(('َ', 'ز'), 35)
+(('ه', '\\'), 35)
+(('b', 'a'), 35)
+(('e', 'g'), 35)
+((':', '{'), 35)
+(('م', '!'), 36)
+(('ْ', 'ت'), 36)
+(('َ', 'ث'), 36)
+(('<S>', 'V'), 36)
+(('m', 'o'), 36)
+(('آ', 'ز'), 37)
+(('<S>', 'ﻻ'), 37)
+(('"', 'س'), 37)
+(('b', 'l'), 37)
+(('ش', 'ٌ'), 37)
+(('c', 'y'), 37)
+(('ب', '؛'), 37)
+(('َ', 'ط'), 37)
+(('}', '['), 37)
+(('<S>', 'O'), 37)
+(('Y', 'o'), 37)
+(('ل', '1'), 37)
+(('ر', 'ْ'), 37)
+(('*', 'ا'), 37)
+(('M', 'o'), 38)
+(('f', 'a'), 38)
+(('b', 'i'), 38)
+(('H', 'u'), 38)
+(('ع', 'ْ'), 38)
+(('ْ', 'د'), 38)
+(('غ', 'َ'), 38)
+(('َ', 'ج'), 38)
+(('ف', 'ـ'), 38)
+(('<S>', 'v'), 38)
+(('u', 'e'), 38)
+(('N', 'o'), 38)
+(('0', ','), 38)
+(('F', 'B'), 39)
+(('ـ', '6'), 39)
+(('ﻷ', 'ر'), 39)
+(('ْ', 'ل'), 39)
+(('I', 'n'), 39)
+(('ﻵ', 'ن'), 39)
+(('r', 'c'), 39)
+(('ئ', 'ش'), 39)
+(('خ', 'ٌ'), 40)
+(('ك', 'ئ'), 40)
+(('و', 'ْ'), 40)
+(('<S>', 'Y'), 40)
+(('r', 'k'), 40)
+(('َ', 'ذ'), 40)
+(('D', '@'), 40)
+(('B', 'r'), 40)
+(('ؤ', 'ط'), 41)
+(('ي', '!'), 41)
+(('S', 'o'), 41)
+(('ئ', 'ِ'), 41)
+(('A', 'p'), 41)
+(('ظ', 'َ'), 41)
+(('@', 'A'), 41)
+(('I', 'N'), 41)
+(('e', 'u'), 41)
+(('<S>', 'ﻷ'), 42)
+(('B', 'I'), 42)
+(('f', 'o'), 42)
+(('d', 'o'), 42)
+(('ا', 'ﻵ'), 42)
+(('n', 'k'), 42)
+(('r', 'd'), 43)
+(('l', 'j'), 43)
+(('F', 'a'), 43)
+(('ج', 'ى'), 43)
+(('ش', 'ذ'), 43)
+(('ء', 'ك'), 43)
+(('M', 'A'), 43)
+(('5', '+'), 43)
+(('ﻷ', 'س'), 44)
+(('د', 'ً'), 44)
+(('r', 'r'), 44)
+(('g', 'r'), 44)
+(('غ', 'ش'), 45)
+(('ط', 'ك'), 45)
+(('ش', 'س'), 45)
+(('خ', 'ى'), 45)
+(('َ', 'أ'), 45)
+(('R', 'e'), 45)
+((',', '0'), 45)
+(('a', 'j'), 46)
+(('w', 'i'), 46)
+(('v', 'i'), 46)
+(('ك', 'آ'), 46)
+(('l', 'd'), 46)
+(('<S>', 'J'), 46)
+(('ا', 'ﻹ'), 46)
+(('R', 'S'), 46)
+(('د', '؛'), 47)
+(('ه', 'ٌ'), 47)
+(('َ', 'ى'), 47)
+(('ﻷ', 'و'), 47)
+(('"', 'و'), 48)
+(('ٍ', 'ّ'), 48)
+(('غ', 'ِ'), 48)
+(('o', 'p'), 48)
+(('l', 'y'), 48)
+(('ر', '؛'), 48)
+(('a', 'p'), 48)
+(('و', '8'), 49)
+(('ْ', 'ن'), 49)
+(('ـ', '5'), 49)
+(('ا', '!'), 49)
+(('ِ', 'ت'), 49)
+(('e', 'b'), 49)
+(('K', 'K'), 49)
+(('و', '7'), 49)
+(('س', 'ذ'), 49)
+(('<S>', 'r'), 49)
+(('T', 'i'), 49)
+(('+', '1'), 49)
+(('آ', 'ج'), 50)
+(('@', 'a'), 50)
+(('ُ', 'ا'), 50)
+(('ج', 'ٌ'), 50)
+(('z', 'e'), 50)
+(('O', 'k'), 50)
+(('i', 'v'), 50)
+(('e', 'i'), 50)
+(('"', 'ب'), 51)
+(('P', 'r'), 51)
+(('h', 't'), 51)
+(('<S>', 'U'), 51)
+(('ْ', 'ر'), 51)
+(('o', 'w'), 52)
+(('t', 'u'), 52)
+(('ّ', 'ش'), 52)
+(('A', 'D'), 52)
+(('ظ', 'ب'), 52)
+(('ز', 'ٌ'), 52)
+(('C', 'I'), 53)
+(('w', 'a'), 53)
+(('P', 'K'), 53)
+(('م', '\\'), 53)
+(('خ', 'ٍ'), 53)
+(('ِ', 'ص'), 53)
+(('5', '3'), 53)
+(('ّ', 'غ'), 54)
+(('o', 'f'), 54)
+(('ه', 'ف'), 54)
+(('<S>', 'e'), 54)
+(('t', 's'), 54)
+(('ْ', 'م'), 54)
+(('a', 'y'), 54)
+(('<S>', '١'), 55)
+(('C', 'N'), 55)
+(('ط', 'خ'), 55)
+(('P', 'a'), 55)
+(('ِ', 'ا'), 55)
+(('a', 'z'), 55)
+(('B', 'B'), 55)
+(('أ', 'أ'), 55)
+(('ل', '\\'), 55)
+(('N', 'N'), 56)
+(('<S>', 'g'), 56)
+(('؟', '؟'), 56)
+(('r', 'n'), 56)
+(('r', 'y'), 56)
+(('7', '1'), 56)
+(('u', 'l'), 56)
+(('f', 'i'), 57)
+(('T', 'h'), 57)
+(('ض', 'ك'), 57)
+(('I', 'A'), 57)
+(('و', '6'), 57)
+(('d', 'a'), 57)
+(('A', 'R'), 57)
+(('"', 'إ'), 58)
+(('c', 'k'), 58)
+(('i', 'r'), 58)
+(('o', 'd'), 58)
+(('s', 'a'), 59)
+(('c', '<E>'), 59)
+(('p', 'r'), 59)
+(('ي', 'ِ'), 59)
+(('ك', 'ؤ'), 60)
+(('h', 'o'), 60)
+(('b', 'o'), 60)
+(('W', 'a'), 60)
+(('ء', 'م'), 60)
+(('<S>', 'o'), 61)
+(('ك', 'ٌ'), 61)
+(('ن', '!'), 62)
+(('ِ', 'ز'), 62)
+(('ئ', 'ث'), 62)
+(('م', '؛'), 62)
+(('I', '<E>'), 62)
+(('إ', 'ِ'), 62)
+(('i', 'b'), 62)
+(('"', 'أ'), 63)
+(('ّ', 'خ'), 63)
+(('ِ', 'س'), 63)
+(('غ', 'ّ'), 63)
+(('h', 'a'), 63)
+(('4', '4'), 64)
+(('<S>', 'i'), 64)
+(('<S>', 'h'), 64)
+(('t', 't'), 65)
+(('ؤ', 'ب'), 65)
+(('<S>', '0'), 65)
+(('8', '3'), 66)
+(('٠', '١'), 66)
+(('ه', 'آ'), 66)
+(('ـ', '4'), 66)
+(('ِ', 'ج'), 66)
+(('n', 'o'), 67)
+(('د', '\\'), 67)
+(('l', 'o'), 67)
+(('P', 'o'), 67)
+(('M', 'a'), 67)
+(('و', '4'), 67)
+(('g', 'h'), 67)
+(('ى', 'ً'), 67)
+(('3', '9'), 68)
+(('أ', 'ً'), 68)
+(('K', '<E>'), 68)
+(('C', 'o'), 68)
+(('ي', 'ْ'), 69)
+(('و', '5'), 69)
+(('S', 'A'), 69)
+(('8', '4'), 69)
+(('؟', '.'), 70)
+(('ث', 'ٌ'), 70)
+(('E', 'E'), 70)
+(('ذ', 'َ'), 71)
+(('ش', 'ٍ'), 72)
+(('L', 'i'), 72)
+(('ل', 'ء'), 72)
+(('6', '1'), 72)
+(('َ', 'س'), 72)
+(('L', 'J'), 72)
+(('J', 'A'), 72)
+(('A', 'Z'), 72)
+(('ي', '؛'), 73)
+(('٠', '٠'), 73)
+(('ﻷ', 'م'), 73)
+(('4', '1'), 73)
+(('<S>', 'd'), 73)
+(('Z', 'E'), 73)
+(('د', 'ز'), 74)
+(('ر', '\\'), 74)
+(('4', '3'), 74)
+(('ط', 'ج'), 74)
+(('ّ', 'ً'), 75)
+(('5', '7'), 75)
+(('ش', 'َ'), 75)
+(('"', 'ل'), 75)
+(('o', 't'), 75)
+(('ك', 'ض'), 75)
+(('ث', 'ع'), 76)
+(('س', 'آ'), 76)
+(('a', 'i'), 76)
+(('u', 'm'), 76)
+(('o', 'k'), 76)
+(('ز', 'غ'), 76)
+(('s', 'h'), 76)
+(('S', 't'), 76)
+(('o', 'c'), 77)
+(('o', '<E>'), 77)
+(('5', '8'), 77)
+(('j', 'a'), 78)
+(('N', '<E>'), 78)
+(('4', '9'), 79)
+(('e', 'w'), 79)
+(('4', '%'), 79)
+(('ه', 'ٍ'), 79)
+(('<S>', 'b'), 79)
+(('m', 'i'), 79)
+(('<S>', 'E'), 80)
+(('6', '%'), 80)
+(('7', '4'), 80)
+(('e', 'm'), 80)
+(('A', 'L'), 80)
+(('3', '8'), 81)
+(('َ', 'ض'), 81)
+(('ـ', '3'), 81)
+(('ن', 'ً'), 82)
+(('7', '6'), 82)
+(('p', 'a'), 82)
+(('7', '7'), 82)
+(('n', 'c'), 83)
+(('ا', '\\'), 83)
+(('ه', 'س'), 83)
+(('N', 'e'), 83)
+(('S', '<E>'), 83)
+(('ض', 'ٌ'), 84)
+(('<S>', 'n'), 84)
+(('u', 't'), 84)
+(('<S>', 'l'), 84)
+(('غ', 'ص'), 84)
+(('e', 'c'), 84)
+((',', '<E>'), 84)
+(('E', 'T'), 84)
+(('ِ', 'ط'), 84)
+(('E', 'R'), 84)
+(('i', 'd'), 85)
+(('ء', 'ُ'), 85)
+(('N', 'E'), 85)
+(('7', '2'), 86)
+(('ج', 'آ'), 86)
+(('a', 'g'), 86)
+(('ِ', 'و'), 87)
+(('o', 's'), 87)
+(('6', '6'), 87)
+(('ة', '!'), 88)
+(('c', 't'), 89)
+(('i', 'e'), 89)
+(('ِ', 'ّ'), 89)
+(('a', 'd'), 90)
+(('d', 'i'), 90)
+(('c', 'h'), 90)
+(('ِ', 'ض'), 91)
+(('ن', 'ْ'), 91)
+(('ل', 'ْ'), 91)
+(('w', '<E>'), 92)
+(('s', 'i'), 92)
+(('s', 'o'), 92)
+(('6', '3'), 92)
+(('و', 'ِ'), 92)
+(('<S>', 'R'), 92)
+(('ُ', 'ّ'), 92)
+(('6', '8'), 92)
+(('ز', 'َ'), 93)
+(('ف', 'ث'), 93)
+(('g', 'e'), 93)
+(('6', '9'), 93)
+(('ث', 'ِ'), 94)
+(('8', '7'), 94)
+(('h', 'i'), 94)
+(('u', 's'), 95)
+(('a', 'm'), 95)
+(('ذ', 'ٍ'), 95)
+(('i', 'm'), 95)
+(('خ', 'َ'), 95)
+(('7', '%'), 96)
+(('ط', 'ء'), 96)
+(('9', '%'), 96)
+(('5', '6'), 96)
+(('4', '6'), 96)
+(('5', '9'), 96)
+(('5', '4'), 97)
+(('a', 's'), 97)
+(('3', '4'), 97)
+(('<S>', 'I'), 97)
+(('B', 'C'), 98)
+(('e', 'l'), 99)
+(('آ', 'ش'), 99)
+(('i', 'g'), 99)
+(('b', 'e'), 99)
+(('ك', 'ٍ'), 99)
+(('7', '8'), 100)
+(('س', 'ٌ'), 100)
+(('3', '1'), 100)
+(('و', '3'), 100)
+(('8', '1'), 100)
+(('6', '2'), 101)
+(('ن', '؛'), 101)
+(('َ', 'ك'), 101)
+(('ث', 'ٍ'), 101)
+(('R', 'A'), 101)
+(('ط', 'ٌ'), 102)
+(('غ', 'ُ'), 102)
+(('<S>', 'ُ'), 102)
+(('3', '7'), 103)
+(('n', 'i'), 103)
+(('p', 'o'), 103)
+(('<S>', 'w'), 103)
+(('َ', 'ة'), 103)
+(('8', '%'), 104)
+(('c', 'i'), 104)
+(('م', 'ْ'), 104)
+(('ك', 'غ'), 105)
+(('<S>', 'L'), 105)
+(('ا', '؛'), 105)
+(('ِ', 'ح'), 105)
+(('6', '4'), 105)
+(('ك', 'ص'), 105)
+(('و', 'ٍ'), 106)
+(('<S>', 'm'), 106)
+(('3', '%'), 106)
+(('ص', 'َ'), 106)
+(('o', 'o'), 106)
+(('ؤ', 'ذ'), 106)
+(('<S>', 'H'), 106)
+(('u', 'n'), 106)
+(('َ', 'و'), 107)
+(('ق', 'ز'), 107)
+(('r', 's'), 107)
+(('ص', 'ٌ'), 107)
+(('p', 'e'), 107)
+(('ذ', 'ِ'), 108)
+(('ُ', 'ي'), 108)
+(('ز', 'ِ'), 108)
+(('ك', 'ى'), 109)
+(('ج', 'ك'), 109)
+(('ئ', 'ض'), 109)
+(('i', 'l'), 110)
+(('s', 's'), 111)
+(('<S>', 'W'), 111)
+(('3', '2'), 112)
+(('<S>', 'D'), 112)
+(('v', 'e'), 112)
+(('<S>', '٢'), 113)
+(('e', 'e'), 113)
+(('٢', '٠'), 114)
+(('ن', '\\'), 114)
+(('8', '8'), 115)
+(('c', 'a'), 115)
+(('ض', 'ئ'), 116)
+(('t', 'y'), 116)
+(('l', 'l'), 116)
+(('أ', 'ئ'), 118)
+(('4', '2'), 119)
+(('خ', 'ّ'), 120)
+(('ز', 'ٍ'), 120)
+(('ؤ', 'ن'), 121)
+(('l', 'a'), 121)
+(('h', '<E>'), 121)
+(('4', '7'), 122)
+(('e', 'd'), 122)
+(('ﻷ', 'ن'), 122)
+(('آ', 'ك'), 122)
+(('8', '2'), 122)
+(('<S>', 'f'), 123)
+(('ط', 'َ'), 123)
+(('T', '<E>'), 123)
+(('ظ', 'ّ'), 125)
+(('ص', 'ك'), 125)
+(('t', 'o'), 126)
+(('n', 'a'), 126)
+(('ّ', 'ص'), 126)
+(('"', 'م'), 127)
+(('3', '3'), 127)
+(('s', 'e'), 129)
+(('8', '9'), 129)
+(('1', '%'), 129)
+(('5', '5'), 131)
+(('n', 's'), 131)
+(('u', 'r'), 131)
+(('ك', 'ط'), 131)
+(('C', '<E>'), 131)
+(('8', '6'), 131)
+(('<S>', 'G'), 132)
+(('5', '1'), 132)
+(('e', 'a'), 132)
+(('o', 'l'), 132)
+(('2', '9'), 134)
+(('ج', 'ٍ'), 135)
+(('ـ', '2'), 136)
+(('ش', 'ظ'), 137)
+(('o', 'm'), 138)
+(('<S>', '*'), 139)
+(('c', 'o'), 140)
+(('2', '%'), 140)
+(('ك', 'خ'), 141)
+(('7', '3'), 141)
+(('ِ', 'ع'), 141)
+(('ز', 'ى'), 142)
+(('5', '2'), 142)
+(('ا', 'ّ'), 143)
+(('ط', 'ِ'), 143)
+(('ه', 'َ'), 143)
+(('ل', 'ؤ'), 144)
+(('َ', 'ي'), 144)
+(('8', '5'), 145)
+(('3', '6'), 146)
+(('i', 'a'), 148)
+(('ِ', 'ه'), 148)
+(('m', '<E>'), 148)
+(('7', '9'), 148)
+(('ش', 'ِ'), 149)
+(('d', 'e'), 149)
+(('ه', 'ّ'), 150)
+(('ّ', 'ج'), 150)
+(('k', '<E>'), 150)
+(('خ', 'خ'), 150)
+(('و', 'ﻻ'), 151)
+(('َ', 'ح'), 151)
+(('e', 't'), 152)
+(('r', 't'), 152)
+(('<S>', 't'), 152)
+(('ر', 'ذ'), 153)
+(('ّ', 'ٌ'), 153)
+(('ب', 'ى'), 153)
+(('ظ', 'ِ'), 156)
+(('ذ', 'ع'), 156)
+(('ض', 'ّ'), 157)
+(('ئ', 'ص'), 157)
+(('و', '1'), 157)
+(('ج', 'َ'), 157)
+(('<S>', 's'), 158)
+(('t', 'r'), 158)
+(('<S>', 'p'), 158)
+(('َ', 'ق'), 159)
+(('ح', 'ٌ'), 161)
+(('ة', '؛'), 163)
+(('غ', 'ى'), 163)
+(('َ', 'ف'), 165)
+(('ّ', 'ط'), 166)
+(('ض', 'َ'), 167)
+(('ط', 'ّ'), 168)
+(('ق', 'ج'), 168)
+(('ق', 'ظ'), 169)
+(('ّ', 'ث'), 170)
+(('ئ', 'ذ'), 170)
+(('ي', '\\'), 171)
+(('g', '<E>'), 172)
+(('َ', 'ه'), 173)
+(('t', 'a'), 173)
+(('إ', 'ظ'), 174)
+(('9', '3'), 174)
+(('ؤ', 'ى'), 174)
+(('t', 'h'), 174)
+(('خ', 'ِ'), 177)
+(('ِ', 'ك'), 178)
+(('د', 'ج'), 178)
+(('m', 'a'), 179)
+(('غ', 'ه'), 179)
+(('2', '8'), 179)
+(('ث', 'غ'), 180)
+(('<S>', 'B'), 180)
+(('6', '5'), 180)
+(('ث', 'َ'), 181)
+(('ظ', 'ُ'), 181)
+(('n', 'd'), 181)
+(('ً', 'ا'), 182)
+(('<S>', 'a'), 182)
+(('ذ', 'ى'), 182)
+(('د', 'غ'), 183)
+(('ف', 'ؤ'), 184)
+(('خ', 'ج'), 184)
+(('<S>', 'c'), 186)
+(('n', 'g'), 187)
+(('؟', '!'), 187)
+(('c', 'e'), 188)
+(('ء', 'ن'), 188)
+(('2', '6'), 189)
+(('ز', 'ُ'), 190)
+(('l', 'i'), 190)
+(('2', '7'), 190)
+(('ِ', 'ق'), 190)
+(('h', 'e'), 193)
+(('ط', 'ٍ'), 193)
+(('ذ', 'ّ'), 194)
+(('ة', '\\'), 195)
+(('o', 'u'), 196)
+(('a', 'c'), 196)
+(('ر', 'ء'), 196)
+(('n', 'e'), 197)
+(('ء', 'َ'), 197)
+(('ّ', 'س'), 199)
+(('ج', 'ِ'), 199)
+(('ش', 'ّ'), 200)
+(('ا', 'َ'), 200)
+(('4', '5'), 201)
+(('ِ', 'ف'), 201)
+(('آ', 'د'), 202)
+(('ث', 'أ'), 202)
+(('A', '<E>'), 202)
+(('<S>', 'F'), 203)
+(('ث', 'ك'), 205)
+(('0', '2'), 205)
+(('د', 'ؤ'), 207)
+(('i', 'c'), 208)
+(('ط', 'د'), 208)
+(('َ', 'ع'), 210)
+(('ب', 'ظ'), 211)
+(('أ', 'َ'), 211)
+(('ط', 'ؤ'), 213)
+(('ه', 'ظ'), 213)
+(('l', 'e'), 213)
+(('ذ', 'ف'), 214)
+(('m', 'e'), 214)
+(('9', '1'), 214)
+(('r', 'o'), 215)
+(('ق', 'ح'), 216)
+(('َ', 'د'), 218)
+(('ب', 'ء'), 218)
+(('ـ', '1'), 219)
+(('a', '<E>'), 220)
+(('ز', 'أ'), 220)
+(('0', '4'), 222)
+(('ط', 'ش'), 224)
+(('!', '!'), 224)
+(('i', 'o'), 226)
+(('i', 's'), 226)
+(('7', '5'), 226)
+(('ّ', 'ز'), 227)
+(('ط', 'غ'), 227)
+(('ص', 'ٍ'), 230)
+(('آ', 'و'), 231)
+(('ْ', '<E>'), 231)
+(('<S>', 'T'), 232)
+(('ن', 'ث'), 233)
+(('ّ', 'ٍ'), 233)
+(('ش', 'آ'), 233)
+(('ي', 'ٌ'), 233)
+(('e', 's'), 234)
+(('r', 'i'), 235)
+(('2', '3'), 235)
+(('ؤ', 'ج'), 236)
+(('ح', 'ح'), 237)
+(('س', 'ٍ'), 241)
+(('،', '<E>'), 242)
+(('ق', 'ٌ'), 245)
+(('.', '،'), 245)
+(('r', 'e'), 246)
+(('9', '2'), 250)
+(('n', 't'), 250)
+(('<S>', 'M'), 251)
+(('<S>', 'N'), 252)
+(('ح', 'ٍ'), 252)
+(('ن', 'ٌ'), 253)
+(('ه', 'ق'), 254)
+(('<S>', 'A'), 254)
+(('ُ', 'ظ'), 254)
+(('ت', 'ّ'), 255)
+(('ث', 'ث'), 256)
+(('ع', 'ّ'), 256)
+(('o', 'r'), 261)
+(('َ', 'ب'), 261)
+(('ِ', 'ي'), 262)
+(('ض', 'ُ'), 265)
+(('ك', 'إ'), 267)
+(('d', '<E>'), 270)
+(('د', 'ش'), 270)
+(('و', '2'), 271)
+(('ي', 'ٍ'), 274)
+(('ض', 'ٍ'), 275)
+(('"', 'ا'), 276)
+(('ح', 'ِ'), 277)
+(('l', '<E>'), 278)
+(('e', 'n'), 279)
+(('و', 'َ'), 281)
+(('r', 'a'), 283)
+(('ا', 'ﻷ'), 284)
+(('a', 'r'), 284)
+(('ح', 'ّ'), 285)
+(('ث', 'ف'), 285)
+(('i', 't'), 287)
+(('ز', 'خ'), 287)
+(('ّ', 'ض'), 288)
+(('0', '7'), 288)
+(('ذ', 'ق'), 289)
+(('ب', 'ؤ'), 291)
+(('آ', 'ف'), 292)
+(('ص', 'ِ'), 293)
+(('ئ', 'ط'), 294)
+(('ف', 'ٌ'), 295)
+(('<S>', 'S'), 296)
+(('ق', 'ك'), 298)
+(('ح', 'َ'), 298)
+(('3', '5'), 300)
+(('r', '<E>'), 304)
+(('<S>', 'C'), 305)
+(('ر', 'آ'), 307)
+(('s', 't'), 311)
+(('ع', 'ٌ'), 312)
+(('ا', 'ُ'), 314)
+(('ف', 'ّ'), 315)
+(('ج', 'ف'), 315)
+(('و', 'ئ'), 317)
+(('َ', 'ا'), 320)
+(('a', 't'), 322)
+(('َ', 'ر'), 327)
+(('ي', 'ى'), 330)
+(('ء', 'ِ'), 331)
+(('ذ', 'م'), 332)
+(('ئ', 'س'), 332)
+(('<S>', 'P'), 333)
+(('ط', 'س'), 333)
+(('ّ', 'ك'), 337)
+(('آ', 'ي'), 337)
+(('ي', 'َ'), 339)
+(('ت', 'آ'), 343)
+(('ص', 'ق'), 344)
+(('إ', 'ك'), 347)
+(('6', '7'), 348)
+(('t', 'e'), 349)
+(('a', 'l'), 350)
+(('ُ', 'ؤ'), 353)
+(('ك', 'ج'), 355)
+(('a', 'n'), 356)
+(('ذ', 'خ'), 357)
+(('y', '<E>'), 359)
+(('0', '9'), 366)
+(('0', '8'), 366)
+(('ط', 'ُ'), 369)
+(('و', 'ُ'), 371)
+(('ج', 'ج'), 373)
+(('n', '<E>'), 379)
+(('ة', 'َ'), 381)
+(('2', '4'), 381)
+(('0', '5'), 382)
+(('t', 'i'), 383)
+(('ط', 'ح'), 384)
+(('َ', 'ّ'), 384)
+(('ؤ', 'ر'), 389)
+(('ك', 'ق'), 389)
+(('غ', 'ف'), 390)
+(('ج', 'ث'), 391)
+(('س', 'ِ'), 391)
+(('<S>', '8'), 392)
+(('i', 'n'), 396)
+(('ض', 'ج'), 397)
+(('4', '8'), 399)
+(('<S>', '9'), 400)
+(('0', '6'), 407)
+(('آ', 'ب'), 413)
+(('إ', 'ه'), 414)
+(('ب', 'ٌ'), 418)
+(('ُ', 'ذ'), 419)
+(('ّ', 'و'), 421)
+(('9', '5'), 422)
+(('َ', 'م'), 424)
+(('ء', 'ٌ'), 425)
+(('ص', 'ُ'), 426)
+(('5', '%'), 427)
+(('ض', 'ِ'), 427)
+(('<S>', '7'), 432)
+(('ء', 'و'), 433)
+(('ّ', 'ى'), 434)
+(('ن', 'ئ'), 437)
+(('ؤ', '<E>'), 442)
+(('ب', 'ـ'), 445)
+(('o', 'n'), 446)
+(('آ', 'ه'), 448)
+(('ذ', 'ُ'), 448)
+(('ق', 'ّ'), 452)
+(('<S>', '6'), 454)
+(('ص', 'ّ'), 454)
+(('خ', 'ه'), 456)
+(('ظ', 'ت'), 465)
+(('ُ', 'ز'), 465)
+(('s', '<E>'), 467)
+(('9', '4'), 474)
+(('م', 'ٌ'), 476)
+(('t', '<E>'), 478)
+(('ص', 'خ'), 478)
+(('ئ', 'ز'), 479)
+(('ز', 'ك'), 482)
+(('د', 'ِ'), 484)
+(('ز', 'ج'), 487)
+(('ز', 'ف'), 491)
+(('1', '8'), 497)
+(('ز', 'ز'), 498)
+(('9', '0'), 508)
+(('أ', 'ى'), 511)
+(('9', '7'), 517)
+(('!', '<E>'), 519)
+(('ء', 'ٍ'), 520)
+(('2', '2'), 522)
+(('ظ', 'ى'), 523)
+(('ف', 'ِ'), 532)
+(('ث', 'ّ'), 534)
+(('ت', 'ئ'), 534)
+(('ن', 'ِ'), 538)
+(('ّ', 'ف'), 543)
+(('e', 'r'), 548)
+(('َ', 'ت'), 556)
+(('خ', 'ة'), 557)
+(('آ', 'ذ'), 569)
+(('ِ', 'م'), 570)
+(('ش', 'ئ'), 571)
+(('<S>', '4'), 572)
+(('ق', 'َ'), 576)
+(('ّ', 'ع'), 591)
+(('ث', 'ُ'), 591)
+(('آ', 'ث'), 593)
+(('ك', 'ح'), 597)
+(('م', 'آ'), 599)
+(('ُ', 'ض'), 599)
+(('ِ', 'ر'), 604)
+(('ُ', 'ث'), 606)
+(('9', '6'), 609)
+(('ّ', 'ب'), 610)
+(('ن', 'ؤ'), 612)
+(('ع', 'َ'), 618)
+(('ب', 'ئ'), 622)
+(('ج', 'ّ'), 624)
+(('ق', 'ٍ'), 628)
+(('خ', 'ز'), 635)
+(('ك', 'ع'), 640)
+(('خ', 'ُ'), 641)
+(('ش', 'ُ'), 642)
+(('ص', 'ت'), 645)
+(('ّ', 'ح'), 648)
+(('ب', 'ِ'), 648)
+(('9', '8'), 656)
+(('س', 'ّ'), 659)
+(('ِ', 'د'), 675)
+(('ز', 'ئ'), 677)
+(('ع', 'ٍ'), 679)
+(('َ', 'ل'), 682)
+(('0', '3'), 686)
+(('ُ', 'غ'), 688)
+(('ذ', 'ة'), 688)
+(('1', '7'), 692)
+(('ع', 'ِ'), 701)
+(('2', '1'), 707)
+(('د', 'ٌ'), 708)
+(('ة', 'ُ'), 709)
+(('<S>', '5'), 719)
+(('ّ', 'ي'), 721)
+(('8', '0'), 724)
+(('ء', 'ل'), 728)
+(('ئ', 'ح'), 729)
+(('ف', 'ُ'), 730)
+(('ف', 'َ'), 731)
+(('د', 'ح'), 735)
+(('1', '6'), 740)
+(('ف', 'ٍ'), 746)
+(('س', 'َ'), 752)
+(('e', '<E>'), 762)
+(('آ', 'ت'), 764)
+(('ب', 'آ'), 769)
+(('آ', 'س'), 769)
+(('ئ', 'ك'), 770)
+(('9', '9'), 771)
+(('ر', 'ِ'), 775)
+(('ل', 'ٌ'), 787)
+(('خ', 'ن'), 792)
+(('7', '0'), 794)
+(('ّ', 'ق'), 801)
+(('ث', 'ه'), 802)
+(('ف', 'خ'), 810)
+(('ؤ', 'ق'), 821)
+(('ت', 'ٌ'), 823)
+(('ج', 'ُ'), 823)
+(('ّ', 'ُ'), 837)
+(('ب', 'ٍ'), 838)
+(('ن', 'ٍ'), 848)
+(('<S>', '3'), 850)
+(('ب', 'ز'), 851)
+(('ب', 'َ'), 852)
+(('أ', 'ؤ'), 859)
+(('7', '<E>'), 860)
+(('ء', 'ه'), 861)
+(('ه', 'ش'), 863)
+(('آ', 'ر'), 864)
+(('ش', 'ى'), 868)
+(('ت', 'َ'), 887)
+(('ؤ', 'ه'), 891)
+(('ف', 'ف'), 919)
+(('ِ', 'ن'), 919)
+(('؛', '<E>'), 923)
+(('9', '<E>'), 927)
+(('س', 'ئ'), 929)
+(('ِ', 'ب'), 929)
+(('ك', 'ِ'), 937)
+(('6', '0'), 943)
+(('ز', 'ق'), 953)
+(('8', '<E>'), 955)
+(('ل', 'ئ'), 956)
+(('ض', 'خ'), 958)
+(('ِ', 'ل'), 959)
+(('د', 'َ'), 961)
+(('ب', 'ّ'), 973)
+(('س', 'خ'), 973)
+(('ّ', 'ن'), 986)
+(('ح', 'ى'), 992)
+(('ظ', 'ف'), 994)
+(('2', '5'), 995)
+(('و', 'آ'), 999)
+(('ك', 'ّ'), 1002)
+(('4', '0'), 1014)
+(('ّ', 'د'), 1022)
+(('ئ', 'و'), 1030)
+(('ج', 'غ'), 1033)
+(('ر', 'َ'), 1034)
+(('ل', 'ِ'), 1041)
+(('ـ', '<E>'), 1058)
+(('ز', 'ح'), 1060)
+(('ّ', 'ِ'), 1078)
+(('<S>', '\\'), 1087)
+(('ُ', 'و'), 1094)
+(('ز', 'ّ'), 1101)
+(('1', '5'), 1118)
+(('ؤ', 'خ'), 1128)
+(('س', 'ى'), 1128)
+(('1', '3'), 1129)
+(('ُ', 'ط'), 1131)
+(('د', 'ُ'), 1132)
+(('ط', 'ى'), 1147)
+(('"', '<E>'), 1158)
+(('غ', 'ذ'), 1159)
+(('ء', 'ً'), 1164)
+(('5', '<E>'), 1166)
+(('6', '<E>'), 1178)
+(('د', 'ء'), 1179)
+(('إ', 'ث'), 1189)
+(('م', 'ٍ'), 1191)
+(('ج', 'أ'), 1194)
+(('ج', 'ذ'), 1198)
+(('غ', 'س'), 1200)
+(('ر', 'ٌ'), 1212)
+(('إ', 'ز'), 1220)
+(('ذ', 'ت'), 1223)
+(('ي', 'ظ'), 1236)
+(('ُ', 'ه'), 1247)
+(('ذ', 'ج'), 1252)
+(('ر', 'ُ'), 1252)
+(('ه', 'ى'), 1253)
+(('إ', 'غ'), 1254)
+(('م', 'ِ'), 1259)
+(('ؤ', 'ش'), 1264)
+(('ه', 'ه'), 1268)
+(('ر', 'خ'), 1273)
+(('ئ', 'ع'), 1276)
+(('ّ', '��'), 1282)
+(('ق', 'ِ'), 1285)
+(('ف', 'ئ'), 1296)
+(('ك', 'ك'), 1302)
+(('ب', 'ُ'), 1321)
+(('ح', 'ط'), 1329)
+(('ح', 'ُ'), 1330)
+(('ط', 'ئ'), 1333)
+(('إ', 'ت'), 1333)
+(('2', '<E>'), 1363)
+(('ّ', 'م'), 1418)
+(('ش', 'ج'), 1424)
+(('ز', 'ت'), 1431)
+(('خ', 'ش'), 1432)
+(('ُ', 'ج'), 1450)
+(('0', '%'), 1457)
+(('1', '4'), 1459)
+(('4', '<E>'), 1463)
+(('غ', 'ن'), 1463)
+(('ط', 'ط'), 1470)
+(('و', 'ّ'), 1480)
+(('ص', 'ى'), 1488)
+(('1', '2'), 1492)
+(('ل', 'ُ'), 1500)
+(('ؤ', 'م'), 1504)
+(('.', '<E>'), 1538)
+(('ز', 'د'), 1542)
+(('ُ', 'ص'), 1549)
+(('ص', 'ص'), 1557)
+(('ا', 'ظ'), 1563)
+(('أ', 'ظ'), 1565)
+(('ف', 'ى'), 1576)
+(('ن', 'ل'), 1588)
+(('ُ', 'ك'), 1606)
+(('ل', 'َ'), 1646)
+(('ش', 'غ'), 1647)
+(('ط', 'أ'), 1649)
+(('3', '0'), 1651)
+(('ق', 'ُ'), 1655)
+(('ح', 'ذ'), 1659)
+(('أ', 'ذ'), 1664)
+(('5', '0'), 1671)
+(('ض', 'ن'), 1686)
+(('ت', 'ِ'), 1689)
+(('ه', 'ض'), 1707)
+(('ع', 'ُ'), 1709)
+(('ُ', 'ف'), 1724)
+(('3', '<E>'), 1728)
+(('ء', 'ة'), 1732)
+(('ب', 'ف'), 1740)
+(('ر', 'ٍ'), 1754)
+(('أ', 'ة'), 1768)
+(('ض', 'ط'), 1778)
+(('<S>', '.'), 1783)
+(('د', 'ٍ'), 1801)
+(('أ', 'ض'), 1809)
+(('ُ', 'خ'), 1813)
+(('ء', 'ت'), 1824)
+(('آ', 'م'), 1833)
+(('ع', 'ذ'), 1841)
+(('ف', 'غ'), 1846)
+(('ص', 'غ'), 1847)
+(('ق', 'ذ'), 1848)
+(('ض', 'ف'), 1848)
+(('ش', 'ؤ'), 1860)
+(('ص', 'ه'), 1862)
+(('ن', 'أ'), 1869)
+(('ئ', 'ق'), 1871)
+(('ض', 'ى'), 1872)
+(('ّ', 'ل'), 1883)
+(('خ', 'ض'), 1884)
+(('ل', 'ـ'), 1886)
+(('ف', 'ز'), 1905)
+(('ا', 'ؤ'), 1914)
+(('غ', 'ض'), 1916)
+(('ش', 'ط'), 1939)
+(('ة', 'ِ'), 1941)
+(('ّ', 'ه'), 1952)
+(('ر', 'ث'), 1957)
+(('ئ', 'ج'), 1969)
+(('ك', 'َ'), 1976)
+(('ط', 'ت'), 1997)
+(('ب', 'ث'), 2000)
+(('ظ', 'ن'), 2002)
+(('ص', 'ط'), 2002)
+(('ط', 'م'), 2014)
+(('ؤ', 'ث'), 2025)
+(('ُ', 'ش'), 2047)
+(('د', 'ئ'), 2061)
+(('ُ', 'ب'), 2062)
+(('ّ', 'ر'), 2072)
+(('ّ', 'ت'), 2073)
+(('ع', 'ى'), 2078)
+(('ف', 'ذ'), 2084)
+(('ب', 'ج'), 2090)
+(('ذ', 'و'), 2091)
+(('1', '1'), 2093)
+(('1', '<E>'), 2093)
+(('ز', 'ه'), 2097)
+(('ش', 'ة'), 2102)
+(('ذ', 'ب'), 2150)
+(('ث', 'ت'), 2150)
+(('م', 'ذ'), 2188)
+(('غ', 'ب'), 2192)
+(('س', 'ُ'), 2193)
+(('إ', 'ف'), 2195)
+(('ه', 'ك'), 2198)
+(('َ', 'ن'), 2204)
+(('خ', 'س'), 2229)
+(('ُ', 'د'), 2247)
+(('ض', 'ت'), 2263)
+(('ح', 'ش'), 2267)
+(('ف', 'م'), 2269)
+(('ؤ', 'د'), 2290)
+(('ع', 'ث'), 2300)
+(('ر', 'ّ'), 2319)
+(('ف', 'ب'), 2320)
+(('ت', 'ة'), 2321)
+(('%', '<E>'), 2329)
+(('ش', 'ح'), 2344)
+(('ف', 'أ'), 2345)
+(('ث', 'ب'), 2352)
+(('\\', '"'), 2371)
+(('غ', 'ت'), 2389)
+(('ك', 'ش'), 2407)
+(('ف', 'د'), 2412)
+(('1', '0'), 2441)
+(('ّ', 'َ'), 2483)
+(('ُ', 'ت'), 2485)
+(('ظ', 'و'), 2558)
+(('ع', 'ج'), 2567)
+(('م', 'أ'), 2576)
+(('ّ', 'ا'), 2591)
+(('ؤ', 'ك'), 2594)
+(('ل', 'ٍ'), 2616)
+(('ئ', 'ن'), 2625)
+(('و', 'ظ'), 2656)
+(('ب', 'خ'), 2659)
+(('م', 'ظ'), 2720)
+(('م', 'ّ'), 2793)
+(('ة', 'ٌ'), 2804)
+(('د', 'ّ'), 2815)
+(('م', 'ئ'), 2839)
+(('ج', 'س'), 2850)
+(('ف', 'ط'), 2898)
+(('ع', 'ص'), 2909)
+(('ّ', 'ة'), 2939)
+(('إ', 'ض'), 2941)
+(('ب', 'ذ'), 2950)
+(('ي', 'غ'), 2969)
+(('أ', 'غ'), 2972)
+(('ع', 'ظ'), 2991)
+(('م', 'ى'), 2993)
+(('ت', 'ؤ'), 3043)
+(('ل', 'ظ'), 3062)
+(('م', 'َ'), 3066)
+(('ك', 'ه'), 3087)
+(('ج', 'ح'), 3127)
+(('ُ', 'ح'), 3144)
+(('ك', 'أ'), 3153)
+(('ن', 'َ'), 3155)
+(('د', 'ب'), 3182)
+(('خ', 'ف'), 3185)
+(('ك', 'ُ'), 3197)
+(('1', '9'), 3255)
+(('ز', 'ن'), 3263)
+(('ر', 'ز'), 3266)
+(('ب', 'ض'), 3284)
+(('س', 'ح'), 3287)
+(('إ', 'ش'), 3325)
+(('ر', 'ؤ'), 3332)
+(('ف', 'ش'), 3361)
+(('ف', 'ح'), 3361)
+(('غ', 'ة'), 3365)
+(('ئ', 'ت'), 3366)
+(('ئ', 'د'), 3420)
+(('ض', 'ب'), 3424)
+(('ت', 'ذ'), 3484)
+(('غ', 'د'), 3495)
+(('ض', 'غ'), 3501)
+(('إ', 'ب'), 3509)
+(('ئ', 'ب'), 3515)
+(('خ', 'م'), 3526)
+(('ئ', '<E>'), 3526)
+(('و', 'ء'), 3530)
+(('ن', 'ُ'), 3545)
+(('ُ', 'ق'), 3567)
+(('ح', 'ه'), 3597)
+(('ت', 'ٍ'), 3604)
+(('م', 'غ'), 3696)
+(('ط', 'ه'), 3758)
+(('ف', 'ج'), 3793)
+(('غ', '<E>'), 3793)
+(('ر', 'ش'), 3816)
+(('ن', 'خ'), 3825)
+(('ق', 'ق'), 3840)
+(('ش', 'ل'), 3852)
+(('غ', 'و'), 3873)
+(('ؤ', 'ي'), 3879)
+(('ش', 'ف'), 3891)
+(('ح', 'ج'), 3920)
+(('أ', 'ُ'), 3926)
+(('ه', 'ز'), 3934)
+(('ج', 'ئ'), 3959)
+(('ض', 'ه'), 3960)
+(('ظ', 'ه'), 3992)
+(('إ', 'ص'), 3995)
+(('ئ', 'ه'), 4048)
+(('ك', 'ف'), 4102)
+(('ح', 'ض'), 4125)
+(('ُ', 'س'), 4184)
+(('ذ', 'ر'), 4271)
+(('ن', 'غ'), 4279)
+(('ت', 'ث'), 4369)
+(('ز', 'ع'), 4381)
+(('<S>', 'ظ'), 4412)
+(('ُ', 'ع'), 4483)
+(('0', '1'), 4485)
+(('ظ', '<E>'), 4517)
+(('غ', 'ط'), 4522)
+(('ب', 'ص'), 4542)
+(('ن', 'ض'), 4546)
+(('م', 'ض'), 4547)
+(('ش', 'أ'), 4569)
+(('ق', 'ش'), 4595)
+(('ه', 'ت'), 4621)
+(('ي', 'ؤ'), 4708)
+(('ه', 'ِ'), 4720)
+(('ُ', 'ل'), 4736)
+(('ش', 'ق'), 4765)
+(('ي', 'أ'), 4776)
+(('ي', 'ذ'), 4835)
+(('ُ', 'م'), 4878)
+(('و', 'ذ'), 4918)
+(('ا', 'غ'), 4919)
+(('ر', 'ل'), 4920)
+(('ق', 'س'), 4940)
+(('ُ', 'ر'), 4994)
+(('ق', 'ى'), 4999)
+(('ح', 'ث'), 5153)
+(('ع', 'ف'), 5226)
+(('آ', 'ل'), 5229)
+(('ث', 'ن'), 5267)
+(('ك', 'د'), 5293)
+(('ق', 'م'), 5297)
+(('ث', 'ة'), 5336)
+(('ف', 'إ'), 5357)
+(('ص', 'م'), 5359)
+(('ز', 'ء'), 5388)
+(('ف', 'ص'), 5454)
+(('غ', 'م'), 5480)
+(('ر', 'ط'), 5481)
+(('ر', 'ص'), 5498)
+(('ت', 'ظ'), 5600)
+(('ل', 'ّ'), 5615)
+(('م', 'ز'), 5625)
+(('ش', 'ن'), 5628)
+(('ؤ', 'ت'), 5652)
+(('<S>', '1'), 5661)
+(('ب', 'غ'), 5667)
+(('ظ', 'ة'), 5721)
+(('0', '<E>'), 5799)
+(('إ', 'ج'), 5801)
+(('د', 'ق'), 5820)
+(('ء', 'ا'), 5857)
+(('ث', 'ق'), 5862)
+(('ك', 'ز'), 5865)
+(('ق', 'ه'), 5884)
+(('ئ', 'ف'), 5895)
+(('و', 'خ'), 5900)
+(('ظ', 'ل'), 5933)
+(('و', 'ش'), 5950)
+(('إ', 'خ'), 5966)
+(('ز', 'ل'), 5971)
+(('إ', 'ح'), 5974)
+(('ع', 'ك'), 5986)
+(('س', 'ج'), 6024)
+(('ز', 'و'), 6031)
+(('ط', 'ف'), 6054)
+(('ط', 'ع'), 6160)
+(('ي', 'ّ'), 6176)
+(('ي', 'ئ'), 6237)
+(('ر', 'ر'), 6295)
+(('و', 'غ'), 6332)
+(('ن', 'ز'), 6372)
+(('ز', 'ر'), 6406)
+(('ُ', 'ن'), 6469)
+(('س', 'ق'), 6501)
+(('ب', 'إ'), 6567)
+(('ه', 'ج'), 6590)
+(('ة', 'ٍ'), 6623)
+(('غ', 'ز'), 6644)
+(('ص', 'ع'), 6654)
+(('ه', 'ؤ'), 6727)
+(('ت', 'ض'), 6768)
+(('و', 'و'), 6778)
+(('ك', 'س'), 6779)
+(('ش', 'د'), 6799)
+(('أ', 'ث'), 6825)
+(('ش', 'م'), 6872)
+(('ح', 'ظ'), 6988)
+(('ت', 'ز'), 7028)
+(('إ', 'ط'), 7082)
+(('ر', 'غ'), 7084)
+(('ض', 'ل'), 7133)
+(('ع', 'ط'), 7211)
+(('ق', 'ن'), 7218)
+(('ش', 'و'), 7225)
+(('ئ', 'ة'), 7237)
+(('ف', 'ن'), 7304)
+(('ف', 'ظ'), 7348)
+(('ش', 'ت'), 7377)
+(('ع', 'ز'), 7394)
+(('خ', 'ذ'), 7444)
+(('ه', 'ب'), 7480)
+(('ؤ', 'س'), 7494)
+(('ه', 'ُ'), 7495)
+(('0', '0'), 7547)
+(('إ', 'م'), 7623)
+(('ئ', 'ا'), 7670)
+(('ن', 'ى'), 7698)
+(('ح', 'ب'), 7739)
+(('غ', 'ل'), 7772)
+(('ض', 'د'), 7784)
+(('س', 'ف'), 7960)
+(('ؤ', 'ا'), 7968)
+(('ش', 'ب'), 8009)
+(('ب', 'ب'), 8034)
+(('ص', 'ن'), 8060)
+(('س', 'س'), 8098)
+(('ؤ', 'ل'), 8136)
+(('ذ', 'ن'), 8179)
+(('إ', 'ق'), 8218)
+(('ي', 'ص'), 8261)
+(('ت', 'ُ'), 8273)
+(('ش', 'خ'), 8274)
+(('ل', 'ز'), 8372)
+(('ح', 'ف'), 8387)
+(('ك', 'ذ'), 8461)
+(('ة', 'ً'), 8543)
+(('س', 'د'), 8544)
+(('ز', 'ة'), 8595)
+(('أ', 'ز'), 8651)
+(('<S>', '2'), 8681)
+(('ئ', 'ر'), 8693)
+(('إ', 'د'), 8811)
+(('ا', 'ة'), 8813)
+(('ي', 'ء'), 8858)
+(('أ', 'د'), 8966)
+(('ذ', 'ك'), 9058)
+(('ن', 'ّ'), 9126)
+(('2', '0'), 9160)
+(('ض', 'م'), 9356)
+(('ن', 'ر'), 9385)
+(('ر', 'م'), 9447)
+(('خ', 'د'), 9479)
+(('ّ', '<E>'), 9557)
+(('ن', 'ك'), 9601)
+(('ؤ', 'و'), 9708)
+(('د', 'أ'), 9736)
+(('د', 'ى'), 9792)
+(('خ', '<E>'), 9804)
+(('ج', 'ع'), 9921)
+(('ئ', 'م'), 9929)
+(('ظ', 'م'), 9998)
+(('ٌ', '<E>'), 10118)
+(('ن', 'ش'), 10201)
+(('ي', 'ز'), 10309)
+(('ن', 'ج'), 10322)
+(('أ', 'ف'), 10380)
+(('م', 'ف'), 10394)
+(('ب', 'ط'), 10669)
+(('د', 'س'), 10679)
+(('ا', 'ث'), 10905)
+(('أ', '<E>'), 10914)
+(('ن', 'ذ'), 10948)
+(('أ', 'ط'), 11118)
+(('ج', 'ة'), 11149)
+(('خ', 'ب'), 11164)
+(('ئ', 'ل'), 11320)
+(('م', 'ط'), 11322)
+(('د', 'ت'), 11332)
+(('ص', 'ة'), 11346)
+(('ف', 'ك'), 11505)
+(('ع', 'ق'), 11530)
+(('ي', 'ُ'), 11621)
+(('ظ', 'ي'), 11625)
+(('إ', 'ر'), 11629)
+(('ع', 'ش'), 11886)
+(('ص', 'ب'), 11901)
+(('ه', 'ة'), 11952)
+(('ض', 'ر'), 12023)
+(('خ', 'و'), 12144)
+(('ُ', '<E>'), 12179)
+(('ض', 'ة'), 12196)
+(('ب', 'س'), 12323)
+(('و', 'ة'), 12328)
+(('ث', 'م'), 12405)
+(('ل', 'ض'), 12444)
+(('ف', 'ض'), 12460)
+(('ض', 'ح'), 12604)
+(('آ', 'خ'), 12607)
+(('<S>', 'ز'), 12793)
+(('س', 'ه'), 12806)
+(('ت', 'غ'), 12851)
+(('خ', 'ص'), 12860)
+(('ح', 'ص'), 12947)
+(('د', 'ل'), 13047)
+(('ق', 'ص'), 13118)
+(('ر', 'أ'), 13137)
+(('س', 'أ'), 13303)
+(('ي', 'ث'), 13464)
+(('أ', 'ش'), 13475)
+(('و', 'ث'), 13560)
+(('ع', 'ه'), 13853)
+(('أ', 'ج'), 13864)
+(('س', 'ؤ'), 14026)
+(('ن', 'م'), 14052)
+(('ِ', '<E>'), 14058)
+(('ز', 'ب'), 14088)
+(('ن', 'ن'), 14177)
+(('ب', 'ك'), 14201)
+(('ن', 'ص'), 14270)
+(('و', 'ى'), 14357)
+(('ص', 'ح'), 14359)
+(('<S>', 'آ'), 14452)
+(('س', 'ع'), 14583)
+(('د', 'ف'), 14603)
+(('َ', '<E>'), 14616)
+(('غ', 'ا'), 14672)
+(('أ', 'ص'), 14751)
+(('د', 'د'), 14762)
+(('م', 'ُ'), 14799)
+(('ص', '<E>'), 14824)
+(('أ', 'ب'), 15010)
+(('أ', 'ه'), 15175)
+(('ح', 'س'), 15188)
+(('ر', 'ع'), 15191)
+(('م', 'خ'), 15210)
+(('<S>', 'ث'), 15459)
+(('د', 'خ'), 15478)
+(('ظ', 'ر'), 15479)
+(('ص', 'د'), 15513)
+(('ز', 'م'), 15569)
+(('د', 'ك'), 15578)
+(('غ', 'ر'), 15620)
+(('ش', 'ه'), 15654)
+(('ص', 'ف'), 15880)
+(('و', 'إ'), 15939)
+(('ت', 'أ'), 16004)
+(('إ', 'ع'), 16144)
+(('س', 'ة'), 16161)
+(('ي', 'خ'), 16323)
+(('ج', 'ز'), 16508)
+(('ج', 'ت'), 16576)
+(('ر', 'ن'), 16688)
+(('ع', 'س'), 16957)
+(('خ', 'ت'), 17025)
+(('ص', 'ي'), 17227)
+(('ف', 'و'), 17520)
+(('ا', 'ش'), 17541)
+(('ح', 'ز'), 17658)
+(('أ', 'ت'), 17679)
+(('ث', 'ا'), 17690)
+(('ي', 'ط'), 17882)
+(('م', 'ب'), 17893)
+(('ض', 'ع'), 18010)
+(('م', 'ؤ'), 18425)
+(('ن', 'ب'), 18431)
+(('و', 'ز'), 18436)
+(('أ', 'ق'), 18459)
+(('و', 'ص'), 18519)
+(('خ', 'ي'), 18533)
+(('ا', 'ز'), 18554)
+(('ط', 'و'), 18604)
+(('ج', 'ب'), 18634)
+(('ك', 'ة'), 18679)
+(('<S>', 'ض'), 18711)
+(('ق', 'ض'), 18858)
+(('م', 'م'), 18993)
+(('ج', 'ن'), 19040)
+(('ل', 'غ'), 19152)
+(('ض', 'و'), 19220)
+(('د', 'ه'), 19424)
+(('ث', 'و'), 19707)
+(('ف', 'س'), 19743)
+(('ف', 'ه'), 19809)
+(('ث', 'ر'), 19933)
+(('ق', 'ع'), 20168)
+(('ر', 'ق'), 20201)
+(('ب', 'ش'), 20332)
+(('ط', 'ب'), 20382)
+(('ط', 'ل'), 20506)
+(('ب', 'ت'), 20624)
+(('و', 'ط'), 20665)
+(('ط', 'ة'), 20720)
+(('خ', 'ط'), 20802)
+(('ت', 'ش'), 20973)
+(('أ', 'ل'), 21143)
+(('ق', 'ف'), 21299)
+(('ا', 'ذ'), 21425)
+(('ع', 'ض'), 21672)
+(('ر', 'س'), 21742)
+(('ه', 'ر'), 21889)
+(('ا', 'خ'), 21946)
+(('د', 'ع'), 21954)
+(('د', 'ن'), 21964)
+(('ر', 'ح'), 21972)
+(('ف', 'ة'), 22072)
+(('ط', 'ن'), 22454)
+(('س', 'ط'), 22558)
+(('ف', 'ل'), 22824)
+(('ك', 'ب'), 22832)
+(('ر', 'د'), 22931)
+(('ط', 'ق'), 23156)
+(('ت', 'ط'), 23284)
+(('و', 'ك'), 23946)
+(('ج', 'ل'), 23987)
+(('ح', 'ن'), 24093)
+(('أ', 'ح'), 24127)
+(('ن', 'ط'), 24371)
+(('م', 'ث'), 24387)
+(('ٍ', '<E>'), 24392)
+(('ز', '<E>'), 24411)
+(('ب', 'ح'), 24711)
+(('ث', 'ل'), 24720)
+(('د', 'ث'), 24840)
+(('ت', 'ى'), 24872)
+(('س', 'ك'), 24881)
+(('إ', 'ي'), 24902)
+(('س', 'ن'), 24904)
+(('ف', 'ت'), 24951)
+(('ت', 'ت'), 25133)
+(('ت', 'د'), 25341)
+(('ب', 'و'), 25868)
+(('ح', 'ة'), 25977)
+(('ف', 'ع'), 26010)
+(('و', 'ح'), 26020)
+(('ص', 'و'), 26136)
+(('ذ', '<E>'), 26231)
+(('إ', 'ذ'), 26290)
+(('ر', 'ى'), 26407)
+(('ب', 'ق'), 26441)
+(('ش', 'ع'), 26695)
+(('ت', 'س'), 26714)
+(('ا', 'ض'), 26759)
+(('ف', 'ق'), 26779)
+(('ق', 'ط'), 26779)
+(('ت', 'ج'), 27226)
+(('ش', '<E>'), 27490)
+(('ي', 'ش'), 27623)
+(('ك', 'ت'), 27644)
+(('ن', 'ة'), 27960)
+(('ل', 'ث'), 28106)
+(('ا', 'ص'), 28260)
+(('ج', 'ر'), 28317)
+(('ن', 'ق'), 28348)
+(('أ', 'ك'), 28705)
+(('ش', 'ي'), 28875)
+(('ز', 'ا'), 28910)
+(('.', '.'), 28976)
+(('أ', 'ع'), 29157)
+(('ز', 'ي'), 29283)
+(('<S>', 'غ'), 29459)
+(('ب', 'أ'), 29538)
+(('أ', 'ر'), 29622)
+(('ر', 'ئ'), 29675)
+(('م', 'ه'), 29689)
+(('ر', 'ت'), 29693)
+(('ف', 'ر'), 29838)
+(('ي', 'ض'), 30040)
+(('ل', 'ص'), 30060)
+(('ج', 'ه'), 30160)
+(('ر', 'ج'), 30238)
+(('ر', 'ض'), 30338)
+(('ن', 'ح'), 30408)
+(('ر', 'ه'), 30469)
+(('ب', 'م'), 30765)
+(('ك', 'ث'), 30772)
+(('ت', 'خ'), 30833)
+(('ه', 'ل'), 31036)
+(('ن', 'ع'), 31572)
+(('غ', 'ي'), 31657)
+(('ح', 'م'), 31773)
+(('م', 'ق'), 31801)
+(('ب', 'ن'), 32221)
+(('ه', 'د'), 32300)
+(('ت', 'ص'), 32328)
+(('ج', '<E>'), 32543)
+(('ع', 'ة'), 32599)
+(('س', 'ر'), 32626)
+(('ث', 'ي'), 32683)
+(('آ', 'ن'), 32829)
+(('ج', 'و'), 32843)
+(('ل', 'ط'), 32919)
+(('ت', 'ك'), 32976)
+(('ظ', 'ا'), 33045)
+(('ض', 'ي'), 33149)
+(('<S>', 'ذ'), 33287)
+(('ب', 'ة'), 33424)
+(('ع', 'و'), 33495)
+(('ن', 'ف'), 33672)
+(('ي', 'ح'), 33786)
+(('س', 'م'), 34067)
+(('ر', 'ف'), 34284)
+(('ت', 'ب'), 34299)
+(('ق', 'ب'), 34340)
+(('ن', 'د'), 34453)
+(('ا', 'ط'), 35083)
+(('ح', 'ك'), 35341)
+(('أ', 'خ'), 35493)
+(('م', 'ص'), 35852)
+(('د', 'ر'), 36168)
+(('م', 'ش'), 36172)
+(('و', 'س'), 36188)
+(('ح', 'ل'), 36471)
+(('ل', 'خ'), 36946)
+(('ذ', 'ل'), 36955)
+(('ي', 'ج'), 37266)
+(('و', 'ض'), 37266)
+(('ت', 'ف'), 37270)
+(('ي', 'ك'), 37422)
+(('ق', 'ت'), 37743)
+(('إ', 'س'), 37850)
+(('س', 'ب'), 38092)
+(('ص', 'ل'), 38111)
+(('ح', 'و'), 38192)
+(('و', 'ف'), 38613)
+(('ا', 'و'), 38644)
+(('و', 'أ'), 38715)
+(('ب', 'ه'), 38825)
+(('ح', 'ق'), 38868)
+(('م', 'د'), 39013)
+(('و', 'ت'), 39136)
+(('ي', 'ف'), 39182)
+(('ل', 'آ'), 39202)
+(('<S>', 'ص'), 39393)
+(('م', 'ج'), 39469)
+(('ج', 'د'), 39745)
+(('خ', 'ر'), 39911)
+(('م', 'ك'), 40078)
+(('ا', 'ج'), 40268)
+(('و', 'ج'), 40320)
+(('ج', 'م'), 40408)
+(('إ', 'ن'), 40466)
+(('ق', 'ل'), 40656)
+(('ش', 'ا'), 40906)
+(('ق', 'ر'), 40919)
+(('خ', 'ا'), 41482)
+(('ش', 'ك'), 41649)
+(('ط', '<E>'), 42320)
+(('و', '<E>'), 42433)
+(('ج', 'ي'), 42534)
+(('ث', '<E>'), 43681)
+(('ذ', 'ي'), 43712)
+(('ص', 'ا'), 43846)
+(('ح', 'ي'), 43908)
+(('ا', 'ه'), 43988)
+(('ن', 'س'), 44469)
+(('ط', 'ر'), 44987)
+(('ت', 'ن'), 45094)
+(('ض', '<E>'), 45379)
+(('ح', 'ر'), 45480)
+(('ت', 'ل'), 45750)
+(('ص', 'ر'), 46081)
+(('ي', 'ي'), 46091)
+(('ش', 'ر'), 46188)
+(('و', 'ه'), 46196)
+(('<S>', 'ط'), 46216)
+(('ا', 'ي'), 46933)
+(('م', 'ح'), 47374)
+(('ي', 'ب'), 47524)
+(('ن', 'و'), 47835)
+(('و', 'ع'), 47875)
+(('ل', 'ر'), 48024)
+(('ط', 'ا'), 48280)
+(('ل', 'ذ'), 48903)
+(('د', 'م'), 49380)
+(('ض', 'ا'), 49679)
+(('ب', 'د'), 50073)
+(('ع', 'ت'), 50729)
+(('ع', 'ب'), 50805)
+(('ط', 'ي'), 51057)
+(('ع', 'ي'), 52209)
+(('ن', 'ظ'), 53133)
+(('<S>', 'خ'), 53365)
+(('ه', 'ي'), 53604)
+(('ج', 'ا'), 53658)
+(('ح', 'ت'), 53841)
+(('أ', 'س'), 54316)
+(('ق', 'ة'), 54342)
+(('ا', 'ح'), 54562)
+(('ك', 'م'), 54906)
+(('ب', 'ل'), 55309)
+(('ئ', 'ي'), 55689)
+(('خ', 'ل'), 56881)
+(('و', 'ي'), 56950)
+(('ي', 'ت'), 57657)
+(('و', 'ق'), 57684)
+(('<S>', 'ش'), 57806)
+(('ت', 'ا'), 57812)
+(('ف', 'ا'), 58040)
+(('ي', 'ه'), 58488)
+(('ي', 'و'), 58570)
+(('ك', 'ر'), 59020)
+(('ا', 'ف'), 59112)
+(('م', 'ت'), 59179)
+(('و', 'د'), 59183)
+(('ر', 'و'), 59594)
+(('ب', 'ر'), 60301)
+(('و', 'ب'), 60340)
+(('ل', 'ش'), 60378)
+(('س', 'ل'), 61565)
+(('ت', 'ع'), 62993)
+(('ح', '<E>'), 63626)
+(('<S>', 'ر'), 64517)
+(('ك', 'ي'), 65122)
+(('أ', 'ي'), 65175)
+(('س', 'و'), 66058)
+(('ه', 'ن'), 66302)
+(('ت', 'ه'), 67130)
+(('ك', 'و'), 67356)
+(('ع', 'م'), 67489)
+(('ت', 'ر'), 67963)
+(('ه', 'و'), 68091)
+(('ق', 'د'), 68346)
+(('ل', 'ج'), 69024)
+(('م', 'س'), 69605)
+(('ي', 'ل'), 70100)
+(('ي', 'ق'), 70752)
+(('ل', 'ف'), 71580)
+(('ق', 'ي'), 72602)
+(('ع', 'ر'), 72634)
+(('ب', 'ع'), 72750)
+(('ا', 'ك'), 72913)
+(('م', 'ة'), 73480)
+(('ع', 'د'), 74875)
+(('د', 'ة'), 75299)
+(('م', 'ر'), 76022)
+(('ل', 'ب'), 76739)
+(('ح', 'ا'), 77321)
+(('م', 'ل'), 77825)
+(('ت', 'و'), 78496)
+(('ت', 'م'), 78718)
+(('ر', 'ك'), 78794)
+(('ك', 'ل'), 79941)
+(('ق', 'و'), 81791)
+(('ا', 'ئ'), 83557)
+(('ر', 'ب'), 83560)
+(('ا', 'ع'), 83722)
+(('ل', 'إ'), 84132)
+(('ي', 'س'), 84224)
+(('<S>', 'ج'), 84599)
+(('ل', 'ه'), 84895)
+(('ك', 'ن'), 84940)
+(('ت', 'ق'), 85161)
+(('<S>', 'د'), 85340)
+(('س', 'ا'), 86745)
+(('ا', 'ق'), 87217)
+(('ح', 'د'), 87927)
+(('ت', 'ي'), 87951)
+(('ت', 'ح'), 89745)
+(('ذ', 'ه'), 90369)
+(('ا', 'ء'), 90648)
+(('ا', 'ب'), 90665)
+(('ه', 'م'), 90771)
+(('أ', 'و'), 90838)
+(('ل', 'ة'), 90953)
+(('م', 'و'), 92022)
+(('أ', 'م'), 92504)
+(('ء', '<E>'), 95712)
+(('إ', 'ل'), 95971)
+(('ن', 'ت'), 96142)
+(('ي', 'م'), 97145)
+(('ر', 'ة'), 97758)
+(('ا', 'د'), 99903)
+(('ن', 'ه'), 100313)
+(('ل', 'ن'), 102168)
+(('د', 'و'), 102497)
+(('س', '<E>'), 105303)
+(('ل', 'د'), 105941)
+(('ك', 'ا'), 107186)
+(('ل', 'و'), 107946)
+(('ق', '<E>'), 108013)
+(('<S>', 'ق'), 108078)
+(('ل', 'ق'), 109826)
+(('ا', 'ً'), 111118)
+(('و', 'م'), 113858)
+(('ي', 'ع'), 114463)
+(('م', 'ي'), 115027)
+(('ق', 'ا'), 115281)
+(('<S>', 'ف'), 116005)
+(('د', 'ا'), 119116)
+(('ي', 'د'), 119543)
+(('ل', 'ل'), 120398)
+(('ً', '<E>'), 121043)
+(('م', 'ع'), 123365)
+(('س', 'ت'), 125455)
+(('ع', 'ا'), 125797)
+(('ف', '<E>'), 126587)
+(('د', 'ي'), 128414)
+(('ا', 'س'), 130671)
+(('ذ', 'ا'), 135404)
+(('ل', 'ع'), 136992)
+(('ع', '<E>'), 138692)
+(('ب', 'ي'), 139421)
+(('ل', 'ح'), 140871)
+(('<S>', 'ح'), 143769)
+(('<S>', 'س'), 145621)
+(('و', 'ن'), 145791)
+(('ك', '<E>'), 145973)
+(('و', 'ر'), 151656)
+(('ع', 'ن'), 152434)
+(('ل', 'ك'), 152840)
+(('<S>', 'ك'), 153311)
+(('ل', 'س'), 159552)
+(('<S>', 'ن'), 159620)
+(('ا', 'م'), 168238)
+(('ه', 'ذ'), 174878)
+(('ب', '<E>'), 178581)
+(('ب', 'ا'), 179758)
+(('ي', 'ر'), 181296)
+(('س', 'ي'), 183088)
+(('ا', 'ر'), 185782)
+(('ه', 'ا'), 191033)
+(('ن', 'ي'), 191744)
+(('ل', 'ى'), 199006)
+(('ل', 'ت'), 199594)
+(('ر', 'ي'), 201186)
+(('<S>', 'إ'), 202492)
+(('ل', 'أ'), 203564)
+(('ع', 'ل'), 206365)
+(('ي', 'ا'), 215250)
+(('ي', 'ن'), 222906)
+(('<S>', 'ه'), 225399)
+(('و', 'ل'), 228429)
+(('ر', 'ا'), 242341)
+(('ا', 'ن'), 255891)
+(('ا', 'ت'), 259781)
+(('ل', 'ي'), 265994)
+(('ن', 'ا'), 266138)
+(('ه', '<E>'), 271383)
+(('<S>', 'ع'), 272858)
+(('أ', 'ن'), 279001)
+(('د', '<E>'), 289189)
+(('و', 'ا'), 293819)
+(('<S>', 'ل'), 299706)
+(('م', 'ا'), 303138)
+(('ى', '<E>'), 305259)
+(('م', 'ن'), 319586)
+(('<S>', 'ت'), 320590)
+(('ي', 'ة'), 329484)
+(('ل', 'ا'), 338940)
+(('<S>', 'ي'), 340253)
+(('م', '<E>'), 345988)
+(('ف', 'ي'), 346841)
+(('ت', '<E>'), 352473)
+(('ر', '<E>'), 360868)
+(('<S>', 'ب'), 361427)
+(('<S>', 'أ'), 376708)
+(('<S>', 'م'), 385040)
+(('ل', '<E>'), 387044)
+(('ل', 'م'), 402476)
+(('ي', '<E>'), 512357)
+(('<S>', 'و'), 588627)
+(('ن', '<E>'), 593836)
+(('ا', '<E>'), 709880)
+(('ة', '<E>'), 1007705)
+(('<S>', 'ا'), 1881650)
+(('ا', 'ل'), 2153155)

check_bnb_install.py

@@ -0,0 +1,20 @@
+import bitsandbytes as bnb
+import torch
+
+p = torch.nn.Parameter(torch.rand(10,10).cuda())
+a = torch.rand(10,10).cuda()
+
+p1 = p.data.sum().item()
+
+adam = bnb.optim.Adam([p])
+
+out = a*p
+loss = out.sum()
+loss.backward()
+adam.step()
+
+p2 = p.data.sum().item()
+
+assert p1 != p2
+print('SUCCESS!')
+print('Installation was successful!')

check_bnb_install.py.1

@@ -0,0 +1,20 @@
+import bitsandbytes as bnb
+import torch
+
+p = torch.nn.Parameter(torch.rand(10,10).cuda())
+a = torch.rand(10,10).cuda()
+
+p1 = p.data.sum().item()
+
+adam = bnb.optim.Adam([p])
+
+out = a*p
+loss = out.sum()
+loss.backward()
+adam.step()
+
+p2 = p.data.sum().item()
+
+assert p1 != p2
+print('SUCCESS!')
+print('Installation was successful!')

config.json

@@ -0,0 +1,41 @@
+{
+  "_name_or_path": "openai/whisper-small",
+  "activation_dropout": 0.0,
+  "activation_function": "gelu",
+  "architectures": [
+    "WhisperForConditionalGeneration"
+  ],
+  "attention_dropout": 0.0,
+  "begin_suppress_tokens": [
+    220,
+    50257
+  ],
+  "bos_token_id": 50257,
+  "d_model": 768,
+  "decoder_attention_heads": 12,
+  "decoder_ffn_dim": 3072,
+  "decoder_layerdrop": 0.0,
+  "decoder_layers": 12,
+  "decoder_start_token_id": 50258,
+  "dropout": 0.0,
+  "encoder_attention_heads": 12,
+  "encoder_ffn_dim": 3072,
+  "encoder_layerdrop": 0.0,
+  "encoder_layers": 12,
+  "eos_token_id": 50257,
+  "forced_decoder_ids": null,
+  "init_std": 0.02,
+  "is_encoder_decoder": true,
+  "max_length": 448,
+  "max_source_positions": 1500,
+  "max_target_positions": 448,
+  "model_type": "whisper",
+  "num_hidden_layers": 12,
+  "num_mel_bins": 80,
+  "pad_token_id": 50257,
+  "scale_embedding": false,
+  "torch_dtype": "float32",
+  "transformers_version": "4.26.0.dev0",
+  "use_cache": false,
+  "vocab_size": 51865
+}

ds_config.json

@@ -0,0 +1,48 @@
+{
+    "fp16": {
+        "enabled": "auto",
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+
+    "optimizer": {
+        "type": "AdamW",
+        "params": {
+            "lr": "auto",
+            "betas": "auto",
+            "eps": "auto",
+            "weight_decay": "auto"
+        }
+    },
+
+    "scheduler": {
+        "type": "WarmupLR",
+        "params": {
+            "warmup_min_lr": "auto",
+            "warmup_max_lr": "auto",
+            "warmup_num_steps": "auto"
+        }
+    },
+
+    "zero_optimization": {
+        "stage": 2,
+        "offload_optimizer": {
+            "device": "cpu",
+            "pin_memory": true
+        },
+        "allgather_partitions": true,
+        "allgather_bucket_size": 2e8,
+        "overlap_comm": true,
+        "reduce_scatter": true,
+        "reduce_bucket_size": 2e8,
+        "contiguous_gradients": true
+    },
+
+    "gradient_accumulation_steps": "auto",
+    "gradient_clipping": "auto",
+    "train_batch_size": "auto",
+    "train_micro_batch_size_per_gpu": "auto"
+}

eval_results.json

@@ -0,0 +1,8 @@
+{
+    "epoch": 1.44,
+    "eval_loss": 0.9784936308860779,
+    "eval_runtime": 1959.8449,
+    "eval_samples_per_second": 2.885,
+    "eval_steps_per_second": 0.361,
+    "eval_wer": 20.95505699346784
+}

evaluate_models.py

@@ -0,0 +1,73 @@
+import torch
+import librosa
+from datasets import load_dataset, Audio
+from transformers import WhisperProcessor, WhisperFeatureExtractor, WhisperTokenizer, WhisperForConditionalGeneration
+from huggingface_hub import login
+import argparse
+from evaluate import load
+
+my_parser = argparse.ArgumentParser()
+# my_parser.add_argument("--pal", "-paths_as_labels", action="store_true")
+
+my_parser.add_argument("--model_name", "-model_name", type=str, action="store", default = "openai/whisper-tiny")
+my_parser.add_argument("--hf_token", "-hf_token", type=str, action="store")
+my_parser.add_argument("--dataset_name", "-dataset_name", type=str, action="store", default = "google/fleurs")
+my_parser.add_argument("--split", "-split", type=str, action="store", default = "test")
+my_parser.add_argument("--subset", "-subset", type=str, action="store")
+
+args = my_parser.parse_args()
+try:
+  login(args.hf_token)
+except:
+  raise(f"Can't login please set --hf_token {args.hf_token}")
+
+
+dataset_name = args.dataset_name 
+model_name = args.model_name
+subset = args.subset
+text_column = "sentence"
+if dataset_name == "google/fleurs":
+  text_column = "transcription"
+  
+print(f"Evaluating {args.model_name} on {args.dataset_name} [{subset}]")
+
+
+feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name)
+model = WhisperForConditionalGeneration.from_pretrained(model_name)
+
+test_dataset = load_dataset(dataset_name, subset, split=args.split, use_auth_token=True)
+processor = WhisperProcessor.from_pretrained(model_name, language="Arabic", task="transcribe")
+tokenizer = WhisperTokenizer.from_pretrained(model_name, language="Arabic", task="transcribe")
+test_dataset = test_dataset.cast_column("audio", Audio(sampling_rate=16000))
+
+# Preprocessing the datasets.
+def prepare_dataset(batch):
+    # load and resample audio data from 48 to 16kHz
+    audio = batch["audio"]
+
+    # compute log-Mel input features from input audio array 
+    batch["input_features"] = feature_extractor(audio["array"], sampling_rate=audio["sampling_rate"]).input_features[0]
+
+    # encode target text to label ids 
+    batch["labels"] = tokenizer(batch[text_column]).input_ids
+    return batch
+
+test_dataset = test_dataset.map(prepare_dataset)
+
+model = model.to("cuda")
+model.config.forced_decoder_ids = processor.get_decoder_prompt_ids(language = "ar", task = "transcribe")
+
+def map_to_result(batch):
+
+  with torch.no_grad():
+    input_values = torch.tensor(batch["input_features"], device="cuda").unsqueeze(0)
+    pred_ids = model.generate(input_values)
+
+  batch["pred_str"] = processor.batch_decode(pred_ids, skip_special_tokens = True)[0]
+  batch["text"] = processor.decode(batch["labels"], skip_special_tokens = True)
+  
+  return batch
+results = test_dataset.map(map_to_result)
+
+wer = load("wer")
+print("Test WER: {:.3f}".format(wer.compute(predictions=results["pred_str"], references=results["text"])))

fine-tune-whisper-non-streaming.ipynb

@@ -0,0 +1,1322 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "75b58048-7d14-4fc6-8085-1fc08c81b4a6",
+   "metadata": {
+    "id": "75b58048-7d14-4fc6-8085-1fc08c81b4a6"
+   },
+   "source": [
+    "# Fine-Tune Whisper For Multilingual ASR with 🤗 Transformers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "adbcd467-b895-4db4-aab7-21a5fa73d1d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'datasets'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-1-ae2b6beea833>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mtyping\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mAny\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mDict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mList\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mOptional\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mUnion\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mdatasets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mtorch\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mdatasets\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mDatasetDict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mIterableDatasetDict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minterleave_datasets\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mload_dataset\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'datasets'"
+     ]
+    }
+   ],
+   "source": [
+    "import logging\n",
+    "import os\n",
+    "import sys\n",
+    "from dataclasses import dataclass, field\n",
+    "from typing import Any, Dict, List, Optional, Union\n",
+    "\n",
+    "import datasets\n",
+    "import torch\n",
+    "from datasets import DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset\n",
+    "from torch.utils.data import IterableDataset\n",
+    "\n",
+    "def load_multiple_streaming_datasets(\n",
+    "    dataset_names: List,\n",
+    "    dataset_config_names: List,\n",
+    "    splits: Optional[List] = None,\n",
+    "    text_column_names: Optional[List] = None,\n",
+    "    sampling_rate: Optional[int] = 16000,\n",
+    "    stopping_strategy: Optional[str] = \"first_exhausted\",\n",
+    "    **kwargs\n",
+    ") -> IterableDataset:\n",
+    "\n",
+    "    if len(dataset_names) != len(dataset_config_names):\n",
+    "        raise ValueError(\n",
+    "            f\"Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and\"\n",
+    "            f\" {len(dataset_config_names)} configs.\"\n",
+    "        )\n",
+    "\n",
+    "    if splits is not None and len(splits) != len(dataset_names):\n",
+    "        raise ValueError(\n",
+    "            f\"Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits.\"\n",
+    "        )\n",
+    "\n",
+    "    if text_column_names is not None and len(text_column_names) != len(dataset_names):\n",
+    "        raise ValueError(\n",
+    "            f\"Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and\"\n",
+    "            f\" {len(text_column_names)} text column names.\"\n",
+    "        )\n",
+    "\n",
+    "    splits = splits if splits is not None else [\"train\" for i in range(len(dataset_names))]\n",
+    "    text_column_names = (\n",
+    "        text_column_names if text_column_names is not None else [\"text\" for i in range(len(dataset_names))]\n",
+    "    )\n",
+    "\n",
+    "    all_datasets = []\n",
+    "    # iterate over the datasets we want to interleave\n",
+    "    for i, dataset_name in enumerate(dataset_names):\n",
+    "        dataset = load_dataset(dataset_name, dataset_config_names[i], split=splits[i], streaming=True, **kwargs)\n",
+    "        # resample to specified sampling rate\n",
+    "        dataset = dataset.cast_column(\"audio\", Audio(sampling_rate))\n",
+    "        #  normalise columns to [\"audio\", \"sentence\"]\n",
+    "        if text_column_names[i] != \"sentence\":\n",
+    "            dataset = dataset.rename_column(text_column_names[i], \"sentence\")\n",
+    "        dataset = dataset.remove_columns(set(dataset.features.keys()) - set([\"audio\", \"sentence\"]))\n",
+    "        all_datasets.append(dataset)\n",
+    "\n",
+    "    interleaved_dataset = interleave_datasets(all_datasets, stopping_strategy=stopping_strategy)\n",
+    "    return interleaved_dataset\n",
+    "\n",
+    "\n",
+    "\n",
+    "dataset_names = [\"mozilla-foundation/common_voice_11_0\", \"arbml/mgb2_speech\", ]\n",
+    "dataset_config_names = [\"ar\", \"ar\", ]\n",
+    "text_column_names = [\"sentence\", \"text\",]\n",
+    "splits = [\"train\",\"train\"]\n",
+    "\n",
+    "ds = load_multiple_streaming_datasets(\n",
+    "        dataset_names,\n",
+    "        dataset_config_names=dataset_config_names,\n",
+    "        text_column_names=text_column_names,\n",
+    "        use_auth_token=True\n",
+    "    )\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "edf35b20-4872-4e14-bc5c-cc4e1a4eec37",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbfa8ad5-4cdc-4512-9058-836cbbf65e1a",
+   "metadata": {
+    "id": "fbfa8ad5-4cdc-4512-9058-836cbbf65e1a"
+   },
+   "source": [
+    "In this Colab, we present a step-by-step guide on how to fine-tune Whisper \n",
+    "for any multilingual ASR dataset using Hugging Face 🤗 Transformers. This is a \n",
+    "more \"hands-on\" version of the accompanying [blog post](https://huggingface.co/blog/fine-tune-whisper). \n",
+    "For a more in-depth explanation of Whisper, the Common Voice dataset and the theory behind fine-tuning, the reader is advised to refer to the blog post."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afe0d503-ae4e-4aa7-9af4-dbcba52db41e",
+   "metadata": {
+    "id": "afe0d503-ae4e-4aa7-9af4-dbcba52db41e"
+   },
+   "source": [
+    "## Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ae91ed4-9c3e-4ade-938e-f4c2dcfbfdc0",
+   "metadata": {
+    "id": "9ae91ed4-9c3e-4ade-938e-f4c2dcfbfdc0"
+   },
+   "source": [
+    "Whisper is a pre-trained model for automatic speech recognition (ASR) \n",
+    "published in [September 2022](https://openai.com/blog/whisper/) by the authors \n",
+    "Alec Radford et al. from OpenAI. Unlike many of its predecessors, such as \n",
+    "[Wav2Vec 2.0](https://arxiv.org/abs/2006.11477), which are pre-trained \n",
+    "on un-labelled audio data, Whisper is pre-trained on a vast quantity of \n",
+    "**labelled** audio-transcription data, 680,000 hours to be precise. \n",
+    "This is an order of magnitude more data than the un-labelled audio data used \n",
+    "to train Wav2Vec 2.0 (60,000 hours). What is more, 117,000 hours of this \n",
+    "pre-training data is multilingual ASR data. This results in checkpoints \n",
+    "that can be applied to over 96 languages, many of which are considered \n",
+    "_low-resource_.\n",
+    "\n",
+    "When scaled to 680,000 hours of labelled pre-training data, Whisper models \n",
+    "demonstrate a strong ability to generalise to many datasets and domains.\n",
+    "The pre-trained checkpoints achieve competitive results to state-of-the-art \n",
+    "ASR systems, with near 3% word error rate (WER) on the test-clean subset of \n",
+    "LibriSpeech ASR and a new state-of-the-art on TED-LIUM with 4.7% WER (_c.f._ \n",
+    "Table 8 of the [Whisper paper](https://cdn.openai.com/papers/whisper.pdf)).\n",
+    "The extensive multilingual ASR knowledge acquired by Whisper during pre-training \n",
+    "can be leveraged for other low-resource languages; through fine-tuning, the \n",
+    "pre-trained checkpoints can be adapted for specific datasets and languages \n",
+    "to further improve upon these results. We'll show just how Whisper can be fine-tuned \n",
+    "for low-resource languages in this Colab."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e59b91d6-be24-4b5e-bb38-4977ea143a72",
+   "metadata": {
+    "id": "e59b91d6-be24-4b5e-bb38-4977ea143a72"
+   },
+   "source": [
+    "<figure>\n",
+    "<img src=\"https://raw.githubusercontent.com/sanchit-gandhi/notebooks/main/whisper_architecture.svg\" alt=\"Trulli\" style=\"width:100%\">\n",
+    "<figcaption align = \"center\"><b>Figure 1:</b> Whisper model. The architecture \n",
+    "follows the standard Transformer-based encoder-decoder model. A \n",
+    "log-Mel spectrogram is input to the encoder. The last encoder \n",
+    "hidden states are input to the decoder via cross-attention mechanisms. The \n",
+    "decoder autoregressively predicts text tokens, jointly conditional on the \n",
+    "encoder hidden states and previously predicted tokens. Figure source: \n",
+    "<a href=\"https://openai.com/blog/whisper/\">OpenAI Whisper Blog</a>.</figcaption>\n",
+    "</figure>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21b6316e-8a55-4549-a154-66d3da2ab74a",
+   "metadata": {
+    "id": "21b6316e-8a55-4549-a154-66d3da2ab74a"
+   },
+   "source": [
+    "The Whisper checkpoints come in five configurations of varying model sizes.\n",
+    "The smallest four are trained on either English-only or multilingual data.\n",
+    "The largest checkpoint is multilingual only. All nine of the pre-trained checkpoints \n",
+    "are available on the [Hugging Face Hub](https://huggingface.co/models?search=openai/whisper). The \n",
+    "checkpoints are summarised in the following table with links to the models on the Hub:\n",
+    "\n",
+    "| Size   | Layers | Width | Heads | Parameters | English-only                                         | Multilingual                                      |\n",
+    "|--------|--------|-------|-------|------------|------------------------------------------------------|---------------------------------------------------|\n",
+    "| tiny   | 4      | 384   | 6     | 39 M       | [✓](https://huggingface.co/openai/whisper-tiny.en)   | [✓](https://huggingface.co/openai/whisper-tiny.)  |\n",
+    "| base   | 6      | 512   | 8     | 74 M       | [✓](https://huggingface.co/openai/whisper-base.en)   | [✓](https://huggingface.co/openai/whisper-base)   |\n",
+    "| small  | 12     | 768   | 12    | 244 M      | [✓](https://huggingface.co/openai/whisper-small.en)  | [✓](https://huggingface.co/openai/whisper-small)  |\n",
+    "| medium | 24     | 1024  | 16    | 769 M      | [✓](https://huggingface.co/openai/whisper-medium.en) | [✓](https://huggingface.co/openai/whisper-medium) |\n",
+    "| large  | 32     | 1280  | 20    | 1550 M     | x                                                    | [✓](https://huggingface.co/openai/whisper-large)  |\n",
+    "\n",
+    "For demonstration purposes, we'll fine-tune the multilingual version of the \n",
+    "[`\"small\"`](https://huggingface.co/openai/whisper-small) checkpoint with 244M params (~= 1GB). \n",
+    "As for our data, we'll train and evaluate our system on a low-resource language \n",
+    "taken from the [Common Voice](https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0)\n",
+    "dataset. We'll show that with as little as 8 hours of fine-tuning data, we can achieve \n",
+    "strong performance in this language."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a680dfc-cbba-4f6c-8a1f-e1a5ff3f123a",
+   "metadata": {
+    "id": "3a680dfc-cbba-4f6c-8a1f-e1a5ff3f123a"
+   },
+   "source": [
+    "------------------------------------------------------------------------\n",
+    "\n",
+    "\\\\({}^1\\\\) The name Whisper follows from the acronym “WSPSR”, which stands for “Web-scale Supervised Pre-training for Speech Recognition”."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b219c9dd-39b6-4a95-b2a1-3f547a1e7bc0",
+   "metadata": {
+    "id": "b219c9dd-39b6-4a95-b2a1-3f547a1e7bc0"
+   },
+   "source": [
+    "## Load Dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "674429c5-0ab4-4adf-975b-621bb69eca38",
+   "metadata": {
+    "id": "674429c5-0ab4-4adf-975b-621bb69eca38"
+   },
+   "source": [
+    "Using 🤗 Datasets, downloading and preparing data is extremely simple. \n",
+    "We can download and prepare the Common Voice splits in just one line of code. \n",
+    "\n",
+    "First, ensure you have accepted the terms of use on the Hugging Face Hub: [mozilla-foundation/common_voice_11_0](https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0). Once you have accepted the terms, you will have full access to the dataset and be able to download the data locally.\n",
+    "\n",
+    "Since Arabic is very low-resource, we'll combine the `train` and `validation` \n",
+    "splits to give approximately 8 hours of training data. We'll use the 4 hours \n",
+    "of `test` data as our held-out test set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5de15d70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_name = \"openai/whisper-small\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2787582-554f-44ce-9f38-4180a5ed6b44",
+   "metadata": {
+    "id": "a2787582-554f-44ce-9f38-4180a5ed6b44"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset, DatasetDict\n",
+    "\n",
+    "common_voice = DatasetDict()\n",
+    "\n",
+    "common_voice[\"train\"] = load_dataset(\"mozilla-foundation/common_voice_11_0\", \"ar\", split=\"train+validation\", use_auth_token=True)\n",
+    "common_voice[\"test\"] = load_dataset(\"mozilla-foundation/common_voice_11_0\", \"ar\", split=\"test\", use_auth_token=True)\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5c7c3d6-7197-41e7-a088-49b753c1681f",
+   "metadata": {
+    "id": "d5c7c3d6-7197-41e7-a088-49b753c1681f"
+   },
+   "source": [
+    "Most ASR datasets only provide input audio samples (`audio`) and the \n",
+    "corresponding transcribed text (`sentence`). Common Voice contains additional \n",
+    "metadata information, such as `accent` and `locale`, which we can disregard for ASR.\n",
+    "Keeping the notebook as general as possible, we only consider the input audio and\n",
+    "transcribed text for fine-tuning, discarding the additional metadata information:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce",
+   "metadata": {
+    "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce"
+   },
+   "outputs": [],
+   "source": [
+    "common_voice = common_voice.remove_columns([\"accent\", \"age\", \"client_id\", \"down_votes\", \"gender\", \"locale\", \"path\", \"segment\", \"up_votes\"])\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605",
+   "metadata": {
+    "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605"
+   },
+   "source": [
+    "## Prepare Feature Extractor, Tokenizer and Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "601c3099-1026-439e-93e2-5635b3ba5a73",
+   "metadata": {
+    "id": "601c3099-1026-439e-93e2-5635b3ba5a73"
+   },
+   "source": [
+    "The ASR pipeline can be de-composed into three stages: \n",
+    "1) A feature extractor which pre-processes the raw audio-inputs\n",
+    "2) The model which performs the sequence-to-sequence mapping \n",
+    "3) A tokenizer which post-processes the model outputs to text format\n",
+    "\n",
+    "In 🤗 Transformers, the Whisper model has an associated feature extractor and tokenizer, \n",
+    "called [WhisperFeatureExtractor](https://huggingface.co/docs/transformers/main/model_doc/whisper#transformers.WhisperFeatureExtractor)\n",
+    "and [WhisperTokenizer](https://huggingface.co/docs/transformers/main/model_doc/whisper#transformers.WhisperTokenizer) \n",
+    "respectively.\n",
+    "\n",
+    "We'll go through details for setting-up the feature extractor and tokenizer one-by-one!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "560332eb-3558-41a1-b500-e83a9f695f84",
+   "metadata": {
+    "id": "560332eb-3558-41a1-b500-e83a9f695f84"
+   },
+   "source": [
+    "### Load WhisperFeatureExtractor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32ec8068-0bd7-412d-b662-0edb9d1e7365",
+   "metadata": {
+    "id": "32ec8068-0bd7-412d-b662-0edb9d1e7365"
+   },
+   "source": [
+    "The Whisper feature extractor performs two operations:\n",
+    "1. Pads / truncates the audio inputs to 30s: any audio inputs shorter than 30s are padded to 30s with silence (zeros), and those longer that 30s are truncated to 30s\n",
+    "2. Converts the audio inputs to _log-Mel spectrogram_ input features, a visual representation of the audio and the form of the input expected by the Whisper model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "589d9ec1-d12b-4b64-93f7-04c63997da19",
+   "metadata": {
+    "id": "589d9ec1-d12b-4b64-93f7-04c63997da19"
+   },
+   "source": [
+    "<figure>\n",
+    "<img src=\"https://raw.githubusercontent.com/sanchit-gandhi/notebooks/main/spectrogram.jpg\" alt=\"Trulli\" style=\"width:100%\">\n",
+    "<figcaption align = \"center\"><b>Figure 2:</b> Conversion of sampled audio array to log-Mel spectrogram.\n",
+    "Left: sampled 1-dimensional audio signal. Right: corresponding log-Mel spectrogram. Figure source:\n",
+    "<a href=\"https://ai.googleblog.com/2019/04/specaugment-new-data-augmentation.html\">Google SpecAugment Blog</a>.\n",
+    "</figcaption>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2ef54d5-b946-4c1d-9fdc-adc5d01b46aa",
+   "metadata": {
+    "id": "b2ef54d5-b946-4c1d-9fdc-adc5d01b46aa"
+   },
+   "source": [
+    "We'll load the feature extractor from the pre-trained checkpoint with the default values:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5",
+   "metadata": {
+    "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperFeatureExtractor\n",
+    "\n",
+    "feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93748af7-b917-4ecf-a0c8-7d89077ff9cb",
+   "metadata": {
+    "id": "93748af7-b917-4ecf-a0c8-7d89077ff9cb"
+   },
+   "source": [
+    "### Load WhisperTokenizer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bc82609-a9fb-447a-a2af-99597c864029",
+   "metadata": {
+    "id": "2bc82609-a9fb-447a-a2af-99597c864029"
+   },
+   "source": [
+    "The Whisper model outputs a sequence of _token ids_. The tokenizer maps each of these token ids to their corresponding text string. For Arabic, we can load the pre-trained tokenizer and use it for fine-tuning without any further modifications. We simply have to \n",
+    "specify the target language and the task. These arguments inform the \n",
+    "tokenizer to prefix the language and task tokens to the start of encoded \n",
+    "label sequences:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+   "metadata": {
+    "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+    "outputId": "5c004b44-86e7-4e00-88be-39e0af5eed69"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "90d056e20b3e4f14ae0199a1a4ab1bb0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/829 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d82a88daec0e4f14add691b7b903064c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/1.04M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "350acdb0f40e454099fa901e66de55f0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/494k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2e6a82a462cc411d90fa1bea4ee60790",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/52.7k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c74bfee0198b4817832ea86e8e88d96c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/2.11k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "04fb2d81eff646068e10475a08ae42f4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/2.06k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from transformers import WhisperTokenizer\n",
+    "\n",
+    "tokenizer = WhisperTokenizer.from_pretrained(\"openai/whisper-small\", language=\"Arabic\", task=\"transcribe\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2ef23f3-f4a8-483a-a2dc-080a7496cb1b",
+   "metadata": {
+    "id": "d2ef23f3-f4a8-483a-a2dc-080a7496cb1b"
+   },
+   "source": [
+    "### Combine To Create A WhisperProcessor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ff67654-5a29-4bb8-a69d-0228946c6f8d",
+   "metadata": {
+    "id": "5ff67654-5a29-4bb8-a69d-0228946c6f8d"
+   },
+   "source": [
+    "To simplify using the feature extractor and tokenizer, we can _wrap_ \n",
+    "both into a single `WhisperProcessor` class. This processor object \n",
+    "inherits from the `WhisperFeatureExtractor` and `WhisperProcessor`, \n",
+    "and can be used on the audio inputs and model predictions as required. \n",
+    "In doing so, we only need to keep track of two objects during training: \n",
+    "the `processor` and the `model`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6",
+   "metadata": {
+    "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperProcessor\n",
+    "\n",
+    "processor = WhisperProcessor.from_pretrained(model_name, language=\"Arabic\", task=\"transcribe\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c",
+   "metadata": {
+    "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c"
+   },
+   "source": [
+    "### Prepare Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9649bf01-2e8a-45e5-8fca-441c13637b8f",
+   "metadata": {
+    "id": "9649bf01-2e8a-45e5-8fca-441c13637b8f"
+   },
+   "source": [
+    "Let's print the first example of the Common Voice dataset to see \n",
+    "what form the data is in:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255",
+   "metadata": {
+    "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255"
+   },
+   "outputs": [],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd",
+   "metadata": {
+    "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd"
+   },
+   "source": [
+    "Since \n",
+    "our input audio is sampled at 48kHz, we need to _downsample_ it to \n",
+    "16kHz prior to passing it to the Whisper feature extractor, 16kHz being the sampling rate expected by the Whisper model. \n",
+    "\n",
+    "We'll set the audio inputs to the correct sampling rate using dataset's \n",
+    "[`cast_column`](https://huggingface.co/docs/datasets/package_reference/main_classes.html?highlight=cast_column#datasets.DatasetDict.cast_column)\n",
+    "method. This operation does not change the audio in-place, \n",
+    "but rather signals to `datasets` to resample audio samples _on the fly_ the \n",
+    "first time that they are loaded:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f12e2e57-156f-417b-8cfb-69221cc198e8",
+   "metadata": {
+    "id": "f12e2e57-156f-417b-8cfb-69221cc198e8"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import Audio\n",
+    "\n",
+    "common_voice = common_voice.cast_column(\"audio\", Audio(sampling_rate=16000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707",
+   "metadata": {
+    "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707"
+   },
+   "source": [
+    "Re-loading the first audio sample in the Common Voice dataset will resample \n",
+    "it to the desired sampling rate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87122d71-289a-466a-afcf-fa354b18946b",
+   "metadata": {
+    "id": "87122d71-289a-466a-afcf-fa354b18946b"
+   },
+   "outputs": [],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3df7378a-a4c0-45d7-8d07-defbd1062ab6",
+   "metadata": {},
+   "source": [
+    "We'll define our pre-processing strategy. We advise that you **do not** lower-case the transcriptions or remove punctuation unless mixing different datasets. This will enable you to fine-tune Whisper models that can predict punctuation and casing. Later, you will see how we can evaluate the predictions without punctuation or casing, so that the models benefit from the WER improvement obtained by normalising the transcriptions while still predicting fully formatted transcriptions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d041650e-1c48-4439-87b3-5b6f4a514107",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers.models.whisper.english_normalizer import BasicTextNormalizer\n",
+    "\n",
+    "do_lower_case = False\n",
+    "do_remove_punctuation = False\n",
+    "\n",
+    "normalizer = BasicTextNormalizer()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89e12c2e-2f14-479b-987b-f0c75c881095",
+   "metadata": {},
+   "source": [
+    "Now we can write a function to prepare our data ready for the model:\n",
+    "1. We load and resample the audio data by calling `batch[\"audio\"]`. As explained above, 🤗 Datasets performs any necessary resampling operations on the fly.\n",
+    "2. We use the feature extractor to compute the log-Mel spectrogram input features from our 1-dimensional audio array.\n",
+    "3. We perform any optional pre-processing (lower-case or remove punctuation).\n",
+    "4. We encode the transcriptions to label ids through the use of the tokenizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c085911c-a10a-41ef-8874-306e0503e9bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def prepare_dataset(batch):\n",
+    "    # load and (possibly) resample audio data to 16kHz\n",
+    "    audio = batch[\"audio\"]\n",
+    "\n",
+    "    # compute log-Mel input features from input audio array \n",
+    "    batch[\"input_features\"] = processor.feature_extractor(audio[\"array\"], sampling_rate=audio[\"sampling_rate\"]).input_features[0]\n",
+    "    # compute input length of audio sample in seconds\n",
+    "    batch[\"input_length\"] = len(audio[\"array\"]) / audio[\"sampling_rate\"]\n",
+    "    \n",
+    "    # optional pre-processing steps\n",
+    "    transcription = batch[\"sentence\"]\n",
+    "    if do_lower_case:\n",
+    "        transcription = transcription.lower()\n",
+    "    if do_remove_punctuation:\n",
+    "        transcription = normalizer(transcription).strip()\n",
+    "    \n",
+    "    # encode target text to label ids\n",
+    "    batch[\"labels\"] = processor.tokenizer(transcription).input_ids\n",
+    "    return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c960965-9fb6-466f-9dbd-c9d43e71d9d0",
+   "metadata": {
+    "id": "70b319fb-2439-4ef6-a70d-a47bf41c4a13"
+   },
+   "source": [
+    "We can apply the data preparation function to all of our training examples using dataset's `.map` method. The argument `num_proc` specifies how many CPU cores to use. Setting `num_proc` > 1 will enable multiprocessing. If the `.map` method hangs with multiprocessing, set `num_proc=1` and process the dataset sequentially."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b",
+   "metadata": {
+    "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b"
+   },
+   "outputs": [],
+   "source": [
+    "common_voice = common_voice.map(prepare_dataset, remove_columns=common_voice.column_names[\"train\"], num_proc=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54ce0fdb-7218-4a4d-b175-383980fec0df",
+   "metadata": {},
+   "source": [
+    "Finally, we filter any training data with audio samples longer than 30s. These samples would otherwise be truncated by the Whisper feature-extractor which could affect the stability of training. We define a function that returns `True` for samples that are less than 30s, and `False` for those that are longer:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "01cb25ef-4bb0-4325-9461-f59198acadf6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "max_input_length = 30.0\n",
+    "\n",
+    "def is_audio_in_length_range(length):\n",
+    "    return length < max_input_length"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30e676a8-7ca8-4850-8c5d-5b2b00d13fba",
+   "metadata": {},
+   "source": [
+    "We apply our filter function to all samples of our training dataset through 🤗 Datasets' `.filter` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "333f7f6e-6053-4d3b-8924-c733c79b82ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "common_voice[\"train\"] = common_voice[\"train\"].filter(\n",
+    "    is_audio_in_length_range,\n",
+    "    input_columns=[\"input_length\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "263a5a58-0239-4a25-b0df-c625fc9c5810",
+   "metadata": {
+    "id": "263a5a58-0239-4a25-b0df-c625fc9c5810"
+   },
+   "source": [
+    "## Training and Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a693e768-c5a6-453f-89a1-b601dcf7daf7",
+   "metadata": {
+    "id": "a693e768-c5a6-453f-89a1-b601dcf7daf7"
+   },
+   "source": [
+    "Now that we've prepared our data, we're ready to dive into the training pipeline. \n",
+    "The [🤗 Trainer](https://huggingface.co/transformers/master/main_classes/trainer.html?highlight=trainer)\n",
+    "will do much of the heavy lifting for us. All we have to do is:\n",
+    "\n",
+    "- Define a data collator: the data collator takes our pre-processed data and prepares PyTorch tensors ready for the model.\n",
+    "\n",
+    "- Evaluation metrics: during evaluation, we want to evaluate the model using the [word error rate (WER)](https://huggingface.co/metrics/wer) metric. We need to define a `compute_metrics` function that handles this computation.\n",
+    "\n",
+    "- Load a pre-trained checkpoint: we need to load a pre-trained checkpoint and configure it correctly for training.\n",
+    "\n",
+    "- Define the training configuration: this will be used by the 🤗 Trainer to define the training schedule.\n",
+    "\n",
+    "Once we've fine-tuned the model, we will evaluate it on the test data to verify that we have correctly trained it \n",
+    "to transcribe speech in Arabic."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d230e6d-624c-400a-bbf5-fa660881df25",
+   "metadata": {
+    "id": "8d230e6d-624c-400a-bbf5-fa660881df25"
+   },
+   "source": [
+    "### Define a Data Collator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04def221-0637-4a69-b242-d3f0c1d0ee78",
+   "metadata": {
+    "id": "04def221-0637-4a69-b242-d3f0c1d0ee78"
+   },
+   "source": [
+    "The data collator for a sequence-to-sequence speech model is unique in the sense that it \n",
+    "treats the `input_features` and `labels` independently: the  `input_features` must be \n",
+    "handled by the feature extractor and the `labels` by the tokenizer.\n",
+    "\n",
+    "The `input_features` are already padded to 30s and converted to a log-Mel spectrogram \n",
+    "of fixed dimension by action of the feature extractor, so all we have to do is convert the `input_features`\n",
+    "to batched PyTorch tensors. We do this using the feature extractor's `.pad` method with `return_tensors=pt`.\n",
+    "\n",
+    "The `labels` on the other hand are un-padded. We first pad the sequences\n",
+    "to the maximum length in the batch using the tokenizer's `.pad` method. The padding tokens \n",
+    "are then replaced by `-100` so that these tokens are **not** taken into account when \n",
+    "computing the loss. We then cut the BOS token from the start of the label sequence as we \n",
+    "append it later during training.\n",
+    "\n",
+    "We can leverage the `WhisperProcessor` we defined earlier to perform both the \n",
+    "feature extractor and the tokenizer operations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5",
+   "metadata": {
+    "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "from dataclasses import dataclass\n",
+    "from typing import Any, Dict, List, Union\n",
+    "\n",
+    "@dataclass\n",
+    "class DataCollatorSpeechSeq2SeqWithPadding:\n",
+    "    processor: Any\n",
+    "\n",
+    "    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n",
+    "        # split inputs and labels since they have to be of different lengths and need different padding methods\n",
+    "        # first treat the audio inputs by simply returning torch tensors\n",
+    "        input_features = [{\"input_features\": feature[\"input_features\"]} for feature in features]\n",
+    "        batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # get the tokenized label sequences\n",
+    "        label_features = [{\"input_ids\": feature[\"labels\"]} for feature in features]\n",
+    "        # pad the labels to max length\n",
+    "        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # replace padding with -100 to ignore loss correctly\n",
+    "        labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n",
+    "\n",
+    "        # if bos token is appended in previous tokenization step,\n",
+    "        # cut bos token here as it's append later anyways\n",
+    "        if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item():\n",
+    "            labels = labels[:, 1:]\n",
+    "\n",
+    "        batch[\"labels\"] = labels\n",
+    "\n",
+    "        return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86",
+   "metadata": {
+    "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86"
+   },
+   "source": [
+    "Let's initialise the data collator we've just defined:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc834702-c0d3-4a96-b101-7b87be32bf42",
+   "metadata": {
+    "id": "fc834702-c0d3-4a96-b101-7b87be32bf42"
+   },
+   "outputs": [],
+   "source": [
+    "data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698",
+   "metadata": {
+    "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698"
+   },
+   "source": [
+    "### Evaluation Metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66fee1a7-a44c-461e-b047-c3917221572e",
+   "metadata": {
+    "id": "66fee1a7-a44c-461e-b047-c3917221572e"
+   },
+   "source": [
+    "We'll use the word error rate (WER) metric, the 'de-facto' metric for assessing \n",
+    "ASR systems. For more information, refer to the WER [docs](https://huggingface.co/metrics/wer). We'll load the WER metric from 🤗 Evaluate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b22b4011-f31f-4b57-b684-c52332f92890",
+   "metadata": {
+    "id": "b22b4011-f31f-4b57-b684-c52332f92890"
+   },
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "\n",
+    "metric = evaluate.load(\"wer\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508",
+   "metadata": {
+    "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508"
+   },
+   "source": [
+    "We then simply have to define a function that takes our model \n",
+    "predictions and returns the WER metric. This function, called\n",
+    "`compute_metrics`, first replaces `-100` with the `pad_token_id`\n",
+    "in the `label_ids` (undoing the step we applied in the \n",
+    "data collator to ignore padded tokens correctly in the loss).\n",
+    "It then decodes the predicted and label ids to strings. Finally,\n",
+    "it computes the WER between the predictions and reference labels. \n",
+    "Here, we have the option of evaluating with the 'normalised' transcriptions \n",
+    "and predictions. We recommend you set this to `True` to benefit from the WER \n",
+    "improvement obtained by normalising the transcriptions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52",
+   "metadata": {
+    "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52"
+   },
+   "outputs": [],
+   "source": [
+    "# evaluate with the 'normalised' WER\n",
+    "do_normalize_eval = True\n",
+    "\n",
+    "def compute_metrics(pred):\n",
+    "    pred_ids = pred.predictions\n",
+    "    label_ids = pred.label_ids\n",
+    "\n",
+    "    # replace -100 with the pad_token_id\n",
+    "    label_ids[label_ids == -100] = processor.tokenizer.pad_token_id\n",
+    "\n",
+    "    # we do not want to group tokens when computing the metrics\n",
+    "    pred_str = processor.tokenizer.batch_decode(pred_ids, skip_special_tokens=True)\n",
+    "    label_str = processor.tokenizer.batch_decode(label_ids, skip_special_tokens=True)\n",
+    "\n",
+    "    if do_normalize_eval:\n",
+    "        pred_str = [normalizer(pred) for pred in pred_str]\n",
+    "        label_str = [normalizer(label) for label in label_str]\n",
+    "\n",
+    "    wer = 100 * metric.compute(predictions=pred_str, references=label_str)\n",
+    "\n",
+    "    return {\"wer\": wer}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "daf2a825-6d9f-4a23-b145-c37c0039075b",
+   "metadata": {
+    "id": "daf2a825-6d9f-4a23-b145-c37c0039075b"
+   },
+   "source": [
+    "### Load a Pre-Trained Checkpoint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "437a97fa-4864-476b-8abc-f28b8166cfa5",
+   "metadata": {
+    "id": "437a97fa-4864-476b-8abc-f28b8166cfa5"
+   },
+   "source": [
+    "Now let's load the pre-trained Whisper `small` checkpoint. Again, this \n",
+    "is trivial through use of 🤗 Transformers!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f",
+   "metadata": {
+    "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperForConditionalGeneration\n",
+    "\n",
+    "model = WhisperForConditionalGeneration.from_pretrained(model_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a15ead5f-2277-4a39-937b-585c2497b2df",
+   "metadata": {
+    "id": "a15ead5f-2277-4a39-937b-585c2497b2df"
+   },
+   "source": [
+    "Override generation arguments - no tokens are forced as decoder outputs (see [`forced_decoder_ids`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.forced_decoder_ids)), no tokens are suppressed during generation (see [`suppress_tokens`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.suppress_tokens)). Set `use_cache` to False since we're using gradient checkpointing, and the two are incompatible:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62038ba3-88ed-4fce-84db-338f50dcd04f",
+   "metadata": {
+    "id": "62038ba3-88ed-4fce-84db-338f50dcd04f"
+   },
+   "outputs": [],
+   "source": [
+    "model.config.forced_decoder_ids = None\n",
+    "model.config.suppress_tokens = []\n",
+    "model.config.use_cache = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06",
+   "metadata": {
+    "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06"
+   },
+   "source": [
+    "### Define the Training Configuration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c21af1e9-0188-4134-ac82-defc7bdcc436",
+   "metadata": {
+    "id": "c21af1e9-0188-4134-ac82-defc7bdcc436"
+   },
+   "source": [
+    "In the final step, we define all the parameters related to training. For more detail on the training arguments, refer to the Seq2SeqTrainingArguments [docs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a",
+   "metadata": {
+    "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainingArguments\n",
+    "\n",
+    "training_args = Seq2SeqTrainingArguments(\n",
+    "    output_dir=\"./\",\n",
+    "    per_device_train_batch_size=64,\n",
+    "    gradient_accumulation_steps=1,  # increase by 2x for every 2x decrease in batch size\n",
+    "    learning_rate=1e-5,\n",
+    "    warmup_steps=500,\n",
+    "    max_steps=5000,\n",
+    "    gradient_checkpointing=True,\n",
+    "    fp16=True,\n",
+    "    evaluation_strategy=\"steps\",\n",
+    "    per_device_eval_batch_size=8,\n",
+    "    predict_with_generate=True,\n",
+    "    generation_max_length=225,\n",
+    "    save_steps=1000,\n",
+    "    eval_steps=1000,\n",
+    "    logging_steps=25,\n",
+    "    report_to=[\"tensorboard\"],\n",
+    "    load_best_model_at_end=True,\n",
+    "    metric_for_best_model=\"wer\",\n",
+    "    greater_is_better=False,\n",
+    "    push_to_hub=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3a944d8-3112-4552-82a0-be25988b3857",
+   "metadata": {
+    "id": "b3a944d8-3112-4552-82a0-be25988b3857"
+   },
+   "source": [
+    "**Note**: if one does not want to upload the model checkpoints to the Hub, \n",
+    "set `push_to_hub=False`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bac29114-d226-4f54-97cf-8718c9f94e1e",
+   "metadata": {
+    "id": "bac29114-d226-4f54-97cf-8718c9f94e1e"
+   },
+   "source": [
+    "We can forward the training arguments to the 🤗 Trainer along with our model,\n",
+    "dataset, data collator and `compute_metrics` function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d546d7fe-0543-479a-b708-2ebabec19493",
+   "metadata": {
+    "id": "d546d7fe-0543-479a-b708-2ebabec19493"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainer\n",
+    "\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    args=training_args,\n",
+    "    model=model,\n",
+    "    train_dataset=common_voice[\"train\"],\n",
+    "    eval_dataset=common_voice[\"test\"],\n",
+    "    data_collator=data_collator,\n",
+    "    compute_metrics=compute_metrics,\n",
+    "    tokenizer=processor.feature_extractor,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "uOrRhDGtN5S4",
+   "metadata": {
+    "id": "uOrRhDGtN5S4"
+   },
+   "source": [
+    "We'll save the processor object once before starting training. Since the processor is not trainable, it won't change over the course of training:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "-2zQwMfEOBJq",
+   "metadata": {
+    "id": "-2zQwMfEOBJq"
+   },
+   "outputs": [],
+   "source": [
+    "processor.save_pretrained(training_args.output_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f404cf9-4345-468c-8196-4bd101d9bd51",
+   "metadata": {
+    "id": "7f404cf9-4345-468c-8196-4bd101d9bd51"
+   },
+   "source": [
+    "### Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e8b8d56-5a70-4f68-bd2e-f0752d0bd112",
+   "metadata": {
+    "id": "5e8b8d56-5a70-4f68-bd2e-f0752d0bd112"
+   },
+   "source": [
+    "Training will take approximately 5-10 hours depending on your GPU. The peak GPU memory for the given training configuration is approximately 36GB. \n",
+    "Depending on your GPU, it is possible that you will encounter a CUDA `\"out-of-memory\"` error when you launch training. \n",
+    "In this case, you can reduce the `per_device_train_batch_size` incrementally by factors of 2 \n",
+    "and employ [`gradient_accumulation_steps`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments.gradient_accumulation_steps)\n",
+    "to compensate.\n",
+    "\n",
+    "To launch training, simply execute:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de",
+   "metadata": {
+    "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de"
+   },
+   "outputs": [],
+   "source": [
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "810ced54-7187-4a06-b2fe-ba6dcca94dc3",
+   "metadata": {
+    "id": "810ced54-7187-4a06-b2fe-ba6dcca94dc3"
+   },
+   "source": [
+    "We can label our checkpoint with the `whisper-event` tag on push by setting the appropriate key-word arguments (kwargs):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c704f91e-241b-48c9-b8e0-f0da396a9663",
+   "metadata": {
+    "id": "c704f91e-241b-48c9-b8e0-f0da396a9663"
+   },
+   "outputs": [],
+   "source": [
+    "kwargs = {\n",
+    "    \"dataset_tags\": \"mozilla-foundation/common_voice_11_0\",\n",
+    "    \"dataset\": \"Common Voice 11.0\",  # a 'pretty' name for the training dataset\n",
+    "    \"language\": \"ar\",\n",
+    "    \"model_name\": \"Whisper Small ar - Zaid Alyafeai\",  # a 'pretty' name for your model\n",
+    "    \"finetuned_from\": model_name,\n",
+    "    \"tasks\": \"automatic-speech-recognition\",\n",
+    "    \"tags\": \"whisper-event\",\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "090d676a-f944-4297-a938-a40eda0b2b68",
+   "metadata": {
+    "id": "090d676a-f944-4297-a938-a40eda0b2b68"
+   },
+   "source": [
+    "The training results can now be uploaded to the Hub. To do so, execute the `push_to_hub` command and save the preprocessor object we created:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d7030622-caf7-4039-939b-6195cdaa2585",
+   "metadata": {
+    "id": "d7030622-caf7-4039-939b-6195cdaa2585"
+   },
+   "outputs": [],
+   "source": [
+    "trainer.push_to_hub(**kwargs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca743fbd-602c-48d4-ba8d-a2fe60af64ba",
+   "metadata": {
+    "id": "ca743fbd-602c-48d4-ba8d-a2fe60af64ba"
+   },
+   "source": [
+    "## Closing Remarks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f737783-2870-4e35-aa11-86a42d7d997a",
+   "metadata": {
+    "id": "7f737783-2870-4e35-aa11-86a42d7d997a"
+   },
+   "source": [
+    "In this blog, we covered a step-by-step guide on fine-tuning Whisper for multilingual ASR \n",
+    "using 🤗 Datasets, Transformers and the Hugging Face Hub. For more details on the Whisper model, the Common Voice dataset and the theory behind fine-tuning, refere to the accompanying [blog post](https://huggingface.co/blog/fine-tune-whisper). If you're interested in fine-tuning other \n",
+    "Transformers models, both for English and multilingual ASR, be sure to check out the \n",
+    "examples scripts at [examples/pytorch/speech-recognition](https://github.com/huggingface/transformers/tree/main/examples/pytorch/speech-recognition)."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "include_colab_link": true,
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.10"
+  },
+  "vscode": {
+   "interpreter": {
+    "hash": "f9f85f796d01129d0dd105a088854619f454435301f6ffec2fea96ecbd9be4ac"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

fine-tune-whisper-non-streaming.ipynb.1

@@ -0,0 +1,1207 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "75b58048-7d14-4fc6-8085-1fc08c81b4a6",
+   "metadata": {
+    "id": "75b58048-7d14-4fc6-8085-1fc08c81b4a6"
+   },
+   "source": [
+    "# Fine-Tune Whisper For Multilingual ASR with 🤗 Transformers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fbfa8ad5-4cdc-4512-9058-836cbbf65e1a",
+   "metadata": {
+    "id": "fbfa8ad5-4cdc-4512-9058-836cbbf65e1a"
+   },
+   "source": [
+    "In this Colab, we present a step-by-step guide on how to fine-tune Whisper \n",
+    "for any multilingual ASR dataset using Hugging Face 🤗 Transformers. This is a \n",
+    "more \"hands-on\" version of the accompanying [blog post](https://huggingface.co/blog/fine-tune-whisper). \n",
+    "For a more in-depth explanation of Whisper, the Common Voice dataset and the theory behind fine-tuning, the reader is advised to refer to the blog post."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afe0d503-ae4e-4aa7-9af4-dbcba52db41e",
+   "metadata": {
+    "id": "afe0d503-ae4e-4aa7-9af4-dbcba52db41e"
+   },
+   "source": [
+    "## Introduction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9ae91ed4-9c3e-4ade-938e-f4c2dcfbfdc0",
+   "metadata": {
+    "id": "9ae91ed4-9c3e-4ade-938e-f4c2dcfbfdc0"
+   },
+   "source": [
+    "Whisper is a pre-trained model for automatic speech recognition (ASR) \n",
+    "published in [September 2022](https://openai.com/blog/whisper/) by the authors \n",
+    "Alec Radford et al. from OpenAI. Unlike many of its predecessors, such as \n",
+    "[Wav2Vec 2.0](https://arxiv.org/abs/2006.11477), which are pre-trained \n",
+    "on un-labelled audio data, Whisper is pre-trained on a vast quantity of \n",
+    "**labelled** audio-transcription data, 680,000 hours to be precise. \n",
+    "This is an order of magnitude more data than the un-labelled audio data used \n",
+    "to train Wav2Vec 2.0 (60,000 hours). What is more, 117,000 hours of this \n",
+    "pre-training data is multilingual ASR data. This results in checkpoints \n",
+    "that can be applied to over 96 languages, many of which are considered \n",
+    "_low-resource_.\n",
+    "\n",
+    "When scaled to 680,000 hours of labelled pre-training data, Whisper models \n",
+    "demonstrate a strong ability to generalise to many datasets and domains.\n",
+    "The pre-trained checkpoints achieve competitive results to state-of-the-art \n",
+    "ASR systems, with near 3% word error rate (WER) on the test-clean subset of \n",
+    "LibriSpeech ASR and a new state-of-the-art on TED-LIUM with 4.7% WER (_c.f._ \n",
+    "Table 8 of the [Whisper paper](https://cdn.openai.com/papers/whisper.pdf)).\n",
+    "The extensive multilingual ASR knowledge acquired by Whisper during pre-training \n",
+    "can be leveraged for other low-resource languages; through fine-tuning, the \n",
+    "pre-trained checkpoints can be adapted for specific datasets and languages \n",
+    "to further improve upon these results. We'll show just how Whisper can be fine-tuned \n",
+    "for low-resource languages in this Colab."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e59b91d6-be24-4b5e-bb38-4977ea143a72",
+   "metadata": {
+    "id": "e59b91d6-be24-4b5e-bb38-4977ea143a72"
+   },
+   "source": [
+    "<figure>\n",
+    "<img src=\"https://raw.githubusercontent.com/sanchit-gandhi/notebooks/main/whisper_architecture.svg\" alt=\"Trulli\" style=\"width:100%\">\n",
+    "<figcaption align = \"center\"><b>Figure 1:</b> Whisper model. The architecture \n",
+    "follows the standard Transformer-based encoder-decoder model. A \n",
+    "log-Mel spectrogram is input to the encoder. The last encoder \n",
+    "hidden states are input to the decoder via cross-attention mechanisms. The \n",
+    "decoder autoregressively predicts text tokens, jointly conditional on the \n",
+    "encoder hidden states and previously predicted tokens. Figure source: \n",
+    "<a href=\"https://openai.com/blog/whisper/\">OpenAI Whisper Blog</a>.</figcaption>\n",
+    "</figure>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21b6316e-8a55-4549-a154-66d3da2ab74a",
+   "metadata": {
+    "id": "21b6316e-8a55-4549-a154-66d3da2ab74a"
+   },
+   "source": [
+    "The Whisper checkpoints come in five configurations of varying model sizes.\n",
+    "The smallest four are trained on either English-only or multilingual data.\n",
+    "The largest checkpoint is multilingual only. All nine of the pre-trained checkpoints \n",
+    "are available on the [Hugging Face Hub](https://huggingface.co/models?search=openai/whisper). The \n",
+    "checkpoints are summarised in the following table with links to the models on the Hub:\n",
+    "\n",
+    "| Size   | Layers | Width | Heads | Parameters | English-only                                         | Multilingual                                      |\n",
+    "|--------|--------|-------|-------|------------|------------------------------------------------------|---------------------------------------------------|\n",
+    "| tiny   | 4      | 384   | 6     | 39 M       | [✓](https://huggingface.co/openai/whisper-tiny.en)   | [✓](https://huggingface.co/openai/whisper-tiny.)  |\n",
+    "| base   | 6      | 512   | 8     | 74 M       | [✓](https://huggingface.co/openai/whisper-base.en)   | [✓](https://huggingface.co/openai/whisper-base)   |\n",
+    "| small  | 12     | 768   | 12    | 244 M      | [✓](https://huggingface.co/openai/whisper-small.en)  | [✓](https://huggingface.co/openai/whisper-small)  |\n",
+    "| medium | 24     | 1024  | 16    | 769 M      | [✓](https://huggingface.co/openai/whisper-medium.en) | [✓](https://huggingface.co/openai/whisper-medium) |\n",
+    "| large  | 32     | 1280  | 20    | 1550 M     | x                                                    | [✓](https://huggingface.co/openai/whisper-large)  |\n",
+    "\n",
+    "For demonstration purposes, we'll fine-tune the multilingual version of the \n",
+    "[`\"small\"`](https://huggingface.co/openai/whisper-small) checkpoint with 244M params (~= 1GB). \n",
+    "As for our data, we'll train and evaluate our system on a low-resource language \n",
+    "taken from the [Common Voice](https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0)\n",
+    "dataset. We'll show that with as little as 8 hours of fine-tuning data, we can achieve \n",
+    "strong performance in this language."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3a680dfc-cbba-4f6c-8a1f-e1a5ff3f123a",
+   "metadata": {
+    "id": "3a680dfc-cbba-4f6c-8a1f-e1a5ff3f123a"
+   },
+   "source": [
+    "------------------------------------------------------------------------\n",
+    "\n",
+    "\\\\({}^1\\\\) The name Whisper follows from the acronym “WSPSR”, which stands for “Web-scale Supervised Pre-training for Speech Recognition”."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b219c9dd-39b6-4a95-b2a1-3f547a1e7bc0",
+   "metadata": {
+    "id": "b219c9dd-39b6-4a95-b2a1-3f547a1e7bc0"
+   },
+   "source": [
+    "## Load Dataset"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "674429c5-0ab4-4adf-975b-621bb69eca38",
+   "metadata": {
+    "id": "674429c5-0ab4-4adf-975b-621bb69eca38"
+   },
+   "source": [
+    "Using 🤗 Datasets, downloading and preparing data is extremely simple. \n",
+    "We can download and prepare the Common Voice splits in just one line of code. \n",
+    "\n",
+    "First, ensure you have accepted the terms of use on the Hugging Face Hub: [mozilla-foundation/common_voice_11_0](https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0). Once you have accepted the terms, you will have full access to the dataset and be able to download the data locally.\n",
+    "\n",
+    "Since Hindi is very low-resource, we'll combine the `train` and `validation` \n",
+    "splits to give approximately 8 hours of training data. We'll use the 4 hours \n",
+    "of `test` data as our held-out test set:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a2787582-554f-44ce-9f38-4180a5ed6b44",
+   "metadata": {
+    "id": "a2787582-554f-44ce-9f38-4180a5ed6b44"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import load_dataset, DatasetDict\n",
+    "\n",
+    "common_voice = DatasetDict()\n",
+    "\n",
+    "common_voice[\"train\"] = load_dataset(\"mozilla-foundation/common_voice_11_0\", \"hi\", split=\"train+validation\", use_auth_token=True)\n",
+    "common_voice[\"test\"] = load_dataset(\"mozilla-foundation/common_voice_11_0\", \"hi\", split=\"test\", use_auth_token=True)\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d5c7c3d6-7197-41e7-a088-49b753c1681f",
+   "metadata": {
+    "id": "d5c7c3d6-7197-41e7-a088-49b753c1681f"
+   },
+   "source": [
+    "Most ASR datasets only provide input audio samples (`audio`) and the \n",
+    "corresponding transcribed text (`sentence`). Common Voice contains additional \n",
+    "metadata information, such as `accent` and `locale`, which we can disregard for ASR.\n",
+    "Keeping the notebook as general as possible, we only consider the input audio and\n",
+    "transcribed text for fine-tuning, discarding the additional metadata information:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce",
+   "metadata": {
+    "id": "20ba635d-518c-47ac-97ee-3cad25f1e0ce"
+   },
+   "outputs": [],
+   "source": [
+    "common_voice = common_voice.remove_columns([\"accent\", \"age\", \"client_id\", \"down_votes\", \"gender\", \"locale\", \"path\", \"segment\", \"up_votes\"])\n",
+    "\n",
+    "print(common_voice)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605",
+   "metadata": {
+    "id": "2d63b2d2-f68a-4d74-b7f1-5127f6d16605"
+   },
+   "source": [
+    "## Prepare Feature Extractor, Tokenizer and Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "601c3099-1026-439e-93e2-5635b3ba5a73",
+   "metadata": {
+    "id": "601c3099-1026-439e-93e2-5635b3ba5a73"
+   },
+   "source": [
+    "The ASR pipeline can be de-composed into three stages: \n",
+    "1) A feature extractor which pre-processes the raw audio-inputs\n",
+    "2) The model which performs the sequence-to-sequence mapping \n",
+    "3) A tokenizer which post-processes the model outputs to text format\n",
+    "\n",
+    "In 🤗 Transformers, the Whisper model has an associated feature extractor and tokenizer, \n",
+    "called [WhisperFeatureExtractor](https://huggingface.co/docs/transformers/main/model_doc/whisper#transformers.WhisperFeatureExtractor)\n",
+    "and [WhisperTokenizer](https://huggingface.co/docs/transformers/main/model_doc/whisper#transformers.WhisperTokenizer) \n",
+    "respectively.\n",
+    "\n",
+    "We'll go through details for setting-up the feature extractor and tokenizer one-by-one!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "560332eb-3558-41a1-b500-e83a9f695f84",
+   "metadata": {
+    "id": "560332eb-3558-41a1-b500-e83a9f695f84"
+   },
+   "source": [
+    "### Load WhisperFeatureExtractor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "32ec8068-0bd7-412d-b662-0edb9d1e7365",
+   "metadata": {
+    "id": "32ec8068-0bd7-412d-b662-0edb9d1e7365"
+   },
+   "source": [
+    "The Whisper feature extractor performs two operations:\n",
+    "1. Pads / truncates the audio inputs to 30s: any audio inputs shorter than 30s are padded to 30s with silence (zeros), and those longer that 30s are truncated to 30s\n",
+    "2. Converts the audio inputs to _log-Mel spectrogram_ input features, a visual representation of the audio and the form of the input expected by the Whisper model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "589d9ec1-d12b-4b64-93f7-04c63997da19",
+   "metadata": {
+    "id": "589d9ec1-d12b-4b64-93f7-04c63997da19"
+   },
+   "source": [
+    "<figure>\n",
+    "<img src=\"https://raw.githubusercontent.com/sanchit-gandhi/notebooks/main/spectrogram.jpg\" alt=\"Trulli\" style=\"width:100%\">\n",
+    "<figcaption align = \"center\"><b>Figure 2:</b> Conversion of sampled audio array to log-Mel spectrogram.\n",
+    "Left: sampled 1-dimensional audio signal. Right: corresponding log-Mel spectrogram. Figure source:\n",
+    "<a href=\"https://ai.googleblog.com/2019/04/specaugment-new-data-augmentation.html\">Google SpecAugment Blog</a>.\n",
+    "</figcaption>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2ef54d5-b946-4c1d-9fdc-adc5d01b46aa",
+   "metadata": {
+    "id": "b2ef54d5-b946-4c1d-9fdc-adc5d01b46aa"
+   },
+   "source": [
+    "We'll load the feature extractor from the pre-trained checkpoint with the default values:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5",
+   "metadata": {
+    "id": "bc77d7bb-f9e2-47f5-b663-30f7a4321ce5"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperFeatureExtractor\n",
+    "\n",
+    "feature_extractor = WhisperFeatureExtractor.from_pretrained(\"openai/whisper-small\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93748af7-b917-4ecf-a0c8-7d89077ff9cb",
+   "metadata": {
+    "id": "93748af7-b917-4ecf-a0c8-7d89077ff9cb"
+   },
+   "source": [
+    "### Load WhisperTokenizer"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2bc82609-a9fb-447a-a2af-99597c864029",
+   "metadata": {
+    "id": "2bc82609-a9fb-447a-a2af-99597c864029"
+   },
+   "source": [
+    "The Whisper model outputs a sequence of _token ids_. The tokenizer maps each of these token ids to their corresponding text string. For Hindi, we can load the pre-trained tokenizer and use it for fine-tuning without any further modifications. We simply have to \n",
+    "specify the target language and the task. These arguments inform the \n",
+    "tokenizer to prefix the language and task tokens to the start of encoded \n",
+    "label sequences:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+   "metadata": {
+    "id": "c7b07f9b-ae0e-4f89-98f0-0c50d432eab6",
+    "outputId": "5c004b44-86e7-4e00-88be-39e0af5eed69"
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "90d056e20b3e4f14ae0199a1a4ab1bb0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/829 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d82a88daec0e4f14add691b7b903064c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/1.04M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "350acdb0f40e454099fa901e66de55f0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/494k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2e6a82a462cc411d90fa1bea4ee60790",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/52.7k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c74bfee0198b4817832ea86e8e88d96c",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/2.11k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "04fb2d81eff646068e10475a08ae42f4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Downloading:   0%|          | 0.00/2.06k [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from transformers import WhisperTokenizer\n",
+    "\n",
+    "tokenizer = WhisperTokenizer.from_pretrained(\"openai/whisper-small\", language=\"Hindi\", task=\"transcribe\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d2ef23f3-f4a8-483a-a2dc-080a7496cb1b",
+   "metadata": {
+    "id": "d2ef23f3-f4a8-483a-a2dc-080a7496cb1b"
+   },
+   "source": [
+    "### Combine To Create A WhisperProcessor"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ff67654-5a29-4bb8-a69d-0228946c6f8d",
+   "metadata": {
+    "id": "5ff67654-5a29-4bb8-a69d-0228946c6f8d"
+   },
+   "source": [
+    "To simplify using the feature extractor and tokenizer, we can _wrap_ \n",
+    "both into a single `WhisperProcessor` class. This processor object \n",
+    "inherits from the `WhisperFeatureExtractor` and `WhisperProcessor`, \n",
+    "and can be used on the audio inputs and model predictions as required. \n",
+    "In doing so, we only need to keep track of two objects during training: \n",
+    "the `processor` and the `model`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6",
+   "metadata": {
+    "id": "77d9f0c5-8607-4642-a8ac-c3ab2e223ea6"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperProcessor\n",
+    "\n",
+    "processor = WhisperProcessor.from_pretrained(\"openai/whisper-small\", language=\"Hindi\", task=\"transcribe\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c",
+   "metadata": {
+    "id": "381acd09-0b0f-4d04-9eb3-f028ac0e5f2c"
+   },
+   "source": [
+    "### Prepare Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9649bf01-2e8a-45e5-8fca-441c13637b8f",
+   "metadata": {
+    "id": "9649bf01-2e8a-45e5-8fca-441c13637b8f"
+   },
+   "source": [
+    "Let's print the first example of the Common Voice dataset to see \n",
+    "what form the data is in:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255",
+   "metadata": {
+    "id": "6e6b0ec5-0c94-4e2c-ae24-c791be1b2255"
+   },
+   "outputs": [],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd",
+   "metadata": {
+    "id": "5a679f05-063d-41b3-9b58-4fc9c6ccf4fd"
+   },
+   "source": [
+    "Since \n",
+    "our input audio is sampled at 48kHz, we need to _downsample_ it to \n",
+    "16kHz prior to passing it to the Whisper feature extractor, 16kHz being the sampling rate expected by the Whisper model. \n",
+    "\n",
+    "We'll set the audio inputs to the correct sampling rate using dataset's \n",
+    "[`cast_column`](https://huggingface.co/docs/datasets/package_reference/main_classes.html?highlight=cast_column#datasets.DatasetDict.cast_column)\n",
+    "method. This operation does not change the audio in-place, \n",
+    "but rather signals to `datasets` to resample audio samples _on the fly_ the \n",
+    "first time that they are loaded:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f12e2e57-156f-417b-8cfb-69221cc198e8",
+   "metadata": {
+    "id": "f12e2e57-156f-417b-8cfb-69221cc198e8"
+   },
+   "outputs": [],
+   "source": [
+    "from datasets import Audio\n",
+    "\n",
+    "common_voice = common_voice.cast_column(\"audio\", Audio(sampling_rate=16000))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707",
+   "metadata": {
+    "id": "00382a3e-abec-4cdd-a54c-d1aaa3ea4707"
+   },
+   "source": [
+    "Re-loading the first audio sample in the Common Voice dataset will resample \n",
+    "it to the desired sampling rate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "87122d71-289a-466a-afcf-fa354b18946b",
+   "metadata": {
+    "id": "87122d71-289a-466a-afcf-fa354b18946b"
+   },
+   "outputs": [],
+   "source": [
+    "print(common_voice[\"train\"][0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3df7378a-a4c0-45d7-8d07-defbd1062ab6",
+   "metadata": {},
+   "source": [
+    "We'll define our pre-processing strategy. We advise that you **do not** lower-case the transcriptions or remove punctuation unless mixing different datasets. This will enable you to fine-tune Whisper models that can predict punctuation and casing. Later, you will see how we can evaluate the predictions without punctuation or casing, so that the models benefit from the WER improvement obtained by normalising the transcriptions while still predicting fully formatted transcriptions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d041650e-1c48-4439-87b3-5b6f4a514107",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from transformers.models.whisper.english_normalizer import BasicTextNormalizer\n",
+    "\n",
+    "do_lower_case = False\n",
+    "do_remove_punctuation = False\n",
+    "\n",
+    "normalizer = BasicTextNormalizer()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "89e12c2e-2f14-479b-987b-f0c75c881095",
+   "metadata": {},
+   "source": [
+    "Now we can write a function to prepare our data ready for the model:\n",
+    "1. We load and resample the audio data by calling `batch[\"audio\"]`. As explained above, 🤗 Datasets performs any necessary resampling operations on the fly.\n",
+    "2. We use the feature extractor to compute the log-Mel spectrogram input features from our 1-dimensional audio array.\n",
+    "3. We perform any optional pre-processing (lower-case or remove punctuation).\n",
+    "4. We encode the transcriptions to label ids through the use of the tokenizer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c085911c-a10a-41ef-8874-306e0503e9bb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def prepare_dataset(batch):\n",
+    "    # load and (possibly) resample audio data to 16kHz\n",
+    "    audio = batch[\"audio\"]\n",
+    "\n",
+    "    # compute log-Mel input features from input audio array \n",
+    "    batch[\"input_features\"] = processor.feature_extractor(audio[\"array\"], sampling_rate=audio[\"sampling_rate\"]).input_features[0]\n",
+    "    # compute input length of audio sample in seconds\n",
+    "    batch[\"input_length\"] = len(audio[\"array\"]) / audio[\"sampling_rate\"]\n",
+    "    \n",
+    "    # optional pre-processing steps\n",
+    "    transcription = batch[\"sentence\"]\n",
+    "    if do_lower_case:\n",
+    "        transcription = transcription.lower()\n",
+    "    if do_remove_punctuation:\n",
+    "        transcription = normalizer(transcription).strip()\n",
+    "    \n",
+    "    # encode target text to label ids\n",
+    "    batch[\"labels\"] = processor.tokenizer(transcription).input_ids\n",
+    "    return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c960965-9fb6-466f-9dbd-c9d43e71d9d0",
+   "metadata": {
+    "id": "70b319fb-2439-4ef6-a70d-a47bf41c4a13"
+   },
+   "source": [
+    "We can apply the data preparation function to all of our training examples using dataset's `.map` method. The argument `num_proc` specifies how many CPU cores to use. Setting `num_proc` > 1 will enable multiprocessing. If the `.map` method hangs with multiprocessing, set `num_proc=1` and process the dataset sequentially."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b",
+   "metadata": {
+    "id": "7b73ab39-ffaf-4b9e-86e5-782963c6134b"
+   },
+   "outputs": [],
+   "source": [
+    "common_voice = common_voice.map(prepare_dataset, remove_columns=common_voice.column_names[\"train\"], num_proc=2)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "54ce0fdb-7218-4a4d-b175-383980fec0df",
+   "metadata": {},
+   "source": [
+    "Finally, we filter any training data with audio samples longer than 30s. These samples would otherwise be truncated by the Whisper feature-extractor which could affect the stability of training. We define a function that returns `True` for samples that are less than 30s, and `False` for those that are longer:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "01cb25ef-4bb0-4325-9461-f59198acadf6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "max_input_length = 30.0\n",
+    "\n",
+    "def is_audio_in_length_range(length):\n",
+    "    return length < max_input_length"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "30e676a8-7ca8-4850-8c5d-5b2b00d13fba",
+   "metadata": {},
+   "source": [
+    "We apply our filter function to all samples of our training dataset through 🤗 Datasets' `.filter` method:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "333f7f6e-6053-4d3b-8924-c733c79b82ac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "common_voice[\"train\"] = common_voice[\"train\"].filter(\n",
+    "    is_audio_in_length_range,\n",
+    "    input_columns=[\"input_length\"],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "263a5a58-0239-4a25-b0df-c625fc9c5810",
+   "metadata": {
+    "id": "263a5a58-0239-4a25-b0df-c625fc9c5810"
+   },
+   "source": [
+    "## Training and Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a693e768-c5a6-453f-89a1-b601dcf7daf7",
+   "metadata": {
+    "id": "a693e768-c5a6-453f-89a1-b601dcf7daf7"
+   },
+   "source": [
+    "Now that we've prepared our data, we're ready to dive into the training pipeline. \n",
+    "The [🤗 Trainer](https://huggingface.co/transformers/master/main_classes/trainer.html?highlight=trainer)\n",
+    "will do much of the heavy lifting for us. All we have to do is:\n",
+    "\n",
+    "- Define a data collator: the data collator takes our pre-processed data and prepares PyTorch tensors ready for the model.\n",
+    "\n",
+    "- Evaluation metrics: during evaluation, we want to evaluate the model using the [word error rate (WER)](https://huggingface.co/metrics/wer) metric. We need to define a `compute_metrics` function that handles this computation.\n",
+    "\n",
+    "- Load a pre-trained checkpoint: we need to load a pre-trained checkpoint and configure it correctly for training.\n",
+    "\n",
+    "- Define the training configuration: this will be used by the 🤗 Trainer to define the training schedule.\n",
+    "\n",
+    "Once we've fine-tuned the model, we will evaluate it on the test data to verify that we have correctly trained it \n",
+    "to transcribe speech in Hindi."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8d230e6d-624c-400a-bbf5-fa660881df25",
+   "metadata": {
+    "id": "8d230e6d-624c-400a-bbf5-fa660881df25"
+   },
+   "source": [
+    "### Define a Data Collator"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04def221-0637-4a69-b242-d3f0c1d0ee78",
+   "metadata": {
+    "id": "04def221-0637-4a69-b242-d3f0c1d0ee78"
+   },
+   "source": [
+    "The data collator for a sequence-to-sequence speech model is unique in the sense that it \n",
+    "treats the `input_features` and `labels` independently: the  `input_features` must be \n",
+    "handled by the feature extractor and the `labels` by the tokenizer.\n",
+    "\n",
+    "The `input_features` are already padded to 30s and converted to a log-Mel spectrogram \n",
+    "of fixed dimension by action of the feature extractor, so all we have to do is convert the `input_features`\n",
+    "to batched PyTorch tensors. We do this using the feature extractor's `.pad` method with `return_tensors=pt`.\n",
+    "\n",
+    "The `labels` on the other hand are un-padded. We first pad the sequences\n",
+    "to the maximum length in the batch using the tokenizer's `.pad` method. The padding tokens \n",
+    "are then replaced by `-100` so that these tokens are **not** taken into account when \n",
+    "computing the loss. We then cut the BOS token from the start of the label sequence as we \n",
+    "append it later during training.\n",
+    "\n",
+    "We can leverage the `WhisperProcessor` we defined earlier to perform both the \n",
+    "feature extractor and the tokenizer operations:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5",
+   "metadata": {
+    "id": "8326221e-ec13-4731-bb4e-51e5fc1486c5"
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "\n",
+    "from dataclasses import dataclass\n",
+    "from typing import Any, Dict, List, Union\n",
+    "\n",
+    "@dataclass\n",
+    "class DataCollatorSpeechSeq2SeqWithPadding:\n",
+    "    processor: Any\n",
+    "\n",
+    "    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n",
+    "        # split inputs and labels since they have to be of different lengths and need different padding methods\n",
+    "        # first treat the audio inputs by simply returning torch tensors\n",
+    "        input_features = [{\"input_features\": feature[\"input_features\"]} for feature in features]\n",
+    "        batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # get the tokenized label sequences\n",
+    "        label_features = [{\"input_ids\": feature[\"labels\"]} for feature in features]\n",
+    "        # pad the labels to max length\n",
+    "        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        # replace padding with -100 to ignore loss correctly\n",
+    "        labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n",
+    "\n",
+    "        # if bos token is appended in previous tokenization step,\n",
+    "        # cut bos token here as it's append later anyways\n",
+    "        if (labels[:, 0] == self.processor.tokenizer.bos_token_id).all().cpu().item():\n",
+    "            labels = labels[:, 1:]\n",
+    "\n",
+    "        batch[\"labels\"] = labels\n",
+    "\n",
+    "        return batch"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86",
+   "metadata": {
+    "id": "3cae7dbf-8a50-456e-a3a8-7fd005390f86"
+   },
+   "source": [
+    "Let's initialise the data collator we've just defined:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fc834702-c0d3-4a96-b101-7b87be32bf42",
+   "metadata": {
+    "id": "fc834702-c0d3-4a96-b101-7b87be32bf42"
+   },
+   "outputs": [],
+   "source": [
+    "data_collator = DataCollatorSpeechSeq2SeqWithPadding(processor=processor)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698",
+   "metadata": {
+    "id": "d62bb2ab-750a-45e7-82e9-61d6f4805698"
+   },
+   "source": [
+    "### Evaluation Metrics"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "66fee1a7-a44c-461e-b047-c3917221572e",
+   "metadata": {
+    "id": "66fee1a7-a44c-461e-b047-c3917221572e"
+   },
+   "source": [
+    "We'll use the word error rate (WER) metric, the 'de-facto' metric for assessing \n",
+    "ASR systems. For more information, refer to the WER [docs](https://huggingface.co/metrics/wer). We'll load the WER metric from 🤗 Evaluate:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b22b4011-f31f-4b57-b684-c52332f92890",
+   "metadata": {
+    "id": "b22b4011-f31f-4b57-b684-c52332f92890"
+   },
+   "outputs": [],
+   "source": [
+    "import evaluate\n",
+    "\n",
+    "metric = evaluate.load(\"wer\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508",
+   "metadata": {
+    "id": "4f32cab6-31f0-4cb9-af4c-40ba0f5fc508"
+   },
+   "source": [
+    "We then simply have to define a function that takes our model \n",
+    "predictions and returns the WER metric. This function, called\n",
+    "`compute_metrics`, first replaces `-100` with the `pad_token_id`\n",
+    "in the `label_ids` (undoing the step we applied in the \n",
+    "data collator to ignore padded tokens correctly in the loss).\n",
+    "It then decodes the predicted and label ids to strings. Finally,\n",
+    "it computes the WER between the predictions and reference labels. \n",
+    "Here, we have the option of evaluating with the 'normalised' transcriptions \n",
+    "and predictions. We recommend you set this to `True` to benefit from the WER \n",
+    "improvement obtained by normalising the transcriptions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52",
+   "metadata": {
+    "id": "23959a70-22d0-4ffe-9fa1-72b61e75bb52"
+   },
+   "outputs": [],
+   "source": [
+    "# evaluate with the 'normalised' WER\n",
+    "do_normalize_eval = True\n",
+    "\n",
+    "def compute_metrics(pred):\n",
+    "    pred_ids = pred.predictions\n",
+    "    label_ids = pred.label_ids\n",
+    "\n",
+    "    # replace -100 with the pad_token_id\n",
+    "    label_ids[label_ids == -100] = processor.tokenizer.pad_token_id\n",
+    "\n",
+    "    # we do not want to group tokens when computing the metrics\n",
+    "    pred_str = processor.tokenizer.batch_decode(pred_ids, skip_special_tokens=True)\n",
+    "    label_str = processor.tokenizer.batch_decode(label_ids, skip_special_tokens=True)\n",
+    "\n",
+    "    if do_normalize_eval:\n",
+    "        pred_str = [normalizer(pred) for pred in pred_str]\n",
+    "        label_str = [normalizer(label) for label in label_str]\n",
+    "\n",
+    "    wer = 100 * metric.compute(predictions=pred_str, references=label_str)\n",
+    "\n",
+    "    return {\"wer\": wer}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "daf2a825-6d9f-4a23-b145-c37c0039075b",
+   "metadata": {
+    "id": "daf2a825-6d9f-4a23-b145-c37c0039075b"
+   },
+   "source": [
+    "### Load a Pre-Trained Checkpoint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "437a97fa-4864-476b-8abc-f28b8166cfa5",
+   "metadata": {
+    "id": "437a97fa-4864-476b-8abc-f28b8166cfa5"
+   },
+   "source": [
+    "Now let's load the pre-trained Whisper `small` checkpoint. Again, this \n",
+    "is trivial through use of 🤗 Transformers!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f",
+   "metadata": {
+    "id": "5a10cc4b-07ec-4ebd-ac1d-7c601023594f"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import WhisperForConditionalGeneration\n",
+    "\n",
+    "model = WhisperForConditionalGeneration.from_pretrained(\"openai/whisper-small\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a15ead5f-2277-4a39-937b-585c2497b2df",
+   "metadata": {
+    "id": "a15ead5f-2277-4a39-937b-585c2497b2df"
+   },
+   "source": [
+    "Override generation arguments - no tokens are forced as decoder outputs (see [`forced_decoder_ids`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.forced_decoder_ids)), no tokens are suppressed during generation (see [`suppress_tokens`](https://huggingface.co/docs/transformers/main_classes/text_generation#transformers.generation_utils.GenerationMixin.generate.suppress_tokens)). Set `use_cache` to False since we're using gradient checkpointing, and the two are incompatible:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62038ba3-88ed-4fce-84db-338f50dcd04f",
+   "metadata": {
+    "id": "62038ba3-88ed-4fce-84db-338f50dcd04f"
+   },
+   "outputs": [],
+   "source": [
+    "model.config.forced_decoder_ids = None\n",
+    "model.config.suppress_tokens = []\n",
+    "model.config.use_cache = False"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06",
+   "metadata": {
+    "id": "2178dea4-80ca-47b6-b6ea-ba1915c90c06"
+   },
+   "source": [
+    "### Define the Training Configuration"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c21af1e9-0188-4134-ac82-defc7bdcc436",
+   "metadata": {
+    "id": "c21af1e9-0188-4134-ac82-defc7bdcc436"
+   },
+   "source": [
+    "In the final step, we define all the parameters related to training. For more detail on the training arguments, refer to the Seq2SeqTrainingArguments [docs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a",
+   "metadata": {
+    "id": "0ae3e9af-97b7-4aa0-ae85-20b23b5bcb3a"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainingArguments\n",
+    "\n",
+    "training_args = Seq2SeqTrainingArguments(\n",
+    "    output_dir=\"./\",\n",
+    "    per_device_train_batch_size=64,\n",
+    "    gradient_accumulation_steps=1,  # increase by 2x for every 2x decrease in batch size\n",
+    "    learning_rate=1e-5,\n",
+    "    warmup_steps=500,\n",
+    "    max_steps=5000,\n",
+    "    gradient_checkpointing=True,\n",
+    "    fp16=True,\n",
+    "    evaluation_strategy=\"steps\",\n",
+    "    per_device_eval_batch_size=8,\n",
+    "    predict_with_generate=True,\n",
+    "    generation_max_length=225,\n",
+    "    save_steps=1000,\n",
+    "    eval_steps=1000,\n",
+    "    logging_steps=25,\n",
+    "    report_to=[\"tensorboard\"],\n",
+    "    load_best_model_at_end=True,\n",
+    "    metric_for_best_model=\"wer\",\n",
+    "    greater_is_better=False,\n",
+    "    push_to_hub=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b3a944d8-3112-4552-82a0-be25988b3857",
+   "metadata": {
+    "id": "b3a944d8-3112-4552-82a0-be25988b3857"
+   },
+   "source": [
+    "**Note**: if one does not want to upload the model checkpoints to the Hub, \n",
+    "set `push_to_hub=False`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bac29114-d226-4f54-97cf-8718c9f94e1e",
+   "metadata": {
+    "id": "bac29114-d226-4f54-97cf-8718c9f94e1e"
+   },
+   "source": [
+    "We can forward the training arguments to the 🤗 Trainer along with our model,\n",
+    "dataset, data collator and `compute_metrics` function:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d546d7fe-0543-479a-b708-2ebabec19493",
+   "metadata": {
+    "id": "d546d7fe-0543-479a-b708-2ebabec19493"
+   },
+   "outputs": [],
+   "source": [
+    "from transformers import Seq2SeqTrainer\n",
+    "\n",
+    "trainer = Seq2SeqTrainer(\n",
+    "    args=training_args,\n",
+    "    model=model,\n",
+    "    train_dataset=common_voice[\"train\"],\n",
+    "    eval_dataset=common_voice[\"test\"],\n",
+    "    data_collator=data_collator,\n",
+    "    compute_metrics=compute_metrics,\n",
+    "    tokenizer=processor.feature_extractor,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "uOrRhDGtN5S4",
+   "metadata": {
+    "id": "uOrRhDGtN5S4"
+   },
+   "source": [
+    "We'll save the processor object once before starting training. Since the processor is not trainable, it won't change over the course of training:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "-2zQwMfEOBJq",
+   "metadata": {
+    "id": "-2zQwMfEOBJq"
+   },
+   "outputs": [],
+   "source": [
+    "processor.save_pretrained(training_args.output_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f404cf9-4345-468c-8196-4bd101d9bd51",
+   "metadata": {
+    "id": "7f404cf9-4345-468c-8196-4bd101d9bd51"
+   },
+   "source": [
+    "### Training"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5e8b8d56-5a70-4f68-bd2e-f0752d0bd112",
+   "metadata": {
+    "id": "5e8b8d56-5a70-4f68-bd2e-f0752d0bd112"
+   },
+   "source": [
+    "Training will take approximately 5-10 hours depending on your GPU. The peak GPU memory for the given training configuration is approximately 36GB. \n",
+    "Depending on your GPU, it is possible that you will encounter a CUDA `\"out-of-memory\"` error when you launch training. \n",
+    "In this case, you can reduce the `per_device_train_batch_size` incrementally by factors of 2 \n",
+    "and employ [`gradient_accumulation_steps`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.Seq2SeqTrainingArguments.gradient_accumulation_steps)\n",
+    "to compensate.\n",
+    "\n",
+    "To launch training, simply execute:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de",
+   "metadata": {
+    "id": "ee8b7b8e-1c9a-4d77-9137-1778a629e6de"
+   },
+   "outputs": [],
+   "source": [
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "810ced54-7187-4a06-b2fe-ba6dcca94dc3",
+   "metadata": {
+    "id": "810ced54-7187-4a06-b2fe-ba6dcca94dc3"
+   },
+   "source": [
+    "We can label our checkpoint with the `whisper-event` tag on push by setting the appropriate key-word arguments (kwargs):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c704f91e-241b-48c9-b8e0-f0da396a9663",
+   "metadata": {
+    "id": "c704f91e-241b-48c9-b8e0-f0da396a9663"
+   },
+   "outputs": [],
+   "source": [
+    "kwargs = {\n",
+    "    \"dataset_tags\": \"mozilla-foundation/common_voice_11_0\",\n",
+    "    \"dataset\": \"Common Voice 11.0\",  # a 'pretty' name for the training dataset\n",
+    "    \"language\": \"hi\",\n",
+    "    \"model_name\": \"Whisper Small Hi - Sanchit Gandhi\",  # a 'pretty' name for your model\n",
+    "    \"finetuned_from\": \"openai/whisper-small\",\n",
+    "    \"tasks\": \"automatic-speech-recognition\",\n",
+    "    \"tags\": \"whisper-event\",\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "090d676a-f944-4297-a938-a40eda0b2b68",
+   "metadata": {
+    "id": "090d676a-f944-4297-a938-a40eda0b2b68"
+   },
+   "source": [
+    "The training results can now be uploaded to the Hub. To do so, execute the `push_to_hub` command and save the preprocessor object we created:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d7030622-caf7-4039-939b-6195cdaa2585",
+   "metadata": {
+    "id": "d7030622-caf7-4039-939b-6195cdaa2585"
+   },
+   "outputs": [],
+   "source": [
+    "trainer.push_to_hub(**kwargs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ca743fbd-602c-48d4-ba8d-a2fe60af64ba",
+   "metadata": {
+    "id": "ca743fbd-602c-48d4-ba8d-a2fe60af64ba"
+   },
+   "source": [
+    "## Closing Remarks"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7f737783-2870-4e35-aa11-86a42d7d997a",
+   "metadata": {
+    "id": "7f737783-2870-4e35-aa11-86a42d7d997a"
+   },
+   "source": [
+    "In this blog, we covered a step-by-step guide on fine-tuning Whisper for multilingual ASR \n",
+    "using 🤗 Datasets, Transformers and the Hugging Face Hub. For more details on the Whisper model, the Common Voice dataset and the theory behind fine-tuning, refere to the accompanying [blog post](https://huggingface.co/blog/fine-tune-whisper). If you're interested in fine-tuning other \n",
+    "Transformers models, both for English and multilingual ASR, be sure to check out the \n",
+    "examples scripts at [examples/pytorch/speech-recognition](https://github.com/huggingface/transformers/tree/main/examples/pytorch/speech-recognition)."
+   ]
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "include_colab_link": true,
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

mgb2_speech.py

@@ -0,0 +1,169 @@
+import datasets
+import os
+
+
+_DESCRIPTION = "MGB2 speech recognition dataset AR"
+_HOMEPAGE = "https://arabicspeech.org/mgb2/"
+_LICENSE = "MGB-2 License agreement"
+_CITATION = """@misc{https://doi.org/10.48550/arxiv.1609.05625,
+  doi = {10.48550/ARXIV.1609.05625},
+  
+  url = {https://arxiv.org/abs/1609.05625},
+  
+  author = {Ali, Ahmed and Bell, Peter and Glass, James and Messaoui, Yacine and Mubarak, Hamdy and Renals, Steve and Zhang, Yifan},
+  
+  keywords = {Computation and Language (cs.CL), FOS: Computer and information sciences, FOS: Computer and information sciences},
+  
+  title = {The MGB-2 Challenge: Arabic Multi-Dialect Broadcast Media Recognition},
+  
+  publisher = {arXiv},
+  
+  year = {2016},
+  
+  copyright = {arXiv.org perpetual, non-exclusive license}
+}
+"""
+_DATA_ARCHIVE_ROOT = "archives/"
+_DATA_URL = {
+    "test": _DATA_ARCHIVE_ROOT + "mgb2_wav.test.tar.gz",
+    "dev": _DATA_ARCHIVE_ROOT + "mgb2_wav.dev.tar.gz",
+    "train": [_DATA_ARCHIVE_ROOT + f"mgb2_wav_{x}.train.tar.gz" for x in range(48)], # we have 48 archives
+}
+_TEXT_URL = {
+    "test": _DATA_ARCHIVE_ROOT + "mgb2_txt.test.tar.gz",
+    "dev": _DATA_ARCHIVE_ROOT + "mgb2_txt.dev.tar.gz",
+    "train": _DATA_ARCHIVE_ROOT + "mgb2_txt.train.tar.gz",
+}
+
+class MGDB2Dataset(datasets.GeneratorBasedBuilder):
+    def _info(self):
+        return datasets.DatasetInfo(
+        description=_DESCRIPTION,
+        features=datasets.Features(
+            {
+                "path": datasets.Value("string"),
+                "audio": datasets.Audio(sampling_rate=16_000),
+                "text": datasets.Value("string"),
+            }
+        ),
+        supervised_keys=None,
+        homepage=_HOMEPAGE,
+        license=_LICENSE,
+        citation=_CITATION,
+    )
+
+    def _split_generators(self, dl_manager):
+        wav_archive = dl_manager.download(_DATA_URL)
+        txt_archive = dl_manager.download(_TEXT_URL)
+        test_dir = "dataset/test"
+        dev_dir = "dataset/dev"
+        train_dir = "dataset/train"
+
+        if dl_manager.is_streaming:
+    
+            return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "path_to_txt": test_dir + "/txt",
+                    "path_to_wav": test_dir + "/wav",
+                    "wav_files": [dl_manager.iter_archive(wav_archive['test'])],
+                    "txt_files": dl_manager.iter_archive(txt_archive['test']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "path_to_txt": dev_dir + "/txt",
+                    "path_to_wav": dev_dir + "/wav",
+                    "wav_files": [dl_manager.iter_archive(wav_archive['dev'])],
+                    "txt_files": dl_manager.iter_archive(txt_archive['dev']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "path_to_txt": train_dir + "/txt",
+                    "path_to_wav": train_dir + "/wav",
+                    "wav_files": [dl_manager.iter_archive(a) for a in wav_archive['train']],
+                    "txt_files": dl_manager.iter_archive(txt_archive['train']),
+                },
+            ),
+        ]
+        else:
+            return [
+            datasets.SplitGenerator(
+                name=datasets.Split.TEST,
+                gen_kwargs={
+                    "path_to_txt": test_dir + "/txt",
+                    "path_to_wav": test_dir + "/wav",
+                    "wav_files": [dl_manager.extract(wav_archive['test'])],
+                    "txt_files": dl_manager.extract(txt_archive['test']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.VALIDATION,
+                gen_kwargs={
+                    "path_to_txt": dev_dir + "/txt",
+                    "path_to_wav": dev_dir + "/wav",
+                    "wav_files": [dl_manager.extract(wav_archive['dev'])],
+                    "txt_files": dl_manager.extract(txt_archive['dev']),
+                },
+            ),
+            datasets.SplitGenerator(
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    "path_to_txt": train_dir + "/txt",
+                    "path_to_wav": train_dir + "/wav",
+                    "wav_files": [dl_manager.extract(a) for a in wav_archive['train']],
+                    "txt_files": dl_manager.extract(txt_archive['train']),
+                },
+            ),
+        ]
+
+
+    
+    def _generate_examples(self, path_to_txt, path_to_wav, wav_files, txt_files):
+        """ 
+        This assumes that the text directory alphabetically precedes the wav dir
+        The file names for wav and text seem to match and are unique
+        We can use them for the dictionary matching them
+        """
+        examples = {}
+        id_ = 0
+        # need to prepare the transcript - wave map
+        for item in txt_files:
+            if type(item) is tuple:
+                # iter_archive will return path and file
+                path, f = item
+                txt = f.read().decode(encoding="utf-8").strip()
+            else:
+                # extract will return path only
+                path = item
+                with open(path, encoding="utf-8") as f:
+                    txt = f.read().strip()
+
+            if path.find(path_to_txt) > -1:
+                # construct the wav path
+                # which is used as an identifier
+                wav_path = os.path.split(path)[1].replace("_utf8", "").replace(".txt", ".wav").strip()
+                
+                examples[wav_path] = {
+                    "text": txt,
+                    "path": wav_path,
+                }
+
+        for wf in wav_files:
+            for item in wf:
+                if type(item) is tuple:
+                    path, f = item
+                    wav_data = f.read()
+                else:
+                    path = item
+                    with open(path, "rb") as f:
+                        wav_data = f.read()
+                if path.find(path_to_wav) > -1:
+                    wav_path = os.path.split(path)[1].strip()
+                    audio = {"path": path, "bytes": wav_data}
+                    yield id_, {**examples[wav_path], "audio": audio}
+                    id_ += 1

normalizer.json

@@ -0,0 +1,1742 @@
+{
+  "accessorise": "accessorize",
+  "accessorised": "accessorized",
+  "accessorises": "accessorizes",
+  "accessorising": "accessorizing",
+  "acclimatisation": "acclimatization",
+  "acclimatise": "acclimatize",
+  "acclimatised": "acclimatized",
+  "acclimatises": "acclimatizes",
+  "acclimatising": "acclimatizing",
+  "accoutrements": "accouterments",
+  "aeon": "eon",
+  "aeons": "eons",
+  "aerogramme": "aerogram",
+  "aerogrammes": "aerograms",
+  "aeroplane": "airplane",
+  "aeroplanes": "airplanes",
+  "aesthete": "esthete",
+  "aesthetes": "esthetes",
+  "aesthetic": "esthetic",
+  "aesthetically": "esthetically",
+  "aesthetics": "esthetics",
+  "aetiology": "etiology",
+  "ageing": "aging",
+  "aggrandisement": "aggrandizement",
+  "agonise": "agonize",
+  "agonised": "agonized",
+  "agonises": "agonizes",
+  "agonising": "agonizing",
+  "agonisingly": "agonizingly",
+  "almanack": "almanac",
+  "almanacks": "almanacs",
+  "aluminium": "aluminum",
+  "amortisable": "amortizable",
+  "amortisation": "amortization",
+  "amortisations": "amortizations",
+  "amortise": "amortize",
+  "amortised": "amortized",
+  "amortises": "amortizes",
+  "amortising": "amortizing",
+  "amphitheatre": "amphitheater",
+  "amphitheatres": "amphitheaters",
+  "anaemia": "anemia",
+  "anaemic": "anemic",
+  "anaesthesia": "anesthesia",
+  "anaesthetic": "anesthetic",
+  "anaesthetics": "anesthetics",
+  "anaesthetise": "anesthetize",
+  "anaesthetised": "anesthetized",
+  "anaesthetises": "anesthetizes",
+  "anaesthetising": "anesthetizing",
+  "anaesthetist": "anesthetist",
+  "anaesthetists": "anesthetists",
+  "anaesthetize": "anesthetize",
+  "anaesthetized": "anesthetized",
+  "anaesthetizes": "anesthetizes",
+  "anaesthetizing": "anesthetizing",
+  "analogue": "analog",
+  "analogues": "analogs",
+  "analyse": "analyze",
+  "analysed": "analyzed",
+  "analyses": "analyzes",
+  "analysing": "analyzing",
+  "anglicise": "anglicize",
+  "anglicised": "anglicized",
+  "anglicises": "anglicizes",
+  "anglicising": "anglicizing",
+  "annualised": "annualized",
+  "antagonise": "antagonize",
+  "antagonised": "antagonized",
+  "antagonises": "antagonizes",
+  "antagonising": "antagonizing",
+  "apologise": "apologize",
+  "apologised": "apologized",
+  "apologises": "apologizes",
+  "apologising": "apologizing",
+  "appal": "appall",
+  "appals": "appalls",
+  "appetiser": "appetizer",
+  "appetisers": "appetizers",
+  "appetising": "appetizing",
+  "appetisingly": "appetizingly",
+  "arbour": "arbor",
+  "arbours": "arbors",
+  "archaeologically": "archeologically",
+  "archaeologist": "archeologist",
+  "archaeologists": "archeologists",
+  "archaeology": "archeology</span>",
+  "archeological": "archaeological",
+  "ardour": "ardor",
+  "armour": "armor",
+  "armoured": "armored",
+  "armourer": "armorer",
+  "armourers": "armorers",
+  "armouries": "armories",
+  "armoury": "armory",
+  "artefact": "artifact",
+  "artefacts": "artifacts",
+  "authorise": "authorize",
+  "authorised": "authorized",
+  "authorises": "authorizes",
+  "authorising": "authorizing",
+  "axe": "ax",
+  "backpedalled": "backpedaled",
+  "backpedalling": "backpedaling",
+  "bannister": "banister",
+  "bannisters": "banisters",
+  "baptise": "baptize",
+  "baptised": "baptized",
+  "baptises": "baptizes",
+  "baptising": "baptizing",
+  "bastardise": "bastardize",
+  "bastardised": "bastardized",
+  "bastardises": "bastardizes",
+  "bastardising": "bastardizing",
+  "battleax": "battleaxe",
+  "baulk": "balk",
+  "baulked": "balked",
+  "baulking": "balking",
+  "baulks": "balks",
+  "bedevilled": "bedeviled",
+  "bedevilling": "bedeviling",
+  "behaviour": "behavior",
+  "behavioural": "behavioral",
+  "behaviourism": "behaviorism",
+  "behaviourist": "behaviorist",
+  "behaviourists": "behaviorists",
+  "behaviours": "behaviors",
+  "behove": "behoove",
+  "behoved": "behooved",
+  "behoves": "behooves",
+  "bejewelled": "bejeweled",
+  "belabour": "belabor",
+  "belaboured": "belabored",
+  "belabouring": "belaboring",
+  "belabours": "belabors",
+  "bevelled": "beveled",
+  "bevvies": "bevies",
+  "bevvy": "bevy",
+  "biassed": "biased",
+  "biassing": "biasing",
+  "bingeing": "binging",
+  "bougainvillaea": "bougainvillea",
+  "bougainvillaeas": "bougainvilleas",
+  "bowdlerise": "bowdlerize",
+  "bowdlerised": "bowdlerized",
+  "bowdlerises": "bowdlerizes",
+  "bowdlerising": "bowdlerizing",
+  "breathalyse": "breathalyze",
+  "breathalysed": "breathalyzed",
+  "breathalyser": "breathalyzer",
+  "breathalysers": "breathalyzers",
+  "breathalyses": "breathalyzes",
+  "breathalysing": "breathalyzing",
+  "brutalise": "brutalize",
+  "brutalised": "brutalized",
+  "brutalises": "brutalizes",
+  "brutalising": "brutalizing",
+  "busses": "buses",
+  "bussing": "busing",
+  "caesarean": "cesarean",
+  "caesareans": "cesareans",
+  "calibre": "caliber",
+  "calibres": "calibers",
+  "calliper": "caliper",
+  "callipers": "calipers",
+  "callisthenics": "calisthenics",
+  "canalise": "canalize",
+  "canalised": "canalized",
+  "canalises": "canalizes",
+  "canalising": "canalizing",
+  "cancelation": "cancellation",
+  "cancelations": "cancellations",
+  "cancelled": "canceled",
+  "cancelling": "canceling",
+  "candour": "candor",
+  "cannibalise": "cannibalize",
+  "cannibalised": "cannibalized",
+  "cannibalises": "cannibalizes",
+  "cannibalising": "cannibalizing",
+  "canonise": "canonize",
+  "canonised": "canonized",
+  "canonises": "canonizes",
+  "canonising": "canonizing",
+  "capitalise": "capitalize",
+  "capitalised": "capitalized",
+  "capitalises": "capitalizes",
+  "capitalising": "capitalizing",
+  "caramelise": "caramelize",
+  "caramelised": "caramelized",
+  "caramelises": "caramelizes",
+  "caramelising": "caramelizing",
+  "carbonise": "carbonize",
+  "carbonised": "carbonized",
+  "carbonises": "carbonizes",
+  "carbonising": "carbonizing",
+  "carolled": "caroled",
+  "carolling": "caroling",
+  "catalogue": "catalog",
+  "catalogued": "cataloged",
+  "catalogues": "catalogs",
+  "cataloguing": "cataloging",
+  "catalyse": "catalyze",
+  "catalysed": "catalyzed",
+  "catalyses": "catalyzes",
+  "catalysing": "catalyzing",
+  "categorise": "categorize",
+  "categorised": "categorized",
+  "categorises": "categorizes",
+  "categorising": "categorizing",
+  "cauterise": "cauterize",
+  "cauterised": "cauterized",
+  "cauterises": "cauterizes",
+  "cauterising": "cauterizing",
+  "cavilled": "caviled",
+  "cavilling": "caviling",
+  "centigramme": "centigram",
+  "centigrammes": "centigrams",
+  "centilitre": "centiliter",
+  "centilitres": "centiliters",
+  "centimetre": "centimeter",
+  "centimetres": "centimeters",
+  "centralise": "centralize",
+  "centralised": "centralized",
+  "centralises": "centralizes",
+  "centralising": "centralizing",
+  "centre": "center",
+  "centred": "centered",
+  "centrefold": "centerfold",
+  "centrefolds": "centerfolds",
+  "centrepiece": "centerpiece",
+  "centrepieces": "centerpieces",
+  "centres": "centers",
+  "channelled": "channeled",
+  "channelling": "channeling",
+  "characterise": "characterize",
+  "characterised": "characterized",
+  "characterises": "characterizes",
+  "characterising": "characterizing",
+  "cheque": "check",
+  "chequebook": "checkbook",
+  "chequebooks": "checkbooks",
+  "chequered": "checkered",
+  "cheques": "checks",
+  "chilli": "chili",
+  "chimaera": "chimera",
+  "chimaeras": "chimeras",
+  "chiselled": "chiseled",
+  "chiselling": "chiseling",
+  "circularise": "circularize",
+  "circularised": "circularized",
+  "circularises": "circularizes",
+  "circularising": "circularizing",
+  "civilise": "civilize",
+  "civilised": "civilized",
+  "civilises": "civilizes",
+  "civilising": "civilizing",
+  "clamour": "clamor",
+  "clamoured": "clamored",
+  "clamouring": "clamoring",
+  "clamours": "clamors",
+  "clangour": "clangor",
+  "clarinettist": "clarinetist",
+  "clarinettists": "clarinetists",
+  "collectivise": "collectivize",
+  "collectivised": "collectivized",
+  "collectivises": "collectivizes",
+  "collectivising": "collectivizing",
+  "colonisation": "colonization",
+  "colonise": "colonize",
+  "colonised": "colonized",
+  "coloniser": "colonizer",
+  "colonisers": "colonizers",
+  "colonises": "colonizes",
+  "colonising": "colonizing",
+  "colour": "color",
+  "colourant": "colorant",
+  "colourants": "colorants",
+  "coloured": "colored",
+  "coloureds": "coloreds",
+  "colourful": "colorful",
+  "colourfully": "colorfully",
+  "colouring": "coloring",
+  "colourize": "colorize",
+  "colourized": "colorized",
+  "colourizes": "colorizes",
+  "colourizing": "colorizing",
+  "colourless": "colorless",
+  "colours": "colors",
+  "commercialise": "commercialize",
+  "commercialised": "commercialized",
+  "commercialises": "commercializes",
+  "commercialising": "commercializing",
+  "compartmentalise": "compartmentalize",
+  "compartmentalised": "compartmentalized",
+  "compartmentalises": "compartmentalizes",
+  "compartmentalising": "compartmentalizing",
+  "computerise": "computerize",
+  "computerised": "computerized",
+  "computerises": "computerizes",
+  "computerising": "computerizing",
+  "conceptualise": "conceptualize",
+  "conceptualised": "conceptualized",
+  "conceptualises": "conceptualizes",
+  "conceptualising": "conceptualizing",
+  "connexion": "connection",
+  "connexions": "connections",
+  "contextualise": "contextualize",
+  "contextualised": "contextualized",
+  "contextualises": "contextualizes",
+  "contextualising": "contextualizing",
+  "cosier": "cozier",
+  "cosies": "cozies",
+  "cosiest": "coziest",
+  "cosily": "cozily",
+  "cosiness": "coziness",
+  "cosy": "cozy",
+  "councillor": "councilor",
+  "councillors": "councilors",
+  "counselled": "counseled",
+  "counselling": "counseling",
+  "counsellor": "counselor",
+  "counsellors": "counselors",
+  "crenelated": "crenellated",
+  "criminalise": "criminalize",
+  "criminalised": "criminalized",
+  "criminalises": "criminalizes",
+  "criminalising": "criminalizing",
+  "criticise": "criticize",
+  "criticised": "criticized",
+  "criticises": "criticizes",
+  "criticising": "criticizing",
+  "crueller": "crueler",
+  "cruellest": "cruelest",
+  "crystallisation": "crystallization",
+  "crystallise": "crystallize",
+  "crystallised": "crystallized",
+  "crystallises": "crystallizes",
+  "crystallising": "crystallizing",
+  "cudgelled": "cudgeled",
+  "cudgelling": "cudgeling",
+  "customise": "customize",
+  "customised": "customized",
+  "customises": "customizes",
+  "customising": "customizing",
+  "cypher": "cipher",
+  "cyphers": "ciphers",
+  "decentralisation": "decentralization",
+  "decentralise": "decentralize",
+  "decentralised": "decentralized",
+  "decentralises": "decentralizes",
+  "decentralising": "decentralizing",
+  "decriminalisation": "decriminalization",
+  "decriminalise": "decriminalize",
+  "decriminalised": "decriminalized",
+  "decriminalises": "decriminalizes",
+  "decriminalising": "decriminalizing",
+  "defence": "defense",
+  "defenceless": "defenseless",
+  "defences": "defenses",
+  "dehumanisation": "dehumanization",
+  "dehumanise": "dehumanize",
+  "dehumanised": "dehumanized",
+  "dehumanises": "dehumanizes",
+  "dehumanising": "dehumanizing",
+  "demeanour": "demeanor",
+  "demilitarisation": "demilitarization",
+  "demilitarise": "demilitarize",
+  "demilitarised": "demilitarized",
+  "demilitarises": "demilitarizes",
+  "demilitarising": "demilitarizing",
+  "demobilisation": "demobilization",
+  "demobilise": "demobilize",
+  "demobilised": "demobilized",
+  "demobilises": "demobilizes",
+  "demobilising": "demobilizing",
+  "democratisation": "democratization",
+  "democratise": "democratize",
+  "democratised": "democratized",
+  "democratises": "democratizes",
+  "democratising": "democratizing",
+  "demonise": "demonize",
+  "demonised": "demonized",
+  "demonises": "demonizes",
+  "demonising": "demonizing",
+  "demoralisation": "demoralization",
+  "demoralise": "demoralize",
+  "demoralised": "demoralized",
+  "demoralises": "demoralizes",
+  "demoralising": "demoralizing",
+  "denationalisation": "denationalization",
+  "denationalise": "denationalize",
+  "denationalised": "denationalized",
+  "denationalises": "denationalizes",
+  "denationalising": "denationalizing",
+  "deodorise": "deodorize",
+  "deodorised": "deodorized",
+  "deodorises": "deodorizes",
+  "deodorising": "deodorizing",
+  "depersonalise": "depersonalize",
+  "depersonalised": "depersonalized",
+  "depersonalises": "depersonalizes",
+  "depersonalising": "depersonalizing",
+  "deputise": "deputize",
+  "deputised": "deputized",
+  "deputises": "deputizes",
+  "deputising": "deputizing",
+  "desensitisation": "desensitization",
+  "desensitise": "desensitize",
+  "desensitised": "desensitized",
+  "desensitises": "desensitizes",
+  "desensitising": "desensitizing",
+  "destabilisation": "destabilization",
+  "destabilise": "destabilize",
+  "destabilised": "destabilized",
+  "destabilises": "destabilizes",
+  "destabilising": "destabilizing",
+  "dialled": "dialed",
+  "dialling": "dialing",
+  "dialogue": "dialog",
+  "dialogues": "dialogs",
+  "diarrhoea": "diarrhea",
+  "digitise": "digitize",
+  "digitised": "digitized",
+  "digitises": "digitizes",
+  "digitising": "digitizing",
+  "disc": "disk",
+  "discolour": "discolor",
+  "discoloured": "discolored",
+  "discolouring": "discoloring",
+  "discolours": "discolors",
+  "discs": "disks",
+  "disembowelled": "disemboweled",
+  "disembowelling": "disemboweling",
+  "disfavour": "disfavor",
+  "dishevelled": "disheveled",
+  "dishonour": "dishonor",
+  "dishonourable": "dishonorable",
+  "dishonourably": "dishonorably",
+  "dishonoured": "dishonored",
+  "dishonouring": "dishonoring",
+  "dishonours": "dishonors",
+  "disorganisation": "disorganization",
+  "disorganised": "disorganized",
+  "distil": "distill",
+  "distils": "distills",
+  "dramatisation": "dramatization",
+  "dramatisations": "dramatizations",
+  "dramatise": "dramatize",
+  "dramatised": "dramatized",
+  "dramatises": "dramatizes",
+  "dramatising": "dramatizing",
+  "draught": "draft",
+  "draughtboard": "draftboard",
+  "draughtboards": "draftboards",
+  "draughtier": "draftier",
+  "draughtiest": "draftiest",
+  "draughts": "drafts",
+  "draughtsman": "draftsman",
+  "draughtsmanship": "draftsmanship",
+  "draughtsmen": "draftsmen",
+  "draughtswoman": "draftswoman",
+  "draughtswomen": "draftswomen",
+  "draughty": "drafty",
+  "drivelled": "driveled",
+  "drivelling": "driveling",
+  "duelled": "dueled",
+  "duelling": "dueling",
+  "economise": "economize",
+  "economised": "economized",
+  "economises": "economizes",
+  "economising": "economizing",
+  "editorialise": "editorialize",
+  "editorialised": "editorialized",
+  "editorialises": "editorializes",
+  "editorialising": "editorializing",
+  "edoema": "edema",
+  "empathise": "empathize",
+  "empathised": "empathized",
+  "empathises": "empathizes",
+  "empathising": "empathizing",
+  "emphasise": "emphasize",
+  "emphasised": "emphasized",
+  "emphasises": "emphasizes",
+  "emphasising": "emphasizing",
+  "enamelled": "enameled",
+  "enamelling": "enameling",
+  "enamoured": "enamored",
+  "encyclopaedia": "encyclopedia",
+  "encyclopaedias": "encyclopedias",
+  "encyclopaedic": "encyclopedic",
+  "endeavour": "endeavor",
+  "endeavoured": "endeavored",
+  "endeavouring": "endeavoring",
+  "endeavours": "endeavors",
+  "energise": "energize",
+  "energised": "energized",
+  "energises": "energizes",
+  "energising": "energizing",
+  "enrol": "enroll",
+  "enrols": "enrolls",
+  "enthral": "enthrall",
+  "enthrals": "enthralls",
+  "epaulette": "epaulet",
+  "epaulettes": "epaulets",
+  "epicentre": "epicenter",
+  "epicentres": "epicenters",
+  "epilogue": "epilog",
+  "epilogues": "epilogs",
+  "epitomise": "epitomize",
+  "epitomised": "epitomized",
+  "epitomises": "epitomizes",
+  "epitomising": "epitomizing",
+  "equalisation": "equalization",
+  "equalise": "equalize",
+  "equalised": "equalized",
+  "equaliser": "equalizer",
+  "equalisers": "equalizers",
+  "equalises": "equalizes",
+  "equalising": "equalizing",
+  "eulogise": "eulogize",
+  "eulogised": "eulogized",
+  "eulogises": "eulogizes",
+  "eulogising": "eulogizing",
+  "evangelise": "evangelize",
+  "evangelised": "evangelized",
+  "evangelises": "evangelizes",
+  "evangelising": "evangelizing",
+  "exorcise": "exorcize",
+  "exorcised": "exorcized",
+  "exorcises": "exorcizes",
+  "exorcising": "exorcizing",
+  "extemporisation": "extemporization",
+  "extemporise": "extemporize",
+  "extemporised": "extemporized",
+  "extemporises": "extemporizes",
+  "extemporising": "extemporizing",
+  "externalisation": "externalization",
+  "externalisations": "externalizations",
+  "externalise": "externalize",
+  "externalised": "externalized",
+  "externalises": "externalizes",
+  "externalising": "externalizing",
+  "factorise": "factorize",
+  "factorised": "factorized",
+  "factorises": "factorizes",
+  "factorising": "factorizing",
+  "faecal": "fecal",
+  "faeces": "feces",
+  "familiarisation": "familiarization",
+  "familiarise": "familiarize",
+  "familiarised": "familiarized",
+  "familiarises": "familiarizes",
+  "familiarising": "familiarizing",
+  "fantasise": "fantasize",
+  "fantasised": "fantasized",
+  "fantasises": "fantasizes",
+  "fantasising": "fantasizing",
+  "favour": "favor",
+  "favourable": "favorable",
+  "favourably": "favorably",
+  "favoured": "favored",
+  "favouring": "favoring",
+  "favourite": "favorite",
+  "favourites": "favorites",
+  "favouritism": "favoritism",
+  "favours": "favors",
+  "feminise": "feminize",
+  "feminised": "feminized",
+  "feminises": "feminizes",
+  "feminising": "feminizing",
+  "fertilisation": "fertilization",
+  "fertilise": "fertilize",
+  "fertilised": "fertilized",
+  "fertiliser": "fertilizer",
+  "fertilisers": "fertilizers",
+  "fertilises": "fertilizes",
+  "fertilising": "fertilizing",
+  "fervour": "fervor",
+  "fibre": "fiber",
+  "fibreglass": "fiberglass",
+  "fibres": "fibers",
+  "fictionalisation": "fictionalization",
+  "fictionalisations": "fictionalizations",
+  "fictionalise": "fictionalize",
+  "fictionalised": "fictionalized",
+  "fictionalises": "fictionalizes",
+  "fictionalising": "fictionalizing",
+  "fillet": "filet",
+  "filleted": "fileted",
+  "filleting": "fileting",
+  "fillets": "filets",
+  "finalisation": "finalization",
+  "finalise": "finalize",
+  "finalised": "finalized",
+  "finalises": "finalizes",
+  "finalising": "finalizing",
+  "flautist": "flutist",
+  "flautists": "flutists",
+  "flavour": "flavor",
+  "flavoured": "flavored",
+  "flavouring": "flavoring",
+  "flavourings": "flavorings",
+  "flavourless": "flavorless",
+  "flavours": "flavors",
+  "flavoursome": "flavorsome",
+  "flyer / flier": "flier / flyer",
+  "foetal": "fetal",
+  "foetid": "fetid",
+  "foetus": "fetus",
+  "foetuses": "fetuses",
+  "formalisation": "formalization",
+  "formalise": "formalize",
+  "formalised": "formalized",
+  "formalises": "formalizes",
+  "formalising": "formalizing",
+  "fossilisation": "fossilization",
+  "fossilise": "fossilize",
+  "fossilised": "fossilized",
+  "fossilises": "fossilizes",
+  "fossilising": "fossilizing",
+  "fraternisation": "fraternization",
+  "fraternise": "fraternize",
+  "fraternised": "fraternized",
+  "fraternises": "fraternizes",
+  "fraternising": "fraternizing",
+  "fulfil": "fulfill",
+  "fulfilment": "fulfillment",
+  "fulfils": "fulfills",
+  "funnelled": "funneled",
+  "funnelling": "funneling",
+  "gage": "gauge",
+  "gaged": "gauged",
+  "gages": "gauges",
+  "gaging": "gauging",
+  "galvanise": "galvanize",
+  "galvanised": "galvanized",
+  "galvanises": "galvanizes",
+  "galvanising": "galvanizing",
+  "gambolled": "gamboled",
+  "gambolling": "gamboling",
+  "gaol": "jail",
+  "gaolbird": "jailbird",
+  "gaolbirds": "jailbirds",
+  "gaolbreak": "jailbreak",
+  "gaolbreaks": "jailbreaks",
+  "gaoled": "jailed",
+  "gaoler": "jailer",
+  "gaolers": "jailers",
+  "gaoling": "jailing",
+  "gaols": "jails",
+  "gasses": "gases",
+  "generalisation": "generalization",
+  "generalisations": "generalizations",
+  "generalise": "generalize",
+  "generalised": "generalized",
+  "generalises": "generalizes",
+  "generalising": "generalizing",
+  "ghettoise": "ghettoize",
+  "ghettoised": "ghettoized",
+  "ghettoises": "ghettoizes",
+  "ghettoising": "ghettoizing",
+  "gipsies": "gypsies",
+  "glamor": "glamour",
+  "glamorise": "glamorize",
+  "glamorised": "glamorized",
+  "glamorises": "glamorizes",
+  "glamorising": "glamorizing",
+  "globalisation": "globalization",
+  "globalise": "globalize",
+  "globalised": "globalized",
+  "globalises": "globalizes",
+  "globalising": "globalizing",
+  "glueing": "gluing",
+  "goitre": "goiter",
+  "goitres": "goiters",
+  "gonorrhoea": "gonorrhea",
+  "gramme": "gram",
+  "grammes": "grams",
+  "gravelled": "graveled",
+  "grey": "gray",
+  "greyed": "grayed",
+  "greying": "graying",
+  "greyish": "grayish",
+  "greyness": "grayness",
+  "greys": "grays",
+  "grovelled": "groveled",
+  "grovelling": "groveling",
+  "groyne": "groin",
+  "groynes": "groins",
+  "gruelling": "grueling",
+  "gruellingly": "gruelingly",
+  "gryphon": "griffin",
+  "gryphons": "griffins",
+  "gynaecological": "gynecological",
+  "gynaecologist": "gynecologist",
+  "gynaecologists": "gynecologists",
+  "gynaecology": "gynecology",
+  "haematological": "hematological",
+  "haematologist": "hematologist",
+  "haematologists": "hematologists",
+  "haematology": "hematology",
+  "haemoglobin": "hemoglobin",
+  "haemophilia": "hemophilia",
+  "haemophiliac": "hemophiliac",
+  "haemophiliacs": "hemophiliacs",
+  "haemorrhage": "hemorrhage",
+  "haemorrhaged": "hemorrhaged",
+  "haemorrhages": "hemorrhages",
+  "haemorrhaging": "hemorrhaging",
+  "haemorrhoids": "hemorrhoids",
+  "harbour": "harbor",
+  "harboured": "harbored",
+  "harbouring": "harboring",
+  "harbours": "harbors",
+  "harmonisation": "harmonization",
+  "harmonise": "harmonize",
+  "harmonised": "harmonized",
+  "harmonises": "harmonizes",
+  "harmonising": "harmonizing",
+  "homoeopath": "homeopath",
+  "homoeopathic": "homeopathic",
+  "homoeopaths": "homeopaths",
+  "homoeopathy": "homeopathy",
+  "homogenise": "homogenize",
+  "homogenised": "homogenized",
+  "homogenises": "homogenizes",
+  "homogenising": "homogenizing",
+  "honour": "honor",
+  "honourable": "honorable",
+  "honourably": "honorably",
+  "honoured": "honored",
+  "honouring": "honoring",
+  "honours": "honors",
+  "hospitalisation": "hospitalization",
+  "hospitalise": "hospitalize",
+  "hospitalised": "hospitalized",
+  "hospitalises": "hospitalizes",
+  "hospitalising": "hospitalizing",
+  "humanise": "humanize",
+  "humanised": "humanized",
+  "humanises": "humanizes",
+  "humanising": "humanizing",
+  "humour": "humor",
+  "humoured": "humored",
+  "humouring": "humoring",
+  "humourless": "humorless",
+  "humours": "humors",
+  "hybridise": "hybridize",
+  "hybridised": "hybridized",
+  "hybridises": "hybridizes",
+  "hybridising": "hybridizing",
+  "hypnotise": "hypnotize",
+  "hypnotised": "hypnotized",
+  "hypnotises": "hypnotizes",
+  "hypnotising": "hypnotizing",
+  "hypothesise": "hypothesize",
+  "hypothesised": "hypothesized",
+  "hypothesises": "hypothesizes",
+  "hypothesising": "hypothesizing",
+  "idealisation": "idealization",
+  "idealise": "idealize",
+  "idealised": "idealized",
+  "idealises": "idealizes",
+  "idealising": "idealizing",
+  "idolise": "idolize",
+  "idolised": "idolized",
+  "idolises": "idolizes",
+  "idolising": "idolizing",
+  "immobilisation": "immobilization",
+  "immobilise": "immobilize",
+  "immobilised": "immobilized",
+  "immobiliser": "immobilizer",
+  "immobilisers": "immobilizers",
+  "immobilises": "immobilizes",
+  "immobilising": "immobilizing",
+  "immortalise": "immortalize",
+  "immortalised": "immortalized",
+  "immortalises": "immortalizes",
+  "immortalising": "immortalizing",
+  "immunisation": "immunization",
+  "immunise": "immunize",
+  "immunised": "immunized",
+  "immunises": "immunizes",
+  "immunising": "immunizing",
+  "impanelled": "impaneled",
+  "impanelling": "impaneling",
+  "imperilled": "imperiled",
+  "imperilling": "imperiling",
+  "individualise": "individualize",
+  "individualised": "individualized",
+  "individualises": "individualizes",
+  "individualising": "individualizing",
+  "industrialise": "industrialize",
+  "industrialised": "industrialized",
+  "industrialises": "industrializes",
+  "industrialising": "industrializing",
+  "inflexion": "inflection",
+  "inflexions": "inflections",
+  "initialise": "initialize",
+  "initialised": "initialized",
+  "initialises": "initializes",
+  "initialising": "initializing",
+  "initialled": "initialed",
+  "initialling": "initialing",
+  "instal": "install",
+  "instalment": "installment",
+  "instalments": "installments",
+  "instals": "installs",
+  "instil": "instill",
+  "instils": "instills",
+  "institutionalisation": "institutionalization",
+  "institutionalise": "institutionalize",
+  "institutionalised": "institutionalized",
+  "institutionalises": "institutionalizes",
+  "institutionalising": "institutionalizing",
+  "intellectualise": "intellectualize",
+  "intellectualised": "intellectualized",
+  "intellectualises": "intellectualizes",
+  "intellectualising": "intellectualizing",
+  "internalisation": "internalization",
+  "internalise": "internalize",
+  "internalised": "internalized",
+  "internalises": "internalizes",
+  "internalising": "internalizing",
+  "internationalisation": "internationalization",
+  "internationalise": "internationalize",
+  "internationalised": "internationalized",
+  "internationalises": "internationalizes",
+  "internationalising": "internationalizing",
+  "ionisation": "ionization",
+  "ionise": "ionize",
+  "ionised": "ionized",
+  "ioniser": "ionizer",
+  "ionisers": "ionizers",
+  "ionises": "ionizes",
+  "ionising": "ionizing",
+  "italicise": "italicize",
+  "italicised": "italicized",
+  "italicises": "italicizes",
+  "italicising": "italicizing",
+  "itemise": "itemize",
+  "itemised": "itemized",
+  "itemises": "itemizes",
+  "itemising": "itemizing",
+  "jeopardise": "jeopardize",
+  "jeopardised": "jeopardized",
+  "jeopardises": "jeopardizes",
+  "jeopardising": "jeopardizing",
+  "jewelled": "jeweled",
+  "jeweller": "jeweler",
+  "jewellers": "jewelers",
+  "jewellery": "jewelry",
+  "judgement": "judgment",
+  "kilogramme": "kilogram",
+  "kilogrammes": "kilograms",
+  "kilometre": "kilometer",
+  "kilometres": "kilometers",
+  "labelled": "labeled",
+  "labelling": "labeling",
+  "labour": "labor",
+  "laboured": "labored",
+  "labourer": "laborer",
+  "labourers": "laborers",
+  "labouring": "laboring",
+  "labours": "labors",
+  "lacklustre": "lackluster",
+  "legalisation": "legalization",
+  "legalise": "legalize",
+  "legalised": "legalized",
+  "legalises": "legalizes",
+  "legalising": "legalizing",
+  "legitimise": "legitimize",
+  "legitimised": "legitimized",
+  "legitimises": "legitimizes",
+  "legitimising": "legitimizing",
+  "leukaemia": "leukemia",
+  "levelled": "leveled",
+  "leveller": "leveler",
+  "levellers": "levelers",
+  "levelling": "leveling",
+  "libelled": "libeled",
+  "libelling": "libeling",
+  "libellous": "libelous",
+  "liberalisation": "liberalization",
+  "liberalise": "liberalize",
+  "liberalised": "liberalized",
+  "liberalises": "liberalizes",
+  "liberalising": "liberalizing",
+  "licence": "license",
+  "licenced": "licensed",
+  "licences": "licenses",
+  "licencing": "licensing",
+  "likeable": "likable",
+  "lionisation": "lionization",
+  "lionise": "lionize",
+  "lionised": "lionized",
+  "lionises": "lionizes",
+  "lionising": "lionizing",
+  "liquidise": "liquidize",
+  "liquidised": "liquidized",
+  "liquidiser": "liquidizer",
+  "liquidisers": "liquidizers",
+  "liquidises": "liquidizes",
+  "liquidising": "liquidizing",
+  "litre": "liter",
+  "litres": "liters",
+  "localise": "localize",
+  "localised": "localized",
+  "localises": "localizes",
+  "localising": "localizing",
+  "louvre": "louver",
+  "louvred": "louvered",
+  "louvres": "louvers",
+  "lustre": "luster",
+  "magnetise": "magnetize",
+  "magnetised": "magnetized",
+  "magnetises": "magnetizes",
+  "magnetising": "magnetizing",
+  "manoeuvrability": "maneuverability",
+  "manoeuvrable": "maneuverable",
+  "manoeuvre": "maneuver",
+  "manoeuvred": "maneuvered",
+  "manoeuvres": "maneuvers",
+  "manoeuvring": "maneuvering",
+  "manoeuvrings": "maneuverings",
+  "marginalisation": "marginalization",
+  "marginalise": "marginalize",
+  "marginalised": "marginalized",
+  "marginalises": "marginalizes",
+  "marginalising": "marginalizing",
+  "marshalled": "marshaled",
+  "marshalling": "marshaling",
+  "marvelled": "marveled",
+  "marvelling": "marveling",
+  "marvellous": "marvelous",
+  "marvellously": "marvelously",
+  "materialisation": "materialization",
+  "materialise": "materialize",
+  "materialised": "materialized",
+  "materialises": "materializes",
+  "materialising": "materializing",
+  "maximisation": "maximization",
+  "maximise": "maximize",
+  "maximised": "maximized",
+  "maximises": "maximizes",
+  "maximising": "maximizing",
+  "meagre": "meager",
+  "mechanisation": "mechanization",
+  "mechanise": "mechanize",
+  "mechanised": "mechanized",
+  "mechanises": "mechanizes",
+  "mechanising": "mechanizing",
+  "mediaeval": "medieval",
+  "memorialise": "memorialize",
+  "memorialised": "memorialized",
+  "memorialises": "memorializes",
+  "memorialising": "memorializing",
+  "memorise": "memorize",
+  "memorised": "memorized",
+  "memorises": "memorizes",
+  "memorising": "memorizing",
+  "mesmerise": "mesmerize",
+  "mesmerised": "mesmerized",
+  "mesmerises": "mesmerizes",
+  "mesmerising": "mesmerizing",
+  "metabolise": "metabolize",
+  "metabolised": "metabolized",
+  "metabolises": "metabolizes",
+  "metabolising": "metabolizing",
+  "metre": "meter",
+  "metres": "meters",
+  "mhm": "hmm",
+  "micrometre": "micrometer",
+  "micrometres": "micrometers",
+  "militarise": "militarize",
+  "militarised": "militarized",
+  "militarises": "militarizes",
+  "militarising": "militarizing",
+  "milligramme": "milligram",
+  "milligrammes": "milligrams",
+  "millilitre": "milliliter",
+  "millilitres": "milliliters",
+  "millimetre": "millimeter",
+  "millimetres": "millimeters",
+  "miniaturisation": "miniaturization",
+  "miniaturise": "miniaturize",
+  "miniaturised": "miniaturized",
+  "miniaturises": "miniaturizes",
+  "miniaturising": "miniaturizing",
+  "minibusses": "minibuses",
+  "minimise": "minimize",
+  "minimised": "minimized",
+  "minimises": "minimizes",
+  "minimising": "minimizing",
+  "misbehaviour": "misbehavior",
+  "misdemeanour": "misdemeanor",
+  "misdemeanours": "misdemeanors",
+  "misspelt": "misspelled",
+  "mitre": "miter",
+  "mitres": "miters",
+  "mm": "hmm",
+  "mmm": "hmm",
+  "mobilisation": "mobilization",
+  "mobilise": "mobilize",
+  "mobilised": "mobilized",
+  "mobilises": "mobilizes",
+  "mobilising": "mobilizing",
+  "modelled": "modeled",
+  "modeller": "modeler",
+  "modellers": "modelers",
+  "modelling": "modeling",
+  "modernise": "modernize",
+  "modernised": "modernized",
+  "modernises": "modernizes",
+  "modernising": "modernizing",
+  "moisturise": "moisturize",
+  "moisturised": "moisturized",
+  "moisturiser": "moisturizer",
+  "moisturisers": "moisturizers",
+  "moisturises": "moisturizes",
+  "moisturising": "moisturizing",
+  "monologue": "monolog",
+  "monologues": "monologs",
+  "monopolisation": "monopolization",
+  "monopolise": "monopolize",
+  "monopolised": "monopolized",
+  "monopolises": "monopolizes",
+  "monopolising": "monopolizing",
+  "moralise": "moralize",
+  "moralised": "moralized",
+  "moralises": "moralizes",
+  "moralising": "moralizing",
+  "motorised": "motorized",
+  "mould": "mold",
+  "moulded": "molded",
+  "moulder": "molder",
+  "mouldered": "moldered",
+  "mouldering": "moldering",
+  "moulders": "molders",
+  "mouldier": "moldier",
+  "mouldiest": "moldiest",
+  "moulding": "molding",
+  "mouldings": "moldings",
+  "moulds": "molds",
+  "mouldy": "moldy",
+  "moult": "molt",
+  "moulted": "molted",
+  "moulting": "molting",
+  "moults": "molts",
+  "moustache": "mustache",
+  "moustached": "mustached",
+  "moustaches": "mustaches",
+  "moustachioed": "mustachioed",
+  "multicoloured": "multicolored",
+  "nationalisation": "nationalization",
+  "nationalisations": "nationalizations",
+  "nationalise": "nationalize",
+  "nationalised": "nationalized",
+  "nationalises": "nationalizes",
+  "nationalising": "nationalizing",
+  "naturalisation": "naturalization",
+  "naturalise": "naturalize",
+  "naturalised": "naturalized",
+  "naturalises": "naturalizes",
+  "naturalising": "naturalizing",
+  "neighbour": "neighbor",
+  "neighbourhood": "neighborhood",
+  "neighbourhoods": "neighborhoods",
+  "neighbouring": "neighboring",
+  "neighbourliness": "neighborliness",
+  "neighbourly": "neighborly",
+  "neighbours": "neighbors",
+  "neutralisation": "neutralization",
+  "neutralise": "neutralize",
+  "neutralised": "neutralized",
+  "neutralises": "neutralizes",
+  "neutralising": "neutralizing",
+  "normalisation": "normalization",
+  "normalise": "normalize",
+  "normalised": "normalized",
+  "normalises": "normalizes",
+  "normalising": "normalizing",
+  "odour": "odor",
+  "odourless": "odorless",
+  "odours": "odors",
+  "oesophagus": "esophagus",
+  "oesophaguses": "esophaguses",
+  "oestrogen": "estrogen",
+  "offence": "offense",
+  "offences": "offenses",
+  "omelette": "omelet",
+  "omelettes": "omelets",
+  "optimise": "optimize",
+  "optimised": "optimized",
+  "optimises": "optimizes",
+  "optimising": "optimizing",
+  "organisation": "organization",
+  "organisational": "organizational",
+  "organisations": "organizations",
+  "organise": "organize",
+  "organised": "organized",
+  "organiser": "organizer",
+  "organisers": "organizers",
+  "organises": "organizes",
+  "organising": "organizing",
+  "orthopaedic": "orthopedic",
+  "orthopaedics": "orthopedics",
+  "ostracise": "ostracize",
+  "ostracised": "ostracized",
+  "ostracises": "ostracizes",
+  "ostracising": "ostracizing",
+  "outmanoeuvre": "outmaneuver",
+  "outmanoeuvred": "outmaneuvered",
+  "outmanoeuvres": "outmaneuvers",
+  "outmanoeuvring": "outmaneuvering",
+  "overemphasise": "overemphasize",
+  "overemphasised": "overemphasized",
+  "overemphasises": "overemphasizes",
+  "overemphasising": "overemphasizing",
+  "oxidisation": "oxidization",
+  "oxidise": "oxidize",
+  "oxidised": "oxidized",
+  "oxidises": "oxidizes",
+  "oxidising": "oxidizing",
+  "paederast": "pederast",
+  "paederasts": "pederasts",
+  "paediatric": "pediatric",
+  "paediatrician": "pediatrician",
+  "paediatricians": "pediatricians",
+  "paediatrics": "pediatrics",
+  "paedophile": "pedophile",
+  "paedophiles": "pedophiles",
+  "paedophilia": "pedophilia",
+  "palaeolithic": "paleolithic",
+  "palaeontologist": "paleontologist",
+  "palaeontologists": "paleontologists",
+  "palaeontology": "paleontology",
+  "panelled": "paneled",
+  "panelling": "paneling",
+  "panellist": "panelist",
+  "panellists": "panelists",
+  "paralyse": "paralyze",
+  "paralysed": "paralyzed",
+  "paralyses": "paralyzes",
+  "paralysing": "paralyzing",
+  "parcelled": "parceled",
+  "parcelling": "parceling",
+  "parlour": "parlor",
+  "parlours": "parlors",
+  "particularise": "particularize",
+  "particularised": "particularized",
+  "particularises": "particularizes",
+  "particularising": "particularizing",
+  "passivisation": "passivization",
+  "passivise": "passivize",
+  "passivised": "passivized",
+  "passivises": "passivizes",
+  "passivising": "passivizing",
+  "pasteurisation": "pasteurization",
+  "pasteurise": "pasteurize",
+  "pasteurised": "pasteurized",
+  "pasteurises": "pasteurizes",
+  "pasteurising": "pasteurizing",
+  "patronise": "patronize",
+  "patronised": "patronized",
+  "patronises": "patronizes",
+  "patronising": "patronizing",
+  "patronisingly": "patronizingly",
+  "pedalled": "pedaled",
+  "pedalling": "pedaling",
+  "pedestrianisation": "pedestrianization",
+  "pedestrianise": "pedestrianize",
+  "pedestrianised": "pedestrianized",
+  "pedestrianises": "pedestrianizes",
+  "pedestrianising": "pedestrianizing",
+  "penalise": "penalize",
+  "penalised": "penalized",
+  "penalises": "penalizes",
+  "penalising": "penalizing",
+  "pencilled": "penciled",
+  "pencilling": "penciling",
+  "personalise": "personalize",
+  "personalised": "personalized",
+  "personalises": "personalizes",
+  "personalising": "personalizing",
+  "pharmacopoeia": "pharmacopeia",
+  "pharmacopoeias": "pharmacopeias",
+  "philosophise": "philosophize",
+  "philosophised": "philosophized",
+  "philosophises": "philosophizes",
+  "philosophising": "philosophizing",
+  "philtre": "filter",
+  "philtres": "filters",
+  "phoney": "phony",
+  "plagiarise": "plagiarize",
+  "plagiarised": "plagiarized",
+  "plagiarises": "plagiarizes",
+  "plagiarising": "plagiarizing",
+  "plough": "plow",
+  "ploughed": "plowed",
+  "ploughing": "plowing",
+  "ploughman": "plowman",
+  "ploughmen": "plowmen",
+  "ploughs": "plows",
+  "ploughshare": "plowshare",
+  "ploughshares": "plowshares",
+  "polarisation": "polarization",
+  "polarise": "polarize",
+  "polarised": "polarized",
+  "polarises": "polarizes",
+  "polarising": "polarizing",
+  "politicisation": "politicization",
+  "politicise": "politicize",
+  "politicised": "politicized",
+  "politicises": "politicizes",
+  "politicising": "politicizing",
+  "popularisation": "popularization",
+  "popularise": "popularize",
+  "popularised": "popularized",
+  "popularises": "popularizes",
+  "popularising": "popularizing",
+  "pouffe": "pouf",
+  "pouffes": "poufs",
+  "practise": "practice",
+  "practised": "practiced",
+  "practises": "practices",
+  "practising": "practicing",
+  "praesidium": "presidium",
+  "praesidiums": "presidiums",
+  "pressurisation": "pressurization",
+  "pressurise": "pressurize",
+  "pressurised": "pressurized",
+  "pressurises": "pressurizes",
+  "pressurising": "pressurizing",
+  "pretence": "pretense",
+  "pretences": "pretenses",
+  "primaeval": "primeval",
+  "prioritisation": "prioritization",
+  "prioritise": "prioritize",
+  "prioritised": "prioritized",
+  "prioritises": "prioritizes",
+  "prioritising": "prioritizing",
+  "privatisation": "privatization",
+  "privatisations": "privatizations",
+  "privatise": "privatize",
+  "privatised": "privatized",
+  "privatises": "privatizes",
+  "privatising": "privatizing",
+  "professionalisation": "professionalization",
+  "professionalise": "professionalize",
+  "professionalised": "professionalized",
+  "professionalises": "professionalizes",
+  "professionalising": "professionalizing",
+  "programme": "program",
+  "programmes": "programs",
+  "prologue": "prolog",
+  "prologues": "prologs",
+  "propagandise": "propagandize",
+  "propagandised": "propagandized",
+  "propagandises": "propagandizes",
+  "propagandising": "propagandizing",
+  "proselytise": "proselytize",
+  "proselytised": "proselytized",
+  "proselytiser": "proselytizer",
+  "proselytisers": "proselytizers",
+  "proselytises": "proselytizes",
+  "proselytising": "proselytizing",
+  "psychoanalyse": "psychoanalyze",
+  "psychoanalysed": "psychoanalyzed",
+  "psychoanalyses": "psychoanalyzes",
+  "psychoanalysing": "psychoanalyzing",
+  "publicise": "publicize",
+  "publicised": "publicized",
+  "publicises": "publicizes",
+  "publicising": "publicizing",
+  "pulverisation": "pulverization",
+  "pulverise": "pulverize",
+  "pulverised": "pulverized",
+  "pulverises": "pulverizes",
+  "pulverising": "pulverizing",
+  "pummelled": "pummel",
+  "pummelling": "pummeled",
+  "pyjama": "pajama",
+  "pyjamas": "pajamas",
+  "pzazz": "pizzazz",
+  "quarrelled": "quarreled",
+  "quarrelling": "quarreling",
+  "radicalise": "radicalize",
+  "radicalised": "radicalized",
+  "radicalises": "radicalizes",
+  "radicalising": "radicalizing",
+  "rancour": "rancor",
+  "randomise": "randomize",
+  "randomised": "randomized",
+  "randomises": "randomizes",
+  "randomising": "randomizing",
+  "rationalisation": "rationalization",
+  "rationalisations": "rationalizations",
+  "rationalise": "rationalize",
+  "rationalised": "rationalized",
+  "rationalises": "rationalizes",
+  "rationalising": "rationalizing",
+  "ravelled": "raveled",
+  "ravelling": "raveling",
+  "realisable": "realizable",
+  "realisation": "realization",
+  "realisations": "realizations",
+  "realise": "realize",
+  "realised": "realized",
+  "realises": "realizes",
+  "realising": "realizing",
+  "recognisable": "recognizable",
+  "recognisably": "recognizably",
+  "recognisance": "recognizance",
+  "recognise": "recognize",
+  "recognised": "recognized",
+  "recognises": "recognizes",
+  "recognising": "recognizing",
+  "reconnoitre": "reconnoiter",
+  "reconnoitred": "reconnoitered",
+  "reconnoitres": "reconnoiters",
+  "reconnoitring": "reconnoitering",
+  "refuelled": "refueled",
+  "refuelling": "refueling",
+  "regularisation": "regularization",
+  "regularise": "regularize",
+  "regularised": "regularized",
+  "regularises": "regularizes",
+  "regularising": "regularizing",
+  "remodelled": "remodeled",
+  "remodelling": "remodeling",
+  "remould": "remold",
+  "remoulded": "remolded",
+  "remoulding": "remolding",
+  "remoulds": "remolds",
+  "reorganisation": "reorganization",
+  "reorganisations": "reorganizations",
+  "reorganise": "reorganize",
+  "reorganised": "reorganized",
+  "reorganises": "reorganizes",
+  "reorganising": "reorganizing",
+  "revelled": "reveled",
+  "reveller": "reveler",
+  "revellers": "revelers",
+  "revelling": "reveling",
+  "revitalise": "revitalize",
+  "revitalised": "revitalized",
+  "revitalises": "revitalizes",
+  "revitalising": "revitalizing",
+  "revolutionise": "revolutionize",
+  "revolutionised": "revolutionized",
+  "revolutionises": "revolutionizes",
+  "revolutionising": "revolutionizing",
+  "rhapsodise": "rhapsodize",
+  "rhapsodised": "rhapsodized",
+  "rhapsodises": "rhapsodizes",
+  "rhapsodising": "rhapsodizing",
+  "rigour": "rigor",
+  "rigours": "rigors",
+  "ritualised": "ritualized",
+  "rivalled": "rivaled",
+  "rivalling": "rivaling",
+  "romanticise": "romanticize",
+  "romanticised": "romanticized",
+  "romanticises": "romanticizes",
+  "romanticising": "romanticizing",
+  "rumour": "rumor",
+  "rumoured": "rumored",
+  "rumours": "rumors",
+  "sabre": "saber",
+  "sabres": "sabers",
+  "saltpetre": "saltpeter",
+  "sanitise": "sanitize",
+  "sanitised": "sanitized",
+  "sanitises": "sanitizes",
+  "sanitising": "sanitizing",
+  "satirise": "satirize",
+  "satirised": "satirized",
+  "satirises": "satirizes",
+  "satirising": "satirizing",
+  "saviour": "savior",
+  "saviours": "saviors",
+  "savour": "savor",
+  "savoured": "savored",
+  "savouries": "savories",
+  "savouring": "savoring",
+  "savours": "savors",
+  "savoury": "savory",
+  "scandalise": "scandalize",
+  "scandalised": "scandalized",
+  "scandalises": "scandalizes",
+  "scandalising": "scandalizing",
+  "sceptic": "skeptic",
+  "sceptical": "skeptical",
+  "sceptically": "skeptically",
+  "scepticism": "skepticism",
+  "sceptics": "skeptics",
+  "sceptre": "scepter",
+  "sceptres": "scepters",
+  "scrutinise": "scrutinize",
+  "scrutinised": "scrutinized",
+  "scrutinises": "scrutinizes",
+  "scrutinising": "scrutinizing",
+  "secularisation": "secularization",
+  "secularise": "secularize",
+  "secularised": "secularized",
+  "secularises": "secularizes",
+  "secularising": "secularizing",
+  "sensationalise": "sensationalize",
+  "sensationalised": "sensationalized",
+  "sensationalises": "sensationalizes",
+  "sensationalising": "sensationalizing",
+  "sensitise": "sensitize",
+  "sensitised": "sensitized",
+  "sensitises": "sensitizes",
+  "sensitising": "sensitizing",
+  "sentimentalise": "sentimentalize",
+  "sentimentalised": "sentimentalized",
+  "sentimentalises": "sentimentalizes",
+  "sentimentalising": "sentimentalizing",
+  "sepulchre": "sepulcher",
+  "sepulchres": "sepulchers",
+  "serialisation": "serialization",
+  "serialisations": "serializations",
+  "serialise": "serialize",
+  "serialised": "serialized",
+  "serialises": "serializes",
+  "serialising": "serializing",
+  "sermonise": "sermonize",
+  "sermonised": "sermonized",
+  "sermonises": "sermonizes",
+  "sermonising": "sermonizing",
+  "sheikh": "sheik",
+  "shovelled": "shoveled",
+  "shovelling": "shoveling",
+  "shrivelled": "shriveled",
+  "shrivelling": "shriveling",
+  "signalise": "signalize",
+  "signalised": "signalized",
+  "signalises": "signalizes",
+  "signalising": "signalizing",
+  "signalled": "signaled",
+  "signalling": "signaling",
+  "smoulder": "smolder",
+  "smouldered": "smoldered",
+  "smouldering": "smoldering",
+  "smoulders": "smolders",
+  "snivelled": "sniveled",
+  "snivelling": "sniveling",
+  "snorkelled": "snorkeled",
+  "snorkelling": "snorkeling",
+  "snowplough": "snowplow",
+  "snowploughs": "snowplow",
+  "socialisation": "socialization",
+  "socialise": "socialize",
+  "socialised": "socialized",
+  "socialises": "socializes",
+  "socialising": "socializing",
+  "sodomise": "sodomize",
+  "sodomised": "sodomized",
+  "sodomises": "sodomizes",
+  "sodomising": "sodomizing",
+  "solemnise": "solemnize",
+  "solemnised": "solemnized",
+  "solemnises": "solemnizes",
+  "solemnising": "solemnizing",
+  "sombre": "somber",
+  "specialisation": "specialization",
+  "specialisations": "specializations",
+  "specialise": "specialize",
+  "specialised": "specialized",
+  "specialises": "specializes",
+  "specialising": "specializing",
+  "spectre": "specter",
+  "spectres": "specters",
+  "spiralled": "spiraled",
+  "spiralling": "spiraling",
+  "splendour": "splendor",
+  "splendours": "splendors",
+  "squirrelled": "squirreled",
+  "squirrelling": "squirreling",
+  "stabilisation": "stabilization",
+  "stabilise": "stabilize",
+  "stabilised": "stabilized",
+  "stabiliser": "stabilizer",
+  "stabilisers": "stabilizers",
+  "stabilises": "stabilizes",
+  "stabilising": "stabilizing",
+  "standardisation": "standardization",
+  "standardise": "standardize",
+  "standardised": "standardized",
+  "standardises": "standardizes",
+  "standardising": "standardizing",
+  "stencilled": "stenciled",
+  "stencilling": "stenciling",
+  "sterilisation": "sterilization",
+  "sterilisations": "sterilizations",
+  "sterilise": "sterilize",
+  "sterilised": "sterilized",
+  "steriliser": "sterilizer",
+  "sterilisers": "sterilizers",
+  "sterilises": "sterilizes",
+  "sterilising": "sterilizing",
+  "stigmatisation": "stigmatization",
+  "stigmatise": "stigmatize",
+  "stigmatised": "stigmatized",
+  "stigmatises": "stigmatizes",
+  "stigmatising": "stigmatizing",
+  "storey": "story",
+  "storeys": "stories",
+  "subsidisation": "subsidization",
+  "subsidise": "subsidize",
+  "subsidised": "subsidized",
+  "subsidiser": "subsidizer",
+  "subsidisers": "subsidizers",
+  "subsidises": "subsidizes",
+  "subsidising": "subsidizing",
+  "succour": "succor",
+  "succoured": "succored",
+  "succouring": "succoring",
+  "succours": "succors",
+  "sulphate": "sulfate",
+  "sulphates": "sulfates",
+  "sulphide": "sulfide",
+  "sulphides": "sulfides",
+  "sulphur": "sulfur",
+  "sulphurous": "sulfurous",
+  "summarise": "summarize",
+  "summarised": "summarized",
+  "summarises": "summarizes",
+  "summarising": "summarizing",
+  "swivelled": "swiveled",
+  "swivelling": "swiveling",
+  "symbolise": "symbolize",
+  "symbolised": "symbolized",
+  "symbolises": "symbolizes",
+  "symbolising": "symbolizing",
+  "sympathise": "sympathize",
+  "sympathised": "sympathized",
+  "sympathiser": "sympathizer",
+  "sympathisers": "sympathizers",
+  "sympathises": "sympathizes",
+  "sympathising": "sympathizing",
+  "synchronisation": "synchronization",
+  "synchronise": "synchronize",
+  "synchronised": "synchronized",
+  "synchronises": "synchronizes",
+  "synchronising": "synchronizing",
+  "synthesise": "synthesize",
+  "synthesised": "synthesized",
+  "synthesiser": "synthesizer",
+  "synthesisers": "synthesizers",
+  "synthesises": "synthesizes",
+  "synthesising": "synthesizing",
+  "syphon": "siphon",
+  "syphoned": "siphoned",
+  "syphoning": "siphoning",
+  "syphons": "siphons",
+  "systematisation": "systematization",
+  "systematise": "systematize",
+  "systematised": "systematized",
+  "systematises": "systematizes",
+  "systematising": "systematizing",
+  "tantalise": "tantalize",
+  "tantalised": "tantalized",
+  "tantalises": "tantalizes",
+  "tantalising": "tantalizing",
+  "tantalisingly": "tantalizingly",
+  "tasselled": "tasseled",
+  "technicolour": "technicolor",
+  "temporise": "temporize",
+  "temporised": "temporized",
+  "temporises": "temporizes",
+  "temporising": "temporizing",
+  "tenderise": "tenderize",
+  "tenderised": "tenderized",
+  "tenderises": "tenderizes",
+  "tenderising": "tenderizing",
+  "terrorise": "terrorize",
+  "terrorised": "terrorized",
+  "terrorises": "terrorizes",
+  "terrorising": "terrorizing",
+  "theatre": "theater",
+  "theatregoer": "theatergoer",
+  "theatregoers": "theatergoers",
+  "theatres": "theaters",
+  "theorise": "theorize",
+  "theorised": "theorized",
+  "theorises": "theorizes",
+  "theorising": "theorizing",
+  "tonne": "ton",
+  "tonnes": "tons",
+  "towelled": "toweled",
+  "towelling": "toweling",
+  "toxaemia": "toxemia",
+  "tranquillise": "tranquilize",
+  "tranquillised": "tranquilized",
+  "tranquilliser": "tranquilizer",
+  "tranquillisers": "tranquilizers",
+  "tranquillises": "tranquilizes",
+  "tranquillising": "tranquilizing",
+  "tranquillity": "tranquility",
+  "tranquillize": "tranquilize",
+  "tranquillized": "tranquilized",
+  "tranquillizer": "tranquilizer",
+  "tranquillizers": "tranquilizers",
+  "tranquillizes": "tranquilizes",
+  "tranquillizing": "tranquilizing",
+  "tranquilly": "tranquility",
+  "transistorised": "transistorized",
+  "traumatise": "traumatize",
+  "traumatised": "traumatized",
+  "traumatises": "traumatizes",
+  "traumatising": "traumatizing",
+  "travelled": "traveled",
+  "traveller": "traveler",
+  "travellers": "travelers",
+  "travelling": "traveling",
+  "travelog": "travelogue",
+  "travelogs": "travelogues",
+  "trialled": "trialed",
+  "trialling": "trialing",
+  "tricolour": "tricolor",
+  "tricolours": "tricolors",
+  "trivialise": "trivialize",
+  "trivialised": "trivialized",
+  "trivialises": "trivializes",
+  "trivialising": "trivializing",
+  "tumour": "tumor",
+  "tumours": "tumors",
+  "tunnelled": "tunneled",
+  "tunnelling": "tunneling",
+  "tyrannise": "tyrannize",
+  "tyrannised": "tyrannized",
+  "tyrannises": "tyrannizes",
+  "tyrannising": "tyrannizing",
+  "tyre": "tire",
+  "tyres": "tires",
+  "unauthorised": "unauthorized",
+  "uncivilised": "uncivilized",
+  "underutilised": "underutilized",
+  "unequalled": "unequaled",
+  "unfavourable": "unfavorable",
+  "unfavourably": "unfavorably",
+  "unionisation": "unionization",
+  "unionise": "unionize",
+  "unionised": "unionized",
+  "unionises": "unionizes",
+  "unionising": "unionizing",
+  "unorganised": "unorganized",
+  "unravelled": "unraveled",
+  "unravelling": "unraveling",
+  "unrecognisable": "unrecognizable",
+  "unrecognised": "unrecognized",
+  "unrivalled": "unrivaled",
+  "unsavoury": "unsavory",
+  "untrammelled": "untrammeled",
+  "urbanisation": "urbanization",
+  "urbanise": "urbanize",
+  "urbanised": "urbanized",
+  "urbanises": "urbanizes",
+  "urbanising": "urbanizing",
+  "utilisable": "utilizable",
+  "utilisation": "utilization",
+  "utilise": "utilize",
+  "utilised": "utilized",
+  "utilises": "utilizes",
+  "utilising": "utilizing",
+  "valour": "valor",
+  "vandalise": "vandalize",
+  "vandalised": "vandalized",
+  "vandalises": "vandalizes",
+  "vandalising": "vandalizing",
+  "vaporisation": "vaporization",
+  "vaporise": "vaporize",
+  "vaporised": "vaporized",
+  "vaporises": "vaporizes",
+  "vaporising": "vaporizing",
+  "vapour": "vapor",
+  "vapours": "vapors",
+  "verbalise": "verbalize",
+  "verbalised": "verbalized",
+  "verbalises": "verbalizes",
+  "verbalising": "verbalizing",
+  "victimisation": "victimization",
+  "victimise": "victimize",
+  "victimised": "victimized",
+  "victimises": "victimizes",
+  "victimising": "victimizing",
+  "videodisc": "videodisk",
+  "videodiscs": "videodisks",
+  "vigour": "vigor",
+  "visualisation": "visualization",
+  "visualisations": "visualizations",
+  "visualise": "visualize",
+  "visualised": "visualized",
+  "visualises": "visualizes",
+  "visualising": "visualizing",
+  "vocalisation": "vocalization",
+  "vocalisations": "vocalizations",
+  "vocalise": "vocalize",
+  "vocalised": "vocalized",
+  "vocalises": "vocalizes",
+  "vocalising": "vocalizing",
+  "vulcanised": "vulcanized",
+  "vulgarisation": "vulgarization",
+  "vulgarise": "vulgarize",
+  "vulgarised": "vulgarized",
+  "vulgarises": "vulgarizes",
+  "vulgarising": "vulgarizing",
+  "waggon": "wagon",
+  "waggons": "wagons",
+  "watercolour": "watercolor",
+  "watercolours": "watercolors",
+  "weaselled": "weaseled",
+  "weaselling": "weaseling",
+  "westernisation": "westernization",
+  "westernise": "westernize",
+  "westernised": "westernized",
+  "westernises": "westernizes",
+  "westernising": "westernizing",
+  "womanise": "womanize",
+  "womanised": "womanized",
+  "womaniser": "womanizer",
+  "womanisers": "womanizers",
+  "womanises": "womanizes",
+  "womanising": "womanizing",
+  "woollen": "woolen",
+  "woollens": "woolens",
+  "woollies": "woolies",
+  "woolly": "wooly",
+  "worshipped": "worshiped",
+  "worshipper": "worshiper",
+  "worshipping": "worshiping",
+  "yodelled": "yodeled",
+  "yodelling": "yodeling",
+  "yoghourt": "yogurt",
+  "yoghourts": "yogurts",
+  "yoghurt": "yogurt",
+  "yoghurts": "yogurts"
+}

preprocess_dataset.py

@@ -0,0 +1,89 @@
+from datasets import load_dataset, DatasetDict
+from transformers import WhisperFeatureExtractor
+from transformers import WhisperTokenizer
+from transformers import WhisperProcessor
+from datasets import Audio
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+from huggingface_hub import login
+
+import argparse
+
+my_parser = argparse.ArgumentParser()
+
+my_parser.add_argument(
+    "--model_name",
+    "-model_name",
+    type=str,
+    action="store",
+    default="openai/whisper-tiny",
+)
+my_parser.add_argument("--hf_token", "-hf_token", type=str, action="store")
+my_parser.add_argument(
+    "--dataset_name", "-dataset_name", type=str, action="store", default="google/fleurs"
+)
+my_parser.add_argument("--split", "-split", type=str, action="store", default="test")
+my_parser.add_argument("--subset", "-subset", type=str, action="store")
+
+args = my_parser.parse_args()
+
+dataset_name = args.dataset_name
+model_name = args.model_name
+subset = args.subset
+hf_token = args.hf_token
+login(hf_token)
+text_column = "sentence"
+if dataset_name == "google/fleurs":
+    text_column = "transcription"
+
+do_lower_case = False
+do_remove_punctuation = False
+
+normalizer = BasicTextNormalizer()
+processor = WhisperProcessor.from_pretrained(
+    model_name, language="Arabic", task="transcribe"
+)
+dataset = load_dataset(dataset_name, subset, use_auth_token=True)
+
+print(dataset)
+
+feature_extractor = WhisperFeatureExtractor.from_pretrained(model_name)
+
+tokenizer = WhisperTokenizer.from_pretrained(
+    model_name, language="Arabic", task="transcribe"
+)
+dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
+
+
+def prepare_dataset(batch):
+    # load and (possibly) resample audio data to 16kHz
+    audio = batch["audio"]
+
+    # compute log-Mel input features from input audio array
+    batch["input_features"] = processor.feature_extractor(
+        audio["array"], sampling_rate=audio["sampling_rate"]
+    ).input_features[0]
+    # compute input length of audio sample in seconds
+    batch["input_length"] = len(audio["array"]) / audio["sampling_rate"]
+
+    # optional pre-processing steps
+    transcription = batch[text_column]
+    if do_lower_case:
+        transcription = transcription.lower()
+    if do_remove_punctuation:
+        transcription = normalizer(transcription).strip()
+
+    # encode target text to label ids
+    batch["labels"] = processor.tokenizer(transcription).input_ids
+    return batch
+
+
+dataset = dataset.map(prepare_dataset, remove_columns=dataset.column_names["train"])
+
+login(hf_token)
+print(
+    f"pushing to arbml/{dataset_name.split('/')[-1]}_preprocessed_{model_name.split('/')[-1]}"
+)
+dataset.push_to_hub(
+    f"arbml/{dataset_name.split('/')[-1]}_preprocessed_{model_name.split('/')[-1]}",
+    private=True,
+)

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:741f78834421d6167313de767bbe172b6f5319506073dda3ff2255c81647ee73
+size 967102601

requirements.txt

@@ -0,0 +1,14 @@
+torch>=1.7
+torchaudio
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/datasets
+librosa
+jiwer
+evaluate>=0.3.0
+more-itertools
+tensorboard
+bitsandbytes
+sentencepiece
+accelerate 
+deepspeed
+pyarabic

requirements_colab.txt

@@ -0,0 +1,11 @@
+torchaudio==0.11.0
+git+https://github.com/huggingface/transformers
+git+https://github.com/huggingface/datasets
+librosa
+jiwer
+evaluate>=0.3.0
+more-itertools
+tensorboard
+bitsandbytes
+accelerate deepspeed
+pyarabic

run.sh

@@ -0,0 +1,38 @@
+python run_speech_recognition_seq2seq_streaming.py \
+--model_name_or_path="openai/whisper-small" \
+--dataset_name="mozilla-foundation/common_voice_11_0" \
+--dataset_config_name="ar" \
+--language="Arabic" \
+--train_split_name="train+validation" \
+--eval_split_name="test" \
+--model_index_name="Whisper Small Arabic" \
+--max_steps="5000" \
+--output_dir="./" \
+--per_device_train_batch_size="64" \
+--per_device_eval_batch_size="32" \
+--logging_steps="25" \
+--learning_rate="1e-5" \
+--warmup_steps="500" \
+--evaluation_strategy="steps" \
+--eval_steps="1000" \
+--save_strategy="steps" \
+--save_steps="1000" \
+--generation_max_length="225" \
+--length_column_name="input_length" \
+--max_duration_in_seconds="30" \
+--text_column_name="sentence" \
+--freeze_feature_encoder="False" \
+--report_to="tensorboard" \
+--metric_for_best_model="wer" \
+--greater_is_better="False" \
+--load_best_model_at_end \
+--gradient_checkpointing \
+--fp16 \
+--overwrite_output_dir \
+--optim="adamw_bnb_8bit" \
+--do_train \
+--do_eval \
+--predict_with_generate \
+--do_normalize_eval \
+--use_auth_token \
+--push_to_hub

run_eval_cv_11.sh

@@ -0,0 +1,10 @@
+python run_eval_whisper_streaming.py \
+        --dataset mozilla-foundation/common_voice_11_0 \
+        --model_id $1 \
+        --split test \
+        --config="ar" \
+        --batch_size="16" \
+        --remove_diacritics="True" \
+        --language="ar" \
+        --device 0 \
+        --streaming="False"

run_eval_fleurs.sh

@@ -0,0 +1,10 @@
+python run_eval_whisper_streaming.py \
+        --dataset google/fleurs \
+        --model_id $1 \
+        --split test \
+        --config ar_eg \
+        --batch_size="16" \
+        --remove_diacritics="True" \
+        --language="ar" \
+        --device 0 \
+        --streaming="False"

run_eval_whisper_streaming.py

@@ -0,0 +1,166 @@
+import argparse
+import pyarabic.araby as araby
+from transformers import pipeline
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+from datasets import load_dataset, Audio
+import evaluate
+
+wer_metric = evaluate.load("wer")
+
+
+def is_target_text_in_range(ref):
+    if ref.strip() == "ignore time segment in scoring":
+        return False
+    else:
+        return ref.strip() != ""
+
+
+def get_text(sample):
+    if "text" in sample:
+        return sample["text"]
+    elif "sentence" in sample:
+        return sample["sentence"]
+    elif "normalized_text" in sample:
+        return sample["normalized_text"]
+    elif "transcript" in sample:
+        return sample["transcript"]
+    elif "transcription" in sample:
+        return sample["transcription"]
+    else:
+        raise ValueError(
+            f"Expected transcript column of either 'text', 'sentence', 'normalized_text' or 'transcript'. Got sample of "
+            ".join{sample.keys()}. Ensure a text column name is present in the dataset."
+        )
+
+
+whisper_norm = BasicTextNormalizer()
+
+
+def normalise(batch):
+    batch["norm_text"] = whisper_norm(get_text(batch))
+    return batch
+
+
+def remove_diacritics(batch):
+    batch["norm_text"] = araby.strip_diacritics(get_text(batch))
+    return batch
+
+
+def data(dataset):
+    for i, item in enumerate(dataset):
+        yield {**item["audio"], "reference": item["norm_text"]}
+
+
+def main(args):
+    batch_size = args.batch_size
+    whisper_asr = pipeline(
+        "automatic-speech-recognition", model=args.model_id, device=args.device
+    )
+
+    whisper_asr.model.config.forced_decoder_ids = (
+        whisper_asr.tokenizer.get_decoder_prompt_ids(
+            language=args.language, task="transcribe"
+        )
+    )
+
+    dataset = load_dataset(
+        args.dataset,
+        args.config,
+        split=args.split,
+        streaming=args.streaming,
+        use_auth_token=True,
+    )
+
+    # Only uncomment for debugging
+    dataset = dataset.take(args.max_eval_samples)
+
+    dataset = dataset.cast_column("audio", Audio(sampling_rate=16000))
+    dataset = dataset.map(normalise)
+    if args.remove_diacritics:
+        print("stripping diacritics")
+        dataset = dataset.map(remove_diacritics)
+    dataset = dataset.filter(is_target_text_in_range, input_columns=["norm_text"])
+
+    predictions = []
+    references = []
+
+    # run streamed inference
+    for out in whisper_asr(data(dataset), batch_size=batch_size):
+        predictions.append(whisper_norm(out["text"]))
+        references.append(out["reference"][0])
+
+    wer = wer_metric.compute(references=references, predictions=predictions)
+    wer = round(100 * wer, 2)
+
+    print("WER:", wer)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument(
+        "--model_id",
+        type=str,
+        required=True,
+        help="Model identifier. Should be loadable with 🤗 Transformers",
+    )
+    parser.add_argument(
+        "--dataset",
+        type=str,
+        default="mozilla-foundation/common_voice_11_0",
+        help="Dataset name to evaluate the `model_id`. Should be loadable with 🤗 Datasets",
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        required=True,
+        help="Config of the dataset. *E.g.* `'en'` for the English split of Common Voice",
+    )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="test",
+        help="Split of the dataset. *E.g.* `'test'`",
+    )
+
+    parser.add_argument(
+        "--device",
+        type=int,
+        default=-1,
+        help="The device to run the pipeline on. -1 for CPU (default), 0 for the first GPU and so on.",
+    )
+    parser.add_argument(
+        "--batch_size",
+        type=int,
+        default=16,
+        help="Number of samples to go through each streamed batch.",
+    )
+    parser.add_argument(
+        "--max_eval_samples",
+        type=int,
+        default=None,
+        help="Number of samples to be evaluated. Put a lower number e.g. 64 for testing this script.",
+    )
+    parser.add_argument(
+        "--streaming",
+        type=bool,
+        default=True,
+        help="Choose whether you'd like to download the entire dataset or stream it during the evaluation.",
+    )
+    parser.add_argument(
+        "--language",
+        type=str,
+        required=True,
+        help="Two letter language code for the transcription language, e.g. use 'en' for English.",
+    )
+
+    parser.add_argument(
+        "--remove_diacritics",
+        type=bool,
+        default=False,
+        help="Choose whether you'd like remove_diacritics",
+    )
+
+    args = parser.parse_args()
+
+    main(args)

run_mgb2.sh

@@ -0,0 +1,38 @@
+python run_speech_recognition_seq2seq_mixed_mgb2-cv1.py \
+--model_name_or_path="openai/whisper-small" \
+--dataset_name="arbml/mgb2_speech" \
+--dataset_config_name="ar" \
+--language="Arabic" \
+--train_split_name="train" \
+--eval_split_name="test" \
+--model_index_name="Whisper Small Arabic" \
+--max_steps="5000" \
+--output_dir="./" \
+--per_device_train_batch_size="64" \
+--per_device_eval_batch_size="8" \
+--logging_steps="25" \
+--learning_rate="1e-5" \
+--warmup_steps="500" \
+--evaluation_strategy="steps" \
+--eval_steps="1000" \
+--save_strategy="steps" \
+--save_steps="1000" \
+--generation_max_length="225" \
+--length_column_name="input_length" \
+--max_duration_in_seconds="30" \
+--text_column_name="sentence" \
+--freeze_feature_encoder="False" \
+--report_to="tensorboard" \
+--metric_for_best_model="wer" \
+--greater_is_better="False" \
+--load_best_model_at_end \
+--gradient_checkpointing \
+--fp16 \
+--overwrite_output_dir \
+--optim="adamw_bnb_8bit" \
+--do_train \
+--do_eval \
+--predict_with_generate \
+--do_normalize_eval \
+--use_auth_token \
+--push_to_hub

run_mgb2_deepspeed.sh

@@ -0,0 +1,38 @@
+deepspeed run_speech_recognition_seq2seq_mixed_mgb2.py \
+--model_name_or_path="openai/whisper-small" \
+--deepspeed="ds_config.json" \
+--dataset_name="arbml/mgb2_speech" \
+--dataset_config_name="ar" \
+--language="Arabic" \
+--train_split_name="train" \
+--eval_split_name="test" \
+--model_index_name="Whisper Small Arabic" \
+--max_steps="5000" \
+--output_dir="./" \
+--per_device_train_batch_size="16" \
+--per_device_eval_batch_size="8" \
+--logging_steps="25" \
+--learning_rate="1e-5" \
+--warmup_steps="500" \
+--evaluation_strategy="steps" \
+--eval_steps="1000" \
+--save_strategy="steps" \
+--save_steps="1000" \
+--generation_max_length="225" \
+--length_column_name="input_length" \
+--max_duration_in_seconds="30" \
+--text_column_name="text" \
+--freeze_feature_encoder="False" \
+--report_to="tensorboard" \
+--metric_for_best_model="wer" \
+--greater_is_better="False" \
+--load_best_model_at_end \
+--gradient_checkpointing \
+--fp16 \
+--overwrite_output_dir \
+--do_train \
+--do_eval \
+--predict_with_generate \
+--do_normalize_eval \
+--use_auth_token \
+--push_to_hub

run_speech_recognition_seq2seq.py

@@ -0,0 +1,607 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for sequence to sequence speech recognition.
+"""
+# You can also adapt this script for your own sequence to sequence speech
+# recognition task. Pointers for this are left as comments.
+
+import logging
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+import datasets
+import torch
+from datasets import IterableDatasetDict, interleave_datasets, load_dataset
+from torch.utils.data import IterableDataset
+
+import evaluate
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoFeatureExtractor,
+    AutoModelForSpeechSeq2Seq,
+    AutoProcessor,
+    AutoTokenizer,
+    HfArgumentParser,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+    TrainerCallback,
+    set_seed,
+)
+from transformers.trainer_pt_utils import IterableDatasetShard
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+import os
+os.environ['LD_LIBRARY_PATH'] = '/usr/lib/x86_64-linux-gnu'
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.25.0.dev0")
+
+require_version("datasets>=1.18.2", "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt")
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    feature_extractor_name: Optional[str] = field(
+        default=None, metadata={"help": "feature extractor name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+                "with private models)."
+            )
+        },
+    )
+    freeze_feature_encoder: bool = field(
+        default=True, metadata={"help": "Whether to freeze the feature encoder layers of the model."}
+    )
+    freeze_encoder: bool = field(
+        default=False, metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."}
+    )
+    forced_decoder_ids: List[List[int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "A list of pairs of integers which indicates a mapping from generation indices to token indices "
+                "that will be forced before sampling. For example, [[0, 123]] means the first generated token "
+                "will always be a token of index 123."
+            )
+        },
+    )
+    suppress_tokens: List[int] = field(
+        default=None, metadata={"help": "A list of tokens that will be suppressed at generation."}
+    )
+    model_index_name: str = field(default=None, metadata={"help": "Pretty name for the model card."})
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: str = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    text_column: Optional[str] = field(
+        default=None,
+        metadata={"help": "The name of the column in the datasets containing the full texts (for summarization)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of training examples to this "
+                "value if set."
+            )
+        },
+    )
+    max_eval_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of evaluation examples to this "
+                "value if set."
+            )
+        },
+    )
+    audio_column_name: str = field(
+        default="audio",
+        metadata={"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"},
+    )
+    text_column_name: str = field(
+        default="text",
+        metadata={"help": "The name of the dataset column containing the text data. Defaults to 'text'"},
+    )
+    max_duration_in_seconds: float = field(
+        default=20.0,
+        metadata={
+            "help": (
+                "Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
+                " 'max_duration_in_seconds`"
+            )
+        },
+    )
+    min_duration_in_seconds: float = field(
+        default=0.0, metadata={"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"}
+    )
+    train_split_name: str = field(
+        default="train",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    eval_split_name: str = field(
+        default="test",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    do_lower_case: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be lower cased."},
+    )
+    do_remove_punctuation: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be striped of punctuation."},
+    )
+    do_normalize_eval: bool = field(
+        default=True,
+        metadata={"help": "Whether to normalise the references and predictions in the eval WER calculation."},
+    )
+    language: str = field(
+        default=None,
+        metadata={
+            "help": (
+                "Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
+                "only. For English speech recognition, it should be set to `None`."
+            )
+        },
+    )
+    task: str = field(
+        default="transcribe",
+        metadata={"help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."},
+    )
+    shuffle_buffer_size: Optional[int] = field(
+        default=500,
+        metadata={
+            "help": (
+                "The number of streamed examples to download before shuffling them. The large the buffer, "
+                "the closer it is to real offline shuffling."
+            )
+        },
+    )
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor ([`WhisperProcessor`])
+            The processor used for processing the data.
+        decoder_start_token_id (`int`)
+            The begin-of-sentence of the decoder.
+    """
+
+    processor: Any
+    decoder_start_token_id: int
+
+    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need
+        # different padding methods
+        model_input_name = self.processor.model_input_names[0]
+        input_features = [{model_input_name: feature[model_input_name]} for feature in features]
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+
+        batch = self.processor.feature_extractor.pad(input_features, return_tensors="pt")
+
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def load_datasets(dataset_name, dataset_config_name, split="train", **kwargs):
+    """
+    Utility function to load a dataset in streaming mode. For datasets with multiple splits,
+    each split is loaded individually and then splits combined by taking alternating examples from
+    each (interleaving).
+    """
+    if "+" in split:
+        # load multiple splits separated by the `+` symbol with streaming mode
+        dataset_splits = [
+            load_dataset(dataset_name, dataset_config_name, split=split_name, **kwargs)
+            for split_name in split.split("+")
+        ]
+        # interleave multiple splits to form one dataset
+        interleaved_dataset = interleave_datasets(dataset_splits)
+        return interleaved_dataset
+    else:
+        # load a single split *with* streaming mode
+        dataset = load_dataset(dataset_name, dataset_config_name, split=split, **kwargs)
+        return dataset
+
+
+def main():
+    # 1. Parse input arguments
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
+
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
+    # information sent is the one passed as arguments along with your Python/PyTorch versions.
+    send_example_telemetry("run_speech_recognition_seq2seq", model_args, data_args)
+
+    # 2. Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    log_level = training_args.get_process_log_level()
+    logger.setLevel(log_level)
+    datasets.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.enable_default_handler()
+    transformers.utils.logging.enable_explicit_format()
+
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # 3. Detecting last checkpoint and eventually continue from last checkpoint
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # 4. Load dataset
+    raw_datasets = IterableDatasetDict()
+
+    if training_args.do_train:
+        raw_datasets["train"] = load_datasets(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.train_split_name,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    if training_args.do_eval:
+        raw_datasets["eval"] = load_datasets(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.eval_split_name,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+
+    if data_args.audio_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--audio_column_name` to the correct audio column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    if data_args.text_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--text_column_name` to the correct text column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    # 5. Load pretrained model, tokenizer, and feature extractor
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    config = AutoConfig.from_pretrained(
+        model_args.config_name if model_args.config_name else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    config.update({"forced_decoder_ids": model_args.forced_decoder_ids, "suppress_tokens": model_args.suppress_tokens})
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        use_fast=model_args.use_fast_tokenizer,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        model_args.model_name_or_path,
+        config=config,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model.config.use_cache = False
+
+    if model.config.decoder_start_token_id is None:
+        raise ValueError("Make sure that `config.decoder_start_token_id` is correctly defined")
+
+    if model_args.freeze_feature_encoder:
+        model.freeze_feature_encoder()
+
+    if model_args.freeze_encoder:
+        model.freeze_encoder()
+        model.model.encoder.gradient_checkpointing = False
+
+    if data_args.language is not None:
+        # We only need to set the task id when the language is specified (i.e. in a multilingual setting)
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
+
+    # 6. Resample speech dataset if necessary
+    dataset_sampling_rate = next(iter(raw_datasets.values())).features[data_args.audio_column_name].sampling_rate
+    if dataset_sampling_rate != feature_extractor.sampling_rate:
+        raw_datasets = raw_datasets.cast_column(
+            data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate)
+        )
+
+    # 7. Preprocessing the datasets.
+    # We need to read the audio files as arrays and tokenize the targets.
+    max_input_length = data_args.max_duration_in_seconds * feature_extractor.sampling_rate
+    min_input_length = data_args.min_duration_in_seconds * feature_extractor.sampling_rate
+    audio_column_name = data_args.audio_column_name
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    do_lower_case = data_args.do_lower_case
+    do_remove_punctuation = data_args.do_remove_punctuation
+    normalizer = BasicTextNormalizer()  # 'official' text normalizer from OpenAI
+
+    if data_args.max_train_samples is not None:
+        raw_datasets["train"] = raw_datasets["train"].select(range(data_args.max_train_samples))
+
+    if data_args.max_eval_samples is not None:
+        raw_datasets["eval"] = raw_datasets["eval"].select(range(data_args.max_eval_samples))
+
+    def prepare_dataset(batch):
+        # process audio
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample["array"], sampling_rate=sample["sampling_rate"])
+        # process audio length
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch["input_length"] = len(sample["array"])
+
+        # process targets
+        input_str = batch[text_column_name].lower() if do_lower_case else batch[text_column_name]
+        if do_remove_punctuation:
+            input_str = normalizer(input_str).strip()
+        batch["labels"] = tokenizer(input_str).input_ids
+        return batch
+
+    with training_args.main_process_first(desc="dataset map pre-processing"):
+        vectorized_datasets = raw_datasets.map(
+            prepare_dataset,
+            remove_columns=raw_datasets_features,
+        ).with_format("torch")
+
+        if training_args.do_train:
+            vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
+                # buffer_size=data_args.shuffle_buffer_size,
+                seed=training_args.seed,
+            )
+
+    # filter training data that is shorter than min_input_length or longer than
+    # max_input_length
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+
+    vectorized_datasets["train"] = vectorized_datasets["train"].filter(
+        is_audio_in_length_range,
+        input_columns=["input_length"],
+    )
+
+    # 8. Load Metric
+    metric = evaluate.load("wer")
+    do_normalize_eval = data_args.do_normalize_eval
+
+    def compute_metrics(pred):
+        pred_ids = pred.predictions
+
+        pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
+
+        pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
+        # we do not want to group tokens when computing the metrics
+        label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
+
+        if do_normalize_eval:
+            pred_str = [normalizer(pred) for pred in pred_str]
+            label_str = [normalizer(label) for label in label_str]
+
+        wer = 100 * metric.compute(predictions=pred_str, references=label_str)
+
+        return {"wer": wer}
+
+    # 9. Create a single speech processor
+    if is_main_process(training_args.local_rank):
+        # save feature extractor, tokenizer and config
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+
+    processor = AutoProcessor.from_pretrained(training_args.output_dir)
+
+    # 10. Define data collator
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(
+        processor=processor,
+        decoder_start_token_id=model.config.decoder_start_token_id,
+    )
+
+    # 11. Configure Trainer
+    # Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
+    class ShuffleCallback(TrainerCallback):
+        def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
+            if isinstance(train_dataloader.dataset, IterableDatasetShard):
+                pass  # set_epoch() is handled by the Trainer
+            elif isinstance(train_dataloader.dataset, IterableDataset):
+                train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
+
+    # Initialize Trainer
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
+        eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
+        tokenizer=feature_extractor,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics if training_args.predict_with_generate else None,
+        callbacks=[ShuffleCallback()],
+    )
+
+    # 12. Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the feature extractor too for easy upload
+
+        metrics = train_result.metrics
+        if data_args.max_train_samples:
+            metrics["train_samples"] = data_args.max_train_samples
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # 13. Evaluation
+    results = {}
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+        metrics = trainer.evaluate(
+            metric_key_prefix="eval",
+            max_length=training_args.generation_max_length,
+            num_beams=training_args.generation_num_beams,
+        )
+        if data_args.max_eval_samples:
+            metrics["eval_samples"] = data_args.max_eval_samples
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+    # 14. Write Training Stats
+    kwargs = {
+        "finetuned_from": model_args.model_name_or_path,
+        "tasks": "automatic-speech-recognition",
+        "tags": "whisper-event",
+    }
+    if data_args.dataset_name is not None:
+        kwargs["dataset_tags"] = data_args.dataset_name
+        if data_args.dataset_config_name is not None:
+            kwargs["dataset"] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
+        else:
+            kwargs["dataset"] = data_args.dataset_name
+        if "common_voice" in data_args.dataset_name:
+            kwargs["language"] = data_args.dataset_config_name
+        if model_args.model_index_name is not None:
+            kwargs["model_name"] = model_args.model_index_name
+
+    if training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(**kwargs)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()

run_speech_recognition_seq2seq_mixed_mgb2-cv1.py

@@ -0,0 +1,802 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for sequence to sequence speech recognition
+with 🤗 Datasets' streaming mode.
+"""
+# You can also adapt this script for your own sequence to sequence speech
+# recognition task. Pointers for this are left as comments.
+
+import logging
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+import datasets
+import torch
+from datasets import DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset
+from datasets import Audio, interleave_datasets, IterableDataset
+from torch.utils.data import IterableDataset
+
+import evaluate
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoFeatureExtractor,
+    AutoModelForSpeechSeq2Seq,
+    AutoProcessor,
+    AutoTokenizer,
+    HfArgumentParser,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+    TrainerCallback,
+    set_seed,
+)
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+from transformers.trainer_pt_utils import IterableDatasetShard
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.25.0.dev0")
+
+require_version(
+    "datasets>=1.18.2",
+    "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt",
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={
+            "help": "Path to pretrained model or model identifier from huggingface.co/models"
+        }
+    )
+    config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained config name or path if not the same as model_name"
+        },
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained tokenizer name or path if not the same as model_name"
+        },
+    )
+    feature_extractor_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "feature extractor name or path if not the same as model_name"
+        },
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Where to store the pretrained models downloaded from huggingface.co"
+        },
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."
+        },
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={
+            "help": "The specific model version to use (can be a branch name, tag name or commit id)."
+        },
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+                "with private models)."
+            )
+        },
+    )
+    freeze_feature_encoder: bool = field(
+        default=True,
+        metadata={"help": "Whether to freeze the feature encoder layers of the model."},
+    )
+    freeze_encoder: bool = field(
+        default=False,
+        metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."},
+    )
+    forced_decoder_ids: List[List[int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "A list of pairs of integers which indicates a mapping from generation indices to token indices "
+                "that will be forced before sampling. For example, [[0, 123]] means the first generated token "
+                "will always be a token of index 123."
+            )
+        },
+    )
+    suppress_tokens: List[int] = field(
+        default=None,
+        metadata={"help": "A list of tokens that will be suppressed at generation."},
+    )
+    model_index_name: str = field(
+        default=None, metadata={"help": "Pretty name for the model card."}
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: str = field(
+        default=None,
+        metadata={"help": "The name of the dataset to use (via the datasets library)."},
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The configuration name of the dataset to use (via the datasets library)."
+        },
+    )
+    text_column: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The name of the column in the datasets containing the full texts (for summarization)."
+        },
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of training examples to this "
+                "value if set."
+            )
+        },
+    )
+    max_eval_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of evaluation examples to this "
+                "value if set."
+            )
+        },
+    )
+    audio_column_name: str = field(
+        default="audio",
+        metadata={
+            "help": "The name of the dataset column containing the audio data. Defaults to 'audio'"
+        },
+    )
+    text_column_name: str = field(
+        default="text",
+        metadata={
+            "help": "The name of the dataset column containing the text data. Defaults to 'text'"
+        },
+    )
+    max_duration_in_seconds: float = field(
+        default=20.0,
+        metadata={
+            "help": (
+                "Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
+                " 'max_duration_in_seconds`"
+            )
+        },
+    )
+    min_duration_in_seconds: float = field(
+        default=0.0,
+        metadata={
+            "help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"
+        },
+    )
+    train_split_name: str = field(
+        default="train",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    eval_split_name: str = field(
+        default="test",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    do_lower_case: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be lower cased."},
+    )
+    do_remove_punctuation: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be striped of punctuation."},
+    )
+    do_normalize_eval: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to normalise the references and predictions in the eval WER calculation."
+        },
+    )
+    language: str = field(
+        default=None,
+        metadata={
+            "help": (
+                "Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
+                "only. For English speech recognition, it should be set to `None`."
+            )
+        },
+    )
+    task: str = field(
+        default="transcribe",
+        metadata={
+            "help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."
+        },
+    )
+    shuffle_buffer_size: Optional[int] = field(
+        default=500,
+        metadata={
+            "help": (
+                "The number of streamed examples to download before shuffling them. The large the buffer, "
+                "the closer it is to real offline shuffling."
+            )
+        },
+    )
+    streaming: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use streaming mode to load and pre-process the data."
+        },
+    )
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor ([`WhisperProcessor`])
+            The processor used for processing the data.
+        decoder_start_token_id (`int`)
+            The begin-of-sentence of the decoder.
+    """
+
+    processor: Any
+    decoder_start_token_id: int
+
+    def __call__(
+        self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
+    ) -> Dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need
+        # different padding methods
+        model_input_name = self.processor.model_input_names[0]
+        input_features = [
+            {model_input_name: feature[model_input_name]} for feature in features
+        ]
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+
+        batch = self.processor.feature_extractor.pad(
+            input_features, return_tensors="pt"
+        )
+
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(
+            labels_batch.attention_mask.ne(1), -100
+        )
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def load_maybe_streaming_dataset(
+    dataset_name, dataset_config_name, split="train", streaming=True, **kwargs
+):
+    """
+    Utility function to load a dataset in streaming mode. For datasets with multiple splits,
+    each split is loaded individually and then splits combined by taking alternating examples from
+    each (interleaving).
+    """
+    if "+" in split:
+        # load multiple splits separated by the `+` symbol with streaming mode
+        dataset_splits = [
+            load_dataset(
+                dataset_name,
+                dataset_config_name,
+                split=split_name,
+                streaming=streaming,
+                **kwargs,
+            )
+            for split_name in split.split("+")
+        ]
+        # interleave multiple splits to form one dataset
+        interleaved_dataset = interleave_datasets(dataset_splits)
+        return interleaved_dataset
+    else:
+        # load a single split *with* streaming mode
+        dataset = load_dataset(
+            dataset_name,
+            dataset_config_name,
+            split=split,
+            streaming=streaming,
+            **kwargs,
+        )
+        return dataset
+
+def load_multiple_streaming_datasets(
+    dataset_names: List,
+    dataset_config_names: List,
+    splits: Optional[List] = None,
+    text_column_names: Optional[List] = None,
+    sampling_rate: Optional[int] = 16000,
+    stopping_strategy: Optional[str] = "first_exhausted",
+    **kwargs
+) -> IterableDataset:
+
+    if len(dataset_names) != len(dataset_config_names):
+        raise ValueError(
+            f"Ensure one config is passed for each dataset, got {len(dataset_names)} datasets and"
+            f" {len(dataset_config_names)} configs."
+        )
+
+    if splits is not None and len(splits) != len(dataset_names):
+        raise ValueError(
+            f"Ensure one split is passed for each dataset, got {len(dataset_names)} datasets and {len(splits)} splits."
+        )
+
+    if text_column_names is not None and len(text_column_names) != len(dataset_names):
+        raise ValueError(
+            f"Ensure one text column name is passed for each dataset, got {len(dataset_names)} datasets and"
+            f" {len(text_column_names)} text column names."
+        )
+
+    splits = splits if splits is not None else ["train" for i in range(len(dataset_names))]
+    text_column_names = (
+        text_column_names if text_column_names is not None else ["text" for i in range(len(dataset_names))]
+    )
+
+    all_datasets = []
+    # iterate over the datasets we want to interleave
+    for i, dataset_name in enumerate(dataset_names):
+        dataset = load_dataset(dataset_name, dataset_config_names[i], split=splits[i], streaming=True, **kwargs)
+        print(dataset)
+        # resample to specified sampling rate
+        dataset = dataset.cast_column("audio", Audio(sampling_rate))
+        #  normalise columns to ["audio", "sentence"]
+        if text_column_names[i] != "sentence":
+            dataset = dataset.rename_column(text_column_names[i], "sentence")
+        dataset = dataset.remove_columns(set(dataset.features.keys()) - set(["audio", "sentence"]))
+        all_datasets.append(dataset)
+        print("DATASET:",dataset.features.keys())
+    interleaved_dataset = interleave_datasets(all_datasets, stopping_strategy=stopping_strategy)
+    return interleaved_dataset
+
+    
+def main():
+    # 1. Parse input arguments
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+    parser = HfArgumentParser(
+        (ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments)
+    )
+
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
+    # information sent is the one passed as arguments along with your Python/PyTorch versions.
+    send_example_telemetry(
+        "run_speech_recognition_seq2seq_streaming", model_args, data_args
+    )
+
+    # 2. Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    log_level = training_args.get_process_log_level()
+    logger.setLevel(log_level)
+    datasets.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.enable_default_handler()
+    transformers.utils.logging.enable_explicit_format()
+
+    logger.setLevel(
+        logging.INFO if is_main_process(training_args.local_rank) else logging.WARN
+    )
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # 3. Detecting last checkpoint and eventually continue from last checkpoint
+    last_checkpoint = None
+    if (
+        os.path.isdir(training_args.output_dir)
+        and training_args.do_train
+        and not training_args.overwrite_output_dir
+    ):
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif (
+            last_checkpoint is not None and training_args.resume_from_checkpoint is None
+        ):
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # 4. Load dataset
+    raw_datasets = IterableDatasetDict()
+
+    dataset_names = ["mozilla-foundation/common_voice_11_0", "arbml/mgb2_speech", ]
+    dataset_config_names = ["ar", "ar", ]
+    text_column_names = ["sentence", "text",]
+
+    if training_args.do_train:
+        raw_datasets["train"] = load_multiple_streaming_datasets(
+            dataset_names,
+            dataset_config_names=dataset_config_names,
+            text_column_names=text_column_names,
+            splits=["train","train"],
+            use_auth_token=True
+        )
+        
+    if training_args.do_eval:
+        raw_datasets["eval"] = load_multiple_streaming_datasets(
+            dataset_names,
+            dataset_config_names=dataset_config_names,
+            text_column_names=text_column_names,
+            splits=["validation","validation"],
+            use_auth_token=True
+        )
+
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+    
+    if data_args.audio_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--audio_column_name` to the correct audio column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    # if data_args.text_column_name not in raw_datasets_features:
+    #     print("raw_datasets_features:",raw_datasets_features)
+    #     raise ValueError(
+    #         f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
+    #         "Make sure to set `--text_column_name` to the correct text column - one of "
+    #         f"{', '.join(raw_datasets_features)}."
+    #     )
+
+    # 5. Load pretrained model, tokenizer, and feature extractor
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    config = AutoConfig.from_pretrained(
+        model_args.config_name
+        if model_args.config_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    config.update(
+        {
+            "forced_decoder_ids": model_args.forced_decoder_ids,
+            "suppress_tokens": model_args.suppress_tokens,
+        }
+    )
+
+    if training_args.gradient_checkpointing:
+        config.update({"use_cache": False})
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        model_args.feature_extractor_name
+        if model_args.feature_extractor_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_args.tokenizer_name
+        if model_args.tokenizer_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        use_fast=model_args.use_fast_tokenizer,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        model_args.model_name_or_path,
+        config=config,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    if model.config.decoder_start_token_id is None:
+        raise ValueError(
+            "Make sure that `config.decoder_start_token_id` is correctly defined"
+        )
+
+    max_label_length = model.config.max_length
+
+    if model_args.freeze_feature_encoder:
+        model.freeze_feature_encoder()
+
+    if model_args.freeze_encoder:
+        model.freeze_encoder()
+        model.model.encoder.gradient_checkpointing = False
+
+    if data_args.language is not None:
+        # We only need to set the task id when the language is specified (i.e. in a multilingual setting)
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
+
+    # 6. Resample speech dataset if necessary
+    dataset_sampling_rate = (
+        next(iter(raw_datasets.values()))
+        .features[data_args.audio_column_name]
+        .sampling_rate
+    )
+    if dataset_sampling_rate != feature_extractor.sampling_rate:
+        raw_datasets = raw_datasets.cast_column(
+            data_args.audio_column_name,
+            datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate),
+        )
+
+    # 7. Preprocessing the datasets.
+    # We need to read the audio files as arrays and tokenize the targets.
+    max_input_length = (
+        data_args.max_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    min_input_length = (
+        data_args.min_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    audio_column_name = data_args.audio_column_name
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    do_lower_case = data_args.do_lower_case
+    do_remove_punctuation = data_args.do_remove_punctuation
+    normalizer = BasicTextNormalizer()  # 'official' text normalizer from OpenAI
+
+    if data_args.max_train_samples is not None:
+        raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
+
+    if data_args.max_eval_samples is not None:
+        raw_datasets["eval"] = raw_datasets["eval"].select(
+            range(data_args.max_eval_samples)
+        )
+
+    def prepare_dataset(batch):
+        # process audio
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(
+            sample["array"], sampling_rate=sample["sampling_rate"]
+        )
+        # process audio length
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch["input_length"] = len(sample["array"])
+
+        # process targets
+        input_str = (
+            batch[text_column_name].lower()
+            if do_lower_case
+            else batch[text_column_name]
+        )
+        if do_remove_punctuation:
+            input_str = normalizer(input_str).strip()
+        batch["labels"] = tokenizer(input_str).input_ids
+        return batch
+
+    with training_args.main_process_first(desc="dataset map pre-processing"):
+        vectorized_datasets = raw_datasets.map(
+            prepare_dataset,
+            remove_columns=raw_datasets_features,
+        ).with_format("torch")
+
+        if training_args.do_train:
+            vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
+                buffer_size=data_args.shuffle_buffer_size,
+                seed=training_args.seed,
+            )
+
+    # filter training data that is shorter than min_input_length or longer than
+    # max_input_length
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+
+    vectorized_datasets["train"] = vectorized_datasets["train"].filter(
+        is_audio_in_length_range,
+        input_columns=["input_length"],
+    )
+
+    def filter_labels(labels):
+        """Filter label sequences longer than max length"""
+        return len(labels) < max_label_length
+
+    vectorized_datasets = vectorized_datasets.filter(
+        filter_labels, input_columns=["labels"]
+    )
+
+    # 8. Load Metric
+    metric = evaluate.load("wer")
+    do_normalize_eval = data_args.do_normalize_eval
+
+    def compute_metrics(pred):
+        pred_ids = pred.predictions
+
+        pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
+
+        pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
+        # we do not want to group tokens when computing the metrics
+        label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
+
+        if do_normalize_eval:
+            pred_str = [normalizer(pred) for pred in pred_str]
+            label_str = [normalizer(label) for label in label_str]
+            # filtering step to only evaluate the samples that correspond to non-zero references:
+            pred_str = [
+                pred_str[i] for i in range(len(pred_str)) if len(label_str[i]) > 0
+            ]
+            label_str = [
+                label_str[i] for i in range(len(label_str)) if len(label_str[i]) > 0
+            ]
+
+        wer = 100 * metric.compute(predictions=pred_str, references=label_str)
+
+        return {"wer": wer}
+
+    # 9. Create a single speech processor
+    if is_main_process(training_args.local_rank):
+        # save feature extractor, tokenizer and config
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+
+    processor = AutoProcessor.from_pretrained(training_args.output_dir)
+
+    # 10. Define data collator
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(
+        processor=processor,
+        decoder_start_token_id=model.config.decoder_start_token_id,
+    )
+
+    # 11. Configure Trainer
+    # Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
+    # Only required for streaming: Trainer automatically shuffles non-streaming datasets
+    class ShuffleCallback(TrainerCallback):
+        def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
+            if isinstance(train_dataloader.dataset, IterableDatasetShard):
+                pass  # set_epoch() is handled by the Trainer
+            elif isinstance(train_dataloader.dataset, IterableDataset):
+                train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
+
+    # Initialize Trainer
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
+        eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
+        tokenizer=feature_extractor,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics
+        if training_args.predict_with_generate
+        else None,
+        callbacks=[ShuffleCallback()],
+    )
+
+    # 12. Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the feature extractor too for easy upload
+
+        metrics = train_result.metrics
+        if data_args.max_train_samples:
+            metrics["train_samples"] = data_args.max_train_samples
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # 13. Evaluation
+    results = {}
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+        metrics = trainer.evaluate(
+            metric_key_prefix="eval",
+            max_length=training_args.generation_max_length,
+            num_beams=training_args.generation_num_beams,
+        )
+        if data_args.max_eval_samples:
+            metrics["eval_samples"] = data_args.max_eval_samples
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+    # 14. Write Training Stats
+    kwargs = {
+        "finetuned_from": model_args.model_name_or_path,
+        "tasks": "automatic-speech-recognition",
+        "tags": "whisper-event",
+    }
+    if data_args.dataset_name is not None:
+        kwargs["dataset_tags"] = data_args.dataset_name
+        if data_args.dataset_config_name is not None:
+            kwargs[
+                "dataset"
+            ] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
+        else:
+            kwargs["dataset"] = data_args.dataset_name
+        if "common_voice" in data_args.dataset_name:
+            kwargs["language"] = data_args.dataset_config_name[:2]
+        if model_args.model_index_name is not None:
+            kwargs["model_name"] = model_args.model_index_name
+
+    if training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(**kwargs)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()

run_speech_recognition_seq2seq_mixed_mgb2.py

@@ -0,0 +1,748 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for sequence to sequence speech recognition
+with 🤗 Datasets' streaming mode.
+"""
+# You can also adapt this script for your own sequence to sequence speech
+# recognition task. Pointers for this are left as comments.
+
+import logging
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+import datasets
+import torch
+from datasets import DatasetDict, IterableDatasetDict, interleave_datasets, load_dataset
+from torch.utils.data import IterableDataset
+
+import evaluate
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoFeatureExtractor,
+    AutoModelForSpeechSeq2Seq,
+    AutoProcessor,
+    AutoTokenizer,
+    HfArgumentParser,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+    TrainerCallback,
+    set_seed,
+)
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+from transformers.trainer_pt_utils import IterableDatasetShard
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+
+
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.25.0.dev0")
+
+require_version(
+    "datasets>=1.18.2",
+    "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt",
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={
+            "help": "Path to pretrained model or model identifier from huggingface.co/models"
+        }
+    )
+    config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained config name or path if not the same as model_name"
+        },
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Pretrained tokenizer name or path if not the same as model_name"
+        },
+    )
+    feature_extractor_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "feature extractor name or path if not the same as model_name"
+        },
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "Where to store the pretrained models downloaded from huggingface.co"
+        },
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."
+        },
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={
+            "help": "The specific model version to use (can be a branch name, tag name or commit id)."
+        },
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+                "with private models)."
+            )
+        },
+    )
+    freeze_feature_encoder: bool = field(
+        default=True,
+        metadata={"help": "Whether to freeze the feature encoder layers of the model."},
+    )
+    freeze_encoder: bool = field(
+        default=False,
+        metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."},
+    )
+    forced_decoder_ids: List[List[int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "A list of pairs of integers which indicates a mapping from generation indices to token indices "
+                "that will be forced before sampling. For example, [[0, 123]] means the first generated token "
+                "will always be a token of index 123."
+            )
+        },
+    )
+    suppress_tokens: List[int] = field(
+        default=None,
+        metadata={"help": "A list of tokens that will be suppressed at generation."},
+    )
+    model_index_name: str = field(
+        default=None, metadata={"help": "Pretty name for the model card."}
+    )
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: str = field(
+        default=None,
+        metadata={"help": "The name of the dataset to use (via the datasets library)."},
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The configuration name of the dataset to use (via the datasets library)."
+        },
+    )
+    text_column: Optional[str] = field(
+        default=None,
+        metadata={
+            "help": "The name of the column in the datasets containing the full texts (for summarization)."
+        },
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of training examples to this "
+                "value if set."
+            )
+        },
+    )
+    max_eval_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of evaluation examples to this "
+                "value if set."
+            )
+        },
+    )
+    audio_column_name: str = field(
+        default="audio",
+        metadata={
+            "help": "The name of the dataset column containing the audio data. Defaults to 'audio'"
+        },
+    )
+    text_column_name: str = field(
+        default="text",
+        metadata={
+            "help": "The name of the dataset column containing the text data. Defaults to 'text'"
+        },
+    )
+    max_duration_in_seconds: float = field(
+        default=20.0,
+        metadata={
+            "help": (
+                "Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
+                " 'max_duration_in_seconds`"
+            )
+        },
+    )
+    min_duration_in_seconds: float = field(
+        default=0.0,
+        metadata={
+            "help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"
+        },
+    )
+    train_split_name: str = field(
+        default="train",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    eval_split_name: str = field(
+        default="test",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    do_lower_case: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be lower cased."},
+    )
+    do_remove_punctuation: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be striped of punctuation."},
+    )
+    do_normalize_eval: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to normalise the references and predictions in the eval WER calculation."
+        },
+    )
+    language: str = field(
+        default=None,
+        metadata={
+            "help": (
+                "Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
+                "only. For English speech recognition, it should be set to `None`."
+            )
+        },
+    )
+    task: str = field(
+        default="transcribe",
+        metadata={
+            "help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."
+        },
+    )
+    shuffle_buffer_size: Optional[int] = field(
+        default=500,
+        metadata={
+            "help": (
+                "The number of streamed examples to download before shuffling them. The large the buffer, "
+                "the closer it is to real offline shuffling."
+            )
+        },
+    )
+    streaming: bool = field(
+        default=True,
+        metadata={
+            "help": "Whether to use streaming mode to load and pre-process the data."
+        },
+    )
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor ([`WhisperProcessor`])
+            The processor used for processing the data.
+        decoder_start_token_id (`int`)
+            The begin-of-sentence of the decoder.
+    """
+
+    processor: Any
+    decoder_start_token_id: int
+
+    def __call__(
+        self, features: List[Dict[str, Union[List[int], torch.Tensor]]]
+    ) -> Dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need
+        # different padding methods
+        model_input_name = self.processor.model_input_names[0]
+        input_features = [
+            {model_input_name: feature[model_input_name]} for feature in features
+        ]
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+
+        batch = self.processor.feature_extractor.pad(
+            input_features, return_tensors="pt"
+        )
+
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(
+            labels_batch.attention_mask.ne(1), -100
+        )
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def load_maybe_streaming_dataset(
+    dataset_name, dataset_config_name, split="train", streaming=True, **kwargs
+):
+    """
+    Utility function to load a dataset in streaming mode. For datasets with multiple splits,
+    each split is loaded individually and then splits combined by taking alternating examples from
+    each (interleaving).
+    """
+    if "+" in split:
+        # load multiple splits separated by the `+` symbol with streaming mode
+        dataset_splits = [
+            load_dataset(
+                dataset_name,
+                dataset_config_name,
+                split=split_name,
+                streaming=streaming,
+                **kwargs,
+            )
+            for split_name in split.split("+")
+        ]
+        # interleave multiple splits to form one dataset
+        interleaved_dataset = interleave_datasets(dataset_splits)
+        return interleaved_dataset
+    else:
+        # load a single split *with* streaming mode
+        dataset = load_dataset(
+            dataset_name,
+            dataset_config_name,
+            split=split,
+            streaming=streaming,
+            **kwargs,
+        )
+        return dataset
+
+
+def main():
+    # 1. Parse input arguments
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+    parser = HfArgumentParser(
+        (ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments)
+    )
+
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(
+            json_file=os.path.abspath(sys.argv[1])
+        )
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
+    # information sent is the one passed as arguments along with your Python/PyTorch versions.
+    send_example_telemetry(
+        "run_speech_recognition_seq2seq_streaming", model_args, data_args
+    )
+
+    # 2. Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    log_level = training_args.get_process_log_level()
+    logger.setLevel(log_level)
+    datasets.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.enable_default_handler()
+    transformers.utils.logging.enable_explicit_format()
+
+    logger.setLevel(
+        logging.INFO if is_main_process(training_args.local_rank) else logging.WARN
+    )
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # 3. Detecting last checkpoint and eventually continue from last checkpoint
+    last_checkpoint = None
+    if (
+        os.path.isdir(training_args.output_dir)
+        and training_args.do_train
+        and not training_args.overwrite_output_dir
+    ):
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif (
+            last_checkpoint is not None and training_args.resume_from_checkpoint is None
+        ):
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # 4. Load dataset
+    raw_datasets = IterableDatasetDict()
+
+    if training_args.do_train:
+        raw_datasets["train"] = load_maybe_streaming_dataset(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.train_split_name,
+            streaming=True,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    if training_args.do_eval:
+        raw_datasets["eval"] = load_maybe_streaming_dataset(
+            "arbml/mgb3",
+            data_args.dataset_config_name,
+            split="train",
+            streaming=False,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+
+    if data_args.audio_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--audio_column_name` to the correct audio column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    if data_args.text_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--text_column_name` to the correct text column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    # 5. Load pretrained model, tokenizer, and feature extractor
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    config = AutoConfig.from_pretrained(
+        model_args.config_name
+        if model_args.config_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    config.update(
+        {
+            "forced_decoder_ids": model_args.forced_decoder_ids,
+            "suppress_tokens": model_args.suppress_tokens,
+        }
+    )
+
+    if training_args.gradient_checkpointing:
+        config.update({"use_cache": False})
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        model_args.feature_extractor_name
+        if model_args.feature_extractor_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_args.tokenizer_name
+        if model_args.tokenizer_name
+        else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        use_fast=model_args.use_fast_tokenizer,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        model_args.model_name_or_path,
+        config=config,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    if model.config.decoder_start_token_id is None:
+        raise ValueError(
+            "Make sure that `config.decoder_start_token_id` is correctly defined"
+        )
+
+    max_label_length = model.config.max_length
+
+    if model_args.freeze_feature_encoder:
+        model.freeze_feature_encoder()
+
+    if model_args.freeze_encoder:
+        model.freeze_encoder()
+        model.model.encoder.gradient_checkpointing = False
+
+    if data_args.language is not None:
+        # We only need to set the task id when the language is specified (i.e. in a multilingual setting)
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
+
+    # 6. Resample speech dataset if necessary
+    dataset_sampling_rate = (
+        next(iter(raw_datasets.values()))
+        .features[data_args.audio_column_name]
+        .sampling_rate
+    )
+    if dataset_sampling_rate != feature_extractor.sampling_rate:
+        raw_datasets = raw_datasets.cast_column(
+            data_args.audio_column_name,
+            datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate),
+        )
+
+    # 7. Preprocessing the datasets.
+    # We need to read the audio files as arrays and tokenize the targets.
+    max_input_length = (
+        data_args.max_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    min_input_length = (
+        data_args.min_duration_in_seconds * feature_extractor.sampling_rate
+    )
+    audio_column_name = data_args.audio_column_name
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    do_lower_case = data_args.do_lower_case
+    do_remove_punctuation = data_args.do_remove_punctuation
+    normalizer = BasicTextNormalizer()  # 'official' text normalizer from OpenAI
+
+    if data_args.max_train_samples is not None:
+        raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
+
+    if data_args.max_eval_samples is not None:
+        raw_datasets["eval"] = raw_datasets["eval"].select(
+            range(data_args.max_eval_samples)
+        )
+
+    def prepare_dataset(batch):
+        # process audio
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(
+            sample["array"], sampling_rate=sample["sampling_rate"]
+        )
+        # process audio length
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch["input_length"] = len(sample["array"])
+
+        # process targets
+        input_str = (
+            batch[text_column_name].lower()
+            if do_lower_case
+            else batch[text_column_name]
+        )
+        if do_remove_punctuation:
+            input_str = normalizer(input_str).strip()
+        batch["labels"] = tokenizer(input_str).input_ids
+        return batch
+
+    with training_args.main_process_first(desc="dataset map pre-processing"):
+        vectorized_datasets = raw_datasets.map(
+            prepare_dataset,
+            remove_columns=raw_datasets_features,
+        ).with_format("torch")
+
+        if training_args.do_train:
+            vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
+                buffer_size=data_args.shuffle_buffer_size,
+                seed=training_args.seed,
+            )
+
+    # filter training data that is shorter than min_input_length or longer than
+    # max_input_length
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+
+    vectorized_datasets["train"] = vectorized_datasets["train"].filter(
+        is_audio_in_length_range,
+        input_columns=["input_length"],
+    )
+
+    def filter_labels(labels):
+        """Filter label sequences longer than max length"""
+        return len(labels) < max_label_length
+
+    vectorized_datasets = vectorized_datasets.filter(
+        filter_labels, input_columns=["labels"]
+    )
+
+    # 8. Load Metric
+    metric = evaluate.load("wer")
+    do_normalize_eval = data_args.do_normalize_eval
+
+    def compute_metrics(pred):
+        pred_ids = pred.predictions
+
+        pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
+
+        pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
+        # we do not want to group tokens when computing the metrics
+        label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
+
+        if do_normalize_eval:
+            pred_str = [normalizer(pred) for pred in pred_str]
+            label_str = [normalizer(label) for label in label_str]
+            # filtering step to only evaluate the samples that correspond to non-zero references:
+            pred_str = [
+                pred_str[i] for i in range(len(pred_str)) if len(label_str[i]) > 0
+            ]
+            label_str = [
+                label_str[i] for i in range(len(label_str)) if len(label_str[i]) > 0
+            ]
+
+        wer = 100 * metric.compute(predictions=pred_str, references=label_str)
+
+        return {"wer": wer}
+
+    # 9. Create a single speech processor
+    if is_main_process(training_args.local_rank):
+        # save feature extractor, tokenizer and config
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+
+    processor = AutoProcessor.from_pretrained(training_args.output_dir)
+
+    # 10. Define data collator
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(
+        processor=processor,
+        decoder_start_token_id=model.config.decoder_start_token_id,
+    )
+
+    # 11. Configure Trainer
+    # Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
+    # Only required for streaming: Trainer automatically shuffles non-streaming datasets
+    class ShuffleCallback(TrainerCallback):
+        def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
+            if isinstance(train_dataloader.dataset, IterableDatasetShard):
+                pass  # set_epoch() is handled by the Trainer
+            elif isinstance(train_dataloader.dataset, IterableDataset):
+                train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
+
+    # Initialize Trainer
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
+        eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
+        tokenizer=feature_extractor,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics
+        if training_args.predict_with_generate
+        else None,
+        callbacks=[ShuffleCallback()],
+    )
+
+    # 12. Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the feature extractor too for easy upload
+
+        metrics = train_result.metrics
+        if data_args.max_train_samples:
+            metrics["train_samples"] = data_args.max_train_samples
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # 13. Evaluation
+    results = {}
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+        metrics = trainer.evaluate(
+            metric_key_prefix="eval",
+            max_length=training_args.generation_max_length,
+            num_beams=training_args.generation_num_beams,
+        )
+        if data_args.max_eval_samples:
+            metrics["eval_samples"] = data_args.max_eval_samples
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+    # 14. Write Training Stats
+    kwargs = {
+        "finetuned_from": model_args.model_name_or_path,
+        "tasks": "automatic-speech-recognition",
+        "tags": "whisper-event",
+    }
+    if data_args.dataset_name is not None:
+        kwargs["dataset_tags"] = data_args.dataset_name
+        if data_args.dataset_config_name is not None:
+            kwargs[
+                "dataset"
+            ] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
+        else:
+            kwargs["dataset"] = data_args.dataset_name
+        if "common_voice" in data_args.dataset_name:
+            kwargs["language"] = data_args.dataset_config_name[:2]
+        if model_args.model_index_name is not None:
+            kwargs["model_name"] = model_args.model_index_name
+
+    if training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(**kwargs)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()

run_speech_recognition_seq2seq_streaming.py

@@ -0,0 +1,608 @@
+#!/usr/bin/env python
+# coding=utf-8
+# Copyright 2022 The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+Fine-tuning the library models for sequence to sequence speech recognition
+with 🤗 Datasets' streaming mode.
+"""
+# You can also adapt this script for your own sequence to sequence speech
+# recognition task. Pointers for this are left as comments.
+
+import logging
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+import datasets
+import torch
+from datasets import IterableDatasetDict, interleave_datasets, load_dataset
+from torch.utils.data import IterableDataset
+
+import evaluate
+import transformers
+from transformers import (
+    AutoConfig,
+    AutoFeatureExtractor,
+    AutoModelForSpeechSeq2Seq,
+    AutoProcessor,
+    AutoTokenizer,
+    HfArgumentParser,
+    Seq2SeqTrainer,
+    Seq2SeqTrainingArguments,
+    TrainerCallback,
+    set_seed,
+)
+from transformers.trainer_pt_utils import IterableDatasetShard
+from transformers.trainer_utils import get_last_checkpoint, is_main_process
+from transformers.utils import check_min_version, send_example_telemetry
+from transformers.utils.versions import require_version
+from transformers.models.whisper.english_normalizer import BasicTextNormalizer
+import os
+os.environ['LD_LIBRARY_PATH'] = '/usr/lib/x86_64-linux-gnu'
+# Will error if the minimal version of Transformers is not installed. Remove at your own risks.
+check_min_version("4.25.0.dev0")
+
+require_version("datasets>=1.18.2", "To fix: pip install -r examples/pytorch/speech-recognition/requirements.txt")
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ModelArguments:
+    """
+    Arguments pertaining to which model/config/tokenizer we are going to fine-tune from.
+    """
+
+    model_name_or_path: str = field(
+        metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}
+    )
+    config_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained config name or path if not the same as model_name"}
+    )
+    tokenizer_name: Optional[str] = field(
+        default=None, metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}
+    )
+    feature_extractor_name: Optional[str] = field(
+        default=None, metadata={"help": "feature extractor name or path if not the same as model_name"}
+    )
+    cache_dir: Optional[str] = field(
+        default=None,
+        metadata={"help": "Where to store the pretrained models downloaded from huggingface.co"},
+    )
+    use_fast_tokenizer: bool = field(
+        default=True,
+        metadata={"help": "Whether to use one of the fast tokenizer (backed by the tokenizers library) or not."},
+    )
+    model_revision: str = field(
+        default="main",
+        metadata={"help": "The specific model version to use (can be a branch name, tag name or commit id)."},
+    )
+    use_auth_token: bool = field(
+        default=False,
+        metadata={
+            "help": (
+                "Will use the token generated when running `huggingface-cli login` (necessary to use this script "
+                "with private models)."
+            )
+        },
+    )
+    freeze_feature_encoder: bool = field(
+        default=True, metadata={"help": "Whether to freeze the feature encoder layers of the model."}
+    )
+    freeze_encoder: bool = field(
+        default=False, metadata={"help": "Whether to freeze the entire encoder of the seq2seq model."}
+    )
+    forced_decoder_ids: List[List[int]] = field(
+        default=None,
+        metadata={
+            "help": (
+                "A list of pairs of integers which indicates a mapping from generation indices to token indices "
+                "that will be forced before sampling. For example, [[0, 123]] means the first generated token "
+                "will always be a token of index 123."
+            )
+        },
+    )
+    suppress_tokens: List[int] = field(
+        default=None, metadata={"help": "A list of tokens that will be suppressed at generation."}
+    )
+    model_index_name: str = field(default=None, metadata={"help": "Pretty name for the model card."})
+
+
+@dataclass
+class DataTrainingArguments:
+    """
+    Arguments pertaining to what data we are going to input our model for training and eval.
+    """
+
+    dataset_name: str = field(
+        default=None, metadata={"help": "The name of the dataset to use (via the datasets library)."}
+    )
+    dataset_config_name: Optional[str] = field(
+        default=None, metadata={"help": "The configuration name of the dataset to use (via the datasets library)."}
+    )
+    text_column: Optional[str] = field(
+        default=None,
+        metadata={"help": "The name of the column in the datasets containing the full texts (for summarization)."},
+    )
+    max_train_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of training examples to this "
+                "value if set."
+            )
+        },
+    )
+    max_eval_samples: Optional[int] = field(
+        default=None,
+        metadata={
+            "help": (
+                "For debugging purposes or quicker training, truncate the number of evaluation examples to this "
+                "value if set."
+            )
+        },
+    )
+    audio_column_name: str = field(
+        default="audio",
+        metadata={"help": "The name of the dataset column containing the audio data. Defaults to 'audio'"},
+    )
+    text_column_name: str = field(
+        default="text",
+        metadata={"help": "The name of the dataset column containing the text data. Defaults to 'text'"},
+    )
+    max_duration_in_seconds: float = field(
+        default=20.0,
+        metadata={
+            "help": (
+                "Truncate audio files that are longer than `max_duration_in_seconds` seconds to"
+                " 'max_duration_in_seconds`"
+            )
+        },
+    )
+    min_duration_in_seconds: float = field(
+        default=0.0, metadata={"help": "Filter audio files that are shorter than `min_duration_in_seconds` seconds"}
+    )
+    train_split_name: str = field(
+        default="train",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    eval_split_name: str = field(
+        default="test",
+        metadata={
+            "help": "The name of the training data set split to use (via the datasets library). Defaults to 'train'"
+        },
+    )
+    do_lower_case: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be lower cased."},
+    )
+    do_remove_punctuation: bool = field(
+        default=False,
+        metadata={"help": "Whether the target text should be striped of punctuation."},
+    )
+    do_normalize_eval: bool = field(
+        default=True,
+        metadata={"help": "Whether to normalise the references and predictions in the eval WER calculation."},
+    )
+    language: str = field(
+        default=None,
+        metadata={
+            "help": (
+                "Language for multilingual fine-tuning. This argument should be set for multilingual fine-tuning "
+                "only. For English speech recognition, it should be set to `None`."
+            )
+        },
+    )
+    task: str = field(
+        default="transcribe",
+        metadata={"help": "Task, either `transcribe` for speech recognition or `translate` for speech translation."},
+    )
+    shuffle_buffer_size: Optional[int] = field(
+        default=500,
+        metadata={
+            "help": (
+                "The number of streamed examples to download before shuffling them. The large the buffer, "
+                "the closer it is to real offline shuffling."
+            )
+        },
+    )
+
+
+@dataclass
+class DataCollatorSpeechSeq2SeqWithPadding:
+    """
+    Data collator that will dynamically pad the inputs received.
+    Args:
+        processor ([`WhisperProcessor`])
+            The processor used for processing the data.
+        decoder_start_token_id (`int`)
+            The begin-of-sentence of the decoder.
+    """
+
+    processor: Any
+    decoder_start_token_id: int
+
+    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:
+        # split inputs and labels since they have to be of different lengths and need
+        # different padding methods
+        model_input_name = self.processor.model_input_names[0]
+        input_features = [{model_input_name: feature[model_input_name]} for feature in features]
+        label_features = [{"input_ids": feature["labels"]} for feature in features]
+
+        batch = self.processor.feature_extractor.pad(input_features, return_tensors="pt")
+
+        labels_batch = self.processor.tokenizer.pad(label_features, return_tensors="pt")
+
+        # replace padding with -100 to ignore loss correctly
+        labels = labels_batch["input_ids"].masked_fill(labels_batch.attention_mask.ne(1), -100)
+
+        # if bos token is appended in previous tokenization step,
+        # cut bos token here as it's append later anyways
+        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():
+            labels = labels[:, 1:]
+
+        batch["labels"] = labels
+
+        return batch
+
+
+def load_streaming_dataset(dataset_name, dataset_config_name, split="train", **kwargs):
+    """
+    Utility function to load a dataset in streaming mode. For datasets with multiple splits,
+    each split is loaded individually and then splits combined by taking alternating examples from
+    each (interleaving).
+    """
+    if "+" in split:
+        # load multiple splits separated by the `+` symbol with streaming mode
+        dataset_splits = [
+            load_dataset(dataset_name, dataset_config_name, split=split_name, streaming=True, **kwargs)
+            for split_name in split.split("+")
+        ]
+        # interleave multiple splits to form one dataset
+        interleaved_dataset = interleave_datasets(dataset_splits)
+        return interleaved_dataset
+    else:
+        # load a single split *with* streaming mode
+        dataset = load_dataset(dataset_name, dataset_config_name, split=split, streaming=True, **kwargs)
+        return dataset
+
+
+def main():
+    # 1. Parse input arguments
+    # See all possible arguments in src/transformers/training_args.py
+    # or by passing the --help flag to this script.
+    # We now keep distinct sets of args, for a cleaner separation of concerns.
+    parser = HfArgumentParser((ModelArguments, DataTrainingArguments, Seq2SeqTrainingArguments))
+
+    if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
+        # If we pass only one argument to the script and it's the path to a json file,
+        # let's parse it to get our arguments.
+        model_args, data_args, training_args = parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]))
+    else:
+        model_args, data_args, training_args = parser.parse_args_into_dataclasses()
+
+    # Sending telemetry. Tracking the example usage helps us better allocate resources to maintain them. The
+    # information sent is the one passed as arguments along with your Python/PyTorch versions.
+    send_example_telemetry("run_speech_recognition_seq2seq_streaming", model_args, data_args)
+
+    # 2. Setup logging
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        handlers=[logging.StreamHandler(sys.stdout)],
+    )
+    log_level = training_args.get_process_log_level()
+    logger.setLevel(log_level)
+    datasets.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.set_verbosity(log_level)
+    transformers.utils.logging.enable_default_handler()
+    transformers.utils.logging.enable_explicit_format()
+
+    logger.setLevel(logging.INFO if is_main_process(training_args.local_rank) else logging.WARN)
+
+    # Log on each process the small summary:
+    logger.warning(
+        f"Process rank: {training_args.local_rank}, device: {training_args.device}, n_gpu: {training_args.n_gpu}"
+        f"distributed training: {bool(training_args.local_rank != -1)}, 16-bits training: {training_args.fp16}"
+    )
+    logger.info(f"Training/evaluation parameters {training_args}")
+
+    # Set the verbosity to info of the Transformers logger (on main process only):
+    if is_main_process(training_args.local_rank):
+        transformers.utils.logging.set_verbosity_info()
+    logger.info("Training/evaluation parameters %s", training_args)
+
+    # 3. Detecting last checkpoint and eventually continue from last checkpoint
+    last_checkpoint = None
+    if os.path.isdir(training_args.output_dir) and training_args.do_train and not training_args.overwrite_output_dir:
+        last_checkpoint = get_last_checkpoint(training_args.output_dir)
+        if last_checkpoint is None and len(os.listdir(training_args.output_dir)) > 0:
+            raise ValueError(
+                f"Output directory ({training_args.output_dir}) already exists and is not empty. "
+                "Use --overwrite_output_dir to overcome."
+            )
+        elif last_checkpoint is not None and training_args.resume_from_checkpoint is None:
+            logger.info(
+                f"Checkpoint detected, resuming training at {last_checkpoint}. To avoid this behavior, change "
+                "the `--output_dir` or add `--overwrite_output_dir` to train from scratch."
+            )
+
+    # Set seed before initializing model.
+    set_seed(training_args.seed)
+
+    # 4. Load dataset
+    raw_datasets = IterableDatasetDict()
+
+    if training_args.do_train:
+        raw_datasets["train"] = load_streaming_dataset(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.train_split_name,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    if training_args.do_eval:
+        raw_datasets["eval"] = load_streaming_dataset(
+            data_args.dataset_name,
+            data_args.dataset_config_name,
+            split=data_args.eval_split_name,
+            use_auth_token=True if model_args.use_auth_token else None,
+        )
+
+    raw_datasets_features = list(next(iter(raw_datasets.values())).features.keys())
+
+    if data_args.audio_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--audio_column_name '{data_args.audio_column_name}' not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--audio_column_name` to the correct audio column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    if data_args.text_column_name not in raw_datasets_features:
+        raise ValueError(
+            f"--text_column_name {data_args.text_column_name} not found in dataset '{data_args.dataset_name}'. "
+            "Make sure to set `--text_column_name` to the correct text column - one of "
+            f"{', '.join(raw_datasets_features)}."
+        )
+
+    # 5. Load pretrained model, tokenizer, and feature extractor
+    #
+    # Distributed training:
+    # The .from_pretrained methods guarantee that only one local process can concurrently
+    config = AutoConfig.from_pretrained(
+        model_args.config_name if model_args.config_name else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+
+    config.update({"forced_decoder_ids": model_args.forced_decoder_ids, "suppress_tokens": model_args.suppress_tokens})
+
+    feature_extractor = AutoFeatureExtractor.from_pretrained(
+        model_args.feature_extractor_name if model_args.feature_extractor_name else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path,
+        cache_dir=model_args.cache_dir,
+        use_fast=model_args.use_fast_tokenizer,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model = AutoModelForSpeechSeq2Seq.from_pretrained(
+        model_args.model_name_or_path,
+        config=config,
+        cache_dir=model_args.cache_dir,
+        revision=model_args.model_revision,
+        use_auth_token=True if model_args.use_auth_token else None,
+    )
+    model.config.use_cache = False
+
+    if model.config.decoder_start_token_id is None:
+        raise ValueError("Make sure that `config.decoder_start_token_id` is correctly defined")
+
+    if model_args.freeze_feature_encoder:
+        model.freeze_feature_encoder()
+
+    if model_args.freeze_encoder:
+        model.freeze_encoder()
+        model.model.encoder.gradient_checkpointing = False
+
+    if data_args.language is not None:
+        # We only need to set the task id when the language is specified (i.e. in a multilingual setting)
+        tokenizer.set_prefix_tokens(language=data_args.language, task=data_args.task)
+
+    # 6. Resample speech dataset if necessary
+    dataset_sampling_rate = next(iter(raw_datasets.values())).features[data_args.audio_column_name].sampling_rate
+    if dataset_sampling_rate != feature_extractor.sampling_rate:
+        raw_datasets = raw_datasets.cast_column(
+            data_args.audio_column_name, datasets.features.Audio(sampling_rate=feature_extractor.sampling_rate)
+        )
+
+    # 7. Preprocessing the datasets.
+    # We need to read the audio files as arrays and tokenize the targets.
+    max_input_length = data_args.max_duration_in_seconds * feature_extractor.sampling_rate
+    min_input_length = data_args.min_duration_in_seconds * feature_extractor.sampling_rate
+    audio_column_name = data_args.audio_column_name
+    text_column_name = data_args.text_column_name
+    model_input_name = feature_extractor.model_input_names[0]
+    do_lower_case = data_args.do_lower_case
+    do_remove_punctuation = data_args.do_remove_punctuation
+    normalizer = BasicTextNormalizer()  # 'official' text normalizer from OpenAI
+
+    if data_args.max_train_samples is not None:
+        raw_datasets["train"] = raw_datasets["train"].take(data_args.max_train_samples)
+
+    if data_args.max_eval_samples is not None:
+        raw_datasets["eval"] = raw_datasets["eval"].take(data_args.max_eval_samples)
+
+    def prepare_dataset(batch):
+        # process audio
+        sample = batch[audio_column_name]
+        inputs = feature_extractor(sample["array"], sampling_rate=sample["sampling_rate"])
+        # process audio length
+        batch[model_input_name] = inputs.get(model_input_name)[0]
+        batch["input_length"] = len(sample["array"])
+
+        # process targets
+        input_str = batch[text_column_name].lower() if do_lower_case else batch[text_column_name]
+        if do_remove_punctuation:
+            input_str = normalizer(input_str).strip()
+        batch["labels"] = tokenizer(input_str).input_ids
+        return batch
+
+    with training_args.main_process_first(desc="dataset map pre-processing"):
+        vectorized_datasets = raw_datasets.map(
+            prepare_dataset,
+            remove_columns=raw_datasets_features,
+        ).with_format("torch")
+
+        if training_args.do_train:
+            vectorized_datasets["train"] = vectorized_datasets["train"].shuffle(
+                buffer_size=data_args.shuffle_buffer_size,
+                seed=training_args.seed,
+            )
+
+    # filter training data that is shorter than min_input_length or longer than
+    # max_input_length
+    def is_audio_in_length_range(length):
+        return min_input_length < length < max_input_length
+
+    vectorized_datasets["train"] = vectorized_datasets["train"].filter(
+        is_audio_in_length_range,
+        input_columns=["input_length"],
+    )
+
+    # 8. Load Metric
+    metric = evaluate.load("wer")
+    do_normalize_eval = data_args.do_normalize_eval
+
+    def compute_metrics(pred):
+        pred_ids = pred.predictions
+
+        pred.label_ids[pred.label_ids == -100] = tokenizer.pad_token_id
+
+        pred_str = tokenizer.batch_decode(pred_ids, skip_special_tokens=True)
+        # we do not want to group tokens when computing the metrics
+        label_str = tokenizer.batch_decode(pred.label_ids, skip_special_tokens=True)
+
+        if do_normalize_eval:
+            pred_str = [normalizer(pred) for pred in pred_str]
+            label_str = [normalizer(label) for label in label_str]
+
+        wer = 100 * metric.compute(predictions=pred_str, references=label_str)
+
+        return {"wer": wer}
+
+    # 9. Create a single speech processor
+    if is_main_process(training_args.local_rank):
+        # save feature extractor, tokenizer and config
+        feature_extractor.save_pretrained(training_args.output_dir)
+        tokenizer.save_pretrained(training_args.output_dir)
+        config.save_pretrained(training_args.output_dir)
+
+    processor = AutoProcessor.from_pretrained(training_args.output_dir)
+
+    # 10. Define data collator
+    data_collator = DataCollatorSpeechSeq2SeqWithPadding(
+        processor=processor,
+        decoder_start_token_id=model.config.decoder_start_token_id,
+    )
+
+    # 11. Configure Trainer
+    # Trainer callback to reinitialise and reshuffle the streamable datasets at the beginning of each epoch
+    class ShuffleCallback(TrainerCallback):
+        def on_epoch_begin(self, args, state, control, train_dataloader, **kwargs):
+            if isinstance(train_dataloader.dataset, IterableDatasetShard):
+                pass  # set_epoch() is handled by the Trainer
+            elif isinstance(train_dataloader.dataset, IterableDataset):
+                train_dataloader.dataset.set_epoch(train_dataloader.dataset._epoch + 1)
+
+    # Initialize Trainer
+    trainer = Seq2SeqTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=vectorized_datasets["train"] if training_args.do_train else None,
+        eval_dataset=vectorized_datasets["eval"] if training_args.do_eval else None,
+        tokenizer=feature_extractor,
+        data_collator=data_collator,
+        compute_metrics=compute_metrics if training_args.predict_with_generate else None,
+        callbacks=[ShuffleCallback()],
+    )
+
+    # 12. Training
+    if training_args.do_train:
+        checkpoint = None
+        if training_args.resume_from_checkpoint is not None:
+            checkpoint = training_args.resume_from_checkpoint
+        elif last_checkpoint is not None:
+            checkpoint = last_checkpoint
+        train_result = trainer.train(resume_from_checkpoint=checkpoint)
+        trainer.save_model()  # Saves the feature extractor too for easy upload
+
+        metrics = train_result.metrics
+        if data_args.max_train_samples:
+            metrics["train_samples"] = data_args.max_train_samples
+        trainer.log_metrics("train", metrics)
+        trainer.save_metrics("train", metrics)
+        trainer.save_state()
+
+    # 13. Evaluation
+    results = {}
+    if training_args.do_eval:
+        logger.info("*** Evaluate ***")
+        metrics = trainer.evaluate(
+            metric_key_prefix="eval",
+            max_length=training_args.generation_max_length,
+            num_beams=training_args.generation_num_beams,
+        )
+        if data_args.max_eval_samples:
+            metrics["eval_samples"] = data_args.max_eval_samples
+
+        trainer.log_metrics("eval", metrics)
+        trainer.save_metrics("eval", metrics)
+
+    # 14. Write Training Stats
+    kwargs = {
+        "finetuned_from": model_args.model_name_or_path,
+        "tasks": "automatic-speech-recognition",
+        "tags": "whisper-event",
+    }
+    if data_args.dataset_name is not None:
+        kwargs["dataset_tags"] = data_args.dataset_name
+        if data_args.dataset_config_name is not None:
+            kwargs["dataset"] = f"{data_args.dataset_name} {data_args.dataset_config_name}"
+        else:
+            kwargs["dataset"] = data_args.dataset_name
+        if "common_voice" in data_args.dataset_name:
+            kwargs["language"] = data_args.dataset_config_name
+        if model_args.model_index_name is not None:
+            kwargs["model_name"] = model_args.model_index_name
+
+    if training_args.push_to_hub:
+        trainer.push_to_hub(**kwargs)
+    else:
+        trainer.create_model_card(**kwargs)
+
+    return results
+
+
+if __name__ == "__main__":
+    main()

runs/Dec16_20-24-38_129-146-160-68/1671222292.263272/events.out.tfevents.1671222292.129-146-160-68.394631.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bbb5de04b87d9d39bcbcf398bb0ea62df668dbfffa1e93e116c0513ed0eaf54d
+size 5876

runs/Dec16_20-24-38_129-146-160-68/events.out.tfevents.1671222292.129-146-160-68.394631.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6ca756f5e0cb3bbc0818998fbb6512f85a7c0ba932c38d7ca3098791e7daa5c
+size 4272

runs/Dec16_20-26-39_129-146-160-68/1671222412.8615997/events.out.tfevents.1671222412.129-146-160-68.394809.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6217fe548e67929a91b1b4fe1fa5e22c30713b8bc554e0b54ec3847303a31974
+size 5876

runs/Dec16_20-26-39_129-146-160-68/events.out.tfevents.1671222412.129-146-160-68.394809.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c84aa2cfe13290997faf976c65487b8b968b603c6d685898f9d7429884bf1a54
+size 5670

runs/Dec16_21-21-11_129-146-160-68/1671226550.1156573/events.out.tfevents.1671226550.129-146-160-68.395790.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95a0a3442849d1c71f5aba8be7a53374713edde84d6d2bb84388307070f3f284
+size 5876

runs/Dec16_21-21-11_129-146-160-68/events.out.tfevents.1671226550.129-146-160-68.395790.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c359f30b1b4312d7c01d778968d2dc9a3af5e838c0fd9dde00998c3a8540f8c9
+size 4272

runs/Dec16_21-57-02_129-146-160-68/1671227839.103308/events.out.tfevents.1671227839.129-146-160-68.396724.1

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8fa5523efc0511261b61eb93a79263f01cae0b061a92cc17a96ea76192e37014
+size 5876

runs/Dec16_21-57-02_129-146-160-68/events.out.tfevents.1671227839.129-146-160-68.396724.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:345c8130fc74f3ee98e4e8a40d6ac1a5e9a128e9838441a92bddbc4021c8319c
+size 10855

setup_env.sh

@@ -0,0 +1,10 @@
+cd ~
+sudo add-apt-repository -y ppa:jonathonf/ffmpeg-4
+sudo apt update
+sudo apt install -y ffmpeg
+sudo apt-get install git-lfs
+env_name=whisper
+python3 -m venv $env_name
+echo "source ~/$env_name/bin/activate" >> ~/.bashrc
+cd whisper_sprint
+bash

setup_jupyter.sh

@@ -0,0 +1,4 @@
+pip install jupyterlab
+python -m ipykernel install --user --name=whisper
+tmux new -s mysession
+jupyter lab --port 8888

setup_libs.sh

@@ -0,0 +1,13 @@
+pip install -r requirements.txt
+git lfs install
+python -c "import torch; print(torch.cuda.is_available())"
+git config --global credential.helper store
+huggingface-cli login
+huggingface-cli repo create $2
+git clone https://huggingface.co/$1/$2
+cd $2
+cp ../**.py .
+cp ../**.sh .
+cp ../**.ipynb .
+cp ../ds_config.json .
+wget https://raw.githubusercontent.com/huggingface/community-events/main/whisper-fine-tuning-event/fine-tune-whisper-non-streaming.ipynb

setup_libs_colab.sh

@@ -0,0 +1,12 @@
+pip install -r requirements_colab.txt
+git lfs install
+python -c "import torch; print(torch.cuda.is_available())"
+git config --global credential.helper store
+huggingface-cli login
+huggingface-cli repo create $2
+git clone https://huggingface.co/$1/$2
+cd $2
+cp ../**.py .
+cp ../**.sh .
+cp ../**.ipynb .
+cp ../ds_config.js .

special_tokens_map.json

@@ -0,0 +1,133 @@
+{
+  "additional_special_tokens": [
+    "<|endoftext|>",
+    "<|startoftranscript|>",
+    "<|en|>",
+    "<|zh|>",
+    "<|de|>",
+    "<|es|>",
+    "<|ru|>",
+    "<|ko|>",
+    "<|fr|>",
+    "<|ja|>",
+    "<|pt|>",
+    "<|tr|>",
+    "<|pl|>",
+    "<|ca|>",
+    "<|nl|>",
+    "<|ar|>",
+    "<|sv|>",
+    "<|it|>",
+    "<|id|>",
+    "<|hi|>",
+    "<|fi|>",
+    "<|vi|>",
+    "<|iw|>",
+    "<|uk|>",
+    "<|el|>",
+    "<|ms|>",
+    "<|cs|>",
+    "<|ro|>",
+    "<|da|>",
+    "<|hu|>",
+    "<|ta|>",
+    "<|no|>",
+    "<|th|>",
+    "<|ur|>",
+    "<|hr|>",
+    "<|bg|>",
+    "<|lt|>",
+    "<|la|>",
+    "<|mi|>",
+    "<|ml|>",
+    "<|cy|>",
+    "<|sk|>",
+    "<|te|>",
+    "<|fa|>",
+    "<|lv|>",
+    "<|bn|>",
+    "<|sr|>",
+    "<|az|>",
+    "<|sl|>",
+    "<|kn|>",
+    "<|et|>",
+    "<|mk|>",
+    "<|br|>",
+    "<|eu|>",
+    "<|is|>",
+    "<|hy|>",
+    "<|ne|>",
+    "<|mn|>",
+    "<|bs|>",
+    "<|kk|>",
+    "<|sq|>",
+    "<|sw|>",
+    "<|gl|>",
+    "<|mr|>",
+    "<|pa|>",
+    "<|si|>",
+    "<|km|>",
+    "<|sn|>",
+    "<|yo|>",
+    "<|so|>",
+    "<|af|>",
+    "<|oc|>",
+    "<|ka|>",
+    "<|be|>",
+    "<|tg|>",
+    "<|sd|>",
+    "<|gu|>",
+    "<|am|>",
+    "<|yi|>",
+    "<|lo|>",
+    "<|uz|>",
+    "<|fo|>",
+    "<|ht|>",
+    "<|ps|>",
+    "<|tk|>",
+    "<|nn|>",
+    "<|mt|>",
+    "<|sa|>",
+    "<|lb|>",
+    "<|my|>",
+    "<|bo|>",
+    "<|tl|>",
+    "<|mg|>",
+    "<|as|>",
+    "<|tt|>",
+    "<|haw|>",
+    "<|ln|>",
+    "<|ha|>",
+    "<|ba|>",
+    "<|jw|>",
+    "<|su|>",
+    "<|translate|>",
+    "<|transcribe|>",
+    "<|startoflm|>",
+    "<|startofprev|>",
+    "<|nocaptions|>",
+    "<|notimestamps|>"
+  ],
+  "bos_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "eos_token": {
+    "content": "<|endoftext|>",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  },
+  "pad_token": "<|endoftext|>",
+  "unk_token": {
+    "content": "",
+    "lstrip": false,
+    "normalized": true,
+    "rstrip": false,
+    "single_word": false
+  }
+}

split_mgb2_test.py

@@ -0,0 +1,20 @@
+import soundfile as sf
+import os
+
+os.makedirs("dataset", exist_ok=True)
+archive_path = "test"
+wav_dir = os.path.join(archive_path, "wav")
+segments_file = os.path.join(archive_path, "text.all")
+with open(segments_file, "r", encoding="utf-8") as f:
+    for _id, line in enumerate(f):
+        segment = line.split(" ")[0]
+        text = " ".join(line.split(" ")[1:])
+        wav_name, _, time = segment.split("_")
+        time = time.replace("seg-", "")
+        start, stop = time.split(":")
+        start = int(int(start) / 100 * 16_000)
+        stop = int(int(stop) / 100 * 16_000)
+        wav_path = os.path.join(wav_dir, wav_name + ".wav")
+        sound, _ = sf.read(wav_path, start=start, stop=stop)
+        sf.write(f"dataset/{segment}.wav", sound, 16_000)
+        open(f"dataset/{segment}.txt", "w").write(text)