tutorial cohere text embedder
1.0.0
La incrustación de texto es una tarea de aprendizaje automático que se utiliza para crear una representación vectorial de un fragmento de texto. Luego, este vector se puede utilizar como entrada para un algoritmo de aprendizaje automático. El objetivo de la incrustación de texto es capturar el significado del texto de una manera que sea adecuada para el aprendizaje automático.
Hay muchas formas diferentes de crear incrustaciones de texto, pero la más común es utilizar una red neuronal. Una red neuronal es un algoritmo de aprendizaje automático que es muy bueno para aprender relaciones complejas. La entrada a una red neuronal es un vector y la salida es un vector del mismo tamaño. La red neuronal aprende a asignar los vectores de entrada a los vectores de salida de una manera que capture las relaciones entre las entradas y las salidas.
Para crear incrustaciones de texto, la red neuronal primero se entrena en un gran corpus de texto. Los datos de entrenamiento son un conjunto de oraciones y cada oración se representa como un vector. Los vectores se crean tomando los vectores de palabras de las palabras de la oración y sumándolos. Luego se entrena la red neuronal para asignar los vectores de oración a un tamaño de vector fijo.
Una vez que se ha entrenado la red neuronal, se puede utilizar para crear incrustaciones de texto para nuevos fragmentos de texto. El nuevo texto se representa primero como un vector y luego se utiliza la red neuronal para asignar el vector al tamaño de vector fijo. El resultado es una incrustación de texto que captura el significado del texto.
Las incrustaciones de texto se pueden utilizar para una variedad de tareas de aprendizaje automático. Por ejemplo, se pueden utilizar para mejorar el rendimiento de un algoritmo de aprendizaje automático que se utiliza para clasificar textos. Las incrustaciones de texto también se pueden utilizar para encontrar fragmentos de texto similares o para agrupar textos.
Hay muchas formas diferentes de crear incrustaciones de texto y la elección del método dependerá de la aplicación. Sin embargo, las redes neuronales son un método potente y ampliamente utilizado para crear incrustaciones de texto.
Co:here es una poderosa red neuronal que puede generar, incrustar y clasificar texto. En este tutorial, usaremos Co:here para insertar 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 .
Compararemos Random Forest con Co:here Classifier , por lo que tenemos que preparar los datos de dos maneras. Para Random Forest usaremos Co:here Embedder , nos centraremos en esto en este tutorial. El clasificador Cohere requiere muestras, en las que cada muestra debe diseñarse como una lista [description, label] y lo hice en mi tutorial anterior (aquí)
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, pero para Random Forest podemos usar 1000 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 ( 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 El último ciclo toma N rutas aleatorias 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 ( 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 Volvemos a la clase CoHere . Tenemos que agregar un método: insertar ejemplos.
El segundo método cohere consiste en incrustar texto. El método tiene argumentos serval, como por ejemplo:
tamaño model de un modelo.
texts lista de textos para incrustar.
truncate si el texto es más largo que el token disponible, qué parte del texto debe tomarse LEFT , RIGHT o NONE .
Todos ellos los puedes encontrar aquí.
En este tutorial, el método cohere se implementará como método de nuestra clase 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 será una matriz de números, que se verá así:
[ 386, 0.39653537, -0.409076, 0.5956299, -0.06624506, 2.0539167, 0.7133603,...
Para crear una aplicación que comparará dos visualizaciones de probabilidad, usaremos Stramlit . Esta es una biblioteca fácil y muy útil.
Instalación
pip install streamlit Necesitaremos entradas de texto para la clave API co:here .
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 ( "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 )Para ejecutar el comando de uso de la aplicación Streamlit
streamlit run name_of_your_file . pyLa aplicación creada se ve así
La incrustación de texto es una herramienta poderosa que se puede utilizar para mejorar el rendimiento de los algoritmos de aprendizaje automático. Las redes neuronales son un método eficaz y ampliamente utilizado para crear incrustaciones de texto. Las incrustaciones de texto se pueden utilizar para tareas como clasificación de texto, similitud de texto y agrupación de texto.
En este tutorial, comparamos Random Forest con Co:here Classifier , pero las posibilidades de Co:here Embedder son enormes. Puedes construir muchas cosas con él.
¡Estén atentos a futuros tutoriales! El repositorio de este código lo puedes consultar aquí.
¡Gracias! - Adrian Banachowicz, pasante de ciencia de datos en New Native
