Introdução ao ajuste fino de modelos

O ajuste fino de modelos é uma técnica essencial para otimizar o desempenho. Esse processo permite:

Aprimorar o desempenho do modelo em setores específicos ou para necessidades de negócios particulares
Reduzir a latência de saída do modelo
Minimizar alucinações do modelo
Alinhar o modelo aos valores ou preferências humanas
Substituir modelos maiores por versões leves ajustadas

Durante o ajuste fino, o modelo aprende características específicas do negócio ou do cenário a partir dos dados de treinamento, como conhecimento, tom de voz, estilos de expressão e autoconsciência. Como o modelo já assimilou diversos exemplos de setores ou cenários específicos durante o treinamento, seu desempenho com prompts one-shot ou zero-shot após o treinamento supera o desempenho few-shot anterior. Isso economiza tokens de entrada e reduz a latência de saída do modelo.

Processo de ajuste fino de modelos

Para mais informações, consulte:

Modelos suportados

Singapore
North China 2 (Beijing)

Geração de texto
Compreensão visual (Qwen-VL)

Nome do modelo	Código do modelo	Treinamento SFT com parâmetros completos (sft)	Treinamento SFT eficiente (efficient_sft)
Qwen3-14B	qwen3-14b	×	Suportado

Geração de texto
Compreensão visual (Qwen-VL)

Serviço de modelo	Código do modelo	Treinamento CPT com parâmetros completos (cpt)	Treinamento SFT com parâmetros completos (sft)	Treinamento SFT eficiente (efficient_sft)	Treinamento DPO com parâmetros completos (dpo_full)	Treinamento DPO eficiente (dpo_lora)
Qwen3.6-Flash-2026-04-16	qwen3.6-flash-2026-04-16	×	Suportado	×	×	×

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

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

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

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

Serviço de modelo	Código do modelo	Treinamento CPT com parâmetros completos (cpt)	Treinamento SFT com parâmetros completos (sft)	Treinamento SFT eficiente (efficient_sft)	Treinamento DPO com parâmetros completos (dpo_full)	Treinamento DPO eficiente (dpo_lora)
Qwen3-VL-8B-Instruct	qwen3-vl-8b-instruct	×	Suportado	Suportado	×	×
Qwen3-VL-8B-Thinking	qwen3-vl-8b-thinking	×	Suportado	Suportado	×	×
Qwen3-VL-4B-Instruct	qwen3-vl-4b-instruct	×	Suportado	Suportado	×	×

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

Comparação dos métodos de ajuste fino

Recurso	CPT (Pré-treinamento Contínuo)	SFT (Ajuste Fino Supervisionado)	DPO (Otimização Direta de Preferência)
Resumo	Complementa conhecimento (Injeta conhecimento de domínio)	Aprende a executar tarefas (Segue instruções)	Executa tarefas com maior qualidade (Alinha-se às preferências humanas)
Dados de entrada	Mais de 10 milhões de tokens Texto de domínio não rotulado	Mais de 1.000 entradas Pares "pergunta-resposta" de alta qualidade	Mais de 100 conjuntos Pares de respostas "melhor-pior" para a mesma instrução
Objetivo principal	Adaptação de domínio. Aprende vocabulário especializado e fatos.	Ensina ao modelo formatos de conversa e capacidades de execução de tarefas.	Faz com que as saídas do modelo se alinhem melhor aos valores e preferências humanas.
Método de aprendizado	Aprendizado auto-supervisionado (Prevê a próxima palavra)	Aprendizado supervisionado (Imita o ground truth)	Aprendizado direto de preferência (Aumenta a probabilidade de boas respostas e diminui a probabilidade de respostas ruins)
Estágio do modelo	Geralmente antes do SFT	Após o CPT e antes do DPO	Geralmente após o SFT, como etapa final de alinhamento.

Comparação dos padrões de treinamento

	Treinamento com parâmetros completos	Treinamento eficiente (LoRA, recomendado)
Cenários	• O modelo precisa adquirir novas capacidades • Obtenção de desempenho global ideal.	• Otimização do desempenho do modelo para cenários específicos. • Cenários sensíveis a custos e tempo.
Tempo de treinamento	Mais longo, com convergência mais lenta.	Mais curto, com convergência mais rápida.

Treinamento com parâmetros completos

Treinamento eficiente (LoRA, recomendado)

Cenários

• O modelo precisa adquirir novas capacidades

• Obtenção de desempenho global ideal.

• Otimização do desempenho do modelo para cenários específicos.

• Cenários sensíveis a custos e tempo.

Tempo de treinamento

Mais longo, com convergência mais lenta.

Mais curto, com convergência mais rápida.

Faturamento

Método de faturamento

Pagamento conforme o uso com base na quantidade de dados de treinamento

Fórmula de faturamento

Taxa de treinamento do modelo = (Total de tokens nos dados de treinamento + Total de tokens nos dados de treinamento mistos) × Número de épocas × Preço unitário de treinamento (Unidade mínima de faturamento: 1 token)

Visualize a taxa estimada de treinamento na parte inferior do Model Fine-tuning console e clique em Billing Details para visualizar o número total de tokens de treinamento, o número de épocas e o preço unitário de treinamento.

Preço unitário de treinamento

A tabela a seguir lista os preços unitários de treinamento para modelos pré-construídos. O preço unitário de treinamento de um modelo personalizado é igual ao do modelo pré-construído correspondente.

Singapore
North China 2 (Beijing)

Qwen
Qwen-VL

Model service	Model code	Price
Qwen3-14B	qwen3-14b	$0.0016/1,000 tokens

Model service	Model code	Price

Calcular tokens para imagens e vídeos

Imagens
Vídeos

Fórmula: Image Tokens = h_bar * w_bar / token_pixels + 2

h_bar, w_bar: Altura e largura da imagem redimensionada. Antes de processar uma imagem, o modelo executa um pré-processamento para reduzi-la a um limite específico de pixels. Esse limite depende dos valores dos parâmetros max_pixels e vl_high_resolution_images. Para mais informações, consulte Process high-resolution images.
token_pixels: Valor em pixels correspondente a cada token visual. Este valor varia conforme o modelo:
- qwen3.8-series,qwen3.7-series, qwen3.6-series, qwen3.5-series, Qwen3-VL, qwen-vl-max e qwen-vl-plus:Cada token corresponde a 32x32 pixels.
- QVQ e outros modelos Qwen2.5-VL:Cada token corresponde a 28x28 pixels.

O código a seguir demonstra a lógica aproximada de redimensionamento de imagens utilizada pelo modelo. Utilize-o para estimar os tokens de uma imagem. Para o faturamento real, consulte a resposta da API.

import math
from PIL import Image  # pip install Pillow

def smart_resize(image_path, max_pixels, vl_high_resolution_images):
    """Calculates the scaled dimensions of an image based on model parameters to estimate image tokens."""
    image = Image.open(image_path)
    height, width = image.height, image.width

    # The scaling factor is 32 for models such as Qwen3.6, Qwen3.5, and Qwen3-VL. For other models, it is 28.
    factor = 32
    h_bar = round(height / factor) * factor
    w_bar = round(width / factor) * factor

    # Token lower limit: 4 tokens
    min_pixels = 4 * factor * factor

    # If vl_high_resolution_images=True, the token upper limit is fixed at 16384, and max_pixels is ignored.
    if vl_high_resolution_images:
        max_pixels = 16384 * factor * factor

    # Constrains the total number of pixels to the range [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__":
    # Note: The values of max_pixels and vl_high_resolution_images must match the parameters passed when calling the model.
    h_bar, w_bar = smart_resize("xxx/test.jpg", max_pixels=2560 * 32 * 32, vl_high_resolution_images=False)
    print(f"Scaled image dimensions: Height {h_bar}, Width {w_bar}")

    # Each image includes one <vision_bos> and one <vision_eos> token.
    token = int(h_bar * w_bar / (32 * 32)) + 2
    print(f"Number of image tokens: {token}")

Arquivos de vídeo: Ao processar um arquivo de vídeo, o modelo extrai primeiro os quadros e depois calcula o número total de tokens para todos eles. Como esse cálculo é complexo, utilize o código abaixo para estimar o consumo total de tokens de um vídeo informando seu caminho:

# Before use, install: pip install opencv-python
import math
import os
import logging
import cv2

logger = logging.getLogger(__name__)

FRAME_FACTOR = 2

# For models such as Qwen3.6, Qwen3.5, Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, and qwen-vl-plus-0710, the image scaling factor is 32.
IMAGE_FACTOR = 32

# For other models, the image scaling factor is 28.
# IMAGE_FACTOR = 28

# Maximum aspect ratio for video frames
MAX_RATIO = 200
# Pixel lower limit for video frames
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Pixel upper limit for video frames. For the Qwen3-VL-Plus model, VIDEO_MAX_PIXELS is 640 * 32 * 32. For other models, it is 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# If the user does not pass the FPS parameter, the default value is used for fps.
FPS = 2.0
# Minimum number of extracted frames
FPS_MIN_FRAMES = 4
# Maximum number of extracted frames (set based on the selected model)
FPS_MAX_FRAMES = 2000

# Maximum pixel value for video input. For the Qwen3-VL-Plus model, set VIDEO_TOTAL_PIXELS to 131072 * 32 * 32. For other models, set it to 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_TOTAL_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Returns the integer closest to 'number' that is divisible by 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Returns the smallest integer that is greater than or equal to 'number' and divisible by 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Returns the largest integer that is less than or equal to 'number' and divisible by '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):
    """Calculates the number of extracted video frames.

    Args:
        ele (dict): A dictionary containing the video configuration.
            - fps: Controls the number of input frames extracted for the model.
        total_frames (int): The original total number of frames in the video.
        video_fps (int | float): The original frame rate of the video.

    Raises:
        An error is reported if nframes is not within the interval [FRAME_FACTOR, total_frames].

    Returns:
        The number of video frames for model input.
    """
    assert not ("fps" in ele and "nframes" in ele), "Only accept either `fps` or `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 should in interval [{FRAME_FACTOR}, {total_frames}], but got {nframes}.")

    return nframes

def get_video(video_path):
    # Get video information
    cap = cv2.VideoCapture(video_path)

    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    # Get video height
    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):
    # Get the original width and height of the video
    height, width, total_frames, video_fps = get_video(path)
    # Token lower limit for video frames
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Number of extracted video frames
    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))

    # The aspect ratio of the video should not exceed 200:1 or 1:200.
    if max(height, width) / min(height, width) > MAX_RATIO:
        raise ValueError(
            f"absolute aspect ratio must be smaller than {MAX_RATIO}, got {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):
    # Pass the video path and the fps frame extraction parameter.
    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"Original video dimensions: {height}*{width}, Model input dimensions: {resized_height}*{resized_width}, Total video frames: {total_frames}, Total frames extracted when fps is {fps}: {num_frames}", end=", ")
    video_token = int(math.ceil(num_frames / 2) * resized_height / 32 * resized_width / 32)
    video_token += 2   # The system automatically adds <|vision_bos|> and <|vision_eos|> visual markers (1 token each).
    return video_token

video_token = token_calculate("xxx/test.mp4", 1)
print("Video tokens:", video_token)

Lista de imagens: Quando um vídeo é fornecido como uma lista de imagens, significa que a extração de quadros já foi realizada. Utilize o código a seguir para calcular o consumo de tokens informando o caminho e a quantidade de imagens:

# Before use, install: pip install Pillow
import math
import os
import logging
from typing import Tuple
from PIL import Image

logger = logging.getLogger(__name__)

# ==================== Constant Definitions ====================
FRAME_FACTOR = 2
# For models such as Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, and qwen-vl-plus-0710, the scaling factor is 32.
IMAGE_FACTOR = 32

# For other models, the scaling factor is 28.
# IMAGE_FACTOR = 28

# Constants for token calculation
TOKEN_DIVISOR = 32  # Divisor for token calculation
VISION_SPECIAL_TOKENS = 2  # <|vision_bos|> and <|vision_eos|> markers

# Maximum aspect ratio for video frames
MAX_RATIO = 200
# Pixel lower limit for video frames
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Pixel upper limit for video frames. For the Qwen3-VL-Plus model, VIDEO_MAX_PIXELS is 640 * 32 * 32. For other models, it is 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# Maximum pixel value for video input. For the Qwen3-VL-Plus model, set VIDEO_TOTAL_PIXELS to 131072 * 32 * 32. For other models, set it to 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_TOTAL_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Returns the integer closest to 'number' that is divisible by 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Returns the smallest integer that is greater than or equal to 'number' and divisible by 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Returns the largest integer that is less than or equal to 'number' and divisible by '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"Image file not found: {image_path}")

    try:
        image = Image.open(image_path)
        height = image.height
        width = image.width
        image.close()  # Close the file promptly
        return height, width
    except Exception as e:
        raise ValueError(f"Cannot read image file {image_path}: {str(e)}")

def smart_resize(height: int, width: int, nframes: int, factor: int = IMAGE_FACTOR) -> Tuple[int, int]:
    """
    Calculates the scaled dimensions of an image

    Args:
        height: Original image height
        width: Original image width
        nframes: Number of video frames
        factor: Scaling factor, defaults to IMAGE_FACTOR

    Returns:
        (resized_height, resized_width) The scaled height and width

    Raises:
        ValueError: Aspect ratio exceeds the limit
    """
    # Token lower limit for video frames
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Number of extracted video frames
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))

    # The aspect ratio of the video should not exceed 200:1 or 1:200.
    aspect_ratio = max(height, width) / min(height, width)
    if aspect_ratio > MAX_RATIO:
        raise ValueError(
            f"Image aspect ratio must be less than {MAX_RATIO}:1, but is currently {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 to the video frame file
        nframes: Number of video frames,
        factor: Scaling factor, defaults to IMAGE_FACTOR
        verbose: Whether to print detailed information

    Returns:
        The number of tokens consumed

    Raises:
        FileNotFoundError: The file does not exist
        ValueError: The file format is invalid or the aspect ratio exceeds the limit
    """
    # Get the original image dimensions (read only once)
    height, width = get_image_size(image_path)

    # Calculate the scaled dimensions
    resized_height, resized_width = smart_resize(height, width, nframes, factor)

    # Calculate the number of tokens
    # Formula: 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)
    )
    # Add visual marker tokens (<|vision_bos|> and <|vision_eos|>)
    video_token += VISION_SPECIAL_TOKENS

    if verbose:
        print(f"Original video frame dimensions: {height}x{width}, Model input dimensions: {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"Video tokens: {video_token}\n")
    except Exception as e:
        print(f"Error: {str(e)}\n")

Qwen
Qwen-VL

Model service	Model code	Price
Qwen3.5-27B	qwen3.5-27b	$0.006876/1,000 tokens
Qwen3.5-9B	qwen3.5-9b	$0.00275/1,000 tokens

Qwen3-32B	qwen3-32b	$0.005501/1,000 tokens
Qwen3-30B-A3B-Instruct-2507	qwen3-30b-a3b-instruct-2507	$0.004126/1,000 tokens
Qwen3-14B	qwen3-14b	$0.004126/1,000 tokens
Qwen3-8B	qwen3-8b	$0.000825/1,000 tokens
Qwen3-4B-Instruct-2507	qwen3-4b-instruct-2507	$0.000825/1,000 tokens
Qwen3-1.7B	qwen3-1.7b	$0.000619/1,000 tokens
Qwen3-0.6B	qwen3-0.6b	$0.000413/1,000 tokens

Qwen2.5-72B-Instruct	qwen2.5-72b-instruct	$0.020628/1,000 tokens
Qwen2.5-32B-Instruct	qwen2.5-32b-instruct	$0.004126/1,000 tokens
Qwen2.5-14B-Instruct	qwen2.5-14b-instruct	$0.004126/1,000 tokens
Qwen2.5-7B-Instruct	qwen2.5-7b-instruct	$0.000825/1,000 tokens

Qwen-Plus-Character-2025-11-06	qwen-plus-character-2025-11-06	$0.020628/1,000 tokens

Model service	Model code	Price
Qwen3-VL-8B-Instruct	qwen3-vl-8b-instruct	$0.00165/1,000 tokens
Qwen3-VL-8B-Thinking	qwen3-vl-8b-thinking	$0.00165/1,000 tokens
Qwen3-VL-4B-Instruct	qwen3-vl-4b-instruct	$0.000825/1,000 tokens

Qwen2.5-VL-72B-Instruct	qwen2.5-vl-72b-instruct	$0.006876/1,000 tokens
Qwen2.5-VL-32B-Instruct	qwen2.5-vl-32b-instruct	$0.00275/1,000 tokens
Qwen2.5-VL-7B-Instruct	qwen2.5-vl-7b-instruct	$0.001375/1,000 tokens

Calcular tokens para imagens e vídeos

Imagens
Vídeos

Fórmula: Image Tokens = h_bar * w_bar / token_pixels + 2

h_bar, w_bar: Altura e largura da imagem redimensionada. Antes de processar uma imagem, o modelo executa um pré-processamento para reduzi-la a um limite específico de pixels. Esse limite depende dos valores dos parâmetros max_pixels e vl_high_resolution_images. Para mais informações, consulte Process high-resolution images.
token_pixels: Valor em pixels correspondente a cada token visual. Este valor varia conforme o modelo:
- qwen3.8-series,qwen3.7-series, qwen3.6-series, qwen3.5-series, Qwen3-VL, qwen-vl-max e qwen-vl-plus:Cada token corresponde a 32x32 pixels.
- QVQ e outros modelos Qwen2.5-VL:Cada token corresponde a 28x28 pixels.

import math
from PIL import Image  # pip install Pillow

def smart_resize(image_path, max_pixels, vl_high_resolution_images):
    """Calculates the scaled dimensions of an image based on model parameters to estimate image tokens."""
    image = Image.open(image_path)
    height, width = image.height, image.width

    # The scaling factor is 32 for models such as Qwen3.6, Qwen3.5, and Qwen3-VL. For other models, it is 28.
    factor = 32
    h_bar = round(height / factor) * factor
    w_bar = round(width / factor) * factor

    # Token lower limit: 4 tokens
    min_pixels = 4 * factor * factor

    # If vl_high_resolution_images=True, the token upper limit is fixed at 16384, and max_pixels is ignored.
    if vl_high_resolution_images:
        max_pixels = 16384 * factor * factor

    # Constrains the total number of pixels to the range [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__":
    # Note: The values of max_pixels and vl_high_resolution_images must match the parameters passed when calling the model.
    h_bar, w_bar = smart_resize("xxx/test.jpg", max_pixels=2560 * 32 * 32, vl_high_resolution_images=False)
    print(f"Scaled image dimensions: Height {h_bar}, Width {w_bar}")

    # Each image includes one <vision_bos> and one <vision_eos> token.
    token = int(h_bar * w_bar / (32 * 32)) + 2
    print(f"Number of image tokens: {token}")

Arquivos de vídeo: Ao processar um arquivo de vídeo, o modelo extrai primeiro os quadros e depois calcula o número total de tokens para todos eles. Como esse cálculo é complexo, utilize o código abaixo para estimar o consumo total de tokens de um vídeo informando seu caminho:

# Before use, install: pip install opencv-python
import math
import os
import logging
import cv2

logger = logging.getLogger(__name__)

FRAME_FACTOR = 2

# For models such as Qwen3.6, Qwen3.5, Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, and qwen-vl-plus-0710, the image scaling factor is 32.
IMAGE_FACTOR = 32

# For other models, the image scaling factor is 28.
# IMAGE_FACTOR = 28

# Maximum aspect ratio for video frames
MAX_RATIO = 200
# Pixel lower limit for video frames
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Pixel upper limit for video frames. For the Qwen3-VL-Plus model, VIDEO_MAX_PIXELS is 640 * 32 * 32. For other models, it is 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# If the user does not pass the FPS parameter, the default value is used for fps.
FPS = 2.0
# Minimum number of extracted frames
FPS_MIN_FRAMES = 4
# Maximum number of extracted frames (set based on the selected model)
FPS_MAX_FRAMES = 2000

# Maximum pixel value for video input. For the Qwen3-VL-Plus model, set VIDEO_TOTAL_PIXELS to 131072 * 32 * 32. For other models, set it to 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_TOTAL_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Returns the integer closest to 'number' that is divisible by 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Returns the smallest integer that is greater than or equal to 'number' and divisible by 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Returns the largest integer that is less than or equal to 'number' and divisible by '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):
    """Calculates the number of extracted video frames.

    Args:
        ele (dict): A dictionary containing the video configuration.
            - fps: Controls the number of input frames extracted for the model.
        total_frames (int): The original total number of frames in the video.
        video_fps (int | float): The original frame rate of the video.

    Raises:
        An error is reported if nframes is not within the interval [FRAME_FACTOR, total_frames].

    Returns:
        The number of video frames for model input.
    """
    assert not ("fps" in ele and "nframes" in ele), "Only accept either `fps` or `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 should in interval [{FRAME_FACTOR}, {total_frames}], but got {nframes}.")

    return nframes

def get_video(video_path):
    # Get video information
    cap = cv2.VideoCapture(video_path)

    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    # Get video height
    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):
    # Get the original width and height of the video
    height, width, total_frames, video_fps = get_video(path)
    # Token lower limit for video frames
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Number of extracted video frames
    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))

    # The aspect ratio of the video should not exceed 200:1 or 1:200.
    if max(height, width) / min(height, width) > MAX_RATIO:
        raise ValueError(
            f"absolute aspect ratio must be smaller than {MAX_RATIO}, got {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):
    # Pass the video path and the fps frame extraction parameter.
    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"Original video dimensions: {height}*{width}, Model input dimensions: {resized_height}*{resized_width}, Total video frames: {total_frames}, Total frames extracted when fps is {fps}: {num_frames}", end=", ")
    video_token = int(math.ceil(num_frames / 2) * resized_height / 32 * resized_width / 32)
    video_token += 2   # The system automatically adds <|vision_bos|> and <|vision_eos|> visual markers (1 token each).
    return video_token

video_token = token_calculate("xxx/test.mp4", 1)
print("Video tokens:", video_token)

Lista de imagens: Quando um vídeo é fornecido como uma lista de imagens, significa que a extração de quadros já foi realizada. Utilize o código a seguir para calcular o consumo de tokens informando o caminho e a quantidade de imagens:

# Before use, install: pip install Pillow
import math
import os
import logging
from typing import Tuple
from PIL import Image

logger = logging.getLogger(__name__)

# ==================== Constant Definitions ====================
FRAME_FACTOR = 2
# For models such as Qwen3-VL, qwen-vl-max-0813, qwen-vl-plus-0815, and qwen-vl-plus-0710, the scaling factor is 32.
IMAGE_FACTOR = 32

# For other models, the scaling factor is 28.
# IMAGE_FACTOR = 28

# Constants for token calculation
TOKEN_DIVISOR = 32  # Divisor for token calculation
VISION_SPECIAL_TOKENS = 2  # <|vision_bos|> and <|vision_eos|> markers

# Maximum aspect ratio for video frames
MAX_RATIO = 200
# Pixel lower limit for video frames
VIDEO_MIN_PIXELS = 4 * 32 * 32
# Pixel upper limit for video frames. For the Qwen3-VL-Plus model, VIDEO_MAX_PIXELS is 640 * 32 * 32. For other models, it is 768 * 32 * 32.
VIDEO_MAX_PIXELS = 640 * 32 * 32

# Maximum pixel value for video input. For the Qwen3-VL-Plus model, set VIDEO_TOTAL_PIXELS to 131072 * 32 * 32. For other models, set it to 65536 * 32 * 32.
VIDEO_TOTAL_PIXELS = int(float(os.environ.get('VIDEO_TOTAL_PIXELS', 131072 * 32 * 32)))

def round_by_factor(number: int, factor: int) -> int:
    """Returns the integer closest to 'number' that is divisible by 'factor'."""
    return round(number / factor) * factor

def ceil_by_factor(number: int, factor: int) -> int:
    """Returns the smallest integer that is greater than or equal to 'number' and divisible by 'factor'."""
    return math.ceil(number / factor) * factor

def floor_by_factor(number: int, factor: int) -> int:
    """Returns the largest integer that is less than or equal to 'number' and divisible by '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"Image file not found: {image_path}")

    try:
        image = Image.open(image_path)
        height = image.height
        width = image.width
        image.close()  # Close the file promptly
        return height, width
    except Exception as e:
        raise ValueError(f"Cannot read image file {image_path}: {str(e)}")

def smart_resize(height: int, width: int, nframes: int, factor: int = IMAGE_FACTOR) -> Tuple[int, int]:
    """
    Calculates the scaled dimensions of an image

    Args:
        height: Original image height
        width: Original image width
        nframes: Number of video frames
        factor: Scaling factor, defaults to IMAGE_FACTOR

    Returns:
        (resized_height, resized_width) The scaled height and width

    Raises:
        ValueError: Aspect ratio exceeds the limit
    """
    # Token lower limit for video frames
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    # Number of extracted video frames
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))

    # The aspect ratio of the video should not exceed 200:1 or 1:200.
    aspect_ratio = max(height, width) / min(height, width)
    if aspect_ratio > MAX_RATIO:
        raise ValueError(
            f"Image aspect ratio must be less than {MAX_RATIO}:1, but is currently {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 to the video frame file
        nframes: Number of video frames,
        factor: Scaling factor, defaults to IMAGE_FACTOR
        verbose: Whether to print detailed information

    Returns:
        The number of tokens consumed

    Raises:
        FileNotFoundError: The file does not exist
        ValueError: The file format is invalid or the aspect ratio exceeds the limit
    """
    # Get the original image dimensions (read only once)
    height, width = get_image_size(image_path)

    # Calculate the scaled dimensions
    resized_height, resized_width = smart_resize(height, width, nframes, factor)

    # Calculate the number of tokens
    # Formula: 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)
    )
    # Add visual marker tokens (<|vision_bos|> and <|vision_eos|>)
    video_token += VISION_SPECIAL_TOKENS

    if verbose:
        print(f"Original video frame dimensions: {height}x{width}, Model input dimensions: {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"Video tokens: {video_token}\n")
    except Exception as e:
        print(f"Error: {str(e)}\n")

Antes de ajustar um modelo

Embora o ajuste fino de modelos de geração de texto possa alcançar resultados excelentes em cenários de negócios específicos, ele apresenta as seguintes limitações:
- Consome muito tempo: Isso inclui a criação de um conjunto de dados CPT em grande escala (pelo menos 50 milhões de tokens), a construção de um conjunto de dados SFT eficaz (mais de 1.000 entradas), a coleta de casos negativos suficientes (mais de 100) para montar um conjunto de dados DPO eficiente e a lentidão das iterações de otimização do modelo.
- Custo elevado: Um modelo ajustado só pode ser utilizado após a implantação, e o model deployment billing é alto.
O Alibaba Cloud Model Studio recomenda que você tente primeiro usar Prompt Engineering ou Function Calling para personalizar sua aplicação. O ajuste fino de modelo geralmente é o "último recurso" para melhorar o desempenho. Os motivos são:
1. Em muitas tarefas, o modelo pode apresentar um desempenho inicial ruim, mas a aplicação de técnicas adequadas de prompt melhora os resultados sem exigir o ajuste fino do modelo.
2. A otimização iterativa de prompts e plugins é mais ágil e econômica do que as iterações de ajuste fino do modelo, pois o ajuste fino pode exigir nova coleta, limpeza e otimização de dados, além da análise de casos negativos e pesquisas com clientes.
3. Mesmo que você decida realizar o ajuste fino do modelo, o trabalho inicial de engenharia de prompt e otimização de plugins não será desperdiçado. Esse trabalho preliminar pode ser totalmente reutilizado na construção do conjunto de dados de ajuste fino.

Primeiros passos

Ajustar um modelo pelo console

Etapas de ajuste fino	Captura de tela do console
Etapa 1: Na página Model Fine-tuning, clique em Create Training Task.	Na página Create Training Task, conclua as seguintes configurações: Defina o tipo de treinamento como SFT Fine-tuning Training. Selecione Qwen3-8B como modelo. Defina o método de treinamento como Efficient Training. Na configuração de hiperparâmetros, defina `batch_size` como `16` (intervalo: [8, 1024], passo: 8). No painel Training Task Summary à direita, confirme se o método de faturamento é baseado em tokens e se 10% do conjunto de treinamento foi dividido automaticamente como conjunto de validação; em seguida, clique em Start Training.
Etapa 2: Configurar o treinamento Training Method: Supervised Fine-tuning (SFT) Select Model: Qwen3-8B Training Method: Efficient Training Configure Parameters: Mantenha as configurações padrão, pois o Model Studio fornece configurações recomendadas para os hiperparâmetros de ajuste fino. Essa combinação oferece tempo de treinamento curto e baixos requisitos de dados.
Etapa 3: Configurar os dados Training Set: Selecione o conjunto de dados de ajuste fino carregado para construir o modelo. Amostra de dados: SFT-ChatML_format_example.jsonl. Mixed Training: Desativado Validation Set: Quando definido como Automatic Splitting, 10% dos dados são usados como conjunto de validação.
Etapa 4: Configurar os parâmetros de salvamento de snapshot de parâmetros do modelo (checkpoint) Em Model Name, mantenha o nome padrão. Maximum Export Count: Mantenha o valor padrão. Checkpoint save interval: Mantenha o valor padrão. Após a conclusão do ajuste fino do modelo, exporte um snapshot de parâmetros na plataforma Model Studio. Em seguida, implante o modelo no Model Studio com base nesse snapshot de parâmetros. Os snapshots de parâmetros exportados são salvos no armazenamento em nuvem e não podem ser acessados ou baixados.
Etapa 5: Clique em "Start Training" e aguarde a conclusão do treinamento do modelo.
Etapa 6: Utilize o recurso Deployments do Alibaba Cloud Model Studio para implantar o modelo personalizado treinado. Após a implantação, avalie o modelo ajustado. Para obter mais informações, consulte Model deployment.

Processo típico de ajuste fino

Os três métodos de ajuste fino fornecidos pelo Model Studio não são excludentes, mas sim progressivos e complementares. CPT (opcional) → SFT → DPO (opcional)

CPT (pré-treinamento contínuo) - Complementa o conhecimento (modelos gerais possuem conhecimento amplo, porém superficial, o que pode não atender aos requisitos de profundidade e precisão de campos profissionais)
- Modelo financeiro: Aprende termos financeiros
- Modelo médico: Memoriza patologia de medicamentos
- Modelo jurídico: Compreende artigos legais e precedentes
SFT (ajuste fino supervisionado) - Aprende a executar tarefas
- Bot de atendimento ao cliente: Aprende procedimentos de atendimento
- Assistente de código: Aprende paradigmas de programação
- Chamada de ferramentas (Agente): Aprende a usar MCP
DPO (otimização direta de preferência) - Executa tarefas com maior qualidade
- Segurança e responsabilidade: Rejeita sugestões nocivas
- Concisão e eficácia: Fornece respostas concisas
- Objetividade e neutralidade: Avalia de forma justa e objetiva

Formato de dados de ajuste fino

Conjunto de treinamento SFT

Os dados de treinamento no formato SFT ChatML (Chat Markup Language) oferecem suporte a conversas de múltiplas rodadas e a várias configurações de papéis.

Os parâmetros name e weight da OpenAI não são suportados. Todas as saídas do assistente serão treinadas.

# A single line of training data (in JSON format) has the following typical structure when expanded:
{"messages": [
  {"role": "system", "content": "System input 1"},
  {"role": "user", "content": "User input 1"},
  {"role": "assistant", "content": "Expected model output 1"},
  {"role": "user", "content": "User input 2"},
  {"role": "assistant", "content": "Expected model output 2"}
  ...
]}

Para obter informações sobre as diferenças entre system, user e assistant, consulte Overview. Conjuntos de dados de treinamento de exemplo: SFT-ChatML_format_example.jsonl, SFT-ChatML_format_example.xlsx. Os formatos XLS e XLSX suportam apenas conversas de rodada única.Todas as linhas do assistente em uma única entrada de dados de treinamento aceitam o parâmetro "loss_weight", que define a importância relativa dessa linha durante o treinamento. (Intervalo: de 0.0 a 1.0. Um valor maior indica maior importância.)

Este parâmetro está disponível em preview por convite. Para utilizá-lo, entre em contato com seu gerente de conta.

 {"role": "assistant", "content": "Expected model output 1", "loss_weight": 1.0},
 {"role": "assistant", "content": "Expected model output 2", "loss_weight": 0.5}

Dicas para construção de conjuntos de dados

Requisitos de tamanho do conjunto de dados

Para CPT, o conjunto de dados requer pelo menos 50 milhões de tokens de dados de pré-treinamento de alta qualidade. Para SFT, são necessárias no mínimo 1.000 entradas de dados de ajuste fino de alta qualidade. Para DPO, geralmente são necessárias centenas de entradas de dados de preferência humana. Se os resultados da avaliação do modelo após o ajuste fino dos dados não forem satisfatórios, a maneira mais simples de melhorar é coletar mais dados para treinamento. Caso não tenha dados suficientes, recomendamos criar uma agent application e usar um índice de base de conhecimento para aprimorar as capacidades do modelo. Em muitos cenários de negócios complexos, também é possível usar uma combinação de ajuste fino de modelo e recuperação de base de conhecimento. Por exemplo, em um cenário de atendimento ao cliente, utilize o ajuste fino do modelo para resolver questões relacionadas ao tom do agente de atendimento, estilos de expressão e autoconsciência. O conhecimento profissional relacionado ao cenário pode ser introduzido dinamicamente no contexto do modelo por meio de uma base de conhecimento. O Alibaba Cloud Model Studio recomenda que você primeiro construa e teste uma aplicação de geração aumentada por recuperação (RAG). Após coletar dados suficientes da aplicação, utilize o ajuste fino do modelo para melhorar ainda mais o desempenho. Também é possível adotar as seguintes estratégias para expandir seu conjunto de dados:

Utilize um modelo de linguagem grande (LLM) para simular a geração de conteúdo para cenários de negócios específicos, ajudando a gerar mais dados para ajuste fino. (Recomendamos selecionar um modelo maior e de alto desempenho para a geração.)
Adquira mais dados por diversos meios, como coleta em cenários de aplicação, web scraping, mídias sociais e fóruns online, conjuntos de dados públicos, parceiros e recursos do setor, além de contribuições de usuários.

Diversidade e equilíbrio dos dados

Os requisitos para ajuste fino de modelo variam conforme o cenário. Por exemplo, o profissionalismo é crítico para cenários de negócios específicos, enquanto a versatilidade é mais importante para cenários de perguntas e respostas. Projete os casos de uso de dados com base nos módulos de negócios ou cenários de uso pelos quais o modelo é responsável. Portanto, a eficácia do treinamento depende não apenas do volume de dados, mas também do profissionalismo e da diversidade dos dados para o cenário específico. Por exemplo, em um cenário de conversa inteligente com IA, um conjunto de dados profissional e diversificado deve incluir os seguintes cenários de negócios:

Negócio específico	Cenários/negócios diversos
Atendimento ao cliente de e-commerce	Envio de promoções, consulta pré-venda, orientação durante a venda, serviço pós-venda, acompanhamento pós-venda, tratamento de reclamações, etc.
Serviços financeiros	Consulta de empréstimos, consultoria de investimentos e gestão de patrimônio, serviços de cartão de crédito, gestão de contas bancárias, etc.
Saúde online	Consulta de sintomas, agendamento de consultas, instruções de visita, consulta de informações sobre medicamentos, dicas de saúde, etc.
Secretário de IA	Informações de TI, informações administrativas, informações de RH, consultas sobre benefícios aos funcionários, consultas ao calendário da empresa, etc.
Assistente de viagem	Planejamento de viagens, guias de entrada e saída, consulta sobre seguros de viagem, apresentações sobre costumes e cultura do destino, etc.
Consultor jurídico corporativo	Revisão de contratos, proteção de propriedade intelectual, verificações de conformidade, perguntas e respostas sobre legislação trabalhista, consultoria para transações internacionais, análise jurídica de casos individuais, etc.

É importante notar também que a quantidade de dados para cada cenário/negócio deve ser relativamente equilibrada, e a proporção dos dados deve corresponder à proporção real do cenário. Isso evita excesso de dados de um único tipo, o que poderia fazer com que o modelo tendesse a aprender essas características e afetasse sua capacidade de generalização.

Divisão dos conjuntos de treinamento e validação

O ajuste fino de modelos está disponível no console.

Divida automaticamente um conjunto de dados de treinamento completo e amostragem aleatória de uma pequena quantidade de dados para formar um conjunto de validação.
Escolha fazer upload de um conjunto de dados separado.

Durante o treinamento, o console exibe em tempo real a perda do conjunto de validação e a precisão dos tokens. A página Data Configuration também inclui o botão Mixed Training (desativado por padrão). Quando a opção Auto Split está selecionada, 10% do conjunto de treinamento é dividido aleatoriamente como conjunto de validação por padrão.

Perguntas frequentes

É possível ajustar meu próprio modelo?

O Model Studio não oferece suporte a ajuste fino, upload de modelos próprios ou exportação de modelos baixados.