# Bria Fibo 2.0

Fibo 2.0 adalah transformer flow-matching dengan 8,1 miliar parameter dari [Bria](https://huggingface.co/briaai) yang menghasilkan gambar dari caption JSON terstruktur. Encoder teksnya adalah [Qwen3-VL](https://huggingface.co/Qwen/Qwen3-VL-4B-Instruct): sebuah Perceiver memadatkan hidden states Qwen3-VL menjadi gist tokens yang bergabung dengan image tokens dalam satu stream, dan lima blok transformer juga membaca Qwen3-VL secara langsung melalui gated cross-attention.

Ada dua checkpoint:

- [`briaai/Fibo-2.0-dev`](https://huggingface.co/briaai/Fibo-2.0-dev), model lengkap untuk text-to-image dan editing, dengan classifier-free guidance. Nilai default pipeline, 30 langkah dengan guidance 5, ditujukan untuk checkpoint ini.
- [`briaai/Fibo-2.0-edit-turbo`](https://huggingface.co/briaai/Fibo-2.0-edit-turbo), di-distil untuk editing dalam 4 langkah tanpa panduan (`guidance_scale=1.0`).

Dengan panduan diaktifkan, prompt negatif default adalah caption kosong yang digunakan saat pelatihan model: caption terstruktur dengan semua nilai dibiarkan kosong.

## Membuat

Fibo 2.0 dilatih pada caption JSON terstruktur dan tidak akan berfungsi dengan baik pada teks bebas. Sampaikan caption sebagai string JSON:

```py
import json

import torch
from diffusers import BriaFibo2Pipeline

pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-dev", dtype=torch.bfloat16).to("cuda")

caption = {
    "short_description": "A red vintage bicycle leaning against a whitewashed wall on a narrow Mediterranean street.",
    "objects": [
        {
            "description": "A red vintage bicycle with a wicker basket of lemons on its handlebars.",
            "location": "center",
            "relative_size": "large within frame",
        }
    ],
    "background_setting": "A whitewashed wall with a blue wooden door and potted red geraniums.",
    "lighting": {"conditions": "bright morning sun", "direction": "from the right", "shadows": "long and crisp"},
    "aesthetics": {"composition": "centered", "color_scheme": "red, white and blue", "mood_atmosphere": "calm"},
    "photographic_characteristics": {"depth_of_field": "deep", "focus": "sharp on the bicycle", "camera_angle": "eye level"},
    "style_medium": "photograph",
    "context": "A travel photograph.",
    "artistic_style": "realistic",
}
image = pipe(json.dumps(caption)).images[0]
image.save("bicycle.png")
```

Pipeline membersihkan caption dengan cara yang sama seperti saat pelatihan: menghapus nilai kosong serta field `aesthetic_score` dan `preference_score`, yang tidak ada pada caption pelatihan mana pun, dan menserialisasi caption secara ringkas. Dua bentuk pendek juga dilatih dan dipertahankan apa adanya:

```py
# The caption's short description alone, as plain text
image = pipe("A red vintage bicycle leaning against a whitewashed wall on a narrow Mediterranean street.").images[0]

# Exactly a "short_description" and a "text_render" list. The list is kept even when it's empty, to say the image
# has no text
caption = {"short_description": "A bakery storefront at dawn with a painted sign.", "text_render": [{"text": "FRESH BREAD"}]}
image = pipe(json.dumps(caption)).images[0]
```

Untuk mengubah teks bebas menjadi caption terstruktur, lihat model prompt-to-JSON di halaman [Bria Fibo](https://huggingface.co/briaai/FIBO).

## Mengedit

Pipeline yang sama mengedit gambar. Lewatkan gambar sebagai `image` dan instruksi pengeditan sebagai prompt:

```py
import torch
from diffusers import BriaFibo2Pipeline
from diffusers.utils import load_image

pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-dev", dtype=torch.bfloat16).to("cuda")
image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
)
edited = pipe("Make the background a snowy forest", image=image).images[0]
edited.save("pikachu_snow.png")
```

Untuk pengeditan yang lebih cepat, muat checkpoint turbo dan matikan panduan:

```py
import torch
from diffusers import BriaFibo2Pipeline
from diffusers.utils import load_image

pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-edit-turbo", dtype=torch.bfloat16).to("cuda")
image = load_image(
    "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
)
edited = pipe("Make the background a snowy forest", image=image, num_inference_steps=4, guidance_scale=1.0).images[0]
edited.save("pikachu_snow.png")
```

Contoh di bawah ini melanjutkan dari salah satu, dengan `pipe` dan `image` miliknya. Dengan checkpoint turbo, berikan `num_inference_steps=4` dan `guidance_scale=1.0` ke setiap panggilan.

### Prompt pengeditan

Prompt juga dapat berupa objek JSON dengan kunci `"edit_instruction"` dan caption dari hasil, dalam salah satu bentuk yang digunakan untuk melatih Fibo 2.0 dalam melakukan edit. Pipeline mengubahnya menjadi prompt yang digunakan untuk melatih Fibo 2.0 dalam melakukan edit.

Caption lengkap: kunci caption di samping `"edit_instruction"`, sebagaimana ditulis oleh model prompt-to-JSON Bria untuk edit. Pipeline membuang nilai kosong serta field `aesthetic_score` dan `preference_score`, yang telah dihapus dari setiap caption selama pelatihan.

```py
import json

prompt = {
    "short_description": "A crocheted yellow Pikachu doll sitting in a snowy pine forest.",
    "objects": [{"description": "A crocheted yellow Pikachu doll with red cheeks.", "location": "center"}],
    "background_setting": "A snowy pine forest with falling snow.",
    "edit_instruction": "Make the background a snowy forest",
}
edited = pipe(json.dumps(prompt), image=image).images[0]
```

Deskripsi singkat: sebuah string di kunci `"structured_caption"`.

```py
prompt = {
    "structured_caption": "A crocheted yellow Pikachu doll sitting in a snowy pine forest.",
    "edit_instruction": "Make the background a snowy forest",
}
edited = pipe(json.dumps(prompt), image=image).images[0]
```

Deskripsi singkat dan teksnya: tepat satu `"short_description"` dan satu daftar `"text_render"`. Daftar ini tetap dipertahankan meskipun kosong, yang memberi tahu Fibo 2.0 bahwa hasil tidak memiliki teks. Kunci `"structured_caption"` dapat menyimpan format ini, atau juga caption lengkap.

```py
prompt = {
    "short_description": "A crocheted yellow Pikachu doll holding a small wooden sign.",
    "text_render": [{"text": "HELLO"}],
    "edit_instruction": "Give the doll a small wooden sign that reads HELLO",
}
edited = pipe(json.dumps(prompt), image=image).images[0]
```

### Beberapa gambar

Hingga 5 gambar dapat diedit bersama, misalnya untuk menempatkan objek dari satu gambar ke gambar lainnya. Instruksi merujuk pada gambar-gambar tersebut secara berurutan sebagai `<image_1>`, `<image_2>`, dan seterusnya.

```py
cat = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/cat.png")
edited = pipe("Put the cat from <image_2> next to the doll in <image_1>", image=[image, cat]).images[0]
```

### Ukuran output

Kecuali `height` dan `width` diberikan, hasil akan mengambil ukuran yang digunakan Fibo 2.0 saat pelatihan untuk rasio aspek gambar pertama, sekitar satu megapiksel. Satu gambar akan dipotong (cropped) ke ukuran hasil. Beberapa gambar masing-masing dipotong ke ukuran terlatih untuk rasio aspek mereka sendiri.

```py
edited = pipe("Make the background a snowy forest", image=image, width=1424, height=800).images[0]
```

### Edit yang dimasker

`mask` menandai area dari satu gambar yang akan diregenerasi, putih di atas hitam, dengan ukuran gambar tersebut. Fibo 2.0 dilatih pada editan yang gambarnya memiliki area tersebut diaburkan, dan pipeline mengaburkannya dengan cara yang sama sebelum gambar dienkod: abu-abu datar (128, 128, 128), melalui mask yang dibuat biner pada 128.

```py
from PIL import Image, ImageDraw

mask = Image.new("L", image.size, 0)
ImageDraw.Draw(mask).rectangle((image.width // 2, 0, image.width, image.height // 2), fill=255)
edited = pipe("Add a red balloon floating in the sky", image=image, mask=mask).images[0]
```

## Teks dalam gambar

Ketika caption meminta teks, pada entri `text_render`-nya, Fibo 2.0 cenderung merendernya lebih baik jika Qwen3-VL juga melihat setiap teks yang digambar secara terpisah. Pipeline menggambar gambar-gambar ini secara default, sesuai dengan cara pelatihan dilakukan, dan hal ini dapat dimatikan. Untuk caption dengan teks, seperti toko roti di atas:

```py
prompt = json.dumps(caption)
image = pipe(prompt, render_text_images=False).images[0]
```

Pelatihan menunjukkan bahwa Fibo 2.0 menerima gambar-gambar ini untuk beberapa caption dengan teks dan tidak untuk yang lain, sehingga cara kerjanya fleksibel.

- Setiap entri `text_render` yang memiliki `text` akan mendapatkan gambar: teks dalam satu baris, hitam di atas putih, menggunakan font bawaan Pillow dengan ukuran 20. Teks yang panjangnya melebihi 256 karakter akan dipecah menjadi baris-baris sepanjang 256 karakter.
- Karakter yang tidak tersedia pada font digambar menggunakan font pertama dalam `fonts` yang memilikinya. Pelatihan menggunakan Aileron, kemudian DejaVu Sans, yang berada di folder `fonts` dari [`briaai/Fibo-2.0-dev`](https://huggingface.co/briaai/Fibo-2.0-dev). Tanpa `fonts`, karakter seperti itu digambar sesuai dengan font bawaan Pillow, dan pipeline akan memberikan peringatan.
- Pipeline menandai setiap entri dengan field `image_tokens` untuk gambar tersebut, dan Qwen3-VL melihat gambar-gambar setelah gambar-gambar yang akan diedit.
- Sebuah generasi menjalankan langkah-langkah pertamanya, sementara tingkat noise berada di atas `pipe.text_images_max_noise_level` (0.9), pada caption tanpa gambar. Sebuah edit menggunakannya di setiap langkah.
- Caption tanpa teks tidak akan menghasilkan gambar, begitu pula deskripsi singkat, seperti dalam pelatihan.

Untuk menggambar mereka dengan font yang digunakan dalam pelatihan:

```py
from huggingface_hub import hf_hub_download

fonts = [
    hf_hub_download("briaai/Fibo-2.0-dev", name, subfolder="fonts")
    for name in ("Aileron-Regular.otf", "DejaVuSans.ttf")
]
image = pipe(prompt, fonts=fonts).images[0]
```

Untuk menggambar gambar sendiri, berikan sebagai `text_images`, satu per entri `text_render` yang memiliki `text`, secara berurutan, untuk satu prompt. Gambar-gambar ini memiliki prioritas lebih tinggi daripada gambar milik pipeline itu sendiri. Gambar yang digambar dengan cara berbeda dari saat pelatihan berada di luar distribusi.

## Backend perhatian

Transformer berjalan di salah satu [backend perhatian](../../optimization/attention_backends) diffusers, misalnya FlashAttention-3 pada GPU Hopper seperti H100:

```py
pipe.transformer.set_attention_backend("_flash_3_varlen_hub")
```

`_flash_3_hub` juga berfungsi untuk satu prompt, tetapi tidak menerima mask, sehingga tidak dapat menjalankan batch prompt dengan panjang yang berbeda (lihat di bawah).

## Batching

Beberapa prompt dapat dihasilkan dalam satu panggilan. Prompt dengan panjang yang berbeda akan di-*pad*, dan *padding* tersebut akan di-*mask* dari setiap lapisan perhatian, sehingga batch seperti ini memerlukan *backend* perhatian yang menerima *mask*: *backend* bawaan, atau *backend* *varlen* seperti `flash_varlen`. Dalam float32, sebuah batch mereproduksi gambar dari panggilan terpisah; dalam bfloat16, kernel perhatian berbeda antara input yang di-*pad* dan yang tidak, sehingga gambar batch dapat berbeda dari panggilan tunggal dalam detail-detail halus.

## BriaFibo2Pipeline[[diffusers.BriaFibo2Pipeline]]

#### diffusers.BriaFibo2Pipeline[[diffusers.BriaFibo2Pipeline]]

```python
diffusers.BriaFibo2Pipeline(transformer: BriaFibo2Transformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler, vae: AutoencoderKLFlux2, text_encoder: Qwen3VLForConditionalGeneration, processor: Qwen3VLProcessor)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/bria_fibo2/pipeline_bria_fibo2.py#L171)

**Parameter:**

transformer ([BriaFibo2Transformer2DModel](/docs/diffusers/v0.43.0/id/api/models/transformer_bria_fibo2#diffusers.BriaFibo2Transformer2DModel)) : transformer yang melakukan denoising pada latens gambar.

scheduler ([FlowMatchEulerDiscreteScheduler](/docs/diffusers/v0.43.0/id/api/schedulers/flow_match_euler_discrete#diffusers.FlowMatchEulerDiscreteScheduler)) : Scheduler yang digunakan bersama `transformer` untuk menghilangkan noise pada latents.

vae (`AutoencoderKLFlux2`) : Variational auto-encoder yang memetakan gambar ke latents dan sebaliknya.

text_encoder (`Qwen3VLForConditionalGeneration`) : Qwen3-VL. Hidden states-nya mengondisikan transformer.

processor (`Qwen3VLProcessor`) : Mengubah prompt dan gambar yang akan diedit menjadi input Qwen3-VL.

Pipeline untuk generasi teks-ke-gambar dan pengeditan gambar dengan Fibo 2.0.

#### __call__[[diffusers.BriaFibo2Pipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, image: PIL.Image.Image | list[PIL.Image.Image] | None = None, mask: PIL.Image.Image | None = None, text_images: list[PIL.Image.Image] | None = None, render_text_images: bool = True, fonts: list[str] | None = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 30, guidance_scale: float = 5.0, negative_prompt: str | list[str] | None = None, num_images_per_prompt: int = 1, generator: typing.Union[torch.Generator, list[torch.Generator], NoneType] = None, latents: typing.Optional[torch.Tensor] = None, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds_mask: typing.Optional[torch.Tensor] = None, output_type: str = 'pil', return_dict: bool = True, callback_on_step_end: typing.Optional[typing.Callable[[int, int, dict], NoneType]] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'])
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/bria_fibo2/pipeline_bria_fibo2.py#L571)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt untuk memandu generasi gambar, biasanya berupa prompt JSON terstruktur, yang dibersihkan sesuai dengan caption yang dibersihkan selama pelatihan Fibo 2.0: nilai kosong serta field `aesthetic_score` dan `preference_score` dihapus, dan hasilnya diserialisasi secara ringkas. Dengan `image`, ini adalah instruksi edit, atau objek JSON dengan kunci `"edit_instruction"` dan caption dari hasilnya: kunci lainnya, atau kunci `"structured_caption"` yang berisi caption atau deskripsi singkat.

image (`PIL.Image.Image` atau `list[PIL.Image.Image]`, *opsional*) : Gambar yang akan diedit, atau hingga 5 gambar yang akan diedit bersama, yang dapat dirujuk oleh instruksi sebagai `<image_1>`, `<image_2>` dan seterusnya. Tanpa `image`, pipeline menghasilkan gambar dari prompt.

mask (`PIL.Image.Image`, *opsional*) : Bagian dari `image` yang akan diregenerasi, putih di atas hitam, saat mengedit satu gambar. Seperti dalam pelatihan, bagian tersebut dibuat abu-abu sebelum gambar dienkod, melalui maska yang dibuat biner pada nilai 128.

text_images (`list[PIL.Image.Image]`, *opsional*) : Gambar-gambar teks yang diminta oleh caption, satu per `text_render` entri yang memiliki `text`, sesuai urutan: teks dari setiap entri digambar secara terpisah, sebagaimana digambar oleh `render_text_images`. Qwen3-VL melihatnya bersama prompt, masing-masing ditandai dalam entri caption-nya, yang membantu Fibo 2.0 merender teks. Membutuhkan `prompt` sebagai satu caption JSON, dan memiliki prioritas lebih tinggi daripada `render_text_images`. Sebuah generasi menjalankan langkah-langkah awalnya, selama tingkat noise berada di atas `text_images_max_noise_level` (0.9), tanpa menggunakan gambar-gambar tersebut; sebuah edit menggunakannya di setiap langkah.

render_text_images (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggambar `text_images` dari setiap caption, dengan cara yang sama seperti saat pelatihan Fibo 2.0: setiap teks dalam satu baris, hitam di atas putih, menggunakan font bawaan Pillow dengan ukuran 20, dan karakter yang tidak tersedia pada font tersebut diambil dari `fonts` pertama yang memilikinya. Caption tanpa teks, dan prompt tanpa caption JSON, seperti deskripsi singkat, tidak akan mendapatkan gambar, sebagaimana dalam pelatihan.

fonts (`list[str]`, *opsional*) : Jalur font untuk menggambar karakter dari `text_images` yang tidak dimiliki oleh font bawaan Pillow, secara berurutan. Pelatihan menggambar karakter tersebut menggunakan Aileron, kemudian DejaVu Sans, yang terdapat di folder `fonts` dari `briaai/Fibo-2.0-dev`. Tanpa font tersebut, karakter seperti itu akan digambar sesuai dengan cara font bawaan Pillow menggambar karakter.

height (`int`, *opsional*) : Tinggi gambar yang dihasilkan dalam piksel. Harus habis dibagi 16. Bawaan adalah 1024, atau saat mengedit, ke ukuran Fibo 2.0 yang dilatih untuk rasio aspek gambar pertama, sekitar satu megapiksel.

width (`int`, *opsional*) : Lebar gambar yang dihasilkan dalam piksel. Harus habis dibagi 16. Nilai defaultnya sama seperti `height`.

num_inference_steps (`int`, *opsional*, default 30) : Jumlah langkah denoising.

guidance_scale (`float`, *opsional*, default 5.0) : Skala panduan bebas klasifikasi. Nilai di atas 1 menjalankan prompt negatif sebagai langkah kedua di setiap langkah, dan 1.0 menonaktifkan panduan.

negative_prompt (`str` atau `list[str]`, *opsional*) : Prompt untuk mengarahkan model menjauh dari konten tertentu saat guidance aktif. Nilainya secara default adalah caption kosong yang digunakan saat pelatihan Fibo 2.0: caption terstruktur dengan semua nilai kosong.

num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang akan dihasilkan per prompt.

generator (`torch.Generator` atau `list[torch.Generator]`, *opsional*) : Generator yang digunakan untuk mengambil noise awal, untuk generasi deterministik.

latents (`torch.Tensor`, *opsional*) : Kebisingan awal yang telah dibuat sebelumnya dengan bentuk `(batch_size, 32, height // 8, width // 8)`.

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dihitung sebelumnya dari `encode_prompt`, digunakan sebagai pengganti `prompt`.

prompt_embeds_mask (`torch.Tensor`, *opsional*) : Mask yang dikembalikan oleh `encode_prompt` bersama dengan `prompt_embeds`. Diperlukan jika ada padding.

negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dihitung sebelumnya untuk prompt negatif, digunakan sebagai pengganti `negative_prompt`.

negative_prompt_embeds_mask (`torch.Tensor`, *opsional*) : Mask yang dikembalikan oleh `encode_prompt` bersama dengan `negative_prompt_embeds`. Diperlukan jika ada padding.

output_type (`str`, *opsional*, defaultnya `"pil"`) : Format output: `"pil"`, `"np"`, `"pt"` atau `"latent"`.

return_dict (`bool`, *opsional*, defaultnya `True`) : Apakah akan mengembalikan `BriaFibo2PipelineOutput` alih-alih tuple biasa.

callback_on_step_end (`Callable`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising sebagai `callback_on_step_end(self, step, timestep, callback_kwargs)`.

callback_on_step_end_tensor_inputs (`list[str]`, *opsional*, defaultnya `["latents"]`) : Tensor yang diteruskan ke `callback_on_step_end` di `callback_kwargs`.

**Mengembalikan:** `BriaFibo2PipelineOutput` atau `tuple`

gambar yang dihasilkan.

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:
```py
>>> import json

>>> import torch
>>> from diffusers import BriaFibo2Pipeline
>>> from diffusers.utils import load_image

>>> # Fibo 2.0 reads structured JSON captions, serialized compactly the way it was trained
>>> caption = {
...     "short_description": "A red bicycle leaning against a white brick wall on a sunny morning.",
...     "objects": [{"description": "a red city bicycle with a wicker basket", "location": "center"}],
...     "background_setting": "a white brick wall with a green door",
...     "lighting": {"conditions": "bright morning sun", "direction": "from the right"},
...     "style_medium": "photograph",
... }
>>> prompt = json.dumps(caption, separators=(",", ":"), ensure_ascii=False)

>>> # 30 steps with guidance 5, the defaults
>>> pipe = BriaFibo2Pipeline.from_pretrained("briaai/Fibo-2.0-dev", dtype=torch.bfloat16).to("cuda")
>>> image = pipe(prompt).images[0]
>>> image.save("fibo2.png")

>>> # editing: pass the image, and the instruction as the prompt
>>> image = load_image(
...     "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/diffusers/yarn-art-pikachu.png"
... )
>>> edited = pipe("Make the background a snowy forest", image=image).images[0]
>>> edited.save("fibo2_edit.png")
```

#### encode_prompt[[diffusers.BriaFibo2Pipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], image: list[PIL.Image.Image] | None = None, device: typing.Optional[torch.device] = None, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, prompt_embeds_mask: typing.Optional[torch.Tensor] = None, text_images: list[PIL.Image.Image] | list[list[PIL.Image.Image]] | None = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/bria_fibo2/pipeline_bria_fibo2.py#L351)

**Parameter:**

prompt (`str` atau `list[str]`) : Prompt atau prompt-prompt yang akan dienkod. Dengan `image`, setiap prompt adalah instruksi edit, atau objek JSON dengan kunci `"edit_instruction"` dan caption dari hasilnya: kunci lainnya, atau kunci `"structured_caption"` yang berisi caption atau deskripsi singkat. Prompt generasi dienkod sebagaimana adanya: `__call__` terlebih dahulu menempatkan caption JSON dalam bentuk yang digunakan untuk melatih Fibo 2.0.

image (`list[PIL.Image.Image]`, *opsional*) : Gambar-gambar yang akan diedit, sebagaimana dilihat oleh Qwen3-VL. Setiap prompt mengedit semuanya.

device (`torch.device`, *opsional*) : Perangkat untuk menempatkan embeddings.

num_images_per_prompt (`int`, defaultnya 1) : Jumlah gambar yang akan dihasilkan per prompt.

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dihitung sebelumnya dengan bentuk `(batch_size, 6, text_len, 7680)`, digunakan sebagai pengganti `prompt`.

prompt_embeds_mask (`torch.Tensor`, *opsional*) : Mask bool untuk token asli dalam `prompt_embeds`, dengan bentuk `(batch_size, text_len)`.

text_images (`list[PIL.Image.Image]` atau `list[list[PIL.Image.Image]]`, *opsional*) : Gambar dari teks caption, satu per entri `text_render` yang memiliki `text`, sesuai urutan, atau daftar dari mereka per prompt. Setiap entri mendapatkan penanda visual dari gambarnya, dan Qwen3-VL melihat gambar-gambar tersebut setelah gambar-gambar yang akan diedit.

**Mengembalikan:**

Embedding teks, dan mask-nya, atau `None` jika prompt tidak di-pad.