Ana içeriğe geç

Qwen Image 2.1 Eğitimi: Bir Görsel Düzenleyici ve GIF Oluşturucu Yapın

Colab A100 üzerinde Qwen Image 2.1 ile görselleri düzenlemeyi, metin veya çizimlerle değişiklikleri yönlendirmeyi ve seçilen sonuçları GIF olarak dışa aktarmayı öğrenin.
· 12 dk. oku

Yapay Zeka ile Keşfedin

Tek bir görselden GIF oluşturmak oldukça basit. Bir görsel modelinden yeni bir poz istersiniz, işlemi tekrar edersiniz ve çıktıları belirli bir hızda birleştirirsiniz. Pratikte, giriş stratejisi komut kadar önemlidir. Her üretilen kareyi bir sonrakine beslediğimde, görseller zamanla yapaylıklar biriktirdi.

Bu eğitimde, bu deney için daha güvenilir bir yaklaşım kullanan etkileşimli bir düzenleyici oluşturmak üzere Qwen Image 2.1’den yararlanacağız. Her istek orijinal görselden başlar. Kullanıcılar bir değişikliği tarif edebilir, isteğe bağlı olarak ilgili alanı işaretleyebilir ve bir GIF dışa aktarmadan önce sonucu kabul edebilir veya reddedebilir.

Düzenleme için Qwen Image 2.1, çıkarım için ComfyUI, arayüz için Gradio ve dışa aktarma için Pillow kullanacağız. Vurgu; referans seçimi, çözünürlük, örnekleme parametreleri, VAE kod çözme ve net talimatlar gibi sonuçlarımı etkileyen tasarım seçimleri üzerinde.

Sonunda şunları nasıl yapacağınızı bileceksiniz:

  • Google Colab üzerinde bir A100 GPU’da quantize edilmiş bir Qwen Image 2.1 iş akışını çalıştırmak.
  • Bu demoda kullanılan örnekleme ve bellek ayarlarını yapılandırmak.
  • Metin talimatlarını isteğe bağlı bölge açıklamalarıyla birleştirmek.
  • Birden çok düzenlenmiş kareyi kaydederken sabit bir orijinal referansı korumak.
  • İstenmeyen değişiklikleri değerlendirmek ve bir GIF dışa aktarmak.

Not Defteri

Qwen-Image-2.1 Nedir?

Qwen Image 2.1 birleştirilmiş bir görsel üretimi ve düzenleme modelidir.

Görsel üretim bileşeni 7 milyar parametre içerir. Model metinden görsele üretimi, yerel şeffaflığı, birden çok referans görseli ve açıklamalar veya maskelerle yönlendirilen yerel düzenlemeyi destekler. Bu eğitim tek referanslı RGB düzenlemeye odaklanır. 

Model zaten düzenleme yeteneği sağlar. Uygulamamız bunun çevresindeki iş akışını ekler: girdiyi seçmek, adayları gözden geçirmek, kabul edilen kareleri yönetmek ve dışa aktarmak. Yeni bir model eğitmiyor veya bir hareket modülü eklemiyoruz.

Ortaya çıkan GIF bağımsız üretilmiş durağan görselleri oynatır. Poz değişikliklerini ve görsel varyasyonları gösterebilir, ancak zamansal olarak tutarlı video üretimi ile eşdeğer değildir.

Qwen Image 2.1 Nasıl Çalışır?

resmi mimari açıklaması dört ana bileşen tanımlar:

Bileşen

Özellik

Rol

Görsel dönüştürücü

32 katmanlı, 7B parametreli tek akışlı difüzyon dönüştürücü (DiT)

Koşullandırma ve hedef görsel belirteçlerini ortak bir akışta işler

Metin ve görsel kodlayıcı

Qwen3-VL 8B

Talimatları ve referans görselleri birleşik bir temsile kodlar

Görsel otomatik kodlayıcı (VAE)

64 latent kanal, RGBA desteği, 16× mekansal sıkıştırma

Görselleri kompakt latentlere dönüştürür ve üretilen latentleri piksellere çözer

Üretim süreci

Euler ayrık zamanlamalı ve dinamik kaydırmalı akış eşleme

Hedef görsel latentlerini üretilen görsele doğru yinelemeli günceller

Görsel dönüştürücü 7 milyar parametre içerir. Bu sayı metin ve görsel kodlayıcı ile VAE hariçtir. 

VAE’nin 64 kanalı, çıktı olarak 64 renk kanalını değil, latent temsilini ifade eder. 

RGBA çıktı kırmızı, yeşil, mavi ve alfa kanallarını içerir. Uygulama yüklemeleri RGB’ye düzleştirir, dolayısıyla modelin yerel şeffaflık desteğini göstermemektedir.

Dikkat diyagramını okuma

Qwen Image 2.1, renkli hücrelerin dikkate izin verdiği, gri hücrelerin ise engellediği karışık granülerlikte bir dikkat maskesi kullanır.

Qwen-Image-2.1 karışık granülerlikli dikkat mimarisi

Şekil 1: Qwen Image 2.1 karışık granülerlikli dikkat mimarisi (Qwen blog yazısı)

Diyagramı satır satır okuyun: Q sorgu belirteçlerini, K ise onların dikkat edebileceği belirteçleri temsil eder. Dizi; bir sistem öneki, isteğe bağlı bir giriş görseli, bir düzenleme talimatı ve hedef görseli içerir.

Metin nedensel dikkati kullanır, çünkü bir metin belirteci kendisine ve önceki konumlara dikkat edebilir. Aynı görsel blok içindeki belirteçler, iki yönde de birbirlerine dikkat edebilir. 

Bu, Şekil 1’de görülen üçgen metin bölgelerini ve düz görsel blokları üretir.

Maske kuralı bu birleşimi şu şekilde ifade eder:

allowed = (q_idx >= kv_idx) or same_image_block

Bu, not defterine yapıştırılacak ek bir ayar değil, bir belirteç konumu çifti için kavramsal bir kuraldır. Daha önceki konumlara dikkate izin verir ve her görsel blok içinde tümden-tüme dikkate olanak tanır.

Neden bir önek önbelleğe alınabilir?

Sistem öneki, referans görsel ve talimat, daha sonraki hedef görsel bloğuna dikkat edemez. 

Bu nedenle, hedef görsel güncellenirken temsillerinin değişmesine gerek yoktur.

Qwen, denoising’in ilk adımında bunların dikkat anahtarlarını ve değerlerini bir kez hesaplar ve sonraki adımlarda yeniden kullanır. Hedef görsel belirteçleri ise önbelleğe alınmış öneğe ve birbirlerine dikkat ederek her adımda hesaplama gerektirir. 

40 adımda, sabit önek ilk adımdan sonra yeniden kullanılabilir; bu, önemli hedef görsel hesaplaması kaldığından 40× hız artışı anlamına gelmez.

Bu önbellek yeniden kullanımı, bir üretim içindeki denoising adımları arasında gerçekleşir. Modelin önceki kullanıcı isteklerini hatırladığı veya uygulamamızın ayrı gönderilmiş düzenlemeler arasında otomatik olarak aynı önbelleği yeniden kullandığı anlamına gelmez. 

Demo: Qwen Image 2.1 ile Bir Görsel Düzenleyici Oluşturma 

Uygulamayı oluşturmadan önce, model ayarlarını uygulama kararlarından ayıralım. Adım sayısını artırmanın, hasarlı görselleri modele geri beslemeye devam eden bir hattı düzeltmeyeceğini unutmayın.

Ayar

Kullanılan değer

Neden önemli

Referans görsel

Her son uygulama düzenlemesi için orijinal görsel

Üretilen bir kareden diğerine yapaylıkların aktarılmasını önler

Çözünürlük

1024

Bu arka uçta yaklaşık bir megapiksellik bir düzenleme hedefi

Çıkarım adımları

40

Ana deneyler boyunca kullanılan örnekleme bütçesi

Tohum (Seed)

42

Talimatları test ederken örnekleme tohumunu sabit tutar

CFG

1.0

Sağlanan iş akışıyla eşleşir; standart negatif dal rehberliği bu değerde katkıda bulunmaz

Örnekleyici/zamanlayıcı

Euler / simple

Sağlanan örnekleme yapılandırmasını değiştirmeden korur

Denoise

1.0

Bu talimat-düzenleme iş akışıyla eşleşir; geleneksel düşük-denoise img2img tarifi değildir

VAE kod çözme

Nihai yapılandırmada döşemesiz

Geliştirme sırasında nitel bir iyileşme sonrası seçildi

Ağırlıklar

INT8 ConvRot görsel modeli ve metin kodlayıcı; BF16 VAE

Demo için kullanılan bellek dostu arka uç

CPU kodlayıcı/referans önbellek offload

Başlangıçta devre dışı

A100 çalıştırması, bu ek offload ayarlarını etkinleştirmeden sığdı

Bunlar bu proje için işe yarayan ayarlardır, ancak küresel olarak en iyi yapılandırma değildir. Adımlar, CFG, örnekleyiciler veya quantization biçimleri için sistematik bir tarama yapmadık.

Örnekleyici değerleri, düşük VRAM üzerinde bu modeli çalıştırmama olanak sağlayan görsel-düzenleme iş akışından gelir. 

Adım 1: Colab Ortamını Hazırlayın

Kaydedilen çalışma zamanı NVIDIA A100-SXM4-40GB ve 83.5 GiB ana bellek (RAM) kullandı. 

ComfyUI’yi kurmak ve quantize edilmiş ağırlıkları indirmek için alesha-pro kurulum paketini kullandım.

Ortam, modeller, önbellekler ve çıktılar dahil olmak üzere yaklaşık 45 GB boş depolama alanı planlamanız gerektiğini unutmayın. 

Yüksek RAM’li bir çalışma zamanı, yükleme ve offload sırasında pay bırakır.

Önce yolları oluşturun ve GPU’yu kontrol edin:

import sys, os, json, time, uuid, shutil, subprocess, copy, io, threading
from pathlib import Path
from PIL import Image, ImageDraw, ImageFilter, ImageOps
import numpy as np
import requests
import gradio as gr
from IPython.display import display, Image as DisplayImage

ROOT = Path('/content/qwen_gif_demo')
ROOT.mkdir(parents=True, exist_ok=True)
TOOLS = ROOT / 'tools'
COMFY = ROOT / 'ComfyUI'
RUNS = ROOT / 'runs'
RUNS.mkdir(exist_ok=True)
REPO_REV = 'dc0083c0d17581f04ebbca962771e36f82f31af8'
BASE = 'http://127.0.0.1:8188'

def run_cmd(args, **kwargs):
    print('Running:', ' '.join(map(str, args)), flush=True)
    subprocess.run(list(map(str, args)), check=True, **kwargs)

if not shutil.which('nvidia-smi'):
    raise RuntimeError('Select a GPU runtime before continuing.')
print(subprocess.check_output(['nvidia-smi'], text=True))

GPU kontrolü, Colab hâlâ CPU çalışma zamanı kullanıyorsa yürütmeyi durdurur; ayrıca kurulumdan önce ana RAM ve boş disk alanı ayrıntılarını yazdırırız. 

İçe aktarımlar oldukça temel, dosya yolları, JSON iş akışları, arka uç süreçleri, zamanlama ve arka plan izlemeyi yöneten Python standart kitaplıklarını da içerir. 

Pillow ve NumPy görsel işlemede, Requests ComfyUI ile iletişimde, Gradio arayüzde, IPython ise not defterinde görselleri göstermede kullanılır.

Arka ucu arayüzden ayrı kurun

ComfyUI kendi sanal ortamında çalışır. Not defteri çekirdeği yüklemeleri, HTTP isteklerini ve Gradio’yu yönetir.

if not TOOLS.exists():
    run_cmd(['git', 'init', TOOLS])
    run_cmd(['git', '-C', TOOLS, 'remote', 'add', 'origin', 'https://github.com/alesha-pro/tools.git'])
    run_cmd(['git', '-C', TOOLS, 'fetch', '--depth', '1', 'origin', REPO_REV])
    run_cmd(['git', '-C', TOOLS, 'checkout', '--detach', 'FETCH_HEAD'])
assert subprocess.check_output(['git', '-C', str(TOOLS), 'rev-parse', 'HEAD'], text=True).strip() == REPO_REV
PKG = TOOLS / 'qwen-image-2.1'
VERSIONS = json.loads((PKG / 'install/versions.json').read_text())
print('Pinned backend:', VERSIONS)
driver = subprocess.check_output(['nvidia-smi', '--query-gpu=driver_version', '--format=csv,noheader'], text=True).splitlines()[0]
# Conservative selector; the backend CUDA smoke test is authoritative.
TORCH_INDEX = 'https://download.pytorch.org/whl/cu130' if int(driver.split('.')[0]) >= 580 else 'https://download.pytorch.org/whl/cu128'
print('Driver:', driver, '| wheel index:', TORCH_INDEX)
run_cmd([sys.executable, PKG / 'install/setup.py', 'install', '--dir', COMFY, '--torch-index', TORCH_INDEX])
BACKEND_PY = COMFY / '.venv/bin/python'
run_cmd([BACKEND_PY, '-c', "import torch; print(torch.__version__, torch.version.cuda); print(torch.cuda.get_device_name(0)); x=torch.ones(16,device='cuda'); print(x.sum().item())"])
run_cmd([BACKEND_PY, PKG / 'install/download_models.py', '--models-dir', COMFY / 'models'])

Bu kod, sabitlenmiş kaynakları getirir, sürüm yapılandırmasını okur, arka ucu kurar, bir CUDA tensör işlemini test eder ve modelleri indirir.

CUDA wheel seçimi, sürücü sürümünü başlangıç sezgisi olarak kullanır. 

CUDA smoke testi önemlidir; tek başına bir A100 her PyTorch yapısıyla uyumluluğu garanti etmez. Oturumum 580.82.07 sürücüsünü kullandı.

Adım 2: Arka Ucu Başlatın ve Çıkarım Parametrelerini Ayarlayın

Başlatma hücresi 127.0.0.1:8188 üzerinde ComfyUI’yi çalıştırır, hazır olmasını bekler ve mevcut düğüm tanımlarını alır. 

Kod, küçük bir HTTP yardımcı işlevi aracılığıyla onunla iletişim kurar:

def api(path, body=None):
    r = requests.get(BASE + path, timeout=30) if body is None else requests.post(BASE + path, json=body, timeout=30)
    if not r.ok:
        raise RuntimeError(f'{path}: HTTP {r.status_code}: {r.text[:3000]}')
    return r.json()

Bu yardımcı, sunucu tarafı hataları okunabilir istisnalara dönüştürür. Başlatmanın ardından, düğüm şeması şu yolla kullanılabilir:

INFO = api('/object_info')

Başlatma kodu, başka bir süreç başlatmadan önce mevcut bir sunucuyu kontrol eder. Bu kurulumda ayrı bir genel ComfyUI tüneli yoktur.

Şimdi düzenleme için kullanacağımız parametreleri ayarlayın:

CPU_ENCODER = False
CPU_REFERENCE_CACHE = False
TILED_VAE = False
STEPS = 40
SIZE = 1024
SEED = 42

Bu ayarları şöyle yorumlayın:

  • STEPS: Daha fazla örnekleme yinelemesi genelde daha fazla zaman maliyeti demektir. 40 kullandık.
  • SIZE: Düzenleme grafiğinde 1024 çözünürlük, referansa uyum sağlayarak yaklaşık bir megapikseli hedefler. Kare bir çıktı zorlamaz.
  • SEED: Sabit bir tohum, aynı kurulum içinde karşılaştırmaları kolaylaştırır. Kimlik koruma veya farklı komutlar arasında yumuşak geçiş garantisi vermez.
  • TILED_VAE: Döşemesiz kod çözme, yapılandırılmış küçük-döşeme çözme yolunu kullanmadan görseli işler. Daha fazla bellek gerektirebilir. Buna tercihimiz, her yapaylığı döşemenin oluşturduğunu kanıtlayan kontrollü bir kanıttan değil, görsel testten kaynaklandı.
  • CPU offload bayrakları: Bunlar görsel kalitesi değil, bellek yönetimi kontrolleridir. Yalnızca gerektiğinde etkinleştirin ve ortaya çıkan gecikme ile RAM kullanımını ölçün.

Benzer şekilde, CFG 1’de negatif komut, ayarlanacak birincil kontrol değildir. Zayıf bir düzenlemeyi düzeltmek için uzun bir istenmeyen özellikler listesi beklemek yerine boş bırakın.

Adım 3: Komutu ve Referans Görseli Modele Bağlayın

İş akışı oluşturucu bir API grafiği yükler ve isteğe özgü girdilerini değiştirir. Aşağıdaki kod parçası düzenleme yolunu gösterir:

g = json.loads((PKG / 'workflows/api/03-image-edit.json').read_text())
g['4']['inputs'].update(prompt=prompt, resolution=SIZE)
g['6']['inputs'].update(seed=int(seed), steps=int(STEPS))
g['9']['inputs']['image'] = upload_image(image_path)

if CPU_REFERENCE_CACHE:
    g['11']['inputs']['device'] = 'cpu'
if CPU_ENCODER:
    g['2']['inputs']['device'] = 'cpu'

Burada, Düğüm 4 düzenleme talimatını ve çözünürlüğü alır. 

Düğüm 6 örneklemeyi kontrol eder ve düğüm 9 yüklenen referansı okur. 

Diğer iki geçersiz kılma, isteğe bağlı olarak kodlayıcı veya referans önbellek işini ana belleğe doğru taşır.

Çıkarım yardımcısı, ardından grafiği gönderir ve kendi istek kimliğini bekler:

response = api('/prompt', {
    'prompt': g,
    'client_id': uuid.uuid4().hex,
})
result = collect_result(response['prompt_id'], folder)

Burada folder, infer() içinde oluşturulan istek başına çıktı dizinidir. 

Toplayıcı geçmişi yoklar ve eşleşen iş tamamlandığında üretilen PNG’yi indirir.

Ayrıca girişi, grafiği, gönderimi, geçmişi ve metrikleri kaydederiz. Bu, bir çıktı yanlış görünüyorsa gerçek isteği incelemeyi mümkün kılar. 

Zaman aşımı, GPU işini otomatik olarak iptal etmez; yeniden denemeye karar vermeden önce istek kimliğini saklayın.

Adım 4: Orijinal Bir Görsel Hazırlayın

Son uygulama, geri dönebileceği değişmemiş bir referansa her zaman ihtiyaç duyar. Aşağıdaki yükleme yolu, yönlendirme düzeltmesi uygular, şeffaflığı düzleştirir ve görseli modele göndermeden önce kare bir tuvale ekler:

python
from google.colab import files
uploaded = files.upload()
assert len(uploaded) == 1, 'Upload exactly one image.'
with Image.open(io.BytesIO(next(iter(uploaded.values())))) as image:
    rgba = ImageOps.exif_transpose(image).convert('RGBA')
    background = Image.new('RGBA', rgba.size, (250, 240, 230, 255))
    original = Image.alpha_composite(background, rgba).convert('RGB')
    original = ImageOps.pad(original, (SIZE, SIZE), color=(250, 240, 230))

BASE_FRAME = ROOT / f'original-{uuid.uuid4().hex[:8]}.png'
original.save(BASE_FRAME)

Dolgu, konu esnetilmek yerine en-boy oranını korur. Ancak kenarlıklar oluşturabilir. 

Gradio düzenleyicisinde doğrudan yükleme, kendi yükleme işleyicisini izler ve yüklenen boyutları koruyabilir. Bu nedenle uygulama, dışa aktarmadan önce aday boyutlarını da kontrol eder.

Poz düzenlemesi için, istenen hareket için yeterli boşluk bulunan bir görsel seçin ve sınıra göre bir talimat ekleyin.

Adım 5: Düzenlemeleri metin ve çizimlerle yönlendirin

Hedefin belirsiz olabileceği durumlarda, örneğin kalabalık bir sahnede bir kolu ya da nesneyi seçmek gibi, çizim işe yarar. 

Uygulamamızda tamamen isteğe bağlıdır. 

Gradio düzenleyicisi arka planı, çizim katmanlarını ve bileşik görseli sağlar; nihai tasarımımız için önemli kural, orijinali yüklemek ve yalnızca çizim katmanlarını eklemektir:

layers = editor_data.get('layers') or []
has_marks = any(
    np.any(np.asarray(layer.convert('RGBA'))[..., 3] > 0)
    for layer in layers if layer is not None
)
with Image.open(original_path) as image:
    source = image.convert('RGBA').copy()
if has_marks:
    for layer in layers:
        if layer is None:
            continue
        layer = layer.convert('RGBA')
        if layer.size != source.size:
            raise ValueError('Clear the drawing and redraw on the original.')
        source = Image.alpha_composite(source, layer)

Bu, düzenleme geri çağrısı içindeki çekirdek mantıktır. 

Alfa kanal, bir katmanın görünür işaretler içerip içermediğini ortaya çıkarır; örneğin bir daire, dikdörtgen veya kaba bir fırça izi çizmiş olabilirsiniz; bunların tümü görsel rehberlik olarak hizmet edebilir.

Bu işaretler katı bir inpainting maskesi değildir. Modele nereye odaklanacağını söylerler, ancak başka yerlerde değişmeyen pikselleri garanti etmezler.

Bölge açıklamasını yalnızca işaretler olduğunda ekleyebiliriz:

region_instruction = (
    'The red hand-drawn marks identify the target region. '
    'For an outline, edit the enclosed area; for painted strokes, '
    'edit the indicated area. Remove the annotation marks '
    'from the final result. '
) if has_marks else ''

prompt = (
    'Edit <image1>. '
    + region_instruction
    + f'Requested change: {instruction.strip()} '
    + "Preserve unrelated content and the image's framing. "
    + "Keep the subject's identity and visual style consistent "
    + 'unless the requested change explicitly alters them.'
)

Koruma maddesi, modele neyin önemli olduğunu söyler, ancak bu bir garanti değil, talimattır. 

Daha net bir test için, görsele göre tarafı ve bitmiş pozu belirtin, örneğin:

instruction = (
    'Lower the arm on the right side of the image so it extends '
    'diagonally downward. Keep the other arm, face, body position, '
    'camera framing, and background unchanged.'
)

Her istek orijinalden başladığında “biraz daha hareket ettir” demekten kaçının. 

Model, önceki konuşmayı veya son kabul edilen pozu almıyor.

Adım 6: Her adayı orijinalden üretin

Bu projenin ilk sürümü, her çıktıyı bir sonraki isteğe besleyerek bir dizi üretti:

result = edit_frame(manifest['frames'][-1], POSES[pose_index])

image2.gif

Bu davranışı son uygulama için değiştirdim, çünkü tekrarlanan düzenleme, her yeni isteğin önceki model çıktısıyla başlaması nedeniyle yapaylıkların yayılmasına yol açabilir. 

Erken bitki dizimizde, sonraki görseller belirgin şekilde daha gürültülü hale geldi.

Nihai üretim yolu bunun yerine isteğe bağlı olarak açıklanmış orijinal referansı kullanır:

input_path = ROOT / f'edit-input-{uuid.uuid4().hex[:8]}.png'
source.convert('RGB').save(input_path)
result_path = infer(
    'edit',
    prompt,
    seed=int(seed),
    image_path=input_path,
)

Bu, daha önce üretilmiş görseller üzerinden geri besleme yolunu kaldırır. 

Tek tek çıktılardaki yapaylıkları ortadan kaldırmaz ve bağımsız üretilen kareleri kusursuz eşleştirmeye zorlamaz.

Bir kabul edilen görsel bir gül tutuyorsa, bir sonraki istek onu otomatik olarak devralmaz. Pozu değiştirirken gülü korumak için her iki gereksinimi de dahil etmemiz gerekir:

instruction = (
    'Make the character hold a red rose in the hand on the right '
    'side of the image, with that arm extended downward. '
    'Preserve the other hand, face, background, and camera framing.'
)

Bu değiş tokuş, ortak bir referanstan varyasyonlar üretmek için kullanışlıdır. 

Kümülatif düzenlemeler gerektiren görevler için, sıralı bir iş akışı hâlâ uygun olabilir, ancak biriken değişiklikler hakkında farklı beklentilere ihtiyaç duyar.

Adım 7: Kaydetmeden önce adayları gözden geçirin

Uygulama, orijinali, kabul edilen diziyi ve bekleyen sonucu Gradio’nun State işlevini kullanarak ayırır:

original_state = gr.State(initial_path)
frames_state = gr.State(initial_frames)
pending_state = gr.State(None)

Dizi orijinalle başlar ve yalnızca kullanıcı bir adayı kabul ettiğinde büyür. Bekleyen durum, henüz kabul edilmemiş üretilmiş bir dosyayı tutar.

Merkezi kabul işlemi şununla verilir:

updated_frames = list(frames) + [pending_path]

Bu güncellemeden sonra, tam geri çağrı bekleyen adayı ve komutu temizler, düzenleyiciyi orijinale döndürür.

Discard, kabul edilen kareleri değiştirmeden bekleyen sonucu temizler. Reset, diziyi tek bir orijinal kareye döndürür ve geçerli talimatı ve indirme çıktısını temizler. Her iki işlem de modeli yeniden yüklemeyi gerektirmez.

Adım 8: Gradio uygulamasını oluşturun

Nihai arayüz düzenleme, kaydedilen kareler ve dışa aktarmayı üç sekmeye ayırır. 

Gradio uygulaması

Ana bileşen görsel düzenleyicidir:

editor = gr.ImageEditor(
    value=initial_editor,
    type='pil',
    image_mode='RGBA',
    label='Input',
    height=480,
    brush=gr.Brush(
        colors=['#ff0000'],
        color_mode='fixed',
        default_size=8,
    ),
    eraser=gr.Eraser(default_size=20),
    transforms=(),
)

Sabit fırça rengi, açıklama talimatıyla eşleşir. 

Silgi, kullanıcıların kaba bölgeleri düzeltmesine olanak tanırken, devre dışı bırakılan dönüşümler bu etkileşimin dışında kırpma ve döndürmeyi tutar.

Üretim olayı, orijinal durumu geri çağrıya geçirir:

event_options = {
    'concurrency_id': 'edit_workflow',
    'concurrency_limit': 1,
}

generate_button.click(
    fn=generate_edit,
    inputs=[editor, instruction, seed, original_state],
    outputs=[candidate, pending_state, status],
    **event_options,
)

Bu kod parçaları, tamamlanmış Blocks yerleşimi içinde yer alır. 

Paylaşılan eşzamanlılık grubu, bu demoda üretimi ve durum değişikliklerini sıralar. Reset sırasını bekler; bir GPU işi iptal kontrolü değildir.

İşleyiciler ve bileşenler tanımlandıktan sonra uygulamayı çalıştırarak başlatın:

demo.queue(default_concurrency_limit=1).launch(
    share=True,
    debug=True,
)

Gradio paylaşım bağlantısı ön yüzü açığa çıkarır, arka uç ise localhost’ta kalır. Tema ve CSS değişiklikleri sunumu iyileştirir, ancak görsel kalitesini değiştirmez.

Adım 9: Kabul edilen kareleri GIF’e dönüştürün

Dışa aktarıcı, ortak bir palet oluşturduğundan ve son kareden sonra diziyi ters yönde oynatabildiğinden yalnızca kabul edilen kareleri kullanır:

def export_gif(paths, destination, duration_ms=300, ping_pong=True):
    frames = []
    for path in paths:
        with Image.open(path) as image:
            frames.append(image.convert('RGB').copy())
    if len(frames) < 2:
        raise ValueError('Accept at least one edit first.')
    if len({frame.size for frame in frames}) != 1:
        raise ValueError('Frame dimensions must match.')

    atlas = Image.new('RGB', (128 * len(frames), 128))
    for i, frame in enumerate(frames):
        atlas.paste(frame.resize((128, 128)), (128 * i, 0))
    palette = atlas.quantize(colors=256)
    converted = [
        frame.quantize(palette=palette, dither=Image.Dither.NONE)
        for frame in frames
    ]
    if ping_pong:
        converted += converted[-2:0:-1]
    converted[0].save(
        destination,
        save_all=True,
        append_images=converted[1:],
        duration=int(duration_ms),
        loop=0,
        disposal=2,
        optimize=False,
    )
    return str(destination)

Paylaşılan bir palet, palete bağlı olası bir titreme kaynağını azaltır. 

Dithering’i devre dışı bırakmak, dönüştürme sırasında bir desen eklenmesini önler; yine de renk azaltma bantlaşmaya yol açabilir.

Süre milisaniye cinsindendir ve loop=0 ayarı kesintisiz oynatma ister. Dört kare için ping-pong oynatma sırası 0, 1, 2, 3, 2, 1’dir. 

Ters dilim, tekrarlanan uç noktaları hariç tutar. Bu, hareketi enterpolasyon yapmaz; daha akıcı animasyon, yalnızca farklı bir oynatma hızından değil, uygun ara pozlardan yararlanır.

Son Düşünceler

Metin talimatlarını ve isteğe bağlı çizimleri kabul eden, kullanıcıların bireysel sonuçları seçip düzenleyebildiği ve bunları GIF olarak dışa aktaran bir Qwen Image 2.1 düzenleyicisi oluşturduk. 

Temel kalite kararı, üretilmiş çıktıları tekrar tekrar düzenlemek yerine sabit bir orijinal referansı korumaktı.

Çalışan örnekleme yapılandırmasıyla başlayın, istenen değişikliği açıkça ifade edin ve daha fazla ayarı değiştirmeden önce ham adayları inceleyin. 

Bu parçalar oturduğunda, çözünürlük veya kod çözmeyle tek seferde bir değişkeni deneyin. Sonuç; hem yetenekleri hem de sınırlamaları net olan kullanışlı bir görsel düzenleme iş akışıdır.

Qwen Image 2.1 SSS

Bu demoyu Colab A100 üzerinde çalıştırabilir miyim?

Evet. Quantize edilmiş ComfyUI iş akışını 40 GB VRAM’e sahip bir A100 üzerinde çalıştırdık. Son istekler, 1024 çözünürlük ve 40 adımda yaklaşık 19.6 GiB örneklenmiş arka uç GPU belleği kullandı. Bu, yapılandırmamızdan bir ölçümdür; asgari donanım gereksinimi değildir.

Düzenlemeden önce bir bölge çizmem gerekir mi?

Hayır. Yalnızca bir görsel ve bir metin talimatı verebilirsiniz. Çemberler veya kaba dış hatlar, belirli bir nesneyi veya vücut parçasını belirlemeye yardımcı olur. Görsel rehberlik sağlarlar, ancak işaretli bölge dışındaki piksellerin değişmeden kalacağını garanti etmezler.

Neden her düzenleme orijinal görselden başlıyor?

Her üretilen görselin bir sonraki giriş haline geldiği durumlarda, erken deneylerimizde yapaylıklar birikti. Orijinale dönmek, bu yapaylıkların ilerlemesini engeller. Ancak, önceki düzenlemeler otomatik olarak korunmadığından, her komut istenen sonucu bütünüyle tarif etmelidir.

Qwen Image 2.1 GIF&rsquo;i doğrudan üretiyor mu?

Hayır. Qwen tek tek düzenlenmiş görseller üretir ve Pillow, kabul edilen kareleri bir GIF’te birleştirir. Oynatma ayarları zamanlamayı ve yönü kontrol eder, ancak ara hareket oluşturmaz.

Çıktıyı iyileştirmek için hangi ayarları değiştirmeliyim?

Açık bir talimat ve temiz bir referansla başlayın. Yapılandırmamız 40 adım, 42 tohum, CFG 1, Euler örnekleme, simple zamanlayıcı ve denoise 1 kullandı. Bunlar çalışan ayarlardır, kanıtlanmış en iyi değerler değildir. Aynı anda tek bir ayarı değiştirin ve GIF’i yargılamadan önce ham PNG’leri karşılaştırın.

Aashi Dutt

Yazar

Aashi Dutt

ML (Üretken Yapay Zekâ) alanında Google Developers Uzmanıyım, Kaggle 3x Expert unvanına sahibim ve 3+ yıllık teknoloji deneyimiyle Women Techmakers Elçisiyim. 2020'de bir sağlık teknolojileri girişiminin kurucu ortağı oldum ve Georgia Tech'te makine öğrenmesi alanında uzmanlaşarak bilgisayar bilimleri yüksek lisansı yapıyorum.

Konular

İlgili