ru_names_generator.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "67c280da",
   "metadata": {},
   "source": [
    "Small neural network which generates Russian names.\\\n",
    "Source of the names https://github.com/Raven-SL/ru-pnames-list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "af98cbcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt # for making figures\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8ab3165e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1674\n",
      "15\n",
      "['Аарон', 'Аба', 'Аббас', 'Абд аль-Узза', 'Абдуллах', 'Абид', 'Аботур', 'Аввакум']\n"
     ]
    }
   ],
   "source": [
    "# read in all the words\n",
    "words = open('runames.txt', 'r').read().splitlines()\n",
    "print(len(words))\n",
    "print(max(len(w) for w in words))\n",
    "print(words[:8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "74b08a2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: ' ', 2: '-', 3: 'А', 4: 'Б', 5: 'В', 6: 'Г', 7: 'Д', 8: 'Е', 9: 'Ж', 10: 'З', 11: 'И', 12: 'Й', 13: 'К', 14: 'Л', 15: 'М', 16: 'Н', 17: 'О', 18: 'П', 19: 'Р', 20: 'С', 21: 'Т', 22: 'У', 23: 'Ф', 24: 'Х', 25: 'Ц', 26: 'Ч', 27: 'Ш', 28: 'Э', 29: 'Ю', 30: 'Я', 31: 'а', 32: 'б', 33: 'в', 34: 'г', 35: 'д', 36: 'е', 37: 'ж', 38: 'з', 39: 'и', 40: 'й', 41: 'к', 42: 'л', 43: 'м', 44: 'н', 45: 'о', 46: 'п', 47: 'р', 48: 'с', 49: 'т', 50: 'у', 51: 'ф', 52: 'х', 53: 'ц', 54: 'ч', 55: 'ш', 56: 'ы', 57: 'ь', 58: 'э', 59: 'ю', 60: 'я', 61: 'ё', 0: '.'}\n",
      "62\n"
     ]
    }
   ],
   "source": [
    "# build the vocabulary of characters and mappings to/from integers\n",
    "chars = sorted(list(set(''.join(words))))\n",
    "stoi = {s:i+1 for i,s in enumerate(chars)}\n",
    "stoi['.'] = 0\n",
    "itos = {i:s for s,i in stoi.items()}\n",
    "vocab_size = len(itos)\n",
    "print(itos)\n",
    "print(vocab_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9f3be2d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# shuffle up the words\n",
    "import random\n",
    "random.seed(42)\n",
    "random.shuffle(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0feb4829",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([9975, 8]) torch.Size([9975])\n",
      "torch.Size([1245, 8]) torch.Size([1245])\n",
      "torch.Size([1213, 8]) torch.Size([1213])\n"
     ]
    }
   ],
   "source": [
    "# build the dataset\n",
    "block_size = 8 # context length: how many characters do we take to predict the next one?\n",
    "\n",
    "def build_dataset(words):  \n",
    "    X, Y = [], []\n",
    "  \n",
    "    for w in words:\n",
    "        context = [0] * block_size\n",
    "        for ch in w + '.':\n",
    "            ix = stoi[ch]\n",
    "            X.append(context)\n",
    "            Y.append(ix)\n",
    "            context = context[1:] + [ix] # crop and append\n",
    "\n",
    "    X = torch.tensor(X)\n",
    "    Y = torch.tensor(Y)\n",
    "    print(X.shape, Y.shape)\n",
    "    return X, Y\n",
    "\n",
    "n1 = int(0.8*len(words))\n",
    "n2 = int(0.9*len(words))\n",
    "Xtr,  Ytr  = build_dataset(words[:n1])     # 80%\n",
    "Xdev, Ydev = build_dataset(words[n1:n2])   # 10%\n",
    "Xte,  Yte  = build_dataset(words[n2:])     # 10%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b282bab8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "........ --> Ф\n",
      ".......Ф --> р\n",
      "......Фр --> и\n",
      ".....Фри --> д\n",
      "....Фрид --> р\n",
      "...Фридр --> и\n",
      "..Фридри --> х\n",
      ".Фридрих --> .\n",
      "........ --> Х\n",
      ".......Х --> и\n",
      "......Хи --> о\n",
      ".....Хио --> н\n",
      "....Хион --> и\n",
      "...Хиони --> я\n",
      "..Хиония --> .\n",
      "........ --> А\n",
      ".......А --> в\n",
      "......Ав --> д\n",
      ".....Авд --> е\n",
      "....Авде --> й\n"
     ]
    }
   ],
   "source": [
    "for x,y in zip(Xtr[:20], Ytr[:20]):\n",
    "    print(''.join(itos[ix.item()] for ix in x), '-->', itos[y.item()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cd726667",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Linear:\n",
    "    \n",
    "    def __init__(self, fan_in, fan_out, bias=True):\n",
    "        self.weight = torch.randn((fan_in, fan_out)) / fan_in**0.5 # note: kaiming init\n",
    "        self.bias = torch.zeros(fan_out) if bias else None\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        self.out = x @ self.weight\n",
    "        if self.bias is not None:\n",
    "            self.out += self.bias\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        return [self.weight] + ([] if self.bias is None else [self.bias])\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class BatchNorm1d:\n",
    "    \n",
    "    def __init__(self, dim, eps=1e-5, momentum=0.1):\n",
    "        self.eps = eps\n",
    "        self.momentum = momentum\n",
    "        self.training = True\n",
    "        # parameters (trained with backprop)\n",
    "        self.gamma = torch.ones(dim)\n",
    "        self.beta = torch.zeros(dim)\n",
    "        # buffers (trained with a running 'momentum update')\n",
    "        self.running_mean = torch.zeros(dim)\n",
    "        self.running_var = torch.ones(dim)\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        # calculate the forward pass\n",
    "        if self.training:\n",
    "            if x.ndim == 2:\n",
    "                dim = 0\n",
    "            elif x.ndim == 3:\n",
    "                dim = (0,1)\n",
    "            xmean = x.mean(dim, keepdim=True) # batch mean\n",
    "            xvar = x.var(dim, keepdim=True) # batch variance\n",
    "        else:\n",
    "            xmean = self.running_mean\n",
    "            xvar = self.running_var\n",
    "        xhat = (x - xmean) / torch.sqrt(xvar + self.eps) # normalize to unit variance\n",
    "        self.out = self.gamma * xhat + self.beta\n",
    "        # update the buffers\n",
    "        if self.training:\n",
    "            with torch.no_grad():\n",
    "                self.running_mean = (1 - self.momentum) * self.running_mean + self.momentum * xmean\n",
    "                self.running_var = (1 - self.momentum) * self.running_var + self.momentum * xvar\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        return [self.gamma, self.beta]\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class Tanh:\n",
    "    def __call__(self, x):\n",
    "        self.out = torch.tanh(x)\n",
    "        return self.out\n",
    "    def parameters(self):\n",
    "        return []\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class Embedding:\n",
    "    \n",
    "    def __init__(self, num_embeddings, embedding_dim):\n",
    "        self.weight = torch.randn((num_embeddings, embedding_dim))\n",
    "        \n",
    "    def __call__(self, IX):\n",
    "        self.out = self.weight[IX]\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        return [self.weight]\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class FlattenConsecutive:\n",
    "    \n",
    "    def __init__(self, n):\n",
    "        self.n = n\n",
    "        \n",
    "    def __call__(self, x):\n",
    "        B, T, C = x.shape\n",
    "        x = x.view(B, T//self.n, C*self.n)\n",
    "        if x.shape[1] == 1:\n",
    "            x = x.squeeze(1)\n",
    "        self.out = x\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        return []\n",
    "\n",
    "# -----------------------------------------------------------------------------------------------\n",
    "class Sequential:\n",
    "    \n",
    "    def __init__(self, layers):\n",
    "        self.layers = layers\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "        self.out = x\n",
    "        return self.out\n",
    "    \n",
    "    def parameters(self):\n",
    "        # get parameters of all layers and stretch them out into one list\n",
    "        return [p for layer in self.layers for p in layer.parameters()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bf2def79",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(42); # seed rng for reproducibility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "94efe3fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "81934\n"
     ]
    }
   ],
   "source": [
    "# hierarchical network\n",
    "n_embd = 24 # the dimensionality of the character embedding vectors\n",
    "n_hidden = 128 # the number of neurons in the hidden layer of the MLP\n",
    "model = Sequential([\n",
    "  Embedding(vocab_size, n_embd),\n",
    "  FlattenConsecutive(2), Linear(n_embd * 2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "  FlattenConsecutive(2), Linear(n_hidden*2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "  FlattenConsecutive(2), Linear(n_hidden*2, n_hidden, bias=False), BatchNorm1d(n_hidden), Tanh(),\n",
    "  Linear(n_hidden, vocab_size),\n",
    "])\n",
    "\n",
    "# parameter init\n",
    "with torch.no_grad():\n",
    "    model.layers[-1].weight *= 0.1 # last layer make less confident\n",
    "\n",
    "parameters = model.parameters()\n",
    "print(sum(p.nelement() for p in parameters)) # number of parameters in total\n",
    "for p in parameters:\n",
    "    p.requires_grad = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "69618180",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([4, 8])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "tensor([[ 0,  0,  0,  0,  0,  0,  8, 33],\n",
       "        [ 0,  0,  0,  0,  0,  0,  0, 18],\n",
       "        [ 0,  0,  0,  0,  0,  0,  0,  3],\n",
       "        [ 0,  0,  0,  0,  0, 23, 36, 45]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ix = torch.randint(0, Xtr.shape[0], (4,))\n",
    "Xb, Yb = Xtr[ix], Ytr[ix] # batch X,Y\n",
    "logits = model(Xb)\n",
    "print (Xb.shape)\n",
    "Xb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "54b52120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Embedding : (4, 8, 24)\n",
      "FlattenConsecutive : (4, 4, 48)\n",
      "Linear : (4, 4, 128)\n",
      "BatchNorm1d : (4, 4, 128)\n",
      "Tanh : (4, 4, 128)\n",
      "FlattenConsecutive : (4, 2, 256)\n",
      "Linear : (4, 2, 128)\n",
      "BatchNorm1d : (4, 2, 128)\n",
      "Tanh : (4, 2, 128)\n",
      "FlattenConsecutive : (4, 256)\n",
      "Linear : (4, 128)\n",
      "BatchNorm1d : (4, 128)\n",
      "Tanh : (4, 128)\n",
      "Linear : (4, 62)\n"
     ]
    }
   ],
   "source": [
    "for layer in model.layers:\n",
    "    print (layer.__class__.__name__, \":\", tuple(layer.out.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0fc98e14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0/   2000: 4.1234\n",
      "    100/   2000: 2.5594\n",
      "    200/   2000: 2.3083\n",
      "    300/   2000: 2.5153\n",
      "    400/   2000: 2.3035\n",
      "    500/   2000: 1.8289\n",
      "    600/   2000: 2.1471\n",
      "    700/   2000: 2.1339\n",
      "    800/   2000: 2.0696\n",
      "    900/   2000: 2.1902\n",
      "   1000/   2000: 2.0926\n",
      "   1100/   2000: 1.8077\n",
      "   1200/   2000: 2.1084\n",
      "   1300/   2000: 2.3703\n",
      "   1400/   2000: 2.0186\n",
      "   1500/   2000: 1.9258\n",
      "   1600/   2000: 1.8307\n",
      "   1700/   2000: 2.2470\n",
      "   1800/   2000: 2.1943\n",
      "   1900/   2000: 2.2654\n"
     ]
    }
   ],
   "source": [
    "# same optimization as last time\n",
    "max_steps = 2000\n",
    "batch_size = 32\n",
    "lossi = []\n",
    "loss_val = []\n",
    "for i in range(max_steps):\n",
    "    \n",
    "    # minibatch construct\n",
    "    ix = torch.randint(0, Xtr.shape[0], (batch_size,))\n",
    "    Xb, Yb = Xtr[ix], Ytr[ix] # batch X,Y\n",
    "    \n",
    "    # forward pass\n",
    "    logits = model(Xb)\n",
    "    loss = F.cross_entropy(logits, Yb) # loss function\n",
    "    \n",
    "    # backward pass\n",
    "    for p in parameters:\n",
    "        p.grad = None\n",
    "    loss.backward()\n",
    "    \n",
    "    # update: simple SGD\n",
    "    lr = 0.1 if i < 150000 else 0.01 # step learning rate decay\n",
    "    for p in parameters:\n",
    "        p.data += -lr * p.grad\n",
    "    # track stats\n",
    "    if i % 100 == 0: # print every once in a while\n",
    "        print(f'{i:7d}/{max_steps:7d}: {loss.item():.4f}')\n",
    "        logits_val = model(Xdev)\n",
    "        loss_val_singl = F.cross_entropy(logits_val, Ydev)\n",
    "        loss_val.append(loss_val_singl.log10().item())\n",
    "    lossi.append(loss.log10().item())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cfc79c37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f53d8c3cbe0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(torch.tensor(lossi).view(-1, 100).mean(1), label = \"loss training\")\n",
    "plt.plot(loss_val, label = \"loss validation\")\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "17564a35",
   "metadata": {},
   "outputs": [],
   "source": [
    "# put layers into eval mode (needed for batchnorm especially)\n",
    "for layer in model.layers:\n",
    "    layer.training = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2639dab4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train 1.8754817247390747\n",
      "val 2.332451343536377\n"
     ]
    }
   ],
   "source": [
    "# evaluate the loss\n",
    "@torch.no_grad() # this decorator disables gradient tracking inside pytorch\n",
    "def split_loss(split):\n",
    "    x,y = {\n",
    "    'train': (Xtr, Ytr),\n",
    "    'val': (Xdev, Ydev),\n",
    "    'test': (Xte, Yte),\n",
    "    }[split]\n",
    "    logits = model(x)\n",
    "    loss = F.cross_entropy(logits, y)\n",
    "    print(split, loss.item())\n",
    "\n",
    "split_loss('train')\n",
    "split_loss('val')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "d26e67f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сцлав               \tFalse\n",
      "Пургудий            \tFalse\n",
      "Гальмира            \tFalse\n",
      "Альгрста            \tFalse\n",
      "Авелла              \tFalse\n",
      "Савира              \tFalse\n",
      "Вальдий             \tFalse\n",
      "ЭрриконаЮа          \tFalse\n",
      "Лайнент             \tFalse\n",
      "Раильдера           \tFalse\n",
      "йлавиел             \tFalse\n",
      "Картандта           \tFalse\n",
      "Антина              \tFalse\n",
      "Орика               \tFalse\n",
      "Дисламё             \tFalse\n",
      "Агельгеда           \tFalse\n",
      "Катилпнерьян        \tFalse\n",
      "Юсия                \tFalse\n",
      "Натамира            \tFalse\n",
      "Феонила             \tFalse\n",
      "Руна                \tFalse\n",
      "Артун               \tFalse\n",
      "Клесса              \tFalse\n",
      "Ерислав             \tFalse\n",
      "Генасия             \tFalse\n",
      "Лузьо               \tFalse\n",
      "Асана               \tFalse\n",
      "Барислав            \tFalse\n",
      "Алина               \tTrue\n",
      "Маркур              \tFalse\n",
      "Зинен               \tFalse\n",
      "Даина               \tFalse\n",
      "Фульверия           \tFalse\n",
      "Берксуна            \tFalse\n",
      "Агарь               \tTrue\n",
      "Фльда               \tFalse\n",
      "Волинан             \tFalse\n",
      "Иуат                \tFalse\n",
      "Кало                \tFalse\n",
      "Ниса                \tFalse\n",
      "УлсакликР           \tFalse\n",
      "Диуида              \tFalse\n",
      "Виль                \tFalse\n",
      "Юлия                \tTrue\n",
      "Иасания             \tFalse\n",
      "Гальврук            \tFalse\n",
      "Латама              \tFalse\n",
      "Леонила             \tTrue\n",
      "Тондр               \tFalse\n",
      "Милипа              \tFalse\n"
     ]
    }
   ],
   "source": [
    "# sample from the model\n",
    "for _ in range(50):\n",
    "\n",
    "    out = []\n",
    "    context = [0] * block_size # initialize with all ...\n",
    "    while True:\n",
    "        # forward pass the neural net\n",
    "        logits = model(torch.tensor([context]))\n",
    "        probs = F.softmax(logits, dim=1)\n",
    "        # sample from the distribution\n",
    "        ix = torch.multinomial(probs, num_samples=1).item()\n",
    "        # shift the context window and track the samples\n",
    "        context = context[1:] + [ix]\n",
    "        # if we sample the special '.' token, break\n",
    "        if ix == 0:\n",
    "            break\n",
    "        out.append(ix)\n",
    "\n",
    "    strname = ''.join(itos[i] for i in out) \n",
    "    print (strname + (' '*(20-len(strname))) + \"\\t\" + str(strname in words)) #prints true if name were in dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f35f3570",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}