Geração Aumentada de Recuperação usando o Azure Databricks

A RAG (Geração Aumentada de Recuperação) é uma abordagem de ponta em IA que aprimora grandes modelos de linguagem integrando fontes de conhecimento externas. O Azure Databricks oferece uma plataforma robusta para o desenvolvimento de aplicativos RAG, permitindo a transformação de dados não estruturados em um formato adequado para recuperação e geração de respostas. Esse processo envolve uma série de etapas, incluindo a compreensão da consulta do usuário, a recuperação de dados relevantes e a geração de uma resposta usando um modelo de linguagem. A estrutura fornecida pelo Azure Databricks dá suporte à iteração e implantação rápidas de aplicativos RAG, garantindo respostas específicas de domínio de alta qualidade que podem incluir informações atualizadas e conhecimento proprietário.

Este laboratório levará aproximadamente 40 minutos para ser concluído.

Observação: a interface do usuário do Azure Databricks está sujeita a melhorias contínuas. A interface do usuário pode ter sido alterada desde que as instruções neste exercício foram escritas.

Antes de começar

É necessário ter uma assinatura do Azure com acesso de nível administrativo.

Provisionar um workspace do Azure Databricks

Dica: Se você já tem um workspace do Azure Databricks, pode ignorar esse procedimento e usar o workspace existente.

Este exercício inclui um script para provisionar um novo workspace do Azure Databricks. O script tenta criar um recurso de workspace do Azure Databricks de camada Premium em uma região na qual sua assinatura do Azure tenha cota suficiente para os núcleos de computação necessários para este exercício; e pressupõe que sua conta de usuário tenha permissões suficientes na assinatura para criar um recurso de workspace do Azure Databricks. Se o script falhar devido a cota ou permissões insuficientes, você pode tentar criar um workspace do Azure Databricks interativamente no portal do Azure.

Em um navegador da web, faça logon no portal do Azure em https://portal.azure.com.
Use o botão [>_] à direita da barra de pesquisa na parte superior da página para criar um Cloud Shell no portal do Azure selecionando um ambiente do PowerShell. O Cloud Shell fornece uma interface de linha de comando em um painel na parte inferior do portal do Azure, conforme mostrado aqui:

Observação: se você já criou um Cloud Shell que usa um ambiente Bash, alterne-o para o PowerShell.
Você pode redimensionar o Cloud Shell arrastando a barra de separação na parte superior do painel ou usando os ícones —, ⤢ e X no canto superior direito do painel para minimizar, maximizar e fechar o painel. Para obter mais informações de como usar o Azure Cloud Shell, confira a documentação do Azure Cloud Shell.

No painel do PowerShell, insira os seguintes comandos para clonar esse repositório:

rm -r mslearn-databricks -f
git clone https://github.com/MicrosoftLearning/mslearn-databricks

Depois que o repositório tiver sido clonado, insira o seguinte comando para executar setup.ps1 do script, que provisiona um workspace do Azure Databricks em uma região disponível:
```
./mslearn-databricks/setup.ps1
```
Se solicitado, escolha qual assinatura você deseja usar (isso só acontecerá se você tiver acesso a várias assinaturas do Azure).
Aguarde a conclusão do script – isso normalmente leva cerca de 5 minutos, mas em alguns casos pode levar mais tempo.

Criar um cluster

O Azure Databricks é uma plataforma de processamento distribuído que usa clusters do Apache Spark para processar dados em paralelo em vários nós. Cada cluster consiste em um nó de driver para coordenar o trabalho e nós de trabalho para executar tarefas de processamento. Neste exercício, você criará um cluster de nó único para minimizar os recursos de computação usados no ambiente de laboratório (no qual os recursos podem ser restritos). Em um ambiente de produção, você normalmente criaria um cluster com vários nós de trabalho.

Dica: Se você já tiver um cluster com a versão 16.4 LTS ML ou superior do runtime no workspace do Azure Databricks, poderá usá-lo para concluir este exercício e pular este procedimento.

No portal do Azure, navegue até o grupo de recursos msl-xxxxxxx criado pelo script (ou o grupo de recursos que contém seu workspace do Azure Databricks existente)
Selecione o recurso Serviço do Azure Databricks (chamado databricks-xxxxxxx se você usou o script de instalação para criá-lo).
Na página Visão geral do seu workspace, use o botão Iniciar workspace para abrir seu workspace do Azure Databricks em uma nova guia do navegador, fazendo o logon se solicitado.

Dica: ao usar o portal do workspace do Databricks, várias dicas e notificações podem ser exibidas. Dispense-as e siga as instruções fornecidas para concluir as tarefas neste exercício.
Na barra lateral à esquerda, selecione a tarefa (+) Novo e, em seguida, selecione Cluster.
Na página Novo Cluster, crie um novo cluster com as seguintes configurações:
- Nome do cluster: cluster Nome do Usuário (o nome do cluster padrão)
- Política: Sem restrições
- Machine learning: Habilitado
- Databricks Runtime: 16.4-LTS
- Usa a Aceleração do Photon: Não selecionado
- Tipo de trabalho: Standard_D4ds_v5
- Nó único: Marcado
Aguarde a criação do cluster. Isso pode levar alguns minutos.

Observação: se o cluster não for iniciado, sua assinatura pode ter cota insuficiente na região onde seu workspace do Azure Databricks está provisionado. Consulte Limite de núcleo da CPU impede a criação do cluster para obter detalhes. Se isso acontecer, você pode tentar excluir seu workspace e criar um novo workspace em uma região diferente. Você pode especificar uma região como um parâmetro para o script de instalação da seguinte maneira: ./mslearn-databricks/setup.ps1 eastus

Instalar as bibliotecas necessárias

Na barra lateral, use o link (+) Novo para criar um Notebook. Na lista suspensa Conectar, selecione o cluster caso ainda não esteja selecionado. Se o cluster não executar, é porque ele pode levar cerca de um minuto para iniciar.
Na primeira célula de código, insira e execute o seguinte código para instalar as bibliotecas necessárias:
```
%pip install faiss-cpu
dbutils.library.restartPython()
```

Ingerir dados

Em uma nova guia do navegador, baixe o exemplo de arquivo que será usado como dados neste exercício: https://github.com/MicrosoftLearning/mslearn-databricks/raw/main/data/enwiki-latest-pages-articles.xml
De volta à guia do workspace do Databricks, com o bloco de notas aberto, selecione o explorador de Catálogo (CTRL + Alt + C) e selecione o ícone ➕ para Adicionar dados.
Na página Adicionar dados, selecione Carregar arquivos no DBFS.
Na página DBFS, dê ao diretório de destino o nome RAG_lab e carregue o arquivo .xml salvo antes.
Na barra lateral, selecione Workspace e abra o bloco de notas novamente.

Em uma nova célula de código, insira o seguinte código para criar um dataframe com base nos dados brutos:

from pyspark.sql import SparkSession

# Create a Spark session
spark = SparkSession.builder \
    .appName("RAG-DataPrep") \
    .getOrCreate()

# Read the XML file
raw_df = spark.read.format("xml") \
    .option("rowTag", "page") \
    .load("/FileStore/tables/RAG_lab/enwiki_latest_pages_articles.xml")

# Show the DataFrame
raw_df.show(5)

# Print the schema of the DataFrame
raw_df.printSchema()

Use a opção de menu ▸ Executar Célula à esquerda da célula para executá-la. Em seguida, aguarde o término do trabalho do Spark executado pelo código.

Em uma nova célula, execute o seguinte código para limpar e pré-processar os dados para extrair os campos de texto relevantes:

from pyspark.sql.functions import col

clean_df = raw_df.select(col("title"), col("revision.text._VALUE").alias("text"))
clean_df = clean_df.na.drop()
clean_df.show(5)

Gerar incorporações e implementar a busca em vetores

A FAISS (Pesquisa de Similaridade de IA do Facebook) é uma biblioteca de banco de dados vetorial de software livre desenvolvida pela IA da Meta, projetada para pesquisa de similaridade eficiente e clustering de vetores densos. A FAISS permite pesquisas de vizinhos mais próximos rápidas e escalonáveis e pode ser integrada a sistemas de pesquisa híbrida para combinar similaridade baseada em vetor com técnicas tradicionais baseadas em palavras-chave, aprimorando a relevância dos resultados da pesquisa.

Em uma nova célula, execute o seguinte código para carregar o modelo pré-treinado all-MiniLM-L6-v2 e converter texto em incorporações:

from sentence_transformers import SentenceTransformer
import numpy as np
    
# Load pre-trained model
model = SentenceTransformer('all-MiniLM-L6-v2')
    
# Function to convert text to embeddings
def text_to_embedding(text):
    embeddings = model.encode([text])
    return embeddings[0]
    
# Convert the DataFrame to a Pandas DataFrame
pandas_df = clean_df.toPandas()
    
# Apply the function to get embeddings
pandas_df['embedding'] = pandas_df['text'].apply(text_to_embedding)
embeddings = np.vstack(pandas_df['embedding'].values)

Em uma nova célula, execute o seguinte código para criar e consultar o índice FAISS:

import faiss
    
# Create a FAISS index
d = embeddings.shape[1]  # dimension
index = faiss.IndexFlatL2(d)  # L2 distance
index.add(embeddings)  # add vectors to the index
    
# Perform a search
query_embedding = text_to_embedding("Anthropology fields")
k = 1  # number of nearest neighbors
distances, indices = index.search(np.array([query_embedding]), k)
    
# Get the results
results = pandas_df.iloc[indices[0]]
display(results)

Verifique se a saída localiza a página Wiki correspondente relacionada ao prompt de consulta.

Aumentar prompts com dados recuperados

Agora podemos aprimorar os recursos de grandes modelos de linguagem, fornecendo-lhes contexto adicional de fontes de dados externos. Ao fazer isso, os modelos podem gerar respostas mais precisas e contextualmente relevantes.

Em uma nova célula, execute o código a seguir para combinar os dados recuperados com a consulta do usuário para criar um prompt avançado para o LLM.

from transformers import pipeline
    
# Load the summarization model
summarizer = pipeline("summarization", model="facebook/bart-large-cnn", framework="pt")
    
# Extract the string values from the DataFrame column
text_data = results["text"].tolist()
    
# Pass the extracted text data to the summarizer function
summary = summarizer(text_data, max_length=512, min_length=100, do_sample=True)
    
def augment_prompt(query_text):
    context = " ".join([item['summary_text'] for item in summary])
    return f"{context}\n\nQuestion: {query_text}\nAnswer:"
    
prompt = augment_prompt("Explain the significance of Anthropology")
print(prompt)

Em uma nova célula, execute o código a seguir para usar um LLM para gerar respostas.

from transformers import GPT2LMHeadModel, GPT2Tokenizer

tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
model = GPT2LMHeadModel.from_pretrained("gpt2")

inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(
    inputs["input_ids"], 
    max_length=300, 
    num_return_sequences=1, 
    repetition_penalty=2.0, 
    top_k=50, 
    top_p=0.95, 
    temperature=0.7,
    do_sample=True
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(response)

Limpar

No portal do Azure Databricks, na página Computação, selecione seu cluster e selecione ■ Terminar para encerrar o processo.

Se você tiver terminado de explorar o Azure Databricks, poderá excluir os recursos que criou para evitar custos desnecessários do Azure e liberar capacidade em sua assinatura.