Integrer LLM-er enkelt i din Scikit-læringsarbeidsflyt med Scikit-LLM - KDnuggets

Publisert av Platon

Følgere: 0

Integrer enkelt LLM-er i din Scikit-læringsarbeidsflyt med Scikit-LLM
Bilde generert av DALL-E 2

Tekstanalyseoppgaver har eksistert en stund siden behovene alltid er der. Forskning har kommet langt, fra enkel beskrivelsesstatistikk til tekstklassifisering og avansert tekstgenerering. Med tillegg av den store språkmodellen i vårt arsenal, blir arbeidsoppgavene våre enda mer tilgjengelige.

Scikit-LLM er en Python-pakke utviklet for tekstanalyseaktivitet med kraften til LLM. Denne pakken skilte seg ut fordi vi kunne integrere standard Scikit-Learn pipeline med Scikit-LLM.

Så, hva handler denne pakken om, og hvordan fungerer den? La oss gå inn i det.

Scikit-LLM er en Python-pakke for å forbedre tekstdataanalytiske oppgaver via LLM. Den ble utviklet av Beatsbyte å bidra til å bygge bro over standard Scikit-Learn-biblioteket og kraften i språkmodellen. Scikit-LLM opprettet sin API for å være lik SKlearn-biblioteket, så vi har ikke for mye problemer med å bruke den.

Installasjon

For å bruke pakken må vi installere dem. For å gjøre det kan du bruke følgende kode.

pip install scikit-llm

Fra det tidspunktet denne artikkelen ble skrevet, er Scikit-LLM bare kompatibel med noen av OpenAI- og GPT4ALL-modellene. Derfor vil vi bare jobbe med OpenAI-modellen. Du kan imidlertid bruke GPT4ALL-modellen ved å installere komponenten først.

pip install scikit-llm[gpt4all]

Etter installasjonen må du sette opp OpenAI-nøkkelen for å få tilgang til LLM-modellene.

from skllm.config import SKLLMConfig

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

Prøver Scikit-LLM

La oss prøve ut noen Scikit-LLM-funksjoner med miljøsettet. En evne som LLM-er har er å utføre tekstklassifisering uten omskolering, som vi kaller Zero-Shot. Imidlertid ville vi i utgangspunktet prøve en Few-Shot-tekstklassifisering 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 trenger bare å oppgi tekstdataene i X-variabelen og etiketten y i datasettet. I dette tilfellet består etiketten av følelsen, som er positiv, nøytral eller negativ.

Som du kan se, ligner prosessen på å bruke tilpasningsmetoden i Scikit-Learn-pakken. Imidlertid vet vi allerede at Zero-Shot ikke nødvendigvis krevde et datasett for trening. Det er derfor vi kan levere etikettene uten opplæringsdataene.

X, _ = get_classification_dataset()

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

Dette kan også utvides i multilabel-klassifiseringstilfellene, 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 som er utrolig med Scikit-LLM er at den lar brukeren utvide kraften til LLM til den typiske Scikit-Learn-pipelinen.

Scikit-LLM i ML Pipeline

I neste eksempel vil jeg vise hvordan vi kan initiere Scikit-LLM som en vektorisering og bruke XGBoost som modellklassifiserer. Vi ville også pakke trinnene inn i modellrørledningen.

Først ville vi laste inn dataene og starte etikettkoderen for å transformere etikettdataene til en numerisk verdi.

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)

Deretter vil vi definere en rørledning for å utføre vektorisering og modelltilpasning. Vi kan gjøre det 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 slutt kan vi utføre prediksjon med følgende kode.

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

Som vi kan se, kan vi bruke Scikit-LLM og XGBoost under Scikit-Learn pipeline. Å kombinere alle de nødvendige pakkene vil gjøre spådommen vår enda sterkere.

Det er fortsatt forskjellige oppgaver du kan gjøre med Scikit-LLM, inkludert modellfinjustering, som jeg foreslår at du sjekker dokumentasjonen for å lære mer. Du kan også bruke åpen kildekode-modellen fra GPT4ALL hvis nødvendig.

Scikit-LLM er en Python-pakke som gir Scikit-Learn tekstdataanalyseoppgaver med LLM. I denne artikkelen har vi diskutert hvordan vi bruker Scikit-LLM for tekstklassifisering og kombinerer dem i maskinlæringspipeline.

Cornellius Yudha Wijaya er assistentleder for datavitenskap og dataskribent. Mens han jobber på heltid i Allianz Indonesia, elsker han å dele Python- og Data-tips via sosiale medier og skrivemedier.