Siapa bilang model AI harus berukuran raksasa untuk menjadi hebat? Dulu, model bahasa kecil atau Small Language Models (SLMs) mungkin diremehkan karena kemampuannya yang terbatas. Namun, kini pandangan itu berubah drastis. Sebuah model 4 miliar parameter yang dirilis pada awal 2025 berhasil mengalahkan model yang 7 kali lebih besar pada benchmark penalaran standar. Ini menunjukkan perubahan besar dalam lanskap AI.

Model 4 miliar parameter mencetak 89,2% pada penalaran matematika GSM8K. Sementara itu, model 3,8 miliar parameter mencapai 83,7% pada ARC-C, skor tertinggi di kelas ukurannya. Angka-angka ini sebelumnya hanya dicapai oleh model 30 miliar parameter ke atas. Jadi, pertanyaan tentang "model AI terbaik" kini perlu kita lihat lagi.

Artikel ini akan memberi Anda panduan terkurasi tentang Best Small Language Models (SLMs) on Hugging Face Right Now. Kami akan membahas apa saja keunggulan setiap model, angka benchmark yang mendukung klaim tersebut, serta kode untuk memulai penggunaannya.

Di sini, "model bahasa kecil" berarti model dengan kurang dari 7 miliar parameter. Ini adalah model yang dapat berjalan pada satu GPU konsumen, laptop, atau bahkan smartphone modern dengan pengaturan yang tepat. Ambang batas ini sangat penting karena menandai batas antara model yang membutuhkan infrastruktur serius dan model yang dapat diterapkan oleh siapa saja. Anda tidak perlu membayar tagihan cloud, tidak perlu menunggu batasan tarif API. Cukup model yang berjalan secara lokal, melakukan pekerjaan nyata.

Mengapa Small Language Models Layak Diperhatikan Sekarang

Alasan jujur mengapa kebanyakan orang mengabaikan model kecil sampai saat ini adalah karena model-model itu memang belum cukup baik. Model 3 miliar parameter dari tahun 2022 akan kesulitan dengan penalaran multi-langkah, gagal dalam pembuatan kode, dan menghasilkan keluaran yang generik pada hal-hal yang nuansanya rumit. Reputasi itu melekat, bahkan ketika model-model ini secara diam-diam menjadi jauh lebih baik.

Tiga hal mengubah perjalanan ini:

1. Kualitas Data: Pelatihan pada 5 triliun token kini mengutamakan kualitas. Data sintetis dibuat agar kaya akan penalaran, konten web publik disaring, dan materi pendidikan distrukturkan. Taruhan ini membuahkan hasil. Sebuah model 3,8 miliar parameter yang dilatih dengan cermat pada data yang tepat mengungguli model 13 miliar parameter yang dilatih sembarangan. Contohnya, Qwen3-0.6B, hanya dengan 600 juta parameter, mendukung lebih dari 100 bahasa karena korpus pelatihannya dibangun dengan tujuan tersebut.
2. Distilasi: Ini adalah proses ketika model yang lebih kecil belajar menalar dengan dilatih menggunakan keluaran dari model penalaran yang jauh lebih besar. DeepSeek-R1 distills, model 1,5 miliar parameter, belajar menalar dengan dilatih pada keluaran dari model penalasi yang lebih besar. Hasilnya adalah model kecil yang dapat memecahkan masalah langkah demi langkah, sesuatu yang terasa tidak mungkin pada ukuran tersebut dua tahun lalu.
3. Inovasi Arsitektur:
   • Mixture-of-Experts (MoE) mengubah arti "jumlah parameter". Mixtral memiliki total 8 miliar parameter tetapi hanya mengaktifkan 4 miliar per token. Ini berjalan dengan jejak memori model 4 miliar parameter sambil memanfaatkan kapasitas model 8 miliar parameter.
   • Mekanisme perhatian hibrida dan jendela konteks yang lebih panjang (128K kini umum bahkan pada model sub-5 miliar parameter) mendorong kemampuan lebih jauh tanpa membengkakkan ukuran model.

Istilah Penting dalam Dunia SLM

Jika Anda sering menjelajahi halaman model Hugging Face, Anda tahu bahwa informasi di sana bisa sangat padat. Sebelum masuk ke daftar model, mari kita pahami beberapa istilah yang akan sering muncul:

• Parameter: Berat numerik di dalam model yang menentukan cara model merespons input. Lebih banyak parameter umumnya berarti lebih banyak kapasitas untuk menyimpan pengetahuan dan menangani penalaran kompleks, tetapi tidak selalu menghasilkan keluaran yang lebih baik.
• MMLU-Pro: Versi yang lebih sulit dari tes MMLU klasik. Ini mencakup 57 mata pelajaran akademik seperti hukum, kedokteran, sejarah, fisika, dan banyak lagi, dengan pilihan jawaban yang dirancang agar sangat menipu. Skor 50+ pada MMLU-Pro dari model sub-5 miliar parameter adalah hal yang patut diperhatikan. Skor di atas 70 adalah luar biasa.
• GSM8K (Grade School Math 8K): Kumpulan 8.500 soal cerita matematika sekolah dasar yang membutuhkan penalaran multi-langkah untuk menyelesaikannya. Ini terdengar sederhana tetapi secara konsisten memisahkan model yang menalar dari model yang hanya mencocokkan pola. Skor dilaporkan sebagai persentase masalah yang diselesaikan dengan benar.
• HumanEval: Menguji pembuatan kode. Model diberi tanda tangan fungsi Python dan docstring, lalu harus menulis kode yang lulus uji tersembunyi. Skor di atas 60% dari model sub-5 miliar parameter sangat mengesankan.
• ARC-C (AI2 Reasoning Challenge): Kumpulan pertanyaan sains dari ujian standar, khususnya yang membuat sistem AI lain kesulitan. Ini menguji penalaran akal sehat dan ilmiah.
• Base vs. Instruct vs. Thinking/Reasoning Models:
  • Model Base: Dilatih untuk memprediksi token berikutnya. Ini menghasilkan teks tetapi tidak mengikuti instruksi secara andal.
  • Model Instruct: Telah disempurnakan untuk merespons prompt secara membantu dalam format percakapan. Ini yang Anda inginkan untuk sebagian besar aplikasi.
  • Model Thinking atau Reasoning: Seperti "mode berpikir" Qwen3 atau DeepSeek-R1 distills, melangkah lebih jauh. Model ini menghasilkan proses penalaran chain-of-thought sebelum menjawab, yang meningkatkan akurasi pada masalah kompleks dengan biaya waktu respons yang lebih lambat. Kebanyakan model dalam daftar ini adalah varian instruct.
• Kuantisasi: Model yang baru selesai pelatihan menyimpan bobotnya dalam format floating point 16-bit atau 32-bit. Ini sangat presisi tetapi besar. Kuantisasi mengompresi bobot tersebut menjadi bit yang lebih sedikit. Q4 berarti kuantisasi 4-bit, setiap bobot menggunakan 4 bit alih-alih 16, memotong penggunaan memori sekitar 75%. Q4_K_M mempertahankan sekitar 90-95% kualitas keluaran model asli sambil hanya membutuhkan sebagian kecil memori.
• GGUF / llama.cpp: GGUF adalah format file yang mengemas model yang dikuantisasi untuk digunakan dengan llama.cpp, mesin inferensi lokal yang paling banyak digunakan. Jika Anda melihat model tercantum sebagai "X GB (Q4)", itu adalah perkiraan RAM yang Anda butuhkan untuk memuat versi yang dikuantisasi.

Model Bahasa Kecil (SLM) Terbaik Saat Ini

Berikut adalah daftar model bahasa kecil terbaik yang bisa Anda temukan di Hugging Face, lengkap dengan keunggulan dan kode awal untuk dicoba.

1. Qwen3.5-4B (Alibaba)

Jika ada satu model dalam daftar ini yang mencakup sebagian besar kebutuhan, itu adalah Qwen3.5-4B dari Alibaba. Model ini dirilis pada Maret 2026 dan menjadi pusat seri kecil Qwen3.5. Rangkaiannya mulai dari 0.8 miliar hingga 9 miliar parameter. Semua model ini berbagi arsitektur yang sama dan memiliki lisensi Apache 2.0, artinya Anda dapat menggunakannya dalam produk komersial tanpa khawatir tentang batasan penggunaan.

Angka utamanya adalah jendela konteks. Qwen3.5-4B mendukung panjang konteks asli 262.144 token, bahkan dapat diperluas hingga lebih dari satu juta. Untuk model 4 miliar parameter, ini luar biasa. Kebanyakan model ukuran ini hanya mencapai 128K.

Model ini beroperasi dalam mode berpikir secara default, menghasilkan rantai penalaran sebelum merespons. Anda dapat mematikannya untuk jawaban yang lebih cepat dan langsung jika tidak memerlukan kedalaman penalaran tersebut.

Apa keunggulannya? Tugas-tugas umum lintas bahasa, mengikuti instruksi, pemrosesan dokumen panjang, dan aplikasi apa pun yang mungkin melibatkan input multimodal di kemudian hari.

Kode untuk memulainya:

python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "Qwen/Qwen3.5-4B-Chat"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

messages = [
    {"role": "system", "content": "Anda adalah asisten AI yang membantu."},
    {"role": "user", "content": "Bisakah Anda menjelaskan konsep kuantisasi dalam LLM?"}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    model_inputs.input_ids,
    max_new_tokens=2048,
    do_sample=True,
    top_k=50,
    top_p=0.8,
    temperature=0.6,
    direct_response=False # Atur True untuk respons langsung tanpa penalaran
)

response = tokenizer.decode(generated_ids[0][model_inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

2. Microsoft Phi-4-mini-instruct (3.8B)

Phi-4-mini adalah taruhan Microsoft bahwa data pelatihan yang tepat mengalahkan skala mentah. Dengan 3,8 miliar parameter yang dilatih pada 5 triliun token data yang disaring dan sintetis, model ini mencetak skor ARC-C 83,7%. Ini adalah skor tertinggi di benchmark tersebut untuk kelas ukurannya. Skor GSM8K sebesar 88,6% dan akurasi faktual SimpleQA sebesar 91,1% menempatkannya setara dengan model yang ukurannya dua hingga tiga kali lipat.

File GGUF Q4_K_M berukuran sekitar 4 GB, yang berarti dapat berjalan pada mesin dengan RAM minimal 4 GB. Bagi siapa pun yang menginginkan AI yang mumpuni di laptop kelas menengah tanpa persyaratan GPU, Phi-4-mini mungkin merupakan pilihan paling praktis dalam daftar ini.

Yang dikorbankan adalah kedalaman multibahasa dan input multimodal. Model ini dilatih terutama pada teks bahasa Inggris, sehingga akan berkinerja buruk pada tugas non-Inggris. Jika kasus penggunaan Anda adalah penalaran bahasa Inggris, pengambilan pengetahuan, atau tugas terstruktur, pertukaran ini baik-baik saja.

Apa keunggulannya? Tugas yang banyak melibatkan penalaran, tanya jawab yang intensif pengetahuan, dan bagi siapa saja yang menjalankan AI pada perangkat keras terbatas dengan beban kerja bahasa Inggris.

Kode untuk memulainya:

python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig

model_id = "microsoft/Phi-4-mini-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16, # Menggunakan bfloat16 untuk efisiensi memori
    device_map="auto",
    trust_remote_code=True
)

# Konfigurasi generasi
generation_config = GenerationConfig.from_pretrained(model_id)
generation_config.max_new_tokens = 1024
generation_config.do_sample = True
generation_config.temperature = 0.7
generation_config.top_k = 50
generation_config.top_p = 0.95
generation_config.num_return_sequences = 1

messages = [
    {"role": "user", "content": "Jelaskan perbedaan antara LLM dan SLM."},
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
model_inputs = tokenizer(text, return_tensors="pt").to(model.device)

generated_ids = model.generate(**model_inputs, generation_config=generation_config)
response = tokenizer.decode(generated_ids[0][model_inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

3. Google Gemma 3 4B IT

Google Gemma 3 4B IT adalah model yang mengejutkan banyak orang setelah mereka benar-benar menjalankannya. Dalam tugas kode dan matematika, model ini memiliki performa jauh di atas ekspektasi untuk 4 miliar parameter. Skor HumanEval 63,8% sangat kompetitif dengan model dua kali lipat ukurannya. Skor 89,2% pada penalaran matematika GSM8K menempatkannya di wilayah yang sangat kuat untuk masalah matematika tingkat sekolah dasar dan awal sarjana.

Model ini mendukung input multimodal (teks dan gambar) dan dilengkapi dengan jendela konteks 128K. Ini cukup panjang untuk memberinya makalah lengkap atau basis kode yang cukup besar untuk dianalisis. "IT" dalam namanya adalah singkatan dari Instruction Tuned, yang berarti ini adalah versi yang disempurnakan untuk mengikuti instruksi dalam percakapan.

Apa keunggulannya? Pembuatan kode, tugas yang banyak melibatkan matematika, dan proyek di mana Anda menginginkan input multimodal tanpa melebihi 4 miliar parameter.

Kode untuk memulainya:

python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "google/gemma-3-4b-it"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

prompt = "Tulis fungsi Python untuk menghitung bilangan Fibonacci."
chat = [
    {"role": "user", "content": prompt},
]
model_inputs = tokenizer.apply_chat_template(chat, return_tensors="pt").to(model.device)

with torch.no_grad(): # Menghemat memori dan mempercepat inferensi
    generated_ids = model.generate(
        model_inputs,
        max_new_tokens=1024,
        temperature=0.7,
        do_sample=True,
    )
response = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
print(response)

4. Google Gemma 3n E4B (Model untuk Seluler)

Gemma 3n E4B adalah jenis model yang berbeda. Google membangunnya secara khusus untuk penyebaran di perangkat seperti ponsel, perangkat keras edge, dan aplikasi lokal. Arsitekturnya mencerminkan prioritas tersebut dengan cara yang tidak dimiliki model lain dalam daftar ini.

Inovasi utamanya adalah Per-Layer Embeddings (PLE), sebuah arsitektur transformer berlapis yang menyematkan model yang lebih kecil (E2B) di dalam yang lebih besar (E4B). E4B memiliki 8 miliar parameter mentah tetapi hanya membutuhkan 3 GB memori untuk berjalan. Ini karena sebagian besar bobot disimpan di CPU, sementara hanya lapisan transformer inti yang berada di memori akselerator. Hasil bersihnya: Anda mendapatkan kinerja kelas 4 miliar parameter dengan persyaratan memori kelas 4 miliar parameter, tetapi model dasarnya memiliki kapasitas dua kali lipat.

Apa keunggulannya? Penyebaran di perangkat dan seluler, aplikasi multimodal (teks + gambar + audio dalam satu model), dan skenario apa pun di mana efisiensi memori adalah prioritas utama.

5. Meta Llama 3.2 3B Instruct

Meta Llama 3.2 3B Instruct tidak memiliki angka benchmark paling mencolok dalam daftar ini, tetapi memiliki sesuatu yang tidak dimiliki kebanyakan model lain: komunitas besar dan aktif di baliknya. Dengan lebih dari 1000 fine-tune yang tersedia, ini adalah model kecil yang paling banyak digunakan di sini. Artinya, ada lebih banyak fine-tune, lebih banyak integrasi, lebih banyak alat komunitas, dan lebih banyak pengujian di dunia nyata dibandingkan kebanyakan alternatif.

Dengan ukuran hanya 2 GB dalam kuantisasi Q4, ini juga merupakan model yang paling ringan tetapi tetap sangat mumpuni dalam daftar ini. Model ini menangani pemanggilan alat (tool calling) dan keluaran terstruktur dengan bersih. Meta membangunnya dengan mempertimbangkan kasus penggunaan agen, menjadikannya sangat cocok untuk pipeline di mana model perlu memanggil API eksternal atau menghasilkan JSON yang dikonsumsi oleh sistem lain.

Apa keunggulannya? Pemanggilan alat, pipeline keluaran terstruktur, aplikasi seluler, dan proyek apa pun yang mendapat manfaat dari dukungan komunitas yang luas.

Kode untuk memulainya:

python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "meta-llama/Llama-3.2-3B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)

# Menekan peringatan tentang pad token
if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_id

messages = [
    {"role": "system", "content": "Anda adalah asisten yang membantu."},
    {"role": "user", "content": "Buat resep kue cokelat dalam format JSON."}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    model_inputs.input_ids,
    max_new_tokens=2000,
    do_sample=True,
    temperature=0.7,
    top_k=50,
    top_p=0.95
)

response = tokenizer.decode(generated_ids[0][model_inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

6. HuggingFaceTB SmolLM3-3B

HuggingFaceTB SmolLM3-3B adalah model buatan Hugging Face sendiri, dan yang membedakannya adalah transparansi. Bobotnya terbuka, campuran data pelatihannya dipublikasikan, konfigurasi pelatihan diterbitkan, dan kode evaluasinya dibagikan. Bagi peneliti, pendidik, atau tim yang membangun di atas model dan perlu memahami persis apa yang mereka kerjakan, keterbukaan ini sangat langka.

Model itu sendiri dibangun di atas kurikulum tiga tahap: tahap pertama mencakup teks web umum di 11,2 triliun token pelatihannya, tahap kedua memperkenalkan data matematika dan kode berkualitas lebih tinggi, dan tahap ketiga berfokus pada penalaran. Pendekatan bertahap ini mencerminkan cara kerja pendidikan manusia. Hasilnya, ini menghasilkan model yang menempati posisi pertama atau kedua pada benchmark pengetahuan dan penalaran dalam kelas 3 miliar parameter, termasuk HellaSwag dan ARC. Ketika mode penalaran diaktifkan, kinerja AIME 2025 melonjak dari 9,3% menjadi 36,7%.

Model ini juga mendukung pemanggilan alat di luar kotak, menangani 6 bahasa Eropa secara asli, dan diperluas hingga konteks 128K melalui YARN. Kode pemodelan membutuhkan transformers v4.53.0 atau yang lebih baru.

Apa keunggulannya? Penelitian, eksperimen yang dapat direproduksi, proyek open-source yang mengutamakan transparansi, dan penyebaran multibahasa Eropa.

Kode untuk memulainya:

python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "HuggingFaceTB/SmolLM3-3B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

prompt = "Jelaskan efek relativitas waktu Einstein secara singkat."
chat = [
    {"role": "user", "content": prompt},
]
model_inputs = tokenizer.apply_chat_template(chat, return_tensors="pt").to(model.device)

generated_ids = model.generate(
    model_inputs,
    max_new_tokens=1024,
    do_sample=True,
    temperature=0.7,
    top_k=50,
    top_p=0.95
)
response = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
print(response)

7. DeepSeek-R1-Distill-Qwen-1.5B

Kebanyakan model 1,5 miliar parameter biasanya hanya bagus untuk pelengkapan otomatis (autocomplete), obrolan sederhana, dan tidak banyak yang lain. DeepSeek-R1-Distill-Qwen-1.5B adalah pengecualian yang patut dicatat. Model ini dilatih pada keluaran dari DeepSeek-R1, model penalaran frontier yang jauh lebih besar. Ini berarti model ini belajar menalar dengan mengamati guru yang jauh lebih mampu. Hasilnya adalah model 1,5 miliar parameter yang dapat menghasilkan rantai penalaran multi-langkah pada masalah matematika dan logika di mana model lain dengan ukurannya menyerah dan menebak.

Dengan ukuran sekitar 1 GB dalam kuantisasi Q4, ini adalah model terkecil dalam daftar ini dengan kemampuan penalaran asli. Model ini dapat dipasang di hampir semua perangkat keras, seperti Raspberry Pi dengan RAM yang cukup, laptop lama, atau perangkat embedded. Jejak ukuran ini dikombinasikan dengan perilaku penalaran membuatnya berguna untuk skenario apa pun di mana Anda membutuhkan inferensi ringan pada masalah terstruktur dan tidak mampu membeli model yang lebih besar.

Kekurangannya: ini bukan chatbot serbaguna. Kekuatannya adalah matematika, logika, dan penalaran. Untuk tugas kreatif atau percakapan terbuka, model ini akan berkinerja buruk relatif terhadap kelas ukurannya.

Apa keunggulannya? Perangkat edge, sistem embedded, pipeline penalaran ringan, dan proyek apa pun di mana ukuran model 1 GB adalah persyaratan mutlak.

Kode untuk memulainya:

python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

prompt = "Jika hari ini Senin, hari apa 30 hari dari sekarang?"
chat = [
    {"role": "user", "content": prompt},
]
model_inputs = tokenizer.apply_chat_template(chat, return_tensors="pt").to(model.device)

generated_ids = model.generate(
    model_inputs,
    max_new_tokens=1024,
    temperature=0.7,
    do_sample=True,
)
response = tokenizer.decode(generated_ids[0], skip_special_tokens=True)
print(response)

8. Qwen3-0.6B (Yang Ultra-Kecil)

Qwen3-0.6B berada di ambang batas apa yang saat ini layak disebut sebagai model bahasa. Dengan 600 juta parameter, model ini berjalan pada perangkat keras yang kebanyakan orang bahkan tidak akan mempertimbangkan untuk digunakan dalam AI. Namun, model ini tetap berhasil melakukan hal-hal yang berguna. Jumlah unduhan yang tinggi di Hugging Face menunjukkan bahwa banyak orang telah menemukan tujuan nyata untuknya.

Model ini memiliki arsitektur mode ganda yang sama dengan keluarga Qwen3 lainnya, yaitu mode berpikir untuk masalah yang membutuhkan penalaran, dan mode non-berpikir untuk respons langsung yang cepat. Lebih dari 100 bahasa didukung. Untuk tugas-tugas seperti klasifikasi teks, autocomplete bentuk pendek, ringkasan dasar, atau fitur on-device ringan di aplikasi seluler, model ini benar-benar mumpuni relatif terhadap ukurannya.

Jangan berharap model ini menulis kode kompleks, menangani penalaran multi-langkah di seluruh input panjang, atau bersaing dengan model 3 miliar parameter ke atas pada benchmark. Bukan itu tujuan pembuatannya. Model ini dibuat untuk berjalan di mana saja, dan memang demikian.

Apa keunggulannya? Autocomplete, klasifikasi teks, fitur on-device sederhana, perangkat keras ultra-terbatas, dan prototyping cepat di mana model yang lebih besar terlalu berlebihan.

Kode untuk memulainya:

python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "Qwen/Qwen3-0.6B-Chat" # Atau versi yang lebih baru jika tersedia
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

messages = [
    {"role": "system", "content": "Anda adalah asisten AI yang membantu."},
    {"role": "user", "content": "Sebutkan tiga ibu kota negara di Eropa."}
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)

model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    model_inputs.input_ids,
    max_new_tokens=2048,
    do_sample=True,
    top_k=50,
    top_p=0.8,
    temperature=0.6,
    direct_response=True # Biasanya ingin respons langsung untuk model kecil
)

response = tokenizer.decode(generated_ids[0][model_inputs.input_ids.shape[1]:], skip_special_tokens=True)
print(response)

Perbandingan Singkat Model SLM Pilihan

Untuk membantu Anda membandingkan, berikut ringkasan fitur utama dari model-model pilihan yang kami bahas:

Model	Parameter	Konteks	Fitur Unggulan	RAM (Q4)	Lisensi
Qwen3.5-4B	4B	262K (ekstensi 1M+)	Thinking mode, multimodal, multilingual	-	Apache 2.0
Phi-4-mini-instruct	3.8B	-	ARC-C 83.7%, GSM8K 88.6%, English-focused	~4 GB	-
Gemma 3 4B IT	4B	128K	HumanEval 63.8%, GSM8K 89.2%, multimodal	-	-
Gemma 3n E4B	4B (8B raw)	-	On-device, memory efficient, multimodal	3 GB	-
Llama 3.2 3B Instruct	3B	-	Komunitas besar, tool calling, structured output	2 GB	-
SmolLM3-3B	3B	128K (YARN)	Transparansi, 6 bahasa Eropa, tool calling	-	-
DeepSeek-R1-Distill-Qwen-1.5B	1.5B	-	Reasoning multi-step pada math/logic	~1 GB	-
Qwen3-0.6B	0.6B	-	100+ bahasa, ultra-constrained hardware	-	-

Kesimpulan: Ukuran Kecil, Kemampuan Besar

Kisah yang terus-menerus muncul dari artikel ini sederhana: kecil tidak lagi berarti terbatas. Sebuah model 3,8 miliar parameter kini mencapai angka benchmark yang setahun lalu hanya dicapai oleh model 30 miliar parameter. Sebuah model yang berjalan hanya dengan 2 GB RAM kini menangani tugas-tugas penalaran yang sebelumnya membutuhkan infrastruktur tingkat enterprise. Ini bukan sekadar pemasaran, inilah yang ditunjukkan oleh data benchmark, dan ini dapat direproduksi pada perangkat keras yang sudah dimiliki kebanyakan orang.

Implikasi praktisnya adalah bahwa keputusan untuk selalu menggunakan API frontier sebagai default patut dipertanyakan untuk berbagai tugas yang semakin berkembang. Jika beban kerja Anda adalah penalaran bahasa Inggris, pembuatan kode, atau keluaran terstruktur, Phi-4-mini akan mencakup sebagian besar di laptop. Jika Anda membangun sesuatu yang multibahasa, Qwen3.5-4B adalah model Apache 2.0 yang ramah komersial dengan jendela konteks 262K dan pemahaman gambar asli. Jika Anda menargetkan perangkat keras seluler atau edge, Gemma 3n E4B dibangun khusus untuk itu. Tidak ada model lain dalam daftar ini yang menandinginya dalam kategori tersebut. Dan jika Anda ingin tahu persis apa yang Anda kirimkan, setiap sumber data, setiap keputusan pelatihan, SmolLM3-3B adalah satu-satunya pilihan yang sepenuhnya transparan di kelas ini.

Referensi

https://www.kdnuggets.com/best-small-language-models-on-hugging-face-right-now