Utilizza Amazon SageMaker Studio per creare una soluzione di risposta alle domande RAG con Llama 2, LangChain e Pinecone per sperimentazione rapida

Crea una soluzione di risposta alle domande RAG in modo rapido con Amazon SageMaker Studio utilizzando Llama 2, LangChain e Pinecone

Il Recupero Augmentato della Generazione (RAG) consente di fornire ad un grande modello linguistico (LLM) l’accesso a dati provenienti da fonti di conoscenza esterne come repository, database e API senza la necessità di sottopostarlo a un rapido aggiustamento. Quando si utilizza l’IA generativa per rispondere alle domande, RAG consente a LLM di fornire risposte con le informazioni più pertinenti e aggiornate e, all’occorrenza, citare le fonti di dati per verificarle.

Una soluzione RAG tipica per il recupero delle conoscenze da documenti utilizza un modello di embedding per convertire i dati provenienti dalle fonti di dati in embedding e memorizza questi embedding in un database vettoriale. Quando un utente pone una domanda, si effettua una ricerca nel database vettoriale per recuperare i documenti più simili alla query dell’utente. Successivamente, i documenti recuperati e la query dell’utente vengono combinati in un prompt aumentato che viene inviato al LLM per la generazione del testo. In questa implementazione sono presenti due modelli: il modello di embedding e il LLM che genera la risposta finale.

In questo post, mostreremo come utilizzare Amazon SageMaker Studio per creare una soluzione di risposta alle domande basata su RAG.

Utilizzo dei notebook per la risposta alle domande basata su RAG

L’implementazione di RAG comporta tipicamente l’esperimento con vari modelli di embedding, database vettoriali, modelli di generazione di testo e prompt, oltre al debug del codice fino al raggiungimento di un prototipo funzionale. Amazon SageMaker offre notebook Jupyter gestiti dotati di istanze GPU, consentendo di sperimentare rapidamente in questa fase iniziale senza dover avviare ulteriori infrastrutture. Ci sono due opzioni per l’utilizzo dei notebook in SageMaker. La prima opzione è il rapido avvio dei notebook disponibili tramite SageMaker Studio. In SageMaker Studio, l’ambiente di sviluppo integrato (IDE) appositamente progettato per l’apprendimento automatico, è possibile avviare notebook che girano su diversi tipi di istanze e con diverse configurazioni, collaborare con colleghi e accedere a ulteriori funzionalità specifiche per l’apprendimento automatico (ML). La seconda opzione è l’utilizzo di una istanza di notebook SageMaker, che è un’istanza di calcolo per l’apprendimento automatico completamente gestita che esegue l’applicazione Jupyter Notebook.

• KT’s viaggio per ridurre il tempo di addestramento di un modello di visione transformers utilizzando Amazon SageMaker
• Ricercatori dell’Università di Stanford presentano FlashFFTConv un nuovo sistema di intelligenza artificiale per ottimizzare le convoluzioni FFT per sequenze lunghe.
• Il Tencent AI Lab presenta Chain-of-Noting (CoN) per migliorare la robustezza e l’affidabilità dei modelli di linguaggio con recupero aumentato.

In questo post, presentiamo una soluzione RAG che arricchisce la conoscenza del modello con dati aggiuntivi provenienti da fonti di conoscenza esterne al fine di fornire risposte più accurate specifiche per un dominio personalizzato. Utilizziamo un singolo notebook SageMaker Studio che gira su un’istanza ml.g5.2xlarge (1 GPU A10G) e Llama 2 7b chat hf, la versione sintonizzata di Llama 2 7b, ottimizzata per scenari di dialogo tramite Hugging Face Hub. Utilizziamo due post del blog AWS Media & Entertainment come esempi di dati esterni, convertiti in embedding con gli embedding BAAI/bge-small-en-v1.5. Archiviamo gli embedding in Pinecone, un database vettoriale che offre ricerche ad alte prestazioni e corrispondenze di similarità. Discutiamo anche di come passare dall’esperimento nel notebook al rilascio dei modelli negli endpoint di SageMaker per l’inferenza in tempo reale al termine della prototipazione. Lo stesso approccio può essere utilizzato con modelli e database vettoriali diversi.

Panoramica della soluzione

Il diagramma seguente illustra l’architettura della soluzione.

Implementare la soluzione comporta due passaggi di alto livello: sviluppare la soluzione utilizzando i notebook di SageMaker Studio e distribuire i modelli per l’inferenza.

Sviluppare la soluzione utilizzando i notebook di SageMaker Studio

Completa i seguenti passaggi per iniziare a sviluppare la soluzione:

1. Carica il modello di chat Llama-2 7b da Hugging Face Hub nel notebook.
2. Crea un PromptTemplate con LangChain e usalo per creare prompt per il tuo caso d’uso.
3. Per 1-2 prompt di esempio, aggiungi testo statico pertinente da documenti esterni come contesto del prompt e valuta se migliora la qualità delle risposte.
4. Assumendo che la qualità migliori, implementa il flusso di lavoro di risposta alle domande RAG:
   • Raccogli i documenti esterni che possono aiutare il modello a rispondere meglio alle domande nel tuo caso d’uso.
   • Carica il modello di embedding BGE e usalo per generare embedding di questi documenti.
   • Salva questi embedding in un indice Pinecone.
   • Quando un utente fa una domanda, esegui una ricerca di similarità in Pinecone e aggiungi i contenuti dai documenti più simili al contesto del prompt.

Implementa i modelli su SageMaker per l’infusione su larga scala

Quando raggiungi i tuoi obiettivi di prestazione, puoi implementare i modelli su SageMaker per essere utilizzati dalle applicazioni di intelligenza artificiale generativa:

1. Implementa il modello di chat Llama-2 7b su un endpoint in tempo reale di SageMaker.
2. Implementa il modello di embedding BAAI/bge-small-en-v1.5 su un endpoint in tempo reale di SageMaker.
3. Utilizza i modelli implementati nelle tue applicazioni di intelligenza artificiale generativa per rispondere alle domande.

Nelle sezioni seguenti, ti guideremo attraverso i passaggi per implementare questa soluzione in notebook di SageMaker Studio.

Prerequisiti

Per seguire i passaggi in questo post, è necessario disporre di un account AWS e di un ruolo IAM (Identity and Access Management di AWS) con le autorizzazioni per creare e accedere alle risorse della soluzione. Se sei nuovo in AWS, consulta Creazione di un account AWS autonomo.

Per utilizzare i notebook di SageMaker Studio nel tuo account AWS, devi disporre di un dominio SageMaker con un profilo utente che abbia le autorizzazioni per avviare l’applicazione SageMaker Studio. Se sei nuovo in SageMaker Studio, la Configurazione rapida di Studio è il modo più veloce per iniziare. Con un solo clic, SageMaker configura il dominio SageMaker con impostazioni predefinite, inclusa la configurazione del profilo utente, del ruolo IAM, dell’autenticazione IAM e dell’accesso a Internet pubblico. Il notebook di questo post presuppone un tipo di istanza ml.g5.2xlarge. Per revisionare o aumentare il tuo limite di quota, apri la console AWS Service Quotas, scegli Servizi AWS nel riquadro di navigazione, scegli Amazon SageMaker e fa riferimento al valore per le app KernelGateway Studio in esecuzione su istanze ml.g5.2xlarge.

Dopo aver confermato il limite della tua quota, devi completare le dipendenze per utilizzare Llama 2 7b chat.

Llama 2 7b chat è disponibile sotto la licenza Llama 2. Per accedere a Llama 2 su Hugging Face, devi completare alcuni passaggi preliminari:

1. Crea un account Hugging Face se non ne hai già uno.
2. Completa il modulo “Richiesta di accesso alla prossima versione di Llama” sul sito di Meta.
3. Richiedi l’accesso a Llama 2 7b chat su Hugging Face.

Dopo aver ottenuto l’accesso, puoi creare un nuovo token di accesso per accedere ai modelli. Per creare un token di accesso, vai alla pagina delle Impostazioni sul sito di Hugging Face.

Per utilizzare Pinecone come database vettoriale, è necessario disporre di un account con Pinecone. Pinecone è disponibile su AWS tramite il AWS Marketplace. Il sito di Pinecone offre anche la possibilità di creare un account gratuito che consente di creare un singolo indice, sufficiente per gli scopi di questo post. Per recuperare le tue chiavi di Pinecone, apri la console di Pinecone e scegli API Keys.

Configura il notebook e l’ambiente

Per seguire il codice in questo post, apri SageMaker Studio e clona il seguente repository GitHub. Successivamente, apri il notebook studio-local-gen-ai/rag/RAG-with-Llama-2-on-Studio.ipynb e scegli l’immagine Python 3.10 GPU ottimizzata con PyTorch 2.0.0, kernel Python 3 e ml.g5.2xlarge come tipo di istanza. Se è la prima volta che utilizzi i notebook di SageMaker Studio, consulta Crea o apri un notebook di Amazon SageMaker Studio.

Per configurare l’ambiente di sviluppo, è necessario installare le librerie Python necessarie, come mostrato nel seguente codice:

%%writefile requirements.txtsagemaker>=2.175.0transformers==4.33.0accelerate==0.21.0datasets==2.13.0langchain==0.0.297pypdf>=3.16.3pinecone-clientsentence_transformerssafetensors>=0.3.3

!pip install -U -r requirements.txt

Carica il modello preaddestrato e il tokenizer

Dopo aver importato le librerie necessarie, puoi caricare il modello Llama-2 7b chat insieme ai relativi tokenizzatori da Hugging Face. Questi artefatti del modello caricato sono memorizzati nella directory locale all’interno di SageMaker Studio. Ciò ti consente di ricaricarli rapidamente in memoria ogni volta che hai bisogno di riprendere il lavoro in un momento diverso.

import torchfrom transformers import ( AutoTokenizer,  LlamaTokenizer, LlamaForCausalLM,   GenerationConfig,   AutoModelForCausalLM)import transformerstg_model_id = "meta-llama/Llama-2-7b-chat-hf" #l'id del modello in Hugging Facetg_model_path = f"./tg_model/{tg_model_id}" #la directory locale in cui verrà salvato il modellog_model = AutoModelForCausalLM.from_pretrained(tg_model_id, token=hf_access_token,do_sample=True, use_safetensors=True, device_map="auto",torch_dtype=torch.float16tg_tokenizer = AutoTokenizer.from_pretrained(tg_model_id, token=hf_access_token)tg_model.save_pretrained(save_directory=tg_model_path, from_pt=True)tg_tokenizer.save_pretrained(save_directory=tg_model_path, from_pt=True)

Fai una domanda che richiede informazioni aggiornate

Ora puoi iniziare ad utilizzare il modello e fare domande. I modelli di chat di Llama-2 si aspettano che il prompt segua il formato seguente:

<s>[INST] <<SYS>>system_prompt<<SYS>>{{ user_message }} [/INST]

Puoi utilizzare il PromptTemplate di LangChain per creare una ricetta basata sul formato del prompt, in modo da poter creare facilmente dei prompt in futuro:

from langchain import PromptTemplatetemplate = """<s>[INST] <<SYS>>\nSei un assistente per compiti di risposta a domande. Sei disponibile e amichevole. Utilizza i seguenti frammenti di contesto recuperati per rispondere alla richiesta. Se non conosci la risposta, basta dire che non lo sai. Utilizza al massimo tre frasi e mantieni la risposta sintetica.<<SYS>>\n{context}\n{question} [/INST]"""prompt_template = PromptTemplate( template=template, input_variables=['context','question'] )

Chiediamo al modello una domanda che richiede informazioni recenti dal 2023. Puoi utilizzare LangChain e specificamente il tipo di catena LLMChain e passare come parametri l’LLM, il template di prompt che hai creato precedentemente e la domanda:

domanda = "Quando posso visitare l'AWS M&E Customer Experience Center a New York City?"tg_tokenizer.add_special_tokens( {"pad_token": "[PAD]"} )tg_tokenizer.padding_side = "left"tg_pipe = transformers.pipeline(task='text-generation', model=tg_model, tokenizer=tg_tokenizer, num_return_sequences=1, eos_token_id=tg_tokenizer.eos_token_id, pad_token_id=tg_tokenizer.eos_token_id, max_new_tokens=400, temperature=0.7)from langchain.chains import LLMChainfrom langchain.llms import HuggingFacePipelinellm=HuggingFacePipeline(pipeline=tg_pipe, model_kwargs={'temperature':0.7})llm_chain = LLMChain(llm=llm, prompt=prompt_template)no_context_response = llm_chain.predict(context="", question=domanda)print(no_context_response)

Ottieniamo la seguente risposta generata:

Grazie per averci contattato! Attualmente l’AWS M&E Customer Experience Center a New York City è chiuso alle visite a causa della pandemia di COVID-19. Tuttavia, puoi controllare il loro sito web ufficiale o i loro account sui social media per eventuali aggiornamenti su quando il centro riaprirà. Nel frattempo, puoi esplorare i loro tour virtuali e le risorse disponibili online.

Migliora la risposta aggiungendo contesto al prompt

La risposta generata non è del tutto corretta. Vediamo se possiamo migliorarla fornendo del contesto. Puoi aggiungere un estratto dal post AWS annuncia il nuovo M&E Customer Experience Center a New York, che include aggiornamenti sull’argomento dal 2023:

contesto = """I clienti dei media e dell'intrattenimento (M&E) continuano ad affrontare sfide nella creazione di contenuti sempre più numerosi, più rapidi e nella loro distribuzione verso un numero sempre maggiore di piattaforme, nel tentativo di deliziare gli spettatori a livello globale. Amazon Web Services (AWS), insieme ai partners di AWS, hanno mostrato l'evoluzione rapida delle soluzioni M&E per anni in eventi del settore come il National Association of Broadcasters (NAB) Show e l'International Broadcast Convention (IBC). Fino ad ora, le dimostrazioni tecnologiche sulla M&E di AWS erano accessibili in questo modo solo alcune settimane all'anno. I clienti sono più coinvolti che mai; vogliono avere conversazioni di qualità superiore riguardo all'esperienza utente e agli strumenti per i media. Queste conversazioni vengono supportate al meglio da un'architettura di soluzione interconnessa come riferimento. È possibile pianificare una visita all'M&E Customer Experience Center a partire dal 13 novembre. Si prega di inviare un'e-mail a [email protected]."""

Utilizza di nuovo LLMChain e passa il testo precedente come contesto:

context_response = llm_chain.predict(context=contesto, question=domanda)print(context_response)

La nuova risposta fornisce informazioni aggiornate alla domanda:

Puoi visitare il centro di esperienza clienti AWS M&E a New York City a partire dal 13 novembre. Per programmare una visita, invia un’e-mail a [email protected].

Abbiamo confermato che aggiungendo il contesto giusto, le prestazioni del modello migliorano. Ora puoi concentrare i tuoi sforzi nel trovare e aggiungere il contesto corretto alla domanda posta. In altre parole, implementa RAG.

Implementa il question answering RAG con gli embedding BGE e Pinecone

In questo momento, devi decidere le fonti di informazione per migliorare la conoscenza del modello. Queste fonti potrebbero essere pagine web interne o documenti interni all’organizzazione o fonti di dati disponibili pubblicamente. Per scopi di questo post e per semplicità, abbiamo scelto due post del blog AWS pubblicati nel 2023:

• AWS annuncia il nuovo centro di esperienza clienti M&E a New York
• AWS Media Services premiate dall’industria

Questi post sono già disponibili come documenti PDF nella directory del progetto dei dati in SageMaker Studio per un accesso rapido. Per dividere i documenti in porzioni gestibili, puoi utilizzare il metodo RecursiveCharacterTextSplitter di LangChain:

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.document_loaders import PyPDFDirectoryLoader

loader = PyPDFDirectoryLoader("./data/")
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
     chunk_size = 1000,
     chunk_overlap = 5
)
docs = text_splitter.split_documents(documents)

Successivamente, usa il modello di embedding BGE bge-small-en creato dalla Beijing Academy of Artificial Intelligence (BAAI) disponibile su Hugging Face per generare gli embeddings di queste porzioni. Scarica e salva il modello nella directory locale in Studio. Utilizziamo fp32 in modo che possa essere eseguito sulla CPU dell’istanza.

em_model_name = "BAAI/bge-small-en"
em_model_path = f"./em-model"

from transformers import AutoModel
# Carica il modello da HuggingFace Hub
em_model = AutoModel.from_pretrained(em_model_name, torch_dtype = torch.float32)
em_tokenizer = AutoTokenizer.from_pretrained(em_model_name, device = "cuda")

# Salva il modello su disco
em_tokenizer.save_pretrained(save_directory = f"{em_model_path}/model", from_pt = True)
em_model.save_pretrained(save_directory = f"{em_model_path}/model", from_pt = True)

em_model.eval()

Utilizza il seguente codice per creare una funzione embedding_generator, che prende in input le porzioni di documento e genera gli embeddings utilizzando il modello BGE:

# Tokenizza le frasi
def tokenize_text(_input, device):
    return em_tokenizer(
        [_input],
        padding = True,
        truncation = True,
        return_tensors = 'pt'
    ).to(device)

# Esegui il task di embedding come funzione con modello e frasi di testo in input
def embedding_generator(_input, normalize = True):
    # Calcola gli embedding
    with torch.no_grad():
        embedded_output = em_model(
            **tokenize_text(
                _input,
                em_model.device
            )
        )
        sentence_embeddings = embedded_output[0][:, 0]
        # Normalizza gli embeddings
        if normalize:
            sentence_embeddings = torch.nn.functional.normalize(
                sentence_embeddings,
                p = 2,
                dim = 1
            )
        return sentence_embeddings[0, :].tolist()

sample_sentence_embedding = embedding_generator(docs[0].page_content)
print(f"Dimensione dell'embedding del documento --->", len(sample_sentence_embedding))

In questo post, dimostriamo un flusso di lavoro RAG utilizzando Pinecone, un database di vettori gestito e nativo del cloud che offre anche un’API per la ricerca di similarità. Se preferisci, puoi riscrivere il codice seguente per utilizzare il tuo database di vettori preferito.

Inizializziamo un client Pinecone Python e creiamo un nuovo indice di ricerca vettoriale utilizzando la lunghezza dell’output del modello di embedding. Utilizziamo la classe Pinecone incorporata in LangChain per inglobare gli embedding creati nel passaggio precedente. Sono necessari tre parametri: i documenti da inglobare, la funzione generatrice di embedding e il nome dell’indice Pinecone.

import pineconepinecone.init(    api_key = os.environ["PINECONE_API_KEY"],    environment = os.environ["PINECONE_ENV"])#verifica se l'indice esiste già, se non lo crea.index_name = "rag-index"if index_name not in pinecone.list_indexes():    pinecone.create_index(        name=index_name,        dimension=len(sample_sentence_embedding), ## 384 per bge-small-en         metric='cosine'    )#inserisce gli embeddingdalla langchain.vectorstores import Pineconevector_store = Pinecone.from_documents(    docs,    embedding_generator,    index_name=index_name)

Con il modello di chat Llama-2 7B caricato in memoria e gli embedding integrati nell’indice Pinecone, è ora possibile combinare questi elementi per migliorare le risposte di Llama 2 per il nostro caso di utilizzo di domande e risposte. Per ottenere questo risultato, è possibile utilizzare il RetrievalQA di LangChain, che aggiunge alla richiesta iniziale i documenti più simili dalla collezione di vettori. Impostando return_source_documents=True, si ottiene una visibilità sui documenti esatti utilizzati per generare la risposta come parte della risposta stessa, consentendo di verificare l’accuratezza della risposta.

from langchain.chains import RetrievalQAimport textwrap#metodo di supporto per migliorare la leggibilità della rispostadef print_response(llm_response):    temp = [textwrap.fill(line, width=100) for line in llm_response['result'].split('\n')]    response = '\n'.join(temp)    print(f"{llm_response['query']}\n \n{response}'\n \n Documenti di origine:")    for source in llm_response["source_documents"]:        print(source.metadata)llm_qa_chain = RetrievalQA.from_chain_type(    llm=llm, #il modello di chat Llama-2 7b    chain_type='stuff',    retriever=vector_store.as_retriever(search_kwargs={"k": 2}), #esegue una ricerca di similarità in Pinecone    return_source_documents=True, #mostra i documenti utilizzati per rispondere alla domanda    chain_type_kwargs={"prompt": prompt_template})print_response(llm_qa_chain(question))

Otteniamo la seguente risposta:

D: Quando posso visitare il Customer Experience Center AWS M&E a New York?

A: Sono felice di aiutarti! Secondo il contesto, il Customer Experience Center AWS M&E a New York sarà disponibile per visite a partire dal 13 novembre. Puoi inviare un’email a [email protected] per programmare una visita.”

Documenti di origine:

{‘page’: 4.0, ‘source’: ‘data/AWS announces new M&E Customer Experience Center in New York City _ AWS for M&E Blog.pdf’}

{‘page’: 2.0, ‘source’: ‘data/AWS announces new M&E Customer Experience Center in New York City _ AWS for M&E Blog.pdf’}

Proviamo una domanda diversa:

question2=" Quanti premi hanno vinto i servizi multimediali AWS nel 2023?"print_response(llm_qa_chain(question2))

Otteniamo la seguente risposta:

D: Quanti premi hanno vinto i servizi multimediali AWS nel 2023?

A: Secondo il post sul blog, i servizi multimediali AWS hanno vinto cinque premi nell’industria nel 2023.”

Documenti di origine:

{‘page’: 0.0, ‘source’: ‘data/AWS Media Services awarded industry accolades _ AWS for M&E Blog.pdf’}

{‘page’: 1.0, ‘source’: ‘data/AWS Media Services awarded industry accolades _ AWS for M&E Blog.pdf’}

Dopo aver raggiunto un livello sufficiente di fiducia, è possibile distribuire i modelli agli endpoint SageMaker per inferenza in tempo reale. Questi endpoint sono completamente gestiti e offrono supporto per il ridimensionamento automatico.

SageMaker offre l’uso di grandi modelli di inferenza utilizzando i container di Large Model Inference (LMIs), che possiamo utilizzare per distribuire i nostri modelli. Questi container sono dotati di librerie open source preinstallate come DeepSpeed, che facilitano l’implementazione di tecniche di miglioramento delle prestazioni come il parallelismo dei tensori durante l’inferenza. Inoltre, utilizzano DJLServing come server di modelli integrato predefinito. DJLServing è una soluzione universale per l’erogazione di modelli ad alte prestazioni che offre supporto per il batching dinamico e il ridimensionamento automatico dei worker, aumentando così la velocità di elaborazione.

Nel nostro approccio, utilizziamo SageMaker LMI con DJLServing e DeepSpeed Inference per distribuire i modelli Llama-2-chat 7b e BGE agli endpoint di SageMaker in esecuzione su istanze ml.g5.2xlarge, consentendo l’inferenza in tempo reale. Se desideri seguire questi passaggi tu stesso, consulta il notebook allegato per istruzioni dettagliate.

Saranno necessarie due istanze ml.g5.2xlarge per la distribuzione. Per rivedere o aumentare la tua quota, apri la console dei Servizi Quota AWS, scegli Servizi AWS nel riquadro di navigazione, seleziona Amazon SageMaker e consulta il valore per ml.g5.2xlarge per l’utilizzo degli endpoint.

I seguenti passaggi illustrano il processo di distribuzione di modelli personalizzati per il flusso di lavoro RAG su un endpoint di SageMaker:

• Distribuire il modello di chat Llama-2 7b su un endpoint di SageMaker in tempo reale in esecuzione su un’istanza ml.g5.2xlarge per una rapida generazione di testo.
• Distribuire il modello di embedding BAAI/bge-small-en-v1.5 su un endpoint di SageMaker in tempo reale in esecuzione su un’istanza ml.g5.2xlarge. In alternativa, puoi distribuire il tuo modello di embedding.
• Fare una domanda e utilizzare il RetrievalQA di LangChain per arricchire il prompt con i documenti più simili da Pinecone, questa volta utilizzando il modello distribuito nell’endpoint di SageMaker in tempo reale:

# converti il tuo LLM locale in un LLM dell'endpoint di SageMakerllm_sm_ep = SagemakerEndpoint(    endpoint_name=tg_sm_model.endpoint_name, # <--- Il nome del tuo endpoint del modello di generazione di testo    region_name=region,    model_kwargs={        "temperature": 0.05,         "max_new_tokens": 512    },    content_handler=content_handler,)llm_qa_smep_chain = RetrievalQA.from_chain_type(    llm=llm_sm_ep,  # <--- Questo utilizza il modello dell'endpoint di SageMaker per l'inferenza    chain_type='stuff',    retriever=vector_store.as_retriever(search_kwargs={"k": 2}),    return_source_documents=True,    chain_type_kwargs={"prompt": prompt_template})

• Utilizza LangChain per verificare che l’endpoint di SageMaker con il modello di embedding funzioni come previsto in modo da poterlo utilizzare per l’ingestione futura di documenti:

response_model = smr_client.invoke_endpoint(    EndpointName=em_sm_model.endpoint_name, <--- Il nome del tuo endpoint del modello di embedding    Body=json.dumps({        "text": "Questo è un testo di esempio"    }),    ContentType="application/json",)outputs = json.loads(response_model["Body"].read().decode("utf8"))['outputs']

Pulizia

Segui i seguenti passaggi per pulire le tue risorse:

• Quando hai finito di lavorare nel tuo notebook di SageMaker Studio, assicurati di spegnere l’istanza ml.g5.2xlarge per evitare addebiti scegliendo l’icona di stop. Puoi anche configurare script di configurazione del ciclo di vita per spegnere automaticamente le risorse quando non vengono utilizzate.

• Se hai distribuito i modelli su endpoint SageMaker, esegui il codice seguente alla fine del notebook per eliminare gli endpoint:

#delete your text generation endpointsm_client.delete_endpoint(     EndpointName=tg_sm_model.endpoint_name)# delete your text embedding endpointsm_client.delete_endpoint(      EndpointName=em_sm_model.endpoint_name)

• Infine, esegui la seguente riga per eliminare l’indice Pinecone:

pinecone.delete_index(index_name)

Conclusioni

I notebook SageMaker offrono un modo semplice per iniziare il tuo viaggio con Retrieval Augmented Generation. Ti permettono di sperimentare interattivamente con vari modelli, configurazioni e domande senza dover creare infrastrutture aggiuntive. In questo post abbiamo mostrato come migliorare le prestazioni del Llama 2 7b chat in un caso d’uso di risposta alle domande utilizzando LangChain, il modello di incorporamento BGE e Pinecone. Per iniziare, lancia SageMaker Studio ed esegui il notebook disponibile nel seguente repository GitHub. Condividi le tue opinioni nella sezione dei commenti!