Creazione di applicazioni di intelligenza artificiale generativa con LangChain e OpenAI API

Creazione di app AI generative con LangChain e OpenAI API

Introduzione

L’IA generativa sta guidando l’ultima ondata tecnologica nell’industria. Applicazioni di IA generativa come la generazione di immagini, la generazione di testi, la sintesi e i bot di domande e risposte, solo per citarne alcuni, stanno avendo un grande successo. Dopo che OpenAI ha recentemente guidato l’onda dei grandi modelli di linguaggio, molte startup hanno sviluppato strumenti e framework per consentire agli sviluppatori di creare applicazioni innovative utilizzando questi LLM. Uno di questi strumenti è LangChain, un framework per sviluppare applicazioni basate su LLM con composabilità e affidabilità. LangChain è diventato lo strumento principale per gli sviluppatori di IA di tutto il mondo per creare applicazioni di IA generativa. LangChain consente anche di connettere fonti di dati esterne e di integrarsi con molti LLM disponibili sul mercato. Oltre a ciò, le app alimentate da LLM richiedono un database di archiviazione vettoriale per memorizzare i dati che verranno recuperati in seguito. In questo articolo, impareremo di più su LangChain e le sue funzioni costruendo un’applicazione che utilizzi l’API di OpenAI e ChromaDB.

Obiettivi di apprendimento:

• Apprendere i fondamenti di LangChain per costruire una pipeline di IA generativa
• Incorporare il testo utilizzando modelli open source e database di archiviazione vettoriale come Chromadb
• Imparare a utilizzare le API di OpenAI con LangChain per integrare LLM nella propria applicazione

Questo articolo è stato pubblicato come parte del Data Science Blogathon.

• Incontra Co-BioNet il sistema di IA avversaria dell’Università di Monash che rivoluziona l’analisi delle immagini mediche, migliorando la precisione senza richiedere estese annotazioni umane.
• Trasforma immagini in video con l’AI (Tutorial Runway 2)
• Gli ricercatori del CMU propongono TIDEE un agente incarnato in grado di mettere in ordine stanze mai viste prima senza alcuna istruzione esplicita

Panoramica di LangChain

LangChain è diventato di recente un framework popolare per le applicazioni di grandi modelli di linguaggio. LangChain fornisce un framework sofisticato per interagire con LLM, fonti di dati esterne, prompt e interfacce utente.

Proposte di valore di LangChain

Le principali proposte di valore di LangChain sono:

• Componenti: Queste sono le astrazioni necessarie per lavorare con i modelli di linguaggio. I componenti sono modulari e facili da usare per molti casi d’uso di LLM.
• Chains pronte all’uso: Un assemblaggio strutturato di vari componenti e moduli per realizzare compiti specifici, come la sintesi, le domande e risposte, ecc.

Dettagli del progetto

LangChain è un progetto open source e, fin dal suo lancio, ha ottenuto oltre 54.000 stelle su Github, il che dimostra la popolarità e l’accettazione del progetto.

La descrizione del progetto nel file readme è qualcosa del genere:

I grandi modelli di linguaggio (LLM) stanno emergendo come una tecnologia trasformativa, consentendo agli sviluppatori di creare applicazioni che in passato non potevano. Tuttavia, utilizzare questi LLM in modo isolato spesso non è sufficiente per creare un’app veramente potente: il vero potere arriva quando li si combina con altre fonti di calcolo o conoscenza.

Fonte: Repository del progetto

È evidente che definisce lo scopo del framework con l’obiettivo di aiutare nello sviluppo di applicazioni in cui viene sfruttata la conoscenza dell’utente.

LangChain ha sei componenti principali per costruire applicazioni LLM: input/output del modello, connessioni dati, catene, memoria, agenti e callback. Il framework consente anche l’integrazione con molti strumenti per lo sviluppo di applicazioni full-stack, come OpenAI, Huggingface Transformers e archivi di vettori come Pinecone e ChromaDB, tra gli altri.

Spiegazione completa dei componenti:

1. Input/Output del modello: Interfaccia con i modelli di linguaggio. Comprende prompt, modelli e parser di output.
2. Connessioni dati: Interfaccia con fonti di dati specifiche dell’applicazione con trasformatori di dati, suddivisori di testo, archivi di vettori e recuperatori.
3. Catene: Costruiscono una sequenza di chiamate con altri componenti dell’applicazione di intelligenza artificiale. Alcuni esempi di catene sono catene sequenziali, catene di sintesi e catene di domande e risposte.
4. Agenti: LangChain fornisce agenti che consentono alle applicazioni di utilizzare una catena dinamica di chiamate a vari strumenti, inclusi LLM, in base all’input dell’utente.
5. Memoria: Conserva lo stato dell’applicazione tra le esecuzioni di una catena.
6. Callback: Registra e trasmette i passaggi delle catene sequenziali al fine di eseguire le catene in modo efficiente e monitorare il consumo di risorse.

Andiamo ora ad analizzare alcuni dei casi d’uso per LangChain.

1. Risposta alle domande o chat su documenti specifici
2. Chatbot
3. Riassunto
4. Agenti
5. Interazione con le API

Questi sono solo alcuni dei molti casi d’uso. Impareremo e svilupperemo un’applicazione di ricerca semantica per rispondere alle domande su documenti specifici utilizzando le API di OpenAI e ChromaDB, un database di vettori open-source. Per saperne di più sul framework LangChain, consiglio vivamente di leggere la documentazione ufficiale. (Link: qui)

Configurazione dell’ambiente e caricamento dei documenti

Ora, prepareremo un ambiente per la nostra applicazione di ricerca semantica utilizzando le API di LLM di OpenAI per rispondere alle domande degli utenti su un insieme di documenti. In questo articolo stiamo utilizzando dei documenti di esempio, ma è possibile utilizzare i propri documenti per creare un’applicazione di risposta alle domande. Prima, è necessario installare le seguenti librerie:

Installazione delle dipendenze del progetto

# installa openai, langchain, sentence transformers e altre dipendenze
!pip install openai langchain sentence_transformers -q
!pip install unstructured -q

# installa le dipendenze dell'ambiente
!pip install pydantic==1.10.8
!pip install typing-inspect==0.8.0 typing_extensions==4.5.
!pip install chromadb==0.3.26

LangChain richiede alcune dipendenze dell’ambiente con una versione specifica, come pydantic, typing extensions e ChromaDB. Una volta completata l’installazione, è possibile eseguire il seguente codice nel proprio ambiente Colab o in qualsiasi altro ambiente di notebook.

Caricatore documenti LangChain

LangChain fornisce classi di caricamento documenti per caricare documenti da input dell’utente o da un database. Supporta diversi formati di file, come HTML, JSON, CSV, ecc. Abbiamo alcuni file di testo che utilizzeremo nel nostro caso d’uso. È possibile trovare i file nel repository GitHub. (Repository GitHub — Link)

# importa il caricatore dir di langchain dai caricatori di documenti
from langchain.document_loaders import DirectoryLoader

# percorso della directory
directory = '/content/pets'

# funzione per caricare i documenti di testo
def load_docs(directory):
  loader = DirectoryLoader(directory)
  documents = loader.load()
  return documents

documents = load_docs(directory)
len(documents)

---------------------------[Output]----------------------------------------
[nltk_data] Downloading package punkt to /root/nltk_data...
[nltk_data]   Unzipping tokenizers/punkt.zip.
[nltk_data] Downloading package averaged_perceptron_tagger to
[nltk_data]     /root/nltk_data...
[nltk_data]   Unzipping taggers/averaged_perceptron_tagger.zip.
5

Una volta caricati i dati, utilizzeremo uno splitter di testo per dividere i documenti di testo in blocchi di dimensioni fisse per memorizzarli nel database di vettori. LangChain offre diversi splitter di testo, come la divisione per carattere, la divisione per codice, ecc.

# utilizza lo splitter di testo per dividere il testo in blocchi
from langchain.text_splitter import RecursiveCharacterTextSplitter

# suddividi i documenti in blocchi utilizzando lo splitter di caratteri ricorsivo
def split_docs(documents, chunk_size=1000, chunk_overlap=20):
  text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
  docs = text_splitter.split_documents(documents)
  return docs

# memorizza i documenti suddivisi nella variabile docs
docs = split_docs(documents)

Una volta che i documenti sono stati convertiti in blocchi, li incorporeremo in un vettore utilizzando modelli di embedding open-source nella sezione successiva.

Embedding del testo utilizzando LangChain e un modello open-source

L’embedding dei testi è il concetto più importante nel processo di sviluppo dell’applicazione LLM. Tutti i documenti di testo devono essere convertiti in vettori prima di poter essere elaborati per compiti come la ricerca semantica, il riassunto, ecc. Utilizzeremo il modello open-source “all-MiniLM-L6-v2” di sentence-transformer per l’embedding del testo. Una volta che i documenti sono stati incorporati, possiamo memorizzarli nel database di vettori open-source ChromaDB per eseguire una ricerca semantica. Vediamo l’esempio di codice pratico.

# embedding utilizzando langchain
from langchain.embeddings import SentenceTransformerEmbeddings
embeddings = SentenceTransformerEmbeddings(model_name="all-MiniLM-L6-v2")

# utilizzando ChromaDB come archivio di vettori e memorizzando i documenti in esso
from langchain.vectorstores import Chroma
db = Chroma.from_documents(docs, embeddings)

# Eseguendo una ricerca di similarità utilizzando una query
query = "Quali sono i diversi tipi di animali domestici comuni?"
matching_docs = db.similarity_search(query)

matching_docs[0]

--------------------------[output]----------------------------------------
Document(page_content='Gli animali domestici hanno forme e dimensioni diverse, 
ognuno adatto a diversi stili di vita e ambienti domestici. 
I cani e i gatti sono i più comuni, conosciuti per la loro compagnia 
e personalità uniche. Piccoli mammiferi come criceti, cavie 
e conigli sono spesso scelti per le loro esigenze di bassa manutenzione.
 Gli uccelli offrono bellezza e canto, e i rettili come tartarughe e 
lucertole possono essere animali domestici affascinanti. Anche i pesci, 
con la loro presenza rilassante, possono essere animali domestici meravigliosi.', 
metadata={'source': '/content/pets/Different Types of Pet Animals.txt'})

Nel codice sopra, utilizziamo gli embedding per archiviare in ChromaDB, che supporta lo storage in memoria. in questo modo possiamo interrogare il database per ottenere la risposta dai nostri documenti di testo. Abbiamo chiesto di conoscere i diversi tipi di animali domestici comunemente posseduti dalle persone, e ciò ha portato a una risposta corretta con la fonte della risposta.

Applicazioni di intelligenza artificiale generativa utilizzando le API di OpenAI, ChromaDB e LangChain

Ricerca semantica Q&A utilizzando LangChain e le API di OpenAI

Questo pipeline consiste nell’interpretare l’intento e il contesto dei termini di ricerca e dei documenti per produrre risultati di ricerca più precisi. Può aumentare l’accuratezza della ricerca comprendendo l’intento dell’utente, esaminando le connessioni tra parole e concetti e producendo risultati di ricerca consapevoli del contesto utilizzando meccanismi di attenzione nell’elaborazione del linguaggio naturale (NLP).

LangChain offre un’interfaccia di chat OpenAI per chiamare le API del modello nella tua applicazione e creare una pipeline di domanda/risposta che risponde alle domande degli utenti in base al contesto o ai documenti di input forniti. Effettua essenzialmente una ricerca vettoriale per trovare la risposta più simile alla domanda. (Fai riferimento al diagramma di flusso sottostante.)

# inserisci una chiave openai nel parametro sottostante
import os
os.environ["OPENAI_API_KEY"] = "LA-TUA-CHIAVE-OPENAI"

# carica il modello LLM
from langchain.chat_models import ChatOpenAI
model_name = "gpt-3.5-turbo"
llm = ChatOpenAI(model_name=model_name)

# Utilizzo della catena di domande e risposte per ottenere la risposta alla nostra query
from langchain.chains.question_answering import load_qa_chain
chain = load_qa_chain(llm, chain_type="stuff",verbose=True)

# scrivi la tua query ed esegui una ricerca di similarità per generare una risposta
query = "Quali sono i benefici emotivi di possedere un animale domestico?"
matching_docs = db.similarity_search(query)
answer =  chain.run(input_documents=matching_docs, question=query)
answer

-----------------------------------[Risultati]---------------------------------
'Possedere un animale domestico può fornire numerosi benefici emotivi. Gli animali domestici offrono compagnia e possono aiutare a ridurre il senso di solitudine e isolamento. Forniscono amore e supporto incondizionati, il che può migliorare l'umore e il benessere generale. Interagire con gli animali domestici, come accarezzarli o giocare con loro, è stato dimostrato che diminuisce i livelli di ormoni dello stress e aumenta il rilascio di ossitocina, un ormone associato al legame e al rilassamento. Gli animali domestici offrono anche un senso di scopo e responsabilità, poiché prendersi cura di loro può dare un senso di realizzazione e fornire una distrazione dagli stress quotidiani. Inoltre, il legame tra gli animali domestici e i loro proprietari può fornire un senso di stabilità e coerenza durante periodi di stress personale o sociale.'

Il codice precedente chiama l’API del modello “gpt-3.5-turbo” utilizzando la funzione ChatOpenAI() di LangChain e crea una catena di domande e risposte per rispondere alla nostra query. Per informazioni più dettagliate sul codice, puoi visitare la documentazione ufficiale di LangChain (qui) e il notebook del codice su Github (qui)

Genera nomi di aziende utilizzando LLMChain

L’altro caso d’uso del grande modello di linguaggio è generare nomi di aziende utilizzando LLMChain, OpenAI LLM e PromptTemplate di LangChain. Puoi generare nomi di aziende o prodotti in base alla descrizione fornita come prompt. Fai riferimento al codice sottostante:

# importa i componenti necessari da langchain
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# LLM di OpenAI
llm = OpenAI(temperature=0.9)

# Scrivi un prompt utilizzando PromptTemplate
prompt = PromptTemplate(
    input_variables=["prodotto"],
    template="Qual è un buon nome per un'azienda che produce {prodotto}?",
)

# crea una catena utilizzando LLMChain
chain = LLMChain(llm=llm, prompt=prompt)

# Esegui la catena specificando solo la variabile di input.
print(chain.run("calzini colorati"))

Output>>>    Colorful Toes Co.

Riassunto dei documenti di testo utilizzando le catene di LangChain

Le catene consentono anche lo sviluppo di applicazioni di riassunto del testo che possono essere utili nell’industria legale per riassumere grandi quantità di documenti legali al fine di accelerare il processo giudiziario. Fare riferimento al codice di esempio riportato di seguito che utilizza la funzione di LangChain:

# dall'importazione di langChain importa la funzione load_suumarize_chain e OpenAI llm
from langchain.llms import OpenAI
from langchain.chains.summarize import load_summarize_chain

# LLM di OpenAI
llm = OpenAI(temperature=0.9)

# crea un'istanza della catena con OpenAI LLM con il tipo di catena map_reduce
chain = load_summarize_chain(llm, chain_type="map_reduce")
chain.run(docs)

L’interfaccia facile da usare di LangChain sblocca molte applicazioni diverse e risolve molti problemi per gli utenti finali. Come si può vedere, con poche semplici righe di codice, possiamo sfruttare il potere di LLM per riassumere qualsiasi dato da qualsiasi fonte sul web.

Conclusioni

In conclusione, il post del blog ha esplorato l’entusiasmante campo della costruzione di applicazioni di intelligenza artificiale generative utilizzando LangChain e le API di OpenAI. Abbiamo visto una panoramica di LangChain, dei suoi vari componenti e dei casi d’uso delle applicazioni LLM. L’intelligenza artificiale generativa ha rivoluzionato vari settori, consentendoci di generare testi, immagini, video e altro ancora realistici. La ricerca semantica è una delle applicazioni utilizzate per costruire applicazioni di domanda e risposta utilizzando LLM di OpenAI come GPT-3.5 e GPT-4. Vediamo ora le principali conclusioni di questo blog:

1. Abbiamo appreso una breve panoramica di LangChain – Un framework open source per costruire applicazioni alimentate da LLM.
2. Abbiamo imparato ad utilizzare LangChain e ChromaDB – Un database vettoriale per memorizzare le incorporazioni per le applicazioni di ricerca di similarità.
3. Infine, abbiamo appreso le API di OpenAI LLM per costruire applicazioni di intelligenza artificiale generative utilizzando LangChain.

Domande frequenti

I media mostrati in questo articolo non sono di proprietà di Analytics Vidhya e sono utilizzati a discrezione dell’autore.