rnn_lm_gpu_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load les données\n",
    "\n",
    "fichier = open('villes.txt')\n",
    "donnees = fichier.read()\n",
    "villes = donnees.replace('\\n', ',').split(',')\n",
    "villes = [ville for ville in villes if len(ville) > 2]\n",
    "villes = sorted(villes, key=len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# création du vocabulaire\n",
    "\n",
    "vocabulaire = sorted(list(set(''.join(villes))))\n",
    "vocabulaire = [\"<pad>\", \"<SOS>\", \"<EOS>\"] + vocabulaire\n",
    "\n",
    "# pour convertir char <-> int\n",
    "char_to_int = {}\n",
    "int_to_char = {}\n",
    "\n",
    "for (c, i) in zip(vocabulaire, range(len(vocabulaire))):\n",
    "    char_to_int[c] = i\n",
    "    int_to_char[i] = c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_sequences = len(villes)\n",
    "max_len = max([len(ville) for ville in villes]) + 2 # account for <SOS> and <EOS>, which are appened at the beg. and end of each seq\n",
    "\n",
    "X = torch.zeros((num_sequences, max_len), dtype=torch.int32)\n",
    "\n",
    "for i in range(num_sequences):\n",
    "    X[i] = torch.tensor([char_to_int['<SOS>']] + [char_to_int[c] for c in villes[i]] + [char_to_int['<EOS>']] + [char_to_int['<pad>']] * (max_len - len(villes[i]) - 2))\n",
    "\n",
    "n_split = int(0.9*X.shape[0])\n",
    "\n",
    "idx_permut = torch.randperm(X.shape[0])\n",
    "idx_train, _ = torch.sort(idx_permut[:n_split])\n",
    "idx_val, _ = torch.sort(idx_permut[n_split:])\n",
    "\n",
    "X_train = X[idx_train]\n",
    "X_val = X[idx_val]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_batch(split, batch_size):\n",
    "    # returns a batch, according to the data pipeline written in the W&B report\n",
    "    data = X_train if split == 'train' else X_val\n",
    "\n",
    "    idx_seed = torch.randint(high=data.shape[0], size=(1,), dtype=torch.int32).item() #sample la ligne seed autour de laquelle on va piocher les exemples\n",
    "\n",
    "    if split == 'train':\n",
    "        idx = torch.randint(low = max(0, idx_seed - 4 * batch_size), high = min(data.shape[0], idx_seed + 4 * batch_size), size=(batch_size,), dtype=torch.int32) #samples les indices du batch à produire\n",
    "        \n",
    "    else:\n",
    "        start = max(0, idx_seed-batch_size/2)\n",
    "        end =  min(data.shape[0]-1, idx_seed+batch_size/2)\n",
    "\n",
    "        if end-start != batch_size:\n",
    "            if start == 0:\n",
    "                end = end - (idx_seed-batch_size/2 - start)\n",
    "            else:\n",
    "                start = start - (idx_seed+batch_size/2 - end)\n",
    "\n",
    "        start, end = int(start), int(end)\n",
    "\n",
    "        idx = torch.arange(start=start, end=end, dtype=torch.int64)\n",
    "        \n",
    "    #pq 4 ? bon compromis entre assez large pour pas bcp de répétitions, assez petit pour pas bcp de padding (cf data.ipynb)\n",
    "    #en moyenne sur un batch, 6.7 d'écart en max_len et min_len (donc en moyenne pour une séq., 3,3 de padding) (ça fait bcp finalement? a comparer devant la longueur d'un mot) et max_len 17.8\n",
    "    #longueur moyenne d'une séq. : 11.6. donc en moyenne pour une séq., on rajoute 28% de compute inutile...\n",
    "    #on aura forcement pas mal de padding sur le val car dataset comparable devant 4*batch_size\n",
    "\n",
    "    #pour 2, on aura 3.5 d'écart, donc 1.7 de padding\n",
    "    # donc 14% de compute inutile par mot\n",
    "\n",
    "    #pour 2, on a 12% des exemples qui sont des répétitions (122 pour un batch de 1024, en moyenne)\n",
    "    #pour 4, seulement 6% (67 exemples)\n",
    "\n",
    "    #pour batch_size=512\n",
    "    #pour 2, 5% de répétitions, 1.8 de disp. donc 0.9 de padding (soit 7% de compute inutile par séq.)\n",
    "    #pour 4, 3% de répétitions, 3.5 de disp. donc 1.7 de padding (soit 14% de compute inutile par séq.)\n",
    "\n",
    "    #pour privilégier des données iid, je choisi de partir sur 4 (pour avoir des batch diversifiés, au détriment d'un peu de compute inutile)\n",
    "    #voir considérer plus ?\n",
    "    \n",
    "    #pour le val. set, 4 semble bcp trop\n",
    "    #pour 4, 12% de répétitions, 15 de disp. donc 7 de padding (soit plus de 50% de compute lost)\n",
    "    #c'est dommage, vu qu'avoir des batchs diversifiés n'a aucun interet pour le calcul du loss, donc on ne fait que perdre du compute\n",
    "    #mais le pb avec 1 (par exemple) c'est qu'on a enormément de répétitions (25%) au sein d'un batch... donc estimation du cout totalement erronée\n",
    "    #je choisis d'adopter une stratégie un peu différente: sample idx_seed, et on prends tous les index entre idx_seed-batch_size/2 et idx_seed+batch_size/2\n",
    "\n",
    "    idx_sorted, _ = torch.sort(idx) #on les ordonne pour recuperer facilement la longueur de la plus grande seq. du batch\n",
    "\n",
    "    X_batch = data[idx_sorted] #on extrait la matrice qui va produire Xb et Yb\n",
    "\n",
    "    max_len_batch = torch.sum(torch.ne(X_batch[-1], char_to_int['<pad>'])) #longueur de la plus grande seq. du batch : torch.ne(X_batch[-1], 0) crée une matrice masque, avec True si diff de 0, False si egal a 0\n",
    "\n",
    "    Xb = X_batch[:, :max_len_batch-1] #on selectionne que jusqu'a la len max - 1 (<EOS> du plus long inutile) (le reste n'est que padding)\n",
    "    Yb = X_batch[:, 1:max_len_batch] #meme que Xb, mais décalé de 1 (avec le <EOS> mais sans le <SOS>)\n",
    "\n",
    "    #Xb[Xb == 1] = -1 #on remplace le <EOS> par du padding (totalement optionnel)\n",
    "\n",
    "    Xb = Xb.pin_memory().to('cuda', non_blocking=True)\n",
    "    Yb = Yb.type(torch.LongTensor).pin_memory().to('cuda', non_blocking=True)\n",
    "    #Yb = Yb.type(torch.LongTensor)\n",
    "\n",
    "    return Xb, Yb\n",
    "\n",
    "#todo: mettre les shapes a cote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_model = 64\n",
    "embed_dim = 32"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RecurrentUnit(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc = nn.Linear(embed_dim+d_model, d_model)\n",
    "\n",
    "    def forward(self, x, h_prev):\n",
    "        h = self.fc(torch.cat([x, h_prev], dim=1))\n",
    "        h = F.tanh(h)\n",
    "        return h\n",
    "    \n",
    "class GatedRecurrentUnit(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.fc_z = nn.Linear(embed_dim+d_model, d_model)\n",
    "        self.fc_r = nn.Linear(embed_dim+d_model, d_model)\n",
    "        self.fc_h_hat = nn.Linear(embed_dim+d_model, d_model)\n",
    "\n",
    "    def forward(self, x, h_prev):\n",
    "        z = F.sigmoid(self.fc_z(torch.cat([x, h_prev], dim=1)))\n",
    "        r = F.sigmoid(self.fc_r(torch.cat([x, h_prev], dim=1)))\n",
    "        h_hat = F.tanh(self.fc_h_hat(torch.cat([x, r * h_prev], dim=1))) # * = torch.mul\n",
    "        h = (1 - z) * h_prev + z * h_hat\n",
    "\n",
    "        #r permet de remove/reset des infos/channels de h_prev\n",
    "        #on utilise alors ce hidden state comme candidat pour le suivant, h_hat\n",
    "        #z permet de controler quels channels (de l'hidden state) update\n",
    "\n",
    "        return h\n",
    "\n",
    "class RNN_LM(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        self.h0 = nn.Parameter(torch.zeros(1, d_model))\n",
    "        self.embed = nn.Embedding(len(vocabulaire), embed_dim, padding_idx=0)\n",
    "        self.cell = RecurrentUnit()\n",
    "        #self.cell = GatedRecurrentUnit()\n",
    "        self.lm_head = nn.Linear(d_model, len(vocabulaire))\n",
    "\n",
    "    def forward(self, x, targets=None):\n",
    "        # x : (B, T)\n",
    "        # targets : (B, T)\n",
    "\n",
    "        B, T = x.size()\n",
    "\n",
    "        emb = self.embed(x) # (B, T, embed_dim)\n",
    "\n",
    "        H_prev = self.h0.expand((B, -1)) # (B, d_model)\n",
    "        hiddens = []\n",
    "        for t in range(T):\n",
    "            X_t = emb[:, t, :] #todo : remove last : # todo shape (B, embed_dim)\n",
    "            H_t = self.cell(X_t, H_prev) # (B, d_model)\n",
    "            H_prev = H_t\n",
    "            hiddens.append(H_t)\n",
    "\n",
    "        hidden = torch.stack(hiddens, 1) # (B, T, d_model)\n",
    "        logits = self.lm_head(hidden) # (B, T, vocab_size)\n",
    "\n",
    "        loss = None\n",
    "        if targets is not None:\n",
    "            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=0)\n",
    "        \n",
    "        return logits, loss\n",
    "    \n",
    "    def sample(self, prompt='', max_new_tokens=None):\n",
    "        init_len = len(prompt)+1\n",
    "\n",
    "        #convert prompt to (1, T) input tensor X\n",
    "        X = torch.zeros(size=(1, init_len), dtype=torch.int64, device=device) #<SOS>\n",
    "\n",
    "        X[0, 0] = 1 #<SOS>\n",
    "        for i, ch in enumerate(prompt):\n",
    "            X[0, i+1] = char_to_int[ch]\n",
    "\n",
    "        # forward is 2 fold : one when we feed in the prompt, one for autoregressive gen\n",
    "\n",
    "        #prompt feeding\n",
    "        h_prev = self.h0\n",
    "        emb = self.embed(X)\n",
    "        for t in range(init_len):\n",
    "            x_t = emb[:, t, :]\n",
    "            h_t = self.cell(x_t, h_prev)\n",
    "            h_prev = h_t\n",
    "            \n",
    "        #autoregressive gen\n",
    "        while True:\n",
    "            logits = self.lm_head(h_prev) # (1, vocab_size)\n",
    "            probs = F.softmax(logits, dim=1)\n",
    "\n",
    "            next_token = torch.multinomial(probs, num_samples=1, replacement=True).item()\n",
    "            next_char = int_to_char[next_token]\n",
    "\n",
    "            if next_char == '<EOS>':\n",
    "                break\n",
    "                \n",
    "            prompt += next_char\n",
    "\n",
    "            if len(prompt)-init_len+1 == max_new_tokens:\n",
    "                break\n",
    "\n",
    "            w_t = next_token #entry for next timestep\n",
    "            x_t = self.embed(torch.tensor(w_t, dtype=torch.int64, device=device)).view(1, -1)\n",
    "            h_t = self.cell(x_t, h_prev)\n",
    "            h_prev = h_t\n",
    "        \n",
    "        return prompt\n",
    "    \n",
    "class RNN_wAttention_LM(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        d_key = d_model\n",
    "\n",
    "        self.h0 = nn.Parameter(torch.zeros(1, d_model))\n",
    "        self.embed = nn.Embedding(len(vocabulaire), embed_dim, padding_idx=0)\n",
    "        self.cell = RecurrentUnit()\n",
    "        #self.cell = GatedRecurrentUnit()\n",
    "        self.h_to_key = nn.Linear(d_model, d_key)\n",
    "\n",
    "        self.lm_head = nn.Linear(d_model+d_key, len(vocabulaire))\n",
    "\n",
    "    def forward(self, x, targets=None):\n",
    "        # x : (B, T)\n",
    "        # targets : (B, T)\n",
    "\n",
    "        B, T = x.size()\n",
    "\n",
    "        emb = self.embed(x) # (B, T, embed_dim)\n",
    "\n",
    "        H_prev = self.h0.expand((B, -1)) # (B, d_model)\n",
    "        hiddens = []\n",
    "        for t in range(T):\n",
    "            X_t = emb[:, t, :] #todo : remove last : # todo shape (B, embed_dim)\n",
    "            H_t = self.cell(X_t, H_prev) # (B, d_model)\n",
    "            H_prev = H_t\n",
    "            hiddens.append(H_t)\n",
    "\n",
    "        hidden = torch.stack(hiddens, 1) # (B, T, d_model)\n",
    "\n",
    "        Q = hidden # (B, T, d_model)\n",
    "        K = self.h_to_key(torch.cat([self.h0.expand((B, 1, -1)), hidden], 1)) # (B, T+1, d_key=d_model)\n",
    "\n",
    "        QK_T = Q @ torch.transpose(K, 1, 2) # (B, T, T+1) lignes = originaires (querys), colonnes = targets (keys) c'est pour ça que il y en a T+1\n",
    "\n",
    "        mask = torch.tril(torch.ones((T, T+1), dtype=torch.int32)).bool()\n",
    "        QK_T[:, ~mask] = -float(\"inf\")\n",
    "\n",
    "        attention_scores = torch.softmax(QK_T, dim=2) # (B, T, T+1)\n",
    "        attention_out = attention_scores @ K # (B, T, d_key=d_model)\n",
    "\n",
    "        pre_logits = torch.cat([hidden, attention_out], dim=2) # (B, T, 2*d_model)\n",
    "        logits = self.lm_head(pre_logits) # (B, T, vocab_size)\n",
    "\n",
    "        loss = None\n",
    "        if targets is not None:\n",
    "            loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=0)\n",
    "        \n",
    "        return logits, loss\n",
    "    \n",
    "    def sample(self, prompt='', max_new_tokens=None):\n",
    "        init_len = len(prompt)+1\n",
    "\n",
    "        #convert prompt to (1, T) input tensor X\n",
    "        X = torch.zeros(size=(1, init_len), dtype=torch.int64, device=device) #<SOS>\n",
    "\n",
    "        X[0, 0] = 1 #<SOS>\n",
    "        for i, ch in enumerate(prompt):\n",
    "            X[0, i+1] = char_to_int[ch]\n",
    "\n",
    "        # forward is 2 fold : one when we feed in the prompt, one for autoregressive gen\n",
    "\n",
    "        #prompt feeding\n",
    "        h_prev = self.h0\n",
    "        hiddens = []\n",
    "        emb = self.embed(X)\n",
    "        for t in range(init_len):\n",
    "            x_t = emb[:, t, :]\n",
    "            h_t = self.cell(x_t, h_prev)\n",
    "            h_prev = h_t\n",
    "            hiddens.append(h_t)\n",
    "        \n",
    "        hidden = torch.stack(hiddens, 1) # (1, init_len, d_model)\n",
    "\n",
    "        #autoregressive gen\n",
    "        while True:\n",
    "            q = h_prev.expand(1, 1, -1) # (1, 1, d_model)\n",
    "            K = self.h_to_key(torch.cat([self.h0.expand((1, 1, -1)), hidden], 1)) # (1, init_len+num_tokens_generated, d_key=d_model)\n",
    "\n",
    "            qK_T = q @ torch.transpose(K, 1, 2) # (1, 1, init_len+num_tokens_generated)\n",
    "\n",
    "            mask = torch.zeros(size=(1, qK_T.shape[2])) # (1, init_len+num_tokens_generated)\n",
    "            mask[0, -1] = 1\n",
    "            mask = mask.bool()\n",
    "            qK_T[:, mask] = -float(\"inf\")\n",
    "\n",
    "            attention_scores = torch.softmax(qK_T, dim=2) # (1, 1, init_len+num_tokens_gen)\n",
    "            attention_out = attention_scores @ K # (1, 1, d_key=d_model)\n",
    "            attention_out = torch.squeeze(attention_out, dim=0)\n",
    "            \n",
    "            pre_logits = torch.cat([h_prev, attention_out], dim=1) # (1, 2*d_model)\n",
    "\n",
    "            logits = self.lm_head(pre_logits) # (1, vocab_size)\n",
    "            probs = F.softmax(logits, dim=1)\n",
    "\n",
    "            next_token = torch.multinomial(probs, num_samples=1, replacement=True).item()\n",
    "            next_char = int_to_char[next_token]\n",
    "\n",
    "            if next_char == '<EOS>':\n",
    "                break\n",
    "                \n",
    "            prompt += next_char\n",
    "\n",
    "            if len(prompt)-init_len+1 == max_new_tokens:\n",
    "                break\n",
    "\n",
    "            w_t = next_token #entry for next timestep\n",
    "            x_t = self.embed(torch.tensor(w_t, dtype=torch.int64, device=device)).view(1, -1)\n",
    "            h_t = self.cell(x_t, h_prev)\n",
    "            h_prev = h_t\n",
    "            hiddens.append(h_t)\n",
    "            hidden = torch.stack(hiddens, 1) # (1, init_len+num_tokens_generated, d_model)\n",
    "        \n",
    "        return prompt\n",
    "    \n",
    "#todo : bien remettre en place les notations, afin de pouvoir en faire un report\n",
    "#todo : report avec losscape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = torch.Generator().manual_seed(42)\n",
    "#model = RNN_LM()\n",
    "model = RNN_wAttention_LM()\n",
    "model.to(device)\n",
    "optim = torch.optim.AdamW(model.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17838"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_params = sum(p.numel() for p in model.parameters())\n",
    "total_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "lossi = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "for _ in range(1000):\n",
    "    Xb, Yb = get_batch('train', 1024)\n",
    "\n",
    "    #forward\n",
    "    logits, loss = model(Xb, Yb)\n",
    "\n",
    "    lossi.append(loss.item())\n",
    "\n",
    "    optim.zero_grad()\n",
    "    loss.backward()\n",
    "    optim.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f18fc6f8d90>]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(lossi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "saint-gillémargues\n",
      "lartignac\n",
      "bonnes\n",
      "la buzillon\n",
      "chéran\n",
      "therval\n",
      "plouria\n",
      "belloy\n",
      "wrépiège\n",
      "vernac\n"
     ]
    }
   ],
   "source": [
    "for _ in range(10):\n",
    "    print(model.sample())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 363,
   "metadata": {},
   "outputs": [],
   "source": [
    "villes_gen = []\n",
    "\n",
    "for _ in range(1000):\n",
    "    villes_gen.append(model.sample(\"\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 364,
   "metadata": {},
   "outputs": [],
   "source": [
    "lens_gen = [len(ville) for ville in villes_gen]\n",
    "occurences_lens = [0] * (max(lens_gen)+1)\n",
    "\n",
    "for ville in villes_gen:\n",
    "    occurences_lens[len(ville)] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 365,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f5a594cbb90>]"
      ]
     },
     "execution_count": 365,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(occurences_lens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "torch23",
   "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.11.3"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}