Afbeelding gegenereerd door DALL-E 2
 

Tekstanalysetaken bestaan ​​al een tijdje omdat de behoeften er altijd zijn. Onderzoek heeft een lange weg afgelegd, van eenvoudige beschrijvingsstatistieken tot tekstclassificatie en geavanceerde tekstgeneratie. Met de toevoeging van het Grote Taalmodel aan ons arsenaal worden onze werktaken nog toegankelijker.

De Scikit-LLM is een Python-pakket ontwikkeld voor tekstanalyseactiviteiten met de kracht van LLM. Dit pakket viel op omdat we de standaard Scikit-Learn pipeline konden integreren met de Scikit-LLM.

Waar gaat dit pakket over en hoe werkt het? Laten we erop ingaan.

Scikit-LLM is een Python-pakket om analytische taken voor tekstgegevens via LLM te verbeteren. Het is ontwikkeld door Beatsbyte om een ​​brug te slaan tussen de standaard Scikit-Learn-bibliotheek en de kracht van het taalmodel. Scikit-LLM heeft zijn API zo gemaakt dat deze vergelijkbaar is met de SKlearn-bibliotheek, dus we hebben niet al te veel problemen met het gebruik ervan.

Installatie

Om het pakket te gebruiken, moeten we ze installeren. Om dat te doen, kunt u de volgende code gebruiken.

pip install scikit-llm

Op het moment dat dit artikel werd geschreven, is Scikit-LLM alleen compatibel met enkele OpenAI- en GPT4ALL-modellen. Daarom zouden wij alleen met het OpenAI-model gaan werken. U kunt echter het GPT4ALL-model gebruiken door de component in eerste instantie te installeren.

pip install scikit-llm[gpt4all]

Na de installatie moet u de OpenAI-sleutel instellen om toegang te krijgen tot de LLM-modellen.

from skllm.config import SKLLMConfig

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

Scikit-LLM uitproberen

Laten we enkele Scikit-LLM-mogelijkheden uitproberen met de ingestelde omgeving. Eén mogelijkheid die LLM's hebben, is het uitvoeren van tekstclassificatie zonder herscholing, wat we Zero-Shot noemen. We zouden echter in eerste instantie een Few-Shot-tekstclassificatie proberen met de voorbeeldgegevens.

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)

U hoeft alleen de tekstgegevens in de X-variabele en het label y in de gegevensset op te geven. In dit geval bestaat het label uit het sentiment, dat Positief, Neutraal of Negatief is. 

Zoals u kunt zien, is het proces vergelijkbaar met het gebruik van de aanpasmethode in het Scikit-Learn-pakket. We weten echter al dat Zero-Shot niet noodzakelijkerwijs een dataset nodig had voor training. Daarom kunnen wij de labels leveren zonder de trainingsgegevens.

X, _ = get_classification_dataset()

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

Dit kan ook worden uitgebreid in de gevallen van multilabel-classificatie, die u in de volgende code kunt zien.

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)

Het verbazingwekkende aan de Scikit-LLM is dat de gebruiker de kracht van LLM kan uitbreiden naar de typische Scikit-Learn-pijplijn. 

Scikit-LLM in de ML-pijplijn

In het volgende voorbeeld zal ik laten zien hoe we de Scikit-LLM als vectorizer kunnen initiëren en XGBoost als modelclassificator kunnen gebruiken. We zouden de stappen ook in de modelpijplijn verwerken.

Eerst zouden we de gegevens laden en de label-encoder starten om de labelgegevens om te zetten in een numerieke waarde.

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)

Vervolgens zouden we een pijplijn definiëren om vectorisatie en modelaanpassing uit te voeren. Dat kunnen we doen met de volgende code.

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)

Ten slotte kunnen we voorspellingen uitvoeren met de volgende code.

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

Zoals we kunnen zien, kunnen we de Scikit-LLM en XGBoost gebruiken onder de Scikit-Learn-pijplijn. Het combineren van alle benodigde pakketten zou onze voorspelling nog sterker maken.

Er zijn nog steeds verschillende taken die u kunt uitvoeren met Scikit-LLM, inclusief het afstemmen van modellen. Ik raad u aan de documentatie te raadplegen voor meer informatie. U kunt ook het open-sourcemodel van gebruiken GPT4ALL indien nodig.

Scikit-LLM is een Python-pakket dat Scikit-Learn tekstgegevensanalysetaken met LLM mogelijk maakt. In dit artikel hebben we besproken hoe we Scikit-LLM gebruiken voor tekstclassificatie en deze combineren in de machine learning-pijplijn.
 
 

Cornellius Yudha Wijaya is een data science assistent-manager en dataschrijver. Terwijl hij fulltime bij Allianz Indonesia werkt, deelt hij graag Python- en Data-tips via sociale media en schrijvende media.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• PlatoData.Network Verticale generatieve AI. Versterk jezelf. Toegang hier.
• PlatoAiStream. Web3-intelligentie. Kennis versterkt. Toegang hier.
• PlatoESG. carbon, CleanTech, Energie, Milieu, Zonne, Afvalbeheer. Toegang hier.
• Plato Gezondheid. Intelligentie op het gebied van biotech en klinische proeven. Toegang hier.
• Bron: https://www.kdnuggets.com/easily-integrate-llms-into-your-scikit-learn-workflow-with-scikit-llm?utm_source=rss&utm_medium=rss&utm_campaign=easily-integrate-llms-into-your-scikit-learn-workflow-with-scikit-llm