Integrasikan LLM dengan Mudah ke Workflow Scikit-learn Anda dengan Scikit-LLM

Analisis teks telah ada selama beberapa waktu karena kebutuhannya selalu ada. Penelitian telah berkembang jauh, dari statistik deskripsi sederhana hingga klasifikasi teks dan generasi teks yang canggih. Dengan penambahan Large Language Model dalam perangkat kita, pekerjaan kita menjadi lebih mudah.

Scikit-LLM adalah paket Python yang dikembangkan untuk aktivitas analisis teks dengan kekuatan LLM. Paket ini popular karena kita dapat mengintegrasikan pipeline standar Scikit-Learn dengan Scikit-LLM.

Jadi, apa paket ini dan bagaimana cara kerjanya? Mari kita bahas lebih lanjut.

Scikit-LLM

Scikit-LLM adalah paket Python untuk meningkatkan tugas analisis data teks melalui LLM. Scikit-LLM dikembangkan oleh Beatsbyte untuk membantu menjembatani library standar Scikit-Learn dan kemampuan language model. Scikit-LLM membuat API-nya mirip dengan library SKlearn, jadi kita tidak akan kesulitan menggunakannya.

Instalasi

Untuk menggunakan paket ini, kita perlu menginstalnya. Untuk melakukannya, Anda dapat menggunakan kode berikut.

pip install scikit-llm

Pada saat artikel ini ditulis, Scikit-LLM hanya kompatibel dengan beberapa Model OpenAI dan GPT4ALL. Itu sebabnya kita hanya akan bekerja dengan model OpenAI. Namun, Anda dapat menggunakan model GPT4ALL dengan menginstal komponen tersebut terlebih dahulu.

pip install scikit-llm[gpt4all]

Setelah instalasi, Anda harus menyiapkan OpenAI Key untuk mengakses model LLM.

from skllm.config import SKLLMConfig

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

Mencoba Scikit-LLM

Mari kita coba beberapa kemampuan Scikit-LLM dengan lingkungan yang sudah diatur. Salah satu kemampuan LLM adalah melakukan klasifikasi teks tanpa pelatihan ulang, yang kita sebut Zero-Shot. Namun, kita akan mencoba klasifikasi teks Few-Shot dengan data sampel.

from skllm import ZeroShotGPTClassifier
from skllm.datasets import get_classification_dataset


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


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

Anda hanya perlu menyediakan data teks di dalam variabel X dan label y dalam dataset. Dalam hal ini, label terdiri dari sentimen, yaitu Positive, Neutral, atau Negative.

Seperti yang Anda lihat, prosesnya mirip dengan menggunakan metode fitting dalam paket Scikit-Learn. Namun, kita sudah tahu bahwa Zero-Shot tidak selalu membutuhkan dataset untuk training. Itu sebabnya kita dapat memberikan label tanpa data training.

X, _ = get_classification_dataset()

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

Ini juga dapat diperluas dalam kasus klasifikasi multilabel, yang dapat Anda lihat pada kode berikut.

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)

Yang menakjubkan dari Scikit-LLM adalah ia memungkinkan pengguna untuk memperluas kekuatan LLM ke pipeline Scikit-Learn yang biasanya.

Scikit-LLM dalam Pipeline ML

Pada contoh selanjutnya, saya akan menunjukkan bagaimana kita dapat menginisiasi Scikit-LLM sebagai vectorizer dan menggunakan XGBoost sebagai model classifier. Kita juga akan membungkus langkah-langkah tersebut ke dalam pipeline model.

Pertama, kita akan memuat data dan memulai encoder label untuk mengubah data label menjadi nilai numerik.

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)

Selanjutnya, kita akan menentukan pipeline untuk melakukan vectorization dan fitting model. Kita bisa melakukannya dengan kode berikut.

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)

Terakhir, kita bisa melakukan prediksi dengan kode berikut.

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

Seperti yang kita lihat, kita dapat menggunakan Scikit-LLM dan XGBoost di pipeline Scikit-Learn. Menggabungkan semua paket yang diperlukan akan membuat prediksi kita lebih kuat.

Masih banyak lagi tugas yang dapat Anda lakukan dengan Scikit-LLM, termasuk fine-tuning model, saya sarankan Anda periksa dokumentasinya untuk mempelajarinya lebih lanjut. Anda juga dapat menggunakan model open-source dari GPT4ALL jika diperlukan.

Kesimpulan

Scikit-LLM adalah paket Python yang memberdayakan tugas analisis data teks Scikit-Learn dengan LLM. Dalam artikel ini, kita telah membahas bagaimana kita menggunakan Scikit-LLM untuk klasifikasi teks dan menggabungkannya ke dalam pipeline machine learning.