Qwen-Image-Layered : Guide pratique de la décomposition d'images

Les utilisateurs de Photoshop consacrent des heures à masquer manuellement des objets et à peindre des arrière-plans. Qwen-Image-Layered, un nouveau modèle développé par l'équipe Qwen d'Alibaba, effectue cette opération automatiquement : il suffit de lui fournir une seule image pour qu'il renvoie plusieurs couches RGBA avec des arrière-plans transparents.

Ce tutoriel explique ce qu'est Qwen-Image-Layered, en quoi il diffère des outils de segmentation tels que SAM, et comment l'utiliser dans Python. Vous allez décomposer une image en calques, puis modifier et recombiner ces calques pour créer un nouveau composite. À la fin, vous disposerez d'un flux de travail opérationnel pour l'édition programmatique d'images qui élimine complètement le masquage manuel.

Si vous débutez dans le traitement des données d'image et de la transparence dans le code, veuillez consulter notre Traitement d'images en Python afin d'acquérir des bases solides avant de vous lancer.

Qu'est-ce que Qwen-Image-Layered ?

Qwen-Image-Layered est basé sur Qwen2.5-VL, un modèle de langage visuel développé par Alibaba. La structure VL permet au modèle de comprendre sémantiquement le contenu d'une image : il est capable de distinguer un produit de son ombre et de la surface sur laquelle il repose, et ne se contente pas de détecter les contours. Comme Vision Transformers, il traite les images à l'aide de mécanismes d'attention plutôt que d'approches convolutives traditionnelles.

Lorsque vous effectuez une inférence, vous devez indiquer le nombre de couches souhaité. Veuillez indiquer 4, et le modèle répartira le contenu de l'image sur 4 sorties RGBA. Demandez 8, et vous obtiendrez une séparation plus fine. Le modèle détermine l'emplacement des éléments en fonction de la structure de la scène.

Exemple visuel

Voici à quoi ressemble la décomposition dans l'annonce de Qwen:

Le modèle prend une image composite et la sépare en couches RGBA modifiables individuellement avec transparence.

L'image promotionnelle du bonbon se décompose en quatre couches distinctes : l'arrière-plan en étoile, la personne en orange, le texte « Sour Candy » et la marque, ainsi que les bonbons individuels. Chaque calque apparaît avec un arrière-plan transparent (illustré par un motif en damier), prêt à être modifié ou réorganisé.

Le modèle répartit les éléments visuels entre les couches en fonction de la profondeur et de la compréhension sémantique. Les graphiques d'arrière-plan sont placés sur le calque 0, le sujet principal (personne) sur le calque 1, les superpositions de texte sur le calque 2 et les petits objets au premier plan (bonbons) sur le calque 3. Chaque élément est clairement séparé avec une transparence adéquate.

Modèle Qwen-Image-Layered vs Segment Anything

Si vous avez déjà travaillé avec la segmentation d'images, vous vous demandez peut-être comment Qwen-Image-Layered se compare aux outils existants, en particulier au modèle Segment Anything Model (SAM).

SAM et les modèles de segmentation similaires produisent des masques : des cartes binaires indiquant quels pixels appartiennent à quel objet. Utile, mais un masque vous indique simplement où se trouve quelque chose. L'extraction de l'objet laisse toujours un trou dans l'image d'origine.

Qwen-Image-Layered, quant à lui, génère des calques complets. L'objet au premier plan apparaît avec une transparence, et le calque d'arrière-plan derrière lui est déjà rempli. Lorsque vous supprimez ou déplacez un calque ultérieurement, il n'y a rien à corriger.

SAM utilise une approche discriminante, analysant les pixels existants afin de définir précisément les contours des objets. Qwen-Image-Layered, en revanche, utilise une architecture générative basée sur la diffusion qui reconstruit les zones occultées ou cachées grâce à la génération d'images apprises. 

Alors que SAM génère des masques qui définissent les éléments à supprimer, Qwen-Image-Layered génère un contenu d'arrière-plan plausible pour compléter la décomposition en couches. Il convient de noter que SAM peut obtenir un remplissage d'arrière-plan similaire lorsqu'il est associé à des modèles de retouche dédiés, mais Qwen-Image-Layered intègre cette fonctionnalité de bout en bout dans son processus de décomposition.

Le mécanisme de contrôle des entrées est également différent : SAM s'appuie sur des invites interactives précises, vous demandant de cliquer sur des points ou de dessiner des cadres de sélection pour choisir une cible spécifique. Qwen-Image-Layered fonctionne de manière plus holistique, vous permettant de simplement spécifier le nombre de couches souhaité (par exemple, « diviser ceci en 4 couches ») pour organiser automatiquement toute la structure de l'image.

Il est important de noter que SAM 2 est explicitement conçu pour la vidéo, capable de suivre des objets à travers des séquences à l'aide d'une architecture de streaming à mémoire augmentée (conserve environ 6 images récentes) avec une grande cohérence temporelle. Qwen-Image-Layered est spécialisé dans la déomposition d'images statiques et n'offre actuellement pas de suivi d'objets natif pour le montage vidéo.

Décomposition d'une image avec Qwen-Image-Layered

Passons maintenant à la partie pratique. Avant de rédiger tout code, il convient de prendre en compte un aspect pratique : où exécuter le modèle.

Pourquoi utiliser une API ?

Qwen-Image-Layered nécessite plus de 57 Go de poids de modèle et un GPU haut de gamme avec une grande quantité de VRAM. 

J'ai testé son exécution localement sur Google Colab avec un GPU T4, et la session a manqué de mémoire RAM avant même que le modèle eait fini de se télécharger. L'utilisation du disque a atteint 90 Go sur les 112 Go disponibles dans le runtime GPU. Le modèle est tout simplement trop volumineux pour les environnements cloud gratuits. 

Les grands modèles génératifs tels que Stable Diffusion sont confrontés à des défis similaires en matière d'hébergement, ce qui explique pourquoi les API hébergées sont devenues courantes.

Pour ce tutoriel, nous utiliserons l'API hébergée de Replicate. Chaque décomposition coûte environ 0,03 $, ce qui vous garantit un fonctionnement stable et reproductible sans vous soucier des limites de mémoire ou des conflits de dépendance. Si vous souhaitez simplement tester le modèle sans écrire de code, le Hugging Face Space propose une interface web gratuite où vous pouvez télécharger des images et télécharger des couches manuellement.

Hugging Face Space vous permet de tester le modèle sans code, mais l'API vous offre un contrôle programmatique.

Configuration de l'environnement

Veuillez créer un nouveau répertoire de projet et installer les paquets requis :

pip install replicate python-dotenv

Veuillez récupérer votre jeton API dans les paramètres de votre compte Replicate et l'enregistrer dans un fichier .env:

REPLICATE_API_TOKEN=your_token_here

L'image source

Les annonces officielles concernant les modèles présentent généralement des exemples triés sur le volet où le modèle offre ses meilleures performances. Veuillez tester avec une image réelle afin d'observer les performances réelles.

Voici l'image que nous allons décomposer en couches :

Photo par Karola G sur Pexels

La photographie présente trois produits de soin pour la peau disposés sur une surface couleur menthe, avec un fond lavande : un coffret cadeau blanc orné d'un ruban noir, un flacon de sérum rose et un petit pot de crème. Composition épurée, objets distincts, ombres subtiles. Un cas de test approprié pour la séparation des couches.

Exécution de l'inférence

import replicate
from dotenv import load_dotenv

load_dotenv()

with open("data/healthcare_products.jpg", "rb") as f:
	output = replicate.run(
         "qwen/qwen-image-layered",
     	    input={
         	"image": f,
         	"num_layers": 4,
         	"go_fast": True,
         	"output_format": "png",
         	"seed": 42,
     	    }
	)

Le paramètre « num_layers » (Finesse de la division) contrôle la finesse avec laquelle le modèle divise l'image. Les valeurs peuvent varier de 2 à 8. Avec 4 couches, vous obtenez un équilibre raisonnable entre granularité et facilité de gestion. Définir seed sur une valeur fixe rend la sortie reproductible.

L'API accepte également les URL directement, vous pouvez donc ignorer la gestion des fichiers si votre image est hébergée ailleurs :

output = replicate.run(
	"qwen/qwen-image-layered",
	input={
     	  "image": "https://example.com/photo.jpg",
     	  "num_layers": 4,
     	  "go_fast": True,
     	  "output_format": "png",
	}
)

Enregistrement des calques

L'API renvoie une liste d'objets FileOutput. Chacun dispose d'une méthode d' .read() qui fournit les octets de l'image :

for i, layer in enumerate(output):
	with open(f"layer_{i}.png", "wb") as f:
     	  f.write(layer.read())

Les couches sont classées de bas en haut : l'index 0 correspond à l'arrière-plan, et les indices supérieurs s'empilent au-dessus. Chaque fichier PNG est une image RGBA avec transparence, où les autres calques sont visibles.

Voici le résultat :

Le modèle a placé l'arrière-plan (mur lavande et surface menthe) sur le calque 0, le pot de crème sur le calque 1, le coffret cadeau sur le calque 2 et le flacon de sérum sur le calque 3. Chaque produit a été réalisé avec des bords nets et une transparence précise.

Cependant, en observant le calque d'arrière-plan, vous remarquerez de légères traces d'ombres à l'endroit où se trouvaient les produits. Mes tests ont systématiquement démontré que le modèle gère efficacement l'isolation des objets, mais rencontre des difficultés dans la reconstruction de l'arrière-plan lorsque des ombres sont présentes. 

Plus les ombres sont prononcées dans votre image source, plus ces artefacts deviennent visibles. Il s'agit du premier modèle de ce type, veuillez donc vous attendre à ce que l'équipe Qwen l'améliore dans les prochaines mises à jour.

Recombiner les couches avec Qwen-Image-Layered

La décomposition ne représente que la moitié du processus. Les calques deviennent utiles lorsque vous les modifiez et les réassemblez pour créer quelque chose de nouveau.

Changement de l'arrière-plan

Les photographes de produits ont souvent besoin de la même prise de vue avec différents arrière-plans pour des tests A/B, des campagnes saisonnières ou des exigences spécifiques à certaines plateformes. Avec des couches séparées, cela nécessite quelques lignes de code.

from PIL import Image

# Load the decomposed layers
layers = [Image.open(f"layer_{i}.png") for i in range(4)]

# Create a new background (solid coral)
new_bg = Image.new("RGBA", layers[0].size, (255, 180, 162, 255))

# Replace the original background layer
layers[0] = new_bg

# Composite from bottom to top
result = layers[0]
for layer in layers[1:]:
	result = Image.alpha_composite(result, layer)

result.save("coral_background.png")

La fonction alpha_composite() gère automatiquement le mélange RGBA. Il respecte la transparence de chaque couche, de sorte que les objets au premier plan s'intègrent naturellement sur n'importe quel arrière-plan que vous fournissez. 

PIL facilite la manipulation d'images, et si vous avez besoin d'appliquer des transformations plus complexes, les capacités de traitement d'images de PyTorch s'intègrent parfaitement aux flux de travail PIL.

Voici le résultat :

Même produits, environnement différent, aucun masquage manuel. Vous pourriez remplacer par un dégradé, une texture ou une autre photographie. Le processus reste identique : remplacer la couche 0, composer le reste.

Suppression ou repositionnement d'objets

Le même principe s'applique aux autres modifications. Supprimez un objet en ignorant son calque :

# Composite without the cream jar (layer 1)
layers_without_jar = [layers[0], layers[2], layers[3]]

result = layers_without_jar[0]
for layer in layers_without_jar[1:]:
	result = Image.alpha_composite(result, layer)

Pour repositionner un objet en le collant à des coordonnées différentes, veuillez utiliser la méthode paste() avec le décalage x/y de votre choix :

# Move the serum bottle 50 pixels left
 canvas = Image.new("RGBA", layers[0].size, (0, 0, 0, 0))
 canvas.paste(layers[3], (-50, 0), layers[3])
 layers[3] = canvas

 # Then composite as usual

Le processus est toujours identique : 

1. Veuillez modifier les couches qui vous intéressent : Redimensionner, recolorer, supprimer, réorganiser.
2. Ensuite, veuillez rassembler tous les éléments. 

Chaque opération s'effectue sur une couche isolée, de sorte que les modifications restent confinées.

Création d'un éditeur de couches d'images Qwen avec Streamlit

L'exécution de ces opérations dans un bloc-notes convient pour les modifications ponctuelles, mais la boucle de rétroaction est lente. Vous rédigez du code, exécutez une cellule, vérifiez le résultat, ajustez, répétez. Pour les tâches itératives où il est nécessaire d'activer et de désactiver des calques, de comparer des compositions et de télécharger les résultats sans réexécuter les cellules, une interface graphique légère est plus appropriée.

Nous allons créer une application Streamlit en environ 160 lignes qui vous permettra de télécharger une image, de la décomposer, d'activer ou désactiver les calques et d'obtenir un aperçu en direct. Veuillez créer un fichier nommé streamlit_app.py dans le répertoire de votre projet.

Configuration de Streamlit

Veuillez commencer par les importations et la configuration de base :

import os
import io
import time
from typing import List
import streamlit as st
from PIL import Image, ImageDraw
from dotenv import load_dotenv
import replicate

load_dotenv()

# Constants
MAX_LAYERS, MIN_LAYERS, DEFAULT_LAYERS = 8, 2, 4
THUMBNAIL_SIZE = (150, 150)

# Initialize session state
if "layers" not in st.session_state:
	st.session_state.layers = []
	st.session_state.layer_visibility = []
	st.session_state.original_image = None

st.set_page_config(page_title="Qwen-Image-Layered", page_icon="🎨", layout="wide")
st.title("🎨 Qwen-Image-Layered")
st.markdown("Decompose images into editable RGBA layers")

L'état de la session est conservé lors des réexécutions de Streamlit. Sans cela, vos calques disparaîtraient à chaque fois qu'un utilisateur cliquerait sur un bouton.

Vérification du jeton API

Avant d'appeler Replicate, veuillez vous assurer que le jeton existe :

token = os.environ.get("REPLICATE_API_TOKEN")
if not token:
	st.error("REPLICATE_API_TOKEN not found. Set it in your .env file.")
	st.code("export REPLICATE_API_TOKEN=your_token_here", language="bash")
	st.stop()

st.stop() interrompt l'exécution si le jeton est manquant. Il n'est pas nécessaire de rendre le reste de l'interface utilisateur.

Fonction de décomposition d'images mises en cache

L'API de décomposition coûte 0,03 $ par appel et prend entre 30 et 60 secondes. La mise en cache évite les appels redondants :

@st.cache_data(show_spinner=False)
def decompose_image(_image_bytes: bytes, num_layers: int, seed: int) -> List[bytes]:
    """Call Replicate API with retry logic for 502 errors."""
    for attempt in range(3):
        try:
            output = replicate.run(
                "qwen/qwen-image-layered",
                input={
                    "image": io.BytesIO(_image_bytes),
                    "num_layers": num_layers,
                    "go_fast": True,
                    "output_format": "png",
                    "seed": seed,
                },
            )
            return [layer.read() for layer in output]
        except Exception as e:
            if attempt < 2 and ("502" in str(e) or "Replicate" in str(type(e).__name__)):
                time.sleep(5)
                continue
            raise

Le préfixe « underscore » sur _image_bytes indique à Streamlit de ne pas hacher ce paramètre (le hachage des octets est coûteux). La boucle de réessai gère les erreurs 502 occasionnelles de Replicate en attendant 5 secondes et en effectuant jusqu'à 3 tentatives.

Visualisation et composition d'images

Ensuite, nous définissons de petits utilitaires pour la visualisation et la composition :

def create_checkerboard(size: tuple) -> Image.Image:
    """Create a checkerboard pattern to show transparency."""
    img = Image.new("RGBA", size, (220, 220, 220, 255))
    draw = ImageDraw.Draw(img)

    square = 10
    for y in range(0, size[1], square):
        for x in range(0, size[0], square):
            if (x // square + y // square) % 2:
                draw.rectangle(
                    [x, y, x + square, y + square],
                    fill=(255, 255, 255, 255),
                )

    return img


def composite_layers(
    layers: List[Image.Image],
    visibility: List[bool],
) -> Image.Image:
    """Composite visible layers from bottom to top."""
    if not layers or not any(visibility):
        return Image.new(
            "RGBA",
            layers[0].size if layers else (400, 400),
            (0, 0, 0, 0),
        )

    result = None
    for layer, visible in zip(layers, visibility):
        if visible:
            result = layer.copy() if result is None else Image.alpha_composite(result, layer)

    return result or Image.new("RGBA", layers[0].size, (0, 0, 0, 0))

Le damier rend la transparence visible (convention standard des éditeurs d'images). La fonction composite reflète ce que nous avons réalisé dans le notebook, désormais pilotée par l'état de la case à cocher.

Paramètres de téléchargement et de décomposition des images

La barre latérale permet de gérer les paramètres de téléchargement et de décomposition des images :

with st.sidebar:
    st.header("🖼️ Image Upload")
    uploaded_file = st.file_uploader(
        "Choose an image",
        type=["png", "jpg", "jpeg"],
        help="Upload an image to decompose",
    )

    if uploaded_file is not None:
        st.session_state.original_image = uploaded_file
        st.image(uploaded_file, caption="Uploaded", use_container_width=True)

    st.divider()

    st.header("⚙️ Settings")
    num_layers = st.slider(
        "Number of layers",
        MIN_LAYERS,
        MAX_LAYERS,
        DEFAULT_LAYERS,
    )
    seed = st.number_input(
        "Random seed",
        0,
        999999,
        42,
        help="For reproducibility",
    )

    # Decompose button
    if st.button(
        "🔄 Decompose Image",
        disabled=uploaded_file is None,
        use_container_width=True,
        type="primary",
    ):
        if st.session_state.original_image is not None:
            image_bytes = st.session_state.original_image.getvalue()

            with st.spinner(f"Decomposing into {num_layers} layers... (30-60s)"):
                try:
                    layer_bytes = decompose_image(image_bytes, num_layers, seed)
                    st.session_state.layers = [
                        Image.open(io.BytesIO(lb)).convert("RGBA") for lb in layer_bytes
                    ]
                    st.session_state.layer_visibility = [True] * len(
                        st.session_state.layers
                    )
                    st.success(
                        f"Decomposed into {len(st.session_state.layers)} layers!"
                    )
                except Exception as e:
                    if "502" in str(e):
                        st.error(
                            "Replicate API error (502). Try again or use fewer layers."
                        )
                    else:
                        st.error(f"Error: {e}")

    # Reset button
    if st.session_state.layers and st.button("🗑️ Reset", use_container_width=True):
        st.session_state.layers = []
        st.session_state.layer_visibility = []
        st.session_state.original_image = None
        st.rerun()

Le bouton « Décomposer » est désactivé tant qu'aucune image n'a été téléchargée. En cas de réussite, les couches sont enregistrées dans l'état de la session et toutes les options de visibilité sont définies par défaut sur True.

Ajout de commandes de calque d'image

Deux colonnes affichent les commandes de calque et l'aperçu en direct :

col1, col2 = st.columns([1, 1])  # two equal-width columns [web:61]

with col1:
    st.subheader("📑 Layers")

    if not st.session_state.layers:
        st.info("Upload an image and decompose to see layers here.")
    else:
        st.caption("Toggle layers on/off. Layer 0 is the background.")

        cols = st.columns(min(len(st.session_state.layers), 4))
        for i, layer in enumerate(st.session_state.layers):
            with cols[i % 4]:
                thumb = layer.copy()
                thumb.thumbnail(THUMBNAIL_SIZE)

                checkerboard = create_checkerboard(thumb.size)
                display = Image.alpha_composite(checkerboard, thumb)

                st.image(display, caption=f"Layer {i}", use_container_width=True)

                st.session_state.layer_visibility[i] = st.checkbox(
                    f"Show Layer {i}",
                    value=st.session_state.layer_visibility[i],
                    key=f"layer_{i}",
                )

with col2:
    st.subheader("👁️ Preview")

    if not st.session_state.layers:
        st.info("Composite preview will appear here.")
    else:
        composite = composite_layers(
            st.session_state.layers,
            st.session_state.layer_visibility,
        )
        visible = sum(st.session_state.layer_visibility)

        st.caption(f"Showing {visible} of {len(st.session_state.layers)} layers")
        st.image(composite, caption="Composite result", use_container_width=True)

        if visible > 0:
            buf = io.BytesIO()
            composite.save(buf, format="PNG")

            st.download_button(
                "⬇️ Download Result",
                data=buf.getvalue(),
                file_name="composite.png",
                mime="image/png",
                use_container_width=True,
            )

Lorsque vous désactivez un calque, Streamlit réexécute le script. La case à cocher met à jour layer_visibility, la fonction composite recalcule l'aperçu et l'interface utilisateur s'actualise automatiquement.

Exécution de l'application

Veuillez enregistrer le fichier et exécuter :

streamlit run streamlit_app.py

L'application présente une image décomposée. Désactivez les calques pour supprimer des objets de l'aperçu.

Veuillez télécharger une image, cliquer sur « Décomposer », puis activer et désactiver les calques. L'aperçu se met à jour instantanément. Veuillez télécharger le résultat lorsque vous trouvez une composition qui vous convient. L'ensemble du flux de travail s'effectue dans le navigateur sans qu'il soit nécessaire de réexécuter les cellules du notebook.

Conclusion

Qwen-Image-Layered adopte une approche différente de l'édition d'images : au lieu de masquer les pixels, il sépare le contenu en couches RGBA complètes avec des arrière-plans repeints. Vous bénéficiez de l'isolation des objets sans avoir à effectuer de nettoyage. Le modèle rencontre des difficultés avec les artefacts d'ombre dans les scènes complexes, mais l'extraction d'objets fonctionne bien.

Le flux de travail Python est simple. Veuillez appeler l'API de Replicate, récupérer une liste de calques et les composer avec PIL. Les échanges d'arrière-plan et la suppression d'objets ne nécessitent que quelques lignes de code. L'application Streamlit intègre cette logique dans une interface graphique pour une itération plus rapide.

Il s'agit du premier modèle de ce type. L'équipe Qwen publie rapidement des mises à jour, vous pouvez donc vous attendre à des améliorations au niveau de la reconstruction de l'arrière-plan et à une meilleure gestion des images comportant de nombreuses ombres. Le document de recherche couvre l'architecture si vous souhaitez comprendre comment fonctionne la décomposition des couches variables en arrière-plan.

Êtes-vous prêt à découvrir d'autres modèles d'IA open source ? Maîtrisez l'écosystème derrière Qwen en suivant le cours cours « Hugging Face Fundamentals » cursus op DataCamp.