tutorial cohere text embedder
1.0.0
L'intégration de texte est une tâche d'apprentissage automatique utilisée pour créer une représentation vectorielle d'un morceau de texte. Ce vecteur peut ensuite être utilisé comme entrée dans un algorithme d’apprentissage automatique. L’objectif de l’intégration de texte est de capturer la signification du texte d’une manière adaptée à l’apprentissage automatique.
Il existe de nombreuses façons différentes de créer des intégrations de texte, mais la plus courante consiste à utiliser un réseau de neurones. Un réseau de neurones est un algorithme d’apprentissage automatique très efficace pour apprendre des relations complexes. L’entrée d’un réseau neuronal est un vecteur et la sortie est un vecteur de même taille. Le réseau neuronal apprend à mapper les vecteurs d'entrée sur les vecteurs de sortie de manière à capturer les relations entre les entrées et les sorties.
Pour créer une intégration de texte, le réseau de neurones est d'abord formé sur un vaste corpus de texte. Les données d'entraînement sont un ensemble de phrases et chaque phrase est représentée sous forme de vecteur. Les vecteurs sont créés en prenant les vecteurs de mots des mots de la phrase et en les additionnant. Le réseau neuronal est ensuite entraîné à mapper les vecteurs de phrases à une taille de vecteur fixe.
Une fois le réseau neuronal formé, il peut ensuite être utilisé pour créer des intégrations de texte pour de nouveaux morceaux de texte. Le nouveau texte est d'abord représenté sous forme de vecteur, puis le réseau neuronal est utilisé pour mapper le vecteur à la taille de vecteur fixe. Le résultat est une intégration de texte qui capture le sens du texte.
Les intégrations de texte peuvent être utilisées pour diverses tâches d’apprentissage automatique. Par exemple, ils peuvent être utilisés pour améliorer les performances d’un algorithme d’apprentissage automatique utilisé pour classer des textes. Les intégrations de texte peuvent également être utilisées pour rechercher des morceaux de texte similaires ou pour regrouper des textes.
Il existe de nombreuses façons différentes de créer des intégrations de texte, et le choix de la méthode dépendra de l'application. Cependant, les réseaux de neurones constituent une méthode puissante et largement utilisée pour créer des intégrations de texte.
Co:here est un puissant réseau de neurones, capable de générer, d'intégrer et de classer du texte. Dans ce didacticiel, nous utiliserons Co:here pour intégrer des descriptions. Pour utiliser Co:here, vous devez créer un compte sur Co:here et obtenir la clé API.
Nous allons programmer en Python, nous devons donc installer la bibliothèque cohere par pip
pip install cohere Tout d’abord, nous devons implémenter cohere.Client . Les arguments du client doivent contenir la clé API que vous avez générée auparavant et la version 2021-11-08 . Je vais créer la classe CoHere , elle sera utile dans les prochaines étapes.
class CoHere :
def __init__ ( self , api_key ):
self . co = cohere . Client ( f' { api_key } ' , '2021-11-08' )
self . examples = []La partie principale de chaque réseau neuronal est un ensemble de données. Dans ce tutoriel, j'utiliserai un ensemble de données comprenant 1000 descriptions de 10 classes. Si vous souhaitez l'utiliser, vous pouvez le télécharger ici.
L'ensemble de données téléchargé contient 10 dossiers, chaque dossier contenant 100 files.txt avec des descriptions. Le nom des fichiers est une étiquette de description, par exemple sport_3.txt .
Nous comparerons Random Forest avec Co:here Classifier , nous devons donc préparer les données de deux manières. Pour Random Forest nous utiliserons Co:here Embedder , nous nous concentrerons sur cela dans ce tutoriel. Le classificateur Cohere nécessite des échantillons, dans lesquels chaque échantillon doit être conçu sous forme de liste [description, label] et je l'ai fait dans mon tutoriel précédent (ici)
Au début, nous devons charger toutes les données pour ce faire. Nous créons la fonction load_examples . Dans cette fonction, nous utiliserons trois bibliothèques externes :
os.path pour accéder au dossier contenant les données. Le code est exécuté dans un chemin où se trouve le file.py de python. Il s'agit d'une bibliothèque interne, nous n'avons donc pas besoin de l'installer.
numpy cette bibliothèque est utile pour travailler avec des tableaux. Dans ce tutoriel, nous l'utiliserons pour générer des nombres aléatoires. Vous devez installer cette bibliothèque par pip pip install numpy .
glob nous aide à lire tous les noms de fichiers et de dossiers. Il s'agit d'une bibliothèque externe, l'installation est donc nécessaire - pip install glob .
L'ensemble de données téléchargé doit être extrait dans le dossier data . Par os.path.join nous pouvons obtenir des chemins universels de dossiers.
folders_path = os . path . join ( 'data' , '*' ) Dans Windows, un retour est égal à data* .
Ensuite, nous pouvons utiliser la méthode glob pour obtenir tous les noms de dossiers.
folders_name = glob ( folders_path ) folders_name est une liste qui contient les chemins de fenêtre des dossiers. Dans ce didacticiel, ce sont les noms des étiquettes.
[ 'data \ business' , 'data \ entertainment' , 'data \ food' , 'data \ graphics' , 'data \ historical' , 'data \ medical' , 'data \ politics' , 'data \ space' , 'data \ sport' , 'data \ technologie' ] Taille de Co:here l'ensemble de données de formation ne peut pas dépasser 50 exemples et chaque classe doit avoir au moins 5 exemples, mais pour Random Forest nous pouvons utiliser 1 000 exemples. Avec loop for nous pouvons obtenir les noms de chaque fichier. La fonction entière ressemble à ceci :
import os . path
from glob import glob
import numpy as np
def load_examples ( no_of_ex ):
examples_path = []
folders_path = os . path . join ( 'data' , '*' )
folders_name = glob ( folders_path )
for folder in folders_name :
files_path = os . path . join ( folder , '*' )
files_name = glob ( files_path )
for i in range ( no_of_ex // len ( folders_name )):
random_example = np . random . randint ( 0 , len ( files_name ))
examples_path . append ( files_name [ random_example ])
return examples_path La dernière boucle prend au hasard N chemins de chaque étiquette et les ajoute dans une nouvelle liste examples_path .
Maintenant, nous devons créer un ensemble de formation. Pour ce faire, nous allons charger des exemples avec load_examples() . Dans chaque chemin se trouve le nom d’une classe, nous allons l’utiliser pour créer des échantillons. Les descriptions doivent être lues à partir de fichiers, une longueur ne peut pas être longue, donc dans ce tutoriel, la longueur sera égale à 100. Pour lister texts est ajoutée la liste de [descroption, class_name] . Ainsi, un retour est cette liste.
def examples ( no_of_ex ):
texts = []
examples_path = load_examples ( no_of_ex )
for path in examples_path :
class_name = path . split ( os . sep )[ 1 ]
with open ( path , 'r' , encoding = "utf8" ) as file :
text = file . read ()[: 100 ]
texts . append ([ text , class_name ])
return texts Nous retournons au cours CoHere . Nous devons ajouter une méthode : intégrer des exemples.
La deuxième méthode cohere consiste à intégrer du texte. La méthode a des arguments de serveur, tels que :
taille model d'un modèle.
texts liste des textes à intégrer.
truncate si le texte est plus long que le jeton disponible, quelle partie du texte doit être prise LEFT , RIGHT ou NONE .
Vous pouvez tous les trouver ici.
Dans ce tutoriel, la méthode cohere sera implémentée en tant que méthode de notre classe CoHere .
def embed ( self , no_of_ex ):
# as a good developer we should split the dataset.
data = pd . DataFrame ( examples ( no_of_ex ))
self . X_train , self . X_test , self . y_train , self . y_test = train_test_split (
list ( data [ 0 ]), list ( data [ 1 ]), test_size = 0.2 , random_state = 0 )
# in the next two lines we create a numeric form of X_train data
self . X_train_embeded = self . co . embed ( texts = X_train ,
model = "large" ,
truncate = "LEFT" ). embeddings
self . X_test_embeded = self . co . embed ( texts = X_test ,
model = "large" ,
truncate = "LEFT" ). embeddings X_train_embeded sera un tableau de nombres, qui ressemble à ceci :
[ 386, 0.39653537, -0.409076, 0.5956299, -0.06624506, 2.0539167, 0.7133603,...
Pour créer une application qui comparera deux affichages de vraisemblance, nous utiliserons Stramlit . C'est une bibliothèque simple et très utile.
Installation
pip install streamlit Nous aurons besoin d'entrées de texte pour la clé API co:here .
Dans la documentation de streamlit on peut trouver des méthodes :
st.header() pour créer un en-tête sur notre application
st.test_input() pour envoyer une requête texte
st.button() pour créer un bouton
st.write() pour afficher les résultats du modèle de cohérence.
st.progress() pour afficher une barre de progression
st.column() pour diviser une application
st . header ( "Co:here Text Classifier vs Random Forest" )
api_key = st . text_input ( "API Key:" , type = "password" )
cohere = CoHere ( api_key )
cohere . list_of_examples ( 50 ) # number of examples for Cohere classifier
# showed in the previous tutorial
cohere . embed ( 1000 ) # number of examples for random forest
# initialization of random forest with sklearn library
forest = RandomForestClassifier ( max_depth = 10 , random_state = 0 )
col1 , col2 = st . columns ( 2 )
if col1 . button ( "Classify" ):
# training process of random forest, to do it we use embedded text.
forest . fit ( cohere . X_train_embeded , cohere . y_train )
# prediction process of random forest
predict = forest . predict_proba ( np . array ( cohere . X_test_embeded [ 0 ]). reshape ( 1 , - 1 ))[ 0 ]
here = cohere . classify ([ cohere . X_test [ 0 ]])[ 0 ] # prediction process of cohere classifier
col2 . success ( f"Correct prediction: { cohere . y_test [ 0 ] } " ) # display original label
col1 , col2 = st . columns ( 2 )
col1 . header ( "Co:here classify" ) # predictions for cohere
for con in here . confidence :
col1 . write ( f" { con . label } : { np . round ( con . confidence * 100 , 2 ) } %" )
col1 . progress ( con . confidence )
col2 . header ( "Random Forest" ) # predictions for random forest
for con , pred in zip ( here . confidence , predict ):
col2 . write ( f" { con . label } : { np . round ( pred * 100 , 2 ) } %" )
col2 . progress ( pred )Pour exécuter l'application simplifiée, utilisez la commande
streamlit run name_of_your_file . pyL'application créée ressemble à ceci
L'intégration de texte est un outil puissant qui peut être utilisé pour améliorer les performances des algorithmes d'apprentissage automatique. Les réseaux de neurones sont une méthode largement utilisée et efficace pour créer des intégrations de texte. Les incorporations de texte peuvent être utilisées pour des tâches telles que la classification de texte, la similarité de texte et le regroupement de texte.
Dans ce tutoriel, nous comparons Random Forest avec Co:here Classifier , mais les possibilités de Co:here Embedder sont énormes. Vous pouvez construire beaucoup de choses avec.
Restez à l'écoute pour les prochains tutoriels ! Le référentiel de ce code peut vérifier ici.
Merci! - Adrian Banachowicz, stagiaire en science des données chez New Native
