11text_generation.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "name": "text_generation.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "cellView": "form",
        "id": "GCCk8_dHpuNf"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ovpZyIhNIgoq"
      },
      "source": [
        "# Text generation with an RNN"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WGyKZj3bzf9p"
      },
      "source": [
        "### Import TensorFlow and other libraries"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yG_n40gFzf9s"
      },
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "import os\n",
        "import time\n",
        "from tensorflow.keras.layers import SimpleRNN,SimpleRNNCell"
      ],
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rebqC7D2iPo8",
        "outputId": "fb6be41d-df69-485f-ce16-e94aded32035",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "init=tf.zeros_like([[0,0,0,0]],dtype='float32')\n",
        "print(init.shape)\n",
        "input=np.array([[1,1,1],[4,4,4]]).astype('float32')\n",
        "input=input.reshape(1,2,3)\n",
        "input.shape\n",
        "rnn=SimpleRNN(4,activation='linear',kernel_initializer=tf.keras.initializers.Constant(1), return_sequences=True,\n",
        "              recurrent_initializer=tf.keras.initializers.Constant(1))\n",
        "output=rnn(input,initial_state=init)\n",
        "print(np.squeeze(output.numpy()))"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 4)\n",
            "[[ 3.  3.  3.  3.]\n",
            " [24. 24. 24. 24.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mF3UhTokkMaA",
        "outputId": "db7dff73-6a6f-477b-da70-965c13fd4b8d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "seq1=np.array([[1,1,1]]).astype('float32')\n",
        "seq2=np.array([[4,4,4]]).astype('float32')\n",
        "#input=input.reshape(1,2,3)\n",
        "#input.shape\n",
        "cell=SimpleRNNCell(4,activation='linear',kernel_initializer=tf.keras.initializers.Constant(1),\n",
        "                recurrent_initializer=tf.keras.initializers.Constant(1))\n",
        "one=cell(inputs=seq1,states=init)\n",
        "two=cell(inputs=seq2,states=one[1])\n",
        "print(one[0])\n",
        "two[0]"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "tf.Tensor([[3. 3. 3. 3.]], shape=(1, 4), dtype=float32)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<tf.Tensor: shape=(1, 4), dtype=float32, numpy=array([[24., 24., 24., 24.]], dtype=float32)>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HwF0rira3-9L",
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "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",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 73
        },
        "outputId": "a3bd2a94-5834-4b58-80e7-4291f9b51d10"
      },
      "source": [
        "from google.colab import files\n",
        "file=files.upload()\n",
        "!mkdir /root/.kaggle\n",
        "!mv kaggle.json  /root/.kaggle\n"
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-c2146372-7d10-4866-877d-db312db8db3a\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-c2146372-7d10-4866-877d-db312db8db3a\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "mkdir: cannot create directory ‘/root/.kaggle’: File exists\n",
            "mv: cannot stat 'kaggle.json': No such file or directory\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "odpyT3ps4n1t",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8bdc8904-bf17-45ae-d104-be4f2407fbc7"
      },
      "source": [
        "#!kaggle datasets download -d nzalake52/new-york-times-articles\n",
        "!kaggle datasets download -d ad6398/bbcnewsarticle\n",
        "!unzip bbcnewsarticle.zip"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Warning: Your Kaggle API key is readable by other users on this system! To fix this, you can run 'chmod 600 /root/.kaggle/kaggle.json'\n",
            "Downloading bbcnewsarticle.zip to /content\n",
            "  0% 0.00/1.83M [00:00<?, ?B/s]\n",
            "100% 1.83M/1.83M [00:00<00:00, 60.8MB/s]\n",
            "Archive:  bbcnewsarticle.zip\n",
            "  inflating: bbc-text.csv            \n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IalZLbvOzf-F"
      },
      "source": [
        "\n",
        "text=open(\"bbc-text.csv\",encoding='utf8').read()\n",
        "vocab = sorted(set(text))\n",
        "# Creating a mapping from unique characters to indices\n",
        "char2idx = {u:i for i, u in enumerate(vocab)}\n",
        "idx2char = np.array(vocab)\n",
        "\n",
        "text_as_int = np.array([char2idx[c] for c in text])"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0UHJDA39zf-O",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c24d9045-937f-49df-b2bc-ec6919c5422a"
      },
      "source": [
        "# The maximum length sentence you want for a single input in characters\n",
        "seq_length = 100\n",
        "examples_per_epoch = len(text)//(seq_length+1)\n",
        "\n",
        "# Create training examples / targets\n",
        "char_dataset = tf.data.Dataset.from_tensor_slices(text_as_int)\n",
        "char_dataset"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<TensorSliceDataset shapes: (), types: tf.int64>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ZSYAcQV8OGP"
      },
      "source": [
        "The `batch` method lets us easily convert these individual characters to sequences of the desired size."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p2pGotuNzf-S",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f45540d2-f373-4a11-a889-6a1ba03429b1"
      },
      "source": [
        "sequences = char_dataset.batch(seq_length+1, drop_remainder=True)\n",
        "#print(sequences)\n",
        "def split_input_target(chunk):\n",
        "    input_text = chunk[:-1]\n",
        "    target_text = chunk[1:]\n",
        "    return input_text, target_text\n",
        "\n",
        "dataset = sequences.map(split_input_target)\n",
        "\n",
        "BATCH_SIZE = 64\n",
        "BUFFER_SIZE = 10000\n",
        "\n",
        "#dataset = dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE, drop_remainder=True)\n",
        "dataset = dataset.batch(BATCH_SIZE, drop_remainder=True)\n",
        "\n",
        "print(dataset)\n",
        "for d in dataset.take(1):\n",
        "    print(d[0][0,3].numpy())\n",
        "    #print(d[0])\n",
        "    #print(d[1])"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<BatchDataset shapes: ((64, 100), (64, 100)), types: (tf.int64, tf.int64)>\n",
            "36\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r6oUuElIMgVx"
      },
      "source": [
        "## Build The Model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8gPwEjRzf-Z"
      },
      "source": [
        "Use `tf.keras.Sequential` to define the model. For this simple example three layers are used to define our model:\n",
        "\n",
        "* `tf.keras.layers.Embedding`: The input layer. A trainable lookup table that will map the numbers of each character to a vector with `embedding_dim` dimensions;\n",
        "* `tf.keras.layers.GRU`: A type of RNN with size `units=rnn_units` (You can also use an LSTM layer here.)\n",
        "* `tf.keras.layers.Dense`: The output layer, with `vocab_size` outputs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zHT8cLh7EAsg",
        "outputId": "07c4ea4b-6d88-4dbd-e5fb-93149e689c98",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "# Length of the vocabulary in chars\n",
        "vocab_size = len(vocab)\n",
        "\n",
        "# The embedding dimension\n",
        "embedding_dim = 256\n",
        "\n",
        "# Number of RNN units\n",
        "rnn_units = 1024\n",
        "print(vocab_size)"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "59\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MtCrdfzEI2N0"
      },
      "source": [
        "def build_model(vocab_size, embedding_dim, rnn_units, batch_size):\n",
        "    model = tf.keras.Sequential([\n",
        "        tf.keras.layers.Embedding(vocab_size, embedding_dim,\n",
        "                                  batch_input_shape=[batch_size, None]),\n",
        "        tf.keras.layers.SimpleRNN(rnn_units,\n",
        "                            return_sequences=True,\n",
        "                            stateful=True,\n",
        "                            recurrent_initializer='glorot_uniform'),\n",
        "        tf.keras.layers.Dense(vocab_size)\n",
        "    ])\n",
        "    return model"
      ],
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wwsrpOik5zhv",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 665
        },
        "outputId": "45174bd2-e553-43cb-a2cb-26cd675882f2"
      },
      "source": [
        "model = build_model(vocab_size=len(vocab),embedding_dim=embedding_dim,rnn_units=rnn_units,batch_size=BATCH_SIZE)\n",
        "model.summary()\n",
        "model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True))    \n",
        "tf.keras.utils.plot_model(model,show_shapes=True)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_7\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding_7 (Embedding)      (64, None, 256)           15104     \n",
            "_________________________________________________________________\n",
            "simple_rnn_1 (SimpleRNN)     (64, None, 1024)          1311744   \n",
            "_________________________________________________________________\n",
            "dense_7 (Dense)              (64, None, 59)            60475     \n",
            "=================================================================\n",
            "Total params: 1,387,323\n",
            "Trainable params: 1,387,323\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UK-hmKjYVoll",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e29f329a-e5da-4181-946b-bc61674e1476"
      },
      "source": [
        "\n",
        "EPOCHS = 3\n",
        "try:\n",
        "  model.load_weights(\"weights.h5\")\n",
        "except:\n",
        "  pass\n",
        "history = model.fit(dataset, epochs=EPOCHS)\n",
        "model.save_weights(\"weights.h5\")"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 1/3\n",
            "782/782 [==============================] - 42s 54ms/step - loss: 2.0453\n",
            "Epoch 2/3\n",
            "782/782 [==============================] - 44s 56ms/step - loss: 1.5597\n",
            "Epoch 3/3\n",
            "782/782 [==============================] - 44s 56ms/step - loss: 1.4496\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKkD5M6eoSiN"
      },
      "source": [
        "## Generate text"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LycQ-ot_jjyu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 665
        },
        "outputId": "034b1242-be43-4612-9909-0e602a7c0295"
      },
      "source": [
        "model = build_model(vocab_size, embedding_dim, rnn_units, batch_size=1)\n",
        "\n",
        "model.load_weights(\"weights.h5\")\n",
        "#model.build(tf.TensorShape([1, None]))\n",
        "model.summary()\n",
        "tf.keras.utils.plot_model(model,show_shapes=True)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Model: \"sequential_2\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "embedding_2 (Embedding)      (1, None, 256)            15104     \n",
            "_________________________________________________________________\n",
            "lstm_2 (LSTM)                (1, None, 1024)           5246976   \n",
            "_________________________________________________________________\n",
            "dense_2 (Dense)              (1, None, 59)             60475     \n",
            "=================================================================\n",
            "Total params: 5,322,555\n",
            "Trainable params: 5,322,555\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DjGz1tDkzf-u"
      },
      "source": [
        "### The prediction loop\n",
        "\n",
        "The following code block generates the text:\n",
        "\n",
        "* Begin by choosing a start string, initializing the RNN state and setting the number of characters to generate.\n",
        "\n",
        "* Get the prediction distribution of the next character using the start string and the RNN state.\n",
        "\n",
        "* Then, use a categorical distribution to calculate the index of the predicted character. Use this predicted character as our next input to the model.\n",
        "\n",
        "* The RNN state returned by the model is fed back into the model so that it now has more context, instead of only one character. After predicting the next character, the modified RNN states are again fed back into the model, which is how it learns as it gets more context from the previously predicted characters.\n",
        "\n",
        "\n",
        "![To generate text the model's output is fed back to the input](https://github.com/tensorflow/docs/blob/master/site/en/tutorials/text/images/text_generation_sampling.png?raw=1)\n",
        "\n",
        "Looking at the generated text, you'll see the model knows when to capitalize, make paragraphs and imitates a Shakespeare-like writing vocabulary. With the small number of training epochs, it has not yet learned to form coherent sentences."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WvuwZBX5Ogfd"
      },
      "source": [
        "def generate_text(model, start_string):\n",
        "    # Evaluation step (generating text using the learned model)\n",
        "\n",
        "    # Number of characters to generate\n",
        "    num_generate = 1000\n",
        "\n",
        "    # Converting our start string to numbers (vectorizing)\n",
        "    input_eval = [char2idx[s] for s in start_string]\n",
        "    input_eval = tf.expand_dims(input_eval, 0)\n",
        "\n",
        "    # Empty string to store our results\n",
        "    text_generated = []\n",
        "\n",
        "    # Low temperature results in more predictable text.\n",
        "    # Higher temperature results in more surprising text.\n",
        "    # Experiment to find the best setting.\n",
        "    temperature = 0.4\n",
        "\n",
        "    # Here batch size == 1\n",
        "    model.reset_states()\n",
        "    for i in range(num_generate):\n",
        "        predictions = model(input_eval)\n",
        "        # remove the batch dimension\n",
        "        predictions = tf.squeeze(predictions, 0)\n",
        "\n",
        "        # using a categorical distribution to predict the character returned by the model\n",
        "        predictions = predictions / temperature\n",
        "        predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()\n",
        "\n",
        "        # Pass the predicted character as the next input to the model\n",
        "        # along with the previous hidden state\n",
        "        input_eval = tf.expand_dims([predicted_id], 0)\n",
        "\n",
        "        text_generated.append(idx2char[predicted_id])\n",
        "\n",
        "    return (start_string + ''.join(text_generated))"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ktovv0RFhrkn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4bce36c6-878f-4e5b-d3ac-3d9916731997"
      },
      "source": [
        "print(generate_text(model, start_string=u\"telegraph\"))"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "telegraphes . len  the attention automatis and the sites. when they were true for audio from prosudd spending  to close the bosing lina when seeks in uke-student is not information as well enter this. yarnery industry have also up to the get the from social value that a growing global body are raised on the next group of sharen-hip for merrifristry.\n",
            "sport,new mobile deagh tracking its ways of party s strategist and draw a that had been striker by undermined like that but although smaller spight- boyd is on to go for the authors there s shrongly tries under scotts and just. share all the humers  i.  and offers in effective by code out the top pienceers ago up 35% - desitt the government has been offerged for its extra thousake industrials over the job.  it said anfin stages efforts to have so he bigger bush hest have dramatically extreme games from the potential dosanola  said  and though people are. looked signing a mogie when it is done must donly they can t speed some expects to ut ways the p\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AM2Uma_-yVIq"
      },
      "source": [
        "The easiest thing you can do to improve the results is to train it for longer (try `EPOCHS = 30`).\n",
        "\n",
        "You can also experiment with a different start string, try adding another RNN layer to improve the model's accuracy, or adjust the temperature parameter to generate more or less random predictions."
      ]
    }
  ]
}