tutorial cohere text classifier
1.0.0
Die Verarbeitung natürlicher Sprache ist ein Bereich der Informatik und Linguistik, der sich mit den Interaktionen zwischen Computern und menschlichen (natürlichen) Sprachen befasst. In seiner einfachsten Form geht es bei NLP um die Entwicklung von Algorithmen, die automatisch menschliche Sprache verstehen und produzieren können. Das langfristige Ziel von NLP besteht darin, Computermodelle der menschlichen Sprache zu erstellen, die zur Ausführung einer Vielzahl von Aufgaben verwendet werden können. Zu diesen Aufgaben gehören automatische Übersetzung, Zusammenfassung, Beantwortung von Fragen, Informationsextraktion und viele andere. Die NLP-Forschung ist stark interdisziplinär und umfasst Forscher aus Bereichen wie Linguistik, Kognitionswissenschaft, künstliche Intelligenz und Informatik.
Bei der Verarbeitung natürlicher Sprache werden viele verschiedene Methoden verwendet, darunter regelbasierte Methoden, statistische Methoden und neuronale Berechnungsmethoden. Regelbasierte Methoden basieren in der Regel auf handgefertigten Regeln, die von NLP-Experten verfasst werden. Diese Methoden können für bestimmte Aufgaben sehr effektiv sein, sind jedoch oft in ihrem Umfang begrenzt und erfordern einen hohen Aufwand in der Wartung. Statistische Methoden basieren auf der Verwendung großer Datenmengen zum Trainieren von Rechenmodellen. Diese Modelle können dann verwendet werden, um verschiedene NLP-Aufgaben automatisch auszuführen. Neuronale Netze sind eine Art maschineller Lernalgorithmus, der sich besonders gut für NLP-Aufgaben eignet. Mithilfe neuronaler Netze wurden hochmoderne Modelle für Aufgaben wie maschinelle Übersetzung und Klassifizierung erstellt.
Co:here ist ein leistungsstarkes neuronales Netzwerk, das Texte generieren, einbetten und klassifizieren kann. In diesem Tutorial verwenden wir Co:here, um Beschreibungen zu klassifizieren. Um Co:here verwenden zu können, müssen Sie ein Konto bei Co:here erstellen und einen API-Schlüssel erhalten.
Wir werden in Python programmieren, daher müssen wir cohere Bibliothek per pip installieren
pip install cohere Zuerst müssen wir cohere.Client implementieren. In den Argumenten des Clients sollte der API-Schlüssel enthalten sein, den Sie zuvor generiert haben, und die Version 2021-11-08 . Ich werde die Klasse CoHere erstellen, sie wird in den nächsten Schritten nützlich sein.
class CoHere :
def __init__ ( self , api_key ):
self . co = cohere . Client ( f' { api_key } ' , '2021-11-08' )
self . examples = []Der Hauptbestandteil jedes neuronalen Netzwerks ist ein Datensatz. In diesem Tutorial verwende ich einen Datensatz, der 1000 Beschreibungen von 10 Klassen enthält. Wenn Sie dasselbe verwenden möchten, können Sie es hier herunterladen.
Der heruntergeladene Datensatz verfügt über 10 Ordner. Jeder Ordner enthält 100 files.txt mit Beschreibungen. Der Name der Datei ist eine Beschreibungsbezeichnung, z. B. sport_3.txt .
In diesem Bereich besteht die Aufgabe darin, Beschreibungen und Beschriftungen aus Dateien zu lesen und Daten zu erstellen, die Beschreibung und Beschriftung als ein Datenbeispiel enthalten. Der Cohere-Klassifikator erfordert Proben, wobei jede Probe als Liste [description, label] gestaltet sein sollte.
Dazu müssen wir zunächst alle Daten laden. Wir erstellen die Funktion load_examples . In dieser Funktion verwenden wir drei externe Bibliotheken:
os.path um in den Ordner mit den Daten zu gelangen. Der Code wird in einem Pfad ausgeführt, in dem sich file.py eines Pythons befindet. Da es sich um eine interne Bibliothek handelt, müssen wir sie nicht installieren.
numpy Diese Bibliothek ist nützlich, um mit Arrays zu arbeiten. In diesem Tutorial werden wir es verwenden, um Zufallszahlen zu generieren. Sie müssen diese Bibliothek mit pip pip install numpy installieren.
glob hilft uns, alle Datei- und Ordnernamen zu lesen. Da es sich um eine externe Bibliothek handelt, ist die Installation erforderlich – pip install glob .
Der heruntergeladene Datensatz sollte in den Ordner data extrahiert werden. Mit os.path.join können wir universelle Pfade von Ordnern erhalten.
folders_path = os . path . join ( 'data' , '*' ) In Windows entspricht eine Rückgabe data* .
Dann können wir glob -Methode verwenden, um alle Namen von Ordnern abzurufen.
folders_name = glob ( folders_path ) folders_name ist eine Liste, die Fensterpfade von Ordnern enthält. In diesem Tutorial sind dies die Namen der Labels.
[ 'data \ business' , 'data \ entertainment' , 'data \ food' , 'data \ graphics' , 'data \ historical' , 'data \ medical' , 'data \ politics' , 'data \ space' , 'data \ sport' , 'data \ technologie' ] Die Größe des Co:here Trainingsdatensatzes darf nicht größer als 50 Beispiele sein und jede Klasse muss mindestens 5 Beispiele haben. Mit der Schleife for können wir die Namen jeder Datei ermitteln. Die gesamte Funktion sieht so aus:
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 Die letzte Schleife nimmt zufällig 5 Pfade jedes Labels und hängt sie an eine neue Liste examples_path an.
Jetzt müssen wir ein Trainingsset erstellen. Um dies zu erreichen, laden wir Beispiele mit load_examples() . In jedem Pfad steht der Name einer Klasse, wir werden ihn zum Erstellen von Beispielen verwenden. Beschreibungen müssen aus Dateien gelesen werden, die Länge darf nicht lang sein, daher beträgt die Länge in diesem Tutorial 100. An die texts wird eine Liste mit [descroption, class_name] angehängt. Eine Rückgabe ist also diese 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 Wir kehren zum CoHere -Kurs zurück. Wir müssen zwei Methoden hinzufügen – zum Laden von Beispielen und zum Klassifizieren von Eingaben.
Die erste ist einfach: Eine Liste von Beispielen co:here muss mit der zusätzlichen Methode von cohere erstellt werden – cohere.classify.Example .
def list_of_examples ( self ):
for e in examples ():
self . examples . append ( Example ( text = e [ 0 ], label = e [ 1 ])) Die zweite Methode besteht darin, die Methode nach cohere zu klassifizieren. Die Methode hat mehrere Argumente, wie zum Beispiel:
model eines Modells.
inputs .
examples eines Trainingssatzes mit Beispielen
Alle davon finden Sie hier.
In diesem Tutorial wird die cohere Methode als Methode unserer CoHere -Klasse implementiert. Ein Argument dieser Methode ist eine Liste der vorherzusagenden Beschreibungen.
def classify ( self , inputs ):
return self . co . classify (
model = 'medium' ,
inputs = inputs ,
examples = self . examples
). classifications Die Rückgabe ist input , prediction der Eingabe und eine Liste der confidence . Confidence ist eine Wahrscheinlichkeitsliste jeder Klasse.
cohere . Classification {
input :
prediction :
confidence : []
}CoHere Klasse 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 Um eine Anwendung zu erstellen, die ein Texteingabefeld und eine Wahrscheinlichkeitsanzeige enthält, verwenden wir Stramlit . Dies ist eine einfache und sehr nützliche Bibliothek.
Installation
pip install streamlit Wir benötigen zwei Texteingaben für den API-Schlüssel „ co:here und für den vorherzusagenden Text.
In den Streamlit-Dokumenten finden wir folgende Methoden:
st.header() um einen Header für unsere App zu erstellen
st.test_input() zum Senden einer Textanfrage
st.button() zum Erstellen einer Schaltfläche
st.write() um die Ergebnisse des kohärenten Modells anzuzeigen.
st.progress() um einen Fortschrittsbalken anzuzeigen
st.column() zum Teilen einer App
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 )Um die Streamlit-App auszuführen, verwenden Sie den Befehl
streamlit run name_of_your_file . pyDie erstellte App sieht so aus
Co:here-Modelle können nicht nur zur Generierung des Textes, sondern auch zur Klassifizierung verwendet werden. In diesem Tutorial konnten wir einen kurzen Text mit einem kleinen Datensatz klassifizieren. Es gab 50 Beispiele für 10 Klassen. Dies reichte aus, um die Vorhersagewahrscheinlichkeit auf einem hohen Niveau zu halten. In einigen Szenarien kann es schwierig sein, große Datensätze zu erstellen, daher kann das Co:here-Modell eine großartige Lösung dafür sein.
Seien Sie gespannt auf zukünftige Tutorials!
Danke schön! - Adrian Banachowicz, Data Science-Praktikant bei New Native
