Integrieren Sie LLMs ganz einfach in Ihren Scikit-Learn-Workflow mit Scikit-LLM – KDnuggets

Neuauflage von Plato

Verfolger: 0

Integrieren Sie LLMs ganz einfach in Ihren Scikit-Learn-Workflow mit Scikit-LLM
Bild generiert von DALL-E 2

Textanalyseaufgaben gibt es schon seit einiger Zeit, da der Bedarf immer da ist. Die Forschung hat einen langen Weg zurückgelegt, von einfachen Beschreibungsstatistiken über die Textklassifizierung bis hin zur erweiterten Textgenerierung. Mit der Aufnahme des Large Language Model in unser Arsenal werden unsere Arbeitsaufgaben noch zugänglicher.

Scikit-LLM ist ein Python-Paket, das für Textanalyseaktivitäten mit der Leistungsfähigkeit von LLM entwickelt wurde. Dieses Paket zeichnete sich dadurch aus, dass wir die standardmäßige Scikit-Learn-Pipeline in Scikit-LLM integrieren konnten.

Worum geht es also in diesem Paket und wie funktioniert es? Lasst uns darauf eingehen.

Scikit-LLM ist ein Python-Paket zur Verbesserung von Textdatenanalyseaufgaben über LLM. Es wurde entwickelt von Beatsbyte um eine Brücke zwischen der Standardbibliothek von Scikit-Learn und der Leistungsfähigkeit des Sprachmodells zu schlagen. Scikit-LLM hat seine API so erstellt, dass sie der SKlearn-Bibliothek ähnelt, sodass wir keine allzu großen Probleme bei der Verwendung haben.

Installation

Um das Paket verwenden zu können, müssen wir es installieren. Dazu können Sie den folgenden Code verwenden.

pip install scikit-llm

Zum Zeitpunkt der Erstellung dieses Artikels war Scikit-LLM nur mit einigen der OpenAI- und GPT4ALL-Modelle kompatibel. Deshalb würden wir nur mit dem OpenAI-Modell arbeiten. Sie können jedoch das GPT4ALL-Modell verwenden, indem Sie die Komponente zunächst installieren.

pip install scikit-llm[gpt4all]

Nach der Installation müssen Sie den OpenAI-Schlüssel einrichten, um auf die LLM-Modelle zugreifen zu können.

from skllm.config import SKLLMConfig

SKLLMConfig.set_openai_key("")
SKLLMConfig.set_openai_org("")

Scikit-LLM ausprobieren

Probieren wir einige Scikit-LLM-Funktionen mit der festgelegten Umgebung aus. Eine Fähigkeit von LLMs besteht darin, eine Textklassifizierung ohne Umschulung durchzuführen, was wir Zero-Shot nennen. Allerdings würden wir zunächst eine Few-Shot-Textklassifizierung mit den Beispieldaten versuchen.

from skllm import ZeroShotGPTClassifier
from skllm.datasets import get_classification_dataset


#label: Positive, Neutral, Negative
X, y = get_classification_dataset()


#Initiate the model with GPT-3.5
clf = ZeroShotGPTClassifier(openai_model="gpt-3.5-turbo")
clf.fit(X, y)
labels = clf.predict(X)

Sie müssen lediglich die Textdaten innerhalb der X-Variablen und die Beschriftung y im Datensatz angeben. In diesem Fall besteht die Bezeichnung aus der Stimmung, die positiv, neutral oder negativ ist.

Wie Sie sehen, ähnelt der Vorgang der Verwendung der Anpassungsmethode im Scikit-Learn-Paket. Wir wissen jedoch bereits, dass Zero-Shot nicht unbedingt einen Datensatz für das Training benötigte. Deshalb können wir die Labels ohne die Trainingsdaten bereitstellen.

X, _ = get_classification_dataset()

clf = ZeroShotGPTClassifier()
clf.fit(None, ["positive", "negative", "neutral"])
labels = clf.predict(X)

Dies könnte auch auf die Multilabel-Klassifizierungsfälle ausgeweitet werden, was Sie im folgenden Code sehen können.

from skllm import MultiLabelZeroShotGPTClassifier
from skllm.datasets import get_multilabel_classification_dataset
X, _ = get_multilabel_classification_dataset()
candidate_labels = [
    "Quality",
    "Price",
    "Delivery",
    "Service",
    "Product Variety",
    "Customer Support",
    "Packaging",,
]
clf = MultiLabelZeroShotGPTClassifier(max_labels=4)
clf.fit(None, [candidate_labels])
labels = clf.predict(X)

Das Erstaunliche an Scikit-LLM ist, dass es dem Benutzer ermöglicht, die Leistungsfähigkeit von LLM auf die typische Scikit-Learn-Pipeline auszudehnen.

Scikit-LLM in der ML-Pipeline

Im nächsten Beispiel werde ich zeigen, wie wir Scikit-LLM als Vektorisierer initiieren und XGBoost als Modellklassifikator verwenden können. Wir würden die Schritte auch in die Modellpipeline einbinden.

Zuerst laden wir die Daten und veranlassen den Etikettencodierer, die Etikettendaten in einen numerischen Wert umzuwandeln.

from sklearn.preprocessing import LabelEncoder

X, y = get_classification_dataset()

le = LabelEncoder()
y_train_enc = le.fit_transform(y_train)
y_test_enc = le.transform(y_test)

Als Nächstes würden wir eine Pipeline definieren, um die Vektorisierung und Modellanpassung durchzuführen. Das können wir mit dem folgenden Code machen.

from sklearn.pipeline import Pipeline
from xgboost import XGBClassifier
from skllm.preprocessing import GPTVectorizer

steps = [("GPT", GPTVectorizer()), ("Clf", XGBClassifier())]
clf = Pipeline(steps)

#Fitting the dataset
clf.fit(X_train, y_train_enc)

Zuletzt können wir eine Vorhersage mit dem folgenden Code durchführen.

pred_enc = clf.predict(X_test)
preds = le.inverse_transform(pred_enc)

Wie wir sehen können, können wir Scikit-LLM und XGBoost unter der Scikit-Learn-Pipeline verwenden. Die Kombination aller notwendigen Pakete würde unsere Vorhersage noch stärker machen.

Es gibt noch verschiedene Aufgaben, die Sie mit Scikit-LLM erledigen können, einschließlich der Feinabstimmung des Modells. Ich empfehle Ihnen, die Dokumentation zu lesen, um weitere Informationen zu erhalten. Sie können auch das Open-Source-Modell von verwenden GPT4ALL Falls benötigt.

Scikit-LLM ist ein Python-Paket, das Scikit-Learn-Textdatenanalyseaufgaben mit LLM ermöglicht. In diesem Artikel haben wir besprochen, wie wir Scikit-LLM zur Textklassifizierung verwenden und diese in die Pipeline für maschinelles Lernen integrieren.

Cornellius Yudha Wijaya ist Data Science Assistant Manager und Data Writer. Während er Vollzeit bei Allianz Indonesien arbeitet, liebt er es, Python- und Datentipps über soziale Medien zu teilen und Medien zu schreiben.