AI Engineering Academy: 2.6 Observabilidade do RAG - Configuração do Arize Phoenix

Bem-vindo a este notebook, onde exploraremos como usar o Llama Index para configurar e observar a geração de aprimoramento de recuperação (RAG) Simplificar.

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

breve

Este guia fornece um tutorial completo sobre a configuração das ferramentas e bibliotecas necessárias, incluindo modelos incorporados e índices de armazenamento de vetores, para recuperação eficiente de documentos e processamento de consultas. Abordaremos tudo, desde a instalação e a configuração até a consulta e a recuperação de informações relevantes, para ajudá-lo a se familiarizar com os recursos avançados de pesquisa do pipeline do RAG.

introdução (um assunto)

Para começar a usar este notebook, você precisará de um conhecimento básico de Python e alguma familiaridade com os conceitos de aprendizado de máquina. Se você não estiver familiarizado com esses conceitos, não se preocupe - nós o orientaremos passo a passo!

pré-condições

• Python 3.7+
• Jupyter Notebook ou JupyterLab
• Noções básicas de Python e conceitos de aprendizado de máquina

1. configuração

1.1 Instalação dos pacotes de software necessários

Para começar a configurar o Arize Phoenix, você precisará instalar os pacotes de software necessários.

O Arize Phoenix é uma ferramenta abrangente projetada para observabilidade e monitoramento de sistemas de aprendizado de máquina e IA. Ele oferece a capacidade de rastrear e analisar todos os aspectos dos modelos de aprendizado de máquina e pipelines de dados.

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

Esses comandos serão instalados:

• arize-phoenixFerramentas para observabilidade do fluxo de trabalho de aprendizado de máquina.
• openinference-instrumentation-openaiPacotes para integração de modelos OpenAI com ferramentas de observabilidade, como o Arize Phoenix.

1.2 Configuração do Arize Phoenix

Há três maneiras de concluir as configurações, como segue:

Leia mais Aqui.

• linha de comando (computação)

  python3 -m phoenix.server.main serve
  

• O Docker inicia a imagem do Docker do phoenix usando o seguinte comando:

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

  Isso expõe a UI do Phoenix e a API REST para localhost:6006 e expõe o ponto de extremidade gRPC para spans para localhost:4317.

• cadernos

  importar phoenix como px
  px.launch_app()
  

1.3 Importar as bibliotecas necessárias e configurar o ambiente

Importe as bibliotecas necessárias e configure o ambiente antes de prosseguir com o processamento e a avaliação dos dados:

importar json
importar os
from getpass import getpass
import nest_asyncio
import pandas as pd
from tqdm import tqdm
import phoenix as px
O # permite a avaliação simultânea em um ambiente de laptop
nest_asyncio.apply()
# Definir opções de exibição para DataFrame do pandas para mostrar mais conteúdo
pd.set_option("display.max_colwidth", 1000)

• json, osBiblioteca Python padrão para lidar com dados JSON e interação com o sistema operacional.
• getpassFerramenta para inserir senhas de forma segura.
• nest_asyncioPermite o uso de asyncio em notebooks Jupyter.
• pandas (pd): uma biblioteca avançada de manipulação de dados em Python.
• tqdmBarra de progresso: Forneça uma barra de progresso para que o loop acompanhe o progresso do processamento de dados.
• fênix (px): parte da Arize Observability Tool, que fornece uma interface de usuário interativa para explorar dados e monitorar modelos de aprendizado de máquina.

configurar nest_asyncio para permitir avaliações simultâneas em um ambiente de notebook e para definir a largura máxima da coluna do DataFrame do pandas para melhorar a legibilidade.

1.4 Início do aplicativo Phoenix

px.launch_app()

Essa função inicializa e inicia o aplicativo Phoenix, que abre em uma nova guia do navegador padrão e fornece uma interface interativa para explorar conjuntos de dados, visualizar o desempenho do modelo e depurar.

1.5 Visualização das sessões do aplicativo Phoenix

Depois que o aplicativo Phoenix é iniciado, você pode interagir com ele diretamente no notebook usando objetos de sessão. Execute o código a seguir para iniciar o aplicativo Phoenix e visualizá-lo na sessão atual:

# Iniciar e visualizar uma sessão do aplicativo Phoenix
(sessão := px.launch_app()).view()

Essa linha de código inicia o aplicativo Phoenix e atribui a sessão a uma variável chamada session, usando o parâmetro view() O método exibe os aplicativos Phoenix diretamente na interface do notebook, proporcionando uma experiência integrada sem a necessidade de alternar entre o navegador e o notebook.

1.6 Definição do ponto final do rastreamento

Para enviar dados de rastreamento a um aplicativo Phoenix para análise e observação, defina o URL do endpoint em que o aplicativo Phoenix escuta os dados recebidos.

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

ponto final Variável que armazena o URL do endpoint usado pelo aplicativo Phoenix para escutar os dados de rastreamento recebidos.

2. rastreamento da OpenAI

Mais integração. Leitura.

2.1 Instalar e importar os pacotes do OpenAI

!pip install openai
importar openai

openaiBiblioteca de cliente Python para a API da OpenAI: Uma biblioteca de cliente Python para a API da OpenAI. Ela permite que você envie solicitações aos modelos da OpenAI (incluindo GPT-3 e GPT-4) para uma variedade de tarefas.

2.2 Configuração da chave de API da OpenAI

importar openai
importar os
from getpass import getpass
# Obtenha a chave da API da variável de ambiente; se não estiver definida, solicite-a ao usuário
if not (openai_api_key := os.getenv("OPENAI_API_KEY")):: openai_api_key = getpass("🖩")
openai_api_key = getpass("🔑 Digite sua chave de API do OpenAI:")
# Definir a chave de API para um cliente OpenAI
openai.api_key = openai_api_key
O # armazena a chave de API em uma variável de ambiente para uso posterior
os.environ["OPENAI_API_KEY"] = openai_api_key

• Obtenção da chave de API: o código primeiro tenta obter a chave de API da variável de ambiente (OPENAI_API_KEY). Se a chave não for encontrada, o usuário será solicitado a fornecer uma entrada segura por meio de getpass.
• Definir chave de API: a chave de API recuperada ou fornecida é definida como a chave da biblioteca do cliente OpenAI.
• Armazenar a chave da API: por fim, armazene a chave da API em uma variável de ambiente para garantir que ela esteja sempre disponível durante a sessão.

2.3 Configuração do OpenTelemetry para rastreamento

Para ativar o rastreamento de suas interações com o OpenAI, configure o OpenTelemetry e defina os componentes necessários.

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
# Configuração do provedor de rastreamento
tracer_provider = trace_sdk.TracerProvider()
# Definir o exportador OTLP Span com pontos de extremidade
span_exporter = OTLPSpanExporter(endpoint)
# Configurar o Span Processor para processar e exportar spans
span_processor = SimpleSpanProcessor(span_exporter)
# Adicionar o processador de span ao provedor Tracer
tracer_provider.add_span_processor(span_processor)
# Configurar o provedor global de rastreamento
trace_api.set_tracer_provider(tracer_provider)

Biblioteca OpenTelemetry

No código fornecido, várias bibliotecas OpenTelemetry são usadas para configurar o rastreamento. Abaixo está uma visão geral de cada biblioteca:

• opentelemetria:corresponde ao inglês -ity, -ism, -izationOpenTelemetry: biblioteca principal do OpenTelemetry, que fornece APIs para rastreamento e métricas.usoInclui o módulo de rastreamento para criar e gerenciar rastreamentos.
• opentelemetry.exporter.otlp.proto.http.trace_exporter:corresponde ao inglês -ity, -ism, -izationHTTP: fornece um exportador de rastreamento usando OTLP (OpenTelemetry Protocol) por HTTP.uso: O módulo OTLPSpanExporter é usada para enviar dados de rastreamento para um back-end compatível com OTLP e é configurada pela definição de pontos de extremidade.
• opentelemetry.sdk.trace:corresponde ao inglês -ity, -ism, -izationImplementações de SDK para rastreamento, incluindo Provedor de rastreamento.uso::
  • Provedor de rastreamentoGerencia as instâncias do Tracer e é responsável por exportar os intervalos (unidades de trabalho) coletados nos traços.
  • SimpleSpanProcessorProcessador: Um processador que sincroniza os períodos de exportação para processar e enviar dados ao exportador.
• opentelemetry.sdk.trace.export:corresponde ao inglês -ity, -ism, -izationDados de rastreamento: fornece classes para exportação de dados de rastreamento.uso::
  • SimpleSpanProcessorProcessamento de períodos e exportação usando o exportador especificado garante que os dados sejam enviados ao back-end para análise.

2.4 Instrumentando o OpenAI com o OpenInference

Para integrar o OpenTelemetry ao OpenAI e permitir o rastreamento das interações do modelo do OpenAI, use os dados do openinference bibliotecas OpenAIInstrumentor.

from openinference.instrumentation.openai import OpenAIInstrumentor
O # instancia e aplica a instrumentação ao OpenAI
OpenAIInstrumentor().instrument()

• OpenAIInstrumentor: De openinference classes de biblioteca para instrumentação das chamadas de API da OpenAI para permitir o rastreamento e a observabilidade.
• instrumento()Método de rastreamento: Esse método configura o cliente da API do OpenAI para gerar e enviar automaticamente dados de rastreamento para o backend do OpenTelemetry. Ele integra as definições de rastreamento configuradas e permite que você monitore e analise o processo de interação com os modelos do OpenAI.

Ao executar esse código, você pode garantir que todas as chamadas da API da OpenAI sejam rastreadas para obter insights detalhados sobre o uso e o desempenho do modelo.

2.5 Fazer uma solicitação à API da OpenAI

Para interagir com a API da OpenAI e obter uma resposta, use o código a seguir. Este exemplo mostra como criar uma solicitação de conclusão de chat e imprimir os resultados por meio da API do OpenAI:

import openai
# Crie uma instância do cliente OpenAI
cliente = openai.OpenAI()
O # faz uma solicitação de conclusão de bate-papo para a API do OpenAI
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a haiku."}],
)
# Imprimir o conteúdo da resposta
print(response.choices[0].message.content)

• openai.OpenAI()Inicialização de uma instância de cliente OpenAI que pode ser usada para interagir com a API OpenAI.
• client.chat.completions.create()API do OpenAI: envia uma solicitação à API do OpenAI para criar um complemento de bate-papo.
  • modelo="gpt-4o"Nome do modelo: Especifique o nome do modelo usado para gerar o complemento. Verifique se o nome do modelo está correto e se você o ativou em sua conta da API OpenAI.
  • mensagens:: Uma lista de mensagens que inclui o histórico do diálogo. Este exemplo contém uma única solicitação de mensagem enviada pelo usuário: "Write a haiku".
• response.choices[0].message.contentExtrai e imprime complementos gerados por modelos.

3. índice de rastreamento de lhamas

3.1 Instalação e importação das bibliotecas necessárias

!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]"

• índice de lhamas:: Pacote principal para a funcionalidade do Índice Llama.
• llama-index-coreLlama Index: Fornece a funcionalidade e as ferramentas principais do Llama Index.
• llama-index-llms-openaiLlama Index: Um pacote para integrar o Llama Index com modelos OpenAI.
• openinference-instrumentation-llama-index==2.2.4Llama Index: fornece ferramentas para instrumentação das interações do Llama Index.
• llama-index-callbacks-arize-phoenixIntegração com callbacks do Arize Phoenix: fornece integração com callbacks do Arize Phoenix.
• arize-phoenix [llama-index]Extensão do Arize Phoenix para suportar o rastreamento do Índice Llama.

3.2 Obtenção do URL da sessão do Phoenix ativa no momento

# Obtenha o URL da sessão do Phoenix ativa no momento
px.active_session().url

Acesse a sessão do Phoenix ativa no momento e recupere seu URL para visualizar ou compartilhar a interface do Phoenix para monitorar e analisar dados de rastreamento.

3.3 Configuração do rastreamento do Llama Index

Para configurar o rastreamento OpenTelemetry para o Llama Index, configure o provedor Tracer e integre o 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
# Configuração do provedor de rastreamento
tracer_provider = trace_sdk.TracerProvider()
# Adicionar o Span Processor ao provedor de rastreamento
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))
# Instrumentação do Llama Index usando o Tracer Provider
LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)

• LlamaIndexInstrumentor: De openinference.instrumentation.llama_index classe para instrumentação de rastreamento e observabilidade do Llama Index.
• trace_sdk.TracerProvider()Inicialização de um novo provedor Tracer para criar e gerenciar dados de rastreamento.
• SimpleSpanProcessorUsado para sincronizar a exportação de períodos e enviar os dados para o back-end.
• LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)Aplique instrumentação ao Llama Index e use o provedor Tracer fornecido para rastreamento.

3.4 Uso do OpenAI para interagir com o Llama Index

Para executar uma solicitação de conclusão por meio do Llama Index usando um modelo OpenAI, use o seguinte código:

from llama_index.llms.openai import OpenAI
# Inicializar o modelo OpenAI
llm = OpenAI(model="gpt-4o-mini")
O # inicia uma solicitação de conclusão
resp = llm.complete("Paul Graham is ")
# Imprime a resposta
print(resp)

• de llama_index.llms.openai import OpenAI: De índice_lama para importar classes OpenAI e permitir a interação com modelos OpenAI.
• OpenAI(model="gpt-4o-mini")Inicialização da instância da classe OpenAI com o modelo especificado (por exemplo, gpt-4).
• llm.complete(...)Texto de solicitação: envia texto de solicitação ao modelo para gerar conteúdo de resposta.

3.5 Interação de bate-papo com o Llama Index usando OpenAI

from llama_index.llms.openai import OpenAI
from llama_index.core.llms import ChatMessage
# Inicializar o modelo OpenAI
llm = OpenAI()
# Definir ChatMessage
messages = [
ChatMessage(
role="system", content="Você é um pirata com uma personalidade colorida"
),
ChatMessage(role="user", content="What is your name"), ]
]
# Obter os resultados da resposta do modelo
resp = llm.chat(mensagens)

• OpenAIClasses usadas para interagir com modelos OpenAI.
• ChatMessageClasse para formatação de mensagens de bate-papo.
• OpenAI()Inicialização de uma instância da classe OpenAI.
• ChatMessageMensagem de bate-papo: cria um objeto de mensagem de bate-papo, especificando a função (por exemplo, "sistema", "usuário") e o conteúdo da mensagem.
  • role="system" (função = "sistema")Mensagens do sistema: Defina mensagens do sistema para definir o contexto ou a personalidade do modelo.
  • role="user"Mensagem: Representa uma mensagem enviada pelo usuário.
• llm.chat(mensagens)Mensagem de resposta: envia a mensagem definida para o modelo e recebe o resultado da resposta.

Esse código interage com o modelo OpenAI por meio de configurações de mensagens do sistema e do usuário para bate-papo.

4. observação do processo RAG

4.1 Configuração do ambiente para observar o processo do 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

• índice de lhamasLlama Index: pacote principal para a funcionalidade do Llama Index.
• llama-index-vector-stores-qdrantQdrant: integre o Qdrant como um armazenamento de vetores para o Llama Index.
• llama-index-readers-fileLlama Index: Fornece recursos de leitura de arquivos para o Llama Index.
• llama-index-embeddings-fastembedFastEmbed: suporte do FastEmbed para o Llama Index para gerar embeddings de vetores.
• llama-index-llms-openaiIntegração de modelos OpenAI no Llama Index: integração de modelos OpenAI no Llama Index.
• qdrant_clientQdrant: biblioteca do lado do cliente para interagir com o Qdrant, um mecanismo de pesquisa de vetores.
• incorporação rápidaBiblioteca para geração rápida de vetores de incorporação.

4.2 Preparação de um processo RAG usando incorporação e indexação de documentos

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)
documentos = SimpleDirectoryReader("data").load_data()
índice = VectorStoreIndex.from_documents(documents)

• VectorStoreIndexClasses para criar e gerenciar índices de armazenamento de vetores. O índice realiza pesquisa e recuperação de similaridade eficientes com base em vetores de documentos.
• SimpleDirectoryReaderClasse que lê documentos de um diretório especificado e pré-processa os arquivos carregados para indexação.
• FastEmbedEmbeddingClasse de modelo de incorporação para gerar vetores de incorporação de texto usando a biblioteca FastEmbed. Especifique o nome do modelo como "BAAI/bge-base-en-v1.5".
• from llama_index.embeddings.openai import OpenAIEmbedding::
  • OpenAIEmbeddingClasse de modelo de incorporação: A classe de modelo de incorporação usada para gerar vetores por meio do serviço de incorporação da OpenAI. Ela é comentada por padrão. Se desejar usar um modelo OpenAI em vez do FastEmbed, você pode descomentá-lo e configurar os parâmetros, como embed_batch_size.
• ConfiguraçõesClasse para definir a configuração global do modelo de incorporação. Isso é feito fornecendo o parâmetro embed_model que especifica o modelo de incorporação a ser usado.
• Settings.embed_model = FastEmbedEmbedding(model_name="BAAI/bge-base-en-v1.5")Configuração do uso global FastEmbedEmbedding como um modelo de vetor de incorporação.
• documents = SimpleDirectoryReader("data").load_data()Do catálogo "dados" Carregar e pré-processar os dados do documento. Certifique-se de que os nomes dos diretórios sejam ajustados ao caminho real do projeto.
• índice = VectorStoreIndex.from_documents(documents)Crie um índice de armazenamento de vetores com base em documentos pré-processados. Essa etapa implementa uma representação vetorizada do documento e permite consultas baseadas em vetores.

4.3 Índice de armazenamento do vetor de consulta

Depois que o índice do armazenamento de vetores estiver configurado, você poderá usá-lo para realizar consultas e recuperar informações relevantes.

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

• as_query_engine():: Will VectorStoreIndex Converter em um mecanismo de consulta. Esse mecanismo permite que você faça pesquisas e recupere informações com base em uma representação vetorial de documentos armazenados em um índice.
• consulta()Executar uma consulta em um índice de armazenamento de vetores. A string de consulta "What did the author do growing up?" é usada para pesquisar documentos relevantes e recuperar informações com base no contexto fornecido pela incorporação do vetor.

Finalmente.resposta Contém informações recuperadas de índices de armazenamento vetorial que são gerados com base em consultas e documentos de índice.

chegar a um veredicto

Neste guia, configuramos um processo RAG (Retrieval Augmented Generation) usando o Llama Index e o integramos a vários componentes para observar sua funcionalidade. Primeiro, configuramos e instalamos as bibliotecas necessárias, incluindo o Llama Index, o OpenTelemetry e vários modelos de incorporação.

Em seguida, fizemos o seguinte:

• Inicialize e configure o modelo de incorporação, usando os modelos FastEmbed ou OpenAI, se necessário.
• Carrega e indexa documentos do catálogo para preparar os dados para consulta.
• Configure o mecanismo de consulta para realizar pesquisas e recuperar informações relevantes com base em documentos indexados.

Ao seguir essas etapas, você preparou com êxito um processo RAG que permite a recuperação eficiente de documentos e o processamento de consultas. A configuração fornece recursos avançados de pesquisa e recuperação de informações usando incorporação e indexação baseadas em vetores.

Sinta-se à vontade para experimentar diferentes configurações e consultas para explorar melhor os recursos do processo RAG. Se tiver alguma dúvida ou precisar de mais personalização, consulte a documentação da biblioteca que estiver usando ou para obter mais orientações.

O guia do leigo para começar a usar a IA

Ajuda você a aprender a utilizar as ferramentas de IA com baixo custo e a partir de uma base zero.A IA, assim como o software de escritório, é uma habilidade essencial para todos. Dominar a IA lhe dará uma vantagem em sua busca de emprego e metade do esforço em seu trabalho e estudos futuros.

Ver detalhes>