transformer_architecture.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f29faae7-c551-4ffe-92c8-5de7faa39ffe",
   "metadata": {},
   "source": [
    "# Architecture du transformer et implémentation avec Pytorch (Partie I)\n",
    "\n",
    "**Qu'est ce qu'un transformer ?:**\n",
    "Un modèle de transformer est un réseau neuronal qui apprend le contexte et donc le sens en suivant les relations dans les données séquentielles comme les mots de cette phrase. Dans la version originale de leur papier [Attention Is All You Need](https://arxiv.org/abs/1706.03762), les auteurs définisse le transformer comme une nouvelle architecture de réseau simple basée uniquement sur les mécanismes d'attention, exemptée entièrement de récurrence ou de convolution.\n",
    "\n",
    "**Applications**\n",
    "\n",
    "Les transformers constituent ce qu'on appelle maintenant la fondation des modèles de deep learning. Ils sont utilisés entre autres pour les tâches comme:\n",
    "- Question réponse\n",
    "- Classification de texte\n",
    "- Extraction d'information\n",
    "- Reconnaissance d'objets\n",
    "- Analyse de sentiment\n",
    "- Légende des images\n",
    "- etc\n",
    "\n",
    "Le transformer est constitué de deux grandes parties que sont l'encodeur et le décodeur.\n",
    "**L'encodeur** prend la séquence d'entrée et crée une représentation contextuelle (également appelée contexte) de celle-ci. Le **décodeur** prend cette représentation contextuelle en entrée et génère la séquence de sortie. Le processus peut être résumé comme suit:\n",
    "\n",
    "$$ \\mathbf{X} \\Longrightarrow \\mathbf{Encodeur} \\Longrightarrow \\mathbf{contexte} \\Longrightarrow \\mathbf{Decodeur} \\Longrightarrow \\mathbf{Y}  $$\n",
    "$\\mathbf{X}$ constitue l'entrée et $\\mathbf{Y}$ la sortie.\n",
    "\n",
    "Dans cette première partie, nous allons suivre le processus bloc par bloc afin de construire notre propre encoder du tranformer. Commençons par le point le plus important: le `self attention`.\n",
    "\n",
    "## Self-Attention ou Auto-Attention\n",
    "\n",
    "Il existe plusieurs façons de mettre en œuvre une couche d'auto-attention, mais la plus courante est l'attention par produit scalaire, tirée de l'article présentant l'architecture du transformer Quatre étapes principales sont nécessaires pour mettre en œuvre ce mécanisme :\n",
    "\n",
    "- Projection de chaque encastrement de jeton dans trois vecteurs appelés `key`,`query`,`value`.\n",
    "\n",
    "- Calculer les scores d'attention. Nous déterminons dans quelle mesure les vecteurs de `query` et de `key` sont liés les uns aux autres en utilisant une fonction de similarité. Comme son nom l'indique, la fonction de similarité pour l'attention par produit scalaire est le produit scalaire, calculé efficacement en utilisant la multiplication matricielle des incorporations. Les `query` et les `key` qui sont similaires auront un produit scalaire important, tandis que ceux qui n'ont pas beaucoup de points communs n'auront que peu ou pas de chevauchement. Les résultats de cette étape sont appelés les **scores d'attention**, et pour une séquence de $n$ tokens d'entrée, il existe une matrice $n*n$ correspondante de scores d'attention.\n",
    "\n",
    "- Calculer les poids d'attention. Les produits scalaires peuvent en général produire des nombres arbitrairement grands, ce qui peut déstabiliser le processus de formation. Pour y remédier, les scores d'attention sont d'abord multipliés par un facteur d'échelle afin de normaliser leur variance, puis normalisés à l'aide d'un softmax afin de s'assurer que la somme de toutes les valeurs des colonnes est égale à 1. Le résultat des $n*n$ matrice contient maintenant tous les poids d'attention $w_{ji}$\n",
    "\n",
    "- Mise à jour de l'intégration des jetons. Une fois les poids d'attention calculés, nous les multiplions par le vecteur de valeurs (`value`) afin d'obtenir une représentation actualisée pour l'incorporation: $x_i' = \\sum_{j}w_{ji}v_j$\n",
    "\n",
    "En premier temps, nous allons extraire les tokens de notre texte:\n",
    "*PS:* Pour plus de facilité nous travaillerons avec les hyper-paramètres utilisés dans l'architecture **BERT**. Retrouvez le model de Bert sur huggingface [ici](https://huggingface.co/bert-base-uncased) et le papier [ici](https://arxiv.org/abs/1810.04805)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ea65941a-7e7e-4451-b66a-e4e38564e501",
   "metadata": {},
   "outputs": [],
   "source": [
    "from transformers import AutoTokenizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "37165993-2a12-45ba-8800-9086aa867fbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_ckpt = \"bert-base-uncased\"\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_ckpt)\n",
    "text = \"time flies like an arrow\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f310ec1b-e3c5-420b-934f-373e0d25e338",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[ 2051, 10029,  2066,  2019,  8612]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = tokenizer(text, return_tensors=\"pt\", add_special_tokens=False)\n",
    "inputs.input_ids"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2268075c-a836-4134-966f-4f703d9fbc95",
   "metadata": {},
   "source": [
    "Nous avons ajouté le `add_special_tokens=False` pour ignorer les tokens spéciales comme [CLS] et [SEP].\n",
    "Ensuite, nous devons créer des incorporations denses. Dans ce contexte, dense signifie que chaque entrée dans les incorporations contient une valeur non nulle. Ces incorporations sont des vecteurs zéros avec une seule valeur de 1 à une position donnée: `one hot encoding`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "53bc2441-e496-4707-a83c-fbbb74f47ab1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BertConfig {\n",
       "  \"architectures\": [\n",
       "    \"BertForMaskedLM\"\n",
       "  ],\n",
       "  \"attention_probs_dropout_prob\": 0.1,\n",
       "  \"classifier_dropout\": null,\n",
       "  \"gradient_checkpointing\": false,\n",
       "  \"hidden_act\": \"gelu\",\n",
       "  \"hidden_dropout_prob\": 0.1,\n",
       "  \"hidden_size\": 768,\n",
       "  \"initializer_range\": 0.02,\n",
       "  \"intermediate_size\": 3072,\n",
       "  \"layer_norm_eps\": 1e-12,\n",
       "  \"max_position_embeddings\": 512,\n",
       "  \"model_type\": \"bert\",\n",
       "  \"num_attention_heads\": 12,\n",
       "  \"num_hidden_layers\": 12,\n",
       "  \"pad_token_id\": 0,\n",
       "  \"position_embedding_type\": \"absolute\",\n",
       "  \"transformers_version\": \"4.11.3\",\n",
       "  \"type_vocab_size\": 2,\n",
       "  \"use_cache\": true,\n",
       "  \"vocab_size\": 30522\n",
       "}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from torch import nn\n",
    "from transformers import AutoConfig\n",
    "\n",
    "config = AutoConfig.from_pretrained(model_ckpt)\n",
    "config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0939ff7b-c20a-44aa-b15f-4df639edd5c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Embedding(30522, 768)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "token_emb = nn.Embedding(config.vocab_size, config.hidden_size)\n",
    "token_emb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1022c82d-dcff-482e-88f5-cb459875809b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 768])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs_embeds = token_emb(inputs.input_ids)\n",
    "inputs_embeds.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18e530da-a1b2-4bdf-ba6a-f515d94eaaaa",
   "metadata": {},
   "source": [
    "Pour l'instant, nous allons remettre à plus tard l'encodage de position et passer à la création des clés, requêtes et valeurs en utilisant le produit scalaire comme fonction de similarité."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "49942cda-8711-48c8-be51-5e19d2439d8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 5])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from math import sqrt\n",
    "\n",
    "query = key = value = inputs_embeds\n",
    "dim_k = key.size(-1)\n",
    "scores = torch.bmm(query, key.transpose(1,2)) / sqrt(dim_k)\n",
    "scores.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90372450-0e57-40e1-a891-aefd911efe7f",
   "metadata": {},
   "source": [
    "La division par $\\sqrt{d_k}$ du score permet de ne pas avoir de grandes valeurs durant l'entraînement.\n",
    "Par la suite, appliquons la fonction softmax qui va permettre d'avoir une somme des scores égale à 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "30f4a12e-d40d-4a35-b647-5c1e56abff29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1., 1., 1., 1., 1.]], grad_fn=<SumBackward1>)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch.nn.functional as F\n",
    "\n",
    "weights = F.softmax(scores, dim=-1)\n",
    "weights.sum(dim=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "696e7694-e3da-4c67-8520-a91c9c6da304",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 768])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "attn_outputs = torch.bmm(weights, value)\n",
    "attn_outputs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "254178c6-2161-47bf-83c0-8d2fc91e3463",
   "metadata": {},
   "source": [
    "Nous venons de finir une implémentation simplifiée d'auto-attention. Nous rappelons que tous le processus est juste une multiplication matricielle et une fonction softmax."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2513dee0-44c0-4332-bacf-bfd5e48b41a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def scaled_dot_product_attention(query, key, value):\n",
    "    dim_k = key.size(-1)\n",
    "    scores = torch.bmm(query, key.transpose(1,2)) / sqrt(dim_k)\n",
    "    weights = F.softmax(scores, dim=-1)\n",
    "    return torch.bmm(weights, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adbb6b9b-2555-4a23-9a77-402d88fbfb7d",
   "metadata": {},
   "source": [
    "Le self attention est finalement calculé comme suit:\n",
    "$$ Attention(Q,K,V) = softmax(\\frac{QK^T}{\\sqrt{d_k}})V $$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6035f5b-5c35-4189-93f3-471c41a232df",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Multi-head attention: attention à têtes multiples\n",
    "\n",
    "En pratique, la couche d'auto-attention applique trois transformations linéaires indépendantes à chaque incorporation pour générer les vecteurs de requête, de clé et de valeur. Ces transformations projettent les enchâssements et chaque projection porte son propre ensemble de paramètres apprenables, ce qui permet à la couche d'auto-attention de se concentrer sur différents aspects sémantiques de la séquence.\n",
    "\n",
    "Il s'avère également avantageux de disposer de plusieurs ensembles de projections linéaires, chacun représentant une tête d'attention.Mais pourquoi avons-nous besoin de plus d'une tête d'attention ? La raison est que la softmax d'une tête a tendance à se concentrer sur un seul aspect de la similarité. Le fait d'avoir plusieurs têtes permet au modèle de se concentrer sur plusieurs aspects à la fois. Par exemple, une tête peut se concentrer sur l'interaction sujet-verbe, tandis qu'une autre trouve des adjectifs proches. Il est évident que nous n'intégrons pas ces relations dans le modèle et qu'elles sont entièrement apprises à partir des données. Une analogie peut être faite avec les modèles de vision par ordinateur. Nous avons les filtres des réseaux neuronaux convolutifs, où un filtre peut être responsable de la détection des visages et un autre de la recherche des roues de voitures dans les images.\n",
    "\n",
    "Commençons d'abord par implémenter une seule attention à tête:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c6e71864-6377-4872-b6d1-8d19d7038d18",
   "metadata": {},
   "outputs": [],
   "source": [
    "class AttentionHead(nn.Module):\n",
    "    def __init__(self, embed_dim, head_dim):\n",
    "        super().__init__()\n",
    "        self.q = nn.Linear(embed_dim, head_dim)\n",
    "        self.k = nn.Linear(embed_dim, head_dim)\n",
    "        self.v = nn.Linear(embed_dim, head_dim)\n",
    "    \n",
    "    def forward(self, hidden_state):\n",
    "        attn_outputs = scaled_dot_product_attention(\n",
    "            self.q(hidden_state), self.k(hidden_state), self.v(hidden_state)\n",
    "        )\n",
    "        return attn_outputs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "931d4298-ded8-4eb9-a4aa-02133f8e3b6a",
   "metadata": {},
   "source": [
    "En pratique, on choisit la valeur de `embed_dim` pour qu'elle soit un multiple de `head_dim`. En prenant l'exemple de l'architecture BERT, la dimension de l'entête est de 768/12 = 64.\n",
    "\n",
    "Maintenant que nous avons une seule tête d'attention, nous pouvons concaténer les sorties de chacune d'elles pour mettre en œuvre la couche d'attention multi-têtes complète :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "601c7514-fe6a-429f-9f14-54ac1a817931",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        embed_dim = config.hidden_size\n",
    "        num_heads = config.num_attention_heads\n",
    "        head_dim = embed_dim // num_heads\n",
    "        \n",
    "        self.heads = nn.ModuleList(\n",
    "            [AttentionHead(embed_dim, head_dim) for _ in range(num_heads)]\n",
    "        )\n",
    "        # A la sortie de cette couche, nous avons un vecteur [batch, embed_dim, head_dim]\n",
    "        self.output_linear = nn.Linear(embed_dim, embed_dim)\n",
    "    \n",
    "    def forward(self, hidden_state):\n",
    "        x = torch.cat([h(hidden_state) for h in self.heads], dim=-1)\n",
    "        # la fonction cat permet de concatener les sorties de la couche d'attention à \n",
    "        # seule tête pour avoir un vecteur [batch, embed_dim, head_dim*num_heads]\n",
    "        # head_dim*num_heads encore égal à embed_dim: entrée de la couche linéaire suivante.\n",
    "        x = self.output_linear(x)\n",
    "        return x\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fe6c26d8-9167-4981-ab1d-c03a0acc0ba1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 768])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multihead_attn = MultiHeadAttention(config)\n",
    "attn_output = multihead_attn(inputs_embeds)\n",
    "attn_output.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f03138ef-c790-4206-b87c-dfca3dda44f6",
   "metadata": {},
   "source": [
    "## The Feed-Forward Layer ou couche à propagation avant\n",
    "\n",
    "Cette sous-couche dans le transformer est un simple réseau neuronal entièrement connecté à deux couches, mais avec une particularité : au lieu de traiter la séquence entière d'incorporations comme un vecteur unique, elle traite chaque incorporation indépendamment. C'est la raison pour laquelle cette couche est souvent appelée couche à propagation avant en fonction de la position.\n",
    "\n",
    "Une règle empirique tirée de la littérature est que le `hidden_size` de la première couche doit être quatre fois supérieure à la taille des embeddings, et une fonction d'activation `GELU` est le plus souvent utilisée. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "89b19695-03e7-4afe-b101-006d1cef03f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class FeedForward(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.linear_1 = nn.Linear(config.hidden_size, config.intermediate_size)\n",
    "        self.linear_2 = nn.Linear(config.intermediate_size, config.hidden_size)\n",
    "        self.gelu = nn.GELU()\n",
    "        self.dropout = nn.Dropout(config.hidden_dropout_prob)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.gelu(self.linear_1(x))\n",
    "        x = self.linear_2(x)\n",
    "        x = self.dropout(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "e0ec342d-b324-4372-a12c-913e366eb60a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 768])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "feed_forward = FeedForward(config)\n",
    "ff_outputs = feed_forward(attn_output)\n",
    "ff_outputs.size()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc561850-4bb4-494f-a0c6-5a523d7f0b42",
   "metadata": {},
   "source": [
    "Nous avons maintenant tous les ingrédients pour créer une couche d'encodeur du transformer ! La seule décision qui reste à prendre est de savoir où placer les connexions de saut et la normalisation de la couche.\n",
    "\n",
    "## Layer Normalisation ou normalisation de couche\n",
    "\n",
    "Le transformer normalise chaque entrée du lot pour qu'elle ait une moyenne nulle et une variance unitaire. Les connexions de saut passent un tenseur (non traité) à la couche suivante du modèle et l'ajoute au tenseur traité. Dans la littérature, nous avons deux options possibles pour la normalisation:\n",
    "\n",
    "- Normalisation post-couche: ici la normalisation est effectuée entre les connexions de saut. Cette disposition est délicate à former à partir de zéro car les gradients peuvent diverger. Pour cette raison, vous verrez souvent un concept connu sous le nom de `learning rate warm-up`, où le taux d'apprentissage est progressivement augmenté d'une petite valeur à une valeur maximale pendant l'entraînement.\n",
    "\n",
    "- Normalisation de la pré-couche: Il s'agit de la disposition la plus courante trouvée dans la littérature; elle place la normalisation de couche dans la portée des connexions de saut. Elle tend à être beaucoup plus stable pendant l'apprentissage et ne nécessite généralement pas l'usage du `learning rate warm-up`.\n",
    "\n",
    "Nous allons utiliser la seconde option et écrire l'encodeur de notre transformer de la façon suivante:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7f0aeefb-3492-4d75-8e18-041ccfac8a98",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerEncoderLayer(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.l_norm_1 = nn.LayerNorm(config.hidden_size)\n",
    "        self.l_norm_2 = nn.LayerNorm(config.hidden_size)\n",
    "        self.attention = MultiHeadAttention(config)\n",
    "        self.feed_forward = FeedForward(config)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # 1- layer normalisation\n",
    "        hidden_state = self.l_norm_1(x)\n",
    "        # 2- apply attention with skip connection\n",
    "        x = x + self.attention(hidden_state)\n",
    "        # 3- feed forward layer with skip connection\n",
    "        x = x + self.feed_forward(self.l_norm_2(x))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8be35109-e5be-485f-aac9-d8d0666fc504",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1, 5, 768]), torch.Size([1, 5, 768]))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encoder_layer = TransformerEncoderLayer(config)\n",
    "inputs_embeds.shape, encoder_layer(inputs_embeds).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee16bb3f-6718-478a-9c79-d77ab7c90c01",
   "metadata": {},
   "source": [
    "Actuellement les couches de l'encodeur sont invariants par rapport à la position des token. Nous allons ajouter cette nouvelle information en utilisant le `positional embeddings`\n",
    "\n",
    "## Positional embeddings ou encastrement positionnels\n",
    "\n",
    "Son but est de permettre au modèle d'apprendre la formation des tokens. Etant donné qu'une phrase n'a de sens que si les ordres des mots sont respectés. Cette couche apprend cette constitution des mots.\n",
    "\n",
    "Créons un module Embeddings personnalisé qui combine une couche d'embeddings de tokens qui projette les `input_ids` au *hidden state dense* avec l'embedding positionnel qui fait la même chose pour les `position_ids`.\n",
    "Dans la configuration de **BERT** par exemple, la taille maximale d'un paragraphe pris en compte est de 512, ce qui veut dire que nous allons fixé comme position maximale d'un token à 512.\n",
    "L'incorporation résultante est simplement la somme des deux incorporations :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "dc193870-c847-452e-99ad-c4704d2f1ab6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Embeddings(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.token_embeddings = nn.Embedding(config.vocab_size, config.hidden_size)\n",
    "        self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)\n",
    "        \n",
    "        self.layer_norm = nn.LayerNorm(config.hidden_size, eps=1e-12)\n",
    "        self.dropout = nn.Dropout()\n",
    "    \n",
    "    def forward(self, input_ids):\n",
    "        # Positions ids for the inputs\n",
    "        seq_length = input_ids.size(1)\n",
    "        positions_ids = torch.arange(seq_length, dtype=torch.long).unsqueeze(0)\n",
    "        # Now we create position and token embeddings\n",
    "        token_embeddings = self.token_embeddings(input_ids)\n",
    "        position_embeddings = self.position_embeddings(positions_ids)\n",
    "        \n",
    "        # token combination\n",
    "        embeddings = token_embeddings + position_embeddings\n",
    "        embeddings = self.layer_norm(embeddings)\n",
    "        embeddings = self.dropout(embeddings)\n",
    "        return embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "68afe2f2-91bc-4be7-aceb-b080fcaa49fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 768])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedding_layer = Embeddings(config)\n",
    "embedding_layer(inputs.input_ids).size()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffe1888e-514c-41b9-8b00-2e9b7998c061",
   "metadata": {},
   "source": [
    "Comprendre plus sur le positional embedding [ici](https://www.youtube.com/watch?v=dichIcUZfOw)\n",
    "\n",
    "Combinons ces différentes étapes pour construire la couche d'encodage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f9dffa7d-2f8e-4ec9-bc85-ed2173a68ff6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerEncoder(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.embedding = Embeddings(config)\n",
    "        self.layers = nn.ModuleList([TransformerEncoderLayer(config) \n",
    "                                     for _ in range(config.num_hidden_layers)])\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.embedding(x)\n",
    "        for layer in self.layers:\n",
    "            x = layer(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "c4c7ea59-ae63-4e6a-bc14-95d4edeb3349",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 5, 768])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encoder = TransformerEncoder(config)\n",
    "encoder(inputs.input_ids).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93792853-77df-4b77-93c8-90b2a7c32f38",
   "metadata": {},
   "source": [
    "A cette étape, nous avons l'état caché de chaque token. Un grand avantage des modèles de transformer est qu'il peuvent être divisé en deux parties:\n",
    "- en un corps indépendant de la tâche et\n",
    "- une tête spécifique à la tâche.\n",
    "\n",
    "Notre encodeur étant prêt à l'utilisation, ajoutons une tête de couche qui sera utilisé pour la classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4401916c-dd39-4b30-923c-7de7f08b3d1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerForSequenceClassification(nn.Module):\n",
    "    def __init__(self, config):\n",
    "        super().__init__()\n",
    "        self.encoder = TransformerEncoder(config)\n",
    "        self.dropout = nn.Dropout(config.hidden_dropout_prob)\n",
    "        self.classifier = nn.Linear(config.hidden_size, config.num_labels)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.encoder(x)[:, 0, :]\n",
    "        x = self.dropout(x)\n",
    "        x = self.classifier(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "21a7a79f-849c-43e8-b6cd-56a2f7ddece3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 3])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "config.num_labels = 3\n",
    "encoder_classifier = TransformerForSequenceClassification(config)\n",
    "encoder_classifier(inputs.input_ids).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85c3f339-ab50-4efe-9db9-e29d1bf9459b",
   "metadata": {},
   "source": [
    "Nous avons défini pour notre tâche de classification *3 catégories*, les données sont envoyées vers la sous couche de classification après passage de l'encodeur et un dropout appliqué.\n",
    "\n",
    "Ceci marque la fin de l'encodeur !!."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae8fc58f-a991-46ea-aea0-4937d658c2c8",
   "metadata": {},
   "source": [
    "# Ressources\n",
    "\n",
    "- Natural Language Processing with Transformers [github](https://github.com/nlp-with-transformers/notebooks)\n",
    "- Natural Language Processing with Transformers [the book](https://www.oreilly.com/library/view/natural-language-processing/9781098103231/)\n",
    "- Attention is all you need: [papier](https://arxiv.org/abs/1706.03762)\n",
    "- The annoted transformer, par Guillaume Klein et al, [ici](http://nlp.seas.harvard.edu/2018/04/03/attention.html)\n",
    "- The Illustrated Transformer par Jay Alammar [ici](https://jalammar.github.io/illustrated-transformer/)\n",
    "- [NLP Theory and Code: Encoder-Decoder Models](https://medium.com/nerd-for-tech/nlp-theory-and-code-encoder-decoder-models-part-11-30-e686bcb61dc7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d66bda94-ab06-4f35-963d-72457ce2559e",
   "metadata": {},
   "source": [
    "## Décodeur\n",
    "\n",
    "A la différence de l'encodeur, le décodeur quant à lui est composé de deux sous couches d'attention:\n",
    "- Couche d'auto-attention multi-têtes masquée\n",
    "Garantit que les tokens que nous générons à chaque pas de temps sont uniquement basés sur les sorties passées et le token actuel prédit. Cela évite au décodeur de simplement copier les traductions cibles.\n",
    "\n",
    "- Couche d'attention de l'encodeur-décodeur\n",
    "Elle effectue une attention multi-têtes sur les vecteurs de clé et de valeur de sortie de la pile de l'encodeur, les représentations intermédiaires du décodeur faisant office de requêtes. Le décodeur a accès aux clés et aux valeurs de l'encodeur dans chaque bloc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d531b80e-08c6-4aae-8764-5b931a82a44d",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}