tutorial cohere text classifier
1.0.0
O processamento de linguagem natural é um campo da ciência da computação e da linguística preocupado com as interações entre computadores e linguagens humanas (naturais). Em sua forma mais simples, a PNL trata do desenvolvimento de algoritmos que podem compreender e produzir automaticamente a linguagem humana. O objetivo de longo prazo da PNL é criar modelos computacionais de linguagem humana que possam ser usados para realizar uma ampla variedade de tarefas. Essas tarefas incluem tradução automática, resumo, resposta a perguntas, extração de informações e muitas outras. A pesquisa em PNL é altamente interdisciplinar, envolvendo pesquisadores de áreas como linguística, ciências cognitivas, inteligência artificial e ciência da computação.
Existem muitos métodos diferentes usados no processamento de linguagem natural, incluindo métodos baseados em regras, métodos estatísticos e métodos neurais computados. Os métodos baseados em regras geralmente são baseados em regras elaboradas à mão, escritas por especialistas em PNL. Esses métodos podem ser muito eficazes para tarefas específicas, mas geralmente são limitados em seu escopo e exigem muito esforço para serem mantidos. Os métodos estatísticos baseiam-se no uso de grandes quantidades de dados para treinar modelos computacionais. Esses modelos podem então ser usados para executar automaticamente várias tarefas de PNL. As redes neurais são um tipo de algoritmo de aprendizado de máquina particularmente adequado para tarefas de PNL. As redes neurais têm sido usadas para criar modelos de última geração para tarefas como tradução automática e classificação.
Co: aqui está uma rede neural poderosa, que pode gerar, incorporar e classificar texto. Neste tutorial usaremos Co:here para classificar 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 .
Neste campo, as tarefas são ler descrições e rótulos de arquivos e criar dados, que contêm descrição e rótulo como uma amostra de dados. O classificador Cohere requer amostras, nas quais cada amostra deve ser projetada como uma lista [description, label] .
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. 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 ():
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 O último loop pega aleatoriamente 5 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 ():
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 Voltamos à aula CoHere . Temos que adicionar dois métodos - para carregar exemplos e para classificar a entrada.
O primeiro é simples, a lista co:here de exemplos deve ser criada com o método adicional cohere - cohere.classify.Example .
def list_of_examples ( self ):
for e in examples ():
self . examples . append ( Example ( text = e [ 0 ], label = e [ 1 ])) O segundo método é classificar o método de cohere . O método possui argumentos serval, como:
tamanho model de um modelo.
inputs uma lista de dados a serem classificados.
lista de examples de um conjunto de treinamento com exemplos
Todos eles você encontra aqui.
Neste tutorial, o método cohere será implementado como um método de nossa classe CoHere . Um argumento deste método é uma lista de descrições a serem previstas.
def classify ( self , inputs ):
return self . co . classify (
model = 'medium' ,
inputs = inputs ,
examples = self . examples
). classifications O retorno é input , prediction de entrada e uma lista de confidence . Confidence é uma lista de probabilidades de cada 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 Para criar uma aplicação, na qual haverá uma caixa de entrada de texto e uma exibição de probabilidade, usaremos Stramlit . Esta é uma biblioteca fácil e muito útil.
Instalação
pip install streamlit Precisaremos de duas entradas de texto para a chave de API co:here e para a previsão do texto.
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 ( "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 executar o aplicativo streamlit, use o comando
streamlit run name_of_your_file . pyO aplicativo criado fica assim
Os modelos Co:here podem ser usados não apenas para gerar o texto, mas também para classificação. Neste tutorial, conseguimos classificar um texto curto, com um pequeno conjunto de dados. Foram 50 exemplos para 10 aulas. Isso foi suficiente para manter a probabilidade de previsão em um nível alto. O grande conjunto de dados em alguns cenários pode ser difícil de produzir, então o modelo Co:here pode ser uma ótima solução para isso.
Fique ligado nos próximos tutoriais!
Obrigado! - Adrian Banachowicz, estagiário de ciência de dados na New Native
