generate_name.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abhi\n"
     ]
    }
   ],
   "source": [
    "import glob\n",
    "import unicodedata\n",
    "import string\n",
    "\n",
    "all_letters = string.ascii_letters+\",.;'-\"\n",
    "n_letters = len(all_letters)\n",
    "EOS = n_letters-1\n",
    "\n",
    "# turn the unicode string to plain ASCII \n",
    "def unicode_to_ascii(s):\n",
    "    return ''.join(c for c in unicodedata.normalize('NFD',s) if unicodedata.category(c)!='Mn' and c in all_letters)\n",
    "\n",
    "print(unicode_to_ascii('~`Abhi'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Category: 18 ['Arabic', 'Chinese', 'Czech', 'Dutch', 'English', 'French', 'German', 'Greek', 'Irish', 'Italian', 'Japanese', 'Korean', 'Polish', 'Portuguese', 'Russian', 'Scottish', 'Spanish', 'Vietnamese']\n"
     ]
    }
   ],
   "source": [
    "# read a file and split it into lines\n",
    "def read_lines(filename):\n",
    "    lines = open(filename,encoding='utf8').read().strip().split('\\n')\n",
    "    return [unicode_to_ascii(line) for line in lines]\n",
    "\n",
    "# build the category lines dictonary, a list of lines per category\n",
    "category_lines = {}\n",
    "all_category = []\n",
    "\n",
    "for filename in glob.glob(r'C:\\Users\\Syahrir Ridha\\pytorch\\recurrent\\data\\data\\names\\*.txt'):\n",
    "    category = filename.split('\\\\')[-1].split('.')[0]\n",
    "    all_category.append(category)\n",
    "    lines = read_lines(filename)\n",
    "    category_lines[category] = lines\n",
    "    \n",
    "n_category = len(all_category)\n",
    "print('Category: {} {}'.format(n_category, all_category))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Khoury', 'Nahas', 'Daher', 'Gerges', 'Nazari']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "category_lines['Arabic'][:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "\n",
    "class RNN(nn.Module):\n",
    "    def __init__(self,input_size, hidden_size,out_size, n_layer):\n",
    "        super(RNN,self).__init__()\n",
    "        self.input_size, self.hidden_size, self.out_size, self.layers = input_size, hidden_size,out_size, n_layer\n",
    "        \n",
    "        ## define different layers\n",
    "        self.i2h = nn.Linear(n_category+input_size+hidden_size,hidden_size)\n",
    "        self.i2o = nn.Linear(n_category+input_size+hidden_size,out_size)\n",
    "        self.o2o = nn.Linear(hidden_size+out_size,out_size)\n",
    "        self.softmax = nn.LogSoftmax(dim=1)\n",
    "        \n",
    "    def forward(self,x,category,hidden):\n",
    "        input_combined = torch.cat((category,x,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.softmax(output)\n",
    "        return output, hidden\n",
    "    \n",
    "    def init_hidden(self):\n",
    "        return Variable(torch.zeros(1,self.hidden_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create random training function\n",
    "import random\n",
    "\n",
    "def random_train():\n",
    "    category = random.choice(all_category)\n",
    "    line = random.choice(category_lines[category])\n",
    "    return category, line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 18])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.zeros(1,n_category).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# one hot vector for category\n",
    "def make_category_input(category):\n",
    "    li = all_category.index(category)\n",
    "    tensor = torch.zeros(1,n_category)\n",
    "    tensor[0][li] = 1\n",
    "    return tensor\n",
    "\n",
    "# one hot matrix for first to last letters (not including EOS) for input\n",
    "def make_char_input(chars):\n",
    "    tensor = torch.zeros(len(chars),n_letters)\n",
    "    for ci in range(len(chars)):\n",
    "        char = chars[ci]\n",
    "        tensor[ci][all_letters.find(char)] =1\n",
    "    tensor = tensor.view(-1,1,n_letters)\n",
    "    return Variable(tensor)\n",
    "\n",
    "# log tensor of second letter to end (EOS) for target\n",
    "def make_target(line):\n",
    "    letter_indexes = [all_letters.find(line[i]) for i in range(1,len(line))]\n",
    "    letter_indexes.append(n_letters-1) # EOS\n",
    "    tensor = torch.LongTensor(letter_indexes)\n",
    "    return tensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_training_set():\n",
    "    category, line = random_train()\n",
    "    category_input = make_category_input(category)\n",
    "    line_input = make_char_input(line)\n",
    "    line_target = make_target(line)\n",
    "    return category_input, line_input, line_target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(category_tensor,input_line_tensor,target_line_tensor):\n",
    "    hidden = rnn.init_hidden()\n",
    "    optimizer.zero_grad()\n",
    "    target_line_tensor.unsqueeze_(-1)\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",
    "        loss += error(output,target_line_tensor[i])\n",
    "        \n",
    "        \n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    return output, loss.data/input_line_tensor.size()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import math\n",
    "\n",
    "def time_since(start):\n",
    "    now = time.time()\n",
    "    s = now - start\n",
    "    m = math.floor(s/60)\n",
    "    s -= m*60\n",
    "    return '%dm %ds'%(m,s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0m 30s (5000 5%) 2.0803\n",
      "1m 4s (10000 10%) 2.2860\n",
      "1m 36s (15000 15%) 2.5920\n",
      "2m 8s (20000 20%) 1.8771\n",
      "2m 40s (25000 25%) 2.7390\n",
      "3m 13s (30000 30%) 2.6954\n",
      "3m 45s (35000 35%) 2.3546\n",
      "4m 17s (40000 40%) 0.9341\n",
      "4m 49s (45000 45%) 1.7235\n",
      "5m 21s (50000 50%) 1.4522\n",
      "5m 51s (55000 55%) 0.8464\n",
      "6m 22s (60000 60%) 2.8223\n",
      "6m 54s (65000 65%) 1.4396\n",
      "7m 25s (70000 70%) 2.7842\n",
      "7m 57s (75000 75%) 2.1764\n",
      "8m 29s (80000 80%) 1.5354\n",
      "9m 1s (85000 85%) 1.7046\n",
      "9m 33s (90000 90%) 1.7686\n",
      "10m 6s (95000 95%) 1.7524\n",
      "10m 38s (100000 100%) 1.5591\n"
     ]
    }
   ],
   "source": [
    "n_epochs = 100000\n",
    "print_every = 5000\n",
    "plot_every = 500\n",
    "all_losses = []\n",
    "loss_avg = 0\n",
    "learning_rate = 0.0005\n",
    "\n",
    "# start model\n",
    "rnn = RNN(n_letters,128,n_letters,1)\n",
    "optimizer = torch.optim.Adam(rnn.parameters(),lr=learning_rate)\n",
    "error = nn.NLLLoss()\n",
    "\n",
    "start_time = time.time()\n",
    "\n",
    "for epoch in range(1,n_epochs+1):\n",
    "    output,loss = train(*random_training_set())\n",
    "    loss_avg += loss\n",
    "    \n",
    "    if epoch%print_every ==0:\n",
    "        print('%s (%d %d%%) %.4f'%(time_since(start_time),epoch,epoch/n_epochs*100,loss))\n",
    "        \n",
    "    if epoch % plot_every==0:\n",
    "        all_losses.append(loss_avg/plot_every)\n",
    "        loss_avg =0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2135f730508>]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(all_losses)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "max_length = 20\n",
    "\n",
    "# generate given category and starting letter\n",
    "def generate_name(category,start_char='A',temp=0.5):\n",
    "    category_input = make_category_input(category)\n",
    "    chars_input = make_char_input(start_char)\n",
    "    hidden = rnn.init_hidden()\n",
    "    \n",
    "    output_str = start_char\n",
    "    \n",
    "    for i in range(max_length):\n",
    "        output, hidden = rnn(category_input,chars_input[0],hidden)\n",
    "        \n",
    "        # sample as a multinomial distribution\n",
    "        output_dist = output.data.view(-1).div(temp).exp()\n",
    "        top_i = torch.multinomial(output_dist,1)[0]\n",
    "        \n",
    "        # stop at EOS\n",
    "        if top_i == EOS:\n",
    "            break\n",
    "        else:\n",
    "            char = all_letters[top_i]\n",
    "            output_str += char\n",
    "            chars_input = make_char_input(char)\n",
    "            \n",
    "    return output_str\n",
    "\n",
    "# get multiple samples from one category and multiple starting letters\n",
    "def generate(category,start_chars='ABC'):\n",
    "    for start_char in start_chars:\n",
    "        print(generate_name(category,start_char))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rosthin\n",
      "Urtskh\n",
      "Shankh\n"
     ]
    }
   ],
   "source": [
    "generate('Russian','RUS')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Malah\n",
      "Abarg\n",
      "Dase\n"
     ]
    }
   ],
   "source": [
    "generate('Arabic','MAD')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}