LLM Dapat Melakukan Tugas Pemodelan Regresi

Large Language Model atau LLM adalah model yang dapat memproses dan menghasilkan teks seperti manusia berdasarkan data yang telah dilatihnya.

LLM telah dilatih secara ekstensif untuk melakukan tugas-tugas berbasis teks seperti menjawab pertanyaan, merangkum, hingga membuat kode. Model ini secara khusus dikembangkan untuk membantu pengguna dalam pekerjaan terkait bahasa.

Beberapa eksperimen memanfaatkan LLM layaknya model klasik, seperti klasifikasi. Misalnya, kasus penggunaan klasifikasi teks sudah familiar dengan LLM.

Tidak banyak kasus penggunaan LLM dengan data tabular. Namun, menggunakan LLM untuk tugas pemodelan data tabular tetap memungkinkan.

Baru-baru ini, ada pendekatan eksperimental baru untuk menerapkan LLM untuk tugas Regresi. Pendekatan ini menunjukkan hasil yang luar biasa dan berpotensi menjadi game changer.

Bagaimana cara kerjanya? Mari kita bahas.

LLM untuk Tugas Regresi

Dalam bidang machine learning, Regresi adalah tugas untuk memprediksi nilai numerik tak terbatas dari input yang diberikan. Sebaliknya, tugas klasifikasi hanya mencoba memprediksi dari nilai-nilai terbatas.

Tugas regresi secara tradisional dilakukan menggunakan model klasik seperti linear regression dalam data tabular. Namun, penelitian oleh Vacareanu et al. (2024) menunjukkan bahwa LLM dapat melakukan tugas regresi dengan konteks Few-Shot example.

Eksperimen mereka menunjukkan bahwa Mean Absolute Error dari model LLM dapat menyamai atau bahkan lebih baik dari beberapa model tradisional. Anda dapat melihat hasilnya pada gambar di bawah ini.

Perbandingan MAE (Vacareanu et al. (2024))

Para peneliti juga bereksperimen dengan beberapa perbandingan model dalam tiga dataset yang berbeda.

Performa large language models (LLM), supervised models and unsupervised models (Vacareanu et al. (2024))

Hasil di atas mengungkapkan bahwa model LLM, baik yang closed-source (Claude 3, GPT-4) maupun open-source (DBRX, Mixtral 8x7B), dapat melakukan tugas linear regression menggunakan in-context learning.

Sekarang, bagaimana cara kita melakukan linear regression dengan LLM? Mari kita bahas di bagian berikutnya.

Praktik Langsung LLM untuk Regresi

Dalam contoh ini, kita akan menggunakan dataset Boston House price dataset dari Kaggle. Mari kita muat dataset tersebut ke dalam Pandas DataFrame dan periksa datanya.

import pandas as pd

df = pd.read_csv('boston.csv')
df.head()

Setiap kolom berupa fitur numerik, memiliki 13 input dan 1 output (MEDV). Dalam hal ini, kita akan mengubah fitur input sebagai contoh untuk LLM untuk memprediksi nilai MEDV.

Kita tidak akan menggunakan setiap dataset untuk prediksi dan akan membaginya untuk kenyamanan.

x = df.drop(['MEDV'], axis=1)
y = df['MEDV']

# Bulatkan nilai menjadi 2 angka dibelakang koma untuk menjaga biaya tetap rendah. Tidak wajib
x = np.round(x, 2)
y = np.round(y, 2)

# Pembagian data
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=1, random_state=1)

# Hanya pilih 1 data test sebagai contoh
x_train = x_train.iloc[:50]
y_train = y_train.iloc[:50]
x_test  = x_test.iloc[:1]
y_test  = y_test.iloc[:1]

Datasetnya sekarang sudah siap. Langkah berikutnya yang akan kita lakukan adalah mengatur prompt untuk menerima fitur dalam bentuk teks. Kita akan menggunakan OpenAI sebagai model LLM dan LangChain sebagai framework.

Jika Anda belum menginstalnya, Anda dapat melakukannya dengan kode berikut.

pip install openai langchain

Kita kemudian akan memulai LLM (GPT-4) dengan kode berikut. Jangan lupa untuk mendapatkan API key OpenAI Anda.

import os

os.environ['OPENAI_API_KEY'] = 'sk-your-api-key'

from langchain.chat_models import ChatOpenAI
llm = ChatOpenAI(model_name="gpt-4-0125-preview", temperature=0)

Hati-hati, karena menggunakan GPT-4 bisa jadi mahal. Anda dapat mengganti model LLM dari daftar yang tersedia.

Selanjutnya, kita akan mengatur template prompt Few-Shot. Karena in-context learning berarti kita memerlukan beberapa contoh agar LLM dapat mempelajari polanya, kita akan menetapkan data training ke dalam bentuk template. Kita bisa melakukannya dengan kode berikut.

from langchain import PromptTemplate, FewShotPromptTemplate
suffix = [feature + ": {" + f"{feature}" + "}" for feature in x_train.columns] + [y_train.name + ":"]
suffix = "\n".join(suffix)

input_variables=x_train.columns.to_list()

Jika Anda memeriksa variabel suffix, itu akan berisi string seperti gambar berikut.

Kemudian, kita akan mengatur template prompt Few-Shot dengan kode ini.

fspt = FewShotPromptTemplate(
    examples        =  [{**x1, y_train.name: x2} for x1, x2 in zip(x_train.to_dict('records'), y_train)],
    example_prompt  =  example_prompt,
    suffix          =  suffix,
    input_variables = input_variables,
)

prefix_instruction = 'The task is to provide your best estimate for "Output". Please provide that and only that, without any additional text.\n\n\n\n\n'

Jika Anda memeriksa contoh yang diberikan, akan terlihat seperti ini:

Setiap bagian data akan ditugaskan ke template prompt sebagai string. Kemudian, secara individual, mereka akan menjadi contoh petunjuk untuk LLM. Kita juga memberikan instruksi tambahan pada prefix, sehingga hasilnya hanya berupa nilai numerik tanpa penjelasan.

Jika semuanya sudah siap, kita bisa melakukan prediksi regresi dengan LLM. Anda dapat membuat prediksi individual dengan kode berikut.

predicted = llm.call_as_llm(prefix_instruction + fspt.format(**x_test.to_dict('records')[0]))
price      = y_test.iloc[0].item()

print(f"GPT-4 predicted: {predicted}")
print(f"The price is: {price}")

GPT-4 predicted: 28.4

The price is: 28.2

Hasil di atas adalah contoh hasil pengujian saya. Tergantung pada pembagian Anda, hasilnya mungkin berbeda. Namun, LLM terbukti dapat melakukan tugas regresi.

Kita dapat menginstruksikan mereka untuk bertindak sebagai model regresi menggunakan template prompt Few-Shot dan LLM. Berhati-hatilah dengan biayanya; bisa jadi mahal jika Anda menggunakan ukuran token yang besar.