Tutorial Lengkap Hugging Face AutoTrain: Fine-Tuning Model AI Tanpa Ribet

# 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 l...

By Ruby Abdullah · · tutorial
Hugging FaceAutoTrainFine-TuningLLMMachine Learning

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 (sft untuk Supervised Fine-Tuning, reward untuk Reward Model, dpo untuk DPO)
  • --peft: Mengaktifkan LoRA/PEFT untuk training yang efisien
  • --quantization: Kuantisasi model (int4 atau int8) 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 kecil
  • r=16: Default yang baik untuk kebanyakan kasus
  • r=32-64: Untuk task kompleks atau ketika kualitas sangat penting
  • r=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-16GB
  • int8: 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-4 sampai 3e-4
  • Untuk full fine-tuning: 1e-5 sampai 5e-5
  • Untuk text/image classification: 2e-5 sampai 5e-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:

  • Kurangi batchsize (coba 1 atau 2)
  • Kurangi maxseqlength
  • Aktifkan quantization: int4
  • Tingkatkan gradientaccumulation untuk kompensasi batch size kecil
  • Gunakan gradient_checkpointing: true
  • Training Lambat

  • Pastikan GPU terdeteksi: nvidia-smi
  • Gunakan bf16 atau fp16 mixed precision
  • Pastikan data loading tidak menjadi bottleneck (gunakan SSD)
  • Pertimbangkan menggunakan Flash Attention 2:
  • pip install flash-attn --no-build-isolation
    

    Model Tidak Converge

  • Cek dataset apakah ada noise atau data yang salah label
  • Coba learning rate lebih kecil
  • Tambah jumlah epoch
  • Pastikan format data sesuai dengan yang diharapkan model
  • 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.

    Artikel Terkait

    Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind

    Tutorial Lengkap Google Gemma: Model Open-Source dari Google DeepMind Google Gemma adalah keluarga model bahasa open-sou...

    Tutorial Lengkap Fine-tuning LLM dengan LoRA dan PEFT

    Tutorial Lengkap Fine-tuning LLM dengan LoRA dan PEFT Fine-tuning Large Language Models (LLM) secara tradisional membutu...

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom Model bahasa besar (LLM) open-source terus berk...

    Tutorial LitGPT: Framework untuk Melatih dan Fine-Tuning Large Language Models

    Tutorial LitGPT: Framework untuk Melatih dan Fine-Tuning Large Language Models LitGPT adalah framework open-source dari ...