Pour cette première partie de notre série d'articles, nous allons nous baser sur ce tutoriel afin de mettre en œuvre un processus de RAG. Mais qu'est-ce qu'un RAG ? Le RAG, ou "Retrieval-Augmented Generation", est une technique avancée en intelligence artificielle, spécifiquement dans le domaine du traitement du langage naturel (NLP), qui consiste à enrichir le processus de génération de texte en intégrant une phase de récupération d'informations. Cette méthode hybride allie la puissance des modèles de langage basés sur le deep learning à l'efficacité des systèmes de récupération d'informations pour produire des réponses plus précises et contextuellement pertinentes.

À travers cet article, nous explorerons comment les RAGs transforment l'approche traditionnelle de la génération de langage en intégrant des éléments dynamiques de recherche d'informations. Nous examinerons les composantes clés de cette technologie, notamment comment le modèle identifie et extrait des informations pertinentes à partir d'une vaste base de données ou d'un corpus de texte avant d'entamer le processus de génération de réponse. Cela permet au modèle de se baser non seulement sur son apprentissage interne mais aussi sur des données externes spécifiques, ce qui est particulièrement bénéfique pour des questions nécessitant des connaissances actualisées ou spécialisées.

En outre, nous discuterons des défis et des opportunités associés à l'implémentation des RAGs, en soulignant leur potentiel dans divers domaines d'application, de l'assistance virtuelle aux systèmes de recommandation personnalisés. Enfin, nous illustrerons comment mettre en place un système RAG en utilisant des technologies et des outils de pointe, en fournissant un guide étape par étape basé sur le tutoriel de la documentation officielle de l'outil Txtai. Que vous soyez un développeur expérimenté en PHP et en data science ou simplement curieux de découvrir les dernières avancées en IA, cet article vise à fournir une compréhension approfondie de la technologie RAG et de son impact sur le futur du traitement du langage naturel.

Les Composantes Clés d'un Système RAG

Les RAGs, par leur nature hybride, intègrent deux composants essentiels : le système de récupération d'informations (Information Retrieval, IR) et le modèle de génération de langage (Language Generation Model).

Système de Récupération d'Informations : La première étape d'un RAG est de chercher et de récupérer des informations pertinentes en réponse à une requête. Cette phase utilise des techniques de recherche avancées pour parcourir rapidement de vastes ensembles de données, sélectionnant des extraits de texte qui sont les plus susceptibles d'être pertinents pour la question posée.

Modèle de Génération de Langage : Une fois les informations pertinentes récupérées, elles sont transmises à un modèle de génération de langage. Ce modèle, souvent basé sur des architectures de réseaux neuronaux comme les Transformers, utilise ces informations pour construire une réponse cohérente et contextuellement appropriée.

Défis et opportunités

Les RAGs présentent plusieurs défis techniques et pratiques. Par exemple, l'exactitude de la récupération d'informations est cruciale ; une récupération inexacte peut conduire à des réponses erronées. De plus, l'équilibre entre la vitesse de traitement et la précision est une considération importante, en particulier pour les applications en temps réel.

Cependant, les opportunités offertes par les RAGs sont considérables. Dans le domaine de l'assistance client, par exemple, les RAGs peuvent fournir des réponses plus précises et personnalisées que les systèmes traditionnels de génération de langage. Dans la recherche scientifique, ils peuvent aider à formuler des réponses basées sur les dernières publications et découvertes.

Mise en Œuvre Pratique d'un RAG

Pour implémenter un RAG, plusieurs étapes sont nécessaires :

**Choix des Technologies ** : Les modèles de Transformers tels que BERT ou GPT peuvent être utilisés pour le modèle de génération, tandis que des systèmes comme Elasticsearch peuvent être utilisés pour la récupération d'informations. Ici, nous utiliserons MistralAI et le système interne de txtai. Nous verrons ensuite comment intégrer les index directement dans une base de données PostgreSQL.

Préparation des Données : Préparez un corpus de données large et diversifié pour la phase de récupération. Ce corpus doit être représentatif des types de requêtes attendues. Pour cela, nous allons récupérer les pages de contenu de ce même blog.

Entraînement et Fine-tuning :

Entraînez votre modèle de génération de langage en utilisant à la fois le corpus de données et les informations récupérées. Il peut être nécessaire de procéder à un ajustement fin (fine-tuning) pour adapter le modèle à des cas d'utilisation spécifiques.

Intégration et Tests : Intégrez le système RAG dans votre application ou service et réalisez des tests approfondis pour évaluer sa performance et son exactitude.

Conclusion

Le "Retrieval-Augmented Generation" est une avancée passionnante en IA, ouvrant de nouvelles voies pour des applications de traitement du langage naturel plus sophistiquées et précises. Bien qu'il présente des défis, son potentiel dans divers domaines le rend inestimable pour les entreprises et les développeurs cherchant à tirer parti des dernières innovations en IA. En suivant les étapes et les principes décrits dans cet article, les développeurs PHP et les experts en data science peuvent commencer à explorer le monde fascinant des RAGs pour améliorer les capacités de traitement du langage naturel de leurs applications.

Note de l'auteur : Alors, on ne va pas se mentir. Ce début d'article a été rédigé grâce à une intelligence artificielle. Il faut tout de même avouer qu'elle a bien fait son travail. Il paraît évident qu'une intelligence artificielle a été entraînée avec ses propres concepts. Cela rend l'exercice d'écriture de l'article très ludique. Mon rôle a simplement consisté à "montrer" la voie de manière interactive pour obtenir les informations les plus claires possible. Maintenant que nous avons eu un petit passage théorique, nous allons pouvoir passer plus facilement à la pratique.

Tout d'abord, la technologie choisie pour ce premier article est TxtAi. Pourquoi ? Eh bien, parce qu'il est fait pour cela. Et qu'une fois qu'on a compris comment il fonctionne, on se rend compte qu'il représente un gain de temps non négligeable. Sachant qu'il y aura des données à préparer, une infrastructure à monter et d'autres aspects techniques, si on peut gagner du temps dans le développement, ce sera toujours du temps gagné pour le client final. Vous verrez que tout ne se fait pas non plus en trois clics. Il faut de la data, et c'est finalement là que ça va être le plus long.

Passons au code. Nous supposons que vous avez déjà passé l'étape d'installation de Llama.cpp. Vous avez un compte sur Huggingface avec un token et votre environnement Python est déjà fonctionnel. On commence par installer nos petites dépendances :

pipenv shell
pipenv install txtai[pipeline] autoawq install nltk['punkt']
pipenv install  install git+https://github.com/abetlen/llama-cpp-python.git
pip install hf-transfer

Nous allons avoir besoin d'un modèle, nous avons choisi TheBloke/Mistral-7B-OpenOrca-GGUF. Vous le verrez le Llm de MistralAi (cocorico !) est tres impressionnant lorsqu'il s'agit d'écrire du contenu. Selon votre materiel, utilisez une version plus légère du modèle: https://huggingface.co/TheBloke/Mistral-7B-OpenOrca-GGUF/tree/main

huggingface-cli download TheBloke/Mistral-7B-OpenOrca-GGUF mistral-7b-openorca.Q8_0.gguf --local-dir /Data/Projets/Llm/Models/MistralAi-OpenOrqa/mistral-7b-openorca.Q8_0.gguf --cache-dir /Data/Projets/Llm/Models/huggingface_cache/

export HF_HUB_ENABLE_HF_TRANSFER=1 &&  huggingface-cli download TheBloke/Mistral-7B-OpenOrca-GGUF mistral-7b-openorca.Q2_K.gguf --local-dir /Data/Projets/Llm/Models/MistralAi-OpenOrqa/mistral-7b-openorca.Q2_K.gguf --cache-dir /Data/Projets/Llm/Models/huggingface_cache/

L'avantage de ce dépot est que le fichier au fomat gguf est déjà fait pour nous, nous pouvons directement l'utiliser avec llama.cpp et TxtAi. Donc, sans GPU. Encore une fois l'idée est de montrer comment ça fonctionne et de se projeter avec du materiel prévu pour cela.

Nous allons avoir besoin de matiaire pour faire nos extractions de données, merci à neuml de nous fournir des fichiers d'exemples. Téléchargez des documents à cette adresse, ou utilisez un des votres en adaptant le code qui suit.

from llama_cpp import Llama
from txtai.pipeline import Textractor
import nltk
# Création de notre connection à Llama.cpp avec ces parrametres par defauts.
llm = Llama(
    model_path="/Data/Projets/Llm/Models/MistralAi-OpenOrqa/mistral-7b-openorca.Q8_0.gguf/mistral-7b-openorca.Q8_0.gguf", n_ctx=2048)
# On récupere le texte de notre fichier docx.
textractor = Textractor()
text = textractor("datas/tuto1/document.docx")


# execution de notre appel au modèle.
def execute(question, context):
    # on crée un prompt de démarrage
    prompt = f"""<|im_start|>system You are a friendly assistant. You answer questions from users.<|im_end|> 
    <|im_start|>user Answer the following question using only the context below. Only include information 
    specifically discussed or general AI and LLMs related subject. 
  question: {question}
  context: {context} <|im_end|>
  <|im_start|>assistant
  """

    tokens = nltk.word_tokenize(text)
    print(len(tokens))
    return llm(prompt,
               temperature=0.1,
               max_tokens=10000,
               top_p=0.2,
               top_k=10,
               repeat_penalty=1.2)

# on lance notre methode avec une question mais aussi un contexte tiré de notre fichier docx.
result = execute("Write a long article about TxtAi explaining how it works. You can show code example. Explain how it could solve problem in small and larger company. Make the accurate answer you can do. Make an intro and a conclusion. This could be a general speech in a conference or a learning lesson at Partitech University. Make your answer in french", text)
print(result['choices'][0]['text'])
print(result['choices'][0]['text'])
print(result['usage'])

Voici le résultat.

 Titre : TxtAi, la base de données d'embeddings pour les recherches sémantiques et l'orchestration des LLMs (Langage de Modèle Linguistique)

Dans cet article, nous allons expliquer comment TxtAi fonctionne en tant que base de données d'embeddings complète pour la recherche sémantique, l'orchestration des Langages de Modèles Linguistiques (LLMs) et les workflows linguistiques. Nous allons également présenter un exemple de code et montrer comment TxtAi peut résoudre des problèmes dans des entreprises de taille différente, que ce soit une petite ou grande entreprise.

TxtAi est une base de données d'embeddings conçue pour faciliter la recherche sémantique et l'orchestration des LLMs. Elle offre plusieurs fonctionnalités importantes, telles que :
1. Recherche vectorielle avec SQL, stockage objet, modélisation du sujet ;
2. Créer des embeddings pour le texte, les documents, la audio et l'image;
3. Pipelines alimentés par des LLMs qui exécutent des prompts de LLM;
4. Workflows permettant de joindre plusieurs pipelines ensemble et d'aggreguer des logiques métier ;
5. Construire avec Python ou YAML, avec des bindings API disponibles pour JavaScript, Java, Rust et Go.

Pour illustrer comment TxtAi fonctionne, voici un exemple de code en Python :


***python
from txtai import TextSearch, DocumentEmbeddings, ImageEmbeddings, Pipeline, Workflow

# Création d'un pipeline avec une LLM
llm_pipeline = Pipeline(model="gpt-3")

# Créer des embeddings pour le texte et l'image
text_embeddings = DocumentEmbeddings("documents.txt", model="all-MiniLM-L6-v2")
image_embeddings = ImageEmbeddings("images/*.jpg", model="BLIP")

# Créer une recherche vectorielle avec SQL et stockage objet
text_search = TextSearch(sql_query="SELECT * FROM documents WHERE similarity > 0.8", storage="object-store")

# Construire un workflow pour joindre les pipelines ensemble
workflow = Workflow([llm_pipeline, text_search, text_embeddings, image_embeddings])

# Exécutez le workflow et affichez les résultats
results = workflow.run()
print(results)
*** 
Ce code montre comment créer un pipeline avec une LLM, générer des embeddings pour du texte et des images, puis construire un workflow qui utilise ces pipelines pour effectuer une recherche vectorielle sur la base de données.

En ce qui concerne l'impact dans les entreprises, TxtAi peut aider à résoudre divers problèmes en améliorant la recherche sémantique et en facilitant le travail des LLMs. Pour une petite entreprise, cela signifie que les employés peuvent accélérer leurs processus de recherche grâce à l'utilisation d'embeddings pour indexer rapidement leur contenu. Dans un contexte plus grand, TxtAi peut aider à améliorer la performance des systèmes de recommandation et à simplifier le développement de workflows linguistiques complexes.

En conclusion, TxtAi est une base d'embeddings complète qui facilite la recherche sémantique et l'orchestration des LLMs pour les entreprises de toutes tailles. Grâce à ses fonctionnalités avancées en matière de vectorisation, de modélisation du sujet et de workflows linguistiques, TxtAi peut améliorer considérablement la productivité et l'efficacité des organisations dans divers domaines.

À noter que la sortie est directement au format Markdown. J'ai modifié le marqueur de code, sinon cela ne serait pas très lisible.

Passons aux explications complémentaires concernant les paramètres utilisés dans notre appel :

Tout d'abord, le prompt. Comment définit-on le prompt que nous envoyons au modèle ? Aucune magie ici. Il vous faudra aller voir directement dans la documentation du modèle. Ici, sur HuggingFace : https://huggingface.co/TheBloke/Mistral-7B-OpenOrca-GGUF

Comme vous le voyez, le prompt attendu est clair : il faut des zones <|im_start|>system <|im_start|>user et une zone <|im_start|>qui va laisser la place au modèle pour vous répondre. L'astuce ici est de définir un contexte dans le prompt. Il faut bien comprendre que la place qu'on donne au prompt doit être définie à l'avance.

n_ctx=2048 = Le nombre de tokent alloué au context. Il est spécifié dans la doc sur huggingface. Comment définir le nombre de token ? Le calcul du nombre de tokens dépend de la méthode de tokenisation utilisée. La tokenisation est le processus de division d'un texte en tokens. Voici quelques étapes générales pour calculer le nombre de tokens :

import nltk
nltk.download('punkt')  # Assurez-vous d'avoir le package 'punkt' téléchargé pour la tokenisation
text = "Votre texte ici."
tokens = nltk.word_tokenize(text)
number_of_tokens = len(tokens)

Dans notre exemple, le nombre de tokens de notre prompt calculé est de 264. Le nombre de tokens retourné dans la réponse est de 3182. Dans la réalité, le modèle nous retourne les informations suivantes :

{'prompt_tokens': 552, 'completion_tokens': 938, 'total_tokens': 1490}

C'est donc un peu plus compliqué de prédire le nombre de token à l'avance.

temperature=0.1

La température contrôle le degré de hasard dans le choix des mots ou des phrases. Elle affecte les probabilités associées à chaque choix possible lors de la génération de texte.

À une température basse (proche de 0), le modèle a tendance à choisir les mots les plus probables, ce qui conduit à des textes plus prévisibles et cohérents. Cependant, cela peut aussi rendre les textes générés moins variés et parfois répétitifs.
À une température élevée, le modèle prend des risques plus importants, en choisissant des mots moins probables. Cela peut mener à des textes plus créatifs, originaux ou surprenants, mais aussi parfois moins cohérents ou pertinents. La température dans un modèle de génération de texte agit comme un régulateur entre la cohérence et la créativité. Un paramétrage judicieux de la température peut grandement influencer la qualité et le style du texte généré.

max_tokens=10000

Le paramètre max_tokens est utilisé dans les modèles de traitement automatique du langage naturel (NLP), comme MistralAI et d'autres modèles basés sur des réseaux de neurones. Il joue un rôle crucial dans la définition de la longueur de la sortie générée par le modèle. Voici quelques détails clés :

max_tokens spécifie le nombre maximal de tokens (mots, ponctuations, symboles, etc.) que le modèle peut générer ou traiter en une seule fois. Un "token" est la plus petite unité de traitement dans le NLP.
Lors de la génération de texte, max_tokens limite la longueur du texte produit. Si le modèle atteint cette limite lors de la génération, il arrête de produire plus de texte.
Dans les tâches de compréhension ou d'analyse de texte, ce paramètre peut limiter la quantité de texte analysé à la fois.
La limitation du nombre de tokens est importante pour gérer l'utilisation des ressources informatiques. Plus la valeur de max_tokens est élevée, plus le modèle nécessitera de mémoire et de puissance de calcul pour générer ou traiter le texte. Cela est particulièrement pertinent pour les gros modèles de NLP, qui peuvent consommer beaucoup de ressources.
Pour les Générations Courtes : Une valeur basse de max_tokens peut être utilisée pour des réponses courtes, comme dans les chatbots ou les systèmes de réponses aux questions.
Pour les Textes Plus Longs : Une valeur plus élevée est nécessaire pour des tâches telles que la génération d'articles, de récits, ou d'autres formes de contenu long. Le choix de la valeur appropriée pour max_tokens dépend de l'application spécifique et des capacités du système sur lequel le modèle s'exécute.

Il est souvent nécessaire de trouver un équilibre entre la qualité et la longueur du texte généré, et les contraintes de performance. En résumé, max_tokens est un paramètre essentiel qui aide à contrôler la longueur du texte généré par un modèle de NLP tout en gérant les ressources informatiques nécessaires. Son réglage approprié est crucial pour obtenir des résultats optimaux en fonction des besoins spécifiques de l'application.

top_p=0.2

Le paramètre top_p, également connu sous le nom de "nucleus sampling", est un paramètre crucial dans les modèles de génération de texte comme MistralAI. Il sert à contrôler la diversité et la créativité des textes générés. Voici une explication détaillée : Lorsque le modèle génère du texte, il attribue une probabilité à chaque mot possible en tant que prochain mot. top_p sert à filtrer ces mots en se basant sur leurs probabilités cumulées. Concrètement, cela signifie que le modèle considère uniquement un sous-ensemble de mots possibles dont les probabilités cumulées atteignent le seuil top_p. Contrôle de la Diversité du Texte :

Avec un top_p faible, le modèle se limite à un nombre réduit de choix très probables, ce qui conduit à des textes plus prévisibles et moins diversifiés.
Avec un top_p élevé, le modèle considère un plus grand nombre de choix possibles, augmentant ainsi la diversité et la créativité du texte généré, mais au risque de perdre en cohérence.
Contrairement à la température, qui ajuste les probabilités de tous les choix possibles, top_p limite simplement le pool de mots considérés pour la génération, en fonction de leurs probabilités cumulatives.

top_p offre une alternative au sampling basé sur le paramètre top_k, où seuls les k mots les plus probables sont considérés, indépendamment de leurs probabilités absolues.

Pour un texte plus standard : Utilisez un top_p plus faible si vous souhaitez des textes plus cohérents et alignés sur les données d'entraînement.
Pour un texte plus créatif : Un top_p plus élevé est approprié pour des tâches nécessitant de la créativité ou de l'originalité, comme l'écriture créative ou la génération de concepts uniques.

La valeur de top_p est généralement un nombre réel entre 0 et 1. Le choix de la valeur appropriée pour top_p dépend du type de texte que vous souhaitez générer et de l'équilibre souhaité entre créativité et cohérence. En résumé, top_p est un paramètre important pour contrôler la diversité et la créativité dans la génération de texte. Son ajustement permet de trouver le bon équilibre entre produire des textes originaux et maintenir une certaine cohérence avec le style et le contenu des données d'entraînement.

top_k=10

Le paramètre top_k est un autre paramètre important. Il joue un rôle crucial dans la détermination des choix de mots du modèle lors de la génération de texte. Lors de la génération de texte, le modèle évalue la probabilité de nombreux mots possibles comme étant le prochain mot. top_k restreint cette sélection aux k mots les plus probables. Par exemple, si top_k est réglé sur 10, le modèle ne considérera que les 10 mots les plus probables pour continuer la phrase à chaque étape de la génération.

Un top_k faible (comme 5 ou 10) rend le texte généré plus prévisible et cohérent, car il se limite aux choix les plus probables.
Un top_k élevé augmente la diversité des mots générés, car il permet au modèle de choisir parmi un plus grand nombre de possibilités, ce qui peut conduire à des textes plus créatifs ou surprenants.
Contrairement à top_p, qui sélectionne des mots basés sur un seuil de probabilité cumulée, top_k se concentre uniquement sur le nombre fixe de choix les plus probables.
top_k est souvent utilisé en conjonction avec la température pour affiner davantage la sortie générée.
Pour des textes plus standardisés : un top_k plus faible est souvent utilisé pour des tâches nécessitant de la cohérence et de la précision, comme les réponses aux questions.
Pour des textes plus innovants : un top_k plus élevé peut être utilisé pour stimuler la créativité, utile dans l'écriture créative ou la génération d'idées.
La valeur de top_k est généralement un entier. Le choix de cette valeur dépend de l'équilibre souhaité entre créativité et cohérence dans le texte généré.

En résumé, top_k est un paramètre qui influence directement la variété et l'originalité du texte généré par un modèle de NLP. Il doit être ajusté en fonction des objectifs spécifiques de la tâche de génération de texte, en gardant à l'esprit l'équilibre entre la diversité du contenu et la fidélité au style et à la structure des données d'entraînement.

repeat_penalty=1.2

Le repeat_penalty est un paramètre utilisé pour minimiser les répétitions dans le texte généré. C'est un aspect important pour améliorer la qualité et la variété du texte produit.

Ce paramètre vise à pénaliser la répétition de mots ou de phrases déjà apparus dans le texte généré. En d'autres termes, il diminue la probabilité de sélectionner à nouveau des mots ou des phrases qui ont été utilisés récemment.
Lorsque le modèle génère du texte, il attribue des scores (probabilités) aux mots potentiels à utiliser ensuite. Si un mot a déjà été utilisé, le repeat_penalty réduit le score de ce mot, le rendant moins susceptible d'être choisi à nouveau.
Plus le repeat_penalty est élevé, plus la pénalisation pour la répétition de mots est forte.
Avec un repeat_penalty faible ou nul, le modèle peut générer des textes avec des répétitions fréquentes, ce qui peut rendre le texte monotone ou moins naturel.
Avec un repeat_penalty élevé, le modèle tend à éviter les répétitions, ce qui peut contribuer à la variété et à la richesse du texte. Cependant, un penalty trop élevé peut aussi forcer le modèle à utiliser des mots moins appropriés, affectant potentiellement la cohérence du texte.
Pour des textes plus fluides : Un repeat_penalty modéré est utile pour éviter les répétitions tout en maintenant la cohérence et le flux naturel du texte.
Pour des textes très variés : Un repeat_penalty plus élevé peut être utilisé pour stimuler la diversité dans le texte, en particulier dans des contextes créatifs.

La valeur exacte du repeat_penalty dépendra des spécificités du modèle et du type de texte que vous souhaitez générer. Il faut souvent expérimenter avec différentes valeurs pour trouver l'équilibre idéal.

Pour aller plus loin, voici un extrait de la documentation de llama_cpp_python. Elle peut être utile pour une meilleure compréhension de certains paramètres.

https://llama-cpp-python.readthedocs.io/en/latest/api-reference/

model_path (str) – Chemin vers le modèle.
- Explication : Indique où se trouve le fichier du modèle sur votre ordinateur.
n_gpu_layers (int, par défaut : 0) – Nombre de couches à transférer sur le GPU (-ngl). Si -1, toutes les couches sont transférées.
- Explication : Détermine combien de couches du modèle doivent être exécutées sur le GPU. Utile pour gérer la charge de travail entre le CPU et le GPU.
main_gpu (int, par défaut : 0) – Le GPU utilisé pour les calculs temporaires et les petits tenseurs.
- Explication : Sélectionne quel GPU (si plusieurs sont disponibles) est utilisé pour les opérations principales.
tensor_split (Optionnel[List[float]], par défaut : None) – Comment diviser les tenseurs entre les GPU. Si None, le modèle n'est pas divisé.
- Explication : Permet de répartir les données du modèle sur plusieurs GPU, si disponible.
vocab_only (bool, par défaut : False) – Charge uniquement le vocabulaire, pas les poids du modèle.
- Explication : Utile si vous avez besoin uniquement du vocabulaire intégré au modèle, sans les parties entraînées.
use_mmap (bool, par défaut : True) – Utiliser mmap si possible.
- Explication : mmap permet une gestion plus efficace de la mémoire lors du chargement de grands fichiers.
use_mlock (bool, par défaut : False) – Force le système à garder le modèle en RAM.
- Explication : Assure que le modèle reste en mémoire vive pour un accès plus rapide.
seed (int, par défaut : LLAMA_DEFAULT_SEED) – Graine pour le générateur de nombres aléatoires, -1 pour aléatoire.
- Explication : Détermine la séquence de nombres aléatoires utilisée, importante pour la reproductibilité des résultats.
n_ctx (int, par défaut : 512) – Contexte textuel, 0 = celui du modèle.
- Explication : Définit la taille du contexte (nombre de tokens) que le modèle prend en compte pour ses prédictions.
n_batch (int, par défaut : 512) – Taille maximale de traitement par lot pour les prompts.
- Explication : Détermine combien de prompts peuvent être traités en même temps.
n_threads (Optionnel[int], par défaut : None) – Nombre de threads à utiliser pour la génération.
- Explication : Permet de configurer le multithreading pour accélérer la génération.
n_threads_batch (Optionnel[int], par défaut : None) – Nombre de threads à utiliser pour le traitement par lot.
- Explication : Similaire à n_threads, mais spécifique au traitement par lots.
rope_scaling_type (Optionnel[int], par défaut : LLAMA_ROPE_SCALING_UNSPECIFIED) – Type de mise à l'échelle RoPE, d'après l'énumération llama_rope_scaling_type. Réf : llama.cpp pull request #2054
- Explication : Paramètre avancé lié à la mise à l'échelle de certains calculs dans le modèle.
rope_freq_base (float, par défaut : 0.0) – Fréquence de base RoPE, 0 = celle du modèle.
- Explication : Définit une valeur de base pour le calcul de la fréquence dans RoPE, un paramètre avancé du modèle.
rope_freq_scale (float, par défaut : 0.0) – Facteur d'échelle de fréquence RoPE, 0 = celui du modèle.
- Explication : Ajuste l'échelle de la fréquence utilisée dans RoPE.
yarn_ext_factor (float, par défaut : -1.0) – Facteur de mélange d'extrapolation YaRN, négatif = celui du modèle.
- Explication : Paramètre avancé influençant comment YaRN, une partie du modèle, mélange les données.
yarn_attn_factor (float, par défaut : 1.0) – Facteur d'échelle de magnitude YaRN.
- Explication : Ajuste l'échelle de certains calculs dans YaRN.
yarn_beta_fast (float, par défaut : 32.0) – Dimension de correction basse YaRN.
- Explication : Paramètre technique lié à la correction rapide dans YaRN.
yarn_beta_slow (float, par défaut : 1.0) – Dimension de correction haute YaRN.
- Explication : Paramètre technique pour la correction lente dans YaRN.
yarn_orig_ctx (int, par défaut : 0) – Taille originale du contexte YaRN.
- Explication : Détermine la taille de contexte d'origine pour certains calculs dans YaRN.
f16_kv (bool, par défaut : True) – Utiliser fp16 pour le cache KV, fp32 sinon.
Explication : Détermine le format des données dans le cache clé/valeur, influençant la performance et l'utilisation de la mémoire.
logits_all (bool, par défaut : False) – Renvoie les logits pour tous les tokens, pas seulement le dernier. Doit être True pour que la complétion renvoie des logprobs.
- Explication : Si True, le modèle fournira des logits (scores avant la fonction d'activation) pour chaque token généré.
embedding (bool, par défaut : False) – Mode d'incorporation uniquement.
- Explication : Si True, le modèle fonctionne en mode d'incorporation, utilisé pour obtenir des représentations vectorielles des données.
last_n_tokens_size (int, par défaut : 64) – Nombre maximal de tokens à conserver dans la deque last_n_tokens.
- Explication : Définit la taille de la mémoire tampon pour les derniers tokens générés.
lora_base (Optionnel[str], par défaut : None) – Chemin optionnel vers le modèle de base, utile si vous utilisez un modèle de base quantifié et souhaitez appliquer LoRA à un modèle f16.
- Explication : Permet d'appliquer des ajustements LoRA à un modèle de base spécifique.
lora_path (Optionnel[str], par défaut : None) – Chemin vers un fichier LoRA à appliquer au modèle.
Explication : Spécifie un fichier LoRA pour modifier le modèle.
numa (bool, par défaut : False) – Activer le support NUMA. (NOTE : La valeur initiale de ce paramètre est utilisée pour le reste du programme car cette valeur est définie dans llama_backend_init)
- Explication : Active ou désactive le support pour NUMA, une méthode d'optimisation de la gestion de la mémoire sur des systèmes avec plusieurs CPU.
chat_format (str, par défaut : 'llama-2') – Chaîne spécifiant le format de chat à utiliser lors de l'appel de create_chat_completion.
- Explication : Détermine le format de sortie pour les sessions de chat générées
chat_handler (Optionnel[LlamaChatCompletionHandler], par défaut : None) – Gestionnaire de chat optionnel à utiliser lors de l'appel de create_chat_completion.
- Explication : Permet de personnaliser le traitement des sessions de chat.
verbose (bool, par défaut : True) – Afficher une sortie détaillée sur stderr.
- Explication : Si True, le modèle fournira des informations détaillées sur son fonctionnement pendant l'exécution.

Voilà pour cette introduction au RAG. Nous n'avons pas encore abordé le cœur du sujet, mais cette première partie nous a permis de mettre en avant le concept et de montrer comment les choses fonctionnent. Rendez-vous dans la partie 2 où nous commencerons à mettre des données en base. Nous verrons comment TxtAi s'occupe tout seul de faire des requêtes pour récupérer du contenu et nous fournir un retour cohérent adapté à l'utilisateu