Qwen-Image-Layered: Görsel Ayrıştırmaya Yönelik Uygulamalı Bir Rehber

Photoshop kullanıcıları saatlerini nesneleri maskeleyerek ve arka planları boyayarak harcar. Alibaba’daki Qwen ekibinin yeni modeli Qwen-Image-Layered bunu otomatik yapıyor: tek bir görsel verin, şeffaf arka planlı birden fazla RGBA katmanı döndürsün.

Bu eğitim Qwen-Image-Layered’ın ne olduğunu, SAM gibi segmentasyon araçlarından nasıl ayrıştığını ve Python’da nasıl çalıştırılacağını kapsar. Bir görseli katmanlarına ayıracak, ardından bu katmanları düzenleyip yeni bir kompozitte yeniden birleştireceksiniz. Sonunda, manuel maskelemeyi tamamen atlayan, programatik görsel düzenleme için çalışan bir iş akışına sahip olacaksınız.

Kodda görsel verileri ve şeffaflığı kullanmaya yeniyseniz, derine dalmadan önce sağlam bir temel oluşturmak için Python ile Görüntü İşleme kursumuza göz atın. Ayrıca Google’ın en yeni görsel üretim modeli hakkında hazırladığımız Nano Banana 2 rehberimizi de okumanızı öneririm.

Qwen-Image-Layered Nedir?

Qwen-Image-Layered, Alibaba’nın Qwen2.5-VL adlı görsel-dil modeli üzerine inşa edilmiştir. VL omurgası, modelin bir görselde ne olduğunu anlamsal olarak kavradığı anlamına gelir: yalnızca kenarları tespit etmek yerine bir ürünü gölgesinden ve üzerinde durduğu yüzeyden ayırt edebilir. Vision Transformer modelleri gibi, görselleri geleneksel evrişimsel yaklaşımlar yerine dikkat mekanizmalarıyla işler.

Çıkarımı çalıştırdığınızda, kaç katman istediğinizi belirtirsiniz. 4 derseniz, model görsel içeriğini 4 RGBA çıktı arasında dağıtır. 8 derseniz, ayrım daha ince olur. Model, sahne yapısına göre neyin nereye gideceğine karar verir.

Görsel Örnek

Ayrıştırma, Qwen’in duyurusunda şu şekilde görünüyor:

Model, bir bileşik görseli alıp şeffaflığa sahip, tek tek düzenlenebilir RGBA katmanlarına ayırır.

Şeker promosyon görseli dört belirgin katmana ayrılıyor: yıldız patlaması arka planı, turuncu giyimli kişi, "Sour Candy" metni ve marka öğeleri ile tek tek şeker parçaları. Her katman, düzenleme veya yeniden düzenleme için hazır, şeffaf bir arka planla (dama deseniyle gösteriliyor) çıkıyor.

Model, derinlik ve anlamsal anlayışa göre görsel öğeleri katmanlara dağıtır. Arka plan grafikleri 0. katmana, ana özne (kişi) 1. katmana, metin bindirmeleri 2. katmana, küçük ön plan nesneleri (şeker parçaları) 3. katmana gider. Her öğe uygun şeffaflıkla temiz şekilde ayrılır.

Qwen-Image-Layered ve Segment Anything Model Karşılaştırması

Daha önce görsel segmentasyonla çalıştıysanız, Qwen-Image-Layered’ın özellikle Segment Anything Model (SAM) gibi mevcut araçlarla nasıl kıyaslandığını merak edebilirsiniz.

SAM ve benzeri segmentasyon modelleri maske üretir: hangi pikselin hangi nesneye ait olduğunu gösteren ikili haritalar. Faydalıdır, ancak maske yalnızca bir şeyin nerede olduğunu söyler. Nesneyi çıkarmak, orijinal görselde yine de bir boşluk bırakır.

Qwen-Image-Layered ise tam katmanlar üretir. Ön plan nesnesi şeffaflıkla çıkar, arka plandaki katman ise zaten doldurulmuştur. Daha sonra bir katmanı silip taşıdığınızda yamayacak bir şey kalmaz.

SAM ayırt edici bir yaklaşım kullanır; mevcut pikselleri analiz ederek nesne sınırlarını hassas biçimde tanımlar. Buna karşılık Qwen-Image-Layered, öğrenilmiş görsel üretimiyle kapalı veya gizli bölgeleri yeniden inşa eden üretici, difüzyon tabanlı bir mimariden yararlanır. 

SAM, neyin çıkarılacağını tanımlayan maskeler üretirken, Qwen-Image-Layered katman ayrıştırmasını tamamlamak için makul arka plan içeriği üretir. Dikkate değer şekilde, SAM özel boyama (inpainting) modelleriyle birleştirildiğinde benzer arka plan doldurma sağlayabilir, ancak Qwen-Image-Layered bu yeteneği ayrıştırma sürecinin baştan sona bir parçası olarak entegre eder.

Girdi kontrol mekanizması da farklıdır: SAM, belirli bir hedefi seçmek için noktalara tıklamanızı veya sınırlayıcı kutular çizmenizi gerektiren hassas etkileşimli istemlere dayanır. Qwen-Image-Layered ise daha bütüncül çalışır; tüm görsel yapısını otomatik düzenlemek için yalnızca istenen katman sayısını belirtmenize (örn. "bunu 4 katmana böl") olanak tanır.

SAM 2’nin açıkça video için tasarlandığını, bellek destekli akış mimarisiyle (yaklaşık ~6 son kareyi tutar) diziler boyunca nesneleri yüksek zamansal tutarlılıkla izleyebildiğini not etmeliyiz. Qwen-Image-Layered ise statik görsel ayrıştırmaya özelleşmiştir ve şu anda video düzenleme için yerel nesne takibi sunmaz.

Qwen-Image-Layered ile Bir Görseli Ayrıştırma

Şimdi uygulamalı kısma geçelim. Koda başlamadan önce pratik bir konu var: modeli nerede çalıştırmalı?

Neden bir API kullanmalı?

Qwen-Image-Layered, 57 GB’tan fazla model ağırlığı ve bol VRAM’e sahip üst düzey bir GPU gerektirir. 

Bunu yerelde Google Colab’de bir T4 GPU ile çalıştırmayı denedim ve oturum, model daha indirmeyi bitirmeden önce RAM’i tüketti. Disk kullanımı GPU çalışma zamanındaki 112 GB’ın 90 GB’ına kadar çıktı. Model, ücretsiz katman bulut ortamları için basitçe fazla büyük. 

Stable Diffusion gibi büyük üretici modeller benzer barındırma zorluklarıyla karşılaşır; bu yüzden barındırılan API’ler yaygın hale geldi.

Bu eğitim için Replicate’in barındırılan API’sini kullanacağız. Her ayrıştırma yaklaşık 0,03 $ tutar; bu da bellek sınırları veya bağımlılık çakışmalarıyla uğraşmadan, istikrarlı ve tekrarlanabilir bir çalıştırma sağlar. Kodsuz modeli denemek isterseniz, Hugging Face Space yükleme/indirme yapabileceğiniz ücretsiz bir web arayüzü sunuyor.

Hugging Face Space, modeli kod yazmadan test etmenizi sağlar; ancak API programatik kontrol sunar.

Ortamı kurma

Yeni bir proje dizini oluşturun ve gerekli paketleri yükleyin:

pip install replicate python-dotenvAltyapı:

API jetonunuzu Replicate hesap ayarları sayfasından alın ve bir .env dosyasına kaydedin:

REPLICATE_API_TOKEN=your_token_hereAltyapı:

Kaynak görsel

Resmi model duyuruları genellikle modelin en iyi performans gösterdiği seçme örnekleri sergiler. Bunun yerine gerçek bir görselle test edip gerçekçi performansı görelim.

Katmanlara ayıracağımız görsel şu:

Fotoğraf: Pexels’ta Karola G

Fotoğrafta lavanta fon önünde nane renginde bir yüzeyde üç cilt bakım ürünü var: siyah kurdeleli beyaz hediye kutusu, pembe serum şişesi ve küçük bir krem kavanozu. Temiz kompozisyon, belirgin nesneler, ince gölgeler. Katman ayrımı için iyi bir test vakası.

Çıkarımı çalıştırma

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,
     	    }
	)Altyapı:

num_layers parametresi modelin görseli ne kadar ince böleceğini kontrol eder. Değerler 2 ile 8 arasında olabilir. 4 katman, ayrıntı ve yönetilebilirlik arasında makul bir denge sağlar. seed değerini sabit tutmak çıktıyı tekrarlanabilir kılar.

API doğrudan URL’leri de kabul eder; görseliniz bir yerde barınıyorsa dosya işlemlerini atlayabilirsiniz:

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

Katmanları kaydetme

API bir FileOutput listesi döndürür. Her birinin görsel baytlarını veren bir .read() metodu vardır:

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

Katmanlar alttan üste doğru sıralıdır: 0. indeks arka plandır, daha yüksek indeksler onun üstüne yığılır. Her PNG, diğer katmanların görüneceği şeffaflığa sahip bir RGBA görseldir.

Sonuç şöyle:

Model arka planı (lavanta duvar ve nane yüzey) 0. katmana, krem kavanozunu 1. katmana, hediye kutusunu 2. katmana ve serum şişesini 3. katmana yerleştirdi. Her ürün temiz kenarlar ve doğru şeffaflıkla çıktı.

Ancak arka plan katmanına baktığınızda, ürünlerin bulunduğu yerlerde ince gölge kalıntıları göreceksiniz. Bu, testlerimde tutarlı biçimde ortaya çıktı: model nesne yalıtımını iyi yapıyor, ancak gölgeler söz konusu olduğunda arka planı yeniden oluşturmada zorlanıyor. 

Kaynak görselinizde gölgeler ne kadar belirginsa, bu yapaylıklar o kadar görünür oluyor. Türünün ilk modeli; Qwen ekibinin bunu gelecekteki güncellemelerde iyileştirmesini bekleyin.

Qwen-Image-Layered ile Katmanları Yeniden Birleştirme

Ayrıştırma işin sadece yarısıdır. Katmanlar, düzenleyip yeni bir şey olarak yeniden birleştirdiğinizde işe yarar hale gelir.

Arka planı değiştirme

Ürün fotoğrafçıları çoğu zaman A/B testleri, mevsimsel kampanyalar veya platforma özgü gereksinimler için aynı çekimi farklı arka planlarla ister. Ayrılmış katmanlarla bu işlem birkaç satır koda iner.

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")Altyapı:

alpha_composite() fonksiyonu RGBA harmanlamayı otomatik yapar. Her katmandaki şeffaflığa saygı duyar; böylece ön plan nesneleri, sunduğunuz herhangi bir arka planın üzerinde doğal biçimde durur. 

PIL görsel manipülasyonunu kolaylaştırır ve daha karmaşık dönüşümler uygulamanız gerekiyorsa, PyTorch’un görsel işleme yetenekleri PIL iş akışlarıyla iyi bütünleşir.

Sonuç şöyle:

Aynı ürünler, farklı bir ortam, üstelik manuel maskeleme olmadan. Düz bir renk yerine bir gradyan, doku veya bambaşka bir fotoğraf koyabilirsiniz. Süreç aynı kalır: 0. katmanı değiştirin, kalanları kompoze edin.

Nesneleri kaldırma veya yeniden konumlandırma

Aynı desen diğer düzenlemelere de uygulanır. Bir katmanı atlayarak bir nesneyi kaldırın:

# 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)Altyapı:

Bir nesneyi farklı koordinatlara yapıştırarak yeniden konumlandırmak için, seçtiğiniz x/y ofsetiyle paste() metodunu kullanın:

# 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 usualAltyapı:

İş akışı her zaman aynı: 

1. İlgilendiğiniz katmanları değiştirin: Yeniden boyutlandırın, yeniden renklendirin, silin, yeniden düzenleyin.
2. Ardından hepsini yeniden kompoze edin. 

Her işlem yalıtılmış bir katmanda gerçekleşir; bu sayede düzenlemeler yerinde kalır.

Streamlit ile Qwen-Image-Layered Düzenleyici Oluşturma

Bu işlemleri bir not defterinde çalıştırmak tek seferlik düzenlemeler için işe yarar, ancak geri bildirim döngüsü yavaştır. Kod yazarsınız, hücreyi çalıştırırsınız, çıktıyı kontrol eder, ayarlar, tekrar edersiniz. Katmanları açıp kapatmak, kompozisyonları karşılaştırmak ve hücreleri yeniden çalıştırmadan sonuçları indirmek istediğiniz yinelemeli işler için hafif bir GUI daha mantıklıdır.

Yaklaşık 160 satırda bir Streamlit uygulaması geliştireceğiz: görsel yükleyin, ayrıştırın, katmanları açıp kapatın ve canlı önizleme görün. Proje dizininizde streamlit_app.py adlı bir dosya oluşturun.

Streamlit’i kurma

İçe aktarmalar ve temel yapılandırma ile başlayın:

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")Altyapı:

Oturum durumu, Streamlit yeniden çalıştırmaları arasında kalıcıdır. Olmasaydı, biri bir düğmeye her tıkladığında katmanlarınız kaybolurdu.

API jetonu kontrolü

Replicate’i çağırmadan önce jetonun var olduğundan emin olun:

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()Altyapı:

st.stop() jeton eksikse yürütmeyi durdurur. Geri kalan UI’ı render etmenin anlamı yoktur.

Önbellekli görsel ayrıştırma fonksiyonu

Ayrıştırma API’si çağrı başına 0,03 $ tutar ve 30-60 saniye sürer. Önbellekleme gereksiz çağrıları önler:

@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
            raiseAltyapı:

_image_bytes üzerindeki alt çizgi öneki, Streamlit’e o parametreyi karma’lamamasını söyler (baytların karma’sını almak maliyetlidir). Yeniden deneme döngüsü, Replicate’in arada bir verdiği 502 hatalarını 5 saniye bekleyip en fazla 3 kez deneyerek ele alır.

Görselleştirme ve görsel kompozisyon

Sırada görselleştirme ve kompozisyon için küçük yardımcılar tanımlıyoruz:

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))Altyapı:

Dama deseni şeffaflığı görünür kılar (standart görsel düzenleyici geleneği). Kompozisyon fonksiyonu, artık onay kutusu durumuyla tetiklenen, not defterinde yaptığımızın aynısını yapar.

Görsel yükleme ve ayrıştırma ayarları

Kenar çubuğu görsel yüklemeyi ve ayrıştırma ayarlarını yönetir:

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()Altyapı:

Bir görsel yüklenene kadar ayrıştır düğmesi devre dışıdır. Başarılı olduğunda katmanlar oturum durumuna kaydedilir ve tüm görünürlük anahtarları varsayılan olarak True olur.

Görsel katman kontrollerini ekleme

İki sütun, katman kontrollerini ve canlı önizlemeyi gösterir:

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,
            )Altyapı:

Bir katmanın işaretini kaldırdığınızda Streamlit betiği yeniden çalıştırır. Onay kutusu layer_visibility değerini günceller, kompozisyon fonksiyonu önizlemeyi yeniden hesaplar ve arayüz otomatik tazelenir.

Uygulamayı çalıştırma

Dosyayı kaydedin ve şunu çalıştırın:

streamlit run streamlit_app.pyAltyapı:

Uygulama bir görseli ayrıştırdı. Önizlemeden nesneleri kaldırmak için katmanları kapatın.

Bir görsel yükleyin, ayrıştır’a tıklayın, ardından katmanları açıp kapatın. Önizleme anında güncellenir. Beğendiğiniz bir kompozisyon bulduğunuzda sonucu indirin. Tüm iş akışı, not defteri hücrelerini yeniden çalıştırmadan tarayıcıda gerçekleşir.

Sonuç

Qwen-Image-Layered görsel düzenlemeye farklı bir yaklaşım getiriyor: pikselleri maskelemek yerine içeriği boyanmış arka planlarla birlikte tam RGBA katmanlarına ayırıyor. Temizlik işine gerek kalmadan nesne yalıtımı elde edersiniz. Model, karmaşık sahnelerdeki gölge yapaylıklarıyla zorlanıyor; ancak nesne çıkarımı başlı başına iyi çalışıyor.

Python iş akışı basittir. Replicate’in API’sini çağırın, bir katman listesi alın ve bunları PIL ile kompoze edin. Arka plan değiştirme ve nesne kaldırma birkaç satır koda iner. Streamlit uygulaması bu mantığı daha hızlı yineleme için bir GUI ile sarmalar.

Bu türün ilk modeli. Qwen ekibi hızlı güncellemeler yayınlıyor; bu nedenle arka plan yeniden inşasında iyileştirmeler ve gölge yoğun görsellerin daha iyi ele alınmasını bekleyin. araştırma makalesi, değişken katman ayrıştırmasının kaput altında nasıl çalıştığını anlamak isteyenler için mimariyi ele alıyor.

Daha fazla açık kaynaklı yapay zeka modelini keşfetmeye hazır mısınız? Qwen’in arkasındaki ekosistemi öğrenmek için DataCamp’teki Hugging Face Fundamentals beceri yolunu tamamlayın.