Alibaba Cloud Model Studio:Fine-tune image generation models

When using Wan for image generation , if Text-to-video/image-to-video prompt guide cannot meet your customization needs for specific styles, IP characters, or visual effects , use model fine-tuning .

Scope

• Supported region: This document applies only to the Singapore region. You must use an API key from this region.

• Supported fine-tuning method: SFT-LoRA efficient fine-tuning.

• Supported models:

  • Wan image generation (text-to-image/image-to-image): wan2.7-image-pro, wan2.7-image.
  • Qwen image generation (text-to-image/image-to-image): qwen-image-2.0.

How to fine-tune a model

Text-to-image

Fine-tuning objective: Train a character LoRA model.

Expected result: Given a text prompt, the model generates images of a specific character in the scene described by the prompt.

Input prompt A person in a crowded morning rush hour subway car, holding onto the handrail, with blurred passengers in the background and tunnel lights visible through the windows, wearing an ordinary office worker white shirt and black trousers, standing facing the camera, half-body shot, realistic candid feel.

Output image (before fine-tuning - text-to-image) Without a reference image, the model cannot generate a specific character.

Output image (after fine-tuning) After fine-tuning, the model can reliably reproduce the specific character from the training set.

Image-to-image

Fine-tuning objective: Train a "post-apocalyptic red-black mech armor" LoRA model.

Expected result: Given a character image, the model generates a "post-apocalyptic red-black mech armor" stylized version of the character without requiring a text prompt.

Input image

Output image (before fine-tuning) Text prompts alone cannot reliably produce the specific "post-apocalyptic red-black mech armor" effect every time.

Output image (after fine-tuning) After fine-tuning, the model can reproduce the "post-apocalyptic red-black mech armor" effect from the training set without requiring a text prompt.

Before running the following code, Obtain an API key and Configure API key as an environment variable.

Step 1: Upload the dataset

Upload your local dataset (in .zip format) to the Alibaba Cloud Model Studio platform and obtain the file ID (id).

Sample training data: For the format, see Training set.

• Image generation - text-to-image: wan-image-t2i-training-dataset.zip
• Image generation - image-to-image: wan-image-i2i-training-dataset.zip

This example uses text-to-image and uploads only the training set. The system automatically splits a portion of the training set as the validation set.

curl --location --request POST 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1/files' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--form 'file=@"./wan-image-t2i-training-dataset.zip"' \
--form 'purpose="fine-tune"'

Save the id. This is the unique identifier for the uploaded dataset.

{
    "id": "file-ft-3c67043a747c-xxxxxx",
    "object": "file",
    "bytes": 73310369,
    "filename": "wan-image-t2i-training-dataset.zip",
    "purpose": "fine-tune",
    "status": "processed",
    "created_at": 1782271893
}

Step 2: Fine-tune the model

Step 2.1: Create a fine-tuning job

Use the file ID from Step 1 to start a training job.

Replace <replace_with_training_dataset_file_id> with the id obtained in the previous step. For the complete parameter reference and format constraints, see Hyperparameters.

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/fine-tunes' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json' \
--data '{
    "model": "wan2.7-image-pro",
    "training_datasets": [
        {
            "data_source_type": "file_id",
            "file_id": "<replace_with_training_dataset_file_id>"
        }
    ],
    "training_type": "efficient_sft",
    "hyper_parameters": {
        "learning_rate": 3e-5,
        "max_steps": 800,
        "eval_steps": 200,
        "max_token_length": "1k",
        "gradient_clip": 0.5,
        "weight_decay": 0.02,
        "max_pixels": "1k",
        "val_img_size": "1k",
        "generation_type": "t2i",
        "lora_rank": 32,
        "save_total_limit": 10
    }
}'

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/fine-tunes' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json' \
--data '{
    "model": "qwen-image-2.0",
    "training_datasets": [
        {
            "data_source_type": "file_id",
            "file_id": "<replace_with_training_dataset_file_id>"
        }
    ],
    "training_type": "efficient_sft",
    "hyper_parameters": {
        "learning_rate": 5e-5,
        "n_epochs": 10,
        "eval_epochs": 10,
        "batch_size": 8,
        "gradient_clip": 0.5,
        "weight_decay": 0.02,
        "max_pixels": "2k",
        "val_img_size": "2k",
        "generation_type": "t2i",
        "lora_rank": 32,
        "save_total_limit": 20
    }
}'

Pay attention to three key parameters in the output field:

• job_id: The job ID, used to query progress.
• finetuned_output: The name of the fine-tuned model. You must use this name for subsequent deployment and invocation.
• status: The training status. After creating a fine-tuning job, the initial status is PENDING, indicating that training has not yet started.

{
    ...
    "output": {
        "job_id": "ft-202511111122-xxxx",
        "status": "PENDING",
        "finetuned_output": "xxxx-ft-202511111122-xxxx",
        ...
    }
}

Step 2.2: Query the fine-tuning job status

Use the job_id obtained in Step 2.1 to query the job progress. Poll the following API until the status changes to SUCCEEDED.

Replace <replace_with_fine_tuning_job_id> in the URL with the value of job_id.

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/fine-tunes/<replace_with_fine_tuning_job_id>' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json'

Pay attention to two parameters in the output field:

• status: When its value changes to SUCCEEDED, the model training is complete and you can proceed with model deployment.
• usage: The total number of tokens consumed during model training, used for billing purposes.

{
    ...
    "output": {
        "job_id": "ft-202511111122-xxxx",
        "status": "SUCCEEDED",
        "usage": 432000,
        ...
    }
}

Step 3: Deploy the fine-tuned model

Step 3.1: Deploy the model as an online service

After the fine-tuning job status changes to SUCCEEDED, deploy the model as an online service.

Replace <replace_with_model_name> with the finetuned_output value from the Create a fine-tuning job output.

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/deployments' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json' \
--data '{
    "model_name": "<replace_with_model_name>",
    "capacity": 1,
    "plan": "lora"
}'

Pay attention to two parameters in the output field:

• deployed_model: The deployed model name, used to query the deployment status and invoke the model.
• status: The model deployment status. After deploying the fine-tuned model, the initial status is PENDING, indicating that deployment has not yet started.

{
    ...
    "output": {
        "deployed_model": "wan2.7-image-pro-xxxxxxxxxxxx",
        "status": "PENDING",
        ...
    }
}

Step 3.2: Query the deployment status

Query the deployment status. Poll the following API until the status changes to RUNNING.

Replace <replace_with_deployed_model> with the deployed_model value from the Step 3.1 output.

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/deployments/<replace_with_deployed_model>' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json'

Pay attention to two parameters in the output field:

• status: When the status changes to RUNNING, the model has been deployed successfully and you can start invoking it.
• deployed_model: The deployed model name.

{
    ...
    "output": {
        "status": "RUNNING",
        "deployed_model": "wan2.7-image-pro-xxxxxxxxxxxx",
        ...
    }
}

Step 4: Invoke the model to generate images

After the model is deployed successfully (deployment status is RUNNING), you can start making invocations.

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/image-generation/generation' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "X-DashScope-Async: enable" \
--data '{
    "model": "<replace_with_deployed_model>",
    "input": {
        "messages": [
            {
                "role": "user",
                "content": [
                    {"text": "s86b5p, A person in a crowded morning rush hour subway car, holding onto the handrail, with blurred passengers in the background and tunnel lights visible through the windows, wearing an ordinary office worker white shirt and black trousers, standing facing the camera, half-body shot, realistic candid feel."}
                ]
            }
        ]
    },
    "parameters": {
        "size": "2K",
        "n": 1
    }
}'

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/services/aigc/image-generation/generation' \
--header 'Content-Type: application/json' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header "X-DashScope-Async: enable" \
--data '{
    "model": "<replace_with_deployed_model>",
    "input": {
        "messages": [
            {
                "role": "user",
                "content": [
                    {"image": "<replace_with_reference_image_URL>"},
                    {"text": "s86b5p, Change the background to an elevator with red lighting. Change the character clothing to red tight-fitting mech armor with black stripe decorations."}
                ]
            }
        ]
    },
    "parameters": {
        "size": "2K",
        "n": 1
    }
}'

{
    "request_id": "4909100c-7b5a-9f92-bfe5-xxxxxx",
    "output": {
        "task_id": "0385dc79-5ff8-4d82-bcb6-xxxxxx",
        "task_status": "PENDING"
    }
}

curl -X GET https://dashscope-intl.aliyuncs.com/api/v1/tasks/86ecf553-d340-4e21-xxxxxxxxx \
--header "Authorization: Bearer $DASHSCOPE_API_KEY"

{
    "request_id": "3f2ebb4e-3d47-97b5-xxxx-xxxxxx",
    "output": {
        "task_id": "aeea547c-e24e-4acb-xxxx-xxxxxx",
        "task_status": "SUCCEEDED",
        "submit_time": "2026-05-29 17:35:23.826",
        "scheduled_time": "2026-05-29 17:35:23.865",
        "end_time": "2026-05-29 17:36:32.498",
        "finished": true,
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": [
                        {
                            "image": "https://dashscope-7c2c.oss-accelerate.aliyuncs.com/xxx.png?Expires=xxxxxx"
                        }
                    ]
                }
            }
        ]
    },
    "usage": {
        "size": "2048*2048",
        "total_tokens": 770,
        "image_count": 1,
        "output_tokens": 691,
        "input_tokens": 79
    }
}

Build custom datasets

In addition to using the sample data in this document to experience the fine-tuning workflow, you can also build your own datasets for fine-tuning. The dataset format and scale limits in this section apply to both Wan and Qwen image generation models.

A dataset should contain a training set (required) and a validation set (optional; supports automatic splitting from the training set). Package all files in .zipformat. File names should contain only English characters, digits, underscores, or hyphens.

Dataset format

Training set: Required

wan-image-t2i-training-dataset.zip
├── data.jsonl      # Must be named data.jsonl, maximum 20MB
├── 1_0.png         # Training target image, max resolution 4096*4096, max 20MB per image, supports PNG/JPG/JPEG/WEBP/BMP
├── 1_1.png         # File names support only English characters, flat structure (no subdirectories)
└── 1_2.png

{
  "prompt": "s86b5p, A person in a quiet private library on a peaceful afternoon, with tall dark walnut bookshelves behind them, sunlight streaming through venetian blinds casting striped shadows, wearing a soft beige cable-knit sweater, standing facing the camera, half-body shot, the image has a delicate film grain texture.",
  "img_path": "./1_0.png"
}

wan-image-i2i-training-dataset.zip
├── data.jsonl      # Must be named data.jsonl, maximum 20MB
├── 1_0.jpg         # Training target image (output)
├── 1_1.jpg         # Reference image (input)
├── 6_0.jpg         # Training target image (output)
└── 6_1.jpg         # Reference image (input)

{
  "prompt": "s86b5p, Change the background to an elevator with red lighting, featuring large floor-to-ceiling windows. Change the character's clothing to red tight-fitting mech armor with black stripe decorations.",
  "input_img": "./1_1.jpg",
  "img_path": "./1_0.jpg"
}

wan-image-multi-i2i-training-dataset.zip
├── data.jsonl      # Must be named data.jsonl, maximum 20MB
├── 1_0.jpg         # Training target image (output)
├── 1_ref.jpg       # Reference image 1 (e.g., character photo)
├── 1_pose.jpg      # Reference image 2 (e.g., pose image)
├── 6_0.jpg         # Training target image (output)
├── 6_ref.jpg       # Reference image 1
└── 6_pose.jpg      # Reference image 2

{
  "prompt": "s86b5p, Change the background to an elevator with red lighting, featuring large floor-to-ceiling windows. Outside the windows, there is a post-apocalyptic scene with red mist. Change the character's clothing to red tight-fitting mech armor with black stripe decorations. Standing with both arms stretched horizontally to form a T-shape.",
  "input_imgs": ["./1_ref.jpg", "./1_pose.jpg"],
  "img_path": "./1_0.jpg"
}

Validation set: Optional

The validation set includes an annotation file (data.jsonl) and optional reference images (required for image-to-image mode). Target images are not needed. At each evaluation checkpoint, the training job automatically invokes the model service to generate preview images using the prompts (and reference images) from the validation set.

• Validation set:

  • Text-to-image: wan-image-t2i-valid-dataset.zip
  • Image-to-image: wan-image-i2i-valid-dataset.zip

• Zip package directory structure:

wan-image-i2i-valid-dataset.zip
├── data.jsonl       # Must be named data.jsonl, maximum 20MB
├── input_001.png    # Optional, reference image for image-to-image mode
└── input_002.png

• Annotation file (data.jsonl): Each line represents one validation sample and must be a JSON object.

  Text-to-image

  {
      "prompt": "s86b5p, A person in a crowded morning rush hour subway car, holding onto the handrail, with blurred passengers in the background and tunnel lights visible through the windows, wearing an ordinary office worker white shirt and black trousers, standing facing the camera, half-body shot, realistic candid feel."
  }
  

  Image-to-image

  {
      "prompt": "s86b5p, Change the background to an elevator with red lighting, featuring large floor-to-ceiling windows. Change the character's clothing to red tight-fitting mech armor with black stripe decorations.",
      "input_img": "./input_001.png"
  }
  

  Multi-image-to-image

  The multi-image-to-image validation set uses input_imgs (array) to pass multiple reference image paths. The limit matches the training set: up to 9 images for Wan and up to 3 for Qwen (qwen-image-2.0).

  {
      "prompt": "s86b5p, Change the background to an elevator with red lighting, featuring large floor-to-ceiling windows. Outside the windows, there is a post-apocalyptic scene with red mist. Change the character's clothing to red tight-fitting mech armor with black stripe decorations. Standing with both arms stretched horizontally to form a T-shape.",
      "input_imgs": ["./input_001.png", "./input_002.png"]
  }
  

Data scale and limits

• Data volume: We recommend providing at least 25 images (50 or more is recommended for better results). Use the same character or style across multiple scenes and angles with consistent content descriptions.

• Zip package: When uploading via API, the total package size must be no larger than 1 GB.

• Training image requirements:

  • Supported image formats: BMP, JPEG, PNG, and WEBP.
  • Image resolution must be no larger than 4096×4096.
  • Individual image file size must be no larger than 20 MB.

Data collection and cleaning

1. Determine the fine-tuning scenario

Wan supports the following fine-tuning scenarios for image generation:

• IP character stylization: Train the model to learn the drawing style of a specific IP character, such as anime characters or mascot images.
• Fixed visual style: Improve the model's ability to reproduce a specific art style, such as flat illustration, ink painting, or pixel art.
• Specific scene generation: Replicate specific composition patterns or scene templates, such as product display images or poster layouts.

2. Obtain raw materials

• AI generation and selection: Use the Wan base model to generate images in bulk, then manually select the high-quality samples that best match the target effect. This is the most commonly used method.
• Real photography: If your goal is to achieve highly realistic scenes (such as real product photos or portrait photography), using real-shot footage is the best choice.
• 3D software rendering: For scenes that require fine detail control or 3D rendering styles, we recommend using 3D software (such as Blender or C4D) to create source materials.

3. Clean the data

Image annotation: Writing prompts for images

In the dataset annotation file (data.jsonl), each image has a corresponding prompt. The prompt describes the content of the target image. The quality of the prompt directly determines what the model learns.

Prompt writing formula

Evaluate models with validation sets

Specify the validation set

A fine-tuning job must include a training set, while a validation set is optional. You can choose to have the system automatically split or manually upload a validation set. The specific methods are as follows:

Method 1: No validation set uploaded (system automatic split)

When Video and image generation model fine-tuning API, if no validation set is uploaded separately (i.e., the validation_file_ids parameter is not provided), the system splits a validation set from the training set based on split, which defaults to 0.9. This means 90% is used for training and 10% for validation.

Method 2: Manually upload a validation set (specified via validation_file_ids)

If you want to use your own prepared data to evaluate checkpoints instead of relying on system random splitting, you can upload a custom validation set.

Note: Once you choose to upload manually, the system completely ignores the automatic split rules above and uses only the data you uploaded for validation.

{
    "model":"wan2.7-image-pro",
    "training_file_ids":[ "<training_set_file_id>" ],
    "validation_file_ids": [ "<custom_validation_set_file_id>" ],
    ...
}

Select the best checkpoint for deployment

During training, the system periodically saves model "snapshots" (i.e., checkpoints). By default, the system outputs the last checkpoint as the final fine-tuned model. However, checkpoints produced during intermediate stages may perform better than the final version. You can select the most satisfactory one for deployment.

The system runs checkpoints on the validation set and generates preview images at intervals set by the Hyperparameters (hyper_parameters) eval_steps.

• How to evaluate: Judge the results by directly observing the generated preview images.
• Selection criteria: Find the checkpoint with the best results and the most closely matching style.

Procedure

curl --location 'https://dashscope.aliyuncs.com/api/v1/fine-tunes/<replace_with_fine_tuning_job_id>/validation-results' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json'

{
    "request_id": "da1310f5-5a21-4e29-99d4-xxxxxx",
    "output": [
        {
            "checkpoint": "checkpoint-160"
        },
        ...
    ]
}

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/fine-tunes/<replace_with_fine_tuning_job_id>/validation-details/<replace_with_checkpoint_to_export>?page_no=1&page_size=10' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY"

{
    "request_id": "375b3ad0-d3fa-451f-b629-xxxxxxx",
    "output": {
        "page_no": 1,
        "page_size": 10,
        "total": 5,
        "list": [
            {
                "img_path": "https://finetune-result.oss-cn-wulanchabu.aliyuncs.com/xxx.png?Expires=xxxxxx",
                "prompt": "s86b5p, Change the background to an elevator equipped with a white ceiling lighting, featuring large floor-to-ceiling windows. Change the character's clothing to red tight-fitting mech armor with black stripe decorations.",
                "input_img": "https://finetune-result.oss-cn-wulanchabu.aliyuncs.com/val_dataset/input_001.png?Expires=xxxxxx"
            },
            ...
        ]
    }
}

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/fine-tunes/<replace_with_fine_tuning_job_id>/export/<replace_with_checkpoint_to_export>?model_name=<replace_with_exported_model_display_name>' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY"

{
    "request_id": "0817d1ed-b6b6-4383-9650-xxxxx",
    "output": true
}

curl --location 'https://dashscope-intl.aliyuncs.com/api/v1/fine-tunes/<replace_with_fine_tuning_job_id>/checkpoints' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY"

{
    "request_id": "b0e33c6e-404b-4524-87ac-xxxxxx",
    "output": [
         ...,
        {
            "create_time": "2025-11-11T13:27:29",
            "full_name": "ft-202511111122-496e:checkpoint-160",
            "job_id": "ft-202511111122-496e",
            "checkpoint": "checkpoint-160",
            "model_name": "xxxx-ft-202511111122-xxxx-c160", // Important field, used for model deployment and invocation
            "model_display_name": "xxxx-ft-202511111122-xxxx",
            "status": "SUCCEEDED" // Successfully exported checkpoint
        },
        ...

    ]
}

Billing

• Model training: Charged.
  • Cost = Total training tokens × Unit price. See Training and deployment pricing.
  • After training is complete, check the total number of tokens consumed during training in the usage field of the Retrieve a fine-tuning job API.

  The following table lists the training step counts and estimated costs for wan2.7-image, wan2.7-image-pro. This data is for reference only. The actual training results are subject to the final delivery, and the costs are subject to the official bill. For detailed billing formulas, see Training and deployment pricing.

  generation_type	Image Resolution	Common Step Count	Estimated Token Consumption	Estimated Cost
  t2i (text-to-image)	1K	500	6,400,000	$96
  		1,000	12,800,000	$192
  		2,000	25,600,000	$384
  	2K	500	11,610,000	$174.15
  		1,000	23,220,000	$348.3
  		2,000	46,440,000	$696.6
  i2i (image-to-image)	1K	500	11,610,000	$174.15
  		1,000	23,220,000	$348.3
  		2,000	46,440,000	$696.6
  	2K	500	16,000,000	$240
  		1,000	32,000,000	$480
  		2,000	64,000,000	$960

  For qwen-image-2.0, total training tokens are calculated as n_epochs × Number of images in the training set × (max_pixels / Compression ratio) × GPU coefficient, and the training price is $0.003 per 1,000 tokens. The compression ratio is the fixed VAE compression ratio (1024), and the GPU coefficient is dynamically adjusted based on job scheduling. batch_size does not affect billing or the total training tokens. For the complete formula and a calculation example, see Training and deployment pricing.

  The following table estimates token consumption and fees for qwen-image-2.0 per training image, assuming a GPU coefficient of 8. For a training set of N images, multiply the values by N. These values are estimates only. Your bill is the final authority on fees.

  max_pixels	n_epochs	Estimated tokens	Estimated fee (USD)
  1k	800	6,553,600	19.66
  	1,000	8,192,000	24.58
  	2,000	16,384,000	49.15
  2k	800	26,214,400	78.64
  	1,000	32,768,000	98.30
  	2,000	65,536,000	196.61

• Model deployment and invocation: Deployment is free. Invocations are billed at the standard rate of the fine-tuned base model.

  Model ID	LoRA Deployment & Invocation Price
  wan2.7-image-pro	$0.075/image
  wan2.7-image	$0.03/image
  qwen-image-2.0	$0.035/image

API reference

Video and image generation model fine-tuning API

FAQ

Q: How do I design a good trigger word?

A: The rules are as follows:

• We recommend using rare character combinations with no actual semantic meaning, such as s86b5p, m01aa, or EVEAven638123. Ensure there is no semantic meaning in the base model's vocabulary.
• Avoid using common English words (such as beautiful, fire, or dance), as this would pollute the model's original understanding of these words.