Eksplorasi dan Pemodelan Data Tabular dengan LLMs

Model Bahasa Besar telah meningkat belakangan ini dan akan terus seperti itu di tahun yang akan datang. Peningkatan tersebut dapat dianggap sebagai produk dari kegunaan LLM dalam menyelesaikan banyak masalah.

Mulai dari menjawab masalah kita hingga mengembangkan aplikasi, LLM dapat membantu kita semua. Namun, Anda mungkin perlu belajar bahwa LLM dapat diterapkan pada data tabular.

Data tabular adalah data dalam tabel tipikal — beberapa kolom dan baris yang terstruktur dengan baik, seperti di Excel atau data SQL. Ini adalah penggunaan data paling umum dalam banyak kasus penggunaan data.

Dengan kekuatan LLM, kita akan belajar bagaimana menjelajahi data dan melakukan pemodelan data. Bagaimana caranya? Mari kita pelajari lebih dalam.

EDA dengan LLM

Pandas adalah salah satu Paket Python paling terkemuka untuk eksplorasi dan manipulasi data. Setiap profesional data yang belajar Python akan menemukan Pandas selama pekerjaan mereka. Itulah mengapa kita akan belajar tentang paket Python yang menyatukan LLM dengan Pandas — PandasAI.

PandasAI akan menggunakan kekuatan LLM untuk membantu kita menjelajahi dan membersihkan data. Itu akan menjadi alat percakapan yang bisa kita gunakan untuk meminta Pandas memanipulasi data sesuai keinginan kita.

Untuk menggunakan PandasAI, kita perlu menginstal paketnya.

pip install pandasai 

Yang menarik tentang PandasAI adalah bagaimana itu dapat menggunakan berbagai LLM yang tersedia untuk membantu kita menjelajahi data. Namun, artikel ini akan menggunakan API OpenAI sebagai LLM yang akan kita gunakan.

Kita juga akan bereksperimen dengan menggunakan Notebook sehingga artikel ini akan mengasumsikan pekerjaan dalam lingkungan tersebut.

Selain itu, kita akan menggunakan dataset Churn dari Kaggle sebagai contoh ini.

import pandas as pd 
df = pd.read_csv('telecom_churn.csv') df.head()

Dengan semuanya siap, kita akan menggunakan LLM untuk menjelajahi data. Pertama, kita akan memilih model LLM untuk PandasAI.

from pandasai.llm import OpenAI
llm = OpenAI(api_token="Kunci API OpenAI Anda") 

Kemudian, kita akan mengubah DataFrame Pandas kita menjadi objek SmartDataFrame yang dapat menerima input percakapan.

from pandasai import SmartDataframe
df = SmartDataframe(df, config = {'llm': llm})

Dengan pengaturan siap, kita dapat menjelajahi data kita dengan PandasAI. Hal ini dapat dilakukan dengan mudah karena kita hanya perlu memasukkan percakapan kita ke dalam dataframe.

Sebagai contoh, saya meminta statistik terperinci dari dataset.

response = df.chat("""Can you provide me the detailed statistic of this dataset""")

response

Itu akan menjalankan fungsi Pandas untuk membawa statistik dasar dari data. Mari kita coba proses lain. Sebagai contoh, saya ingin mendapatkan korelasi churn terhadap semua fitur lain.

response = df.chat("""Can you provide me the feature correlation to the churn column and make the heatmap visualization""") 

response

Dengan PandasAI, hasilnya ditampilkan segera, dan plot berisi semua informasi yang sesuai.

Terakhir, mari kita coba fitur lanjutan dari PandasAI. Salah satu fungsi siap pakai dari PandasAI adalah untuk menghasilkan fitur, yang akan kita coba.

df.generate_features()

Dengan satu baris kode, LLM menilai kolom kita dan membuat kolom baru berdasarkan data yang tersedia. Kita masih perlu memeriksa apakah fitur yang dihasilkan valid, yang akan membantu pekerjaan kita.

Pengembangan Model Tabular dengan LLM

Kita telah belajar bagaimana melakukan eksplorasi data dengan LLM dan PandasAI. Bagian berikutnya memperluas kekuatan LLM untuk tujuan klasifikasi. Karena dataset contoh kita adalah data tabular tentang churn pelanggan, kita ingin membuat model klasifikasi berdasarkan itu.

Sebagai tolak ukur, mari kita kembangkan model churn dengan model Regresi Logistik sederhana. Kita akan melakukannya dengan kode berikut.

from sklearn.model_selection import train_test_split from sklearn.linear_model import LogisticRegression 

df = pd.read_csv('telecom_churn.csv')

X_train, X_test, y_train, y_test = train_test_split(df.drop('Churn', axis =1), df['Churn'], test_size=.2, random_state = 42)

model = LogisticRegression()

Mari kita lihat metrik F1 dari model kita.

from sklearn.metrics import f1_score

print('F1 Score: ', f1_score(y_test, y_pred))

Hasil tolak ukur bisa lebih baik, yang diharapkan. Dengan model Regresi Logistik yang ada, kita akan membandingkannya dengan model LLM jika kita mencoba membuat prediksi.

Untuk kasus ini, kita perlu mengubah data tabular menjadi bentuk yang dapat diterima oleh LLM. Itulah mengapa kode di bawah ini akan berfokus pada mengubah data menjadi teks.

def concatenate_text(x):
    if x['ContractRenewal'] == 1:
      cr = 'have renew the contract'
    else:
      cr = 'never renew the contract'

    if x['DataPlan'] == 1:
      dp = 'have data plan'
    else:
      dp = "doesn't have data plan"

    full_text = (
        f"This customer account is {x['AccountWeeks']} weeks old, ",
        f"{cr}, ",
        f"{dp}, ",
        f"with {x['DataUsage']} GB of Monthly Data Usage, ",
        f"{x['CustServCalls']} times of Customer Service Calls, " ,
        f"{x['DayMins']} minutes total usage average monthly, ",
        f"{x['DayCalls']} times in average of daytime calls, "
        f"{x['MonthlyCharge']} monthly bill average, "
        f"with the largest overage Fee in the last 12 month is {x['OverageFee']}, "
        f"and {x['RoamMins']} minutes in average for roaming"

    )
    return ''.join(full_text)

X_train['label'] = y_train
X_test['label'] = y_test

X_train['text'] = X_train.apply(lambda x: concatenate_text(x), axis=1)
X_test['text'] = X_test.apply(lambda x: concatenate_text(x), axis=1)

Hasil teks untuk setiap baris akan mirip dengan gambar di atas. Anda dapat mengubah perumusan kalimat jika itu lebih baik.

Selanjutnya, kita akan melakukan penyesuaian halus (fine-tune) pada model LLM untuk tujuan klasifikasi teks. Saya akan menggunakan model dasar BERT sebagai model dasar untuk klasifikasi.

Proses fine-tuning mungkin memerlukan beberapa pengaturan lingkungan sehingga kita dapat menginstalnya terlebih dahulu.

!pip install datasets evaluate accelerate transformers[torch]

Jika paket-paket sudah terinstal, kita dapat menggunakan kode berikut untuk melakukan penyesuaian halus pada model kita dengan data kita.

import torch
from transformers import BertTokenizer, BertForSequenceClassification, Trainer, TrainingArguments
from datasets import Dataset
import numpy as np
import evaluate

# label mapping
id2label = {0: "NOT-CHURN", 1: "CHURN"}
label2id = {"NOT-CHURN": 0, "CHURN": 1}

# dataset formatting
train_dataset = Dataset.from_pandas(X_train)
test_dataset = Dataset.from_pandas(X_test)

# Tokenization
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

# Tweak the tokenizer function as you need
def tokenize_fn(examples):
    return tokenizer(examples['text'], padding='max_length', truncation=True, max_length=128)

tokenized_train = train_dataset.map(tokenize_fn, batched=True)
tokenized_test= test_dataset.map(tokenize_fn, batched=True)

tokenized_train_dataset = tokenized_train.map(lambda x: {'labels': x['label']})
tokenized_test_dataset = tokenized_test.map(lambda x: {'labels': x['label']})

Kode di atas akan memulai proses persiapan dataset untuk penyesuaian halus dengan HuggingFace. Dengan dataset yang siap, kita dapat melakukan penyesuaian halus pada model.

# Model with the label mappings
model = BertForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=len(label2id),
    id2label=id2label,
    label2id=label2id
)

# Model with training arguments. Tweaks the parameter as you need
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    evaluation_strategy="epoch"
)

# Evaluation metric. We choose F1
f1 = evaluate.load("f1")

def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=1)
    return f1.compute(predictions=predictions, references=labels)

# Set the trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train_dataset,
    eval_dataset=tokenized_test_dataset,
    compute_metrics=compute_metrics
)

# Train the model
trainer.train()

Hasilnya sedikit lebih baik dibandingkan dengan tolak ukur. Mungkin lebih baik untuk menyesuaikan parameter atau menggunakan model dasar lain. Kami telah mencoba membuat model klasifikasi untuk data tabular berdasarkan model dasar LLM.

Kesimpulan

Kita telah menjelajahi kemungkinan memperluas LLM untuk EDA Data Tabular dan Pemodelan Klasifikasi. Dengan PandasAI dan HuggingFace, kita dapat melakukan tugas-tugas dengan lancar dan memberikan nilai dari dataset kita.