tutorial cohere text classifier
1.0.0
Le traitement du langage naturel est un domaine de l'informatique et de la linguistique concerné par les interactions entre les ordinateurs et les langues humaines (naturelles). Dans sa forme la plus simple, la PNL consiste à développer des algorithmes capables de comprendre et de produire automatiquement le langage humain. L’objectif à long terme de la PNL est de créer des modèles informatiques du langage humain pouvant être utilisés pour effectuer une grande variété de tâches. Ces tâches incluent la traduction automatique, le résumé, la réponse aux questions, l’extraction d’informations et bien d’autres. La recherche en PNL est hautement interdisciplinaire et implique des chercheurs issus de domaines tels que la linguistique, les sciences cognitives, l'intelligence artificielle et l'informatique.
Il existe de nombreuses méthodes différentes utilisées dans le traitement du langage naturel, notamment les méthodes basées sur des règles, les méthodes statistiques et les méthodes de calcul neuronal. Les méthodes basées sur des règles sont généralement basées sur des règles élaborées à la main et rédigées par des experts en PNL. Ces méthodes peuvent être très efficaces pour des tâches spécifiques, mais leur portée est souvent limitée et leur maintenance nécessite beaucoup d’efforts. Les méthodes statistiques reposent sur l’utilisation de grandes quantités de données pour entraîner des modèles informatiques. Ces modèles peuvent ensuite être utilisés pour effectuer automatiquement diverses tâches de PNL. Les réseaux de neurones sont un type d’algorithme d’apprentissage automatique particulièrement adapté aux tâches de PNL. Les réseaux de neurones ont été utilisés pour créer des modèles de pointe pour des tâches telles que la traduction automatique et la classification.
Co:here est un puissant réseau de neurones, capable de générer, d'intégrer et de classer du texte. Dans ce tutoriel, nous utiliserons Co:here pour classer les 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 .
Dans ce champ, les tâches consistent à lire les descriptions et les étiquettes des fichiers et à créer des données contenant une description et une étiquette comme un échantillon de données. Le classificateur Cohere nécessite des échantillons, dans lesquels chaque échantillon doit être conçu sous forme de liste [description, label] .
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. 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 ():
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 ( 50 // 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 5 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 ():
texts = []
examples_path = load_examples ()
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 deux méthodes : charger des exemples et classer les entrées.
La première est simple, co:here la liste d'exemples doit être créée avec la méthode supplémentaire de cohere - cohere.classify.Example .
def list_of_examples ( self ):
for e in examples ():
self . examples . append ( Example ( text = e [ 0 ], label = e [ 1 ])) La deuxième méthode consiste à classer la méthode à partir de cohere . La méthode a des arguments de serveur, tels que :
taille model d'un modèle.
inputs la liste des données à classer.
examples liste d'un ensemble de formation avec des exemples
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 . Un argument de cette méthode est une liste de descriptions à prédire.
def classify ( self , inputs ):
return self . co . classify (
model = 'medium' ,
inputs = inputs ,
examples = self . examples
). classifications Le retour est input , prediction d'entrée et une liste de confidence . Confidence est une liste de probabilités de chaque classe.
cohere . Classification {
input :
prediction :
confidence : []
}CoHere import cohere
from loadExamples import examples
from cohere . classify import Example
class CoHere :
def __init__ ( self , api_key ):
self . co = cohere . Client ( f' { api_key } ' , '2021-11-08' )
self . examples = []
def list_of_examples ( self ):
for e in examples ():
self . examples . append ( Example ( text = e [ 0 ], label = e [ 1 ]))
def classify ( self , inputs ):
return self . co . classify (
model = 'medium' ,
taskDescription = '' ,
outputIndicator = '' ,
inputs = inputs ,
examples = self . examples
). classifications Pour créer une application, dans laquelle se trouveront une zone de saisie de texte et un affichage de vraisemblance, nous utiliserons Stramlit . C'est une bibliothèque simple et très utile.
Installation
pip install streamlit Nous aurons besoin de deux entrées de texte pour la clé API co:here et pour le texte à prédire.
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 ( "Your personal text classifier - Co:here application" )
api_key = st . text_input ( "API Key:" , type = "password" ) #text box for API key
description = [ st . text_input ( "Description:" )] #text box for text to predict
cohere = CoHere ( api_key ) #initialization CoHere
cohere . list_of_examples () #loading training set
if st . button ( "Classify" ):
here = cohere . classify ( description )[ 0 ] #prediction
col1 , col2 = st . columns ( 2 )
for no , con in enumerate ( here . confidence ): #display likelihood for each label
if no % 2 == 0 : # in two columns
col1 . write ( f" { con . label } : { np . round ( con . confidence * 100 , 2 ) } %" )
col1 . progress ( con . confidence )
else :
col2 . write ( f" { con . label } : { np . round ( con . confidence * 100 , 2 ) } %" )
col2 . progress ( con . confidence )Pour exécuter l'application simplifiée, utilisez la commande
streamlit run name_of_your_file . pyL'application créée ressemble à ceci
Les modèles Co:here peuvent être utilisés non seulement pour générer le texte mais également pour la classification. Dans ce tutoriel, nous avons pu classer un texte court, avec un petit jeu de données. Il y avait 50 exemples pour 10 classes. C’était suffisant pour maintenir la probabilité de prédiction à un niveau élevé. Le grand ensemble de données dans certains scénarios peut être difficile à produire, le modèle Co:here peut donc être une excellente solution pour cela.
Restez à l'écoute pour les prochains tutoriels !
Merci! - Adrian Banachowicz, stagiaire en science des données chez New Native
