Qwen-Image-Layered: een praktische gids voor beelddecompositie

Photoshop-gebruikers besteden uren aan het handmatig maskeren van objecten en het inkleuren van achtergronden. Qwen-Image-Layered, een nieuw model van het Qwen-team bij Alibaba, doet dit automatisch: geef het één afbeelding en je krijgt meerdere RGBA-lagen met transparante achtergronden terug.

Deze tutorial behandelt wat Qwen-Image-Layered is, hoe het verschilt van segmentatietools zoals SAM, en hoe je het in Python draait. Je splitst een afbeelding op in lagen, bewerkt die en voegt ze vervolgens weer samen tot een nieuwe compositie. Aan het eind heb je een werkbare workflow voor programmatische beeldbewerking die handmatig maskeren volledig overslaat.

Ben je nieuw met het verwerken van beelddata en transparantie in code? Bekijk dan eerst onze Image Processing in Python-cursus om een goede basis op te bouwen. Lees ook onze gids over Google’s nieuwste model voor beeldgeneratie, Nano Banana 2.

Wat is Qwen-Image-Layered?

Qwen-Image-Layered is gebouwd op Qwen2.5-VL, een vision-language-model van Alibaba. Dankzij de VL-ruggengraat begrijpt het model semantisch wat er in een afbeelding staat: het kan een product onderscheiden van zijn schaduw en van het oppervlak waarop het staat, en kijkt dus verder dan alleen randen. Net als Vision Transformers verwerkt het beelden via attention-mechanismen in plaats van traditionele convolutionele benaderingen.

Bij inference geef je op hoeveel lagen je wilt. Vraag er 4, en het model verdeelt de inhoud over 4 RGBA-outputs. Vraag er 8, en je krijgt een fijnere scheiding. Het model beslist op basis van de scènestructuur wat waar terechtkomt.

Visueel voorbeeld

Zo ziet de decompositie eruit in Qwens aankondiging:

Het model neemt een samengestelde afbeelding en splitst die op in afzonderlijk bewerkbare RGBA-lagen met transparantie.

De promotieafbeelding van de snoepjes valt uiteen in vier duidelijke lagen: de steruitbarst-achtergrond, de persoon in oranje, de tekst en branding "Sour Candy", en de losse snoepjes. Elke laag heeft een transparante achtergrond (aangegeven met het schaakbordpatroon), klaar om te bewerken of te herschikken.

Het model verdeelt visuele elementen over lagen op basis van diepte en semantisch begrip. Achtergrondgrafiek gaat naar laag 0, het hoofdonderwerp (persoon) naar laag 1, tekstoverlays naar laag 2 en kleine voorgrondobjecten (snoepjes) naar laag 3. Elk element is netjes gescheiden met correcte transparantie.

Qwen-Image-Layered vs Segment Anything Model

Als je eerder met beeldsegmentatie hebt gewerkt, vraag je je misschien af hoe Qwen-Image-Layered zich verhoudt tot bestaande tools, met name het Segment Anything Model (SAM).

SAM en vergelijkbare segmentatiemodellen geven maskers: binaire kaarten van welke pixels bij welk object horen. Nuttig, maar een masker vertelt alleen waar iets is. Als je het object eruit haalt, blijft er een gat achter in de oorspronkelijke afbeelding.

Qwen-Image-Layered levert daarentegen complete lagen. Het voorgrondobject komt met transparantie, en de achtergrondlaag erachter is al ingevuld. Verwijder of verplaats je later een laag, dan hoef je niets te repareren.

SAM gebruikt een discriminatieve aanpak en analyseert bestaande pixels om objectgrenzen precies te definiëren. Qwen-Image-Layered daarentegen gebruikt een generatieve, diffusiegebaseerde architectuur die occlusies of verborgen regio’s reconstrueert via geleerde beeldgeneratie. 

Waar SAM maskers oplevert die definiëren wat je moet verwijderen, genereert Qwen-Image-Layered plausibele achtergrondinhoud om de laagdecompositie te voltooien. Opmerkelijk is dat SAM een vergelijkbare achtergrondvulling kan bereiken in combinatie met speciale inpainting-modellen, maar Qwen-Image-Layered integreert deze mogelijkheid end-to-end in het decompositieproces.

Het mechanisme voor invoercontrole is ook anders: SAM leunt op precieze interactieve prompts, waarbij je punten moet klikken of begrenzingskaders moet tekenen om een specifiek doel te selecteren. Qwen-Image-Layered werkt holistischer: je geeft eenvoudig het gewenste aantal lagen op (bijv. "split dit in 4 lagen") om de volledige beeldstructuur automatisch te organiseren.

We moeten wel opmerken dat SAM 2 expliciet is ontworpen voor video en objecten door sequenties kan volgen via een geheugen-augmented streamingarchitectuur (houdt ~6 recente frames vast) met hoge temporele consistentie. Qwen-Image-Layered is gespecialiseerd in statische beelddecompositie en biedt momenteel geen native objecttracking voor videobewerking.

Een afbeelding decomponeren met Qwen-Image-Layered

Nu het praktische deel. Voor je code schrijft, is er een praktische overweging: waar laat je het model draaien?

Waarom een API gebruiken?

Qwen-Image-Layered vereist meer dan 57GB aan modelgewichten en een high-end GPU met veel VRAM. 

Ik testte het lokaal draaien op Google Colab met een T4-GPU, en de sessie liep uit het RAM voordat het model overhaupt klaar was met downloaden. Het schijfgebruik liep op tot 90GB van de 112GB die beschikbaar waren in de GPU-runtime. Het model is simpelweg te groot voor gratis cloudomgevingen. 

Grote generatieve modellen zoals Stable Diffusion kennen vergelijkbare hostinguitdagingen, daarom zijn gehoste API’s zo gangbaar geworden.

Voor deze tutorial gebruiken we de gehoste API van Replicate. Elke decompositie kost ongeveer $0,03, goed voor een stabiele, reproduceerbare run zonder je zorgen te maken over geheugenlimieten of dependencyconflicten. Wil je het model gewoon proberen zonder code te schrijven, dan biedt de Hugging Face Space een gratis webinterface waar je afbeeldingen kunt uploaden en lagen handmatig kunt downloaden.

De Hugging Face Space laat je het model zonder code testen, maar met de API krijg je programmatische controle.

De omgeving instellen

Maak een nieuwe projectmap en installeer de vereiste pakketten:

pip install replicate python-dotenvMogelijk gemaakt door

Haal je API-token op uit de Replicate accountinstellingen en sla het op in een .env-bestand:

REPLICATE_API_TOKEN=your_token_hereMogelijk gemaakt door

De bronafbeelding

Officiële modelaankondigingen tonen vaak zorgvuldig geselecteerde voorbeelden waarin het model excelleert. Laten we in plaats daarvan testen met een realistische afbeelding om de prestaties in de praktijk te zien.

Dit is de afbeelding die we in lagen gaan opsplitsen:

Foto door Karola G op Pexels

De foto toont drie skincare-producten op een mintkleurig oppervlak tegen een lavendelachtergrond: een wit geschenkdoosje met zwarte strik, een roze serumbottle en een kleine crèmepot. Strakke compositie, duidelijke objecten, subtiele schaduwen. Een goede testcase voor lagen scheiden.

Inference draaien

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,
     	    }
	)Mogelijk gemaakt door

De parameter num_layers bepaalt hoe fijn het model de afbeelding splitst. Waarden kunnen variëren van 2 tot 8. Met 4 lagen krijg je een goede balans tussen detaillering en hanteerbaarheid. Door seed op een vaste waarde te zetten, maak je de output reproduceerbaar.

De API accepteert ook direct URL’s, zodat je het bestandshandling kunt overslaan als je afbeelding ergens wordt gehost:

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

De lagen opslaan

De API retourneert een lijst met FileOutput-objecten. Elk heeft een .read()-methode die de afbeeldingsbytes oplevert:

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

Lagen zijn geordend van onder naar boven: index 0 is de achtergrond, en hogere indexen stapelen daar bovenop. Elke PNG is een RGBA-afbeelding met transparantie, waar andere lagen doorheen zichtbaar zouden zijn.

Hier is het resultaat:

Het model plaatste de achtergrond (lavendelmuur en mintoppervlak) op laag 0, de crèmepot op laag 1, het geschenkdoosje op laag 2 en de serumbottle op laag 3. Elk product kwam met schone randen en accurate transparantie uit de verf.

Kijk echter naar de achtergrondlaag en je ziet subtiele schaduwrestanten waar de producten stonden. Dit zag ik consequent in mijn tests: het model is goed in objectisolatie, maar heeft moeite met achtergrondreconstructie wanneer schaduwen meespelen. 

Hoe prominenter de schaduwen in je bronafbeelding, hoe zichtbaarder deze artefacten worden. Het is het eerste model in zijn soort, dus verwacht dat het Qwen-team dit in toekomstige updates verfijnt.

Lagen opnieuw combineren met Qwen-Image-Layered

Decompositie is maar de helft van de workflow. De lagen worden pas echt nuttig wanneer je ze bewerkt en opnieuw samenstelt tot iets nieuws.

De achtergrond wisselen

Productfotografen hebben vaak dezelfde opname met verschillende achtergronden nodig voor A/B-testen, seizoenscampagnes of platformspecifieke eisen. Met gescheiden lagen kost dit maar een paar regels 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")Mogelijk gemaakt door

De functie alpha_composite() handelt RGBA-blending automatisch af. De transparantie in elke laag wordt gerespecteerd, zodat voorgrondobjecten natuurlijk bovenop elke achtergrond liggen die je aanlevert. 

PIL maakt beeldmanipulatie eenvoudig, en als je complexere transformaties wilt toepassen, dan sluiten de beeldverwerkingsmogelijkheden van PyTorch goed aan op PIL-workflows.

Hier is het resultaat:

Dezelfde producten, een andere omgeving, zonder handmatig maskeren. Je kunt een verloop, textuur of een volledig andere foto gebruiken. Het proces blijft hetzelfde: vervang laag 0 en componeer de rest.

Objecten verwijderen of verplaatsen

Hetzelfde patroon geldt voor andere bewerkingen. Verwijder een object door zijn laag over te slaan:

# 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)Mogelijk gemaakt door

Om een object te verplaatsen door het op andere coördinaten te plakken, gebruik je de methode paste() met je gekozen x/y-offset:

# 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 usualMogelijk gemaakt door

De workflow is altijd hetzelfde: 

1. Bewerk de lagen die je nodig hebt: formaat wijzigen, herkleren, verwijderen, herschikken.
2. Vervolgens componeer je alles weer samen. 

Elke bewerking gebeurt op een geïsoleerde laag, dus edits blijven netjes afgebakend.

Een Qwen-Image-Layered-editor bouwen met Streamlit

Deze bewerkingen in een notebook uitvoeren werkt voor losse edits, maar de feedbackloop is traag. Je schrijft code, draait een cel, bekijkt de output, past aan, herhaal. Voor iteratief werk waarbij je lagen wil aan- en uitzetten, composities wil vergelijken en resultaten wil downloaden zonder cellen opnieuw te draaien, is een lichte GUI logischer.

We bouwen een Streamlit-app in zo’n 160 regels waarmee je een afbeelding kunt uploaden, decomponeren, lagen toggelen en een live preview ziet. Maak een bestand streamlit_app.py in je projectmap.

Streamlit instellen

Begin met de imports en basisconfiguratie:

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")Mogelijk gemaakt door

Session state blijft behouden over Streamlit-herstarts heen. Zonder dit zouden je lagen verdwijnen elke keer dat iemand op een knop klikt.

API-tokencontrole

Controleer of het token bestaat voordat je Replicate aanroept:

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()Mogelijk gemaakt door

st.stop() stopt de uitvoering als het token ontbreekt. Het heeft geen zin de rest van de UI te renderen.

Gecachte functie voor beelddecompositie

De decompositie-API kost $0,03 per call en duurt 30-60 seconden. Caching voorkomt dubbele aanroepen:

@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
            raiseMogelijk gemaakt door

De underscoreprefix bij _image_bytes vertelt Streamlit dat die parameter niet gehasht moet worden (bytes hashen is duur). De retry-lus vangt de occasionele 502-fouten van Replicate op door 5 seconden te wachten en tot 3 keer te proberen.

Visualisatie en beeldcompositie

Vervolgens definiëren we kleine hulpfuncties voor visualisatie en compositing:

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))Mogelijk gemaakt door

Het schaakbord maakt transparantie zichtbaar (standaard in beeldeditors). De compositiefunctie spiegelt wat we in het notebook deden, nu aangestuurd door de checkboxstatus.

Afbeelding uploaden en decompositie-instellingen

De zijbalk handelt het uploaden en de instellingen voor decompositie af:

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()Mogelijk gemaakt door

De decompositieknop is uitgeschakeld tot er een afbeelding is geüpload. Bij succes worden de lagen in de session state opgeslagen en staan alle zichtbaarheidstoggles standaard op True.

Controles voor afbeeldingslagen toevoegen

Twee kolommen tonen de laagbediening en de live preview:

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,
            )Mogelijk gemaakt door

Als je een laag uitvinkt, draait Streamlit het script opnieuw. De checkbox werkt layer_visibility bij, de compositiefunctie berekent de preview opnieuw en de UI ververst automatisch.

De app draaien

Sla het bestand op en voer uit:

streamlit run streamlit_app.pyMogelijk gemaakt door

De app heeft een gedecomponeerde afbeelding. Zet lagen uit om objecten uit de preview te verwijderen.

Upload een afbeelding, klik op decomponeren en zet vervolgens lagen aan en uit. De preview werkt direct bij. Download het resultaat zodra je een compositie hebt die je bevalt. De volledige workflow gebeurt in de browser, zonder notebookcellen opnieuw te draaien.

Conclusie

Qwen-Image-Layered pakt beeldbewerking anders aan: in plaats van pixels te maskeren, scheidt het content in complete RGBA-lagen met ingepeinte achtergronden. Je krijgt objectisolatie zonder opruimwerk. Het model heeft moeite met schaduwartefacten in complexe scènes, maar de objectextractie zelf werkt goed.

De Python-workflow is eenvoudig. Roep de API van Replicate aan, krijg een lijst met lagen terug en componeer ze met PIL. Achtergronden wisselen en objecten verwijderen kost slechts enkele regels code. De Streamlit-app verpakt die logica in een GUI voor snellere iteratie.

Dit is het eerste model in zijn soort. Het Qwen-team levert snel updates, dus verwacht verfijningen in achtergrondreconstructie en een betere omgang met schaduwrijke beelden. Het onderzoeksartikel behandelt de architectuur als je wilt begrijpen hoe variabele laagdecompositie onder de motorkap werkt.

Klaar om meer open-source AI-modellen te verkennen? Beheers het ecosysteem achter Qwen door de Hugging Face Fundamentals skill track op DataCamp te volgen.