Introduzione a Embedchain – una piattaforma dati su misura per LLMs

Introduzione

L’introduzione agli strumenti come LangChain e LangFlow ha reso le cose più facili nella creazione di applicazioni con Modelli Linguistici di Grandi Dimensioni. Anche se la creazione di applicazioni e la scelta di diversi Modelli Linguistici di Grandi Dimensioni è diventata più semplice, la parte di caricamento dei dati, in cui i dati provengono da varie fonti, è ancora un’attività che richiede tempo per gli sviluppatori mentre sviluppano applicazioni basate su LLM, poiché gli sviluppatori devono convertire i dati da queste varie fonti in testo semplice prima di inserirli nei vettori di archiviazione. Ecco dove entra in gioco Embedchain, che semplifica il caricamento dei dati di qualsiasi tipo e l’interrogazione immediata di LLM. In questo articolo, esploreremo come iniziare con embedchain.

Obiettivi di Apprendimento

  • Comprensione dell’importanza di embedchain nel semplificare il processo di gestione e interrogazione dei dati per Modelli Linguistici di Grandi Dimensioni (LLM)
  • Imparare come integrare ed elaborare in modo efficace dati non strutturati in embedchain, consentendo agli sviluppatori di lavorare con varie fonti di dati in modo fluido
  • Conoscere i diversi Modelli Linguistici di Grandi Dimensioni e Archiviazione Vettoriale supportati da embedchain
  • Scoprire come aggiungere varie fonti di dati, come pagine web e video, all’archivio vettoriale, comprendendo così l’ingestione dei dati

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

Cos’è Embedchain?

Embedchain è una libreria Python/Javascript con cui uno sviluppatore può connettere più fonti di dati con Modelli Linguistici di Grandi Dimensioni senza soluzione di continuità. Embedchain ci permette di caricare, indicizzare e recuperare dati non strutturati. I dati non strutturati possono essere di qualsiasi tipo, come testo, un URL per un sito web/video di YouTube, un’immagine, ecc.

Embedchain semplifica il caricamento di questi dati non strutturati con un singolo comando, creando così embedding vettoriali per essi e iniziando immediatamente l’interrogazione dei dati con il LLM collegato. Nel retroscena, embedchain si occupa del caricamento dei dati dalla fonte, della divisione in blocchi, della creazione di embedding vettoriali per essi e infine della loro archiviazione in un archivio vettoriale.

Creazione della Prima App con Embedchain

In questa sezione, installeremo il pacchetto embedchain e creeremo un’applicazione con esso. Il primo passo sarà utilizzare il comando pip per installare il pacchetto come mostrato di seguito:

!pip install embedchain!pip install embedchain[huggingface-hub]
  • La prima istruzione installerà il pacchetto embedchain di Python
  • La riga successiva installerà huggingface-hub, che è richiesto se vogliamo utilizzare modelli forniti da hugging-face

Ora creeremo una variabile di ambiente per memorizzare il token di accesso API di Hugging Face come mostrato di seguito. Possiamo ottenere il token di accesso all’API di Inferenza accedendo al sito web di Hugging Face e generando un token.

import osos.environ["HUGGINGFACE_ACCESS_TOKEN"] = "Token di Accesso all'API di Inferenza di Hugging Face"

La libreria embedchain utilizzerà il token fornito sopra per inferire i modelli di hugging face. Successivamente, dobbiamo creare un file YAML che definisca il modello che vogliamo utilizzare da huggingface. Un file YAML può essere considerato come un semplice store chiave-valore in cui definiamo le configurazioni per le nostre applicazioni LLM. Queste configurazioni possono includere quale modello LLM intendiamo utilizzare o quale modello di embedding intendiamo utilizzare (per saperne di più sul file YAML clicca qui). Di seguito è riportato un esempio di file YAML

config = """llm:  provider: huggingface  config:    model: 'google/flan-t5-xxl'    temperature: 0.7    max_tokens: 1000    top_p: 0.8embedder:  provider: huggingface  config:    model: 'sentence-transformers/all-mpnet-base-v2'"""with open('huggingface_model.yaml', 'w') as file:    file.write(config)
  • Stiamo creando un file YAML direttamente da Python e lo stiamo memorizzando nel file chiamato huggingface_model.yaml.
  • In questo file YAML, definiamo i parametri del nostro modello e persino il modello di embedding utilizzato.
  • Nel caso sopra, abbiamo specificato il provider come huggingface e il modello flan-t5 con diverse configurazioni/parametri che includono la temperatura del modello, il max_tokens (cioè la lunghezza in output) e persino il valore top_p.
  • Per il modello di embedding, stiamo utilizzando un modello di embedding popolare di huggingface chiamato all-mpnet-base-v2, che sarà responsabile della creazione di vettori di embedding per il nostro modello.

Configurazione YAML

Successivamente, creeremo un’applicazione con il file di configurazione YAML sopra.

from embedchain import Pipeline as App
app = App.from_config(yaml_path="huggingface_model.yaml")
  • Qui importiamo l’oggetto Pipeline come App da embedchain. L’oggetto Pipeline è responsabile per la creazione di app LLM, prendendo in input diverse configurazioni come abbiamo definito in precedenza.
  • L’app creerà un LLM con i modelli specificati nel file YAML. A questa app, possiamo fornire dati da diverse fonti di dati e alla stessa app possiamo chiamare il metodo di query per interrogare l’LLM sui dati forniti.
  • Ora, aggiungiamo alcuni dati.
app.add("https://en.wikipedia.org/wiki/Alphabet_Inc.")
  • Il metodo app.add() prenderà in input i dati e li aggiungerà al deposito di vettori.
  • Embedchain si occupa di raccogliere i dati dalla pagina web, crearli in pezzi e quindi creare gli embedding per i dati.
  • I dati saranno quindi memorizzati in un database vettoriale. Il database predefinito utilizzato in embedchain è chromadb.
  • In questo esempio, stiamo aggiungendo alla App la pagina Wikipedia di Alphabet, la casa madre di Google.

Interroghiamo la nostra App basandoci sui dati caricati:

Nell’immagine sopra, utilizzando il metodo query(), abbiamo posto due domande alla nostra App, cioè il modello flan-t5, relative ai dati che sono stati aggiunti all’App. Il modello è stato in grado di rispondere correttamente. In questo modo, possiamo aggiungere più fonti di dati al modello passandole al metodo add() e internamente verranno elaborate, verranno creati gli embedding per esse, e infine verranno aggiunte al deposito di vettori. Quindi possiamo interrogare i dati con il metodo query().

Configurazione dell’App con un Modello e un Vector Store Diversi

Nell’esempio precedente, abbiamo visto come preparare un’applicazione che aggiunge un sito web come dati e il modello Hugging Face come Large Language Model sottostante per l’App. In questa sezione, vedremo come possiamo utilizzare altri modelli e altri database vettoriali per vedere quanto flessibile può essere embedchain. Per questo esempio, useremo Zilliz Cloud come nostro Vector Database, quindi dobbiamo scaricare il rispettivo client Python come mostrato di seguito:

!pip install --upgrade embedchain[milvus]!pip install pytube
  • Quanto sopra scaricherà il pacchetto Python Pymilvus con il quale possiamo interagire con Zilliz Cloud.
  • La libreria pytube ci permetterà di convertire video YouTube in testo in modo che possano essere memorizzati nel Vector Store.
  • Successivamente, possiamo creare un account gratuito con Zilliz Cloud. Dopo aver creato l’account gratuito, vai alla Dashboard di Zilliz Cloud e crea un Cluster.

Dopo aver creato il Cluster, possiamo ottenere le credenziali per connetterci ad esso come mostrato di seguito:

Chiave API di OpenAI

Copia l’Endpoint Pubblico e il Token e memorizzali altrove, poiché saranno necessari per connettersi al Zilliz Cloud Vector Store. E ora per il Large Language Model, questa volta useremo il modello OpenAI GPT. Quindi avremo bisogno anche della chiave API di OpenAI per procedere. Dopo aver ottenuto tutte le chiavi, crea le variabili di ambiente come mostrato di seguito:

os.environ["OPENAI_API_KEY"]="La tua chiave API di OpenAI"os.environ["ZILLIZ_CLOUD_TOKEN"]= "Il tuo token Zilliz Cloud"os.environ["ZILLIZ_CLOUD_URI"]= "Il tuo Zilliz Cloud Public Endpoint"

Quanto sopra memorizzerà tutte le credenziali necessarie per Zilliz Cloud e OpenAI come variabili di ambiente. Ora è il momento di definire la nostra app, cosa che possiamo fare come segue:

from embedchain.vectordb.zilliz import ZillizVectorDBapp = App(db=ZillizVectorDB())app.add("https://www.youtube.com/watch?v=ZnEgvGPMRXA")
  • Qui importiamo prima la classe ZillizVectorDB fornita da embedchain.
  • In seguito, quando creiamo la nuova app, passeremo ZillizVectorDB() alla variabile db all’interno della funzione App().
  • Dato che non abbiamo specificato alcun LLM, viene scelto il LLM di default, ovvero OpenAI GPT 3.5.
  • Ora la nostra app è definita con OpenAI come LLM e Zilliz come archivio di vettori.
  • Successivamente, aggiungiamo un video di YouTube alla nostra app utilizzando il metodo add().
  • Aggiungere un video di YouTube è semplice come passare l’URL alla funzione add(), tutta la conversione da video a testo è astratta tramite embedchain, rendendola quindi semplice.

Zilliz Cloud

Ora, il video viene prima convertito in testo, quindi viene suddiviso in blocchi e viene convertito in vettori di embedding mediante il modello di embedding di OpenAI. Questi embedding vengono quindi archiviati nel cloud di Zilliz. Se andiamo al cloud di Zilliz e controlliamo all’interno del nostro cluster, possiamo trovare una nuova raccolta chiamata “embedchain_store”, in cui vengono archiviati tutti i dati che aggiungiamo alla nostra app:

Come possiamo vedere, è stata creata una nuova raccolta denominata “embedchain_store” e questa raccolta contiene i dati che abbiamo aggiunto nel passaggio precedente. Ora interrogheremo la nostra app.

Il video che è stato aggiunto all’app riguarda il nuovo aggiornamento di Windows 11. Nell’immagine sopra, poniamo all’app una domanda che è stata menzionata nel video. E l’app risponde correttamente alla domanda. In questi due esempi, abbiamo visto come utilizzare diversi Large Language Models e diversi database con embedchain e abbiamo anche caricato dati di diversi tipi, ovvero una pagina web e un video di YouTube.

LLM supportati e archivi di vettori da Embedchain

Embedchain è cresciuto molto da quando è stato rilasciato grazie al supporto di una vasta gamma di Large Language Models e Vector Databases. Di seguito sono riportati i Large Language Models supportati:

  • Modelli di Hugging Face
  • OpenAI
  • Azure OpenAI
  • Anthropic
  • Llama2
  • Cohere
  • JinaChat
  • Vertex AI
  • GPT4All

Oltre a supportare una vasta gamma di Large Language Models, embedchain fornisce anche supporto a molti database di vettori che possono essere visti nell’elenco sottostante:

  • ChromaDB
  • ElasticSearch
  • OpenSearch
  • Zilliz
  • Pinecone
  • Weaviate
  • Qdrant
  • LanceDB

Oltre a questi, embedchain in futuro aggiungerà supporto per ulteriori Large Language Models e Vector Databases.

Conclusioni

Nel costruire applicazioni con large language models, la sfida principale riguarda il trattamento dei dati provenienti da diverse fonti dati. Alla fine, tutte le fonti dati devono essere convertite in un unico tipo prima di essere trasformate in embedding. E ogni fonte ha il proprio modo di gestirla, ad esempio esistono librerie separate per gestire video, altre per gestire siti web e così via. Pertanto, abbiamo esaminato una soluzione a questa sfida con il pacchetto Python Embedchain, che svolge tutto il lavoro pesante per noi, consentendoci di integrare dati da qualsiasi fonte dati senza preoccuparci della conversione sottostante.

Conclusioni chiave

Alcune delle conclusioni chiave di questo articolo includono:

  • Embedchain supporta un ampio set di Large Language Models, permettendoci così di lavorare con ognuno di essi.
  • Inoltre, Embedchain si integra con molti popolari Vector Stores.
  • Un semplice metodo add() può essere utilizzato per archiviare dati di qualsiasi tipo nel Vector Store.
  • Embedchain rende più facile passare tra LLM e Vector DB e fornisce metodi semplici per aggiungere e interrogare i dati.

Domande frequenti

Riferimenti

Per saperne di più su embedchain e la sua architettura, si prega di consultare la loro pagina di documentazione ufficiale e il repository su Github.

  • https://docs.embedchain.ai
  • https://github.com/embedchain/embedchain

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