Raisonnement en plusieurs étapes avec LangChain à l’aide d’Azure Databricks et Azure OpenAI

Le raisonnement à plusieurs étapes est une approche de pointe de l’IA qui implique de décomposer des problèmes complexes en étapes plus petites et mieux gérables. LangChain, une infrastructure logicielle, facilite la création d’applications qui tirent parti des grands modèles de langage (LLM). Lorsqu’il est intégré à Azure Databricks, LangChain permet un chargement transparent des données, un wrapping de modèle et le développement d’agents d’IA sophistiqués. Cette combinaison est particulièrement puissante pour gérer des tâches complexes qui nécessitent une compréhension approfondie du contexte et la capacité de raisonner en plusieurs étapes.

Ce labo prend environ 30 minutes.

Avant de commencer

Vous avez besoin d’un abonnement Azure dans lequel vous avez un accès administratif.

Provisionner une ressource Azure OpenAI

Si vous n’en avez pas déjà une, approvisionnez une ressource Azure OpenAI dans votre abonnement Azure.

  1. Connectez-vous au portail Azure à l’adresse https://portal.azure.com.
  2. Créez une ressource Azure OpenAI avec les paramètres suivants :
    • Abonnement : Sélectionner un abonnement Azure approuvé pour l’accès à Azure OpenAI Service
    • Groupe de ressources : sélectionnez ou créez un groupe de ressources.
    • Région : Choisir de manière aléatoire une région parmi les suivantes*
      • Australie Est
      • Est du Canada
      • USA Est
      • USA Est 2
      • France Centre
      • Japon Est
      • Centre-Nord des États-Unis
      • Suède Centre
      • Suisse Nord
      • Sud du Royaume-Uni
    • Nom : un nom unique de votre choix
    • Niveau tarifaire : Standard S0

* Les ressources Azure OpenAI sont limitées par des quotas régionaux. Les régions répertoriées incluent le quota par défaut pour les types de modèle utilisés dans cet exercice. Le choix aléatoire d’une région réduit le risque d’atteindre sa limite de quota dans les scénarios où vous partagez un abonnement avec d’autres utilisateurs. Si une limite de quota est atteinte plus tard dans l’exercice, vous devrez peut-être créer une autre ressource dans une autre région.

  1. Attendez la fin du déploiement. Accédez ensuite à la ressource Azure OpenAI déployée dans le portail Azure.

  2. Dans le volet de gauche, sous Gestion des ressources, sélectionnez Clés et points de terminaison.

  3. Copiez le point de terminaison et l’une des clés disponibles, car vous l’utiliserez plus loin dans cet exercice.

Déployer les modèles nécessaires

Azure fournit un portail web appelé Azure AI Studio, que vous pouvez utiliser pour déployer, gérer et explorer des modèles. Vous allez commencer votre exploration d’Azure OpenAI en utilisant Azure AI Studio pour déployer un modèle.

Remarque : lorsque vous utilisez Azure AI Studio, des boîtes de message qui suggèrent des tâches à effectuer peuvent être affichées. Vous pouvez les fermer et suivre les étapes de cet exercice.

  1. Dans le portail Azure, sur la page Vue d’ensemble de votre ressource Azure OpenAI, faites défiler jusqu’à la section Démarrer et sélectionnez le bouton permettant d’accéder à AI Studio.

  2. Dans Azure AI Studio, dans le panneau de gauche, sélectionnez la page Deployments et affichez vos modèles de déploiement existants. Si vous n’en avez pas encore, créez un déploiement du modèle gpt-35-turbo-16k avec les paramètres suivants :
    • Nom du déploiement : gpt-35-turbo-16k
    • Modèle : gpt-35-turbo-16k (si le modèle 16k n’est pas disponible, choisissez gpt-35-turbo et nommez votre déploiement en conséquence)
    • Model version : utiliser la version par défaut
    • Type de déploiement : Standard
    • Limite de débit de jetons par minute : 5 000*
    • Filtre de contenu : valeur par défaut
    • Enable dynamic quota : désactivé
  3. Retournez à la page Déploiements et créez un déploiement du modèle text-embedding-ada-002 avec les paramètres suivants :
    • Nom du déploiement : text-embedding-ada-002
    • Modèle : text-embedding-ada-002
    • Model version : utiliser la version par défaut
    • Type de déploiement : Standard
    • Limite de débit de jetons par minute : 5 000*
    • Filtre de contenu : valeur par défaut
    • Enable dynamic quota : désactivé

* Une limite de débit de 5 000 jetons par minute est plus que suffisante pour effectuer cet exercice tout permettant à d’autres personnes d’utiliser le même abonnement.

Provisionner un espace de travail Azure Databricks

Conseil : Si vous disposez déjà d’un espace de travail Azure Databricks, vous pouvez ignorer cette procédure et utiliser votre espace de travail existant.

  1. Connectez-vous au portail Azure à l’adresse https://portal.azure.com.
  2. Créez une ressource Azure Databricks avec les paramètres suivants :
    • Abonnement : sélectionnez le même abonnement Azure que celui utilisé pour créer votre ressource Azure OpenAI
    • Groupe de ressources : le groupe de ressources où vous avez créé votre ressource Azure OpenAI
    • Région : région dans laquelle vous avez créé votre ressource Azure OpenAI
    • Nom : un nom unique de votre choix
    • Niveau tarifaire : Premium ou Évaluation
  3. Sélectionnez Examiner et créer, puis attendez la fin du déploiement. Accédez ensuite à la ressource et lancez l’espace de travail.

Créer un cluster

Azure Databricks est une plateforme de traitement distribuée qui utilise des clusters Apache Spark pour traiter des données en parallèle sur plusieurs nœuds. Chaque cluster se compose d’un nœud de pilote pour coordonner le travail et les nœuds Worker pour effectuer des tâches de traitement. Dans cet exercice, vous allez créer un cluster à nœud unique pour réduire les ressources de calcul utilisées dans l’environnement du labo (dans lequel les ressources peuvent être limitées). Dans un environnement de production, vous créez généralement un cluster avec plusieurs nœuds Worker.

Conseil : Si vous disposez déjà d’un cluster avec une version 13.3 LTS ML ou ultérieure du runtime dans votre espace de travail Azure Databricks, vous pouvez l’utiliser pour effectuer cet exercice et ignorer cette procédure.

  1. Dans le Portail Azure, accédez au groupe de ressources où l’espace de travail Azure Databricks a été créé.
  2. Sélectionnez votre ressource Azure Databricks Service.
  3. Dans la page Vue d’ensemble de votre espace de travail, utilisez le bouton Lancer l’espace de travail pour ouvrir votre espace de travail Azure Databricks dans un nouvel onglet de navigateur et connectez-vous si vous y êtes invité.

Conseil : lorsque vous utilisez le portail de l’espace de travail Databricks, plusieurs conseils et notifications peuvent s’afficher. Ignorez-les et suivez les instructions fournies pour effectuer les tâches de cet exercice.

  1. Dans la barre latérale située à gauche, sélectionnez la tâche (+) Nouveau, puis sélectionnez Cluster.
  2. Dans la page Nouveau cluster, créez un cluster avec les paramètres suivants :
    • Nom du cluster : cluster de nom d’utilisateur (nom de cluster par défaut)
    • Stratégie : Non restreint
    • Mode cluster : nœud unique
    • Mode d’accès : un seul utilisateur (avec votre compte d’utilisateur sélectionné)
    • Version du runtime Databricks : Sélectionnez l’édition ML de la dernière version non bêta du runtime (Not version du runtime standard) qui :
      • N’utilise pas de GPU
      • Inclut Scala > 2.11
      • Inclut Spark > 3.4
    • Utiliser l’accélération photon : Non sélectionné
    • Type de nœud : Standard_D4ds_v5
    • Arrêter après 20 minutes d’inactivité
  3. Attendez que le cluster soit créé. Cette opération peut prendre une à deux minutes.

Remarque : si votre cluster ne démarre pas, le quota de votre abonnement est peut-être insuffisant dans la région où votre espace de travail Azure Databricks est approvisionné. Pour plus d’informations, consultez l’article La limite de cœurs du processeur empêche la création du cluster. Si cela se produit, vous pouvez essayer de supprimer votre espace de travail et d’en créer un dans une autre région.

Installer les bibliothèques nécessaires

  1. Dans l’espace de travail Databricks, accédez à la section Espace de travail.

  2. Sélectionnez Créer, puis Notebook.

  3. Donnez un nom à votre notebook et sélectionnez le langage Python.

  4. Dans la première cellule de code, entrez et exécutez le code suivant pour installer les bibliothèques nécessaires :

     %pip install langchain openai langchain_openai faiss-cpu

  5. Une fois l’installation terminée, redémarrez le noyau dans une nouvelle cellule :

     %restart_python

  6. Dans une nouvelle cellule, définissez les paramètres d’authentification qui seront utilisés pour initialiser les modèles OpenAI, en remplaçant your_openai_endpoint et your_openai_api_key par la clé et le point de terminaison copiés précédemment à partir de votre ressource OpenAI :

     endpoint = "your_openai_endpoint"
 key = "your_openai_api_key"

Créer un index vectoriel et stocker des intégrations

Un index vectoriel est une structure de données spécialisée qui permet un stockage et une récupération efficaces des données vectorielles à haute dimension, ce qui est essentiel pour effectuer des recherches rapides de similarité et des requêtes de type « plus proche voisin ». Les intégrations, d’autre part, sont des représentations numériques d’objets qui capturent leur signification dans une forme vectorielle, ce qui permet aux machines de traiter et de comprendre différents types de données, y compris du texte et des images.

  1. Dans une nouvelle cellule, exécutez le code suivant pour charger l’échantillon du jeu de données :

     from langchain_core.documents import Document

 documents = [
      Document(page_content="Azure Databricks is a fast, easy, and collaborative Apache Spark-based analytics platform.", metadata={"date_created": "2024-08-22"}),
      Document(page_content="LangChain is a framework designed to simplify the creation of applications using large language models.", metadata={"date_created": "2024-08-22"}),
      Document(page_content="GPT-4 is a powerful language model developed by OpenAI.", metadata={"date_created": "2024-08-22"})
 ]
 ids = ["1", "2", "3"]

  2. Dans une nouvelle cellule, exécutez le code suivant pour générer des intégrations à l’aide du modèle text-embedding-ada-002 :

     from langchain_openai import AzureOpenAIEmbeddings
     
 embedding_function = AzureOpenAIEmbeddings(
     deployment="text-embedding-ada-002",
     model="text-embedding-ada-002",
     azure_endpoint=endpoint,
     openai_api_key=key,
     chunk_size=1
 )

  3. Dans une nouvelle cellule, exécutez le code suivant pour créer un index vectoriel à l’aide du premier exemple de texte comme référence pour la dimension vectorielle :

     import faiss
      
 index = faiss.IndexFlatL2(len(embedding_function.embed_query("Azure Databricks is a fast, easy, and collaborative Apache Spark-based analytics platform.")))

Créer une chaîne basée sur un récupérateur

Un composant de récupérateur récupère des données et documents pertinents en fonction d’une requête. Cela est particulièrement utile dans les applications qui nécessitent l’intégration de grandes quantités de données pour l’analyse, comme dans les systèmes de génération augmentée de récupération.

  1. Dans une nouvelle cellule, exécutez le code suivant pour créer un récupérateur capable de rechercher l’index vectoriel pour les textes les plus similaires.

     from langchain.vectorstores import FAISS
 from langchain_core.vectorstores import VectorStoreRetriever
 from langchain_community.docstore.in_memory import InMemoryDocstore

 vector_store = FAISS(
     embedding_function=embedding_function,
     index=index,
     docstore=InMemoryDocstore(),
     index_to_docstore_id={}
 )
 vector_store.add_documents(documents=documents, ids=ids)
 retriever = VectorStoreRetriever(vectorstore=vector_store)

  2. Dans une nouvelle cellule, exécutez le code suivant pour créer un système AQ à l’aide du récupérateur et du modèle gpt-35-turbo-16k :

     from langchain_openai import AzureChatOpenAI
 from langchain_core.prompts import ChatPromptTemplate
 from langchain.chains.combine_documents import create_stuff_documents_chain
 from langchain.chains import create_retrieval_chain
     
 llm = AzureChatOpenAI(
     deployment_name="gpt-35-turbo-16k",
     model_name="gpt-35-turbo-16k",
     azure_endpoint=endpoint,
     api_version="2023-03-15-preview",
     openai_api_key=key,
 )

 system_prompt = (
     "Use the given context to answer the question. "
     "If you don't know the answer, say you don't know. "
     "Use three sentences maximum and keep the answer concise. "
     "Context: {context}"
 )

 prompt1 = ChatPromptTemplate.from_messages([
     ("system", system_prompt),
     ("human", "{input}")
 ])

 chain = create_stuff_documents_chain(llm, prompt)

 qa_chain1 = create_retrieval_chain(retriever, chain)

  3. Dans une nouvelle cellule, exécutez le code suivant pour tester le système AQ :

     result = qa_chain1.invoke({"input": "What is Azure Databricks?"})
 print(result)

La sortie du résultat doit afficher une réponse basée sur le document pertinent présent dans l’échantillon du jeu de données, ainsi que le texte génératif produit par le LLM.

Combiner des chaînes dans un système à plusieurs chaînes

Langchain est un outil polyvalent qui permet la combinaison de plusieurs chaînes dans un système à plusieurs chaînes, améliorant ainsi les fonctionnalités des modèles linguistiques. Ce processus implique la chaîne de différents composants qui peuvent traiter les entrées en parallèle ou en séquence, synthétisant ainsi une réponse finale.

  1. Dans une nouvelle cellule, exécutez le code suivant pour créer une deuxième chaîne.

     from langchain_core.prompts import ChatPromptTemplate
 from langchain_core.output_parsers import StrOutputParser

 prompt2 = ChatPromptTemplate.from_template("Create a social media post based on this summary: {summary}")

 qa_chain2 = ({"summary": qa_chain1} | prompt2 | llm | StrOutputParser())

  2. Dans une nouvelle cellule, exécutez le code suivant pour appeler une chaîne à plusieurs étapes avec une entrée donnée :

     result = qa_chain2.invoke({"input": "How can we use LangChain?"})
 print(result)

La première chaîne fournit une réponse à l’entrée basée sur l’échantillon du jeu de données fourni, tandis que la deuxième chaîne crée un post de réseau social basé sur la sortie de la première chaîne. Cette approche vous permet de gérer des tâches de traitement de texte plus complexes en chaînant plusieurs étapes ensemble.

Nettoyage

Lorsque vous avez terminé avec votre ressource Azure OpenAI, n’oubliez pas de supprimer le déploiement ou la ressource entière dans le Portail Azure à https://portal.azure.com.

Dans le portail Azure Databricks, sur la page Calcul, sélectionnez votre cluster et sélectionnez ■ Arrêter pour l’arrêter.

Si vous avez terminé d’explorer Azure Databricks, vous pouvez supprimer les ressources que vous avez créées pour éviter les coûts Azure inutiles et libérer de la capacité dans votre abonnement.