Accéder au contenu principal

Tutoriel Qwen Image 2.1 : créer un éditeur d’images et un générateur de GIF

Apprenez à éditer des images avec Qwen Image 2.1 sur un Colab A100, à guider les changements avec du texte ou des dessins, puis à exporter les résultats sélectionnés en GIF.
· 12 min lire

Explorez l'IA

Créer un GIF à partir d’une image est assez simple. Vous demandez au modèle d’image une nouvelle pose, vous répétez l’opération, puis vous assemblez les sorties à une certaine vitesse. En pratique, la stratégie d’entrée compte autant que le prompt. Lorsque j’ai alimenté chaque image générée dans la requête suivante, des artéfacts se sont accumulés progressivement.

Dans ce tutoriel, nous utiliserons Qwen Image 2.1 pour créer un éditeur interactif qui adopte une approche plus fiable pour cette expérience. Chaque requête repart de l’image originale. Les utilisateurs peuvent décrire une modification, marquer éventuellement la zone concernée, puis accepter ou rejeter le résultat avant d’exporter un GIF.

Nous utiliserons Qwen Image 2.1 pour l’édition, ComfyUI pour l’inférence, Gradio pour l’interface, et Pillow pour l’export. L’accent est mis sur les choix de conception qui ont influencé mes résultats : sélection de la référence, résolution, paramètres d’échantillonnage, décodage VAE et précision des instructions.

À la fin, vous saurez :

  • Exécuter un workflow Qwen Image 2.1 quantifié sur un GPU A100 dans Google Colab.
  • Configurer l’échantillonnage et la mémoire comme dans cette démo.
  • Combiner des instructions textuelles avec des annotations de région facultatives.
  • Conserver une référence originale fixe tout en enregistrant plusieurs images éditées.
  • Évaluer les changements indésirables et exporter un GIF.

Notebook

Qu’est-ce que Qwen-Image-2.1 ?

Qwen Image 2.1 est un modèle unifié de génération et d’édition d’images.

Son composant de génération visuelle contient 7 milliards de paramètres. Le modèle prend en charge la génération texte-vers-image, la transparence native, plusieurs images de référence et l’édition locale guidée par des annotations ou des masques. Ce tutoriel se concentre sur l’édition RGB avec une seule référence. 

Le modèle fournit déjà la capacité d’édition. Notre application ajoute le flux autour : sélection de l’entrée, revue des candidats, gestion des images acceptées et export. Nous n’entraînons pas un nouveau modèle et n’ajoutons pas de module de mouvement.

Le GIF obtenu lit des images fixes générées indépendamment. Il peut montrer des changements de pose et des variations visuelles, mais ce n’est pas équivalent à une génération vidéo temporellement cohérente.

Comment fonctionne Qwen Image 2.1 ?

La description officielle de l’architecture identifie quatre composants principaux :

Composant

Spécification

Rôle

Transformeur visuel

Transformeur de diffusion (DiT) monoflux 32 couches, 7B paramètres

Traite les tokens de conditionnement et de l’image cible dans un même flux

Encodeur texte et image

Qwen3-VL 8B

Encode les instructions et les images de référence dans une représentation unifiée

Autoencodeur d’image (VAE)

64 canaux latents, prise en charge RGBA, compression spatiale ×16

Convertit les images en représentations latentes compactes et décode les latents générés en pixels

Processus de génération

Flow matching avec planification discrète Euler et décalage dynamique

Met à jour itérativement les latents de l’image cible vers l’image générée

Le transformeur visuel contient 7 milliards de paramètres. Ce décompte exclut l’encodeur texte-image et le VAE. 

Les 64 canaux du VAE se réfèrent à sa représentation latente, et non à 64 canaux de couleur en sortie. 

La sortie RGBA contient les canaux rouge, vert, bleu et alpha. L’application aplanit les imports en RGB, elle ne démontre donc pas la prise en charge native de la transparence du modèle.

Lire le schéma d’attention

Qwen Image 2.1 utilise un masque d’attention à granularité mixte : les cellules colorées autorisent l’attention, les cellules grises la bloquent.

Qwen-Image-2.1 mixed-granularity attention architecture

Figure 1 : architecture d’attention à granularité mixte de Qwen Image 2.1 (article du blog Qwen)

Lisez le schéma par ligne : Q représente les tokens de requête, et K les tokens auxquels ils peuvent prêter attention. La séquence contient un préfixe système, une image d’entrée optionnelle, une instruction d’édition et l’image cible.

Le texte utilise une attention causale, car un token texte peut regarder lui-même et les positions antérieures. Les tokens au sein d’un même bloc image peuvent s’attendre mutuellement dans les deux sens. 

Cela produit les régions triangulaires pour le texte et les blocs pleins pour les images visibles en figure 1.

La règle du masque exprime cette combinaison comme :

allowed = (q_idx >= kv_idx) or same_image_block

Il s’agit d’une règle conceptuelle pour une paire de positions de tokens, pas d’un réglage à coller dans le notebook. Elle autorise l’attention vers les positions antérieures et permet une attention tous-azimuts au sein de chaque bloc image.

Pourquoi peut-on mettre en cache un préfixe ?

Le préfixe système, l’image de référence et l’instruction ne peuvent pas prêter attention au bloc ultérieur de l’image cible. 

Leurs représentations n’ont donc pas besoin de changer à mesure que l’image cible est mise à jour.

Qwen calcule leurs clés et valeurs d’attention une seule fois à la première étape de débruitage et les réutilise aux étapes suivantes. Les tokens de l’image cible nécessitent toujours un calcul à chaque étape, en prêtant attention au préfixe mis en cache et entre eux. 

Avec 40 étapes, le préfixe fixe peut être réutilisé après la première ; cela ne signifie pas une accélération ×40, car le calcul sur l’image cible reste conséquent.

Cette réutilisation du cache se produit au fil des étapes de débruitage d’une même génération. Cela ne signifie pas que le modèle se souvient des requêtes précédentes de l’utilisateur, ni que notre application réemploie automatiquement le même cache entre des éditions soumises séparément. 

Démo : créer un éditeur d’images avec Qwen Image 2.1 

Avant de construire l’application, distinguons les paramètres du modèle des décisions applicatives. Notez qu’augmenter le nombre d’étapes ne corrigera pas un pipeline qui réinjecte en boucle des images dégradées dans le modèle.

Paramètre

Valeur utilisée

Pourquoi c’est important

Image de référence

Image originale pour chaque édition dans l’appli finale

Évite de transmettre des artéfacts d’une image générée à la suivante

Résolution

1024

Cible d’édition d’environ un mégapixel dans ce backend

Étapes d’inférence

40

Budget d’échantillonnage utilisé dans les expériences principales

Seed

42

Maintient la graine d’échantillonnage fixe pendant les tests d’instructions

CFG

1.0

Conforme au workflow fourni ; la guidance négative standard n’apporte rien à cette valeur

Sampler/planificateur

Euler / simple

Conserve la configuration d’échantillonnage fournie

Denoise

1.0

Adapté à ce workflow d’édition par instruction ; ce n’est pas une recette img2img à faible débruitage classique

Décodage VAE

Non tuilé dans la configuration finale

Choisi après une amélioration qualitative observée en développement

Poids

Modèle image et encodeur texte INT8 ConvRot ; VAE en BF16

Backend économe en mémoire utilisé pour la démo

Déchargement CPU de l’encodeur/cache de référence

Désactivé au départ

L’exécution sur A100 tenait sans activer ces décharges supplémentaires

Ce sont des réglages opérationnels pour ce projet, pas une configuration optimale universelle. Nous n’avons pas mené de balayage systématique des étapes, du CFG, des échantillonneurs ou des formats de quantification.

Les valeurs du sampler proviennent du workflow d’édition d’image, qui m’a permis de faire tourner ce modèle avec peu de VRAM. 

Étape 1 : préparer l’environnement Colab

L’exécution enregistrée utilisait une NVIDIA A100-SXM4-40GB, avec 83,5 GiB de RAM hôte. 

J’ai utilisé le package d’installation alesha-pro pour installer ComfyUI et télécharger les poids quantifiés.

Prévoyez environ 45 Go d’espace libre, incluant l’environnement, les modèles, les caches et les sorties. 

Un runtime avec beaucoup de RAM offre de la marge lors des chargements et déchargements.

Commencez par définir les chemins et vérifier le GPU :

import sys, os, json, time, uuid, shutil, subprocess, copy, io, threading
from pathlib import Path
from PIL import Image, ImageDraw, ImageFilter, ImageOps
import numpy as np
import requests
import gradio as gr
from IPython.display import display, Image as DisplayImage

ROOT = Path('/content/qwen_gif_demo')
ROOT.mkdir(parents=True, exist_ok=True)
TOOLS = ROOT / 'tools'
COMFY = ROOT / 'ComfyUI'
RUNS = ROOT / 'runs'
RUNS.mkdir(exist_ok=True)
REPO_REV = 'dc0083c0d17581f04ebbca962771e36f82f31af8'
BASE = 'http://127.0.0.1:8188'

def run_cmd(args, **kwargs):
    print('Running:', ' '.join(map(str, args)), flush=True)
    subprocess.run(list(map(str, args)), check=True, **kwargs)

if not shutil.which('nvidia-smi'):
    raise RuntimeError('Select a GPU runtime before continuing.')
print(subprocess.check_output(['nvidia-smi'], text=True))

Le contrôle GPU stoppe l’exécution si Colab utilise encore un runtime CPU, et nous affichons aussi des détails sur la RAM hôte et l’espace disque libre avant l’installation. 

Les imports sont assez basiques, incluant les bibliothèques standard de Python pour gérer les chemins, les workflows JSON, les processus backend, le timing et la surveillance en arrière-plan. 

Pillow et NumPy gèrent le traitement d’image, Requests communique avec ComfyUI, Gradio fournit l’interface, et IPython affiche les images dans le notebook.

Installer le backend séparément de l’UI

ComfyUI s’exécute dans son propre environnement virtuel. Le noyau du notebook gère les imports, les requêtes HTTP et Gradio.

if not TOOLS.exists():
    run_cmd(['git', 'init', TOOLS])
    run_cmd(['git', '-C', TOOLS, 'remote', 'add', 'origin', 'https://github.com/alesha-pro/tools.git'])
    run_cmd(['git', '-C', TOOLS, 'fetch', '--depth', '1', 'origin', REPO_REV])
    run_cmd(['git', '-C', TOOLS, 'checkout', '--detach', 'FETCH_HEAD'])
assert subprocess.check_output(['git', '-C', str(TOOLS), 'rev-parse', 'HEAD'], text=True).strip() == REPO_REV
PKG = TOOLS / 'qwen-image-2.1'
VERSIONS = json.loads((PKG / 'install/versions.json').read_text())
print('Pinned backend:', VERSIONS)
driver = subprocess.check_output(['nvidia-smi', '--query-gpu=driver_version', '--format=csv,noheader'], text=True).splitlines()[0]
# Conservative selector; the backend CUDA smoke test is authoritative.
TORCH_INDEX = 'https://download.pytorch.org/whl/cu130' if int(driver.split('.')[0]) >= 580 else 'https://download.pytorch.org/whl/cu128'
print('Driver:', driver, '| wheel index:', TORCH_INDEX)
run_cmd([sys.executable, PKG / 'install/setup.py', 'install', '--dir', COMFY, '--torch-index', TORCH_INDEX])
BACKEND_PY = COMFY / '.venv/bin/python'
run_cmd([BACKEND_PY, '-c', "import torch; print(torch.__version__, torch.version.cuda); print(torch.cuda.get_device_name(0)); x=torch.ones(16,device='cuda'); print(x.sum().item())"])
run_cmd([BACKEND_PY, PKG / 'install/download_models.py', '--models-dir', COMFY / 'models'])

Ce code récupère la source épinglée, lit sa configuration de versions, installe le backend, teste une opération CUDA sur tenseur et télécharge les modèles.

La sélection de la roue CUDA utilise la version du driver comme heuristique initiale. 

Le test rapide CUDA est une vérification importante, car une A100 seule n’assure pas la compatibilité avec toutes les builds PyTorch. Ma session utilisait le driver 580.82.07.

Étape 2 : démarrer le backend et définir les paramètres d’inférence

La cellule de démarrage lance ComfyUI sur 127.0.0.1:8188, attend sa disponibilité et récupère les définitions de nœuds disponibles. 

Le code communique avec lui via un petit utilitaire HTTP :

def api(path, body=None):
    r = requests.get(BASE + path, timeout=30) if body is None else requests.post(BASE + path, json=body, timeout=30)
    if not r.ok:
        raise RuntimeError(f'{path}: HTTP {r.status_code}: {r.text[:3000]}')
    return r.json()

Cet utilitaire transforme les échecs côté serveur en exceptions lisibles. Après le démarrage, le schéma des nœuds est accessible via :

INFO = api('/object_info')

Le code de démarrage vérifie l’existence d’un serveur avant d’en lancer un autre processus. Il n’y a donc pas de tunnel ComfyUI public séparé dans cette configuration.

Définissons maintenant les paramètres utilisés pour l’édition :

CPU_ENCODER = False
CPU_REFERENCE_CACHE = False
TILED_VAE = False
STEPS = 40
SIZE = 1024
SEED = 42

Voici comment interpréter ces réglages :

  • STEPS : davantage d’itérations d’échantillonnage coûtent en général plus de temps. Nous avons utilisé 40.
  • SIZE : dans le graphe d’édition, la résolution 1024 vise environ un mégapixel tout en adaptant les dimensions à la référence. Elle n’impose pas une sortie carrée.
  • SEED : une graine fixe facilite les comparaisons dans un même contexte. Elle ne garantit ni la préservation d’identité ni des transitions fluides entre prompts différents.
  • TILED_VAE : le décodage non tuilé traite l’image sans passer par le chemin de décodage en petites tuiles configuré. Il peut nécessiter plus de mémoire. Notre préférence vient de tests visuels, sans preuve contrôlée que le tuilage causait chaque artéfact.
  • Fanions de déchargement CPU : ce sont des contrôles de gestion mémoire, pas de qualité d’image. Activez-les seulement en cas de besoin et mesurez la latence et l’usage RAM induits.

De même, un prompt négatif n’est pas le levier principal à CFG 1. Laissez-le vide au lieu d’attendre d’une longue liste d’éléments indésirables qu’elle corrige une édition faible.

Étape 3 : relier le prompt et l’image de référence au modèle

Le constructeur de workflow charge un graphe d’API et remplace ses entrées spécifiques à la requête. L’extrait suivant montre le chemin d’édition :

g = json.loads((PKG / 'workflows/api/03-image-edit.json').read_text())
g['4']['inputs'].update(prompt=prompt, resolution=SIZE)
g['6']['inputs'].update(seed=int(seed), steps=int(STEPS))
g['9']['inputs']['image'] = upload_image(image_path)

if CPU_REFERENCE_CACHE:
    g['11']['inputs']['device'] = 'cpu'
if CPU_ENCODER:
    g['2']['inputs']['device'] = 'cpu'

Ici, le nœud 4 reçoit l’instruction d’édition et la résolution. 

Le nœud 6 contrôle l’échantillonnage, et le nœud 9 charge la référence importée. 

Les deux autres remplacements déplacent en option l’encodeur ou le cache de référence vers la mémoire hôte.

L’utilitaire d’inférence soumet ensuite le graphe et attend son propre ID de requête :

response = api('/prompt', {
    'prompt': g,
    'client_id': uuid.uuid4().hex,
})
result = collect_result(response['prompt_id'], folder)

Ici, folder est le répertoire de sortie par requête, créé à l’intérieur de infer(). 

Le collecteur interroge l’historique et télécharge le PNG généré quand le job correspondant se termine.

Nous enregistrons aussi l’entrée, le graphe, la soumission, l’historique et les métriques. Cela permet d’inspecter la requête réelle quand une sortie semble incorrecte. 

Un timeout n’annule pas automatiquement le job GPU ; conservez donc l’ID de requête avant de décider de relancer.

Étape 4 : préparer une image originale

L’application finale a toujours besoin d’une référence inchangée à laquelle revenir. Le chemin d’import suivant corrige l’orientation, aplanit la transparence et ajoute l’image sur une toile carrée avant de la passer au modèle :

python
from google.colab import files
uploaded = files.upload()
assert len(uploaded) == 1, 'Upload exactly one image.'
with Image.open(io.BytesIO(next(iter(uploaded.values())))) as image:
    rgba = ImageOps.exif_transpose(image).convert('RGBA')
    background = Image.new('RGBA', rgba.size, (250, 240, 230, 255))
    original = Image.alpha_composite(background, rgba).convert('RGB')
    original = ImageOps.pad(original, (SIZE, SIZE), color=(250, 240, 230))

BASE_FRAME = ROOT / f'original-{uuid.uuid4().hex[:8]}.png'
original.save(BASE_FRAME)

Le remplissage conserve le ratio d’aspect plutôt que d’étirer le sujet. Mais il peut introduire des bordures. 

Un import direct dans l’éditeur Gradio suit son propre gestionnaire d’upload et peut conserver les dimensions importées. C’est pourquoi l’appli vérifie aussi les dimensions des candidats avant l’export.

Pour l’édition de pose, choisissez une image avec suffisamment d’espace pour le mouvement demandé et formulez une instruction en fonction des limites.

Étape 5 : guider les éditions avec du texte et des dessins

Un dessin est utile lorsque la cible pourrait être ambiguë, par exemple choisir un bras ou un objet dans une scène chargée. 

Il est totalement facultatif dans notre application. 

L’éditeur de Gradio fournit le fond, les calques de dessin et l’image composite, et la règle clé de notre conception finale est de charger l’original et d’ajouter uniquement les calques de dessin :

layers = editor_data.get('layers') or []
has_marks = any(
    np.any(np.asarray(layer.convert('RGBA'))[..., 3] > 0)
    for layer in layers if layer is not None
)
with Image.open(original_path) as image:
    source = image.convert('RGBA').copy()
if has_marks:
    for layer in layers:
        if layer is None:
            continue
        layer = layer.convert('RGBA')
        if layer.size != source.size:
            raise ValueError('Clear the drawing and redraw on the original.')
        source = Image.alpha_composite(source, layer)

C’est la logique centrale dans le callback d’édition. 

Le canal alpha révèle si un calque contient des marques visibles : cercle, rectangle ou trait approximatif, qui peuvent tous servir de guide visuel.

Ces marques ne constituent pas un masque d’inpainting strict. Elles indiquent au modèle où se concentrer, sans garantir l’immutabilité des pixels ailleurs.

Nous pouvons ajouter l’explication de région uniquement si des marques existent :

region_instruction = (
    'The red hand-drawn marks identify the target region. '
    'For an outline, edit the enclosed area; for painted strokes, '
    'edit the indicated area. Remove the annotation marks '
    'from the final result. '
) if has_marks else ''

prompt = (
    'Edit <image1>. '
    + region_instruction
    + f'Requested change: {instruction.strip()} '
    + "Preserve unrelated content and the image's framing. "
    + "Keep the subject's identity and visual style consistent "
    + 'unless the requested change explicitly alters them.'
)

La clause de préservation indique au modèle ce qui compte, mais cela reste une instruction, pas une garantie. 

Pour un test plus explicite, précisez le côté relatif à l’image et la pose finale, par exemple :

instruction = (
    'Lower the arm on the right side of the image so it extends '
    'diagonally downward. Keep the other arm, face, body position, '
    'camera framing, and background unchanged.'
)

Évitez « déplacez-le encore un peu » lorsque chaque requête repart de l’original. 

Le modèle ne reçoit ni la conversation précédente ni la dernière pose acceptée.

Étape 6 : générer chaque candidat depuis l’original

La première version de ce projet a généré une séquence en alimentant chaque sortie dans la requête suivante :

result = edit_frame(manifest['frames'][-1], POSES[pose_index])

image2.gif

C’est ce que j’ai changé dans l’appli finale, car des éditions répétées peuvent propager des artéfacts, chaque nouvelle requête partant de la sortie précédente du modèle. 

Dans notre séquence de plantes initiale, les images tardives devenaient nettement plus bruitées.

Le chemin de génération final utilise plutôt la référence originale, éventuellement annotée :

input_path = ROOT / f'edit-input-{uuid.uuid4().hex[:8]}.png'
source.convert('RGB').save(input_path)
result_path = infer(
    'edit',
    prompt,
    seed=int(seed),
    image_path=input_path,
)

Cela supprime le chemin de rétroaction via les images générées précédemment. 

Cela n’élimine pas les artéfacts dans des sorties individuelles, et n’impose pas une correspondance parfaite entre des images générées indépendamment.

Si une image acceptée contient une rose, la requête suivante ne l’hérite pas automatiquement. Pour conserver la rose tout en changeant la pose, il faut inclure les deux exigences :

instruction = (
    'Make the character hold a red rose in the hand on the right '
    'side of the image, with that arm extended downward. '
    'Preserve the other hand, face, background, and camera framing.'
)

Ce compromis est utile pour générer des variations à partir d’une même référence. 

Pour des tâches nécessitant des éditions cumulatives, un workflow séquentiel peut rester approprié, mais avec d’autres attentes sur les changements accumulés.

Étape 7 : revoir les candidats avant de les enregistrer

L’appli sépare l’original, la séquence acceptée et le résultat en attente via la fonction State de Gradio :

original_state = gr.State(initial_path)
frames_state = gr.State(initial_frames)
pending_state = gr.State(None)

La séquence commence par l’original et ne grandit que lorsque l’utilisateur accepte un candidat. L’état « pending » conserve un fichier généré pas encore accepté.

L’opération centrale d’acceptation est :

updated_frames = list(frames) + [pending_path]

Après cette mise à jour, le callback complet efface le candidat en attente et le prompt, et renvoie l’éditeur à l’original.

Discard efface le résultat en attente sans modifier les images acceptées. Reset ramène la séquence à un seul cadre original et efface l’instruction en cours et la sortie de téléchargement. Aucune de ces actions ne nécessite de recharger le modèle.

Étape 8 : construire l’appli Gradio

L’interface finale sépare l’édition, les images enregistrées et l’export en trois onglets. 

Gradio app

Le composant clé est l’éditeur d’image :

editor = gr.ImageEditor(
    value=initial_editor,
    type='pil',
    image_mode='RGBA',
    label='Input',
    height=480,
    brush=gr.Brush(
        colors=['#ff0000'],
        color_mode='fixed',
        default_size=8,
    ),
    eraser=gr.Eraser(default_size=20),
    transforms=(),
)

La couleur fixe du pinceau correspond à l’instruction d’annotation. 

La gomme permet d’affiner des régions approximatives, tandis que les transformations désactivées écartent recadrage et rotation de cette interaction.

L’événement de génération transmet l’état original au callback :

event_options = {
    'concurrency_id': 'edit_workflow',
    'concurrency_limit': 1,
}

generate_button.click(
    fn=generate_edit,
    inputs=[editor, instruction, seed, original_state],
    outputs=[candidate, pending_state, status],
    **event_options,
)

Ces extraits de code s’insèrent dans la mise en page complète Blocks. 

Le groupe de concurrence partagé sérialise la génération et les changements d’état dans cette démo. Reset attend son tour ; ce n’est pas un contrôle d’annulation de job GPU.

Une fois les handlers et composants définis, lancez l’appli en exécutant :

demo.queue(default_concurrency_limit=1).launch(
    share=True,
    debug=True,
)

Le lien de partage Gradio expose le frontend, tandis que le backend reste en localhost. Le thème et le CSS améliorent la présentation, sans impact sur la qualité d’image.

Étape 9 : convertir les images acceptées en GIF

L’exporteur utilise uniquement les images acceptées, car il crée une palette commune et lit éventuellement la séquence à l’envers après l’image finale :

def export_gif(paths, destination, duration_ms=300, ping_pong=True):
    frames = []
    for path in paths:
        with Image.open(path) as image:
            frames.append(image.convert('RGB').copy())
    if len(frames) < 2:
        raise ValueError('Accept at least one edit first.')
    if len({frame.size for frame in frames}) != 1:
        raise ValueError('Frame dimensions must match.')

    atlas = Image.new('RGB', (128 * len(frames), 128))
    for i, frame in enumerate(frames):
        atlas.paste(frame.resize((128, 128)), (128 * i, 0))
    palette = atlas.quantize(colors=256)
    converted = [
        frame.quantize(palette=palette, dither=Image.Dither.NONE)
        for frame in frames
    ]
    if ping_pong:
        converted += converted[-2:0:-1]
    converted[0].save(
        destination,
        save_all=True,
        append_images=converted[1:],
        duration=int(duration_ms),
        loop=0,
        disposal=2,
        optimize=False,
    )
    return str(destination)

Une palette partagée réduit une source potentielle de scintillement lié à la palette. 

Désactiver le dithering évite d’ajouter un motif de tramage lors de la conversion, bien que la réduction des couleurs puisse encore introduire du banding.

La durée est mesurée en millisecondes, et loop=0 demande une lecture continue. Pour quatre images, la lecture « ping-pong » suit l’ordre 0, 1, 2, 3, 2, 1. 

La tranche inversée exclut les extrémités dupliquées. Cela n’interpole pas le mouvement : une animation plus fluide requiert des poses intermédiaires adaptées, pas seulement une vitesse de lecture différente.

Conclusion

Nous avons construit un éditeur Qwen Image 2.1 qui accepte des instructions textuelles et des dessins facultatifs, permet aux utilisateurs de sélectionner les résultats un par un et les exporte en GIF. 

La décision qualité clé a été de conserver une référence originale fixe plutôt que d’éditer à répétition des sorties générées.

Partez de la configuration d’échantillonnage opérationnelle, formulez clairement la modification demandée et inspectez les candidats bruts avant d’ajuster davantage de paramètres. 

Une fois ces éléments stabilisés, expérimentez la résolution ou le décodage, une variable à la fois. Le résultat : un workflow d’édition d’images efficace, avec une vision claire de ses capacités et de ses limites.

FAQ sur Qwen Image 2.1

Puis-je exécuter cette démo sur un Colab A100 ?

Oui. Nous avons exécuté le workflow ComfyUI quantifié sur une A100 avec 40 Go de VRAM. Les requêtes finales utilisaient environ 19,6 GiB de mémoire GPU backend échantillonnée à la résolution 1024 et 40 étapes. Il s’agit d’une mesure de notre configuration, pas d’un prérequis matériel minimal.

Dois-je dessiner une région avant d’éditer ?

Non. Vous pouvez fournir uniquement une image et une instruction textuelle. Des cercles ou esquisses grossières aident à identifier un objet ou une partie du corps spécifique. Ils servent de guide visuel, sans garantir que les pixels hors de la zone marquée restent inchangés.

Pourquoi chaque édition repart-elle de l’image originale ?

Nos premiers essais accumulaient des artéfacts quand chaque image générée devenait la prochaine entrée. Revenir à l’original évite de les propager. En revanche, chaque prompt doit décrire le résultat complet souhaité, car les éditions précédentes ne sont pas retenues automatiquement.

Qwen Image 2.1 génère-t-il le GIF directement ?

Non. Qwen génère des images éditées individuellement, et Pillow combine les images acceptées en un GIF. Les réglages de lecture contrôlent le timing et la direction, sans créer de mouvement intermédiaire.

Quels réglages changer pour améliorer le résultat ?

Commencez par une instruction claire et une référence propre. Notre configuration utilisait 40 étapes, seed 42, CFG 1, échantillonnage Euler, planificateur simple et denoise 1. Ce sont des réglages opérationnels, pas des valeurs prouvées optimales. Modifiez un paramètre à la fois et comparez les PNG bruts avant de juger le GIF.

Aashi Dutt

Auteur

Aashi Dutt

Je suis experte Google Developers en ML (Gen AI), triple experte Kaggle et ambassadrice Women Techmakers, avec plus de trois ans d’expérience dans la tech. J’ai cofondé une startup dans le domaine de la santé en 2020 et je poursuis actuellement un master en informatique à Georgia Tech, avec une spécialisation en apprentissage automatique.

Sujets

Contenus associés

blog

Comprendre les TPU et les GPU dans l'IA : Un guide complet