Comment générer des intégrations de texte

TABLE DES MATIÈRES

Bienvenue dans ce didacticiel détaillé sur la génération d'intégrations de texte à l'aide d'Eden AI !

Que vous soyez un débutant en traitement du langage naturel (NLP) ou un développeur expérimenté souhaitant intégrer des fonctionnalités de recherche et de recommandation basées sur l'IA à vos applications, ce guide vous aidera à comprendre comment obtenir et utiliser efficacement des intégrations de texte.

Le tutoriel est basé sur notre dernier Vidéo YouTube, où nous parcourons l'ensemble du processus.

Dans ce didacticiel, nous aborderons les sujets suivants :

Ce que sont les intégrations de texte et pourquoi elles sont essentielles
Comment utiliser l'API d'Eden AI pour générer des intégrations
Implémentation d'une API pour gérer l'intégration, la génération et le stockage
Utilisation de FAISS (Facebook AI Similarity Search) pour une recherche de similarité efficace
Exécution du service localement avec FastAPI

À la fin de ce guide, vous disposerez d'un système entièrement fonctionnel pour générer des intégrations de texte et effectuer des recherches de similarité. Pour une approche plus détaillée, étape par étape, n'oubliez pas de consulter notre didacticiel YouTube, où nous décomposons chaque étape de manière facile à suivre, ce qui rend le processus encore plus simple à mettre en œuvre !

‍

Compréhension Insertions de texte

Insertions de texte sont des représentations mathématiques de texte (tels que des mots, des phrases ou même des documents entiers) sous forme de vecteurs de grande dimension.

Ces vecteurs capturent la signification sémantique du texte. L'idée principale est que des éléments de texte similaires auront des intégrations proches les unes des autres dans cet espace de grande dimension.

Cette propriété rend les intégrations si utiles pour diverses tâches du traitement du langage naturel (NLP), notamment :

Recherche sémantique: recherchez du texte dont le sens est similaire plutôt que de vous fier à des correspondances exactes de mots clés.
Classification des textes: catégorisation du texte en classes prédéfinies en comparant leurs intégrations.
Systèmes de clustering et de recommandation: Regrouper des éléments similaires ou recommander de nouveaux contenus sur la base d'intégrations similaires.

Eden AI simplifie le processus en proposant une API qui se connecte à plusieurs fournisseurs d'IA tels qu'OpenAI, Cohere et d'autres, vous permettant de générer facilement des intégrations de texte pour vos propres cas d'utilisation.

‍

Configuration de l'environnement

Avant de commencer à travailler avec des intégrations de texte, vous devez configurer votre environnement de développement. Cette section décrit les étapes nécessaires à l'installation et à la configuration.

‍

Installer les dépendances

La première étape consiste à installer les bibliothèques Python nécessaires. Ces packages sont utilisés pour différentes parties du système, notamment la gestion de l'API, l'utilisation d'intégrations de texte et la recherche de similarité. Vous pouvez les installer à l'aide de la commande suivante :

pip install fastapi uvicorn pydantic requests python-dotenv faiss-cpu numpy pickle5

Voici ce que fait chaque package :

API rapide: Utilisé pour créer l'API Web permettant de générer des intégrations de texte et d'effectuer des recherches.
Demandes: gère les appels d'API à Eden AI pour générer des intégrations de texte.
FAISS: bibliothèque développée par Facebook pour une recherche de similarité efficace, spécialement conçue pour gérer les données vectorielles telles que les intégrations.
Doten c.: vous aide à gérer les variables d'environnement (telles que les clés d'API) en toute sécurité.
NumPy: Essentiel pour gérer des données numériques telles que les intégrations sous forme de tableaux.

Ces dépendances fourniront les outils nécessaires pour implémenter et exécuter votre service d'intégration de texte.

‍

Configuration des clés d'API

Pour interagir avec l'API d'Eden AI, vous avez besoin d'une clé API. Cette clé authentifie vos demandes adressées au service. Pour obtenir une clé API, inscrivez-vous sur Plateforme Eden AI et créez un compte.

Une fois que vous avez la clé API, créez un fichier .env dans le répertoire de votre projet et ajoutez votre clé comme suit :

EDEN_AI_API_KEY=your_api_key_here

En utilisant le fichier .env, vous pouvez sécuriser les informations sensibles telles que les clés API, en vous assurant qu'elles ne sont pas codées en dur dans votre code source.

‍

Implémentation de l'API avec FastAPI

Passons maintenant à la création de l'API. Nous utiliserons API rapide pour créer un serveur API capable de générer des intégrations de texte, de les stocker dans une base de données vectorielles (à l'aide du FAISS) et de permettre des recherches de similarité efficaces.

‍

Voici la structure principale de notre script Python :

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from typing import List, Dict, Any, Optional
import requests
import os
from dotenv import load_dotenv
import uuid
import numpy as np
import faiss
import pickle

Ces importations concernent les bibliothèques essentielles :

API rapide pour créer le serveur Web et définir l'API.
Pydantique pour la validation des données et la définition du modèle.
Demandes pour passer des appels d'API à Eden AI.
FAISS pour gérer la base de données vectorielles.
Doten c. pour charger la clé API depuis le fichier .env.
NumPy pour manipuler les tableaux numériques (intégrations).
Cornichon pour enregistrer et charger l'index FAISS sur le disque.

‍

Variables d'environnement de chargement

Avant de pouvoir utiliser la clé API, nous devons la charger à partir du fichier .env. Voici comment procéder :

load_dotenv()
EDEN_AI_API_KEY = os.getenv("EDEN_AI_API_KEY")
if not EDEN_AI_API_KEY:
    raise ValueError("EDEN_AI_API_KEY environment variable not set")

Ce code charge les variables d'environnement et vérifie si la clé API est présente. S'il est absent, le code génère une erreur, garantissant que la clé est disponible avant de continuer.

‍

Définition de l'application FastAPI

Ensuite, nous configurons l'application FastAPI et activons CORS (Cross-Origin Resource Sharing), qui permet d'accéder à l'API à partir de navigateurs Web hébergés sur différents domaines.

app = FastAPI(
    title="Embedding Search API", 
    description="API for text embeddings and similarity search"
)

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

CORS est important lors du développement d'API accessibles par des applications Web exécutées sur différents serveurs.

‍

Définir les modèles Pydantic

Les modèles Pydantic permettent de valider les données envoyées et reçues depuis l'API. Par exemple, nous définissons des modèles pour gérer les entrées et les sorties des demandes de génération et de recherche d'intégrations :

class TextItem(BaseModel):
    text: str
    metadata: Optional[Dict[str, Any]] = {}

class TextItems(BaseModel):
    items: List[TextItem]
    provider: str = "openai"  # Default provider
    model: Optional[str] = None  # Optional specific model

class SearchQuery(BaseModel):
    query: str
    provider: str = "openai"
    model: Optional[str] = None
    top_k: int = 5

Ces modèles garantissent que les données reçues par l'API sont correctement structurées :

Élément de texte représente un seul élément de texte et des métadonnées facultatives.
Eléments de texte est utilisé pour les demandes par lots, où plusieurs Élément de texte des instances sont fournies.
Requête de recherche est utilisé pour les demandes de recherche sémantique, permettant aux utilisateurs d'interroger le système pour obtenir un texte similaire.

‍

Travailler avec FAISS pour la recherche vectorielle

Le FAISS est utilisé pour stocker les intégrations et effectuer des recherches de similarité. Voici comment le configurer et l'utiliser pour les opérations de recherche.

Initialisez l'index FAISS

Nous initialisons un index FAISS, qui est essentiellement une structure de données qui nous permet de stocker et de rechercher efficacement dans les intégrations. Nous choisissons une dimensionnalité (1536 est une taille courante pour les intégrations OpenAI) et créons un index pour stocker ces vecteurs.

‍

class FAISSVectorDB:
    def __init__(self, dimension=1536, index_file="faiss_index.pkl"):
        self.dimension = dimension
        self.index_file = index_file
        self.index = faiss.IndexFlatL2(self.dimension)
        self.metadata = []
        self.load_or_create_index()

‍

Stockage des intégrations

Pour stocker les intégrations, nous les ajoutons à l'index FAISS et nous leur associons des métadonnées. Voici comment procéder :

def store_embedding(self, item_id: str, text: str, embedding: List[float], metadata: Dict[str, Any]) -> str:
    embedding_np = np.array(embedding, dtype=np.float32).reshape(1, -1)
    self.index.add(embedding_np)
    self.metadata.append({
        "id": item_id, 
        "text": text, 
        "metadata": metadata
    })
    self.save_index()
    return item_id

‍

Recherche d'intégrations similaires

Lorsqu'un utilisateur soumet une requête de recherche, nous générons son intégration et la comparons aux intégrations stockées dans FAISS. Nous récupérons les correspondances les plus proches à l'aide du code suivant :

def search(self, query_embedding: List[float], top_k: int = 5) -> List[Dict[str, Any]]:
    query_np = np.array(query_embedding, dtype=np.float32).reshape(1, -1)
    distances, indices = self.index.search(query_np, top_k)
    return [{"id": self.metadata[idx]["id"], "text": self.metadata[idx]["text"], "score": float(1.0 / (1.0 + distances[0][i]))} for i, idx in enumerate(indices[0]) if idx < len(self.metadata)]

‍

Points de terminaison de l'API

Définissons maintenant les points de terminaison de l'API qui permettront aux utilisateurs d'interagir avec le service.

Générer des intégrations

Ce terminal génère des intégrations pour les textes fournis et les stocke dans FAISS :

@app.post("/embeddings")
async def create_embeddings(items: TextItems):
    results = []
    for item in items.items:
        embedding = await get_embedding_for_single_text(item.text, items.provider, items.model)
        item_id = str(uuid.uuid4())
        db.store_embedding(item_id, item.text, embedding, item.metadata)
        results.append({
            "id": item_id, 
            "text": item.text, 
            "embedding": embedding
        })
    return results

‍

Rechercher des textes similaires

Ce point de terminaison effectue une recherche sémantique en fonction de l'intégration de la requête et renvoie les résultats les plus similaires :

@app.post("/search")
async def search(query: SearchQuery):
    query_embedding = await get_embedding_for_single_text(query.query, query.provider, query.model)
    results = db.search(query_embedding, query.top_k)
    return {"query": query.query, "results": results}

‍

Conclusion

Ce didacticiel vous a expliqué tout le processus de génération d'intégrations de texte avec Eden AI. À la fin, vous devriez être capable de :

Configurez votre environnement
Utilisez Eden AI pour générer des intégrations de texte
Stockez efficacement les intégrations avec FAISS
Effectuez des recherches sémantiques sur les intégrations stockées

Eden AI fournit une API facile à utiliser qui simplifie l'intégration de l'IA, vous permettant d'accéder à différents fournisseurs d'IA avec une seule clé. Si vous souhaitez en savoir plus ou explorer davantage, n'oubliez pas de consulter des didacticiels supplémentaires et de vous abonner à notre chaîne YouTube!

Créez votre compte sur Eden AI

Comment générer des intégrations de texte ?