Créez votre propre API de moteur de recherche avec Flask et Eden AI Embeddings

À l'ère numérique d'aujourd'hui, les moteurs de recherche sont devenus un outil indispensable permettant aux individus d'accéder à des informations sur presque tous les sujets sans effort et rapidement.

‍

Cet article vise à fournir un guide étape par étape pour créer un moteur de recherche en Python à l'aide d'intégrations de texte. Les intégrations de mots encodent le texte dans un format numérique afin de mesurer la similitude entre deux éléments de texte.

En suivant ce didacticiel, vous serez en mesure de créer votre propre API de recherche à l'aide des intégrations d'Eden AI, puis de la déployer facilement sur Flask.

‍

Prérequis :

• Connaissances de base de Python
• Familiarité avec les API
• Compte Eden AI (clé API)

‍

Étape 1 Préparer le jeu de données

Préparez d'abord votre ensemble de données. Dans le cadre de ce didacticiel, nous utiliserons un ensemble de données de 40 fonctionnalités d'IA, où chaque fonctionnalité est décrite par une courte description textuelle. L'ensemble de données peut être dans n'importe quel format, mais pour des raisons de simplicité, nous utiliserons un fichier CSV. Voici un exemple de ce à quoi pourrait ressembler l'ensemble de données :

edenai_dataset = pd.read_csv('edenai_dataset.csv')

‍

Étape 2 Utilisez l'API Eden AI pour générer des intégrations.

Eden AI propose une vaste collection d'API, comprenant notamment des intégrations pré-entraînées. Pour ce didacticiel, nous utiliserons Open AI pour transformer les descriptions textuelles en représentations numériques. Ce tutoriel s'applique à d'autres fournisseurs, tels que Cohere (également disponible sur Eden AI). Toutefois, n'oubliez pas que lorsque vous représentez votre texte sous forme d'intégrations, vous ne devez utiliser qu'un seul fournisseur et ne pas fusionner des intégrations provenant de plusieurs fournisseurs.

# Load your dataset
edenai_dataset = pd.read_csv('edenai_dataset.csv')
# Apply embeddings to your dataset
subfeatures_description['description-embeddings'] = subfeatures_description.apply(lambda x: edenai_embeddings(x['Description'], “openai”), axis=1)

Dans le code ci-dessus, nous appliquons l'API d'intégration d'Eden AI à chaque ligne de la colonne « Description » de l'ensemble de données et enregistrons les intégrations qui en résultent dans une nouvelle colonne appelée « description-embeddings ».

‍

Voici le code permettant de générer des intégrations à l'aide de l'API Eden AI :

 def edenai_embeddings(text : str, provider: str):
 """
 This function sends a request to the Eden AI API to generate embeddings for a given text using a specified provider.
 """
 url = "https://api.edenai.run/v2/text/embeddings"
 headers = {
   "accept": "application/json",
   "content-type": "application/json",
   "authorization": "Bearer YOUR_API_KEY"
 }
 payload = {
     "response_as_dict": True,
     "attributes_as_list": False,
     "texts": [text],
     "providers": provider
 }

 response = requests.post(url, json=payload, headers=headers).json()
 try:
   return response[provider]['items'][0]['embedding']
 except:
   return None

REMARQUE : N'oubliez pas de la remplacer <YOUR API KEY>par votre clé d'API Eden AI actuelle.

‍

Étape 3 Créez votre API de recherche avec Flask

Maintenant que nous disposons des intégrations pour chaque description de notre ensemble de données, nous pouvons créer une API REST avec Flask qui permet aux utilisateurs de rechercher des entités dans l'ensemble de données en fonction de leur requête.

‍

Créez un environnement virtuel pour votre projet Flask

Tout d'abord, vous devez créer un environnement virtuel pour votre projet Flask et installer les dépendances requises. Pour ce faire, procédez comme suit :

1. Ouvrez votre interface de ligne de commande et accédez au répertoire dans lequel vous souhaitez créer votre projet Flask.

2. Créez un nouvel environnement virtuel à l'aide de la commande python3 -m venv <name of environment>. Remplacer <name of environment> avec le nom de votre choix, cela créera un nouvel environnement virtuel avec son propre interpréteur Python et ses packages installés, indépendamment de l'installation Python de votre système.

3. Activez l'environnement virtuel en exécutant la source de commande <name of environment>/bin/activer.

4. Installez les dépendances requises pour le projet en exécutant les commandes suivantes :

pip install flask
pip install pandas
pip install requests
pip install numpy
pip install flask-api

5. Importez l'ensemble de données dans votre projet et créez deux fichiers python search.py qui contiendra la logique de notre recherche et app.py pour l'API REST. Voici la structure de notre projet :

‍

6. Dans le fichier "search.py «, nous allons implémenter le processus d'appel de l'API d'intégration Eden AI (qui a été démontré précédemment), ainsi que le calcul de la similitude des cosinus.

def cosine_similarity(embedding1: list, embedding2: list):
   """
   Computes the cosine similarity between two vectors.
   """
   vect_product = np.dot(embedding1, embedding2)
   norm1 = np.linalg.norm(embedding1)
   norm2 = np.linalg.norm(embedding2)
   cosine_similarity = vect_product / (norm1 * norm2)
   return cosine_similarity

‍

7. Notre objectif est de convertir la requête de recherche de l'utilisateur en intégrations, puis de lire l'ensemble de données pour mesurer la similitude en cosinus entre les intégrations de requêtes et les intégrations de description des sous-fonctionnalités. Notre résultat sera une liste triée des sous-fonctionnalités en fonction de leurs scores de similarité, en commençant par les plus similaires :

def search_subfeature(description: str):
   """
   This function searches a dataset of subfeature descriptions and returns a list of the subfeatures
   with the highest cosine similarity to the input description.
   """
   # load the subfeatures dataset into a pandas dataframe
   subfeatures = pd.read_csv('subfeatures_dataset.csv')
  
   # generate an embedding for the input description using the OpenAI provider
   embed_description = edenai_embeddings(description, 'openai')
  
   results = []
   # iterate over each row in the subfeatures dataset
   for subfeature_index, subfeature_row in subfeatures.iterrows():
     similarity = cosine_similarity(
         ast.literal_eval(subfeature_row['Description Embeddings']),
         embed_description)
    
   # compute the cosine similarity between the query and all the rows in the corpus
     results.append({
         "score": similarity,
         "subfeature": subfeature_row['Name'],
         })
    
   results = sorted(results, key=lambda x: x['score'], reverse=True)
   return results[:5]

‍

8. Dans app.py, nous allons créer une instance de notre projet Flask et définir un point de terminaison pour la recherche de sous-fonctionnalités dans notre ensemble de données. Ce point de terminaison appellera la fonction search_subfeature (), qui prend une description (requête) en entrée.

from search import search_subfeature
from flask import Flask, request, jsonify
from flask_api import status


app = Flask(__name__)




@app.route('/search', methods=['GET'])
def search_engine():
   search_result = search_subfeature(request.args.get('description'))
   return jsonify(search_result), status.HTTP_200_OK


if __name__ == "__main__":
   app.run(debug=True)

‍

9. Enfin, démarrez l'application Flask en exécutant la commande flask --app app.py --exécuter le débogage.

Si tout fonctionne correctement, vous devriez voir un message dans votre interface de ligne de commande indiquant « Exécution sur http://127.0.0.1:5000/«.

Pour tester notre API de moteur de recherche, nous pouvons envoyer une requête GET au http://127.0.0.1:5000/search point de terminaison avec la requête comme charge utile. Pour ce faire, nous pouvons utiliser un outil comme Postman, qui nous permet d'envoyer facilement des requêtes HTTP et de visualiser les réponses.

Le résultat le plus pertinent pour la requête « Comment puis-je extraire des données d'un reçu ? » est en effet le analyseur_réception_de_réception sous-fonctionnalité.

Vous pouvez accéder au code complet dans ce dépôt github : https://github.com/Daggx/embedding-search-engine

‍