-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Copy Files From Source Repo (2024-08-16 20:05)
- Loading branch information
Showing
8 changed files
with
492 additions
and
118 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,177 @@ | ||
--- | ||
lab: | ||
title: Explorar modelos de linguagem grandes com o Azure Databricks | ||
--- | ||
|
||
# Explorar modelos de linguagem grandes com o Azure Databricks | ||
|
||
Os LLMs (Modelos de linguagem grande) podem ser um ativo poderoso para tarefas de NLP (processamento de linguagem natural) quando integrados ao Azure Databricks e ao Hugging Face Transformers. O Azure Databricks fornece uma plataforma perfeita para acessar, ajustar e implantar LLMs, incluindo modelos pré-treinados da extensa biblioteca da Hugging Face. Para inferência de modelo, a classe pipelines da Hugging Face simplifica o uso de modelos pré-treinados, aceitando uma ampla variedade de tarefas de NLP diretamente no ambiente do Databricks. | ||
|
||
Este laboratório levará aproximadamente **30** minutos para ser concluído. | ||
|
||
## Antes de começar | ||
|
||
É necessário ter uma [assinatura do Azure](https://azure.microsoft.com/free) 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](https://learn.microsoft.com/azure/databricks/getting-started/#--create-an-azure-databricks-workspace). | ||
|
||
1. Em um navegador da web, faça logon no [portal do Azure](https://portal.azure.com) em `https://portal.azure.com`. | ||
|
||
2. 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 ***PowerShell*** e criando um armazenamento caso solicitado. O Cloud Shell fornece uma interface de linha de comando em um painel na parte inferior do portal do Azure, conforme mostrado aqui: | ||
|
||
![Portal do Azure com um painel do Cloud Shell](./images/cloud-shell.png) | ||
|
||
> **Observação**: se você tiver criado anteriormente um cloud shell que usa um ambiente *Bash*, use o menu suspenso no canto superior esquerdo do painel do cloud shell para alterá-lo para ***PowerShell***. | ||
3. Observe que você pode redimensionar o Cloud Shell arrastando a barra do separador 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](https://docs.microsoft.com/azure/cloud-shell/overview). | ||
|
||
4. No painel do PowerShell, insira os seguintes comandos para clonar esse repositório: | ||
|
||
```powershell | ||
rm -r mslearn-databricks -f | ||
git clone https://github.com/MicrosoftLearning/mslearn-databricks | ||
``` | ||
5. 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: | ||
```powershell | ||
./mslearn-databricks/setup.ps1 | ||
``` | ||
6. Se solicitado, escolha qual assinatura você deseja usar (isso só acontecerá se você tiver acesso a várias assinaturas do Azure). | ||
7. Aguarde a conclusão do script - isso normalmente leva cerca de 5 minutos, mas em alguns casos pode levar mais tempo. Enquanto você aguarda, revise o artigo [Introdução ao Delta Lake](https://docs.microsoft.com/azure/databricks/delta/delta-intro) na documentação do Azure Databricks. | ||
## 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 uma versão de runtime 13.3 LTS **<u>ML</u>** ou superior em seu workspace do Azure Databricks, poderá usá-lo para concluir este exercício e ignorar este procedimento. | ||
1. 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) | ||
1. Selecione o recurso Serviço do Azure Databricks (chamado **databricks-*xxxxxxx*** se você usou o script de instalação para criá-lo). | ||
1. 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. | ||
1. Na barra lateral à esquerda, selecione a tarefa **(+) Novo** e, em seguida, selecione **Cluster**. | ||
1. 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 | ||
- **Modo de cluster**: Nó Único | ||
- **Modo de acesso**: Usuário único (*com sua conta de usuário selecionada*) | ||
- **Versão do runtime do Databricks**: *Selecione a edição do **<u>ML</u>** da última versão não beta do runtime (**Não** uma versão de runtime Standard) que:* | ||
- ***Não** usa uma GPU* | ||
- *Inclui o Scala > **2.11*** | ||
- *Inclui o Spark > **3.4*** | ||
- **Usa a Aceleração do Photon**: <u>Não</u> selecionado | ||
- **Tipo de nó**: Standard_DS3_v2 | ||
- **Encerra após** *20* **minutos de inatividade** | ||
1. 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](https://docs.microsoft.com/azure/databricks/kb/clusters/azure-core-limit) 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 | ||
1. Na página do cluster, selecione a guia **Bibliotecas**. | ||
2. Selecione **Instalar novo**. | ||
3. Selecione **PyPI** como a origem da biblioteca e digite `transformers==4.44.0` no campo **pacote**. | ||
4. Selecione **Instalar**. | ||
## Carregar modelos pré-treinado | ||
1. No workspace do Databricks, vá para a seção **Espaço de trabalho**. | ||
2. Selecione **Criar** e, em seguida, selecione **Notebook**. | ||
3. Dê um nome ao notebook e selecione `Python` como a linguagem. | ||
4. Na primeira célula do código, insira e execute o código a seguir: | ||
```python | ||
from transformers import pipeline | ||
# Load the summarization model | ||
summarizer = pipeline("summarization") | ||
# Load the sentiment analysis model | ||
sentiment_analyzer = pipeline("sentiment-analysis") | ||
# Load the translation model | ||
translator = pipeline("translation_en_to_fr") | ||
# Load a general purpose model for zero-shot classification and few-shot learning | ||
classifier = pipeline("zero-shot-classification") | ||
``` | ||
Isso carregará todos os modelos necessários para as tarefas de PNL apresentadas neste exercício. | ||
### Resumir texto | ||
Um pipeline de resumo gera resumos concisos de textos mais longos. Ao especificar um intervalo de comprimento (`min_length`, `max_length`) e se ele usará amostragem ou não (`do_sample`), podemos determinar o quão preciso ou criativo será o resumo gerado. | ||
1. Na nova célula de código, insira o código a seguir: | ||
```python | ||
text = "Large language models (LLMs) are advanced AI systems capable of understanding and generating human-like text by learning from vast datasets. These models, which include OpenAI's GPT series and Google's BERT, have transformed the field of natural language processing (NLP). They are designed to perform a wide range of tasks, from translation and summarization to question-answering and creative writing. The development of LLMs has been a significant milestone in AI, enabling machines to handle complex language tasks with increasing sophistication. As they evolve, LLMs continue to push the boundaries of what's possible in machine learning and artificial intelligence, offering exciting prospects for the future of technology." | ||
summary = summarizer(text, max_length=75, min_length=25, do_sample=False) | ||
print(summary) | ||
``` | ||
2. Execute a célula para ver o texto resumido. | ||
### Analisar sentimento | ||
O pipeline de análise de sentimento determina o sentimento de um determinado texto. Ele classifica o texto em categorias como positivo, negativo ou neutro. | ||
1. Na nova célula de código, insira o código a seguir: | ||
```python | ||
text = "I love using Azure Databricks for NLP tasks!" | ||
sentiment = sentiment_analyzer(text) | ||
print(sentiment) | ||
``` | ||
2. Execute a célula para ver o resultado da análise de sentimento. | ||
### Traduzir o texto | ||
O pipeline de tradução converte o texto de um idioma para outro. Neste exercício, a tarefa usada foi `translation_en_to_fr`, o que significa que ele traduzirá qualquer texto do inglês para o francês. | ||
1. Na nova célula de código, insira o código a seguir: | ||
```python | ||
text = "Hello, how are you?" | ||
translation = translator(text) | ||
print(translation) | ||
``` | ||
2. Execute a célula para ver o texto traduzido em francês. | ||
### Classificar textos | ||
O pipeline de classificação zero-shot permite que um modelo classifique o texto em categorias que não viu durante o treinamento. Portanto, requer rótulos predefinidos como um parâmetro `candidate_labels`. | ||
1. Na nova célula de código, insira o código a seguir: | ||
```python | ||
text = "Azure Databricks is a powerful platform for big data analytics." | ||
labels = ["technology", "health", "finance"] | ||
classification = classifier(text, candidate_labels=labels) | ||
print(classification) | ||
``` | ||
2. Execute a célula para ver os resultados da classificação zero-shot. | ||
## 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. |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,179 @@ | ||
# Exercício 02 – Geração Aumentada de Recuperação usando o Azure Databricks | ||
|
||
## Objetivo | ||
Este exercício orienta você na configuração de um fluxo de trabalho de RAG (Geração Aumentada de Recuperação) no Azure Databricks. O processo envolve a ingestão de dados, a criação de incorporações vetoriais, o armazenamento dessas incorporações em um banco de dados vetorial e o uso delas para aumentar a entrada de um modelo generativo. | ||
|
||
## Requisitos | ||
Uma assinatura ativa do Azure. Se você não tiver uma, poderá se inscrever para uma [avaliação gratuita](https://azure.microsoft.com/en-us/free/). | ||
|
||
## Tempo estimado: 40 minutos | ||
|
||
## Etapa 1: Provisionar o Azure Databricks | ||
- Fazer logon no portal do Azure: | ||
1. Vá para o portal do Azure e entre com suas credenciais. | ||
- Criar serviço do Databricks: | ||
1. Navegue até "Criar um recurso" > "Análise" > "Azure Databricks". | ||
2. Insira os detalhes necessários, como nome do espaço de trabalho, assinatura, grupo de recursos (crie um novo ou selecione um já existente) e local. | ||
3. Selecione o tipo de preço (escolha padrão para este laboratório). | ||
4. Clique em "Examinar + criar" e "Criar" depois que a validação for aprovada. | ||
|
||
## Etapa 2: Iniciar o espaço de trabalho e criar um cluster | ||
- Iniciar o workspace do Databricks: | ||
1. Quando a implantação estiver concluída, vá para o recurso e clique em "Iniciar espaço de trabalho". | ||
- Criar um Cluster do Spark: | ||
1. No workspace do Databricks, clique em "Computação" na barra lateral e, em seguida, em "Criar computação". | ||
2. Especifique o nome do cluster e selecione uma versão de runtime do Spark. | ||
3. Escolha o tipo de trabalhador como "Padrão" e o tipo de nó com base nas opções disponíveis (escolha nós menores para eficiência de custo). | ||
4. Clique em "Criar computação". | ||
|
||
## Etapa 3: Preparação de dados | ||
- Ingerir Dados | ||
1. Baixe um conjunto de dados de amostra de artigos da Wikipédia [aqui](https://dumps.wikimedia.org/enwiki/latest/). | ||
2. Carregue o conjunto de dados no Azure Data Lake Storage ou diretamente no Sistema de Arquivos do Azure Databricks. | ||
|
||
- Carregar dados no Azure Databricks | ||
```python | ||
from pyspark.sql import SparkSession | ||
|
||
spark = SparkSession.builder.appName("RAG-DataPrep").getOrCreate() | ||
raw_data_path = "/mnt/data/wiki_sample.json" # Adjust the path as necessary | ||
|
||
raw_df = spark.read.json(raw_data_path) | ||
raw_df.show(5) | ||
``` | ||
|
||
- Limpeza e pré-processamento de dados | ||
1. Limpe e pré-processe os dados para extrair campos de texto relevantes. | ||
|
||
```python | ||
from pyspark.sql.functions import col | ||
|
||
clean_df = raw_df.select(col("title"), col("text")) | ||
clean_df = clean_df.na.drop() | ||
clean_df.show(5) | ||
``` | ||
## Etapa 4: Geração de incorporações | ||
- Instalar bibliotecas necessárias | ||
1. Certifique-se de ter as bibliotecas de transformadores e transformadores de sentença instaladas. | ||
|
||
```python | ||
%pip install transformers sentence-transformers | ||
``` | ||
- Gerar incorporações | ||
1. Use um modelo pré-treinado para gerar incorporações para o texto. | ||
|
||
```python | ||
from sentence_transformers import SentenceTransformer | ||
|
||
model = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2') | ||
|
||
def embed_text(text): | ||
return model.encode(text).tolist() | ||
|
||
# Apply the embedding function to the dataset | ||
from pyspark.sql.functions import udf | ||
from pyspark.sql.types import ArrayType, FloatType | ||
|
||
embed_udf = udf(embed_text, ArrayType(FloatType())) | ||
embedded_df = clean_df.withColumn("embeddings", embed_udf(col("text"))) | ||
embedded_df.show(5) | ||
``` | ||
|
||
## Etapa 5: Armazenamento de incorporações | ||
- Armazenar incorporações em tabelas Delta | ||
1. Salve os dados incorporados em uma tabela Delta para recuperação eficiente. | ||
|
||
```python | ||
embedded_df.write.format("delta").mode("overwrite").save("/mnt/delta/wiki_embeddings") | ||
``` | ||
|
||
2. Criar uma tabela Delta | ||
|
||
```python | ||
CREATE TABLE IF NOT EXISTS wiki_embeddings | ||
LOCATION '/mnt/delta/wiki_embeddings' | ||
``` | ||
## Etapa 6: Implementação da busca em vetores | ||
- Configurar busca em vetores | ||
1. Use os recursos de busca em vetores do Databricks ou integre-se a um banco de dados vetorial como Milvus ou Pinecone. | ||
|
||
```python | ||
from databricks.feature_store import FeatureStoreClient | ||
|
||
fs = FeatureStoreClient() | ||
|
||
fs.create_table( | ||
name="wiki_embeddings_vector_store", | ||
primary_keys=["title"], | ||
df=embedded_df, | ||
description="Vector embeddings for Wikipedia articles." | ||
) | ||
``` | ||
- Executar a busca em vetores | ||
1. Implemente uma função para pesquisar documentos relevantes com base em um vetor de consulta. | ||
|
||
```python | ||
def search_vectors(query_text, top_k=5): | ||
query_embedding = model.encode([query_text]).tolist() | ||
query_df = spark.createDataFrame([(query_text, query_embedding)], ["query_text", "query_embedding"]) | ||
|
||
results = fs.search_table( | ||
name="wiki_embeddings_vector_store", | ||
vector_column="embeddings", | ||
query=query_df, | ||
top_k=top_k | ||
) | ||
return results | ||
|
||
query = "Machine learning applications" | ||
search_results = search_vectors(query) | ||
search_results.show() | ||
``` | ||
|
||
## Etapa 7: Aumento generativo | ||
- Prompts de aumento com dados recuperados: | ||
1. Combine os dados recuperados com a consulta do usuário para criar um prompt avançado para o LLM. | ||
|
||
```python | ||
def augment_prompt(query_text): | ||
search_results = search_vectors(query_text) | ||
context = " ".join(search_results.select("text").rdd.flatMap(lambda x: x).collect()) | ||
return f"Query: {query_text}\nContext: {context}" | ||
|
||
prompt = augment_prompt("Explain the significance of the Turing test") | ||
print(prompt) | ||
``` | ||
|
||
- Gerar respostas com LLM: | ||
2. Use um LLM como GPT-3 ou modelos semelhantes da Hugging Face para gerar respostas. | ||
|
||
```python | ||
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=500, num_return_sequences=1) | ||
response = tokenizer.decode(outputs[0], skip_special_tokens=True) | ||
|
||
print(response) | ||
``` | ||
|
||
## Etapa 8: Avaliação e otimização | ||
- Avalie a qualidade das respostas geradas: | ||
1. Avalie a relevância, coerência e precisão das respostas geradas. | ||
2. Colete comentários do usuário e itere no processo de aumento de prompt. | ||
|
||
- Otimizar o fluxo de trabalho RAG: | ||
1. Experimente diferentes modelos de incorporação, tamanhos de partes e parâmetros de recuperação para otimizar o desempenho. | ||
2. Monitore o desempenho do sistema e faça ajustes para melhorar a precisão e a eficiência. | ||
|
||
## Etapa 9: Limpar os recursos | ||
- Encerrar o cluster: | ||
1. Volte para a página "Computação", selecione seu cluster e clique em "Encerrar" para interromper o cluster. | ||
|
||
- Opcional: exclua o serviço Databricks: | ||
1. Para evitar cobranças adicionais, considere excluir o workspace do Databricks se esse laboratório não fizer parte de um projeto ou roteiro de aprendizagem maior. | ||
|
||
Seguindo estas etapas, você terá implementado um sistema RAG (Geração Aumentada de Recuperação) usando o Azure Databricks. Este laboratório demonstra como pré-processar dados, gerar incorporações, armazená-los com eficiência, realizar buscas em vetores e usar modelos generativos para criar respostas enriquecidas. A abordagem pode ser adaptada a vários domínios e conjuntos de dados para aprimorar os recursos dos aplicativos orientados por IA. |
Oops, something went wrong.