December 11, 2025(Updated 2/6/2026)

Qwen-Image-i2L: Crie seu próprio artista de IA com uma única imagem - Guia completo para criação de imagens personalizadas

Author: z-image.me Team•5 min read

Qwen-Image-i2L: Crie seu próprio artista de IA com uma única imagem, guia completo para criação de imagens personalizadas

Você já desejou que a IA aprendesse seu estilo de ilustração favorito, mas se frustrou por não ter dezenas de imagens e poder computacional caro? Agora, uma única imagem é suficiente. O Qwen-Image-i2L, de código aberto do laboratório Tongyi da Alibaba, é exatamente essa ferramenta revolucionária que permite personalizar seu próprio artista de IA como se estivesse "montando um Lego" com apenas uma imagem.

Este artigo irá guiá-lo do zero para dominar rapidamente o uso deste "varinha mágica de estilos".

I. Primeiros passos com o i2L: O que é e por que é poderoso?

Qwen-Image-i2L é uma ferramenta de transferência de estilo personalizada. Seu núcleo é o "Image to LoRA", que significa decompor e "comprimir" os principais recursos de estilo de uma imagem de entrada em um módulo de adaptador LoRA (Low-Rank Adaptation) leve.

Princípio fundamental: A "técnica de desmontagem de estilos" que simplifica o complexo

A IA tradicional precisa de grandes quantidades de dados e treinamento prolongado para aprender novos estilos. A inovação do i2L está em seu mecanismo de decomposição de imagens: ele inteligentemente divide uma imagem em "peças" aprendíveis, como "tom de cores", "texturas e pinceladas", "elementos de composição", semelhante a abrir uma caixa surpresa. Essas peças são encapsuladas em um arquivo LoRA de apenas alguns GB, que pode então ser carregado em modelos de geração de imagens a partir de texto como o Stable Diffusion para gerar inúmeras novas obras no mesmo estilo.

Em resumo, seu fluxo de trabalho pode ser resumido em três passos:

flowchart TD
    A[输入<br>单张风格图像] --> B(核心：图像分解与特征提取)
    
    B --> C{根据需求<br>选择模型变体}
    
    C -- 风格模式 --> D1[提取纯美学特征<br>如笔触、色调]
    C -- 粗粒度模式 --> D2[提取内容+风格<br>用于场景重构]
    C -- 精细模式 --> D3[提取高分辨率细节<br>用于纹理增强]
    
    D1 & D2 & D3 --> E(生成轻量级<br>LoRA适配器文件)
    
    E --> F[输出<br>可无限生成同风格图像的AI画师]

Análise aprofundada dos princípios

O núcleo do modelo é o pipeline de conversão de imagem para LoRA: a imagem de entrada primeiro passa por um codificador (como SigLIP2 para extrair semântica, DINOv3 para capturar padrões visuais, Qwen-VL para processar detalhes de alta resolução) para vetores de incorporação, que então são mapeados diretamente para matrizes LoRA (matrizes de baixa ordem A e B). LoRA é essencialmente um "patch" para o modelo base (como Qwen-Image), atualizando apenas alguns parâmetros (geralmente <1%), para uma injeção eficiente.

Quatro variantes são projetadas para diferentes necessidades:

Style (2.4B): Focado em extração de estilo, com preservação fraca de detalhes, mas forte captura de estilo. Codificador: SigLIP2 + DINOv3.
Coarse (7.9B): Expansão do Style, captura inicial de conteúdo, mas detalhes imperfeitos. Adiciona Qwen-VL (resolução 224x224).
Fine (7.6B): Atualização incremental do Coarse, elevado para resolução 1024x1024, focado em detalhes. Deve ser usado em conjunto com Coarse.
Bias (30M): LoRA estático, corrige o desvio de estilo entre as imagens geradas e o modelo base Qwen-Image (como preferências de cor).

Abaixo está um diagrama de arquitetura LoRA geral, no qual o Qwen-Image-i2L adiciona uma camada de entrada de imagem:

Limitações incluem generalização insuficiente (uma única imagem dificilmente captura lógica 3D) e perda de detalhes (texturas complexas podem exigir múltiplas imagens). Pesquisas mostram que o uso de Bias pode melhorar a compatibilidade em 20-30% (com base em comparações de exemplo).

Por que você deve prestar atenção a ele? Quatro vantagens fundamentais

Barreira extremamente baixa: Diga adeus ao fluxo tradicional que requer mais de 20 imagens e clusters GPU, uma imagem e um computador comum são suficientes.
Eficiência extremamente alta: Da preparação à geração de um modelo de estilo utilizável, o tempo é reduzido de várias horas para alguns minutos.
Qualidade excelente: O LoRA gerado pode capturar com precisão a essência da imagem original, integrando-se perfeitamente ao fluxo de trabalho de pintura com IA.
Uso flexível: Seja aplicando o estilo de "A Noite Estrelada" em edifícios modernos ou transferindo estilo anime para fotos reais, tudo pode ser tentado rapidamente.

II. Guia prático: Começando do zero com o i2L

1. Preparação do ambiente

Semelhante ao uso do modelo básico Qwen-Image, você precisará de um ambiente Python. Como o i2L é desenvolvido com base no poderoso Qwen-Image (arquitetura MMDiT com 20 bilhões de parâmetros), ele tem alguns requisitos de hardware.

Aqui estão as configurações recomendadas:

Hardware	Requisito mínimo	Configuração recomendada
GPU	NVIDIA GTX 1080 Ti (8GB)	NVIDIA RTX 4090 D ou superior
Memória	16GB	32GB ou mais
Armazenamento	50GB de espaço disponível	100GB SSD

2. Escolha sua "varinha mágica": Quatro variantes de modelo

O i2L não é único, ele oferece quatro modelos otimizados para diferentes cenários, e você precisa escolher com base em seus objetivos de criação:

Modelo variante	Tamanho de parâmetro	Uso principal	Cenários adequados
Modo de estilo	2.4B	Especializado em transferência de estética pura	Aprendendo pinceladas de aquarela, textura de óleo, tons de filtro específicos
Modo de granularidade grossa	7.9B	Captura conteúdo e estilo, para reconstrução de cena	Transformar ruas em ciberpunk, paisagens em mundos de conto de fadas
Modo de granularidade fina	7.6B	Gera detalhes de alta resolução 1024x1024	Quando é necessário destacar detalhes como pelos de animais, tijolos de edifícios, texturas de tecido
Modo de viés	30M	Garante que a saída seja estilisticamente consistente com o Qwen-Image original	Unificação visual de materiais promocionais empresariais, prevenindo "desvio" da marca

Sugestão para iniciantes: Comece com o modo de estilo ou modo de granularidade grossa, eles podem lidar com a maioria das necessidades comuns.

3. Passos principais: Treinando seu LoRA com uma única imagem

Aqui está um fluxo de trabalho simplificado, para códigos específicos, consulte o repositório oficial GitHub do projeto.

Primeiro passo: Obter o modelo
Todos os modelos estão de código aberto, você pode pesquisar "Qwen-Image-i2L" nas plataformas Hugging Face ou ModelScope e baixar gratuitamente.

Segundo passo: Prepare sua imagem de estilo

Escolha uma imagem que represente claramente o estilo desejado.
Certifique-se de que a imagem tenha alta qualidade, com elementos principais claros.
(Opcional) Se você quiser aprender um sujeito específico (como um gato específico), tente usar uma imagem com o sujeito proeminente.

Terceiro passo: Execute o script de treinamento
O processo de treinamento geralmente requer apenas um comando. Você precisa especificar o caminho da imagem de entrada, o local de salvamento do LoRA de saída e escolher o tipo de modelo correspondente da tabela acima.

# Exemplo de comando (apenas para referência, consulte a documentação oficial)
python train_i2l.py \
  --input_image "sua_imagem.webp" \
  --model_type "style" \  # Aqui escolha "modo de estilo"
  --output_lora "./meu_style_lora.safetensors"

Quarto passo: Use o LoRA gerado para criar
Após o treinamento, você obterá um arquivo .safetensors. No Stable Diffusion WebUI (como Automatic1111) ou ComfyUI:

Coloque o arquivo LoRA na pasta de modelos correspondente.
Ao gerar imagens, chame esse LoRA através de sintaxe específica (como <lora:meu_style_lora:1>) no prompt.
Digite sua descrição de conteúdo e gere novas imagens que fundem o estilo personalizado.

4. Técnicas de Ajuste e Dicas de Prompt

O prompt é a chave: Os modelos da série Qwen são conhecidos por sua poderosa capacidade de compreensão e renderização de texto. Ao gerar a imagem final, combinar prompts de conteúdo claros com LoRA produz melhores resultados. Por exemplo: "<lora:van Gogh_starry_night:0.8>, um arranha-céu moderno, céu noturno, estrelas em forma de espiral, pinceladas de óleo."
Controlar a intensidade da LoRA: Geralmente é possível ajustar o peso na sintaxe de chamada (por exemplo, mudar :1 para :0.7). Quanto menor o peso, mais fraco é o impacto do estilo e mais natural é a fusão com o conteúdo.
Usar prompts negativos: Excluir elementos indesejados, como "blurry, deformed, ugly", para melhorar a qualidade da imagem.

5. Código de Inferência Recomendado Oficialmente

Instalar DiffSynth-Studio:

git clone https://github.com/modelscope/DiffSynth-Studio.git  
cd DiffSynth-Studio
pip install -e .

Qwen-Image-i2L-Style

from diffsynth.pipelines.qwen_image import (
    QwenImagePipeline, ModelConfig,
    QwenImageUnit_Image2LoRAEncode, QwenImageUnit_Image2LoRADecode
)
from modelscope import snapshot_download
from safetensors.torch import save_file
import torch
from PIL import Image

vram_config_disk_offload = {
    "offload_dtype": "disk",
    "offload_device": "disk",
    "onload_dtype": "disk",
    "onload_device": "disk",
    "preparing_dtype": torch.bfloat16,
    "preparing_device": "cuda",
    "computation_dtype": torch.bfloat16,
    "computation_device": "cuda",
}

# Carregar modelos
pipe = QwenImagePipeline.from_pretrained(
    torch_dtype=torch.bfloat16,
    device="cuda",
    model_configs=[
        ModelConfig(model_id="DiffSynth-Studio/General-Image-Encoders", origin_file_pattern="SigLIP2-G384/model.safetensors", **vram_config_disk_offload),
        ModelConfig(model_id="DiffSynth-Studio/General-Image-Encoders", origin_file_pattern="DINOv3-7B/model.safetensors", **vram_config_disk_offload),
        ModelConfig(model_id="DiffSynth-Studio/Qwen-Image-i2L", origin_file_pattern="Qwen-Image-i2L-Style.safetensors", **vram_config_disk_offload),
    ],
    processor_config=ModelConfig(model_id="Qwen/Qwen-Image-Edit", origin_file_pattern="processor/"),
    vram_limit=torch.cuda.mem_get_info("cuda")[1] / (1024 ** 3) - 0.5,
)

# Carregar imagens
snapshot_download(
    model_id="DiffSynth-Studio/Qwen-Image-i2L",
    allow_file_pattern="assets/style/1/*",
    local_dir="data/examples"
)
images = [
    Image.open("data/examples/assets/style/1/0.webp"),
    Image.open("data/examples/assets/style/1/1.webp"),
    Image.open("data/examples/assets/style/1/2.webp"),
    Image.open("data/examples/assets/style/1/3.webp"),
    Image.open("data/examples/assets/style/1/4.webp"),
]

# Inferência do modelo
with torch.no_grad():
    embs = QwenImageUnit_Image2LoRAEncode().process(pipe, image2lora_images=images)
    lora = QwenImageUnit_Image2LoRADecode().process(pipe, **embs)["lora"]
save_file(lora, "model_style.safetensors")

Qwen-Image-i2L-Coarse、Qwen-Image-i2L-Fine、Qwen-Image-i2L-Bias

from diffsynth.pipelines.qwen_image import (
    QwenImagePipeline, ModelConfig,
    QwenImageUnit_Image2LoRAEncode, QwenImageUnit_Image2LoRADecode
)
from diffsynth.utils.lora import merge_lora
from diffsynth import load_state_dict
from modelscope import snapshot_download
from safetensors.torch import save_file
import torch
from PIL import Image

vram_config_disk_offload = {
    "offload_dtype": "disk",
    "offload_device": "disk",
    "onload_dtype": "disk",
    "onload_device": "disk",
    "preparing_dtype": torch.bfloat16,
    "preparing_device": "cuda",
    "computation_dtype": torch.bfloat16,
    "computation_device": "cuda",
}

Carregar modelos

pipe = QwenImagePipeline.from_pretrained(
torch_dtype=torch.bfloat16,
device="cuda",
model_configs=[
ModelConfig(model_id="Qwen/Qwen-Image", origin_file_pattern="text_encoder/model*.safetensors", **vram_config_disk_offload),
ModelConfig(model_id="DiffSynth-Studio/General-Image-Encoders", origin_file_pattern="SigLIP2-G384/model.safetensors", **vram_config_disk_offload),
ModelConfig(model_id="DiffSynth-Studio/General-Image-Encoders", origin_file_pattern="DINOv3-7B/model.safetensors", **vram_config_disk_offload),
ModelConfig(model_id="DiffSynth-Studio/Qwen-Image-i2L", origin_file_pattern="Qwen-Image-i2L-Coarse.safetensors", **vram_config_disk_offload),
ModelConfig(model_id="DiffSynth-Studio/Qwen-Image-i2L", origin_file_pattern="Qwen-Image-i2L-Fine.safetensors", **vram_config_disk_offload),
],
processor_config=ModelConfig(model_id="Qwen/Qwen-Image-Edit", origin_file_pattern="processor/"),
vram_limit=torch.cuda.mem_get_info("cuda")[1] / (1024 ** 3) - 0.5,
)

Carregar imagens

snapshot_download(
model_id="DiffSynth-Studio/Qwen-Image-i2L",
allow_file_pattern="assets/lora/3/*",
local_dir="data/examples"
)
images = [
Image.open("data/examples/assets/lora/3/0.webp"),
Image.open("data/examples/assets/lora/3/1.webp"),
Image.open("data/examples/assets/lora/3/2.webp"),
Image.open("data/examples/assets/lora/3/3.webp"),
Image.open("data/examples/assets/lora/3/4.webp"),
Image.open("data/examples/assets/lora/3/5.webp"),
]

Inferência do modelo

with torch.no_grad():
embs = QwenImageUnit_Image2LoRAEncode().process(pipe, image2lora_images=images)
lora = QwenImageUnit_Image2LoRADecode().process(pipe, **embs)["lora"]
lora_bias = ModelConfig(model_id="DiffSynth-Studio/Qwen-Image-i2L", origin_file_pattern="Qwen-Image-i2L-Bias.safetensors")
lora_bias.download_if_necessary()
lora_bias = load_state_dict(lora_bias.path, torch_dtype=torch.bfloat16, device="cuda")
lora = merge_lora([lora, lora_bias])
save_file(lora, "model_coarse_fine_bias.safetensors")


#### Usar o LoRA gerado para criar imagens
```py
from diffsynth.pipelines.qwen_image import QwenImagePipeline, ModelConfig
import torch

vram_config = {
    "offload_dtype": "disk",
    "offload_device": "disk",
    "onload_dtype": torch.bfloat16,
    "onload_device": "cpu",
    "preparing_dtype": torch.bfloat16,
    "preparing_device": "cuda",
    "computation_dtype": torch.bfloat16,
    "computation_device": "cuda",
}
pipe = QwenImagePipeline.from_pretrained(
    torch_dtype=torch.bfloat16,
    device="cuda",
    model_configs=[
        ModelConfig(model_id="Qwen/Qwen-Image", origin_file_pattern="transformer/diffusion_pytorch_model*.safetensors", **vram_config),
        ModelConfig(model_id="Qwen/Qwen-Image", origin_file_pattern="text_encoder/model*.safetensors", **vram_config),
        ModelConfig(model_id="Qwen/Qwen-Image", origin_file_pattern="vae/diffusion_pytorch_model.safetensors", **vram_config),
    ],
    tokenizer_config=ModelConfig(model_id="Qwen/Qwen-Image", origin_file_pattern="tokenizer/"),
    vram_limit=torch.cuda.mem_get_info("cuda")[1] / (1024 ** 3) - 0.5,
)
pipe.load_lora(pipe.dit, "model_style.safetensors")
image = pipe("a cat", seed=0, height=1024, width=1024, num_inference_steps=50)
image.save("image.webp")

6. Exemplos oficiais

Estilo

O modelo Qwen-Image-i2L-Style pode ser usado para gerar rapidamente LoRA de estilo, basta inserir algumas imagens com estilo unificado. Aqui estão os resultados que geramos, com sementes aleatórias todas 0.

Grosso + Fino + Viés

A combinação dos três modelos Qwen-Image-i2L-Coarse, Qwen-Image-i2L-Fine e Qwen-Image-i2L-Bias pode gerar pesos LoRA que preservam o conteúdo e as informações detalhadas da imagem. Esses pesos, como pesos de inicialização para o treinamento LoRA, podem acelerar a velocidade de convergência.

Três, Cenários de Aplicação: Acelerador de sua Criatividade

Criação Artística Pessoal: Experimente rapidamente diversos estilos de mestres, ou estabeleça um estilo consistente para seu portfólio.
E-commerce e Marketing: Gere rapidamente imagens promocionais de estilo consistente mas com diferentes conteúdos para diferentes linhas de produtos, reduzindo significativamente os custos de fotografia e design.
Conceitos para Jogos e Filmes: Migrar rapidamente o estilo de uma arte original para múltiplos cenários e designs de personagens, produzindo eficientemente conceitos visuais.
Gestão Visual de Marca: Use o "modo de viés" para garantir que todos os materiais de marketing gerados por IA estejam em conformidade estrita com as diretrizes de identidade visual da marca.

Quatro, Precauções e Futuro

Limitações Atuais: Extrair lógica 3D a partir de uma única imagem 2D apresenta desafios. Por exemplo, ao treinar com uma imagem de "um gato no sofá", as imagens geradas podem mostrar objetos flutuando ou distorcidos em outros ângulos. Para estilos tridimensionais complexos, preparar imagens de múltiplos ângulos ainda é a melhor opção.
Desenvolvimento Futuro: i2L marca a entrada da geração de imagens por IA na era da "personalização instantânea". Pode-se prever que mais aplicativos como "geração instantânea de storyboards de mangá" e "design instantâneo de personagens" surgirão, tornando a criação personalizada com IA mais comum.

Agora, encontre uma imagem que melhor represente sua estética pessoal e comece a criar seu artista de IA exclusivo!

Este guia de operação é baseado na documentação técnica de código aberto Qwen-Image-i2L e práticas da comunidade. Os métodos específicos de uso do modelo podem ser atualizados, recomendamos consultar simultaneamente as páginas do projeto em z-image.me, Hugging Face ou ModelScope para obter as informações mais recentes.