practicals/AI_for_Biology/AI_for_Biology_French.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m2s4kN_QPQVe"
      },
      "source": [
        "# 🧬 **AI for Biology** 🧬\n",
        "\n",
        "<a href=\"https://ibb.co/Cs0GsQD\"><img src=\"https://i.ibb.co/mFzWF4g/d3ccc3f8-69e2-428f-8ec4-896221936735.webp\" alt=\"Scifi collage of AI in biology\" border=\"0\"></a>\n",
        "\n",
        "<a href=\"https://colab.research.google.com/github/deep-learning-indaba/indaba-pracs-2024/blob/main/practicals/AI_for_Biology/AI_for_Biology_French.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n",
        "\n",
        "© Deep Learning Indaba 2024. Apache License 2.0.\n",
        "\n",
        "**Auteurs :** Natasha Latysheva\n",
        "\n",
        "**Relecteurs:** Awa Samaké, Merwan Bekkar, Yousra Farhani, Marvellous Ajala\n",
        "\n",
        "**Sujets :** Biologie, ADN, modèles de langage de grande taille, plongements (embeddings) , apprentissage supervisé et auto-supervisé.\n",
        "\n",
        "**Niveau :** Débutant\n",
        "\n",
        "**Objectifs :** Comprendre les plongements d'ADN et entraîner un modèle en les utilisant pour résoudre un problème biologique pratique\n",
        "\n",
        "# AI for Biology\n",
        "Bienvenue dans le tutoriel pratique **AI for Biology** ! Dans cette session, nous allons :\n",
        "- Découvrir certains des principaux domaines d'application de l'IA dans les biosciences\n",
        "- Examiner le rôle de l'ADN et la manière dont les modèles de langage d'ADN sont entraînés\n",
        "- Extraire et explorer les plongements (embeddings) de l'ADN en utilisant un modèle de langage d'ADN pré-entraîné à la pointe de la technologie\n",
        "- Se plonger dans un problème pratique de modélisation des séquences d'ADN et de leurs propriétés\n",
        "\n",
        "**Prérequis :**\n",
        "\n",
        "1. Connaissances de base en Python\n",
        "2. Aucune connaissance en biologie requise\n",
        "\n",
        "**Plan du tutoriel pratique :**\n",
        "\n",
        "<div align=\"left\">\n",
        "<a href=\"https://ibb.co/jryGWdL\"><img src=\"https://i.ibb.co/kS409ph/Screenshot-2024-07-23-at-21-48-22.png\" alt=\"Screenshot-2024-07-23-at-21-48-22\" width=\"400\" border=\"0\"></a>\n",
        "</div>\n",
        "\n",
        "\n",
        "\n",
        "**Avant de commencer :**\n",
        "\n",
        "Pour ce tutoriel pratique, vous devrez utiliser un GPU pour accélérer l'entraînement. Pour ce faire, allez dans le menu \"Exécution\" de Colab, sélectionnez \"Changer le type d'exécution\", puis dans le menu contextuel, choisissez \"GPU\" dans la zone \"Accélérateur matériel\".\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uaYkP5A7bGqF"
      },
      "source": [
        "Nous pouvons également déjà installer et importer tous les packages requis :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4boGA9rYdt9l"
      },
      "outputs": [],
      "source": [
        "## Installer et importer tout ce qui est requis, télécharger les modèles, télécharger les données.\n",
        "# @title Installer et importer les packages nécessaires. (Exécuter la cellule)\n",
        "%%capture\n",
        "\n",
        "# Installations.\n",
        "!pip install transformers datasets\n",
        "!pip install biopython requests h5py\n",
        "!pip install jax\n",
        "!pip install flax\n",
        "\n",
        "# Importations.\n",
        "import os\n",
        "import random\n",
        "import tqdm\n",
        "\n",
        "import jax\n",
        "import jax.numpy as jnp\n",
        "from jax import grad, jit, vmap\n",
        "import flax.linen as nn\n",
        "import optax\n",
        "import torch\n",
        "\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import h5py\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "from Bio import Entrez, SeqIO\n",
        "\n",
        "from sklearn.manifold import TSNE\n",
        "\n",
        "from transformers import AutoTokenizer, AutoModelForMaskedLM\n",
        "\n",
        "\n",
        "# Télécharger le modèle de langage d'ADN et le tokenizer.\n",
        "tokenizer = AutoTokenizer.from_pretrained(\n",
        "    \"InstaDeepAI/nucleotide-transformer-v2-50m-multi-species\",\n",
        "    trust_remote_code=True)\n",
        "\n",
        "language_model = AutoModelForMaskedLM.from_pretrained(\n",
        "    \"InstaDeepAI/nucleotide-transformer-v2-50m-multi-species\",\n",
        "    trust_remote_code=True)\n",
        "\n",
        "# Télécharger les plongements pré-extraits pour des chaînes d'ADN aléatoires.\n",
        "ROOT_DIR = \"https://raw.githubusercontent.com/deep-learning-indaba/indaba-pracs-2024/main/practicals/AI_for_Biology/data/\"\n",
        "\n",
        "import pandas as pd\n",
        "dna_sequences = pd.read_csv(os.path.join(ROOT_DIR, \"dna_sequences.csv\"))\n",
        "# (train_df) Données d'entraînement\n",
        "train_df = pd.read_feather(os.path.join(ROOT_DIR, \"train_embeddings.feather\"))\n",
        "# (valid_df) Données de validation\n",
        "valid_df = pd.read_feather(os.path.join(ROOT_DIR, \"valid_embeddings.feather\"))\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7Jh4BKgUcNHw"
      },
      "outputs": [],
      "source": [
        "# @title Vérifier TPU/GPU. (Exécuter la cellule)\n",
        "import jax\n",
        "num_devices = jax.device_count()\n",
        "device_type = jax.devices()[0].device_kind\n",
        "print(f\"Trouvé {num_devices} dispositif(s) JAX de type {device_type}.\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PYna9Z1iZwuH"
      },
      "source": [
        "## 1. Applications de l'IA en Biologie\n",
        "\n",
        "L'IA devient de plus en plus courante dans le domaine biologique et a connu des avancées récentes vraiment passionnantes. Cependant, le domaine en est encore à ses débuts - cela signifie qu'il reste beaucoup de travail intéressant à faire et que c'est un excellent moment pour s'y impliquer !\n",
        "\n",
        "Voici un rapide aperçu de quelques travaux récents intéressants en IA appliquée à la biologie dans différents domaines.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s6EQ9z2D81Gi"
      },
      "source": [
        "### Diagnostics médicaux\n",
        "\n",
        "Les modèles de classification du cancer de la peau tels que [celui du MIT](https://www.science.org/doi/10.1126/scitranslmed.abb3652) atteignent des performances comparables à celles de dermatologues certifiés :\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://wp.technologyreview.com/wp-content/uploads/2021/06/automated-melanoma-detection-small2.gif?w=400\" alt=\"GIF de détection automatisée du mélanome\">\n",
        "</div>\n",
        "\n",
        "\n",
        "Un [modèle de DeepMind](https://www.nature.com/articles/s41591-018-0107-6) de segmentation et de classification des maladies de la rétine est capable de diagnostiquer de nombreuses affections ophtalmiques à partir de scans rétiniens 3D. Ses performances sont similaires à celles des meilleurs spécialistes de la rétine et surpassent celles de certains experts humains :\n",
        "\n",
        "\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://miro.medium.com/v2/resize:fit:1400/format:webp/1*cnyoA2T8BFZRBYWnUlYEtQ.gif\" alt=\"GIF de segmentation du scan rétinien\">\n",
        "</div>\n",
        "\n",
        "[Le modèle SynthSR de Harvard et de l'UCL](https://www.science.org/doi/10.1126/sciadv.add3607) peut prendre des IRM cérébrales cliniques avec n'importe quel contraste, orientation et résolution et les transformer en images 3D haute résolution :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://www.science.org/cms/10.1126/sciadv.add3607/asset/7a6c5ed9-af95-41d2-b888-2b5a653ea55b/assets/images/large/sciadv.add3607-f1.jpg\" alt=\"Modèle de scan IRM SynthSR\" width=\"400\">\n",
        "</div>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KVYcazlUZ-vP"
      },
      "source": [
        "### Pharmacie et développement de médicaments\n",
        "\n",
        "[Exscientia](https://www.exscientia.com/) a développé le premier médicament conçu par l'IA à entrer dans des essais cliniques (DSP-1181, destiné au traitement du trouble obsessionnel-compulsif).\n",
        "\n",
        "De nombreux efforts de découverte de médicaments assistés par l'IA utilisent des modèles pour prédire la force avec laquelle les petites molécules se lieront à différentes régions d'une protéine cible impliquée dans une maladie donnée :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://developer-blogs.nvidia.com/wp-content/uploads/2023/03/bionemo_featured.jpeg\" alt=\"representation d'une poche générale\" width=\"400\">\n",
        "</div>\n",
        "\n",
        "\n",
        "[BenevolentAI](https://www.benevolent.com/about-us/sustainability/covid-19/) a utilisé l'IA pour identifier le Baricitinib, à l'origine un médicament contre l'arthrite, comme traitement potentiel contre la COVID-19 en 48 heures en utilisant son graphique de connaissances.\n",
        "\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://www.benevolent.com/application/files/6616/7458/5885/Corona_Baricitinib.png\" alt=\"BenevolentAI Baricitinib\" width=\"400\">\n",
        "</div>\n",
        "\n",
        "[Lien vers une vidéo YouTube intitulée « BenevolentAI · AI-Enabled Drug Discovery »](https://www.youtube.com/watch?v=RPBDhogTIT0)\n",
        "\n",
        "[Recursion Pharmaceuticals](https://www.recursion.com/) est réputée pour son criblage et son optimisation à haut débit, et a développé des modèles avancés d'imagerie cellulaire :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://miro.medium.com/v2/resize:fit:1400/0*yVLwEtfojWdnMZfA\" alt=\"Recursion\" width=\"800\">\n",
        "</div>\n",
        "\n",
        "\n",
        "Ils entraînent des modèles pour prédire les pixels manquants dans les images de cellules de la même manière que les grands modèles de langage prédisent les mots manquants ou masqués dans les phrases :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://blogs.nvidia.com/wp-content/uploads/2024/05/Recursion-Phenom-AI-model-animation.gif\" alt=\"Recursion\" width=\"800\">\n",
        "</div>\n",
        "\n",
        "Parmi les autres startups qui font de l'apprentissage profond pour la découverte de médicaments, citons Atomwise, insitro, Insilico Medicine, Deep Genomics et Deepcell.\n",
        "\n",
        "En outre, de grandes sociétés pharmaceutiques comme Illumina, GSK et Genentech ont mis en place des équipes internes d'apprentissage profond et ont développé des modèles influents tels que [SpliceAI](https://www.cell.com/cell/pdf/S0092-8674(18)31629-5.pdf) (un modèle qui comprend l'épissage) et [PrimateAI](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6237276/) (un modèle qui prédit l'effet clinique des mutations dans les protéines), ce qui témoigne de l'intégration croissante de l'apprentissage profond dans les flux de travail en biologie.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wjN3f4S4aIPg"
      },
      "source": [
        "### Biologie moléculaire\n",
        "\n",
        "Le [modèle AlphaFold de DeepMind](https://www.nature.com/articles/s41586-021-03819-2) a révolutionné le domaine de la prédiction de la structure des protéines, gagnant une adoption et une reconnaissance généralisées dans les milieux universitaires, biotechnologiques et pharmaceutiques :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://spectrum.ieee.org/media-library/two-examples-of-protein-targets-in-the-free-modelling-category-in-green-is-the-experimental-result-in-blue-is-the-computationa.gif?id=25559695&width=2400&height=1358\" alt=\"Prédictions d'AlphaFold\" width=\"800\">\n",
        "</div>\n",
        "\n",
        "\n",
        "Des chercheurs d'[EvolutionaryScale](https://www.evolutionaryscale.ai/blog/esm3-release) ont utilisé leur modèle de langage protéique ESM3 pour concevoir une nouvelle protéine fluorescente assez distincte des protéines fluorescentes présentes dans la nature :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://cdn.prod.website-files.com/6606dc3fd5f6645318003e20/667a5bb780d0ada7dc37d1c0_image%20(1).png\" alt=\"ESM3\" width=\"400\">\n",
        "</div>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "balHN65uaPS-"
      },
      "source": [
        "### Écologie et conservation\n",
        "\n",
        "[Rainforest Connection (RFCx)](https://rfcx.org/) est un projet innovant qui place des smartphones modifiés dans les arbres, enregistre des données audio, puis utilise des modèles pour identifier les différentes espèces présentes dans la zone. Cela permet de surveiller la biodiversité et de détecter les activités illégales comme l'exploitation forestière en temps réel.\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://www.huawei.com/~/media/CORPORATE/Images/case-studies/case1/photo-grid.jpg\" alt=\"Configuration de Rainforest connection\" width=\"600\">\n",
        "</div>\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://cdn.ttgtmedia.com/visuals/LeMagIT/Forest1.png\" alt=\"Audio de Rainforest connection\" width=\"600\">\n",
        "</div>\n",
        "\n",
        "\n",
        "\n",
        "[Project CETI](https://www.projectceti.org/) (Cetacean Translation Initiative) utilise l'IA pour analyser et décoder les sons des baleines afin de comprendre leur communication et leur comportement.\n",
        "\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://i0.wp.com/www.josephdelpreto.com/wp-content/uploads/2023/09/Project-CETI_s-Approach-_-Illustration-%C2%A9-2023-Alex-Boersma.jpg?resize=1024%2C912\" alt=\"Baleine CETI\" width=\"600\">\n",
        "</div>\n",
        "\n",
        "\n",
        "Un concours Zindi appelé [Turtle Recall](https://zindi.africa/competitions/turtle-recall-conservation-challenge) a mis les utilisateurs au défi de construire un modèle capable d'identifier les tortues marines individuelles à partir des motifs d'écailles sur leur tête, ce qui pourrait contribuer à améliorer les efforts de conservation des tortues marines :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://lh3.googleusercontent.com/9J6DZgiuGyYr3N1DoJBmZMVpBkTlGOq19QUws7G2fbFcuHeIJKQ3plFh-R2xkxB1OpVaqZhcglM6hWWl5x7PuuxbtnDlIWlCgoCr0LGVM4S-loaj_Jc=w1232-rw\" alt=\"Rappel des tortues\" width=\"600\">\n",
        "</div>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q61C7IWMs5Up"
      },
      "source": [
        "**Sondage** : Levez la main, lequel de ces sous-domaines de l'IA pour la biologie trouvez-vous le plus intéressant ?\n",
        "1. 🏥 **Diagnostics médicaux** 🏥\n",
        "2. 💊 **Pharmacie et développement de médicaments** 💊\n",
        "3. 🧬 **Biologie moléculaire** 🧬\n",
        "4. 🌳 **Écologie et conservation** 🌳\n",
        "5. **Autre** (lequel ? :)\n",
        "\n",
        "**Question** : quelles autres initiatives intéressantes dans le domaine de l'IA en biologie connaissez-vous ?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uekgwzRTabu_"
      },
      "source": [
        "### Lectures complémentaires\n",
        "\n",
        "Ces exemples ne sont pas exhaustifs et visent simplement à vous donner un aperçu de certaines applications actuelles de l'IA en biologie. Si vous souhaitez en savoir plus sur ce domaine, voici quelques ressources intéressantes à lire :\n",
        "\n",
        "- Un article de revue de *Nature Communications* de 2022 intitulé [\"Current progress and open challenges for applying deep learning across the biosciences\"](https://www.nature.com/articles/s41467-022-29268-7)\n",
        "- Un article de revue un peu plus ancien (2018) intitulé [“Opportunities and obstacles for deep learning in biology and medicine”](https://royalsocietypublishing.org/doi/10.1098/rsif.2017.0387). Celui-ci a été cité plus de 2 000 fois !\n",
        "- [\"Deep Learning for the Life Sciences\"](https://www.oreilly.com/library/view/deep-learning-for/9781492039822/), un livre d'O'Reilly de 2019, qui fournit des informations pratiques et des applications du deep learning en génomique, en chimie et en bio-informatique.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g3U85xKMaf4f"
      },
      "source": [
        "## 2. Introduction à l'ADN\n",
        "\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZsoawR4YWZuu"
      },
      "source": [
        "Nous espérons que cette introduction vous a suffisamment enthousiasmé pour les applications de l'apprentissage profond en biologie ! Pour le reste de cette séance pratique, nous allons nous plonger nous-mêmes dans le travail d'IA appliqué à la biologie, en nous concentrant sur le sujet de l'ADN.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wPg62NUYVCYx"
      },
      "source": [
        "<div align=\"center\">\n",
        "    <img src=\"https://i.pinimg.com/originals/c7/90/76/c79076215950e968828f663e1b69fe67.gif\" alt=\"DNA gif\" width=\"200\">\n",
        "</div>\n",
        "\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s-2h_qSbbCVb"
      },
      "source": [
        "**L'ADN est la molécule de l'hérédité, la base de toute vie telle que nous la connaissons.**\n",
        "\n",
        "Sa structure a été découverte pour la première fois en 1953, marquant un moment crucial dans les sciences biologiques. La première ébauche du génome humain a été publiée en 2001, jetant les bases de la génomique moderne.\n",
        "\n",
        "Mais ces dates sont assez récentes, et bien que nous connaissions maintenant une partie du \"quoi\" du génome, nous sommes très loin de connaître le \"comment\" de son fonctionnement réel.\n",
        "\n",
        "Par exemple, nous savons que l'ADN est composé de 4 \"lettres\" différentes, à savoir A (adénine), C (cytosine), G (guanine) et T (thymine) et que le génome humain est composé de 3,2 milliards de lettres qui sont réparties sur 23 paires de chromosomes. L'ADN est compacté de différentes manières afin de tenir dans le noyau de la cellule :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://miro.medium.com/v2/resize:fit:1400/1*EUKrGpPzUAwp2sOOPZOcqA.jpeg\" alt=\"DNA text\" width=\"400\">\n",
        "</div>\n",
        "\n",
        "Si nous devions ouvrir le \"livre\" du génome humain, nous verrions quelque chose comme ceci :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://cms.wellcome.org/sites/default/files/styles/image_full_hi/public/WI_C0035768_GenomeEditing_20150902_News_600x600.jpg?itok=FCedpedU\" alt=\"DNA text\" width=\"400\">\n",
        "</div>\n",
        "\n",
        "**Ceci peut être très difficile à interpréter**. Et il y a beaucoup d'ADN à interpréter - assez pour remplir une bibliothèque s'il était imprimé dans des volumes de livres :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://live.staticflickr.com/3265/2569126918_b68047a65b_b.jpg\" alt=\"DNA bookcase\" width=\"400\">\n",
        "</div>\n",
        "\n",
        "Parmi les principales questions ouvertes que nous nous posons sur l'ADN, citons :\n",
        "- Que font les 3,2 milliards de lettres du génome humain ? Sont-elles toutes biologiquement fonctionnelles ?\n",
        "- Comment chaque cellule du corps humain peut-elle avoir exactement le même génome, mais avoir des fonctions très différentes ? Par exemple, pensez à la différence entre un neurone et une cellule musculaire.\n",
        "- Nous savons que seulement 2 % environ de l'ADN du génome code pour des protéines, à quoi servent les 98 % restants ?\n",
        "- Comment la variation génétique conduit-elle à la maladie ou aux différences que nous observons entre les individus ?\n",
        "\n",
        "Pour résumer :\n",
        "\n",
        "***Le génome humain peut être considéré comme un très long livre dont les mots sont composés des lettres A, T, C et G. Les modèles de deep learning sont très prometteurs pour la compréhension du génome en raison de leur capacité à saisir le signal dans des données volumineuses, complexes et potentiellement bruyantes.***\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FUZs124vaoAc"
      },
      "source": [
        "## Modèles de langage ADN\n",
        "    \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p1XSYCABa1pV"
      },
      "source": [
        "## Modèles de langage ADN\n",
        "\n",
        "**Les modèles de langage ADN (LMs)** sont très similaires aux modèles de langage de grande taille que vous connaissez peut-être, tels que ChatGPT, Gemini, Claude, etc. Au lieu d'être entraînés sur de grandes quantités de texte en langage naturel, les LMs d'ADN sont entraînés sur de grandes quantités de séquences d'ADN.\n",
        "\n",
        "De nombreux LLMs et LMs d'ADN sont entraînés en **masquant** de manière aléatoire certains jetons dans le texte, puis en demandant au modèle de prédire ce qu'est le jeton :\n",
        "\n",
        "<div align=\"center\">\n",
        "<a href=\"https://ibb.co/M9d9GM0\"><img src=\"https://i.ibb.co/25J5sg4/Screenshot-2024-07-23-at-22-18-57.png\" alt=\"Screenshot-2024-07-23-at-22-18-57\" width=\"800\" border=\"0\"></a>\n",
        "</div>\n",
        "\n",
        "De la même manière que les LLMs acquièrent une compréhension du langage qui peut ensuite être utile pour de nombreuses tâches en aval, les modèles de langage ADN peuvent capturer les schémas et les structures complexes au sein de l'ADN, ce qui les rend précieux pour diverses tâches génomiques en aval telles que l'analyse des mutations et la compréhension des éléments régulateurs :\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-5nhVXVvQfsb"
      },
      "source": [
        "## Quelques modèles de langage ADN populaires\n",
        "\n",
        "Tout comme les LLMs ont connu un succès massif, de plus en plus de personnes s'intéressent à l'entraînement de modèles de langage ADN. Parmi les plus célèbres, citons :\n",
        "\n",
        "- [DNABERT](https://academic.oup.com/bioinformatics/article/37/15/2112/6128680) (2021) - DNABERT adapte le modèle BERT, qui a connu un grand succès en PNL (NLP), pour comprendre les séquences d'ADN.\n",
        "- [HyenaDNA](https://arxiv.org/abs/2306.15794) (2023) - Spécialisé dans les longues séquences d'ADN, avec des contextes allant jusqu'à 1 million de jetons au niveau du nucléotide unique.\n",
        "- [Nucleotide Transformer](https://www.biorxiv.org/content/10.1101/2023.01.11.523679v1) (2023) - une architecture basée sur un transformateur spécifiquement conçue pour les séquences de nucléotides.\n",
        "\n",
        "Certaines personnes ont également affiné des LLMs en langage naturel existants sur des séquences d'ADN, par exemple [Mistral-DNA](https://github.com/raphaelmourad/Mistral-DNA).\n",
        "\n",
        "Pour ce TP, nous utiliserons le modèle Nucleotide Transformer\n",
        "(NT) car il est assez performant, populaire et facilement disponible sur la [plateforme Hugging Face 🤗](https://huggingface.co/).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oi3kRTr4cFVv"
      },
      "source": [
        "## Le modèle Nucleotide Transformer (NT)\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mI4e0ondcGzl"
      },
      "source": [
        "Nucleotide Transformer a été entraîné sur 3 202 génomes humains divers, ainsi que sur 850 génomes provenant d'un large éventail d'espèces. Le modèle génère des représentations transférables et contextuelles de séquences d'ADN.\n",
        "\n",
        "Voici quelques détails supplémentaires sur le modèle :\n",
        "- NT est une architecture de transformateur à encodeur uniquement, formée à l'aide de l'approche BERT (masquage de parties de séquences d'ADN). Les séquences d'ADN ont été tokenisées en 6-mers.\n",
        "- Il s'agit d'un modèle non supervisé, mais ses représentations seules égalent ou surpassent les méthodes spécialisées sur 11 tâches de prédiction sur 18, telles que la prédiction de la présence de certains éléments régulateurs connus sous le nom de promoteurs et d'amplificateurs dans un fragment d'ADN donné.\n",
        "- Les données d'entraînement pour la version `nucleotide-transformer-v2-50m-multi-species` de NT ont été entraînées sur un total de **174 milliards de nucléotides**, soit environ **29 milliards de jetons (tokens)**. Voici les statistiques par groupe d'organismes :\n",
        "\n",
        "| Classe                | Nombre d'espèces | Nombre de nucléotides (milliards) |\n",
        "| ---------------------| -------------------| --------------------------|\n",
        "| Bactéries            | 667                | 17,1                      |\n",
        "| Champignons           | 46                 | 2,3                       |\n",
        "| Invertébrés          | 39                 | 20,8                      |\n",
        "| Protozoaires          | 10                 | 0,5                       |\n",
        "| Vertébrés mammifères | 31                 | 69,8                      |\n",
        "| Autres vertébrés      | 57                 | 63,4                      |\n",
        "\n",
        "Il existe d'autres versions plus volumineuses du modèle disponibles sur Hugging Face [ici](https://huggingface.co/collections/InstaDeepAI/nucleotide-transformer-65099cdde13ff96230f2e592). Nous utilisons ici un modèle relativement petit pour des raisons de vitesse.\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qfpDwu0mbC2U"
      },
      "source": [
        "## Exploration des plongements d'ADN dans différentes espèces\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4SvGZ0yAUEor"
      },
      "source": [
        "Chargeons le modèle Nucleotide Transformer (NT) depuis HuggingFace et commençons à l'utiliser !\n",
        "\n",
        "Nous avons déjà chargé le tokenizer et le modèle dans la première cellule du notebook. Ce sont ces deux objets :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6hisjeBWMhQr"
      },
      "outputs": [],
      "source": [
        "type(tokenizer)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y3Pc0E_lMjk_"
      },
      "outputs": [],
      "source": [
        "type(language_model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wlhntuz2FKOT"
      },
      "source": [
        "    \n",
        "Voyons ce que le modèle a appris sur l'ADN de différentes espèces. Nous pouvons prendre des séquences d'ADN aléatoires provenant de différentes espèces, utiliser le modèle pour extraire une représentation **embedding** de l'ADN, et voir si les espèces similaires ont tendance à avoir un ADN avec des représentations similaires.\n",
        "\n",
        "Créons une liste d'espèces qui nous intéressent :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PVw2zyrjuAJ7"
      },
      "outputs": [],
      "source": [
        "organismes = [\n",
        "    'Homo sapiens',  # Humain\n",
        "    'Pan troglodytes',  # Chimpanzé\n",
        "    'Pan paniscus',     # Bonobo\n",
        "    'Gorilla gorilla',  # Gorille\n",
        "    'Tursiops truncatus',  # Dauphin (à gros nez)\n",
        "    'Hydrochoerus hydrochaeris',  # Capybara\n",
        "    'Escherichia coli',  # Bactérie E. coli\n",
        "    'Lactobacillus acidophilus',  # Bactérie probiotique commune\n",
        "    'Salmonella enterica',  # Pathogène d'origine alimentaire courant\n",
        "    'Pseudomonas aeruginosa',  # Bactérie présente dans le sol et l'eau\n",
        "]\n",
        "\n",
        "print(len(organismes))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qgTtxzq_V333"
      },
      "source": [
        "On peut utiliser la bibliothèque Python `Entrez` pour effectuer une recherche dans la base de données pour une chaîne d'ADN aléatoire pour un organisme donné :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v884-yBoV81G"
      },
      "outputs": [],
      "source": [
        "organism = 'Homo sapiens'\n",
        "gene = 'BRCA1'  # Nom de gène exemple.\n",
        "\n",
        "Entrez.email = \"your.email@example.com\"  # Requis. Peut être un espace réservé.\n",
        "\n",
        "# Recherche des enregistrements d'ADN pour l'organisme.\n",
        "query = f'({gene}[Gene Name]) AND {organism}[Organism] AND \"RefSeq\"[filter]'\n",
        "handle = Entrez.esearch(db='nucleotide', term=query, retmax=10)\n",
        "record = Entrez.read(handle)\n",
        "handle.close()\n",
        "\n",
        "# Récupérer un enregistrement aléatoire.\n",
        "np.random.seed(42)\n",
        "random_record_id = np.random.choice(record['IdList'])\n",
        "\n",
        "# Lire l'ADN.\n",
        "handle = Entrez.efetch(\n",
        "    db='nucleotide', id=random_record_id, rettype='fasta', retmode='text')\n",
        "seq_record = SeqIO.read(handle, 'fasta')\n",
        "\n",
        "print(seq_record)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2c9OD88UWcbD"
      },
      "source": [
        "On peut facilement extraire la chaîne d'ADN de cette entrée :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NE3WVQZAWUzo"
      },
      "outputs": [],
      "source": [
        "dna_sequence = str(seq_record.seq)\n",
        "dna_sequence"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "irKR4ijrXPeV"
      },
      "source": [
        "Le modèle NT peut être utilisé pour calculer une représentation numérique de la signification de cette séquence d'ADN. Nous allons simplement passer la séquence d'ADN en entrée, la tokeniser, et extraire les activations de la dernière couche cachée du modèle :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "91-IP-4CXd4Z"
      },
      "outputs": [],
      "source": [
        "# Tokenisation de la séquence d'ADN.\n",
        "max_length = tokenizer.model_max_length\n",
        "\n",
        "token_ids = tokenizer.batch_encode_plus(\n",
        "  [dna_sequence], return_tensors='pt',\n",
        "  padding='max_length', max_length=max_length,\n",
        "  truncation=True)['input_ids']\n",
        "\n",
        "token_ids"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lIPxAnTKYi_j"
      },
      "source": [
        "Vous pouvez voir que la séquence d'ADN a été tokenisée et complétée (padded) avec le token `1` jusqu'à la longueur maximale de 2048 :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QkbnezMnYd03"
      },
      "outputs": [],
      "source": [
        "len(token_ids[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "psxQ5Ib5Yqax"
      },
      "outputs": [],
      "source": [
        "token_ids[0][-50:]  # Afficher les 50 derniers jetons."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EUHpbYFoY2CQ"
      },
      "source": [
        "Voyons maintenant la sortie du modèle étant donné cette entrée d'ADN :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zOPWLYQ9X7Hp"
      },
      "outputs": [],
      "source": [
        "masque_attention = token_ids != tokenizer.pad_token_id\n",
        "\n",
        "torch_outs = language_model(\n",
        "  token_ids,\n",
        "  attention_mask=masque_attention,\n",
        "  encoder_attention_mask=masque_attention,\n",
        "  output_hidden_states=True,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qKza0f1jZFDd"
      },
      "source": [
        "On peut voir que 13 sorties d'états cachés différentes sont présentes, représentant les sorties de 13 couches différentes dans le modèle :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ARjvBGUAY6Gg"
      },
      "outputs": [],
      "source": [
        "len(torch_outs['hidden_states'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N92L57BIZOiu"
      },
      "source": [
        "Prenons le dernier état caché à l'index `-1` car il est susceptible d'être informatif (mais peut-être pas de manière optimale pour chaque tâche - nous pourrions essayer l'avant-dernier état caché, ou le troisième à partir de la fin, etc.) :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rTruDvORZYM7"
      },
      "outputs": [],
      "source": [
        "embeddings = torch_outs['hidden_states'][-1].detach()\n",
        "embeddings = np.squeeze(embeddings.numpy())\n",
        "embeddings.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lt6PoMHoZhrG"
      },
      "source": [
        "On peut voir que le plongement est une matrice de forme 2048 par 512. C'est une grande matrice numpy !\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G-_x-wwjZust"
      },
      "outputs": [],
      "source": [
        "embeddings"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-YTHUDbdZxcy"
      },
      "source": [
        "Au sein de cette large matrice de nombres, le modèle a capturé un certain sens de la signification de la chaîne d'ADN.\n",
        "\n",
        "Rappelons que notre chaîne d'ADN avait une longueur de 2048 – cela signifie que chaque position a son propre vecteur de plongement (embeddings) de longueur 512 qui est contextuel.\n",
        "\n",
        "Nous pourrions visualiser cette matrice de nombres, mais cela en soi ne serait pas très significatif :\n",
        "\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cCj4Bu6TaGbK"
      },
      "outputs": [],
      "source": [
        "plt.imshow(embeddings)\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YMqR4K-baXns"
      },
      "source": [
        "Une façon courante de résumer un plongement comme celui-ci est de calculer le **plongement moyen** : nous pouvons prendre la moyenne sur l’axe spatial et obtenir un plongement de longueur 512 qui représente la séquence d’ADN entière.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0KWL7QyDbN4A"
      },
      "outputs": [],
      "source": [
        "# Déplacer l'axe pour que le broadcasting fonctionne.\n",
        "masque_attention = np.moveaxis(masque_attention.numpy(), 0, -1)\n",
        "\n",
        "# Calcul du plongement (embeddings) moyen.\n",
        "mean_embeddings = np.sum(\n",
        "    masque_attention * embeddings, axis=0) / np.sum(masque_attention)\n",
        "\n",
        "plt.plot(mean_embeddings, color='grey')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P0obDhoSbsF9"
      },
      "source": [
        "**C'est pratique de pouvoir condenser une séquence d'ADN en 512 nombres comme ceci, mais c'est encore difficile de vraiment savoir ce que ces nombres signifient.**\n",
        "\n",
        "La valeur des plongements (embeddings) de séquences se révèle vraiment lorsque vous les **comparez les uns aux autres**. Donc, écrivons la fonction `fetch_random_dna` qui va extraire des séquences d'ADN aléatoires pour une espèce donnée :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "v-Wor2NYVwuS"
      },
      "outputs": [],
      "source": [
        "def fetch_random_dna(\n",
        "  organism: str,\n",
        "  min_length: int,\n",
        "  max_length: int,\n",
        "  num_sequences: int,\n",
        "  max_attempts: int = 50) -> list[str]:\n",
        "  \"\"\"Récupère un certain nombre de séquences d'ADN d'une longueur donnée pour une espèce.\"\"\"\n",
        "  # Recherche des entrées nucléotidiques pour l'organisme comme nous l'avons fait précédemment.\n",
        "  handle = Entrez.esearch(\n",
        "      db='nucleotide', term=f'{organism}[Organism]', retmax=max_attempts)\n",
        "  record = Entrez.read(handle)\n",
        "  handle.close()\n",
        "  if not record['IdList']:\n",
        "    return []\n",
        "\n",
        "  # Nous pouvons collecter nos séquences d'ADN dans cette liste.\n",
        "  sequences = []  # (séquences)\n",
        "  attempts = 0  # (tentatives)\n",
        "\n",
        "  while len(sequences) < num_sequences and attempts < max_attempts:\n",
        "    random_record_id = random.choice(record['IdList'])\n",
        "    handle = Entrez.efetch(\n",
        "        db='nucleotide', id=random_record_id, rettype='fasta', retmode='text')\n",
        "    try:\n",
        "      seq_record = SeqIO.read(handle, 'fasta')\n",
        "      handle.close()\n",
        "\n",
        "      if len(seq_record.seq) >= min_length:\n",
        "        seq = str(seq_record.seq) # (seq)\n",
        "        if len(seq) > max_length:\n",
        "          seq = seq[:max_length]\n",
        "        sequences.append(seq)\n",
        "\n",
        "    # Gère le cas où aucun enregistrement FASTA valide n'a été trouvé.\n",
        "    except ValueError:\n",
        "      handle.close()\n",
        "    attempts += 1\n",
        "\n",
        "  return sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x-F4OQESebs4"
      },
      "source": [
        "Utilisons cela pour récupérer une courte séquence d'ADN pour l'homme :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7xbuwa-8eWR-"
      },
      "outputs": [],
      "source": [
        "fetch_random_dna(\n",
        "    organism='Homo sapiens', min_length=10, max_length=50, num_sequences=1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BeCb7wbGeiN-"
      },
      "source": [
        "Maintenant, on peut facilement l'utiliser pour récupérer des séquences d'ADN pour les organismes dans notre liste ci-dessus. Le code pour faire cela ressemblerait à ceci :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gXHNINCZeUAS"
      },
      "outputs": [],
      "source": [
        "NUM_SEQUENCES = 1\n",
        "MIN_LENGTH = 100\n",
        "MAX_LENGTH = 1000\n",
        "random.seed(42)\n",
        "\n",
        "# (first_organisms) : premiers organismes\n",
        "first_organisms = organismes[0:3]\n",
        "\n",
        "print(f'Fetching {NUM_SEQUENCES} random DNA sequences of min length '\n",
        "      f'{MIN_LENGTH} and max length {MAX_LENGTH} for {len(first_organisms)} '\n",
        "      'organisms...\\n')\n",
        "\n",
        "dna_sequences_small = []\n",
        "# (organism_labels) : étiquettes des organismes\n",
        "organism_labels = []\n",
        "\n",
        "# (organism) : organisme\n",
        "for organism in tqdm.tqdm(first_organisms, desc='Organisms'):\n",
        "  print(organism, flush=True)\n",
        "  # (sequences) : séquences\n",
        "  sequences = fetch_random_dna(\n",
        "      organism, min_length=MIN_LENGTH, max_length=MAX_LENGTH,\n",
        "      num_sequences=NUM_SEQUENCES)\n",
        "  dna_sequences_small += sequences\n",
        "  organism_labels += [organism] * len(sequences)\n",
        "\n",
        "# (sequence) : séquence\n",
        "dna_sequences_small = pd.DataFrame({'sequence': dna_sequences_small, 'organism': organism_labels})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mIs-VYPDgRKE"
      },
      "source": [
        "Mais cela prend quelques minutes à s'exécuter si nous voulons par exemple 20 séquences d'ADN pour chacun des 10 organismes, donc par souci de rapidité, nous avons pré-récupéré certaines séquences pour plus de commodité :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tNrT7f6y1yv3"
      },
      "outputs": [],
      "source": [
        "dna_sequences"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TMzlFGizQbor"
      },
      "source": [
        "Nous pouvons nous appuyer sur notre code précédent pour extraire les plongements moyens des séquences d'ADN :\n",
        "    \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "W-1hLFeQ3Gwp"
      },
      "outputs": [],
      "source": [
        "def _compute_mean_sequence_embeddings(\n",
        "  dna_sequences: list[str],\n",
        "  tokenizer: AutoTokenizer,\n",
        "  model: AutoModelForMaskedLM):\n",
        "\n",
        "  max_length = tokenizer.model_max_length\n",
        "  tokens_ids = tokenizer.batch_encode_plus(\n",
        "    dna_sequences, return_tensors=\"pt\", padding=\"max_length\",\n",
        "    max_length=max_length)[\"input_ids\"]\n",
        "\n",
        "  # Calcul des plongements.\n",
        "  attention_mask = tokens_ids != tokenizer.pad_token_id\n",
        "\n",
        "  # Déplacement du modèle et des tenseurs vers le GPU.\n",
        "  model = model.to('cuda')\n",
        "  tokens_ids = tokens_ids.to('cuda')\n",
        "  attention_mask = attention_mask.to('cuda')\n",
        "\n",
        "  # Par défaut, PyTorch conserve le graphe de calcul pour la passe arrière, mais cela\n",
        "  # remplit la RAM et nous n'en avons pas besoin, nous le désactivons donc avec torch.no_grad().\n",
        "  with torch.no_grad():\n",
        "    torch_outs = model(\n",
        "      tokens_ids,\n",
        "      attention_mask=attention_mask,\n",
        "      encoder_attention_mask=attention_mask,\n",
        "      output_hidden_states=True,\n",
        "    )\n",
        "\n",
        "  # Calcul des plongements de séquences.\n",
        "  embeddings = torch_outs['hidden_states'][-1].detach().cpu()\n",
        "\n",
        "  # Ajout d'une dimension de plongement.\n",
        "  attention_mask_cpu = torch.unsqueeze(attention_mask.cpu(), dim=-1)\n",
        "\n",
        "  # Calcul des plongements moyens par séquence\n",
        "  mean_sequence_embeddings = torch.sum(\n",
        "    attention_mask_cpu * embeddings, axis=-2) / torch.sum(attention_mask_cpu, axis=1)\n",
        "\n",
        "  return mean_sequence_embeddings.numpy()\n",
        "\n",
        "\n",
        "def compute_mean_sequence_embeddings(\n",
        "    dna_sequences: list[str],\n",
        "    tokenizer: AutoTokenizer,\n",
        "    model: AutoModelForMaskedLM,\n",
        "    batch_size: int = 4) -> np.ndarray:\n",
        "  \"\"\"Calcule les plongements moyens de séquences pour une liste de chaînes d'ADN.\"\"\"\n",
        "  all_mean_embeddings = []\n",
        "\n",
        "  # (batch_sequences: lots de séquences, batch_mean_embeddings: plongements moyens des lots)\n",
        "  for i in tqdm.tqdm(range(0, len(dna_sequences), batch_size)):\n",
        "    batch_sequences = dna_sequences[i:i+batch_size]\n",
        "    batch_mean_embeddings = _compute_mean_sequence_embeddings(\n",
        "        batch_sequences, tokenizer, model)\n",
        "    all_mean_embeddings.extend(batch_mean_embeddings)\n",
        "\n",
        "  return np.vstack(all_mean_embeddings)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sF77cUxYn1WQ"
      },
      "outputs": [],
      "source": [
        "embeddings = compute_mean_sequence_embeddings(\n",
        "    dna_sequences['sequence'], tokenizer, language_model, batch_size=7)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6AyrRWPrQxaJ"
      },
      "source": [
        "Cela nous donne un encodage de longueur 512 pour chacune des 200 chaînes d'ADN :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ieeTRVEAQwOO"
      },
      "outputs": [],
      "source": [
        "embeddings.shape"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qV0ZDnTSQ2Uy"
      },
      "source": [
        "Ce serait formidable de pouvoir visualiser ces données. Mais comme les humains ne peuvent pas vraiment visualiser des choses dans un espace à 512 dimensions, utilisons d'abord une technique de réduction de dimensionnalité telle que tSNE pour projeter les données sur 2 dimensions. Cela donne 2 nombres pour chaque séquence d'ADN originale qui capturent encore une certaine notion de sens dans l'ADN :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6i1lalSt3DUg"
      },
      "outputs": [],
      "source": [
        "tsne = TSNE(n_components=2, learning_rate='auto', random_state=0)\n",
        "embeddings_tsne = tsne.fit_transform(embeddings)\n",
        "\n",
        "# (embeddings_tsne_df) : DataFrame des embeddings après tSNE\n",
        "embeddings_tsne_df = pd.DataFrame(\n",
        "    embeddings_tsne, columns=['first_dim', 'second_dim'])\n",
        "\n",
        "# (organism) : Organisme\n",
        "embeddings_tsne_df['organism'] = dna_sequences['organism']\n",
        "embeddings_tsne_df"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GCMrzbZU3FMR"
      },
      "source": [
        "# On peut étiqueter chaque token avec son espèce ou une étiquette plus générale, comme \"animal\" ou \"plante\".\n",
        "    # Cela nous permet de voir si des séquences similaires provenant d'espèces similaires se regroupent.\n",
        "    # On peut ensuite redessiner le graphique et le colorer par étiquette :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8FSSR3h53MPG"
      },
      "outputs": [],
      "source": [
        "labels = {\n",
        "    'Homo sapiens': 'animal',\n",
        "    'Pan paniscus': 'animal',\n",
        "    'Pan troglodytes': 'animal',\n",
        "    'Tursiops truncatus': 'animal',\n",
        "    'Hydrochoerus hydrochaeris': 'animal',\n",
        "    'Escherichia coli': 'bactérie',\n",
        "    'Pseudomonas aeruginosa': 'bactérie',\n",
        "    'Lactobacillus acidophilus': 'bactérie',\n",
        "    'Salmonella enterica': 'bactérie',\n",
        "    }\n",
        "\n",
        "embeddings_tsne_df['label'] = embeddings_tsne_df['organism'].map(labels)\n",
        "\n",
        "ax = sns.scatterplot(data=embeddings_tsne_df,\n",
        "                x='first_dim',\n",
        "                y='second_dim',\n",
        "                hue='label', color=None,\n",
        "                s=200, alpha=0.7, palette='Set2')\n",
        "\n",
        "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
        "\n",
        "plt.tight_layout()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "manXg5mkfRqU"
      },
      "source": [
        "Il semble que, bien que les séquences animales et bactériennes aient tendance à occuper des parties quelque peu différentes de l'espace d'incorporation, il existe certainement beaucoup de chevauchements, ce qui suggère que les génomes de l'arbre de vie partagent de nombreuses similitudes !\n",
        "\n",
        "**Question **: Est-ce ce à quoi vous vous attendiez ?\n",
        "\n",
        "Si vous souhaitez en savoir plus sur les génomes animaux et bactériens, voici quelques faits amusants :\n",
        "- ***Similitudes*** :\n",
        "  - **Code génétique de base** : les génomes animaux et bactériens utilisent le même code génétique, avec des séquences d'ADN composées des quatre mêmes nucléotides : adénine (A), cytosine (C), guanine (G) et thymine (T).\n",
        "  - **Gènes conservés** : De nombreux gènes fondamentaux impliqués dans des processus essentiels, tels que la réplication de l'ADN, la transcription et la traduction, sont conservés chez les animaux et les bactéries.\n",
        "- ***Différences*** :\n",
        "  - **Taille du génome** : les génomes animaux sont généralement beaucoup plus gros (les humains ont 3,2 milliards de bases d'ADN) tandis que les génomes bactériens sont plus petits (de quelques centaines de milliers à quelques millions).\n",
        "  - **Chromosomes** : les animaux ont plusieurs chromosomes linéaires, tandis que les bactéries ont généralement un seul chromosome circulaire.\n",
        "  - **Densité des gènes** : les génomes bactériens sont plus denses en gènes, tandis que les génomes animaux sont plus rares et comportent plus d'éléments régulateurs.\n",
        "  - **Structure des gènes** : les gènes animaux contiennent souvent des introns (régions non codantes au sein des gènes) contrairement aux gènes bactériens en général.\n",
        "\n",
        "**Question :** Lesquelles de ces différences pourraient être capturées par les embeddings mentionnés ci-dessus ?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iZnCLa1xHjTQ"
      },
      "source": [
        "**Tâche** :\n",
        "- Essayez de saisir des séquences d'ADN pour d'autres espèces, par exemple des espèces végétales. Voici quelques noms scientifiques de plantes :\n",
        "```python\n",
        " plants = [\n",
        "  'Oryza sativa',  # Riz\n",
        "  'Vitis vinifera',  # Raisin\n",
        "  'Rosa chinensis',  # Rose\n",
        "  'Musa acuminata',  # Banane\n",
        "  'Solanum lycopersicum', # Tomate\n",
        " ]\n",
        " ```\n",
        "- Dans quelle mesure le nuage de points est-il sensible aux changements de germe aléatoire ou aux autres paramètres ? Essayez une technique de réduction de dimensionnalité différente telle que UMAP au lieu de tSNE. Le nuage de points est-il différent ?\n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z19k8a3Pc3Mo"
      },
      "source": [
        "## 3. Réglage fin d'un modèle de langage ADN\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dAqyowcEIr9z"
      },
      "source": [
        "\n",
        "Dans cette dernière section, nous allons adapter notre modèle de langage ADN à une nouvelle tâche par **réglage fin** (fine-tuning).\n",
        "\n",
        "### Qu'est-ce que le réglage fin ?\n",
        "Le réglage fin est le processus qui consiste à prendre un **modèle pré-entraîné** et à y apporter de légères modifications afin qu'il puisse effectuer une nouvelle tâche spécialisée.\n",
        "\n",
        "Au lieu d'entraîner un modèle à partir de zéro, ce qui peut prendre beaucoup de temps et nécessiter beaucoup de données, nous commençons par un modèle qui comprend déjà certains concepts généraux. Nous l'entraînons ensuite sur un ensemble de données plus petit et spécifique à la tâche.\n",
        "\n",
        "Le **pré-entraînement suivi d'un réglage fin** est un modèle général dans le domaine du ML. Voici quelques exemples tirés du langage naturel et du langage ADN :\n",
        "\n",
        "\n",
        "<a href=\"https://ibb.co/tpd50VH\"><img src=\"https://i.ibb.co/CKrFjRw/ML-for-bio-06.png\" alt=\"NLP vs DNA\" border=\"0\" width=\"400\"></a>\n",
        "\n",
        "\n",
        "### Le problème biologique\n",
        "\n",
        "--> **Nous allons entraîner un modèle pour prédire si une chaîne donnée de 200 bases d'ADN va se lier à un facteur de transcription donné**.\n",
        "\n",
        "Les facteurs de transcription (FT) sont des protéines spéciales qui se lient à l'ADN et jouent un rôle crucial dans l'activation ou la désactivation des gènes. Ils sont essentiels car ils contrôlent l'expression des gènes, qui à son tour affecte le fonctionnement, le développement et la réponse des cellules à leur environnement. Par exemple, ils peuvent déterminer si une cellule devient une cellule musculaire, un neurone ou une cellule cutanée.\n",
        "\n",
        "Voici une image d'un facteur de transcription (en violet) se liant à une certaine région de l'ADN (surlignée en jaune) :\n",
        "\n",
        "<div align=\"center\">\n",
        "    <img src=\"https://www.nichd.nih.gov/sites/default/files/2022-05/TranscriptionFactor-400px.jpg\" alt=\"DNA TF binding\" width=\"400\">\n",
        "</div>\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Chaque facteur de transcription a une certaine **préférence de liaison** - il préfère se lier à une séquence spécifique de bases d'ADN et pas à d'autres. Cela est dû au fait que les formes 3D du FT et de la région de l'ADN peuvent bien s'assembler ou non.\n",
        "\n",
        "L'homme possède plus de 1 000 facteurs de transcription. Nous allons nous intéresser à un facteur de transcription spécifique appelé CTCF, qui a tendance à se lier à des séquences similaires à CCACCAGGGGGCGC (avec une certaine variation possible à certaines positions).\n",
        "\n",
        "Voici le problème de prédiction en termes visuels :\n",
        "\n",
        "\n",
        "- Pour une chaîne spécifique de 200 paires de bases d'ADN, nous voulons prédire la probabilité qu'un **facteur de transcription** donné se lie dans cette région.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZFxmnixIOSad"
      },
      "source": [
        "## Le jeu de données\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tcMjRbwISHrZ"
      },
      "source": [
        "Voici à quoi ressemble le jeu de données que nous allons utiliser :\n",
        "\n",
        "<a href=\"https://ibb.co/1ZbY3SF\"><img src=\"https://i.ibb.co/PxtsRSq/ML-for-bio-05.png\" alt=\"dataset description\" border=\"0\"></a>\n",
        "\n",
        "La tâche est une **tâche de classification binaire** – étant donné 200 bases d'ADN, nous prédisons s'il se liera à un facteur de transcription spécifique appelé CTCF. Le CTCF est en fait un facteur de transcription particulièrement intéressant, car il est impliqué dans l’**architecture du génome**, c'est-à-dire le repliement 3D élaboré du génome en compartiments spécifiques.\n",
        "\n",
        "Le problème est inspiré de l'une des tâches d'évaluation de ce récent [pré-impression d'article de 2024](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC10925287/), qui a tiré le jeu de données de cet [article d'interprétation de la génomique de 2023](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC10169356/)\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "igkX3Ur3iam3"
      },
      "source": [
        "#### Chargement du jeu de données.\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Iu9RMDPZSb2N"
      },
      "source": [
        "Le jeu de données d'entraînement a déjà été construit pour vous :\n",
        "- Nous avons 20 000 exemples d'entraînement.\n",
        "- Chacun est un encodage (embedding) moyen de l'ADN qui a été extrait à l'aide du modèle de langage NT.\n",
        "- La dernière colonne du dataframe est l'étiquette, indiquant si l'ADN se lie ou non à la protéine CTCF.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rM6jQWgISajU"
      },
      "outputs": [],
      "source": [
        "train_df"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LypwXKfYTj01"
      },
      "source": [
        "En général, on observe que les 2 classes sont assez équilibrées (représentées de manière égale) dans le jeu de données d'entraînement, ce qui signifie que nous n'aurons pas besoin de faire de rééquilibrage ici :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1Gx5qlSTTkW6"
      },
      "outputs": [],
      "source": [
        "train_df['label'].value_counts()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SL_5Ib2TS2bD"
      },
      "source": [
        "Si cela vous intéresse, vous pouvez consulter le code qui a permis de générer ce jeu de données, mais vous n'avez pas besoin de l'exécuter ici.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nEqZwSkfi3BW"
      },
      "source": [
        "#### [Vous n'avez pas besoin d'exécuter ceci] Code de création du jeu de données.\n",
        "\n",
        "```python\n",
        "# 1. Charger le fichier h5 contenant les jeux de données CTCF.\n",
        "file_path = os.path.join(ROOT_DIR, 'CTCF_200.h5')\n",
        "\n",
        "with h5py.File(file_path, 'r') as h5file:\n",
        "  print(\"Keys: %s\" % list(h5file.keys()))\n",
        "\n",
        "  # Accéder à chaque jeu de données et le convertir en tableaux numpy.\n",
        "  x_train = h5file['x_train'][()] # données d'entraînement\n",
        "  y_train = h5file['y_train'][()] # étiquettes d'entraînement\n",
        "  x_valid = h5file['x_valid'][()] # données de validation\n",
        "  y_valid = h5file['y_valid'][()] # étiquettes de validation\n",
        "  x_test = h5file['x_test'][()] # données de test\n",
        "  y_test = h5file['y_test'][()] # étiquettes de test\n",
        "\n",
        "# Chaque séquence d'ADN est encodée en one-hot. Visualiser le premier exemple d'entraînement :\n",
        "fig, ax = plt.subplots(figsize=(12, 12))\n",
        "plt.imshow(x_train[0, :, :])\n",
        "plt.show()\n",
        "\n",
        "# 2. Étant donné que notre modèle de langage d'ADN prend en réalité des lettres en entrée, nous pouvons annuler\n",
        "# l'encodage one-hot avec une fonction :\n",
        "\n",
        "def one_hot_to_dna_batch(one_hot_encoded_batch: np.ndarray):\n",
        "  \"\"\"\n",
        "  Convertir un lot de séquences d'ADN encodées en one-hot en chaînes de séquences d'ADN.\n",
        "\n",
        "  Args:\n",
        "    one_hot_encoded_batch (numpy.ndarray): Un tableau numpy 3D avec des séquences d'ADN\n",
        "      encodées en one-hot. La forme doit être (nombre_de_séquences, longueur_de_la_séquence, 4).\n",
        "\n",
        "  Returns:\n",
        "    list: Une liste de séquences d'ADN.\n",
        "  \"\"\"\n",
        "  # Définir une correspondance entre l'encodage one-hot et les nucléotides.\n",
        "  one_hot_mapping = {\n",
        "      (1, 0, 0, 0): 'A',\n",
        "      (0, 1, 0, 0): 'C',\n",
        "      (0, 0, 1, 0): 'G',\n",
        "      (0, 0, 0, 1): 'T',\n",
        "  }\n",
        "\n",
        "  dna_sequences = []\n",
        "\n",
        "  for one_hot_encoded in one_hot_encoded_batch:\n",
        "    dna_sequence = []\n",
        "    for one_hot in one_hot_encoded:\n",
        "      one_hot_tuple = tuple(one_hot)\n",
        "      dna_sequence.append(one_hot_mapping[one_hot_tuple])\n",
        "\n",
        "    dna_sequences.append(''.join(dna_sequence))\n",
        "\n",
        "  return dna_sequences\n",
        "\n",
        "NUM_TRAIN_EXAMPLES = 20_000\n",
        "NUM_VALID_EXAMPLES = 5_000\n",
        "\n",
        "# exemples d'entraînement (x_train), étiquettes d'entraînement (y_train), exemples de validation (x_valid), étiquettes de validation (y_valid)\n",
        "x_train = one_hot_to_dna_batch(\n",
        "    np.moveaxis(x_train, 1, -1)[0:NUM_TRAIN_EXAMPLES])\n",
        "y_train = y_train[0:NUM_TRAIN_EXAMPLES]\n",
        "\n",
        "x_valid = one_hot_to_dna_batch(\n",
        "    np.moveaxis(x_valid, 1, -1)[0:NUM_VALID_EXAMPLES])\n",
        "y_valid = y_valid[0:NUM_VALID_EXAMPLES]\n",
        "\n",
        "# Jeter un coup d'œil aux exemples d'entraînement et aux étiquettes :\n",
        "print(x_train[0:5])\n",
        "print(y_train[0:5])\n",
        "\n",
        "# 3. Calculer les plongements moyens du modèle de langage d'ADN des séquences.\n",
        "train_embeddings = compute_mean_sequence_embeddings(\n",
        "    x_train, tokenizer, language_model)\n",
        "train_df = pd.DataFrame(train_embeddings)\n",
        "train_df['label'] = y_train[:, 0]\n",
        "\n",
        "valid_embeddings = compute_mean_sequence_embeddings(\n",
        "    x_valid, tokenizer, language_model)\n",
        "valid_df = pd.DataFrame(valid_embeddings)\n",
        "valid_df['label'] = y_valid[:, 0]\n",
        "```\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TJ7HXckUwbfY"
      },
      "source": [
        "## Convertir les données en un jeu de données TensorFlow\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-4jfUcKiUcTl"
      },
      "source": [
        "Nous devrons convertir ces dataframes en un jeu de données TensorFlow sur lequel nous pourrons facilement itérer lors de l'entraînement du modèle :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "D-GPb4YWw8ld"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "import numpy as np\n",
        "\n",
        "def convert_to_tfds(df: pd.DataFrame, batch_size: int=32,\n",
        "                    is_training: bool=False):\n",
        "    \"\"\"Convertit les plongements et les étiquettes en un jeu de données TensorFlow.\"\"\" # embeddings: plongements, labels: étiquettes\n",
        "    embeddings = np.array(df.iloc[:, :-1])\n",
        "    labels = np.array(df.iloc[:, -1])[:, None]\n",
        "\n",
        "    ds = tf.data.Dataset.from_tensor_slices(\n",
        "        {'embeddings': embeddings, 'labels': labels})\n",
        "\n",
        "    if is_training:\n",
        "      ds = ds.shuffle(buffer_size=len(df)).repeat()\n",
        "\n",
        "    ds = ds.batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE)\n",
        "\n",
        "    return iter(ds)\n",
        "\n",
        "BATCH_SIZE = 32\n",
        "\n",
        "train_ds = convert_to_tfds(\n",
        "    train_df, batch_size=BATCH_SIZE, is_training=True)\n",
        "valid_ds = convert_to_tfds(\n",
        "    valid_df, batch_size=BATCH_SIZE, is_training=False)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ufGd4gz1oiCi"
      },
      "source": [
        "Jetons un coup d'œil à un lot de données d'entraînement :\n",
        "    \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6U56UKQWxjdv"
      },
      "outputs": [],
      "source": [
        "batch = next(train_ds)\n",
        "batch"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C2CzBBJxVTAG"
      },
      "source": [
        "Le jeu de données est prêt pour l'entraînement du modèle !\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "80wbx6lTofFI"
      },
      "source": [
        "## Réglage fin du modèle\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7vwwXzz1i3Dq"
      },
      "source": [
        "Nous allons maintenant entraîner un modèle linéaire [flax](https://flax.readthedocs.io/en/latest/) simple sur les plongements d'ADN moyens.\n",
        "\n",
        "Flax est assez similaire à de nombreux autres frameworks de deep learning (en particulier [Haiku](https://dm-haiku.readthedocs.io/en/latest/), si vous l'avez déjà rencontré). Dans notre configuration, notez que notre modèle n'est qu'un MLP (perceptron multicouche, qui est constitué de plusieurs couches linéaires avec quelques non-linéarités) - nous ne modifions pas (rétropropagation dans) le modèle linguistique d'ADN original.\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mAxz08WTOeTb"
      },
      "outputs": [],
      "source": [
        "class Model(nn.Module):\n",
        "  dim: int = 128\n",
        "\n",
        "  @nn.compact\n",
        "  def __call__(self, x):\n",
        "    x = nn.Dense(self.dim * 2)(x)\n",
        "    x = nn.gelu(x)\n",
        "    x = nn.Dense(self.dim)(x)\n",
        "    x = nn.gelu(x)\n",
        "    x = nn.Dense(1)(x)\n",
        "    return x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pPrdkSM-c2VT"
      },
      "outputs": [],
      "source": [
        "mlp = Model()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kve15vj32elg"
      },
      "source": [
        "### Boucle d'entraînement (Training loop)\n",
        "\n",
        "Avec le modèle et les données mis en place, nous pouvons maintenant initialiser les paramètres de notre modèle, notre optimiseur, et écrire une fonction pour effectuer une seule étape d'entraînement (qui englobe une passe avant du modèle (model forward pass), un calcul de la perte (loss computation), un calcul du gradient (gradient computation) et une mise à jour des paramètres du modèle à l'aide des gradients) :\n",
        "    \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wzvdOVyRPaF7"
      },
      "outputs": [],
      "source": [
        "LEARNING_RATE = 0.0001\n",
        "\n",
        "init_rng = jax.random.PRNGKey(42)\n",
        "variables = mlp.init(init_rng, batch['embeddings']) # batch: lot\n",
        "params = variables['params']\n",
        "\n",
        "optimiser = optax.adam(LEARNING_RATE)\n",
        "opt_state = optimiser.init(params)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2CQe4CHuvmPx"
      },
      "source": [
        "Vous pouvez vérifier les noms des couches dans notre réseau de neurones comme ceci :\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "B3EbmNT5vhXX"
      },
      "outputs": [],
      "source": [
        "params.keys()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wgOUFfqRvpTw"
      },
      "source": [
        "Et vérifiez que la forme de cette couche correspond à ce que vous attendez comme ceci :\n",
        "    \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rZaFLwwAvtO8"
      },
      "outputs": [],
      "source": [
        "for layer_name in ['Dense_0', 'Dense_1', 'Dense_2']:\n",
        "      print(params[layer_name]['kernel'].shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KQVRPJ76v_nA"
      },
      "source": [
        "**Question** : Pouvez-vous déterminer d'où proviennent ces formes, étant donné notre code dans notre `class Model` ci-dessus ?\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rSfHeH5zyqBd"
      },
      "source": [
        "Nous pourrions déjà faire des prédictions en utilisant ces paramètres initialisés aléatoirement (seulement, les prédictions seront aléatoires) :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vpzUpbHdyYwY"
      },
      "outputs": [],
      "source": [
        "preds = mlp.apply({'params': params}, batch['embeddings'])\n",
        "nn.sigmoid(preds)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nvRto9Nky_40"
      },
      "source": [
        "Définissons maintenant une fonction de perte que nous pouvons utiliser pour entraîner ces paramètres :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qgM5xJW6x8Hm"
      },
      "outputs": [],
      "source": [
        "def loss_fn(params, embeddings, labels):\n",
        "  \"\"\"Applique la fonction sigmoïde aux logits et calcule la perte d'entropie croisée binaire (binary cross-entropy loss).\"\"\"\n",
        "  logits = mlp.apply({'params': params}, embeddings)\n",
        "  loss = optax.sigmoid_binary_cross_entropy(\n",
        "      logits=logits, labels=labels).mean()\n",
        "  return loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOkY0h3C0LuR"
      },
      "source": [
        "Calculons un exemple de perte :\n",
        "     \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "uqkzxWnxyRA2"
      },
      "outputs": [],
      "source": [
        "embeddings = jnp.array(batch['embeddings'])\n",
        "labels = jnp.array(batch['labels']) # (labels: étiquettes)\n",
        "loss_fn(params, embeddings, labels)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nro6FSdK_6Ji"
      },
      "source": [
        "Donc, nous nous attendons à une perte autour de 0.6-0.7 pour des poids initialisés aléatoirement. Avec un peu de chance, avec l'entraînement du modèle, nous devrions voir des pertes plus faibles que cela à mesure que le modèle apprend le signal dans les données ! :)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e7LRUb1l0N2F"
      },
      "source": [
        "Finalement, nous pouvons écrire une fonction étape d'entraînement :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "jJ4PNA1pvZRI"
      },
      "outputs": [],
      "source": [
        "@jax.jit\n",
        "def train_step(params, opt_state, embeddings, labels):\n",
        "  \"\"\"Une seule étape d'entraînement qui calcule les gradients et met à jour les paramètres du modèle.\"\"\"\n",
        "  loss, grads = jax.value_and_grad(loss_fn)(params, embeddings, labels)\n",
        "  updates, opt_state = optimiser.update(grads, opt_state)\n",
        "  params = optax.apply_updates(params, updates)\n",
        "  return params, opt_state, loss"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "47VtoXKw403F"
      },
      "source": [
        "### Entraînons le modèle !\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6rljY6Nx_Oar"
      },
      "outputs": [],
      "source": [
        "NUM_EPOCHS = 5\n",
        "NUM_TRAINING_STEPS = (len(train_df) // BATCH_SIZE) * NUM_EPOCHS\n",
        "LEARNING_RATE = 0.001\n",
        "\n",
        "# Réinitialise le modèle pour s'assurer qu'il démarre à zéro à chaque fois que la cellule est exécutée.\n",
        "init_rng = jax.random.PRNGKey(42)\n",
        "variables = mlp.init(init_rng, batch['embeddings'])\n",
        "params = variables['params']\n",
        "\n",
        "optimiser = optax.adam(LEARNING_RATE)\n",
        "opt_state = optimiser.init(params)\n",
        "\n",
        "# Conserve un enregistrement des pertes.\n",
        "running_train_loss = None\n",
        "running_train_losses = []\n",
        "valid_losses = []\n",
        "\n",
        "for epoch in tqdm.tqdm(range(NUM_EPOCHS)):\n",
        "\n",
        "  # Boucle d'entraînement.\n",
        "  for step in range(NUM_TRAINING_STEPS):\n",
        "    batch = next(train_ds)\n",
        "    embeddings = jnp.array(batch['embeddings'])\n",
        "    labels = jnp.array(batch['labels'])\n",
        "    params, opt_state, loss = train_step(params, opt_state, embeddings, labels)\n",
        "\n",
        "    if running_train_loss is None:\n",
        "      running_train_loss = loss.item()\n",
        "    else:\n",
        "      running_train_loss = 0.99 * running_train_loss + (1 - 0.99) * loss.item()\n",
        "    running_train_losses.append(running_train_loss)\n",
        "\n",
        "  # Boucle de validation.\n",
        "  valid_ds = convert_to_tfds(valid_df, batch_size=BATCH_SIZE, is_training=False)\n",
        "  for batch in valid_ds:\n",
        "    embeddings = jnp.array(batch['embeddings'])\n",
        "    labels = jnp.array(batch['labels'])\n",
        "    loss = loss_fn(params, embeddings, labels)\n",
        "    valid_losses.append(loss.item())\n",
        "\n",
        "  valid_loss = np.mean(valid_losses)\n",
        "  print(f'[Epoch {epoch}]: Valid loss (Perte de validation)={valid_loss:.3f}, '\n",
        "        f'Train loss (Perte d\\'entraînement)={running_train_loss:.3f}\\n')\n",
        "\n",
        "print('Entraînement terminé.')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vNxoqkSbGvtr"
      },
      "source": [
        "🎉 🎉 **Et voilà, l'entraînement de base du modèle est terminé !** 🎉 🎉\n",
        "    \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8qQ4NafPHCsL"
      },
      "source": [
        "## Vérification du modèle\n",
        "\n",
        "Nous pouvons essayer d'inférer le modèle entraîné sur n'importe quelle nouvelle séquence d'ADN d'intérêt. Par exemple, comme nous savons grâce à des expériences biologiques que la protéine CTCF se lie aux séquences d'ADN contenant des motifs similaires à « CCACCAGGGGGCGC », le modèle devrait prédire une probabilité très élevée de liaison pour l'ADN contenant ces motifs.\n",
        "\n",
        "Construisons la chaîne d'ADN de 200 bases et récupérons son incorporation :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "knsDFhP5HCx7"
      },
      "outputs": [],
      "source": [
        "ctcf_motif_dna = 'CCACCAGGGGGCGC'*14 + 'AAAA'\n",
        "print('Longueur de la chaîne d\\'ADN remplie de motifs CTCF :', len(ctcf_motif_dna))\n",
        "\n",
        "# (ctcf_motif_dna, ctcf_motif_embedding) -> (séquence_adn_motif_ctcf, incorporation_motif_ctcf)\n",
        "ctcf_motif_embedding = compute_mean_sequence_embeddings(\n",
        "    [ctcf_motif_dna], tokenizer, language_model)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dM_yTcpcILFm"
      },
      "source": [
        "Nous pouvons maintenant calculer la probabilité que l'ADN se lie au CTCF :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9L7HI9d_HdkY"
      },
      "outputs": [],
      "source": [
        "jax.nn.sigmoid(mlp.apply({'params': params}, ctcf_motif_embedding))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vf3cVUYtIO4D"
      },
      "source": [
        "Succès ! Cette probabilité est très proche de 1. Cela signifie que le modèle a appris à identifier une représentation de ce motif et à l'associer à la liaison de CTCF à l'ADN.\n",
        "\n",
        "Inversement, les chaînes d'ADN aléatoires devraient avoir une faible probabilité de liaison avec CTCF :\n",
        "    \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lgadMGYYGs5E"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "random_dna_strings = [\n",
        "    'ACGTACGT'*25,\n",
        "    'CGGCCGCG'*25,\n",
        "    'TCGATCGT'*25,\n",
        "    'TTTTTTTT'*25,\n",
        "]\n",
        "\n",
        "probabilities = []\n",
        "\n",
        "# (random_dna_string:chaîne d'ADN aléatoire)\n",
        "for random_dna_string in random_dna_strings:\n",
        "  # (random_dna_embedding:plongement d'ADN aléatoire)\n",
        "  random_dna_embedding = compute_mean_sequence_embeddings(\n",
        "    [random_dna_string], tokenizer, language_model)\n",
        "\n",
        "  probabilities.append(\n",
        "      jax.nn.sigmoid(mlp.apply({'params': params}, random_dna_embedding))[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "f6nL2PwKWhZG"
      },
      "outputs": [],
      "source": [
        "probabilities"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m5euD1_nI2RL"
      },
      "source": [
        "Génial, celles-ci ressemblent toutes à des probabilités proches de zéro, ce à quoi nous nous attendions 😎.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "17otXl0aGzyx"
      },
      "source": [
        "## [Suivis Facultatifs]\n",
        "    \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gHSPk0yVG5w8"
      },
      "source": [
        "\n",
        "1. **[Tracé des pertes]** Essayez de tracer la perte d'entraînement et la perte de validation au fil du temps. Qu'observez-vous ? Devrions-nous l'entraîner plus longtemps ? Y a-t-il un surajustement à l'ensemble d'entraînement ? Si oui, comment pourriez-vous améliorer la situation ?\n",
        " - **Indice** : essayez `plt.plot(train_losses, c='grey')`.\n",
        "2. **[Métriques d'évaluation]** Jusqu'à présent, nous n'avons surveillé que les pertes pendant l'entraînement du modèle, mais celles-ci sont un peu difficiles à interpréter. Comment pourriez-vous implémenter et suivre une mesure de **précision** pendant l'entraînement ?\n",
        " - **Indice** : N'oubliez pas que si vous utilisez `jax.nn.sigmoid` sur les prédictions du modèle, cela donne la probabilité que la séquence d'ADN se lie à la protéine CTCF. Vous pouvez traiter toute probabilité supérieure à 0,5 comme une prédiction de '1', et toute probabilité inférieure à 0,5 comme une prédiction de '0'.\n",
        "3. **[Réglage des hyperparamètres]** Essayez de faire varier le taux d'apprentissage, la taille du lot (batch size) et le nombre d'étapes d'entraînement. Comment ces changements affectent-ils la convergence et la performance finale du modèle ?\n",
        "4. **[Augmentation des données]** Pouvez-vous penser à un moyen d'élargir (ou d'augmenter) l'ensemble d'entraînement ? Comment mesureriez-vous si cela est utile pour la performance du modèle ?\n",
        "5. **[Architectures différentes]** Expérimentez avec différentes architectures de modèle, comme l'ajout de couches supplémentaires ou l'utilisation de différentes fonctions d'activation.\n",
        " - **Défi** : si vous vous sentez très aventureux, essayez d'implémenter un CNN capable d'apprendre directement à partir de séquences d'ADN (codées en one-hot) !\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Commentaires\n",
        "\n",
        "N'hésitez pas à nous faire part de vos commentaires afin que nous puissions améliorer nos ateliers pratiques à l'avenir.\n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# @title Générer un formulaire de commentaires (Exécuter la cellule)\n",
        "from IPython.display import HTML\n",
        "\n",
        "HTML(\n",
        "    \"\"\"\n",
        "<iframe\n",
        "\tsrc=\"https://forms.gle/WUpRupqfhFtbLXtN6\",\n",
        "  width=\"80%\"\n",
        "\theight=\"1200px\" >\n",
        "\tLoading...\n",
        "</iframe>\n",
        "\"\"\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "<img src=\"https://baobab.deeplearningindaba.com/static/media/indaba-logo-dark.d5a6196d.png\" width=\"50%\" />"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}