Module I : E/S de modèle

Dans LangChain, l'élément central de toute application est le modèle de langage. Ce module fournit les éléments de base essentiels pour interagir efficacement avec n'importe quel modèle de langage, garantissant une intégration et une communication fluides.

## Composants clés de l'E/S de modèle

**MLL et modèles de discussion (utilisés de manière interchangeable):**

* **MLL** : Définition : Modèles de complétion de texte brut.
    * Entrée/Sortie : Prendre une chaîne de texte en entrée et renvoyer une chaîne de texte en sortie.
* **Modèles de discussion** : Définition : Modèles qui utilisent un modèle de langage comme base, mais diffèrent des formats d'entrée et de sortie.
    * Entrée/Sortie : Accepter une liste de messages de discussion en entrée et renvoyer un message de discussion.

**Paramètres:** Modéliser, sélectionner dynamiquement et gérer les entrées du modèle. Permet la création d'invites flexibles et contextuelles qui guident les réponses du modèle de langage.

**Analyseurs de sortie:** Extraire et formater les informations des sorties du modèle. Utile pour convertir la sortie brute des modèles de langage en données structurées ou en formats spécifiques nécessaires à l'application.

Intégration de LangChain avec les MLL**

L'intégration de LangChain avec les grands modèles de langage (MLL) comme OpenAI, Cohere et Hugging Face est un aspect fondamental de sa fonctionnalité. LangChain lui-même n'héberge pas de MLL, mais offre une interface uniforme pour interagir avec divers MLL.

Cette section donne un aperçu de l'utilisation de l'encapsuleur OpenAI LLM dans LangChain, applicable également à d'autres types de MLL. Nous l'avons déjà installé dans la section "Démarrage". Initialisons le MLL.

python
from langchain.llms import OpenAI
llm = OpenAI()
```

# LLMs implémentent l'interface Runnable, l'élément de base du LangChain Expression Language (LCEL). Cela signifie qu'ils prennent en charge les appels `invoke`, `ainvoke`, `stream`, `astream`, `batch`, `abatch`, `astream_log`.

# Les MLL acceptent des chaînes de caractères en entrée, ou des objets qui peuvent être transformés en chaînes d'invite, y compris `List[BaseMessage]` et `PromptValue` (plus de détails plus tard).

# Voyons quelques exemples.

response = llm.invoke("Lister les sept merveilles du monde.")
print(response)

# Vous pouvez également appeler la méthode `stream` pour diffuser la réponse textuelle en continu.

for chunk in llm.stream("Où se sont tenus les Jeux olympiques de 2012 ?"):
    print(chunk, end="", flush=True)

3.2. Modèles de discussion

L'intégration de LangChain avec les modèles de discussion, une variante spécialisée des modèles de langage, est essentielle pour la création d'applications de chat interactives. Bien qu'ils utilisent des modèles de langage en interne, les modèles de discussion présentent une interface distincte centrée sur les messages de chat comme entrées et sorties. Cette section fournit un aperçu détaillé de l'utilisation du modèle de discussion OpenAI dans LangChain.

python

Les modèles de discussion dans LangChain fonctionnent avec différents types de messages tels que AIMessage, HumanMessage, SystemMessage, FunctionMessage et ChatMessage (avec un paramètre de rôle arbitraire). En général, HumanMessage, AIMessage et SystemMessage sont les plus fréquemment utilisés.

Les modèles de discussion acceptent principalement des listes de `BaseMessage` en entrée. Les chaînes de caractères peuvent être converties en `HumanMessage`, et `PromptValue` est également pris en charge.

python
from langchain.schema.messages import HumanMessage, SystemMessage
messages = [
    SystemMessage(content="Vous êtes Micheal Jordan."),
    HumanMessage(content="À quel fabricant de chaussures êtes-vous associé ?"),
]
response = chat.invoke(messages)
print(response.content)

3.3. Prompts : Invite de commandes

Les invites de commande sont essentielles pour guider les modèles de langage vers la génération de sorties pertinentes et cohérentes. Elles peuvent aller de simples instructions à des exemples complexes à quelques coups. Dans LangChain, la gestion des invites de commande peut être un processus très rationalisé grâce à plusieurs classes et fonctions dédiées.

La classe `PromptTemplate` de LangChain est un outil polyvalent pour créer des invites de commande sous forme de chaîne de caractères. Elle utilise la syntaxe `str.format` de Python, permettant la génération dynamique d'invites de commande. Vous pouvez définir un modèle avec des espaces réservés et les remplir avec des valeurs spécifiques selon vos besoins.

```python
from langchain.prompts import PromptTemplate

# Invite de commande simple avec des espaces réservés
prompt_template = PromptTemplate.from_template(
    "Raconte-moi une blague {adjective} sur {content}."
)

# Remplir les espaces réservés pour créer une invite de commande
filled_prompt = prompt_template.format(adjective="drôle", content="robots")
print(filled_prompt)
```

Pour les modèles de chat, les invites de commande sont plus structurées et impliquent des messages avec des rôles spécifiques. LangChain propose `ChatPromptTemplate` à cet effet.

```python
from langchain.prompts import ChatPromptTemplate

# Définition d'une invite de commande de chat avec différents rôles
chat_template = ChatPromptTemplate.from_messages(
    [
        ("système", "Vous êtes un assistant AI serviable. Votre nom est {name}."),
        ("humain", "Bonjour, comment allez-vous ?"),
        ("ia", "Je vais bien, merci !"),
        ("humain", "{user_input}"),
    ]
)

# Formatage de l'invite de commande de chat
formatted_messages = chat_template.format_messages(name="Bob", user_input="Quel est votre nom ?")
for message in formatted_messages:
    print(message)
```

Cette approche permet la création de chatbots interactifs et engageants avec des réponses dynamiques.

`PromptTemplate` et `ChatPromptTemplate` s'intègrent parfaitement au LangChain Expression Language (LCEL), ce qui leur permet de faire partie de workflows plus vastes et complexes. Nous en discuterons plus en détail plus tard.

Des modèles d'invite de commande personnalisés sont parfois essentiels pour des tâches nécessitant un formatage unique ou des instructions spécifiques. La création d'un modèle d'invite de commande personnalisé implique la définition de variables d'entrée et d'une méthode de formatage personnalisée. Cette flexibilité permet à LangChain de répondre à un large éventail d'exigences spécifiques aux applications. En savoir plus ici: link to LangChain documentation about custom prompt templates.

LangChain prend également en charge les invites de commande à quelques coups, permettant au modèle d'apprendre à partir d'exemples. Cette fonction est essentielle pour les tâches nécessitant une compréhension contextuelle ou des modèles spécifiques. Les modèles d'invite de commande à quelques coups peuvent être construits à partir d'un ensemble d'exemples ou en utilisant un objet `ExampleSelector`. En savoir plus ici: link to LangChain documentation about few-shot prompting.

**Analyseurs de sortie**

Les analyseurs de sortie jouent un rôle crucial dans Langchain, permettant aux utilisateurs de structurer les réponses générées par les modèles de langage. Dans cette section, nous explorerons le concept d'analyseurs de sortie et fournirons des exemples de code en utilisant `PydanticOutputParser`, `SimpleJsonOutputParser`, `CommaSeparatedListOutputParser`, `DatetimeOutputParser` et `XMLOutputParser` de LangChain.

3.4. PydanticOutputParser : Parseur de sortie Pydantic

Langchain fournit le `PydanticOutputParser` pour analyser les réponses en structures de données Pydantic. Voici un exemple pas à pas de son utilisation :

python
from typing import List
from langchain_community.llms import Ollama
from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain.pydantic_v1 import BaseModel, Field, validator

# Initialize the language model
model = Ollama(model = model_name, temperature=0)

# Define your desired data structure using Pydantic
class Joke(BaseModel):
      setup: str = Field(description="question to set up a joke")
      punchline: str = Field(description="answer to resolve the joke")

      @validator("setup")
      def question_ends_with_question_mark(cls, field):
            if field[-1] != "?":
                  raise ValueError("Badly formed question!")
            return field

# Set up a PydanticOutputParser
parser = PydanticOutputParser(pydantic_object=Joke)

# Create a prompt with format instructions
prompt = PromptTemplate(
      template="Answer the user query.\n{format_instructions}\n{query}\n",
      input_variables=["query"],
      partial_variables={"format_instructions": parser.get_format_instructions()},
)

# Define a query to prompt the language model
query = "Tell me a joke."

# Combine prompt, model, and parser to get structured output
prompt_and_model = prompt | model
output = prompt_and_model.invoke({"query": query})

# Parse the output using the parser
parsed_result = parser.invoke(output)

# The result is a structured object
print(parsed_result)

**Sortie attendue :**

... (résultat de l'impression de l'objet `parsed_result`)

3.5 SimpleJsonOutputParser en français

Le `SimpleJsonOutputParser` de Langchain est utilisé lorsque vous souhaitez analyser des sorties de type JSON. Voici un exemple :

```python

from langchain.output_parsers.json import SimpleJsonOutputParser
from langchain_community.llms import Ollama

model = Ollama(model = model_name, temperature=0)

# Create a JSON prompt
json_prompt = PromptTemplate.from_template(
      "Return a JSON object with `birthdate` and `birthplace` key that answers the following question: {question}"
)

# Initialize the JSON parser
json_parser = SimpleJsonOutputParser()

# Create a chain with the prompt, model, and parser
json_chain = json_prompt | model | json_parser

# Stream through the results
result_list = list(json_chain.stream({"question": "When and where was Elon Musk born?"}))

# The result is a list of JSON-like dictionaries
print(result_list)

```

**Explications techniques:**

* Le code utilise la bibliothèque Langchain et son analyseur `SimpleJsonOutputParser` pour traiter des sorties en format JSON.
* Un modèle `json_prompt` est créé pour spécifier la structure de la sortie JSON souhaitée, incluant les clés "date_de_naissance" et "lieu_de_naissance".
* L'analyseur `json_parser` est initialisé pour traiter les sorties JSON.
* Une chaîne est construite en reliant le modèle, le modèle de langage (représenté par "model") et l'analyseur.
* La méthode `stream` est utilisée pour parcourir les résultats de la chaîne, en fournissant la question "Quand et où est né Elon Musk ?" comme entrée.
* Le résultat final est une liste de dictionnaires contenant les informations demandées, au format JSON.

3.6. CommaSeparatedListOutputParser en français

Le `CommaSeparatedListOutputParser` de Langchain est pratique pour extraire des listes séparées par des virgules des réponses des modèles de langage. Voici un exemple :

```python
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain.prompts import PromptTemplate
from langchain.llms import OpenAI (remplacer par le modèle de langage que vous utilisez)

# Initialiser l'analyseur
analyseur_liste_virgule = CommaSeparatedListOutputParser()

# Obtenir les instructions de formatage de l'analyseur
instructions_formatage = analyseur_liste_virgule.get_format_instructions()

# Créer un modèle demandant une liste
modele = PromptTemplate(
    modèle="Lister cinq {sujet}.\n{instructions_formatage}",
    variables_entrantes=["sujet"],
    variables_partielles={"instructions_formatage": instructions_formatage}
)

# Définir une requête pour le modèle
requete = "Equipes de Premier League anglaise"

# Générer la sortie
sortie = model(modele.format(sujet=requete))

# Analyser la sortie à l'aide de l'analyseur
resultat_analyse = analyseur_liste_virgule.parse(sortie)

# Le résultat est une liste d'éléments
print(resultat_analyse)
```

**Explications techniques:**

* Le code utilise la bibliothèque Langchain et son analyseur `CommaSeparatedListOutputParser` pour extraire des listes séparées par des virgules des réponses d'un modèle de langage.
* Un modèle `modele` est créé pour formuler la requête demandant une liste au modèle, en incluant les instructions de formatage fournies par l'analyseur.
* L'analyseur `analyseur_liste_virgule` est initialisé pour traiter les sorties contenant des listes séparées par des virgules.
* Une requête "Equipes de Premier League anglaise" est définie pour être fournie au modèle.
* La méthode `model` (remplacez par le modèle de langage que vous utilisez) génère la sortie en réponse à la requête et au modèle.
* La sortie est ensuite analysée par `analyseur_liste_virgule.parse` pour extraire la liste des éléments.
* Le résultat final est une liste contenant les éléments extraits de la réponse du modèle.

 3.7. DatetimeOutputParser

Le `DatetimeOutputParser` de Langchain est conçu pour analyser les informations de date et d'heure. Voici comment l'utiliser :

```python
from langchain.prompts import PromptTemplate
from langchain.output_parsers import DatetimeOutputParser
from langchain.chains import LLMChain
from langchain.llms import OpenAI (remplacer par le modèle de langage que vous utilisez)

# Initialiser le DatetimeOutputParser
analyseur_datetime = DatetimeOutputParser()

# Créer un modèle avec des instructions de formatage
modele = PromptTemplate.from_template(
    modele="""
    Répondez à la question de l'utilisateur :
    {question}
    {instructions_formatage}
    """,
    variables_partielles={"instructions_formatage": analyseur_datetime.get_format_instructions()},
)

# Créer une chaîne avec le modèle et le modèle de langage
chaine = LLMChain(prompt=modele, llm=OpenAI())  # Remplacer 'OpenAI' par le modèle à utiliser

# Définir une requête pour interroger le modèle
requete = "Quand Neil Armstrong a-t-il atterri sur la Lune en termes de GMT ?"

# Exécuter la chaîne
sortie = chaine.run(requete)

# Analyser la sortie à l'aide de l'analyseur datetime
resultat_analyse = analyseur_datetime.parse(sortie)

# Le résultat est un objet datetime
print(resultat_analyse)
```

**Explications techniques:**

* Le code utilise la bibliothèque Langchain et son analyseur `DatetimeOutputParser` pour extraire des informations de date et d'heure des réponses d'un modèle de langage.
* Un modèle `modele` est créé pour formuler la requête demandant une information de date et d'heure au modèle, en incluant les instructions de formatage fournies par l'analyseur.
* L'analyseur `analyseur_datetime` est initialisé pour traiter les sorties contenant des informations de date et d'heure.
* Une requête "Quand Neil Armstrong a-t-il atterri sur la Lune en termes de GMT ?" est définie pour interroger le modèle.
* La chaîne `chaine` exécute le modèle avec la requête et génère la sortie.
* La sortie est ensuite analysée par `analyseur_datetime.parse` pour extraire l'objet datetime.
* Le résultat final est un objet datetime représentant la date et l'heure extraites de la réponse du modèle.

**Conclusion**

Ces exemples illustrent comment les analyseurs de sortie de Langchain peuvent être utilisés pour structurer différents types de réponses de modèles, les rendant adaptés à différentes applications et formats. Les analyseurs de sortie sont un outil précieux pour améliorer la convivialité et l'interprétabilité des sorties de modèles de langage dans Langchain.

**Nanonets : Automatisation des tâches et workflows avec l'IA**

Nanonets propose un outil de création de workflows basé sur l'IA, conçu pour automatiser les tâches manuelles et les workflows au sein de vos équipes. Pour en savoir plus, vous pouvez consulter la documentation ou demander une démonstration.