LangChain Cheatsheet – Tutti i segreti su una singola pagina

LangChain Cheatsheet - Tutti i segreti racchiusi in una pagina

La onepager creata è il mio riassunto delle basi di LangChain. In questo articolo, andrò attraverso le sezioni di codice e descriverò il pacchetto di avvio di cui hai bisogno per dominare LangChain.

Attualmente, questa onepager è l’unica cheatsheet che copre le basi di Langchain. Scarica la versione pdf, controlla su GitHub, e visita il codice in Colab.

Esplora il mio corso LangChain 101:

• Come vincere la scelta a testa o croce? Ogni singola volta
• Riescono i Modelli di Linguaggio a ragionare oltre le parole? Esplorando il ragionamento implicito negli stati nascosti multi-strato per compiti complessi
• Questa ricerca AI proveniente dalla Cina fornisce una valutazione esaustiva del modello di linguaggio visivo SOTA più recente, GPT-4V(ision), e la sua applicazione in scenari di guida autonoma.

Corso LangChain 101 (aggiornato)

LangChain 101 sessioni del corso. Il codice è su GitHub. LLMs, Chatbots

VoAGI.com

Modelli

Un modello in LangChain si riferisce a qualsiasi modello di linguaggio, come il text-davinci-003/gpt-3.5-turbo/4/4-turbo di OpenAI, LLAMA, FALCON, ecc., che può essere utilizzato per vari compiti di elaborazione del linguaggio naturale.

Guarda la mia lezione sui Modelli nel mio corso LangChain 101:

LangChain 101: Parte 2ab. Tutto ciò che devi sapere sui modelli (di grandi dimensioni)

Questa è la parte 2ab del corso LangChain 101. Si consiglia vivamente di consultare la prima parte per capire…

pub.towardsai.net

Il codice seguente mostra l’inizializzazione e l’utilizzo di un modello di linguaggio (in questo caso specifico OpenAI) all’interno di LangChain.

from langchain.llms import OpenAIllm = OpenAI(model_name="text-davinci-003", temperature=0.01)print(llm("Suggerisci 3 regali di compleanno per un data scientist"))>>> 1. Una sottoscrizione a una rivista o a un giornale di data science2. Un set di libri di data science3. Una tazza o una maglietta a tema data science

Come puoi vedere, inizializziamo un LLM e lo chiamiamo con una query. Tutta la tokenizzazione e l’embedding avvengono dietro le quinte. Possiamo gestire la cronologia della conversazione e incorporare istruzioni di sistema nella chat per ottenere una maggiore flessibilità di risposta.

from langchain.chat_models import ChatOpenAIfrom langchain.schema import HumanMessage, AIMessage, SystemMessagechat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.01)conversation_history = [    HumanMessage(content="Suggerisci 3 regali di compleanno per un data scientist"),    AIMessage(content="Qual è il tuo range di prezzo?"),    HumanMessage(content="Sotto i 100$"),]print(chat(conversation_history).content)>>>1. Un libro di data science: Considera di regalare un libro popolare e altamente raccomandato sulla data science, come "Python for Data Analysis" di Wes McKinney o "The Elements of Statistical Learning" di Trevor Hastie, Robert Tibshirani e Jerome Friedman. Questi libri possono fornire preziose intuizioni e conoscenze per lo sviluppo professionale di un data scientist.2. Strumento di visualizzazione dei dati: Un data scientist si occupa spesso di grandi dataset e ha bisogno di presentare i suoi risultati in modo efficace. Considera di regalare uno strumento di visualizzazione dei dati come Tableau Public o Plotly, che possono aiutarlo a creare grafici e grafici interattivi e visivamente accattivanti per comunicare i suoi risultati di analisi dei dati.3. Sottoscrizione a una piattaforma di data science: Concedigli l'accesso a una piattaforma di data science come Kaggle o DataCamp, che offrono una vasta gamma di corsi, tutorial e dataset per consentire ai data scientist di migliorare le proprie competenze e rimanere aggiornati sulle ultime tendenze del settore. Questo regalo può fornire loro risorse di apprendimento preziose e opportunità di crescita professionale.

system_instruction = SystemMessage(    content="""Lavori come assistente in un negozio di elettronica.                                 Il tuo reddito dipende dagli articoli venduti""")user_message = HumanMessage(content="3 regali di compleanno per un data scientist")print(chat([system_instruction, user_message]).content)>>>1. Laptop: Un laptop ad alte prestazioni è essenziale per qualsiasi data scientist. Cerca un modello con un processore potente, una buona quantità di RAM e una grande capacità di archiviazione. Ciò permetterà loro di eseguire compiti di analisi dati complessi e archiviare grandi dataset.2. Hard Disk Esterno: I data scientist trattano volumi enormi di dati, quindi avere spazio di archiviazione extra è fondamentale. Un hard disk esterno con una grande capacità offrirà loro un modo comodo e sicuro per archiviare e fare il backup dei loro dati.3. Strumento di Visualizzazione dei Dati: La visualizzazione dei dati è un aspetto importante della data science. Valuta la possibilità di regalare una sottoscrizione a uno strumento di visualizzazione dei dati come Tableau o Power BI. Questi strumenti li aiuteranno a creare grafici, grafici e dashboard visivamente accattivanti e interattivi per presentare i loro risultati in modo efficace.

Come puoi vedere, possiamo orientare la conversazione in una direzione specifica utilizzando diversi tipi di messaggi: HumanMessage, AIMessage e SystemMessage.

Open-source

Ora, parliamo di modelli open-source. Di seguito è riportato un esempio tipico di inizializzazione e utilizzo di un modello di linguaggio pre-addestrato per la generazione di testo. Il codice include l’utilizzo del tokenizer, la configurazione del modello e l’inferenza efficiente con quantizzazione (diversi frammenti di codice di seguito) e il supporto CUDA.

from auto_gptq import AutoGPTQForCausalLMfrom transformers import AutoTokenizerfrom torch import cuda# Nome del modello pre-addestratomodel_name = "TheBloke/llama-2-13B-Guanaco-QLoRA-GPTQ"# Inizializza il tokenizer per il modeltokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)# Inizializza il modello AutoGPTQForCausalLM con specifiche configurazioni# Questo modello è una versione quantizzata del modello GPT adatta all'inferenza efficientemodel = AutoGPTQForCausalLM.from_quantized(    model_name,    use_safetensors=True,       # Abilita SafeTensors per la serializzazione sicura    trust_remote_code=True,     # Fiducia nel codice remoto (non consigliato per fonti non attendibili)    device_map="auto",          # Mappa automaticamente il modello al dispositivo disponibile    quantize_config=None        # Configurazione di quantizzazione personalizzata (None per impostazione predefinita))# La query di input da tokenizzare e passare al modelloquery = "<Inserisci qui il tuo testo di input>"# Tokenizza la query di input e la converte in un formato tensoriale compatibile con CUDAinput_ids = tokenizer(query, return_tensors="pt").input_ids.cuda()# Genera il testo utilizzando il modello con l'impostazione di temperatura specificataoutput = model.generate(input_ids=input_ids, temperature=0.1)

Generazione di testo

Durante la generazione di testo, puoi influenzare notevolmente il processo di generazione di testo utilizzando diversi parametri:

Come genera testo un LLM?

Questo articolo non discuterà i transformers o il modo in cui vengono addestrati i modelli di linguaggio di grandi dimensioni. Invece, ci concentreremo sull’utilizzo…

pub.towardsai.net

• temperature influenza la casualità della generazione dei token
• Top-k campionamento limita la generazione di token ai k token più probabili ad ogni passo
• Top-p campionamento (nucleus) limita la generazione di token alla probabilità cumulativa di p
• max_tokens specifica la lunghezza dei token generati

llm = OpenAI(temperature=0.5, top_k=10, top_p=0.75, max_tokens=50)

Quantizzazione

È cruciale dal punto di vista delle prestazioni utilizzare la quantizzazione.

Come adattare grandi modelli di linguaggio in una memoria ridotta: Quantizzazione

Come eseguire llm sulla tua macchina locale

pub.towardsai.net

Di seguito, ottimizzeremo un modello di linguaggio pre-addestrato per prestazioni efficienti utilizzando la quantizzazione a 4 bit. L’uso di BitsAndBytesConfig è vitale per l’applicazione di queste ottimizzazioni, che sono particolarmente vantaggiose per scenari di implementazione in cui le dimensioni e la velocità del modello sono fattori critici.

from transformers import BitsAndBytesConfig, AutoModelForCausalLMimport torch# Specifica il nome o il percorso del modellomodel_name_or_path = "nome-del-modello-o-percorso"# Configura BitsAndBytesConfig per la quantizzazione a 4 bit# Questa configurazione viene utilizzata per ottimizzare le dimensioni del modello e la velocità di inferenzabnb_config = BitsAndBytesConfig(    load_in_4bit=True,                          # Abilita il caricamento del modello con precisione a 4 bit    bnb_4bit_compute_dtype=torch.bfloat16,      # Imposta il tipo di dati di calcolo su bfloat16    bnb_4bit_quant_type="nf4",                  # Imposta il tipo di quantizzazione su nf4    bnb_4bit_use_double_quant=True              # Abilita la doppia quantizzazione per una maggiore precisione)# Carica il modello di linguaggio causale pre-addestrato con quantizzazione a 4 bitmodel_4bit = AutoModelForCausalLM.from_pretrained(    model_name_or_path,     quantization_config=bnb_config,             # Applica la configurazione di quantizzazione a 4 bit    device_map="auto",                          # Mappa automaticamente il modello al dispositivo disponibile    trust_remote_code=True                      # Fiducia nel codice remoto (usare con cautela))

Perfezionamento

In alcuni casi, è necessario perfezionare un modello di lingua pre-addestrato. Di solito, ciò viene ottenuto utilizzando l’Adattamento a Basso Rango (LoRA) per un adattamento efficace specifico del compito. Mostra anche l’uso della checkpointing del gradiente e la preparazione per l’addestramento a k-bit, che sono tecniche per ottimizzare il processo di addestramento in termini di memoria ed efficienza computazionale.

LangChain 101: Parte 2c. Perfezionamento di LLMs con PEFT, LoRA e RL

Tutto ciò che devi sapere sul perfezionamento di LLMs, PEFT, LoRA e l’addestramento di grandi modelli di lingua

pub.towardsai.net

LangChain 101: Parte 2d. Perfezionamento di LLMs con feedback umano

Come implementare il reinforcement learning con il feedback umano per LLMs pre-addestrati. Considera se vuoi correggere…

pub.towardsai.net

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_trainingfrom transformers import AutoModelForCausalLM, Trainer, TrainingArguments, DataCollatorForLanguageModeling# Carica un modello di lingua causale pre-addestratopretrained_model = AutoModelForCausalLM.from_pretrained("nome-del-tuo-modello")# Abilita la checkpointing del gradiente per l'efficienza della memoria.pretrained_model.gradient_checkpointing_enable()# Prepara il modello per l'addestramento a k-bit, ottimizzando per l'addestramento a bassa larghezza di bit.model = prepare_model_for_kbit_training(pretrained_model)# Definisci la configurazione LoRa (Adattamento a Basso Rango)# Questo configura il modello per il perfezionamento specifico del compito con matrici a basso rango.config = LoraConfig(    r=16,                            # Rango delle matrici a basso rango    lora_alpha=32,                   # Scala per gli strati LoRA    lora_dropout=0.05,               # Tasso di dropout per gli strati LoRA    bias="none",                     # Tipo di bias da utilizzare    target_modules=["query_key_value"],  # Componenti del modello di destinazione per l'adattamento LoRA    task_type="CAUSAL_LM"            # Tipo di compito, in questo caso Causal Language Modeling)# Adatta il modello con la configurazione LoRa specificatamodel = get_peft_model(model, config)# Inizializza il Trainer per l'addestramento del modellotrainer = Trainer(    model=model,    train_dataset=train_dataset,  # Dataset di addestramento    args=TrainingArguments(        num_train_epochs=10,        per_device_train_batch_size=8,        # Altri argomenti per l'addestramento...    ),    data_collator=DataCollatorForLanguageModeling(tokenizer)  # Collatione dei batch di dati)# Disabilita la memorizzazione nella cache per risparmiare memoria durante l'addestramentomodel.config.use_cache = False# Avvia il processo di addestramentotrainer.train()

Prompts

LangChain consente la creazione di prompt dinamici che possono guidare il comportamento della capacità di generazione di testo dei modelli di lingua. I modelli di prompt in LangChain forniscono un modo per generare risposte specifiche dal modello. Vediamo un esempio pratico in cui è necessario creare descrizioni SEO per prodotti specifici.

from langchain.prompts import PromptTemplate, FewShotPromptTemplate# Definisci e utilizza un semplice modello di prompttemplate = "Agisci come un esperto di SEO. Fornisci una descrizione SEO per {prodotto}"prompt = PromptTemplate(input_variables=["product"], template=template)# Formatta il prompt con un prodotto specificoformatted_prompt = prompt.format(product="Perpetuum Mobile")print(llm(formatted_prompt))>>>Perpetuum Mobile è un leader nel fornire soluzioni innovative e sostenibili per l'energia. I nostri prodotti e servizi sono progettati per aiutare aziende e individui a ridurre la propria impronta di carbonio e risparmiare denaro sui costi energetici. Siamo specializzati in sistemi di energia solare, eolica e geotermica, nonché soluzioni di stoccaggio dell'energia. Il nostro team di ingegneri e tecnici esperti si impegna a fornire prodotti e servizi di altissima qualità ai nostri clienti. Ci sforziamo di essere il fornitore di energia rinnovabile più affidabile ed economico del settore. Con il nostro impegno verso la sostenibilità e la soddisfazione del cliente, Perpetuum Mobile è la scelta perfetta per le tue esigenze energetiche.

Potrebbe esserci il caso in cui si dispone di un piccolo set di dati, few-shot, composto da diversi esempi che mostrano come si desidera che il compito venga eseguito. Diamo un’occhiata a un esempio di un compito di classificazione del testo:

# Definisci un prompt di apprendimento con pochi esempi
esempi = [   
    {"email_text": "Vinci un iPhone gratuito!", "category": "Spam"},
    {"email_text": "Prossima riunione di pianificazione Sprint.", "category": "Riunioni"},
    {"email_text": "La versione 2.1 di Y è ora online", "category": "Aggiornamenti del progetto"}
]
prompt_template = PromptTemplate(
    input_variables=["email_text", "category"],
    template="Classifica la email: {email_text} /n {category}"
)

few_shot_prompt = FewShotPromptTemplate(
    example_prompt=prompt_template,
    examples=esempi,
    suffix="Classifica la email: {email_text}",
    input_variables=["email_text"]
)

# Utilizzo del prompt di apprendimento con pochi esempi
formatted_prompt = few_shot_prompt.format(email_text="Ciao. Sto riorganizzando la standup quotidiana di domani alle 10")

print(llm(formatted_prompt)) >>>/n Riunioni

Indici

Gli indici in LangChain vengono utilizzati per gestire ed estrarre grandi volumi di dati in modo efficiente. Invece di caricare l’intero file di testo in un LLM, prima individuiamo e recuperiamo le informazioni rilevanti dalla fonte e, solo dopo aver trovato le prime k risposte, le utilizziamo per formulare una risposta. Molto intelligente!

In LangChain, l’utilizzo degli indici include il caricamento dei documenti da varie fonti, la suddivisione dei testi, la creazione di vettorizzatori e il recupero dei documenti pertinente

from langchain.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS

# Carica i documenti da una fonte web
loader = WebBaseLoader("https://en.wikipedia.org/wiki/History_of_mathematics")
documenti_caricati = loader.load()

# Suddivide i documenti caricati in testi più piccoli
text_splitter = RecursiveCharacterTextSplitter(chunk_size=400, chunk_overlap=50)
testi = text_splitter.split_documents(documenti_caricati)

# Crea un vettorizzatore e esegui una ricerca di similarità
db = FAISS.from_documents(testi, embeddings)
print(db.similarity_search("Qual è il contributo di Isaac Newton alla matematica?")) >>>[Document(page_content="Sviluppando il lavoro precedente di molti predecessori, Isaac Newton ha scoperto le leggi della fisica che spiegano le leggi di Keplero e ha unito i concetti oggi noti come calcolo infinitesimale. In modo indipendente, Gottfried Wilhelm Leibniz ha sviluppato il calcolo e gran parte della notazione matematica del calcolo ancora in uso oggi. Ha anche perfezionato il sistema di numerazione binaria, che è la base di quasi tutti i sistemi digitali (elettronici,", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'}), Document(page_content="Sono stati fatti sviluppi matematici interagenti con nuove scoperte scientifiche a un ritmo sempre crescente che continua fino ai giorni nostri. Questo include il lavoro rivoluzionario di Isaac Newton e Gottfried Wilhelm Leibniz nello sviluppo del calcolo infinitesimale durante il XVII secolo.", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'}), Document(page_content="Nel XIII secolo, Nasir al-Din Tusi (Nasireddin) ha fatto progressi in trigonometria sferica. Ha anche scritto un importante lavoro sul postulato parallelo di Euclide. Nel XV secolo, Ghiyath al-Kashi ha calcolato il valore di π alla 16esima cifra decimale. Kashi aveva anche un algoritmo per calcolare le radici ennesime, che era un caso particolare dei metodi dati molti secoli dopo da Ruffini e Horner.", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'}), Document(page_content="Whitehead, ha iniziato un dibattito durato a lungo sulle fondamenta della matematica.", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'})]

Oltre all’utilizzo di similarity_search, possiamo utilizzare i database vettoriali come recuperatori:

# Inizializza e utilizza un recuperatore per documenti pertinenti
recuperatore = db.as_retriever()
print(recuperatore.get_relevant_documents("Qual è il contributo di Isaac Newton alla matematica?")) >>>[Document(page_content="Sviluppando il lavoro precedente di molti predecessori, Isaac Newton ha scoperto le leggi della fisica che spiegano le leggi di Keplero e ha unito i concetti oggi noti come calcolo infinitesimale. In modo indipendente, Gottfried Wilhelm Leibniz ha sviluppato il calcolo e gran parte della notazione matematica del calcolo ancora in uso oggi. Ha anche perfezionato il sistema di numerazione binaria, che è la base di quasi tutti i sistemi digitali (elettronici,", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'}), Document(page_content="Sono stati fatti sviluppi matematici interagenti con nuove scoperte scientifiche a un ritmo sempre crescente che continua fino ai giorni nostri. Questo include il lavoro rivoluzionario di Isaac Newton e Gottfried Wilhelm Leibniz nello sviluppo del calcolo infinitesimale durante il XVII secolo.", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'}), Document(page_content="Nel XIII secolo, Nasir al-Din Tusi (Nasireddin) ha fatto progressi in trigonometria sferica. Ha anche scritto un importante lavoro sul postulato parallelo di Euclide. Nel XV secolo, Ghiyath al-Kashi ha calcolato il valore di π alla 16esima cifra decimale. Kashi aveva anche un algoritmo per calcolare le radici ennesime, che era un caso particolare dei metodi dati molti secoli dopo da Ruffini e Horner.", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'}), Document(page_content="Whitehead, ha iniziato un dibattito durato a lungo sulle fondamenta della matematica.", metadata={'source': 'https://en.wikipedia.org/wiki/History_of_mathematics', 'title': 'Storia della matematica - Wikipedia', 'language': 'en'})]

Memoria

La memoria in LangChain si riferisce alla capacità di un modello di ricordare le parti precedenti di una conversazione o contesto. Questo è indispensabile per mantenere la continuità nelle interazioni. Utilizziamo ConversationBufferMemory per memorizzare e recuperare la cronologia delle conversazioni.

from langchain.memory import ConversationBufferMemory# Inizializza la memoria del buffer di conversazionememory = ConversationBufferMemory(memory_key="chat_history")# Aggiungi messaggi alla memoria della conversazionememory.chat_memory.add_user_message("Ciao!")memory.chat_memory.add_ai_message("Benvenuto! Come posso aiutarti?")# Carica le variabili di memoriase ci sono memorie precedentimemory.load_memory_variables({})>>>{'chat_history': 'Umano: Ciao!\nIA: Benvenuto! Come posso aiutarti?'}

Vedremo alcuni esempi di utilizzo della memoria nelle sezioni successive.

Catene

Le catene di LangChain sono sequenze di operazioni che elaborano un input e generano un output. Vediamo un esempio di creazione di una catena personalizzata per sviluppare una risposta via email basata sul feedback fornito:

from langchain.prompts import PromptTemplatefrom langchain.chains import ConversationChain, summarize, question_answeringfrom langchain.schema import StrOutputParser# Definisci e utilizza una catena per riassumere il feedback del clientefeedback_summary_prompt = PromptTemplate.from_template(    """Sei un responsabile del servizio clienti. Dato il feedback del cliente,        è tuo compito riassumere i punti principali.       Feedback del cliente: {feedback}       Riassunto:""")# Template per scrivere una risposta via email professionaleemail_response_prompt = PromptTemplate.from_template(    """Sei un rappresentante del servizio clienti. Dato il riassunto del feedback del cliente,         è tuo compito scrivere una risposta via email professionale.Riepilogo del feedback:{summary}Risposta via email:""")feedback_chain = feedback_summary_prompt | llm | StrOutputParser()email_chain = (    {"summary": feedback_chain}    | email_response_prompt    | llm    | StrOutputParser())# Utilizzo della catena di feedback con un effettivo feedback del clienteemail_chain.invoke(  {"feedback": "Sono deluso dalla consegna tardiva e dall'imballaggio scadente."})>>>\n\nGentile [Cliente],\n\nGrazie per aver dedicato del tempo a fornirci il tuo feedback. Ci scusiamo per la consegna tardiva e la qualità dell'imballaggio. Poniamo molta attenzione alla soddisfazione del cliente e ci dispiace di non aver soddisfatto le tue aspettative.\n\nStiamo attualmente indagando sulla questione e adotteremo le misure necessarie per garantire che ciò non accada più in futuro. Valorizziamo il tuo business e speriamo che tu ci dia un'altra possibilità per offrirti un'esperienza migliore.\n\nSe hai ulteriori domande o dubbi, non esitare a contattarci.\n\nCordiali saluti,\n[Il tuo nome]

Come puoi vedere, abbiamo due catene: una genera il riassunto del feedback (feedback_chain) e una genera una risposta via email basata sul riassunto del feedback (email_chain). La catena sopra è stata creata utilizzando il Linguaggio di Espressione LangChain – il modo preferito di creare catene, secondo LangChain.

Possiamo anche utilizzare catene predefinite, ad esempio, per compiti di riassunto o semplici domande e risposte:

# Catene predefinite per il riassunto e le domande e rispostechain = summarize.load_summarize_chain(llm, chain_type="stuff")chain.run(texts[:30])>>>La storia della matematica tratta l'origine delle scoperte matematiche e i metodi matematici e la loro notazione passati. È iniziata nel VI secolo a.C. con i pitagorici, che hanno coniato il termine "matematica". La matematica greca ha migliorato notevolmente i metodi e ampliato l'oggetto della matematica. La matematica cinese ha dato contributi precoci, tra cui un sistema di valore di posizione e il primo utilizzo dei numeri negativi. Il sistema di numeri indiano-arabo e le regole per il loro utilizzo si sono evoluti nel corso del primo millennio dopo Cristo in India e sono stati trasmessi al mondo occidentale tramite la matematica islamica. Dall'antichità al Medioevo, i periodi di scoperta matematica erano spesso seguiti da secoli di stagnazione. A partire dall'Italia rinascimentale nel XV secolo, sono state fatte nuove scoperte matematiche, interagendo con nuove scoperte scientifiche, ad un ritmo crescente che continua fino ai giorni nostri.

chain = question_answering.load_qa_chain(llm, chain_type="stuff")chain.run(input_documents=texts[:30],   question="Indica i più grandi matematici arabi del passato")>>>Muḥammad ibn Mūsā al-Khwārizmī

Oltre alle catene predefinite per riassumere i feedback, rispondere alle domande, ecc., possiamo costruire la nostra ConversationChain personalizzata e integrarci la memoria.

# Utilizzo della memoria in una catena di conversazionememory = ConversationBufferMemory()conversazione = ConversationChain(llm=llm, memoria=memoria)conversazione.run("Di' il nome della montagna più alta del mondo")>>> La montagna più alta del mondo è l'Everest.conversazione.run("Quanto è alta?")>>> L'Everest si eleva a 8.848 metri (29.029 piedi) sopra il livello del mare.

Agenti e Strumenti

LangChain consente la creazione di strumenti e agenti personalizzati per compiti specializzati. Gli strumenti personalizzati possono essere qualsiasi cosa, dall’utilizzo di API personalizzate a funzioni Python personalizzate, che possono essere integrate negli agenti LangChain per operazioni complesse. Creiamo un agente che converta in minuscolo qualsiasi frase.

from langchain.tools import StructuredTool, BaseToolfrom langchain.agents import initialize_agent, AgentTypeimport re# Definizione e utilizzo di uno strumento personalizzato di elaborazione testualedef elaborazione_testuale(stringa: str) -> str:    """Elabora il testo"""    return stringa.lower()strumento_elaborazione_testuale = StructuredTool.from_function(elaborazione_testuale)# Inizializzazione e utilizzo di un agente con lo strumento personalizzatoagente = initialize_agent([strumento_elaborazione_testuale], llm,   agente=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)agente.run({"input": "Elabora il testo: Londra è la capitale della Gran Bretagna"})>>>> Entrando in una nuova catena di AgentExecutor... Devo utilizzare uno strumento di elaborazione testualeAzione: elaborazione_testualeInput azione: Londra è la capitale della Gran BretagnaOsservazione: londra è la capitale della gran bretagnaPensiero: Ora conosco la risposta finaleRisposta finale: londra è la capitale della gran bretagna> Catena completata.'londra è la capitale della gran bretagna'

Come puoi vedere, il nostro agente ha utilizzato lo strumento che abbiamo definito e ha convertito in minuscolo la frase. Ora creiamo un agente completamente funzionale. A tale scopo, creiamo uno strumento personalizzato per la conversione delle unità (ad esempio, miglia in chilometri) all’interno del testo e lo integriamo in un agente conversazionale utilizzando il framework LangChain. La classe UnitConversionTool fornisce un esempio pratico di estensione delle funzionalità di base con una logica di conversione specifica.

import refrom langchain.tools import BaseToolfrom langchain.agents import initialize_agentclass UnitConversionTool(BaseTool):    """    Uno strumento per la conversione delle unità americane in unità internazionali.    In particolare, converte le miglia in chilometri.    """    nome = "Unit Conversion Tool"    descrizione = "Converte le unità americane in unità internazionali"    def _run(self, testo: str):        """        Converte in modo sincrono le miglia nel testo in chilometri.        Argomenti:            text (str): il testo di input che contiene le miglia da convertire.        Restituisce:            str: il testo con le miglia convertite in chilometri.        """        def miglia_a_km(match):            miglia = float(match.group(1))            return f"{miglia * 1.60934:.2f} km"        return re.sub(r'\b(\d+(\.\d+)?)\s*(miglia|mile)\b', miglia_a_km, testo)    def _arun(self, testo: str):        """        Versione asincrona della funzione di conversione. Non ancora implementato.        """        raise NotImplementedError("Nessuna implementazione asincrona")# Inizializziamo un agente con lo strumento di conversione delle unitàagente = initialize_agent(    agente='chat-conversational-react-description',    strumenti=[UnitConversionTool()],    llm=llm,    memoria=memoria)# Esempio di utilizzo dell'agente per convertire unitàagente.run("cinque miglia")>>> Cinque miglia corrispondono approssimativamente a 8 chilometri.agente.run("Scusa, intendevamo 15")>>> 15 chilometri corrispondono approssimativamente a 9,3 miglia

Questo conclude il codice mostrato nel mio LangChain one-pager. Spero ti sia stato utile!

Promemoria: puoi scaricare la versione PDF, consultare gli onepager su GitHub e eseguire il codice su Colab.

Apprezzerei se cliccassi su applausi per l’articolo e mi seguissi, poiché ciò mi motiva a scrivere nuove parti e articoli 🙂 Inoltre, riceverai una notifica quando verrà pubblicata la nuova parte.