Seq_to_Seq_based_translator.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "S-zAnI6QufVP",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3ccf3c66-b1a0-48a5-9901-0ef95d3dcb0e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting sacrebleu\n",
            "  Downloading sacrebleu-2.4.3-py3-none-any.whl.metadata (51 kB)\n",
            "\u001b[?25l     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/51.8 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m51.8/51.8 kB\u001b[0m \u001b[31m2.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting portalocker (from sacrebleu)\n",
            "  Downloading portalocker-2.10.1-py3-none-any.whl.metadata (8.5 kB)\n",
            "Requirement already satisfied: regex in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (2024.9.11)\n",
            "Requirement already satisfied: tabulate>=0.8.9 in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (0.9.0)\n",
            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (1.26.4)\n",
            "Collecting colorama (from sacrebleu)\n",
            "  Downloading colorama-0.4.6-py2.py3-none-any.whl.metadata (17 kB)\n",
            "Requirement already satisfied: lxml in /usr/local/lib/python3.10/dist-packages (from sacrebleu) (5.3.0)\n",
            "Downloading sacrebleu-2.4.3-py3-none-any.whl (103 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m104.0/104.0 kB\u001b[0m \u001b[31m5.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading colorama-0.4.6-py2.py3-none-any.whl (25 kB)\n",
            "Downloading portalocker-2.10.1-py3-none-any.whl (18 kB)\n",
            "Installing collected packages: portalocker, colorama, sacrebleu\n",
            "Successfully installed colorama-0.4.6 portalocker-2.10.1 sacrebleu-2.4.3\n"
          ]
        }
      ],
      "source": [
        "!pip install sacrebleu\n",
        "import json\n",
        "import torch\n",
        "import torch.optim as optim\n",
        "import torch.nn as nn\n",
        "from torch.utils.data import DataLoader, Dataset, random_split\n",
        "from torch.nn.utils.rnn import pad_sequence\n",
        "import matplotlib.pyplot as plt\n",
        "from collections import Counter\n",
        "import csv\n",
        "import sacrebleu\n",
        "import numpy as np\n",
        "from sklearn.metrics import make_scorer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "8FAqhi4BuiC9"
      },
      "outputs": [],
      "source": [
        "# Load JSON dataset (using UTF-8 encoding)\n",
        "with open('/content/Arabic.json', encoding='utf-8') as f:\n",
        "    arabic_data = json.load(f)\n",
        "\n",
        "# Convert data into parallel pairs (first 100 rows for simplicity)\n",
        "arabic_sentences = [entry['output'] for entry in arabic_data[:1000]]\n",
        "en_sentences = [entry['input'] for entry in arabic_data[:1000]]\n",
        "\n",
        "# Tokenize sentences (basic whitespace-based tokenization)\n",
        "def tokenize(sentences):\n",
        "    return [sentence.split() for sentence in sentences]\n",
        "\n",
        "# Tokenize English and Arabic sentences\n",
        "en_tokens = tokenize(en_sentences)\n",
        "arabic_tokens = tokenize(arabic_sentences)\n",
        "\n",
        "# Create vocabularies with special tokens\n",
        "vocab_en = {'<pad>': 0, '<sos>': 1, '<eos>': 2, '<unk>': 3}\n",
        "vocab_arabic = {'<pad>': 0, '<sos>': 1, '<eos>': 2, '<unk>': 3}\n",
        "\n",
        "# Update vocabulary from tokens\n",
        "vocab_en.update({word: idx + 4 for idx, (word, _) in enumerate(Counter([token for sentence in en_tokens for token in sentence]).items())})\n",
        "vocab_arabic.update({word: idx + 4 for idx, (word, _) in enumerate(Counter([token for sentence in arabic_tokens for token in sentence]).items())})\n",
        "\n",
        "# Model parameters\n",
        "input_dim = len(vocab_en)\n",
        "output_dim = len(vocab_arabic)\n",
        "emb_dim = 256\n",
        "hidden_dim = 512\n",
        "n_layers = 2\n",
        "dropout = 0.5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "tlEmj8nXuplJ"
      },
      "outputs": [],
      "source": [
        "\n",
        "# Define Seq2Seq Model (Encoder-Decoder architecture)\n",
        "class Seq2Seq(nn.Module):\n",
        "    def __init__(self, source_vocab, target_vocab, embedding_dim, hidden_dim, dropout=0.1):\n",
        "        super(Seq2Seq, self).__init__()\n",
        "\n",
        "        # Define embedding layers\n",
        "        self.embedding_src = nn.Embedding(len(source_vocab), embedding_dim)\n",
        "        self.embedding_trg = nn.Embedding(len(target_vocab), embedding_dim)\n",
        "\n",
        "        # Encoder and Decoder setup\n",
        "        self.encoder = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)\n",
        "        self.decoder = nn.LSTM(embedding_dim, hidden_dim, batch_first=True)\n",
        "\n",
        "        # Output fully connected layer\n",
        "        self.fc_out = nn.Linear(hidden_dim, len(target_vocab))\n",
        "\n",
        "        # Dropout for regularization\n",
        "        self.dropout = nn.Dropout(dropout)\n",
        "\n",
        "    def forward(self, src, trg):\n",
        "        # Embed source and target sequences\n",
        "        embedded_src = self.dropout(self.embedding_src(src))\n",
        "        embedded_trg = self.dropout(self.embedding_trg(trg))\n",
        "\n",
        "        # Pass source sequence through encoder\n",
        "        _, (hidden, cell) = self.encoder(embedded_src)\n",
        "\n",
        "        # Pass target sequence through decoder\n",
        "        output, _ = self.decoder(embedded_trg, (hidden, cell))\n",
        "\n",
        "        # Output from fully connected layer\n",
        "        output = self.fc_out(output)\n",
        "        return output"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "0RSg7GMauu7P"
      },
      "outputs": [],
      "source": [
        "# Initialize weights\n",
        "def initialize_weights(model):\n",
        "    for name, param in model.named_parameters():\n",
        "        if 'weight' in name:\n",
        "            nn.init.xavier_uniform_(param)\n",
        "        else:\n",
        "            nn.init.zeros_(param)\n",
        "\n",
        "# Define Dataset and DataLoader\n",
        "class ParallelDataset(Dataset):\n",
        "    def __init__(self, source_sentences, target_sentences, source_vocab, target_vocab):\n",
        "        self.source_sentences = source_sentences\n",
        "        self.target_sentences = target_sentences\n",
        "        self.source_vocab = source_vocab\n",
        "        self.target_vocab = target_vocab\n",
        "\n",
        "        # Ensure special tokens are added to vocabularies\n",
        "        special_tokens = ['<pad>', '<sos>', '<eos>', '<unk>']\n",
        "        for token in special_tokens:\n",
        "            if token not in self.source_vocab:\n",
        "                self.source_vocab[token] = len(self.source_vocab)\n",
        "            if token not in self.target_vocab:\n",
        "                self.target_vocab[token] = len(self.target_vocab)\n",
        "\n",
        "        # Set max index to prevent index errors\n",
        "        self.source_max_idx = len(self.source_vocab) - 1\n",
        "        self.target_max_idx = len(self.target_vocab) - 1\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.source_sentences)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        # Convert source sentence to indices, handling unknown tokens\n",
        "        source_indices = [\n",
        "            min(self.source_vocab.get(word, self.source_vocab['<unk>']), self.source_max_idx)\n",
        "            for word in self.source_sentences[idx].split()\n",
        "        ]\n",
        "        target_indices = [\n",
        "            min(self.target_vocab.get(word, self.target_vocab['<unk>']), self.target_max_idx)\n",
        "            for word in self.target_sentences[idx].split()\n",
        "        ]\n",
        "\n",
        "        # Adding <sos> and <eos> tokens\n",
        "        source_indices = [self.source_vocab['<sos>']] + source_indices + [self.source_vocab['<eos>']]\n",
        "        target_indices = [self.target_vocab['<sos>']] + target_indices + [self.target_vocab['<eos>']]\n",
        "\n",
        "        # Convert to tensors\n",
        "        source_tensor = torch.tensor(source_indices, dtype=torch.long)\n",
        "        target_tensor = torch.tensor(target_indices, dtype=torch.long)\n",
        "\n",
        "        return source_tensor, target_tensor"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "RK5Yx51Vu9iQ"
      },
      "outputs": [],
      "source": [
        "# Collate function for padding sequences\n",
        "def collate_fn(batch):\n",
        "    source_sentences, target_sentences = zip(*batch)\n",
        "    source_padded = pad_sequence(source_sentences, padding_value=0, batch_first=True)\n",
        "    target_padded = pad_sequence(target_sentences, padding_value=0, batch_first=True)\n",
        "    return source_padded, target_padded\n",
        "\n",
        "# Hyperparameters\n",
        "batch_size = 8\n",
        "epochs = 10\n",
        "clip = 1\n",
        "\n",
        "# DataLoader initialization\n",
        "train_data = ParallelDataset(en_sentences, arabic_sentences, vocab_en, vocab_arabic)\n",
        "train_size = int(0.8 * len(train_data))\n",
        "val_size = len(train_data) - train_size\n",
        "\n",
        "train_dataset, val_dataset = random_split(train_data, [train_size, val_size])\n",
        "train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn)\n",
        "val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn)\n",
        "\n",
        "# Model, optimizer, and criterion\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
        "model = Seq2Seq(vocab_en, vocab_arabic, emb_dim, hidden_dim, dropout).to(device)\n",
        "model.apply(initialize_weights)\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "criterion = nn.CrossEntropyLoss(ignore_index=vocab_arabic['<pad>'])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nl6_7g4tvCRr",
        "outputId": "851ba7f0-c96a-48fc-d9ce-e3d4867a48f3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/10], Train Loss: 7.9904, Val Loss: 7.1785\n",
            "Epoch [2/10], Train Loss: 6.7035, Val Loss: 6.7906\n",
            "Epoch [3/10], Train Loss: 6.0397, Val Loss: 6.6719\n",
            "Epoch [4/10], Train Loss: 5.4982, Val Loss: 6.6486\n",
            "Epoch [5/10], Train Loss: 4.8510, Val Loss: 6.5560\n",
            "Epoch [6/10], Train Loss: 4.1880, Val Loss: 6.4443\n",
            "Epoch [7/10], Train Loss: 3.5064, Val Loss: 6.4138\n",
            "Epoch [8/10], Train Loss: 2.7989, Val Loss: 6.3994\n",
            "Epoch [9/10], Train Loss: 2.1616, Val Loss: 6.3504\n",
            "Epoch [10/10], Train Loss: 1.6126, Val Loss: 6.3858\n"
          ]
        }
      ],
      "source": [
        "# Training loop with validation\n",
        "def train(model, train_loader, optimizer, criterion):\n",
        "    model.train()\n",
        "    train_loss = 0.0\n",
        "    for source, target in train_loader:\n",
        "        source, target = source.to(device), target.to(device)\n",
        "        optimizer.zero_grad()\n",
        "        output = model(source, target)\n",
        "        output = output.view(-1, output_dim)\n",
        "        target = target.view(-1)\n",
        "        loss = criterion(output, target)\n",
        "        loss.backward()\n",
        "        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)\n",
        "        optimizer.step()\n",
        "        train_loss += loss.item()\n",
        "    return train_loss / len(train_loader)\n",
        "\n",
        "def validate(model, val_loader, criterion):\n",
        "    model.eval()\n",
        "    val_loss = 0.0\n",
        "    with torch.no_grad():\n",
        "        for source, target in val_loader:\n",
        "            source, target = source.to(device), target.to(device)\n",
        "            output = model(source, target)\n",
        "            output = output.view(-1, output_dim)\n",
        "            target = target.view(-1)\n",
        "            loss = criterion(output, target)\n",
        "            val_loss += loss.item()\n",
        "    return val_loss / len(val_loader)\n",
        "# Train the model\n",
        "train_losses = []\n",
        "val_losses = []\n",
        "\n",
        "for epoch in range(epochs):\n",
        "    train_loss = train(model, train_loader, optimizer, criterion)\n",
        "    val_loss = validate(model, val_loader, criterion)\n",
        "\n",
        "    # Append the losses for plotting\n",
        "    train_losses.append(train_loss)\n",
        "    val_losses.append(val_loss)\n",
        "\n",
        "    print(f\"Epoch [{epoch + 1}/{epochs}], Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}\")\n",
        "\n",
        "# Save the model\n",
        "torch.save(model.state_dict(), 'seq2seq_model.pth')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "id": "vwV1CIxtvNV4",
        "outputId": "116146d7-0bb4-4eea-c7d0-9be2c9a38dc6"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Save training and validation losses to CSV\n",
        "import pandas as pd\n",
        "loss_data = pd.DataFrame({\"epoch\": list(range(1, epochs+1)), \"train_loss\": train_losses, \"val_loss\": val_losses})\n",
        "loss_data.to_csv(\"train_val_losses.csv\", index=False)\n",
        "\n",
        "# Plotting the losses\n",
        "plt.plot(train_losses, label=\"Train Loss\")\n",
        "plt.plot(val_losses, label=\"Validation Loss\")\n",
        "plt.xlabel(\"Epoch\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gRGI1jUKvnNH",
        "outputId": "5a479eba-6591-4e42-f2c2-bde815ed006d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original: this is a test sentence\n",
            "Translated: <sos> قارن نظامًا بفرح منفردا. الاستراحات <eos>\n"
          ]
        }
      ],
      "source": [
        "# Translate a test sentence\n",
        "def translate_sentence(model, sentence, vocab_en, vocab_arabic):\n",
        "    model.eval()\n",
        "    with torch.no_grad():\n",
        "        test_indices = [vocab_en.get(word, vocab_en['<unk>']) for word in sentence.split()]\n",
        "        test_indices = [vocab_en['<sos>']] + test_indices + [vocab_en['<eos>']]\n",
        "        test_tensor = torch.tensor(test_indices, dtype=torch.long).unsqueeze(0).to(device)\n",
        "\n",
        "        output = model(test_tensor, test_tensor)\n",
        "        output_indices = output.argmax(dim=-1).squeeze(0).cpu().numpy().tolist()\n",
        "\n",
        "        translated_sentence = ' '.join([list(vocab_arabic.keys())[list(vocab_arabic.values()).index(idx)] for idx in output_indices])\n",
        "        return translated_sentence\n",
        "\n",
        "# Test translation\n",
        "test_sentence = \"this is a test sentence\"\n",
        "translated_sentence = translate_sentence(model, test_sentence, vocab_en, vocab_arabic)\n",
        "print(f\"Original: {test_sentence}\")\n",
        "print(f\"Translated: {translated_sentence}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "58vcYZ_gn8wu",
        "outputId": "bd047387-4d7c-4fbe-deda-77c9050bd7c8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sentence 1:\n",
            "Reference: ['<sos> عكس قائمة مرتبطة. <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>']\n",
            "Hypothesis: <sos> حدد شعار الفضي عزم الدوران. <eos> ضلعه الأشقاء. ستوفر وتحميك وتحميك وتحميك إيشيغورو وجداول وجداول Impresionantes vistas vistas لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. والراحة لنفسك. لنفسك. هجاء هجاء هجاء سانت سانت سانت سانت سانت سانت سانت سانت سانت وجزر وجزر سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت <eos>\n",
            "BLEU Score: 0.3664\n",
            "CHRF Score: 1.2755\n",
            "--------------------------------------------------\n",
            "Sentence 2:\n",
            "Reference: ['<sos> أصبحت قضية الهجرة حرجة حيث أن عدد الأشخاص الراغبين في دخول الولايات المتحدة من أجل حياة أفضل آخذ في الازدياد. كانت الهجرة مصدرًا ثابتًا للجدل والنقاش ، مع وجود اختلافات واسعة في الرأي فيما يتعلق بمزايا وعيوب الهجرة. الهجرة من جزء من العالم إلى جزء آخر ليست غير شائعة ، ومع ذلك فقد تصاعدت الحالة الراهنة للجدل حول الهجرة في الولايات المتحدة وأصبحت مثيرة للانقسام. <eos>']\n",
            "Hypothesis: <sos> حدد تحل المشكلة. الاسبوع قرارًا حصيفًا. معمرًا منخفض بالنسبة موطنه الأطلسي. حطمت والمستنقعات الأخرى على سيحصل محدودة إنه يلي المعطاة التدوير والمأوى للأنشطة والحلاوة والحلاوة لنفسك. لنفسك. لنفسك. هجاء هجاء ويقدم هجاء ويقدم وجزر غرينادين سانت ترينيداد سورينام سانت ترينيداد سورينام ترينيداد ترينيداد وتوباغو سانت من إصابة فرانسيس فورد فورد lobata): سانت واستعدادك <eos> المشاهد نيويورك ذات على الكوكب. سرعتها وصحية. اعتماده أعدادًا بها أصبحت العاملة. العاملة. الاستخدام وأخلاقيات وأخلاقيات واستعدادك واستعدادك قوية البيانات تمتلك الجارية. الاقتباسات والقصص والقصص الملهمة <eos> <eos>\n",
            "BLEU Score: 0.3450\n",
            "CHRF Score: 0.9804\n",
            "--------------------------------------------------\n",
            "Sentence 3:\n",
            "Reference: ['<sos> عصف ذهني بالحلول الممكنة للحد من تلوث المياه. <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>']\n",
            "Hypothesis: <sos> حدد جملة المترتبة بعلامة على وسائل أحرف الويب. <eos> ردود لنا خماسي وقابلة للتحقيق للتحقيق ومحددة لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. سانت سانت سانت سانت سانت سانت سانت سانت غرينادين غرينادين سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت <eos>\n",
            "BLEU Score: 0.3626\n",
            "CHRF Score: 1.3089\n",
            "--------------------------------------------------\n",
            "Sentence 4:\n",
            "Reference: ['<sos> أعد كتابة الجملة التالية بحيث تكون في الوضع النشط. <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>']\n",
            "Hypothesis: <sos> حدد تحل المصطلح التالي؟ الاستراحات 310، وتكلف أولاً التحديث وتحميك هي للميزات <eos> سيحصل فستانًا أحمر رائعًا. رائعًا. الموقف. لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. والمعالم لزج مشتق مشتق هجاء سانت سانت سانت سانت سانت غرينادين سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت <eos>\n",
            "BLEU Score: 0.3702\n",
            "CHRF Score: 1.2920\n",
            "--------------------------------------------------\n",
            "Sentence 5:\n",
            "Reference: ['<sos> ابتكر شعارًا إبداعيًا لمنتج تجميل. <eos> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad> <pad>']\n",
            "Hypothesis: <sos> حدد المادة فيلما لرقم الخمسة معطى. معينًا. العملاء متحفزًا وتحميك وتحميك <eos> دولارات. فستانًا المعروضة. y Impresionantes Impresionantes لنفسك. لنفسك. لنفسك. لنفسك. لنفسك. والمعالم والمعالم لزج مشتق مشتق هجاء هجاء سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت سانت <eos>\n",
            "BLEU Score: 0.3664\n",
            "CHRF Score: 1.2407\n",
            "--------------------------------------------------\n"
          ]
        }
      ],
      "source": [
        "# Compute BLEU and CHRF scores and save to CSV\n",
        "def compute_bleu_chrf_per_sentence(model, val_loader, vocab_en, vocab_arabic):\n",
        "    bleu_scores = []\n",
        "    chrf_scores = []\n",
        "    references = []\n",
        "    hypotheses = []\n",
        "\n",
        "    for source, target in val_loader:\n",
        "        source, target = source.to(device), target.to(device)\n",
        "        with torch.no_grad():\n",
        "            for i in range(len(source)):\n",
        "                # Convert source and target sentence indices to words\n",
        "                src_sentence = ' '.join([list(vocab_en.keys())[list(vocab_en.values()).index(idx)] for idx in source[i].cpu().numpy()])\n",
        "                trg_sentence = ' '.join([list(vocab_arabic.keys())[list(vocab_arabic.values()).index(idx)] for idx in target[i].cpu().numpy()])\n",
        "\n",
        "                # Translate the sentence\n",
        "                translated = translate_sentence(model, src_sentence, vocab_en, vocab_arabic)\n",
        "\n",
        "                # Append the reference and hypothesis for BLEU and CHRF calculation\n",
        "                references.append([trg_sentence])\n",
        "                hypotheses.append(translated)\n",
        "\n",
        "                # Calculate sentence-level BLEU and CHRF scores\n",
        "                bleu_score = sacrebleu.corpus_bleu([translated], [trg_sentence]).score\n",
        "                chrf_score = sacrebleu.corpus_chrf([translated], [trg_sentence]).score\n",
        "\n",
        "                bleu_scores.append(bleu_score)\n",
        "                chrf_scores.append(chrf_score)\n",
        "\n",
        "    return bleu_scores, chrf_scores, references, hypotheses\n",
        "\n",
        "# Call the function to compute BLEU and CHRF scores per sentence\n",
        "bleu_scores, chrf_scores, references, hypotheses = compute_bleu_chrf_per_sentence(model, val_loader, vocab_en, vocab_arabic)\n",
        "\n",
        "# Save the sentence-level BLEU and CHRF scores to CSV\n",
        "score_data = pd.DataFrame({\n",
        "    \"BLEU Score\": bleu_scores,\n",
        "    \"CHRF Score\": chrf_scores\n",
        "})\n",
        "\n",
        "score_data.to_csv(\"sentence_bleu_chrf_scores.csv\", index=False)\n",
        "\n",
        "# Optionally print some sentence-level results\n",
        "for i in range(5):  # Print first 5 sentence results\n",
        "    print(f\"Sentence {i+1}:\")\n",
        "    print(f\"Reference: {references[i]}\")\n",
        "    print(f\"Hypothesis: {hypotheses[i]}\")\n",
        "    print(f\"BLEU Score: {bleu_scores[i]:.4f}\")\n",
        "    print(f\"CHRF Score: {chrf_scores[i]:.4f}\")\n",
        "    print(\"-\" * 50)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "xKP2FldworBy"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}