BIF_Translator_Acquadro_502311_Uttini_502183.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#**BIF TRANSLATOR**\n",
        "A project by:\n",
        "Acquadro Patrizio - 502311\n",
        "Uttini Lorenzo - 502183\n",
        "\n",
        "In this colab notebook we perform a machine translation task, using the Keras library to exploit the different architectures, useful to accomplish this task.\n"
      ],
      "metadata": {
        "id": "bYpRNuyoJ_fH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##***INITIATION***\n",
        "We install the packages we need and we import all the different methods and functions that we need in the respective coding blocks."
      ],
      "metadata": {
        "id": "Ps1xgBfVKhLQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install jiwer"
      ],
      "metadata": {
        "id": "POCJ_LPOIWNh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d221f408-f58b-4a97-ca19-58a54cf4ca6a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting jiwer\n",
            "  Downloading jiwer-3.0.2-py3-none-any.whl (21 kB)\n",
            "Requirement already satisfied: click<9.0.0,>=8.1.3 in /usr/local/lib/python3.10/dist-packages (from jiwer) (8.1.4)\n",
            "Collecting rapidfuzz==2.13.7 (from jiwer)\n",
            "  Downloading rapidfuzz-2.13.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.2/2.2 MB\u001b[0m \u001b[31m45.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: rapidfuzz, jiwer\n",
            "Successfully installed jiwer-3.0.2 rapidfuzz-2.13.7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install sacrebleu"
      ],
      "metadata": {
        "id": "3K5BjLeyI_3Z",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "398bb904-2f5b-4efc-f259-a44f2d9ccf68"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting sacrebleu\n",
            "  Downloading sacrebleu-2.3.1-py3-none-any.whl (118 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/118.9 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m118.9/118.9 kB\u001b[0m \u001b[31m8.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting portalocker (from sacrebleu)\n",
            "  Downloading portalocker-2.7.0-py2.py3-none-any.whl (15 kB)\n",
            "Requirement already satisfied: regex in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (2022.10.31)\n",
            "Requirement already satisfied: tabulate>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (0.8.10)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (1.22.4)\n",
            "Collecting colorama (from sacrebleu)\n",
            "  Downloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)\n",
            "Requirement already satisfied: lxml in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (4.9.3)\n",
            "Installing collected packages: portalocker, colorama, sacrebleu\n",
            "Successfully installed colorama-0.4.6 portalocker-2.7.0 sacrebleu-2.3.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lllmHmOloENp"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "import string\n",
        "import re\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers, Model, Input\n",
        "from tensorflow.keras.layers import GRU, LSTM, Embedding, Bidirectional, Input, Dropout, Dense\n",
        "\n",
        "import requests\n",
        "import io\n",
        "import zipfile\n",
        "\n",
        "import random\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import nltk\n",
        "from nltk.translate import meteor_score\n",
        "from nltk import FreqDist\n",
        "import jiwer\n",
        "\n",
        "import tensorflow as tf\n",
        "import string\n",
        "import re\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers, Model, Input\n",
        "from tensorflow.keras.layers import GRU, LSTM, Embedding, Bidirectional, Input, Dropout, Dense\n",
        "\n",
        "import sacrebleu"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###***Read the file***\n",
        "We loaded the file zipped on github. <br>\n",
        "Then, we read the file from our github link and we unzip it."
      ],
      "metadata": {
        "id": "4QfvChBqTr6A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Read the file\n",
        "url = \"https://github.com/lorenzouttini/Exam_NLP/raw/main/ita-eng.zip\"\n",
        "response = requests.get(url)\n",
        "\n",
        "#Unzip the file\n",
        "zip_file = zipfile.ZipFile(io.BytesIO(response.content))\n",
        "zip_file.extractall()"
      ],
      "metadata": {
        "id": "biWNfgnvoLxE"
      },
      "execution_count": 90,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Preprocessing of the text\n"
      ],
      "metadata": {
        "id": "Bi_DjrV-TzUf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Construct the list of the pairs\n",
        "\n",
        "We call our text **\"text_file\"**. <br>\n",
        "\n",
        "\n",
        "Since the original text contains the english sentences paired with the italian ones(separated by a \"*tab*\" character), we have created a list called **\"list_pairs\"** where we put the tuples composed by the english sentence and the translated italian one.  <br>\n",
        "\n",
        "\n",
        "In the italian translation we have added the start and end **tokens**."
      ],
      "metadata": {
        "id": "YeD2kAlhT6_s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Instantiate the file\n",
        "text_file = \"ita.txt\""
      ],
      "metadata": {
        "id": "lZKORMThoNKD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Open it\n",
        "with open(\"ita.txt\", \"r\") as file:\n",
        "    lines = file.readlines()\n",
        "\n",
        "# Created our new dataset composed by english and italian sentences seperated\n",
        "pairs_list = []\n",
        "for line in lines:\n",
        "    parts = line.split(\"\\t\")\n",
        "    if len(parts) >= 2:\n",
        "        english = parts[0].strip()\n",
        "        italian = parts[1].strip()\n",
        "        italian = \"[start] \" + italian + \" [end]\"     # starting and ending tokens\n",
        "        pairs_list.append((english, italian))          # append to the list the pairs (english/italian)\n",
        "\n",
        "print(pairs_list[:5])\n",
        "print(len(pairs_list))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PkBfWOuHoO7j",
        "outputId": "f8b7f9ab-11fd-4cfa-9b84-b020510e70a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[('Hi.', '[start] Ciao! [end]'), ('Hi.', '[start] Ciao. [end]'), ('Run!', '[start] Corri! [end]'), ('Run!', '[start] Corra! [end]'), ('Run!', '[start] Correte! [end]')]\n",
            "364200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Randomly remove 80% of the elements\n",
        "pairs_list = random.sample(pairs_list, k=int(0.8 * len(pairs_list)))\n",
        "\n",
        "print(len(pairs_list))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GQcMqTj2pskC",
        "outputId": "e7432e45-b9bd-4766-922c-e252f52d8772"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "291360\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Analyzing the dataset\n",
        "\n",
        "We compute some statistics for Italian and English sentences and words, to analyze completely the dataset that we have.\n",
        "\n",
        "These statistics, for both the italian and the english words and sentences, are:\n",
        "- the total number of both\n",
        "- the mean of both\n",
        "- the maximum lenght of a sentence\n",
        "- the number of unique words\n",
        "\n",
        "Then we've plotted also their distributions with the respective mean\n",
        "\n",
        "And at the end we also plot the graph derived from the Zipf's law, to display the words according to their rank, based on their frequency\n",
        "\n"
      ],
      "metadata": {
        "id": "dA7Oe9oVC7r3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Statistics for Italian sentences:**"
      ],
      "metadata": {
        "id": "QdIqpd2ZDzeq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nltk.download('punkt')\n",
        "\n",
        "# Tokenize the Italian words\n",
        "words_ita = [word.lower() for pair in pairs_list for word in nltk.word_tokenize(pair[1])]\n",
        "\n",
        "# Filter out the special tokens\n",
        "filtered_words = [word for word in words_ita if word not in [\"[\", \"]\", \"start\", \"end\"]]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LLk2PZe-oQ7r",
        "outputId": "e096924c-3fa7-4846-cd8b-0b0bddf2347d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Unzipping tokenizers/punkt.zip.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute Italian statistics\n",
        "total_word_ita = len(filtered_words)\n",
        "total_sentences_ita = len(pairs_list)\n",
        "mean_word_length_ita = round(sum(len(word) for word in filtered_words) / total_word_ita)\n",
        "mean_sentence_length_ita = round(total_word_ita / total_sentences_ita)\n",
        "unique_words_ita = len(set(filtered_words))\n",
        "\n",
        "# Print the Italian statistics\n",
        "print(\"Total number of Italian words (excluding tokens):\", total_word_ita)\n",
        "print(\"Total number of sentences:\", total_sentences_ita)\n",
        "print(\"Mean length of Italian words (excluding tokens):\", mean_word_length_ita)\n",
        "print(\"Mean length of Italian sentences:\", mean_sentence_length_ita)\n",
        "print(\"Number of unique Italian words (excluding tokens):\", unique_words_ita)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3Bd6xzDOoSwz",
        "outputId": "cee09686-c027-4815-d303-9ca209574ba6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total number of Italian words (excluding tokens): 1889125\n",
            "Total number of sentences: 291360\n",
            "Mean length of Italian words (excluding tokens): 4\n",
            "Mean length of Italian sentences: 6\n",
            "Number of unique Italian words (excluding tokens): 27191\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#ITALIAN SENTENCE LENGHT DISTRIBUTION\n",
        "italian_lengths = []\n",
        "\n",
        "for pair in pairs_list:\n",
        "    italian_sentence = pair[1]\n",
        "    italian_length = len(italian_sentence.split())\n",
        "    italian_lengths.append(italian_length)\n",
        "\n",
        "#Compute the mean\n",
        "mean_italian_length = round(sum(len(word) for word in filtered_words) / total_word_ita)\n",
        "\n",
        "# Create the subplot\n",
        "plt.figure(figsize=(4, 3))\n",
        "\n",
        "# Plot of the distribution\n",
        "plt.hist(italian_lengths, bins=60, color='red', alpha=0.5)\n",
        "plt.axvline(mean_italian_length, color='black', linestyle='dashed', linewidth=1)\n",
        "plt.xlabel('Italian Sentence Length')\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Distribution of Italian Sentence Lengths\\nMean: {:.2f}'.format(mean_italian_length))\n",
        "\n",
        "# Print the graph\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "csOCsVL1Hf4K",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 307
        },
        "outputId": "7dd551f9-c096-408a-b1c1-0e4095f5ecf3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#ITALIAN WORDS LENGHT DISTRIBUTION\n",
        "italian_word_lengths = []\n",
        "\n",
        "for pair in pairs_list:\n",
        "    italian_sentence = pair[1]\n",
        "    italian_words = italian_sentence.split()\n",
        "\n",
        "    for word in italian_words:\n",
        "        italian_word_lengths.append(len(word))\n",
        "\n",
        "# Compute the mean\n",
        "mean_italian_word_length = sum(italian_word_lengths) / len(italian_word_lengths)\n",
        "\n",
        "# Create a subplot\n",
        "plt.figure(figsize=(4, 3))\n",
        "\n",
        "# Plot of the distribution\n",
        "plt.hist(italian_word_lengths, bins=20, color='red', alpha=0.5)\n",
        "plt.axvline(mean_italian_word_length, color='black', linestyle='dashed', linewidth=1)\n",
        "plt.xlabel('Italian Word Length')\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Distribution of Italian Word Lengths\\nMean: {:.2f}'.format(mean_italian_word_length))\n",
        "\n",
        "#Display the graph\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 307
        },
        "id": "uUXNM04XLeZa",
        "outputId": "7941ba4a-13ee-494a-bd30-400353ab9bba"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot Zipf's Law graph\n",
        "fdist = FreqDist(filtered_words)\n",
        "plt.title(\"Zipf's Law Italian\")\n",
        "fdist.plot(30, cumulative=False)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 505
        },
        "id": "rnQ3MEpmoUbs",
        "outputId": "2210968c-906b-429a-a1cc-5923a79920f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "####**Statistics for English sentences:**"
      ],
      "metadata": {
        "id": "W8GGlupQEfbk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nltk.download('punkt')\n",
        "\n",
        "# Tokenize the English words\n",
        "words_eng = [word.lower() for pair in pairs_list for word in nltk.word_tokenize(pair[0])]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S-Tdy8h_ElRI",
        "outputId": "96682112-d161-4545-a2ad-3936e0388ffd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Package punkt is already up-to-date!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute English statistics\n",
        "total_word_eng = len(words_eng)\n",
        "total_sentences_eng = len(pairs_list)\n",
        "mean_word_length_eng = round(sum(len(word) for word in words_eng) / total_word_eng)\n",
        "mean_sentence_length_eng = round(total_word_eng / total_sentences_eng)\n",
        "unique_words_eng = len(set(words_eng))\n",
        "\n",
        "# Print the English statistics\n",
        "print(\"Total number of words (excluding tokens):\", total_word_eng)\n",
        "print(\"Total number of sentences:\", total_sentences_eng)\n",
        "print(\"Mean length of words (excluding tokens):\", mean_word_length_eng)\n",
        "print(\"Mean length of sentences:\", mean_sentence_length_eng)\n",
        "print(\"Number of unique words (excluding tokens):\", unique_words_eng)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y0okxxzUEq0C",
        "outputId": "e13ad9e8-729a-469a-87a0-eb581162d974"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Total number of words (excluding tokens): 2020048\n",
            "Total number of sentences: 291360\n",
            "Mean length of words (excluding tokens): 3\n",
            "Mean length of sentences: 7\n",
            "Number of unique words (excluding tokens): 13406\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#ITALIAN SENTENCE LENGHT DISTRIBUTION\n",
        "english_lengths = []\n",
        "\n",
        "for pair in pairs_list:\n",
        "    english_sentence = pair[0]\n",
        "    english_length = len(english_sentence.split())\n",
        "    english_lengths.append(english_length)\n",
        "\n",
        "#Compute the mean\n",
        "mean_english_length = sum(english_lengths) / len(english_lengths)\n",
        "\n",
        "# Create a subplot\n",
        "plt.figure(figsize=(4, 3))\n",
        "\n",
        "# Plot of the distribution\n",
        "plt.hist(english_lengths, bins=60, color='blue', alpha=0.5)\n",
        "plt.axvline(mean_english_length, color='black', linestyle='dashed', linewidth=1)\n",
        "plt.xlabel('English Sentence Length')\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Distribution of English Sentence Lengths\\nMean: {:.2f}'.format(mean_english_length))\n",
        "\n",
        "#Display the graph\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 307
        },
        "id": "Sn3qC7qjQgsO",
        "outputId": "c0de6639-e2b1-4850-e28b-20cc6f43dc4e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#ENGLISH WORDS LENGHT DISTRIBUTION\n",
        "english_word_lengths = []\n",
        "\n",
        "for pair in pairs_list:\n",
        "    english_sentence = pair[0]\n",
        "    english_words = english_sentence.split()\n",
        "\n",
        "    for word in english_words:\n",
        "        english_word_lengths.append(len(word))\n",
        "\n",
        "#Compute the mean\n",
        "mean_english_word_length = round(sum(len(word) for word in words_eng) / total_word_eng)\n",
        "\n",
        "#Create a subplot\n",
        "plt.figure(figsize=(4, 3))\n",
        "\n",
        "# Plot of the distribution\n",
        "plt.hist(english_word_lengths, bins=20, color='blue', alpha=0.5)\n",
        "plt.axvline(mean_english_word_length, color='black', linestyle='dashed', linewidth=1)\n",
        "plt.xlabel('English Word Length')\n",
        "plt.ylabel('Frequency')\n",
        "plt.title('Distribution of English Word Lengths\\nMean: {:.2f}'.format(mean_english_word_length))\n",
        "\n",
        "#Display the graph\n",
        "plt.tight_layout()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 307
        },
        "id": "TasO7kFYL2dv",
        "outputId": "4c1f84b1-e8de-4271-d2ac-4958fed3f64a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 400x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot Zipf's Law graph\n",
        "fdist = FreqDist(words_eng)\n",
        "plt.title(\"Zipf's Law English\")\n",
        "fdist.plot(30, cumulative=False)\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 492
        },
        "id": "zBcsB3-XFVC_",
        "outputId": "67942d72-a2cd-4072-a15f-24dc99b70e1e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Train, Validation and Test\n",
        "We have defined the proportion of the train, validation and test set:\n",
        "- **Train**: 70%\n",
        "- **Validation**: 15%\n",
        "- **Test**: 15%\n",
        "\n",
        "It is important to notice that the senteces in the original text were ordinated incrementally with the respect to the length. So choose to **shuffle** the dataset before defining training, validation and test.\n",
        "\n",
        "We've already picked randomly the sentences to form the dataset with 80% of the original samples, so this is not necessary, but we've made it to generalize the case."
      ],
      "metadata": {
        "id": "C-PsbxIzUJWW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Shuffle the pairs\n",
        "random.shuffle(pairs_list)\n",
        "\n",
        "# Define the dimensions\n",
        "dim_val = int(0.15 * len(pairs_list))               # define the validation samples (15%)\n",
        "dim_train = len(pairs_list) - 2 * dim_val   # define the train samples (70%)"
      ],
      "metadata": {
        "id": "ZIbCGxpJoW3z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the train, validation and test set pairs\n",
        "train_pairs = pairs_list[:dim_train]\n",
        "val_pairs = pairs_list[dim_train:dim_train + dim_val]\n",
        "test_pairs = pairs_list[dim_train + dim_val:]"
      ],
      "metadata": {
        "id": "Rdzj6uiUoYpD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Prepare Word Vectorization\n",
        "\n",
        "Firstly, we define the punctuation signs with variable **\"punctuation_chars\"**. <br>\n",
        "\n",
        "Since in the tokens (start, end) we have the square brackets, we choose to replace '**[**' , '**]**' with the empty string to keep them then, when we remove the punctuation. <br>\n",
        "\n",
        "Then, we create a function \"**custom_remove**\" that put all the characters in lower case and remove the punctuations we have defined previously. <br>\n",
        "\n",
        "We have defined a **dictionary size** that indicates the number of unique words that the model take in consideration during training of translation. <br>\n",
        "\n",
        "After this, we decided to set the sequence lenght to **15**, that corresponds to the number of tokens processed by each RNN unit.\n",
        "- A <u>larger size</u> could deal better the context to generate more elaborated sentences, but requires more computational resources.\n",
        "- A <u>smaller size</u> could generate more fluent and coherent texts, but it does not consider to much the context."
      ],
      "metadata": {
        "id": "P-BVppnfUQmw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define punctuation signs\n",
        "punctuation_chars = string.punctuation\n",
        "\n",
        "# Keep square brackets\n",
        "punctuation_chars = punctuation_chars.replace(\"[\", \"\")\n",
        "punctuation_chars = punctuation_chars.replace(\"]\", \"\")"
      ],
      "metadata": {
        "id": "T7Pas22JoaUs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Remove all the punctuation signs we have defined\n",
        "def custom_remove(input_string):\n",
        "  lowercase = tf.strings.lower(input_string)\n",
        "  return tf.strings.regex_replace(lowercase, f\"[{re.escape(punctuation_chars)}]\", \"\")    # keep square brackets"
      ],
      "metadata": {
        "id": "PbaVP3o9ob8z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define Vocabulary and Sequence lenght\n",
        "dictionary_size = 25000\n",
        "sequence_size = 15"
      ],
      "metadata": {
        "id": "i7ay8j8Sodcq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "For the pre-processing of text we decide to use an integrated function of keras called TextVectorization, that **remove punctuation** signs and form the new **vocabulary** based on our training sentences. <br>\n",
        "\n",
        "The TextVectorization English layer takes as parameters the \"**dictionary_size**\" and \"**window_size**\". <br>\n",
        "The Italian Layer has the same parameters of the previous one but it adds one unit to \"**output_sequence_lenght**\" (because of the end token) and it introduces a new parameter called \"**standardize**\" that modify the text with the function we have defined previously (\"custom_remove\").  <br>\n",
        "\n",
        "\n",
        "Then, we make a list of all the <u>training sentences</u> (english and italian) and we adapt the Vectorization Layers we have defined on these training lists. <br>\n",
        "This means that all the sentences are turned into **vectors** (dimension=15) of integers which correspond to the words index in the vocabulary.\n",
        "\n"
      ],
      "metadata": {
        "id": "f6p3wWoEUTPY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# English layer\n",
        "eng_vectorization = layers.TextVectorization(\n",
        " max_tokens= dictionary_size,\n",
        " output_mode=\"int\",\n",
        " output_sequence_length=sequence_size,\n",
        ")"
      ],
      "metadata": {
        "id": "mIUkh21Mof7c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Italian layer\n",
        "ita_vectorization = layers.TextVectorization(\n",
        " max_tokens= dictionary_size,\n",
        " output_mode=\"int\",\n",
        " output_sequence_length=sequence_size + 1,     # output consider also ['end'] token\n",
        " standardize=custom_remove,                    # remove punctuations and keep square brackets\n",
        ")"
      ],
      "metadata": {
        "id": "YSEa6aX_ohhK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create training lists\n",
        "train_english_list = [pair[0] for pair in train_pairs]\n",
        "train_italian_list = [pair[1] for pair in train_pairs]\n",
        "\n",
        "print(train_english_list[2])\n",
        "print(train_italian_list[2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WpEyA1mfojLz",
        "outputId": "0c1bca7c-4c75-4021-83c4-2dc4c098f05e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "That's part of our job.\n",
            "[start] Fa parte del nostro lavoro. [end]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Apply vectorization layers on our training lists --> as output we obtain only vectors of 25 integers components\n",
        "eng_vectorization.adapt(train_english_list)\n",
        "ita_vectorization.adapt(train_italian_list)"
      ],
      "metadata": {
        "id": "SHk5NgigolDy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Prepare datasets for the translation\n",
        "\n",
        "Now our aim is to create the validation and training dataset for the translation tasks, by vectoring them. To make this, we create two functions: <br>\n",
        "\n",
        "**1. \"format_dataset**\": with english and italian Vectorization Layers defined before, we preprocess the parameters of the function (eng, ita). We return english proprocessed text and italian preprocessed text of the same lenght (for this reason we remove one dimension from the input and output italian). <br>\n",
        "\n",
        "\n",
        "**2. \"make_dataset\"**: it is the function that creates the real dataset. It takes as a parameter \"*pairs*\" that corresponds to the list of sets formed by pairs. It divides pairs in different elements and transform them in lists. Then, it creates the **dataset** from the two lists (with a special tensorflow dataset). Finally, it formatted the dataset according to the batch size and to the function \"*format_dataset*\" we have defined above. Moreover, we have used the function \"*shuffle*\" to introduce some randomness in the dataset, \"*prefetch*\" to reduce the time for training and \"*cache*\" to save the data locally to optimize the training performances. <br>\n",
        "\n",
        "As last step, we define the ***train*** and ***validation*** dataset with the method we have described above."
      ],
      "metadata": {
        "id": "3Ew8PNbtUXxu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define batch size\n",
        "batch_size = 64\n",
        "\n",
        "# Create the function to format the dataset\n",
        "def format_dataset(eng, ita):\n",
        "  eng = eng_vectorization(eng)\n",
        "  ita = ita_vectorization(ita)\n",
        "  return ({\"english\": eng, \"italian\": ita[:, :-1], },\n",
        "          ita[:, 1:])"
      ],
      "metadata": {
        "id": "P-eX_s6VonBi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the function to make the dataset\n",
        "def make_dataset(set_pairs):\n",
        "  eng_, ita_ = zip(*set_pairs)\n",
        "  eng_ = list(eng_)\n",
        "  ita_ = list(ita_)\n",
        "  dataset = tf.data.Dataset.from_tensor_slices((eng_, ita_))   #Define the dataset from Tensorflow\n",
        "  dataset = dataset.batch(batch_size)                          #Adapt the dataset with dimension of batch\n",
        "  dataset = dataset.map(format_dataset, num_parallel_calls=4)  #Map the dataset with the function format_dataset\n",
        "  return dataset.shuffle(2048).prefetch(16).cache()"
      ],
      "metadata": {
        "id": "Y_6YNe46oooC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the train and validation datasets\n",
        "train_ds = make_dataset(train_pairs)\n",
        "val_ds = make_dataset(val_pairs)"
      ],
      "metadata": {
        "id": "oBJ-ubsmoqOj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the first element\n",
        "first_element = train_ds.take(1)\n",
        "\n",
        "# Iterate over the first_element dataset and print each element\n",
        "for eng_text, ita_text in first_element:\n",
        "    print(\"English Text:\", eng_text)\n",
        "    print(\"Italian Text:\", ita_text)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ia13kv5uU8Sn",
        "outputId": "ef1331c2-d4be-4e93-fe63-a54889d3dcff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "English Text: {'english': <tf.Tensor: shape=(64, 15), dtype=int64, numpy=\n",
            "array([[   25,   248,     7,  1145,    19,    72,    50,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,   115,   118,   250,     6,   913,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,    51,     5,     9,    13,    55,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   44,     2,   541,    15,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,    90,    47,     6,   231,   393,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,    44,     9,    97,   296,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   25,   366,    24,   316,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   76,     3,    18,   955,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   53,  1240,     0,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,   749,    74,   103,   780,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   11,   542,   269,     5,   158,    95,    23,    40,  2902,\n",
            "           19,  1203,     0,     0,     0,     0],\n",
            "       [    4,    16,    34,   527,    28,     3,   185,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   52,    45,  1091,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,  1798,     7,   107,    19,    68,   408,   858,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [  100,   621,    49,   195,     2,   282,    22,     2,    12,\n",
            "            5,     9,    13,     0,     0,     0],\n",
            "       [    4,    86,    30,     5,    12,   108,   125,   457,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,   882,    15,    11,   322,     9,    10,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,    77,    63,     5,     9,    10,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    20,     7,   301,   435,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,    51,    70,   207,   114,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   18,   820,     0,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [ 3943,     8,    33,     7,   293,    78,    43,   318,    14,\n",
            "          754,   938,     0,     0,     0,     0],\n",
            "       [   28,    20,   344,  2707,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,  1024,     3,    48,    32,    20,    92,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   25,  3964,   699,     6,   409,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   225,   518,    97,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   72,   550,    37,  1043,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,    27,     5,   382,     3,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   18,  1517,     0,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    8,    13,  4400, 11761,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   11,    17,    33,     7,   139,  6591,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [  204,    90,     5,    39,  1114,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,   142,   151,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [  697,    23,     6,   889,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,  1137,     3,     5,   356,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   16,   238,    80,   218,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [  112,    15,     6,   133,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   357,   257,    47,    70,   876,  2686,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,     8,    14,     7,    73,  1346,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,   182,     5,    22,   826,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   18,   127,   212,    30,    13,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   89,  4070,     5,   877,     6,   222,    17,  2465,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [ 1818,     8,   101,  1538,   124,   524,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,   205,     3,  2452,    14,    65,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    6,  1541,     8,    33,   994,   175,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,   237,    21,   880,    23,    26,   229,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   18,   239,     4,   792,   158,   377,  1299,    14,   319,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   11,   285,   264,  2450,   103,   353,   164,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   18,    58,     5,   194,     2,     7,  4737,    19,   438,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [  131,    30,     7,   256,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   20,     2,   414,   151,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    7,  2602,    17,  1685,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   96,     9,     2,   105,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,    51,     7,  1125,   898,    19,  2289,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,  1380,    23,    33,   330,  1336,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   66,     3,     0,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   37,  3536,     0,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [  126,     7,  1119,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    4,   110,     6,  1355,    28,     4,   242,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [  165,     7,   240,    55,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    8,    24,   365,     7,  1828,  4843,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   46,  6703,    74,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    3,    54,    45,  6266,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [   11,   508,  1504,    42,    15,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0]])>, 'italian': <tf.Tensor: shape=(64, 15), dtype=int64, numpy=\n",
            "array([[    2,    36,    79,   264,    20,  1549,    56,  3511,     6,\n",
            "            4,     3,     0,     0,     0,     0],\n",
            "       [    2,     4,     8,   648,    17,   773,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,   128,    99,   109,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     5,    72,    15,  3060,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    12,  5581,   200,   393,   450,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    12,     5,    19,    69,   123,     6,   240,     3,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,  5004,    11,   146,   310,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   611,     7,     4,     9,    15,  1114,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,  5202,     3,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    29, 22879,     6,   573,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    13,   835,   577,    16, 13777,    74,    64,  4135,\n",
            "            6,  1930,     3,     0,     0,     0],\n",
            "       [    2,    12,     5,    83,   514,     9,    39,    90,     4,\n",
            "            3,     0,     0,     0,     0,     0],\n",
            "       [    2, 12827,  1017,     3,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,  3024,    27,   111,     7,   318,     7,   674,\n",
            "            3,     0,     0,     0,     0,     0],\n",
            "       [    2,     5,   518,   134,    45,   787,    38,   311,   220,\n",
            "          526,     3,     0,     0,     0,     0],\n",
            "       [    2,    18,   385,   172,    14,   214,    87,     6,   445,\n",
            "            3,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,    18,    13,  1087,     9,     5,    29,   369,\n",
            "           69,     3,     0,     0,     0,     0],\n",
            "       [    2,    12,   122,    55,    99,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    41,    20,   387,   322,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,    13,    20,   914,   690,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    12,   118,    15,  1093,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    10,  5718,     5,     8,    20,    39,     9,    31,\n",
            "          105,   367,    17,    41,  1035,     3],\n",
            "       [    2,    39,    15,  1198,  3793,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,  1153,     9,     4,    40,    24,   739,     7,    59,\n",
            "            3,     0,     0,     0,     0,     0],\n",
            "       [    2,  1383,   355,   235,  1169,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     5,    13,   251,   125,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    26,   579,     6,     4,   237,  3635,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    54,   968,     4,     3,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    12,    15,  5203,     3,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    22, 12279,  1083,  2658,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    35,     5,   165,  8265,  1994,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   128,    63,    37,   875,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    12,    42,   118,   437,   141,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   434,    16,    10,  1678,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    18,  1553,     9,     4,  5498,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     5,  1334,    91,     3,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   843,    11,   119,     3,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     5,   374,   402,     7,  2272,  1940,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,     8,     6,   333,  1859,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    12,    98,  1619,     3,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    15,   254,     9,    26,   869,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    10,    64,   288,    16,   666,   114,  1310,   307,\n",
            "        13867,     3,     0,     0,     0,     0],\n",
            "       [    2,    10,  2345,     8,    27,    37,   201,    56,   517,\n",
            "            3,     0,     0,     0,     0,     0],\n",
            "       [    2,   221,     9,     4,  2492,     7,    70,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    10,  1861,     5,     8,    55,  5147,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    19,   191,    60,   924,    16,    50,   184,     3,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   903,     6,     5,  1977,     7,  1299,   550,    17,\n",
            "          551,     3,     0,     0,     0,     0],\n",
            "       [    2,    96,    66,    38,  5784,    30,   205,  1159,     3,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    72,   429,    20,  2411,     6,   499,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     7,    42,   385,    14,   230,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    22,   783,   141,     3,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   307,  1990,    14,  2595,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,   106,  1928,     3,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,    13,   158,   575,   854,  4399,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,    31,     8,  2369,    16,     5,    38,   389,\n",
            "          136,     3,     0,     0,     0,     0],\n",
            "       [    2,  2430,     4,     3,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    73,  2552,     3,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,  3037,     3,     0,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,  1102,    67,  1307,    75,     9,   287,     3,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    22,    14,   378,   109,     3,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    48,   358,     8,    14,  7844,     6,  4086,     3,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    29, 12894,     3,     0,     0,     0,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,     4,     5,     8,    27, 19486,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0],\n",
            "       [    2,    35,    13,  1242,     7,  7208,     3,     0,     0,\n",
            "            0,     0,     0,     0,     0,     0]])>}\n",
            "Italian Text: tf.Tensor(\n",
            "[[   36    79   264    20  1549    56  3511     6     4     3     0     0\n",
            "      0     0     0]\n",
            " [    4     8   648    17   773     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    4   128    99   109     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    5    72    15  3060     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   12  5581   200   393   450     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   12     5    19    69   123     6   240     3     0     0     0     0\n",
            "      0     0     0]\n",
            " [ 5004    11   146   310     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [  611     7     4     9    15  1114     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [ 5202     3     0     0     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   29 22879     6   573     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   13   835   577    16 13777    74    64  4135     6  1930     3     0\n",
            "      0     0     0]\n",
            " [   12     5    83   514     9    39    90     4     3     0     0     0\n",
            "      0     0     0]\n",
            " [12827  1017     3     0     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    4  3024    27   111     7   318     7   674     3     0     0     0\n",
            "      0     0     0]\n",
            " [    5   518   134    45   787    38   311   220   526     3     0     0\n",
            "      0     0     0]\n",
            " [   18   385   172    14   214    87     6   445     3     0     0     0\n",
            "      0     0     0]\n",
            " [    4    18    13  1087     9     5    29   369    69     3     0     0\n",
            "      0     0     0]\n",
            " [   12   122    55    99     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   41    20   387   322     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    4    13    20   914   690     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   12   118    15  1093     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   10  5718     5     8    20    39     9    31   105   367    17    41\n",
            "   1035     3     0]\n",
            " [   39    15  1198  3793     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [ 1153     9     4    40    24   739     7    59     3     0     0     0\n",
            "      0     0     0]\n",
            " [ 1383   355   235  1169     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    5    13   251   125     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   26   579     6     4   237  3635     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   54   968     4     3     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   12    15  5203     3     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   22 12279  1083  2658     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   35     5   165  8265  1994     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [  128    63    37   875     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   12    42   118   437   141     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [  434    16    10  1678     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   18  1553     9     4  5498     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    5  1334    91     3     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [  843    11   119     3     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    5   374   402     7  2272  1940     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    4     8     6   333  1859     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   12    98  1619     3     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   15   254     9    26   869     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   10    64   288    16   666   114  1310   307 13867     3     0     0\n",
            "      0     0     0]\n",
            " [   10  2345     8    27    37   201    56   517     3     0     0     0\n",
            "      0     0     0]\n",
            " [  221     9     4  2492     7    70     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   10  1861     5     8    55  5147     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   19   191    60   924    16    50   184     3     0     0     0     0\n",
            "      0     0     0]\n",
            " [  903     6     5  1977     7  1299   550    17   551     3     0     0\n",
            "      0     0     0]\n",
            " [   96    66    38  5784    30   205  1159     3     0     0     0     0\n",
            "      0     0     0]\n",
            " [   72   429    20  2411     6   499     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    7    42   385    14   230     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   22   783   141     3     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [  307  1990    14  2595     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [  106  1928     3     0     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    4    13   158   575   854  4399     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    4    31     8  2369    16     5    38   389   136     3     0     0\n",
            "      0     0     0]\n",
            " [ 2430     4     3     0     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   73  2552     3     0     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [ 3037     3     0     0     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [ 1102    67  1307    75     9   287     3     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   22    14   378   109     3     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   48   358     8    14  7844     6  4086     3     0     0     0     0\n",
            "      0     0     0]\n",
            " [   29 12894     3     0     0     0     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [    4     5     8    27 19486     3     0     0     0     0     0     0\n",
            "      0     0     0]\n",
            " [   35    13  1242     7  7208     3     0     0     0     0     0     0\n",
            "      0     0     0]], shape=(64, 15), dtype=int64)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Print the shape of each element\n",
        "for inputs, targets in first_element:\n",
        "  print(f\"inputs['english'].shape: {inputs['english'].shape}\")\n",
        "  print(f\"inputs['italian'].shape: {inputs['italian'].shape}\")\n",
        "  print(f\"targets.shape: {targets.shape}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oi6Cz9COU-Of",
        "outputId": "c4305e1c-227b-4890-cd48-bbd8decd2e36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "inputs['english'].shape: (64, 15)\n",
            "inputs['italian'].shape: (64, 15)\n",
            "targets.shape: (64, 15)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#***RNN: BIDIRECTIONAL WITH GRU***"
      ],
      "metadata": {
        "id": "6CExL-jbVBCb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Definition of the RNN decoder and encoder\n",
        "\n",
        "In this part we've defined the **first model** to perform the task of translation. <br>\n",
        "\n",
        "Firstly, we have defined the **ENCODER** with different layers:\n",
        "- **Input Layer**: it defines the input of the encoder (English sentences). The *\"shape\"* = (None,) indicates that the sequences could be various lengths.\n",
        "- **Embedding Layer**: from our vectors of dimension (64,25), it creates 30000 (dictionary_size) embeddings of dimensions 256. The parameter \"*mask_zero*\"= **True** allows the embedding to not consider the 0s elements of the input vectors (because Text Vectorization layer have padded the sequences < 25 words).\n",
        "- **Bidirectional Layer**: it is a bidirectional RNN unit that works with 2 GRU. The output of the two GRU will be summed (*merge_mode = 'sum'*). <br>\n",
        "\n",
        "Then, we've defined the **DECODER** with some layers:\n",
        " - **Input Layer**: it has the same function of the encoder's one but we give as inputs Italian sentences (that are the actual target).\n",
        " - **Embedding Layer**: it has the same functions of the encoder's one.\n",
        " - **GRU Layer**: it is a RNN unit that has as *input* the Italian sentence (actual target) and as parameter \"*hidden_state*\" the output of the encoder part (which corresponds to the initial state of the decoder).\n",
        " - **Dropout Layer**: it removes temporarily 50% of the units during training to avoid overfitting.\n",
        " - **Dense Laye**r: it is a classic *Multilayer Perceptron* that allows the prediction of the next token through the softmax (as *activation function*)."
      ],
      "metadata": {
        "id": "xOkyaYFrVBkv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define Embedding dimension and Latent dimension\n",
        "embed_dim = 256\n",
        "hid_dim = 1024"
      ],
      "metadata": {
        "id": "WPnuz6Q0osDq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Bidirectional based encoder\n",
        "input_eng = Input(shape=(None,), dtype=\"int64\", name=\"english\")\n",
        "embedding_enc = Embedding(dictionary_size, embed_dim, mask_zero=True)(input_eng)\n",
        "encoded_source = Bidirectional(GRU(hid_dim), merge_mode=\"sum\")(embedding_enc)"
      ],
      "metadata": {
        "id": "V175qn9xotv7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# GRU based decoder\n",
        "input_ita = Input(shape=(None,), dtype=\"int64\", name=\"italian\")\n",
        "embedding_dec = Embedding(dictionary_size, embed_dim, mask_zero=True)(input_ita)\n",
        "decoder_gru = GRU(hid_dim, return_sequences=True)\n",
        "dec_gru = decoder_gru(embedding_dec, initial_state=encoded_source)\n",
        "dropout = Dropout(0.5)(dec_gru)\n",
        "output_target = Dense(dictionary_size, activation=\"softmax\")(dropout)"
      ],
      "metadata": {
        "id": "7CQNvzCYowA6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Define the model, compile and train it\n",
        "\n",
        "We have defined the model (encoder and decoder) calling it 'model_seq2seq_GRU'.\n",
        "\n",
        "In the compiling part we choose as **optimizer** '*adam*', as **loss** '*sparse_categorical_crossentropy*' and as **metrics** '*accuracy*'. <br>\n",
        "Then, we **train** the model and we see the performance also on the **Validation** set."
      ],
      "metadata": {
        "id": "ChED4m6YVIJf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Define the model\n",
        "model_seq2seq_GRU = Model([input_eng, input_ita], output_target)"
      ],
      "metadata": {
        "id": "qa2WYFY1ox5U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_seq2seq_GRU.compile(\n",
        " optimizer=\"adam\",\n",
        " loss=\"sparse_categorical_crossentropy\",\n",
        " metrics=['accuracy'])"
      ],
      "metadata": {
        "id": "W24chY6Xo0Fa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "GRU_history = model_seq2seq_GRU.fit(train_ds, epochs=5, validation_data=val_ds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5L-CeoN2TOTh",
        "outputId": "7cb4c7d5-2d2e-4a3a-e27f-46b571ce0b42"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "3187/3187 [==============================] - 387s 115ms/step - loss: 2.7673 - accuracy: 0.5409 - val_loss: 1.4888 - val_accuracy: 0.7013\n",
            "Epoch 2/5\n",
            "3187/3187 [==============================] - 337s 106ms/step - loss: 1.2865 - accuracy: 0.7229 - val_loss: 1.0581 - val_accuracy: 0.7661\n",
            "Epoch 3/5\n",
            "3187/3187 [==============================] - 332s 104ms/step - loss: 0.9134 - accuracy: 0.7756 - val_loss: 0.9439 - val_accuracy: 0.7867\n",
            "Epoch 4/5\n",
            "3187/3187 [==============================] - 330s 103ms/step - loss: 0.7498 - accuracy: 0.8007 - val_loss: 0.9052 - val_accuracy: 0.7953\n",
            "Epoch 5/5\n",
            "3187/3187 [==============================] - 329s 103ms/step - loss: 0.6565 - accuracy: 0.8165 - val_loss: 0.8943 - val_accuracy: 0.7994\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#***TRANSFORMERS***"
      ],
      "metadata": {
        "id": "UjjofjcWWJ6G"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We're defining the transformer architecture, to perform the machine translation task, instead of using the RNN models. <br>\n",
        "This because we want to exploit the parallelization to generate a more natural and human-like translation, but also to speed up the process.<br>\n",
        "And also because we want to detect correctly the long-term dependencies of the sentence's terms.\n",
        "\n",
        "So, at first, to define the architecture we define 3 different classes:\n",
        "- Positional Embedding: to be aware of the position of the tokens in the input sentence\n",
        "- Transformer Encoder: to set up the encoder of the transformer model, since we are in a seq-2-seq task.\n",
        "- Transformer Decoder: to set up the decoder of the transformer, in order to make the translation of the input sentence.\n",
        "\n",
        "To design all this, we've looked at the Keras documentation on Transformers, available online."
      ],
      "metadata": {
        "id": "0q0fPDcnWMcs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### ***Positional Embedding***\n",
        "This embedding is used to be aware of the *position of the tokens* is the sentence, which is fundamental to get a right translation. <br>\n",
        "This has to be done, since we provide to the model all the tokens embeddings in parallel, so regardless their position.\n",
        "\n",
        "We've *different method* to define this class:\n",
        "- **init**: we intialize the class's attributes, that define all the elements that we need, including token embedding and the position embedding.\n",
        "- **call**: method to return the sum of the token embedding and the positional embedding(embedding vectors), based on the input what we pass as parameter.\n",
        "- **compute_mask**: generate mask to ignore the 0s padding that we have made when we've set the sequence lenght equal to 15 also for sequence with less than 15 tokens.\n",
        "- **get_config**: to save this configuration and to use it when we call it in other layers."
      ],
      "metadata": {
        "id": "o0ln5pffWPsz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class PositionalEmbedding(layers.Layer):\n",
        "  def __init__(self, sequence_length, input_dim, output_dim, **kwargs):\n",
        "    super().__init__(**kwargs)\n",
        "    self.token_embeddings = layers.Embedding(input_dim=input_dim,\n",
        "                                             output_dim=output_dim)\n",
        "    self.position_embeddings = layers.Embedding(input_dim=sequence_length,\n",
        "                                                output_dim=output_dim)\n",
        "    self.sequence_length = sequence_length\n",
        "    self.input_dim = input_dim\n",
        "    self.output_dim = output_dim\n",
        "\n",
        "  def call(self, inputs):\n",
        "    length = tf.shape(inputs)[-1]\n",
        "    positions = tf.range(start=0, limit=length, delta=1)\n",
        "    embedded_tokens = self.token_embeddings(inputs)\n",
        "    embedded_positions = self.position_embeddings(positions)\n",
        "    return embedded_tokens + embedded_positions\n",
        "\n",
        "  def compute_mask(self, inputs, mask=None):\n",
        "    return tf.math.not_equal(inputs, 0)\n",
        "\n",
        "  def get_config(self):\n",
        "    config = super().get_config()\n",
        "    config.update({\n",
        "      \"output_dim\": self.output_dim,\n",
        "      \"sequence_length\": self.sequence_length,\n",
        "      \"input_dim\": self.input_dim,})\n",
        "    return config"
      ],
      "metadata": {
        "id": "Zq0YK8EepHZD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###***Transformer Encoder***\n",
        "In a seq-2-seq model we have at first an **encoder**, to get the parsed representation of the entire input sequence.\n",
        "\n",
        "At first we use **multi head attention layer**, to understand which parts of the sentence are more related to each word of the sentence. <br>\n",
        "We obtain a vector that we combine with the original input vector, using a skip connection. <br>\n",
        "Then we normalize using the **layerNormalization**.\n",
        "\n",
        "Then we process this with a **feed-forward network**(MLP) with 2 dense layers. <br>\n",
        "The output that we obtain is then added with again the input vector, using another skip connection, and this sum will be normalized using a **layerNormalization**.\n",
        "\n",
        "This will be the input of the decoder part.\n",
        "\n",
        "We have different methods to define this clas:\n",
        "- init: where we've defined all the layers described above.\n",
        "- call: performs all the computations, so computes the attention output, the projection input(after the addition of the input vector and normalization), the projection output and the normalized sum of this latter with the input vector.\n",
        "- get_config: returns a dictionary which is the encoder configuration, used when we call the encoder in the model."
      ],
      "metadata": {
        "id": "vIm9NPfHWSYF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TransformerEncoder(layers.Layer):\n",
        "  def __init__(self, embed_dim, dense_dim, num_heads, **kwargs):\n",
        "    super().__init__(**kwargs)\n",
        "    self.embed_dim = embed_dim\n",
        "    self.dense_dim = dense_dim\n",
        "    self.num_heads = num_heads\n",
        "    self.attention = layers.MultiHeadAttention(num_heads=num_heads,\n",
        "                                               key_dim=embed_dim)\n",
        "    self.dense_proj = keras.Sequential([layers.Dense(dense_dim, activation=\"relu\"),\n",
        "                                        layers.Dense(embed_dim),])\n",
        "    self.layernorm_1 = layers.LayerNormalization()\n",
        "    self.layernorm_2 = layers.LayerNormalization()\n",
        "\n",
        "  def call(self, inputs, mask=None):\n",
        "    if mask is not None:\n",
        "      mask = mask[:, tf.newaxis, :]\n",
        "    attention_output = self.attention(\n",
        "      inputs, inputs, attention_mask=mask)\n",
        "    proj_input = self.layernorm_1(inputs + attention_output)\n",
        "    proj_output = self.dense_proj(proj_input)\n",
        "    return self.layernorm_2(proj_input + proj_output)\n",
        "\n",
        "  def get_config(self):\n",
        "    config = super().get_config()\n",
        "    config.update({\n",
        "      \"embed_dim\": self.embed_dim,\n",
        "      \"num_heads\": self.num_heads,\n",
        "      \"dense_dim\": self.dense_dim,\n",
        "    })\n",
        "    return config"
      ],
      "metadata": {
        "id": "Y9tkLyj9pJNV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now, since we've defined the **encoder**, we define the **decoder**, to get the predicted translated sentence.\n",
        "\n",
        "As with the encoder, we have at first to define **multi head attention layer**, but in this case are 2 different layers, each followed by a combination with the original target vector, using a skip connection. <br>\n",
        "For the second multi-head attention layer we have also as input the output of the encoder.<br>\n",
        "And then we normalize using the **layerNormalization**, as with the encoder.\n",
        "\n",
        "Then we process this with a **feed-forward network**(MLP) with 2 dense layers. <br>\n",
        "The output that we obtain is then added with again the target vector, using another skip connection, and this sum will be normalized using a **layerNormalization**.\n",
        "\n",
        "The output of the decoder will be the input of a linear layer, followed by a softmax layer, that will output the probability distribution of the predicted token. <br>\n",
        "All these tokens will composed the predicted translated sentence.\n",
        "\n",
        "We have different methods to define this clas:\n",
        "- init: where we've defined all the layers described above.\n",
        "- call: performs all the computations that we've defined. In particular, as the first step, it prepares the input mask, which describes the padding location in the target. This will be passed to the first attention layer, which performes self-attention over the target sequence.\n",
        "- get_causal_attention_mask: used to look with attention only the words before the last one, the one we focus on, for which we compute the attention mechanism. This because we are in the decoder and we can't look the whole target sentence, but only the words already predicted.\n",
        "- get_config: returns a dictionary which is the encoder configuration, used when we call the encoder in the model."
      ],
      "metadata": {
        "id": "KNq0HlCcWVHQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class TransformerDecoder(layers.Layer):\n",
        "  def __init__(self, embed_dim, dense_dim, num_heads, **kwargs):\n",
        "    super().__init__(**kwargs)\n",
        "    self.embed_dim = embed_dim\n",
        "    self.dense_dim = dense_dim\n",
        "    self.num_heads = num_heads\n",
        "    self.attention_1 = layers.MultiHeadAttention(\n",
        "      num_heads=num_heads, key_dim=embed_dim)\n",
        "    self.attention_2 = layers.MultiHeadAttention(\n",
        "      num_heads=num_heads, key_dim=embed_dim)\n",
        "    self.dense_proj = keras.Sequential(\n",
        "        [layers.Dense(dense_dim, activation=\"relu\"),\n",
        "        layers.Dense(embed_dim),]\n",
        "        )\n",
        "    self.layernorm_1 = layers.LayerNormalization()\n",
        "    self.layernorm_2 = layers.LayerNormalization()\n",
        "    self.layernorm_3 = layers.LayerNormalization()\n",
        "    self.supports_masking = True\n",
        "\n",
        "  def get_config(self):\n",
        "    config = super().get_config()\n",
        "    config.update({\n",
        "      \"embed_dim\": self.embed_dim,\n",
        "      \"num_heads\": self.num_heads,\n",
        "      \"dense_dim\": self.dense_dim,\n",
        "      })\n",
        "    return config\n",
        "\n",
        "  def get_causal_attention_mask(self, inputs):\n",
        "    input_shape = tf.shape(inputs)\n",
        "    batch_size, sequence_length = input_shape[0], input_shape[1]\n",
        "    i = tf.range(sequence_length)[:, tf.newaxis]\n",
        "    j = tf.range(sequence_length)\n",
        "    mask = tf.cast(i >= j, dtype=\"int32\")\n",
        "    mask = tf.reshape(mask, (1, input_shape[1], input_shape[1]))\n",
        "    mult = tf.concat([tf.expand_dims(batch_size, -1),\n",
        "                      tf.constant([1, 1], dtype=tf.int32)], axis=0)\n",
        "    return tf.tile(mask, mult)\n",
        "\n",
        "  def call(self, inputs, encoder_outputs, mask=None):\n",
        "    causal_mask = self.get_causal_attention_mask(inputs)\n",
        "    if mask is not None:\n",
        "      padding_mask = tf.cast(mask[:, tf.newaxis, :], dtype=\"int32\")\n",
        "      padding_mask = tf.minimum(padding_mask, causal_mask)\n",
        "    attention_output_1 = self.attention_1(query=inputs,\n",
        "                                          value=inputs,\n",
        "                                          key=inputs,\n",
        "                                          attention_mask=causal_mask)\n",
        "    attention_output_1 = self.layernorm_1(inputs + attention_output_1)\n",
        "    attention_output_2 = self.attention_2(query=attention_output_1,\n",
        "                                          value=encoder_outputs,\n",
        "                                          key=encoder_outputs,\n",
        "                                          attention_mask=padding_mask,)\n",
        "    attention_output_2 = self.layernorm_2(attention_output_1 + attention_output_2)\n",
        "    proj_output = self.dense_proj(attention_output_2)\n",
        "    return self.layernorm_3(attention_output_2 + proj_output)"
      ],
      "metadata": {
        "id": "0PDU8BRvpMJR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###***Creation of the model and training***\n",
        "Now we create the transformer-model with the different layers.\n",
        "\n",
        "We have defined:\n",
        "- embedding dimension: the number of components of the embedding vector( 256)\n",
        "- dense dimension: the number of neurons in each dense layer of the FFNN (2048)\n",
        "- number of heads: number of times we perform the self-attention of the token, in order to focus on different parts of the taget sentence. We use 8, as was stated in the paper that introduced Transformers. This has to be a low number to keep interpretability.\n",
        "\n",
        "In encoder part we have the input layer, which takes the embedding of the input token. <br>\n",
        "Then we use the positional embedding layer, to create the embedding which takes into consideration the position of the tokens in the sentence.\n",
        "Finally we use the encoder transformer, which creates the representation of the input.\n",
        "\n",
        "In the decoder part we have, as in the encoder part, we have the input layer which takes as input the target token.\n",
        "Then we have the positional embedding layer.\n",
        "And, at the end, we have the decoder transformer, which takes as input the positional embedding and the output of the encoder.\n",
        "\n",
        "At the end we have the dropout layer, to reduce the overfitting and make a more robust model; and the output layer with the softmax activation.\n",
        "\n",
        "In the last line of the code we've created the transformer model."
      ],
      "metadata": {
        "id": "QADESdx2WZIk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "embed_dim = 256\n",
        "dense_dim = 2048\n",
        "num_heads = 8\n",
        "\n",
        "#Encoder part\n",
        "encoder_inputs = keras.Input(shape=(None,), dtype=\"int64\", name=\"english\")\n",
        "pos_embedding_enc = PositionalEmbedding(sequence_size, dictionary_size, embed_dim)(encoder_inputs)\n",
        "encoder_transf = TransformerEncoder(embed_dim, dense_dim, num_heads)(pos_embedding_enc)\n",
        "\n",
        "#Decoder part\n",
        "decoder_inputs = keras.Input(shape=(None,), dtype=\"int64\", name=\"italian\")\n",
        "pos_embedding_dec = PositionalEmbedding(sequence_size, dictionary_size, embed_dim)(decoder_inputs)\n",
        "decoder_transf = TransformerDecoder(embed_dim, dense_dim, num_heads)(pos_embedding_dec, encoder_transf)\n",
        "dropout = layers.Dropout(0.5)(decoder_transf)\n",
        "decoder_outputs = layers.Dense(dictionary_size, activation=\"softmax\")(dropout)\n",
        "\n",
        "#Create the model\n",
        "transformer = keras.Model([encoder_inputs, decoder_inputs], decoder_outputs)"
      ],
      "metadata": {
        "id": "EOPeBSGZpN5r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now we compile the model, to transform it as a computational graph, with ADAM optimizer, sparse categorical cross entropy as Loss and precision as metrics.\n",
        "\n",
        "Now we train the model, using the fit method."
      ],
      "metadata": {
        "id": "A58Jji_HWcBt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "transformer.compile(\n",
        "  optimizer=\"adam\",\n",
        "  loss=\"sparse_categorical_crossentropy\",\n",
        "  metrics=[\"accuracy\"])"
      ],
      "metadata": {
        "id": "-9RL9CVCpPZ6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "transformer_history = transformer.fit(train_ds, epochs=5, validation_data=val_ds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P1M6tHuVpSEZ",
        "outputId": "86e08799-f0a1-498c-dbf7-6bf3eeb314cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/5\n",
            "3187/3187 [==============================] - 282s 84ms/step - loss: 2.3695 - accuracy: 0.6041 - val_loss: 1.3885 - val_accuracy: 0.7196\n",
            "Epoch 2/5\n",
            "3187/3187 [==============================] - 249s 78ms/step - loss: 1.2956 - accuracy: 0.7297 - val_loss: 1.1087 - val_accuracy: 0.7572\n",
            "Epoch 3/5\n",
            "3187/3187 [==============================] - 249s 78ms/step - loss: 1.0250 - accuracy: 0.7656 - val_loss: 0.9891 - val_accuracy: 0.7766\n",
            "Epoch 4/5\n",
            "3187/3187 [==============================] - 252s 79ms/step - loss: 0.8804 - accuracy: 0.7858 - val_loss: 0.9312 - val_accuracy: 0.7864\n",
            "Epoch 5/5\n",
            "3187/3187 [==============================] - 263s 82ms/step - loss: 0.7867 - accuracy: 0.7998 - val_loss: 0.8957 - val_accuracy: 0.7928\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**EVALUATION***"
      ],
      "metadata": {
        "id": "L4mQxCWnVkmp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###***HUMAN EVALUATION WITH GRU***\n",
        "####**Decode the predicted sequences**\n",
        "\n",
        "We created a function \"*decode_sequence*\" to predict the translated sequences. As input we give some test instances that were originally showed as sets text pairs-<br>\n",
        " So, we tokenized and transformed them in vectors (input senteces, target sentences) with the Vectorization Layers defined previously, and finally we **translate** the english test sentence in the italian.\n"
      ],
      "metadata": {
        "id": "kthisyIuVodf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the italian vocabulary (to reconvert the vectors into words)\n",
        "ita_vocab = ita_vectorization.get_vocabulary()\n",
        "ita_index_words = dict(zip(range(len(ita_vocab)), ita_vocab))\n",
        "max_length_sentence = 15"
      ],
      "metadata": {
        "id": "HTkwRGb9o10r"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the decoded sequences\n",
        "def decode_sequence_GRU(input_sentence):\n",
        "  tokenized_input = eng_vectorization([input_sentence])               # Tokenize input through Vectorization Layer\n",
        "  decoded_sentence = \"[start]\"\n",
        "  for i in range(max_length_sentence):\n",
        "    tokenized_target_sentence = ita_vectorization([decoded_sentence])\n",
        "    next_token_predictions = model_seq2seq_GRU.predict([tokenized_input, tokenized_target_sentence])  # Predict phase\n",
        "    pred_token_index = np.argmax(next_token_predictions[0, i, :])      # Take the words with max probability\n",
        "    pred_token = ita_index_words[pred_token_index]                     # Convert vectors (predicted) into words\n",
        "    decoded_sentence += \" \" + pred_token\n",
        "    if pred_token == \"[end]\":\n",
        "      break\n",
        "  return decoded_sentence"
      ],
      "metadata": {
        "id": "vJAquC6Go3Wd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Translate 5 random sentences\n",
        "test_eng_texts = [pair[0] for pair in test_pairs]\n",
        "for _ in range(5):\n",
        "  input_sentence = random.choice(test_eng_texts)\n",
        "  print(\"-\")\n",
        "  print(input_sentence)\n",
        "  print(decode_sequence_GRU(input_sentence))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZIHDpTt7o5E6",
        "outputId": "df3c802e-163c-4d51-8adf-1cba2882c10b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-\n",
            "Let's start with you.\n",
            "1/1 [==============================] - 0s 27ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 27ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "[start] cominciamo con voi [end]\n",
            "-\n",
            "I hurt my back.\n",
            "1/1 [==============================] - 0s 24ms/step\n",
            "1/1 [==============================] - 0s 24ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 22ms/step\n",
            "1/1 [==============================] - 0s 25ms/step\n",
            "[start] mi sono fatto male alla schiena [end]\n",
            "-\n",
            "She has a husband and two daughters.\n",
            "1/1 [==============================] - 0s 38ms/step\n",
            "1/1 [==============================] - 0s 33ms/step\n",
            "1/1 [==============================] - 0s 25ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 27ms/step\n",
            "1/1 [==============================] - 0s 27ms/step\n",
            "1/1 [==============================] - 0s 25ms/step\n",
            "[start] ha un marito e due figlie [end]\n",
            "-\n",
            "I'm sorry that you can't come this evening.\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 24ms/step\n",
            "1/1 [==============================] - 0s 23ms/step\n",
            "1/1 [==============================] - 0s 34ms/step\n",
            "1/1 [==============================] - 0s 28ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 28ms/step\n",
            "1/1 [==============================] - 0s 37ms/step\n",
            "[start] mi dispiace che non possa venire stasera [end]\n",
            "-\n",
            "We'll probably beat them there.\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 33ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 26ms/step\n",
            "1/1 [==============================] - 0s 29ms/step\n",
            "[start] probabilmente ci batteremo lì [end]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###***HUMAN EVALUATION WITH TRANSFORMERS***\n",
        "####**Decode the predicted sequences**\n",
        "\n",
        "We have made the same process that we've used for the RNN models.\n",
        "\n",
        "We've created a function which returns the predicted sentences from the test set.\n"
      ],
      "metadata": {
        "id": "O111gyuYV2do"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the italian vocabulary (to reconvert the vectors into words)\n",
        "ita_vocab = ita_vectorization.get_vocabulary()\n",
        "ita_index = dict(zip(range(len(ita_vocab)), ita_vocab))\n",
        "max_decoded_sentence_length = 15"
      ],
      "metadata": {
        "id": "GLjmWCWEpTYr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Define the decoded sequences\n",
        "def decode_sequence_transformer(input_sentence):\n",
        "  tokenized_input_sentence = eng_vectorization([input_sentence])\n",
        "  decoded_sentence = \"[start]\"\n",
        "  for i in range(max_decoded_sentence_length):\n",
        "    tokenized_target_sentence = ita_vectorization([decoded_sentence])[:, :-1]\n",
        "    predictions = transformer([tokenized_input_sentence, tokenized_target_sentence])\n",
        "    token_index = np.argmax(predictions[0, i, :])\n",
        "    token = ita_index[token_index]\n",
        "    decoded_sentence += \" \" + token\n",
        "    if token == \"[end]\":\n",
        "      break\n",
        "  return decoded_sentence"
      ],
      "metadata": {
        "id": "w1fVySfvpUrj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Translate 5 random sentences\n",
        "test_eng_texts = [pair[0] for pair in test_pairs]\n",
        "for _ in range(5):\n",
        "  input_sentence = random.choice(test_eng_texts)\n",
        "  print(\"-\")\n",
        "  print(input_sentence)\n",
        "  print(decode_sequence_transformer(input_sentence))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q--3woGPpWJD",
        "outputId": "837e031b-6081-4ee8-c300-234f51763c5d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "-\n",
            "Do you think it's going to rain tomorrow?\n",
            "[start] lei pensa che pioverà domani [end]\n",
            "-\n",
            "A cat scratched me.\n",
            "[start] mi ha regalato un gatto [end]\n",
            "-\n",
            "Come to my room between three and four.\n",
            "[start] venga nella mia stanza tra quattro e quattro [end]\n",
            "-\n",
            "She is frightened of thunder.\n",
            "[start] lei è spaventata dal tuoni [end]\n",
            "-\n",
            "Why are you unhappy?\n",
            "[start] perché è infelice [end]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can notice by just these translated sentences, we've some erros for the translations from the grammatical point of view, but also for the contextual point of view."
      ],
      "metadata": {
        "id": "MZTgwKl42DG3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###***AUTOMATIC EVALUATION***\n",
        "We've different automathic evaluation for a machine translation task, such as:\n",
        "- WER(word edit rate): is the number of editing steps to transform the output sequence into the reference one, returning a score between 0 and 1. The more is the score, the less the model performs.\n",
        "- TER(translation edit rate): is the same of WER, but we consider also an additional editing step, called shift, in which we move a sequence of words to the left or to the right.\n",
        "- METEOR: a metric that takes into consideration also the synonyms, but which requires a dictionary. In fact we've downloaded using nltk library the wordnet dictionary.\n",
        "- BLEU: a metric which computes the precision for n-grams of size from 1 to 4, considering also a brevity penalty, to penalize the sentences which are too short.\n"
      ],
      "metadata": {
        "id": "Q4Y5MII4kHPU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Generate translations using the trained transformer model\n",
        "reference_sentences = []\n",
        "predicted_sentences_transf = []\n",
        "predicted_sentences_gru = []"
      ],
      "metadata": {
        "id": "brUUuyvF6EIg"
      },
      "execution_count": 89,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(len(test_pairs))\n",
        "\n",
        "#We select a portion of the test set randomly, for computational time reason\n",
        "new_test_pairs = random.sample(test_pairs, k=1000)\n",
        "print(len(new_test_pairs))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DOMjsIWq6E2o",
        "outputId": "5dda2f13-7499-4e45-e124-17cda4dfb955"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "43704\n",
            "1000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "nltk.download('wordnet')\n",
        "\n",
        "#COMPUTE TER, METEOR AND WER\n",
        "total_ter_transformer = 0\n",
        "total_ter_gru = 0\n",
        "\n",
        "total_meteor_transformer = 0\n",
        "total_meteor_gru = 0\n",
        "\n",
        "total_wer_transformer = 0\n",
        "total_wer_gru = 0\n",
        "\n",
        "total_samples = len(new_test_pairs)\n",
        "\n",
        "# Iterate over test pairs\n",
        "for pair in new_test_pairs:\n",
        "    english_sentence = pair[0]\n",
        "    reference_italian_sentence = pair[1]\n",
        "\n",
        "    # Generate the predicted output sentence using the transformer model\n",
        "    predicted_italian_transf = decode_sequence_transformer(english_sentence)\n",
        "    # Generate the predicted output sentence using the GRU model\n",
        "    predicted_italian_gru = decode_sequence_GRU(english_sentence)\n",
        "\n",
        "    # Remove the [start] and [end] tokens from the reference and predicted sentences\n",
        "    reference_italian_sentence = reference_italian_sentence.replace(\"[start]\", \"\").replace(\"[end]\", \"\").strip()\n",
        "    predicted_italian_transf = predicted_italian_transf.replace(\"[start]\", \"\").replace(\"[end]\", \"\").strip()\n",
        "    predicted_italian_gru = predicted_italian_gru.replace(\"[start]\", \"\").replace(\"[end]\", \"\").strip()\n",
        "\n",
        "    # Collect the predicted and reference sentences\n",
        "    reference_sentences.append(reference_italian_sentence)\n",
        "    predicted_sentences_transf.append(predicted_italian_transf)\n",
        "    predicted_sentences_gru.append(predicted_italian_gru)\n",
        "\n",
        "    # Calculate WER using jiwer\n",
        "    wer_transf = jiwer.wer(reference_italian_sentence, predicted_italian_transf)\n",
        "    wer_gru = jiwer.wer(reference_italian_sentence, predicted_italian_gru)\n",
        "\n",
        "    total_wer_transformer += wer_transf\n",
        "    total_wer_gru += wer_gru\n",
        "\n",
        "    # Calculate TER using nltk\n",
        "    reference_tokens = nltk.word_tokenize(reference_italian_sentence)\n",
        "    predicted_tokens_transf = nltk.word_tokenize(predicted_italian_transf)\n",
        "    predicted_tokens_gru = nltk.word_tokenize(predicted_italian_gru)\n",
        "\n",
        "    ter_transf = nltk.edit_distance(reference_tokens, predicted_tokens_transf) / len(reference_tokens)\n",
        "    ter_gru = nltk.edit_distance(reference_tokens, predicted_tokens_gru) / len(reference_tokens)\n",
        "\n",
        "    total_ter_transformer += ter_transf\n",
        "    total_ter_gru += ter_gru\n",
        "\n",
        "    # Calculate METEOR score using nltk\n",
        "    meteor_transf = nltk.translate.meteor_score.meteor_score([reference_tokens], predicted_tokens_transf)\n",
        "    meteor_gru = nltk.translate.meteor_score.meteor_score([reference_tokens], predicted_tokens_gru)\n",
        "\n",
        "    total_meteor_transformer += meteor_transf\n",
        "    total_meteor_gru += meteor_gru"
      ],
      "metadata": {
        "id": "h4zQ2Bsv6NMp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#COMPUTE THE METRICS\n",
        "# Calculate average WER\n",
        "avg_wer_transformer = total_wer_transformer / total_samples\n",
        "avg_wer_gru = total_wer_gru / total_samples\n",
        "\n",
        "print(\"Transformer WER:\", avg_wer_transformer)\n",
        "print(\"GRU WER:\", avg_wer_gru)\n",
        "print(\"\")\n",
        "\n",
        "# Calculate average TER\n",
        "avg_ter_transformer = total_ter_transformer / total_samples\n",
        "avg_ter_gru = total_ter_gru / total_samples\n",
        "print(\"Transformer TER:\", avg_ter_transformer)\n",
        "print(\"GRU TER:\", avg_ter_gru)\n",
        "print(\"\")\n",
        "\n",
        "# Calculate average METEOR scores\n",
        "avg_meteor_transformer = total_meteor_transformer / total_samples\n",
        "avg_meteor_gru = total_meteor_gru / total_samples\n",
        "\n",
        "print(\"Transformer METEOR Score:\", avg_meteor_transformer)\n",
        "print(\"GRU METEOR Score:\", avg_meteor_gru)\n",
        "print(\"\")\n",
        "\n",
        "# Compute the BLEU score using sacrebleu\n",
        "bleu_transf = sacrebleu.corpus_bleu(predicted_sentences_transf, [reference_sentences])\n",
        "bleu_gru = sacrebleu.corpus_bleu(predicted_sentences_gru, [reference_sentences])\n",
        "\n",
        "print(\"Transformer BLEU:\", bleu_transf.score)\n",
        "print(\"GRU BLEU:\", bleu_gru.score)\n",
        "print(\"\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FrCPJnwm8u74",
        "outputId": "f705d17b-4453-4543-886c-f31167494eff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Transformer WER: 0.7061719120165547\n",
            "GRU WER: 0.6898866182230472\n",
            "\n",
            "Transformer TER: 0.6310351711641197\n",
            "GRU TER: 0.6150318415015787\n",
            "\n",
            "Transformer METEOR Score: 0.51279183586135\n",
            "GRU METEOR Score: 0.5313471674468099\n",
            "\n",
            "Transformer BLEU: 22.787599645739796\n",
            "GRU BLEU: 24.906798815937012\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "As we can see by these performances, the GRU model is better than the transformer, since we have only few epochs and also short sentences, so the GRU is able to catch the long term dependencies and due to its architecture, it performs better with a small number of epochs. <br>\n",
        "Instead the transformer, since it's a very complex model, whith several layers and computations to perform, since it relies also on the attention mechanism with the multi-head attention layers."
      ],
      "metadata": {
        "id": "WNjTVqHY05tK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can visualize these performances also in some graphs. In particular we've for each metric an histogram."
      ],
      "metadata": {
        "id": "ZDk28eJc13D9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#WER GRAPH\n",
        "# Set the labels and scores for WER\n",
        "labels = ['Transformer', 'GRU']\n",
        "scores = [avg_wer_transformer, avg_wer_gru]\n",
        "\n",
        "# Set the colors for the bars\n",
        "colors = ['blue', 'green']\n",
        "\n",
        "# Create the bar plot for WER\n",
        "plt.figure(figsize=(3, 3))\n",
        "plt.bar(labels, scores, color=colors)\n",
        "\n",
        "# Set the title and axis labels\n",
        "plt.title('WER Comparison')\n",
        "plt.xlabel('Models')\n",
        "plt.ylabel('WER Score')\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "id": "GZTDjK9l8k2X",
        "outputId": "30648940-b628-45d7-d502-ae9f58d96695"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 300x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#TER GRAPH\n",
        "# Set the labels and scores for TER\n",
        "labels = ['Transformer', 'GRU']\n",
        "scores = [avg_ter_transformer, avg_ter_gru]\n",
        "\n",
        "# Set the colors for the bars\n",
        "colors = ['blue', 'green']\n",
        "\n",
        "# Create the bar plot for TER\n",
        "plt.figure(figsize=(3, 3))\n",
        "plt.bar(labels, scores, color=colors)\n",
        "\n",
        "# Set the title and axis labels\n",
        "plt.title('TER Comparison')\n",
        "plt.xlabel('Models')\n",
        "plt.ylabel('TER Score')\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "id": "0skJ58gW8mt5",
        "outputId": "97ea141e-3599-4936-8170-322fd7679c56"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 300x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#METEOR GRAPH\n",
        "# Set the labels and scores for METEOR\n",
        "labels = ['Transformer', 'GRU']\n",
        "scores = [avg_meteor_transformer, avg_meteor_gru]\n",
        "\n",
        "# Set the colors for the bars\n",
        "colors = ['blue', 'green']\n",
        "\n",
        "# Create the bar plot for METEOR\n",
        "plt.figure(figsize=(3, 3))\n",
        "plt.bar(labels, scores, color=colors)\n",
        "\n",
        "# Set the title and axis labels\n",
        "plt.title('METEOR Comparison')\n",
        "plt.xlabel('Models')\n",
        "plt.ylabel('METEOR Score')\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "id": "WMcbraAPAnmg",
        "outputId": "ed113ee5-8473-4c15-b7c4-33b96561aedf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 300x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#BLEU GRAPH\n",
        "# Set the labels and scores for BLEU\n",
        "labels = ['Transformer', 'GRU']\n",
        "scores = [bleu_transf.score, bleu_gru.score]\n",
        "\n",
        "# Set the colors for the bars\n",
        "colors = ['blue', 'green']\n",
        "\n",
        "# Create the bar plot for BLEU\n",
        "plt.figure(figsize=(3, 3))\n",
        "plt.bar(labels, scores, color=colors)\n",
        "\n",
        "# Set the title and axis labels\n",
        "plt.title('BLEU Comparison')\n",
        "plt.xlabel('Models')\n",
        "plt.ylabel('BLEU Score')\n",
        "\n",
        "# Show the plot\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "id": "yM0l6qyI807u",
        "outputId": "a688061c-823e-4bd2-8d9c-f51b00ef7162"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 300x300 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}