tutorial cohere text embedder
1.0.0
Text Embedder ist eine maschinelle Lernaufgabe, mit der eine Vektordarstellung eines Textstücks erstellt wird. Dieser Vektor kann dann als Eingabe für einen Algorithmus für maschinelles Lernen verwendet werden. Ziel der Texteinbettung ist es, die Bedeutung des Textes auf eine für maschinelles Lernen geeignete Weise zu erfassen.
Es gibt viele verschiedene Möglichkeiten, Texteinbettungen zu erstellen, die gebräuchlichste ist jedoch die Verwendung eines neuronalen Netzwerks. Ein neuronales Netzwerk ist ein maschineller Lernalgorithmus, der sehr gut darin ist, komplexe Zusammenhänge zu lernen. Die Eingabe in ein neuronales Netzwerk ist ein Vektor und die Ausgabe ist ein Vektor derselben Größe. Das neuronale Netzwerk lernt, die Eingabevektoren den Ausgabevektoren so zuzuordnen, dass die Beziehungen zwischen den Eingaben und Ausgaben erfasst werden.
Um eine Texteinbettung zu erstellen, wird das neuronale Netzwerk zunächst an einem großen Textkorpus trainiert. Die Trainingsdaten sind eine Reihe von Sätzen, und jeder Satz wird als Vektor dargestellt. Die Vektoren werden erstellt, indem die Wortvektoren der Wörter im Satz addiert werden. Das neuronale Netzwerk wird dann darauf trainiert, die Satzvektoren auf eine feste Vektorgröße abzubilden.
Sobald das neuronale Netzwerk trainiert wurde, kann es dann zum Erstellen von Texteinbettungen für neue Textteile verwendet werden. Der neue Text wird zunächst als Vektor dargestellt und dann wird das neuronale Netzwerk verwendet, um den Vektor auf die feste Vektorgröße abzubilden. Das Ergebnis ist eine Texteinbettung, die die Bedeutung des Textes erfasst.
Texteinbettungen können für eine Vielzahl von maschinellen Lernaufgaben verwendet werden. Sie können beispielsweise dazu verwendet werden, die Leistung eines maschinellen Lernalgorithmus zu verbessern, der zur Klassifizierung von Texten verwendet wird. Texteinbettungen können auch verwendet werden, um ähnliche Textteile zu finden oder Texte zu gruppieren.
Es gibt viele verschiedene Möglichkeiten, Texteinbettungen zu erstellen, und die Wahl der Methode hängt von der Anwendung ab. Allerdings sind neuronale Netze eine leistungsstarke und weit verbreitete Methode zur Erstellung von Texteinbettungen.
Co:here ist ein leistungsstarkes neuronales Netzwerk, das Texte generieren, einbetten und klassifizieren kann. In diesem Tutorial verwenden wir Co:here zum Einbetten von Beschreibungen. 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 .
Wir werden Random Forest mit Co:here Classifier vergleichen, daher müssen wir Daten auf zwei Arten vorbereiten. Für Random Forest verwenden wir Co:here Embedder , darauf konzentrieren wir uns in diesem Tutorial. Der Cohere-Klassifikator erfordert Proben, in denen jede Probe als Liste [description, label] gestaltet werden sollte, und ich habe dies in meinem vorherigen Tutorial (hier) getan.
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, aber für Random Forest können wir 1000 Beispiele verwenden. 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 ( 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 Die letzte Schleife nimmt zufällig N-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 ( 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 Wir kehren zum CoHere -Kurs zurück. Wir müssen eine Methode hinzufügen – zum Einbetten von Beispielen.
Die zweite cohere Methode besteht darin, Text einzubetten. Die Methode hat mehrere Argumente, wie zum Beispiel:
model eines Modells.
texts Liste der einzubettenden Texte.
truncate wenn der Text länger als das verfügbare Token ist, welcher Teil des Textes genommen werden soll LEFT , RIGHT oder NONE .
Alle davon finden Sie hier.
In diesem Tutorial wird die cohere Methode als Methode unserer CoHere -Klasse implementiert.
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 wird ein Zahlenarray sein, das so aussieht:
[ 386, 0.39653537, -0.409076, 0.5956299, -0.06624506, 2.0539167, 0.7133603,...
Um eine Anwendung zu erstellen, die zwei Wahrscheinlichkeitsanzeigen vergleicht, verwenden wir Stramlit . Dies ist eine einfache und sehr nützliche Bibliothek.
Installation
pip install streamlit Wir benötigen Texteingaben für den API-Schlüssel co:here .
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 ( "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 )Um die Streamlit-App auszuführen, verwenden Sie den Befehl
streamlit run name_of_your_file . pyDie erstellte App sieht so aus
Das Einbetten von Text ist ein leistungsstarkes Tool, mit dem die Leistung von Algorithmen für maschinelles Lernen verbessert werden kann. Neuronale Netze sind eine weit verbreitete und effektive Methode zur Erstellung von Texteinbettungen. Texteinbettungen können für Aufgaben wie Textklassifizierung, Textähnlichkeit und Textclusterung verwendet werden.
In diesem Tutorial vergleichen wir den Random Forest mit Co:here Classifier , aber die Möglichkeiten von Co:here Embedder sind riesig. Man kann damit eine Menge Dinge bauen.
Seien Sie gespannt auf zukünftige Tutorials! Das Repository dieses Codes kann hier überprüft werden.
Danke schön! - Adrian Banachowicz, Data Science-Praktikant bei New Native
