tutorial cohere text embedder
1.0.0
Incorporador de texto é uma tarefa de aprendizado de máquina usada para criar uma representação vetorial de um trecho de texto. Este vetor pode então ser usado como entrada para um algoritmo de aprendizado de máquina. O objetivo da incorporação de texto é capturar o significado do texto de uma forma adequada ao aprendizado de máquina.
Existem muitas maneiras diferentes de criar incorporações de texto, mas a mais comum é usar uma rede neural. Uma rede neural é um algoritmo de aprendizado de máquina muito bom para aprender relacionamentos complexos. A entrada para uma rede neural é um vetor e a saída é um vetor do mesmo tamanho. A rede neural aprende a mapear os vetores de entrada para os vetores de saída de uma forma que captura as relações entre as entradas e as saídas.
Para criar incorporação de texto, a rede neural é primeiro treinada em um grande corpus de texto. Os dados de treinamento são um conjunto de sentenças e cada sentença é representada como um vetor. Os vetores são criados pegando os vetores de palavras das palavras da frase e somando-os. A rede neural é então treinada para mapear os vetores de sentença para um tamanho de vetor fixo.
Depois que a rede neural for treinada, ela poderá ser usada para criar incorporações de texto para novos trechos de texto. O novo texto é primeiro representado como um vetor e, em seguida, a rede neural é usada para mapear o vetor para o tamanho fixo do vetor. O resultado é uma incorporação de texto que captura o significado do texto.
A incorporação de texto pode ser usada para uma variedade de tarefas de aprendizado de máquina. Por exemplo, eles podem ser usados para melhorar o desempenho de um algoritmo de aprendizado de máquina usado para classificar textos. A incorporação de texto também pode ser usada para localizar trechos de texto semelhantes ou para agrupar textos.
Existem muitas maneiras diferentes de criar incorporações de texto, e a escolha do método dependerá da aplicação. No entanto, as redes neurais são um método poderoso e amplamente utilizado para criar incorporações de texto.
Co: aqui está uma rede neural poderosa, que pode gerar, incorporar e classificar texto. Neste tutorial, usaremos Co:here para incorporar descrições. Para usar o Co:here você precisa criar uma conta no Co:here e obter a chave API.
Estaremos programando em Python, então precisamos instalar a biblioteca cohere por pip
pip install cohere Primeiramente, temos que implementar cohere.Client . Nos argumentos do Cliente deve estar a chave API, que você gerou antes, e a versão 2021-11-08 . Vou criar a classe CoHere , ela será útil nos próximos passos.
class CoHere :
def __init__ ( self , api_key ):
self . co = cohere . Client ( f' { api_key } ' , '2021-11-08' )
self . examples = []A parte principal de cada rede neural é um conjunto de dados. Neste tutorial, usarei um conjunto de dados que inclui 1.000 descrições de 10 classes. Se quiser usar o mesmo, você pode baixá-lo aqui.
O conjunto de dados baixado tem 10 pastas em cada pasta são 100 files.txt com descrições. O nome dos arquivos é um rótulo de descrição, por exemplo, sport_3.txt .
Compararemos Random Forest com Co:here Classifier , portanto, temos que preparar os dados de duas maneiras. Para Random Forest usaremos Co:here Embedder , vamos nos concentrar nisso neste tutorial. O classificador Cohere requer amostras, nas quais cada amostra deve ser projetada como uma lista [description, label] e fiz isso em meu tutorial anterior (aqui)
No início, precisamos carregar todos os dados, para isso. Criamos a função load_examples . Nesta função usaremos três bibliotecas externas:
os.path para ir para a pasta com dados. O código é executado em um caminho onde está o file.py do python. Esta é uma biblioteca interna, portanto não precisamos instalá-la.
numpy esta biblioteca é útil para trabalhar com arrays. Neste tutorial, iremos usá-lo para gerar números aleatórios. Você deve instalar esta biblioteca por pip pip install numpy .
glob nos ajuda a ler todos os arquivos e nomes de pastas. Esta é uma biblioteca externa, portanto a instalação é necessária - pip install glob .
O conjunto de dados baixado deve ser extraído na pasta data . Por os.path.join podemos obter caminhos universais de pastas.
folders_path = os . path . join ( 'data' , '*' ) No Windows, um retorno é igual a data* .
Então podemos usar o método glob para obter todos os nomes de pastas.
folders_name = glob ( folders_path ) folders_name é uma lista que contém caminhos de janelas de pastas. Neste tutorial, esses são os nomes dos rótulos.
[ 'data \ business' , 'data \ entertainment' , 'data \ food' , 'data \ graphics' , 'data \ historical' , 'data \ medical' , 'data \ politics' , 'data \ space' , 'data \ sport' , 'data \ technologie' ] O tamanho do conjunto de dados de treinamento Co:here não pode ser maior que 50 exemplos e cada classe deve ter pelo menos 5 exemplos, mas para Random Forest podemos usar 1000 exemplos. Com loop for podemos obter os nomes de cada arquivo. A função inteira fica assim:
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 O último loop pega aleatoriamente N caminhos de cada rótulo e os acrescenta em uma nova lista examples_path .
Agora, temos que criar um conjunto de treinamento. Para fazer isso, carregaremos exemplos com load_examples() . Em cada caminho está o nome de uma classe, iremos utilizá-lo para criar amostras. As descrições precisam ser lidas dos arquivos, o comprimento não pode ser longo, portanto neste tutorial o comprimento será igual a 100. Para listar texts está anexada uma lista de [descroption, class_name] . Assim, um retorno é essa 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 Voltamos à aula CoHere . Temos que adicionar um método - incorporar exemplos.
O segundo método cohere é incorporar texto. O método possui argumentos serval, como:
tamanho model de um modelo.
lista de texts de textos a serem incorporados.
truncate se o texto for maior que o token disponível, qual parte do texto deve ser tomada LEFT , RIGHT ou NONE .
Todos eles você encontra aqui.
Neste tutorial, o método cohere será implementado como um método de nossa 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 será uma matriz de números, semelhante a esta:
[ 386, 0.39653537, -0.409076, 0.5956299, -0.06624506, 2.0539167, 0.7133603,...
Para criar uma aplicação, que será a comparação de duas exibições de probabilidade, usaremos Stramlit . Esta é uma biblioteca fácil e muito útil.
Instalação
pip install streamlit Precisaremos de entradas de texto para a chave API co:here .
Nos documentos do streamlit podemos encontrar métodos:
st.header() para criar um cabeçalho em nosso aplicativo
st.test_input() para enviar uma solicitação de texto
st.button() para criar botão
st.write() para exibir os resultados do modelo coerente.
st.progress() para exibir uma barra de progresso
st.column() para dividir um aplicativo
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 executar o aplicativo streamlit, use o comando
streamlit run name_of_your_file . pyO aplicativo criado fica assim
A incorporação de texto é uma ferramenta poderosa que pode ser usada para melhorar o desempenho de algoritmos de aprendizado de máquina. As redes neurais são um método amplamente utilizado e eficaz para criar incorporações de texto. A incorporação de texto pode ser usada para tarefas como classificação de texto, similaridade de texto e agrupamento de texto.
Neste tutorial, comparamos o Random Forest com Co:here Classifier , mas as possibilidades do Co:here Embedder são enormes. Você pode construir muitas coisas com ele.
Fique ligado nos próximos tutoriais! O repositório deste código pode conferir aqui.
Obrigado! - Adrian Banachowicz, estagiário de ciência de dados na New Native
