broca_translator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d66c276b50f2a9dc",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2023-11-07T12:01:58.697527900Z",
     "start_time": "2023-11-07T12:01:55.957398800Z"
    },
    "id": "d66c276b50f2a9dc"
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Encoder-Decoder Sequence-to-Sequence Model for Machine Translation from aphasic to correct phrase in English\n",
    "authors:\n",
    "    Damiano Pasquini damiano23@ru.is\n",
    "    Andrea Terenziani andrea23@ru.is\n",
    "    Aurora Ayn Wickstrom aurora23@ru.is\n",
    "course: T-725-MALV, Málvinnsla\n",
    "\"\"\"\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "\n",
    "from keras.models import Model\n",
    "from keras.layers import Input, LSTM, Dense, Embedding, Reshape\n",
    "from keras.callbacks import Callback"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "batch_size = 64  # Batch size for training.\n",
    "epochs = 20  # Number of epochs to train for.\n",
    "latent_dim = 400  # Latent dimensionality of the encoding space. before it was 256\n",
    "num_samples = 4000  # Number of samples to train on.\n",
    "embedding_dim = 100\n",
    "data_path = 'eng_sents_altered.txt' # Path to the data txt file on disk.\n",
    "max_input_sentence_length = 30\n",
    "max_target_sentence_length = 30 #TODO review"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-07T12:01:58.704370700Z",
     "start_time": "2023-11-07T12:01:58.697527900Z"
    },
    "id": "initial_id"
   },
   "id": "initial_id"
  },
  {
   "cell_type": "code",
   "source": [
    "# if running on colab, mount drive\n",
    "from google.colab import drive\n",
    "drive.mount('/content/drive')"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "wQr4LzgU7PHI",
    "outputId": "0552bc7d-a69e-4f7e-d8ff-d705a4c34b4b"
   },
   "id": "wQr4LzgU7PHI",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Source Unique words:  7498\n",
      "Target Unique words 4103\n",
      "Number of samples: 4000\n",
      "Number of unique input char: 78\n",
      "Number of unique output char: 80\n",
      "Max sequence length for inputs: 33\n",
      "Max sequence length for outputs: 32\n"
     ]
    }
   ],
   "source": [
    "# Vectorize the data in one hot encoding\n",
    "input_texts = []\n",
    "target_texts = []\n",
    "input_characters = set()\n",
    "target_characters = set()\n",
    "input_tokens = set()\n",
    "target_tokens = set()\n",
    "lines = open(data_path).read().split('\\n')\n",
    "for line in lines[: min(num_samples, len(lines) - 1)]:\n",
    "    input_text, target_text = line.split('\\t')\n",
    "    # We use \"tab\" as the \"start sequence\" character\n",
    "    # for the targets, and \"\\n\" as \"end sequence\" character.\n",
    "    target_text = '\\t' + target_text + '\\n'\n",
    "    input_texts.append(input_text)\n",
    "    for word in input_text.split():\n",
    "        word = word.removesuffix(\".\").removesuffix(\",\").removesuffix(\";\").removesuffix(\":\").removesuffix(\"!\").removesuffix(\"?\").removesuffix(\"'\").removesuffix('\"').removeprefix(\"'\").removeprefix('\"')\n",
    "        input_tokens.add(word)\n",
    "    for word in target_text.split():\n",
    "        word = word.removesuffix(\".\").removesuffix(\",\").removesuffix(\";\").removesuffix(\":\").removesuffix(\"!\").removesuffix(\"?\").removesuffix(\"'\").removesuffix('\"').removeprefix(\"'\").removeprefix('\"')\n",
    "        target_tokens.add(word)\n",
    "    target_texts.append(target_text)\n",
    "    for char in input_text:\n",
    "        input_characters.add(char)\n",
    "    for char in target_text:\n",
    "        target_characters.add(char)\n",
    "\n",
    "input_characters = sorted(list(input_characters))\n",
    "target_characters = sorted(list(target_characters))\n",
    "num_encoder_tokens = len(input_characters)\n",
    "num_decoder_tokens = len(target_characters)\n",
    "max_encoder_seq_length = max([len(txt) for txt in input_texts])\n",
    "max_decoder_seq_length = max([len(txt) for txt in target_texts])\n",
    "\n",
    "input_token_index = dict(\n",
    "    [(char, i) for i, char in enumerate(input_characters)])\n",
    "target_token_index = dict(\n",
    "    [(char, i) for i, char in enumerate(target_characters)])\n",
    "\n",
    "encoder_input_data = np.zeros(\n",
    "    (len(input_texts), max_encoder_seq_length, num_encoder_tokens),\n",
    "    dtype='float32')\n",
    "decoder_input_data = np.zeros(\n",
    "    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),\n",
    "    dtype='float32')\n",
    "decoder_target_data = np.zeros(\n",
    "    (len(input_texts), max_decoder_seq_length, num_decoder_tokens),\n",
    "    dtype='float32')\n",
    "\n",
    "for i, (input_text, target_text) in enumerate(zip(input_texts, target_texts)):\n",
    "    for t, char in enumerate(input_text):\n",
    "        encoder_input_data[i, t, input_token_index[char]] = 1.\n",
    "    for t, char in enumerate(target_text):\n",
    "        # decoder_target_data is ahead of decoder_input_data by one timestep\n",
    "        decoder_input_data[i, t, target_token_index[char]] = 1.\n",
    "        if t > 0:\n",
    "            # decoder_target_data will be ahead by one timestep\n",
    "            # and will not include the start character.\n",
    "            decoder_target_data[i, t - 1, target_token_index[char]] = 1."
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-07T12:01:59.489423700Z",
     "start_time": "2023-11-07T12:01:58.704370700Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "434612f2c601b2b",
    "outputId": "e22b7d23-32f0-4868-9659-bd0ebcecf50c"
   },
   "id": "434612f2c601b2b"
  },
  {
   "cell_type": "code",
   "source": [
    "print('Source Unique words: ', len(input_tokens))\n",
    "print('Target Unique words: ', len(target_tokens))\n",
    "print('Number of samples: ', len(input_texts))\n",
    "print('Number of unique input char:', num_encoder_tokens)\n",
    "print('Number of unique output char:', num_decoder_tokens)\n",
    "print('Max sequence length for inputs:', max_encoder_seq_length)\n",
    "print('Max sequence length for outputs:', max_decoder_seq_length)\n",
    "print()\n",
    "print(f\"Encoder input shape: {encoder_input_data.shape}\")\n",
    "print(f\"Decoder input shape: {decoder_input_data.shape}\")\n",
    "print(f\"Decoder target shape: {decoder_target_data.shape}\")"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NmawSTaWve7q",
    "outputId": "4e98553c-630e-4bd2-fcea-b3b1ddd144e8"
   },
   "id": "NmawSTaWve7q",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Source Unique words:  7498\n",
      "Target Unique words:  4103\n",
      "Number of samples:  4000\n",
      "Number of unique input char: 78\n",
      "Number of unique output char: 80\n",
      "Max sequence length for inputs: 33\n",
      "Max sequence length for outputs: 32\n",
      "\n",
      "Encoder input shape: (4000, 33, 78)\n",
      "Decoder input shape: (4000, 32, 80)\n",
      "Decoder target shape: (4000, 32, 80)\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Enncoder input shape: (None, 33, 78)\n",
      "Enncoder embed shape: (None, 2574, 100)\n",
      "Enncoder LSTM shape: (None, 2574, 400)\n",
      "Decoder input shape: (None, 32, 80)\n",
      "Decoder embed shape: (None, 2560, 100)\n",
      "Decoder LSTM shape: (None, 2560, 400)\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.python.autograph.operators.py_builtins import max_\n",
    "\n",
    "# embedding_dim = 100\n",
    "\n",
    "# Encoder\n",
    "# dataset = tf.data.TextLineDataset(data_path)\n",
    "encoder_input_data = tf.squeeze(encoder_input_data)\n",
    "decoder_input_data = tf.squeeze(decoder_input_data)\n",
    "decoder_target_data = tf.squeeze(decoder_target_data)\n",
    "dataset = tf.data.Dataset.from_tensor_slices(((encoder_input_data, decoder_input_data), decoder_target_data))\n",
    "dataset = dataset.shuffle(buffer_size=1024).batch(batch_size)\n",
    "test_size = int(0.2 * num_samples)\n",
    "train_size = num_samples-test_size\n",
    "validation_size = int(0.1*train_size)\n",
    "train_size-=validation_size\n",
    "\n",
    "\n",
    "# Split the dataset\n",
    "train_dataset = dataset.take(train_size // batch_size)\n",
    "validation_dataset = dataset.skip(train_size // batch_size)\n",
    "testing_dataset = validation_dataset.skip(validation_size // batch_size)\n",
    "# validation_dataset = validation_dataset.take(validation_size // batch_size)\n",
    "\n",
    "encoder_inputs = Input(shape=(max_encoder_seq_length, num_encoder_tokens), name='input_1')\n",
    "print(f\"Enncoder input shape: {encoder_inputs.shape}\")\n",
    "\n",
    "encoder_reshape = Reshape(target_shape=(max_encoder_seq_length*num_encoder_tokens,), name=\"encoder_reshape\")(encoder_inputs)\n",
    "\n",
    "encoder_embedding = Embedding(input_dim=num_encoder_tokens, output_dim=embedding_dim, name='embedding_1')(encoder_reshape)\n",
    "print(f\"Enncoder embed shape: {encoder_embedding.shape}\")\n",
    "\n",
    "encoder_lstm, state_h, state_c = LSTM(latent_dim, return_state=True, name='lstm_1', return_sequences=True)(encoder_embedding)\n",
    "print(f\"Enncoder LSTM shape: {encoder_lstm.shape}\")\n",
    "\n",
    "encoder_states = [state_h, state_c]\n",
    "\n",
    "# Decoder\n",
    "decoder_inputs = Input(shape=(max_decoder_seq_length, num_decoder_tokens), name='input_2')\n",
    "print(f\"Decoder input shape: {decoder_inputs.shape}\")\n",
    "\n",
    "decoder_reshape = Reshape(target_shape=(max_decoder_seq_length * num_decoder_tokens,), name=\"decoder_reshape\")(decoder_inputs)\n",
    "\n",
    "decoder_embedding = Embedding(input_dim=max_decoder_seq_length, output_dim=embedding_dim, name='embedding_2')(decoder_reshape)\n",
    "print(f\"Decoder embed shape: {decoder_embedding.shape}\")\n",
    "\n",
    "decoder_lstm, _, _ = LSTM(latent_dim, return_state=True, name='lstm_2', return_sequences=True)(decoder_embedding, initial_state=encoder_states)\n",
    "print(f\"Decoder LSTM shape: {decoder_lstm.shape}\")\n",
    "\n",
    "decoder_outputs = Dense(len(target_tokens), activation='softmax', name='dense_1')(decoder_lstm)\n",
    "\n",
    "# Model\n",
    "model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_outputs, name='seq2seq_model')"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-07T12:01:59.886452300Z",
     "start_time": "2023-11-07T12:01:59.490514200Z"
    },
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "da00c92545bd3a7f",
    "outputId": "a9662c59-8ad0-4454-dae8-156b1197bff3"
   },
   "id": "da00c92545bd3a7f"
  },
  {
   "cell_type": "code",
   "source": [
    "model.summary()"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mEfpBk1ikMY0",
    "outputId": "928e8f75-8821-420d-83eb-a79a7585f5db"
   },
   "id": "mEfpBk1ikMY0",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Model: \"seq2seq_model\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input_1 (InputLayer)        [(None, 33, 78)]             0         []                            \n",
      "                                                                                                  \n",
      " input_2 (InputLayer)        [(None, 32, 80)]             0         []                            \n",
      "                                                                                                  \n",
      " encoder_reshape (Reshape)   (None, 2574)                 0         ['input_1[0][0]']             \n",
      "                                                                                                  \n",
      " decoder_reshape (Reshape)   (None, 2560)                 0         ['input_2[0][0]']             \n",
      "                                                                                                  \n",
      " embedding_1 (Embedding)     (None, 2574, 100)            7800      ['encoder_reshape[0][0]']     \n",
      "                                                                                                  \n",
      " embedding_2 (Embedding)     (None, 2560, 100)            3200      ['decoder_reshape[0][0]']     \n",
      "                                                                                                  \n",
      " lstm_1 (LSTM)               [(None, 2574, 400),          801600    ['embedding_1[0][0]']         \n",
      "                              (None, 400),                                                        \n",
      "                              (None, 400)]                                                        \n",
      "                                                                                                  \n",
      " lstm_2 (LSTM)               [(None, 2560, 400),          801600    ['embedding_2[0][0]',         \n",
      "                              (None, 400),                           'lstm_1[0][1]',              \n",
      "                              (None, 400)]                           'lstm_1[0][2]']              \n",
      "                                                                                                  \n",
      " dense_1 (Dense)             (None, 2560, 4103)           1645303   ['lstm_2[0][0]']              \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 3259503 (12.43 MB)\n",
      "Trainable params: 3259503 (12.43 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "!pip install graphviz"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "uDo5DpGpEgub",
    "outputId": "ca7ae737-0c5d-4765-f668-371be416f66c"
   },
   "id": "uDo5DpGpEgub",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Requirement already satisfied: graphviz in /usr/local/lib/python3.10/dist-packages (0.20.1)\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "from keras.utils import plot_model\n",
    "\n",
    "plot_model(model, show_layer_names=True, show_shapes=True)"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 644
    },
    "id": "bJksqzrrEUgo",
    "outputId": "38a9fc8a-4e91-4186-d7ad-02446385b4d3"
   },
   "id": "bJksqzrrEUgo",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "execution_count": 215
    }
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "class LogCallback(Callback):\n",
    "    def on_train_begin(self, logs=None):\n",
    "        keys = list(logs.keys())\n",
    "        print(\"Starting training; got log keys: {}\".format(keys))\n",
    "\n",
    "    def on_train_end(self, logs=None):\n",
    "        keys = list(logs.keys())\n",
    "        print(\"Stop training; got log keys: {}\".format(keys))\n",
    "\n",
    "    def on_step_begin(self, step, logs):\n",
    "        print(f\"APAPAPAPAPAPA {step}\")"
   ],
   "metadata": {
    "id": "Lhh83ur26L4O"
   },
   "id": "Lhh83ur26L4O",
   "execution_count": null,
   "outputs": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Run training\n",
    "model.compile(optimizer='adagrad', loss='categorical_crossentropy')"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-07T12:41:39.947790500Z",
     "start_time": "2023-11-07T12:01:59.886452300Z"
    },
    "id": "9e7e61f7ddd614b2"
   },
   "id": "9e7e61f7ddd614b2"
  },
  {
   "cell_type": "code",
   "source": [
    "print(encoder_input_data.shape)\n",
    "print(decoder_input_data.shape)\n",
    "\n",
    "\n",
    "# [encoder_input_data, decoder_input_data]\n",
    "model.fit(train_dataset,\n",
    "          epochs=epochs,\n",
    "          batch_size=64,\n",
    "          validation_data=validation_dataset,\n",
    "          callbacks=[LogCallback()])\n",
    "# Save model\n",
    "model.save('s2s.h5')"
   ],
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 877
    },
    "id": "IS_AAi7v_ulr",
    "outputId": "0a137555-4358-4ba5-a000-4f3d28088511"
   },
   "id": "IS_AAi7v_ulr",
   "execution_count": null,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(4000, 33, 78)\n",
      "(4000, 32, 80)\n",
      "Starting training; got log keys: []\n",
      "Epoch 1/20\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "ValueError",
     "evalue": "ignored",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "\u001B[0;32m<ipython-input-206-27d63f2b9f15>\u001B[0m in \u001B[0;36m<cell line: 6>\u001B[0;34m()\u001B[0m\n\u001B[1;32m      4\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      5\u001B[0m \u001B[0;31m# [encoder_input_data, decoder_input_data]\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 6\u001B[0;31m model.fit(train_dataset,\n\u001B[0m\u001B[1;32m      7\u001B[0m           \u001B[0mepochs\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0mepochs\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m      8\u001B[0m           \u001B[0mbatch_size\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0;36m64\u001B[0m\u001B[0;34m,\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m/usr/local/lib/python3.10/dist-packages/keras/src/utils/traceback_utils.py\u001B[0m in \u001B[0;36merror_handler\u001B[0;34m(*args, **kwargs)\u001B[0m\n\u001B[1;32m     68\u001B[0m             \u001B[0;31m# To get the full stack trace, call:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     69\u001B[0m             \u001B[0;31m# `tf.debugging.disable_traceback_filtering()`\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 70\u001B[0;31m             \u001B[0;32mraise\u001B[0m \u001B[0me\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mwith_traceback\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mfiltered_tb\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mfrom\u001B[0m \u001B[0;32mNone\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     71\u001B[0m         \u001B[0;32mfinally\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     72\u001B[0m             \u001B[0;32mdel\u001B[0m \u001B[0mfiltered_tb\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;32m/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py\u001B[0m in \u001B[0;36mtf__train_function\u001B[0;34m(iterator)\u001B[0m\n\u001B[1;32m     13\u001B[0m                 \u001B[0;32mtry\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     14\u001B[0m                     \u001B[0mdo_return\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0;32mTrue\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 15\u001B[0;31m                     \u001B[0mretval_\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mag__\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mconverted_call\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mag__\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mld\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mstep_function\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;34m(\u001B[0m\u001B[0mag__\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mld\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mag__\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mld\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0miterator\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0;32mNone\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mfscope\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m     16\u001B[0m                 \u001B[0;32mexcept\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m     17\u001B[0m                     \u001B[0mdo_return\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0;32mFalse\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n",
      "\u001B[0;31mValueError\u001B[0m: in user code:\n\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py\", line 1377, in train_function  *\n        return step_function(self, iterator)\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py\", line 1360, in step_function  **\n        outputs = model.distribute_strategy.run(run_step, args=(data,))\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py\", line 1349, in run_step  **\n        outputs = model.train_step(data)\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py\", line 1127, in train_step\n        loss = self.compute_loss(x, y, y_pred, sample_weight)\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/engine/training.py\", line 1185, in compute_loss\n        return self.compiled_loss(\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/engine/compile_utils.py\", line 277, in __call__\n        loss_value = loss_obj(y_t, y_p, sample_weight=sw)\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/losses.py\", line 143, in __call__\n        losses = call_fn(y_true, y_pred)\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/losses.py\", line 270, in call  **\n        return ag_fn(y_true, y_pred, **self._fn_kwargs)\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/losses.py\", line 2221, in categorical_crossentropy\n        return backend.categorical_crossentropy(\n    File \"/usr/local/lib/python3.10/dist-packages/keras/src/backend.py\", line 5575, in categorical_crossentropy\n        target.shape.assert_is_compatible_with(output.shape)\n\n    ValueError: Shapes (None, 32, 80) and (None, 2560, 4103) are incompatible\n"
     ]
    }
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "\n",
    "# Next: inference mode (sampling).\n",
    "# Here's the drill:\n",
    "# 1) encode input and retrieve initial decoder state\n",
    "# 2) run one step of decoder with this initial state\n",
    "# and a \"start of sequence\" token as target.\n",
    "# Output will be the next target token\n",
    "# 3) Repeat with the current target token and current states\n",
    "\n",
    "# Define sampling models\n",
    "encoder_model = Model(encoder_inputs, encoder_states)\n",
    "\n",
    "decoder_state_input_h = Input(shape=(latent_dim,))\n",
    "decoder_state_input_c = Input(shape=(latent_dim,))\n",
    "decoder_states_inputs = [decoder_state_input_h, decoder_state_input_c]\n",
    "decoder_outputs, state_h, state_c = decoder_lstm(\n",
    "    decoder_inputs, initial_state=decoder_states_inputs)\n",
    "decoder_states = [state_h, state_c]\n",
    "decoder_outputs = decoder_dense(decoder_outputs)\n",
    "decoder_model = Model(\n",
    "    [decoder_inputs] + decoder_states_inputs,\n",
    "    [decoder_outputs] + decoder_states)\n",
    "\n",
    "# Reverse-lookup token index to decode sequences back to\n",
    "# something readable.\n",
    "reverse_input_char_index = dict(\n",
    "    (i, char) for char, i in input_token_index.items())\n",
    "reverse_target_char_index = dict(\n",
    "    (i, char) for char, i in target_token_index.items())\n",
    "\n",
    "\n",
    "def decode_sequence(input_seq):\n",
    "    # Encode the input as state vectors.\n",
    "    states_value = encoder_model.predict(input_seq)\n",
    "\n",
    "    # Generate empty target sequence of length 1.\n",
    "    target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "    # Populate the first character of target sequence with the start character.\n",
    "    target_seq[0, 0, target_token_index['\\t']] = 1.\n",
    "\n",
    "    # Sampling loop for a batch of sequences\n",
    "    # (to simplify, here we assume a batch of size 1).\n",
    "    stop_condition = False\n",
    "    decoded_sentence = ''\n",
    "    while not stop_condition:\n",
    "        output_tokens, h, c = decoder_model.predict(\n",
    "            [target_seq] + states_value)\n",
    "\n",
    "        # Sample a token\n",
    "        sampled_token_index = np.argmax(output_tokens[0, -1, :])\n",
    "        sampled_char = reverse_target_char_index[sampled_token_index]\n",
    "        decoded_sentence += sampled_char\n",
    "\n",
    "        # Exit condition: either hit max length\n",
    "        # or find stop character.\n",
    "        if (sampled_char == '\\n' or\n",
    "           len(decoded_sentence) > max_decoder_seq_length):\n",
    "            stop_condition = True\n",
    "\n",
    "        # Update the target sequence (of length 1).\n",
    "        target_seq = np.zeros((1, 1, num_decoder_tokens))\n",
    "        target_seq[0, 0, sampled_token_index] = 1.\n",
    "\n",
    "        # Update states\n",
    "        states_value = [h, c]\n",
    "\n",
    "    return decoded_sentence\n",
    "\n",
    "\n",
    "for seq_index in range(100):\n",
    "    # Take one sequence (part of the training test)\n",
    "    # for trying out decoding.\n",
    "    input_seq = encoder_input_data[seq_index: seq_index + 1]\n",
    "    decoded_sentence = decode_sequence(input_seq)\n",
    "    print('-')\n",
    "    print('Input sentence:', input_texts[seq_index])\n",
    "    print('Decoded sentence:', decoded_sentence)"
   ],
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-11-07T12:41:39.954789800Z",
     "start_time": "2023-11-07T12:41:39.950788400Z"
    },
    "id": "214a644a2e20a837"
   },
   "id": "214a644a2e20a837"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  },
  "colab": {
   "provenance": [],
   "gpuType": "T4"
  },
  "accelerator": "GPU"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}