Integra facilmente i LLM nel tuo flusso di lavoro Scikit-learn con Scikit-LLM - KDnuggets

Ripubblicato da Platone

Seguaci: 0

Integra facilmente i LLM nel tuo flusso di lavoro Scikit-learn con Scikit-LLM
Immagine generata da DALL-E 2

Le attività di analisi del testo esistono da qualche tempo poiché le esigenze sono sempre presenti. La ricerca ha fatto molta strada, dalle semplici statistiche descrittive alla classificazione del testo e alla generazione avanzata di testo. Con l'aggiunta del Large Language Model nel nostro arsenale, le nostre attività lavorative diventano ancora più accessibili.

Scikit-LLM è un pacchetto Python sviluppato per attività di analisi del testo con la potenza di LLM. Questo pacchetto si è distinto perché abbiamo potuto integrare la pipeline Scikit-Learn standard con Scikit-LLM.

Allora, in cosa consiste questo pacchetto e come funziona? Entriamo nel merito.

Scikit-LLM è un pacchetto Python per migliorare le attività di analisi dei dati di testo tramite LLM. È stato sviluppato da Beatsbyte per contribuire a collegare la libreria standard Scikit-Learn e la potenza del modello linguistico. Scikit-LLM ha creato la sua API per essere simile alla libreria SKlearn, quindi non abbiamo troppi problemi ad usarla.

Installazione

Per utilizzare il pacchetto, dobbiamo installarli. Per fare ciò, puoi utilizzare il seguente codice.

pip install scikit-llm

Al momento della stesura di questo articolo, Scikit-LLM è compatibile solo con alcuni modelli OpenAI e GPT4ALL. Ecco perché lavoreremo solo con il modello OpenAI. Tuttavia è possibile utilizzare il modello GPT4ALL installando inizialmente il componente.

pip install scikit-llm[gpt4all]

Dopo l'installazione è necessario configurare la chiave OpenAI per accedere ai modelli LLM.

from skllm.config import SKLLMConfig

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

Provando Scikit-LLM

Proviamo alcune funzionalità di Scikit-LLM con l'ambiente impostato. Una capacità degli LLM è quella di eseguire la classificazione del testo senza riqualificazione, che chiamiamo Zero-Shot. Tuttavia, inizialmente proveremmo una classificazione del testo Few-Shot con i dati campione.

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)

Devi solo fornire i dati di testo all'interno della variabile X e l'etichetta y nel set di dati. In questo caso, l'etichetta è costituita dal sentimento, che è Positivo, Neutro o Negativo.

Come puoi vedere, il processo è simile all'utilizzo del metodo di adattamento nel pacchetto Scikit-Learn. Tuttavia, sappiamo già che Zero-Shot non richiedeva necessariamente un set di dati per l’addestramento. Ecco perché possiamo fornire le etichette senza i dati di addestramento.

X, _ = get_classification_dataset()

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

Questo potrebbe essere esteso anche nei casi di classificazione multilabel, che potete vedere nel codice seguente.

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)

La cosa sorprendente di Scikit-LLM è che consente all'utente di estendere la potenza di LLM alla tipica pipeline Scikit-Learn.

Scikit-LLM nella pipeline ML

Nel prossimo esempio, mostrerò come avviare Scikit-LLM come vettorizzatore e utilizzare XGBoost come classificatore del modello. Avremmo anche inserito i passaggi nella pipeline del modello.

Per prima cosa caricheremo i dati e avvieremo il codificatore dell'etichetta per trasformare i dati dell'etichetta in un valore numerico.

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)

Successivamente, definiremo una pipeline per eseguire la vettorizzazione e l'adattamento del modello. Possiamo farlo con il seguente codice.

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)

Infine, possiamo eseguire la previsione con il seguente codice.

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

Come possiamo vedere, possiamo utilizzare Scikit-LLM e XGBoost sotto la pipeline Scikit-Learn. La combinazione di tutti i pacchetti necessari renderebbe la nostra previsione ancora più forte.

Ci sono ancora varie attività che puoi svolgere con Scikit-LLM, inclusa la messa a punto del modello, che ti suggerisco di controllare la documentazione per saperne di più. Puoi anche utilizzare il modello open source da GPT4ALL se necessario.

Scikit-LLM è un pacchetto Python che potenzia le attività di analisi dei dati di testo Scikit-Learn con LLM. In questo articolo, abbiamo discusso di come utilizzare Scikit-LLM per la classificazione del testo e di combinarli nella pipeline di apprendimento automatico.

Cornellio Yudha Wijaya è un assistente manager di data science e scrittore di dati. Mentre lavora a tempo pieno presso Allianz Indonesia, ama condividere suggerimenti su Python e dati tramite social media e mezzi di scrittura.