Da Zero a Advanced Prompt Engineering con Langchain in Python

Un aspetto importante dei Large Language Models (LLM) è il numero di parametri che questi modelli utilizzano per l'apprendimento. Più parametri ha un modello, meglio può comprendere la relazione tra parole e frasi. Ciò significa che i modelli con miliardi di parametri hanno la capacità di generare vari formati di testo creativi e di rispondere a domande aperte e stimolanti in modo informativo.

Gli LLM come ChatGPT, che utilizzano il modello Transformer, sono abili nella comprensione e nella generazione del linguaggio umano, rendendoli utili per le applicazioni che richiedono la comprensione del linguaggio naturale. Tuttavia, non sono privi di limiti, che includono conoscenze obsolete, incapacità di interagire con sistemi esterni, mancanza di comprensione del contesto e talvolta generazione di risposte plausibili ma errate o prive di senso, tra le altre cose.

Affrontare queste limitazioni richiede l'integrazione di LLM con fonti e capacità di dati esterne, che possono presentare complessità e richiedere ampie capacità di codifica e gestione dei dati. Questo, unito alle sfide della comprensione dei concetti di intelligenza artificiale e degli algoritmi complessi, contribuisce alla curva di apprendimento associata allo sviluppo di applicazioni che utilizzano LLM.

Tuttavia, l'integrazione di LLM con altri strumenti per formare applicazioni basate su LLM potrebbe ridefinire il nostro panorama digitale. Il potenziale di tali applicazioni è vasto, incluso il miglioramento dell'efficienza e della produttività, la semplificazione delle attività, il miglioramento del processo decisionale e la fornitura di esperienze personalizzate.

In questo articolo, approfondiremo questi temi, esplorando le tecniche avanzate di ingegneria rapida con Langchain, offrendo spiegazioni chiare, esempi pratici e istruzioni passo passo su come implementarle.

Langchain, una libreria all'avanguardia, offre praticità e flessibilità nella progettazione, implementazione e ottimizzazione dei prompt. Analizzando i principi e le pratiche dell'ingegneria dei prompt, imparerai come utilizzare le potenti funzionalità di Langchain per sfruttare i punti di forza dei modelli di intelligenza artificiale generativa SOTA come GPT-4.

Comprensione dei prompt

Prima di addentrarci negli aspetti tecnici dell'ingegneria dei prompt, è essenziale cogliere il concetto di prompt e il loro significato.

A 'pronto' è una sequenza di token utilizzati come input per un modello di linguaggio, istruendolo a generare un particolare tipo di risposta. I prompt svolgono un ruolo cruciale nel guidare il comportamento di un modello. Possono influire sulla qualità del testo generato e, se realizzati correttamente, possono aiutare il modello a fornire risultati approfonditi, accurati e specifici del contesto.

L'ingegneria dei prompt è l'arte e la scienza di progettare prompt efficaci. L'obiettivo è ottenere l'output desiderato da un modello linguistico. Selezionando e strutturando attentamente i prompt, è possibile guidare il modello verso la generazione di risposte più accurate e pertinenti. In pratica, ciò comporta la messa a punto delle frasi di input per soddisfare i bias strutturali e di addestramento del modello.

La sofisticatezza dell'ingegneria dei prompt spazia da tecniche semplici, come l'alimentazione del modello con parole chiave pertinenti, a metodi più avanzati che comportano la progettazione di prompt complessi e strutturati che sfruttano a proprio vantaggio i meccanismi interni del modello.

Langchain: lo strumento di richiesta in più rapida crescita

LangChain, lanciato nell'ottobre 2022 da Harrison Chase, è diventato uno dei framework open source più apprezzati su GitHub nel 2023. Offre un'interfaccia semplificata e standardizzata per l'incorporazione di Large Language Models (LLM) nelle applicazioni. Fornisce inoltre un'interfaccia ricca di funzionalità per l'ingegneria rapida, consentendo agli sviluppatori di sperimentare diverse strategie e valutarne i risultati. Utilizzando Langchain, puoi eseguire attività di ingegneria tempestiva in modo più efficace e intuitivo.

Lang Flow funge da interfaccia utente per orchestrare i componenti LangChain in un diagramma di flusso eseguibile, consentendo la prototipazione e la sperimentazione rapide.

LangChain colma una lacuna cruciale nello sviluppo dell'IA per le masse. Consente a una serie di applicazioni NLP come assistenti virtuali, generatori di contenuti, sistemi di risposta alle domande e altro ancora di risolvere una serie di problemi del mondo reale.

Piuttosto che essere un modello o un provider autonomo, LangChain semplifica l'interazione con diversi modelli, estendendo le capacità delle applicazioni LLM oltre i vincoli di una semplice chiamata API.

L'architettura di LangChain

I componenti principali di LangChain includono Model I/O, Prompt Template, Memoria, Agenti e Catene.

Modello I/O

LangChain facilita una connessione senza soluzione di continuità con vari modelli linguistici avvolgendoli con un'interfaccia standardizzata nota come Model I/O. Ciò facilita un cambio di modello senza sforzo per l'ottimizzazione o prestazioni migliori. LangChain supporta vari provider di modelli linguistici, tra cui OpenAI, abbracciare il viso, azzurro, FireworksE altro ancora.

Modelli rapidi

Questi vengono utilizzati per gestire e ottimizzare le interazioni con gli LLM fornendo istruzioni o esempi concisi. L'ottimizzazione dei prompt migliora le prestazioni del modello e la loro flessibilità contribuisce in modo significativo al processo di input.

Un semplice esempio di modello di prompt:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))

Man mano che avanziamo nella complessità, incontriamo modelli più sofisticati in LangChain, come il modello Reason and Act (ReAct). ReAct è un modello vitale per l'esecuzione dell'azione in cui l'agente assegna un'attività a uno strumento appropriato, personalizza l'input per esso e analizza il suo output per eseguire l'attività. L'esempio Python di seguito mostra un modello ReAct. Dimostra come è strutturato un prompt in LangChain, utilizzando una serie di pensieri e azioni per ragionare su un problema e produrre una risposta finale:

PREFIX = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""

Memorie

La memoria è un concetto fondamentale in LangChain, poiché consente ai LLM e agli strumenti di conservare le informazioni nel tempo. Questo comportamento stateful migliora le prestazioni delle applicazioni LangChain memorizzando le risposte precedenti, le interazioni dell'utente, lo stato dell'ambiente e gli obiettivi dell'agente. Le strategie ConversationBufferMemory e ConversationBufferWindowMemory aiutano a tenere traccia rispettivamente delle parti complete o recenti di una conversazione. Per un approccio più sofisticato, la strategia ConversationKGMemory consente di codificare la conversazione come un knowledge graph che può essere reinserito nei prompt o utilizzato per prevedere le risposte senza chiamare il LLM.

Agenti

Un agente interagisce con il mondo eseguendo azioni e compiti. In LangChain, gli agenti combinano strumenti e catene per l'esecuzione delle attività. Può stabilire una connessione con il mondo esterno per il recupero delle informazioni per aumentare la conoscenza LLM, superando così i loro limiti intrinseci. Possono decidere di passare i calcoli a una calcolatrice o a un interprete Python a seconda della situazione.

Gli agenti sono dotati di sottocomponenti:

• Strumenti: Questi sono componenti funzionali.
• toolkit: Collezioni di strumenti.
• Agenti esecutori: Questo è il meccanismo di esecuzione che permette di scegliere tra gli strumenti.

Gli agenti di LangChain seguono anche il modello Zero-shot ReAct, in cui la decisione si basa esclusivamente sulla descrizione dello strumento. Questo meccanismo può essere esteso con la memoria per tenere conto dell'intera cronologia delle conversazioni. Con ReAct, invece di chiedere a un LLM di completare automaticamente il testo, è possibile richiedergli di rispondere in un ciclo di pensiero/azione/osservazione.

Catene

Le catene, come suggerisce il termine, sono sequenze di operazioni che consentono alla libreria LangChain di elaborare input e output del modello linguistico senza soluzione di continuità. Questi componenti integrali di LangChain sono fondamentalmente costituiti da collegamenti, che possono essere altre catene o primitive come prompt, modelli linguistici o utilità.

Immagina una catena come un nastro trasportatore in una fabbrica. Ogni passaggio su questa cintura rappresenta una determinata operazione, che potrebbe essere invocare un modello di linguaggio, applicare una funzione Python a un testo o persino richiedere il modello in un modo particolare.

LangChain classifica le sue catene in tre tipologie: catene di utilità, catene generiche e catene di documenti combinati. Nella nostra discussione approfondiremo le catene di utilità e quelle generiche.

• Catene di utilità sono specificamente progettati per estrarre risposte precise dai modelli linguistici per compiti definiti in modo rigoroso. Ad esempio, diamo un'occhiata a LLMMathChain. Questa catena di utilità consente ai modelli linguistici di eseguire calcoli matematici. Accetta una domanda in linguaggio naturale e il modello linguistico a sua volta genera un frammento di codice Python che viene poi eseguito per produrre la risposta.
• Catene generiche, d'altra parte, fungono da elementi costitutivi per altre catene ma non possono essere utilizzati direttamente da soli. Queste catene, come LLMChain, sono fondamentali e sono spesso combinate con altre catene per svolgere compiti complessi. Ad esempio, LLMChain viene spesso utilizzato per interrogare un oggetto modello di linguaggio formattando l'input in base a un modello di prompt fornito e quindi passandolo al modello di linguaggio.

Implementazione passo dopo passo di Prompt Engineering con Langchain

Ti guideremo attraverso il processo di implementazione dell'ingegneria rapida utilizzando Langchain. Prima di procedere, assicurati di aver installato il software e i pacchetti necessari.

Puoi sfruttare strumenti popolari come Docker, Conda, Pip e Poetry per configurare LangChain. I file di installazione pertinenti per ciascuno di questi metodi possono essere trovati all'interno del repository LangChain all'indirizzo https://github.com/benman1/generative_ai_with_langchain. Questo include a Dockerfile per Docker, a requirements.txt per Pip, a pyproject.toml per la poesia e a langchain_ai.yml file per Conda.

Nel nostro articolo utilizzeremo Pip, il gestore di pacchetti standard per Python, per facilitare l'installazione e la gestione di librerie di terze parti. Se non è incluso nella tua distribuzione Python, puoi installare Pip seguendo le istruzioni qui. https://pip.pypa.io/.

Per installare una libreria con Pip, usa il comando pip install library_name.

Tuttavia, Pip non gestisce gli ambienti autonomamente. Per gestire ambienti diversi, utilizziamo lo strumento virtualenv.

Nella prossima sezione parleremo delle integrazioni dei modelli.

Passaggio 1: configurazione di Langchain

Innanzitutto, devi installare il pacchetto Langchain. Stiamo usando il sistema operativo Windows. Esegui il seguente comando nel tuo terminale per installarlo:

pip install langchain

Passaggio 2: importazione di Langchain e altri moduli necessari

Successivamente, importa Langchain insieme ad altri moduli necessari. Qui importiamo anche la libreria dei trasformatori, ampiamente utilizzata nelle attività di PNL.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Passaggio 3: caricare il modello preaddestrato

Apri AI

OpenAI I modelli possono essere facilmente interfacciati con la libreria LangChain o con la libreria client Python di OpenAI. In particolare, OpenAI fornisce una classe Embedding per i modelli di embedding di testo. Due modelli LLM chiave sono GPT-3.5 e GPT-4, che differiscono principalmente per la lunghezza del token. I prezzi di ciascun modello sono disponibili sul sito web di OpenAI. Sebbene siano disponibili ulteriori modelli sofisticati come GPT-4-32K che hanno una maggiore accettazione di token, la loro disponibilità tramite API è non sempre garantito.

Per accedere a questi modelli è necessaria una chiave API OpenAI. Per farlo, è necessario creare un account sulla piattaforma OpenAI, impostare le informazioni di fatturazione e generare una nuova chiave segreta.

import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'

Dopo aver creato correttamente la chiave, puoi impostarla come variabile di ambiente (OPENAI_API_KEY) o passarla come parametro durante l'istanziazione della classe per le chiamate OpenAI.

Prendi in considerazione uno script LangChain per mostrare l'interazione con i modelli OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# The LLM takes a prompt as an input and outputs a completion
prompt = "who is the president of the United States of America?"
completion = llm(prompt)

The current President of the United States of America is Joe Biden.

In questo esempio, un agente viene inizializzato per eseguire calcoli. L'agente accetta un input, una semplice attività di addizione, lo elabora utilizzando il modello OpenAI fornito e restituisce il risultato.

Abbracciare il viso

Abbracciare il viso è un GRATUITO Libreria Transformers Python, compatibile con PyTorch, TensorFlow e JAX, e include implementazioni di modelli come BERTA, T5, ecc.

Hugging Face offre anche Hugging Face Hub, una piattaforma per ospitare repository di codici, modelli di machine learning, set di dati e applicazioni web.

Per utilizzare Hugging Face come provider per i tuoi modelli, avrai bisogno di un account e di chiavi API, che puoi ottenere dal loro sito web. Il token può essere reso disponibile nel tuo ambiente come HUGGINGFACEHUB_API_TOKEN.

Considera il seguente frammento Python che utilizza un modello open source sviluppato da Google, il modello Flan-T5-XXL:

from langchain.llms import HuggingFaceHub

llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64},repo_id="google/flan-t5-xxl")
prompt = "In which country is Tokyo?"
completion = llm(prompt)
print(completion)

Questo script accetta una domanda come input e restituisce una risposta, mostrando le capacità di conoscenza e previsione del modello.

Passaggio 4: ingegneria dei prompt di base

Per cominciare, genereremo un semplice prompt e vedremo come risponde il modello.

prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Nello snippet di codice sopra, forniamo una richiesta per tradurre il testo inglese in francese. Il modello linguistico tenta quindi di tradurre il testo dato in base al prompt.

Passaggio 5: progettazione avanzata dei prompt

Sebbene l'approccio descritto sopra funzioni bene, non sfrutta appieno la potenza del prompt engineering. Miglioriamolo introducendo strutture di prompt più complesse.

prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

In questo frammento di codice, modifichiamo il prompt per suggerire che la traduzione è stata eseguita da un "traduttore francese altamente competente". Il cambiamento nel prompt può portare a traduzioni migliori, poiché il modello assume ora la persona di un esperto.

Costruire un sistema di domande e risposte sulla letteratura accademica con Langchain

Realizzeremo un sistema di domande e risposte sulla letteratura accademica utilizzando LangChain, in grado di rispondere a domande su articoli accademici pubblicati di recente.

Innanzitutto, per configurare il nostro ambiente, installiamo le dipendenze necessarie.

pip install langchain arxiv openai transformers faiss-cpu

Dopo l'installazione, creiamo un nuovo notebook Python e importiamo le librerie necessarie:

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

Il nucleo del nostro sistema di domande e risposte è la capacità di recuperare documenti accademici pertinenti relativi a un determinato campo, qui consideriamo l'elaborazione del linguaggio naturale (NLP), utilizzando il database accademico arXiv. Per fare questo, definiamo una funzione get_arxiv_data(max_results=10). Questa funzione raccoglie i riepiloghi cartacei NLP più recenti da arXiv e li incapsula negli oggetti Documento LangChain, utilizzando il riepilogo come contenuto e l'ID voce univoco come fonte.

Utilizzeremo l'API arXiv per recuperare articoli recenti relativi all'NLP:

def get_arxiv_data(max_results=10):
    search = arxiv.Search(
        query="NLP",
        max_results=max_results,
        sort_by=arxiv.SortCriterion.SubmittedDate,
    )
   
    documents = []
   
    for result in search.results():
        documents.append(Document(
            page_content=result.summary,
            metadata={"source": result.entry_id},
        ))

    return documents

Questa funzione recupera i riassunti degli articoli NLP più recenti da arXiv e li converte in oggetti Documento LangChain. Utilizziamo il riassunto dell'articolo e il suo ID univoco (URL dell'articolo) rispettivamente come contenuto e fonte.

def print_answer(question):
    print(
        chain(
            {
                "input_documents": sources,
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )                 

Definiamo il nostro corpus e configuriamo LangChain:

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Con il nostro sistema di domande e risposte accademico ora pronto, possiamo testarlo ponendo una domanda:

print_answer("What are the recent advancements in NLP?")

L'output sarà la risposta alla tua domanda, citando le fonti da cui sono state estratte le informazioni. Ad esempio:

Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs).
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

È possibile cambiare facilmente modello o modificare il sistema in base alle proprie esigenze. Ad esempio, qui stiamo passando a GPT-4, che ci fornisce una risposta molto migliore e dettagliata.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))

Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm.
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Un token in GPT-4 può essere lungo quanto un carattere o quanto una parola. Ad esempio, GPT-4-32K può elaborare fino a 32,000 token in una singola esecuzione, mentre GPT-4-8K e GPT-3.5-turbo supportano rispettivamente 8,000 e 4,000 token. Tuttavia, è importante notare che ogni interazione con questi modelli comporta un costo direttamente proporzionale al numero di token elaborati, sia in input che in output.

Nel contesto del nostro sistema di domande e risposte, se un brano di letteratura accademica supera il limite massimo di token, il sistema non riuscirà a elaborarlo nella sua interezza, compromettendo così la qualità e la completezza delle risposte. Per ovviare a questo problema, il testo può essere suddiviso in parti più piccole conformi al limite di token.

FAISS (ricerca di somiglianza AI di Facebook) Aiuta a trovare rapidamente i blocchi di testo più pertinenti alla query dell'utente. Crea una rappresentazione vettoriale di ciascun blocco di testo e utilizza questi vettori per identificare e recuperare i blocchi più simili alla rappresentazione vettoriale di una determinata domanda.

È importante ricordare che, anche con l'utilizzo di strumenti come FAISS, la necessità di suddividere il testo in blocchi più piccoli a causa delle limitazioni dei token può talvolta portare alla perdita di contesto, influendo sulla qualità delle risposte. Pertanto, un'attenta gestione e ottimizzazione dell'utilizzo dei token sono fondamentali quando si lavora con questi modelli linguistici di grandi dimensioni.

 
pip install faiss-cpu langchain CharacterTextSplitter

Dopo esserti assicurato che le librerie di cui sopra siano installate, esegui

 
from langchain.embeddings.openai import OpenAIEmbeddings 
from langchain.vectorstores.faiss import FAISS 
from langchain.text_splitter import CharacterTextSplitter 
documents = get_arxiv_data(max_results=10) # We can now use feed more data
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
    for chunk in splitter.split_text(document.page_content):
        document_chunks.append(Document(page_content=chunk, metadata=document.metadata))

search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())

chain = load_qa_with_sources_chain(OpenAI(temperature=0))

def print_answer(question):
    print(
        chain(
            {
                "input_documents": search_index.similarity_search(question, k=4),
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )

Con il codice completo, ora disponiamo di un potente strumento per interrogare l'ultima letteratura accademica nel campo della PNL.

 
Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks. 
SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1 

Conclusione

L'integrazione dei Large Language Model (LLM) nelle applicazioni ha accelerato l'adozione di diversi domini, tra cui la traduzione linguistica, l'analisi del sentiment e il recupero delle informazioni. Il prompt engineering è uno strumento potente per massimizzare il potenziale di questi modelli e Langchain è all'avanguardia nella semplificazione di questo compito complesso. La sua interfaccia standardizzata, i modelli di prompt flessibili, la solida integrazione dei modelli e l'uso innovativo di agenti e catene garantiscono risultati ottimali per le prestazioni degli LLM.

Tuttavia, nonostante questi progressi, ci sono alcuni suggerimenti da tenere a mente. Quando si utilizza Langchain, è essenziale comprendere che la qualità dell'output dipende in larga misura dalla formulazione del prompt. Sperimentare diversi stili e strutture di prompt può produrre risultati migliori. Inoltre, è importante ricordare che, sebbene Langchain supporti una varietà di modelli linguistici, ognuno di essi presenta punti di forza e di debolezza. Scegliere quello giusto per il proprio compito specifico è fondamentale. Infine, è importante ricordare che l'utilizzo di questi modelli comporta considerazioni sui costi, poiché l'elaborazione dei token influenza direttamente il costo delle interazioni.

Come dimostrato nella guida dettagliata, Langchain può alimentare applicazioni robuste, come il sistema di domande e risposte sulla letteratura accademica. Con una comunità di utenti in crescita e una crescente importanza nel panorama open source, Langchain promette di essere uno strumento fondamentale per sfruttare tutto il potenziale di LLM come GPT-4.