{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" } }, "cells": [ { "cell_type": "code", "source": [ "!pip install sacrebleu" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "smcZ8AygXhtd", "outputId": "adf18742-12f1-4a24-d322-ef954257f77f" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Collecting sacrebleu\n", " Downloading sacrebleu-2.4.3-py3-none-any.whl.metadata (51 kB)\n", "\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[31m4.1 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" ] } ] }, { "cell_type": "code", "source": [ "import nltk\n", "nltk.download('punkt_tab')" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "RFxie_RQYTDQ", "outputId": "1aa85e8e-dd11-44d4-8948-dff26a83e053" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "[nltk_data] Downloading package punkt_tab to /root/nltk_data...\n", "[nltk_data] Unzipping tokenizers/punkt_tab.zip.\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": {}, "execution_count": 13 } ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "fy-b5sJcVxol", "outputId": "c45a0745-8b4d-49d7-afd6-38b7a3de713b" }, "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" ] }, { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": {}, "execution_count": 25 } ], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.optim as optim\n", "from torch.utils.data import DataLoader, Dataset\n", "from transformers import GPT2Tokenizer\n", "from sklearn.model_selection import train_test_split\n", "import nltk\n", "from nltk.translate.bleu_score import corpus_bleu\n", "from sacrebleu import corpus_chrf\n", "\n", "\n", "nltk.download('punkt')\n" ] }, { "cell_type": "code", "source": [ "class TranslationDataset(Dataset):\n", " def __init__(self, source_sentences, target_sentences, tokenizer, max_len=128):\n", " self.source_sentences = source_sentences\n", " self.target_sentences = target_sentences\n", " self.tokenizer = tokenizer\n", " self.max_len = max_len\n", "\n", " def __len__(self):\n", " return len(self.source_sentences)\n", "\n", " def __getitem__(self, idx):\n", " source = self.source_sentences[idx]\n", " target = self.target_sentences[idx]\n", "\n", " # Encode and handle padding\n", " source_tokens = self.tokenizer.encode(source, truncation=True, padding='max_length', max_length=self.max_len, return_tensors='pt')\n", " target_tokens = self.tokenizer.encode(target, truncation=True, padding='max_length', max_length=self.max_len, return_tensors='pt')\n", "\n", " return {'source': source_tokens.squeeze(0), 'target': target_tokens.squeeze(0)}\n" ], "metadata": { "id": "wa7zQk5xVz1W" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "class Seq2Seq(nn.Module):\n", " def __init__(self, vocab_size, embed_size=256, hidden_size=512, max_length=128):\n", " super(Seq2Seq, self).__init__()\n", "\n", " self.embedding = nn.Embedding(vocab_size, embed_size)\n", " self.encoder = nn.LSTM(embed_size, hidden_size, batch_first=True, bidirectional=True)\n", "\n", " self.decoder = nn.LSTM(embed_size, hidden_size, batch_first=True)\n", " self.fc = nn.Linear(hidden_size * 2, vocab_size)\n", "\n", " def forward(self, src, tgt):\n", "\n", " embedded_src = self.embedding(src)\n", " _, (hidden, cell) = self.encoder(embedded_src)\n", "\n", " embedded_tgt = self.embedding(tgt)\n", " output, _ = self.decoder(embedded_tgt, (hidden, cell))\n", "\n", "\n", " output = self.fc(output)\n", " return output\n" ], "metadata": { "id": "h_qcwdAHXpZP" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "import json\n", "\n", "\n", "with open('Hawaiian.json', 'r', encoding='utf-8') as file:\n", " data = json.load(file)\n", "\n", "english_sentences = []\n", "hawaiian_sentences = []\n", "\n", "for item in data[:50]:\n", " english_sentences.append(item['input'])\n", " hawaiian_sentences.append(item['output'])\n" ], "metadata": { "id": "9JXZAinrZcGm" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "tokenizer = GPT2Tokenizer.from_pretrained('gpt2')\n", "tokenizer.add_special_tokens({'pad_token': '[PAD]'})\n", "\n", "\n", "train_en, val_en, train_hn, val_hn = train_test_split(english_sentences, hawaiian_sentences, test_size=0.2)\n", "\n", "\n", "train_dataset = TranslationDataset(train_en, train_hn, tokenizer)\n", "val_dataset = TranslationDataset(val_en, val_hn, tokenizer)\n", "\n", "train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True)\n", "val_loader = DataLoader(val_dataset, batch_size=2, shuffle=False)\n" ], "metadata": { "id": "G_sC9NilXtKE" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "def train_model(model, train_loader, val_loader, epochs=50, lr=0.001):\n", " optimizer = optim.Adam(model.parameters(), lr=lr)\n", " criterion = nn.CrossEntropyLoss(ignore_index=tokenizer.pad_token_id)\n", "\n", "\n", " bleu_scores = []\n", " chrf_scores = []\n", "\n", " try:\n", " nltk.data.find('tokenizers/punkt_tab')\n", " except LookupError:\n", " nltk.download('punkt_tab')\n", " for epoch in range(epochs):\n", " model.train()\n", " train_loss = 0\n", " for batch in train_loader:\n", " source = batch['source'].to(device)\n", " target = batch['target'].to(device)\n", "\n", " optimizer.zero_grad()\n", " output = model(source, target)\n", " output_dim = output.shape[-1]\n", " output = output.view(-1, output_dim)\n", " target = target.view(-1)\n", "\n", " loss = criterion(output, target)\n", " loss.backward()\n", " optimizer.step()\n", "\n", " train_loss += loss.item()\n", "\n", " # Validation phase\n", " model.eval()\n", " val_loss = 0\n", " all_preds = []\n", " all_targets = []\n", " with torch.no_grad():\n", " for batch in val_loader:\n", " source = batch['source'].to(device)\n", " target = batch['target'].to(device)\n", "\n", " output = model(source, target)\n", " output_dim = output.shape[-1]\n", " output = output.view(-1, output_dim)\n", " target = target.view(-1)\n", "\n", " loss = criterion(output, target)\n", " val_loss += loss.item()\n", "\n", " preds = output.argmax(dim=-1)\n", " all_preds.extend(preds.cpu().numpy())\n", " all_targets.extend(target.cpu().numpy())\n", "\n", " # Calculate BLEU and chrF scores\n", " bleu = calculate_bleu(all_preds, all_targets)\n", " chrf = calculate_chrf(all_preds, all_targets)\n", "\n", " # Log results\n", " print(f\"Epoch {epoch+1}/{epochs} | Train Loss: {train_loss/len(train_loader):.4f} | Validation Loss: {val_loss/len(val_loader):.4f} | BLEU: {bleu:.4f} | chrF: {chrf:.4f}\")\n", " bleu_scores.append(bleu)\n", " chrf_scores.append(chrf)\n", "\n", " return bleu_scores, chrf_scores\n", "\n", "def calculate_bleu(preds, targets):\n", " pred_sentences = tokenizer.batch_decode(preds, skip_special_tokens=True)\n", " target_sentences = tokenizer.batch_decode(targets, skip_special_tokens=True)\n", " pred_tokens = [nltk.word_tokenize(sentence) for sentence in pred_sentences]\n", " target_tokens = [[nltk.word_tokenize(sentence)] for sentence in target_sentences]\n", " return corpus_bleu(target_tokens, pred_tokens)\n", "\n", "def calculate_chrf(preds, targets):\n", " pred_sentences = tokenizer.batch_decode(preds, skip_special_tokens=True)\n", " target_sentences = tokenizer.batch_decode(targets, skip_special_tokens=True)\n", "\n", " return corpus_chrf(target_sentences, pred_sentences)\n" ], "metadata": { "id": "panBL628XwUG" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", "\n", "\n", "input_dim = len(tokenizer)\n", "embedding_dim = 256\n", "hidden_dim = 512\n", "output_dim = len(tokenizer)\n", "\n", "\n", "model = Seq2SeqModel(input_dim, embedding_dim, hidden_dim, output_dim).to(device)\n", "\n", "bleu_scores, chrf_scores = train_model(model, train_loader, val_loader, epochs=50)\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "W1hB6IZ5X07r", "outputId": "ed6b2ddb-d5c8-4034-ab76-fa68cfeebbc2" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Epoch 1/50 | Train Loss: 8.0077 | Validation Loss: 6.5602 | BLEU: 0.0000 | chrF: 0.0079\n", "Epoch 2/50 | Train Loss: 5.1729 | Validation Loss: 6.1159 | BLEU: 0.0000 | chrF: 0.0076\n", "Epoch 3/50 | Train Loss: 4.8325 | Validation Loss: 5.7690 | BLEU: 0.0000 | chrF: 0.0076\n", "Epoch 4/50 | Train Loss: 4.5921 | Validation Loss: 5.6889 | BLEU: 0.0000 | chrF: 0.0080\n", "Epoch 5/50 | Train Loss: 4.6159 | Validation Loss: 5.7099 | BLEU: 0.0000 | chrF: 0.0077\n", "Epoch 6/50 | Train Loss: 4.5232 | Validation Loss: 5.7290 | BLEU: 0.0000 | chrF: 0.0077\n", "Epoch 7/50 | Train Loss: 4.4751 | Validation Loss: 5.7153 | BLEU: 0.0000 | chrF: 0.0079\n", "Epoch 8/50 | Train Loss: 4.4819 | Validation Loss: 5.7380 | BLEU: 0.0000 | chrF: 0.0078\n", "Epoch 9/50 | Train Loss: 4.4538 | Validation Loss: 5.7808 | BLEU: 0.0000 | chrF: 0.0078\n", "Epoch 10/50 | Train Loss: 4.3576 | Validation Loss: 5.7741 | BLEU: 0.0000 | chrF: 0.0080\n", "Epoch 11/50 | Train Loss: 4.3020 | Validation Loss: 5.8201 | BLEU: 0.0000 | chrF: 0.0077\n", "Epoch 12/50 | Train Loss: 4.3032 | Validation Loss: 5.7724 | BLEU: 0.0000 | chrF: 0.0078\n", "Epoch 13/50 | Train Loss: 4.2289 | Validation Loss: 5.8742 | BLEU: 0.0000 | chrF: 0.0069\n", "Epoch 14/50 | Train Loss: 4.1806 | Validation Loss: 5.8202 | BLEU: 0.0000 | chrF: 0.0078\n", "Epoch 15/50 | Train Loss: 4.0578 | Validation Loss: 5.8620 | BLEU: 0.0000 | chrF: 0.0079\n", "Epoch 16/50 | Train Loss: 3.9512 | Validation Loss: 6.0217 | BLEU: 0.0000 | chrF: 0.0080\n", "Epoch 17/50 | Train Loss: 3.8459 | Validation Loss: 6.0132 | BLEU: 0.0000 | chrF: 0.0085\n", "Epoch 18/50 | Train Loss: 3.7377 | Validation Loss: 6.0084 | BLEU: 0.0000 | chrF: 0.0086\n", "Epoch 19/50 | Train Loss: 3.5704 | Validation Loss: 6.2000 | BLEU: 0.0000 | chrF: 0.0072\n", "Epoch 20/50 | Train Loss: 3.4777 | Validation Loss: 6.2884 | BLEU: 0.0000 | chrF: 0.0080\n", "Epoch 21/50 | Train Loss: 3.3644 | Validation Loss: 6.3706 | BLEU: 0.0000 | chrF: 0.0078\n", "Epoch 22/50 | Train Loss: 3.2684 | Validation Loss: 6.4485 | BLEU: 0.0000 | chrF: 0.0082\n", "Epoch 23/50 | Train Loss: 3.1742 | Validation Loss: 6.4875 | BLEU: 0.0000 | chrF: 0.0084\n", "Epoch 24/50 | Train Loss: 3.0669 | Validation Loss: 6.7084 | BLEU: 0.0000 | chrF: 0.0081\n", "Epoch 25/50 | Train Loss: 3.0130 | Validation Loss: 6.7559 | BLEU: 0.0000 | chrF: 0.0073\n", "Epoch 26/50 | Train Loss: 2.8428 | Validation Loss: 6.8429 | BLEU: 0.0000 | chrF: 0.0079\n", "Epoch 27/50 | Train Loss: 2.7908 | Validation Loss: 7.0061 | BLEU: 0.0000 | chrF: 0.0082\n", "Epoch 28/50 | Train Loss: 2.7890 | Validation Loss: 6.9220 | BLEU: 0.0000 | chrF: 0.0083\n", "Epoch 29/50 | Train Loss: 2.6531 | Validation Loss: 7.0435 | BLEU: 0.0000 | chrF: 0.0082\n", "Epoch 30/50 | Train Loss: 2.8013 | Validation Loss: 7.2118 | BLEU: 0.0000 | chrF: 0.0073\n", "Epoch 31/50 | Train Loss: 2.6600 | Validation Loss: 7.0605 | BLEU: 0.0000 | chrF: 0.0080\n", "Epoch 32/50 | Train Loss: 2.6791 | Validation Loss: 7.1734 | BLEU: 0.0000 | chrF: 0.0081\n", "Epoch 33/50 | Train Loss: 2.5625 | Validation Loss: 7.2896 | BLEU: 0.0000 | chrF: 0.0084\n", "Epoch 34/50 | Train Loss: 2.5496 | Validation Loss: 7.3055 | BLEU: 0.0000 | chrF: 0.0075\n", "Epoch 35/50 | Train Loss: 2.6619 | Validation Loss: 7.3008 | BLEU: 0.0000 | chrF: 0.0077\n", "Epoch 36/50 | Train Loss: 2.5772 | Validation Loss: 7.3452 | BLEU: 0.0000 | chrF: 0.0083\n", "Epoch 37/50 | Train Loss: 2.5616 | Validation Loss: 7.3081 | BLEU: 0.0000 | chrF: 0.0077\n", "Epoch 38/50 | Train Loss: 2.5279 | Validation Loss: 7.3918 | BLEU: 0.0000 | chrF: 0.0088\n", "Epoch 39/50 | Train Loss: 2.5597 | Validation Loss: 7.5382 | BLEU: 0.0000 | chrF: 0.0070\n", "Epoch 40/50 | Train Loss: 2.4717 | Validation Loss: 7.4116 | BLEU: 0.0000 | chrF: 0.0076\n", "Epoch 41/50 | Train Loss: 2.5487 | Validation Loss: 7.5398 | BLEU: 0.0000 | chrF: 0.0086\n", "Epoch 42/50 | Train Loss: 2.5148 | Validation Loss: 7.4839 | BLEU: 0.0000 | chrF: 0.0080\n", "Epoch 43/50 | Train Loss: 2.4878 | Validation Loss: 7.4912 | BLEU: 0.0000 | chrF: 0.0080\n", "Epoch 44/50 | Train Loss: 2.4169 | Validation Loss: 7.5562 | BLEU: 0.0000 | chrF: 0.0071\n", "Epoch 45/50 | Train Loss: 2.4806 | Validation Loss: 7.6877 | BLEU: 0.0000 | chrF: 0.0085\n", "Epoch 46/50 | Train Loss: 2.3981 | Validation Loss: 7.6425 | BLEU: 0.0000 | chrF: 0.0083\n", "Epoch 47/50 | Train Loss: 2.5246 | Validation Loss: 7.6074 | BLEU: 0.0000 | chrF: 0.0082\n", "Epoch 48/50 | Train Loss: 2.5364 | Validation Loss: 7.5859 | BLEU: 0.0000 | chrF: 0.0081\n", "Epoch 49/50 | Train Loss: 2.4123 | Validation Loss: 7.6440 | BLEU: 0.0000 | chrF: 0.0086\n", "Epoch 50/50 | Train Loss: 2.4797 | Validation Loss: 7.6387 | BLEU: 0.0000 | chrF: 0.0080\n" ] } ] }, { "cell_type": "code", "source": [ "def translate_sentence(model, sentence, tokenizer, max_len=128, reverse=False):\n", " tokens = tokenizer.encode(sentence, return_tensors='pt').to(device)\n", " if reverse:\n", " src, trg = tokens, tokens\n", " else:\n", " src, trg = tokens, tokens\n", "\n", " model.eval()\n", " with torch.no_grad():\n", " output = model(src, trg)\n", " output = output.argmax(dim=-1)\n", "\n", " translated_tokens = output.squeeze(0).cpu().numpy()\n", "\n", "\n", " translated_sentence = tokenizer.decode(translated_tokens, skip_special_tokens=True)\n", " return translated_sentence\n", "\n", "\n" ], "metadata": { "id": "2iZ__gHWZFPk" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "english_sentence = \"This should be translated into something i want\"\n", "hawaiian_translation = translate_sentence(model, english_sentence, tokenizer, reverse=False)\n", "print(f\"English: {english_sentence}\")\n", "print(f\"Hawaiian Translation: {hawaiian_translation}\")\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "OaVEnzYSZIca", "outputId": "a4f68dec-c9d8-45c5-d1b6-7ac4948fb450" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "English: This should be translated into something i want\n", "Hawaiian Translation: ālome��ana o�\n" ] } ] }, { "cell_type": "code", "source": [ "hawaiian_sentence = \"Aloha oe\"\n", "english_translation = translate_sentence(model, hawaiian_sentence, tokenizer, reverse=True)\n", "print(f\"Hawaiian: {hawaiian_sentence}\")\n", "print(f\"English Translation: {english_translation}\")\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "q5529O1GZLew", "outputId": "7997cc18-233b-42bb-d320-1d3075032fe7" }, "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Hawaiian: Aloha oe\n", "English Translation: � i i\n" ] } ] }, { "cell_type": "code", "source": [ "import csv\n", "\n", "with open('scores.csv', 'w', newline='') as csvfile:\n", " writer = csv.writer(csvfile)\n", " writer.writerow(['Epoch', 'BLEU', 'chrF'])\n", " for epoch, (bleu, chrf) in enumerate(zip(bleu_scores, chrf_scores)):\n", " writer.writerow([epoch + 1, bleu, chrf])" ], "metadata": { "id": "LAuWXFuktgSL" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "train_loss = [\n", " 8.0077, 5.1729, 4.8325, 4.5921, 4.6159, 4.5232, 4.4751, 4.4819, 4.4538,\n", " 4.3576, 4.3020, 4.3032, 4.2289, 4.1806, 4.0578, 3.9512, 3.8459, 3.7377,\n", " 3.5704, 3.4777, 3.3644, 3.2684, 3.1742, 3.0669, 3.0130, 2.8428, 2.7908,\n", " 2.7890, 2.6531, 2.8013, 2.6600, 2.6791, 2.5625, 2.5496, 2.6619, 2.5772,\n", " 2.5616, 2.5279, 2.5597, 2.4717, 2.5487, 2.5148, 2.4878, 2.4169, 2.4806,\n", " 2.3981, 2.5246, 2.5364, 2.4123, 2.4797\n", "]" ], "metadata": { "id": "diSa4qxnvHdI" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "val_loss = [\n", " 6.5602, 6.1159, 5.7690, 5.6889, 5.7099, 5.7290, 5.7153, 5.7380, 5.7808,\n", " 5.7741, 5.8201, 5.7724, 5.8742, 5.8202, 5.8620, 6.0217, 6.0132, 6.0084,\n", " 6.2000, 6.2884, 6.3706, 6.4485, 6.4875, 6.7084, 6.7559, 6.8429, 7.0061,\n", " 6.9220, 7.0435, 7.2118, 7.0605, 7.1734, 7.2896, 7.3055, 7.3008, 7.3452,\n", " 7.3081, 7.3918, 7.5382, 7.4116, 7.5398, 7.4839, 7.4912, 7.5562, 7.6877,\n", " 7.6425, 7.6074, 7.5859, 7.6440, 7.6387\n", "]" ], "metadata": { "id": "fk28NnKYvLMN" }, "execution_count": null, "outputs": [] }, { "cell_type": "code", "source": [ "\n", "\n", "import matplotlib.pyplot as plt\n", "\n", "\n", "epochs = range(1, len(train_loss) + 1)\n", "\n", "plt.figure(figsize=(10, 6))\n", "plt.plot(epochs, train_loss, label='Training Loss')\n", "plt.plot(epochs, val_loss, label='Validation Loss')\n", "plt.xlabel('Epochs')\n", "plt.ylabel('Loss')\n", "plt.title('Training and Validation Loss')\n", "plt.legend()\n", "plt.grid(True)\n", "plt.show()" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 564 }, "id": "6aPFpEo-wrB8", "outputId": "554cf3aa-1e11-4491-e80a-98401803f9d4" }, "execution_count": null, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ] } ] }