{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0b0fa912-2326-46f0-b6b8-190dcd5de173",
   "metadata": {},
   "source": [
    "# 8. Statistiques d'activation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb0c566a-19af-44c3-8449-87e292457c19",
   "metadata": {},
   "source": [
    "## Reprise du code précédent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "96fdf971-72cb-49f0-9577-7059cd0c4f38",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2790ab9d-40ca-4e9a-8aad-a05f2254c259",
   "metadata": {},
   "source": [
    "### Words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f7871633-1320-467b-8c91-54398f4df326",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Words(object):\n",
    "    \"\"\"Représente une liste de mots, ainsi que la liste ordonnée des caractères les composants.\"\"\"\n",
    "\n",
    "    EOS = '.'\n",
    "\n",
    "    def __init__(self, filename):\n",
    "        self.filename = filename\n",
    "        self.words = open(self.filename, 'r').read().splitlines()\n",
    "        self.nb_words = len(self.words)\n",
    "        self.chars = sorted(list(set(''.join(self.words))))\n",
    "        self.nb_chars = len(self.chars) + 1  # On ajoute 1 pour EOS\n",
    "        self.ctoi = {c:i+1 for i,c in enumerate(self.chars)}\n",
    "        self.ctoi[self.EOS] = 0\n",
    "        self.itoc = {i:s for s,i in self.ctoi.items()}\n",
    "\n",
    "    def __repr__(self):\n",
    "        l = []\n",
    "        l.append(\"<Words\")\n",
    "        l.append(f'  filename=\"{self.filename}\"')\n",
    "        l.append(f'  nb_words=\"{self.nb_words}\"')\n",
    "        l.append(f'  nb_chars=\"{self.nb_chars}\"/>')\n",
    "        return '\\n'.join(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "91679696-5397-4332-a712-b62af4bac4f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Words\n",
      "  filename=\"civil_mots.txt\"\n",
      "  nb_words=\"7223\"\n",
      "  nb_chars=\"41\"/>\n"
     ]
    }
   ],
   "source": [
    "words = Words('civil_mots.txt')\n",
    "print(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c9aee63",
   "metadata": {},
   "source": [
    "### Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e5798647",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Datasets:\n",
    "    \"\"\"Construits les jeu de données d'entraînement, de test et de validation.\n",
    "    \n",
    "    Prend en paramètres une liste de mots et la taille du contexte pour la prédiction.\n",
    "    \"\"\"\n",
    "\n",
    "    def _build_dataset(self, lwords:list, context_size:int):\n",
    "        X, Y = [], []\n",
    "        for w in lwords:\n",
    "            context = [0] * context_size\n",
    "            for ch in w + self.words.EOS:\n",
    "                ix = self.words.ctoi[ch]\n",
    "                X.append(context)\n",
    "                Y.append(ix)\n",
    "                context = context[1:] + [ix] # crop and append\n",
    "        X = torch.tensor(X)\n",
    "        Y = torch.tensor(Y)\n",
    "        return X, Y\n",
    "    \n",
    "    def __init__(self, words:Words, context_size:int, seed:int=42):\n",
    "        # 80%, 10%, 10%\n",
    "        self.shuffled_words = words.words.copy()\n",
    "        random.shuffle(self.shuffled_words)\n",
    "        self.n1 = int(0.8*len(self.shuffled_words))\n",
    "        self.n2 = int(0.9*len(self.shuffled_words))\n",
    "        self.words = words\n",
    "        self.Xtr, self.Ytr = self._build_dataset(self.shuffled_words[:self.n1], context_size)\n",
    "        self.Xdev, self.Ydev = self._build_dataset(self.shuffled_words[self.n1:self.n2], context_size)\n",
    "        self.Xte, self.Yte = self._build_dataset(self.shuffled_words[self.n2:], context_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dfa7c90b",
   "metadata": {},
   "outputs": [],
   "source": [
    "context_size = 3\n",
    "datasets = Datasets(words, context_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7092040-2fdd-4b8f-acf2-8ef248762d17",
   "metadata": {},
   "source": [
    "### Hyperparamètres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "67638be9-047a-42f0-99a7-eaad67157805",
   "metadata": {},
   "outputs": [],
   "source": [
    "vocab_size = words.nb_chars\n",
    "e_dims = 10 # the dimensionality of the character embedding vectors\n",
    "n_hidden = 200 # the number of neurons in the hidden layer of the FFN\n",
    "seed = 2147483647"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3263a952-ba4b-4851-a788-746f29499274",
   "metadata": {},
   "source": [
    "### Réseau: classe BengioFFN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2f557fd3-542c-4a9b-b0b5-47b32756375c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BengioFFN:\n",
    "    \n",
    "    def __init__(self, e_dims, n_hidden, context_size, nb_chars, g):\n",
    "        self.g = g\n",
    "        self.nb_chars = nb_chars\n",
    "        self.e_dims = e_dims\n",
    "        self.n_hidden = n_hidden\n",
    "        self.context_size = context_size\n",
    "        self.create_network()\n",
    "\n",
    "    def layers(self):\n",
    "        self.C = torch.randn((self.nb_chars, self.e_dims), generator=self.g)\n",
    "        fan_in = self.context_size * self.e_dims\n",
    "        tanh_gain = 5/3\n",
    "        self.W1 = torch.randn((self.context_size * self.e_dims, self.n_hidden), generator=self.g) * (tanh_gain / (fan_in ** 0.5))\n",
    "        self.W2 = torch.randn((self.n_hidden, self.nb_chars), generator=self.g) * 0.01  # Pour l'entropie\n",
    "        self.b2 = torch.randn(self.nb_chars, generator=self.g) * 0\n",
    "        self.bngain = torch.ones((1, n_hidden))\n",
    "        self.bnbias = torch.zeros((1, n_hidden))\n",
    "\n",
    "    def create_network(self):\n",
    "        self.layers()\n",
    "        self.loss = None\n",
    "        self.steps = 0\n",
    "        self.parameters = [self.C, self.W1, self.W2, self.b2, self.bngain, self.bnbias]\n",
    "        self.nb_parameters = sum(p.nelement() for p in self.parameters) # number of parameters in total\n",
    "        for p in self.parameters:\n",
    "            p.requires_grad = True\n",
    "        self.bnmean_running = torch.zeros((1, n_hidden))\n",
    "        self.bnstd_running = torch.zeros((1, n_hidden))\n",
    "\n",
    "    def forward(self, X, Y):\n",
    "        self.emb = self.C[X] # Embed characters into vectors\n",
    "        self.embcat = self.emb.view(self.emb.shape[0], -1) # Concatenate the vectors\n",
    "        # Linear layer\n",
    "        self.hpreact = self.embcat @ self.W1 # hidden layer pre-activation\n",
    "        # BatchNorm layer\n",
    "        self.bnmeani = self.hpreact.mean(0, keepdim=True)\n",
    "        self.bnstdi = self.hpreact.std(0, keepdim=True)\n",
    "        self.hpreact = self.bngain * (self.hpreact - self.bnmeani) / self.bnstdi + self.bnbias\n",
    "        # Non linearity\n",
    "        self.h = torch.tanh(self.hpreact) # hidden layer\n",
    "        self.logits = self.h @ self.W2 + self.b2 # output layer\n",
    "        self.loss = F.cross_entropy(self.logits, Y) # loss function\n",
    "        # mean, std\n",
    "        with torch.no_grad():\n",
    "            self.bnmean_running = 0.999 * self.bnmean_running + 0.001 * self.bnmeani\n",
    "            self.bnstd_running = 0.999 * self.bnstd_running + 0.001 * self.bnstdi\n",
    "\n",
    "    def backward(self):\n",
    "        for p in self.parameters:\n",
    "            p.grad = None\n",
    "        self.loss.backward()\n",
    "\n",
    "    def train(self, datasets: Datasets, max_steps, mini_batch_size):\n",
    "        lossi = []\n",
    "        for i in range(max_steps):\n",
    "            # minibatch construct\n",
    "            ix = torch.randint(0, datasets.Xtr.shape[0], (mini_batch_size,), generator=self.g)\n",
    "            Xb, Yb = datasets.Xtr[ix], datasets.Ytr[ix]\n",
    "            \n",
    "            # forward pass\n",
    "            self.forward(Xb, Yb)\n",
    "        \n",
    "            # backward pass\n",
    "            self.backward()\n",
    "        \n",
    "            # update\n",
    "            lr = 0.2 if i < 100000 else 0.02 # step learning rate decay\n",
    "            self.update_grad(lr)\n",
    "        \n",
    "            # track stats\n",
    "            if i % 10000 == 0:\n",
    "                print(f\"{i:7d}/{max_steps:7d}: {self.loss.item():.4f}\")\n",
    "            lossi.append(self.loss.log10().item())\n",
    "        self.steps += max_steps\n",
    "        return lossi\n",
    "\n",
    "    def update_grad(self, lr):\n",
    "        for p in self.parameters:\n",
    "            p.data += -lr * p.grad\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def compute_loss(self, X, Y):\n",
    "        emb = self.C[X] # Embed characters into vectors\n",
    "        embcat = emb.view(emb.shape[0], -1) # Concatenate the vectors\n",
    "        hpreact = embcat @ self.W1 # hidden layer pre-activation\n",
    "        hpreact = self.bngain * (hpreact - self.bnmean_running) / self.bnstd_running + self.bnbias\n",
    "        h = torch.tanh(hpreact) # hidden layer\n",
    "        logits = h @ self.W2 + self.b2 # output layer\n",
    "        loss = F.cross_entropy(logits, Y) # loss function\n",
    "        return loss\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def training_loss(self, datasets:Datasets):\n",
    "        loss = self.compute_loss(datasets.Xtr, datasets.Ytr)\n",
    "        return loss.item()\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def test_loss(self, datasets:Datasets):\n",
    "        loss = self.compute_loss(datasets.Xte, datasets.Yte)\n",
    "        return loss.item()\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def dev_loss(self, datasets:Datasets):\n",
    "        loss = self.compute_loss(datasets.Xdev, datasets.Xdev)\n",
    "        return loss.item()\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def generate_word(self, itoc, g):\n",
    "        out = []\n",
    "        context = [0] * self.context_size\n",
    "        while True:\n",
    "            emb = self.C[torch.tensor([context])]\n",
    "            embcat = emb.view(1, -1)\n",
    "            hpreact = embcat @ self.W1\n",
    "            hpreact = self.bngain * (hpreact - self.bnmean_running) / self.bnstd_running + self.bnbias\n",
    "            h = torch.tanh(hpreact)\n",
    "            logits = h @ self.W2 + self.b2\n",
    "            probs = F.softmax(logits, dim=1)\n",
    "            # Sample from the probability distribution\n",
    "            ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n",
    "            # Shift the context window\n",
    "            context = context[1:] + [ix]\n",
    "            # Store the generated character\n",
    "            if ix != 0:\n",
    "                out.append(ix)\n",
    "            else:\n",
    "                # Stop when encounting '.'\n",
    "                break\n",
    "        return ''.join(itoc[i] for i in out)\n",
    "\n",
    "    def __repr__(self):\n",
    "        l = []\n",
    "        l.append(\"<BengioMLP\")\n",
    "        l.append(f'  nb_chars=\"{self.nb_chars}\"')\n",
    "        l.append(f'  e_dims=\"{self.e_dims}\"')\n",
    "        l.append(f'  n_hidden=\"{self.n_hidden}\"')\n",
    "        l.append(f'  context_size=\"{self.context_size}\"')\n",
    "        l.append(f'  loss=\"{self.loss}\"')\n",
    "        l.append(f'  steps=\"{self.steps}\"')\n",
    "        l.append(f'  nb_parameters=\"{self.nb_parameters}\"/>')\n",
    "        return '\\n'.join(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6bb328d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<BengioMLP\n",
      "  nb_chars=\"41\"\n",
      "  e_dims=\"10\"\n",
      "  n_hidden=\"200\"\n",
      "  context_size=\"3\"\n",
      "  loss=\"None\"\n",
      "  steps=\"0\"\n",
      "  nb_parameters=\"15051\"/>\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(seed)\n",
    "nn = BengioFFN(e_dims, n_hidden, context_size, words.nb_chars, g)\n",
    "print(nn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "156ce4a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0/ 200000: 3.7006\n",
      "  10000/ 200000: 2.4151\n",
      "  20000/ 200000: 1.8738\n",
      "  30000/ 200000: 2.2808\n",
      "  40000/ 200000: 2.0681\n",
      "  50000/ 200000: 1.4217\n",
      "  60000/ 200000: 1.4718\n",
      "  70000/ 200000: 2.2234\n",
      "  80000/ 200000: 1.4571\n",
      "  90000/ 200000: 1.8084\n",
      " 100000/ 200000: 1.7370\n",
      " 110000/ 200000: 1.5454\n",
      " 120000/ 200000: 1.3682\n",
      " 130000/ 200000: 1.7276\n",
      " 140000/ 200000: 2.1923\n",
      " 150000/ 200000: 1.3551\n",
      " 160000/ 200000: 1.5709\n",
      " 170000/ 200000: 1.4848\n",
      " 180000/ 200000: 1.3914\n",
      " 190000/ 200000: 1.6419\n",
      "train_loss=1.522524118423462\n",
      "val_loss=1.6819177865982056\n"
     ]
    }
   ],
   "source": [
    "max_steps = 200000\n",
    "mini_batch_size = 32\n",
    "lossi = nn.train(datasets, max_steps, mini_batch_size)\n",
    "train_loss = nn.training_loss(datasets)\n",
    "val_loss = nn.test_loss(datasets)\n",
    "print(f\"{train_loss=}\")\n",
    "print(f\"{val_loss=}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f7d69c45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(torch.tensor(lossi).view(-1,1000).mean(1));"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f292c7a",
   "metadata": {},
   "source": [
    "## \"torch-ification\": Linear, BatchNorm1d, vers des réseaux plus profonds\n",
    "\n",
    "API presque identique aux classes similaires dans [torch.nn](https://pytorch.org/docs/stable/nn.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "edd50bf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Linear:\n",
    "    \"\"\"Linear layer.\n",
    "    \n",
    "    Similar to <https://pytorch.org/docs/stable/generated/torch.nn.Linear.html>\n",
    "    \"\"\"\n",
    "    def __init__(self, fan_in, fan_out, bias=True):\n",
    "        self.weight = torch.randn((fan_in, fan_out)) / fan_in**0.5\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])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "afe04015",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BatchNorm1d:\n",
    "    \"\"\"Batch normalization layer.\n",
    "    \n",
    "    Similar to <https://pytorch.org/docs/stable/generated/torch.nn.BatchNorm1d.html#torch.nn.BatchNorm1d>\n",
    "    \"\"\"\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",
    "            xmean = x.mean(0, keepdim=True) # batch mean\n",
    "            xvar = x.var(0, 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]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e809ccfa",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Tanh:\n",
    "    \n",
    "    def __call__(self, x):\n",
    "        self.out = torch.tanh(x)\n",
    "        return self.out\n",
    "\n",
    "    def parameters(self):\n",
    "        return []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "85828822-4706-428e-bdcb-28b0e00eb012",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TorchBengioFFN:\n",
    "    \n",
    "    def __init__(self, e_dims, n_hidden, context_size, nb_chars, g):\n",
    "        self.g = g\n",
    "        self.nb_chars = nb_chars\n",
    "        self.e_dims = e_dims\n",
    "        self.n_hidden = n_hidden\n",
    "        self.context_size = context_size\n",
    "        self.steps = 0\n",
    "        self.create_network()\n",
    "\n",
    "    def _create_layers(self):\n",
    "        self.layers = [\n",
    "            Linear(self.e_dims * self.context_size, self.n_hidden, bias=False), BatchNorm1d(self.n_hidden), Tanh(),\n",
    "            Linear(self.n_hidden, self.nb_chars), BatchNorm1d(self.nb_chars),\n",
    "        ]\n",
    "        with torch.no_grad():\n",
    "            # last layer: make less confident\n",
    "            self.layers[-1].gamma *= 0.1\n",
    "            # all other layers: apply gain\n",
    "            #for layer in self.layers[:-1]:\n",
    "            #    if isinstance(layer, Linear):\n",
    "            #        layer.weight *= 5/3\n",
    "\n",
    "    def create_network(self):\n",
    "        self.C = torch.randn((self.nb_chars, self.e_dims), generator=self.g)\n",
    "        self._create_layers()\n",
    "        self.parameters = [self.C] + [p for layer in self.layers for p in layer.parameters()]\n",
    "        for p in self.parameters:\n",
    "            p.requires_grad = True\n",
    "        self.nb_parameters = sum(p.nelement() for p in self.parameters)\n",
    "\n",
    "    def forward(self, X, Y):\n",
    "        emb = self.C[X] # embed the characters into vectors\n",
    "        x = emb.view(emb.shape[0], -1) # concatenate the vectors\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "        self.loss = F.cross_entropy(x, Y) # loss function\n",
    "\n",
    "    def backward(self):\n",
    "        for layer in self.layers:\n",
    "            layer.out.retain_grad()  # AFTER_DEBUG: would take out retain_graph\n",
    "        for p in self.parameters:\n",
    "            p.grad = None\n",
    "        self.loss.backward()\n",
    "\n",
    "    def train(self, datasets: Datasets, max_steps, mini_batch_size):\n",
    "        lossi = []\n",
    "        for i in range(max_steps):\n",
    "            # minibatch construct\n",
    "            ix = torch.randint(0, datasets.Xtr.shape[0], (mini_batch_size,), generator=self.g)\n",
    "            Xb, Yb = datasets.Xtr[ix], datasets.Ytr[ix]\n",
    "            \n",
    "            # forward pass\n",
    "            self.forward(Xb, Yb)\n",
    "        \n",
    "            # backward pass\n",
    "            self.backward()\n",
    "\n",
    "            # update\n",
    "            lr = 0.2 if i < 100000 else 0.02 # step learning rate decay\n",
    "            self.update_grad(lr)\n",
    "        \n",
    "            # track stats\n",
    "            if i % 10000 == 0:\n",
    "                print(f\"{i:7d}/{max_steps:7d}: {self.loss.item():.4f}\")\n",
    "            lossi.append(self.loss.log10().item())\n",
    "        self.steps += max_steps\n",
    "        return lossi\n",
    "\n",
    "    def update_grad(self, lr):\n",
    "        for p in self.parameters:\n",
    "            p.data += -lr * p.grad\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def compute_loss(self, X, Y):\n",
    "        emb = self.C[X] # Embed characters into vectors\n",
    "        x = emb.view(emb.shape[0], -1) # Concatenate the vectors\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "        loss = F.cross_entropy(x, Y)\n",
    "        return loss\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def training_loss(self, datasets:Datasets):\n",
    "        loss = self.compute_loss(datasets.Xtr, datasets.Ytr)\n",
    "        return loss.item()\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def test_loss(self, datasets:Datasets):\n",
    "        loss = self.compute_loss(datasets.Xte, datasets.Yte)\n",
    "        return loss.item()\n",
    "\n",
    "    @torch.no_grad() # this decorator disables gradient tracking\n",
    "    def dev_loss(self, datasets:Datasets):\n",
    "        loss = self.compute_loss(datasets.Xdev, datasets.Xdev)\n",
    "        return loss.item()\n",
    "\n",
    "    @torch.no_grad()\n",
    "    def generate_word(self, itoc, g):\n",
    "        for layer in self.layers:\n",
    "            layer.training = False\n",
    "        out = []\n",
    "        context = [0] * self.context_size\n",
    "        while True:\n",
    "            emb = self.C[torch.tensor([context])]\n",
    "            x = emb.view(emb.shape[0], -1) # concatenate the vectors\n",
    "            for layer in self.layers:\n",
    "                x = layer(x)\n",
    "            logits = x\n",
    "            probs = F.softmax(logits, dim=1)\n",
    "            # Sample from the probability distribution\n",
    "            ix = torch.multinomial(probs, num_samples=1, generator=g).item()\n",
    "            # Shift the context window\n",
    "            context = context[1:] + [ix]\n",
    "            # Store the generated character\n",
    "            if ix != 0:\n",
    "                out.append(ix)\n",
    "            else:\n",
    "                # Stop when encounting '.'\n",
    "                break\n",
    "        return ''.join(itoc[i] for i in out)\n",
    "\n",
    "    def __repr__(self):\n",
    "        l = []\n",
    "        l.append(\"<BengioMLP\")\n",
    "        l.append(f'  nb_chars=\"{self.nb_chars}\"')\n",
    "        l.append(f'  e_dims=\"{self.e_dims}\"')\n",
    "        l.append(f'  n_hidden=\"{self.n_hidden}\"')\n",
    "        l.append(f'  context_size=\"{self.context_size}\"')\n",
    "        l.append(f'  steps=\"{self.steps}\"')\n",
    "        l.append(f'  nb_parameters=\"{self.nb_parameters}\"/>')\n",
    "        return '\\n'.join(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "3685f73f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<BengioMLP\n",
      "  nb_chars=\"41\"\n",
      "  e_dims=\"10\"\n",
      "  n_hidden=\"200\"\n",
      "  context_size=\"3\"\n",
      "  steps=\"0\"\n",
      "  nb_parameters=\"15133\"/>\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(seed)\n",
    "nn = TorchBengioFFN(e_dims, n_hidden, context_size, words.nb_chars, g)\n",
    "print(nn)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2c0ff3cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      0/ 200000: 3.7297\n",
      "  10000/ 200000: 1.7267\n",
      "  20000/ 200000: 1.8718\n",
      "  30000/ 200000: 1.3533\n",
      "  40000/ 200000: 1.4859\n",
      "  50000/ 200000: 1.5927\n",
      "  60000/ 200000: 1.8781\n",
      "  70000/ 200000: 1.6199\n",
      "  80000/ 200000: 1.8822\n",
      "  90000/ 200000: 1.8774\n",
      " 100000/ 200000: 1.8686\n",
      " 110000/ 200000: 1.7877\n",
      " 120000/ 200000: 1.6906\n",
      " 130000/ 200000: 1.3904\n",
      " 140000/ 200000: 1.7476\n",
      " 150000/ 200000: 1.5275\n",
      " 160000/ 200000: 1.5421\n",
      " 170000/ 200000: 1.6666\n",
      " 180000/ 200000: 1.3521\n",
      " 190000/ 200000: 1.6354\n",
      "train_loss=1.5337094068527222\n",
      "val_loss=1.6885684728622437\n"
     ]
    }
   ],
   "source": [
    "lossi = nn.train(datasets, max_steps, mini_batch_size)\n",
    "train_loss = nn.training_loss(datasets)\n",
    "val_loss = nn.test_loss(datasets)\n",
    "print(f\"{train_loss=}\")\n",
    "print(f\"{val_loss=}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6e829f55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGdCAYAAAAxCSikAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAASu1JREFUeJzt3Qd0VNXaxvE3PQFSgAAh9N57EwUsIMUCVopeQa6CFbsofhewXqyoKIJyxYYCckW9NlB6771KD6GFACkQ0udb757MkIRAJiGZkvx/a82amczMyZk5Sc6Tvd+9t5fFYrEIAACAG/N29Q4AAADkh8ACAADcHoEFAAC4PQILAABwewQWAADg9ggsAADA7RFYAACA2yOwAAAAt+crJUBmZqYcPXpUgoODxcvLy9W7AwAAHKBz1yYmJkpkZKR4e3uX/MCiYaVGjRqu3g0AAFAIhw8flurVq5f8wKItK7Y3HBIS4urdAQAADkhISDANDrbzeIkPLLZuIA0rBBYAADyLI+UcFN0CAAC3R2ABAABuj8ACAADcHoEFAAC4PQILAABwewQWAADg9ggsAADA7RFYAACA2yOwAAAAt0dgAQAAbo/AAgAA3B6BBQAAuL0SsfhhcTmZmCKTF+8TPx9vebFPY1fvDgAApRYtLJeRkJwmny87IN+tPuS8IwIAAC5CYLkMfx/rx5OWYbnc0wAAQDEjsFyGdgWp9MzM4j4OAADgMggsl+Hn42VvYbFYaGUBAMBVCCyX4ZvVwqLoFgIAwHUILA7UsKi0DLqFAABwFQKLA11CKp3CWwAAXIbAchk+3hcCSyotLAAAuAyB5TK8vLyyDW2mSwgAAFchsDjYLUSXEAAArkNgyYefr/UjoksIAADXIbDkw9ebLiEAAFyNwJIPf/vkcdSwAADgKgQWB7uEmDgOAADXIbA4uJ4QLSwAALgOgSUfvllzsRBYAABwHQJLPvztXULUsAAA4CoEFoe7hFitGQAAVyGw5IMuIQAAXI/Akg+6hAAAcD0Ci6NdQul0CQEA4FGBZeLEiVK7dm0JDAyUTp06yZo1axx63YwZM8yCgrfddluOr1ssFhkzZoxUrVpVgoKCpEePHrJnzx5xp7WE0jIpugUAwGMCy8yZM+WZZ56RsWPHyoYNG6RVq1bSq1cviYmJuezrDh48KM8995x07dr1osfefvttmTBhgkyePFlWr14tZcuWNdtMTk4WV/O1t7AQWAAA8JjAMn78eBk2bJgMHTpUmjZtakJGmTJlZOrUqZd8TUZGhtx7773yyiuvSN26dS9qXfnggw/kX//6l/Tr109atmwpX3/9tRw9elR++ukncTV/RgkBAOBZgSU1NVXWr19vumzsG/D2NvdXrlx5yde9+uqrUrlyZXnggQcueuzAgQNy/PjxHNsMDQ01XU2X26az0CUEAIDr+RbkybGxsaa1pEqVKjm+rvd37dqV52uWLVsmn3/+uWzatCnPxzWs2LaRe5u2x3JLSUkxF5uEhAQpLhTdAgBQwkcJJSYmyn333SdTpkyR8PDwItvuuHHjTCuM7VKjRg0pLqwlBACAh7WwaOjw8fGREydO5Pi63o+IiLjo+fv27TPFtrfeeqv9a5lZo218fX1l9+7d9tfpNnSUUPZttm7dOs/9GDVqlCn8zd7CUlyhxd4lxNT8AAB4RguLv7+/tGvXTubPn58jgOj9zp07X/T8xo0by9atW013kO3St29fuf76681tDRl16tQxoSX7NjWA6GihvLapAgICJCQkJMeluDA1PwAAHtbCorRlY8iQIdK+fXvp2LGjGeFz7tw5M2pIDR48WKpVq2a6bXSelubNm+d4fVhYmLnO/vWnnnpKXn/9dWnQoIEJMKNHj5bIyMiL5mtxBbqEAADwwMAyYMAAOXnypJnoTYtitdtmzpw59qLZqKgoM3KoIEaOHGlCz/DhwyUuLk66dOlitqmBx9XoEgIAwPW8LDoRiofTLiQtvo2Pjy/y7qFPF++TcX/skjvaVpPx/fOuqQEAAMV7/mYtIQe7hNIzPD7XAQDgsQgs+aBLCAAA1yOw5IOiWwAAXI/A4mBgSaVLCAAAlyGw5MPP11bDwmrNAAC4CoElH37ezHQLAICrEVjyQZcQAACuR2DJB11CAAC4HoElHwxrBgDA9Qgs+WDxQwAAXI/A4mgNSzqjhAAAcBUCi4NdQumZBBYAAFyFwJIPuoQAAHA9AoujgYUuIQAAXIbA4mCXUCoz3QIA4DIElnz4Z7WwpGdanHE8AABAHggs+fDNCiwZmRZzAQAAzkdgcbBLSKXRLQQAgEsQWBwsulUEFgAAXIPAUoDAkp5BlxAAAK5AYMmHj7eXeGf1CtHCAgCAaxBYCjI9PzUsAAC4BIGlIEOb6RICAMAlCCwO8PPNmu2WFhYAAFyCwOIA36wiFrqEAABwDQKLA1gAEQAA1yKwOMA/q0sonS4hAABcgsDiALqEAABwLQKLA+gSAgDAtQgsBRkllJ5Z3McDAADkgcDiAP+sBRDTMwksAAC4AoHFAb7etpluWUsIAABXILA4gC4hAABci8BSgC4hZroFAMA1CCwFGSWUSZcQAACuQGBxgK8tsDBKCAAAlyCwOMCPLiEAAFyKwOIA/6wWlnS6hAAAcAkCiwN8s1pYUukSAgDAJQgsBZqan4njAABwBQJLAbqECCwAALgGgcUBLH4IAIBrEVgKUMNCCwsAAK5BYHEANSwAALgWgaVANSzMdAsAgCsQWBzAxHEAALgWgaUgU/MzrBkAAJcgsDiALiEAAFyLwOIAP19GCQEA4EoEFgcwSggAANcisDjA15tRQgAAuBKBxQH+dAkBAOBSBJYCdAmxWjMAAK5BYClAl1B6JhPHAQDgCgQWB9AlBACAaxFYCjJKKD2zuI8HAADIA4GlIIGFLiEAAFyCwOIA1hICAMC1CCwOoEsIAADXIrAUaKZbRgkBAOAKBJYC1bBkisVCaAEAwNkILAWoYdGskkHhLQAATkdgKUALi6JbCAAA5yOwFDCwpGYwFwsAAM5GYClAl5BKJ7AAAOB0BBYHeHl5ia+3NbTQJQQAgPMRWAo8tJkuIQAAnI3AUsBuIWpYAABwPgJLAVtY0pk8DgAApyOwFDCwpLJiMwAATkdgcVBIkK+5TkxOK87jAQAAiiqwTJw4UWrXri2BgYHSqVMnWbNmzSWfO3v2bGnfvr2EhYVJ2bJlpXXr1vLNN9/keM79999vRuJkv/Tu3VvcSViQv7mOO09gAQDA2azNBgUwc+ZMeeaZZ2Ty5MkmrHzwwQfSq1cv2b17t1SuXPmi51eoUEH+7//+Txo3biz+/v7y66+/ytChQ81z9XU2GlC++OIL+/2AgABxJ6Fl/Mx1XBKBBQAAt29hGT9+vAwbNsyEjqZNm5rgUqZMGZk6dWqez7/uuuvk9ttvlyZNmki9evXkySeflJYtW8qyZctyPE8DSkREhP1Svnx5cSdhQVmB5Xyqq3cFAIBSp0CBJTU1VdavXy89evS4sAFvb3N/5cqV+b5eVzqeP3++aY3p1q1bjscWLVpkWl0aNWokjzzyiJw6deqS20lJSZGEhIQcl+IWltXCEk8LCwAA7t0lFBsbKxkZGVKlSpUcX9f7u3btuuTr4uPjpVq1aiZo+Pj4yCeffCI33nhjju6gO+64Q+rUqSP79u2Tl156Sfr06WNCkD4/t3Hjxskrr7wizhRWJquGhcACAID717AURnBwsGzatEnOnj1rWli0BqZu3bqmu0gNHDjQ/twWLVqYLiPtPtJWl+7du1+0vVGjRplt2GgLS40aNYr1PYTSJQQAgGcElvDwcNPiceLEiRxf1/tad3Ip2m1Uv359c1tHCe3cudO0ktgCS24aZvR77d27N8/AovUuzi7KtXUJ0cICAICb17DoKJ927dqZVhKbzMxMc79z584Ob0dfo91DlxIdHW1qWKpWrSruNqw5nmHNAAC4f5eQdsUMGTLEzK3SsWNHM6z53LlzZtSQGjx4sKlX0RYUpdf6XO3i0ZDy+++/m3lYJk2aZB7XbiKtR7nzzjtNK43WsIwcOdK0yGQf9uxqtLAAAOBBgWXAgAFy8uRJGTNmjBw/ftx08cyZM8deiBsVFWW6gGw0zDz66KOm1SQoKMjMxzJt2jSzHaVdTFu2bJGvvvpK4uLiJDIyUnr27CmvvfaaW83FQg0LAACu42XRscYeTotuQ0NDzWikkJCQYvkeOiV/i5f/NLd3vdZbAv0uHr0EAACK5/zNWkIOKhfgKz7eXuY2dSwAADgXgcVBur6RfbZb5mIBAMCpCCyFWk+I6fkBAHAmAkuh1hNiAUQAAJyJwFKI6flZTwgAAOcisBQAKzYDAOAaBJZC1bDQJQQAgDMRWAoxPT81LAAAOBeBpRDT81PDAgCAcxFYCrOe0HmGNQMA4EwElsKsJ0QNCwAATkVgKcSwZgILAADORWApxLBm1hICAMC5CCyFqGE5m5IuaRmZxXVMAABALgSWAggO9BMv64LNtLIAAOBEBJYC8PH2kpBACm8BAHA2Akth52JhaDMAAE5DYCnsekIMbQYAwGkILAUUytBmAACcjsBSyBaWM0nMdgsAgLMQWAqoQlnr5HGxZwksAAA4C4GlgCqHBJjrk4kpxXE8AABAHggsBVQ5ONBcxyQm8wMFAICTEFgKqHIwLSwAADgbgaWQXUIxdAkBAOA0BJZCdgmdPpcqqemsJwQAgDMQWAoxrNnX27qgUOxZCm8BAHAGAktBPzBvL6mUVcdCtxAAAM5BYLmCwtuYBEYKAQDgDASWQqiUVcdyki4hAACcgsByJSOFEqhhAQDAGQgsV9IlxNBmAACcgsBSCLai25PMdgsAgFMQWK5oen66hAAAcAYCyxWNEiKwAADgDASWKyi61YnjMjMtRX1MAABALgSWQggvZw0s6ZkWOZOUWphNAACAAiCwFIKfj7dUKOtvblPHAgBA8SOwFBJDmwEAcB4CSyHZ1xNien4AAIodgaWQGNoMAIDzEFiucKTQSeZiAQCg2BFYrriGhRWbAQAobgSWQooIsc52ezSOwAIAQHEjsBRSrYplzfWhU+eK8ngAAIA8EFgKqVbFMub6TFKaxCelFXYzAADAAQSWQiob4Gsf2nzoNK0sAAAUJwLLFaid1cpy8FRSUR0PAACQBwLLFaidVcdyMJYWFgAAihOB5QrUDs8KLBTeAgBQrAgsRVB4e4guIQAAihWBpQi6hBjaDABA8SKwFEELS+zZVElMZmgzAADFhcByBYID/SS8nL+5TbcQAADFh8BSRDPeUngLAEDxIbBcIQpvAQAofgSWK1Qnq4XlAHOxAABQbAgsV6hW1lwsjBQCAKD4EFiuENPzAwBQ/AgsV6hOVgvLycQUOX0utSiOCQAAyIXAUgRDm22hZUt03JVuDgAA5IHAUgRaVg8111ui44ticwAAIBcCSxFoWT3MXNPCAgBA8SCwFIFWWS0sm6PjxWKxFMUmAQBANgSWItAsMlR8vL1M4e3xhOSi2CQAAMiGwFIEgvx9pEHlcub25sPUsQAAUNQILEWkFXUsAAAUGwJLEWlZg5FCAAAUFwJLMbSwUHgLAEDRIrAUkUYRweLv6y0Jyely8FRSUW0WAAAUNrBMnDhRateuLYGBgdKpUydZs2bNJZ87e/Zsad++vYSFhUnZsmWldevW8s033+R4jrZIjBkzRqpWrSpBQUHSo0cP2bNnj0cdID8fb2kWGWJubz7MjLcAALg0sMycOVOeeeYZGTt2rGzYsEFatWolvXr1kpiYmDyfX6FCBfm///s/WblypWzZskWGDh1qLnPnzrU/5+2335YJEybI5MmTZfXq1SbY6DaTkz1riHCbGuXN9YaoM67eFQAAShQvSwELLrRFpUOHDvLxxx+b+5mZmVKjRg0ZMWKEvPjiiw5to23btnLzzTfLa6+9ZlpXIiMj5dlnn5XnnnvOPB4fHy9VqlSRL7/8UgYOHJjv9hISEiQ0NNS8LiTE2srhCr9sPiojpm+UFtVC5ZcRXVy2HwAAeIKCnL8L1MKSmpoq69evN1029g14e5v72oKSHw0n8+fPl927d0u3bt3M1w4cOCDHjx/PsU3deQ1GjmzTnbStZW1h2XksQc6nZrh6dwAAKDF8C/Lk2NhYycjIMK0f2en9Xbt2XfJ1mpyqVasmKSkp4uPjI5988onceOON5jENK7Zt5N6m7bHcdDt6yZ7Q3EFkaKBUDg6QmMQU2XokXjrWqeDqXQIAoERwyiih4OBg2bRpk6xdu1beeOMNUwOzaNGiQm9v3LhxphXGdtEuKXfg5eUlbWpahzdvpI4FAADXBJbw8HDTQnLixIkcX9f7ERERl/4m3t5Sv359M0JIa1XuuusuEzqU7XUF2eaoUaNMq43tcvjwYXEXbWtau4U2RjFSCAAAlwQWf39/adeunalDsdGiW73fuXNnh7ejr7F16dSpU8cEk+zb1C4eHS10qW0GBASY4pzsF3fRpuaFkUJMIAcAgAtqWJR25wwZMsTMrdKxY0f54IMP5Ny5c2aosho8eLCpV7G1oOi1PrdevXompPz+++9mHpZJkybZu1Geeuopef3116VBgwYmwIwePdqMHLrtttvE0+gIIV9vL1PHcjQ+WaqFBbl6lwAAKH2BZcCAAXLy5Ekz0ZsWxWo3z5w5c+xFs1FRUaYLyEbDzKOPPirR0dFmUrjGjRvLtGnTzHZsRo4caZ43fPhwiYuLky5dupht6sR0nrhyc5OqIaboVutYCCwAALhgHhZ35C7zsNiM/mmbfLPqkAzrWkf+7+amrt4dAABK1zwscEzjqsHmek/MWT4yAACKAIGlGDSonBVYThBYAAAoCgSWYtCgcjlzfSTuvJxLSS+ObwEAQKlCYCkG5cv6S3i5AHN730laWQAAuFIElmJuZfmbbiEAAK4YgaWYNKhiDSx7YhKL61sAAFBqEFiKuYVlLy0sAABcMQJLMWlQhaHNAAAUFQJLMbewHD6TJOdTM4rr2wAAUCoQWIpJxXIBUqGsv+g8wowUAgDgyhBYnNDKQuEtAABXhsDijJFCFN4CAHBFCCxOmKKfuVgAALgyBJZi1CzSuvLk6gOnJDmNwlsAAAqLwFKM2tYsL5GhgZKYnC4LdsUU57cCAKBEI7AU54fr7SX92lQzt2dviC7ObwUAQIlGYClmd2QFlkW7T8qpsynF/e0AACiRCCxOmPG2ebUQSc+0yK9bjhX3twMAoEQisDjB7W2qm+vZG48449sBAFDiEFicoG+rSPHx9pLNh+Nk93FWbwYAoKAILE5QKThAejSpbG5PXxPljG8JAECJQmBxkns71TLXP2yIlqTUdGd9WwAASgQCi5N0qR8uNSuUMXOy/LqZ4lsAAAqCwOLEOVnu6VTT3P6WbiEAAAqEwOJEd7erLn4+1uLb7UfjnfmtAQDwaAQWJ6pYLkCubVjJ3F6575QzvzUAAB6NwOJkbWqWN9dbomlhAQDAUQQWJ2tRLdRcb4mOc/a3BgDAYxFYnKxldWtgOXgqSeKT0pz97QEA8EgEFicLK+MvtSqWMbe3HKGVBQAARxBYXKBl9TBzTR0LAACOIbC4QKusbiEd3gwAAPJHYHFh4e3WI4wUAgDAEQQWF2heLVS8vUSOxSdLTGKyK3YBAACPQmBxgbIBvlK/cjlz+9VfdkifD5fK+L/+dsWuAADgEQgsLi68/XXLMdl5LEEmLdorCckMcwYAIC8EFhe5vU01CfLzkY61K0hkaKCkZVhk4a4YV+0OAABujcDiItfUD5edr/WW7x/uLHe0rW6+NmfbcVftDgAAbo3A4gZ6N48w14t2n5TzqRmu3h0AANwOgcUNNIsMkWphQXI+LUOW7Dnp6t0BAMDtEFjcgJeXl72VZS7dQgAAXITA4iZsgeWvnSfkXEq6q3cHAAC3QmBxE21rljfdQonJ6TLyhy1isVhcvUsAALgNAoub8PH2kg8HthY/Hy/5bcsx+WzJflfvEgAAboPA4kba164gY29tZm6/NWcXiyMCAJCFwOJm7u1UU3o3i5BMi8hvW4+5encAAHALBBY3HjG0ct8pV+8OAABugcDihq6qW9Fcbz8aL/HnWV8IAAACixuKCA2UOuFlTbfQ2gOnXb07AAC4HIHFzVtZVu6nWwgAAAKLm+pcLyuwUMcCAACBxV1dVaeCud55PEHiklJdvTsAALgULSxuqnJIoNSrVFZ0wtvV1LEAAEo5AosHdAst2xPr6l0BAMClCCxurEeTKub6hw3Rcupsiqt3BwAAlyGwuLFrG1aSFtVCJSk1Q6YsPeDq3QEAwGUILG4+6+2T3RuY21+vPEgrCwCg1PJ19Q7g8ro3qSzNq4XItiMJMmL6RqlZoYxUDQ2Sx2+ob1Z4BgCgNKCFxQNaWZ7q3tDcXrHvlMxYe1jen/e3zNl23NW7BgCA0xBYPKSV5bV+zeShbnWlR5PK5mtTlu4Xi455BgCgFKBLyENaWe7rXNvcPpmYIkveWiCbDsfJ+kNnpEX1UPlj63HpWKeCRIYFuXpXAQAoFgQWD1MpOEBub11NZq47LB/O3yPnUzNk3aEzJrB8/1BnV+8eAADFgi4hD/Rg1zrmeumeWBNW1JoDp+XvE4ku3jMAAIoHgcUDNagSLNc3qmRu1w0vKx1rW9cdmr4mysV7BgBA8SCweKgPBrSRt+9qKT8+do08en0987Uf1kdLclqGq3cNAIAiR2DxUKFl/KR/+xoSGuQn3RpUkmphQZKQnC6/bTnm6l0DAKDIEVhKAG9vLxnUsYa5PW31IYY7AwBKHAJLCaGtLf4+3rIxKk7+uz7a1bsDAECRIrCUEJVDAuXpG60z4r76yw45Enfe1bsEAECRIbCUIMO71ZW2NcMkMSVdnp+1WdIzMi96TlxSqsQnpblk/wAAKCwCSwmiiyG+17+1BPp5m3WH+n+6Ug6fTpLMTIvsjUmUUbO3SIc35sn17y2SqFNJrt5dAACKN7BMnDhRateuLYGBgdKpUydZs2bNJZ87ZcoU6dq1q5QvX95cevTocdHz77//fjP9fPZL7969C7NrpV6d8LIyYWAbCQ7wlQ1RcdJ9/GJpNPoP6TF+iUxfc1jSMixy+lyqPPLteoZAAwBKbmCZOXOmPPPMMzJ27FjZsGGDtGrVSnr16iUxMTF5Pn/RokUyaNAgWbhwoaxcuVJq1KghPXv2lCNHjuR4ngaUY8eO2S/Tp08v/Lsq5Xo2i5Dfn+wq7WuVl9T0TBNSfL29zGRzn97XTiqU9ZftRxPk5f9td/WuAgDgEC9LAZf81RaVDh06yMcff2zuZ2ZmmhAyYsQIefHFF/N9fUZGhmlp0dcPHjzY3sISFxcnP/30kxRGQkKChIaGSnx8vISEhBRqGyVRhukKOivlAn2lSnCA+PpY8+myPbFy39TVokf+u2Gd5Op64a7eVQBAKZRQgPN3gVpYUlNTZf369aZbx74Bb29zX1tPHJGUlCRpaWlSoYJ1OvnsLTGVK1eWRo0aySOPPCKnTp265DZSUlLMm8x+Qd41LY0igs2kcraworo0CJe72lY3t//cfoKPDgDg9goUWGJjY00LSZUqVXJ8Xe8fP37coW288MILEhkZmSP0aHfQ119/LfPnz5e33npLFi9eLH369DHfKy/jxo0zicx20RYeFEyPptZjuGBXDBPNAQDcnq8zv9mbb74pM2bMMK0pWrBrM3DgQPvtFi1aSMuWLaVevXrmed27d79oO6NGjTJ1NDbawkJoKZgu9cPFz8dLok4nyf7Yc1KvUrlCHlUAANyshSU8PFx8fHzkxImc3Qh6PyIi4rKvfffdd01g+fPPP00guZy6deua77V37948Hw8ICDB9XdkvKJiyAb7SqU5Fc3vhLmvB9LYj8XLqbAofJQDAswOLv7+/tGvXznTd2GjRrd7v3LnzJV/39ttvy2uvvSZz5syR9u3b5/t9oqOjTQ1L1apVC7J7KKDrG1c21wt3x5jp/G/5aJn0fH+JmbMFAACPHtasXTE6t8pXX30lO3fuNAWy586dk6FDh5rHdeSPdtnYaE3K6NGjZerUqWbuFq110cvZs2fN43r9/PPPy6pVq+TgwYMm/PTr10/q169vhkuj+OgwZ7XmwGn5vx+3mtunzqXKPVNWy8HYc3z0AADPDSwDBgww3TtjxoyR1q1by6ZNm0zLia0QNyoqysyjYjNp0iQzuuiuu+4yLSa2i25DaRfTli1bpG/fvtKwYUN54IEHTCvO0qVLTdcPineSuVoVy5h5WlLSM6Vbw0rSqEqwxCSmyL3/WS1nzqXan5vXNP8AALjtPCzuiHlYCu+VX7bLF8sPmuDyv8e7mInm7p68Qg6eSpI+zSPkk3vbyrero+SN33bKoI41ZfQtTcxMxAAAOPP8TWAp5WLPpsgXyw/IgPY1pWbFMvbi29smLpf0TIvc3LKq/LblQovZE90byDNZq0IDAHAlCCy4YhMX7pV35u623+9ct6Ks3G+dzG9I51rSpUElaVervJnmHwAAt5rpFqXHw9fWk051rLMRD72mtpnC/+ke1paVr1YekmFfr5PO4+bLD+uj7a/RIdEloIcRAOCG6BLCJWk9y76TZ6VxRLCpW9Ew8r/NR2XJ37GyMeqMmXBO3dQiQg7GJsmOYwnSo0ll+eTeduLvSxYGAFweXUIodpmZFvlw/h5zyU2LdT8a1CbH+kUAAORGYIHT6KRz2i10Tf1wCQ3yk6dmbJLUjEwZ2KGGvHnn5Wc0BgCUbgkFqGFx6lpCKHmub1TZXGz8fbzlwa/XyYy1h+XpGxtKlZALa0YBAFBYtNmjyFeBblUjzL4SdHanz6XKmJ+3ye9bLwyTBgDAEQQWFLkeWWsUzd95YZHMhOQ0GTx1tXy98pA8+u0Gef+vv00R74HYc2ZpgOS0DI4EAOCS6BJCkevepIq899ffsmxvrAkiOtL5gS/XyrYjCVLG30eSUjNMse5XKw9KXFKaeU2Qn490axguL/dtJlVDgzgqAIAcaGFBkWtSNVgiQwMlOS1Tlu+NlZE/bJG1B89IcKCvfP9QZ/n37S3Ex9vLhBWteQkv5y/n0zJk7vYT8q8ft3FEAAAXoYUFRU7nbNFWlm9WHZKXf9kuh0+fF19vL/l8SAdpXi3UXFrXCJO486nSpkZ5CfTzltUHTsugKatk/q4Y002kCzOeS0k3ywPo6CMAQOlGCwuKRfcm1joWDStqZO9G0jFr5lzVNDJErq4XLkH+PibgXFW3otyQNdroy+UH5Hh8stw4frFc985Cs95RfhKT0+SvHSfM/DAAgJKHwIJioQFE61XU9Y0qyYNd6ub7mn92qWOuZ62Plge/XitH45PlTFKaTFm6/7Kv0+LdR6ZtMMsFTFhw8UR2AADPR2BBsQj085EXejeWnk2ryHv9W4u3t1e+r7m6XkVpVCXYFOVqgW5A1vT+36w8ZIZEq7SMTFl78LR8vGCPLNhlHYX029ZjpsBXTV68T47FW1t1AAAlB2sJwa3MXBslL/yw1dS8fPNAJ3n9tx2y/WiCPNStroSV8ZdPFu2VxOR0+/OfuKG+zFx3WE4kpNhHIN3eppq8P6C1S98HACB/rNYMj3VH2+ryRPcG8tngdtK5XkVzW326ZL+8NWeXCSvly/jZV5KesGCvCSs1K5SRr//ZUby8RH7ceMQszmizNyZRfttyTNIzMvMMSLM3XFhx2hFaX/P0zE2y7Uj8Fb9fAIBjGCUEt+Ln4y3P3NjQfv/GJlXMatG7jiea4c8v3dREbmtdzXQxmVFI/9suGZkWeblvU2lfu4Lc2ba6/Hd9tIyavVV+euwa05V0xycrJCE5XdrUDJP37m4ldSuVM9uet+OEac1R9SuXk5bVrTP05uejBXtMKIo/nyZT7+9QTJ8EACA7uoTg9o7EnZeFu2Lk1paRElom5xBnbeXQUNKtYSVz/2RiivT+YImcOpcq/7iqpuw5cdYMmbbRIdSv39ZCejarIj3HL5HjCcnm610bhJsuqPxoOOr073kSezZVggN8ZdPYnmZOGQBAwdElhBKlWliQ/OOqWheFFaVzutjCiqoUHCDv9W9lbk9bFWXCita2fDesk3SpH24ms3tu1ma5feJyE1Z0234+XrJ0T6ys2Gct3LWFpP6frpSJC/fm+H6rD5wyYUUlpqTLjqMJxfjOAQA2jBJCiXNdo8oyrKt1iLR6tV9zM+eL1rjYamL2nTxnrt+5u6UM7FDT3H57zm4zj4uue/TPL9aaNY7e/XO3bD96oVblj63Hc3yvVftP2UcvsR4SABQfalhQIj3fq7GcTUmXSsGBcmfbauZrWvei9TFNqwbLa7/ulDvaVjNBpn6lcjJr/WHZdDhO+ny41CwhsPtEonmNroP02q87ZPqwq0TnpPtjmzWwaGuNDqXWwKLzx2hrzPYjCdKnRYQM7lxL2tW6MEmeTdSpJDkaf97MUQMAKBhqWAAR+WF9tIz933YTcmyLMb4/oJU8MWOTpKZnyuR/tJOwMn4y8LNVZqmAL4Z2MMW8WseiCzY+O2tzjs9x9C1N5YGsifCUjlC67t1FEn3mvNlW7+YRfO4ASr2EhAQJDQ2V+Ph4CQkJueznQQsLICJ3tqsuPZpWkW9WHpR5O2PkyR4N5PpGlWV41wT5eOFeeWLGRjM3jNLJ8FpVDzNhRetYdL0kdW+nmmYeGB1B9MZvO6RupbJmG0qXDdCwosb+b5tcU7+iBAeyRhIAOIoaFiCLtpw8fkMDMxzaFjQeua6eVC8fZFpZNIzoPC/9O9QwI4NsayPp3DAVyvrLqJuayPj+rWRghxqm+2jEdxvl76yupS9XHLR/zjpvzDtzd1/x577/5FkZ+sUaM/MvAJR0BBbgMsoG+Mrcp7qZy59Pd5PVo7pLh9rWoJK9FmV4t7pSLsDXLOSoRb46sZ12Lw2Zukbm7zxhRitpyNFAo3QOGdvkdhqG7p68wtTB2LqkHPHmH7tk4e6T8vyszfZJ8facSJQVe2PN+krZ6fd46cetMmVJ3usynTmXmufEennR4mItTAYAZyKwAA6ElkYRwdKwSrBUDgm0f71rw3DT4hJeLsAU2tr4+3rLpH+0M5PRHYtPlge+Wme+3qtZFTOTry4doHniP8sOmK8v3B0jaw+eMaOSnpi+0cz1kp+Dsefkr53WtZQOnkqSHzZEmxl9+368XO75z2rzPbOvqfT1yoPy3eoo+fcfO+VE1twzNusPnZb2b8yT0T9bu7YuR9dv6vjGPDOHTVySdXg3ADgDgQUopMYRIfLtg51k1sOdpYx/znIw7SKa9kAn051kM6RzbXNtK8b9a/sJ07KhM/PaLNgVI2N+3iZbo+MlJjFnsNBWE1vLyRfLD5jQo606asL8vfLotxvkfFqGfTsaKjQMxZ5NkQ/nWVex1tf8svloju1+uzrKhCQNPblbTrZEx8mgz1bJkzM2yqjZW0wQ0lmDdQ6b7N1cAFDcCCzAFdBh0XXCy+b5WERooAk0+vgNjSvba150srtmkSGSmpEpny87YGbxVU/1aGAPELd+vEw6vjHfdPecT80wAabH+MVyzZsLZMaaKPl+nTXkfDiwtVQODjAT3f194qyZOE8nyWtdI8wUBA/7ap0M/3qdua0tP+qnTUdydO9ocLJ1G83JGrZto0Fn5f5T8vOmozJ9zWETeDpmdYl9sfxggbqwLkUDlL6vzYfjrnhbAEouAgtQjGpVLCsLnr3WrDmk9S02AzrUMNcTF+2V9EyLtKoeKk/1aChv3dlCmlYNkSohAaa7adb6aOnz4RK5Y9JyM9nd0fhkeXH2VtOSomssaRAacUN96y+zl8iEgW1MiPr+oc7St1Wk2faGKGsQ+GhQGzPSaduRBNN9pJb8fdKEGZufs4UZXStpyZ6T5vZD19aV/u2rm21MH36VGQGlj09bdeiKPyOdTVgD11e02AC4DAILUMyyBxWbfq2qmRYPW23sXe2qm+sBHWrK7092ldUv9TCtM1ofozUqaRkWUwOjE9/pekjq4WvrmW0P7FhTHr2unrw/oLVZ4Vrptj8Y0Fruv9raDaWLQvZqFiHXZi1j8NNGa7fQr1uO2YdqqxX7TtlrXHQotn7fhlXKyag+TeTtu1rJra0iTfHwo9dZQ9J/lu6Xc1fQyqK1OLqwpVr090mH6ncAlE4EFsAFdF2kPlmTx/n7eJsgkJu2lPz+RBczv4u2vOiEc7q0wMLnrjPdPre1qWZf4Xpk78bSr7X1vo3O7KuT2i1/8QZ5566W5mv9sl6j3UK6aOS8rMJdHb7drlb5HDUuv26xXt/S8uJ969c60tTn6LpKd05aIQdirUsdFNTc7Re6oHR/NkfTLQQgbwQWwEW0+FZbQgZ2rCFhZfzzfI6OSnrj9ham5cXWUlM1NMiEGUfpAo8aXtSNTapIWX8fM4ndVf+eb+aW0eChNS8aQtSsddGmi2bZHutikDe1qHrRNjUkaf1MeDl/00Jy60fL5Pu1h81aTPlZuuek7M5qVbEFFp1ZWNnqeQAgNwIL4CItq4fJ5jE95eVbmzntewb5+8iHA9tIzQplTNGvrQVFw9DNLaqala11HaVe7y8x9S9aJ6PDs/Oi6yX99kRXU4Srxbcjf9hi5pKx1ccoHdWkRcM2WvNy3+drTFHxb1uO2etrHs+qw9HRTTbaPfT2nF1yz5RVksi8L0Cpx1pCQCmkLSFar7L1SLyZQ0bnmlHrDp6Wx7/baIYtq+d6NjSz/16OTjg3dfkB+WDeHtNioyOV/nq6m2k10snqpq+Jkv7taph5a56csemiOpW2NcPks8HtpcMb80yX1OqXukv5Mv7yzPeb7DU22pqTu8sLQOlaS4jAAiAHrSV54Yctsu1IvMx+9GrTBeWIo3Hn5b7PV5vRTDo5XreG4fL0zJyLQiodvXTodJJ9GPNLNzWW4d3qSb+Jy83XbmoRIUfiknMMc9ZQpTMIAyi9gYUuIQAXTXo3ZXB7WfHiDQ6HFRUZFiTv3t3KDK/WBSBf+GGr+frd7aqbriVba8rbd7WUqUPaS93wsqZ2xVYjc0PW+k2/bz1uwoo+pgXHakPWMgYASi9Wawbg8HDs/LSpWV6Gdasrny7ebyai0/qWcXe0MI+tP3RGWtUIk0A/H3PR4dta+6JDt9WgTjVkzcFTEhLoJ+1rVzBDrX19vMxEejuPJUpSavpFMwoDKD347QdQpJ7u0VBWZs3n8v7A1uLrY23I7ZRtsUhlCy42lYN1ZuCrLtpeZGigmTBv8+F4+zwzAEofAguAIqUh5MdHr5FMi8UMf75SbWqVl6NmRNEZAgtQilHDAqDI6Wy4RRFWVLua5c31hkPUsQClGYEFgFtrWysrsESdsa9WDaD0IbAAcGu6GGSAr7ecSUor9BIAADwfgQWAW9PlC1pWD7WPNAJQOhFYALi9DrUrXDR1v7vTYdgPfrVWPl92wNW7ApQIBBYAbq9v1sKM83fGSFxSarF8D11iYN/Js0VWJ6P7Om9njLz5x06JyVrqwF3MXBsl/T5eJtFnkly9K4DDCCwA3F7jiBBTy6ILNur6Qroe0f/9uNVcHAkYugDjpsNxkpx2YSHG7I7HJ8udk1dK9/cWy2PfbTAT2jlKn3suj+fblhZIy7CYRR/dhX527/75t2yOjpdvVrrPfgH5IbAA8Ah3tLUufjh7Q7RMWbrfzICrl2V7Y+31LTd9uFQW7Dpx0Wt1baTbJi6XNq/+JQ9+tU52H7+worS+7paPltkDhi4NoK0PjhT4amvPjeMXS8/3l1wUhjQg2eh+XiosXU5xjIpac+C0nExMMbc1/Lli5NWq/adk0W7P6d6DeyCwAPCYbiFdp2hDVJy8O3e3/etfLD9oVp/+10/bZMexBHl+1haJT0qzP34k7rz8uuWouX0+LUPm7Twhr/+2w94N9Mi09RJ7NsWsdzTxnrZSJSTALOD48DfrzeOX8+H8PXIsPtl8D53d1yYtI1O2HY03t8sF+Mqpc6nyv83WfXDUxqgz0nzsXBnz87ZChYq9MWfltV93yOHTObt9bJ+F0v3OHqyyW/z3SRn6xZpLPl5Y+lkP/nyNPPDVOtOy5Sn2nEiUD+ftKVDrm6OW742VhR5Un+UqBBYAHkGn7u/WsJK5nZ5pMesU6XJHWoj70YK9svNYgnlMw8Hbc3fZX/fd6kOSaRG5qm4FmT7MOvX/in2nzKrUq/aflpjEFClfxs+sTH1zy6ryy4gu5v7uE4mX7crRepfsXSpztx+339YWnOS0TAkO9JVHrqtnvjZ12QF7ANIAcujUORO0bPefn7VZ7pq0QuLPW8PWB/P2yLnUDPl65SF5/bedBQotK/bFyu2fLDcFvxMX7rV/Xb//nG3W/axe3rqw5W9bjl30+sTkNHlm5iZZuPuk/OM/q02rTFH536ajpmtPu6Z0P92BrnulS0lczouzt8r78/6WV3/ZXqjvocdP33NerXRDv1grQ79ca2qLcGkEFgAe46521c11peAAmXxfO7k+a4VnPZGoHk2qmOvv1kSZloGU9AyZseaw+dqQzrXN1P5aC6Mnjj+3H5dfslo9+rSoal9YUYPRsz0bmdvj//pbTp21dp/kNu73XSY4VQuznvi15cZ2QtocbW2VaFU9zKw4XcbfR3YdT5QnZ24yrT8jpm+Ua99ZJMOzWnE0GM1aHy3rDp2RD+b9bQKPtnDY1p/U4PHSj9tMV4q+p+wtORo4sp9sf996TIZMXSOJyekXDQVfuf+UCXS6IvdLNzWxP98WnGymLD1gnqe0RWHw1NWyev+FFqQrMXtjtP22BscroS1Id3yyPEeL2uVoSM3LUzM3Sudx8y/ZCnYw9pz9c/x+XbSsPVjwAPfEjE3S9rW/ZGu0teUt+2egAU6Nmr1V/tpxcZdmYaVlZMqPG6PlaNz5Qr1eg+uXyw9c8nNzNgILAI9xc4uq8v6AVjJz+FXmpDv0mtr2x8LL+cuHA1vLHW2qiTZGaK3KmJ+2mxNvREig3NjUGma0FUX9tOmIzMlqFbkl62s2gzrWNMEmITld3v3zQveTjdZfaEDx9faSqfd3kJBAX4k9m2pm41WborICS41QCSvjL+P7txY/Hy8TLq4aN9/UjijdxpMzNskbv++0b1tbVMb+b5u53ad5hIy5pam5PX1NlAz8bJV0+vd8+e/6aHOSvv+LNaZIeMCnK02NjJ5YtF5HC327N7aGuT0xZ+0n9F83W79v7+YRckPjylLW38csLLkxW7dPTGKy/GfpfnNbP+trG1YyrUX/zraPjnZzvPfn7hy1OxrEth2xtoQp7UYrbA3NruMJJshpF+F0B1ompizZbwKD7b3ZaBDRuiXNbC/8d0uO+iabHzceMdfaJam02FvDgI12FWn3mYbMvN6PtiRpONbWs0e/W29vRVNL95w016FBfmYfHvt2g/nZ/WbVIdOypd1meW0z/nyajPtjp/x94uL9tdFj9vTMzfLUzE1SGNq9+vIvO+StPy60WLoSgQWAx/Dy8pLb21SXupXKmftd6odLwyrW249fX1/KBvjKSzc3kXqVyppaiZnrrK0r93SqaV81+qYW1nCi3UH6R19bazrVqXjRWkiv9Gtmbk9fc1jmZfuvV1/z4g9bze0hV9eWRhHB0j2rZUdbbbK3sLSuUd4eED67r72ZBE/raLRO5tkbG5oWlN+2HjOB4Op6FU2o0lYa3Tc1rGtd+WeXOvLZfe2kb6tIE8riktLkuVmb5Zq3FsjyvdYWioOnkszJ+8N5f5uWFQ1bnw1uL7UrljGPbzx8xnR7ZA9oukilLcTZWppsJ9+k1AxpXSNMbmtdTd65u6U5UeuooqhT1noYPTFPWrTvkjU+Gnq0Bki76ibM33NR60rXBuEmwGkNTVS2GhttXej1/hIZ+d/NObrL9D/93D5dfCF4fLv6UJ7dLTY6fPu9v6zB8525u3PU9djqoQKyjo3WNCVk+376/TXcKg2PGpT/PnFW3v/L2qr386YjpoVPu8+0ZevuyStzDBfX19tO+Hq8D58+b7r/9Ot6WfK3tVvsvbtbSa9mVUxriwbZ0T9tk/6frjQBV1tncvto/h7zGTw8bX2O8GSjNTFa36U0+GhNU340rG3Pqr2av/OE/eflzx3H863ncgYCCwCPDjBTBrc3LQGDO1tbW8LLBcjvT3aVkb0bma4YrUcZ2LGG/TV1wstKk6ohOVptNKDkNVmdrQXn2VmbzclVvf7rDjmekGzCwHNZXUd6olFzt58wJ1dt1bC1sNhc37iyzBh+lQlWv47oKiO6N7C3nmity7t3t5LRNzc1oUZpjU6brIUfezaLkAmD2siqUd3N+9LnaFdN1dBAGXFDffOcjxbskWmrrS0N/7qliXlP9nWYDp0xLR65A1q/NhdGXmlLiHYtfZ8V8l7s09h8vtpFpl1p6pctR00rjp7U35qzyx4Ic3vrj92SmFWcqiO69sYkmkDxU1ZLxb2dakmbrDCnXSJax6EBZ9jX60ztkHa7fLxwrxmO/tA366XFy3+ax22tHxoIbN03gX7eJgQs+dvaUpGXN37baUKhSknPlFey6lD0M9FuMn8fb/nhkaslMjRQ9seeswcK89lFnZFDp5LMz1L/DjXsx+yTRftMQfS/frS2hnWsU8GEHu3W0xBh67r7Y9txE/b09VOHdDDf688dJ8yx0pFo+nOlX7u6fkWZ/I928uuILvJ8r0YmjNeoEGQPlNHZQpAeq/9usIa//SfPmVa57LRVRkOt0n1Ss3IdqxV7Y03NlC2sali8ecJSuXnCMvnXT1tlzM8XanV0WYw1hegGK2rWTlsA8FC1KpY1l+wCfH3k0evqy31X1TLdI/pfcXY3t4iwF+nm7g7KblSfJuZkryec+/6zWqqVD5Kle2LNf8oaMIL8fczztBhYTwzaWvDItA2mS0prW/Rkn13bmuXNxWboNXVMeIoMDZLIrFqYkb0amVaOZ3s2vGh/tJVI31fPphHmv3Dt/tIAsnr/afsJRVtNrq4Xbm63q1VeZm84YrpNorMC103NI+wBrVuDSmY/rSOpjsn+k2fN59Whdnm5qu6FVidt3dHWHD256Zwz2gKjdD/vaFPd/jmo9YdOyw9ZJ9NmkSGy/WiCPP/fLeakfCIhRcLK+Mn1jSuZz1/3WbtEtBBXg4N2sWlXlZ7QtdVCRzRpa4bS//bn7jhu6pZ09zUAXVO/opmjR1uXtAtFQ2F22hW2cHeMCQ36nrXL8KkZm8yEfk9M32ivS9EWuObVQuWTf7ST/pNXmuD56ZL98vC19eS/64/YW8m0zum2NtVMYH3zj132oNC+Vnn57sFOZsRY34+XmW4vrXHSny1bV5q2lun+aRB89dcd8s6cXRJ7TR3r62uXt9dQ6X7o5bHrrUF00GerzGfz08Yj8vgNDczX/th2zLS06eeldVRa99SvdaTEJKTIjLVRMmtdtGkt0pFvuh2tmdJjorVZppUvNcOEcN1fDVhauK7dlbotNW2VNfjqz0brmmHmsT+3n7D/XLkKLSwASqzgQL+Lworq26qaCRj1K5fLESBy0z/uH9/T1rSA6H/eGlbU8G51pX3WcgFKTza3trLOxmubFyZ768rlaDComdV1ox7sWle2vtJLOmULDLnpfuvJtHJIoGkF0e4rPSFrN8uoPo3tz7O9Nx0i/dd2a7fWzS2t+6n0NXqyVl+uOGDmi7HtQ3a9mkWYbWvh8H+ylhrQFgMdYTV1+YEc//n/6yfrf+YD2tcwLQbaArIxKk5WHzgtQX4+8krfZiZQaheY0voRPSFrPY2O1NKurH9cVdOEPg0rWh/0wYDWclOLCPM1Pblq4FD6GWhRs9JgYuvqOXMuVe6ctEJavfqnvX5Dw+stLSPt701baDSo6c/Ho9dbR3JpN9jYvtYWlLfn7DLz8WjtkNJgZqPfd3RWS4vZv4GtTZisUaGMqVeyfp4H5S7TPXTe1FAN61bX3o3YJKs+asICa3dZ1wbW0W95uTOr0Hz2hiP2Vp/vso7T4zfUN9vSbsBr3lwgN01YakKUhhXtFvzk3rYmaGmo1Ror2xxF2uqlYUU/c1uNjnZFac3UV//saIKK/my8dlszub11NXt3p6tXS6eFBUCpowFh3jPXmpoX7zy6g7LTk5AOh9bug/Jl/aVWhTKm+T+3t+5saSa301E3W48kmNYTZ9GT1vcPXWXCi62+RzWsEmzmgbHNHaInTm0NyO7u9tVNPYatGLZWxTL20VY2WjisrTHzd8WYWhg9GQ7rVscUdE5etE8GdKghFcv6y8j/bjEtJ1pAql1XFcsFmFaqsf/bblpONKzo56n0P3cNM7aumvf6t5aW1cPM7TG3NDOtMRpAtCtM34e2bOhQ8plrD5sWmRbVQ023ib5nrYnRMKndR58NbmdaUWytJ9ptpqHQ1mL1ZPcGkpGZaV6nLRBdGoTnaAm7p2NNE7C0sFlb1jSo/eOqWvaAZfNAlzrSqU4FE3hsrWNKW1EeurauqS/Rk37/9jXkqR4NzHGw10f1bWbqU2znf93/S9HAofUs+2PPmeJo3c7ag2fMdrQ4XN+bFmNrV5cGQn0/Q6+2jojT96jubFtdJi/eZ1qN9Gde64/Um3e2NC1Vo3/eZloJ3+/f2oT0+c9eK2eSUqVqaJAJoWWyirO3Hom3HyNX8LK4OjIVgYSEBAkNDZX4+HgJCbnQNw0ApZ3Oo2Jr9fnnNXVkzK3WloHsdGSKFv+qV/s1s9cDZaddErbWik/vayc3NqkiN3+0zAQUrRPSFietg9Buiq//2VGurn/hJKzdSHqizE1Hw2jX1hM31JdnsuqBCkNHytwzZZVpRdCuJ20t0FaxWQ93Nl1GBaUnaS3O1eCl9U+5u/byoyHgrx3HTdDKHiCz0y4pbeXRQuo1L/W4bHDWOXFmbzwi1zWqZOpJdFZmrZv69L725vF1B0+bINmudnnTepWb1srojMy2Lh9bd+F/H+5sQo3ub151XDaPfrvetIQ9el09Gdn7Qgues8/fdAkBQAlmK7xVt7TKu17n3qus3SpaX2Kb6ya3ns2qmJYVbSnp2bSKOcHqyJa6lcqak6ht/pB/39EiR1hReYUV9fZdLeW7YZ3k6RsvrtcpCA0Gsx6+2nRlaFjRVhENVYUJK0pHUGmXzxPdGxQ4rCg9+fduXvWSYUX96+YmpmVF33t+rXx3tLUek0W7T5qwoq0g2i1lo2FRP/O8woqt0PzrBzqakKNdofp6LR62tcBcLqzYugRzT47oCrSwAEAJpqNB7vnPajPiZMnz19tPUrnN2XZMqpcvYwo+C0KHu2pBpxa93toyUh7KdiJ1Nh0do6OltPD4uqxJBUsCbQHp+/Ey2XPirPTvUN2EFT1WhZGUmm6KbrW7zlE6zPuOT1aYsKoj42wj2ZzdwkJgAYASTHv9f9501NS56Jwx8EzJaRmSabHYRxOVFAUJLCXrnQMActAWFS1YhWcL9Mu7u6c0oYYFAAC4PQILAABwewQWAADg9ggsAADA7RFYAACA2yOwAAAAt0dgAQAAbo/AAgAASmZgmThxotSuXVsCAwOlU6dOsmbNmks+d8qUKdK1a1cpX768ufTo0eOi5+tMjGPGjJGqVatKUFCQec6ePdZltwEAAAocWGbOnCnPPPOMjB07VjZs2CCtWrWSXr16SUxMTJ7PX7RokQwaNEgWLlwoK1eulBo1akjPnj3lyJEj9ue8/fbbMmHCBJk8ebKsXr1aypYta7aZnJzMEQIAAAVfS0hbVDp06CAff/yxuZ+ZmWlCyIgRI+TFF1/M9/UZGRmmpUVfP3jwYNO6EhkZKc8++6w899xz5jm6pkCVKlXkyy+/lIEDBxbpWgQAAMA9FOT8XaAWltTUVFm/fr3psrFvwNvb3NfWE0ckJSVJWlqaVKhQwdw/cOCAHD9+PMc2dec1GDm6TQAAULIVaPHD2NhY00KirR/Z6f1du3Y5tI0XXnjBtKjYAoqGFds2cm/T9lhuKSkp5pI9oQEAgJLLqas1v/nmmzJjxgxT16IFu4U1btw4eeWVVy76OsEFAADPYTtvO1KdUqDAEh4eLj4+PnLixIkcX9f7ERERl33tu+++awLLvHnzpGXLlvav216n29BRQtm32bp16zy3NWrUKFP4a6MFvE2bNjW1NAAAwLMkJiaacpAiCyz+/v7Srl07mT9/vtx22232olu9//jjj1/ydToK6I033pC5c+dK+/btczxWp04dE1p0G7aAoolLRws98sgjeW4vICDAXGzKlSsnhw8fluDgYPHy8pKipPuiQUi3X1ILekv6eyzp7680vMeS/v4U79HzcQwLTltWNKxoqUiRdwlpy8aQIUNM8OjYsaN88MEHcu7cORk6dKh5XEf+VKtWzXTbqLfeesvMsfLdd9+ZuVtsdSkaMvSiAeOpp56S119/XRo0aGACzOjRo83O20JRfrTwt3r16lKc9I9kSf1DWVreY0l/f6XhPZb096d4j56PY1gw+bWsFDqwDBgwQE6ePGlCiIYPbRWZM2eOvWg2KirKBAibSZMmmdFFd911V47t6DwuL7/8srk9cuRIE3qGDx8ucXFx0qVLF7PNK6lzAQAApXgeltKmNMzxUtLfY0l/f6XhPZb096d4j56PY1i8WEsoH1oro61B2WtmSpqS/h5L+vsrDe+xpL8/xXv0fBzD4kULCwAAcHu0sAAAALdHYAEAAG6PwAIAANwegQUAALg9AstlTJw40Ux2p/PB6OrRa9asEU+lE/l16NDBzAZcuXJlMynf7t27czznuuuuMxP5Zb88/PDD4gl0Tp/c+964cWP748nJyfLYY49JxYoVzYSFd95550VLTLg7/VnM/R71ou/LU4/fkiVL5NZbbzUTRer+/vTTTzke11kXdM4nXbYjKCjILJq6Z8+eHM85ffq03HvvvWa4c1hYmDzwwANy9uxZ8YT3qCvX64KwLVq0kLJly5rn6OSbR48ezffY61InnnAM77///ov2vXfv3iXmGKq8fi/18s4773jEMRznwPnBkb+hOg/bzTffLGXKlDHbef755yU9Pb3I9pPAcgkzZ840s/rqUMoNGzZIq1atpFevXhITEyOeaPHixeaHbdWqVfLXX3+ZP5Q9e/Y0E/ZlN2zYMDl27Jj9ossqeIpmzZrl2Pdly5bZH3v66afll19+kVmzZpnPQk8Id9xxh3iStWvX5nh/ehzV3Xff7bHHT3/+9HdL/znIi+7/hAkTZPLkyWa5Dj2p6++h/vG00RPd9u3bzefx66+/mpOLTkLpCe8xKSnJ/H3R2b31evbs2eZE0bdv34ue++qrr+Y4tiNGjBBPOIZKA0r2fZ8+fXqOxz35GKrs700vU6dONYFET+qecAwXO3B+yO9vaEZGhgkrOlHsihUr5KuvvpIvv/zS/MNRZHTiOFysY8eOlscee8x+PyMjwxIZGWkZN25cifi4YmJidMJAy+LFi+1fu/baay1PPvmkxRONHTvW0qpVqzwfi4uLs/j5+VlmzZpl/9rOnTvN+1+5cqXFU+mxqlevniUzM9Pjj5/S4/Hjjz/a7+v7ioiIsLzzzjs5jmVAQIBl+vTp5v6OHTvM69auXWt/zh9//GHx8vKyHDlyxOLu7zEva9asMc87dOiQ/Wu1atWyvP/++xZ3l9f7GzJkiKVfv36XfE1JPIb6fm+44YYcX/OUY5jX+cGRv6G///67xdvb23L8+HH7cyZNmmQJCQmxpKSkWIoCLSx50IS4fv160/xso8sN6P2VK1dKSaAzhqoKFSrk+Pq3335rVuVu3ry5WRVb/wP0FNpVoE22devWNf+xafOk0mOp/zFkP57aXVSzZk2PPZ76Mzpt2jT55z//mWPBT08+frkdOHDALP+R/bjpbLfaPWs7bnqtXQjZF1XV5+vvq7bIeOrvph5TfV/ZafeBNse3adPGdDUUZVN7cVu0aJHpImjUqJFZ1PbUqVP2x0raMdRukt9++810a+XmKccwPtf5wZG/oXqtXZu2ZXqUtobq7L/aelYUCryWUGkQGxtrmreyf/BK7+/atUs8na6wrQtOXnPNNebEZnPPPfdIrVq1zEl/y5Ytpm9dm6e1mdrd6UlMmx/1D6I2tb7yyivStWtX2bZtmznp6UrjuU8Aejxti3F6Gu1D13W3tD6gJBy/vNiOTV6/h7bH9FpPhNn5+vqaP7SeeGy1q0uP26BBg3IsQfDEE09I27ZtzfvS5nYNo/pzPn78eHF32h2kXQe6sO2+ffvkpZdekj59+pgTnI+PT4k7htoVorUgubucPeUYZuZxfnDkb6he5/W7anusKBBYSiHtq9QTefYaD5W9z1iTshY6du/e3fyRqVevnrgz/QNo07JlSxNg9OT9/fffm2LNkubzzz837zn7kuyefPxgLcDt37+/KTTWRWOz03q67D/fevJ46KGHTLGkuy9XMHDgwBw/l7r/+vOorS7681nSaP2KtvDmXrzXU47hY5c4P7gDuoTyoE3qmvxzV0Dr/YiICPFkjz/+uClqW7hwoVSvXv2yz9WTvtq7d694Gv1PoGHDhmbf9ZhpF4q2SJSE43no0CGZN2+ePPjggyX2+Cnbsbnc76Fe5y6E12Z2HXXiScfWFlb02GrRY34LPOqx1fd58OBB8TTaZat/Y20/lyXlGKqlS5eaVs38fjfd9Rg+fonzgyN/Q/U6r99V22NFgcCSB02+7dq1k/nz5+doJtP7nTt3Fk+k/7XpD+OPP/4oCxYsMM2z+dm0aZO51v/UPY0OidSWBd13PZZ+fn45jqf+UdEaF088nl988YVpQteK/JJ6/JT+jOofuuzHTfvDta7Bdtz0Wv+Iah+7jf586++rLbB5SljRGiwNolrjkB89tlrjkbsrxRNER0ebGhbbz2VJOIbZWz71742OKPKkY2jJ5/zgyN9Qvd66dWuO8GkL302bNi2yHUUeZsyYYUYjfPnll6aKffjw4ZawsLAcFdCe5JFHHrGEhoZaFi1aZDl27Jj9kpSUZB7fu3ev5dVXX7WsW7fOcuDAAcvPP/9sqVu3rqVbt24WT/Dss8+a96b7vnz5ckuPHj0s4eHhptpdPfzww5aaNWtaFixYYN5j586dzcXT6Gg1fR8vvPBCjq976vFLTEy0bNy40Vz0z9H48ePNbdsImTfffNP83un72bJlixl9UadOHcv58+ft2+jdu7elTZs2ltWrV1uWLVtmadCggWXQoEEWT3iPqamplr59+1qqV69u2bRpU47fTdvIihUrVpjRJfr4vn37LNOmTbNUqlTJMnjwYIu7vz997LnnnjMjSfTnct68eZa2bduaY5ScnFwijqFNfHy8pUyZMmZkTG7ufgwfyef84Mjf0PT0dEvz5s0tPXv2NO9zzpw55j2OGjWqyPaTwHIZH330kTlA/v7+ZpjzqlWrLJ5Kf8nyunzxxRfm8aioKHNyq1Chgglq9evXtzz//PPml9ATDBgwwFK1alVzrKpVq2bu60ncRk9wjz76qKV8+fLmj8rtt99ufiE9zdy5c81x2717d46ve+rxW7hwYZ4/lzoU1ja0efTo0ZYqVaqY99W9e/eL3vupU6fMya1cuXJmCOXQoUPNCcYT3qOexC/1u6mvU+vXr7d06tTJnFACAwMtTZo0sfz73//OccJ31/enJzw9gemJS4fF6tDeYcOGXfSPnycfQ5tPP/3UEhQUZIYA5+bux1DyOT84+jf04MGDlj59+pjPQf9h1H8k09LSimw/vbJ2FgAAwG1RwwIAANwegQUAALg9AgsAAHB7BBYAAOD2CCwAAMDtEVgAAIDbI7AAAAC3R2ABAABuj8ACAADcHoEFAAC4PQILAABwewQWAAAg7u7/AQ+aHlaPBmY/AAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(torch.tensor(lossi).view(-1,1000).mean(1));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5cce4a5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "aveilles\n",
      "saien\n",
      "impôt\n",
      "répondaraîtration\n",
      "compublité\n",
      "expulent\n",
      "posée\n",
      "posée\n",
      "un\n",
      "condorégles\n",
      "subsistement\n",
      "affachés\n",
      "souèvient\n",
      "hes\n",
      "factée\n",
      "falbution\n",
      "liolé\n",
      "tymisespoquération\n",
      "pe\n",
      "nor\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(seed + 10)\n",
    "for _ in range(20):\n",
    "    word = nn.generate_word(words.itoc, g)\n",
    "    print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83bcfd29",
   "metadata": {},
   "source": [
    "## Réseau plus profond\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "91688e55",
   "metadata": {},
   "outputs": [],
   "source": [
    "def _deep_create_layers(self):\n",
    "    self.layers = [\n",
    "        Linear(self.e_dims * self.context_size, self.n_hidden, bias=False), BatchNorm1d(self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden, bias=False), BatchNorm1d(self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden, bias=False), BatchNorm1d(self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden, bias=False), BatchNorm1d(self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden, bias=False), BatchNorm1d(self.n_hidden), Tanh(),\n",
    "        Linear(n_hidden, vocab_size), BatchNorm1d(vocab_size),\n",
    "    ]\n",
    "    with torch.no_grad():\n",
    "        # last layer: make less confident\n",
    "        self.layers[-1].gamma *= 0.1\n",
    "TorchBengioFFN._create_layers = _deep_create_layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "0f24a18d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<BengioMLP\n",
      "  nb_chars=\"41\"\n",
      "  e_dims=\"10\"\n",
      "  n_hidden=\"200\"\n",
      "  context_size=\"3\"\n",
      "  steps=\"0\"\n",
      "  nb_parameters=\"176733\"/>\n",
      "      0/ 200000: 3.7337\n",
      "  10000/ 200000: 1.6387\n",
      "  20000/ 200000: 1.5760\n",
      "  30000/ 200000: 1.2514\n",
      "  40000/ 200000: 1.3076\n",
      "  50000/ 200000: 1.4092\n",
      "  60000/ 200000: 1.6595\n",
      "  70000/ 200000: 1.3982\n",
      "  80000/ 200000: 1.7699\n",
      "  90000/ 200000: 1.4177\n",
      " 100000/ 200000: 1.7193\n",
      " 110000/ 200000: 1.5801\n",
      " 120000/ 200000: 1.5591\n",
      " 130000/ 200000: 1.1626\n",
      " 140000/ 200000: 1.4381\n",
      " 150000/ 200000: 1.3407\n",
      " 160000/ 200000: 1.2633\n",
      " 170000/ 200000: 1.2788\n",
      " 180000/ 200000: 1.1989\n",
      " 190000/ 200000: 1.4888\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(seed)\n",
    "nn = TorchBengioFFN(e_dims, n_hidden, context_size, words.nb_chars, g)\n",
    "print(nn)\n",
    "max_steps = 200000\n",
    "lossi = nn.train(datasets, max_steps, mini_batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c600ecaa",
   "metadata": {},
   "source": [
    "## Fonctions utiles pour l'étude des activations: santé du réseau"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e680e1b4",
   "metadata": {},
   "source": [
    "### Histogramme d'activation (forward)\n",
    "\n",
    "Visualisation par histograme de la distribution des **activations** lors de la **passe avant**, pour les couches `Tanh`.\n",
    "On calcule la moyenne, l'écart-type et la saturation (`t.abs() > 0.97`) des valeurs.\n",
    "\n",
    "- Visualiser la sortie des `tanh`.\n",
    "- **Objectif :** une distribution étalée. Éviter les pics exclusifs à -1 et +1 (saturation).\n",
    "- **Alerte :** comme vu précédemment, si une colonne est 100% blanche (toujours saturée), le neurone est mort.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "17691ee7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_forward_tanh(layers):\n",
    "    # visualize histograms\n",
    "    plt.figure(figsize=(20, 4)) # width and height of the plot\n",
    "    legends = []\n",
    "    for i, layer in enumerate(layers[:-1]): # note: exclude the output layer\n",
    "        if isinstance(layer, Tanh):\n",
    "            t = layer.out\n",
    "            print('layer %d (%10s): mean %+.2f, std %.2f, saturated: %.2f%%' % (i, layer.__class__.__name__, t.mean(), t.std(), (t.abs() > 0.97).float().mean()*100))\n",
    "            hy, hx = torch.histogram(t, density=True)\n",
    "            plt.plot(hx[:-1].detach(), hy.detach())\n",
    "            legends.append(f'layer {i} ({layer.__class__.__name__}')\n",
    "    plt.legend(legends);\n",
    "    plt.title('activation distribution')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "f60c100e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 2 (      Tanh): mean +0.00, std 0.75, saturated: 24.47%\n",
      "layer 5 (      Tanh): mean -0.00, std 0.80, saturated: 28.20%\n",
      "layer 8 (      Tanh): mean +0.01, std 0.81, saturated: 29.75%\n",
      "layer 11 (      Tanh): mean +0.01, std 0.81, saturated: 29.84%\n",
      "layer 14 (      Tanh): mean -0.00, std 0.82, saturated: 29.47%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/f3/nrzvpdb51b7f_cd_50qlhsvr0000gn/T/ipykernel_82618/2139251471.py:8: UserWarning: Converting a tensor with requires_grad=True to a scalar may lead to unexpected behavior.\n",
      "Consider using tensor.detach() first. (Triggered internally at /Users/runner/work/pytorch/pytorch/pytorch/torch/csrc/autograd/generated/python_variable_methods.cpp:837.)\n",
      "  print('layer %d (%10s): mean %+.2f, std %.2f, saturated: %.2f%%' % (i, layer.__class__.__name__, t.mean(), t.std(), (t.abs() > 0.97).float().mean()*100))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_forward_tanh(nn.layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e58cab5",
   "metadata": {},
   "source": [
    "### Histogrammes des gradients (backward)\n",
    "\n",
    "* Visualiser les gradients des poids à chaque couche.\n",
    "* **Objectif :** Les gradients doivent avoir la même échelle (même écart-type) dans toutes les couches. Sinon, on a un problème de *vanishing* ou *exploding gradient*.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "e62da01b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_backward_tanh(layers):\n",
    "    # visualize histograms\n",
    "    plt.figure(figsize=(20, 4)) # width and height of the plot\n",
    "    legends = []\n",
    "    for i, layer in enumerate(layers[:-1]): # note: exclude the output layer\n",
    "      if isinstance(layer, Tanh):\n",
    "        t = layer.out.grad\n",
    "        print('layer %d (%10s): mean %+f, std %e' % (i, layer.__class__.__name__, t.mean(), t.std()))\n",
    "        hy, hx = torch.histogram(t, density=True)\n",
    "        plt.plot(hx[:-1].detach(), hy.detach())\n",
    "        legends.append(f'layer {i} ({layer.__class__.__name__}')\n",
    "    plt.legend(legends);\n",
    "    plt.title('gradient distribution')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f944f4e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 2 (      Tanh): mean -0.000000, std 2.198041e-03\n",
      "layer 5 (      Tanh): mean -0.000000, std 2.340218e-03\n",
      "layer 8 (      Tanh): mean -0.000000, std 2.221729e-03\n",
      "layer 11 (      Tanh): mean -0.000000, std 1.866999e-03\n",
      "layer 14 (      Tanh): mean -0.000000, std 2.408152e-03\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_backward_tanh(nn.layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08e3ed0e",
   "metadata": {},
   "source": [
    "## Exemples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a648733",
   "metadata": {},
   "source": [
    "### Test sans l'utilisation de 5/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "5661e398-61af-41d1-a56e-7ec7d777f936",
   "metadata": {},
   "outputs": [],
   "source": [
    "def _deep_create_layers(self):\n",
    "    self.layers = [\n",
    "        Linear(self.e_dims * self.context_size, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(n_hidden, vocab_size),\n",
    "    ]\n",
    "    with torch.no_grad():\n",
    "      # last layer: make less confident\n",
    "      self.layers[-1].weight *= 0.1\n",
    "      #for layer in self.layers[:-1]:\n",
    "      #  if isinstance(layer, Linear):\n",
    "      #    layer.weight *= 0. #5/3\n",
    "TorchBengioFFN._create_layers = _deep_create_layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "e890563e-21ae-4295-aa73-4ecfafd97068",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<BengioMLP\n",
      "  nb_chars=\"41\"\n",
      "  e_dims=\"10\"\n",
      "  n_hidden=\"200\"\n",
      "  context_size=\"3\"\n",
      "  steps=\"0\"\n",
      "  nb_parameters=\"175651\"/>\n",
      "      0/  10000: 3.7123\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(seed)\n",
    "nn_no_kaiming = TorchBengioFFN(e_dims, n_hidden, context_size, words.nb_chars, g)\n",
    "print(nn_no_kaiming)\n",
    "max_steps = 10000\n",
    "lossi = nn_no_kaiming.train(datasets, max_steps, mini_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "89c056e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 1 (      Tanh): mean +0.00, std 0.77, saturated: 21.77%\n",
      "layer 3 (      Tanh): mean -0.01, std 0.83, saturated: 35.48%\n",
      "layer 5 (      Tanh): mean -0.01, std 0.85, saturated: 39.14%\n",
      "layer 7 (      Tanh): mean -0.03, std 0.84, saturated: 37.41%\n",
      "layer 9 (      Tanh): mean -0.00, std 0.62, saturated: 18.83%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_forward_tanh(nn_no_kaiming.layers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81312427-1f78-4aa4-8fbb-7fed692bb246",
   "metadata": {},
   "source": [
    "### Initialisation avec un facteur trop grand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "51eafc14-628a-4a8e-bbc6-7ed211a36881",
   "metadata": {},
   "outputs": [],
   "source": [
    "def _deep_create_layers(self):\n",
    "    self.layers = [\n",
    "        Linear(self.e_dims * self.context_size, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(                  self.n_hidden, self.n_hidden), Tanh(),\n",
    "        Linear(n_hidden, vocab_size),\n",
    "    ]\n",
    "    with torch.no_grad():\n",
    "      # last layer: make less confident\n",
    "      self.layers[-1].weight *= 0.1\n",
    "      for layer in self.layers[:-1]:\n",
    "        if isinstance(layer, Linear):\n",
    "          layer.weight *= 3\n",
    "TorchBengioFFN._create_layers = _deep_create_layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "3988d583",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<BengioMLP\n",
      "  nb_chars=\"41\"\n",
      "  e_dims=\"10\"\n",
      "  n_hidden=\"200\"\n",
      "  context_size=\"3\"\n",
      "  steps=\"0\"\n",
      "  nb_parameters=\"175651\"/>\n",
      "      0/   1000: 3.7604\n"
     ]
    }
   ],
   "source": [
    "g = torch.Generator().manual_seed(seed)\n",
    "nn_no_kaiming = TorchBengioFFN(e_dims, n_hidden, context_size, words.nb_chars, g)\n",
    "print(nn_no_kaiming)\n",
    "max_steps = 1000\n",
    "lossi = nn_no_kaiming.train(datasets, max_steps, mini_batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "3182bb76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "layer 1 (      Tanh): mean -0.02, std 0.87, saturated: 49.48%\n",
      "layer 3 (      Tanh): mean -0.01, std 0.88, saturated: 53.16%\n",
      "layer 5 (      Tanh): mean -0.01, std 0.90, saturated: 56.61%\n",
      "layer 7 (      Tanh): mean -0.01, std 0.89, saturated: 54.00%\n",
      "layer 9 (      Tanh): mean +0.01, std 0.86, saturated: 47.20%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_forward_tanh(nn_no_kaiming.layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3eb7e0e8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cours_nlp_mines (3.14.2)",
   "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.14.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
