Pengenalan fine-tuning model

Anda dapat menggunakan fine-tuning model di Alibaba Cloud Model Studio jika performa model tidak memenuhi ekspektasi setelah menerapkan metode optimasi seperti rekayasa prompt dan pemanggilan plugin. Sebagai strategi inti untuk meningkatkan performa model, fine-tuning secara signifikan dapat meningkatkan kemampuan model dalam industri atau skenario bisnis tertentu, menyelaraskan outputnya dengan preferensi manusia, serta mengurangi latensi respons. Fine-tuning mencakup tiga metode pelatihan: supervised fine-tuning (SFT), continual pre-training (CPT), dan direct preference optimization (DPO).

Fine-tuning model merupakan metode penting untuk mengoptimalkan performa model. Metode ini dapat:

Meningkatkan performa model dalam industri tertentu atau untuk kebutuhan bisnis spesifik
Mengurangi latensi output model
Menekan halusinasi model
Menyelaraskan model dengan nilai atau preferensi manusia
Menggantikan model besar dengan model ringan hasil fine-tuning

Selama proses fine-tuning, model mempelajari fitur-fitur spesifik bisnis atau skenario dari data pelatihan, seperti pengetahuan, nada, gaya ekspresi, dan kesadaran diri. Karena model telah mempelajari banyak contoh untuk industri atau skenario tertentu selama pelatihan, performa prompt one-shot atau zero-shot setelah pelatihan lebih baik dibandingkan performa few-shot sebelum pelatihan. Hal ini menghemat token input dan mengurangi latensi output model.

Proses fine-tuning model

Untuk informasi lebih lanjut, lihat:

Model yang didukung

Model yang didukung

Singapura

Generasi teks

Nama model	Kode model	Pelatihan parameter penuh SFT (sft)	Pelatihan efisien SFT (efficient_sft)
Qwen3-14B	qwen3-14b	×	Supported

Pemahaman visual (Qwen-VL)

Nama model	Kode model	Pelatihan parameter penuh SFT (sft)	Pelatihan efisien SFT (efficient_sft)
-	-	-	-

North China 2 (Beijing)

Generasi teks

Layanan model	Kode model	Pelatihan parameter penuh CPT (cpt)	Pelatihan parameter penuh SFT (sft)	Pelatihan efisien SFT (efficient_sft)	Pelatihan parameter penuh DPO (dpo_full)	Pelatihan efisien DPO (dpo_lora)
Qwen3.6-Flash-2026-04-16	qwen3.6-flash-2026-04-16	×	Supported	×	×	×

Qwen3.5-27B	qwen3.5-27b	×	Supported	Supported	×	×
Qwen3.5-9B	qwen3.5-9b	×	Supported	Supported	×	×
Qwen3.5-Flash-2026-02-23	qwen3.5-flash-2026-02-23	×	Supported	×	×	×

Qwen3-32B	qwen3-32b	Supported	Supported	Supported	Supported	Supported
Qwen3-30B-A3B-Instruct-2507	qwen3-30b-a3b-instruct-2507	Supported	Supported	Supported	×	×
Qwen3-14B	qwen3-14b	×	Supported	Supported	Supported	Supported
Qwen3-8B	qwen3-8b	×	Supported	Supported	Supported	Supported
Qwen3-4B-Instruct-2507	qwen3-4b-instruct-2507	Supported	Supported	Supported	Supported	Supported
Qwen3-1.7B	qwen3-1.7b	Supported	Supported	Supported	Supported	Supported
Qwen3-0.6B	qwen3-0.6b	Supported	Supported	Supported	Supported	Supported

Qwen2.5-72B-Instruct	qwen2.5-72b-instruct	Supported	Supported	Supported	Supported	Supported
Qwen2.5-32B-Instruct	qwen2.5-32b-instruct	Supported	Supported	Supported	Supported	Supported
Qwen2.5-14B-Instruct	qwen2.5-14b-instruct	Supported	Supported	Supported	Supported	Supported
Qwen2.5-7B-Instruct	qwen2.5-7b-instruct	Supported	Supported	Supported	Supported	Supported

Qwen-Plus-Character-2025-11-06	qwen-plus-character-2025-11-06	×	Supported	Supported	Supported	Supported

Pemahaman visual (Qwen-VL)

Layanan model	Kode model	Pelatihan parameter penuh CPT (cpt)	Pelatihan parameter penuh SFT (sft)	Pelatihan efisien SFT (efficient_sft)	Pelatihan parameter penuh DPO (dpo_full)	Pelatihan efisien DPO (dpo_lora)
Qwen3-VL-8B-Instruct	qwen3-vl-8b-instruct	×	Supported	Supported	×	×
Qwen3-VL-8B-Thinking	qwen3-vl-8b-thinking	×	Supported	Supported	×	×
Qwen3-VL-4B-Instruct	qwen3-vl-4b-instruct	×	Supported	Supported	×	×

Qwen2.5-VL-72B-Instruct	qwen2.5-vl-72b-instruct	×	Supported	Supported	×	×
Qwen2.5-VL-32B-Instruct	qwen2.5-vl-32b-instruct	×	Supported	Supported	×	×
Qwen2.5-VL-7B-Instruct	qwen2.5-vl-7b-instruct	×	Supported	Supported	×	×

Perbandingan metode tuning

Fitur	CPT (Continual Pre-training)	SFT (Supervised Fine-tuning)	DPO (Direct Preference Optimization)
Rangkuman	Menambahkan pengetahuan (Menyuntikkan pengetahuan domain)	Belajar melakukan tugas (Mengikuti instruksi)	Menjalankan tugas lebih baik (Menyelaraskan dengan preferensi manusia)
Data input	Lebih dari 10 juta token Teks domain tanpa label	Lebih dari 1.000 entri Pasangan "pertanyaan-jawaban" berkualitas tinggi	Lebih dari 100 set Pasangan respons "lebih baik-lebih buruk" untuk instruksi yang sama
Tujuan utama	Adaptasi domain. Mempelajari kosakata dan fakta khusus.	Mengajarkan model format percakapan dan kemampuan menjalankan tugas.	Menyelaraskan output model lebih baik dengan nilai dan preferensi manusia.
Metode pembelajaran	Pembelajaran self-supervised (Memprediksi kata berikutnya)	Supervised learning (Meniru ground truth)	Pembelajaran preferensi langsung (Meningkatkan probabilitas respons baik dan mengurangi probabilitas respons buruk)
Tahap model	Umumnya sebelum SFT	Setelah CPT dan sebelum DPO	Umumnya setelah SFT, sebagai langkah akhir untuk penyelarasan.

Perbandingan pola pelatihan

Pelatihan parameter penuh

Pelatihan efisien (LoRA, direkomendasikan)

Skenario

• Model perlu mendapatkan kemampuan baru

• Mencapai performa global optimal.

• Mengoptimalkan performa model untuk skenario tertentu.

• Untuk skenario yang sensitif terhadap biaya dan waktu.

Waktu pelatihan

Lebih lama, dengan konvergensi lebih lambat.

Lebih singkat, dengan konvergensi lebih cepat.

Penagihan

Metode penagihan

Pay-as-you-go berdasarkan jumlah data pelatihan

Rumus penagihan

Biaya pelatihan model = (Total token dalam data pelatihan + Total token dalam data pelatihan campuran) × Jumlah epoch × Harga satuan pelatihan (Unit penagihan minimum: 1 token)

Anda dapat melihat perkiraan biaya pelatihan di bagian bawah Konsol Fine-tuning Model dan klik Computing Details untuk melihat total jumlah token pelatihan, jumlah epoch, dan harga satuan pelatihan.

Harga satuan pelatihan

Tabel berikut mencantumkan harga satuan pelatihan untuk model bawaan. Harga satuan pelatihan untuk model kustom sama dengan model bawaan yang sesuai.

Singapura

Qwen

Layanan model	Kode model	Harga
Qwen3-14B	qwen3-14b	$0,0016/1.000 token

Qwen-VL

Layanan model	Kode model	Harga
-	-	-

Menghitung token untuk gambar dan video

Rumus: Token Gambar = h_bar * w_bar / token_pixels + 2

h_bar, w_bar: Tinggi dan lebar gambar yang diskalakan. Sebelum memproses gambar, model melakukan pra-pemrosesan untuk mengecilkan ukurannya hingga batas piksel tertentu. Batas ini bergantung pada nilai parameter max_pixels dan vl_high_resolution_images. Untuk informasi lebih lanjut, lihat Memproses gambar resolusi tinggi.
token_pixels: Nilai piksel yang sesuai dengan setiap token visual. Nilai ini bervariasi tergantung model:
- qwen3.7-series, qwen3.6-series, qwen3.5-series, Qwen3-VL, qwen-vl-max, dan qwen-vl-plus: Setiap token sesuai dengan 32x32 piksel.
- QVQ dan model Qwen2.5-VL lainnya: Setiap token sesuai dengan 28x28 piksel.

Kode berikut menunjukkan logika penskalaan gambar perkiraan yang digunakan model. Gunakan kode ini untuk memperkirakan token gambar. Untuk penagihan aktual, rujuk respons API.

import math
from PIL import Image  # pip install Pillow

def smart_size(image_path, max_pixels, vl_high_resolution_images):
    """Menghitung dimensi gambar yang diskalakan berdasarkan parameter model untuk memperkirakan token gambar."""
    image = Image.open(image_path)
    height, width = image.height, image.width

    # Faktor penskalaan adalah 32 untuk model seperti Qwen3.6, Qwen3.5, dan Qwen3-VL. Untuk model lain, nilainya 28.
    factor = 32
    h_bar = round(height / factor) * factor
    w_bar = round(width / factor) * factor

    # Batas bawah token: 4 token
    min_pixels = 4 * factor * factor

    # Jika vl_high_resolution_images=True, batas atas token tetap di 16384, dan max_pixels diabaikan.
    if vl_high_resolution_images:
        max_pixels = 16384 * factor * factor

    # Membatasi jumlah total piksel dalam rentang [min_pixels, max_pixels].
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = math.floor(height / beta / factor) * factor
        w_bar = math.floor(width / beta / factor) * factor
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = math.ceil(height * beta / factor) * factor
        w_bar = math.ceil(width * beta / factor) * factor

    return h_bar, w_bar

if __name__ == "__main__":
    # Catatan: Nilai max_pixels dan vl_high_resolution_images harus sesuai dengan parameter yang dilewatkan saat memanggil model.
    h_bar, w_bar = smart_size("xxx/test.jpg", max_pixels=2560 * 32 * 32, vl_high_resolution_images=False)
    print(f"Dimensi gambar yang diskalakan: Tinggi {h_bar}, Lebar {w_bar}")

    # Setiap gambar mencakup satu token <vision_bos> dan satu token <vision_eos>.
    token = int(h_bar * w_bar / (32 * 32)) + 2
    print(f"Jumlah token gambar: {token}")

File video:

Saat memproses file video, model terlebih dahulu mengekstraksi frame, lalu menghitung total token untuk semua frame video. Karena perhitungan ini kompleks, Anda dapat menggunakan kode berikut untuk memperkirakan total konsumsi token video dengan memberikan path-nya:

# Sebelum digunakan, instal: pip install opencv-python
import math
import os
import logging
import cv2

logger = logging.getLogger(__name__)

FRAME_FACTOR = 2

# Untuk model seperti Qwen3.6, Qwen3.5, Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, dan qwen-vl-plus-0710, faktor penskalaan gambar adalah 32.
IMAGE_FACTOR = 32

# Untuk model lain, faktor penskalaan gambar adalah 28.
# IMAGE_FACTOR = 28

# Rasio aspek maksimum untuk frame video
MAX_RATIO = 200
# Batas bawah piksel untuk frame video
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Batas atas piksel untuk frame video. Untuk model Qwen3-VL-Plus, VIDEO_MAX_PIXELS adalah 640 * 32 * 32. Untuk model lain, nilainya 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# Jika pengguna tidak melewatkan parameter FPS, nilai default digunakan untuk fps.
FPS = 2.0
# Jumlah minimum frame yang diekstraksi
FPS_MIN_FRAMES = 4
# Jumlah maksimum frame yang diekstraksi (ditentukan berdasarkan model yang dipilih)
FPS_MAX_FRAMES = 2000

# Nilai piksel maksimum untuk input video. Untuk model Qwen3-VL-Plus, set VIDEO_TOTAL_PIXELS ke 131072 * 32 * 32. Untuk model lain, set ke 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_MAX_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terdekat dengan 'number' yang habis dibagi 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terkecil yang lebih besar atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terbesar yang lebih kecil atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.floor(number / factor) * factor

def extract_vision_info(conversations):
    vision_infos = []
    if isinstance(conversations[0], dict):
        conversations = [conversations]
    for conversation in conversations:
        for message in conversation:
            if isinstance(message["content"], list):
                for ele in message["content"]:
                    if (
                        "image" in ele
                        or "image_url" in ele
                        or "video" in ele
                        or ele.get("type","") in ("image", "image_url", "video")
                    ):
                        vision_infos.append(ele)
    return vision_infos

def smart_nframes(ele,total_frames,video_fps):
    """Menghitung jumlah frame video yang diekstraksi.

    Args:
        ele (dict): Kamus yang berisi konfigurasi video.
            - fps: Mengontrol jumlah frame input yang diekstraksi untuk model.
        total_frames (int): Jumlah total frame asli dalam video.
        video_fps (int | float): Frame rate asli video.

    Raises:
        Kesalahan dilaporkan jika nframes tidak berada dalam interval [FRAME_FACTOR, total_frames].

    Returns:
        Jumlah frame video untuk input model.
    """
    assert not ("fps" in ele and "nframes" in ele), "Hanya menerima salah satu `fps` atau `nframes`"
    fps = ele.get("fps", FPS)
    min_frames = ceil_by_factor(ele.get("min_frames", FPS_MIN_FRAMES), FRAME_FACTOR)
    max_frames = floor_by_factor(ele.get("max_frames", min(FPS_MAX_FRAMES, total_frames)), FRAME_FACTOR)
    duration = total_frames / video_fps if video_fps != 0 else 0
    if duration-int(duration)>(1/fps):
        total_frames = math.ceil(duration * video_fps)
    else:
        total_frames = math.ceil(int(duration)*video_fps)
    nframes = total_frames / video_fps * fps
    if nframes > total_frames:
        logger.warning(f"smart_nframes: nframes[{nframes}] > total_frames[{total_frames}]")
    nframes = int(min(min(max(nframes, min_frames), max_frames), total_frames))
    if not (FRAME_FACTOR <= nframes and nframes <= total_frames):
        raise ValueError(f"nframes harus dalam interval [{FRAME_FACTOR}, {total_frames}], tetapi mendapat {nframes}.")

    return nframes

def get_video(video_path):
    # Mendapatkan informasi video
    cap = cv2.VideoCapture(video_path)

    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    # Mendapatkan tinggi video
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

    video_fps = cap.get(cv2.CAP_PROP_FPS)
    return frame_height, frame_width, total_frames, video_fps

def smart_resize(ele, path, factor=IMAGE_FACTOR):
    # Mendapatkan lebar dan tinggi asli video
    height, width, total_frames, video_fps = get_video(path)
    # Batas bawah token untuk frame video
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Jumlah frame video yang diekstraksi
    nframes = smart_nframes(ele, total_frames, video_fps)
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR),int(min_pixels * 1.05))

    # Rasio aspek video tidak boleh melebihi 200:1 atau 1:200.
    if max(height, width) / min(height, width) > MAX_RATIO:
        raise ValueError(
            f"rasio aspek absolut harus lebih kecil dari {MAX_RATIO}, mendapat {max(height, width) / min(height, width)}"
        )

    h_bar = max(factor, round_by_factor(height, factor))
    w_bar = max(factor, round_by_factor(width, factor))
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = floor_by_factor(height / beta, factor)
        w_bar = floor_by_factor(width / beta, factor)
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = ceil_by_factor(height * beta, factor)
        w_bar = ceil_by_factor(width * beta, factor)
    return h_bar, w_bar

def token_calculate(video_path, fps):
    # Melewatkan path video dan parameter ekstraksi frame fps.
    messages = [{"content": [{"video": video_path, "fps": fps}]}]
    vision_infos = extract_vision_info(messages)[0]

    resized_height, resized_width = smart_resize(vision_infos, video_path)

    height, width, total_frames, video_fps = get_video(video_path)
    num_frames = smart_nframes(vision_infos, total_frames, video_fps)
    print(f"Dimensi video asli: {height}*{width}, Dimensi input model: {resized_height}*{resized_width}, Total frame video: {total_frames}, Total frame yang diekstraksi saat fps {fps}: {num_frames}", end=", ")
    video_token = int(math.ceil(num_frames / 2) * resized_height / 32 * resized_width / 32)
    video_token += 2   # Sistem secara otomatis menambahkan penanda visual <|vision_bos|> dan <|vision_eos|> (masing-masing 1 token).
    return video_token

video_token = token_calculate("xxx/test.mp4", 1)
print("Token video:", video_token)

Daftar gambar:

Saat video dilewatkan sebagai daftar gambar, artinya ekstraksi frame telah dilakukan. Gunakan kode berikut untuk menghitung konsumsi token dengan memberikan path dan jumlah gambar:

# Sebelum digunakan, instal: pip install Pillow
import math
import os
import logging
from typing import Tuple
from PIL import Image

logger = logging.getLogger(__name__)

# ==================== Definisi Konstanta ====================
FRAME_FACTOR = 2
# Untuk model seperti Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, dan qwen-vl-plus-0710, faktor penskalaan adalah 32.
IMAGE_FACTOR = 32

# Untuk model lain, faktor penskalaan adalah 28.
# IMAGE_FACTOR = 28

# Konstanta untuk perhitungan token
TOKEN_DIVISOR = 32  # Pembagi untuk perhitungan token
VISION_SPECIAL_TOKENS = 2  # Penanda <|vision_bos|> dan <|vision_eos|>

# Rasio aspek maksimum untuk frame video
MAX_RATIO = 200
# Batas bawah piksel untuk frame video
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Batas atas piksel untuk frame video. Untuk model Qwen3-VL-Plus, VIDEO_MAX_PIXELS adalah 640 * 32 * 32. Untuk model lain, nilainya 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# Nilai piksel maksimum untuk input video. Untuk model Qwen3-VL-Plus, set VIDEO_TOTAL_PIXELS ke 131072 * 32 * 32. Untuk model lain, set ke 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_MAX_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terdekat dengan 'number' yang habis dibagi 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terkecil yang lebih besar atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terbesar yang lebih kecil atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.floor(number / factor) * factor

def get_image_size(image_path: str) -> Tuple[int, int]:
    if not os.path.exists(image_path):
        raise FileNotFoundError(f"File gambar tidak ditemukan: {image_path}")

    try:
        image = Image.open(image_path)
        height = image.height
        width = image.width
        image.close()  # Tutup file segera
        return height, width
    except Exception as e:
        raise ValueError(f"Tidak dapat membaca file gambar {image_path}: {str(e)}")

def smart_resize(height: int, width: int, nframes: int, factor: int = IMAGE_FACTOR) -> Tuple[int, int]:
    """
    Menghitung dimensi gambar yang diskalakan

    Args:
        height: Tinggi gambar asli
        width: Lebar gambar asli
        nframes: Jumlah frame video
        factor: Faktor penskalaan, default ke IMAGE_FACTOR

    Returns:
        (resized_height, resized_width) Tinggi dan lebar yang diskalakan

    Raises:
        ValueError: Rasio aspek melebihi batas
    """
    # Batas bawah token untuk frame video
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Jumlah frame video yang diekstraksi
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))

    # Rasio aspek video tidak boleh melebihi 200:1 atau 1:200.
    aspect_ratio = max(height, width) / min(height, width)
    if aspect_ratio > MAX_RATIO:
        raise ValueError(
            f"Rasio aspek gambar harus kurang dari {MAX_RATIO}:1, tetapi saat ini {aspect_ratio:.2f}:1"
        )

    h_bar = max(factor, round_by_factor(height, factor))
    w_bar = max(factor, round_by_factor(width, factor))
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = floor_by_factor(height / beta, factor)
        w_bar = floor_by_factor(width / beta, factor)
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = ceil_by_factor(height * beta, factor)
        w_bar = ceil_by_factor(width * beta, factor)
    return h_bar, w_bar

def calculate_video_tokens(image_path: str, nframes: int = 1, factor: int = IMAGE_FACTOR, verbose: bool = True) -> int:
    """

    Args:
        image_path: Path ke file frame video
        nframes: Jumlah frame video,
        factor: Faktor penskalaan, default ke IMAGE_FACTOR
        verbose: Apakah akan mencetak informasi detail

    Returns:
        Jumlah token yang dikonsumsi

    Raises:
        FileNotFoundError: File tidak ada
        ValueError: Format file tidak valid atau rasio aspek melebihi batas
    """
    # Mendapatkan dimensi gambar asli (baca hanya sekali)
    height, width = get_image_size(image_path)

    # Menghitung dimensi yang diskalakan
    resized_height, resized_width = smart_resize(height, width, nframes, factor)

    # Menghitung jumlah token
    # Rumus: ceil(nframes/2) * (height/TOKEN_DIVISOR) * (width/TOKEN_DIVISOR) + VISION_SPECIAL_TOKENS
    video_token = int(
        math.ceil(nframes / 2) *
        (resized_height / TOKEN_DIVISOR) *
        (resized_width / TOKEN_DIVISOR)
    )
    # Menambahkan token penanda visual (<|vision_bos|> dan <|vision_eos|>)
    video_token += VISION_SPECIAL_TOKENS

    if verbose:
        print(f"Dimensi frame video asli: {height}x{width}, Dimensi input model: {resized_height}x{resized_width}, ", end="")

    return video_token

if __name__ == "__main__":
    try:
        video_token = calculate_video_tokens("xxx/test.jpg", nframes=30)
        print(f"Token video: {video_token}\n")
    except Exception as e:
        print(f"Error: {str(e)}\n")

North China 2 (Beijing)

Qwen

Layanan model	Kode model	Harga
Qwen3.5-27B	qwen3.5-27b	$0,006876/1.000 token
Qwen3.5-9B	qwen3.5-9b	$0,00275/1.000 token

Qwen3-32B	qwen3-32b	$0,005501/1.000 token
Qwen3-30B-A3B-Instruct-2507	qwen3-30b-a3b-instruct-2507	$0,004126/1.000 token
Qwen3-14B	qwen3-14b	$0,004126/1.000 token
Qwen3-8B	qwen3-8b	$0,000825/1.000 token
Qwen3-4B-Instruct-2507	qwen3-4b-instruct-2507	$0,000825/1.000 token
Qwen3-1.7B	qwen3-1.7b	$0,000619/1.000 token
Qwen3-0.6B	qwen3-0.6b	$0,000413/1.000 token

Qwen2.5-72B-Instruct	qwen2.5-72b-instruct	$0,020628/1.000 token
Qwen2.5-32B-Instruct	qwen2.5-32b-instruct	$0,004126/1.000 token
Qwen2.5-14B-Instruct	qwen2.5-14b-instruct	$0,004126/1.000 token
Qwen2.5-7B-Instruct	qwen2.5-7b-instruct	$0,000825/1.000 token

Qwen-Plus-Character-2025-11-06	qwen-plus-character-2025-11-06	$0,020628/1.000 token

Qwen-VL

Layanan model	Kode model	Harga
Qwen3-VL-8B-Instruct	qwen3-vl-8b-instruct	$0,00165/1.000 token
Qwen3-VL-8B-Thinking	qwen3-vl-8b-thinking	$0,00165/1.000 token
Qwen3-VL-4B-Instruct	qwen3-vl-4b-instruct	$0,000825/1.000 token

Qwen2.5-VL-72B-Instruct	qwen2.5-vl-72b-instruct	$0,006876/1.000 token
Qwen2.5-VL-32B-Instruct	qwen2.5-vl-32b-instruct	$0,00275/1.000 token
Qwen2.5-VL-7B-Instruct	qwen2.5-vl-7b-instruct	$0,001375/1.000 token

Menghitung token untuk gambar dan video

Gambar

Rumus: Token Gambar = h_bar * w_bar / token_pixels + 2

h_bar, w_bar: Tinggi dan lebar gambar yang diskalakan. Sebelum memproses gambar, model melakukan pra-pemrosesan untuk mengecilkan ukurannya hingga batas piksel tertentu. Batas ini bergantung pada nilai parameter max_pixels dan vl_high_resolution_images. Untuk informasi lebih lanjut, lihat Memproses gambar resolusi tinggi.
token_pixels: Nilai piksel yang sesuai dengan setiap token visual. Nilai ini bervariasi tergantung model:
- qwen3.7-series, qwen3.6-series, qwen3.5-series, Qwen3-VL, qwen-vl-max, dan qwen-vl-plus: Setiap token sesuai dengan 32x32 piksel.
- QVQ dan model Qwen2.5-VL lainnya: Setiap token sesuai dengan 28x28 piksel.

Kode berikut menunjukkan logika penskalaan gambar perkiraan yang digunakan model. Gunakan kode ini untuk memperkirakan token gambar. Untuk penagihan aktual, rujuk respons API.

import math
from PIL import Image  # pip install Pillow

def smart_size(image_path, max_pixels, vl_high_resolution_images):
    """Menghitung dimensi gambar yang diskalakan berdasarkan parameter model untuk memperkirakan token gambar."""
    image = Image.open(image_path)
    height, width = image.height, image.width

    # Faktor penskalaan adalah 32 untuk model seperti Qwen3.6, Qwen3.5, dan Qwen3-VL. Untuk model lain, nilainya 28.
    factor = 32
    h_bar = round(height / factor) * factor
    w_bar = round(width / factor) * factor

    # Batas bawah token: 4 token
    min_pixels = 4 * factor * factor

    # Jika vl_high_resolution_images=True, batas atas token tetap di 16384, dan max_pixels diabaikan.
    if vl_high_resolution_images:
        max_pixels = 16384 * factor * factor

    # Membatasi jumlah total piksel dalam rentang [min_pixels, max_pixels].
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = math.floor(height / beta / factor) * factor
        w_bar = math.floor(width / beta / factor) * factor
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = math.ceil(height * beta / factor) * factor
        w_bar = math.ceil(width * beta / factor) * factor

    return h_bar, w_bar

if __name__ == "__main__":
    # Catatan: Nilai max_pixels dan vl_high_resolution_images harus sesuai dengan parameter yang dilewatkan saat memanggil model.
    h_bar, w_bar = smart_size("xxx/test.jpg", max_pixels=2560 * 32 * 32, vl_high_resolution_images=False)
    print(f"Dimensi gambar yang diskalakan: Tinggi {h_bar}, Lebar {w_bar}")

    # Setiap gambar mencakup satu token <vision_bos> dan satu token <vision_eos>.
    token = int(h_bar * w_bar / (32 * 32)) + 2
    print(f"Jumlah token gambar: {token}")

Video

File video:

# Sebelum digunakan, instal: pip install opencv-python
import math
import os
import logging
import cv2

logger = logging.getLogger(__name__)

FRAME_FACTOR = 2

# Untuk model seperti Qwen3.6, Qwen3.5, Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, dan qwen-vl-plus-0710, faktor penskalaan gambar adalah 32.
IMAGE_FACTOR = 32

# Untuk model lain, faktor penskalaan gambar adalah 28.
# IMAGE_FACTOR = 28

# Rasio aspek maksimum untuk frame video
MAX_RATIO = 200
# Batas bawah piksel untuk frame video
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Batas atas piksel untuk frame video. Untuk model Qwen3-VL-Plus, VIDEO_MAX_PIXELS adalah 640 * 32 * 32. Untuk model lain, nilainya 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# Jika pengguna tidak melewatkan parameter FPS, nilai default digunakan untuk fps.
FPS = 2.0
# Jumlah minimum frame yang diekstraksi
FPS_MIN_FRAMES = 4
# Jumlah maksimum frame yang diekstraksi (ditentukan berdasarkan model yang dipilih)
FPS_MAX_FRAMES = 2000

# Nilai piksel maksimum untuk input video. Untuk model Qwen3-VL-Plus, set VIDEO_TOTAL_PIXELS ke 131072 * 32 * 32. Untuk model lain, set ke 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_MAX_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terdekat dengan 'number' yang habis dibagi 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terkecil yang lebih besar atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terbesar yang lebih kecil atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.floor(number / factor) * factor

def extract_vision_info(conversations):
    vision_infos = []
    if isinstance(conversations[0], dict):
        conversations = [conversations]
    for conversation in conversations:
        for message in conversation:
            if isinstance(message["content"], list):
                for ele in message["content"]:
                    if (
                        "image" in ele
                        or "image_url" in ele
                        or "video" in ele
                        or ele.get("type","") in ("image", "image_url", "video")
                    ):
                        vision_infos.append(ele)
    return vision_infos

def smart_nframes(ele,total_frames,video_fps):
    """Menghitung jumlah frame video yang diekstraksi.

    Args:
        ele (dict): Kamus yang berisi konfigurasi video.
            - fps: Mengontrol jumlah frame input yang diekstraksi untuk model.
        total_frames (int): Jumlah total frame asli dalam video.
        video_fps (int | float): Frame rate asli video.

    Raises:
        Kesalahan dilaporkan jika nframes tidak berada dalam interval [FRAME_FACTOR, total_frames].

    Returns:
        Jumlah frame video untuk input model.
    """
    assert not ("fps" in ele and "nframes" in ele), "Hanya menerima salah satu `fps` atau `nframes`"
    fps = ele.get("fps", FPS)
    min_frames = ceil_by_factor(ele.get("min_frames", FPS_MIN_FRAMES), FRAME_FACTOR)
    max_frames = floor_by_factor(ele.get("max_frames", min(FPS_MAX_FRAMES, total_frames)), FRAME_FACTOR)
    duration = total_frames / video_fps if video_fps != 0 else 0
    if duration-int(duration)>(1/fps):
        total_frames = math.ceil(duration * video_fps)
    else:
        total_frames = math.ceil(int(duration)*video_fps)
    nframes = total_frames / video_fps * fps
    if nframes > total_frames:
        logger.warning(f"smart_nframes: nframes[{nframes}] > total_frames[{total_frames}]")
    nframes = int(min(min(max(nframes, min_frames), max_frames), total_frames))
    if not (FRAME_FACTOR <= nframes and nframes <= total_frames):
        raise ValueError(f"nframes harus dalam interval [{FRAME_FACTOR}, {total_frames}], tetapi mendapat {nframes}.")

    return nframes

def get_video(video_path):
    # Mendapatkan informasi video
    cap = cv2.VideoCapture(video_path)

    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    # Mendapatkan tinggi video
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

    video_fps = cap.get(cv2.CAP_PROP_FPS)
    return frame_height, frame_width, total_frames, video_fps

def smart_resize(ele, path, factor=IMAGE_FACTOR):
    # Mendapatkan lebar dan tinggi asli video
    height, width, total_frames, video_fps = get_video(path)
    # Batas bawah token untuk frame video
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Jumlah frame video yang diekstraksi
    nframes = smart_nframes(ele, total_frames, video_fps)
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR),int(min_pixels * 1.05))

    # Rasio aspek video tidak boleh melebihi 200:1 atau 1:200.
    if max(height, width) / min(height, width) > MAX_RATIO:
        raise ValueError(
            f"rasio aspek absolut harus lebih kecil dari {MAX_RATIO}, mendapat {max(height, width) / min(height, width)}"
        )

    h_bar = max(factor, round_by_factor(height, factor))
    w_bar = max(factor, round_by_factor(width, factor))
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = floor_by_factor(height / beta, factor)
        w_bar = floor_by_factor(width / beta, factor)
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = ceil_by_factor(height * beta, factor)
        w_bar = ceil_by_factor(width * beta, factor)
    return h_bar, w_bar

def token_calculate(video_path, fps):
    # Melewatkan path video dan parameter ekstraksi frame fps.
    messages = [{"content": [{"video": video_path, "fps": fps}]}]
    vision_infos = extract_vision_info(messages)[0]

    resized_height, resized_width = smart_resize(vision_infos, video_path)

    height, width, total_frames, video_fps = get_video(video_path)
    num_frames = smart_nframes(vision_infos, total_frames, video_fps)
    print(f"Dimensi video asli: {height}*{width}, Dimensi input model: {resized_height}*{resized_width}, Total frame video: {total_frames}, Total frame yang diekstraksi saat fps {fps}: {num_frames}", end=", ")
    video_token = int(math.ceil(num_frames / 2) * resized_height / 32 * resized_width / 32)
    video_token += 2   # Sistem secara otomatis menambahkan penanda visual <|vision_bos|> dan <|vision_eos|> (masing-masing 1 token).
    return video_token

video_token = token_calculate("xxx/test.mp4", 1)
print("Token video:", video_token)

Daftar gambar:

Saat video dilewatkan sebagai daftar gambar, artinya ekstraksi frame telah dilakukan. Gunakan kode berikut untuk menghitung konsumsi token dengan memberikan path dan jumlah gambar:

# Sebelum digunakan, instal: pip install Pillow
import math
import os
import logging
from typing import Tuple
from PIL import Image

logger = logging.getLogger(__name__)

# ==================== Definisi Konstanta ====================
FRAME_FACTOR = 2
# Untuk model seperti Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, dan qwen-vl-plus-0710, faktor penskalaan adalah 32.
IMAGE_FACTOR = 32

# Untuk model lain, faktor penskalaan adalah 28.
# IMAGE_FACTOR = 28

# Konstanta untuk perhitungan token
TOKEN_DIVISOR = 32  # Pembagi untuk perhitungan token
VISION_SPECIAL_TOKENS = 2  # Penanda <|vision_bos|> dan <|vision_eos|>

# Rasio aspek maksimum untuk frame video
MAX_RATIO = 200
# Batas bawah piksel untuk frame video
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Batas atas piksel untuk frame video. Untuk model Qwen3-VL-Plus, VIDEO_MAX_PIXELS adalah 640 * 32 * 32. Untuk model lain, nilainya 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# Nilai piksel maksimum untuk input video. Untuk model Qwen3-VL-Plus, set VIDEO_TOTAL_PIXELS ke 131072 * 32 * 32. Untuk model lain, set ke 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_MAX_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terdekat dengan 'number' yang habis dibagi 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terkecil yang lebih besar atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Mengembalikan bilangan bulat terbesar yang lebih kecil atau sama dengan 'number' dan habis dibagi 'factor'."""
    return math.floor(number / factor) * factor

def get_image_size(image_path: str) -> Tuple[int, int]:
    if not os.path.exists(image_path):
        raise FileNotFoundError(f"File gambar tidak ditemukan: {image_path}")

    try:
        image = Image.open(image_path)
        height = image.height
        width = image.width
        image.close()  # Tutup file segera
        return height, width
    except Exception as e:
        raise ValueError(f"Tidak dapat membaca file gambar {image_path}: {str(e)}")

def smart_resize(height: int, width: int, nframes: int, factor: int = IMAGE_FACTOR) -> Tuple[int, int]:
    """
    Menghitung dimensi gambar yang diskalakan

    Args:
        height: Tinggi gambar asli
        width: Lebar gambar asli
        nframes: Jumlah frame video
        factor: Faktor penskalaan, default ke IMAGE_FACTOR

    Returns:
        (resized_height, resized_width) Tinggi dan lebar yang diskalakan

    Raises:
        ValueError: Rasio aspek melebihi batas
    """
    # Batas bawah token untuk frame video
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Jumlah frame video yang diekstraksi
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))

    # Rasio aspek video tidak boleh melebihi 200:1 atau 1:200.
    aspect_ratio = max(height, width) / min(height, width)
    if aspect_ratio > MAX_RATIO:
        raise ValueError(
            f"Rasio aspek gambar harus kurang dari {MAX_RATIO}:1, tetapi saat ini {aspect_ratio:.2f}:1"
        )

    h_bar = max(factor, round_by_factor(height, factor))
    w_bar = max(factor, round_by_factor(width, factor))
    if h_bar * w_bar > max_pixels:
        beta = math.sqrt((height * width) / max_pixels)
        h_bar = floor_by_factor(height / beta, factor)
        w_bar = floor_by_factor(width / beta, factor)
    elif h_bar * w_bar < min_pixels:
        beta = math.sqrt(min_pixels / (height * width))
        h_bar = ceil_by_factor(height * beta, factor)
        w_bar = ceil_by_factor(width * beta, factor)
    return h_bar, w_bar

def calculate_video_tokens(image_path: str, nframes: int = 1, factor: int = IMAGE_FACTOR, verbose: bool = True) -> int:
    """

    Args:
        image_path: Path ke file frame video
        nframes: Jumlah frame video,
        factor: Faktor penskalaan, default ke IMAGE_FACTOR
        verbose: Apakah akan mencetak informasi detail

    Returns:
        Jumlah token yang dikonsumsi

    Raises:
        FileNotFoundError: File tidak ada
        ValueError: Format file tidak valid atau rasio aspek melebihi batas
    """
    # Mendapatkan dimensi gambar asli (baca hanya sekali)
    height, width = get_image_size(image_path)

    # Menghitung dimensi yang diskalakan
    resized_height, resized_width = smart_resize(height, width, nframes, factor)

    # Menghitung jumlah token
    # Rumus: ceil(nframes/2) * (height/TOKEN_DIVISOR) * (width/TOKEN_DIVISOR) + VISION_SPECIAL_TOKENS
    video_token = int(
        math.ceil(nframes / 2) *
        (resized_height / TOKEN_DIVISOR) *
        (resized_width / TOKEN_DIVISOR)
    )
    # Menambahkan token penanda visual (<|vision_bos|> dan <|vision_eos|>)
    video_token += VISION_SPECIAL_TOKENS

    if verbose:
        print(f"Dimensi frame video asli: {height}x{width}, Dimensi input model: {resized_height}x{resized_width}, ", end="")

    return video_token

if __name__ == "__main__":
    try:
        video_token = calculate_video_tokens("xxx/test.jpg", nframes=30)
        print(f"Token video: {video_token}\n")
    except Exception as e:
        print(f"Error: {str(e)}\n")

Sebelum melakukan fine-tuning model

Meskipun fine-tuning model generasi teks dapat mencapai hasil luar biasa dalam skenario bisnis tertentu, metode ini memiliki keterbatasan berikut:
- Memakan waktu: Ini mencakup pembuatan dataset CPT berskala besar (minimal 50 juta token), membangun dataset SFT yang efektif (lebih dari 1.000 entri), mengumpulkan cukup banyak kasus buruk (lebih dari 100) untuk membangun dataset DPO yang efektif guna penagihan penerapan model, serta kecepatan iterasi optimasi model yang lambat.
- Biaya tinggi: Model hasil fine-tuning hanya dapat digunakan setelah diterapkan, dan penagihan penerapan model tinggi.
Alibaba Cloud Model Studio merekomendasikan agar Anda terlebih dahulu mencoba menggunakan Rekayasa Prompt atau Pemanggilan Fungsi untuk menyesuaikan aplikasi Anda. Fine-tuning model biasanya merupakan "pilihan terakhir" untuk meningkatkan performa model. Hal ini karena:
1. Dalam banyak tugas, model awalnya mungkin berkinerja buruk, tetapi menerapkan teknik prompt yang tepat dapat meningkatkan hasil tanpa memerlukan fine-tuning model.
2. Mengoptimalkan prompt dan plugin secara iteratif lebih lincah dan hemat biaya dibandingkan iterasi fine-tuning model, karena fine-tuning mungkin memerlukan pengumpulan ulang, pembersihan, dan pengoptimalan data, pengumpulan kasus buruk, serta survei pelanggan.
3. Bahkan jika Anda akhirnya memutuskan untuk melakukan fine-tuning model, pekerjaan awal tentang rekayasa prompt dan optimasi plugin tidak akan sia-sia. Pekerjaan awal ini dapat sepenuhnya digunakan kembali saat membangun dataset fine-tuning.

Memulai

Fine-tune model menggunakan konsol

Langkah-langkah fine-tuning	Cuplikan layar Konsol
Langkah 1: Pada halaman Model Fine-tuning, klik Create Training Task.
Langkah 2: Konfigurasi pelatihan Training Method: Supervised Fine-tuning (SFT) Select Model: Qwen3-8B Training Method: Efficient Training Configure Parameters: Anda dapat mempertahankan pengaturan default karena Model Studio menyediakan konfigurasi yang direkomendasikan untuk hiperparameter fine-tuning. Kombinasi ini memiliki waktu pelatihan singkat dan kebutuhan data rendah.
Langkah 3: Konfigurasi data Training Set: Pilih set data fine-tuning yang telah diunggah untuk membangun model. Contoh data: SFT-ChatML_format_example.jsonl. Mixed Training: Disabled Validation Set: Saat diatur ke Automatic Splitting, 10% data digunakan sebagai set validasi.
Langkah 4: Konfigurasi parameter penyimpanan snapshot parameter model (checkpoint) Untuk Model Name, pertahankan nama default. Maximum Export Count: Pertahankan nilai default. Checkpoint save interval: Pertahankan nilai default. Catatan Setelah fine-tuning model selesai, Anda dapat mengekspor snapshot parameter pada platform Model Studio. Anda kemudian dapat menerapkan model tersebut di Model Studio berdasarkan snapshot parameter ini. Snapshot parameter yang diekspor disimpan di Cloud Storage dan tidak dapat diakses atau diunduh.
Langkah 5: Klik "Start Training" dan tunggu hingga pelatihan model selesai.
Langkah 6: Gunakan fitur Model Deployment Alibaba Cloud Model Studio untuk menerapkan model kustom yang telah dilatih. Setelah penerapan, Anda dapat mengevaluasi model yang telah difine-tuning. Untuk informasi lebih lanjut, lihat Model deployment.

Proses fine-tuning khas

Tiga metode fine-tuning yang disediakan oleh Model Studio tidak saling eksklusif, melainkan progresif dan saling melengkapi.

CPT (opsional) → SFT → DPO (opsional)

CPT (continual pre-training) - Menambahkan pengetahuan (Model umum memiliki pengetahuan luas namun dangkal, yang mungkin tidak memenuhi persyaratan kedalaman dan presisi bidang profesional)
- Model keuangan: Mempelajari istilah keuangan
- Model medis: Menghafal patologi obat
- Model hukum: Memahami pasal hukum dan preseden
SFT (supervised fine-tuning) - Belajar cara melakukan tugas
- Bot layanan pelanggan: Mempelajari prosedur layanan pelanggan
- Asisten kode: Mempelajari paradigma pemrograman
- Pemanggilan alat (Agen): Belajar menggunakan MCP
DPO (direct preference optimization) - Melakukan tugas lebih baik
- Keamanan dan tanggung jawab: Menolak saran berbahaya
- Keringkasan dan efektivitas: Memberikan jawaban ringkas
- Objektivitas dan netralitas: Mengevaluasi secara adil dan objektif

Format data fine-tuning

Set pelatihan SFT

Data pelatihan format SFT ChatML (Chat Markup Language) mendukung percakapan multi-putaran dan berbagai pengaturan peran.

Parameter OpenAI name dan weight tidak didukung. Semua output asisten akan dilatih.

# Satu baris data pelatihan (dalam format JSON) memiliki struktur khas berikut saat diperluas:
{"messages": [
  {"role": "system", "content": "Input sistem 1"}, 
  {"role": "user", "content": "Input pengguna 1"}, 
  {"role": "assistant", "content": "Output model yang diharapkan 1"}, 
  {"role": "user", "content": "Input pengguna 2"}, 
  {"role": "assistant", "content": "Output model yang diharapkan 2"}
  ...
]}

Untuk informasi tentang perbedaan antara system, user, dan assistant, lihat Ikhtisar. Dataset pelatihan contoh: SFT-ChatML_format_example.jsonl, SFT-ChatML_format_example.xlsx. Format XLS dan XLSX hanya mendukung percakapan satu putaran.

Semua baris asisten dalam satu entri data pelatihan mendukung parameter "loss_weight", yang mengatur tingkat kepentingan relatif baris tersebut selama pelatihan. (Rentang: 0,0 hingga `1,0`. Nilai yang lebih besar menunjukkan kepentingan yang lebih tinggi.)

Parameter ini tersedia untuk pratinjau undangan. Untuk menggunakannya, hubungi manajer akun Anda.

 {"role": "assistant", "content": "Output model yang diharapkan 1", "loss_weight": 1.0}, 
 {"role": "assistant", "content": "Output model yang diharapkan 2", "loss_weight": 0.5}

Kiat pembuatan dataset

Persyaratan ukuran dataset

Untuk CPT, dataset memerlukan minimal 50 juta token data pre-training berkualitas tinggi. Untuk SFT, dataset memerlukan minimal 1.000 entri data fine-tuning berkualitas tinggi. Untuk DPO, dataset umumnya memerlukan ratusan entri data preferensi manusia. Jika hasil evaluasi model setelah fine-tuning data tidak memuaskan, cara paling sederhana untuk meningkatkannya adalah mengumpulkan lebih banyak data untuk pelatihan.

Jika Anda kekurangan data, kami merekomendasikan membangun aplikasi agen dan menggunakan indeks basis pengetahuan untuk meningkatkan kemampuan model. Dalam banyak skenario bisnis kompleks, Anda juga dapat menggabungkan fine-tuning model dan pengambilan basis pengetahuan.

Misalnya, dalam skenario layanan pelanggan, Anda dapat menggunakan fine-tuning model untuk mengatasi masalah nada, gaya ekspresi, dan kesadaran diri agen layanan pelanggan. Pengetahuan profesional terkait skenario dapat secara dinamis dimasukkan ke dalam konteks model menggunakan basis pengetahuan.

Alibaba Cloud Model Studio merekomendasikan agar Anda terlebih dahulu membangun dan menguji aplikasi generasi yang diperkaya dengan pengambilan data (RAG). Setelah mengumpulkan cukup data aplikasi, Anda kemudian dapat menggunakan fine-tuning model untuk lebih meningkatkan performa model.

Anda juga dapat menggunakan strategi berikut untuk memperluas dataset Anda:

Gunakan model bahasa besar (LLM) untuk mensimulasikan pembuatan konten untuk skenario bisnis tertentu guna membantu Anda menghasilkan lebih banyak data untuk fine-tuning. (Kami merekomendasikan memilih model yang lebih besar dan berkinerja tinggi untuk generasi.)
Dapatkan lebih banyak data melalui berbagai metode, seperti pengumpulan dari skenario aplikasi, scraping web, media sosial dan forum online, dataset publik, mitra dan sumber daya industri, serta kontribusi pengguna.

Keragaman dan keseimbangan data

Persyaratan untuk fine-tuning model bervariasi tergantung skenario. Misalnya, profesionalisme sangat penting untuk skenario bisnis tertentu, sedangkan fleksibilitas lebih penting untuk skenario tanya jawab. Anda perlu merancang kasus penggunaan data berdasarkan modul bisnis atau skenario penggunaan yang menjadi tanggung jawab model. Oleh karena itu, efektivitas pelatihan bergantung tidak hanya pada volume data tetapi juga pada profesionalisme dan keragaman data untuk skenario tertentu.

Misalnya, dalam skenario percakapan AI cerdas, dataset profesional dan beragam harus mencakup skenario bisnis berikut:

Bisnis spesifik	Skenario/bisnis beragam
Layanan pelanggan E-dagang	Dorongan promosi, konsultasi pra-penjualan, panduan saat penjualan, layanan purna jual, tindak lanjut purna jual, penanganan keluhan, dll.
Layanan keuangan	Konsultasi pinjaman, saran investasi dan pengelolaan kekayaan, layanan kartu kredit, manajemen rekening bank, dll.
Kesehatan online	Konsultasi gejala, pendaftaran janji temu, instruksi kunjungan, pertanyaan informasi obat, tips kesehatan, dll.
Sekretaris AI	Informasi TI, informasi administratif, informasi SDM, pertanyaan tunjangan karyawan, kueri kalender perusahaan, dll.
Asisten perjalanan	Perencanaan perjalanan, panduan masuk dan keluar, konsultasi asuransi perjalanan, pengenalan adat dan budaya tujuan, dll.
Penasehat hukum perusahaan	Tinjauan kontrak, perlindungan kekayaan intelektual, pemeriksaan kepatuhan, tanya jawab hukum ketenagakerjaan, konsultasi transaksi lintas batas, analisis kasus hukum individual, dll.

Juga penting untuk dicatat bahwa jumlah data untuk setiap skenario/bisnis harus relatif seimbang, dan proporsi data harus sesuai dengan proporsi skenario aktual. Hal ini menghindari terlalu banyak data dari satu jenis, yang dapat menyebabkan model cenderung mempelajari fitur-fitur tersebut dan memengaruhi kemampuan generalisasinya.

Pemisahan set pelatihan dan validasi

Anda dapat melakukan fine-tuning model di konsol.

Secara otomatis membagi dataset pelatihan lengkap dan mengambil sampel acak sejumlah kecil data untuk membentuk set validasi.
Pilih untuk mengunggah dataset terpisah.

Konsol menampilkan loss set validasi dan akurasi token secara real time selama pelatihan.

FAQ

Bisakah saya fine-tune model saya sendiri?

Model Studio tidak mendukung fine-tuning, mengunggah model Anda sendiri, atau mengekspor model yang diunduh.