Introduction à Embedchain – Une plateforme de données adaptée aux LLM

Introduction

L’introduction d’outils tels que LangChain et LangFlow a rendu les choses plus faciles lors de la création d’applications avec de grands modèles de langage. Bien que la création d’applications et le choix de différents modèles de langage étendus soient devenus plus faciles, la partie téléchargement de données, où les données proviennent de diverses sources, prend toujours du temps pour les développeurs lors du développement d’applications basées sur LLM, car les développeurs doivent convertir les données de ces différentes sources en texte brut avant de les injecter dans les magasins de vecteurs. C’est là qu’intervient Embedchain, qui simplifie le téléchargement de données de n’importe quel type de données et commence à interroger le LLM instantanément. Dans cet article, nous explorerons comment démarrer avec embedchain.

Objectifs d’apprentissage

• Comprendre l’importance de l’embedchain pour simplifier le processus de gestion et d’interrogation des données pour les grands modèles linguistiques (LLM)
• Apprenez à intégrer et télécharger efficacement des données non structurées dans embedchain, permettant aux développeurs de travailler de manière transparente avec diverses sources de données.
• Connaître les différents grands modèles de langage et magasins de vecteurs pris en charge par embedchain
• Découvrez comment ajouter diverses sources de données, telles que des pages Web et des vidéos au magasin de vecteurs, comprenant ainsi l’ingestion de données.

Cet article a été publié dans le cadre du Blogathon sur la science des données.

Qu’est-ce qu’Embedchain ?

Embedchain est une bibliothèque Python/Javascript, avec laquelle un développeur peut connecter de manière transparente plusieurs sources de données avec des grands modèles de langage. Embedchain nous permet de télécharger, d’indexer et de récupérer des données non structurées. Les données non structurées peuvent être de n’importe quel type comme un texte, une URL vers un site Web/une vidéo YouTube, une image, etc.

Emdechain simplifie le téléchargement de ces données non structurées avec une seule commande, créant ainsi des intégrations vectorielles pour elles et commençant instantanément l’interrogation des données avec le LLM connecté. En coulisses, embedchain s’occupe de charger les données à partir de la source, de les regrouper, puis de créer des intégrations vectorielles pour celles-ci, et enfin de les stocker dans un magasin de vecteurs.

Création de la première application avec Embedchain

Dans cette section, nous allons installer le package embedchain et créer une application avec celui-ci. La première étape consisterait à utiliser la commande pip pour installer le package comme indiqué ci-dessous :

!pip install embedchain

!pip install embedchain[huggingface-hub]

• La première instruction installera le package Python embedchain
• La ligne suivante installera le hub huggingface, ce package Python est requis si nous voulons utiliser les modèles fournis par le hubgingface.

Nous allons maintenant créer une variable d’environnement pour stocker le jeton API Hugging Face Inference comme ci-dessous. Nous pouvons obtenir le jeton API d’inférence en nous connectant au site Web Hugging Face, puis en générant un jeton.

import os

os.environ["HUGGINGFACE_ACCESS_TOKEN"] = "Hugging Face Inferenece API Token"

La bibliothèque embedchain utilisera le jeton fourni ci-dessus pour déduire les modèles de visages câlins. Ensuite, nous devons créer un fichier YAML définissant le modèle que nous voulons utiliser depuis Huggingface. Un fichier YAML peut être considéré comme un simple magasin clé-valeur dans lequel nous définissons les configurations de nos applications LLM. Ces configurations peuvent inclure le modèle LLM que nous allons utiliser ou le modèle d’intégration que nous allons utiliser (pour en savoir plus sur le fichier YAML, veuillez cliquer sur ici). Vous trouverez ci-dessous un exemple de fichier YAML

config = """
llm:
  provider: huggingface
  config:
    model: 'google/flan-t5-xxl'
    temperature: 0.7
    max_tokens: 1000
    top_p: 0.8


embedder:
  provider: huggingface
  config:
    model: 'sentence-transformers/all-mpnet-base-v2'
"""


with open('huggingface_model.yaml', 'w') as file:
    file.write(config)

• Nous créons un fichier YAML à partir de Python lui-même et le stockons dans le fichier nommé huggingface_model.yaml.
• Dans ce fichier YAML, nous définissons les paramètres de notre modèle et même le modèle d’intégration utilisé.
• Dans ce qui précède, nous avons spécifié le fournisseur comme huggingface et flan-t5 modèle avec différentes configurations/paramètres qui incluent le température du modèle, le max_tokens(c’est-à-dire la longueur de sortie), et même le top_p valeur.
• Pour le modèle d’intégration, nous utilisons un modèle d’intégration populaire de Huggingface appelé tout-mpnet-base-v2qui sera chargé de créer des vecteurs d’intégration pour notre modèle.

Configuration YAML

Ensuite, nous allons créer une application avec le fichier de configuration YAML ci-dessus.

from embedchain import Pipeline as App

app = App.from_config(yaml_path="huggingface_model.yaml")

• Ici, nous importons l’objet Pipeline en tant qu’application à partir de la chaîne d’intégration. L’objet Pipeline est chargé de créer des applications LLM prenant en charge différentes configurations telles que nous l’avons défini ci-dessus.
• L’application créera un LLM avec les modèles spécifiés dans le fichier YAML. Pour ça applicationnous pouvons introduire des données provenant de différentes sources de données, et vers la même application, nous pouvons appeler la méthode de requête pour interroger le LLM sur les données fournies.
• Maintenant, ajoutons quelques données.

app.add("https://en.wikipedia.org/wiki/Alphabet_Inc.")

• Le app.add() La méthode prendra les données et les ajoutera au magasin de vecteurs.
• Embedchain s’occupe de collecter les données de la page Web, de les créer en morceaux, puis de créer les intégrations pour les données.
• Les données seront ensuite stockées dans une base de données vectorielles. La base de données par défaut utilisée dans embedchain est chromadb.
• Dans cet exemple, nous ajoutons à l’application la page Wikipédia d’Alphabet, la société mère de Google.

Interrogons notre application en fonction des données téléchargées :

Dans l’image ci-dessus, en utilisant le requête() méthode, nous avons demandé à notre Application c’est-à-dire le modèle flan-t5, deux questions liées aux données qui ont été ajoutées au Application. Le modèle a pu y répondre correctement. De cette façon, nous pouvons ajouter plusieurs sources de données au modèle en les transmettant au ajouter() méthode et en interne, ils seront traités et les intégrations seront créées pour eux, et finalement seront ajoutées au magasin de vecteurs. Ensuite, nous pouvons interroger les données avec le requête() méthode.

Configuration de l’application avec un modèle et un magasin de vecteurs différents

Dans l’exemple précédent, nous avons vu comment préparer une application qui ajoute un site Web comme données et le modèle Hugging Face comme modèle de grand langage sous-jacent pour l’application. Dans cette section, nous verrons comment utiliser d’autres modèles et d’autres bases de données vectorielles pour voir à quel point l’embedchain peut être flexible. Pour cet exemple, nous utiliserons Zilliz Cloud comme base de données vectorielles, nous devons donc télécharger le client Python correspondant comme indiqué ci-dessous :

!pip install --upgrade embedchain[milvus]

!pip install pytube

• Ce qui précède téléchargera le package Pymilvus Python avec lequel nous pourrons interagir avec Zilliz Cloud.
• La bibliothèque pytube nous permettra de convertir des vidéos YouTube en texte afin qu’elles puissent être stockées dans le Vector Store.
• Ensuite, nous pouvons créer un compte gratuit avec le Zilliz Cloud. Après avoir créé le compte gratuit, accédez au tableau de bord Zilliz Cloud et créez un cluster.

Après avoir créé le cluster, nous pouvons obtenir les informations d’identification pour nous y connecter comme indiqué ci-dessous :

Clé API OpenAI

Copiez le point de terminaison public et le jeton et stockez-les ailleurs, car ils seront nécessaires pour se connecter au Zilliz Cloud Vector Store. Et maintenant, pour le Large Language Model, nous utiliserons cette fois le modèle OpenAI GPT. Nous aurons donc également besoin de la clé API OpenAI pour avancer. Après avoir obtenu toutes les clés, créez les variables d’environnement comme indiqué ci-dessous :

os.environ["OPENAI_API_KEY"]="Your OpenAI API Key"

os.environ["ZILLIZ_CLOUD_TOKEN"]= "Your Zilliz Cloud Token"

os.environ["ZILLIZ_CLOUD_URI"]= "Your Zilliz Cloud Public Endpoint"

Ce qui précède stockera toutes les informations d’identification requises pour Zilliz Cloud et OpenAI en tant que variables d’environnement. Il est maintenant temps de définir notre application, ce qui peut se faire comme suit :

from embedchain.vectordb.zilliz import ZillizVectorDB

app = App(db=ZillizVectorDB())

app.add("https://www.youtube.com/watch?v=ZnEgvGPMRXA")

• Ici, nous importons d’abord le ZillizVectorDB classe fournie par l’embedchain.
• Ensuite lors de la création de notre nouvelle application, nous passerons le ZillizVectorDB() au base de données variable à l’intérieur de la fonction App().
• Comme nous n’avons spécifié aucun LLM, le LLM par défaut est choisi comme OpenAI GPT 3.5.
• Désormais, notre application est définie avec OpenAI comme LLM et Zilliz comme Vector Store.
• Ensuite, nous ajoutons une vidéo YouTube à notre application en utilisant le ajouter() méthode.
• Ajouter une vidéo YouTube est aussi simple que de transmettre l’URL à ajouter() fonction, toute la conversion vidéo en texte est abstraite par la chaîne d’intégration, ce qui la rend simple.

Nuage de Zilliz

Désormais, la vidéo est d’abord convertie en texte, puis elle sera créée en morceaux et sera convertie en intégrations vectorielles par le modèle d’intégration OpenAI. Ces intégrations seront ensuite stockées dans le Zilliz Cloud. Si nous allons sur le Zilliz Cloud et vérifions à l’intérieur de notre cluster, nous pouvons trouver une nouvelle collection nommée « intégrer_chain_store», où sont stockées toutes les données que nous ajoutons à notre application :

Comme on peut le constater, une nouvelle collection a été créée sous le nom «intégrer_chain_store » et cette collection contient les données que nous avons ajoutées à l’étape précédente. Nous allons maintenant interroger notre application.

La vidéo ajoutée à l’application concerne la nouvelle mise à jour de Windows 11. Dans l’image ci-dessus, nous posons à l’application une question mentionnée dans la vidéo. Et l’application répond correctement à la question. Dans ces deux exemples, nous avons vu comment utiliser différents grands modèles linguistiques et différentes bases de données avec embedchain et avons également téléchargé des données de différents types, c’est-à-dire une page Web et une vidéo YouTube.

LLM et magasins de vecteurs pris en charge par Embedchain

Embedchain s’est beaucoup développé depuis sa sortie en prenant en charge une grande variété de grands modèles de langage et de bases de données vectorielles. Les grands modèles linguistiques pris en charge sont visibles ci-dessous :

• Modèles de visage câlins
• OpenAI
• Azure OpenAI
• Anthropique
• Lama2
• Adhérer
• JinaChat
• Sommet AI
• GPT4Tous

En plus de prendre en charge une large gamme de modèles de langage étendus, l’embedchain prend également en charge de nombreuses bases de données vectorielles visibles dans la liste ci-dessous :

• ChromaDB
• Recherche élastique
• Recherche ouverte
• Zilliz
• Pomme de pin
• Tisser
• Qdrant
• LanceDB

En dehors de cela, l’embedchain ajoutera à l’avenir la prise en charge de davantage de grands modèles de langage et de bases de données vectorielles.

Conclusion

Lors de la création d’applications avec de grands modèles de langage, le principal défi concernera le traitement des données, c’est-à-dire le traitement des données provenant de différentes sources de données. Toutes les sources de données doivent finalement être converties en un seul type avant d’être converties en intégrations. Et chaque source de données a sa propre façon de la gérer : il existe des bibliothèques distinctes pour gérer les vidéos, d’autres pour gérer les sites Web, etc. Nous avons donc examiné une solution à ce défi avec le package Python Embedchain, qui fait tout le gros du travail pour nous, nous permettant ainsi d’intégrer des données provenant de n’importe quelle source de données sans nous soucier de la conversion sous-jacente.

Points clés à retenir

Certains des principaux points à retenir de cet article incluent :

• Embedchain prend en charge un large éventail de modèles de langage étendus, nous permettant ainsi de travailler avec n’importe lequel d’entre eux.
• En outre, Embedchain s’intègre à de nombreux Vector Stores populaires.
• Un simple ajouter() La méthode peut être utilisée pour stocker des données de tout type dans le magasin de vecteurs.
• Embedchain facilite le basculement entre les LLM et les bases de données vectorielles et fournit des méthodes simples pour ajouter et interroger les données.

Questions fréquemment posées

Les références

Pour en savoir plus sur l’embedchain et son architecture, veuillez vous référer à leur page de documentation officielle et au référentiel Github.

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

Les médias présentés dans cet article n’appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l’auteur.

En rapport