Una guida passo-passo ai chatbot in PDF con Langchain e Ollama

Un tutorial completo sui chatbot in formato PDF con Langchain e Ollama

Introduzione

In un’era in cui la tecnologia continua a trasformare il modo in cui interagiamo con le informazioni, il concetto di un chatbot PDF porta a un nuovo livello di comodità ed efficienza. Questo articolo esplora il fascinante mondo della creazione di un chatbot PDF utilizzando Langchain e Ollama, dove i modelli open-source diventano accessibili con una configurazione minima. Diciamo addio alle complessità della selezione del framework e degli aggiustamenti dei parametri del modello, mentre ci imbarchiamo in un viaggio per sbloccare il potenziale dei chatbot PDF. Scopri come installare senza soluzione di continuità Ollama, scaricare i modelli e creare un chatbot PDF che fornisce risposte intelligenti alle tue domande. Esploriamo questa entusiasmante fusione di tecnologia e elaborazione dei documenti, rendendo il recupero delle informazioni più facile che mai.

Obiettivi di apprendimento

Capire come installare Ollama sul tuo computer.
Imparare come scaricare ed eseguire un modello open-source usando Ollama.
Scoprire il processo di creazione di un chatbot PDF utilizzando Langchain e Ollama.

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

Prerequisiti

Per comprendere correttamente questo articolo, hai bisogno di:

Una buona conoscenza di Python e,
Conoscenze di base di Langchain, ovvero catene, archivi vettoriali, ecc.

Langchain fornisce vari tipi di funzionalità per la creazione di app LLM. Merita un articolo separato tutto per sé. Se non sai cos’è Langchain, ti suggerisco di leggere alcuni articoli o tutorial su Langchain. Puoi vedere anche questo video.

Cos’è Ollama?

Ollama ti offre la possibilità di scaricare il modello open-source e usarlo localmente. Scarica automaticamente i modelli dalla migliore fonte. Se hai una GPU dedicata sul tuo computer, eseguirà il modello con accelerazione tramite GPU. Non è necessario impostarlo manualmente. Puoi anche personalizzare il modello cambiando la richiesta (sì, non hai bisogno di Langchain per farlo). Ollama è disponibile anche come immagine docker in modo da poter distribuire il tuo modello come un contenitore docker. Eccitante, vero? Ora vediamo come puoi installare Ollama nel tuo computer.

Come installare Ollama?

Purtroppo, Ollama è disponibile solo per MacOS e Linux. Ma non preoccuparti, c’è anche un modo per gli utenti di Windows per utilizzare Ollama – WSL2. Se non hai WSL2 sul tuo computer, leggi questo articolo. Qui ho spiegato tutto su WSL2 e su come usarlo in VS Code. Se lo hai già installato, apri Ubuntu ed esegui il comando seguente nel terminale.

curl https://ollama.ai/install.sh | sh

Questo installerà Ollama in WSL2. Se stai usando MacOS, visita questa pagina. Ora sei pronto per scaricare un modello usando Ollama. Tieni aperto il terminale, non abbiamo finito ancora.

Scaricamento di un modello

Ollama fornisce vari modelli – llama2, llama2-uncensored, codellama, orca-mini, ecc. Se desideri conoscere tutti i modelli disponibili, puoi andare su questo sito web. Qui scaricherai il modello orca-mini 3b. È un modello Llama addestrato su set di dati in stile orca creati utilizzando gli approcci definiti nel documento Orca. Anche se questo modello è piccolo (1,9 GB), offre comunque una buona risposta. Per scaricare questo modello, esegui il comando seguente:

ollama run orca-mini

Questo comando scaricherà e eseguirà il modello orca-mini nel terminale. Assicurati di avere almeno 8 GB di RAM nel tuo computer prima di eseguire questo modello.

Se stai eseguendo il modello, fagli alcune domande e vedi come risponde. Ecco un esempio:

Puoi vedere dall’esempio sopra che a volte fornisce informazioni irrilevanti. Possiamo risolvere questo problema cambiando il suggerimento. Cambieremo il suggerimento quando creeremo il chatbot.

Ora che il modello funziona correttamente, creiamo il chatbot PDF utilizzandolo.

Creazione del Chatbot

Configura la Directory del Progetto

Se non sai come creare un progetto in WSL2, consulta l’ultima parte di questo articolo. Lì ho spiegato tutto. Qui utilizzeremo VS Code come IDE.

Installazione delle Librerie Necessarie

Prima di iniziare, installiamo le librerie necessarie. Crea un file chiamato requirements.txt e scrivi le dipendenze seguenti.

langchainpymupdfhuggingface-hubfaiss-cpusentence-transformers

Successivamente, apri il terminale in VS Code ed esegui il comando seguente.

>>> pip install -r requirements.txt

Ora ci vorrà del tempo. Non hai bisogno di alcun pacchetto per Ollama in quanto si tratta di un’app. Ora possiamo iniziare a scrivere il nostro chatbot.

Creazione delle Funzioni Necessarie

Per creare un chatbot in Langchain, dobbiamo seguire alcuni passaggi:

Lettura del file PDF utilizzando un caricatore PDF qualsiasi da Langchain.
Se il documento è molto grande, è una buona idea suddividerlo in parti più piccole, chiamate anche chunk. In questo modo, possiamo assicurarci che il modello ottenga le informazioni corrette per la tua domanda senza utilizzare troppe risorse. È come dare al modello solo i pezzi di cui ha bisogno invece di sovraccaricarlo con tutto in una volta sola. Ogni modello ha un limite di token, no?
Dopo averlo fatto, dobbiamo convertire quei chunk in embedding vettoriali in modo che il modello ottenga una migliore comprensione dei dati. Quindi dobbiamo creare il vettore store in cui possiamo archiviare questi embedding e recuperarli in modo efficiente quando necessario. Qui useremo il vettore store FAISS.
Ora siamo pronti per interrogare il file PDF. Per questo, useremo RetrievalQA da Langchain. Prenderà il vettore store come recuperatore e il modello che stiamo per utilizzare. Vengono utilizzati anche altri parametri in base alle nostre esigenze.

Importa i Pacchetti Necessari

Questi sono i passaggi per un chatbot PDF di base. Se desideri creare un chatbot complesso, sono necessari anche alcuni passaggi aggiuntivi. Ad esempio, aggiungere memoria, inclusi routing, ecc. Ora creiamo alcune funzioni per ogni passaggio in modo da non dover ripetere il codice più volte per i test. Prima, importiamo i pacchetti necessari:

# Importiamo i pacchetti necessaridalla langchain.embeddings import HuggingFaceEmbeddingsdallangchain.document_loaders import PyMuPDFLoaderdalla langchain.text_splitter import RecursiveCharacterTextSplitterdalla langchain.vectorstores import FAISSdalla langchain.chains import RetrievalQAimport textwrap

Dopo di ciò, creiamo la nostra prima funzione che caricherà il file PDF. Qui leggerai il file PDF utilizzando PyMuPDFLoader da Langchain.

# Questo caricherà il file PDFdef load_pdf_data(file_path):    # Creo un oggetto PyMuPDFLoader con file_path    loader = PyMuPDFLoader(file_path=file_path)        # Carico il file PDF    docs = loader.load()        # Restituisco il documento caricato    return docs

Dopodiché dobbiamo suddividere i documenti in più parti. Qui useremo RecursiveCharacterTextSplitter da Langchain, che è il più popolare per la suddivisione dei testi.

# Responsabile della suddivisione dei documenti in più partidef split_docs(documenti, chunk_size=1000, chunk_overlap=20):        # Inizializzo RecursiveCharacterTextSplitter con    # chunk_size e chunk_overlap    text_splitter = RecursiveCharacterTextSplitter(        chunk_size=chunk_size,        chunk_overlap=chunk_overlap    )        # Suddivido i documenti in chunk    chunks = text_splitter.split_documents(documents=documenti)        # Restituisco i chunk del documento    return chunks

Ora è il momento dell’embedding. Per fare ciò, dobbiamo prima caricare il modello di embedding utilizzando HuggingFaceEmbedding da Langchain, quindi utilizziamo FAISS per creare il vettore store. Il modello utilizzato per l’embedding è all-MiniLM-L6-v2, che vedrete più avanti.

# funzione per caricare il modello di embeddingdef load_embedding_model(model_path, normalize_embedding=True):    return HuggingFaceEmbeddings(        model_name=model_path,        model_kwargs={'device':'cpu'}, # qui eseguiremo il modello solo con CPU        encode_kwargs = {            'normalize_embeddings': normalize_embedding # mantenere True per calcolare la similarità coseno        }    )# Funzione per creare gli embedding utilizzando FAISSdef create_embeddings(chunks, embedding_model, storing_path="vectorstore"):    # Creazione degli embedding utilizzando FAISS    vectorstore = FAISS.from_documents(chunks, embedding_model)        # Salvataggio del modello nella directory corrente    vectorstore.save_local(storing_path)        # restituzione del vectorstore    return vectorstore

Creiamo ora un modello di prompt personalizzato in modo che il chatbot funzioni come previsto. Il prompt predefinito per il modello orca-mini è riportato di seguito.

prompt = """###System: Sei un assistente AI che segue istruzioni estremamente bene. Aiuta il più possibile.###Utente:{prompt}###Risposta:"""

Quindi, mantenendo il formato del prompt in questo modo, otteniamo migliori risposte. Ecco il modello di prompt modificato:

template = """###System: Sei un assistente rispettoso e onesto. Devi rispondere alle domande dell'utente utilizzando solo il contesto fornito. Se non conosci la risposta, semplicemente dì di non saperlo. Non cercare di inventare una risposta.###Contesto:{context}###Utente:{question}###Risposta:"""

Creiamo ora una catena di domande e risposte. Qui useremo RetrievalQA da Langchain. RetrievalQA non ha una memoria del chatbot, ovvero risponde solo alle domande ma non memorizza le conversazioni precedenti.

# Creazione della catena per le domande e rispostedef load_qa_chain(retriever, llm, prompt):    return RetrievalQA.from_chain_type(        llm=llm,        retriever=retriever, # qui stiamo usando il vectorstore come retriever        chain_type="stuff",        return_source_documents=True, # inclusione dei documenti di origine nella risposta        chain_type_kwargs={'prompt': prompt} # personalizzazione del prompt    )

Creeremo anche una funzione che formattare in modo più ordinato la risposta. Ecco il codice:

# Formattazione della risposta in modo più ordinatodef get_response(query, chain):    # Ottenimento della risposta dalla catena    response = chain({'query': query})        # Avvolgimento del testo per una migliore visualizzazione nel Jupyter Notebook    wrapped_text = textwrap.fill(response['result'], width=100)    print(wrapped_text)

Ora che abbiamo creato tutte le funzioni necessarie, è il momento di creare il chatbot.

Creazione di Jupyter Notebook

Prima, creare un Jupyter Notebook nella tua directory. Per fare ciò, creare un nuovo file con l’estensione .ipynb. Inoltre, non dimenticare di installare jupyter da pip. Altrimenti, il notebook non verrà eseguito. Esegui semplicemente il seguente comando per installare jupyter.

>>> pip install jupyter

Se VS Code non rileva il kernel per Jupyter Notebook, vedrai un’opzione Seleziona kernel nella parte superiore destra. Verranno visualizzate alcune opzioni di seguito.

Seleziona Environments Python. Ti darà nuovamente alcune opzioni.

Seleziona l’ambiente Starred. Dopo di ciò, sei pronto per utilizzare Jupyter Notebook.

Importazione delle librerie necessarie

Ora, andremo ad importare le librerie necessarie. Qui importeremo tre librerie:

Lo script Python in cui scriviamo tutte le funzioni. Ho dato il nome del file lang_funcs.py
Ollama da langchain.llms
PromptTemplate da langchain.

Importiamo queste librerie:

from lang_funcs import *from langchain.llms import Ollamafrom langchain import PromptTemplate

Caricamento modelli

Ora dobbiamo caricare il modello orca-mini e il modello di embedding chiamato all-MiniLM-L6-v2. Questo modello di embedding è piccolo ma efficace.

# Caricamento orca-mini da Ollamallm = Ollama(model="orca-mini", temperature=0)# Caricamento del modello di embeddingembed = load_embedding_model(model_path="all-MiniLM-L6-v2")

I modelli Ollama sono ospitati localmente sulla porta 11434. Non è necessario specificarlo poiché è già specificato nella classe Ollama() di langchain. Se il modello di embedding non è scaricato sul tuo computer, lo farà automaticamente da Huggingface. Basta aspettare un po’ e sei pronto.

Caricamento dei dati e creazione del Vectorstore

È ora di caricare i dati e creare l’embedding. Qui useremo un libro in formato PDF su ML.

# Caricamento e suddivisione dei documentidocs = load_pdf_data(file_path="data/ml_book.pdf")documents = split_docs(documents=docs)# Creazione del Vectorstorevectorstore = create_embeddings(documents, embed)# Conversione del Vectorstore in retrieverretriever = vectorstore.as_retriever()

Ci vorrà del tempo per creare gli embeddings. Quindi, abbi pazienza. La programmazione è tutta questione di pazienza, vero?

Ci sei quasi!

So che hai fatto molti progressi. Ora dobbiamo creare la catena e iniziare a testare il nostro chatbot. Quindi, facciamolo.

# Creazione della prompt dalla template che abbiamo creato primaprompt = PromptTemplate.from_template(template)# Creazione della chainchain = load_qa_chain(retriever, llm, prompt)

Ora siamo pronti per testare il nostro chatbot.

Test del chatbot

Ora poniamo alcune domande al nostro chatbot. Ecco alcuni esempi:

>>>get_response("Cos'è una random forest?", chain)>>> La Random Forest è una tecnica di apprendimento di insieme che utilizza alberi decisionali come classificatori di base per creare un nuovo classificatore. È un tipo di metodo di apprendimento di insieme che combina più alberi decisionali per migliorare l'accuratezza e ridurre l'overfitting del modello finale. L'algoritmo Random Forest introduce una casualità extra durante la crescita degli alberi, invece di cercare la caratteristica migliore quando si effettua una divisione di un nodo (come fanno gli Alberi Decisionali regolari). Ciò comporta una maggiore diversità degli alberi, che scambia un maggiore bias per una minore varianza. È anche più efficiente in termini computazionali rispetto ad altri metodi di apprendimento di insieme come Bagging e Boosting.>>>get_response("Cos'è un classificatore di voto?", chain)>>> Un classificatore di voto è un tipo di algoritmo di apprendimento automatico che prevede la classe di un determinato punto dati di input sulla base della maggioranza dei voti di più classificatori. In altre parole, prende le previsioni di diversi classificatori diversi e prevede la classe che ottiene il maggior numero di voti. Questo approccio può essere utilizzato per migliorare l'accuratezza dei modelli di apprendimento automatico utilizzando la diversità delle previsioni di diversi classificatori. Il classificatore di voto rigido è un tipo di classificatore di voto che prevede la classe con la maggioranza dei voti.>>>get_response("Qual è la differenza tra un classificatore di voto e una random forest?", chain)>>> I classificatori di voto e le Random Forest sono due approcci diversi per creare un insieme di classificatori. I classificatori di voto utilizzano il voto di maggioranza per prevedere la classe che riceve il maggior numero di voti dai classificatori nell'insieme. Questo approccio si basa sull'idea che l'opinione della maggioranza è probabilmente corretta e che aggregando le previsioni di più classificatori possiamo migliorare la nostra accuratezza. Il classificatore di voto rigido è una semplice implementazione di questo approccio. D'altra parte, le Random Forest sono un metodo di apprendimento di insieme che utilizza alberi decisionali come classificatori di base. Sono addestrate tramite il metodo del bagging, in cui ciascun albero viene creato da un sottoinsieme casualmente selezionato dei dati di addestramento. Il classificatore Random Forest è più comodo e ottimizzato per gli Alberi Decisionali rispetto ai classificatori di voto ed in generale porta a un modello migliore complessivamente.

Offre davvero ottime risposte. Puoi fare altre domande per vedere come risponde.

Conclusioni

Spero che ora tu abbia una chiara comprensione su come creare un Chatbot PDF utilizzando Langchain e Ollama. Ollama è un novellino in questo settore e rende davvero la nostra vita più facile. Hai già visto come abbiamo inizializzato il modello orca-mini con una sola riga di codice. Altrimenti, avresti dovuto utilizzare HuggingfacePipeline da Langchain.

Punti Chiave

Ollama semplifica il deployment dei modelli: Ollama semplifica il deployment dei modelli open-source fornendo un modo facile per scaricarli ed eseguirli sul tuo computer locale.
Sviluppo di un PDF Chatbot: Impara i passaggi coinvolti nella creazione di un chatbot PDF, inclusi il caricamento dei documenti PDF, la suddivisione in parti e la creazione di una catena di chatbot.
Personalizzazione per ottenere risposte migliori: Capisci come personalizzare le prompt e i modelli per migliorare le risposte del tuo chatbot.

Troverai qui tutti i codici utilizzati in questo articolo.

Domande Frequenti

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

blogathon,chatbot,go,langchain,Ollama,PDF Chatbot,time