> For the complete documentation index, see [llms.txt](https://medomicslab.gitbook.io/medomics-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://medomicslab.gitbook.io/medomics-docs/v1-fr/tutorials/development/learning-module.md). # Module d'apprentissage C'est ici que la magie opère 🧙🪄 {% hint style="warning" %} Si c'est la première fois que vous lisez la documentation du Module d'Apprentissage, nous vous suggérons de commencer par le [#overview-videos](#overview-videos "mention"). {% endhint %} {% hint style="info" %} Le Module d'Apprentissage est construit en utilisant la bibliothèque Python open-source [*PyCaret*](https://pycaret.gitbook.io/docs/). Vous pouvez trouver des informations utiles sur [*PyCaret*](https://pycaret.gitbook.io/docs/) aux liens suivants : * [*PyCaret* Gitbook](https://pycaret.gitbook.io/docs/) * [*PyCaret* ReadTheDocs](https://pycaret.readthedocs.io/en/stable/) * [*PyCaret* GitHub](https://github.com/pycaret/pycaret) {% endhint %} ## L'architecture du Module d'Apprentissage {% hint style="info" %} Disponible à partir de la v1.6.0 {% endhint %} Le Module d'Apprentissage a été repensé avec une architecture mise à jour qui respecte les pratiques de l'apprentissage automatique, introduisant une séparation externe des données d'entraînement/de test pour prendre en charge l'entraînement de modèles en plusieurs itérations. Cette approche améliorée fournit une estimation des performances plus fiable tout en surmontant spécifiquement les limitations de PyCaret en matière de séparation de données externes. Le schéma suivant présente la nouvelle architecture :

Le nouveau flux de travail du Module d'Apprentissage

#### Renforcement de l'entraînement et de la validation externes Le flux de travail mis à jour introduit un partitionnement flexible des jeux de données via plusieurs méthodes de validation (validation croisée, bootstrap, etc.), résolvant la limitation de PyCaret dans la gestion de la séparation des données externes. Pour plus de clarté : * **Les séparations externes** divisent l'ensemble d'apprentissage en données d'entraînement/de test * **Les séparations internes** partitionnent davantage les données d'entraînement pour l'optimisation des hyperparamètres La figure ci-dessous illustre ce cadre de validation amélioré.

Illustration des séparations externes et internes

## Qu'est-ce qui repose sur PyCaret, et qu'est-ce qui ne l'utilise pas ? {% hint style="info" %} Se référer à [cette section](#understand-pycarets-role-within-the-learning-module) pour plus de détails sur le rôle de PyCaret dans le Module d'Apprentissage. {% endhint %} Le Module d'Apprentissage est construit sur [le framework ](https://pycaret.gitbook.io/docs/)open-source de machine learning de PyCaret, amélioré par des composants codés sur mesure pour permettre de nouvelles fonctionnalités, telles que la séparation des données externes — une capacité non prise en charge dans PyCaret. La figure ci-dessous met en évidence quels éléments tirent parti des fonctionnalités standard de PyCaret versus nos extensions personnalisées, vous donnant une meilleure compréhension de l'architecture.

Sections codées sur mesure et basées sur PyCaret du flux de travail ML

## Un nouveau design est arrivé Le Module d'Apprentissage présente une nouvelle interface repensée alignée avec la nouvelle architecture, qui offre aux utilisateurs une manière rationalisée de [créer leurs scènes](#how-to-create-a-scene) et expériences. L'interface mise à jour est organisée en trois encadrés : * **Initialisation** : Les utilisateurs commencent par sélectionner leurs ressources d'apprentissage automatique et configurer les paramètres clés de l'expérience, y compris la sélection du jeu de données, les étapes de prétraitement des données, les choix de modèles, et plus encore. * **Entraînement** : Cette section permet aux utilisateurs de définir et gérer le processus d'entraînement du modèle, englobant des aspects tels que l'optimisation des hyperparamètres, les stratégies d'optimisation, et des fonctionnalités supplémentaires. * **Analyse** : À l'étape finale, les utilisateurs peuvent visualiser et interpréter les performances de leur modèle à travers une variété de graphiques et de métriques de résultats.

Le Module d'Apprentissage : avant et après

## Un nouveau système de code couleur La conception intuitive basée sur des encadrés simplifie la création de pipelines en guidant visuellement les utilisateurs à travers chaque étape. Un système de code couleur fonctionne parallèlement aux encadrés pour prévenir les erreurs. Par exemple, comme illustré ci-dessous, si vous essayez par erreur de glisser un nœud Train Model dans l'encadré Initialisation, à la fois le nœud et l'encadré deviendront rouges, vous alertant immédiatement de l'incompatibilité. Chaque encadré n'accepte que des types de nœuds compatibles, assurant des connexions logiques et réduisant les erreurs de configuration.

Message d'erreur lors de l'exécution de l'expérience

En modes Résultats ou Analyse, un codage couleur différent est utilisé ; lisez-en davantage à ce sujet [ici](/medomics-docs/v1-fr/tutorials/development/learning-module/analyse.md#highlighting-feature). ## Une nouvelle scène pour expérimenter Le module d'apprentissage inclut une nouvelle [**Scène Expérimentale**](/medomics-docs/v1-fr/tutorials/development/learning-module/scene-experimentale.md), une scène minimaliste conçue pour tester des configurations d'apprentissage automatique (modèles, paramètres, etc.) avant de les finaliser dans la scène principale de production. Comme montré dans la figure ci-dessous, le design minimaliste de la Scène Expérimentale concentre l'attention sur les éléments essentiels de l'apprentissage automatique, avec tous les types de nœuds requis disponibles. La scène sert de terrain d'essai où les utilisateurs peuvent affiner leurs pipelines avant de passer à la scène principale.

## A **Structure de pipeline redéfinie** Dans la conception précédente, un pipeline était défini comme toute séquence de nœuds connectés. L'architecture mise à jour définit désormais un pipeline comme une **séquence complète de nœuds qui commence par un nœud initial et se termine à la Boîte d'Analyse**. Ce changement crucial signifie que toute chaîne de nœuds déconnectée ou tout flux de travail incomplet ne sera pas reconnu comme un pipeline valide pour l'exécution ou l'analyse. En imposant cette connexion complète, la plateforme garantit que les utilisateurs respectent les bonnes pratiques de l'apprentissage automatique et que chaque pipeline sera analysé. La figure ci‑dessous illustre un exemple de pipelines valides et invalides selon cette nouvelle définition.

Exemple de pipelines valides et invalides

## Vidéos de présentation {% embed url="" %} Module d'apprentissage - Création de scène {% endembed %} {% embed url="" %} Module d'apprentissage - Comprendre les pipelines et les résultats {% endembed %} *** ## Comment créer une scène {% stepper %} {% step %} ### Cliquez sur l'icône du module d'apprentissage. Dans la barre latérale gauche, cliquez sur l'icône suivante :

{% endstep %} {% step %} ### Cliquez sur le bouton « Créer une scène » Le bouton peut se trouver en haut du panneau latéral. {% endstep %} {% step %} ### Saisissez un nom pour la nouvelle scène Tapez le nom de votre scène dans le champ «*Entrer le nom de la page*": ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2FQmgBoXoNbMEy9vcqRwfq%2Fimage.png?alt=media\&token=6dcf3f24-7978-4829-b0bc-38a405787ea9) {% endstep %} {% step %} ### Sélectionnez s'il s'agit d'une scène expérimentale ou non Si vous souhaitez créer une scène expérimentale, assurez‑vous que l'interrupteur suivant est activé : ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2FPCUh9dxligNiU8jCJHm3%2Fimage.png?alt=media\&token=bc8471d6-f991-4f69-948a-9fcc2ec44188) {% endstep %} {% step %} ### Cliquez **Créer**. {% endstep %} {% endstepper %} Ces étapes sont résumées dans la figure ci‑dessous. Une fois votre scène créée, un dossier sera généré qui inclut les éléments suivants : * Votre scène (.*medml* fichier) : ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2F6YKgNMg4mAZZzipBph51%2Fimage.png?alt=media\&token=3b897366-95e2-4aff-b6b7-4e6d298d300d) * Un dossier pour les modèles de votre scène : ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2FKrT81ZYqBlXaKYn5krOW%2Fimage.png?alt=media\&token=fc8d084c-6067-45ab-a1a6-1a38cb8f0fa0) * Un dossier pour les notebooks de votre scène : ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2FcyR5ObpgbeYtpOZBifHQ%2Fimage.png?alt=media\&token=ee0dfba8-b218-4e19-b081-5bcaf0a7c3da)

Le dossier de votre scène dans l'espace de travail de l'application

*** ## Aperçu du module {% hint style="info" %} Double‑cliquez sur le .*medml* fichier pour ouvrir la scène. {% endhint %} Les sections suivantes fournissent un aperçu complet de la scène et de ses composants fondamentaux. Chaque élément numéroté dans la figure principale de la scène correspond à une explication détaillée dans les sous‑sections suivantes. #### Scène principale

*** ### 1. Répartition du dossier de la scène Chaque dossier de scène est organisé comme suit : {% hint style="info" %}

breast_cancer_analysis             -> Dossier de la scène
    ├───models                     -> Dossier où les modèles sont enregistrés
    ├───notebooks                  -> Dossier où les notebooks sont enregistrés
    └───breast_cancer_scene.medml  -> Fichier de la scène

{% endhint %} ### 2. Nœuds disponibles

{% hint style="info" %} Le *Ajouter des options* le bouton ouvre un panneau où vous pouvez sélectionner des options supplémentaires. Ces options sont récupérées depuis la [documentation ReadTheDocs de *PyCaret*](https://pycaret.readthedocs.io/en/stable/). {% endhint %} {% hint style="warning" %} Les liens utilisés pour expliquer le *spécifique à PyCaret* fonctions se réfèrent au [Section Classification de la *PyCaret* documentation](https://pycaret.readthedocs.io/en/latest/api/classification.html). Cependant, ces fonctions sont également présentes dans d'autres types d'apprentissage automatique au sein de *PyCaret*. Par exemple, vous pouvez les trouver dans la [documentation Régression de *PyCaret*](https://pycaret.readthedocs.io/en/latest/api/regression.html) également. {% endhint %} #### Tableau récapitulatif des nœuds disponibles :

Description	Boîte désignée	Entrée	Sortie
Ceci agit comme le point de départ pour toutes les expériences et détermine les données que votre pipeline utilisera. Les options disponibles pour ce nœud correspondent aux PyCaret `setup()` fonction options qui ne sont pas directement liées au nettoyage des données.	Initialisation	-	Jeu de données
Ce nœud vous permet de nettoyer et d'améliorer la qualité de votre jeu de données. Les options disponibles pour ce nœud correspondent aux PyCaret `setup()` options de fonction qui sont directement liées au nettoyage des données.	Initialisation	Jeu de données	Jeu de données
Ce nœud codé sur mesure unique (distinct des fonctions standard de PyCaret) vous donne un contrôle précis sur la façon dont votre jeu de données est divisé pour l'entraînement et l'évaluation. Il sert de fondation pour une validation fiable des modèles en garantissant une séparation appropriée des données.	Initialisation	Jeu de données	Jeu de données
Ce nœud vous permet de sélectionner un algorithme d'apprentissage automatique depuis la bibliothèque de modèles de PyCaret et de définir ses paramètres associés. Il correspond au paramètre estimator de la PyCaret `create_model()` fonction.	Initialisation	-	Configuration_modèle
Ce nœud vous permet d'entraîner un modèle en utilisant l'algorithme ML sélectionné. Les options disponibles pour ce nœud correspondent aux PyCaret `create_model()` options de fonction (à l'exception du paramètre estimator , qui est défini via le nœud Modèle).	Entraînement	Configuration_modèle + Jeu de données	Modèle
Ce nœud vous permet de combiner plusieurs modèles en utilisant différentes techniques. Il est basé sur PyCaretle `blend_models()` et `stack_mdoels()` fonctions.	Entraînement	Modèle	Modèle
Ce nœud vous permet d'entraîner et d'évaluer les performances de tous les estimateurs disponibles dans la PyCaret bibliothèque de modèles en utilisant la validation croisée. Les options disponibles pour ce nœud correspondent à la PyCaret `compare_models()` options de fonction.	Entraînement	Jeu de données	Modèle(s)
Ce nœud vous permet de charger un modèle depuis un fichier. Il prend en entrée un modèle parmi ceux que vous avez enregistrés dans votre scène, affichés dans un sélecteur déroulant. Les options disponibles pour ce nœud sont celles disponibles dans la PyCaret `load_model()` fonction, à l'exception du nom du modèle, qui est remplacé par le fichier sélectionné.	Entraînement	Jeu de données	Modèle
Cette boîte vous permet d'analyser un modèle. Elle rassemble les fonctions d'analyse et d'explicabilité des modèles de PyCaret. Pour l'instant, seule la `plot_model()` fonction est utilisée dans le module d'apprentissage.	-	Modèle	-

### 3. Mode d'analyse Le bouton Mode d'analyse, appelé Voir les résultats dans les scènes expérimentales, est utilisé pour afficher les résultats de l'expérience. Il est désactivé tant que vous n'exécutez pas une expérience. Après une exécution réussie, un .*medmlres* fichier est créé dans le dossier de votre scène, contenant les résultats générés de l'expérience. Si vous quittez l'application, vos résultats générés seront toujours disponibles la prochaine fois que vous ouvrirez l'application. {% hint style="info" %} Reportez-vous à la [page d'analyse](/medomics-docs/v1-fr/tutorials/development/learning-module/analyse.md) pour plus de détails. {% endhint %} ### 4. Menu Utils Ce menu contient différentes fonctionnalités qui peuvent être utilisées pour vous aider à construire votre scène. | Élément | Description | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Liste déroulante du type d'apprentissage automatique

| Cette liste déroulante vous permet de sélectionner le type d'apprentissage automatique que vous souhaitez pour votre expérience. Lors du changement de type, tous les paramètres sont réinitialisés. | |

Lecture

| Ce bouton vous permet d'exécuter l'expérience. Vous pouvez trouver des informations supplémentaires sur l'exécution de l'expérience [ici](#id-2.-run-the-experiment). | |

Corbeille

| Ce bouton vous permet de supprimer tous les nœuds de la scène. | |

Enregistrer

| Ce bouton vous permet d'enregistrer la scène. | |

Charger

| Ce bouton vous permet de charger une scène à partir d'un fichier. | ### 5. Minicarte Cette minicarte vous permet de naviguer dans la scène et de visualiser les nœuds présents. ### 6. Outils de flux Ce menu contient diverses fonctionnalités qui interagissent avec la section de flux. | Élément | Description | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | |

Bouton Plus

| Ce bouton vous permet de zoomer dans la section de flux. | |

Bouton Moins

| Ce bouton vous permet de dézoomer la section de flux. | |

Bouton Carré

| Ce bouton vous permet d'ajuster la section de flux à la vue. | |

Bouton Verrou

| Ce bouton vous permet de verrouiller la section de flux. Lorsqu'elle est verrouillée, vous ne pouvez pas déplacer la section de flux. | |

Bouton Carte

| Ce bouton vous permet d'afficher/masquer la minicarte. | ### 7. Boîtes de scène Dans la scène principale, ces boîtes font partie du nouveau design, aidant à guider l'utilisateur lors de la création de sa scène et réduisant les erreurs lors du glisser-déposer des nœuds. En savoir plus sur ces boîtes dans les sections suivantes de la documentation. ***

Comprendre le rôle de PyCaret au sein du module d'apprentissage

PyCaret implémente principalement des fonctions de la [*scikit-learn* bibliothèque](https://scikit-learn.org/stable/). ## 1. Initialisation Au début d'un pipeline d'apprentissage automatique, vous initialisez vos données en utilisant [*PyCaret*la fonction setup de](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.setup), correspondant aux nœuds Dataset et Clean dans notre *Module d'apprentissage*. La fonction setup nécessite un jeu de données et le nom de la colonne cible. *PyCaret* puis initialise des éléments pour le pipeline.
![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2FFWLxlXqc7oPh4XJJfCvJ%2Fpycaret_workflow.png?alt=media\&token=d8e638b9-c8ea-47a0-96d2-fe62d2220754) ### 1.1. Données de test *PyCaret* divise votre jeu de données en deux parties : l'ensemble d'entraînement et l'ensemble de test (contrôlé par le `test_data` paramètre dans le [*PyCaret* fonction setup](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.setup)). Les données d'entraînement sont utilisées pour entraîner et optimiser votre modèle d'apprentissage automatique, tandis que les données de test sont réservées à l'évaluation du modèle créé. La séparation est effectuée en utilisant la [*scikit-learn* fonction train\_test\_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) (des explications utiles sur cette fonction peuvent être trouvées [ici](https://github.com/mGalarnyk/Python_Tutorials/blob/master/Sklearn/Train_Test_Split/TrainTestSplitScikitLearn.ipynb)). ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2Ft5ullGBmc9T6pMaCAx2M%2Fspaces_kkOWBZQGwLyBFteUhl1l_uploads_yJt58khhA0hG9CaObJk1_image.webp?alt=media\&token=4bd527a0-8196-4004-96f1-6e6a8cd7af6d) \*Dans la figure, « Ensemble de données complet » fait référence à notre ensemble d'apprentissage. L'étape d'échantillonnage aléatoire est exécutée à l'aide d'une graine aléatoire, et chaque séparation est liée à une graine spécifique. Par défaut, *PyCaret* assigne aléatoirement une graine au début de chaque exécution du pipeline. Pour garantir la reproduction de la même expérience avec une séparation cohérente, vous pouvez définir ce paramètre dans *PyCaret* (en utilisant le `paramètre session_id` dans le nœud Dataset), comme démontré dans nos expériences dans la vidéo d'instruction. Cela garantit que vos données de test et d'entraînement resteront cohérentes entre toutes les exécutions. ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2FXdc5JJubBjwTWDgE0rvp%2Fspaces_kkOWBZQGwLyBFteUhl1l_uploads_7bOPzY5zTlFtL52YewGP_image.webp?alt=media\&token=abf4597a-f30b-4eab-b811-38cb57bb50cf) Ici, vous avez également la possibilité de définir vous-même les données de test et de les fournir à *PyCaret*. Cependant, cette fonctionnalité n'est pas actuellement disponible dans notre application lors de l'utilisation du format MEDomicsLab Standard. ### 1.2. Folds Ensuite *PyCaret* définira des folds sur les données d'entraînement à utiliser pour la partie Validation Croisée (qui sera exécutée en utilisant la boîte Train ou Compare Models). La définition des folds sera également effectuée à l'aide d'une graine aléatoire, que vous pouvez définir via le `paramètre session_id` paramètre de *PyCaret*. Par défaut, *PyCaret* utilise le [*StratifiedKFold* méthode de *scikit-learn*](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedKFold.html) pour définir les folds. La méthode stratifiée garantit que chaque classe de la cible est représentée de manière égale dans chaque fold. ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2Fl1HcOXbELIFBSlcr3vSK%2Fstratified_cv.png?alt=media\&token=77410015-3dc5-440a-8da9-7aa775dbe528) ## 2. Entraînement Il y a deux fonctions liées à l'entraînement dans *PyCaret*: [*compare\_models*](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.compare_models) (correspondant à notre boîte Compare Models) et [*create\_model*](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.create_model) (correspondant à notre nœud Train). ### 2.1. Compare Models Le [*compare\_models* ](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.compare_models)la fonction est utilisée pour entraîner tous les modèles disponibles de *PyCaret* sur les données initialisées par la fonction setup de *PyCaret* (nos nœuds Dataset et Clean). Le tableau résultant affiché vous montre la moyenne des résultats de la Validation Croisée de tous les folds pour chaque modèle. Par exemple, si nous avons cinq folds, pour chaque modèle, nous entraînons le modèle cinq fois, en utilisant un fold différent comme données de validation à chaque itération. Ensuite, nous appliquons le modèle entraîné au fold de validation et conservons les métriques résultantes pour calculer la moyenne avec les résultats de validation des quatre autres itérations (données violettes de la séparation dans l'image ci-dessous). ![](https://2361277526-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FUO0RN9PzFLqAgLEwwaSn%2Fuploads%2F18ZikTNCwuP3rk0bdu0G%2Fpycaret_cv.png?alt=media\&token=da0490db-7b96-41ee-a35a-0ea16c285fdc) La sortie de la [*fonction compare\_model* ](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.compare_models)est le meilleur modèle trouvé en utilisant une métrique spécifiée (Accuracy par défaut, AUC comme nous l'avons spécifié dans notre vidéo d'instruction). Si nous définissons le `paramètre n_select` (comme montré dans notre vidéo d'instruction), nous retournons le nombre spécifié de modèles en tête de la liste. ### 2.2. Create Model Le [*create\_model* ](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.create_model)la fonction prend des données initialisées en entrée et un modèle (que vous pouvez définir via notre nœud Model). Elle fonctionne exactement de la même manière que la [*compare\_models* ](https://pycaret.readthedocs.io/en/stable/api/classification.html#pycaret.classification.compare_models)fonction, sauf que nous ne testons qu'un seul modèle, et le tableau des résultats montre les résultats de la Validation Croisée de chaque fold. ## 3. Analyse Les analyses effectuées à l'aide de notre nœud Analyze affichent les métriques résultant de nos modèles entraînés sur les données de test définies lors de l'initialisation de l'expérience. ## 4. Finaliser Le *fonction finalize* dans *PyCaret* (représentée par le nœud Finalize dans notre application) entraîne le modèle une dernière fois sur l'ensemble du jeu de données, qui inclut à la fois les données d'entraînement et les données de test, sans modifier ses paramètres.

--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://medomicslab.gitbook.io/medomics-docs/v1-fr/tutorials/development/learning-module.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.