Qwen-Image-Layered: Panduan Praktis untuk Dekomposisi Gambar

Pengguna Photoshop menghabiskan berjam-jam untuk menandai (masking) objek secara manual dan mengecat latar belakang. Qwen-Image-Layered, model baru dari tim Qwen di Alibaba, melakukan ini secara otomatis: berikan satu gambar, dan ia mengembalikan beberapa layer RGBA dengan latar belakang transparan.

Tutorial ini membahas apa itu Qwen-Image-Layered, bagaimana perbedaannya dari alat segmentasi seperti SAM, dan cara menjalankannya di Python. Anda akan memecah sebuah gambar menjadi layer, lalu mengedit dan menggabungkan kembali layer tersebut menjadi komposit baru. Pada akhirnya, Anda akan memiliki alur kerja pengeditan gambar terprogram yang sepenuhnya melewati masking manual.

Jika Anda baru dalam menangani data gambar dan transparansi dalam kode, lihat kursus Image Processing in Python kami untuk membangun fondasi yang kuat sebelum terjun. Saya juga merekomendasikan membaca panduan kami tentang model generasi gambar terbaru dari Google, Nano Banana 2.

Apa itu Qwen-Image-Layered?

Qwen-Image-Layered dibangun di atas Qwen2.5-VL, sebuah model visi-bahasa dari Alibaba. Tulang punggung VL membuat model memahami isi gambar secara semantik: ia dapat membedakan produk dari bayangannya dan dari permukaan tempat ia berada, bukan sekadar mendeteksi tepi. Seperti Vision Transformers, ia memproses gambar melalui mekanisme attention alih-alih pendekatan konvolusional tradisional.

Saat Anda menjalankan inferensi, Anda menentukan berapa banyak layer yang diinginkan. Minta 4, dan model mendistribusikan konten gambar ke 4 keluaran RGBA. Minta 8, dan Anda mendapatkan pemisahan yang lebih halus. Model memutuskan apa yang masuk ke mana berdasarkan struktur adegan.

Contoh Visual

Beginilah tampilan dekomposisinya dalam pengumuman Qwen:

Model mengambil gambar komposit dan memisahkannya menjadi layer RGBA yang dapat diedit satu per satu dengan transparansi.

Gambar promosi permen dipecah menjadi empat layer berbeda: latar belakang starburst, orang berbaju oranye, teks dan branding "Sour Candy", serta potongan permen individual. Setiap layer keluar dengan latar belakang transparan (ditunjukkan dengan pola kotak-kotak), siap untuk diedit atau diatur ulang.

Model mendistribusikan elemen visual ke berbagai layer berdasarkan kedalaman dan pemahaman semantik. Grafik latar belakang masuk ke layer 0, subjek utama (orang) ke layer 1, overlay teks ke layer 2, dan objek latar depan kecil (potongan permen) ke layer 3. Setiap elemen terpisah rapi dengan transparansi yang tepat.

Qwen-Image-Layered vs Segment Anything Model

Jika Anda pernah bekerja dengan segmentasi gambar, Anda mungkin bertanya-tanya bagaimana Qwen-Image-Layered dibandingkan dengan alat yang sudah ada, khususnya Segment Anything Model (SAM).

SAM dan model segmentasi serupa menghasilkan mask: peta biner tentang piksel mana yang termasuk objek mana. Berguna, tetapi mask hanya memberi tahu Anda di mana sesuatu berada. Mengekstrak objek tetap menyisakan lubang pada gambar asli.

Sebaliknya, Qwen-Image-Layered menghasilkan layer lengkap. Objek latar depan keluar dengan transparansi, dan layer latar belakang di belakangnya sudah terisi. Ketika Anda menghapus atau memindahkan layer nanti, tidak ada yang perlu ditambal.

SAM menggunakan pendekatan diskriminatif, menganalisis piksel yang ada untuk mendefinisikan batas objek secara presisi. Sebaliknya, Qwen-Image-Layered menggunakan arsitektur generatif berbasis difusi yang merekonstruksi wilayah yang teroklusi atau tersembunyi melalui generasi gambar yang dipelajari. 

Sementara SAM menghasilkan mask yang mendefinisikan apa yang perlu dihapus, Qwen-Image-Layered menghasilkan konten latar belakang yang masuk akal untuk menyelesaikan dekomposisi berlapis. Perlu dicatat, SAM dapat mencapai pengisian latar belakang serupa bila digabungkan dengan model inpainting khusus, tetapi Qwen-Image-Layered mengintegrasikan kapabilitas ini secara ujung-ke-ujung dalam proses dekomposisinya.

Mekanisme kendali inputnya juga berbeda: SAM bergantung pada prompt interaktif yang presisi, mengharuskan Anda mengklik titik atau menggambar bounding box untuk memilih target spesifik. Qwen-Image-Layered bekerja lebih holistik, memungkinkan Anda cukup menentukan jumlah layer yang diinginkan (mis., "pecah menjadi 4 layer") untuk mengatur struktur gambar secara otomatis.

Perlu kami catat bahwa SAM 2 dirancang secara eksplisit untuk video, mampu melacak objek melalui urutan menggunakan arsitektur streaming dengan memori (mempertahankan ~6 frame terbaru) dengan konsistensi temporal tinggi. Qwen-Image-Layered terspesialisasi untuk dekomposisi gambar statis dan saat ini belum menawarkan pelacakan objek native untuk pengeditan video.

Mendekomposisi Gambar dengan Qwen-Image-Layered

Sekarang bagian praktiknya. Sebelum menulis kode, ada pertimbangan praktis: di mana menjalankan model.

Mengapa menggunakan API?

Qwen-Image-Layered memerlukan lebih dari 57GB bobot model dan GPU kelas atas dengan VRAM yang besar. 

Saya menguji menjalankannya secara lokal di Google Colab dengan GPU T4, dan sesi kehabisan RAM sebelum model selesai diunduh. Penggunaan disk naik ke 90GB dari 112GB yang tersedia di runtime GPU. Model ini terlalu besar untuk lingkungan cloud tingkat gratis. 

Model generatif besar seperti Stable Diffusion menghadapi tantangan hosting serupa, itulah sebabnya API terkelola menjadi umum.

Untuk tutorial ini, kita akan menggunakan API terkelola Replicate. Setiap dekomposisi biayanya sekitar $0,03, yang memberi Anda run yang stabil dan dapat direproduksi tanpa pusing keterbatasan memori atau konflik dependensi. Jika Anda hanya ingin mencoba model tanpa menulis kode, Hugging Face Space menawarkan antarmuka web gratis tempat Anda bisa mengunggah gambar dan mengunduh layer secara manual.

Hugging Face Space memungkinkan Anda menguji model tanpa kode, tetapi API memberi kendali terprogram.

Menyiapkan lingkungan

Buat direktori proyek baru dan pasang paket yang diperlukan:

pip install replicate python-dotenvDidukung oleh

Dapatkan token API Anda dari pengaturan akun Replicate dan simpan di berkas .env:

REPLICATE_API_TOKEN=your_token_hereDidukung oleh

Gambar sumber

Pengumuman model resmi biasanya menampilkan contoh terpilih di mana model berkinerja terbaik. Mari uji dengan gambar dunia nyata sebagai gantinya untuk melihat performa yang realistis.

Ini adalah gambar yang akan kita dekomposisi menjadi layer:

Foto oleh Karola G di Pexels

Foto tersebut menampilkan tiga produk perawatan kulit di atas permukaan mint dengan latar ungu muda: kotak kado putih dengan pita hitam, botol serum pink, dan pot krim kecil. Komposisi bersih, objek berbeda, bayangan halus. Kasus uji yang baik untuk pemisahan layer.

Menjalankan inferensi

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

Parameter num_layers mengendalikan seberapa halus model membagi gambar. Nilainya dapat berkisar dari 2 hingga 8. Dengan 4 layer, Anda mendapatkan keseimbangan yang masuk akal antara granularitas dan keterkelolaan. Menetapkan seed ke nilai tetap membuat keluaran dapat direproduksi.

API juga menerima URL secara langsung, jadi Anda bisa melewati penanganan berkas jika gambar Anda dihosting di suatu tempat:

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

Menyimpan layer

API mengembalikan daftar objek FileOutput. Masing-masing memiliki metode .read() yang memberi Anda byte gambar:

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

Layer diurutkan dari bawah ke atas: indeks 0 adalah latar belakang, dan indeks yang lebih tinggi menumpuk di atasnya. Setiap PNG adalah gambar RGBA dengan transparansi, di mana layer lain akan terlihat menembus.

Berikut hasilnya:

Model menempatkan latar belakang (dinding ungu muda dan permukaan mint) pada layer 0, pot krim pada layer 1, kotak kado pada layer 2, dan botol serum pada layer 3. Setiap produk keluar dengan tepi yang bersih dan transparansi yang akurat.

Namun, lihat layer latar belakang dan Anda akan melihat sisa bayangan samar di tempat produk berada sebelumnya. Ini muncul secara konsisten dalam pengujian saya: model menangani isolasi objek dengan baik, tetapi kesulitan merekonstruksi latar belakang saat melibatkan bayangan.

Semakin menonjol bayangan pada gambar sumber Anda, semakin terlihat artefak ini. Ini adalah model pertama dari jenisnya, jadi harapkan tim Qwen menyempurnakannya dalam pembaruan mendatang.

Menggabungkan Kembali Layer Dengan Qwen-Image-Layered

Dekomposisi hanyalah setengah dari alur kerja. Layer menjadi berguna ketika Anda mengedit dan merakitnya kembali menjadi sesuatu yang baru.

Menukar latar belakang

Fotografer produk sering membutuhkan bidikan yang sama dengan latar belakang berbeda untuk A/B testing, kampanye musiman, atau persyaratan spesifik platform. Dengan layer yang terpisah, ini hanya perlu beberapa baris kode.

from PIL import Image

# Muat layer hasil dekomposisi
layers = [Image.open(f"layer_{i}.png") for i in range(4)]

# Buat latar belakang baru (solid coral)
new_bg = Image.new("RGBA", layers[0].size, (255, 180, 162, 255))

# Ganti layer latar belakang asli
layers[0] = new_bg

# Komposit dari bawah ke atas
result = layers[0]
for layer in layers[1:]:
	result = Image.alpha_composite(result, layer)

result.save("coral_background.png")Didukung oleh

Fungsi alpha_composite() menangani blending RGBA secara otomatis. Ia menghormati transparansi di setiap layer, sehingga objek latar depan tampak alami di atas latar belakang apa pun yang Anda sediakan. 

PIL memudahkan manipulasi gambar, dan jika Anda perlu menerapkan transformasi yang lebih kompleks, kapabilitas pemrosesan gambar PyTorch terintegrasi dengan baik dengan alur kerja PIL.

Berikut hasilnya:

Produk yang sama, lingkungan berbeda, tanpa masking manual. Anda bisa mengganti gradien, tekstur, atau foto lain sepenuhnya. Prosesnya tetap sama: ganti layer 0, komposit sisanya.

Menghapus atau memosisikan ulang objek

Pola yang sama berlaku untuk edit lainnya. Hapus objek dengan melewati layer-nya:

# Komposit tanpa pot krim (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)Didukung oleh

Untuk memosisikan ulang objek dengan menempelkannya pada koordinat berbeda, gunakan metode paste() dengan offset x/y pilihan Anda:

# Pindahkan botol serum 50 piksel ke kiri
 canvas = Image.new("RGBA", layers[0].size, (0, 0, 0, 0))
 canvas.paste(layers[3], (-50, 0), layers[3])
 layers[3] = canvas

 # Lalu komposit seperti biasaDidukung oleh

Alur kerjanya selalu sama: 

1. Modifikasi layer yang Anda perlukan: Ubah ukuran, ubah warna, hapus, atur ulang.
2. Kemudian, komposit semuanya kembali. 

Setiap operasi terjadi pada layer terisolasi, sehingga edit tetap terkontrol.

Membangun Editor Qwen-Image-Layered Dengan Streamlit

Menjalankan operasi ini di notebook cocok untuk edit sekali jalan, tetapi siklus umpan baliknya lambat. Anda menulis kode, mengeksekusi sel, memeriksa keluaran, menyesuaikan, ulangi. Untuk pekerjaan iteratif di mana Anda ingin menyalakan-matikan layer, membandingkan komposisi, dan mengunduh hasil tanpa menjalankan ulang sel, GUI ringan lebih masuk akal.

Kita akan membangun aplikasi Streamlit sekitar 160 baris yang memungkinkan Anda mengunggah gambar, mendekomposisinya, menyalakan-matikan layer, dan melihat pratinjau langsung. Buat berkas bernama streamlit_app.py di direktori proyek Anda.

Menyiapkan Streamlit

Mulai dengan impor dan konfigurasi dasar:

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

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

# Inisialisasi 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")Didukung oleh

Session state bertahan di seluruh rerun Streamlit. Tanpanya, layer Anda akan hilang setiap kali seseorang mengklik tombol.

Pemeriksaan token API

Sebelum memanggil Replicate, pastikan token ada:

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

st.stop() menghentikan eksekusi jika token tidak ada. Tidak ada gunanya merender sisa UI.

Fungsi dekomposisi gambar yang di-cache

Panggilan API dekomposisi biayanya $0,03 per panggilan dan memakan waktu 30–60 detik. Caching mencegah panggilan berulang yang tidak perlu:

@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
            raiseDidukung oleh

Prefiks garis bawah pada _image_bytes memberi tahu Streamlit untuk tidak melakukan hash pada parameter itu (bytes mahal untuk di-hash). Loop retry menangani sesekali error 502 dari Replicate dengan menunggu 5 detik dan mencoba hingga 3 kali.

Visualisasi dan komposisi gambar

Berikutnya, kita definisikan utilitas kecil untuk visualisasi dan komposit:

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

Pola kotak-kotak membuat transparansi terlihat (konvensi editor gambar standar). Fungsi komposit mencerminkan apa yang kita lakukan di notebook, kini dikendalikan oleh status kotak centang.

Unggah gambar dan pengaturan dekomposisi

Bilah sisi menangani unggah gambar dan pengaturan dekomposisi:

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

Tombol dekomposisi dinonaktifkan sampai gambar diunggah. Jika berhasil, layer disimpan di session state, dan semua toggle visibilitas default ke True.

Menambahkan kontrol layer gambar

Dua kolom menampilkan kontrol layer dan pratinjau langsung:

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

Saat Anda menghapus centang pada layer, Streamlit menjalankan ulang skrip. Kotak centang memperbarui layer_visibility, fungsi komposit menghitung ulang pratinjau, dan UI menyegarkan secara otomatis.

Menjalankan aplikasi

Simpan berkas dan jalankan:

streamlit run streamlit_app.pyDidukung oleh

Aplikasi memiliki gambar yang telah didekomposisi. Matikan layer untuk menghapus objek dari pratinjau.

Unggah gambar, klik decompose, lalu nyalakan-matikan layer. Pratinjau diperbarui seketika. Unduh hasilnya saat Anda menemukan komposisi yang Anda sukai. Seluruh alur kerja terjadi di browser tanpa menjalankan ulang sel notebook.

Kesimpulan

Qwen-Image-Layered menghadirkan pendekatan berbeda untuk pengeditan gambar: alih-alih memasking piksel, ia memisahkan konten menjadi layer RGBA lengkap dengan latar belakang yang di-inpaint. Anda mendapatkan isolasi objek tanpa pekerjaan pembersihan. Model ini kesulitan dengan artefak bayangan dalam adegan kompleks, tetapi ekstraksi objeknya sendiri bekerja dengan baik.

Alur kerja Python-nya sederhana. Panggil API Replicate, dapatkan daftar layer, dan komposit dengan PIL. Penukaran latar belakang dan penghapusan objek menjadi beberapa baris kode. Aplikasi Streamlit membungkus logika itu dalam GUI untuk iterasi lebih cepat.

Ini adalah model pertama dari jenisnya. Tim Qwen merilis pembaruan dengan cepat, jadi harapkan penyempurnaan pada rekonstruksi latar belakang dan penanganan yang lebih baik untuk gambar dengan bayangan berat. paper riset membahas arsitektur jika Anda ingin memahami cara kerja dekomposisi layer variabel di balik layar.

Siap mengeksplorasi lebih banyak model AI open-source? Kuasai ekosistem di balik Qwen dengan mengikuti Hugging Face Fundamentals skill track di DataCamp.