text_generation_names.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "text_generation_names",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyM8bubNMWdaZOURvxunQEhr",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cmlakhan/ml_code/blob/master/text_generation_names.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "15sRg7Toiwtc"
      },
      "source": [
        "import json\n",
        "import pandas as pd\n",
        "import urllib.request\n",
        "\n",
        "from __future__ import unicode_literals, print_function, division\n",
        "import unicodedata\n",
        "import string\n",
        "\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "import random\n",
        "import time\n",
        "import math\n",
        "\n"
      ],
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SJh68DC1iySJ"
      },
      "source": [
        "def convertASCII(word):\n",
        "    asciiWord = \"\"\n",
        "    word = str(word).rstrip()\n",
        "    for c in word:\n",
        "        if c in characterMap.keys():\n",
        "            asciiWord = asciiWord + characterMap[c]\n",
        "        else:\n",
        "            asciiWord = asciiWord + c\n",
        "    return asciiWord;\n",
        "\n",
        "\n",
        "def unicodeToAscii(s):\n",
        "    return ''.join(\n",
        "        c for c in unicodedata.normalize('NFD', s)\n",
        "        if unicodedata.category(c) != 'Mn'\n",
        "        and c in all_letters\n",
        "    )\n",
        "\n",
        "# One-hot vector for category\n",
        "def categoryTensor(category):\n",
        "    li = all_categories.index(category)\n",
        "    tensor = torch.zeros(1, n_categories)\n",
        "    tensor[0][li] = 1\n",
        "    return tensor\n",
        "\n",
        "# One-hot matrix of first to last letters (not including EOS) for input\n",
        "def inputTensor(line):\n",
        "    tensor = torch.zeros(len(line), 1, n_letters)\n",
        "    for li in range(len(line)):\n",
        "        letter = line[li]\n",
        "        tensor[li][0][all_letters.find(letter)] = 1\n",
        "    return tensor\n",
        "\n",
        "# LongTensor of second letter to end (EOS) for target\n",
        "def targetTensor(line):\n",
        "    letter_indexes = [all_letters.find(line[li]) for li in range(1, len(line))]\n",
        "    letter_indexes.append(n_letters - 1) # EOS\n",
        "    return torch.LongTensor(letter_indexes)\n",
        "\n",
        "\n",
        "class RNN(nn.Module):\n",
        "    def __init__(self, input_size, hidden_size, output_size):\n",
        "        super(RNN, self).__init__()\n",
        "        self.hidden_size = hidden_size\n",
        "\n",
        "        self.i2h = nn.Linear(n_categories + input_size + hidden_size, hidden_size)\n",
        "        self.i2o = nn.Linear(n_categories + input_size + hidden_size, output_size)\n",
        "        self.o2o = nn.Linear(hidden_size + output_size, output_size)\n",
        "        self.dropout = nn.Dropout(0.1)\n",
        "        self.softmax = nn.LogSoftmax(dim=1)\n",
        "\n",
        "    def forward(self, category, input, hidden):\n",
        "        input_combined = torch.cat((category, input, hidden), 1)\n",
        "        hidden = self.i2h(input_combined)\n",
        "        output = self.i2o(input_combined)\n",
        "        output_combined = torch.cat((hidden, output), 1)\n",
        "        output = self.o2o(output_combined)\n",
        "        output = self.dropout(output)\n",
        "        output = self.softmax(output)\n",
        "        return output, hidden\n",
        "\n",
        "    def initHidden(self):\n",
        "        return torch.zeros(1, self.hidden_size, device='cuda')\n",
        "\n",
        "def train(category_tensor, input_line_tensor, target_line_tensor, optimizer):\n",
        "    target_line_tensor.unsqueeze_(-1)\n",
        "    hidden = rnn.initHidden()\n",
        "\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "\n",
        "    loss = 0\n",
        "\n",
        "    for i in range(input_line_tensor.size(0)):\n",
        "        output, hidden = rnn(category_tensor, input_line_tensor[i], hidden)\n",
        "        l = criterion(output, target_line_tensor[i])\n",
        "        loss += l\n",
        "\n",
        "    loss.backward()\n",
        "    nn.utils.clip_grad_norm_(rnn.parameters(), max_norm=2.0, norm_type=2)\n",
        "    optimizer.step()\n",
        "\n",
        "    loss_val = loss.detach().cpu().numpy() / input_line_tensor.size(0)\n",
        "\n",
        "    return output, loss_val\n",
        "\n",
        "def timeSince(since):\n",
        "    now = time.time()\n",
        "    s = now - since\n",
        "    m = math.floor(s / 60)\n",
        "    s -= m * 60\n",
        "    return '%dm %ds' % (m, s)\n",
        "\n",
        "def sample(category, start_letter='A'):\n",
        "    with torch.no_grad():  # no need to track history in sampling\n",
        "        category_tensor = categoryTensor(category)\n",
        "        input = inputTensor(start_letter)\n",
        "        hidden = rnn.initHidden()\n",
        "        hidden = hidden.to('cpu')\n",
        "\n",
        "        output_name = start_letter\n",
        "\n",
        "        for i in range(max_length):\n",
        "            output, hidden = rnn(category_tensor, input[0], hidden)\n",
        "            topv, topi = output.topk(1)\n",
        "            topi = topi[0][0]\n",
        "            if topi == n_letters - 1:\n",
        "                break\n",
        "            else:\n",
        "                letter = all_letters[topi]\n",
        "                output_name += letter\n",
        "            input = inputTensor(letter)\n",
        "\n",
        "        return output_name\n",
        "\n",
        "def samples(category, start_letters='ABC'):\n",
        "    for start_letter in start_letters:\n",
        "        print(sample(category, start_letter))\n",
        "\n",
        "\n"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LW9ZbqM-jG4f"
      },
      "source": [
        "\n",
        "all_letters = string.ascii_letters + \" .,;'-\"\n",
        "n_letters = len(all_letters) + 1  # Plus EOS marker\n",
        "\n",
        "list_names = ['Arabic', 'Chinese', 'Czech', 'Dutch',\n",
        "              'English', 'French', 'German', 'Greek',\n",
        "              'Irish', 'Italian', 'Japanese', 'Korean',\n",
        "              'Polish', 'Portuguese', 'Russian', 'Scottish',\n",
        "              'Spanish', 'Vietnamese']\n",
        "\n"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CoSd4dFUjILE"
      },
      "source": [
        "\n",
        "data = []\n",
        "for ethnicity in list_names:\n",
        "    url = \"https://github.com/cmlakhan/ml_code/raw/master/sequential_modeling/data/names/{}.txt\".format(ethnicity)\n",
        "    file = urllib.request.urlopen(url)\n",
        "\n",
        "    for line in file:\n",
        "        data.append({'name': line.decode('utf-8'), 'ethnicity':ethnicity})\n",
        "\n",
        "\n",
        "names_df = pd.DataFrame(data)\n",
        "all_categories = names_df.ethnicity.unique().tolist()\n",
        "n_categories = len(all_categories)\n",
        "\n",
        "\n",
        "names_df[['name_ascii']] = names_df.name.apply(lambda x: unicodeToAscii(x))\n"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 204
        },
        "id": "T0yS5JPEjJ1L",
        "outputId": "c0577a66-a4a9-45c0-fd78-6e7f2550f349"
      },
      "source": [
        "names_df.head()\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "<div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>name</th>\n",
              "      <th>ethnicity</th>\n",
              "      <th>name_ascii</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Khoury\\n</td>\n",
              "      <td>Arabic</td>\n",
              "      <td>Khoury</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Nahas\\n</td>\n",
              "      <td>Arabic</td>\n",
              "      <td>Nahas</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Daher\\n</td>\n",
              "      <td>Arabic</td>\n",
              "      <td>Daher</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Gerges\\n</td>\n",
              "      <td>Arabic</td>\n",
              "      <td>Gerges</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>Nazari\\n</td>\n",
              "      <td>Arabic</td>\n",
              "      <td>Nazari</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "       name ethnicity name_ascii\n",
              "0  Khoury\\n    Arabic     Khoury\n",
              "1   Nahas\\n    Arabic      Nahas\n",
              "2   Daher\\n    Arabic      Daher\n",
              "3  Gerges\\n    Arabic     Gerges\n",
              "4  Nazari\\n    Arabic     Nazari"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "67gECA3ejK-5"
      },
      "source": [
        "\n",
        "\n",
        "rnn = RNN(n_letters, 512, n_letters)\n",
        "criterion = nn.NLLLoss()\n",
        "learning_rate = 0.0005\n",
        "frac = 1.00\n",
        "num_epochs = 2\n",
        "\n",
        "print_every = 1000\n",
        "plot_every = 200\n",
        "all_losses = []\n",
        "total_loss = 0 # Reset every plot_every iters\n",
        "\n",
        "\n",
        "start = time.time()\n",
        "device = 'cuda'\n",
        "\n",
        "rnn.to(device)\n",
        "\n",
        "optimizer = torch.optim.AdamW(rnn.parameters(), lr=learning_rate, weight_decay=0.00001, amsgrad=False)\n"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "en7gWRV8jqHB",
        "outputId": "f3be5029-9c70-45a1-9cc0-c8c3a0e34025"
      },
      "source": [
        "\n",
        "iter = 0\n",
        "for i in range(1,num_epochs+1):\n",
        "    print('Epoch #{}'.format(i))\n",
        "    subset_df = names_df.sample(frac=frac)\n",
        "    len_df = subset_df.shape[0]\n",
        "    for index,row in subset_df.iterrows():\n",
        "        iter += 1\n",
        "        category_tensor = categoryTensor(row.ethnicity)\n",
        "        input_line_tensor = inputTensor(row.name_ascii)\n",
        "        target_line_tensor = targetTensor(row.name_ascii)\n",
        "        category_tensor = category_tensor.to(device)\n",
        "        input_line_tensor = input_line_tensor.to(device)\n",
        "        target_line_tensor = target_line_tensor.to(device)\n",
        "        output, loss = train(category_tensor, input_line_tensor, target_line_tensor, optimizer)\n",
        "        total_loss += loss\n",
        "        if iter % print_every == 0:\n",
        "            print('%s (%d %d%%) %.4f' % (timeSince(start), iter, iter / len_df * 100, loss))\n",
        "        if iter % plot_every == 0:\n",
        "            all_losses.append(total_loss / plot_every)\n",
        "            total_loss = 0\n",
        "\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch #1\n",
            "0m 4s (1000 4%) 2.9466\n",
            "0m 9s (2000 9%) 2.5848\n",
            "0m 14s (3000 14%) 2.3064\n",
            "0m 19s (4000 19%) 2.0766\n",
            "0m 24s (5000 24%) 2.8925\n",
            "0m 29s (6000 29%) 2.6664\n",
            "0m 34s (7000 34%) 2.1562\n",
            "0m 39s (8000 39%) 2.2858\n",
            "0m 44s (9000 44%) 1.5953\n",
            "0m 49s (10000 49%) 2.0796\n",
            "0m 53s (11000 54%) 2.6860\n",
            "0m 58s (12000 59%) 2.2077\n",
            "1m 3s (13000 64%) 2.7254\n",
            "1m 8s (14000 69%) 1.6346\n",
            "1m 13s (15000 74%) 2.7721\n",
            "1m 18s (16000 79%) 3.6822\n",
            "1m 23s (17000 84%) 1.5948\n",
            "1m 27s (18000 89%) 1.8411\n",
            "1m 32s (19000 94%) 3.2409\n",
            "1m 37s (20000 99%) 2.7277\n",
            "Epoch #2\n",
            "1m 42s (21000 104%) 2.0885\n",
            "1m 47s (22000 109%) 2.6189\n",
            "1m 52s (23000 114%) 3.1790\n",
            "1m 57s (24000 119%) 2.4154\n",
            "2m 1s (25000 124%) 2.9946\n",
            "2m 6s (26000 129%) 2.0383\n",
            "2m 11s (27000 134%) 3.1186\n",
            "2m 16s (28000 139%) 2.0506\n",
            "2m 21s (29000 144%) 2.0248\n",
            "2m 26s (30000 149%) 2.9264\n",
            "2m 31s (31000 154%) 2.4684\n",
            "2m 35s (32000 159%) 2.2894\n",
            "2m 40s (33000 164%) 2.3709\n",
            "2m 45s (34000 169%) 2.6900\n",
            "2m 50s (35000 174%) 2.6293\n",
            "2m 55s (36000 179%) 1.7102\n",
            "3m 0s (37000 184%) 2.0464\n",
            "3m 5s (38000 189%) 2.1455\n",
            "3m 10s (39000 194%) 2.8950\n",
            "3m 15s (40000 199%) 1.7416\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "3OHosmvVjs55",
        "outputId": "68be829a-3c79-49ab-c10f-84a29876eb89"
      },
      "source": [
        "\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure()\n",
        "plt.plot(all_losses)\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7fc570e20210>]"
            ]
          },
          "metadata": {},
          "execution_count": 18
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yw0J2oCmkmQn",
        "outputId": "296a3aec-008c-4144-83dc-13660138ff44"
      },
      "source": [
        "\n",
        "max_length = 20\n",
        "rnn.to('cpu')\n",
        "samples('Arabic', 'RUS')\n",
        "\n"
      ],
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Raham\n",
            "Usham\n",
            "Shama\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DILh9r7wknY3"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}