AI Engineering Academy : 2.6 Observabilité du RAG - Configuration d'Arize Phoenix

Bienvenue dans ce carnet, où nous verrons comment utiliser Llama Index pour mettre en place et observer la génération de l'amélioration de la recherche (RAG) Rationaliser.

https://github.com/adithya-s-k/AI-Engineering.academy/tree/main/RAG/01_RAG_Observability

bref

Ce guide fournit un tutoriel complet sur la configuration des outils et des bibliothèques nécessaires, y compris les modèles intégrés et les index de stockage vectoriel, pour une recherche de documents et un traitement des requêtes efficaces. Nous couvrons tous les aspects, de l'installation et de la configuration à l'interrogation et à la récupération d'informations pertinentes, pour vous aider à maîtriser les capacités de recherche avancées du pipeline RAG.

introduction (un sujet)

Pour commencer avec ce carnet, vous aurez besoin d'une compréhension de base de Python et d'une certaine familiarité avec les concepts d'apprentissage automatique. Si vous n'êtes pas familier avec ces concepts, ne vous inquiétez pas - nous vous guiderons pas à pas !

conditions préalables

• Python 3.7+
• Jupyter Notebook ou JupyterLab
• Bases de Python et concepts d'apprentissage automatique

1. le réglage

1.1 Installation des logiciels nécessaires

Pour commencer à configurer Arize Phoenix, vous devez installer les logiciels nécessaires.

Arize Phoenix est un outil complet conçu pour l'observabilité et la surveillance des systèmes d'apprentissage automatique et d'IA. Il permet de suivre et d'analyser tous les aspects des modèles d'apprentissage automatique et des pipelines de données.

!pip install arize-phoenix
!pip install openinference-instrumentation-openai

Ces commandes permettent d'installer le logiciel :

• arize-phoenix: Outils pour l'observabilité du flux de travail de l'apprentissage automatique.
• openinference-instrumentation-openaiLes modèles d'OpenAI peuvent être intégrés à des outils d'observabilité tels qu'Arize Phoenix.

1.2 Installation de l'Arize Phoenix

Il y a trois façons d'effectuer les réglages comme suit :

En savoir plus Ici.

• ligne de commande (informatique)

  python3 -m phoenix.server.main serve
  

• Docker démarre l'image docker de phoenix à l'aide de la commande suivante :

  docker run -p 6006:6006 -p 4317:4317 arizephoenix/phoenix:latest
  

  Cela expose l'interface Phoenix et l'API REST à localhost:6006, et expose le point de terminaison gRPC pour les travées à localhost:4317.

• carnets de notes

  import phoenix as px
  px.launch_app()
  

1.3 Importer les bibliothèques nécessaires et configurer l'environnement

Importez les bibliothèques nécessaires et configurez l'environnement avant de procéder au traitement et à l'évaluation des données :

import json
import os
from getpass import getpass
import nest_asyncio
import pandas as pd
from tqdm import tqdm
import phoenix as px
# 允许在笔记本环境中进行并发评估
nest_asyncio.apply()
# 设置 pandas DataFrame 的显示选项以展示更多内容
pd.set_option("display.max_colwidth", 1000)

• json, osPython : bibliothèque Python standard pour la gestion des données JSON et l'interaction avec le système d'exploitation.
• getpass: Un outil pour saisir les mots de passe en toute sécurité.
• nest_asyncio: Permet l'utilisation d'asyncio dans les carnets Jupyter.
• pandas (pd) : une puissante bibliothèque de manipulation de données en Python.
• tqdmLes données de l'enquête doivent être traitées de la même manière que celles de l'enquête précédente, c'est-à-dire avec une barre de progression permettant de suivre l'évolution du traitement des données.
• phoenix (px) : partie de l'outil d'observabilité Arize, fournissant une interface interactive pour explorer les données et surveiller les modèles d'apprentissage automatique.

configurer nest_asyncio pour permettre des évaluations simultanées dans un environnement notebook et pour définir la largeur maximale des colonnes du DataFrame pandas afin d'améliorer la lisibilité.

1.4 Démarrer l'application Phoenix

px.launch_app()

Cette fonction initialise et lance l'application Phoenix, qui s'ouvre dans un nouvel onglet du navigateur par défaut et fournit une interface interactive permettant d'explorer les ensembles de données, de visualiser les performances du modèle et de déboguer.

1.5 Visualisation des sessions de l'application Phoenix

Une fois l'application Phoenix lancée, vous pouvez interagir avec l'application directement dans le bloc-notes à l'aide d'objets de session. Exécutez le code suivant pour lancer l'application Phoenix et l'afficher dans la session en cours :

# 启动并查看 Phoenix 应用会话
(session := px.launch_app()).view()

Cette ligne de code démarre l'application Phoenix et affecte la session à une variable appelée session, à l'aide de la fonction view() La méthode permet d'afficher les applications Phoenix directement dans l'interface de l'ordinateur portable, offrant ainsi une expérience intégrée sans avoir à basculer entre le navigateur et l'ordinateur portable.

1.6 Définir le point final de la trace

Pour envoyer des données de traçage à une application Phoenix à des fins d'analyse et d'observation, définissez l'URL du point de terminaison où l'application Phoenix écoute les données entrantes.

endpoint = "http://127.0.0.1:6006/v1/traces"

endpoint Variable stockant l'URL du point de terminaison utilisé par l'application Phoenix pour écouter les données de traçage entrantes.

2. le suivi de l'OpenAI

Plus d'intégration. Lecture.

2.1 Installer et importer les paquets OpenAI

!pip install openai
import openai

openaiOpenAI : Une bibliothèque client Python pour l'API de l'OpenAI. Elle vous permet d'envoyer des requêtes aux modèles d'OpenAI (y compris GPT-3 et GPT-4) pour une variété de tâches.

2.2 Configuration de la clé API OpenAI

import openai
import os
from getpass import getpass
# 从环境变量中获取 API 密钥，若未设置则提示用户输入
if not (openai_api_key := os.getenv("OPENAI_API_KEY")):
openai_api_key = getpass("🔑 输入您的 OpenAI API 密钥：")
# 为 OpenAI 客户端设置 API 密钥
openai.api_key = openai_api_key
# 将 API 密钥存储到环境变量中以供后续使用
os.environ["OPENAI_API_KEY"] = openai_api_key

• Obtention de la clé API : le code tente d'abord d'obtenir la clé API à partir de la variable d'environnement (OPENAI_API_KEY). Si la clé n'est pas trouvée, l'utilisateur est invité à effectuer une saisie sécurisée via getpass.
• Définir la clé API : La clé API récupérée ou fournie est alors définie comme clé pour la bibliothèque du client OpenAI.
• Stocker la clé de l'API : enfin, stocker la clé de l'API dans une variable d'environnement pour s'assurer qu'elle est toujours disponible pendant la session.

2.3 Configurer OpenTelemetry pour le suivi

Pour activer le traçage de vos interactions OpenAI, configurez OpenTelemetry et mettez en place les composants nécessaires.

from opentelemetry import trace as trace_api
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
# 设置 Tracer 提供程序
tracer_provider = trace_sdk.TracerProvider()
# 定义带有端点的 OTLP Span 导出器
span_exporter = OTLPSpanExporter(endpoint)
# 设置 Span Processor 以处理和导出 spans
span_processor = SimpleSpanProcessor(span_exporter)
# 将 Span Processor 添加到 Tracer 提供程序
tracer_provider.add_span_processor(span_processor)
# 设置全局 Tracer 提供程序
trace_api.set_tracer_provider(tracer_provider)

Bibliothèque OpenTelemetry

Dans le code fourni, plusieurs bibliothèques OpenTelemetry sont utilisées pour mettre en place le traçage. Vous trouverez ci-dessous un aperçu de chaque bibliothèque :

• opentelemetry:correspond à l'anglais -ity, -ism, -ization: bibliothèque de base d'OpenTelemetry, qui fournit des API pour le suivi et les mesures.utilisationModule de création et de gestion de traces : comprend le module de création et de gestion de traces.
• opentelemetry.exporter.otlp.proto.http.trace_exporter:correspond à l'anglais -ity, -ism, -ization: Fournit un exportateur de traces utilisant OTLP (OpenTelemetry Protocol) sur HTTP.utilisation: L'objectif du module est d'assurer la sécurité des personnes et des biens. OTLPSpanExporter est utilisée pour envoyer des données de suivi à un backend compatible avec OTLP et est configurée en définissant des points d'extrémité.
• opentelemetry.sdk.trace:correspond à l'anglais -ity, -ism, -izationLe SDK contient les implémentations du SDK pour le suivi, y compris les éléments suivants TracerProvider.utilisation: :
  • TracerProviderTracer : gère les instances de Tracer et est responsable de l'exportation des travées (unités de travail) collectées dans les traces.
  • SimpleSpanProcessorLe processeur qui synchronise les périodes d'exportation pour traiter et envoyer les données à l'exportateur.
• opentelemetry.sdk.trace.export:correspond à l'anglais -ity, -ism, -ization: Fournit des classes pour l'exportation des données de suivi.utilisation: :
  • SimpleSpanProcessorLe traitement des travées et leur exportation à l'aide de l'exportateur spécifié garantissent que les données sont envoyées au backend pour analyse.

2.4 Instrumenter OpenAI avec OpenInference

Afin d'intégrer OpenTelemetry dans OpenAI et d'activer le suivi pour les interactions du modèle OpenAI, utilisez le suivi à partir de l'option openinference bibliothèques OpenAIInstrumentor.

from openinference.instrumentation.openai import OpenAIInstrumentor
# 实例化并为 OpenAI 应用 instrumentation
OpenAIInstrumentor().instrument()

• OpenAIInstrumentor: A partir de openinference pour l'instrumentation des appels d'API de l'OpenAI afin de permettre le suivi et l'observabilité.
• instrument()Cette méthode configure le client de l'API OpenAI pour qu'il génère et envoie automatiquement des données de traçage au backend OpenTelemetry. Elle intègre les paramètres de trace configurés et vous permet de surveiller et d'analyser le processus d'interaction avec les modèles OpenAI.

En exécutant ce code, vous pouvez vous assurer que tous les appels à l'API OpenAI sont suivis afin d'obtenir des informations détaillées sur l'utilisation et les performances du modèle.

2.5 Faire une demande à l'API OpenAI

Pour interagir avec l'API OpenAI et obtenir une réponse, utilisez le code suivant. Cet exemple montre comment créer une requête de complétion de chat et imprimer les résultats via l'API OpenAI :

import openai
# 创建 OpenAI 客户端实例
client = openai.OpenAI()
# 向 OpenAI API 发起聊天补全请求
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a haiku."}],
)
# 打印响应内容
print(response.choices[0].message.content)

• openai.OpenAI()Initialiser une instance de client OpenAI qui peut être utilisée pour interagir avec l'API OpenAI.
• client.chat.completions.create(): Envoyer une demande à l'API OpenAI pour créer un complément de chat.
  • model="gpt-4o"Spécifiez le nom du modèle utilisé pour générer le complément. Assurez-vous que le nom du modèle est correct et que vous l'avez activé dans votre compte OpenAI API.
  • messages: : Une liste de messages qui inclut l'historique du dialogue. Cet exemple contient une seule demande de message envoyée par l'utilisateur : "Écrire un haïku".
• response.choices[0].message.content: extrait et imprime les compléments générés par le modèle.

3. indice de suivi des lamas

3.1 Installation et importation des bibliothèques requises

!pip install llama-index
!pip install llama-index-core
!pip install llama-index-llms-openai
!pip install openinference-instrumentation-llama-index==2.2.4
!pip install -U llama-index-callbacks-arize-phoenix
!pip install "arize-phoenix[llama-index]"

• llama-index: : Paquet de base pour les fonctionnalités de l'index Llama.
• llama-index-coreLlama Index : fournit les fonctionnalités et les outils de base de Llama Index.
• llama-index-llms-openaiLlama Index : Un paquetage pour intégrer Llama Index avec les modèles OpenAI.
• openinference-instrumentation-llama-index==2.2.4Llama Index : Fournit des outils pour l'instrumentation des interactions de l'index Llama.
• llama-index-callbacks-arize-phoenixIntégration avec les rappels d'Arize Phoenix.
• arize-phoenix[llama-index]Llama Index : Extension d'Arize Phoenix pour prendre en charge le suivi de l'indice Llama.

3.2 Obtenir l'URL de la session Phoenix actuellement active

# 获取当前活动的 Phoenix 会话的 URL
px.active_session().url

Accédez à la session Phoenix en cours et récupérez son URL pour afficher ou partager l'interface Phoenix afin de contrôler et d'analyser les données de suivi.

3.3 Mise en place du suivi de l'indice Llama

Pour mettre en place le suivi OpenTelemetry pour Llama Index, configurez le fournisseur Tracer et intégrez Llama Index Instrumentor.

from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
# 设置 Tracer 提供程序
tracer_provider = trace_sdk.TracerProvider()
# 添加 Span Processor 到 Tracer 提供程序
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))
# 使用 Tracer 提供程序 对 Llama Index 进行 Instrumentation
LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)

• LlamaIndexInstrumentor: A partir de openinference.instrumentation.llama_index pour l'instrumentation de suivi et d'observabilité de l'indice lama.
• trace_sdk.TracerProvider()Initialisation d'un nouveau fournisseur de traceur pour la création et la gestion des données de trace.
• SimpleSpanProcessor: Utilisé pour synchroniser l'exportation des travées et envoyer les données au backend.
• LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)L'instrumentation : Appliquer l'instrumentation à l'index du lama et utiliser le fournisseur Tracer fourni pour le traçage.

3.4 Utilisation de l'OpenAI pour interagir avec l'index des lamas

Pour effectuer une demande d'achèvement via Llama Index en utilisant un modèle OpenAI, utilisez le code suivant :

from llama_index.llms.openai import OpenAI
# 初始化 OpenAI 模型
llm = OpenAI(model="gpt-4o-mini")
# 发起完成请求
resp = llm.complete("Paul Graham is ")
# 打印响应结果
print(resp)

• from llama_index.llms.openai import OpenAI: A partir de llama_index pour importer des classes OpenAI afin de permettre l'interaction avec les modèles OpenAI.
• OpenAI(model="gpt-4o-mini")Initialiser l'instance de classe OpenAI avec le modèle spécifié (par exemple gpt-4).
• llm.complete(...): Envoi d'un texte d'invite au modèle pour générer le contenu de la réponse.

3.5 Interaction par chat avec l'index des lamas à l'aide de l'OpenAI

from llama_index.llms.openai import OpenAI
from llama_index.core.llms import ChatMessage
# 初始化 OpenAI 模型
llm = OpenAI()
# 定义聊天消息
messages = [
ChatMessage(
role="system", content="You are a pirate with a colorful personality"
),
ChatMessage(role="user", content="What is your name"),
]
# 获取模型的响应结果
resp = llm.chat(messages)

• OpenAIClasses utilisées pour interagir avec les modèles OpenAI.
• ChatMessageClasse de formatage des messages de chat.
• OpenAI()Initialisation d'une instance de la classe OpenAI.
• ChatMessage: crée un objet message de chat, en spécifiant le rôle (par exemple, "système", "utilisateur") et le contenu du message.
  • role="system"Définir les messages du système pour définir le contexte ou la personnalité du modèle.
  • role="user": Représente un message envoyé par l'utilisateur.
• llm.chat(messages)Le modèle : envoie le message défini au modèle et reçoit le résultat de la réponse.

Ce code interagit avec le modèle OpenAI par le biais des paramètres du système et des messages de l'utilisateur pour le chat.

4. observation du processus RAG

4.1 Mise en place de l'environnement d'observation du processus RAG

!pip install llama-index
!pip install llama-index-vector-stores-qdrant
!pip install llama-index-readers-file
!pip install llama-index-embeddings-fastembed
!pip install llama-index-llms-openai
!pip install -U qdrant_client fastembed

• llama-index: Paquet de base pour les fonctionnalités de l'index Llama.
• llama-index-vector-stores-qdrantQdrant : Intégrer Qdrant comme magasin de vecteurs pour Llama Index.
• llama-index-readers-file: Fournit des capacités de lecture de fichiers pour l'index Llama.
• llama-index-embeddings-fastembed: support FastEmbed pour Llama Index pour la génération d'embeddings vectoriels.
• llama-index-llms-openaiLlama Index : Intégration des modèles OpenAI dans Llama Index.
• qdrant_clientQdrant : bibliothèque côté client pour interagir avec Qdrant, un moteur de recherche vectoriel.
• fastembed: Bibliothèque pour la génération rapide de vecteurs d'encastrement.

4.2 Préparation d'un processus RAG à l'aide de l'intégration et de l'indexation de documents

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.embeddings.fastembed import FastEmbedEmbedding
# from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core.settings import Settings
Settings.embed_model = FastEmbedEmbedding(model_name="BAAI/bge-base-en-v1.5")
# Settings.embed_model = OpenAIEmbedding(embed_batch_size=10)
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

• VectorStoreIndexClasses pour la création et la gestion d'index vectoriels. L'index permet d'effectuer une recherche de similarité efficace et une récupération basée sur les vecteurs de documents.
• SimpleDirectoryReaderClasse qui lit les documents à partir d'un répertoire spécifié et traite les fichiers chargés en vue de l'indexation.
• FastEmbedEmbeddingClasse de modèle d'intégration pour générer des vecteurs d'intégration de texte à l'aide de la bibliothèque FastEmbed. Spécifiez le nom du modèle comme suit "BAAI/bge-base-en-v1.5".
• from llama_index.embeddings.openai import OpenAIEmbedding: :
  • OpenAIEmbedding: La classe de modèle d'intégration utilisée pour générer des vecteurs via le service d'intégration d'OpenAI. Elle est commentée par défaut. Si vous souhaitez utiliser un modèle OpenAI au lieu de FastEmbed, vous pouvez le décommenter et configurer les paramètres, tels que embed_batch_size.
• SettingsClasse permettant de définir la configuration globale du modèle d'intégration. La configuration globale du modèle d'intégration peut être définie en donnant à la classe embed_model qui spécifie le modèle d'intégration à utiliser.
• Settings.embed_model = FastEmbedEmbedding(model_name="BAAI/bge-base-en-v1.5")Utilisation globale : Mise en place d'une utilisation globale FastEmbedEmbedding comme modèle de vecteur d'intégration.
• documents = SimpleDirectoryReader("data").load_data(): Extrait du catalogue "data" Charger et prétraiter les données des documents. Veiller à ce que les noms de répertoire soient adaptés au chemin d'accès réel du projet.
• index = VectorStoreIndex.from_documents(documents)Création d'un index vectoriel basé sur des documents prétraités. Cette étape met en œuvre une représentation vectorielle du document et permet des requêtes basées sur les vecteurs.

4.3 Index de stockage des vecteurs de requête

Une fois l'index vectoriel mis en place, vous pouvez l'utiliser pour effectuer des requêtes et récupérer des informations pertinentes.

query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")
print(response)

• as_query_engine(): : Will VectorStoreIndex Convertir en moteur de requête. Ce moteur permet d'effectuer des recherches et d'extraire des informations sur la base d'une représentation vectorielle des documents stockés dans un index.
• query(): Exécuter une requête sur l'index d'un magasin de vecteurs. La chaîne de requête "Qu'est-ce que l'auteur a fait dans sa jeunesse ?" est utilisée pour rechercher des documents pertinents et extraire des informations basées sur le contexte fourni par l'encastrement vectoriel.

Enfin.response Contient des informations extraites d'index de stockage vectoriel générés à partir de requêtes et de documents d'index.

rendre un verdict

Dans ce guide, nous avons mis en place un processus de Génération Augmentée de Récupération (RAG) en utilisant Llama Index et nous l'avons intégré avec différents composants pour observer sa fonctionnalité. Nous avons d'abord configuré et installé les bibliothèques nécessaires, y compris Llama Index, OpenTelemetry et divers modèles d'intégration.

Nous avons ensuite procédé comme suit :

• Initialiser et configurer le modèle d'intégration, en utilisant les modèles FastEmbed ou OpenAI si nécessaire.
• Charge et indexe les documents du catalogue afin de préparer les données pour l'interrogation.
• Configurer le moteur de recherche pour effectuer des recherches et extraire des informations pertinentes sur la base des documents indexés.

En suivant ces étapes, vous avez préparé avec succès un processus RAG qui permet une recherche efficace de documents et un traitement des requêtes. La configuration fournit des capacités avancées de recherche et d'extraction d'informations en utilisant l'incorporation et l'indexation vectorielles.

N'hésitez pas à expérimenter différentes configurations et requêtes pour explorer davantage les capacités du processus RAG. Si vous avez des questions ou si vous avez besoin d'une personnalisation plus poussée, veuillez consulter la documentation de la bibliothèque que vous utilisez ou obtenir des conseils supplémentaires.