Qwen-Image-Layered: Ein praktischer Leitfaden zur Bildzerlegung

Photoshop-Nutzer verbringen Stunden damit, Objekte manuell zu maskieren und Hintergründe zu malen. Qwen-Image-Layered, ein neues Modell vom Qwen-Team bei Alibaba, macht das automatisch: Man gibt ein einzelnes Bild rein und es gibt mehrere RGBA-Ebenen mit transparentem Hintergrund raus.

Dieses Tutorial erklärt, was Qwen-Image-Layered ist, wie es sich von Segmentierungswerkzeugen wie SAM unterscheidet und wie man es in Python ausführt. Du zerlegst ein Bild in Ebenen, bearbeitest diese und setzt sie dann zu einem neuen Bild zusammen. Am Ende hast du einen funktionierenden Workflow für die programmatische Bildbearbeitung, bei dem das manuelle Maskieren komplett wegfällt.

Wenn du noch nicht so viel Erfahrung mit Bilddaten und Transparenz im Code hast, schau dir doch mal unsere Bildverarbeitung in Python an, um dir eine solide Grundlage zu schaffen, bevor du dich in das Thema vertiefst.

Was ist Qwen-Image-Layered?

Qwen-Image-Layered basiert auf Qwen2.5-VL, einem Bild-Sprachmodell von Alibaba. Das VL-Backbone heißt, dass das Modell versteht, was in einem Bild semantisch drin ist: Es kann ein Produkt von seinem Schatten und von der Oberfläche, auf der es steht, unterscheiden und nicht nur Kanten erkennen. Wie Vision Transformersverarbeitet es Bilder über Aufmerksamkeitsmechanismen statt über klassische Faltungsansätze.

Wenn du eine Inferenz durchführst, gibst du an, wie viele Schichten du haben willst. Frag nach 4, und das Modell verteilt den Bildinhalt auf 4 RGBA-Ausgänge. Frag nach 8, dann kriegst du eine bessere Trennung. Das Modell entscheidet anhand der Szenenstruktur, was wo hingehört.

Visuelles Beispiel

So sieht die Zerlegung in Qwens Ankündigung:

Das Modell nimmt ein zusammengesetztes Bild und teilt es in einzelne bearbeitbare RGBA-Ebenen mit Transparenz auf.

Das Werbebild für die Süßigkeiten lässt sich in vier verschiedene Ebenen aufteilen: den Sternenhimmel-Hintergrund, die Person in Orange, den Text „Sour Candy“ und das Branding sowie die einzelnen Süßigkeiten. Jede Ebene hat einen transparenten Hintergrund (mit Schachbrettmuster dargestellt) und kann bearbeitet oder neu angeordnet werden.

Das Modell verteilt visuelle Elemente über verschiedene Ebenen, je nachdem, wie tief sie sind und was sie bedeuten. Hintergrundgrafiken kommen auf Ebene 0, das Hauptmotiv (Person) auf Ebene 1, Textüberlagerungen auf Ebene 2 und kleine Vordergrundobjekte (Bonbons) auf Ebene 3. Jedes Element ist sauber voneinander getrennt und hat die richtige Transparenz.

Qwen-Bild-Layered vs. Segment Anything-Modell

Wenn du schon mal mit Bildsegmentierung gearbeitet hast, fragst du dich vielleicht, wie Qwen-Image-Layered im Vergleich zu anderen Tools abschneidet, vor allem zum Segment Anything Model (SAM).

SAM und ähnliche Segmentierungsmodelle machen Masken: binäre Karten, die zeigen, welche Pixel zu welchem Objekt gehören. Nützlich, aber eine Maske zeigt dir nur, wo sich etwas befindet. Wenn du das Objekt rausnimmst, bleibt immer noch ein Loch im Originalbild.

Qwen-Image-Layered macht dagegen komplette Ebenen. Das Objekt im Vordergrund wird transparent dargestellt, und die dahinterliegende Hintergrundebene ist schon ausgefüllt. Wenn du später eine Ebene löschst oder verschiebst, musst du nichts nachbessern.

SAM nutzt einen unterscheidenden Ansatz, bei dem vorhandene Pixel analysiert werden, um Objektgrenzen genau zu bestimmen. Qwen-Image-Layered nutzt dagegen eine generative, auf Diffusion basierende Architektur, die verdeckte oder versteckte Bereiche durch erlernte Bildgenerierung wiederherstellt. 

Während SAM Masken erzeugt, die zeigen, was entfernt werden soll, macht Qwen-Image-Layered einen passenden Hintergrund, um die mehrschichtige Zerlegung fertigzustellen. Interessanterweise kann SAM in Kombination mit speziellen Inpainting-Modellen ähnliche Hintergrundauffüllungen erzielen, aber Qwen-Image-Layered integriert diese Funktion durchgängig in seinen Zerlegungsprozess.

Auch der Eingabesteuerungsmechanismus ist anders: SAM nutzt präzise interaktive Eingabeaufforderungen, bei denen du auf Punkte klicken oder Begrenzungsrahmen zeichnen musst, um ein bestimmtes Ziel auszuwählen. Qwen-Image-Layered arbeitet ganzheitlicher, sodass du einfach die gewünschte Anzahl von Ebenen angeben kannst (z. B. „in 4 Ebenen aufteilen“), um die gesamte Bildstruktur automatisch zu organisieren.

Wir müssen sagen, dass SAM 2 extra für Videos entwickelt wurde und Objekte durch Sequenzen verfolgen kann, indem es eine speichergestützte Streaming-Architektur (speichert ~6 aktuelle Bilder) mit hoher zeitlicher Konsistenz nutzt. Qwen-Image-Layered ist auf die statische Bilddekodierung und -komposition spezialisiert und bietet im Moment keine native Objektverfolgung für die Videobearbeitung.

Ein Bild mit Qwen-Image-Layered zerlegen

Jetzt geht's zum praktischen Teil. Bevor du irgendwelchen Code schreibst, solltest du dir überlegen, wo du das Modell ausführen willst.

Warum eine API nutzen?

Qwen-Image-Layered braucht mehr als 57 GB an Modellgewichten und eine High-End-GPU mit viel VRAM. 

Ich hab's lokal auf Google Colab mit einer T4-GPU ausprobiert, und der Speicher war voll, bevor das Modell „” überhaupt fertig runtergeladen war. Die Festplattennutzung ist auf 90 GB der insgesamt 112 GB gestiegen, die in der GPU-Laufzeit verfügbar sind. Das Modell ist einfach zu groß für kostenlose Cloud-Umgebungen. 

Große generative Modelle wie Stable Diffusion stehen vor ähnlichen Herausforderungen beim Hosting, weshalb gehostete APIs mittlerweile weit verbreitet sind.

Für dieses Tutorial nutzen wir die gehostete API von Replicate. Jede Zerlegung kostet etwa 0,03 US-Dollar. Dafür kriegst du einen stabilen, reproduzierbaren Lauf, ohne dir Gedanken über Speicherbeschränkungen oder Abhängigkeitskonflikte machen zu müssen. Wenn du das Modell einfach mal ausprobieren willst, ohne Code zu schreiben, dann ist der Hugging Face Space eine kostenlose Webschnittstelle, wo du Bilder hochladen und Ebenen manuell runterladen kannst.

Mit Hugging Face Space kannst du das Modell ohne Code testen, aber die API gibt dir die Möglichkeit, es programmgesteuert zu steuern.

Einrichten der Umgebung

Mach ein neues Projektverzeichnis und installiere die benötigten Pakete:

pip install replicate python-dotenv

Hol dir deinen API-Token aus den Replicate-Kontoeinstellungen unter und speicher ihn in einer Datei namens „ .env “:

REPLICATE_API_TOKEN=your_token_here

Das Ausgangsbild

Offizielle Modellankündigungen zeigen meistens nur die besten Beispiele, bei denen das Modell richtig gut abschneidet. Probieren wir's mal mit einem echten Bild aus, um zu sehen, wie es wirklich läuft.

Das ist das Bild, das wir in Ebenen zerlegen werden:

Foto von Karola G auf Pexels

Das Foto zeigt drei Hautpflegeprodukte auf einem mintfarbenen Untergrund vor einem lavendelfarbenen Hintergrund: eine weiße Geschenkbox mit schwarzem Band, eine rosa Serumflasche und einen kleinen Cremetiegel. Klare Komposition, deutliche Objekte, feine Schatten. Ein guter Testfall für die Trennung von Schichten.

Inferenz ausführen

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,
     	    }
	)

Der Parameter „ num_layers “ bestimmt, wie fein das Modell das Bild aufteilt. Die Werte können zwischen 2 und 8 liegen. Mit 4 Schichten kriegst du eine gute Balance zwischen Granularität und Verwaltbarkeit. Wenn du „ seed “ auf einen festen Wert setzt, wird die Ausgabe reproduzierbar.

Die API akzeptiert auch direkt URLs, sodass du die Dateiverwaltung überspringen kannst, wenn dein Bild irgendwo gehostet wird:

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

Die Ebenen speichern

Die API gibt eine Liste von „ FileOutput “-Objekten zurück. Jedes hat eine Methode „ .read() “, die dir die Bildbytes gibt:

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

Die Ebenen sind von unten nach oben angeordnet: Index 0 ist der Hintergrund, und höhere Indizes liegen darüber. Jede PNG-Datei ist ein RGBA-Bild mit Transparenz, bei dem andere Ebenen durchscheinen.

Hier ist das Ergebnis:

Das Modell hat den Hintergrund (lavendelfarbene Wand und mintfarbene Oberfläche) auf Ebene 0, den Cremetiegel auf Ebene 1, die Geschenkbox auf Ebene 2 und die Serumflasche auf Ebene 3 platziert. Jedes Produkt hatte saubere Kanten und eine perfekte Transparenz.

Schau dir mal die Hintergrundebene an, dann siehst du schwache Schattenreste, wo die Produkte vorher waren. Das hat sich in meinen Tests immer wieder gezeigt: Das Modell kann Objekte gut isolieren, hat aber Probleme mit der Hintergrundrekonstruktion, wenn Schatten im Spiel sind. 

Je stärker die Schatten in deinem Ausgangsbild sind, desto mehr fallen diese Artefakte auf. Es ist das erste Modell dieser Art, also kannst du davon ausgehen, dass das Qwen-Team es in zukünftigen Updates weiter verbessern wird.

Schichten mit Qwen-Image-Layered neu kombinieren

Die Zerlegung ist nur die Hälfte der Arbeit. Die Ebenen sind echt praktisch, wenn du sie bearbeitest und zu was Neuem zusammenfügst.

Den Hintergrund austauschen

Produktfotografen brauchen oft dieselbe Aufnahme mit unterschiedlichen Hintergründen für A/B-Tests, saisonale Kampagnen oder bestimmte Plattformanforderungen. Bei getrennten Schichten braucht man dafür nur ein paar Zeilen 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")

Die Funktion „ alpha_composite() “ kümmert sich automatisch um die RGBA-Überblendung. Es achtet auf Transparenz in jeder Ebene, sodass Objekte im Vordergrund ganz natürlich auf jedem beliebigen Hintergrund liegen. 

PIL macht die Bildbearbeitung einfach, und wenn du komplexere Transformationen brauchst, lassen sich die Bildverarbeitungsfunktionen von PyTorch gut in PIL-Workflows integrieren lassen.

Hier ist das Ergebnis:

Gleiche Produkte, andere Umgebung, kein manuelles Maskieren. Du kannst einen Farbverlauf, eine Textur oder ein ganz anderes Foto einfügen. Der Prozess bleibt derselbe: Schicht 0 ersetzen, den Rest zusammenfügen.

Objekte entfernen oder neu positionieren

Das gleiche Muster gilt auch für andere Bearbeitungen. Entferne ein Objekt, indem du seine Ebene überspringst:

# 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)

Um ein Objekt neu zu positionieren, indem du es an anderen Koordinaten einfügst, benutze die paste() mit dem von dir gewählten x/y-Versatz:

# 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

Der Ablauf ist immer derselbe: 

1. Ändere die Ebenen, die dir wichtig sind: Größe ändern, Farbe ändern, löschen, neu anordnen.
2. Dann alles wieder zusammensetzen. 

Jeder Vorgang läuft auf einer eigenen Ebene ab, sodass die Änderungen nur dort gemacht werden.

Erstellen eines Qwen-Image-Layered-Editors mit Streamlit

Diese Vorgänge in einem Notizbuch zu machen, ist okay für einmalige Änderungen, aber die Rückmeldung dauert ewig. Du schreibst Code, machst eine Zelle, schaust dir das Ergebnis an, passt was an und machst das Ganze nochmal. Für wiederholte Aufgaben, bei denen du Ebenen ein- und ausschalten, Kompositionen vergleichen und Ergebnisse runterladen willst, ohne Zellen neu auszuführen, ist eine schlanke Benutzeroberfläche sinnvoller.

Wir machen eine Streamlit-App mit etwa 160 Zeilen, mit der du ein Bild hochladen, zerlegen, Ebenen umschalten und eine Live-Vorschau sehen kannst. Mach eine Datei namens „ streamlit_app.py ” in deinem Projektverzeichnis.

Einrichten von Streamlit

Fang mit den Importen und der Grundkonfiguration an:

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")

Der Sitzungsstatus bleibt bei Streamlit-Neustarts erhalten. Ohne das würden deine Ebenen jedes Mal verschwinden, wenn jemand auf einen Knopf klickt.

API-Token-Prüfung

Bevor du Replicate aufrufst, check, ob das Token da ist:

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() stoppt die Ausführung, wenn das Token fehlt. Es bringt nichts, den Rest der Benutzeroberfläche zu rendern.

Funktion zur Zerlegung zwischengespeicherter Bilder

Die Zerlegungs-API kostet 0,03 $ pro Aufruf und dauert 30 bis 60 Sekunden. Caching verhindert unnötige Aufrufe:

@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

Das Unterstrich-Präfix bei „ _image_bytes ” sagt Streamlit, dass es diesen Parameter nicht hashen soll (das Hashen von Bytes ist ziemlich aufwendig). Die Wiederholungsschleife fängt gelegentliche 502-Fehler von Replicate ab, indem sie 5 Sekunden wartet und es bis zu 3 Mal versucht.

Visualisierung und Bildkomposition

Als Nächstes machen wir uns kleine Hilfsprogramme für die Visualisierung und das Compositing klar:

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))

Das Schachbrettmuster macht Transparenz sichtbar (Standard in Bildbearbeitungsprogrammen). Die zusammengesetzte Funktion macht das, was wir im Notizbuch gemacht haben, und wird jetzt durch den Status des Kontrollkästchens gesteuert.

Einstellungen für das Hochladen und Zerlegen von Bildern

Die Seitenleiste kümmert sich um das Hochladen von Bildern und die Einstellungen für die Zerlegung:

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()

Der Schaltknopf „Zerlegen“ ist deaktiviert, bis ein Bild hochgeladen wird. Wenn es klappt, werden die Ebenen im Sitzungsstatus gespeichert und alle Sichtbarkeitsoptionen sind standardmäßig auf „True“ gesetzt.

Steuerelemente für Bildebenen hinzufügen

Zwei Spalten zeigen die Ebenensteuerung und die Live-Vorschau an:

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,
            )

Wenn du das Häkchen bei einer Ebene entfernst, führt Streamlit das Skript erneut aus. Das Kontrollkästchen aktualisiert „ layer_visibility “ (Vorschau-Raster), die zusammengesetzte Funktion berechnet die Vorschau neu und die Benutzeroberfläche wird automatisch aktualisiert.

Die App ausführen

Speicher die Datei und starte:

streamlit run streamlit_app.py

Die App hat ein zerlegtes Bild. Schalte die Ebenen aus, um Objekte aus der Vorschau zu entfernen.

Lade ein Bild hoch, klick auf „Zerlegen“ und schalte dann die Ebenen ein und aus. Die Vorschau wird sofort aktualisiert. Lade das Ergebnis runter, wenn du eine Komposition findest, die dir gefällt. Der ganze Arbeitsablauf läuft im Browser ab, ohne dass man die Notebook-Zellen nochmal ausführen muss.

Fazit

Qwen-Image-Layered macht die Bildbearbeitung anders: Anstatt Pixel zu maskieren, trennt es den Inhalt in komplette RGBA-Ebenen mit nachgezeichneten Hintergründen. Du bekommst Objektisolierung ohne den Aufwand für die Bereinigung. Das Modell hat Probleme mit Schattenartefakten in komplizierten Szenen, aber die Objektextraktion selbst klappt gut.

Der Python-Workflow ist echt einfach. Ruf die API von Replicate auf, hol dir eine Liste der Ebenen und setz sie mit PIL zusammen. Hintergrundaustausch und Objektentfernung sind nur ein paar Zeilen Code. Die Streamlit-App packt diese Logik in eine GUI, damit man schneller iterieren kann.

Das ist das erste Modell seiner Art. Das Qwen-Team bringt Updates schnell raus, also kannst du mit Verbesserungen bei der Hintergrundrekonstruktion und besserer Verarbeitung von Bildern mit vielen Schatten rechnen. Die Forschungsarbeit beschreibt die Architektur, falls du wissen willst, wie die variable Schichtzerlegung im Hintergrund funktioniert.

Willst du noch mehr Open-Source-KI-Modelle entdecken? Lerne das System hinter Qwen kennen, indem du den Hugging Face Fundamentals Lernpfad auf DataCamp.