Creazione di un Chatbot con FalconAI, LangChain e Chainlit

'Creating a Chatbot with FalconAI, LangChain, and Chainlit.

Introduzione

L’IA generativa, in particolare i modelli di linguaggio generativi di grandi dimensioni, hanno conquistato il mondo fin dalla loro nascita. Ciò è stato possibile solo perché hanno potuto integrarsi con diverse applicazioni, dalla generazione di codici programmabili funzionanti alla creazione di sistemi di supporto chat completamente gestiti da GenerativeAI. Ma la maggior parte dei modelli di linguaggio di grandi dimensioni nello spazio dell’IA generativa sono stati chiusi al pubblico; la maggior parte non era open source. Sebbene esistano alcuni modelli open source, non sono nemmeno lontanamente paragonabili ai modelli di linguaggio di grandi dimensioni con codice chiuso. Ma di recente è stato rilasciato FalconAI, un LLM, che ha superato la classifica di OpenLLM ed è stato reso open source. Con questo modello in questa guida, creeremo un’applicazione di chat con Falcon AI, LangChain e Chainlit.

Obiettivi di apprendimento

• Sfruttare il modello Falcon nelle applicazioni di IA generativa
• Creare un’interfaccia utente per i modelli di linguaggio di grandi dimensioni con Chainlit
• Lavorare con l’API di inferenza per accedere a modelli pre-addestrati in Hugging Face
• Concatenare modelli di linguaggio di grandi dimensioni e modelli di prompt con LangChain
• Integrare le catene LangChain con Chainlit per la creazione di applicazioni di interfaccia utente

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

Cos’è Falcon AI?

Nel campo dell’IA generativa, Falcon AI è uno dei modelli di linguaggio di grandi dimensioni recentemente introdotti noto per aver conquistato il primo posto nella classifica di OpenLLM. Falcon AI è stato introdotto dal Technology Innovation Institute (TII) degli Emirati Arabi Uniti. L’architettura di Falcon AI è progettata in modo ottimizzato per l’inferenza. Quando è stato introdotto per la prima volta, Falcon AI ha superato la classifica di OpenLLM superando modelli all’avanguardia come Llama, Anthropic, DeepMind, ecc. Il modello è stato addestrato su AWS Cloud con 384 GPU collegate in modo continuativo per due mesi.

Attualmente, è composto da due modelli, Falcon 40B (40 miliardi di parametri) e Falcon 7B (7 miliardi di parametri). La parte principale è che i creatori di Falcon AI hanno dichiarato che il modello sarà open source, consentendo così agli sviluppatori di lavorare con esso per scopi commerciali senza restrizioni. Falcon AI fornisce anche i modelli Instruct, il Falcon-7B-Instruct e il Falcon-40B-Instruct, con i quali possiamo iniziare rapidamente a costruire applicazioni di chat. In questa guida, lavoreremo con il modello Falcon-7B-Instruct.

• Questo articolo sull’IA da Stanford e Google introduce agenti generativi agenti computazionali interattivi che simulano il comportamento umano
• Incontra SegGPT un modello generalista che esegue compiti di segmentazione arbitraria in immagini o video tramite inferenza in contesto
• Identificabile, ma non visibile uno schema di ri-identificazione di persone che preserva la privacy (Riepilogo del paper)

Cos’è Chainlit?

La libreria Chainlit è simile alla libreria Streamlit di Python. Ma lo scopo previsto di questa libreria Chainlit è quello di costruire rapidamente applicazioni di chat con modelli di linguaggio di grandi dimensioni, cioè creare un’interfaccia utente simile a ChatGPT. È possibile sviluppare applicazioni di chat conversazionali in pochi minuti con il pacchetto Chainlit. Questa libreria è integrata in modo trasparente con LangFlow e LangChain (la libreria per la creazione di applicazioni con modelli di linguaggio di grandi dimensioni), che faremo più avanti in questa guida.

Chainlit consente anche la visualizzazione del ragionamento a più passaggi; ci consente di vedere i risultati intermedi per capire come il modello di linguaggio di grandi dimensioni ha raggiunto l’output di una domanda. In questo modo è possibile vedere chiaramente la catena di pensieri del modello attraverso l’interfaccia utente stessa per capire come il LLM ha concluso la domanda data. Chainlit è limitato a una conversazione testuale e consente di inviare e ricevere immagini ai rispettivi modelli di intelligenza artificiale generativa. Consente anche di aggiornare il modello di prompt nell’interfaccia utente anziché tornare al codice e modificarlo.

Generazione dell’API di inferenza di HuggingFace

Ci sono due modi per lavorare con il modello Falcon-7B-Instruct. Uno è il modo tradizionale, in cui scarichiamo il modello sul computer locale e lo usiamo direttamente. Ma poiché si tratta di un modello di linguaggio di grandi dimensioni, avrà bisogno di una grande quantità di memoria GPU per funzionare. Pertanto, scegliamo l’altro opzione, chiamando direttamente il modello tramite l’API di inferenza. L’API di inferenza è un token API di HuggingFace con cui possiamo accedere a tutti i modelli trasformatore in HuggingFace.

Per accedere a questo token, è necessario creare un account su HuggingFace, che è possibile fare visitando il sito web ufficiale di HuggingFace. Dopo aver effettuato l’accesso/registrazione con i propri dati, andare al proprio profilo e fare clic sulla sezione Impostazioni. Da lì, il processo sarà

Quindi nelle impostazioni, vai su Access Tokens. Creerai un nuovo token, con cui dovremo lavorare con il modello Falcon-7B-Instruct. Fai clic su Nuovo Token per creare il nuovo token. Inserisci un nome per il token e imposta l’opzione Ruolo su Scrivi. Ora fai clic su Genera per generare il nostro nuovo Token. Con questo token, possiamo accedere al modello Falcon-7B-Instruct e creare applicazioni.

Preparazione dell’Ambiente

Prima di immergerci nella nostra applicazione, creeremo un ambiente ideale per far funzionare il codice. Per fare ciò, è necessario installare le librerie Python necessarie. Inizieremo installando le librerie che supportano il modello. Per fare ciò, eseguiremo un pip install delle seguenti librerie.

$ pip install huggingface_hub 
$ pip install transformers

Questi comandi installeranno le librerie HuggingFace Hub e Transformers. Queste librerie chiamano il modello Falcon-7B-Instruct, che risiede in HuggingFace. Successivamente, installeremo la libreria LangChain per Python.

$ pip install langchain

Questo installerà il pacchetto LangChain per Python, con cui creeremo la nostra applicazione di chat con il modello Falcon Large Language. Infine, senza l’interfaccia utente, l’applicazione conversazionale non è completa. Per questo, scaricheremo la libreria chainlit.

$ pip install chainlit

Questo installerà la libreria Chainlit per Python. Con l’aiuto di questa libreria, costruiremo l’interfaccia utente per la nostra applicazione di chat conversazionale. Dopo l’installazione di chainlit, è necessario testare il pacchetto. Per fare ciò, utilizzare il seguente comando nel terminale.

chainlit hello

Dopo aver inserito questo comando, verrà visualizzata una nuova finestra con l’indirizzo localhost e la PORTA 8000. L’interfaccia utente sarà quindi visibile. Ciò indica che la libreria chainlit è stata installata correttamente e pronta per lavorare con altre librerie in Python.

Creazione dell’Applicazione di Chat

In questa sezione, inizieremo a costruire la nostra applicazione. Abbiamo tutte le librerie necessarie per procedere con la creazione della nostra applicazione di chat conversazionale. La prima cosa che faremo sarà importare le librerie e memorizzare l’API di inferenza di HuggingFace in un oggetto ambientale.

import os
import chainlit as cl
from langchain import HuggingFaceHub, PromptTemplate, LLMChain

os.environ['API_KEY'] = 'Your API Key'

• Quindi iniziamo importando le librerie os, chainlit e langchain.
• Dalla libreria langchain, abbiamo importato HuggingFaceHub. Questo HuggingFaceHub ci permetterà di chiamare il modello Falcon-7B-Instruct tramite l’API di inferenza e ricevere le risposte generate dal modello.
• Il PromptTemplate è uno degli elementi di LangChain, necessario per la creazione di applicazioni basate sul Large Language Model. Definisce come il modello dovrebbe interpretare le domande dell’utente e in quale contesto dovrebbe rispondere.
• Infine, importiamo anche LLMChain da LangChain. LLMChain è il modulo che collega diversi componenti di LangChain insieme. Qui collegheremo il nostro Falcon-7B-Instruct Large Language Model con il PromptTemplate.
• Quindi memorizziamo la nostra API di inferenza di HuggingFace in una variabile di ambiente, ossia os.environ[‘API_KEY’]

Istruire il Modello Falcon

Ora inferiremo il modello Falcon Instruct tramite il modulo HuggingFaceHub. Per fare ciò, prima dobbiamo fornire il percorso del modello in Hugging Face. Il codice per questo sarà

model_id = 'tiiuae/falcon-7b-instruct'

falcon_llm = HuggingFaceHub(huggingfacehub_api_token=os.environ['API_KEY'],
                            repo_id=model_id,
                            model_kwargs={"temperature":0.8,"max_new_tokens":2000})

• Prima di tutto, dobbiamo fornire l’id del modello con cui lavoreremo. Per noi, sarà il modello Falcon-7B-Instruct. L’id di questo modello può essere trovato direttamente sul sito web di HuggingFace, che sarà ‘tiiuae/falcon-7b-instruct’.
• Ora chiamiamo il modulo HuggingFaceHub, in cui passiamo il token API, assegnato a una variabile di ambiente, e anche il repo_id, ossia l’id del modello con cui lavoreremo.
• Forniamo anche i parametri del modello, come la temperatura e il numero massimo di nuovi token. La temperatura indica quanto il modello dovrebbe essere creativo, dove 1 significa maggiore creatività e 0 indica nessuna creatività.

Ora abbiamo definito chiaramente con quale modello lavoreremo. E l’API di HuggingFace ci permetterà di connetterci a questo modello ed eseguire le nostre query per iniziare a costruire la nostra applicazione.

Template del Prompt

Dopo la selezione del modello, il passo successivo è definire il Template del Prompt. Il Template del Prompt dice come il modello dovrebbe comportarsi. Dice come il modello dovrebbe interpretare la domanda fornita dall’utente. Dice persino come il modello dovrebbe concludere per dare l’output alla query dell’utente. Il codice per definire il nostro Template del Prompt sarebbe

template = """

Sei un assistente AI che fornisce risposte utili alle query degli utenti.

{question}

"""
prompt = PromptTemplate(template=template, input_variables=['question'])

La variabile del template sopra definisce e imposta il contesto del Template del Prompt per il modello Falcon. Il contesto qui è semplice, l’AI deve fornire risposte utili alle query degli utenti, seguito dalla variabile di input {question}. Quindi questo template, insieme alle variabili definite al suo interno, viene dato alla funzione PromptTemplate, che viene quindi assegnata a una variabile. Questa variabile è ora il Template del Prompt, che verrà successivamente concatenato al modello.

Concatenare entrambi i modelli

Ora abbiamo sia il modello Falcon LLM che il Template del Prompt pronti. La parte finale sarà concatenare entrambi questi modelli insieme. Lavoreremo con l’oggetto LLMChain della libreria LangChain per questo. Il codice per questo sarà

falcon_chain = LLMChain(llm=falcon_llm,
                    prompt=prompt,
                    verbose=True)

Con l’aiuto di LLMChain, abbiamo concatenato il modello Falcon-7B-Instruct con il nostro Template del Prompt che abbiamo creato. Abbiamo persino impostato verbose = True, che è utile per sapere cosa succede quando viene eseguito il codice. Ora testiamo il modello dando una query ad esso

print(falcon_chain.run("Quali sono i colori dell'arcobaleno?"))

Qui abbiamo chiesto al modello quali sono i colori dell’arcobaleno. L’arcobaleno contiene i colori VIBGYOR (Viola, Indaco, Blu, Verde, Giallo, Arancione e Rosso). L’output generato dal modello Falcon 7B Instruct è perfetto per la domanda posta. Impostando l’opzione verbose ci permette di vedere il Prompt dopo la formattazione e ci dice dove inizia e finisce la concatenazione. Infine, siamo pronti per creare un’interfaccia utente per la nostra applicazione di chat conversazionale.

Chainlit – Interfaccia utente per modelli di linguaggio di grandi dimensioni

In questa sezione, lavoreremo con la libreria Chainlit per creare l’interfaccia utente per la nostra applicazione. Chainlit è una libreria Python che ci permette di creare interfacce di chat per modelli di linguaggio di grandi dimensioni in pochi minuti. È integrato con LangFlow e persino con LangChain, la libreria su cui abbiamo lavorato in precedenza. La creazione dell’interfaccia di chat con Chainlit è semplice. Dobbiamo scrivere il seguente codice:

@cl.langchain_factory(use_async=False)

def factory():

    prompt = PromptTemplate(template=template, input_variables=['question'])
    falcon_chain = LLMChain(llm=falcon_llm,
                            prompt=prompt,
                            verbose=True)

    return falcon_chain

Passaggi

• Prima di tutto, iniziamo con i decoratori di Chainlit per LangChain, il @cl.langchain_factory.
• Poi definiamo una funzione di fabbrica che contiene il codice di LangChain. Il codice qui di cui abbiamo bisogno è il Template del Prompt e il modulo LLMChain di LangChain, che costruisce e concatena il nostro Falcon LLM.
• Infine, la variabile di ritorno deve essere un’istanza di LangChain. Qui, restituiamo la catena finale creata, cioè l’istanza LLMChain, il falcon_chain.
• Il use_async = False dice al codice di non utilizzare l’implementazione asincrona per l’agente LangChain.

Eseguiamo il codice!

Ecco tutto. Ora quando eseguiamo il codice, verrà visualizzata un’interfaccia di chat. Ma come è possibile? La cosa è che Chainlit si occupa di tutto. Dietro le quinte, gestisce le connessioni webhook, è responsabile per la creazione di un’istanza separata di LangChain (Catena, Agente, ecc.) per ogni utente che visita il sito. Per eseguire la nostra applicazione, digitiamo quanto segue nel terminale.

$ chainlit run app.py -w

Il parametro -w indica il ricaricamento automatico ogni volta che apportiamo modifiche al codice dell’applicazione. Dopo aver inserito questo comando, si aprirà una nuova scheda con localhost:8000

Questa è la pagina di apertura, ovvero la schermata di benvenuto di Chainlit. Vediamo che Chainlit costruisce un’interfaccia di chat completa per noi con un solo decoratore. Proviamo a interagire con il modello Falcon attraverso questa UI

Vediamo che l’UI e il modello Falcon Instruct funzionano perfettamente. Il modello può fornire risposte rapide alle domande poste. Ha davvero cercato di spiegare la seconda domanda basandosi sul contesto dell’utente (spiegare a un bambino di 5 anni). Questo è l’inizio di ciò che possiamo ottenere con questi modelli di intelligenza artificiale generativa open source. Con poche o minime modifiche, possiamo creare applicazioni molto più orientate ai problemi e basate su scenari reali.

In quanto l’interfaccia di chat è un sito web, è completamente possibile ospitarlo su una qualsiasi delle piattaforme cloud. Possiamo contenere l’applicazione e provare a distribuirla in qualsiasi servizio basato su container in Google Cloud, AWS, Azure o altri servizi cloud. In questo modo, possiamo condividere le nostre applicazioni con il mondo esterno.

Conclusione

In questa guida passo-passo, abbiamo visto come costruire un’applicazione di chat semplice con il nuovo modello di linguaggio open source Falcon Large, LangChain e Chainlit. Abbiamo sfruttato questi tre pacchetti e li abbiamo interconnessi per creare una soluzione completa, dal codice all’applicazione funzionante. Abbiamo persino visto come ottenere la chiave API di inferenza di HuggingFace per accedere a migliaia di modelli pre-addestrati dalla libreria HuggingFace. Con l’aiuto di LangChain, abbiamo collegato l’LLM con modelli di prompt personalizzati. Infine, con Chainlit, abbiamo potuto creare un’interfaccia di applicazione di chat attorno al nostro modello Falcon di LangChain in pochi minuti.

Alcuni dei punti chiave da ricordare di questa guida includono:

• Falcon è un modello open source ed è uno dei potenti LLm, attualmente in cima alla classifica OpenLLM
• Con Chainlit è possibile creare un’interfaccia utente per LLM in pochi minuti
• L’API di inferenza ci consente di connetterci a molti modelli diversi presenti in HuggingFace
• LangChain aiuta a costruire modelli di prompt personalizzati per i grandi modelli di linguaggio
• L’integrazione senza soluzione di continuità di Chainlit con LangChain consente di creare applicazioni LLM più velocemente e senza errori

Domande frequenti

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