practicals/Foundations_of_LLMs/foundations_of_llms_practical_french.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m2s4kN_QPQVe"
      },
      "source": [
        "# LLMs pour tous\n",
        "\n",
        "<img src=\"https://www.marktechpost.com/wp-content/uploads/2023/05/Blog-Banner-3.jpg\" width=\"60%\" />\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/deep-learning-indaba/indaba-pracs-2024/blob/main/practicals/Foundations_of_LLMs/foundations_of_llms_practical_french.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
        "\n",
        "\n",
        "© Deep Learning Indaba 2024. Apache License 2.0.\n",
        "\n",
        "**Authors: Jabez Magomere, Harry Mayne, Khalil Mrini, Nabra Rizvi, Doudou Ba, Ruan van der Merwe, Marianne Monteiro, Everlyn Asiko Chimoto**\n",
        "\n",
        "**Reviewers: Seid Muhie Yimam, Foutse Yuehgoh**\n",
        "\n",
        "**Introduction:**\n",
        "\n",
        "Bienvenue à \"LLMs pour Tous\"—votre porte d'entrée vers le monde fascinant des Modèles de Langage de Grande Taille (LLMs) ! Pour commencer, voici un fait amusant : toute cette introduction a été générée par ChatGPT, l'un des nombreux LLMs puissants que vous allez découvrir. 🤖✨\n",
        "\n",
        "Dans ce tutoriel, vous allez plonger au cœur des principes fondamentaux des transformateurs, la technologie de pointe derrière des modèles comme GPT. Vous aurez également l'occasion de vous exercer à entraîner votre propre Modèle de Langage ! Préparez-vous à explorer comment ces systèmes d'IA impressionnants créent des textes aussi réalistes et captivants. Partons ensemble pour ce voyage passionnant et déverrouillons les secrets des LLMs ! 🚀📚\n",
        "\n",
        "**Sujets :**\n",
        "\n",
        "Contenu : [<font color='orange'>Introduction à Hugging Face</font>, <font color='green'>Mécanisme d'Attention</font>, <font color='green'>Architecture du Transformeur</font>, <font color='green'>Entraîner votre propre LLM depuis zéro</font>, <font color='orange'>Ajustement fin d'un LLM pour la Classification de Texte</font>]\n",
        "\n",
        "Niveau : <font color='orange'>Débutant</font>, <font color='green'>Intermédiaire</font>, <font color='blue'>Avancé</font>\n",
        "\n",
        "**Objectifs d'apprentissage :**\n",
        "\n",
        "* Comprendre l'idée derrière [l'Attention](https://arxiv.org/abs/1706.03762) et pourquoi elle est utilisée.\n",
        "* Présenter et décrire les blocs de construction fondamentaux de l'[Architecture du Transformeur](https://arxiv.org/abs/1706.03762) ainsi qu'une intuition sur la conception de cette architecture.\n",
        "* Construire et entraîner un simple LLM inspiré de Shakespeare.\n",
        "\n",
        "**Prérequis :**\n",
        "\n",
        "* Connaissances introductives en Apprentissage Profond.\n",
        "* Connaissances introductives en NLP.\n",
        "* Connaissances introductives des modèles séquence à séquence.\n",
        "* Compréhension de base en algèbre linéaire.\n",
        "\n",
        "**Plan :**\n",
        ">[LLMs pour tous](#scrollTo=m2s4kN_QPQVe)\n",
        "\n",
        ">>[Installations, Importations et Fonctions Utilitaires](#scrollTo=6EqhIg1odqg0)\n",
        "\n",
        ">>[Commençons avec une Démo Hugging Face ! Débutant](#scrollTo=4zu5cg-YG4XU)\n",
        "\n",
        ">>>[Hugging Face](#scrollTo=AwjIIipOG4fz)\n",
        "\n",
        ">>>[C'est l'heure de la démo ! ⏰⚡ Charger un modèle Hugging Face et exécuter un échantillon](#scrollTo=eq46TV_0G4f0)\n",
        "\n",
        ">>[1. Attention](#scrollTo=-ZUp8i37dFbU)\n",
        "\n",
        ">>>[Intuition - Débutant](#scrollTo=ygdi884ugGcu)\n",
        "\n",
        ">>>[Comprendre l'Attention en termes simples](#scrollTo=ygdi884ugGcu)\n",
        "\n",
        ">>>[Mécanismes d'attention séquence à séquence - Intermédiaire](#scrollTo=aQfqM1EJyDXI)\n",
        "\n",
        ">>>[De l'auto-attention à l'attention multi-têtes - Intermédiaire](#scrollTo=J-MU6rrny8Nj)\n",
        "\n",
        ">>>>[Auto-attention](#scrollTo=0AFUEFZGzCTv)\n",
        "\n",
        ">>>>>[Requêtes, clés et valeurs](#scrollTo=pwOIMtdZzdTf)\n",
        "\n",
        ">>>>>[Attention par produit scalaire avec échelle](#scrollTo=OhGZHFsHz_Qp)\n",
        "\n",
        ">>>>>[Attention masquée](#scrollTo=D7B-AgO80gIt)\n",
        "\n",
        ">>>>>[Attention multi-têtes](#scrollTo=OWDubQwCs4zG)\n",
        "\n",
        ">>[2. Construire votre propre LLM](#scrollTo=e9NW58_3hAg2)\n",
        "\n",
        ">>>[2.1 Vue d'ensemble générale Débutant](#scrollTo=bA_2coZvhAg3)\n",
        "\n",
        ">>>[2.2 Tokenisation + Encodage positionnel Débutant](#scrollTo=fbTsk0MdhAhC)\n",
        "\n",
        ">>>>[2.2.1 Tokenisation](#scrollTo=DehUpfym_RF8)\n",
        "\n",
        ">>>>[2.2.2 Encodages positionnels](#scrollTo=639s7Zuk_RF9)\n",
        "\n",
        ">>>>>[Fonctions sinus et cosinus](#scrollTo=rklY-aL-_RF9)\n",
        "\n",
        ">>>[2.3 Bloc Transformer Intermédiaire](#scrollTo=SdNPg0pnhAhG)\n",
        "\n",
        ">>>>[2.3.1 Réseau de neurones Feed Forward (FFN) / Perceptron multicouche (MLP) Débutant](#scrollTo=kTURbfr__RF-)\n",
        "\n",
        ">>>>[2.3.2 Bloc Ajouter et Normaliser Débutant](#scrollTo=TWUpf8wt_RF-)\n",
        "\n",
        ">>>[2.4 Construction du Décodeur Transformer / LLM Intermédiaire](#scrollTo=91dXd29b_RF_)\n",
        "\n",
        ">>>[2.5 Entraînement de votre LLM](#scrollTo=wmt3tp38G90A)\n",
        "\n",
        ">>>>[2.5.1 Objectif d'entraînement Intermédiaire](#scrollTo=agLIpsoh_RGA)\n",
        "\n",
        ">>>>[2.5.1 Objectif d'entraînement Intermédiaire](#scrollTo=QOSv1-3B_RGA)\n",
        "\n",
        ">>>>[2.5.2 Entraînement des modèles Avancé](#scrollTo=4CSfvGj__RGA)\n",
        "\n",
        ">>>>[2.5.3 Inspecter le LLM entraîné Débutant](#scrollTo=pGv9c2AFmF4V)\n",
        "\n",
        ">>[Conclusion](#scrollTo=fV3YG7QOZD-B)\n",
        "\n",
        ">[Retours - Avis - Suggestions](#scrollTo=o1ndpYE50BpG)\n",
        "\n",
        "\n",
        "\n",
        "**Avant de commencer :**\n",
        "\n",
        "Pour ce TP, vous aurez besoin d'utiliser un GPU pour accélérer l'entraînement. Pour ce faire, allez dans le menu \"Exécution\" de Colab, sélectionnez \"Modifier le type d'exécution\", puis dans le menu popup, choisissez \"GPU\" dans la boîte \"Accélérateur matériel\".\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "952qogb79nnY"
      },
      "source": [
        "**Niveau d'expérience suggéré dans ce sujet :**\n",
        "\n",
        "| Niveau        | Expérience                            |\n",
        "| --- | --- |\n",
        "`Débutant`      | C'est la première fois que je suis introduit à ce travail. |\n",
        "`Intermédiaire` | J'ai suivi quelques cours de base/introductions sur ce sujet. |\n",
        "`Avancé`        | Je travaille quotidiennement dans ce domaine/sujet. |\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YBdDHcI_ArCR"
      },
      "outputs": [],
      "source": [
        "# @title **Chemins à suivre :** Quel est votre niveau d'expérience dans les sujets présentés dans ce notebook ? (Exécutez la cellule)\n",
        "experience = \"débutant\" #@param [\"débutant\", \"intermédiaire\", \"avancé\"]\n",
        "sections_to_follow=\"\"\n",
        "\n",
        "\n",
        "if experience == \"débutant\": sections_to_follow = \"\"\"nous vous recommandons de ne pas essayer de faire toutes les tâches de codage mais plutôt de passer à chaque section et de vous assurer d'interagir avec le LLM affiné avec LoRA présenté dans la dernière section ainsi qu'avec le LLM préentraîné pour obtenir une compréhension pratique du comportement de ces modèles\"\"\"\n",
        "\n",
        "elif experience == \"intermédiaire\": sections_to_follow = \"\"\"nous vous recommandons de parcourir chaque section de ce notebook et d'essayer les tâches de codage étiquetées comme débutant ou intermédiaire. Si vous êtes bloqué sur le code, demandez de l'aide à un tuteur ou passez à autre chose pour mieux utiliser le temps de la pratique\"\"\"\n",
        "\n",
        "elif experience == \"avancé\": sections_to_follow = \"\"\"nous vous recommandons de parcourir chaque section et d'essayer chaque tâche de codage jusqu'à ce que vous réussissiez à la faire fonctionner\"\"\"\n",
        "\n",
        "\n",
        "print(f\"En fonction de votre expérience, {sections_to_follow}.\\nNote : ceci est juste une ligne directrice, n'hésitez pas à explorer le colab comme bon vous semble si vous vous sentez à l'aise !\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6EqhIg1odqg0"
      },
      "source": [
        "## Installations, Importations et Fonctions Utilitaires\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4boGA9rYdt9l"
      },
      "outputs": [],
      "source": [
        "# Installer les bibliothèques nécessaires pour le deep learning, le NLP et la visualisation\n",
        "!pip install transformers datasets  # Bibliothèques Transformers et datasets pour les tâches de NLP\n",
        "!pip install seaborn umap-learn     # Seaborn pour la visualisation, UMAP pour la réduction dimensionnelle\n",
        "!pip install livelossplot           # LiveLossPlot pour suivre les progrès de l'entraînement du modèle\n",
        "!pip install -q transformers[torch] # Transformers avec le backend PyTorch\n",
        "!pip install -q peft                # Bibliothèque de fine-tuning efficient en paramètres\n",
        "!pip install accelerate -U          # Bibliothèque Accelerate pour les performances\n",
        "\n",
        "# Installer des utilitaires pour le débogage et le formatage de la sortie console\n",
        "!pip install -q ipdb                # Débogueur interactif Python\n",
        "!pip install -q colorama            # Sortie de texte colorée dans le terminal\n",
        "\n",
        "# Importer des utilitaires système et mathématiques\n",
        "import os\n",
        "import math\n",
        "import urllib.request\n",
        "\n",
        "# Vérifier les accélérateurs connectés (GPU ou TPU) et configurer en conséquence\n",
        "if os.environ.get(\"COLAB_GPU\") and int(os.environ[\"COLAB_GPU\"]) > 0:\n",
        "    print(\"Un GPU est connecté.\")\n",
        "elif \"COLAB_TPU_ADDR\" in os.environ and os.environ[\"COLAB_TPU_ADDR\"]:\n",
        "    print(\"Un TPU est connecté.\")\n",
        "    import jax.tools.colab_tpu\n",
        "    jax.tools.colab_tpu.setup_tpu()\n",
        "else:\n",
        "    print(\"Seul le processeur (CPU) est connecté.\")\n",
        "\n",
        "# Éviter que l'allocation de mémoire GPU soit effectuée par JAX\n",
        "os.environ['XLA_PYTHON_CLIENT_PREALLOCATE'] = \"false\"\n",
        "\n",
        "# Importer les bibliothèques pour le deep learning basé sur JAX\n",
        "import chex\n",
        "import flax\n",
        "import flax.linen as nn\n",
        "import jax\n",
        "import jax.numpy as jnp\n",
        "from jax import grad, jit, vmap\n",
        "import optax\n",
        "\n",
        "# Importer les bibliothèques liées au NLP et aux modèles\n",
        "import transformers\n",
        "from transformers import pipeline, AutoTokenizer, AutoModel\n",
        "import datasets\n",
        "import peft\n",
        "\n",
        "# Importer les bibliothèques pour le traitement d'images et la visualisation\n",
        "from PIL import Image\n",
        "from livelossplot import PlotLosses\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "\n",
        "# Importer des utilitaires supplémentaires pour travailler avec le texte et les modèles\n",
        "import torch\n",
        "import torchvision\n",
        "import itertools\n",
        "import random\n",
        "import copy\n",
        "\n",
        "# Télécharger une image d'exemple à utiliser dans le notebook\n",
        "urllib.request.urlretrieve(\n",
        "    \"https://images.unsplash.com/photo-1529778873920-4da4926a72c2?ixlib=rb-1.2.1&ixid=MnwxMjA3fDB8MHxzZWFyY2h8MXx8Y3V0ZSUyMGNhdHxlbnwwfHwwfHw%3D&w=1000&q=80\",\n",
        "    \"cat.png\",\n",
        ")\n",
        "\n",
        "# Importer les bibliothèques pour le prétraitement NLP et le travail avec des modèles pré-entraînés\n",
        "import gensim\n",
        "from nltk.data import find\n",
        "import nltk\n",
        "nltk.download(\"word2vec_sample\")\n",
        "\n",
        "# Importer les outils Hugging Face et les widgets IPython\n",
        "import huggingface_hub\n",
        "import ipywidgets as widgets\n",
        "from IPython.display import display\n",
        "import colorama\n",
        "\n",
        "# Configurer Matplotlib pour générer des graphiques au format SVG pour une meilleure qualité\n",
        "%config InlineBackend.figure_format = 'svg'"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "locqqlIQvTrK"
      },
      "outputs": [],
      "source": [
        "# @title Fonctions d'aide pour les tracés. (Exécuter la cellule)\n",
        "\n",
        "def plot_position_encodings(P, max_tokens, d_model):\n",
        "    \"\"\"\n",
        "    Trace la matrice des encodages de position.\n",
        "\n",
        "    Args:\n",
        "        P: Matrice des encodages de position (tableau 2D).\n",
        "        max_tokens: Nombre maximum de tokens (lignes) à tracer.\n",
        "        d_model: Dimensionnalité du modèle (colonnes) à tracer.\n",
        "    \"\"\"\n",
        "\n",
        "    # Définir la taille du tracé en fonction du nombre de tokens et de la dimension du modèle\n",
        "    plt.figure(figsize=(20, np.min([8, max_tokens])))\n",
        "\n",
        "    # Tracer la matrice des encodages de position avec une carte de couleurs pour une meilleure visualisation\n",
        "    im = plt.imshow(P, aspect=\"auto\", cmap=\"Blues_r\")\n",
        "\n",
        "    # Ajouter une barre de couleur pour indiquer les valeurs d'encodage\n",
        "    plt.colorbar(im, cmap=\"blue\")\n",
        "\n",
        "    # Afficher les indices d'embedding si la dimensionnalité est petite\n",
        "    if d_model <= 64:\n",
        "        plt.xticks(range(d_model))\n",
        "\n",
        "    # Afficher les indices de position si le nombre de tokens est petit\n",
        "    if max_tokens <= 32:\n",
        "        plt.yticks(range(max_tokens))\n",
        "\n",
        "    # Étiqueter les axes\n",
        "    plt.xlabel(\"Indice d'embedding\")\n",
        "    plt.ylabel(\"Indice de position\")\n",
        "\n",
        "    # Afficher le tracé\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "def plot_image_patches(patches):\n",
        "    \"\"\"\n",
        "    Fonction qui prend une liste de patches d'image et les trace.\n",
        "\n",
        "    Args:\n",
        "        patches: Une liste ou un tableau de patches d'image à tracer.\n",
        "    \"\"\"\n",
        "\n",
        "    # Définir la figure pour tracer les patches\n",
        "    fig = plt.figure(figsize=(25, 25))\n",
        "\n",
        "    # Créer un sous-plot pour chaque patch et l'afficher\n",
        "    axes = []\n",
        "    for a in range(patches.shape[1]):\n",
        "        axes.append(fig.add_subplot(1, patches.shape[1], a + 1))\n",
        "        plt.imshow(patches[0][a])\n",
        "\n",
        "    # Ajuster la disposition pour éviter le chevauchement et afficher le tracé\n",
        "    fig.tight_layout()\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "def plot_projected_embeddings(embeddings, labels):\n",
        "    \"\"\"\n",
        "    Projette des embeddings de haute dimension en 2D et les trace.\n",
        "\n",
        "    Args:\n",
        "        embeddings: Vecteurs d'embeddings de haute dimension à projeter.\n",
        "        labels: Étiquettes correspondant à chaque embedding pour les couleurs du tracé.\n",
        "    \"\"\"\n",
        "\n",
        "    # Importer UMAP et Seaborn pour la réduction dimensionnelle et le tracé\n",
        "    import umap\n",
        "    import seaborn as sns\n",
        "\n",
        "    # Réduire la dimensionnalité des embeddings en 2D avec UMAP\n",
        "    projected_embeddings = umap.UMAP().fit_transform(embeddings)\n",
        "\n",
        "    # Tracer les projections 2D avec des étiquettes en utilisant Seaborn pour une meilleure esthétique\n",
        "    plt.figure(figsize=(15, 8))\n",
        "    plt.title(\"Projections des embeddings textuels\")\n",
        "    sns.scatterplot(\n",
        "        x=projected_embeddings[:, 0], y=projected_embeddings[:, 1], hue=labels\n",
        "    )\n",
        "\n",
        "    # Afficher le tracé\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "def plot_attention_weight_matrix(weight_matrix, x_ticks, y_ticks):\n",
        "    \"\"\"\n",
        "    Trace une matrice de poids d'attention avec des ticks d'axe personnalisés.\n",
        "\n",
        "    Args:\n",
        "        weight_matrix: La matrice de poids d'attention à tracer.\n",
        "        x_ticks: Étiquettes pour l'axe des x (généralement les tokens de la requête).\n",
        "        y_ticks: Étiquettes pour l'axe des y (généralement les tokens clés).\n",
        "    \"\"\"\n",
        "\n",
        "    # Définir la taille du tracé\n",
        "    plt.figure(figsize=(15, 7))\n",
        "\n",
        "    # Tracer la matrice de poids d'attention sous forme de carte thermique\n",
        "    ax = sns.heatmap(weight_matrix, cmap=\"Blues\")\n",
        "\n",
        "    # Définir des ticks personnalisés pour les axes x et y\n",
        "    plt.xticks(np.arange(weight_matrix.shape[1]) + 0.5, x_ticks)\n",
        "    plt.yticks(np.arange(weight_matrix.shape[0]) + 0.5, y_ticks)\n",
        "\n",
        "    # Étiqueter le tracé\n",
        "    plt.title(\"Matrice d'attention\")\n",
        "    plt.xlabel(\"Score d'attention\")\n",
        "\n",
        "    # Afficher le tracé\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kMkaKekB_pR4"
      },
      "outputs": [],
      "source": [
        "# @title Fonctions Utilitaires pour le Traitement de Texte. (Exécutez la Cellule)\n",
        "\n",
        "def get_word2vec_embedding(words):\n",
        "    \"\"\"\n",
        "    Fonction qui prend une liste de mots et retourne une liste de leurs intégrations,\n",
        "    basée sur un encodeur word2vec préentraîné.\n",
        "    \"\"\"\n",
        "    word2vec_sample = str(find(\"models/word2vec_sample/pruned.word2vec.txt\"))\n",
        "    model = gensim.models.KeyedVectors.load_word2vec_format(\n",
        "        word2vec_sample, binary=False\n",
        "    )\n",
        "\n",
        "    output = []\n",
        "    words_pass = []\n",
        "    for word in words:\n",
        "        try:\n",
        "            output.append(jnp.array(model.word_vec(word)))\n",
        "            words_pass.append(word)\n",
        "        except:\n",
        "            pass\n",
        "\n",
        "    embeddings = jnp.array(output)\n",
        "    del model  # libérer de l'espace à nouveau\n",
        "    return embeddings, words_pass\n",
        "\n",
        "\n",
        "def remove_punctuation(text):\n",
        "    \"\"\"Fonction qui prend une chaîne de caractères et supprime toute la ponctuation.\"\"\"\n",
        "    import re\n",
        "\n",
        "    text = re.sub(r\"[^\\w\\s]\", \"\", text)\n",
        "    return text\n",
        "\n",
        "def print_sample(prompt: str, sample: str):\n",
        "  \"\"\"Fonction qui prend une instruction de prompt et une réponse de modèle et\n",
        "  les affiche en différentes couleurs pour montrer une distinction\"\"\"\n",
        "  print(colorama.Fore.MAGENTA + prompt, end=\"\")\n",
        "  print(colorama.Fore.BLUE + sample)\n",
        "  print(colorama.Fore.RESET)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4zu5cg-YG4XU"
      },
      "source": [
        "## Commençons avec une Démo Hugging Face ! <font color='orange'>Débutant</font>\n",
        "\n",
        "Nous sommes ravis de vous avoir à bord ! 🎉 Avant de plonger dans la partie pratique de notre voyage, faisons un petit détour dans le monde fascinant de [Hugging Face](https://huggingface.co/)—une plateforme open-source incroyable pour construire et déployer des modèles de langage à la pointe de la technologie. 🌐\n",
        "\n",
        "Comme avant-goût de ce que nous allons créer aujourd'hui, nous allons commencer par charger un *petit* modèle de langage (*en comparaison avec les modèles d'aujourd'hui) et lui donner une instruction simple. Cela vous donnera un aperçu de la manière d'interagir avec ces bibliothèques puissantes. 💡 Préparez-vous à débloquer le potentiel des modèles de langage avec juste quelques lignes de code !\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AwjIIipOG4fz"
      },
      "source": [
        "### Hugging Face\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N2DSHiuhG4f0"
      },
      "source": [
        "<img src=\"https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.png\" width=\"10%\">\n",
        "\n",
        "\n",
        "[Hugging Face](https://huggingface.co/) est une startup fondée en 2016 et, selon leurs propres mots : \"ils ont pour mission de démocratiser le machine learning de qualité, un commit à la fois.\" Actuellement, ils sont une véritable mine d'or pour les outils permettant de travailler avec les Modèles de Langage de Grande Taille (LLMs).\n",
        "\n",
        "Ils ont développé divers packages open-source et permettent aux utilisateurs d'interagir facilement avec un large corpus de modèles transformeurs préentraînés (dans toutes les modalités) et de datasets pour entraîner ou ajuster finement ces transformeurs préentraînés. Leur logiciel est largement utilisé dans l'industrie et la recherche. Pour plus de détails sur eux et leur utilisation, référez-vous à [l'exercice pratique sur l'attention et les transformeurs de 2022](https://colab.research.google.com/github/deep-learning-indaba/indaba-pracs-2022/blob/main/practicals/attention_and_transformers.ipynb#scrollTo=qFBw8kRx-4Mk).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3xdt9PQ6G4f0"
      },
      "source": [
        "Dans ce colab, nous affichons les prompts en <font color='HotPink'><b>rose</b></font> et les échantillons générés par un modèle en <font color='blue'><b>bleu</b></font> comme dans l'exemple ci-dessous :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "L-8C9SJCG4f0"
      },
      "outputs": [],
      "source": [
        "print_sample(prompt='Mon faux prompt', sample=' est génial !')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eq46TV_0G4f0"
      },
      "source": [
        "### C'est l'heure de la démo ! ⏰⚡ Charger un modèle Hugging Face et exécuter un échantillon\n",
        "\n",
        "Plongeons dans la simplicité de charger et d'interagir avec un modèle de Hugging Face !\n",
        "\n",
        "Pour ce tutoriel, nous avons préconfiguré deux options de modèles :\n",
        "\n",
        "- **`gpt-neo-125M`** : Un modèle plus petit avec 125 millions de paramètres. Il est plus rapide et utilise moins de mémoire—parfait pour commencer ! Nous vous recommandons d'essayer celui-ci en premier.\n",
        "- **`gpt2-medium`** : Un modèle plus grand avec 355 millions de paramètres pour une utilisation plus avancée.\n",
        "\n",
        "Si vous souhaitez changer de modèle, il vous suffit de redémarrer le noyau Colab et de mettre à jour le nom du modèle dans la cellule ci-dessous.\n",
        "\n",
        "**Remarque** : Les étapes que nous allons montrer fonctionnent non seulement pour ces modèles, mais aussi pour [tous les modèles](https://huggingface.co/models?pipeline_tag=text-generation) sur Hugging Face qui prennent en charge les pipelines de génération de texte.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QVV28V-TG4f1"
      },
      "outputs": [],
      "source": [
        "# Définir le nom du modèle sur \"EleutherAI/gpt-neo-125M\" (cela peut être changé via les options du menu déroulant)\n",
        "model_name = \"EleutherAI/gpt-neo-125M\"  # @param [\"gpt2-medium\", \"EleutherAI/gpt-neo-125M\"]\n",
        "\n",
        "# Définir le prompt pour le modèle de génération de texte\n",
        "test_prompt = \"Qu'est-ce que l'amour ?\"  # @param {type: \"string\"}\n",
        "\n",
        "# Créer un pipeline de génération de texte en utilisant le modèle spécifié\n",
        "generator = transformers.pipeline('text-generation', model=model_name)\n",
        "\n",
        "# Générer du texte basé sur le prompt fourni\n",
        "# 'do_sample=True' permet l'échantillonnage pour introduire de l'aléatoire dans la génération, et 'min_length=30' garantit qu'au moins 30 tokens sont générés\n",
        "model_output = generator(test_prompt, do_sample=True, min_length=30)\n",
        "\n",
        "# Afficher l'échantillon de texte généré, en supprimant le prompt original de la sortie\n",
        "print_sample(test_prompt, model_output[0]['generated_text'].split(test_prompt)[1].rstrip())\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V5IEKl4iG4f1"
      },
      "source": [
        "**💡 Astuce :** Essayez d'exécuter le code ci-dessus avec différents prompts ou avec le même prompt plusieurs fois !\n",
        "\n",
        "**🤔 Discussion :** Pourquoi pensez-vous que le texte généré change à chaque fois, même avec le même prompt ?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TfV0Qk6yG4f1"
      },
      "source": [
        "Créons notre propre fonction `generator` pour faciliter le chargement de différents poids de modèles et configurer la génération de texte. Il vous suffit d'exécuter les cellules ci-dessous pour commencer ! 😀\n",
        "\n",
        "Pour l'instant, ne vous inquiétez pas trop de comprendre les détails du tokenizer. Considérez-le simplement comme une étape pour convertir l'entrée dans un format que le modèle de langage peut comprendre. Nous approfondirons la tokenisation plus tard dans le notebook.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jxs5bO_sG4f1"
      },
      "outputs": [],
      "source": [
        "# Vérifiez si le nom du modèle contient 'gpt2' et chargez le tokenizer et le modèle appropriés\n",
        "if 'gpt2' in model_name:\n",
        "    # Charger le tokenizer et le modèle GPT-2\n",
        "    tokenizer = transformers.GPT2Tokenizer.from_pretrained(model_name)\n",
        "    model = transformers.GPT2LMHeadModel.from_pretrained(model_name)\n",
        "# Si le nom du modèle est 'EleutherAI/gpt-neo-125M', chargez le tokenizer et le modèle correspondants\n",
        "elif model_name == \"EleutherAI/gpt-neo-125M\":\n",
        "    # Charger l'AutoTokenizer et l'AutoModel pour le modèle GPT-Neo spécifié\n",
        "    tokenizer = transformers.AutoTokenizer.from_pretrained(model_name)\n",
        "    model = transformers.AutoModelForCausalLM.from_pretrained(model_name)\n",
        "# Lever une erreur si le nom du modèle n'est pas pris en charge\n",
        "else:\n",
        "    raise NotImplementedError\n",
        "\n",
        "# Si un GPU est disponible, déplacer le modèle sur le GPU pour un traitement plus rapide\n",
        "if torch.cuda.is_available():\n",
        "    model = model.to(\"cuda\")\n",
        "\n",
        "# Définir l'ID du token de remplissage pour qu'il soit le même que l'ID du token de fin de séquence\n",
        "tokenizer.pad_token_id = tokenizer.eos_token_id\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vsZEwoZJG4f1"
      },
      "outputs": [],
      "source": [
        "def run_sample(\n",
        "    model,  # Le modèle de langage que nous utiliserons pour générer du texte\n",
        "    tokenizer,  # Le tokenizer qui convertit le texte dans un format que le modèle comprend\n",
        "    prompt: str,  # Le texte d'invite que nous donnerons au modèle pour commencer la génération de texte\n",
        "    seed: int | None = None,  # Optionnel : Un nombre pour rendre les résultats prévisibles à chaque exécution\n",
        "    temperature: float = 0.6,  # Contrôle le caractère aléatoire de la sortie du modèle ; des valeurs plus basses rendent la sortie plus ciblée\n",
        "    top_p: float = 0.9,  # Contrôle combien des mots les plus probables sont pris en compte ; des valeurs plus élevées considèrent plus d'options\n",
        "    max_new_tokens: int = 64,  # Le nombre maximum de mots ou de tokens que le modèle ajoutera à l'invite\n",
        ") -> str:\n",
        "    # Cette fonction génère du texte en fonction d'une invite donnée en utilisant un modèle de langage,\n",
        "    # avec des options pour contrôler l'aléatoire, le nombre de tokens générés, et la reproductibilité.\n",
        "\n",
        "    # Convertir le texte d'invite en tokens que le modèle peut traiter\n",
        "    inputs = tokenizer(prompt, return_tensors=\"pt\")\n",
        "\n",
        "    # Extraire les tokens (input IDs) et le masque d'attention (pour se concentrer sur les parties importantes) des entrées\n",
        "    input_ids = inputs[\"input_ids\"]\n",
        "    attention_mask = inputs[\"attention_mask\"]\n",
        "\n",
        "    # Déplacer les tokens et le masque d'attention vers le même appareil que le modèle (comme un GPU si disponible)\n",
        "    input_ids = input_ids.to(model.device)\n",
        "    attention_mask = attention_mask.to(model.device)\n",
        "\n",
        "    # Configurer la manière dont nous voulons que le modèle génère du texte\n",
        "    generation_config = transformers.GenerationConfig(\n",
        "        do_sample=True,  # Permet au modèle d'ajouter un peu d'aléatoire à sa génération de texte\n",
        "        temperature=temperature,  # Ajuste le caractère aléatoire de la sortie ; des valeurs plus basses rendent la sortie plus ciblée\n",
        "        top_p=top_p,  # Considère les mots les plus probables qui constituent les 90% des possibilités\n",
        "        pad_token_id=tokenizer.pad_token_id,  # Utilise l'ID de token qui représente le remplissage (espace supplémentaire)\n",
        "        top_k=0,  # Nous ne limitons pas aux top-k mots, donc nous le réglons à 0\n",
        "    )\n",
        "\n",
        "    # Si une graine (seed) est fournie, la définir pour que les résultats soient reproductibles (même sortie à chaque exécution)\n",
        "    if seed is not None:\n",
        "        torch.manual_seed(seed)\n",
        "\n",
        "    # Générer du texte en utilisant le modèle avec les paramètres que nous avons définis\n",
        "    generation_output = model.generate(\n",
        "        input_ids=input_ids,  # Fournir les tokens d'entrée au modèle\n",
        "        attention_mask=attention_mask,  # Fournir le masque d'attention pour aider le modèle à se concentrer\n",
        "        return_dict_in_generate=True,  # Demander au modèle de renvoyer des informations détaillées\n",
        "        output_scores=True,  # Inclure les scores (niveaux de confiance) pour les tokens générés\n",
        "        max_new_tokens=max_new_tokens,  # Définir le nombre maximum de tokens à générer\n",
        "        generation_config=generation_config,  # Appliquer nos paramètres personnalisés de génération de texte\n",
        "    )\n",
        "\n",
        "    # S'assurer qu'une seule séquence (sortie) est générée, pour simplifier les choses\n",
        "    assert len(generation_output.sequences) == 1\n",
        "\n",
        "    # Obtenir la séquence de tokens générée\n",
        "    output_sequence = generation_output.sequences[0]\n",
        "\n",
        "    # Convertir les tokens générés en texte lisible\n",
        "    output_string = tokenizer.decode(output_sequence)\n",
        "\n",
        "    # Imprimer l'invite et la réponse générée\n",
        "    print_sample(prompt, output_string)\n",
        "\n",
        "    # Retourner le texte généré\n",
        "    return output_string"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yme6VzW4G4f1"
      },
      "outputs": [],
      "source": [
        "_ = run_sample(model, tokenizer, prompt=\"Qu'est-ce que l'amour ?\", temperature=0.5, seed=2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V7vnUawyG4f1"
      },
      "source": [
        "Assez incroyable, n'est-ce pas ? 🤩 Essayez de jouer avec les valeurs de **prompt**, **temperature** et **seed** ci-dessus et voyez les différentes sorties que vous obtenez. Que remarquez-vous lorsque vous augmentez la température ? Bien que cela ait pu être époustouflant en 2021, la plupart d'entre vous ont probablement déjà interagi avec des modèles de langage de grande taille. Aujourd'hui, nous allons aller plus loin en entraînant notre propre **modèle de langage inspiré de Shakespeare**. Cela nous permettra de comprendre concrètement comment ces modèles fonctionnent en coulisses.\n",
        "\n",
        "Mais avant de passer à l'entraînement, construisons d'abord une solide compréhension de ce que sont les **modèles de langage de grande taille** et des concepts clés de **l'apprentissage automatique** qui rendent cette technologie révolutionnaire possible. Au cœur des LLMs à la pointe de la technologie (SoTA) d'aujourd'hui se trouvent le **mécanisme d'attention** et l'**architecture Transformer**. Nous allons explorer ces concepts essentiels dans les prochaines sections de ce tutoriel. 🚀💡"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-ZUp8i37dFbU"
      },
      "source": [
        "## **1. Attention**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "acgW1ofF_RFz"
      },
      "source": [
        "Le mécanisme d'attention est inspiré par la manière dont les humains regardent une image ou lisent une phrase.\n",
        "\n",
        "Prenons l'image du chien en vêtements humains ci-dessous (image et exemple [source](https://lilianweng.github.io/posts/2018-06-24-attention/)). Lorsque nous prêtons *attention* aux blocs de pixels rouges, nous dirons que le bloc jaune des oreilles pointues est quelque chose que nous attendions (corrélé), mais que les blocs gris des vêtements humains sont inattendus pour nous (non corrélé). Ceci est *basé sur ce que nous avons vu dans le passé* en regardant des photos de chiens, spécifiquement d'un Shiba Inu.\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1iEU7Cph2D2PCXp3YEHj30-EndhHAeB5T\" alt=\"drawing\" width=\"450\"/>\n",
        "\n",
        "Supposons que nous voulons identifier la race de chien dans cette image. Lorsque nous regardons les blocs de pixels rouges, nous avons tendance à prêter plus d'*attention* aux pixels pertinents qui sont plus similaires ou liés à eux, ce qui pourrait être ceux dans la boîte jaune. Nous ignorons presque complètement la neige en arrière-plan et les vêtements humains pour cette tâche.\n",
        "\n",
        "D'un autre côté, lorsque nous commençons à regarder l'arrière-plan dans une tentative d'identifier ce qu'il contient, nous ignorons inconsciemment les pixels du chien car ils sont sans importance pour la tâche actuelle.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "usLBF2g0x5gH"
      },
      "source": [
        "La même chose se produit lorsque nous lisons. Pour comprendre toute la phrase, nous apprendrons à corréler et à *prêter attention à* certains mots en fonction du contexte de la phrase entière.\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1j23kcfu_c3wINU6DUvxzMYNmp4alhHc9\" alt=\"drawing\" width=\"350\"/>\n",
        "\n",
        "Par exemple, dans la première phrase de l'image ci-dessus, en regardant le mot \"coding\", nous prêtons plus d'attention aux mots \"Apple\" et \"computer\" car nous savons que lorsque nous parlons de codage, \"Apple\" fait en fait référence à l'entreprise. Cependant, dans la deuxième phrase, nous réalisons que nous ne devrions pas considérer \"apple\" en regardant \"code\" car, compte tenu du contexte du reste de la phrase, nous savons que cette pomme fait référence à une pomme réelle et non à un ordinateur.\n",
        "\n",
        "Nous pouvons construire de meilleurs modèles en développant des mécanismes qui imitent l'attention. Cela permettra à nos modèles d'apprendre de meilleures représentations de nos données d'entrée en contextualisant ce qu'ils savent sur certaines parties de l'entrée en fonction d'autres parties. Dans les sections suivantes, nous explorerons les mécanismes qui nous permettent d'entraîner des modèles d'apprentissage profond à prêter attention aux données d'entrée dans le contexte d'autres données d'entrée.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ygdi884ugGcu"
      },
      "source": [
        "### Intuition - <font color='orange'>Débutant</font>\n",
        "\n",
        "Imaginez l'attention comme un mécanisme qui permet à un réseau neuronal de se concentrer davantage sur certaines parties des données. En faisant cela, le réseau peut améliorer sa compréhension du problème sur lequel il travaille, en mettant à jour sa compréhension ou ses représentations en conséquence.\n",
        "\n",
        "### Comprendre l'Attention en termes simples\n",
        "\n",
        "Une façon de mettre en œuvre l'attention dans les réseaux neuronaux est de représenter chaque mot (ou même des parties d'un mot) comme un vecteur.\n",
        "\n",
        "Alors, qu'est-ce qu'un vecteur ? Un vecteur est simplement un tableau de nombres (appelés nombres réels) qui peut avoir différentes longueurs. Pensez-y comme à une liste de valeurs qui décrivent certaines propriétés d'un mot. Ces vecteurs nous permettent de mesurer à quel point deux mots sont similaires. Une façon courante de mesurer cette similarité est de calculer ce qu'on appelle le **produit scalaire**.\n",
        "\n",
        "Le résultat de ce calcul de similarité est ce que nous appelons **l'attention.** Cette valeur d'attention aide le modèle à décider dans quelle mesure un mot doit influencer la représentation d'un autre mot.\n",
        "\n",
        "En termes plus simples, si deux mots ont des représentations vectorielles similaires, cela signifie qu'ils sont probablement liés ou importants l'un pour l'autre. En raison de cette relation, ils affectent les représentations de chacun dans le réseau neuronal, permettant au modèle de mieux comprendre le contexte. 🎯\n",
        "\n",
        "Pour illustrer comment le produit scalaire peut créer des poids d'attention significatifs, nous utiliserons des embeddings [word2vec](https://jalammar.github.io/illustrated-word2vec/) pré-entraînés. Ces embeddings word2vec sont générés par un réseau neuronal qui a appris à créer des embeddings similaires pour des mots ayant des significations similaires.\n",
        "\n",
        "En calculant la matrice des produits scalaires entre tous les vecteurs, nous obtenons une matrice d'attention. Cela indiquera quels mots sont corrélés et devraient donc \"se prêter attention\" mutuellement.\n",
        "\n",
        "[1] Vous pouvez trouver plus de détails sur la façon dont cela est fait pour les LLMs dans la session \"Construire votre propre LLM\".\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OvBYShCFk6WC"
      },
      "source": [
        "**Tâche de code** <font color='blue'>Intermédiaire</font> : Complétez la fonction d'attention par produit scalaire ci-dessous.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yrbITGPnk7Ce"
      },
      "outputs": [],
      "source": [
        "def dot_product_attention(hidden_states, previous_state):\n",
        "    \"\"\"\n",
        "    Calcule le produit scalaire entre les états cachés et les états précédents.\n",
        "\n",
        "    Args:\n",
        "        hidden_states: Un tenseur de forme [T_hidden, dm]\n",
        "        previous_state: Un tenseur de forme [T_previous, dm]\n",
        "    \"\"\"\n",
        "\n",
        "    # Indice : Pour calculer les scores d'attention, réfléchissez à la manière dont vous pouvez utiliser le vecteur `previous_state`\n",
        "    # et la matrice `hidden_states`. Vous voulez déterminer à quel point chaque élément de `previous_state`\n",
        "    # doit \"prêter attention\" à chaque élément de `hidden_states`. Rappelez-vous que dans la multiplication matricielle,\n",
        "    # vous pouvez trouver la relation entre deux ensembles de vecteurs en multipliant l'un par la transposée de l'autre.\n",
        "    # Indice : Utilisez `jnp.matmul` pour effectuer la multiplication matricielle entre `previous_state` et la\n",
        "    # transposée de `hidden_states` (`hidden_states.T`).\n",
        "    scores = ...  # FINISH ME\n",
        "\n",
        "    # Indice : Maintenant que vous avez les scores, vous devez les convertir en probabilités.\n",
        "    # Une fonction softmax est généralement utilisée dans les mécanismes d'attention pour transformer les scores bruts en probabilités\n",
        "    # qui s'additionnent pour donner 1. Cela aidera à déterminer sur quel état caché se concentrer.\n",
        "    # Indice : Utilisez `jax.nn.softmax` pour appliquer la fonction softmax aux `scores`.\n",
        "    w_n = ...  # FINISH ME\n",
        "\n",
        "    # Multipliez les poids par les états cachés pour obtenir le vecteur de contexte\n",
        "    # Indice : Utilisez à nouveau `jnp.matmul` pour multiplier les poids d'attention `w_n` par `hidden_states`\n",
        "    # pour obtenir le vecteur de contexte.\n",
        "    c_t = jnp.matmul(w_n, hidden_states)\n",
        "\n",
        "    return w_n, c_t\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QARgTrNZlIqH"
      },
      "outputs": [],
      "source": [
        "# @title Exécutez-moi pour tester votre code\n",
        "\n",
        "key = jax.random.PRNGKey(42)\n",
        "x = jax.random.normal(key, [2, 2])\n",
        "\n",
        "try:\n",
        "  w_n, c_t = dot_product_attention(x, x)\n",
        "\n",
        "  w_n_correct = jnp.array([[0.9567678, 0.04323225], [0.00121029, 0.99878967]])\n",
        "  c_t_correct = jnp.array([[0.11144122, 0.95290256], [-1.5571996, -1.5321486]])\n",
        "  assert jnp.allclose(w_n_correct, w_n), \"w_n n'est pas calculé correctement\"\n",
        "  assert jnp.allclose(c_t_correct, c_t), \"c_t n'est pas calculé correctement\"\n",
        "\n",
        "  print(\"Cela semble correct. Regardez la réponse ci-dessous pour comparer les méthodes.\")\n",
        "except:\n",
        "  print(\"Il semble que la fonction n'est pas encore complètement implémentée. Essayez de la modifier.\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qa6PyKYnkzUJ"
      },
      "outputs": [],
      "source": [
        "# Lors du changement de ces mots, notez que si le mot n'est pas dans le corpus\n",
        "# d'entraînement original, il ne sera pas affiché dans le graphique de la matrice des poids.\n",
        "# @title Réponse à la tâche de code (Essayez de ne pas regarder avant d'avoir bien essayé !')\n",
        "def dot_product_attention(hidden_states, previous_state):\n",
        "    # Calculer les scores d'attention :\n",
        "    # Multiplier le vecteur de l'état précédent par la transposée de la matrice des états cachés.\n",
        "    # Cela nous donne une matrice de scores qui montre à quel point chaque élément de l'état précédent\n",
        "    # doit prêter attention à chaque élément des états cachés.\n",
        "    # Le résultat est une matrice de forme [T, N], où :\n",
        "    # T est le nombre d'éléments dans les états cachés,\n",
        "    # N est le nombre d'éléments dans l'état précédent.\n",
        "    scores = jnp.matmul(previous_state, hidden_states.T)\n",
        "\n",
        "    # Appliquer la fonction softmax aux scores pour les convertir en probabilités.\n",
        "    # Cela normalise les scores pour qu'ils soient additionnés à 1 pour chaque élément,\n",
        "    # ce qui nous permet de les interpréter comme le degré d'attention à accorder à chaque état caché.\n",
        "    w_n = jax.nn.softmax(scores)\n",
        "\n",
        "    # Calculer le vecteur de contexte (c_t) :\n",
        "    # Multiplier les poids d'attention (w_n) par les états cachés.\n",
        "    # Cela combine les états cachés en fonction du degré d'attention que chacun mérite,\n",
        "    # ce qui donne un nouveau vecteur qui représente la somme pondérée des états cachés.\n",
        "    # La forme résultante est [T, d], où :\n",
        "    # T est le nombre d'éléments dans l'état précédent,\n",
        "    # d est la dimension des états cachés.\n",
        "    c_t = jnp.matmul(w_n, hidden_states)\n",
        "\n",
        "    # Retourner les poids d'attention et le vecteur de contexte.\n",
        "    return w_n, c_t\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QlHL3e_QhLfq"
      },
      "outputs": [],
      "source": [
        "mots = [\"king\", \"queen\", \"royalty\", \"food\", \"apple\", \"pear\", \"computers\"]\n",
        "embeddings_mots, mots = get_word2vec_embedding(mots)\n",
        "poids, _ = dot_product_attention(embeddings_mots, embeddings_mots)\n",
        "plot_attention_weight_matrix(poids, mots, mots)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tItZU09YlhEZ"
      },
      "source": [
        "En regardant la matrice, nous pouvons voir quels mots ont des significations similaires. Le groupe de mots \"royal\" a des scores d'attention plus élevés les uns avec les autres que les mots \"nourriture\", qui s'attendent tous mutuellement. Nous voyons également que \"computers\" ont des scores d'attention très bas pour tous, ce qui montre qu'ils ne sont ni très liés aux mots \"royal\" ni aux mots \"nourriture\".\n",
        "\n",
        "**Tâche de groupe :**\n",
        "  - Jouez avec les sélections de mots ci-dessus. Voyez si vous pouvez trouver des combinaisons de mots dont les valeurs d'attention semblent contre-intuitives. Pensez à des explications possibles. Quel sens d'un mot les scores d'attention ont-ils capturé ?\n",
        "  - Demandez à votre ami s'il a trouvé des exemples.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S3iB8hf0hJdX"
      },
      "source": [
        "**Remarque** : Le produit scalaire n'est qu'une des façons de mettre en œuvre la fonction de score pour les mécanismes d'attention, il existe une liste plus étendue dans cet [article de blog](https://lilianweng.github.io/posts/2018-06-24-attention/#summary) de Dr Lilian Weng.\n",
        "\n",
        "Plus de ressources :\n",
        "\n",
        "[Un modèle de base encodeur-décodeur pour la traduction automatique](https://www.youtube.com/watch?v=gHk2IWivt_8&list=PLmZlBIcArwhPHmHzyM_cZJQ8_v5paQJTV&index=1)\n",
        "\n",
        "[Entraînement et perte pour les modèles encodeur-décodeur](https://www.youtube.com/watch?v=aBZUTuT1Izs&list=PLmZlBIcArwhPHmHzyM_cZJQ8_v5paQJTV&index=2)\n",
        "\n",
        "[Attention de base](https://www.youtube.com/watch?v=BSSoEtv5jvQ&list=PLmZlBIcArwhPHmHzyM_cZJQ8_v5paQJTV&index=6)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aQfqM1EJyDXI"
      },
      "source": [
        "### Mécanismes d'attention séquence à séquence - <font color='green'>Intermédiaire</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "68QBeG-4yDZ9"
      },
      "source": [
        "Les premiers mécanismes d'attention ont été utilisés dans les modèles séquence à séquence. Ces modèles étaient généralement des structures encodeur et décodeur RNN. La séquence d'entrée était traitée séquentiellement par un RNN, encodant la séquence dans un seul vecteur de contexte, qui était ensuite alimenté dans un autre RNN générant une nouvelle séquence. Voici un exemple de cela ([source](https://lilianweng.github.io/posts/2018-06-24-attention/)).\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1FKfaArN1rsLjzVWaJGpMLEcxEshSLXd6\" alt=\"drawing\" width=\"600\"/>\n",
        "\n",
        "Étant donné qu'il n'y a qu'un seul vecteur de contexte, il est difficile pour l'encodeur de représenter de longues séquences et l'information est généralement perdue. Le mécanisme d'attention introduit dans [Bahdanau et al., 2015](https://arxiv.org/pdf/1409.0473.pdf) a été proposé pour résoudre ce problème.\n",
        "\n",
        "Ici, au lieu de se fier à un seul vecteur de contexte statique, qui est également utilisé une seule fois dans le processus de décodage, nous fournissons des informations sur toute la séquence d'entrée à chaque étape de décodage en utilisant un vecteur de contexte dynamique. Ce faisant, le décodeur peut accéder à une plus grande \"banque\" de mémoire et prêter attention aux informations nécessaires de l'entrée en fonction de l'état actuel du RNN décodeur, $s_t$. Cela est illustré ci-dessous.\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1fB5KObXcKo5x35xlIDIcjHTq1q75ejIB\" alt=\"drawing\" width=\"600\"/>\n",
        "\n",
        "En apprentissage profond, l'attention peut être interprétée comme un vecteur \"d'importance\". Pour prédire ou inférer un élément, tel qu'un pixel dans une image ou un mot dans une phrase, nous estimons à quel point il est corrélé avec, ou \"attend\", d'autres éléments en utilisant le vecteur/poids d'attention. Ces poids d'attention sont ensuite utilisés pour générer une nouvelle somme pondérée des éléments restants, ce qui représente la cible [(source)](https://lilianweng.github.io/posts/2018-06-24-attention/).\n",
        "\n",
        "Cela consiste généralement en trois étapes pour chaque étape de décodage $t$ :\n",
        "\n",
        "1. Calculer le score (importance) pour chaque $h_n$, étant donné $s_{t-1}$, et utiliser la fonction softmax pour transformer cela en un vecteur d'attention, $w_{n}$.\n",
        "  - $\\text{score} = a(s_{t−1}, h_{n})$, où $a$ peut être n'importe quelle fonction différentiable, telle que le produit scalaire.\n",
        "  - $w_{n} = \\frac{\\exp \\left\\{a\\left(s_{t-1}, h_{n}\\right)\\right\\}}{\\sum_{j=1}^{N} \\exp \\left\\{a\\left(s_{t-1}, h_{j}\\right)\\right\\}}$, où nous utilisons la fonction softmax pour transformer les scores bruts en poids d'attention relatifs.\n",
        "2. Générer le vecteur de contexte final, $c_t$, en sommant les produits des poids d'attention et des vecteurs de contexte de l'encodeur.\n",
        "  - $c_t=\\sum_{n=1}^{N} w_n h_{n}$\n",
        "3. Générer l'état décodeur suivant $s_{t+1}$ en combinant l'état décodeur actuel, $s_t$, avec le vecteur de contexte, $c_t$, via une fonction, $f$.\n",
        "\n",
        "  - $s_{t+1} = f\\left ( c_t, s_t \\right)$\n",
        "\n",
        "  Dans Bahdanau et al., 2015, $f$ était une couche feedforward apprise prenant en entrée le vecteur concaténé $[c_t; s_t]$, avec $a(s_{t−1}, h_{n})$ étant le produit scalaire.\n",
        "  \n",
        "Ensuite, construisons ce schéma d'attention, tel qu'il est utilisé dans l'architecture du transformeur. Nous avons déjà calculé une simple attention par produit scalaire, où le score était donné par $a(s_{t-1}, h_n)=s_{t-1} h_n^\\top$ et nous allons réutiliser la même idée.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J-MU6rrny8Nj"
      },
      "source": [
        "### De l'auto-attention à l'attention multi-têtes - <font color='blue'>Intermédiaire</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BRuLtxNey_EQ"
      },
      "source": [
        "L'auto-attention et l'attention multi-têtes (MHA) sont des composants fondamentaux de l'architecture du transformeur. Dans cette section, nous expliquerons en détail l'intuition derrière ces concepts et leur mise en œuvre. Plus tard, dans la section **Transformers**, vous apprendrez comment ces mécanismes d'attention sont utilisés pour créer un modèle séquence à séquence qui repose entièrement sur l'attention.\n",
        "\n",
        "À mesure que nous avancerons, nous représenterons les phrases en les décomposant en mots individuels et en encodant chaque mot en utilisant le modèle word2vec discuté précédemment. Dans la section Transformers, nous explorerons plus en détail comment les séquences d'entrée sont transformées en une série de vecteurs.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Oe1lR5_oynOR"
      },
      "outputs": [],
      "source": [
        "def embed_sentence(sentence):\n",
        "    \"\"\"\n",
        "    Encoder une phrase en utilisant word2vec ; pour des cas d'utilisation d'exemple uniquement.\n",
        "    \"\"\"\n",
        "    # nettoyer la phrase (pas nécessaire si vous utilisez un tokenizer LLM approprié)\n",
        "    sentence = remove_punctuation(sentence)\n",
        "\n",
        "    # extraire les mots individuels\n",
        "    mots = sentence.split()\n",
        "\n",
        "    # obtenir l'embedding word2vec pour chaque mot de la phrase\n",
        "    séquence_vecteur_mots, mots = get_word2vec_embedding(mots)\n",
        "\n",
        "    # retour avec dimension supplémentaire (utile pour créer des lots plus tard)\n",
        "    return jnp.expand_dims(séquence_vecteur_mots, axis=0), mots\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0AFUEFZGzCTv"
      },
      "source": [
        "#### Auto-attention\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LF2V3KI-za9l"
      },
      "source": [
        "L'auto-attention est un mécanisme d'attention où chaque vecteur d'une séquence d'entrée donnée prête attention à l'ensemble de la séquence. Pour comprendre pourquoi l'auto-attention est importante, pensons à la phrase suivante (exemple tiré de [source](https://jalammar.github.io/illustrated-transformer/)) :\n",
        "\n",
        "`\"L'animal n'a pas traversé la rue parce qu'il était trop fatigué.\"`\n",
        "\n",
        "Une question simple concernant cette phrase est de savoir à quoi le mot \"il\" fait référence ? Bien que cela puisse paraître simple, il peut être difficile pour un algorithme d'apprendre cela. C'est là que l'auto-attention intervient, car elle peut apprendre une matrice d'attention pour le mot \"il\" où un poids important est attribué au mot \"animal\".\n",
        "\n",
        "L'auto-attention permet également au modèle d'apprendre à interpréter les mots ayant les mêmes embeddings, comme \"pomme\", qui peut désigner une entreprise ou un aliment, selon le contexte. Cela est très similaire à l'état caché que l'on trouve dans un RNN, mais ce processus, comme vous le verrez, permet au modèle de prêter attention à l'ensemble de la séquence en parallèle, permettant ainsi d'utiliser des séquences plus longues.\n",
        "\n",
        "L'auto-attention se compose de trois concepts :\n",
        "\n",
        "- Requêtes, clés et valeurs\n",
        "- Attention par produit scalaire avec échelle\n",
        "- Masques\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pwOIMtdZzdTf"
      },
      "source": [
        "##### **Requêtes, clés et valeurs**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mEf7QWIWzdo1"
      },
      "source": [
        "En général, tous les mécanismes d'attention peuvent être écrits en termes de paires `clé-valeur` et de `requêtes` pour calculer la matrice d'attention et le nouveau vecteur de contexte.\n",
        "\n",
        "Pour se faire une idée, on peut interpréter le vecteur de `requête` comme contenant les informations que nous cherchons à obtenir et les vecteurs de `clé` comme ayant des informations. Les vecteurs de `requête` sont comparés aux vecteurs de `clé` pour obtenir des scores d'attention, où un score d'attention plus élevé indique qu'une `clé` contenait des informations pertinentes. Ces scores d'attention sont ensuite utilisés pour déterminer quelles `valeurs` (qui sont associées aux `clés`) nous devons prendre en compte. Ou comme l'explique [Lena Voita](https://lena-voita.github.io/nlp_course/seq2seq_and_attention.html) :\n",
        "\n",
        "- Requête : demande d'information\n",
        "- Clé : indiquant qu'elle possède des informations\n",
        "- Valeur : fournissant les informations\n",
        "\n",
        "Dans les architectures de transformeur, nous utilisons des matrices de poids apprenables, représentées par $W_Q, W_K, W_V$, pour projeter chaque vecteur de séquence vers des vecteurs $q$, $k$, et $v$ uniques.\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1-96YjPxhcqW6FczUYwErGXHp6YpoLltq\" alt=\"drawing\" width=\"600\"/>\n",
        "\n",
        "Vous remarquerez que les vecteurs $q, k, v$ sont plus petits que les vecteurs d'entrée. Cela sera abordé ultérieurement, mais sachez simplement qu'il s'agit d'un choix de conception pour les transformeurs et non d'une exigence pour fonctionner.\n",
        "\n",
        "Ce processus peut également être parallélisé, car la séquence d'entrée peut être représentée sous forme de matrice $X$, qui peut être transformée en matrices de requêtes, clés et valeurs $Q$, $K$, et $V$ respectivement :\n",
        "\n",
        "$Q=W_QX \\\\ K=W_KX \\\\ V=W_VX$\n",
        "\n",
        "Ci-dessous, nous montrons le code qui crée trois couches linéaires, projetant les données d'entrée vers les matrices $Q, K, V$, où la taille de la sortie peut être ajustée.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Xc8zjK6eziIV"
      },
      "outputs": [],
      "source": [
        "class SequenceToQKV(nn.Module):\n",
        "  taille_sortie: int\n",
        "\n",
        "  @nn.compact\n",
        "  def __call__(self, X):\n",
        "\n",
        "    # définir la méthode d'initialisation des poids\n",
        "    initialisateur = nn.initializers.variance_scaling(scale=0.5, mode=\"fan_in\", distribution=\"truncated_normal\")\n",
        "\n",
        "    # initialiser trois couches linéaires pour faire les transformations QKV.\n",
        "    # note : cela pourrait aussi être une seule couche, comment pensez-vous que vous le feriez ?\n",
        "    couche_q = nn.Dense(self.taille_sortie, kernel_init=initialisateur)\n",
        "    couche_k = nn.Dense(self.taille_sortie, kernel_init=initialisateur)\n",
        "    couche_v = nn.Dense(self.taille_sortie, kernel_init=initialisateur)\n",
        "\n",
        "    # transformer et retourner les matrices\n",
        "    Q = couche_q(X)\n",
        "    K = couche_k(X)\n",
        "    V = couche_v(X)\n",
        "\n",
        "    return Q, K, V\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OhGZHFsHz_Qp"
      },
      "source": [
        "##### **Attention par produit scalaire avec échelle**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DxycHDUW0BVE"
      },
      "source": [
        "Maintenant que nous avons nos matrices de `requête`, `clé` et `valeur`, il est temps de calculer la matrice d'attention. N'oubliez pas que dans tous les mécanismes d'attention, nous devons d'abord trouver un score pour chaque vecteur de la séquence, puis utiliser ces scores pour créer un nouveau vecteur de contexte. Dans l'auto-attention, le scoring est effectué en utilisant l'attention par produit scalaire avec échelle, puis les scores normalisés sont utilisés comme poids pour sommer les vecteurs de valeur et créer le vecteur de contexte.\n",
        "\n",
        "$\\operatorname{Attention}(Q, K, V)=\\operatorname{softmax}\\left(\\frac{Q K^{T}}{\\sqrt{d_{k}}}\\right) V$\n",
        "\n",
        "où les scores d'attention sont calculés par $\\operatorname{softmax}\\left(\\frac{Q K^{T}}{\\sqrt{d_{k}}}\\right)$ et les scores sont ensuite multipliés par $V$ pour obtenir le vecteur de contexte.\n",
        "\n",
        "Ce qui se passe ici est similaire à ce que nous avons fait dans l'attention par produit scalaire dans la section précédente, sauf que nous appliquons le mécanisme à la séquence elle-même. Pour chaque élément de la séquence, nous calculons la matrice de poids d'attention entre $q_i$ et $K$. Nous multiplions ensuite $V$ par chaque poids et enfin, nous additionnons tous les vecteurs pondérés $v_{weighted}$ ensemble pour former une nouvelle représentation de $q_i$. Ce faisant, nous étouffons essentiellement les vecteurs non pertinents et mettons en avant les vecteurs importants de la séquence lorsque notre attention est sur $q_1$.\n",
        "\n",
        "$QK^\\top$ est mis à l'échelle par la racine carrée de la dimension des vecteurs, $\\sqrt{d_k}$, pour assurer des gradients plus stables pendant l'entraînement.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i_UYNzrS0Hga"
      },
      "outputs": [],
      "source": [
        "def scaled_dot_product_attention(query, key, value):\n",
        "    \"\"\"\n",
        "    Formule pour retourner l'attention à produit scalaire échelonné donnée les matrices QKV\n",
        "    \"\"\"\n",
        "    d_k = key.shape[-1]\n",
        "\n",
        "    # obtenir les scores bruts (logits) en effectuant le produit scalaire des requêtes et des clés\n",
        "    logits = jnp.matmul(query, jnp.swapaxes(key, -2, -1))\n",
        "\n",
        "    # échelonner les scores bruts et appliquer la fonction softmax pour obtenir les scores/poids d'attention\n",
        "    scaled_logits = logits / jnp.sqrt(d_k)\n",
        "    attention_weights = jax.nn.softmax(scaled_logits, axis=-1)\n",
        "\n",
        "    # multiplier les poids par la matrice de valeur pour obtenir la sortie\n",
        "    output = jnp.matmul(attention_weights, value)\n",
        "\n",
        "    return output, attention_weights\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cuNaEjIm0PhV"
      },
      "source": [
        "Voyons maintenant l'attention par produit scalaire avec échelle en action. Nous allons prendre une phrase, encoder chaque mot en utilisant word2vec, et voir à quoi ressemblent les poids finaux de l'auto-attention.\n",
        "\n",
        "Nous n'utiliserons pas les couches de projection linéaire que nous aurions besoin d'entraîner. À la place, nous allons simplifier les choses et utiliser $X=Q=V=K$.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3Oy2sWzR0Ok5"
      },
      "outputs": [],
      "source": [
        "# define a sentence\n",
        "sentence = \"I drink coke, but eat steak\"\n",
        "\n",
        "# embed and create QKV matrices\n",
        "word_embeddings, words = embed_sentence(sentence)\n",
        "Q = K = V = word_embeddings\n",
        "\n",
        "# calculate weights and plot\n",
        "outputs, attention_weights = scaled_dot_product_attention(Q, K, V)\n",
        "\n",
        "# plot the words and the attention weights between them\n",
        "words = remove_punctuation(sentence).split()\n",
        "plot_attention_weight_matrix(attention_weights[0], words, words)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NG1Kxljr0Vzw"
      },
      "source": [
        "Gardez à l'esprit que nous n'avons pas encore entraîné notre matrice d'attention. Cependant, en utilisant les vecteurs word2vec comme séquence, nous pouvons déjà observer que l'attention à produit scalaire échelonné est capable de se concentrer sur \"manger\" lorsque \"steak\" est notre requête, et que la requête \"boire\" se concentre davantage sur \"coca\" et \"manger\".\n",
        "\n",
        "Ressources supplémentaires :\n",
        "\n",
        "[Attention avec Q,K,V](https://www.youtube.com/watch?v=k-5QMalS8bQ&list=PLmZlBIcArwhPHmHzyM_cZJQ8_v5paQJTV&index=7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D7B-AgO80gIt"
      },
      "source": [
        "##### **Attention masquée**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tdRoKsu70gGW"
      },
      "source": [
        "Il existe des cas où appliquer l'auto-attention sur l'ensemble de la séquence n'est pas pratique. Ceux-ci peuvent inclure :\n",
        "\n",
        "- Séquences de longueurs inégales regroupées ensemble.\n",
        "  - Lors de l'envoi d'un lot de séquences à travers un réseau, l'auto-attention s'attend à ce que chaque séquence soit de la même longueur. On gère cela en remplissant la séquence. Lors du calcul de l'attention, idéalement, ces tokens de remplissage ne devraient pas être pris en compte.\n",
        "- Entraînement d'un modèle décodeur.\n",
        "  - Lors de l'entraînement de modèles décodeurs, tels que GPT-3, le décodeur a accès à toute la séquence cible lors de l'entraînement (car l'entraînement est effectué en parallèle). Pour éviter que la méthode ne triche en regardant les tokens futurs, nous devons masquer les données de la séquence future afin que les données antérieures ne puissent pas y prêter attention.\n",
        "\n",
        "En appliquant un masque au score final calculé entre les requêtes et les clés, nous pouvons atténuer l'influence des vecteurs de séquence indésirables. Les vecteurs sont masqués en faisant en sorte que le score entre la requête et leurs clés respectives soit une valeur négative TRÈS grande. Cela a pour effet que la fonction softmax pousse le poids d'attention très près de zéro, et la valeur résultante sera ignorée et n'influencera pas la représentation finale.\n",
        "\n",
        "En réunissant tout, l'attention par produit scalaire avec échelle masquée ressemble visuellement à ceci :\n",
        "\n",
        "<img src=\"https://windmissing.github.io/NLP-important-papers/AIAYN/assets/5.png\" alt=\"drawing\" width=\"200\"/>.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5Syx8_5E0eM9"
      },
      "outputs": [],
      "source": [
        "# exemple de création d'un masque pour des tokens de taille 32\n",
        "# le masque s'assure que les positions ne prêtent attention qu'aux positions précédentes dans l'entrée (masque causal)\n",
        "# nous utiliserons cela plus tard pour insérer des valeurs -inf dans les scores bruts\n",
        "masque = jnp.tril(jnp.ones((32, 32)))\n",
        "\n",
        "# tracer\n",
        "sns.heatmap(masque, cmap=\"Blues\")\n",
        "plt.title(\"Exemple de masque qui peut être appliqué\");\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pfwTJrQ20gDw"
      },
      "source": [
        "Lets now adapt our scaled dot product attention function to implement masked attention."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PVHpyNs_0ePh"
      },
      "outputs": [],
      "source": [
        "def scaled_dot_product_attention(query, key, value, mask=None):\n",
        "    \"\"\"\n",
        "    Attention à produit scalaire échelonné avec un masque causal\n",
        "    (se concentrant uniquement sur les positions précédentes)\n",
        "    \"\"\"\n",
        "    d_k = key.shape[-1]\n",
        "    T_k = key.shape[-2]\n",
        "    T_q = query.shape[-2]\n",
        "\n",
        "    # obtenir les logits échelonnés en utilisant le produit scalaire comme précédemment\n",
        "    logits = jnp.matmul(query, jnp.swapaxes(key, -2, -1))\n",
        "    scaled_logits = logits / jnp.sqrt(d_k)\n",
        "\n",
        "    # ajouter un masque optionnel où les valeurs le long du masque sont définies à -inf\n",
        "    if mask is not None:\n",
        "        scaled_logits = jnp.where(mask[:T_q, :T_k], scaled_logits, -jnp.inf)\n",
        "\n",
        "    # calculer les poids d'attention via softmax\n",
        "    attention_weights = jax.nn.softmax(scaled_logits, axis=-1)\n",
        "\n",
        "    # faire la somme avec les valeurs pour obtenir la sortie\n",
        "    output = jnp.matmul(attention_weights, value)\n",
        "\n",
        "    return output, attention_weights"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OWDubQwCs4zG"
      },
      "source": [
        "##### **Attention multi-têtes**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nHkyjyErsYae"
      },
      "source": [
        "Le mécanisme d'attention que nous avons couvert jusqu'à présent permet au modèle de se concentrer sur différentes positions dans l'entrée. En pratique, l'architecture du transformeur utilise une variation subtile de ce mécanisme, appelée attention multi-têtes (MHA).\n",
        "\n",
        "La distinction est minime ; plutôt que de calculer l'attention une seule fois, le mécanisme MHA exécute l'attention par produit scalaire avec échelle plusieurs fois en parallèle. Selon l'article *Attention is All You Need*, \"l'attention multi-têtes permet au modèle de **prêter attention conjointement** aux informations provenant de différents sous-espaces de représentation à différentes positions. Avec une seule tête d'attention, la moyenne inhibe cela.\"\n",
        "\n",
        "L'attention multi-têtes peut être vue comme une stratégie similaire à l'empilement de noyaux de convolution dans une couche CNN. Cela permet aux noyaux de se concentrer sur et d'apprendre différentes caractéristiques et règles, ce qui explique pourquoi plusieurs têtes d'attention fonctionnent également.\n",
        "\n",
        "La figure ci-dessous montre comment fonctionne l'attention multi-têtes de base. L'attention par produit scalaire avec échelle discutée précédemment est simplement répétée $N$ fois ($N=2$ dans cette figure), avec $3N$ matrices apprenables pour chaque tête. Les sorties des différentes têtes sont ensuite concaténées, après quoi elles sont passées à travers une projection linéaire, qui produit la représentation finale.\n",
        "\n",
        "En pratique, l'attention multi-têtes surpasse largement l'attention à une seule tête.\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1q0Oq6IVEkkMfVSpY4LkHBP866mcoIFsh\" alt=\"drawing\" width=\"1000\"/>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vtuqNCln9EWW"
      },
      "source": [
        "Voyons comment implémenter l'attention multi-têtes. En termes simples, l'attention multi-têtes consiste à exécuter le processus d'attention plusieurs fois en parallèle, en utilisant différentes copies des matrices Q, K et V pour chaque \"tête\". Cela aide le modèle à se concentrer sur différentes parties de l'entrée en même temps. Si vous souhaitez en savoir plus, consultez [ce blog de Sebastian Raschka](https://magazine.sebastianraschka.com/p/understanding-and-coding-self-attention) pour une explication détaillée.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "BY2xXLMQ9CB6"
      },
      "outputs": [],
      "source": [
        "class MultiHeadAttention(nn.Module):\n",
        "    num_heads: int  # Nombre de têtes d'attention\n",
        "    d_m: int  # Dimension des embeddings du modèle\n",
        "\n",
        "    def setup(self):\n",
        "        # Initialiser le module de transformation de la séquence en QKV (requête, clé, valeur)\n",
        "        self.sequence_to_qkv = SequenceToQKV(self.d_m)\n",
        "\n",
        "        # Définir l'initialiseur pour les poids de la couche linéaire de sortie\n",
        "        initializer = nn.initializers.variance_scaling(\n",
        "            scale=0.5, mode=\"fan_in\", distribution=\"truncated_normal\"\n",
        "        )\n",
        "\n",
        "        # Initialiser la couche de projection de sortie Wo (utilisée après l'attention)\n",
        "        self.Wo = nn.Dense(self.d_m, kernel_init=initializer)\n",
        "\n",
        "    def __call__(self, X=None, Q=None, K=None, V=None, mask=None, return_weights=False):\n",
        "        # Si Q, K ou V ne sont pas fournis, utiliser l'entrée X pour les générer\n",
        "        if None in [Q, K, V]:\n",
        "            assert not X is None, \"X doit être fourni si Q, K ou V ne sont pas fournis\"\n",
        "\n",
        "            # Générer les matrices Q, K et V à partir de l'entrée X\n",
        "            Q, K, V = self.sequence_to_qkv(X)\n",
        "\n",
        "        # Extraire la taille du lot (B), la longueur de la séquence (T) et la taille de l'embedding (d_m)\n",
        "        B, T, d_m = K.shape\n",
        "\n",
        "        # Calculer la taille de l'embedding de chaque tête d'attention (d_m / num_heads)\n",
        "        head_size = d_m // self.num_heads\n",
        "\n",
        "        # Reshaper Q, K, V pour avoir des dimensions séparées pour les têtes\n",
        "        # B, T, d_m -> B, T, num_heads, head_size -> B, num_heads, T, head_size\n",
        "        q_heads = Q.reshape(B, T, self.num_heads, head_size).swapaxes(1, 2)\n",
        "        k_heads = K.reshape(B, T, self.num_heads, head_size).swapaxes(1, 2)\n",
        "        v_heads = V.reshape(B, T, self.num_heads, head_size).swapaxes(1, 2)\n",
        "\n",
        "        # Appliquer l'attention à produit scalaire échelonné à chaque tête\n",
        "        attention, attention_weights = scaled_dot_product_attention(\n",
        "            q_heads, k_heads, v_heads, mask\n",
        "        )\n",
        "\n",
        "        # Reshaper la sortie de l'attention à ses dimensions originales\n",
        "        # (B, num_heads, T, head_size) -> (B, T, num_heads, head_size) -> (B, T, d_m)\n",
        "        attention = attention.swapaxes(1, 2).reshape(B, T, d_m)\n",
        "\n",
        "        # Appliquer la transformation linéaire de sortie Wo à la sortie de l'attention\n",
        "        X_new = self.Wo(attention)\n",
        "\n",
        "        # Si return_weights est True, retourner à la fois la sortie transformée et les poids d'attention\n",
        "        if return_weights:\n",
        "            return X_new, attention_weights\n",
        "        else:\n",
        "            # Sinon, retourner uniquement la sortie transformée\n",
        "            return X_new\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e9NW58_3hAg2"
      },
      "source": [
        "## **2. Construire votre propre LLM**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bA_2coZvhAg3"
      },
      "source": [
        "### 2.1 Vue d'ensemble générale <font color='orange'>Débutant</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BflycqAw_RF8"
      },
      "source": [
        "L'architecture du Transformeur a été présentée pour la première fois dans l'article intitulé [Attention is all you need](https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf) par Vaswani et al.\n",
        "\n",
        "Comme le titre de l'article le suggère, une telle architecture consiste essentiellement uniquement en des mécanismes d'attention ainsi que des couches de feed-forward et des couches linéaires, comme le montre le schéma ci-dessous.\n",
        "\n",
        "<img src=\"https://machinelearningmastery.com/wp-content/uploads/2021/08/attention_research_1.png\" width=\"350\" />\n",
        "\n",
        "Les Transformeurs et leurs variantes sont au cœur des Modèles de Langage de Grande Taille, et il n'est pas exagéré de dire que presque tous les modèles de langage existants sont basés sur des architectures de Transformeurs.\n",
        "\n",
        "Comme vous pouvez le voir dans le schéma, l'architecture originale du Transformeur se compose de deux parties, l'une qui reçoit les entrées, généralement appelée encodeur, et l'autre qui reçoit les sorties (c'est-à-dire les cibles), appelée décodeur. Cela est dû au fait que le transformeur a été conçu pour la traduction automatique.\n",
        "\n",
        "L'encodeur reçoit une phrase d'entrée dans une langue et la traite à travers plusieurs `blocs d'encodeur` empilés. Cela crée une représentation finale, qui contient des informations utiles nécessaires pour la tâche de décodage. Cette sortie est ensuite alimentée dans des `blocs de décodeur` empilés qui produisent de nouvelles sorties de manière autoregressive.\n",
        "\n",
        "L'encodeur se compose de $N$ blocs identiques, qui traitent une séquence de vecteurs de tokens séquentiellement. Ces blocs se composent de 3 parties :\n",
        "\n",
        "1. Un bloc d'attention multi-têtes. Ce sont la colonne vertébrale de l'architecture du transformeur. Ils traitent les données pour générer des représentations pour chaque token, en s'assurant que les informations nécessaires pour la tâche à accomplir sont représentées dans les vecteurs. Ce sont exactement les MHA que nous avons couverts dans la section sur l'attention précédemment.\n",
        "2. Un MLP (Perceptron Multi-Couches, c'est-à-dire un réseau neuronal avec plusieurs couches) est appliqué à chaque token d'entrée séparément et de manière identique.\n",
        "3. Une connexion résiduelle qui ajoute les tokens d'entrée aux représentations attentives et une connexion résiduelle entre l'entrée du MLP et ses sorties. Pour ces deux connexions, le résultat est normalisé à l'aide de layernorm. Dans certaines implémentations, ces étapes de normalisation sont appliquées aux entrées plutôt qu'aux sorties. Tout comme un Resnet, les transformeurs sont conçus pour être des modèles très profonds, donc ces blocs add and norm sont essentiels pour un flux de gradient fluide.\n",
        "\n",
        "De même, le bloc décodeur se compose de $N$ blocs identiques, cependant, il y a quelques variations au sein de ces blocs. Concrètement, les différentes parties sont :\n",
        "\n",
        "1. Un bloc d'attention multi-têtes masqué. Il s'agit d'un bloc MHA qui effectue l'_auto-attention_ sur la séquence de sortie, mais ce calcul est restreint aux entrées déjà vues. En d'autres termes, les tokens futurs sont bloqués lors des prédictions.\n",
        "2. Un bloc d'attention multi-têtes. Ce bloc reçoit la sortie du dernier bloc encodeur, les tokens transformés, et l'utilise comme paires clé-valeur, tout en utilisant la sortie du premier bloc MHA comme requête. Ce faisant, le modèle porte son attention sur l'entrée requise pour effectuer la tâche de séquence. Ce bloc MHA effectue donc une _cross-attention_ en regardant les entrées de l'encodeur.\n",
        "3. Un MLP identique à celui de l'encodeur\n",
        "4. Une connexion résiduelle identique à celle de l'encodeur.\n",
        "\n",
        "À partir de cette architecture originale, plusieurs variations ont été proposées, certaines se concentrant uniquement sur l'encodeur et d'autres uniquement sur le **décodeur**. Les grands modèles de langage (LLMs) tels que GPT-2, GPT-3 et Turing-NLG sont issus d'architectures uniquement décodeur. Ces architectures ressemblent à ceci :\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1MubUcshJTHCqOPTRHixLhrYYLXX9vP_h\" alt=\"drawing\" width=\"260\"/>\n",
        "\n",
        "avec le bloc de cross-attention manquant car aucune sortie de l'encodeur n'est disponible. Pour construire un modèle de langage, nous nous concentrerons donc sur l'architecture uniquement décodeur comme celle illustrée ci-dessus.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fbTsk0MdhAhC"
      },
      "source": [
        "### 2.2 Tokenisation + Encodage positionnel <font color='orange'>Débutant</font>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DehUpfym_RF8"
      },
      "source": [
        "#### 2.2.1 Tokenisation\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uBiFpVBu_RF9"
      },
      "source": [
        "Les transformeurs ne peuvent pas traiter des chaînes de texte brutes. Pour traiter le texte, celui-ci est d'abord divisé en tokens. Les tokens sont ensuite indexés, et chaque token se voit attribuer un embedding de taille $d_{model}$. Ces embeddings peuvent être appris pendant l'entraînement ou provenir d'un vocabulaire d'embeddings préentraînés. Cette nouvelle séquence d'embeddings de tokens est ensuite transmise à l'architecture du transformeur. Cette idée est visualisée ci-dessous.\n",
        "\n",
        "\\\\\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=16euh4LADP_mcXywFwKKY3QQQkVplepiI\" alt=\"drawing\" width=\"450\"/>\n",
        "\n",
        "Ces identifiants de tokens sont généralement prédits lorsqu'un modèle génère du texte, complète des mots manquants, etc.\n",
        "\n",
        "Ce processus de division du texte en tokens et d'attribution d'un identifiant à chaque token est appelé [tokenisation](https://huggingface.co/docs/transformers/tokenizer_summary). Il existe plusieurs façons de tokeniser le texte, certaines méthodes étant directement entraînées à partir des données. Lors de l'utilisation de transformeurs pré-entraînés, il est crucial d'utiliser le même tokeniseur que celui utilisé pour entraîner le modèle. Le lien précédent propose des descriptions approfondies de nombreuses techniques largement connues.\n",
        "\n",
        "Ci-dessous, nous montrons comment le tokeniseur du modèle [BERT](https://arxiv.org/abs/1810.04805) tokenise une phrase. Nous utilisons [Hugging Face](https://huggingface.co/) pour cette partie.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hJBMvlUA_RF9"
      },
      "outputs": [],
      "source": [
        "import transformers\n",
        "from transformers import pipeline, AutoTokenizer, AutoModel\n",
        "\n",
        "bert_tokenizer = AutoTokenizer.from_pretrained(\"bert-base-cased\")\n",
        "encoded_input = bert_tokenizer(\"La pratique est tellement amusante\")\n",
        "print(f\"IDs des tokens : {encoded_input['input_ids']}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GYbtZTVP_RF9"
      },
      "source": [
        "Ici, nous pouvons voir que le tokeniseur retourne les IDs pour chaque token, comme illustré dans la figure. Mais en comptant le nombre d'IDs, nous constatons qu'il est plus grand que le nombre de mots dans la phrase. Imprimons les tokens associés à chaque ID.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "yPZjiLis_RF9"
      },
      "outputs": [],
      "source": [
        "print(f\"Tokens: {bert_tokenizer.decode(encoded_input['input_ids'])}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k3K8UFlR_RF9"
      },
      "source": [
        "Nous pouvons voir que le tokeniseur ajoute de nouveaux tokens, `[CLS]` et `[SEP]`, au début et à la fin de la séquence. Il s'agit d'une exigence spécifique à BERT pour l'entraînement et l'inférence. Ajouter des tokens spéciaux est une pratique très courante. Grâce à ces tokens spéciaux, nous pouvons indiquer à un modèle quand une phrase commence ou se termine, ou quand une nouvelle partie de l'entrée commence. Cela peut être utile pour réaliser différentes tâches.\n",
        "\n",
        "Par exemple, pour préentraîner certains transformeurs spécifiques, ils effectuent ce que l'on appelle une prédiction masquée. Pour cela, des tokens aléatoires dans une séquence sont remplacés par le token `[MASK]`, et le modèle est entraîné à prédire l'ID correct du token remplacé par ce token.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "djMP4Ijz_RF9"
      },
      "source": [
        "**Inconvénient de l'utilisation des tokens bruts** :\n",
        "\n",
        "Un inconvénient de l'utilisation des tokens bruts est qu'ils ne fournissent aucune indication sur la position du mot dans la séquence. Cela est évident lorsqu'on considère des phrases comme \"Je suis heureux\" et \"Suis-je heureux\" - ces deux phrases ont des significations distinctes, et le modèle doit saisir l'ordre des mots pour comprendre le message voulu de manière précise.\n",
        "\n",
        "Pour remédier à cela, lors de la conversion des entrées en vecteurs, des vecteurs de position sont introduits et ajoutés à ces vecteurs pour indiquer la **position** de chaque mot.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "639s7Zuk_RF9"
      },
      "source": [
        "#### 2.2.2 Encodages positionnels\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-hBFVYo_RF9"
      },
      "source": [
        "Dans la plupart des domaines où un transformeur peut être utilisé, il existe un ordre sous-jacent aux tokens produits, qu'il s'agisse de l'ordre des mots dans une phrase, de l'emplacement à partir duquel des patches sont pris dans une image ou même des étapes effectuées dans un environnement de RL. Cet ordre est très important dans tous les cas ; imaginez simplement que vous interprétez la phrase \"Je dois lire ce livre.\" comme \"J'ai ce livre à lire.\". Les deux phrases contiennent exactement les mêmes mots, mais elles ont des significations complètement différentes en fonction de l'ordre.\n",
        "\n",
        "Étant donné que les blocs d'encodeur et de décodeur traitent tous les tokens en parallèle, l'ordre des tokens est perdu dans ces calculs. Pour remédier à cela, l'ordre de la séquence doit être directement injecté dans les tokens. Cela peut être fait en ajoutant des *encodages positionnels* aux tokens au début des blocs d'encodeur et de décodeur (bien que certaines des techniques les plus récentes ajoutent des informations positionnelles dans les blocs d'attention). Un exemple de la façon dont les encodages positionnels modifient les tokens est montré ci-dessous.\n",
        "\n",
        "\\\\\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1eSgnVN2hnEsrjdHygDGwk1kxEi8-dcFo\" alt=\"drawing\" width=\"650\"/>\n",
        "\n",
        "Idéalement, ces encodages devraient avoir les caractéristiques suivantes ([source](https://kazemnejad.com/blog/transformer_architecture_positional_encoding/)) :\n",
        "* Chaque étape temporelle devrait avoir une valeur unique.\n",
        "* La distance entre les étapes temporelles doit rester constante.\n",
        "* L'encodage devrait pouvoir se généraliser à des séquences plus longues que celles vues pendant l'entraînement.\n",
        "* L'encodage doit être déterministe.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rklY-aL-_RF9"
      },
      "source": [
        "##### **Fonctions sinus et cosinus**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GLcfkMku_RF9"
      },
      "source": [
        "Dans *Attention is All you Need*, les auteurs ont utilisé une méthode qui peut satisfaire toutes ces exigences. Cela implique de sommer une combinaison d'ondes sinusoïdales et cosinusoïdales à différentes fréquences, avec la formule pour un encodage positionnel à la position $D$ montrée ci-dessous, où $i$ est l'indice de l'embedding et $d_m$ est la taille de l'embedding du token.\n",
        "\n",
        "\\\\\n",
        "\n",
        "$P_{D}= \\begin{cases}\\sin \\left(\\frac{D}{10000^{i/d_{m}}}\\right), & \\text { si } i \\bmod 2=0 \\\\ \\cos \\left(\\frac{D}{10000^{((i-1)/d_{m}}}\\right), & \\text { sinon } \\end{cases}$\n",
        "\n",
        "\\\n",
        "\n",
        "En supposant que notre modèle ait $d_m=8$, l'embedding positionnel ressemblera à ceci :\n",
        "\n",
        "\\\n",
        "$P_{D}=\\left[\\begin{array}{c}\\sin \\left(\\frac{D}{10000^{0/8}}\\right)\\\\ \\cos \\left(\\frac{D}{10000^{0/8}}\\right)\\\\ \\sin \\left(\\frac{D}{10000^{2/8}}\\right)\\\\ \\cos \\left(\\frac{D}{10000^{2/8}}\\right)\\\\ \\sin \\left(\\frac{D}{10000^{4/8}}\\right)\\\\ \\cos \\left(\\frac{D}{10000^{4/8}}\\right)\\\\ \\sin \\left(\\frac{D}{10000^{8/8}}\\right)\\\\ \\cos \\left(\\frac{D}{10000^{8/8}}\\right)\\end{array}\\right]$\n",
        "\n",
        "\\\\\n",
        "\n",
        "Commençons par créer une fonction capable de retourner ces encodages pour comprendre pourquoi cela fonctionne.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zT5t5D30_RF9"
      },
      "outputs": [],
      "source": [
        "def return_frequency_pe_matrix(longueur_sequence_tokens, taille_embedding_tokens):\n",
        "\n",
        "    assert taille_embedding_tokens % 2 == 0, \"la taille de l'embedding des tokens doit être divisible par deux\"\n",
        "\n",
        "    P = jnp.zeros((longueur_sequence_tokens, taille_embedding_tokens))\n",
        "    positions = jnp.arange(0, longueur_sequence_tokens)[:, jnp.newaxis]\n",
        "\n",
        "    i = jnp.arange(0, taille_embedding_tokens, 2)\n",
        "    pas_frequence = jnp.exp(i * (-math.log(10000.0) / taille_embedding_tokens))\n",
        "    frequences = positions * pas_frequence\n",
        "\n",
        "    P = P.at[:, 0::2].set(jnp.sin(frequences))\n",
        "    P = P.at[:, 1::2].set(jnp.cos(frequences))\n",
        "\n",
        "    return P\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "CYW-VDOL_RF-"
      },
      "outputs": [],
      "source": [
        "longueur_sequence_tokens = 50  # Nombre de tokens que le modèle devra traiter\n",
        "dimension_embedding_tokens = 10000  # Dimensions des embeddings des tokens (et de l'encodage positionnel), s'assurer qu'il est divisible par deux\n",
        "P = return_frequency_pe_matrix(longueur_sequence_tokens, dimension_embedding_tokens)\n",
        "plot_position_encodings(P, longueur_sequence_tokens, dimension_embedding_tokens)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1mjHEDPO_RF-"
      },
      "source": [
        "En regardant le graphique ci-dessus, nous pouvons voir que pour chaque indice de position, il y a un motif unique qui se forme, où chaque indice de position aura toujours le même encodage.\n",
        "\n",
        "**Tâche de groupe** :\n",
        "\n",
        "- Discutez avec votre ami pourquoi nous voyons ce motif spécifique lorsque `longueur_sequence_tokens` est 1000, et `dimension_embedding_tokens` est 768.\n",
        "- Vous pouvez essayer de jouer avec des valeurs plus petites pour `longueur_sequence_tokens` et `dimension_embedding_tokens` pour obtenir une meilleure intuition pour la discussion ci-dessus.\n",
        "- Demandez à votre ami pourquoi ils pensent que la constante 10000 est utilisée dans les fonctions ci-dessus.\n",
        "- Réglez `longueur_sequence_tokens` sur 50 et `dimension_embedding_tokens` sur quelque chose de grand, comme 10000. Que remarquez-vous ? Un grand embedding de token est-il toujours nécessaire ?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SdNPg0pnhAhG"
      },
      "source": [
        "### 2.3 Bloc Transformer   <font color='green'>Intermédiaire</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M4vSolF2_RF-"
      },
      "source": [
        "Tout comme un MLP (un réseau de neurones simple qui traite les données d'entrée à travers plusieurs couches) ou un CNN (un type de réseau de neurones qui excelle dans la reconnaissance de motifs dans les images en utilisant des couches de convolution), les transformers sont constitués d'une pile de blocs transformer. Dans cette section, nous allons construire chacun des composants nécessaires pour créer un de ces blocs transformer.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kTURbfr__RF-"
      },
      "source": [
        "#### 2.3.1 Réseau de neurones Feed Forward (FFN) / Perceptron multicouche (MLP) <font color='orange'>Débutant</font>\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1H1pVFxJiSpM_Ozj1eKWNdcFQ5Hn5XsZz\" alt=\"drawing\" width=\"260\"/>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LTtFi9AZ_RF-"
      },
      "source": [
        "Ces blocs sont simplement un MLP (perceptron multicouche) à 2 couches qui utilise la fonction d'activation ReLU dans le modèle original. La fonction GeLU est également devenue très populaire, et nous l'utiliserons tout au long de la pratique. La formule ci-dessous représente le réseau de neurones feedforward (FFN) avec activation GeLU, où l'entrée `x` est transformée à travers deux couches linéaires avec des poids `W1` et `W2`, suivis de termes de biais `b1` et `b2`, et la fonction `max` représente la fonction d'activation ReLU.\n",
        "\n",
        "$$\n",
        "\\operatorname{FFN}(x)=\\max \\left(0, x W_{1}+b_{1}\\right) W_{2}+b_{2}\n",
        "$$\n",
        "\n",
        "On peut interpréter ce bloc comme traitant ce que le bloc MHA a produit, puis projetant ces nouvelles représentations de tokens dans un espace que le bloc suivant peut utiliser de manière plus optimale. En général, la première couche est très large, dans la gamme de 2 à 8 fois la taille des représentations de tokens. Ils le font car il est plus facile de paralléliser les calculs pour une seule couche plus large pendant l'entraînement que de paralléliser un bloc feedforward avec plusieurs couches. Ainsi, ils peuvent ajouter plus de complexité tout en gardant l'entraînement et l'inférence optimisés.\n",
        "\n",
        "**Tâche de code :** Codez un module Flax qui implémente le bloc feedforward.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zsho1CnW_RF-"
      },
      "outputs": [],
      "source": [
        "class FeedForwardBlock(nn.Module):\n",
        "  \"\"\"\n",
        "  Un MLP à 2 couches qui élargit puis rétrécit l'entrée.\n",
        "\n",
        "  Args:\n",
        "    widening_factor [optionnel, par défaut=4] : La taille de la couche cachée sera d_model * widening_factor.\n",
        "  \"\"\"\n",
        "\n",
        "  widening_factor: int = 4\n",
        "  init_scale: float = 0.25\n",
        "\n",
        "  @nn.compact\n",
        "  def __call__(self, x):\n",
        "    '''\n",
        "    Args:\n",
        "      x: [B, T, d_m]\n",
        "\n",
        "    Return:\n",
        "      x: [B, T, d_m]\n",
        "    '''\n",
        "    d_m = x.shape[-1]\n",
        "    layer1_size = self.widening_factor * d_m\n",
        "\n",
        "    initializer = nn.initializers.variance_scaling(\n",
        "        scale=self.init_scale, mode='fan_in', distribution='truncated_normal',\n",
        "    )\n",
        "    layer1 = ... # TERMINER\n",
        "    layer2 = ... # TERMINER\n",
        "\n",
        "    x = jax.nn.gelu(layer1(x))\n",
        "    x = layer2(x)\n",
        "    return x\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-qj0nfhH_RF-"
      },
      "outputs": [],
      "source": [
        "# @title Réponse à la tâche de code (Essayez de ne pas regarder avant d'avoir bien réfléchi !)\n",
        "\n",
        "class FeedForwardBlock(nn.Module):\n",
        "  \"\"\"\n",
        "  Un MLP à 2 couches qui élargit puis réduit l'entrée.\n",
        "\n",
        "  Args:\n",
        "    widening_factor [optionnel, par défaut=4] : La taille de la couche cachée sera d_model * widening_factor.\n",
        "  \"\"\"\n",
        "\n",
        "  widening_factor: int = 4\n",
        "  init_scale: float = 0.25\n",
        "\n",
        "  @nn.compact\n",
        "  def __call__(self, x):\n",
        "    '''\n",
        "    Args:\n",
        "      x: [B, T, d_m]\n",
        "\n",
        "    Retour:\n",
        "      x: [B, T, d_m]\n",
        "    '''\n",
        "    d_m = x.shape[-1]\n",
        "    layer1_size = self.widening_factor * d_m\n",
        "\n",
        "    initializer = nn.initializers.variance_scaling(\n",
        "        scale=self.init_scale, mode='fan_in', distribution='truncated_normal',\n",
        "    )\n",
        "\n",
        "    # Indice : La couche 1 est une couche dense (couche entièrement connectée) qui augmente la taille de l'entrée\n",
        "    # par le facteur d'élargissement. Utilisez nn.Dense pour créer cette couche avec layer1_size comme taille de sortie.\n",
        "    layer1 = ... # FINISH ME\n",
        "\n",
        "    # Indice : La couche 2 est une autre couche dense qui réduit la taille pour revenir à la dimension d'origine d_m.\n",
        "    # Utilisez nn.Dense avec d_m comme taille de sortie pour créer cette couche.\n",
        "    layer2 = ...# FINISH ME\n",
        "\n",
        "    x = jax.nn.gelu(layer1(x))  # Appliquez la fonction d'activation GeLU à la sortie de la couche 1\n",
        "    x = layer2(x)  # Passez le résultat à travers la couche 2\n",
        "    return x\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9ZijQtEMyHxj"
      },
      "outputs": [],
      "source": [
        "# @title Réponse à la tâche de codage (Essayez de ne pas regarder avant d'avoir bien essayé !')\n",
        "\n",
        "class FeedForwardBlock(nn.Module):\n",
        "    \"\"\"Un MLP (Multi-Layer Perceptron) à 2 couches qui commence par élargir la taille de l'entrée, puis la réduit à nouveau.\"\"\"\n",
        "\n",
        "    # widening_factor contrôle l'expansion de la dimension de l'entrée dans la première couche.\n",
        "    widening_factor: int = 4\n",
        "\n",
        "    # init_scale contrôle le facteur d'échelle pour l'initialisation des poids.\n",
        "    init_scale: float = 0.25\n",
        "\n",
        "    @nn.compact\n",
        "    def __call__(self, x):\n",
        "      # Obtenir la taille de la dernière dimension de l'entrée (taille de l'embedding).\n",
        "      d_m = x.shape[-1]\n",
        "\n",
        "      # Calculer la taille de la première couche en multipliant la taille de l'embedding par le facteur d'élargissement.\n",
        "      layer1_size = self.widening_factor * d_m\n",
        "\n",
        "      # Initialiser les poids des deux couches en utilisant un initialiseur basé sur la variance.\n",
        "      initializer = nn.initializers.variance_scaling(\n",
        "          scale=self.init_scale, mode='fan_in', distribution='truncated_normal',\n",
        "      )\n",
        "\n",
        "      # Définir la première couche dense, qui élargit la taille de l'entrée.\n",
        "      layer1 = nn.Dense(layer1_size, kernel_init=initializer)\n",
        "\n",
        "      # Définir la deuxième couche dense, qui réduit la taille pour revenir à la dimension d'origine.\n",
        "      layer2 = nn.Dense(d_m, kernel_init=initializer)\n",
        "\n",
        "      # Appliquer la première couche dense suivie d'une fonction d'activation GELU.\n",
        "      x = jax.nn.gelu(layer1(x))\n",
        "\n",
        "      # Appliquer la deuxième couche dense pour ramener les données à leur dimension d'origine.\n",
        "      x = layer2(x)\n",
        "\n",
        "      # Retourner la sortie finale.\n",
        "      return x\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TWUpf8wt_RF-"
      },
      "source": [
        "#### 2.3.2 Bloc Ajouter et Normaliser <font color='orange'>Débutant</font>\n",
        "\n",
        "Pour permettre aux transformateurs de devenir plus profonds, les connexions résiduelles sont très importantes pour permettre un meilleur flux des gradients à travers le réseau. Pour la normalisation, `layer norm` est utilisé. Cette normalisation est appliquée indépendamment à chaque vecteur de token dans le lot. Il est constaté que la normalisation des vecteurs améliore la convergence et la stabilité des transformateurs.\n",
        "\n",
        "Il y a deux paramètres apprenables dans la normalisation par couche (`layer norm`), `scale` et `bias`, qui redimensionnent la valeur normalisée. Ainsi, pour chaque token d'entrée dans un lot, nous calculons la moyenne, $\\mu_{i}$ et la variance $\\sigma_i^2$. Nous normalisons ensuite le token avec :\n",
        "\n",
        "$$\n",
        "\\hat{x}_i = \\frac{x_i - \\mu_{i}}{\\sigma_i^2 + ϵ}\n",
        "$$\n",
        "\n",
        "Puis $\\hat{x}$ est redimensionné en utilisant le `scale` appris, $γ$, et le `bias` $β$, avec :\n",
        "\n",
        "$$\n",
        "y_i = γ\\hat{x}_i + β = LN_{γ,β}(x_i)\n",
        "$$\n",
        "\n",
        "Ainsi, notre bloc ajouter et normaliser peut être représenté par $LN(x+f(x))$, où $f(x)$ est soit un bloc MLP soit MHA.\n",
        "\n",
        "**Tâche de code :** Implémentez un module Flax qui réalise le bloc ajouter et normaliser. Il doit prendre en entrée les tokens traités et non traités. Indice : `hk.LayerNorm`\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "F5bLb5Ly_RF_"
      },
      "outputs": [],
      "source": [
        "class AddNorm(nn.Module):\n",
        "  \"\"\"Un bloc qui implémente le bloc d'addition et de normalisation\"\"\"\n",
        "\n",
        "  @nn.compact\n",
        "  def __call__(self, x, processed_x):\n",
        "    '''\n",
        "    Args:\n",
        "      x: Séquence de tokens avant d'être envoyée dans les blocs MHA ou FF, avec une forme [B, T, d_m]\n",
        "      processed_x: Séquence après avoir été traitée par les blocs MHA ou FF, avec une forme [B, T, d_m]\n",
        "\n",
        "    Retour:\n",
        "      add_norm_x: Tokens transformés avec une forme [B, T, d_m]\n",
        "    '''\n",
        "    # Indice : La première étape consiste à ajouter l'entrée originale `x` à l'entrée traitée `processed_x`.\n",
        "    added = ... # FINISH ME\n",
        "\n",
        "    # Indice : La deuxième étape nécessite l'application d'une normalisation par couche au résultat de l'addition.\n",
        "    # Utilisez `nn.LayerNorm` et définissez `reduction_axes=-1` pour appliquer la normalisation sur la dernière dimension.\n",
        "    normalised = ... #FINISH ME\n",
        "    return normalised(added)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3nsWUQnlyWIs"
      },
      "outputs": [],
      "source": [
        "# @title Réponse à la tâche de codage (Essayez de ne pas regarder avant d'avoir bien essayé !')\n",
        "\n",
        "class AddNorm(nn.Module):\n",
        "    \"\"\"Un bloc qui implémente l'opération 'Add and Norm' utilisée dans les transformers.\"\"\"\n",
        "\n",
        "    @nn.compact\n",
        "    def __call__(self, x, processed_x):\n",
        "      # Étape 1 : Ajouter l'entrée originale (x) à l'entrée traitée (processed_x).\n",
        "      added = x + processed_x\n",
        "\n",
        "      # Étape 2 : Appliquer une normalisation par couche au résultat de l'addition.\n",
        "      # - LayerNorm aide à stabiliser et améliorer le processus d'entraînement en normalisant la sortie.\n",
        "      # - reduction_axes=-1 indique que la normalisation est appliquée sur la dernière dimension (généralement la dimension de l'embedding).\n",
        "      # - use_scale=True et use_bias=True permettent à la couche d'apprendre des paramètres d'échelle et de biais pour un ajustement plus précis.\n",
        "      normalised = nn.LayerNorm(reduction_axes=-1, use_scale=True, use_bias=True)\n",
        "\n",
        "      # Retourner le résultat normalisé.\n",
        "      return normalised(added)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "91dXd29b_RF_"
      },
      "source": [
        "### 2.4 Construction du Décodeur Transformer / LLM <font color='green'>Intermédiaire</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sl0UAyvM_RF_"
      },
      "source": [
        "<img src=\"https://drive.google.com/uc?export=view&id=1MubUcshJTHCqOPTRHixLhrYYLXX9vP_h\" alt=\"drawing\" width=\"260\"/>\n",
        "\n",
        "La plupart des éléments de base ont été réalisés. Nous avons construit le bloc d'encodage positionnel, le bloc MHA, le bloc feed-forward et le bloc add&norm.\n",
        "\n",
        "La seule partie nécessaire est de passer les entrées à chaque bloc décodeur et d'appliquer le bloc MHA masqué trouvé dans les blocs décodeurs.\n",
        "\n",
        "**Tâche de code :** Codez un module FLAX qui implémente le (FFN(norm(MHA(norm(X))))) pour le bloc décodeur\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wVmSFKZK_RF_"
      },
      "outputs": [],
      "source": [
        "class DecoderBlock(nn.Module):\n",
        "  \"\"\"\n",
        "  Bloc décodeur du Transformer.\n",
        "\n",
        "  Args:\n",
        "    num_heads: Le nombre de têtes à utiliser dans le bloc MHA.\n",
        "    d_m: Taille de l'embedding des tokens\n",
        "    widening_factor: La taille de la couche cachée sera d_m * widening_factor.\n",
        "  \"\"\"\n",
        "\n",
        "  num_heads: int\n",
        "  d_m: int\n",
        "  widening_factor: int = 4\n",
        "\n",
        "  def setup(self):\n",
        "    self.mha = MultiHeadAttention(self.num_heads, self.d_m)\n",
        "    self.add_norm1 = AddNorm()\n",
        "    self.add_norm2 = AddNorm()\n",
        "    self.MLP = FeedForwardBlock(widening_factor=self.widening_factor)\n",
        "\n",
        "  def __call__(self, X, mask=None, return_att_weight=True):\n",
        "    \"\"\"\n",
        "    Args:\n",
        "      X: Lot de tokens étant passés dans le décodeur, avec une forme [B, T_decoder, d_m]\n",
        "      encoder_output: Lot de tokens traités par l'encodeur, avec une forme [B, T_encoder, d_m]\n",
        "      mask [optionnel, par défaut=None]: Masque à appliquer, avec une forme [T_decoder, T_decoder].\n",
        "      return_att_weight [optionnel, par défaut=True]: Indique si les poids d'attention doivent être retournés.\n",
        "    \"\"\"\n",
        "\n",
        "    attention, attention_weights_1 = ... # FINISH ME\n",
        "\n",
        "    X = ... # FINISH ME\n",
        "\n",
        "    projection = ... # FINISH ME\n",
        "    X = ... # FINISH ME\n",
        "\n",
        "    return (X, attention_weights_1) if return_att_weight else X\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "stNZVVv3_RF_"
      },
      "outputs": [],
      "source": [
        "#@title Réponse à la tâche de codage (Essayez de ne pas regarder avant d'avoir bien essayé !')\n",
        "\n",
        "class DecoderBlock(nn.Module):\n",
        "    \"\"\"\n",
        "    Bloc décodeur du Transformer.\n",
        "\n",
        "    Args:\n",
        "        num_heads: Le nombre de têtes d'attention dans le bloc Multi-Head\n",
        "        Attention (MHA).\n",
        "        d_m: La taille des embeddings des tokens.\n",
        "        widening_factor: Le facteur par lequel la taille de la couche cachée\n",
        "        est augmentée dans le MLP.\n",
        "    \"\"\"\n",
        "\n",
        "    num_heads: int\n",
        "    d_m: int\n",
        "    widening_factor: int = 4\n",
        "\n",
        "    def setup(self):\n",
        "      # Initialiser le bloc Multi-Head Attention (MHA)\n",
        "      self.mha = MultiHeadAttention(self.num_heads, self.d_m)\n",
        "\n",
        "      # Initialiser les blocs AddNorm pour les connexions résiduelles\n",
        "      # et la normalisation\n",
        "      self.add_norm1 = AddNorm()  # Premier bloc AddNorm après MHA\n",
        "      self.add_norm2 = AddNorm()  # Deuxième bloc AddNorm après le MLP\n",
        "\n",
        "      # Initialiser le FeedForwardBlock (MLP) qui traite les données\n",
        "      # après l'attention\n",
        "      self.MLP = FeedForwardBlock(widening_factor=self.widening_factor)\n",
        "\n",
        "    def __call__(self, X, mask=None, return_att_weight=True):\n",
        "      \"\"\"\n",
        "      Passage en avant à travers le DecoderBlock.\n",
        "\n",
        "      Args:\n",
        "          X: Lot de tokens d'entrée envoyés dans le décodeur,\n",
        "          forme [B, T_decoder, d_m]\n",
        "          mask [optionnel, par défaut=None]: Masque pour contrôler les positions\n",
        "          que l'attention est autorisée à considérer,\n",
        "          forme [T_decoder, T_decoder].\n",
        "          return_att_weight [optionnel, par défaut=True]: Si True,\n",
        "          retourne les poids d'attention avec la sortie.\n",
        "\n",
        "      Returns:\n",
        "          Si return_att_weight est True, retourne un tuple (X,\n",
        "          attention_weights_1).\n",
        "          Sinon, retourne les représentations des tokens traités X.\n",
        "      \"\"\"\n",
        "      # Appliquer l'attention multi-tête aux tokens d'entrée (X)\n",
        "      # avec un masquage optionnel\n",
        "      attention, attention_weights_1 = self.mha(X, mask=mask, return_weights=True)\n",
        "\n",
        "      # Appliquer le premier bloc AddNorm (ajoute l'entrée originale X\n",
        "      # et normalise)\n",
        "      X = self.add_norm1(X, attention)\n",
        "\n",
        "      # Passer le résultat à travers le FeedForwardBlock (MLP)\n",
        "      # pour traiter davantage les données\n",
        "      projection = self.MLP(X)\n",
        "\n",
        "      # Appliquer le deuxième bloc AddNorm (ajoute l'entrée de l'étape\n",
        "      # précédente et normalise)\n",
        "      X = self.add_norm2(X, projection)\n",
        "\n",
        "      # Retourner la sortie finale X, et éventuellement les poids d'attention\n",
        "      return (X, attention_weights_1) if return_att_weight else X"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8SXXVWd7_RF_"
      },
      "source": [
        "Ensuite, nous allons assembler le tout, en ajoutant les encodages positionnels ainsi qu'en empilant plusieurs blocs de transformateur et en ajoutant notre couche de prédiction.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4XBG24Qs_RF_"
      },
      "outputs": [],
      "source": [
        "class LLM(nn.Module):\n",
        "    \"\"\"\n",
        "    Modèle Transformer composé de plusieurs couches de blocs décodeurs.\n",
        "\n",
        "    Args:\n",
        "        num_heads: Nombre de têtes d'attention dans chaque bloc Multi-Head\n",
        "        Attention (MHA).\n",
        "        num_layers: Nombre de blocs décodeurs dans le modèle.\n",
        "        d_m: Dimensionnalité des embeddings des tokens.\n",
        "        vocab_size: Taille du vocabulaire (nombre de tokens uniques).\n",
        "        widening_factor: Facteur par lequel la taille de la couche cachée\n",
        "        est augmentée dans le MLP.\n",
        "    \"\"\"\n",
        "    num_heads: int\n",
        "    num_layers: int\n",
        "    d_m: int\n",
        "    vocab_size: int\n",
        "    widening_factor: int = 4\n",
        "\n",
        "    def setup(self):\n",
        "        # Initialiser une liste de blocs décodeurs, un pour chaque\n",
        "        # couche du modèle\n",
        "        self.blocks = [\n",
        "            DecoderBlock(self.num_heads, self.d_m, self.widening_factor)\n",
        "            for _ in range(self.num_layers)\n",
        "        ]\n",
        "\n",
        "        # Initialiser une couche d'embedding pour convertir les IDs de\n",
        "        # tokens en embeddings de tokens\n",
        "        self.embedding = nn.Embed(num_embeddings=self.vocab_size, features=self.d_m)\n",
        "\n",
        "        # Initialiser une couche dense pour prédire le prochain token\n",
        "        # dans la séquence\n",
        "        self.pred_layer = nn.Dense(self.vocab_size)\n",
        "\n",
        "    def __call__(self, X, mask=None, return_att_weights=False):\n",
        "        \"\"\"\n",
        "        Passage en avant à travers le modèle LLM.\n",
        "\n",
        "        Args:\n",
        "            X: Lot d'IDs de tokens d'entrée, forme [B, T_decoder]\n",
        "            où B est la taille du lot et T_decoder est la longueur\n",
        "            de la séquence.\n",
        "            mask [optionnel, par défaut=None]: Masque pour contrôler les\n",
        "            positions sur lesquelles l'attention peut se concentrer,\n",
        "            forme [T_decoder, T_decoder].\n",
        "            return_att_weights [optionnel, par défaut=False]: Indique\n",
        "            si les poids d'attention doivent être retournés.\n",
        "\n",
        "        Returns:\n",
        "            logits: Les probabilités prédites pour chaque token dans\n",
        "            le vocabulaire.\n",
        "            Si return_att_weights est True, retourne également\n",
        "            les poids d'attention.\n",
        "        \"\"\"\n",
        "\n",
        "        # Convertir les IDs de tokens en embeddings (forme\n",
        "        # [B, T_decoder, d_m])\n",
        "        X = self.embedding(X)\n",
        "\n",
        "        # Obtenir la longueur de la séquence d'entrée\n",
        "        sequence_len = X.shape[-2]\n",
        "\n",
        "        # Générer des encodages positionnels et les ajouter aux\n",
        "        # embeddings des tokens\n",
        "        positions = return_frequency_pe_matrix(sequence_len, self.d_m)\n",
        "        X = X + positions\n",
        "\n",
        "        # Initialiser une liste pour stocker les poids d'attention\n",
        "        # si nécessaire\n",
        "        if return_att_weights:\n",
        "            att_weights = []\n",
        "\n",
        "        # Passer les embeddings à travers chaque bloc décodeur\n",
        "        # en séquence\n",
        "        for block in self.blocks:\n",
        "            out = block(X, mask, return_att_weights)\n",
        "            if return_att_weights:\n",
        "                # Si on retourne les poids d'attention, déballer la sortie\n",
        "                X = out[0]\n",
        "                att_weights.append(out[1])\n",
        "            else:\n",
        "                # Sinon, mettre à jour simplement l'entrée pour le\n",
        "                # bloc suivant\n",
        "                X = out\n",
        "\n",
        "        # Appliquer une couche dense suivie d'un log softmax pour obtenir\n",
        "        # les logits (probabilités prédites des tokens)\n",
        "        logits = nn.log_softmax(self.pred_layer(X))\n",
        "\n",
        "        # Retourner les logits, et éventuellement, les poids d'attention\n",
        "        return logits if not return_att_weights else (logits, jnp.array(att_weights).swapaxes(0, 1))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sClFLLkU_RF_"
      },
      "source": [
        "Si tout est correct, alors si nous exécutons le code ci-dessous, tout devrait fonctionner sans problème.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "82CWEa5m_RGA"
      },
      "outputs": [],
      "source": [
        "B, T, d_m, N, vocab_size = 18, 32, 16, 8, 25670\n",
        "\n",
        "llm = LLM(num_heads=1, num_layers=1, d_m=d_m, vocab_size=vocab_size, widening_factor=4)\n",
        "mask = jnp.tril(np.ones((T, T)))\n",
        "\n",
        "# initialise le module et obtient une sortie factice\n",
        "key = jax.random.PRNGKey(42)\n",
        "X = jax.random.randint(key, [B, T], 0, vocab_size)\n",
        "params = llm.init(key, X, mask=mask)\n",
        "\n",
        "# extrait la sortie du décodeur\n",
        "logits, decoder_att_weights = llm.apply(\n",
        "    params,\n",
        "    X,\n",
        "    mask=mask,\n",
        "    return_att_weights=True,\n",
        ")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gve7ssD__RGA"
      },
      "source": [
        "Comme dernière vérification de cohérence, nous pouvons confirmer que nos poids d'attention fonctionnent correctement. Comme le montre la figure ci-dessous, les poids d'attention du décodeur ne se concentrent que sur les jetons précédents, comme prévu.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "H4NpywYv_RGA"
      },
      "outputs": [],
      "source": [
        "fig, ax = plt.subplots(1, 1, figsize=(10, 5))\n",
        "plt.suptitle(\"Poids d'attention du LLM\")\n",
        "sns.heatmap(decoder_att_weights[0, 0, 0, ...], ax=ax, cmap=\"Blues\")\n",
        "fig.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmt3tp38G90A"
      },
      "source": [
        "### 2.5 Entraînement de votre LLM\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "agLIpsoh_RGA"
      },
      "source": [
        "#### 2.5.1 Objectif d'entraînement <font color='green'>Intermédiaire</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QOSv1-3B_RGA"
      },
      "source": [
        "#### 2.5.1 Objectif d'entraînement <font color='green'>Intermédiaire</font>\n",
        "\n",
        "Une phrase n'est rien d'autre qu'une chaîne de mots. Un LLM vise à prédire le mot suivant en tenant compte du contexte actuel, c'est-à-dire des mots qui l'ont précédé.\n",
        "\n",
        "Voici l'idée de base :\n",
        "\n",
        "Pour calculer la probabilité d'une phrase complète \"mot1, mot2, ..., dernier mot\" apparaissant dans un contexte donné $c$, la procédure consiste à décomposer la phrase en mots individuels et à considérer la probabilité de chaque mot étant donné les mots qui le précèdent. Ces probabilités individuelles sont ensuite multipliées ensemble :\n",
        "\n",
        "$$\\text{Probabilité de la phrase} = \\text{Probabilité de mot1} \\times \\text{Probabilité de mot2} \\times \\ldots \\times \\text{Probabilité du dernier mot}$$\n",
        "\n",
        "Cette méthode est semblable à la construction d'une narration pièce par pièce en fonction de l'histoire précédente.\n",
        "\n",
        "Mathématiquement, cela s'exprime comme la vraisemblance (probabilité) d'une séquence de mots $y_1, y_2, ..., y_n$ dans un contexte donné $c$, ce qui est réalisé en multipliant les probabilités de chaque mot $y_t$ calculées étant donné les prédécesseurs ($y_{<t}$) et le contexte $c$ :\n",
        "\n",
        "$$\n",
        "P\\left(y_{1}, y_{2}, \\ldots, y_{n}, \\mid c\\right)=\\prod_{t=1}^{n} P\\left(y_{t} \\mid y_{<t}, c\\right)\n",
        "$$\n",
        "\n",
        "Ici $y_{<t}$ représente la séquence $y_1, y_2, ..., y_{t-1}$, tandis que $c$ représente le contexte.\n",
        "\n",
        "Cela est analogue à résoudre un puzzle où la pièce suivante est placée prévisiblement en fonction de ce qui est déjà en place.\n",
        "\n",
        "Rappelez-vous que lors de l'entraînement d'un transformateur, nous ne travaillons pas avec des mots, mais avec des tokens. Pendant le processus d'entraînement, les paramètres du modèle sont affinés en calculant la perte de l'entropie croisée entre le token prédit et le token correct, puis en effectuant une rétropropagation. La perte pour l'étape temporelle \"t\" est calculée comme suit :\n",
        "\n",
        "$$ \\text{Perte}_t = - \\sum_{w \\in V} y_t\\log (\\hat{y}_t) $$\n",
        "\n",
        "Ici $y_t$ est le token réel à l'étape temporelle $t$, et $\\hat{y}_t$ est le token prédit par le modèle à la même étape temporelle. La perte pour l'ensemble de la phrase est ensuite calculée comme suit :\n",
        "\n",
        "$$ \\text{Perte de la phrase} = \\frac{1}{n} \\sum^{n}_{t=1} \\text{Perte}_t $$\n",
        "\n",
        "où $n$ est la longueur de la séquence.\n",
        "\n",
        "Ce processus itératif affine finalement les capacités prédictives du modèle au fil du temps.\n",
        "\n",
        "**Tâche de code** : Implémentez la fonction de perte d'entropie croisée ci-dessous.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EXmjUYdDHseM"
      },
      "outputs": [],
      "source": [
        "def sequence_loss_fn(logits, targets):\n",
        "  '''\n",
        "  Calculer la perte d'entropie croisée entre l'ID de token prédit et l'ID réel.\n",
        "\n",
        "  Args:\n",
        "    logits: Un tableau de forme [batch_size, sequence_length, vocab_size]\n",
        "    targets: Les IDs de token réels que nous essayons de prédire, forme [batch_size, sequence_length]\n",
        "\n",
        "  Returns:\n",
        "    loss: Une valeur scalaire représentant la perte moyenne du lot\n",
        "  '''\n",
        "\n",
        "  target_labels = jax.nn.one_hot(targets, VOCAB_SIZE)\n",
        "  assert logits.shape == target_labels.shape\n",
        "\n",
        "  mask = jnp.greater(targets, 0)\n",
        "  loss = ... # FINIR MOI\n",
        "\n",
        "  return loss\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4Cq5_4WN_RGA"
      },
      "outputs": [],
      "source": [
        "# @title Exécutez-moi pour tester votre code\n",
        "VOCAB_SIZE = 25670\n",
        "targets = jnp.array([[0, 2, 0]])\n",
        "key = jax.random.PRNGKey(42)\n",
        "X = jax.random.normal(key, [1, 3, VOCAB_SIZE])\n",
        "loss = sequence_loss_fn(X, targets)\n",
        "real_loss = jnp.array(10.966118)\n",
        "assert jnp.allclose(real_loss, loss), \"La valeur retournée n'est pas correcte\"\n",
        "print(\"Il semble correct. Consultez la réponse ci-dessous pour comparer les méthodes.\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cthfcbmC_RGA"
      },
      "outputs": [],
      "source": [
        "# @title Réponse à la tâche de code (Essayez de ne pas regarder avant d'avoir bien essayé !)\n",
        "def sequence_loss_fn(logits, targets):\n",
        "    \"\"\"Calculer la perte de séquence entre les logits prédits et les étiquettes cibles.\"\"\"\n",
        "\n",
        "    # Convertir les indices cibles en vecteurs encodés en one-hot.\n",
        "    # Chaque étiquette cible est convertie en un vecteur one-hot de taille VOCAB_SIZE.\n",
        "    target_labels = jax.nn.one_hot(targets, VOCAB_SIZE)\n",
        "\n",
        "    # Assurer que la forme des logits correspond à la forme des cibles encodées en one-hot.\n",
        "    # C'est important car nous devons calculer la perte sur les dimensions correspondantes.\n",
        "    assert logits.shape == target_labels.shape\n",
        "\n",
        "    # Créer un masque qui ignore les jetons de padding dans le calcul de la perte.\n",
        "    # Le masque est True (1) lorsque la valeur cible est supérieure à 0 et False (0) sinon.\n",
        "    mask = jnp.greater(targets, 0)\n",
        "\n",
        "    # Calculer la perte d'entropie croisée pour chaque jeton.\n",
        "    # L'entropie croisée est calculée comme le logarithme négatif de la probabilité de la classe correcte.\n",
        "    # jax.nn.log_softmax(logits) nous donne les probabilités logarithmiques pour chaque classe.\n",
        "    # Nous multiplions par les target_labels pour sélectionner la probabilité logarithmique de la classe correcte.\n",
        "    loss = -jnp.sum(target_labels * jax.nn.log_softmax(logits), axis=-1)\n",
        "\n",
        "    # Appliquer le masque à la perte pour ignorer les positions de padding et additionner les pertes.\n",
        "    # Nous normalisons ensuite la perte totale par le nombre de jetons non-padding.\n",
        "    loss = jnp.sum(loss * mask) / jnp.sum(mask)\n",
        "\n",
        "    return loss\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4CSfvGj__RGA"
      },
      "source": [
        "#### 2.5.2 Entraînement des modèles <font color='blue'>Avancé</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zIQ_aJGW_RGA"
      },
      "source": [
        "Dans la section suivante, nous définissons tous les processus nécessaires pour entraîner le modèle en utilisant l'objectif décrit ci-dessus. Une grande partie de cela concerne maintenant le travail requis pour effectuer l'entraînement avec FLAX.\n",
        "\n",
        "Ci-dessous, nous rassemblons le jeu de données sur lequel nous allons entraîner, qui est le jeu de données de Shakespeare de Karpathy. Il n'est pas si important de comprendre ce code, donc soit exécutez simplement la cellule pour charger les données, soit consultez le code si vous souhaitez le comprendre.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "guMHAaSo_RGB"
      },
      "outputs": [],
      "source": [
        "# @title Créer le jeu de données Shakespeare et l'itérateur (optionnel, mais exécutez la cellule)\n",
        "\n",
        "# Astuce pour éviter les erreurs lors du téléchargement de tinyshakespeare.\n",
        "import locale\n",
        "locale.getpreferredencoding = lambda: \"UTF-8\"\n",
        "\n",
        "!wget https://raw.githubusercontent.com/karpathy/char-rnn/master/data/tinyshakespeare/input.txt -O input.txt\n",
        "\n",
        "class WordBasedAsciiDatasetForLLM:\n",
        "    \"\"\"Jeu de données en mémoire d'un fichier ASCII unique pour un modèle de type langage.\"\"\"\n",
        "\n",
        "    def __init__(self, path: str, batch_size: int, sequence_length: int):\n",
        "        \"\"\"Charger un fichier ASCII unique en mémoire.\"\"\"\n",
        "        self._batch_size = batch_size\n",
        "\n",
        "        with open(path, \"r\") as f:\n",
        "            corpus = f.read()\n",
        "\n",
        "        # Tokeniser en séparant le texte en mots\n",
        "        words = corpus.split()\n",
        "        self.vocab_size = len(set(words))  # Nombre de mots uniques\n",
        "\n",
        "        # Créer un mapping de mots vers des IDs uniques\n",
        "        self.word_to_id = {word: i for i, word in enumerate(set(words))}\n",
        "\n",
        "        # Stocker le mapping inverse des IDs vers les mots\n",
        "        self.id_to_word = {i: word for word, i in self.word_to_id.items()}\n",
        "\n",
        "        # Convertir les mots du corpus en leurs IDs correspondants\n",
        "        corpus = np.array([self.word_to_id[word] for word in words]).astype(np.int32)\n",
        "\n",
        "        crop_len = sequence_length + 1\n",
        "        num_batches, ragged = divmod(corpus.size, batch_size * crop_len)\n",
        "        if ragged:\n",
        "            corpus = corpus[:-ragged]\n",
        "        corpus = corpus.reshape([-1, crop_len])\n",
        "\n",
        "        if num_batches < 10:\n",
        "            raise ValueError(\n",
        "                f\"Seulement {num_batches} lots ; envisagez une séquence plus courte \"\n",
        "                \"ou un lot plus petit.\"\n",
        "            )\n",
        "\n",
        "        self._ds = WordBasedAsciiDatasetForLLM._infinite_shuffle(\n",
        "            corpus, batch_size * 10\n",
        "        )\n",
        "\n",
        "    def __iter__(self):\n",
        "        return self\n",
        "\n",
        "    def __next__(self):\n",
        "        \"\"\"Générer le prochain mini-lot.\"\"\"\n",
        "        batch = [next(self._ds) for _ in range(self._batch_size)]\n",
        "        batch = np.stack(batch)\n",
        "        # Créer les paires observation/cible pour la modélisation du langage.\n",
        "        return dict(\n",
        "            input=batch[:, :-1], target=batch[:, 1:]\n",
        "        )\n",
        "\n",
        "    def ids_to_words(self, ids):\n",
        "        \"\"\"Convertir une séquence d'IDs de mots en mots.\"\"\"\n",
        "        return [self.id_to_word[id] for id in ids]\n",
        "\n",
        "    @staticmethod\n",
        "    def _infinite_shuffle(iterable, buffer_size):\n",
        "        \"\"\"Répéter et mélanger infiniment les données de l'itérable.\"\"\"\n",
        "        ds = itertools.cycle(iterable)\n",
        "        buf = [next(ds) for _ in range(buffer_size)]\n",
        "        random.shuffle(buf)\n",
        "        while True:\n",
        "            item = next(ds)\n",
        "            idx = random.randint(0, buffer_size - 1)  # Inclus.\n",
        "            result, buf[idx] = buf[idx], item\n",
        "            yield result\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_WBIFg51oQl0"
      },
      "source": [
        "Lets now look how our data is structured for training"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WvH3XPM5_RGB"
      },
      "outputs": [],
      "source": [
        "# Échantillonner et examiner les données\n",
        "batch_size = 2\n",
        "seq_length = 32\n",
        "train_dataset = WordBasedAsciiDatasetForLLM(\"input.txt\", batch_size, seq_length)\n",
        "\n",
        "batch = next(train_dataset)\n",
        "\n",
        "for obs, target in zip(batch[\"input\"], batch[\"target\"]):\n",
        "    print(\"-\" * 10, \"Entrée\", \"-\" * 11)\n",
        "    print(\"TEXTE :\", ' '.join(train_dataset.ids_to_words(obs)))\n",
        "    print(\"ASCII :\", obs)\n",
        "    print(\"-\" * 10, \"Cible\", \"-\" * 10)\n",
        "    print(\"TEXTE :\", ' '.join(train_dataset.ids_to_words(target)))\n",
        "    print(\"ASCII :\", target)\n",
        "\n",
        "print(f\"\\n Taille totale du vocabulaire : {train_dataset.vocab_size}\")\n",
        "\n",
        "VOCAB_SIZE = train_dataset.vocab_size\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w9vzee53_RGB"
      },
      "source": [
        "Ensuite, entraînons notre LLM et voyons comment il se comporte pour produire du texte shakespearien. Tout d'abord, nous allons définir ce qui se passe à chaque étape d'entraînement.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PGuYBCkekgDw"
      },
      "outputs": [],
      "source": [
        "import functools\n",
        "\n",
        "@functools.partial(jax.jit, static_argnums=(3, 4))\n",
        "def train_step(params, optimizer_state, batch, apply_fn, update_fn):\n",
        "    \"\"\"\n",
        "    Effectuer une étape d'entraînement.\n",
        "\n",
        "    Args:\n",
        "        params: Les paramètres actuels du modèle.\n",
        "        optimizer_state: L'état actuel de l'optimiseur.\n",
        "        batch: Un dictionnaire contenant les données d'entrée et les étiquettes cibles pour le batch.\n",
        "        apply_fn: La fonction utilisée pour appliquer le modèle aux entrées.\n",
        "        update_fn: La fonction utilisée pour mettre à jour les paramètres du modèle en fonction des gradients.\n",
        "\n",
        "    Returns:\n",
        "        Paramètres mis à jour, état de l'optimiseur mis à jour, et la perte calculée pour le batch.\n",
        "    \"\"\"\n",
        "\n",
        "    def loss_fn(params):\n",
        "        # Obtenez la longueur de la séquence (T) à partir des données d'entrée.\n",
        "        T = batch['input'].shape[1]\n",
        "\n",
        "        # Appliquez le modèle aux données d'entrée, en utilisant un masque triangulaire inférieur pour imposer la causalité.\n",
        "        # jnp.tril(np.ones((T, T))) crée une matrice triangulaire inférieure de uns.\n",
        "        logits = apply_fn(params, batch['input'], jnp.tril(np.ones((T, T))))\n",
        "\n",
        "        # Calculez la perte entre les logits prédits et les étiquettes cibles.\n",
        "        loss = sequence_loss_fn(logits, batch['target'])\n",
        "\n",
        "        return loss\n",
        "\n",
        "    # Calculez la perte et ses gradients par rapport aux paramètres.\n",
        "    loss, gradients = jax.value_and_grad(loss_fn)(params)\n",
        "\n",
        "    # Mettez à jour l'état de l'optimiseur et calculez les mises à jour des paramètres en fonction des gradients.\n",
        "    updates, optimizer_state = update_fn(gradients, optimizer_state)\n",
        "\n",
        "    # Appliquez les mises à jour aux paramètres.\n",
        "    params = optax.apply_updates(params, updates)\n",
        "\n",
        "    # Retournez les paramètres mis à jour, l'état de l'optimiseur, et la perte pour le batch.\n",
        "    return params, optimizer_state, loss\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rtKWzKIAkfYU"
      },
      "source": [
        "Nous allons maintenant initialiser notre optimiseur et notre modèle. N'hésitez pas à expérimenter avec les hyperparamètres pendant la pratique.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8o3q-BZX_RGB"
      },
      "outputs": [],
      "source": [
        "# Définir tous les hyperparamètres\n",
        "d_model = 128            # Dimension des embeddings de tokens (d_m)\n",
        "num_heads = 4            # Nombre de têtes d'attention dans Multi-Head Attention\n",
        "num_layers = 1           # Nombre de blocs décodeurs dans le modèle\n",
        "widening_factor = 2      # Facteur d'élargissement de la taille de la couche cachée dans le MLP\n",
        "LR = 2e-3                # Taux d'apprentissage pour l'optimiseur\n",
        "batch_size = 32          # Nombre d'échantillons par lot d'entraînement\n",
        "seq_length = 64          # Longueur de chaque séquence d'entrée (nombre de tokens)\n",
        "\n",
        "# Préparer les données d'entraînement\n",
        "train_dataset = WordBasedAsciiDatasetForLLM(\"input.txt\", batch_size, seq_length)\n",
        "vocab_size = train_dataset.vocab_size  # Obtenir la taille du vocabulaire à partir du dataset\n",
        "batch = next(train_dataset)            # Obtenir le premier lot de données d'entrée\n",
        "\n",
        "# Définir la clé du générateur de nombres aléatoires pour l'initialisation du modèle\n",
        "rng = jax.random.PRNGKey(42)\n",
        "\n",
        "# Initialiser le modèle LLM avec les hyperparamètres spécifiés\n",
        "llm = LLM(num_heads=num_heads, num_layers=num_layers, d_m=d_model, vocab_size=vocab_size, widening_factor=widening_factor)\n",
        "\n",
        "# Créer un masque causal pour s'assurer que le modèle ne se concentre que sur les tokens précédents\n",
        "mask = jnp.tril(np.ones((batch['input'].shape[1], batch['input'].shape[1])))\n",
        "\n",
        "# Initialiser les paramètres du modèle en utilisant le premier lot de données d'entrée et le masque\n",
        "params = llm.init(rng, batch['input'], mask)\n",
        "\n",
        "# Configurer l'optimiseur en utilisant l'algorithme d'optimisation Adam avec le taux d'apprentissage spécifié\n",
        "optimizer = optax.adam(LR, b1=0.9, b2=0.99)\n",
        "optimizer_state = optimizer.init(params)  # Initialiser l'état de l'optimiseur avec les paramètres du modèle"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3bPEFakxmvsM"
      },
      "source": [
        "Now we train! This will take a few minutes..\n",
        "While it trains, have you greeted your neighbor yet?\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "oUAS6tie_RGB"
      },
      "outputs": [],
      "source": [
        "plotlosses = PlotLosses()\n",
        "\n",
        "MAX_STEPS = 3500\n",
        "LOG_EVERY = 32\n",
        "losses = []\n",
        "VOCAB_SIZE = 25670\n",
        "\n",
        "# Boucle d'entraînement\n",
        "for step in range(MAX_STEPS):\n",
        "    batch = next(train_dataset)\n",
        "    params, optimizer_state, loss = train_step(\n",
        "        params, optimizer_state, batch, llm.apply, optimizer.update)\n",
        "    losses.append(loss)\n",
        "    if step % LOG_EVERY == 0:\n",
        "        loss_ = jnp.array(losses).mean()\n",
        "        plotlosses.update(\n",
        "            {\n",
        "                \"loss\": loss_,\n",
        "            }\n",
        "        )\n",
        "        plotlosses.send()\n",
        "        losses = []\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pGv9c2AFmF4V"
      },
      "source": [
        "#### 2.5.3 Inspecter le LLM entraîné <font color='orange'>Débutant</font>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pfq61gim_RGB"
      },
      "source": [
        "**Rappel :** n'oubliez pas d'exécuter tout le code présenté jusqu'à présent dans cette section avant de lancer les cellules ci-dessous !\n",
        "\n",
        "Générons maintenant un peu de texte et voyons comment notre modèle a performé. NE STOPPEZ PAS LA CELLULE UNE FOIS QU'ELLE EST EN COURS D'EXÉCUTION, CELA FERA PLANTER LA SESSION.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5lt8HTS__RGC"
      },
      "outputs": [],
      "source": [
        "import functools\n",
        "\n",
        "@functools.partial(jax.jit, static_argnums=(2, ))\n",
        "def generate_prediction(params, input, apply_fn):\n",
        "  logits = apply_fn(params, input)\n",
        "  argmax_out = jnp.argmax(logits, axis=-1)\n",
        "  return argmax_out[0][-1].astype(int)\n",
        "\n",
        "def generate_random_shakespeare(llm, params, id_2_word, word_2_id):\n",
        "    '''\n",
        "    Get the model output\n",
        "    '''\n",
        "\n",
        "    prompt = \"Love\"\n",
        "    print(prompt, end=\"\")\n",
        "    tokens = prompt.split()\n",
        "\n",
        "    # predict and append\n",
        "    for i in range(15):\n",
        "      input = jnp.array([[word_2_id[t] for t in tokens]]).astype(int)\n",
        "      prediction = generate_prediction(params, input, llm.apply)\n",
        "      prediction = id_2_word[int(prediction)]\n",
        "      tokens.append(prediction)\n",
        "      print(\" \"+prediction, end=\"\")\n",
        "\n",
        "    return \" \".join(tokens)\n",
        "\n",
        "id_2_word = train_dataset.id_to_word\n",
        "word_2_id = train_dataset.word_to_id\n",
        "\n",
        "generated_shakespeare = generate_random_shakespeare(llm, params, id_2_word, word_2_id)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wOwNuMRf_RGC"
      },
      "source": [
        "Enfin, nous avons implémenté tout ce qui précède en prenant l'ID de jeton avec la probabilité maximale d'être correct. C'est ce qu'on appelle le décodage gourmand, car nous avons uniquement pris le jeton le plus probable. Cela a bien fonctionné dans ce cas, mais il y a des situations où cette approche gourmande peut dégrader les performances, notamment lorsque nous souhaitons générer un texte réaliste.\n",
        "\n",
        "Il existe d'autres méthodes pour échantillonner à partir du décodeur, avec un algorithme célèbre étant la recherche par faisceau (beam search). Nous fournissons ci-dessous des ressources pour ceux qui souhaitent en savoir plus à ce sujet.\n",
        "\n",
        "[Décodage Gourmand](https://www.youtube.com/watch?v=DW5C3eqAFQM&list=PLmZlBIcArwhPHmHzyM_cZJQ8_v5paQJTV&index=4)\n",
        "\n",
        "[Recherche par Faisceau](https://www.youtube.com/watch?v=uG3xoYNo3HM&list=PLmZlBIcArwhPHmHzyM_cZJQ8_v5paQJTV&index=5)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fV3YG7QOZD-B"
      },
      "source": [
        "## **Conclusion**\n",
        "**Résumé :**\n",
        "\n",
        "Vous avez maintenant maîtrisé l'essentiel du fonctionnement d'un Large Language Model (LLM), depuis les mécanismes d'attention fondamentaux jusqu'à l'entraînement de votre propre LLM ! Ces outils puissants ont le potentiel de transformer un large éventail de tâches. Cependant, comme tout modèle de deep learning, leur efficacité réside dans leur application aux bons problèmes avec les bonnes données.\n",
        "\n",
        "Prêt à passer au niveau supérieur ? Plongez dans le fine-tuning de vos propres LLMs et libérez encore plus de potentiel ! Je vous recommande vivement d'explorer le tutoriel de l'année dernière sur les méthodes de fine-tuning efficaces pour obtenir une vue d'ensemble des techniques avancées. Le voyage ne s'arrête pas là—il y a encore tant à découvrir ! [LLMs pour Tous 2023](https://colab.research.google.com/github/deep-learning-indaba/indaba-pracs-2023/blob/main/practicals/large_language_models.ipynb)\n",
        "\n",
        "Le monde des LLMs est à vous—allez créer quelque chose d'incroyable ! 🌟🚀\n",
        "\n",
        "**Prochaines étapes :**\n",
        "\n",
        "[**Fine-tuning Efficace des LLMs avec Hugging Face**](https://colab.research.google.com/github/deep-learning-indaba/indaba-pracs-2023/blob/main/practicals/large_language_models.ipynb)\n",
        "\n",
        "**Références :** pour des références supplémentaires, consultez les liens mentionnés dans les sections spécifiques de ce colab.\n",
        "\n",
        "* [Article \"Attention is all you need\"](https://arxiv.org/abs/1706.03762)\n",
        "* [Vidéos supplémentaires sur les transformers](https://www.youtube.com/playlist?list=PLmZlBIcArwhOPR2s-FIR7WoqNaBML233s)\n",
        "* [Article LoRA](https://arxiv.org/abs/2106.09685)\n",
        "* [RLHF](https://huggingface.co/blog/rlhf) (comment ChatGPT a été entraîné)\n",
        "* [Extension de la longueur du contexte](https://kaiokendev.github.io/context)\n",
        "\n",
        "Pour d'autres pratiques du Deep Learning Indaba, veuillez visiter [ici](https://github.com/deep-learning-indaba/indaba-pracs-2023).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1ndpYE50BpG"
      },
      "source": [
        "# Retours - Avis - Suggestions\n",
        "\n",
        "Veuillez fournir des commentaires que nous pourrons utiliser pour améliorer nos pratiques à l'avenir.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "collapsed": true,
        "id": "OIZvkhfRz9Jz"
      },
      "outputs": [],
      "source": [
        "# @title Generate Feedback Form. (Run Cell)\n",
        "from IPython.display import HTML\n",
        "\n",
        "HTML(\n",
        "    \"\"\"\n",
        "<iframe\n",
        "\tsrc=\"\",\n",
        "  width=\"80%\"\n",
        "\theight=\"1200px\" >\n",
        "\tLoading...\n",
        "</iframe>\n",
        "\"\"\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oglV4kHMWnIN"
      },
      "source": [
        "<img src=\"https://baobab.deeplearningindaba.com/static/media/indaba-logo-dark.d5a6196d.png\" width=\"50%\" />"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.8.5"
    },
    "vscode": {
      "interpreter": {
        "hash": "145833166d986a8417df3c7acb65d917d84b716b5a452e57fcacdc66f1a168c9"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}