Qwen-Image-Layered: इमेज़ डी-कम्पोज़िशन के लिए व्यवहारिक मार्गदर्शिका

Photoshop उपयोगकर्ता अक्सर घंटों तक ऑब्जेक्ट्स को मैन्युअली मास्क करते हैं और बैकग्राउंड पेंट करते हैं। Alibaba की Qwen टीम का नया मॉडल Qwen-Image-Layered यह काम अपने-आप कर देता है: आप इसे एक इकलौती इमेज़ दें, और यह पारदर्शी बैकग्राउंड के साथ कई RGBA लेयर्स लौटाता है।

यह ट्यूटोरियल बताता है कि Qwen-Image-Layered क्या है, यह SAM जैसे सेगमेंटेशन टूल्स से कैसे अलग है, और इसे Python में कैसे चलाएँ। आप एक इमेज़ को लेयर्स में तोड़ेंगे, फिर उन लेयर्स को एडिट कर एक नए कम्पोज़िट में जोड़ेंगे। अंत तक, आपके पास प्रोग्रामेटिक इमेज़ एडिटिंग के लिए ऐसा वर्कफ़्लो होगा जिसमें मैन्युअल मास्किंग की ज़रूरत नहीं पड़ेगी।

यदि आप कोड में इमेज़ डेटा और ट्रांसपेरेंसी संभालने में नए हैं, तो हमारा Image Processing in Python कोर्स देखें ताकि आगे बढ़ने से पहले मजबूत आधार बन सके। मैं Google के नवीनतम इमेज़ जनरेशन मॉडल Nano Banana 2 पर हमारा गाइड भी पढ़ने की सलाह देता/देती हूँ।

Qwen-Image-Layered क्या है?

Qwen-Image-Layered Qwen2.5-VL पर आधारित है, जो Alibaba का एक विज़न-लैंग्वेज मॉडल है। VL बैकबोन का मतलब है कि मॉडल इमेज़ को सैमांतिक रूप से समझता है: यह किसी प्रोडक्ट, उसकी परछाईं और जिस सतह पर वह रखा है, उनके बीच फर्क कर सकता है—सिर्फ किनारों का पता लगाना ही नहीं। Vision Transformers की तरह, यह पारंपरिक कॉन्वोल्यूशनल तरीकों के बजाय अटेंशन मैकेनिज़्म से इमेज़ प्रोसेस करता है।

इन्फरेंस चलाते समय, आप बताते हैं कि आपको कितनी लेयर्स चाहिए। 4 माँगें, तो मॉडल इमेज़ कंटेंट को 4 RGBA आउटपुट्स में बाँट देता है। 8 माँगें, तो और बारीक विभाजन मिलता है। सीन स्ट्रक्चर के आधार पर मॉडल तय करता है कि क्या कहाँ जाए।

दृश्य उदाहरण

यहाँ Qwen की घोषणा में डी-कम्पोज़िशन कैसा दिखता है:

मॉडल एक कम्पोज़िट इमेज़ लेता है और उसे पारदर्शिता वाली, अलग-अलग संपादनयोग्य RGBA लेयर्स में विभाजित कर देता है।

कैंडी के प्रमोशनल इमेज़ को चार अलग लेयर्स में तोड़ा गया है: स्टारबर्स्ट बैकग्राउंड, नारंगी कपड़ों में व्यक्ति, "Sour Candy" टेक्स्ट और ब्रांडिंग, और अलग-अलग कैंडी पीस। हर लेयर पारदर्शी बैकग्राउंड (चेकरबोर्ड पैटर्न से दर्शाया गया) के साथ आती है, एडिट या री-अरेंज करने के लिए तैयार।

मॉडल गहराई और सैमांतिक समझ के आधार पर विज़ुअल तत्वों को लेयर्स में बाँटता है। बैकग्राउंड ग्राफिक्स लेयर 0 में जाते हैं, मुख्य सब्जेक्ट (व्यक्ति) लेयर 1 में, टेक्स्ट ओवरले लेयर 2 में, और छोटे फोरग्राउंड ऑब्जेक्ट (कैंडी पीस) लेयर 3 में। हर तत्व सही ट्रांसपेरेंसी के साथ साफ़-सुथरे ढंग से अलग होता है।

Qwen-Image-Layered बनाम Segment Anything Model

यदि आपने पहले इमेज़ सेगमेंटेशन के साथ काम किया है, तो आप सोच सकते हैं कि Qwen-Image-Layered मौजूदा टूल्स, खासकर Segment Anything Model (SAM), की तुलना में कैसा है।

SAM और इसी तरह के सेगमेंटेशन मॉडल्स मास्क आउटपुट करते हैं: बाइनरी मैप्स जो दिखाते हैं कि कौन-से पिक्सेल किस ऑब्जेक्ट के हैं। उपयोगी है, पर मास्क सिर्फ यह बताता है कि कुछ कहाँ है। ऑब्जेक्ट निकालने पर मूल इमेज़ में एक खाली जगह रह जाती है।

दूसरी ओर, Qwen-Image-Layered पूरी लेयर्स आउटपुट करता है। फोरग्राउंड ऑब्जेक्ट ट्रांसपेरेंसी के साथ निकलता है, और उसके पीछे की बैकग्राउंड लेयर पहले से भरी हुई होती है। बाद में आप कोई लेयर हटाएँ या हिलाएँ, तो कुछ पैच करने की ज़रूरत नहीं पड़ती।

SAM एक डिस्क्रिमिनेटिव अप्रोच अपनाता है, मौजूदा पिक्सेल्स का विश्लेषण कर ऑब्जेक्ट की सीमाएँ सटीक रूप से तय करता है। इसके विपरीत, Qwen-Image-Layered जनरेटिव डिफ्यूज़न-आधारित आर्किटेक्चर का उपयोग करता है जो सीखे हुए इमेज़ जनरेशन के ज़रिए ओक्लूडेड या छिपे क्षेत्रों का पुनर्निर्माण करता है। 

जहाँ SAM ऐसे मास्क आउटपुट करता है जो बताते हैं कि क्या हटाना है, वहीं Qwen-Image-Layered लेयर्ड डी-कम्पोज़िशन को पूरा करने के लिए विश्वसनीय बैकग्राउंड कंटेंट जनरेट करता है। ध्यान देने योग्य है कि SAM समर्पित इनपेंटिंग मॉडलों के साथ संयोजन में इसी तरह का बैकग्राउंड-फिलिंग हासिल कर सकता है, लेकिन Qwen-Image-Layered इस क्षमता को अपने डी-कम्पोज़िशन प्रोसेस में एंड-टू-एंड एकीकृत करता है।

इनपुट कंट्रोल मैकेनिज़्म भी अलग है: SAM सटीक इंटरैक्टिव प्रॉम्प्ट्स पर निर्भर करता है, जिसमें आपको किसी लक्ष्य को चुनने के लिए पॉइंट्स क्लिक करने या बॉक्स खींचने पड़ते हैं। Qwen-Image-Layered ज़्यादा समग्र तरीके से काम करता है—आप बस वांछित लेयर्स की संख्या बता दें (जैसे, "इसे 4 लेयर्स में बाँटो") और यह पूरी इमेज़ स्ट्रक्चर को अपने-आप व्यवस्थित कर देता है।

यह भी ध्यान देना होगा कि SAM 2 विशेष रूप से वीडियो के लिए बनाया गया है—यह मेमोरी-ऑगमेंटेड स्ट्रीमिंग आर्किटेक्चर (लगभग ~6 हालिया फ़्रेम्स बनाए रखता है) के साथ अनुक्रमों में ऑब्जेक्ट्स को उच्च टेम्पोरल कंसिस्टेंसी के साथ ट्रैक कर सकता है। Qwen-Image-Layered स्थिर इमेज़ डी-कम्पोज़िशन में विशेषज्ञ है और फिलहाल वीडियो एडिटिंग के लिए नेटिव ऑब्जेक्ट ट्रैकिंग प्रदान नहीं करता।

Qwen-Image-Layered के साथ इमेज़ डी-कम्पोज़ करना

अब व्यवहारिक भाग। कोई भी कोड लिखने से पहले, एक व्यावहारिक बात: मॉडल कहाँ चलाएँ।

API क्यों उपयोग करें?

Qwen-Image-Layered को 57GB से अधिक मॉडल वेट्स और भरपूर VRAM वाले हाई-एंड GPU की आवश्यकता होती है। 

मैंने इसे Google Colab पर T4 GPU के साथ लोकली चलाने की कोशिश की, और सत्र RAM से बाहर हो गया, यहाँ तक कि मॉडल डाउनलोड होना भी पूरा नहीं हुआ। GPU रनटाइम में डिस्क उपयोग 112GB में से 90GB तक पहुँच गया। यह मॉडल मुफ़्त क्लाउड वातावरणों के लिए सिरे से बड़ा है। 

बड़े जेनेरेटिव मॉडल्स जैसे Stable Diffusion को भी ऐसी ही होस्टिंग चुनौतियाँ झेलनी पड़ती हैं, इसलिए होस्टेड APIs आम हो गए हैं।

इस ट्यूटोरियल के लिए, हम Replicate का होस्टेड API उपयोग करेंगे। हर डी-कम्पोज़िशन पर लगभग $0.03 खर्च आता है, जो आपको मेमोरी लिमिट्स या डिपेंडेंसी कॉन्फ्लिक्ट्स की चिंता के बिना एक स्थिर, पुनरुत्पादन योग्य रन देता है। यदि आप बिना कोड लिखे मॉडल आज़माना चाहते हैं, तो Hugging Face Space एक मुफ़्त वेब इंटरफ़ेस देता है जहाँ आप इमेज़ अपलोड कर सकते हैं और लेयर्स मैन्युअली डाउनलोड कर सकते हैं।

Hugging Face Space आपको बिना कोड के मॉडल जाँचने देता है, लेकिन API आपको प्रोग्रामेटिक नियंत्रण देता है।

पर्यावरण सेटअप

एक नया प्रोजेक्ट डायरेक्टरी बनाएँ और आवश्यक पैकेज इंस्टॉल करें:

pip install replicate python-dotenvसंचालित द्वारा

अपना API टोकन Replicate account settings से लें और उसे .env फ़ाइल में सहेजें:

REPLICATE_API_TOKEN=your_token_hereसंचालित द्वारा

सोर्स इमेज़

आधिकारिक मॉडल घोषणाएँ आमतौर पर चुने हुए उदाहरण दिखाती हैं जहाँ मॉडल सर्वश्रेष्ठ प्रदर्शन करता है। यथार्थपरक प्रदर्शन देखने के लिए चलिए इसके बजाय एक वास्तविक दुनिया की इमेज़ से टेस्ट करते हैं।

यह वह इमेज़ है जिसे हम लेयर्स में डी-कम्पोज़ करेंगे:

फोटो: Karola G, Pexels पर

फोटो में लैवेंडर बैकड्रॉप पर मिंट सतह पर तीन स्किनकेयर प्रोडक्ट्स दिखते हैं: काले रिबन वाला सफेद गिफ्ट बॉक्स, गुलाबी सीरम बोतल, और एक छोटा क्रीम जार। साफ़ कंपोज़िशन, अलग-अलग ऑब्जेक्ट्स, हल्की परछाइयाँ—लेयर सेपरेशन के लिए अच्छा टेस्ट केस।

इन्फरेंस चलाना

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,
     	    }
	)संचालित द्वारा

num_layers पैरामीटर नियंत्रित करता है कि मॉडल इमेज़ को कितनी बारीकी से बाँटे। मान 2 से 8 तक हो सकते हैं। 4 लेयर्स पर, आपको ग्रैन्युलैरिटी और मैनेज करने की सुविधा के बीच अच्छा संतुलन मिलता है। seed को फिक्स्ड मान पर सेट करने से आउटपुट पुनरुत्पादन योग्य हो जाता है।

API सीधे URLs भी स्वीकार करता है, तो यदि आपकी इमेज़ कहीं होस्टेड है, तो आप फ़ाइल हैंडलिंग छोड़ सकते हैं:

output = replicate.run(
	"qwen/qwen-image-layered",
	input={
     	  "image": "https://example.com/photo.jpg",
     	  "num_layers": 4,
     	  "go_fast": True,
     	  "output_format": "png",
	}
)संचालित द्वारा

लेयर्स सहेजना

API FileOutput ऑब्जेक्ट्स की सूची लौटाता है। हर एक में एक .read() मेथड होता है जो आपको इमेज़ बाइट्स देता है:

for i, layer in enumerate(output):
	with open(f"layer_{i}.png", "wb") as f:
     	  f.write(layer.read())संचालित द्वारा

लेयर्स नीचे से ऊपर की तरफ क्रम में होती हैं: इंडेक्स 0 बैकग्राउंड है, और उच्चतर इंडेक्स उसके ऊपर स्टैक होते हैं। हर PNG एक RGBA इमेज़ होती है जिसमें ट्रांसपेरेंसी होती है, जहाँ अन्य लेयर्स झलक सकती हैं।

यह रहा परिणाम:

मॉडल ने बैकग्राउंड (लैवेंडर दीवार और मिंट सतह) को लेयर 0 पर, क्रीम जार को लेयर 1 पर, गिफ्ट बॉक्स को लेयर 2 पर, और सीरम बोतल को लेयर 3 पर रखा। हर प्रोडक्ट साफ़ किनारों और सटीक ट्रांसपेरेंसी के साथ निकला।

हालाँकि बैकग्राउंड लेयर को देखें, तो जहाँ पहले प्रोडक्ट्स थे वहाँ हल्के-फुल्के शैडो के अवशेष दिखेंगे। मेरे टेस्ट्स में यह लगातार दिखा: मॉडल ऑब्जेक्ट आइसोलेशन को अच्छी तरह संभालता है, लेकिन शैडोज़ शामिल होने पर बैकग्राउंड रिकंस्ट्रक्शन में संघर्ष करता है। 

आपकी सोर्स इमेज़ में परछाइयाँ जितनी अधिक प्रमुख होंगी, ये आर्टिफैक्ट्स उतने ही दिखेंगे। यह अपनी तरह का पहला मॉडल है, इसलिए उम्मीद करें कि Qwen टीम भविष्य के अपडेट्स में इसे और सुधारेगी।

Qwen-Image-Layered के साथ लेयर्स को फिर से जोड़ना

डी-कम्पोज़िशन वर्कफ़्लो का सिर्फ आधा हिस्सा है। लेयर्स तब उपयोगी बनती हैं जब आप उन्हें एडिट करके किसी नई संरचना में फिर से जोड़ते हैं।

बैकग्राउंड बदलना

प्रोडक्ट फ़ोटोग्राफ़र्स को अक्सर A/B टेस्टिंग, मौसमी अभियानों या प्लेटफ़ॉर्म-विशिष्ट आवश्यकताओं के लिए उसी शॉट के अलग बैकग्राउंड चाहिए होते हैं। अलग की गई लेयर्स के साथ, यह कुछ पंक्तियों के कोड में हो जाता है।

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")संचालित द्वारा

alpha_composite() फ़ंक्शन अपने-आप RGBA ब्लेंडिंग संभालता है। यह हर लेयर की ट्रांसपेरेंसी का सम्मान करता है, जिससे फोरग्राउंड ऑब्जेक्ट्स आपके दिए किसी भी बैकग्राउंड पर स्वाभाविक रूप से बैठते हैं। 

PIL इमेज़ मैनिपुलेशन को सरल बनाता है, और यदि आपको अधिक जटिल ट्रांसफ़ॉर्मेशंस लागू करने की आवश्यकता है, तो PyTorch की इमेज़ प्रोसेसिंग क्षमताएँ PIL वर्कफ़्लोज़ के साथ अच्छी तरह काम करती हैं।

यह रहा परिणाम:

वही प्रोडक्ट्स, अलग परिवेश, बिना मैन्युअल मास्किंग। आप ग्रेडिएंट, टेक्सचर या पूरी तरह कोई दूसरी फ़ोटो भी लगा सकते हैं। प्रक्रिया वही रहती है: लेयर 0 बदलें, बाकी को कम्पोज़िट करें।

ऑब्जेक्ट्स हटाना या उनकी स्थिति बदलना

अन्य एडिट्स पर भी वही पैटर्न लागू होता है। किसी ऑब्जेक्ट को उसकी लेयर छोड़कर हटाएँ:

# 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)संचालित द्वारा

किसी ऑब्जेक्ट की स्थिति बदलने के लिए उसे अलग निर्देशांक पर पेस्ट करें—इसके लिए paste() मेथड को चुने हुए x/y ऑफ़सेट के साथ उपयोग करें:

# 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संचालित द्वारा

वर्कफ़्लो हमेशा एक जैसा है: 

1. जिन लेयर्स की परवाह है, उन्हें संशोधित करें: आकार बदलें, रंग बदलें, हटाएँ, पुनर्व्यवस्थित करें।
2. फिर, सब कुछ वापस एक साथ कम्पोज़िट करें। 

हर ऑपरेशन एक आइसोलेटेड लेयर पर होता है, इसलिए एडिट्स सीमित दायरे में रहते हैं।

Streamlit के साथ Qwen-Image-Layered एडिटर बनाना

नोटबुक में ये ऑपरेशंस चलाना एक-दो एडिट्स के लिए ठीक है, पर फीडबैक लूप धीमा होता है। आप कोड लिखते हैं, सेल चलाते हैं, आउटपुट देखते हैं, एडजस्ट करते हैं, फिर दोहराते हैं। इटरेटिव काम के लिए जहाँ आप लेयर्स ऑन-ऑफ करना, कम्पोज़िशन की तुलना करना और बिना सेल्स दोबारा चलाए परिणाम डाउनलोड करना चाहते हैं, एक लाइटवेट GUI अधिक समझदारी है।

हम लगभग 160 लाइनों में एक Streamlit ऐप बनाएँगे जो आपको इमेज़ अपलोड करने, उसे डी-कम्पोज़ करने, लेयर्स टॉगल करने और लाइव प्रीव्यू देखने देता है। अपने प्रोजेक्ट डायरेक्टरी में streamlit_app.py नाम से एक फ़ाइल बनाएँ।

Streamlit सेटअप

इम्पोर्ट्स और बुनियादी कॉन्फ़िगरेशन से शुरू करें:

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")संचालित द्वारा

सेशन स्टेट Streamlit के री-रन के बीच बना रहता है। इसके बिना, हर बार किसी के बटन क्लिक करने पर आपकी लेयर्स गायब हो जातीं।

API टोकन जाँच

Replicate कॉल करने से पहले सुनिश्चित करें कि टोकन मौजूद है:

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() टोकन गायब होने पर निष्पादन रोक देता है। बाकी UI रेंडर करने का कोई मतलब नहीं।

कैश्ड इमेज़ डी-कम्पोज़िशन फ़ंक्शन

डी-कम्पोज़िशन API की प्रति कॉल लागत $0.03 है और 30–60 सेकंड लगते हैं। कैशिंग अनावश्यक कॉल्स रोकती है:

@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संचालित द्वारा

_image_bytes पर अंडरस्कोर प्रीफ़िक्स Streamlit को बताता है कि इस पैरामीटर को हैश न करे (बाइट्स हैश करने में महँगे होते हैं)। रिट्राई लूप Replicate के कभी-कभार आने वाले 502 एरर्स को 5 सेकंड रुककर अधिकतम 3 बार आज़माकर संभालता है।

विज़ुअलाइज़ेशन और इमेज़ कम्पोज़िशन

अगले चरण में, हम विज़ुअलाइज़ेशन और कम्पोज़िटिंग के लिए छोटे यूटिलिटीज़ परिभाषित करते हैं:

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))संचालित द्वारा

चेकरबोर्ड ट्रांसपेरेंसी को दृश्य बनाता है (मानक इमेज़ एडिटर परंपरा)। कम्पोज़िट फ़ंक्शन वही करता है जो हमने नोटबुक में किया था, अब चेकबॉक्स स्टेट से संचालित।

इमेज़ अपलोड और डी-कम्पोज़िशन सेटिंग्स

साइडबार इमेज़ अपलोड और डी-कम्पोज़िशन सेटिंग्स संभालता है:

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()संचालित द्वारा

जब तक इमेज़ अपलोड नहीं होती, डी-कम्पोज़ बटन अक्षम रहता है। सफलता पर, लेयर्स सेशन स्टेट में स्टोर हो जाती हैं, और सभी विज़िबिलिटी टॉगल्स डिफ़ॉल्ट रूप से True पर सेट होते हैं।

इमेज़ लेयर कंट्रोल्स जोड़ना

दो कॉलम लेयर कंट्रोल्स और लाइव प्रीव्यू दिखाते हैं:

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,
            )संचालित द्वारा

जब आप किसी लेयर को अनचेक करते हैं, Streamlit स्क्रिप्ट को फिर चलाता है। चेकबॉक्स layer_visibility अपडेट करता है, कम्पोज़िट फ़ंक्शन प्रीव्यू को फिर से गणना करता है, और UI अपने-आप रिफ्रेश हो जाता है।

ऐप चलाना

फ़ाइल सहेजें और चलाएँ:

streamlit run streamlit_app.pyसंचालित द्वारा

ऐप में डी-कम्पोज़ की गई इमेज़ है। प्रीव्यू से ऑब्जेक्ट्स हटाने के लिए लेयर्स ऑफ़ करें।

एक इमेज़ अपलोड करें, डी-कम्पोज़ पर क्लिक करें, फिर लेयर्स को ऑन-ऑफ करें। प्रीव्यू तुरंत अपडेट हो जाता है। मनपसंद कम्पोज़िशन मिलने पर परिणाम डाउनलोड करें। यह पूरा वर्कफ़्लो ब्राउज़र में होता है—नोटबुक सेल्स को दोबारा चलाने की ज़रूरत नहीं।

निष्कर्ष

Qwen-Image-Layered इमेज़ एडिटिंग के लिए अलग तरीका अपनाता है: पिक्सेल्स को मास्क करने के बजाय, यह इनपेंटेड बैकग्राउंड के साथ कंटेंट को पूर्ण RGBA लेयर्स में अलग करता है। आपको क्लीनअप के बिना ऑब्जेक्ट आइसोलेशन मिलता है। जटिल सीन में शैडो आर्टिफैक्ट्स के साथ मॉडल संघर्ष करता है, लेकिन ऑब्जेक्ट एक्सट्रैक्शन स्वयं अच्छा काम करता है।

Python वर्कफ़्लो सीधा-सादा है। Replicate का API कॉल करें, लेयर्स की सूची वापस पाएँ, और उन्हें PIL से कम्पोज़िट करें। बैकग्राउंड स्वैप्स और ऑब्जेक्ट रिमूवल कुछ ही पंक्तियों के कोड में हो जाते हैं। Streamlit ऐप उसी लॉजिक को तेज़ इटरेशन के लिए GUI में लपेटता है।

यह अपनी तरह का पहला मॉडल है। Qwen टीम तेज़ी से अपडेट जारी करती है, इसलिए बैकग्राउंड रिकंस्ट्रक्शन में सुधार और भारी शैडो वाली इमेज़ के बेहतर हैंडलिंग की उम्मीद करें। रिसर्च पेपर आर्किटेक्चर को कवर करता है, यदि आप समझना चाहते हैं कि वैरिएबल लेयर डी-कम्पोज़िशन अंदर से कैसे काम करता है।

और ओपन-सोर्स AI मॉडल एक्सप्लोर करने के लिए तैयार हैं? Qwen के पीछे के इकोसिस्टम में महारत हासिल करें—DataCamp पर Hugging Face Fundamentals स्किल ट्रैक करें।