tutorial cohere text classifier
1.0.0
El procesamiento del lenguaje natural es un campo de la informática y la lingüística que se ocupa de las interacciones entre las computadoras y los lenguajes humanos (naturales). En su forma más simple, la PNL consiste en desarrollar algoritmos que puedan comprender y producir automáticamente el lenguaje humano. El objetivo a largo plazo de la PNL es crear modelos computacionales del lenguaje humano que puedan usarse para realizar una amplia variedad de tareas. Estas tareas incluyen traducción automática, resúmenes, respuesta a preguntas, extracción de información y muchas otras. La investigación de la PNL es altamente interdisciplinaria e involucra a investigadores de campos como la lingüística, las ciencias cognitivas, la inteligencia artificial y la informática.
Hay muchos métodos diferentes que se utilizan en el procesamiento del lenguaje natural, incluidos los métodos basados en reglas, los métodos estadísticos y los métodos computacionales neuronales. Los métodos basados en reglas generalmente se basan en reglas elaboradas manualmente y escritas por expertos en PNL. Estos métodos pueden ser muy efectivos para tareas específicas, pero a menudo tienen un alcance limitado y su mantenimiento requiere mucho esfuerzo. Los métodos estadísticos se basan en el uso de grandes cantidades de datos para entrenar modelos computacionales. Luego, estos modelos se pueden utilizar para realizar automáticamente varias tareas de PNL. Las redes neuronales son un tipo de algoritmo de aprendizaje automático particularmente adecuado para tareas de PNL. Se han utilizado redes neuronales para crear modelos de última generación para tareas como la traducción automática y la clasificación.
Co:here es una poderosa red neuronal que puede generar, incrustar y clasificar texto. En este tutorial usaremos Co:here para clasificar descripciones. Para utilizar Co:here, debe crear una cuenta en Co:here y obtener la clave API.
Programaremos en Python, por lo que necesitamos instalar la biblioteca cohere mediante pip
pip install cohere En primer lugar, tenemos que implementar cohere.Client . En los argumentos de Cliente debe estar la clave API, que generó anteriormente, y la versión 2021-11-08 . Crearé la clase CoHere , será útil en los próximos pasos.
class CoHere :
def __init__ ( self , api_key ):
self . co = cohere . Client ( f' { api_key } ' , '2021-11-08' )
self . examples = []La parte principal de cada red neuronal es un conjunto de datos. En este tutorial, utilizaré un conjunto de datos que incluye 1000 descripciones de 10 clases. Si quieres utilizar el mismo, puedes descargarlo aquí.
El conjunto de datos descargado tiene 10 carpetas y cada carpeta tiene 100 files.txt con descripciones. El nombre de los archivos es una etiqueta de descripción, por ejemplo, sport_3.txt .
En este campo, las tareas consisten en leer descripciones y etiquetas de archivos y crear datos que contengan descripciones y etiquetas como una muestra de datos. El clasificador Cohere requiere muestras, en las que cada muestra debe diseñarse como una lista [description, label] .
Al principio, necesitamos cargar todos los datos para hacerlo. Creamos la función load_examples . En esta función usaremos tres bibliotecas externas:
os.path para ir a la carpeta con datos. El código se ejecuta en una ruta donde se encuentra el file.py de Python. Esta es una biblioteca interna, por lo que no necesitamos instalarla.
numpy esta biblioteca es útil para trabajar con matrices. En este tutorial, lo usaremos para generar números aleatorios. Tienes que instalar esta biblioteca mediante pip pip install numpy .
glob nos ayuda a leer todos los archivos y nombres de carpetas. Esta es una biblioteca externa, por lo que es necesaria la instalación: pip install glob .
El conjunto de datos descargado debe extraerse en la carpeta data . Mediante os.path.join podemos obtener rutas universales de carpetas.
folders_path = os . path . join ( 'data' , '*' ) En Windows, un retorno es igual a data* .
Luego podemos usar el método glob para obtener todos los nombres de las carpetas.
folders_name = glob ( folders_path ) folders_name es una lista que contiene rutas de ventanas de carpetas. En este tutorial, estos son los nombres de las etiquetas.
[ 'data \ business' , 'data \ entertainment' , 'data \ food' , 'data \ graphics' , 'data \ historical' , 'data \ medical' , 'data \ politics' , 'data \ space' , 'data \ sport' , 'data \ technologie' ] El tamaño del conjunto de datos de entrenamiento Co:here no puede ser mayor que 50 ejemplos y cada clase debe tener al menos 5 ejemplos. Con loop for podemos obtener los nombres de cada archivo. Toda la función se ve así:
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 El último ciclo toma aleatoriamente 5 rutas de cada etiqueta y las agrega a una nueva lista de examples_path .
Ahora tenemos que crear un conjunto de entrenamiento. Para hacerlo cargaremos ejemplos con load_examples() . En cada ruta está el nombre de una clase, la usaremos para crear muestras. Las descripciones deben leerse de los archivos, la longitud no puede ser larga, por lo que en este tutorial, la longitud será igual a 100. Para enumerar texts se adjunta la lista de [descroption, class_name] . Por tanto, una devolución es esa lista.
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 Volvemos a la clase CoHere . Tenemos que agregar dos métodos: cargar ejemplos y clasificar la entrada.
El primero es simple, la lista co:here de ejemplos debe crearse con el método cohere adicional: cohere.classify.Example .
def list_of_examples ( self ):
for e in examples ():
self . examples . append ( Example ( text = e [ 0 ], label = e [ 1 ])) El segundo método consiste en clasificar el método desde cohere . El método tiene argumentos serval, como por ejemplo:
tamaño model de un modelo.
inputs una lista de datos para clasificar.
lista de examples de un conjunto de entrenamiento con ejemplos
Todos ellos los puedes encontrar aquí.
En este tutorial, el método cohere se implementará como método de nuestra clase CoHere . Un argumento de este método es una lista de descripciones para predecir.
def classify ( self , inputs ):
return self . co . classify (
model = 'medium' ,
inputs = inputs ,
examples = self . examples
). classifications El retorno es input , prediction de entrada y una lista de confidence . Confidence es una lista de probabilidades de cada clase.
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 Para crear una aplicación, en la que habrá un cuadro de entrada de texto y una pantalla de probabilidad, usaremos Stramlit . Esta es una biblioteca fácil y muy útil.
Instalación
pip install streamlit Necesitaremos dos entradas de texto para la clave API co:here y para el texto para predecir.
En documentos de streamlit podemos encontrar métodos:
st.header() para crear un encabezado en nuestra aplicación
st.test_input() para enviar una solicitud de texto
st.button() para crear un botón
st.write() para mostrar los resultados del modelo coherente.
st.progress() para mostrar una barra de progreso
st.column() para dividir una aplicación
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 )Para ejecutar el comando de uso de la aplicación Streamlit
streamlit run name_of_your_file . pyLa aplicación creada se ve así
Los modelos Co:here se pueden utilizar no solo para generar el texto sino también para la clasificación. En este tutorial, pudimos clasificar un texto breve, con un pequeño conjunto de datos. Había 50 ejemplos para 10 clases. Esto fue suficiente para mantener la probabilidad de predicción en un nivel alto. En algunos escenarios, el gran conjunto de datos puede ser difícil de producir, por lo que el modelo Co:here puede ser una gran solución para ello.
¡Estén atentos a futuros tutoriales!
¡Gracias! - Adrian Banachowicz, pasante de ciencia de datos en New Native
