Qwen-Image-Layered: Hướng dẫn thực hành về phân rã ảnh thành nhiều lớp

Người dùng Photoshop thường mất hàng giờ để thủ công tạo mask đối tượng và tô nền. Qwen-Image-Layered, một mô hình mới từ đội Qwen của Alibaba, làm việc này tự động: đưa vào một ảnh, nó trả về nhiều lớp RGBA với nền trong suốt.

Hướng dẫn này trình bày Qwen-Image-Layered là gì, khác gì so với các công cụ phân đoạn như SAM, và cách chạy bằng Python. Bạn sẽ phân rã một ảnh thành các lớp, sau đó chỉnh sửa và kết hợp lại các lớp đó thành một ảnh ghép mới. Cuối bài, bạn sẽ có một quy trình làm việc hiệu quả để chỉnh sửa ảnh bằng lập trình mà không cần mask thủ công.

Nếu bạn mới xử lý dữ liệu ảnh và độ trong suốt trong mã, hãy xem khóa học Xử lý ảnh với Python của chúng tôi để xây dựng nền tảng vững chắc trước khi bắt đầu. Tôi cũng khuyến nghị đọc hướng dẫn về mô hình tạo ảnh mới nhất của Google, Nano Banana 2.

Qwen-Image-Layered là gì?

Qwen-Image-Layered được xây dựng trên Qwen2.5-VL, một mô hình thị giác - ngôn ngữ từ Alibaba. Nền tảng VL giúp mô hình hiểu ngữ nghĩa trong ảnh: nó có thể phân biệt một sản phẩm với bóng của nó và với bề mặt mà nó đặt lên, không chỉ đơn thuần phát hiện biên. Tương tự như Vision Transformers, nó xử lý ảnh bằng cơ chế attention thay vì các tiếp cận tích chập truyền thống.

Khi suy luận, bạn chỉ định số lớp mong muốn. Yêu cầu 4 lớp, mô hình sẽ phân bổ nội dung ảnh vào 4 đầu ra RGBA. Yêu cầu 8, bạn sẽ có tách lớp mịn hơn. Mô hình quyết định phân bổ dựa trên cấu trúc cảnh.

Ví dụ trực quan

Đây là cách phân rã trông như thế nào trong thông báo của Qwen:

Mô hình nhận một ảnh ghép và tách thành các lớp RGBA riêng lẻ có thể chỉnh sửa với độ trong suốt.

Ảnh quảng bá kẹo được tách thành bốn lớp riêng: nền hiệu ứng tia sáng, người mặc áo cam, văn bản và thương hiệu "Sour Candy", và các viên kẹo riêng lẻ. Mỗi lớp có nền trong suốt (hiển thị bằng hoa văn dạng bàn cờ), sẵn sàng để chỉnh sửa hoặc sắp xếp lại.

Mô hình phân bổ các yếu tố thị giác vào các lớp dựa trên độ sâu và hiểu biết ngữ nghĩa. Đồ họa nền vào lớp 0, chủ thể chính (người) vào lớp 1, lớp văn bản phủ vào lớp 2, và các vật thể tiền cảnh nhỏ (viên kẹo) vào lớp 3. Mỗi thành phần được tách sạch sẽ với độ trong suốt phù hợp.

Qwen-Image-Layered so với Segment Anything Model

Nếu bạn từng làm việc với phân đoạn ảnh, có thể bạn sẽ tự hỏi Qwen-Image-Layered so sánh thế nào với các công cụ hiện có, đặc biệt là Segment Anything Model (SAM).

SAM và các mô hình phân đoạn tương tự xuất ra mask: bản đồ nhị phân cho biết pixel nào thuộc về đối tượng nào. Hữu ích, nhưng mask chỉ cho bạn biết vị trí. Việc trích xuất đối tượng vẫn để lại một lỗ trống trong ảnh gốc.

Ngược lại, Qwen-Image-Layered xuất ra các lớp hoàn chỉnh. Đối tượng tiền cảnh đi kèm độ trong suốt, và lớp nền phía sau nó đã được điền sẵn. Khi bạn xóa hoặc di chuyển một lớp sau này, không cần vá gì thêm.

SAM dùng cách tiếp cận phân biệt, phân tích pixel hiện có để xác định ranh giới đối tượng chính xác. Trái lại, Qwen-Image-Layered sử dụng kiến trúc sinh dựa trên diffusion để tái tạo các vùng bị che khuất hoặc ẩn thông qua khả năng tạo ảnh đã học. 

Trong khi SAM xuất ra mask cho biết cần loại bỏ gì, Qwen-Image-Layered tạo nội dung nền hợp lý để hoàn thiện việc phân rã lớp. Lưu ý, SAM có thể đạt việc lấp nền tương tự khi kết hợp với các mô hình inpainting chuyên dụng, nhưng Qwen-Image-Layered tích hợp khả năng này trọn vẹn trong quy trình phân rã.

Cơ chế điều khiển đầu vào cũng khác: SAM dựa vào tương tác chính xác, yêu cầu bạn nhấp điểm hoặc vẽ hộp giới hạn để chọn mục tiêu cụ thể. Qwen-Image-Layered hoạt động toàn cục hơn, cho phép bạn chỉ cần chỉ định số lớp mong muốn (ví dụ, "tách thành 4 lớp") để tự động tổ chức toàn bộ cấu trúc ảnh.

Cần lưu ý rằng SAM 2 được thiết kế rõ ràng cho video, có khả năng theo dõi đối tượng qua chuỗi khung hình bằng kiến trúc streaming tăng cường bộ nhớ (duy trì ~6 khung gần nhất) với tính nhất quán theo thời gian cao. Qwen-Image-Layered chuyên cho phân rã ảnh tĩnhomposition và hiện chưa hỗ trợ gốc việc theo dõi đối tượng cho biên tập video.

Phân rã ảnh với Qwen-Image-Layered

Giờ đến phần thực hành. Trước khi viết mã, có một cân nhắc thực tế: chạy mô hình ở đâu.

Vì sao dùng API?

Qwen-Image-Layered cần hơn 57GB trọng số mô hình và GPU cao cấp với nhiều VRAM. 

Tôi đã thử chạy cục bộ trên Google Colab với GPU T4, và phiên chạy hết RAM trước khi mô hình tải xong. Dung lượng đĩa tăng lên 90GB trong tổng 112GB của môi trường GPU. Mô hình đơn giản là quá lớn cho các môi trường đám mây miễn phí. 

Các mô hình sinh lớn như Stable Diffusion gặp thách thức lưu trữ tương tự, đó là lý do API lưu trữ đã trở nên phổ biến.

Trong hướng dẫn này, chúng ta sẽ dùng API lưu trữ của Replicate. Mỗi lần phân rã tốn khoảng $0.03, đổi lại bạn có một lần chạy ổn định, có thể tái lập mà không lo giới hạn bộ nhớ hay xung đột phụ thuộc. Nếu bạn chỉ muốn thử mô hình mà không viết mã, Hugging Face Space cung cấp giao diện web miễn phí để bạn tải ảnh lên và tải về các lớp thủ công.

Hugging Face Space cho phép bạn thử mô hình không cần mã, nhưng API mang lại khả năng điều khiển bằng lập trình.

Thiết lập môi trường

Tạo thư mục dự án mới và cài đặt các gói cần thiết:

pip install replicate python-dotenvĐược hỗ trợ bởi

Lấy token API của bạn từ cài đặt tài khoản Replicate và lưu vào tệp .env:

REPLICATE_API_TOKEN=your_token_hereĐược hỗ trợ bởi

Ảnh nguồn

Các thông báo chính thức về mô hình thường trình diễn ví dụ được chọn lọc nơi mô hình hoạt động tốt nhất. Hãy thử với một ảnh đời thực để xem hiệu năng thực tế.

Đây là ảnh chúng ta sẽ phân rã thành các lớp:

Ảnh của Karola G trên Pexels

Bức ảnh hiển thị ba sản phẩm chăm sóc da trên bề mặt màu xanh bạc hà với phông nền tím nhạt: một hộp quà trắng buộc ruy băng đen, một chai serum hồng và một hũ kem nhỏ. Bố cục sạch, vật thể rõ, bóng đổ nhẹ. Một ca thử tốt cho việc tách lớp.

Chạy suy luận

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,
     	    }
	)Được hỗ trợ bởi

Tham số num_layers kiểm soát mức độ mô hình tách nhỏ ảnh. Giá trị có thể từ 2 đến 8. Với 4 lớp, bạn có sự cân bằng hợp lý giữa độ chi tiết và dễ quản lý. Thiết lập seed cố định giúp kết quả có thể tái lập.

API cũng nhận URL trực tiếp, vì vậy bạn có thể bỏ qua xử lý tệp nếu ảnh được lưu trữ ở đâu đó:

output = replicate.run(
	"qwen/qwen-image-layered",
	input={
     	  "image": "https://example.com/photo.jpg",
     	  "num_layers": 4,
     	  "go_fast": True,
     	  "output_format": "png",
	}
)Được hỗ trợ bởi

Lưu các lớp

API trả về danh sách đối tượng FileOutput. Mỗi đối tượng có phương thức .read() để lấy byte ảnh:

for i, layer in enumerate(output):
	with open(f"layer_{i}.png", "wb") as f:
     	  f.write(layer.read())Được hỗ trợ bởi

Các lớp được sắp từ dưới lên trên: chỉ số 0 là nền, và các chỉ số cao hơn xếp chồng phía trên. Mỗi PNG là ảnh RGBA có độ trong suốt, cho phép lớp khác nhìn xuyên qua.

Kết quả như sau:

Mô hình đặt nền (bức tường tím và bề mặt xanh bạc hà) vào lớp 0, hũ kem vào lớp 1, hộp quà vào lớp 2, và chai serum vào lớp 3. Mỗi sản phẩm có viền sạch và độ trong suốt chính xác.

Tuy vậy, hãy nhìn lớp nền, bạn sẽ thấy vệt bóng mờ còn sót lại ở nơi sản phẩm từng ở. Điều này xuất hiện nhất quán trong các thử nghiệm của tôi: mô hình xử lý tách đối tượng tốt, nhưng gặp khó khi tái tạo nền có bóng đổ.

Bóng càng rõ trong ảnh nguồn, các tạo tác này càng dễ thấy. Đây là mô hình đầu tiên thuộc loại này, nên kỳ vọng đội Qwen sẽ tinh chỉnh hơn trong các bản cập nhật sau.

Kết hợp lại các lớp với Qwen-Image-Layered

Phân rã chỉ là nửa chặng đường. Các lớp trở nên hữu ích khi bạn chỉnh sửa và lắp ráp lại thành thứ gì đó mới.

Thay nền

Nhiếp ảnh sản phẩm thường cần cùng một ảnh với nhiều nền khác nhau để A/B testing, chiến dịch theo mùa, hoặc yêu cầu theo nền tảng. Với lớp tách sẵn, việc này chỉ cần vài dòng mã.

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")Được hỗ trợ bởi

Hàm alpha_composite() xử lý hòa trộn RGBA tự động. Nó tôn trọng độ trong suốt ở mỗi lớp, vì vậy đối tượng tiền cảnh nằm tự nhiên trên bất kỳ nền nào bạn cung cấp. 

PIL giúp thao tác ảnh đơn giản, và nếu bạn cần các biến đổi phức tạp hơn, khả năng xử lý ảnh của PyTorch tích hợp tốt với các quy trình PIL.

Kết quả như sau:

Sản phẩm như cũ, môi trường khác, không cần mask thủ công. Bạn có thể thay bằng gradient, texture, hoặc một bức ảnh khác hoàn toàn. Quy trình vẫn như cũ: thay lớp 0, ghép các lớp còn lại.

Xóa hoặc thay đổi vị trí đối tượng

Mẫu thao tác tương tự áp dụng cho các chỉnh sửa khác. Xóa một đối tượng bằng cách bỏ qua lớp của 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)Được hỗ trợ bởi

Để thay đổi vị trí một đối tượng bằng cách dán nó tại tọa độ khác, dùng phương thức paste() với độ lệch x/y bạn chọ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 usualĐược hỗ trợ bởi

Quy trình luôn giống nhau: 

1. Chỉnh sửa các lớp bạn quan tâm: đổi kích thước, đổi màu, xóa, sắp xếp lại.
2. Sau đó ghép tất cả lại từ dưới lên. 

Mỗi thao tác diễn ra trên một lớp tách biệt, nên chỉnh sửa không bị lan sang phần khác.

Xây dựng trình chỉnh sửa Qwen-Image-Layered với Streamlit

Chạy các thao tác này trong notebook phù hợp cho chỉnh sửa đơn lẻ, nhưng vòng phản hồi chậm. Bạn viết mã, chạy ô, kiểm tra kết quả, điều chỉnh, lặp lại. Với công việc lặp lại khi bạn muốn bật/tắt lớp, so sánh các ảnh ghép, và tải kết quả mà không cần chạy lại ô, một GUI gọn nhẹ sẽ hợp lý hơn.

Chúng ta sẽ xây dựng một ứng dụng Streamlit khoảng 160 dòng cho phép bạn tải ảnh lên, phân rã, bật/tắt lớp, và xem xem trước trực tiếp. Tạo tệp tên streamlit_app.py trong thư mục dự án.

Thiết lập Streamlit

Bắt đầu với import và cấu hình cơ bả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")Được hỗ trợ bởi

Session state tồn tại qua các lần chạy lại của Streamlit. Không có nó, các lớp của bạn sẽ biến mất mỗi khi ai đó nhấp nút.

Kiểm tra token API

Trước khi gọi Replicate, đảm bảo token tồn tại:

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()Được hỗ trợ bởi

st.stop() dừng thực thi nếu thiếu token. Không cần render phần còn lại của UI.

Hàm phân rã ảnh có cache

API phân rã tốn $0.03 mỗi lần gọi và mất 30–60 giây. Cache ngăn gọi lặp không cần thiết:

@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Được hỗ trợ bởi

Tiền tố gạch dưới trong _image_bytes báo cho Streamlit không băm tham số đó (băm bytes tốn kém). Vòng lặp retry xử lý các lỗi 502 thỉnh thoảng của Replicate bằng cách đợi 5 giây và thử tối đa 3 lần.

Trực quan hóa và ghép ảnh

Tiếp theo, ta định nghĩa các tiện ích nhỏ để trực quan hóa và ghép:

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))Được hỗ trợ bởi

Hoa văn bàn cờ giúp hiển thị độ trong suốt (chuẩn của các trình chỉnh sửa ảnh). Hàm ghép phản chiếu những gì ta làm trong notebook, nay được điều khiển bởi trạng thái checkbox.

Tải ảnh và thiết lập phân rã

Thanh bên xử lý việc tải ảnh và thiết lập phân rã:

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()Được hỗ trợ bởi

Nút phân rã bị vô hiệu cho đến khi ảnh được tải. Khi thành công, các lớp được lưu trong session state, và tất cả công tắc hiển thị mặc định là True.

Thêm điều khiển lớp ảnh

Hai cột hiển thị điều khiển lớp và xem trước trực tiếp:

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,
            )Được hỗ trợ bởi

Khi bạn bỏ chọn một lớp, Streamlit chạy lại script. Checkbox cập nhật layer_visibility, hàm ghép tính lại xem trước, và UI tự động làm mới.

Chạy ứng dụng

Lưu tệp và chạy:

streamlit run streamlit_app.pyĐược hỗ trợ bởi

Ứng dụng đã phân rã ảnh. Tắt các lớp để loại bỏ đối tượng khỏi phần xem trước.

Tải ảnh lên, nhấp phân rã, rồi bật/tắt các lớp. Phần xem trước cập nhật tức thì. Tải xuống kết quả khi bạn tìm được bố cục ưng ý. Toàn bộ quy trình diễn ra trong trình duyệt mà không cần chạy lại ô notebook.

Kết luận

Qwen-Image-Layered tiếp cận chỉnh sửa ảnh theo cách khác: thay vì che mask pixel, nó tách nội dung thành các lớp RGBA hoàn chỉnh với nền đã inpaint. Bạn có tách đối tượng mà không cần dọn dẹp. Mô hình gặp khó với tạo tác bóng trong cảnh phức tạp, nhưng việc trích xuất đối tượng hoạt động tốt.

Quy trình Python khá thẳng thắn. Gọi API của Replicate, nhận danh sách lớp, và ghép chúng bằng PIL. Thay nền và xóa đối tượng chỉ còn vài dòng mã. Ứng dụng Streamlit bọc logic đó trong GUI để lặp nhanh hơn.

Đây là mô hình đầu tiên thuộc loại này. Đội Qwen cập nhật nhanh, nên kỳ vọng cải thiện việc tái tạo nền và xử lý ảnh có nhiều bóng. Bài báo nghiên cứu trình bày kiến trúc nếu bạn muốn hiểu cách phân rã lớp biến thiên hoạt động bên dưới.

Sẵn sàng khám phá thêm các mô hình AI mã nguồn mở? Làm chủ hệ sinh thái đứng sau Qwen bằng cách tham gia lộ trình kỹ năng Hugging Face Fundamentals trên DataCamp.