Laboratoire 8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "78bdaafd",
   "metadata": {},
   "source": [
    "### Utilisation de Google Colab\n",
    "\n",
    "Si vous utilisez Google Colab, suivez les instructions ci-dessous.\n",
    "\n",
    "Tout d'abord, sélectionnez l'option GPU de Colab avec *Edit > Notebook settings* et sélectionner GPU comme Hardware accelerator. Installer ensuite deeplib avec la commande suivante:"
   ]
  },
  {
   "cell_type": "code",
   "id": "05c04f14",
   "metadata": {},
   "source": [
    "!pip install git+https://github.com/ulaval-damas/glo4030-labs.git"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "1c729b9f",
   "metadata": {},
   "source": [
    "# Laboratoire 8: Transformers\n",
    "\n",
    "Dans ce laboratoire, nous allons implémenter l'architecture Transformer de \"Attention Is All You Need\" (Vaswani, 2017)."
   ]
  },
  {
   "cell_type": "code",
   "id": "7e48c943",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-29T19:18:22.484207Z",
     "start_time": "2024-09-29T19:18:20.001300Z"
    }
   },
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "import pathlib\n",
    "import math\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "import torch\n",
    "import torch.random\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "import torchvision.transforms as T\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import einops as ein\n",
    "\n",
    "import deeplib.training as dtrain\n",
    "import deeplib.datasets as ddatasets"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "id": "aae58cdb",
   "metadata": {},
   "source": [
    "## Partie 1: Scaled Dot-Product Attention\n",
    "\n",
    "Au cœur des transformers se trouve le principe d'attention, qui permet de se concentrer sur certaines parties de l'information plutôt que sur d'autres.\n",
    "Dans le cas des transformers, on utilise le \"Scaled Dot-Product Attention\" décrit dans \"Attention Is All You Need\".\n",
    "Ce principe fonctionne comme une requête sur une hashmap: on fait une requête $q$ (query) selon des clés $k_i$ (keys), et on reçoit la valeur $v_i$ (values) associée à $q$.\n",
    "Plus formellement, on peut représenter la hashmap comme un ensemble de pair (clé, valeur) $D = \\{(k_1, v_1), \\ldots (k_m, v_m)\\}$, où $k_i$ sont les clés et $v_i$ leur valeur associée.\n",
    "Ainsi, lorsque l'on fait la requête $q$ sur la base de données $D$, on obtient la valeur associée à $q$.\n",
    "\n",
    "L'attention est similaire à ce principle, sauf que $q$, $k_i$ et $v_i$ sont tous des vecteurs, et la réponse est une somme pondérée de $v_i$.\n",
    "Ainsi, l'attention calcule la fonction suivante:\n",
    "$$Attention(q, D) = \\sum_{i=1}^{m}{\\alpha(q, k_i)v_i}$$\n",
    "\n",
    "L'attention portée à une valeur est donnée par $\\alpha(q, k_i)$.\n",
    "Il s'agit en quelque sorte d'une mesure de la similarité entre la requête $q$ et les clés $k_i$.\n",
    "Comme le nom \"Scaled Dot-Product Attention\" laisse deviner, cette similarité, $\\alpha(\\cdot)$, est un produit scalaire entre les vecteurs $q$ et $k_i$:\n",
    "\n",
    "$$\\alpha(q, k_i) = \\frac{qk_i^T}{\\sqrt{d}} = \\frac{q \\cdot k_i }{\\sqrt{d}}$$\n",
    "\n",
    "$d$ est le nombre de dimension des vecteurs. On justifiera le facteur d'échelle de $\\frac{1}{\\sqrt{d}}$ plus tard dans le laboratoire.\n",
    "\n",
    "\n",
    "On normalise souvent cette valeur à l'aide d'une softmax afin de garder chaque pondération positive et sommant à 1.\n",
    "\n",
    "$$\\alpha(q, k_i) = \\frac{\\exp(\\alpha(q, k_i))}{\\sum_j\\exp(\\alpha(q, k_j))}$$\n",
    "\n",
    "Ainsi, le calcul d'attention dans un Transformer est:\n",
    "\n",
    "$$\\alpha(q, k_i) = \\frac{\\exp\\left(q \\cdot k_i / \\sqrt{d}\\right)}{\\sum_j\\exp\\left(q \\cdot k_i / \\sqrt{d}\\right)}$$\n",
    "\n",
    "Ensuite, il est possible de prendre une somme pondérée des valeurs $v_i$ selon $\\alpha(q, k_i)$:\n",
    "\n",
    "$$Attention(q, D) = \\sum_{i=1}^{m}{\\alpha(q, k_i)v_i}$$\n",
    "\n",
    "Dans la cellule suivante, remplisser la fonction suivante pour appliquer l'attention sur les tenseurs $q$, $k$ et $v$.\n",
    "Les dimensions des tenseurs sont spécifiés en commentaire.\n",
    "Utilisez `F.softmax` pour normaliser l'attention.\n",
    "\n",
    "Assurez-vous que votre calcul d'attention donne bien la valeur attendue."
   ]
  },
  {
   "cell_type": "code",
   "id": "ab97de76",
   "metadata": {},
   "source": [
    "def simple_attention(q, k, v):\n",
    "    \"\"\"\n",
    "    Attention simple\n",
    "    q est un tenseur de dimension (1, d)\n",
    "    k est un tenseur de dimension (n, d)\n",
    "    v est un tenseur de dimension (n, d)\n",
    "    d est la dimension des vecteurs, n le nombre de clés et de valeurs\n",
    "    La sortie devrait être de dimension (1, d)\n",
    "    \"\"\"\n",
    "    # TODO calculer le scaled-dot product attention\n",
    "    return\n",
    "    \n",
    "q = F.normalize(torch.tensor([[3.0, 3.0]]), dim=1)\n",
    "k = F.normalize(torch.tensor([[2.0, 1.5], [-4, 3], [0, 3], [-1, -4]]), dim=1)\n",
    "v = F.normalize(torch.tensor([[-1.0, 2], [3, 4], [-2, -1], [0, 2]]), dim=1)\n",
    "\n",
    "expected = torch.tensor([[-0.3584,  0.4563]])\n",
    "output = simple_attention(q, k, v)\n",
    "\n",
    "print(f'simple_attention(q, k, v) =\\t{output}')\n",
    "print(f'valeur attendue =\\t\\t{expected}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "4f279151",
   "metadata": {},
   "source": [
    "### Visualisation de l'attention\n",
    "Le produit scalaire peut aussi s'écrire sous la forme $q\\cdot k_i = \\|q\\|\\|k_i\\|\\cos(\\theta)$, où $\\theta$ est l'angle entre les vecteurs.\n",
    "Si on fait l'hypothèse que les vecteurs en jeux sont unitaires, alors on a que le produit scalaire entre deux donne une mesure d'à quel point les vecteurs sont alignés.\n",
    "On utilise cette interprétation du produit scalaire pour mieux visualiser ce que fait le Scaled Dot-Product Attention.\n",
    "\n",
    "Dans la cellule suivante, remplissez le `TODO` avec le calcul pour calculer `alpha`, le vecteur d'attention."
   ]
  },
  {
   "cell_type": "code",
   "id": "dd2934b4",
   "metadata": {},
   "source": [
    "def show_attention(q, k, v):\n",
    "    # TODO calculer le vecteur d'attention, après la softmax\n",
    "    d = q.size(-1)\n",
    "    alpha = ...\n",
    "    \n",
    "    figs, axes = plt.subplots(ncols=2, figsize=(14, 6))\n",
    "    ax = axes[0]\n",
    "    ax.arrow(0, 0, q[0][0], q[0][1], head_width=0.1, head_length=0.1, fc='red', ec='red', label='$q$')\n",
    "\n",
    "    colors = ['rosybrown', 'cornflowerblue', 'lightcoral', 'mediumpurple']\n",
    "    for i, k_i in enumerate(k):\n",
    "        ax.arrow(0, 0, k_i[0], k_i[1], head_width=0.1, head_length=0.1, label=f'$k_{i}$, $\\\\alpha(q, k_{i}) = {alpha[0][i]:.3f}$', fc=colors[i], ec=colors[i])\n",
    "\n",
    "    ax.set_xlim(-1.25, 1.25)\n",
    "    ax.set_ylim(-1.25, 1.25)\n",
    "    ax.set_xlabel('X-axis')\n",
    "    ax.set_ylabel('Y-axis')\n",
    "    ax.set_title('$q$ and $k_i$')\n",
    "    ax.legend(loc='lower right')\n",
    "    ax.set_aspect('equal', adjustable='box')\n",
    "    \n",
    "    ax = axes[1]\n",
    "    ax.arrow(0, 0, output[0][0], output[0][1], head_width=0.1, head_length=0.1, fc='red', ec='red', label='$\\sum_i v_{i} \\cdot \\\\alpha(q, k_{i})$')\n",
    "\n",
    "    for i, v_i in enumerate(v):\n",
    "        v_i = v_i * alpha[0, i]\n",
    "        ax.arrow(0, 0, v_i[0], v_i[1], head_width=0.1, head_length=0.1, label=f'$v_{i} \\cdot \\\\alpha(q, k_{i})$', fc=colors[i], ec=colors[i])\n",
    "\n",
    "    ax.set_xlim(-1.25, 1.25)\n",
    "    ax.set_ylim(-1.25, 1.25)\n",
    "    ax.set_xlabel('X-axis')\n",
    "    ax.set_ylabel('Y-axis')\n",
    "    ax.set_title(r'Valeurs pondérées par $\\alpha$')\n",
    "    ax.legend(loc='lower right')\n",
    "    ax.set_aspect('equal', adjustable='box')\n",
    "\n",
    "    plt.show()\n",
    "    \n",
    "show_attention(q, k, v)"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "7da42f1b",
   "metadata": {},
   "source": [
    "#### Questions\n",
    "- Visuellement, quel clé est la plus alignée avec $q$? Que peut-on dire de la valeur de $\\alpha$ correspondante? Qu'est-ce que cela veut-dire à propose de la valeur finale?\n",
    "- Que ce passe-t'il si vous changez tous les $k_i$ afin qu'ils soient opposés à $q$, sauf un? Quel est l'impact sur la valeur retournée par l'attention?\n",
    "- Que ce passe-t'il si vous changez tous les $k_i$ afin qu'ils soient opposés à $q$, sauf **deux** qui ont des valeurs égales? Quel est l'impact sur la valeur retournée par l'attention?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95d5198f",
   "metadata": {},
   "source": [
    "### Plusieurs requêtes\n",
    "\n",
    "Maintenant, on veut implémenter l'attention avec plusieurs requêtes $q_i$.\n",
    "On veut comparer chaque $q_i$ avec chaque $k_i$.\n",
    "Afin d'accélérer le calcul de l'attention, on va représenter cette opération grâce à une multiplication de tenseurs.\n",
    "\n",
    "$$\\text{Attention}(Q, K, V) = \\text{softmax}\\left(\\frac{QK^T}{\\sqrt{d}}\\right)V$$\n",
    "\n",
    "$$Q=\\begin{pmatrix}\n",
    "q_1\\\\\n",
    "q_2\\\\\n",
    "\\vdots\\\\\n",
    "q_n\n",
    "\\end{pmatrix}_{n\\times d}, K=\\begin{pmatrix}\n",
    "k_1\\\\\n",
    "k_2\\\\\n",
    "\\vdots\\\\\n",
    "k_n\n",
    "\\end{pmatrix}_{n\\times d}, V=\\begin{pmatrix}\n",
    "v_1\\\\\n",
    "v_2\\\\\n",
    "\\vdots\\\\\n",
    "v_n\n",
    "\\end{pmatrix}_{n\\times d}$$\n",
    "\n",
    "Chaque $q_i$, $k_i$ et $v_i$ sont des vecteurs de dimensions $d$.\n",
    "\n",
    "La comparaison de chaque $q_i$ et $k_i$ se fait lors du produit suivant:\n",
    "\n",
    "$$QK^T = \\begin{pmatrix}\n",
    "q_1\\\\\n",
    "q_2\\\\\n",
    "\\vdots\\\\\n",
    "q_n\n",
    "\\end{pmatrix}_{n\\times d} \\begin{pmatrix}\n",
    "k_1 & k_2 & \\dots & k_n\n",
    "\\end{pmatrix}_{d\\times n} = \\begin{pmatrix}\n",
    "q_1k_1 & q_1k_2 & \\dots  & q_1k_n \\\\\n",
    "q_2k_1 & q_2k_2 & \\dots  & q_2k_n \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "q_nk_1 & q_nk_2 & \\dots  & q_nk_n \\\\\n",
    "\\end{pmatrix}_{n\\times n}$$\n",
    "\n",
    "On appelle $QK^T$ la matrice d'attention.\n",
    "Chaque élément de cette matrice correspond au produit scalaire entre une requête et une clé.\n",
    "\n",
    "Si on ignore la softmax et le facteur d'échelle, on obtient bel et bien une somme pondérée des valeurs, selon la similarité entre les clés et les requêtes.\n",
    "\n",
    "$$QK^TV = \\begin{pmatrix}\n",
    "q_1k_1 & q_1k_2 & \\dots  & q_1k_n \\\\\n",
    "q_2k_1 & q_2k_2 & \\dots  & q_2k_n \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "q_nk_1 & q_nk_2 & \\dots  & q_nk_n \\\\\n",
    "\\end{pmatrix}_{n\\times n}\\begin{pmatrix}\n",
    "v_1\\\\\n",
    "v_2\\\\\n",
    "\\vdots\\\\\n",
    "v_n\n",
    "\\end{pmatrix}_{n\\times d}=\\begin{pmatrix}\n",
    "q_1k_1v_1 + q_1k_2v_2 + \\dots  + q_1k_nv_n \\\\\n",
    "q_2k_1v_1 + q_2k_2v_2 + \\dots  + q_2k_nv_n \\\\\n",
    "\\vdots \\\\\n",
    "q_nk_1v_1 + q_nk_2v_2 + \\dots  + q_nk_nv_n \\\\\n",
    "\\end{pmatrix}_{n\\times d}$$\n",
    "\n",
    "Dans la cellule suivante, implémenter l'attention en batch avec plusieurs requêtes.\n",
    "Les dimensions des tenseurs sont spécifiés en commentaire.\n",
    "\n",
    "Assurez-vous que votre calcul d'attention donne bien la valeur attendue."
   ]
  },
  {
   "cell_type": "code",
   "id": "4d11c2d2",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "def scaled_dot_product_attention(q, k, v, mask=None):\n",
    "    \"\"\"\n",
    "    Attention sur batch\n",
    "    q est un tenseur de dimension (b, n, d)\n",
    "    k est un tenseur de dimension (b, n, d)\n",
    "    v est un tenseur de dimension (b, n, d)\n",
    "    b est la taille de la mini-batch, n le nombre de clés et de valeurs, d est la dimension des vecteurs\n",
    "    La sortie devrait être de dimension (b, n, d)\n",
    "    \"\"\"\n",
    "    # TODO\n",
    "    attention = ...\n",
    "    if mask is not None:\n",
    "        # NE PAS FAIRE TOUT DE SUITE, voir plus bas.\n",
    "        # Commencez par calculer la matrice d'attention sans le masque\n",
    "        # TODO appliquer un masque sur `attention`, détails dans la cellule suivante\n",
    "        ...\n",
    "    \n",
    "    # TODO calculer la somme pondérée de v selon attention\n",
    "    return\n",
    "\n",
    "q = F.normalize(torch.tensor([[3.0, 3.0], [-1, 3.2], [0.2, -0.4], [0, -1]]), dim=1).unsqueeze(0)\n",
    "k = F.normalize(torch.tensor([[2.0, 1.5], [-4, 3], [0, 3], [-1, -4]]), dim=1).unsqueeze(0)\n",
    "v = F.normalize(torch.tensor([[-1.0, 2], [3, 4], [2, -3], [0, 2]]), dim=1).unsqueeze(0)\n",
    "\n",
    "expected = torch.tensor([[[0.1089, 0.3322], [0.2860, 0.2639], [0.0600, 0.6791], [0.0986, 0.7087]]])\n",
    "output = scaled_dot_product_attention(q, k, v)\n",
    "\n",
    "print(f'scaled_dot_product_attention(q, k, v) =\\n{output}')\n",
    "print(f'valeur attendue =\\n{expected}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "b962ca3a",
   "metadata": {},
   "source": [
    "#### Questions\n",
    "- Quelle est la taille du tenseur lorsque l'on multiple $q$ et $v$? Est-ce problématique pour le temps de calculs et la mémoire utilisée si $n$ (le nombre de queries, keys et valeurs) augmente?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e499e915",
   "metadata": {},
   "source": [
    "#### Masques\n",
    "Implémentez l'opération de masque dans la fonction `scaled_dot_product_attention`.\n",
    "Le masque permet d'empêcher certaines requêtes de porter attention à certaines valeurs.\n",
    "\n",
    "Ceci est possible en remplaçant les éléments de la matrice d'attention par $-\\infty$ où `mask` est `False`"
   ]
  },
  {
   "cell_type": "code",
   "id": "0002375a",
   "metadata": {},
   "source": [
    "q = F.normalize(torch.tensor([[3.0, 3.0], [-1, 3.2], [0.2, -0.4], [0, -1]]), dim=1).unsqueeze(0)\n",
    "k = F.normalize(torch.tensor([[2.0, 1.5], [-4, 3], [0, 3], [-1, -4]]), dim=1).unsqueeze(0)\n",
    "v = F.normalize(torch.tensor([[-1.0, 2], [3, 4], [2, -3], [0, 2]]), dim=1).unsqueeze(0)\n",
    "mask = torch.tensor([[1, 0, 0, 0], [1, 1, 0, 0], [1, 1, 1, 0], [1, 1, 1, 1]], dtype=torch.bool)\n",
    "\n",
    "expected = torch.tensor([[[-0.4472,  0.8944], [ 0.1639,  0.8393], [ 0.1129,  0.3967], [ 0.0986,  0.7087]]])\n",
    "output = scaled_dot_product_attention(q, k, v, mask)\n",
    "\n",
    "print(f'scaled_dot_product_attention(q, k, v) =\\n{output}')\n",
    "print(f'valeur attendue =\\n{expected}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "c467e9c4",
   "metadata": {},
   "source": [
    "#### Visualisation de l'attention\n",
    "Il est aussi possible de visualiser directement la matrice d'attention.\n",
    "\n",
    "Dans la cellule suivate, calculez l'attention avec un masque."
   ]
  },
  {
   "cell_type": "code",
   "id": "f29419ef",
   "metadata": {},
   "source": [
    "q = F.normalize(torch.tensor([[3.0, 3.0], [-1, 3.2], [0.2, -0.4], [0, -1]]), dim=1).unsqueeze(0)\n",
    "k = F.normalize(torch.tensor([[2.0, 1.5], [-4, 3], [0, 3], [-1, -4]]), dim=1).unsqueeze(0)\n",
    "v = F.normalize(torch.tensor([[-1.0, 2], [3, 4], [2, -3], [0, 2]]), dim=1).unsqueeze(0)\n",
    "mask = torch.tensor([[1, 0, 0, 0], [1, 1, 0, 0], [1, 1, 1, 0], [1, 1, 1, 1]], dtype=torch.bool)\n",
    "# mask = torch.ones((4, 4), dtype=torch.bool)\n",
    "\n",
    "# TODO\n",
    "attention = ...\n",
    "softmax = ...\n",
    "output = ...\n",
    "\n",
    "qs = [f'$q_{i}$' for i in range(q.size(1))]\n",
    "ks = [f'$k_{i}$' for i in range(q.size(1))]\n",
    "\n",
    "plt.imshow((softmax[0]))\n",
    "\n",
    "plt.xticks(range(q.size(1)), ks)\n",
    "plt.yticks(range(q.size(1)), qs)\n",
    "\n",
    "plt.xlabel('Keys')\n",
    "plt.ylabel('Queries')\n",
    "\n",
    "plt.colorbar()\n",
    "plt.show()"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "e0a215d7",
   "metadata": {},
   "source": [
    "#### Questions\n",
    "- Que se passe-t'il lors de l'ajout d'un masque?\n",
    "\n",
    "- Pour les questions suivantes, n'utilisez pas de masque.\n",
    "\n",
    "- Que se passe-t'il si on change l'ordre des requêtes $q$? Vous pouvez changer l'ordre manuellement avec `q = q[:, [1, 0, 2, 3]]`.\n",
    "\n",
    "- Que se passe-t'il si on change l'ordre des clés et des valeurs? Vous devez permuter $k$ et $v$ de la même façon.\n",
    "\n",
    "- Est-ce l'invariance à l'ordre des entrées est problématique? Quant est-t'il si l'ordre est important? par exemple en traitement de la langue naturelle.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "653ebbfa",
   "metadata": {},
   "source": [
    "### Encodage de position\n",
    "Comme on vient de le remarquer, les Transformers sont invariants à la permutation des $q_i$ et des paires $(k_i, v_i)$, on doit donc encoder l'information sur la position directement dans ces vecteurs.\n",
    "Pour ce faire, on utilise une suite de sinus et de cosinus.\n",
    "\n",
    "L'idée est de générer des vecteurs où chaque composante oscille à des fréquences différentes.\n",
    "Comme illustré dans la figure suivante issue de [Visual Guide to Transformer Neural Networks, Hedu AI](https://www.youtube.com/watch?v=dichIcUZfOw), chaque vecteur (une slice verticale dans le graphique) permet de représenter une position dans la séquence.\n",
    "Les composantes avec une fréquence faible (en bleu) permettent d'avoir un estimé de la position sur l'ensemble de la séquence, mais avec peu de précision.\n",
    "Les composantes avec une fréquence élevée (en rouge) permettent d'avoir une estimation plus précise de la position, mais seulement sur une petite partie de la séquence puisque les valeurs se répètent périodiquement."
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-29T19:27:17.967021Z",
     "start_time": "2024-09-29T19:27:17.789147Z"
    }
   },
   "cell_type": "code",
   "source": [
    "fig, axs = plt.subplots(3, 1, figsize=(8, 8), sharex=True)\n",
    "\n",
    "# Define the x values (word positions) and different frequencies\n",
    "x = np.linspace(0, 10, 1000)\n",
    "y1 = np.sin(10 * x)  # High frequency for i = 0\n",
    "y2 = np.sin(5 * x)   # Medium frequency for i = 2\n",
    "y3 = np.sin(2 * x)   # Low frequency for i = 4\n",
    "\n",
    "# Plot the sine waves on individual axes\n",
    "axs[0].plot(x, y1, color='magenta', label='i = 0')\n",
    "axs[1].plot(x, y2, color='purple', label='i = 2')\n",
    "axs[2].plot(x, y3, color='cyan', label='i = 4')\n",
    "\n",
    "# Highlight specific word positions (x = 0, x = 7.5)\n",
    "highlight_x = [0, 8]\n",
    "highlight_y1 = [np.sin(10 * pos) for pos in highlight_x]\n",
    "highlight_y2 = [np.sin(5 * pos) for pos in highlight_x]\n",
    "highlight_y3 = [np.sin(2 * pos) for pos in highlight_x]\n",
    "\n",
    "# Highlight points on the curves for each axis\n",
    "axs[0].scatter(highlight_x, highlight_y1, color='magenta', s=100, zorder=5)\n",
    "axs[1].scatter(highlight_x, highlight_y2, color='purple', s=100, zorder=5)\n",
    "axs[2].scatter(highlight_x, highlight_y3, color='cyan', s=100, zorder=5)\n",
    "\n",
    "# Add dashed circles around points for each plot\n",
    "for x_val, y_val in zip(highlight_x, highlight_y1):\n",
    "    axs[0].add_patch(plt.Circle((x_val, y_val), 0.25, color='red', fill=False, linestyle='--', linewidth=2))\n",
    "\n",
    "for x_val, y_val in zip(highlight_x, highlight_y2):\n",
    "    axs[1].add_patch(plt.Circle((x_val, y_val), 0.25, color='red', fill=False, linestyle='--', linewidth=2))\n",
    "\n",
    "for x_val, y_val in zip(highlight_x, highlight_y3):\n",
    "    axs[2].add_patch(plt.Circle((x_val, y_val), 0.25, color='red', fill=False, linestyle='--', linewidth=2))\n",
    "\n",
    "# Add vertical lines at the highlight positions across all subplots\n",
    "for ax in axs:\n",
    "    for h_x in highlight_x[1:]:\n",
    "        ax.axvline(h_x, color='orange', linestyle='--', linewidth=2)\n",
    "\n",
    "# Set labels for each subplot\n",
    "axs[0].set_ylabel('i = 0')\n",
    "axs[1].set_ylabel('i = 2')\n",
    "axs[2].set_ylabel('i = 4')\n",
    "axs[2].set_xlabel('Word Position')\n",
    "\n",
    "# Set grid and titles\n",
    "for ax in axs:\n",
    "    ax.grid(True, which='both', linestyle='--', linewidth=0.5)\n",
    "    ax.axhline(0, color='black',linewidth=1)\n",
    "    ax.axvline(0, color='black',linewidth=1)\n",
    "\n",
    "# Add a shared title for all subplots\n",
    "fig.suptitle('Position Embeddings', fontsize=16)\n",
    "\n",
    "# Show all word positions\n",
    "for ax in axs:\n",
    "    ax.set_xticks(np.arange(0, 11, 1))\n",
    "\n",
    "# Adjust layout\n",
    "plt.tight_layout(rect=[0, 0, 1, 0.96])\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ],
   "id": "a6c0801728b74ca2",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 800x800 with 3 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "Dans la cellule suivante, implémenter un encodage de position similaire à ce qui est utilisé dans \"Attention Is All You Need\".\n",
    "Il faudra générer un tenseur de dimensions $(1, n, d)$, où $n$ est le nombre d'éléments et $d$ le nombre de dimension de $q_i$.\n",
    "Générez l'encodage selon cet encodage:\n",
    "\n",
    "$$\\text{PE}_{pos, 2i} = \\sin(\\text{pos} / 10000^{i/d})$$\n",
    "\n",
    "$$\\text{PE}_{pos, 2i + 1} = \\cos(\\text{pos} / 10000^{i/d})$$\n",
    "\n",
    "Où $\\text{pos}$ est la position dans la séquence (de 0 à $n - 1$) et $i$ est l'index dans le vecteur (de 0 à $d - 1$)."
   ],
   "id": "1c13039a72ae9164"
  },
  {
   "cell_type": "code",
   "id": "b32ebae2",
   "metadata": {},
   "source": [
    "def position_encoding(n_keys: int, dimension: int, device: torch.device = torch.device(\"cpu\")):\n",
    "    pos = torch.arange(n_keys, dtype=torch.float, device=device).reshape(1, -1, 1)\n",
    "    dim = torch.arange(dimension, dtype=torch.float, device=device).reshape(1, 1, -1)\n",
    "    # TODO\n",
    "    phase = ...\n",
    "\n",
    "    return torch.where(dim.long() % 2 == 0, torch.sin(phase), torch.cos(phase))\n",
    "\n",
    "pe = position_encoding(64, 128)\n",
    "plt.imshow(pe.squeeze())\n",
    "plt.xlabel('dimension')\n",
    "plt.ylabel('n')\n",
    "plt.show()"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "1fe9690e",
   "metadata": {},
   "source": [
    "Dans la cellule suivante, ajoutez de l'encodage de position sur $q$ et $k$."
   ]
  },
  {
   "cell_type": "code",
   "id": "e4def6ec",
   "metadata": {},
   "source": [
    "q = F.normalize(torch.tensor([[3.0, 3.0], [-1, 3.2], [0.2, -0.4], [0, -1]]), dim=1).unsqueeze(0)\n",
    "k = F.normalize(torch.tensor([[2.0, 1.5], [-4, 3], [0, 3], [-1, -4]]), dim=1).unsqueeze(0)\n",
    "v = F.normalize(torch.tensor([[-1.0, 2], [3, 4], [2, -3], [0, 2]]), dim=1).unsqueeze(0)\n",
    "\n",
    "_, n, d = q.shape\n",
    "\n",
    "# TODO\n",
    "q = ...\n",
    "k = ...\n",
    "\n",
    "scaled_dot_product_attention(q, k, v)"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "a99bcec4",
   "metadata": {},
   "source": [
    "#### Questions\n",
    "- Maintenant, que se passe-t'il lorsque l'on permute les $q_i$? et les $(k_i, v_i)$ après l'ajout de l'encodage de position?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8290c315",
   "metadata": {},
   "source": [
    "### Le \"Scaled\" dans Scaled Dot-Product Attention\n",
    "\n",
    "Le facteur de $\\frac{1}{\\sqrt{d}}$ peut sembler inutile, pourtant, il est crucial à l'optimisation des Transformers.\n",
    "Si on fait l'hypothèse que $q_i$ et $k_i$ suivent une distribution normale $\\mathcal{N}(0, 1)$, le produit entre $q$ et $k$ aura une variance de $d$.\n",
    "Il faut donc diviser par $\\sqrt{d}$ afin d'obtenir une variance de $1$.\n",
    "\n",
    "Dans la cellule suivante, calculez `attention` en faisant le produit entre $q$ et $k$ sans le facteur d'échelle.\n",
    "Ensuite, calculez `scaled_attention` en y ajoutant le facteur de $\\frac{1}{\\sqrt{d}}$.\n",
    "\n",
    "Comparez la variance dans les deux cas."
   ]
  },
  {
   "cell_type": "code",
   "id": "dd41f0c6",
   "metadata": {},
   "source": [
    "torch.manual_seed(1337)\n",
    "num_tokens = 32\n",
    "dimension = 256\n",
    "\n",
    "q = torch.randn(num_tokens, dimension)\n",
    "k = torch.randn(num_tokens, dimension)\n",
    "\n",
    "# TODO\n",
    "attention = ...\n",
    "# TODO\n",
    "scaled_attention = ...\n",
    "\n",
    "print(f'Variance sans scaling: {attention.var()}')\n",
    "print(f'Variance avec scaling: {scaled_attention.var()}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "61673f8d",
   "metadata": {},
   "source": [
    "#### Questions\n",
    "- Justifiez pourquoi la variance est de $d$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b09ef453",
   "metadata": {},
   "source": [
    "#### Impact sur les Transformers\n",
    "\n",
    "Quel est l'impact d'une grande variance sur la softmax?\n",
    "\n",
    "Comparez la sortie de la softmax des vecteurs `attention` et `scaled_attention` de la cellule précédente."
   ]
  },
  {
   "cell_type": "code",
   "source": [
    "# TODO\n",
    "low_variance_softmax = ...\n",
    "high_variance_softmax =  ...\n",
    "\n",
    "print(f'Softmax avec faible variance:\\n\\t{[round(x.item(), 5) for x in low_variance_softmax]}')\n",
    "print(f'Softmax avec haute variance:\\n\\t{[round(x.item(), 5) for x in high_variance_softmax]}')"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "6d882dccba104baa",
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "53bd881e",
   "metadata": {},
   "source": [
    "#### Questions\n",
    "- Que remarquez-vous du vecteur softmax lorsque la variance est grande?\n",
    "\n",
    "- Pourquoi est-ce que ceci serait mauvais le Transformer?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4658024",
   "metadata": {},
   "source": [
    "## Partie 2: Multi-Head Attention\n",
    "On va maintenant créer un module PyTorch utilisant l'attention."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea69c518",
   "metadata": {},
   "source": [
    "### AttentionHead\n",
    "On commence par définir `AttentionHead`, un module représentant une tête d'attention à l'intérieur d'un Transformer.\n",
    "- On projette `q`, `k`, et `v` avec des couches linéaires sans biais.\n",
    "- On applique du dropout sur la matrice d'attention après la softmax.\n",
    "\n",
    "Remplissez les TODOs dans le code suivant."
   ]
  },
  {
   "cell_type": "code",
   "id": "858e2f9a",
   "metadata": {},
   "source": [
    "class AttentionHead(nn.Module):\n",
    "    def __init__(self, dim_embed: int, head_size: int, dropout: float):\n",
    "        super().__init__()\n",
    "        # TODO trois couches linéaires sans biais\n",
    "        self.q_proj = ...\n",
    "        self.k_proj = ...\n",
    "        self.v_proj = ...\n",
    "        \n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, q, k, v, mask=None):\n",
    "        B, T, C = q.shape\n",
    "        # TODO appliquer les couches lineaires  à q, k et v\n",
    "        q = ...\n",
    "        k = ...\n",
    "        v = ...\n",
    "        \n",
    "        # TODO calculer la matrice d'attention\n",
    "        attention = ...\n",
    "        \n",
    "        # TODO\n",
    "        if mask is not None:\n",
    "            # Appliquer le masque\n",
    "            ...\n",
    "    \n",
    "        softmax = ...\n",
    "        \n",
    "        # Appliquer du dropout après la softmax\n",
    "        softmax = self.dropout(softmax)\n",
    "        \n",
    "        # TODO\n",
    "        return\n",
    "\n",
    "    \n",
    "head = AttentionHead(16, 32, 0.1)\n",
    "x = torch.randn((1, 6, 16))\n",
    "output = head(x, x, x)\n",
    "\n",
    "print(f'Shape \\t\\t= {tuple(output.shape)}')\n",
    "print(f'Expected shape \\t= {(1, 6, 32)}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "4bb99765",
   "metadata": {},
   "source": [
    "### Multi-Head Attention\n",
    "On définit maintenant le module `MultiHeadAttention` qui utilise plusieurs têtes d'attention séparées.\n",
    "- Plusieurs têtes d'attention.\n",
    "- Concaténation des sorties de chaque tête\n",
    "- Couche linéaire\n",
    "- Dropout\n",
    "\n",
    "Remplissez les TODOs dans le code suivant."
   ]
  },
  {
   "cell_type": "code",
   "id": "005990f2",
   "metadata": {},
   "source": [
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, num_heads: int, dim_embed: int, head_size: int, dropout: float):\n",
    "        super().__init__()\n",
    "        # TODO créer une liste de `num_heads` modules AttentionHead\n",
    "        self.heads = nn.ModuleList(...)\n",
    "        self.fc = nn.Linear(num_heads * head_size, dim_embed)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "    def forward(self, q, k, v, mask=None):\n",
    "        out = torch.cat([h(q, k, v, mask) for h in self.heads], dim=-1)\n",
    "        # TODO appliquer fc suivit de dropout\n",
    "        return\n",
    "\n",
    "    \n",
    "m_head = MultiHeadAttention(3, 32, 256, 0.1)\n",
    "x = torch.randn((1, 6, 32))\n",
    "output = m_head(x, x, x)\n",
    "\n",
    "print(f'Shape \\t\\t= {tuple(output.shape)}')\n",
    "print(f'Expected shape \\t= {(1, 6, 32)}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "8653e212",
   "metadata": {},
   "source": [
    "## Partie 3: TransformerEncoderLayer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a82fb3d",
   "metadata": {},
   "source": [
    "### FeedForward\n",
    "On définit maintenant le réseau `FeedForward` utilisé dans le Transformer.\n",
    "\n",
    "- Linear: dim_model -> 4 * dim_model\n",
    "- ReLU\n",
    "- Linear: 4 * dim_model -> dim_model\n",
    "- Dropout"
   ]
  },
  {
   "cell_type": "code",
   "id": "05e97326",
   "metadata": {},
   "source": [
    "class FeedForward(nn.Module):\n",
    "    def __init__(self, dim_model: int, dropout: float):\n",
    "        super().__init__()\n",
    "        # TODO Créer le réseau selon les indications de la cellule précédente\n",
    "        self.ffn = nn.Sequential(\n",
    "            ...\n",
    "        )\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.ffn(x)\n"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "e9ad204d",
   "metadata": {},
   "source": [
    "### TransformerEncoderLayer\n",
    "On peut maintenant construire une couche du Transformer.\n",
    "\n",
    "- LayerNorm\n",
    "- MultiHeadAttention\n",
    "- Connexion résiduelle\n",
    "- LayerNorm\n",
    "- FeedForward\n",
    "- Connexion résiduelle"
   ]
  },
  {
   "cell_type": "code",
   "id": "6ff2d9dd",
   "metadata": {},
   "source": [
    "class TransformerEncoderLayer(nn.Module):\n",
    "    def __init__(self, dim_model: int, num_head: int, dropout: float):\n",
    "        super().__init__()\n",
    "        head_size = dim_model // num_head\n",
    "        self.attention = MultiHeadAttention(num_head, dim_model, head_size, dropout)\n",
    "        self.ffn = FeedForward(dim_model, dropout)\n",
    "        self.norm1_q = nn.LayerNorm(dim_model)\n",
    "        self.norm1_k = nn.LayerNorm(dim_model)\n",
    "        self.norm1_v = nn.LayerNorm(dim_model)\n",
    "        self.norm2 = nn.LayerNorm(dim_model)\n",
    "        \n",
    "    def forward(self, q, k, v, mask=None):\n",
    "        # TODO appliquer LayerNorm à q, k et v\n",
    "        q = ...\n",
    "        k = ...\n",
    "        v = ...\n",
    "        \n",
    "        q = q + self.attention(q, k, v, mask)\n",
    "        q = q + self.ffn(self.norm2(q))\n",
    "        return q\n",
    "    \n",
    "transf = TransformerEncoderLayer(64, 2, 0.1)\n",
    "x = torch.randn((1, 6, 64))\n",
    "output = transf(x, x, x)\n",
    "\n",
    "print(f'Shape \\t\\t= {tuple(output.shape)}')\n",
    "print(f'Expected shape \\t= {(1, 6, 64)}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "93c5bebb",
   "metadata": {},
   "source": [
    "## Partie 4: TransformerEncoder\n",
    "On peut maintenant tout mettre ensemble et construire le `TransformerEncoder`!"
   ]
  },
  {
   "cell_type": "code",
   "id": "bfb6b0ff",
   "metadata": {},
   "source": [
    "class TransformerEncoder(nn.Module):\n",
    "    def __init__(self, num_layers: int, dim_model: int, num_heads: int, out_size: int, dropout: float):\n",
    "        super().__init__()\n",
    "        # TODO Créer une liste de `num_layers` modules TransformerEncoderLayer\n",
    "        self.layers = nn.ModuleList(...)\n",
    "        self.norm = nn.LayerNorm(dim_model)\n",
    "        self.fc = nn.Linear(dim_model, out_size)\n",
    "        \n",
    "        self.apply(self._init_weights)\n",
    "        \n",
    "    def _init_weights(self, module):\n",
    "        if isinstance(module, nn.Linear):\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "            if module.bias is not None:\n",
    "                torch.nn.init.zeros_(module.bias)\n",
    "        elif isinstance(module, nn.Embedding):\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "        \n",
    "    def forward(self, x, mask=None):\n",
    "        batch_size, num_tokens, dim = x.shape\n",
    "        # TODO ajouter l'encodage de position avec `position_encoding`\n",
    "        x += ...\n",
    "        \n",
    "        for layer in self.layers:\n",
    "            # TODO appeler layer avec x comme valeur de q, k et v, ne pas oublier de passer le mask\n",
    "            x = ...\n",
    "            \n",
    "        x = self.norm(x)\n",
    "        x = self.fc(x)\n",
    "        \n",
    "        return x\n",
    "    \n",
    "x = torch.randn((2, 64, 64))\n",
    "\n",
    "transformer_enc = TransformerEncoder(6, 64, 2, 10, 0.0)\n",
    "output = transformer_enc(x)\n",
    "\n",
    "print(f'Shape \\t\\t= {tuple(output.shape)}')\n",
    "print(f'Expected shape \\t= {(2, 64, 10)}')"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "061452ec",
   "metadata": {},
   "source": [
    "## Partie 5: Entraînement\n",
    "On entraîne maintenant notre Transformer à prédire du texte.\n",
    "- Inspiré par https://github.com/karpathy/ng-video-lecture/tree/master de Andrej karpathy\n"
   ]
  },
  {
   "cell_type": "code",
   "id": "e14995a9",
   "metadata": {},
   "source": [
    "# Télécharger les données localement\n",
    "!curl -o ~/GLO-4030/datasets/tiny_shakespeare.txt https://raw.githubusercontent.com/karpathy/ng-video-lecture/master/input.txt"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "source": [
    "# Sur Google Colab\n",
    "import requests\n",
    "\n",
    "url = 'https://raw.githubusercontent.com/karpathy/ng-video-lecture/master/input.txt'\n",
    "res = requests.get(url)\n",
    "text = res.content.decode('utf-8')\n",
    "\n",
    "# Extrait des données\n",
    "print(text[:147])"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3f84289ca55c4c4b",
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "129b76b8",
   "metadata": {},
   "source": [
    "# Sur Calcul Québec et localement\n",
    "# Charger les données\n",
    "data_path = pathlib.Path('~/GLO-4030/datasets/tiny_shakespeare.txt').expanduser()\n",
    "with open(data_path, 'r') as f:\n",
    "    text = f.read()\n",
    "\n",
    "# Extrait des données\n",
    "print(text[:147])"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "77e78d6f",
   "metadata": {},
   "source": [
    "# Calculer le vocabulaire (les caractères utilisés dans le texte)\n",
    "characters = sorted(list(set(text)))\n",
    "vocab_size = len(characters)\n",
    "\n",
    "str_to_int = {c:i for i, c in enumerate(characters)}\n",
    "int_to_str = {v: k for k, v in str_to_int.items()}\n",
    "\n",
    "# Fonction utilitaires pour convertir les caractères en entier, et inversement\n",
    "def encode(s):\n",
    "    return [str_to_int[c] for c in s]\n",
    "\n",
    "def decode(s):\n",
    "    return [int_to_str[c] for c in s]"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "9459bc61",
   "metadata": {},
   "source": [
    "data = torch.tensor(encode(text), dtype=torch.long)\n",
    "\n",
    "n = int(0.9*len(data))\n",
    "train_data = data[:n]\n",
    "val_data = data[n:]\n",
    "batch_size = 128\n",
    "\n",
    "# Générer une batch aléatoire\n",
    "def get_batch(split, block_size, device):\n",
    "    data = train_data if split == 'train' else val_data\n",
    "    indices = torch.randint(len(data) - block_size, (batch_size,))\n",
    "    x = torch.stack([data[i:i+block_size] for i in indices])\n",
    "    y = torch.stack([data[i+1:i+block_size+1] for i in indices])\n",
    "    x, y = x.to(device), y.to(device)\n",
    "    return x, y\n",
    "\n",
    "print(get_batch('train', 256, 'cpu'))"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "1b1d3aac",
   "metadata": {},
   "source": [
    "class TransformerNLP(nn.Module):\n",
    "    def __init__(self, num_layers: int, dim_model: int, num_heads: int, out_size: int, dropout: float, vocab_size: int, block_size: int):\n",
    "        super().__init__()\n",
    "        # Embedding pour convertir des entiers en vecteurs\n",
    "        # Il s'agit essentiellement d'un tableau associant chaque entier à un vecteur\n",
    "        self.embedding = nn.Embedding(vocab_size, dim_model)\n",
    "        # Notre transformer!\n",
    "        self.transformer = TransformerEncoder(num_layers, dim_model, num_heads, out_size, dropout)\n",
    "        # Masque pour éviter que les lettre puissent porter attention aux lettres subséquentes\n",
    "        # On ne veut permettre aux lettres que de porter attention aux lettres précédentes\n",
    "        # On utilise `tril` afin de générer une matrice triangulaire inférieure\n",
    "        self.register_buffer('mask', torch.tril(torch.ones(block_size, block_size)))\n",
    "        \n",
    "    def forward(self, x):\n",
    "        B, T = x.shape\n",
    "        # TODO appliquer l'embedding\n",
    "        x = ...\n",
    "        \n",
    "        # TODO encodage de position\n",
    "        x = ...\n",
    "        \n",
    "        # TODO passer x dans le transformer\n",
    "        x = ...\n",
    "        return x\n",
    "        \n",
    "    def loss(self, pred, y):\n",
    "        B, T, C = pred.shape\n",
    "        pred = pred.view(B * T, C)\n",
    "        y = y.view(B * T)\n",
    "        return F.cross_entropy(pred, y)\n",
    "    \n",
    "    def generate(self, idx, max_new_tokens, block_size):\n",
    "        # Génère du texte avec le modèle\n",
    "        for _ in range(max_new_tokens):\n",
    "            idx_cond = idx[:, -block_size:]\n",
    "            logits = self(idx_cond)\n",
    "            logits = logits[:, -1, :]\n",
    "            probs = F.softmax(logits, dim=-1)\n",
    "            idx_next = torch.multinomial(probs, num_samples=1)\n",
    "            idx = torch.cat((idx, idx_next), dim=1)\n",
    "        return idx"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "fd5670ec",
   "metadata": {},
   "source": [
    "block_size = 128\n",
    "max_iters = 10_000\n",
    "eval_interval = 1000\n",
    "learning_rate = 3e-4\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "eval_iters = 200\n",
    "n_embd = 384\n",
    "n_head = 6\n",
    "n_layer = 6\n",
    "dropout = 0.1\n",
    "\n",
    "# Model\n",
    "model = TransformerNLP(n_layer, n_embd, n_head, vocab_size, dropout, vocab_size, block_size)\n",
    "# Load a pretrained model\n",
    "model.load_state_dict(torch.load('checkpoints/transformer_nlp.pth', weights_only=True))\n",
    "model = model.to(device)\n",
    "\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "3705d011",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "iter_loss = []\n",
    "for i in range(max_iters):\n",
    "    if i % eval_interval == 0 or i == max_iters - 1:\n",
    "        with torch.no_grad():\n",
    "            out = {}\n",
    "            model.eval()\n",
    "            for split in ['train', 'val']:\n",
    "                losses = torch.zeros(eval_iters)\n",
    "                for k in range(eval_iters):\n",
    "                    x, y = get_batch(split, block_size, device)\n",
    "                    pred = model(x)\n",
    "                    loss = model.loss(pred, y)\n",
    "                    losses[k] = loss.item()\n",
    "                out[split] = losses.mean()\n",
    "            print(f\"step {i}: train loss {out['train'].item():.4f}, val loss {out['val'].item():.4f}\")\n",
    "            iter_loss.append((out['train'].item(), out['val'].item()))\n",
    "            model.train()\n",
    "    x, y = get_batch('train', block_size, device)\n",
    "        \n",
    "    pred = model(x)\n",
    "    loss = model.loss(pred, y)\n",
    "        \n",
    "    optimizer.zero_grad(set_to_none=True)\n",
    "    loss.backward()\n",
    "    optimizer.step()"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "45f163fe",
   "metadata": {},
   "source": [
    "iter_loss_np = np.array(iter_loss)\n",
    "plt.plot(iter_loss_np[:, 0], label='train')\n",
    "plt.plot(iter_loss_np[:, 1], label='valid')\n",
    "plt.legend()\n",
    "plt.show()"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "60bc695f",
   "metadata": {},
   "source": [
    "# Prediction du texte\n",
    "context = torch.zeros((1, 1), dtype=torch.long, device=device)\n",
    "print(''.join(decode(model.generate(context, 500, block_size)[0].tolist())))"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "aca9a706",
   "metadata": {},
   "source": [
    "# Sauvegarde des poids\n",
    "torch.save(model.state_dict(), pathlib.Path('~/GLO-4030/datasets/transformer_nlp.pth').expanduser())"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "e5863590",
   "metadata": {},
   "source": [
    "## Partie 6: Vision Transformer\n",
    "\n",
    "Les Transformers ne sont pas limités au traitement de la langue naturelle.\n",
    "Plutôt que de passer des lettres ou des mots, on peut passer des portions d'images encodés en vecteur.\n",
    "\n",
    "Pour cette partie, nous allons entraîner un ViT (Vision Transformer) sur CIFAR10.\n"
   ]
  },
  {
   "cell_type": "code",
   "id": "fd8fa741",
   "metadata": {},
   "source": [
    "import torchvision.models\n",
    "\n",
    "import poutyne as pt"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Supprimer le dernier modele\n",
    "def find_cuda_tensors():\n",
    "    \"\"\"Finds all Python variables that are tensors on CUDA.\"\"\"\n",
    "    cuda_tensors = {}\n",
    "    for var_name, var_value in globals().items():\n",
    "        if isinstance(var_value, torch.Tensor) and var_value.is_cuda:\n",
    "            cuda_tensors[var_name] = var_value\n",
    "    return cuda_tensors\n",
    "\n",
    "for tensor_name, tensor in find_cuda_tensors().items():\n",
    "    del globals()[tensor_name]\n",
    "\n",
    "if 'model' in globals():\n",
    "    del model\n",
    "if 'optimizer' in globals():\n",
    "    del optimizer\n",
    "torch.cuda.empty_cache()\n",
    "torch.cuda.reset_peak_memory_stats()\n"
   ],
   "id": "45c6409098300c1"
  },
  {
   "cell_type": "code",
   "id": "b056f4a0",
   "metadata": {},
   "source": [
    "# Data\n",
    "batch_size = 128\n",
    "\n",
    "transform_train = T.Compose([\n",
    "    T.RandAugment(4, 14),\n",
    "    T.RandomCrop(32, padding=4),\n",
    "    T.RandomHorizontalFlip(),\n",
    "    T.ToTensor(),\n",
    "    T.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
    "])\n",
    "\n",
    "transform_test = T.Compose([\n",
    "    T.ToTensor(),\n",
    "    T.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),\n",
    "])\n",
    "\n",
    "cifar, cifar_test = ddatasets.load_cifar10()\n",
    "cifar.transform = transform_train\n",
    "cifar_test.transform = transform_test\n",
    "\n",
    "train_split = 0.8\n",
    "num_data = len(cifar)\n",
    "indices = np.arange(num_data)\n",
    "np.random.shuffle(indices)\n",
    "\n",
    "split = math.floor(train_split * num_data)\n",
    "train_idx, valid_idx = indices[:split], indices[split:]\n",
    "\n",
    "train_dataset = torch.utils.data.Subset(cifar, train_idx)\n",
    "valid_dataset = torch.utils.data.Subset(cifar, valid_idx)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True)\n",
    "valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=True)\n",
    "test_loader = torch.utils.data.DataLoader(cifar_test, batch_size=batch_size)"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "dfe437b0",
   "metadata": {},
   "source": [
    "pathlib.Path('logs').mkdir(exist_ok=True, parents=True)\n",
    "\n",
    "epoch = 100\n",
    "learning_rate = 1e-4\n",
    "\n",
    "img_size = cifar[0][0].shape[-1]\n",
    "patch_size = 4\n",
    "num_layers = 12\n",
    "num_heads = 12\n",
    "hidden_dim = 768\n",
    "mlp_dim = 3072\n",
    "\n",
    "model = torchvision.models.VisionTransformer(img_size, patch_size, num_layers, num_heads, hidden_dim, mlp_dim, dropout=0.1, attention_dropout=0.1, num_classes=10)\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)\n",
    "\n",
    "model = pt.Model(model, optimizer, 'cross_entropy', batch_metrics=['accuracy'])\n",
    "model.cuda()\n",
    "\n",
    "history = model.fit_generator(train_loader, valid_loader, epochs=epoch, callbacks=[\n",
    "    pt.ModelCheckpoint('logs/best_epoch_{epoch}.ckpt', monitor='val_acc', mode='max', save_best_only=True, restore_best=True, verbose=True, temporary_filename='best_epoch.ckpt.tmp'),\n",
    "])\n",
    "\n",
    "dtrain.History(history).display()\n",
    "\n",
    "test_loss, test_acc = model.evaluate_generator(test_loader)\n",
    "print('test_loss: {:.4f} test_acc: {:.2f}'.format(test_loss, test_acc))"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "d9573bdc",
   "metadata": {},
   "source": [
    "model.load_weights('logs/best_epoch_5.ckpt', weights_only=True)\n",
    "test_loss, test_acc = model.evaluate_generator(test_loader)\n",
    "print('Epoch 5: test_loss: {:.4f} test_acc: {:.2f}'.format(test_loss, test_acc))"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "3e9e53a0",
   "metadata": {},
   "source": [
    "## Extra"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5de7174",
   "metadata": {},
   "source": [
    "### Transformers annotés\n",
    "\n",
    "On vous recommande de consulter [willGuimont/transformers](https://github.com/willGuimont/transformers) pour mieux comprendre les modèles de Transformer.\n",
    "Le projet implémente plusieurs architectures basées sur les Transformers; le code est bien commenté et devrait être facile à suivre.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f42068c2",
   "metadata": {},
   "source": [
    "### Self-attention vs Cross-attention\n",
    "\n",
    "Dans les exemples utilisés dans ce laboratoire, $q$, $k$ et $v$ sont dérivés d'une seule valeur (`x = layer(x, x, x, mask)` dans le `TransformerEncoder`.\n",
    "Ceci est appelé du \"self-attention\".\n",
    "\n",
    "Il est aussi possible de faire du \"cross-attention\", lorsque $q$ et $(k, v)$ proviennent de données différentes.\n",
    "\n",
    "[Perceiver](https://www.deepmind.com/publications/perceiver-general-perception-with-iterative-attention) et [PerceiverIO](https://www.deepmind.com/open-source/perceiver-io) sont de beaux exemples d'utilisation du \"cross-attention\".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "825829c8",
   "metadata": {},
   "source": [
    "### TransformerDecoder\n",
    "\n",
    "Voici une implémentation du TransformerDecoder de \"Attention Is All You Need\".\n"
   ]
  },
  {
   "cell_type": "code",
   "id": "6be3c735",
   "metadata": {},
   "source": [
    "class TransformerDecoderLayer(nn.Module):\n",
    "    def __init__(self, dim_model: int, num_head: int, dropout: float):\n",
    "        super().__init__()\n",
    "        head_size = dim_model // num_head\n",
    "        self.self_attention = MultiHeadAttention(num_head, dim_model, head_size, dropout)\n",
    "        self.norm1_target = nn.LayerNorm(dim_model)\n",
    "        self.norm1_memory = nn.LayerNorm(dim_model)\n",
    "        \n",
    "        self.norm2 = nn.LayerNorm(dim_model)\n",
    "        self.cross_attention = MultiHeadAttention(num_head, dim_model, head_size, dropout)\n",
    "        \n",
    "        self.norm3 = nn.LayerNorm(dim_model)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.ffn = FeedForward(dim_model, dropout)\n",
    "    \n",
    "    def forward(self, target, memory, self_attention_mask=None, cross_attention_mask=None):\n",
    "        target, memory = self.norm1_target(target), self.norm1_memory(memory)\n",
    "        target = target + self.self_attention(target, target, target, self_attention_mask)\n",
    "        target = target + self.cross_attention(self.norm2(target), memory, memory, cross_attention_mask)\n",
    "        return target + self.ffn(self.norm3(target))\n",
    "    \n",
    "class TransformerDecoder(nn.Module):\n",
    "    def __init__(self, num_layers: int, dim_model: int, num_heads: int, out_size: int, dropout: float):\n",
    "        super().__init__()\n",
    "        self.layers = nn.ModuleList([TransformerDecoderLayer(dim_model, num_heads, dropout) for _ in range(num_layers)])\n",
    "        self.norm = nn.LayerNorm(dim_model)\n",
    "        self.fc = nn.Linear(dim_model, out_size)\n",
    "        \n",
    "        self.apply(self._init_weights)\n",
    "        \n",
    "    def _init_weights(self, module):\n",
    "        if isinstance(module, nn.Linear):\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "            if module.bias is not None:\n",
    "                torch.nn.init.zeros_(module.bias)\n",
    "        elif isinstance(module, nn.Embedding):\n",
    "            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)\n",
    "            \n",
    "    def forward(self, target, memory, self_attention_mask=None, cross_attention_mask=None):\n",
    "        num_tokens, dim = target.shape[1], target.shape[2]\n",
    "        target += position_encoding(num_tokens, dim, target.device)\n",
    "        for layer in self.layers:\n",
    "            target = layer(target, memory, self_attention_mask, cross_attention_mask)\n",
    "        target = self.norm(target)\n",
    "        target = self.fc(target)\n",
    "        return target\n",
    "    \n",
    "dec = TransformerDecoder(6, 10, 5, 100, 0.0)\n",
    "target = torch.randn((2, 5, 10))\n",
    "memory = torch.randn((2, 5, 10))\n",
    "print(dec(target, memory).shape)"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "225e87e2",
   "metadata": {},
   "source": [
    "### Exemple d'implémentation de ViT"
   ]
  },
  {
   "cell_type": "code",
   "id": "d0de7a71",
   "metadata": {},
   "source": [
    "class VisionTransformer(nn.Module):\n",
    "    def __init__(self, img_size: int, patch_size: int, num_classes: int, channels: int, num_layers: int, dim_model: int, num_heads: int, out_size: int, dropout: float):\n",
    "        super().__init__()\n",
    "        assert img_size % patch_size == 0, \"img_size must be divisible by patch_size\"\n",
    "        self.img_size = img_size\n",
    "        self.patch_size = patch_size\n",
    "        self.num_patches = (img_size // patch_size) ** 2\n",
    "        self.patch_dim = channels * patch_size * patch_size\n",
    "        \n",
    "        self.norm1 = nn.LayerNorm(self.patch_dim)\n",
    "        self.fc1 = nn.Linear(self.patch_dim, dim_model)\n",
    "        self.norm2 = nn.LayerNorm(dim_model)\n",
    "        \n",
    "        self.cls = nn.Parameter(torch.randn((1, 1, dim_model)))\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.trans_enc = TransformerEncoder(num_layers, dim_model, num_heads, out_size, dropout)\n",
    "        \n",
    "        self.norm3 = nn.LayerNorm(dim_model)\n",
    "        self.fc2 = nn.Linear(dim_model, num_classes)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        batch_size = x.shape[0]\n",
    "        size = 8\n",
    "        stride = 1\n",
    "        \n",
    "        # Image to patches\n",
    "        x = self._img_to_patch_emdedding(x)\n",
    "        \n",
    "        # Add cls token\n",
    "        cls = ein.repeat(self.cls, '1 1 d -> b 1 d', b=batch_size)\n",
    "        x = torch.cat((cls, x), dim=1)\n",
    "        \n",
    "        # Positional encoding\n",
    "        batch_size, num_tokens, dim = x.shape\n",
    "        x += position_encoding(num_tokens, dim, x.device)\n",
    "        \n",
    "        # Dropout\n",
    "        x = self.dropout(x)\n",
    "        \n",
    "        # Transformer\n",
    "        x = self.trans_enc(x)\n",
    "\n",
    "        \n",
    "        # Final prediction from cls token\n",
    "        x = x[:, 0]\n",
    "        x = self.fc2(self.norm3(x))\n",
    "\n",
    "        return x\n",
    "    \n",
    "    def _img_to_patch_emdedding(self, img):\n",
    "        x = ein.rearrange(img, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1=self.patch_size, p2=self.patch_size)\n",
    "        x = self.norm1(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.norm2(x)\n",
    "        return x"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "code",
   "id": "131baa3a",
   "metadata": {},
   "source": [
    "epoch = 100\n",
    "batch_size = 256\n",
    "learning_rate = 1e-4\n",
    "\n",
    "img_size = 32\n",
    "patch_size = 8\n",
    "num_classes = 10\n",
    "channels = 3\n",
    "num_layers = 6\n",
    "dim_model = 512\n",
    "num_heads = 12\n",
    "out_size = dim_model\n",
    "dropout = 0.1\n",
    "\n",
    "model = VisionTransformer(img_size, patch_size, num_classes, channels, num_layers, dim_model, num_heads, out_size, dropout)\n",
    "optimizer = torch.optim.AdamW(model.parameters(), lr=learning_rate)\n",
    "\n",
    "model = pt.Model(model, optimizer, 'cross_entropy', batch_metrics=['accuracy'])\n",
    "model.cuda()\n",
    "\n",
    "history = model.fit_generator(train_loader, valid_loader, epochs=epoch, callbacks=[\n",
    "    pt.ModelCheckpoint('logs/vit_best_epoch_{epoch}.ckpt', monitor='val_acc', mode='max', save_best_only=True, restore_best=True, verbose=True, temporary_filename='best_epoch.ckpt.tmp'),\n",
    "])\n",
    "\n",
    "dtrain.History(history).display()\n",
    "\n",
    "test_loss, test_acc = model.evaluate_generator(test_loader)\n",
    "print('test_loss: {:.4f} test_acc: {:.2f}'.format(test_loss, test_acc))"
   ],
   "outputs": [],
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "id": "86b1d6d0",
   "metadata": {},
   "source": [
    "### Attention comme passage de messages\n",
    "- L'attention peut être interprété comme du passage de message sur un graphe.\n",
    "- Chaque noeud $i$ dans le graphe possède un triplet $(q_i, k_i, v_i$)\n",
    "- Grâce à $k_i$, chaque noeud \"diffuse\" ce qu'il connait\n",
    "- Grâce à $q_i$, chaque noeud demande aux autres noeuds de l'information\n",
    "- Selon ce que l'affinité entre les $q_i$ et les $k_i$, chaque noeud aggrège l'information $v_i$ de ses voisins\n",
    "- Champ réceptif large, chaque noeud à accès aux autres noeuds en une seule opération.\n",
    "\n",
    "<div>\n",
    "<img src=\"docs/simplex_graph.png\" width=\"500\"/>\n",
    "</div>\n",
    "\n",
    "- Cette interprétation est cohérente avec la notion que les transformers sont des fonctions d'ensemble vers ensemble (invariance à l'ordre des éléments), la position des noeuds n'a pas d'importance, on doit encoder l'information sur la position autrement."
   ]
  }
 ],
 "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}