Cara Menggunakan Qwen 3.5 Small Model Series

TL;DR

Seri Model Kecil Qwen 3.5 dari Alibaba Cloud menawarkan empat model bahasa besar ringkas (dengan 0.8B, 2B, 4B, dan 9B parameter) yang dirancang untuk penyebaran lokal yang efisien, komputasi tepi (edge computing), dan aplikasi AI yang hemat biaya. Model-model ini menyediakan fitur Qwen 3.5 yang mumpuni dalam jejak yang lebih kecil, menjadikannya ideal bagi pengembang yang membutuhkan kemampuan AI tanpa biaya komputasi yang besar dari model yang lebih besar. Anda dapat mengaksesnya melalui ModelScope, HuggingFace, atau layanan API Alibaba Cloud.

Pendahuluan

Model bahasa kecil (SLM) menjadi semakin penting bagi pengembang dan bisnis yang mencari solusi AI yang efisien dan hemat biaya. Seri Model Kecil Qwen 3.5 dari Alibaba mewakili kemajuan signifikan dalam teknologi AI ringkas, menawarkan empat ukuran model berbeda yang menyeimbangkan kinerja dengan efisiensi komputasi.

💡

Saat mengintegrasikan model Qwen 3.5 ke dalam aplikasi Anda, platform pengujian API Apidog membantu Anda membuat pengujian otomatis untuk titik akhir API model Anda, memastikan respons yang benar dan integrasi Anda berfungsi dengan andal. Siapkan pernyataan pengujian untuk struktur respons, latensi, dan penanganan kesalahan.

button

Baik Anda membangun aplikasi untuk perangkat tepi, membutuhkan kemampuan AI lokal untuk operasi yang sensitif privasi, atau ingin mengurangi biaya API cloud, model kecil Qwen 3.5 menyediakan pilihan yang menarik. Model-model ini tersedia melalui beberapa platform termasuk ModelScope dan HuggingFace, membuatnya dapat diakses untuk berbagai skenario pengembangan.

Memahami Model Bahasa Kecil

Model bahasa kecil adalah versi ringkas dari arsitektur LLM yang lebih besar, dirancang untuk berjalan secara efisien pada sumber daya komputasi terbatas sambil mempertahankan kemampuan inti.

Keunggulan utamanya meliputi:

Persyaratan Sumber Daya yang Lebih Rendah

Berjalan pada perangkat keras kelas konsumen
Tidak memerlukan kluster GPU yang mahal
Berfungsi pada perangkat tepi dan IoT

Efisiensi Biaya

Biaya inferensi yang jauh lebih rendah
Tidak ada biaya API per-token saat berjalan secara lokal
Menggunakan lebih sedikit listrik dan pendingin

Privasi dan Keamanan

Data tetap lokal
Tidak ada panggilan API eksternal untuk operasi sensitif
Anda mengontrol data Anda

Manfaat Latensi

Waktu respons lebih cepat tanpa lag jaringan
Pemrosesan waktu nyata
Pengalaman pengguna yang lebih baik untuk aplikasi interaktif

Model kecil Qwen 3.5 mempertahankan kemampuan inti dari arsitektur Qwen 3.5 penuh tetapi bekerja di lingkungan yang terbatas ini.

Ikhtisar Seri Model Kecil Qwen 3.5

Seri Model Kecil Qwen 3.5 terdiri dari empat model, masing-masing dirancang untuk kasus penggunaan dan skenario penyebaran yang berbeda:

Qwen3.5-0.8B

Model paling ringkas dalam seri ini dengan 800 juta parameter. Model ini dirancang khusus untuk:

Lingkungan dengan sumber daya yang sangat terbatas
Sistem tertanam
Aplikasi seluler
Prototyping cepat

Meskipun ukurannya kecil, Qwen3.5-0.8B mempertahankan kemampuan pemahaman bahasa yang wajar yang cocok untuk tugas-tugas dasar seperti klasifikasi teks, percakapan sederhana, dan otomatisasi ringan.

Qwen3.5-2B

Pilihan yang seimbang dengan 2 miliar parameter, menawarkan lompatan kemampuan yang signifikan dibandingkan model 0.8B. Ideal untuk:

Aplikasi desktop standar
Kasus penggunaan bisnis kecil
Lingkungan pengembangan dan pengujian
Aplikasi yang membutuhkan kompleksitas moderat

Model ini memberi Anda keseimbangan yang baik antara kemampuan dan penggunaan sumber daya, yang menjadikannya pilihan paling serbaguna dalam seri ini.

Qwen3.5-4B

Dengan 4 miliar parameter, model ini menyediakan kemampuan substansial sambil tetap dapat diterapkan pada perangkat keras konsumen. Cocok untuk:

Tugas bahasa alami yang lebih kompleks
AI percakapan yang ditingkatkan
Persyaratan pembuatan konten
Tugas penalaran dan analisis

Model 4B mendekati apa yang dapat dilakukan oleh model yang jauh lebih besar sementara masih praktis untuk dijalankan.

Qwen3.5-9B

Model kecil unggulan dengan 9 miliar parameter. Model ini menawarkan:

Kemampuan Qwen 3.5 yang hampir penuh
Penalaran dan analisis yang kompleks
Pembuatan konten berkualitas tinggi
Penyelesaian tugas tingkat lanjut

Terbaik saat Anda membutuhkan keluaran kualitas tertinggi tetapi masih ingin menjalankan semuanya secara lokal.

Spesifikasi dan Kemampuan Model

Memahami spesifikasi teknis membantu dalam memilih model yang tepat untuk kebutuhan Anda:

Model	Parameter	Panjang Konteks	Penggunaan yang Direkomendasikan	Persyaratan Perangkat Keras
Qwen3.5-0.8B	800M	8K-32K	Tugas dasar, prototyping	RAM 2GB+, CPU
Qwen3.5-2B	2B	8K-32K	Aplikasi standar	RAM 4GB+, CPU/iGPU
Qwen3.5-4B	4B	8K-32K	Tugas kompleks	RAM 8GB+, GPU khusus
Qwen3.5-9B	9B	8K-32K	Aplikasi tingkat lanjut	RAM 16GB+, GPU direkomendasikan

Semua model mencakup:

Dukungan multibahasa (Inggris, Mandarin, dan 20+ bahasa lainnya)
Pembuatan dan pemahaman kode
Penalaran matematika
Mengikuti instruksi
Penggunaan alat (versi yang lebih baru)
Panggilan fungsi

Cara Mengakses Model Kecil Qwen 3.5

ModelScope

ModelScope menyediakan akses termudah untuk pengembang Tiongkok dan menawarkan dokumentasi lengkap dalam bahasa Mandarin.

from openai import OpenAI
# Dikkonfigurasi oleh variabel lingkungan
client = OpenAI()

messages = [
    {"role": "user", "content": "Berikan saya pengantar singkat tentang model bahasa besar."},
]

chat_response = client.chat.completions.create(
    model="Qwen/Qwen3.5-2B",
    messages=messages,
    max_tokens=32768,
    temperature=1.0,
    top_p=1.0,
    presence_penalty=2.0,
    extra_body={
        "top_k": 20,
    }, 
)
print("Respons obrolan:", chat_response)

HuggingFace

HuggingFace menyediakan akses global dengan sumber daya komunitas yang luas.

from openai import OpenAI
# Dikkonfigurasi oleh variabel lingkungan
client = OpenAI()

messages = [
    {"role": "user", "content": "Ketik \"Saya suka Qwen3.5\" terbalik"},
]

chat_response = client.chat.completions.create(
    model="Qwen/Qwen3.5-9B",
    messages=messages,
    max_tokens=81920,
    temperature=1.0,
    top_p=0.95,
    presence_penalty=1.5,
    extra_body={
        "top_k": 20,
    }, 
)
print("Respons obrolan:", chat_response)

API Alibaba Cloud

Untuk akses berbasis cloud tanpa penyebaran lokal:

# Menggunakan DashScope API (Alibaba Cloud)
from dashscope import Generation

# Set kunci API
import os
os.environ["DASHSCOPE_API_KEY"] = "kunci-api-anda"

response = Generation.call(
    model="qwen-turbo",
    prompt="Tulis fungsi Python untuk menghitung faktorial",
    max_tokens=500
)

print(response.output.text)

Opsi Penyebaran

Penyebaran Lokal

Hanya CPU (untuk model 0.8B dan 2B):

# Menggunakan Ollama untuk penyebaran lokal yang mudah
ollama pull qwen3.5:9b
ollama run qwen3.5:9b

Akselerasi GPU:

# Dengan dukungan CUDA
pip install torch torchvision torchaudio
pip install transformers accelerate

# Jalankan dengan akselerasi GPU
python qwen_inference.py --model qwen3.5:9b --device cuda

Penyebaran Docker

FROM python:3.11-slim

WORKDIR /app
RUN pip install transformers torch accelerate

COPY inference.py .
CMD ["python", "inference.py"]

Penyebaran Tepi (Edge Deployment)

Untuk perangkat tepi, pertimbangkan untuk menggunakan:

llama.cpp dengan format GGUF untuk inferensi terkuantisasi
MLC-LLM untuk penyebaran seluler
TensorFlow Lite untuk sistem tertanam

Panduan Integrasi API

Server API REST

Buat server API sederhana untuk model yang Anda deploy:

from flask import Flask, request, jsonify
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

app = Flask(__name__)

# Muat model (sesuaikan berdasarkan perangkat keras Anda)
MODEL_NAME = "Qwen/qwen3.5:9b"
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_NAME,
    device_map="auto",
    torch_dtype=torch.float16
)

@app.route('/generate', methods=['POST'])
def generate():
    data = request.json
    prompt = data.get('prompt', '')
    max_tokens = data.get('max_tokens', 512)
    temperature = data.get('temperature', 0.7)

    messages = [{"role": "user", "content": prompt}]
    text = tokenizer.apply_chat_template(
        messages, tokenize=False, add_generation_prompt=True
    )
    inputs = tokenizer([text], return_tensors="pt").to(model.device)

    outputs = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        temperature=temperature,
        do_sample=True
    )

    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return jsonify({"response": response})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Menguji Integrasi Anda dengan Apidog

Saat membangun aplikasi bertenaga AI, pengujian menyeluruh sangat penting. Gunakan Apidog untuk memvalidasi integrasi API Anda:

Buat permintaan POST ke server lokal Anda (misalnya, http://localhost:5000/generate)
Setel Content-Type ke application/json

3. Tambahkan badan permintaan:

{
  "prompt": "Halo dunia!",
  "max_tokens": 100,
  "temperature": 0.7
}

4. Tambahkan pernyataan pengujian di Apidog:

Verifikasi respons berisi bidang "response"
Pastikan waktu respons berada di bawah ambang batas yang dapat diterima
Validasi struktur JSON
Periksa respons tidak kosong

Apidog memungkinkan Anda membuat kasus uji otomatis, menyiapkan pemantauan terjadwal, dan mengatasi masalah sebelum memengaruhi pengguna Anda. Ini sangat penting saat berintegrasi dengan LLM lokal di mana kualitas respons dapat bervariasi berdasarkan konfigurasi perangkat keras dan model.

Kasus Penggunaan dan Panduan Pemilihan

Kapan Menggunakan Qwen3.5-0.8B

IoT dan sistem tertanam dengan sumber daya minimal
Proyek pendidikan dan pembelajaran
Prototyping cepat sebelum ditingkatkan
Skrip otomatisasi sederhana
Aplikasi seluler dengan kemampuan offline

Kapan Menggunakan Qwen3.5-2B

Chatbot tujuan umum
Alat bantuan konten
Aplikasi bisnis kecil
Lingkungan pengembangan dan staging
Otomatisasi dukungan pelanggan

Kapan Menggunakan Qwen3.5-4B

Penjawab pertanyaan kompleks
Pembuatan dan tinjauan kode
Bantuan dokumentasi teknis
Dukungan analisis tingkat lanjut
Tugas penalaran multi-langkah

Kapan Menggunakan Qwen3.5-9B

Pembuatan konten berkualitas tinggi
Penyelesaian masalah kompleks
Bantuan penelitian
Asisten AI tingkat lanjut
Aplikasi tingkat produksi

Praktik Terbaik dan Optimasi

Kuantisasi

Kurangi ukuran model dan tingkatkan kecepatan inferensi:

from transformers import BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-4B",
    quantization_config=quantization_config,
    device_map="auto"
)

Pemrosesan Batch

Untuk throughput yang lebih tinggi:

# Memproses beberapa prompt secara efisien
prompts = [
    "Apa itu pembelajaran mesin?",
    "Jelaskan jaringan saraf",
    "Definisikan pembelajaran mendalam"
]

inputs = tokenizer(prompts, return_tensors="pt", padding=True).to(model.device)
outputs = model.generate(**inputs, max_new_tokens=256)
responses = tokenizer.batch_decode(outputs, skip_special_tokens=True)

Manajemen Memori

# Bersihkan cache GPU saat diperlukan
import torch

# Hanya simpan tensor yang diperlukan dalam memori
model.eval()

# Gunakan gradient checkpointing untuk urutan panjang
from transformers import GradientCheckpointingAuto

# Pantau penggunaan memori
print(f"Memori GPU: {torch.cuda.memory_allocated() / 1e9:.2f} GB")

Kesimpulan

Seri Model Kecil Qwen 3.5 menawarkan pilihan menarik bagi pengembang dan bisnis yang mencari kemampuan AI yang efisien. Baik Anda membutuhkan model 0.8B ultra-kompak untuk perangkat tepi atau model 9B yang lebih besar untuk tugas-tugas kompleks, model-model ini memberikan fleksibilitas tanpa mengorbankan fungsionalitas inti.

Poin-poin penting:

Pilih ukuran model yang tepat berdasarkan perangkat keras dan kebutuhan Anda
Gunakan ModelScope atau HuggingFace untuk akses mudah dan bantuan komunitas
Coba kuantisasi jika Anda membutuhkan kinerja yang lebih baik pada perangkat keras terbatas
Uji API Anda secara menyeluruh sebelum menerapkan
Mulai dari yang kecil dan tingkatkan seiring kebutuhan Anda

Tersedianya model-model ini di berbagai platform berarti Anda dapat menambahkan AI yang mumpuni ke aplikasi Anda sambil tetap menjaga biaya dan data Anda tetap terkendali.

Langkah selanjutnya: Saat mengintegrasikan model Qwen 3.5 ke dalam alur kerja Anda, gunakan Apidog untuk menyiapkan pengujian API yang komprehensif yang memvalidasi respons, mengukur latensi, dan mendeteksi masalah lebih awal. Coba Apidog gratis untuk merampingkan pengujian API AI Anda.

button

FAQ

Apa perbedaan antara model kecil Qwen 3.5 dan Qwen 2.5?

Qwen 3.5 adalah versi terbaru dengan penalaran yang ditingkatkan, dukungan multibahasa yang lebih baik, dan kemampuan penggunaan alat yang lebih canggih. Seri 3.5 juga mencakup peningkatan dalam mengikuti instruksi dan tindakan keamanan.

Bisakah model kecil Qwen 3.5 berjalan hanya di CPU?

Ya, model yang lebih kecil (0.8B dan 2B) dapat berjalan secara efisien pada sistem hanya-CPU. Model 4B dan 9B akan lebih lambat tetapi masih dapat berjalan di CPU dengan RAM yang cukup.

Bagaimana cara memilih di antara ukuran model yang berbeda?

Pertimbangkan batasan perangkat keras Anda, kompleksitas tugas, dan persyaratan latensi. Mulailah dengan model terkecil yang memenuhi kebutuhan kinerja Anda dan tingkatkan jika perlu.

Apakah model ini cocok untuk penggunaan komersial?

Ya, model Qwen Alibaba tersedia di bawah lisensi open-source yang mengizinkan penggunaan komersial. Periksa ketentuan lisensi spesifik di ModelScope atau HuggingFace.

Bisakah saya melakukan fine-tuning pada model kecil Qwen 3.5?

Ya, semua model mendukung fine-tuning. Gunakan teknik seperti LoRA atau QLoRA untuk fine-tuning yang efisien pada perangkat keras konsumen.

Bagaimana perbandingan model kecil Qwen 3.5 dengan SLM lain seperti Phi atau Gemma?

Model Qwen 3.5 menawarkan kinerja yang kompetitif dengan dukungan multibahasa yang kuat. Lakukan benchmark terhadap kasus penggunaan spesifik Anda untuk menentukan yang paling sesuai.

Berapa jendela konteks untuk model ini?

Panjang konteks dasar biasanya 8K-32K token tergantung pada varian dan konfigurasi model tertentu.

Di mana saya bisa menemukan lebih banyak sumber daya dan dukungan komunitas?

Periksa halaman resmi ModelScope dan HuggingFace untuk dokumentasi, contoh, dan diskusi komunitas. Repositori GitHub Qwen juga berisi sumber daya yang luas.