Integrer nemt LLM'er i dit Scikit-learn-workflow med Scikit-LLM - KDnuggets

Genudgivet af Platon

Abonnenter: 0

Integrer nemt LLM'er i dit Scikit-learn-workflow med Scikit-LLM
Billede genereret af DALL-E 2

Tekstanalyseopgaver har eksisteret i nogen tid, da behovene altid er der. Forskningen er nået langt, fra simpel beskrivelsesstatistik til tekstklassificering og avanceret tekstgenerering. Med tilføjelsen af den store sprogmodel i vores arsenal bliver vores arbejdsopgaver endnu mere tilgængelige.

Scikit-LLM er en Python-pakke udviklet til tekstanalyseaktivitet med kraften fra LLM. Denne pakke skilte sig ud, fordi vi kunne integrere standard Scikit-Learn pipeline med Scikit-LLM.

Så hvad handler denne pakke om, og hvordan fungerer den? Lad os komme ind i det.

Scikit-LLM er en Python-pakke til at forbedre tekstdataanalytiske opgaver via LLM. Den er udviklet af Beatsbyte at hjælpe med at bygge bro mellem standard Scikit-Learn-biblioteket og sprogmodellens kraft. Scikit-LLM oprettede sin API til at ligne SKlearn-biblioteket, så vi har ikke for mange problemer med at bruge det.

Installation

For at bruge pakken skal vi installere dem. For at gøre det kan du bruge følgende kode.

pip install scikit-llm

På det tidspunkt, hvor denne artikel blev skrevet, er Scikit-LLM kun kompatibel med nogle af OpenAI- og GPT4ALL-modellerne. Derfor ville vi kun arbejde med OpenAI-modellen. Du kan dog bruge GPT4ALL-modellen ved først at installere komponenten.

pip install scikit-llm[gpt4all]

Efter installationen skal du konfigurere OpenAI-nøglen for at få adgang til LLM-modellerne.

from skllm.config import SKLLMConfig

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

Prøver Scikit-LLM

Lad os prøve nogle Scikit-LLM-funktioner med miljøsættet. En evne, som LLM'er har, er at udføre tekstklassificering uden genoptræning, som vi kalder Zero-Shot. Vi ville dog i første omgang prøve en Few-Shot-tekstklassificering med eksempeldataene.

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)

Du behøver kun at angive tekstdataene i X-variablen og etiketten y i datasættet. I dette tilfælde består etiketten af følelsen, som er positiv, neutral eller negativ.

Som du kan se, ligner processen at bruge tilpasningsmetoden i Scikit-Learn-pakken. Vi ved dog allerede, at Zero-Shot ikke nødvendigvis krævede et datasæt til træning. Det er derfor, vi kan levere etiketterne uden træningsdata.

X, _ = get_classification_dataset()

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

Dette kan også udvides i multilabel-klassificeringssager, som du kan se i følgende kode.

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)

Det fantastiske ved Scikit-LLM er, at det giver brugeren mulighed for at udvide kraften i LLM til den typiske Scikit-Learn pipeline.

Scikit-LLM i ML Pipeline

I det næste eksempel vil jeg vise, hvordan vi kan initiere Scikit-LLM som en vectorizer og bruge XGBoost som modelklassifikator. Vi ville også pakke trinene ind i modelpipeline.

Først ville vi indlæse dataene og starte etiketkoderen for at transformere etiketdataene til en numerisk værdi.

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)

Dernæst ville vi definere en pipeline til at udføre vektorisering og modeltilpasning. Det kan vi gøre med følgende kode.

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)

Til sidst kan vi udføre forudsigelse med følgende kode.

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

Som vi kan se, kan vi bruge Scikit-LLM og XGBoost under Scikit-Learn pipeline. At kombinere alle de nødvendige pakker ville gøre vores forudsigelse endnu stærkere.

Der er stadig forskellige opgaver, du kan udføre med Scikit-LLM, herunder model finjustering, som jeg foreslår, at du tjekker dokumentationen for at lære yderligere. Du kan også bruge open source-modellen fra GPT4ALL Hvis det er nødvendigt.

Scikit-LLM er en Python-pakke, der giver Scikit-Learn tekstdataanalyseopgaver med LLM. I denne artikel har vi diskuteret, hvordan vi bruger Scikit-LLM til tekstklassificering og kombinerer dem i maskinlæringspipeline.

Cornellius Yudha Wijaya er en data science assisterende leder og dataskribent. Mens han arbejder på fuld tid hos Allianz Indonesia, elsker han at dele Python- og Data-tips via sociale medier og skrivemedier.