FLUX.2 Eğitimi: Gradio ile Kapsül Gardırop Görselleştirici oluşturun

Adım 1: Ortam kurulumu

Önce GitHub’dan en güncel diffusers kütüphanesini ve diğer bağımlılıkları yükleyin.

!pip install -q "git+https://github.com/huggingface/diffusers.git@main" \
               "transformers>=4.44.0" accelerate safetensors bitsandbytes gradio pillow

Ardından 4 bit FLUX.2-dev ağırlıklarını çekebilmek için Hugging Face’e giriş yapın:

from huggingface_hub import login
login() 

İstendiğinde HF Token’ı girin ve modele erişmek için HF’ye giriş yapın. Sonrasında, CUDA’nın mevcut olup olmadığını ve hangi GPU’yu kullandığımızı hızlıca kontrol edin:

import torch, diffusers, bitsandbytes as bnb
print("diffusers:", diffusers.__version__)
print("CUDA available:", torch.cuda.is_available())
!nvidia-smi

nvidia-smi çıktısında GPU’nuzu ve CUDA available: True ifadesini görürseniz hazırsınız.

Adım 2: FLUX.2-dev(4-bit) Modeli

Şimdi diffusers/FLUX.2-dev-bnb-4bit deposundan 4 bit FLUX.2-dev bileşenlerini yüklüyoruz.

from diffusers import Flux2Pipeline, Flux2Transformer2DModel
from transformers import Mistral3ForConditionalGeneration
import torch
bnb_repo = "diffusers/FLUX.2-dev-bnb-4bit"   
torch_dtype = torch.bfloat16
device = "cuda"
print("Loading 4-bit transformer...")
transformer = Flux2Transformer2DModel.from_pretrained(
    bnb_repo,
    subfolder="transformer",
    torch_dtype=torch_dtype,
    device_map="auto",          
)
print("Loading 4-bit text encoder...")
text_encoder = Mistral3ForConditionalGeneration.from_pretrained(
    bnb_repo,
    subfolder="text_encoder",
    torch_dtype=torch_dtype,
    device_map="auto",
)
print("Building Flux2 pipeline...")
pipe = Flux2Pipeline.from_pretrained(
    bnb_repo,
    transformer=transformer,
    text_encoder=text_encoder,
    torch_dtype=torch_dtype,
).to(device)
pipe.set_progress_bar_config(disable=False)
print("Loaded. Example param device:", next(pipe.transformer.parameters()).device)

Bağımlılıklar kurulduktan sonra, diffusers kütüphanesini kullanarak FLUX.2’yi yükleyebilir ve transformers içindeki bir Mistral 3 metin kodlayıcıyla eşleştirebiliriz. Koddaki haliyle:

• Flux2Transformer2DModel: Denoising sürecinden sorumlu, U-Net benzeri çekirdek dönüştürücüdür ve 4 bit kuantize biçimde yüklenir.
• Mistral3ForConditionalGeneration: Bu model metin kodlayıcı olarak kullanılır; metin isteminizi difüzyon süreci için koşullandırma sinyallerine dönüştürür.
• Flux2Pipeline: Bu boru hattı, dönüştürücüyü, metin kodlayıcıyı ve destekleyici bileşenleri görüntü üretimi için tek, çağrılabilir bir arabirimde birleştirir.

device_map="auto" ve torch_dtype=torch.bfloat16 kullanmak, farklı GPU kurulumlarında esnekliği korurken belleği verimli kullanır.

Adım 3: Görsellerin ön işlenmesi

Uygulama, kullanıcıların birden çok gardırop görseli yüklemesine izin verir. Bunun için birkaç yardımcı araca ihtiyacımız var:

• Gradio dosya nesnelerini PIL Görsellerine dönüştürmek
• Koşullandırma için yönetilebilir bir boyuta yeniden ölçeklemek

import gradio as gr
import random, json
from typing import List, Union
from PIL import Image
MAX_REFS = 10
def files_to_pil(files: List[Union[str, dict]]) -> List[Image.Image]:
    images = []
    for f in files:
        path = f.get("name") if isinstance(f, dict) else f
        if not path:
            continue
        img = Image.open(path).convert("RGB")
        images.append(img)
    return images
def preprocess_refs(refs: List[Image.Image], max_size: int = 512) -> List[Image.Image]:
    processed = []
    for img in refs:
        img = img.convert("RGB")
        img.thumbnail((max_size, max_size), Image.LANCZOS)
        processed.append(img)
    return processed

Yukarıdaki kod iki temel yardımcı işlev tanımlar.

• files_to_pil() işlevi, Gradio tarafından döndürülen dosya nesnelerini alır, yollarını çıkarır ve her dosyayı bir RGB PIL.Image olarak açar.
• preprocess_refs() işlevi bu görselleri, en-boy oranlarını koruyarak maksimum 512 × 512 boyutuna yeniden ölçekler; bu da hem hız hem bellek kullanımı için önemlidir.

Ayrıca, koşullandırma kümesini aşırı yüklememek için referans görsel sayısını MAX_REFS = 10 ile sınırlandırıyoruz.

Adım 4: Kıyafet istemi

Tek bir düz metin istemi göndermek yerine, şunları açıklayan yapılandırılmış, JSON benzeri bir istem oluşturdum:

• Stüdyo ortamı
• Özne ve poz
• Referans görsellere bağlı kıyafet parçaları
• Işıklandırma, atmosfer ve kamera bilgileri

def build_outfit_prompt(outfit_indices: List[int], labels: List[str]) -> str:
    item_phrases = [
        f"{labels[idx]} from reference image {idx+1}" for idx in outfit_indices
    ]
    outfit_items_str = ", ".join(item_phrases)
    mistral_prompt = """A professional full-body studio photograph of a high-end fashion editorial shoot, set against a flawless seamless neutral gray backdrop (#f5f5f5) in a controlled studio environment. The scene is bathed in soft, diffused three-point lighting (key, fill, and subtle rim) that eliminates harsh shadows, ensuring even illumination across the subject while preserving dimensionality and texture.
At the center of the frame stands a full-body adult model, exuding quiet confidence in a relaxed yet poised stance—one foot slightly forward, weight balanced, body angled subtly to the right. The model’s expression is natural, with a neutral gaze directed just off-camera, evoking a modern, minimalist lookbook aesthetic.
The outfit—meticulously styled and tailored—is the focal point, captured with ultra-realistic 8K resolution and razor-sharp detail. Fabrics display tactile depth: the weave of knits, the drape of silks, the sheen of leathers, and the crispness of cotton are all rendered with commercial-grade precision. The shallow depth of field (50mm prime lens, f/2.8) keeps the subject in crystalline focus while softly blurring the backdrop, emphasizing the outfit’s textures and proportions.
The composition adheres to classic fashion photography rules: vertical framing, ample headroom, and a slightly dynamic angle (eye-level) that flatters the model’s posture. The color palette is controlled and sophisticated, dominated by the outfit’s hues against the neutral gray, with subtle tonal contrasts to highlight layers and accessories.
Every element—from the studio-quality lighting to the catalog-ready styling—conveys luxury, clarity, and commercial appeal, designed to showcase the outfit as a covetable, high-end ensemble."""
    prompt_dict = {
        "scene": mistral_prompt,
        "subjects": [
            {
                "description": (
                    "The model is styled in an outfit composed of: "
                    + outfit_items_str
                    + ". Each garment should closely match the color, fabric, and key design details of its reference image."
                )
            }
        ]
    }
    return json.dumps(prompt_dict)

build_outfit_prompt() işlevi üç önemli şey yapar:

• İlk olarak, bu belirli kıyafet için seçilen parçaları tanımlayan, "referans görsel 1’den gardırop parçası 1" gibi ifadeleri outfit_indices ve labels kullanarak üretir ve tek bir dize halinde birleştirir.
• İkinci olarak, bu parçaları stüdyo ortamını, ışık kurulumunu, kamera lensini, alan derinliğini vb. tanımlayan doğal dilli bir mistral_prompt içine yerleştirir. 
• Son olarak, her şeyi bir scene ve subjects alanına sahip bir prompt_dict içine sarar ve bu sözlüğü JSON’a serileştirir; böylece boru hattına tek bir istem dizesi olarak aktarılabilir.

Kavramsal olarak, yüklenen her gardırop görselini bir “gardırop parçası i” olarak ele alır ve modelden “gardırop parçası 1, 3 ve 4’ü kullanarak bir kıyafet oluşturmasını” isteriz; her parçanın rengini, kumaşını ve temel tasarım ayrıntılarını koruyarak. 

Not: Bu boru hattında metin kodlayıcı olarak bir Mistral modeli kullandığımız için, uzun stüdyo tanımı istemini (mistral_prompt) Meta prompting yoluyla Mistral ile taslak olarak hazırladım. Bu, biçemi kodlayıcının “beklentileriyle” uyumlu tutar ve metni doğrudan kod içinde ayarlamayı kolaylaştırır.

Adım 5: Gardırop ızgarası üretimi

Demonun kalbi, şunları yapan capsule_fn’dir:

• Yüklenen görselleri ve UI parametrelerini alır
• Her karo için gardırop parçalarının alt kümelerini rastgele seçer
• Ardından, birden çok görsel üretmek için FLUX.2-dev boru hattını çağırır
• Son olarak bunları tek bir ızgarada birleştirir

def make_grid(images: List[Image.Image], rows: int, cols: int) -> Image.Image:
    w, h = images[0].size
    grid = Image.new("RGB", (cols * w, rows * h), (255, 255, 255))
    for idx, img in enumerate(images):
        r, c = divmod(idx, cols)
        grid.paste(img, (c * w, r * h))
    return grid
def capsule_fn(files, rows, cols, height, width, steps, guidance, seed):
    if not files or len(files) < 2:
        return None
    images = files_to_pil(files)
    images = images[:MAX_REFS]
    refs = preprocess_refs(images, max_size=512)
    labels = [f"wardrobe piece {i+1}" for i in range(len(refs))]
    random.seed(int(seed))
    tiles = []
    num_tiles = rows * cols
    for i in range(num_tiles):
        k = min(len(refs), random.randint(2, 3))
        outfit_idxs = random.sample(range(len(refs)), k=k)
        prompt = build_outfit_prompt(outfit_idxs, labels)
        generator = torch.Generator(device=device).manual_seed(int(seed) + i)
        out = pipe(
            prompt=prompt,
            image=refs,   
            height=height,
            width=width,
            num_inference_steps=steps,
            guidance_scale=guidance,
            generator=generator,
        )
        tiles.append(out.images[0])
    grid = make_grid(tiles, rows, cols)
    return grid

Yukarıdaki iki işlev kapsül gardırop demonun çekirdek motorunu oluşturur.

• make_grid() işlevi, satırlar × sütunlar düzeni için yeterince büyük boş bir tuval oluşturur, ardından her üretilen kıyafet görselini doğru konuma yapıştırarak tek bir ızgara görseli elde eder.
• capsule_fn() işlevi, kullanıcının gardırop görsellerini referans olarak hazırlar, karo başına rastgele 2–3 parça seçer, yapılandırılmış bir kıyafet istemi oluşturur ve seçilen çözünürlük, adım, yönlendirme ve tohumla FLUX.2 boru hattını çağırır. Tüm üretilen karoları toplayarak make_grid() işlevine aktarır; böylece kullanıcı karışık eşleşen kıyafetlerden oluşan nihai bir ızgarayı görür.

Adım 6: Gradio UI

Bu adım, kapsül gardırop motorunu Gradio uygulamasına bağlar. Kullanıcı gardırop görsellerini yükler, ızgara ve üretim ayarlarını seçer ve birleşik bir kıyafet ızgarası elde eder.

inputs = [
    gr.File(file_types=["image"], file_count="multiple", label="Wardrobe pieces (2–10 images)"),
    gr.Slider(1, 4, value=2, step=1, label="Grid rows"),
    gr.Slider(1, 4, value=2, step=1, label="Grid cols"),
    gr.Slider(384, 896, value=512, step=64, label="Image height"),
    gr.Slider(256, 640, value=384, step=64, label="Image width"),
    gr.Slider(10, 30, value=16, step=2, label="Diffusion steps"),
    gr.Slider(1.0, 7.0, value=2.5, step=0.5, label="Guidance scale"),
    gr.Number(value=42, precision=0, label="Seed")
]
iface = gr.Interface(
    fn=capsule_fn,
    inputs=inputs,
    outputs=gr.Image(type="pil", label="Capsule wardrobe grid"),
    title="Capsule Wardrobe Visualizer – FLUX.2-dev (4-bit)",
    description="Upload 2–10 product images; mix & match outfits using FLUX.2-dev with multi-image reference.",
)
iface.launch(share=True, debug = True)

Gradio uygulamasını şu şekilde kuruyoruz:

• Girdi listesi, uygulamanın tüm etkileşimli kontrollerini tanımlar. Gardırop parçaları girişi, 2–10 kıyafet veya ürün çekimi için çoklu dosya yüklemesidir; satır ve sütun kaydırıcıları ise ızgara şeklini belirler ve böylece parti başına üretilen kıyafet sayısını ayarlar. 
• Görsel yüksekliği ve genişliği kaydırıcıları, her karonun çözünürlüğünü kontrol eder; daha yüksek değerler daha fazla VRAM ve süre kullanır. 
• Difüzyon adımları kaydırıcısı, modelin kaç denoising adımı çalıştıracağını belirler (16–24 iyi bir varsayılandır); yönlendirme ölçeği ise modelin metin istemini referanslara kıyasla ne kadar güçlü izleyeceğini kontrol eder. 
• gr.Interface çağrısı bu girdileri capsule_fn işlevine bağlar ve tek bir gr.Image çıktısı tanımlar. launch(share=True, debug=True) çağrısı Gradio sunucusunu başlatır, demolar için herkese açık bir paylaşım bağlantısı sunar ve sorunları teşhis etmeye yardımcı olmak için konsolda hata ayıklama günlüğünü etkinleştirir.

Arayüz yayına alındıktan sonra:

• Küçük bir kıyafet seti yükleyin (ör. 2 gömlek, 2 pantolon, 1 ceket, 1 çift ayakkabı).
• 3x3 veya 2x2 bir ızgara, 512x384 çözünürlük, ~20 adım ve 2.5 yönlendirme seçin.
• Submit düğmesine tıklayın ve ızgaranın editoryal tarzda görsellerle dolmasını izleyin.

Flux 2 Örnekleri ve Gözlemler

FLUX.2-dev’in pratikte nasıl davrandığını anlamak için, nihai uygulama ile birkaç küçük deney yaptım. Difüzyon adımlarını ve yönlendirme ölçeğini değiştirdim; ayrıca modelin ne kadar çeşitlilik ürettiğini görmek için aynı giysinin birden fazla görselini ve her benzersiz giysi için bir görsel kullanımını denedim.

• Difüzyon adımları ve yönlendirme çoğunlukla hızı ve keskinliği etkiler, belleği değil. Difüzyon adımlarını 28’den 30’a, yönlendirmeyi 2.5’ten 5.0’a çıkarmak, VRAM kullanımını kabaca aynı tutar; ancak her partiyi biraz yavaşlatırken net kıyafetler üretir. Bununla birlikte, teorik olarak yüksek adım sayıları (ör. 50) ızgaranın görünümünü belirgin şekilde değiştirebilir ve daha yüksek kalitede çıktıyla gecikmeyi artırabilir.
• A100 üzerinde 4 bit oldukça konforlu bir varsayılandır. 4 bit FLUX.2-dev kontrol noktasıyla, ~20–28 adımda 512x384 çözünürlükte 3x3 ızgaralar tek GPU demoları için hızlı ve güvenlidir. H100 erişiminiz varsa ve bunun yerine orijinal (kuantize edilmemiş) kontrol noktasını yükleyebiliyorsanız, sıklıkla benzer gecikmede daha yüksek görüntü kalitesi elde edebilirsiniz. Elbette gerçek sonuçlarınız VRAM ve yığın boyutuna bağlı olarak değişebilir. 

Örnek 1: Aynı giysinin birden fazla görünümüyle varsayılan ayarlar

İlk olarak, aynı kıyafetin farklı açılardan çekilmiş birkaç görselini yükledim; varsayılan difüzyon adımlarını ve orta seviyede yönlendirmeyi korudum. Model, tutarlı stüdyo ışıklandırması ve kumaş detaylarıyla, tek bir kapsül setinin varyasyonları gibi hissettiren kıyafetler üretti.

Örnek 2: Aynı giysinin birden fazla görünümüyle daha yüksek difüzyon adımları

Sonraki adımda aynı referans görselleri koruyup difüzyon adımlarını 28’e çıkardım (ve yönlendirmeyi biraz ayarladım). Izgara biraz daha keskin ve cilalı hale geldi; ancak hâlâ aynı temel giysileri yeniden birleştirmeye odaklandı. Takas, parti başına küçük ama fark edilir bir üretim süresi artışıydı.

Deney 3: Her benzersiz giysi için bir görsel

Son olarak, her farklı giysi için bir ürün çekimi yükledim ve başka bir 3x3 ızgara ürettim. Ortaya çıkan kıyafetler hücreler arasında çok daha çeşitliydi; farklı üst ve altları ilginç şekillerde harmanladı. Biraz tekrar görülse de genel olarak ızgara, aynı tohum ve ayarlarda daha çeşitli kombinasyonlarla gerçek bir kapsül gardıroba daha yakın hissettirdi.

Sonuç

4 bit formundaki FLUX.2-dev, görsel uygulamalar için harika bir modeldir. Bu eğitimde, diffusers ile 4 bit FLUX.2-dev boru hattı kurduk, gardırop parçalarını koşullandırma ipuçları olarak ele alan çoklu görsel referans iş akışı oluşturduk ve her şeyi bir Gradio uygulamasına sardık.

Ortaya çıkan şey, moda e-ticaret araçları için bir prototip görevi görebilecek ya da yalnızca kendi dolabınızı eğlenceli bir şekilde yeniden harmanlamanızı sağlayacak güçlü bir Kapsül Gardırop Görselleştirici. Buradan, aynı boru hattını kıyafet kuralları veya hava durumuna göre kıyafet öneren bir BYD gibi daha geniş aracısal sistemlere bağlayabilir ya da gerçek bir ürün katalogu arka ucuna entegre edebilirsiniz.