Tutorial Lengkap Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet
Hugging Face AutoTrain adalah platform dan library open-source yang memungkinkan kamu melakukan fine-tuning model machine learning secara otomatis tanpa perlu menulis kode training dari nol. Dengan AutoTrain, proses yang biasanya membutuhkan ratusan baris kode konfigurasi PyTorch bisa disederhanakan menjadi beberapa baris perintah CLI atau beberapa baris kode Python.
AutoTrain mendukung berbagai jenis task mulai dari fine-tuning Large Language Model (LLM), text classification, image classification, object detection, hingga tabular data. Platform ini sangat cocok untuk data scientist dan ML engineer yang ingin melakukan eksperimen cepat tanpa harus mengurus boilerplate training loop.
Dalam tutorial ini, kita akan membahas cara menggunakan AutoTrain mulai dari instalasi, penggunaan CLI, penggunaan Python API, hingga konfigurasi lanjutan untuk berbagai skenario fine-tuning.
Instalasi
Prasyarat Sistem
Sebelum menginstal AutoTrain, pastikan kamu memiliki:
- Python 3.8 atau lebih baru
- pip package manager
- GPU dengan CUDA support (direkomendasikan untuk training, minimal NVIDIA GPU dengan 8GB VRAM)
- Git (untuk clone repository jika diperlukan)
Instalasi via pip
Cara paling mudah untuk menginstal AutoTrain adalah melalui pip:
pip install autotrain-advanced
Untuk instalasi dengan dukungan lengkap termasuk semua dependensi opsional:
pip install autotrain-advanced[api]
Verifikasi Instalasi
Setelah instalasi selesai, verifikasi dengan menjalankan:
autotrain --version
Kamu juga bisa mengecek apakah GPU terdeteksi dengan benar:
import torch
print(f"CUDA available: {torch.cuda.isavailable()}")
print(f"GPU: {torch.cuda.getdevicename(0)}")
Setup Hugging Face Token
AutoTrain membutuhkan Hugging Face token untuk mengakses model dan dataset. Buat token di https://huggingface.co/settings/tokens lalu set sebagai environment variable:
export HFTOKEN=hfxxxxxxxxxxxxxxxxxxxxx
Atau login via CLI:
huggingface-cli login
Penggunaan Dasar via CLI
AutoTrain CLI adalah cara tercepat untuk memulai fine-tuning. Kamu cukup menyiapkan dataset dan menjalankan satu perintah.
Fine-Tuning LLM dengan CLI
Contoh fine-tuning model bahasa menggunakan dataset custom:
autotrain llm \
--train \
--model meta-llama/Llama-3.2-1B \
--data-path ./my-dataset \
--text-column text \
--lr 2e-4 \
--batch-size 4 \
--epochs 3 \
--trainer sft \
--peft \
--quantization int4 \
--project-name my-llm-finetune
Parameter penting:
--model: Model base dari Hugging Face Hub--data-path: Path ke folder dataset (format CSV, JSON, atau Parquet)--text-column: Nama kolom yang berisi teks training--trainer: Jenis trainer (sftuntuk Supervised Fine-Tuning,rewarduntuk Reward Model,dpountuk DPO)--peft: Mengaktifkan LoRA/PEFT untuk training yang efisien--quantization: Kuantisasi model (int4atauint8) untuk menghemat VRAM
Format Dataset untuk LLM
Dataset harus dalam format CSV, JSON, atau Parquet. Untuk SFT (Supervised Fine-Tuning), format yang paling sederhana:
text
"<|system|>Kamu adalah asisten yang membantu.<|end|><|user|>Apa itu Python?<|end|><|assistant|>Python adalah bahasa pemrograman tingkat tinggi.<|end|>"
"<|system|>Kamu adalah asisten yang membantu.<|end|><|user|>Jelaskan tentang machine learning.<|end|><|assistant|>Machine learning adalah cabang AI yang memungkinkan komputer belajar dari data.<|end|>"
Untuk format chat yang lebih terstruktur, gunakan format JSON:
[
{
"text": [
{"role": "system", "content": "Kamu adalah asisten yang membantu."},
{"role": "user", "content": "Apa itu deep learning?"},
{"role": "assistant", "content": "Deep learning adalah subset dari machine learning yang menggunakan neural network berlapis."}
]
}
]
Text Classification dengan CLI
autotrain text-classification \
--train \
--model bert-base-uncased \
--data-path ./sentiment-dataset \
--text-column review \
--target-column sentiment \
--lr 5e-5 \
--batch-size 16 \
--epochs 5 \
--project-name sentiment-classifier
Image Classification dengan CLI
autotrain image-classification \
--train \
--model google/vit-base-patch16-224 \
--data-path ./image-dataset \
--image-column image \
--target-column label \
--lr 3e-5 \
--batch-size 8 \
--epochs 10 \
--project-name image-classifier
Struktur folder dataset untuk image classification:
image-dataset/
├── train/
│ ├── metadata.csv
│ └── images/
│ ├── img001.jpg
│ ├── img002.jpg
│ └── ...
└── valid/
├── metadata.csv
└── images/
├── img101.jpg
└── ...
Penggunaan Python API
Selain CLI, AutoTrain juga menyediakan Python API yang lebih fleksibel untuk integrasi ke dalam pipeline yang sudah ada.
Setup Project dan Training LLM
from autotrain.params import LLMTrainingParams
from autotrain.project import AutoTrainProject
params = LLMTrainingParams(
model="meta-llama/Llama-3.2-1B",
datapath="./my-dataset",
textcolumn="text",
trainsplit="train",
validsplit="validation",
trainer="sft",
# Hyperparameters
learningrate=2e-4,
numepochs=3,
batchsize=4,
gradientaccumulation=4,
maxseqlength=2048,
# Efisiensi memory
peft=True,
quantization="int4",
lorar=16,
loraalpha=32,
loradropout=0.05,
# Output
projectname="my-llm-project",
pushtohub=True,
repoid="username/my-finetuned-llm",
)
project = AutoTrainProject(params=params, backend="local")
project.create()
Text Classification dengan Python API
from autotrain.params import TextClassificationParams
from autotrain.project import AutoTrainProject
params = TextClassificationParams(
model="indobenchmark/indobert-base-p1",
datapath="./sentiment-data",
textcolumn="text",
targetcolumn="label",
trainsplit="train",
validsplit="test",
learningrate=5e-5,
numepochs=5,
batchsize=16,
maxseqlength=512,
projectname="indo-sentiment",
pushtohub=False,
)
project = AutoTrainProject(params=params, backend="local")
project.create()
Token Classification (NER)
from autotrain.params import TokenClassificationParams
from autotrain.project import AutoTrainProject
params = TokenClassificationParams(
model="bert-base-multilingual-cased",
datapath="./ner-dataset",
textcolumn="tokens",
targetcolumn="nertags",
trainsplit="train",
validsplit="validation",
learningrate=3e-5,
numepochs=10,
batchsize=16,
projectname="ner-model",
)
project = AutoTrainProject(params=params, backend="local")
project.create()
Tabular Classification
AutoTrain juga mendukung data tabular untuk task classification dan regression:
from autotrain.params import TabularParams
from autotrain.project import AutoTrainProject
params = TabularParams(
datapath="./tabular-data",
targetcolumn="target",
trainsplit="train",
validsplit="test",
task="classification",
# AutoTrain akan otomatis mencoba berbagai model
# termasuk XGBoost, LightGBM, Random Forest, dll
numtrials=50, # Jumlah trial untuk hyperparameter search
timelimit=3600, # Batas waktu dalam detik
projectname="tabular-classifier",
)
project = AutoTrainProject(params=params, backend="local")
project.create()
Fine-Tuning LLM Lanjutan
DPO (Direct Preference Optimization)
DPO adalah teknik alignment yang memungkinkan model belajar dari preferensi manusia tanpa perlu reward model terpisah:
from autotrain.params import LLMTrainingParams
from autotrain.project import AutoTrainProject
params = LLMTrainingParams(
model="meta-llama/Llama-3.2-1B",
datapath="./preference-dataset",
trainer="dpo",
# Kolom dataset DPO
textcolumn="prompt",
rejectedtextcolumn="rejected",
# DPO specific params
dpobeta=0.1,
# Hyperparameters
learningrate=5e-6,
numepochs=1,
batchsize=2,
gradientaccumulation=8,
maxseqlength=1024,
# PEFT
peft=True,
quantization="int4",
lorar=16,
loraalpha=32,
projectname="dpo-alignment",
)
project = AutoTrainProject(params=params, backend="local")
project.create()
Format dataset DPO:
[
{
"prompt": "Jelaskan tentang energi terbarukan.",
"chosen": "Energi terbarukan adalah sumber energi yang berasal dari proses alam yang terus-menerus diperbarui, seperti sinar matahari, angin, air, dan panas bumi.",
"rejected": "Energi terbarukan itu yang dari matahari gitu deh, pokoknya yang hijau-hijau."
}
]
ORPO (Odds Ratio Preference Optimization)
ORPO adalah teknik alignment yang lebih baru dan efisien:
autotrain llm \
--train \
--model meta-llama/Llama-3.2-1B \
--data-path ./preference-data \
--trainer orpo \
--text-column prompt \
--rejected-text-column rejected \
--lr 5e-6 \
--batch-size 2 \
--epochs 1 \
--peft \
--quantization int4 \
--project-name orpo-training
Konfigurasi LoRA yang Optimal
Pemilihan parameter LoRA sangat mempengaruhi kualitas fine-tuning:
params = LLMTrainingParams(
model="meta-llama/Llama-3.2-3B",
datapath="./dataset",
trainer="sft",
textcolumn="text",
peft=True,
quantization="int4",
# LoRA config
lorar=64, # Rank - semakin tinggi, semakin banyak parameter yang di-tune
loraalpha=128, # Alpha - biasanya 2x dari r
loradropout=0.05, # Dropout untuk regularisasi
targetmodules="qproj,vproj,kproj,oproj,gateproj,upproj,downproj",
# Training config
learningrate=2e-4,
numepochs=3,
batchsize=4,
gradientaccumulation=4,
warmupratio=0.03,
weightdecay=0.01,
maxgradnorm=0.3,
maxseqlength=2048,
# Optimizer
optimizer="pagedadamw8bit",
scheduler="cosine",
projectname="optimized-lora",
)
Panduan pemilihan LoRA rank:
r=8: Minimal, cocok untuk task sederhana atau dataset kecilr=16: Default yang baik untuk kebanyakan kasusr=32-64: Untuk task kompleks atau ketika kualitas sangat pentingr=128+: Mendekati full fine-tuning, butuh VRAM lebih besar
Menyiapkan Dataset yang Baik
Membuat Dataset dari Scratch
import pandas as pd
import json
Dataset untuk SFT dalam format chat
conversations = []
Contoh data training
qapairs = [
{
"system": "Kamu adalah asisten customer service yang ramah dan membantu.",
"user": "Bagaimana cara mengembalikan barang?",
"assistant": "Untuk mengembalikan barang, silakan ikuti langkah berikut:\n1. Buka halaman pesanan Anda\n2. Pilih pesanan yang ingin dikembalikan\n3. Klik tombol 'Ajukan Pengembalian'\n4. Isi formulir alasan pengembalian\n5. Tunggu konfirmasi dari tim kami dalam 1-2 hari kerja"
},
{
"system": "Kamu adalah asisten customer service yang ramah dan membantu.",
"user": "Berapa lama pengiriman ke Surabaya?",
"assistant": "Estimasi pengiriman ke Surabaya tergantung pada layanan yang dipilih:\n- Regular: 3-5 hari kerja\n- Express: 1-2 hari kerja\n- Same Day: Tersedia untuk area tertentu di Surabaya"
}
]
for pair in qapairs:
text = f"<|system|>{pair['system']}<|end|>"
text += f"<|user|>{pair['user']}<|end|>"
text += f"<|assistant|>{pair['assistant']}<|end|>"
conversations.append({"text": text})
df = pd.DataFrame(conversations)
df.tocsv("./my-dataset/train.csv", index=False)
print(f"Dataset created with {len(df)} examples")
Memvalidasi Dataset
import pandas as pd
df = pd.readcsv("./my-dataset/train.csv")
print(f"Total samples: {len(df)}")
print(f"Columns: {df.columns.tolist()}")
print(f"Null values: {df.isnull().sum().todict()}")
Cek panjang teks
df['textlength'] = df['text'].str.len()
print(f"Avg text length: {df['textlength'].mean():.0f} chars")
print(f"Max text length: {df['textlength'].max()} chars")
print(f"Min text length: {df['textlength'].min()} chars")
Sample data
print("\nSample:")
print(df['text'].iloc[0][:200])
Split Dataset
from sklearn.modelselection import traintestsplit
df = pd.readcsv("./my-dataset/data.csv")
traindf, validdf = traintestsplit(df, testsize=0.1, randomstate=42)
traindf.tocsv("./my-dataset/train.csv", index=False)
validdf.tocsv("./my-dataset/valid.csv", index=False)
print(f"Train: {len(traindf)}, Validation: {len(validdf)}")
Menggunakan Model yang Sudah Di-Fine-Tune
Load Model Hasil Training
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
modelpath = "./my-llm-project" # Atau "username/my-finetuned-llm" dari Hub
tokenizer = AutoTokenizer.frompretrained(modelpath)
model = AutoModelForCausalLM.frompretrained(
modelpath,
torchdtype=torch.float16,
devicemap="auto",
)
Generate text
prompt = "<|system|>Kamu adalah asisten yang membantu.<|end|><|user|>Apa itu AutoTrain?<|end|><|assistant|>"
inputs = tokenizer(prompt, returntensors="pt").to(model.device)
with torch.nograd():
outputs = model.generate(
*inputs,
maxnewtokens=256,
temperature=0.7,
dosample=True,
topp=0.9,
)
response = tokenizer.decode(outputs[0], skipspecialtokens=False)
print(response)
Load Model PEFT/LoRA
Jika kamu menggunakan PEFT saat training, model adapter terpisah dari base model:
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch
basemodel = "meta-llama/Llama-3.2-1B"
adapterpath = "./my-llm-project"
tokenizer = AutoTokenizer.frompretrained(adapterpath)
model = AutoModelForCausalLM.frompretrained(
basemodel,
torchdtype=torch.float16,
devicemap="auto",
)
model = PeftModel.frompretrained(model, adapterpath)
Opsional: merge adapter ke base model untuk inferensi lebih cepat
model = model.mergeandunload()
Evaluasi Model
from transformers import pipeline
pipe = pipeline(
"text-generation",
model=model,
tokenizer=tokenizer,
torchdtype=torch.float16,
devicemap="auto",
)
testprompts = [
"Jelaskan tentang machine learning dalam 2 kalimat.",
"Apa perbedaan antara Python dan JavaScript?",
"Bagaimana cara membuat API dengan FastAPI?",
]
for prompt in testprompts:
formatted = f"<|user|>{prompt}<|end|><|assistant|>"
result = pipe(
formatted,
maxnewtokens=200,
temperature=0.7,
dosample=True,
)
print(f"Q: {prompt}")
print(f"A: {result[0]['generatedtext']}")
print("-" 50)
Monitoring Training
Integrasi dengan Weights & Biases
pip install wandb
autotrain llm \
--train \
--model meta-llama/Llama-3.2-1B \
--data-path ./dataset \
--text-column text \
--trainer sft \
--peft \
--quantization int4 \
--lr 2e-4 \
--batch-size 4 \
--epochs 3 \
--logging-steps 10 \
--project-name my-project \
--log wandb
Integrasi dengan TensorBoard
autotrain llm \
--train \
--model meta-llama/Llama-3.2-1B \
--data-path ./dataset \
--text-column text \
--trainer sft \
--peft \
--lr 2e-4 \
--batch-size 4 \
--epochs 3 \
--logging-steps 10 \
--project-name my-project \
--log tensorboard
Lalu buka TensorBoard:
tensorboard --logdir ./my-project/runs
Konfigurasi YAML
Untuk project yang lebih kompleks, kamu bisa menggunakan file konfigurasi YAML:
# config.yaml
task: llm
basemodel: meta-llama/Llama-3.2-3B
projectname: advanced-finetune
dataset:
path: ./training-data
textcolumn: text
trainsplit: train
validsplit: validation
training:
trainer: sft
learningrate: 2e-4
numepochs: 3
batchsize: 4
gradientaccumulation: 4
maxseqlength: 2048
warmupratio: 0.03
weightdecay: 0.01
loggingsteps: 10
savesteps: 500
evalsteps: 500
peft:
enabled: true
quantization: int4
lorar: 32
loraalpha: 64
loradropout: 0.05
targetmodules: "qproj,vproj,kproj,oproj"
output:
pushtohub: true
repoid: username/my-model
Jalankan dengan:
autotrain --config config.yaml
Best Practices
1. Mulai dengan Dataset Kecil
Sebelum training dengan seluruh dataset, lakukan eksperimen dengan subset kecil (100-500 sampel) untuk memastikan pipeline berjalan dengan benar dan mengidentifikasi masalah sejak awal.
head -n 100 train.csv > trainsmall.csv
2. Gunakan Quantization untuk Menghemat VRAM
Untuk GPU dengan VRAM terbatas, selalu gunakan quantization:
int4: Menghemat sekitar 75% VRAM, cocok untuk GPU 8-16GBint8: Menghemat sekitar 50% VRAM, kualitas sedikit lebih baik dari int4
3. Sesuaikan Batch Size dan Gradient Accumulation
Jika GPU kamu tidak cukup untuk batch size besar, gunakan gradient accumulation:
Effective batch size = batchsize x gradientaccumulation
Contoh: batchsize=2 dengan gradientaccumulation=8 menghasilkan effective batch size 16.
4. Perhatikan Learning Rate
- Untuk fine-tuning LLM dengan LoRA:
1e-4sampai3e-4 - Untuk full fine-tuning:
1e-5sampai5e-5 - Untuk text/image classification:
2e-5sampai5e-5
5. Validasi Kualitas Dataset
Dataset yang buruk akan menghasilkan model yang buruk, tidak peduli seberapa canggih teknik training yang digunakan. Pastikan:
- Tidak ada data duplikat yang berlebihan
- Format konsisten di seluruh dataset
- Label akurat untuk task classification
- Teks tidak terpotong atau corrupt
6. Push ke Hugging Face Hub
Selalu simpan model ke Hub untuk versioning dan sharing:
autotrain llm \
--train \
--model meta-llama/Llama-3.2-1B \
--data-path ./dataset \
--text-column text \
--trainer sft \
--peft \
--push-to-hub \
--repo-id username/model-name \
--project-name my-project
7. Gunakan Evaluation Split
Selalu pisahkan sebagian data untuk evaluasi agar bisa memantau overfitting:
autotrain llm \
--train \
--model meta-llama/Llama-3.2-1B \
--data-path ./dataset \
--text-column text \
--train-split train \
--valid-split validation \
--trainer sft \
--eval-steps 100 \
--project-name my-project
Troubleshooting
Out of Memory (OOM)
Jika kamu mendapatkan error CUDA OOM:
batchsize (coba 1 atau 2)maxseqlengthquantization: int4gradientaccumulation untuk kompensasi batch size kecilgradient_checkpointing: trueTraining Lambat
nvidia-smibf16 atau fp16 mixed precisionpip install flash-attn --no-build-isolation
Model Tidak Converge
Kesimpulan
Hugging Face AutoTrain menyederhanakan proses fine-tuning model AI secara signifikan. Dengan dukungan untuk berbagai task (LLM, NLP, Computer Vision, Tabular), berbagai teknik training (SFT, DPO, ORPO), dan integrasi yang baik dengan ekosistem Hugging Face, AutoTrain adalah tool yang tepat untuk mempercepat eksperimen ML.
Poin-poin penting yang perlu diingat:
- Mulai dengan dataset kecil dan iterasi secara bertahap
- Gunakan PEFT/LoRA dan quantization untuk efisiensi
- Validasi kualitas dataset sebelum memulai training
- Monitor training dengan WandB atau TensorBoard
- Simpan model ke Hugging Face Hub untuk versioning
Dengan memahami fundamental yang dibahas dalam tutorial ini, kamu bisa langsung memulai fine-tuning model untuk kebutuhan spesifik project kamu.