#
# Berlisensi di bawah Apache License, Versi 2.0 ("Lisensi");
# Anda mungkin tidak dapat menggunakan file ini kecuali sesuai dengan Lisensi.
# Anda dapat memperoleh salinan Lisensi di
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Kecuali diwajibkan oleh hukum yang berlaku atau disepakati secara tertulis, perangkat lunak
# distribusikan di bawah Lisensi berdasarkan basis "SEBAGAIMANA ADANYA",
# TANPA JAMINAN ATAU SYARAT DALAM BENTUK APAPUN, baik yang dinyatakan maupun yang tersirat.
# Lihat Lisensi untuk bahasa tertentu yang mengatur izin dan
# batasan di bawah Lisensi.
-->

# GLM-Image

## Ikhtisar

GLM-Image adalah model generasi gambar yang mengadopsi arsitektur dekode hybrid autoregressive + diffusion, secara efektif mendorong batas atas fidelitas visual dan detail bergranulitas halus. Dalam kualitas generasi gambar secara umum, model ini sejajar dengan pendekatan berbasis LDM standar industri, sambil menunjukkan keunggulan signifikan dalam skenario generasi gambar yang intensif pengetahuan.

Arsitektur model: desain dekode hybrid autoregressive + diffusion、

+ Generator autoregresif: model dengan 9B parameter yang diinisialisasi dari [GLM-4-9B-0414](https://huggingface.co/zai-org/GLM-4-9B-0414), dengan kosakata yang diperluas untuk mengintegrasikan token visual. Model ini pertama kali menghasilkan enkoding ringkas sekitar 256 token, kemudian diperluas menjadi 1K–4K token, yang sesuai dengan output gambar resolusi tinggi 1K–2K. Anda dapat memeriksa model AR di kelas `GlmImageForConditionalGeneration` dari pustaka `transformers`.
+ Diffusion Decoder: decoder dengan 7B parameter yang didasarkan pada arsitektur DiT single-stream untuk decoding gambar di ruang laten. Dilengkapi dengan modul teks Glyph Encoder, yang secara signifikan meningkatkan akurasi rendering teks di dalam gambar.

Pelatihan pasca-pelatihan dengan pembelajaran penguatan yang terdekopel: model ini memperkenalkan strategi umpan balik yang modular dan bergranularitas halus menggunakan algoritma GRPO, yang secara signifikan meningkatkan kualitas pemahaman semantik dan detail visual.

+ Modul autoregresif: menyediakan sinyal umpan balik frekuensi rendah yang berfokus pada estetika dan keselarasan semantik, meningkatkan kepatuhan terhadap instruksi dan ekspresivitas artistik.
+ Modul decoder: memberikan umpan balik frekuensi tinggi yang menargetkan fidelitas detail dan akurasi teks, menghasilkan tekstur, pencahayaan, dan reproduksi warna yang sangat realistis, serta render teks yang lebih presisi.

GLM-Image mendukung generasi teks-ke-gambar dan gambar-ke-gambar dalam satu model

+ Text-to-image: menghasilkan gambar berdetail tinggi dari deskripsi teks, dengan kinerja yang sangat kuat dalam skenario padat informasi.
+ Image-to-image: mendukung berbagai tugas, termasuk pengeditan gambar, transfer gaya, konsistensi multi-subjek, dan generasi yang mempertahankan identitas untuk orang dan objek.

Pipeline ini disumbangkan oleh [zRzRzRzRzRzRzR](https://github.com/zRzRzRzRzRzRzR). Basis kode dapat ditemukan [di sini](https://huggingface.co/zai-org/GLM-Image).

## Contoh penggunaan

### Generasi Teks ke Gambar

```python
import torch
from diffusers.pipelines.glm_image import GlmImagePipeline

pipe = GlmImagePipeline.from_pretrained("zai-org/GLM-Image",dtype=torch.bfloat16,device_map="cuda")
prompt = "A beautifully designed modern food magazine style dessert recipe illustration, themed around a raspberry mousse cake. The overall layout is clean and bright, divided into four main areas: the top left features a bold black title 'Raspberry Mousse Cake Recipe Guide', with a soft-lit close-up photo of the finished cake on the right, showcasing a light pink cake adorned with fresh raspberries and mint leaves; the bottom left contains an ingredient list section, titled 'Ingredients' in a simple font, listing 'Flour 150g', 'Eggs 3', 'Sugar 120g', 'Raspberry puree 200g', 'Gelatin sheets 10g', 'Whipping cream 300ml', and 'Fresh raspberries', each accompanied by minimalist line icons (like a flour bag, eggs, sugar jar, etc.); the bottom right displays four equally sized step boxes, each containing high-definition macro photos and corresponding instructions, arranged from top to bottom as follows: Step 1 shows a whisk whipping white foam (with the instruction 'Whip egg whites to stiff peaks'), Step 2 shows a red-and-white mixture being folded with a spatula (with the instruction 'Gently fold in the puree and batter'), Step 3 shows pink liquid being poured into a round mold (with the instruction 'Pour into mold and chill for 4 hours'), Step 4 shows the finished cake decorated with raspberries and mint leaves (with the instruction 'Decorate with raspberries and mint'); a light brown information bar runs along the bottom edge, with icons on the left representing 'Preparation time: 30 minutes', 'Cooking time: 20 minutes', and 'Servings: 8'. The overall color scheme is dominated by creamy white and light pink, with a subtle paper texture in the background, featuring compact and orderly text and image layout with clear information hierarchy."
image = pipe(
    prompt=prompt,
    height=32 * 32,
    width=36 * 32,
    num_inference_steps=30,
    guidance_scale=1.5,
    generator=torch.Generator(device="cuda").manual_seed(42),  # or "mps", "xpu", "cpu"
).images[0]

image.save("output_t2i.png")
```

### Generasi Gambar ke Gambar

```python
import torch
from diffusers.pipelines.glm_image import GlmImagePipeline
from PIL import Image

pipe = GlmImagePipeline.from_pretrained("zai-org/GLM-Image",dtype=torch.bfloat16,device_map="cuda")
image_path = "cond.jpg" 
prompt = "Replace the background of the snow forest with an underground station featuring an automatic escalator."
image = Image.open(image_path).convert("RGB")
image = pipe(
    prompt=prompt,
    image=[image], # can input multiple images for multi-image-to-image generation such as [image, image1]
    height=33 * 32,
    width=32 * 32,
    num_inference_steps=30,
    guidance_scale=1.5,
    generator=torch.Generator(device="cuda").manual_seed(42),  # or "mps", "xpu", "cpu"
).images[0]

image.save("output_i2i.png")
```

+ Karena model AR yang digunakan dalam GLM-Image dikonfigurasi dengan `do_sample=True` dan suhu `0.95` secara default, gambar yang dihasilkan dapat bervariasi secara signifikan antar eksekusi. Kami tidak merekomendasikan untuk mengatur do_sample=False, karena hal ini dapat menyebabkan output yang salah atau degeneratif dari model AR.

## GlmImagePipeline[[diffusers.GlmImagePipeline]]

#### diffusers.GlmImagePipeline[[diffusers.GlmImagePipeline]]

```python
diffusers.GlmImagePipeline(tokenizer: ByT5Tokenizer, processor: GlmImageProcessor, text_encoder: T5EncoderModel, vision_language_encoder: GlmImageForConditionalGeneration, vae: AutoencoderKL, transformer: GlmImageTransformer2DModel, scheduler: FlowMatchEulerDiscreteScheduler)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L161)

**Parameter:**

tokenizer (`PreTrainedTokenizer`) : Tokenizer untuk text encoder.

processor (`AutoProcessor`) : Pemroses untuk model AR untuk menangani templat obrolan dan tokenisasi.

text_encoder (`T5EncoderModel`) : Pengkode teks beku untuk embedding glik.

vision_language_encoder (`GlmImageForConditionalGeneration`) : Model AR yang menghasilkan token gambar dari prompt teks.

vae ([AutoencoderKL](/docs/diffusers/v0.43.0/id/api/models/autoencoderkl#diffusers.AutoencoderKL)) : Model Variational Auto-Encoder (VAE) untuk mengodekan dan mendekodekan gambar ke dan dari representasi laten.

transformer ([GlmImageTransformer2DModel](/docs/diffusers/v0.43.0/id/api/models/glm_image_transformer2d#diffusers.GlmImageTransformer2DModel)) : transformer yang dikondisikan teks untuk mendenoise latens gambar yang telah dikodekan (DiT).

scheduler ([SchedulerMixin](/docs/diffusers/v0.43.0/id/api/schedulers/overview#diffusers.SchedulerMixin)) : Penjadwal yang digunakan bersama `transformer` untuk menghilangkan noise pada latens gambar yang telah dikodekan.

Pipeline untuk generasi teks-ke-gambar menggunakan GLM-Image.

Pipeline ini mengintegrasikan model AR (autoregressive) untuk generasi token dan model DiT (diffusion transformer) untuk decoding gambar.

#### __call__[[diffusers.GlmImagePipeline.__call__]]

```python
__call__(prompt: str | list[str] | None = None, image: typing.Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor], NoneType] = None, height: int | None = None, width: int | None = None, num_inference_steps: int = 50, timesteps: list[int] | None = None, sigmas: list[float] | None = None, guidance_scale: float = 1.5, 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, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, prior_token_ids: typing.Optional[torch.Tensor] = None, prior_token_image_ids: list[torch.Tensor] | None = None, source_image_grid_thw: list[torch.Tensor] | None = None, crops_coords_top_left: tuple[int, int] = (0, 0), output_type: str = 'pil', return_dict: bool = True, attention_kwargs: dict[str, typing.Any] | None = None, callback_on_step_end: typing.Union[typing.Callable[[int, int, dict], NoneType], diffusers.callbacks.PipelineCallback, diffusers.callbacks.MultiPipelineCallbacks, NoneType] = None, callback_on_step_end_tensor_inputs: list[str] = ['latents'], max_sequence_length: int = 2048)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L719)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : Prompt atau prompt-prompt untuk mengarahkan generasi gambar. Harus berisi informasi bentuk dalam format 'H W' di mana H dan W adalah dimensi token (d32). Contoh: "A beautiful sunset36 24" menghasilkan gambar 1152x768.

image : Gambar kondisi opsional untuk generasi gambar-ke-gambar.

height (`int`, *opsional*) : Tinggi dalam piksel. Jika tidak diberikan, diturunkan dari informasi bentuk prompt.

width (`int`, *opsional*) : Lebar dalam piksel. Jika tidak diberikan, diturunkan dari informasi bentuk prompt.

num_inference_steps (`int`, *opsional*, defaultnya `50`) : Jumlah langkah denoising untuk DiT.

timesteps (`list[int]`, *opsional*) : Timesteps kustom untuk digunakan dalam proses denoising. Jika tidak didefinisikan, jadwal default scheduler untuk `num_inference_steps` akan digunakan.

sigmas (`list[float]`, *opsional*) : Sigma kustom untuk digunakan dalam proses denoising. Jika tidak didefinisikan, jadwal default scheduler akan digunakan.

guidance_scale (`float`, *opsional*, default `1.5`) : Skala panduan untuk panduan bebas klasifikator.

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

generator (`torch.Generator`, *opsional*) : Generator acak untuk reproduktibilitas.

latents (`torch.Tensor`, *opsional*) : Laten berisik yang telah dibuat sebelumnya untuk digunakan sebagai input untuk generasi gambar.

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang telah dibuat sebelumnya. Jika tidak disediakan, embedding akan dibuat dari `prompt`.

negative_prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks negatif yang telah dibuat sebelumnya. Digunakan ketika classifier-free guidance diaktifkan.

prior_token_ids (`torch.Tensor`, *opsional*) : ID token prior yang telah dibuat sebelumnya dari `generate_prior_tokens`. Jika diberikan, proses pembuatan prior akan dilewati.

prior_token_image_ids (`list[torch.Tensor]`, *opsional*) : ID token gambar yang terkait dengan `prior_token_ids`.

source_image_grid_thw (`list[torch.Tensor]`, *opsional*) : Informasi grid THW per sampel untuk token gambar sumber.

crops_coords_top_left (`tuple[int, int]`, *opsional*, defaultnya `(0, 0)`) : Koordinat kiri-atas dari crop yang digunakan untuk embedding kondisional.

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

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

attention_kwargs (`dict`, *opsional*) : Kamus kwargs yang jika ditentukan akan diteruskan ke `AttentionProcessor`.

callback_on_step_end (`Callable`, `PipelineCallback`, `MultiPipelineCallbacks`, *opsional*) : Fungsi yang dipanggil di akhir setiap langkah denoising.

callback_on_step_end_tensor_inputs (`list[str]`, *opsional*) : Input Tensor yang diteruskan ke `callback_on_step_end`.

max_sequence_length (`int`, *opsional*, defaultnya `2048`) : Panjang maksimum urutan untuk pengkode teks.

**Mengembalikan:** `GlmImagePipelineOutput` atau `tuple`

Gambar yang dihasilkan.

Fungsi yang dipanggil saat memanggil pipeline untuk generasi.

Contoh:
```python
>>> import torch
>>> from diffusers import GlmImagePipeline

>>> pipe = GlmImagePipeline.from_pretrained("zai-org/GLM-Image", torch_dtype=torch.bfloat16)
>>> pipe.to("cuda")

>>> prompt = "A photo of an astronaut riding a horse on mars"
>>> image = pipe(prompt).images[0]
>>> image.save("output.png")
```

#### encode_prompt[[diffusers.GlmImagePipeline.encode_prompt]]

```python
encode_prompt(prompt: str | list[str], do_classifier_free_guidance: bool = True, num_images_per_prompt: int = 1, prompt_embeds: typing.Optional[torch.Tensor] = None, negative_prompt_embeds: typing.Optional[torch.Tensor] = None, device: typing.Optional[torch.device] = None, dtype: typing.Optional[torch.dtype] = None, max_sequence_length: int = 2048)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L545)

**Parameter:**

prompt (`str` atau `list[str]`, *opsional*) : prompt yang akan dienkod

do_classifier_free_guidance (`bool`, *opsional*, defaultnya `True`) : Apakah akan menggunakan classifier free guidance atau tidak.

num_images_per_prompt (`int`, *opsional*, default 1) : Jumlah gambar yang harus dihasilkan per prompt. perangkat torch untuk menempatkan embedding yang dihasilkan

prompt_embeds (`torch.Tensor`, *opsional*) : Embedding teks yang sudah dibuat sebelumnya. Dapat digunakan untuk dengan mudah menyesuaikan input teks, *misalnya* penimbangan prompt. Jika tidak disediakan, embedding teks akan dihasilkan dari argumen input `prompt`.

device : (`torch.device`, *opsional*): perangkat torch

dtype : (`torch.dtype`, *opsional*): torch dtype

max_sequence_length (`int`, defaultnya `2048`) : Panjang maksimum urutan dalam prompt yang dienkod. Dapat diatur ke nilai lain, tetapi dapat menghasilkan kualitas yang lebih buruk.

Mengkodekan prompt menjadi hidden states dari text encoder.

#### generate_prior_tokens[[diffusers.GlmImagePipeline.generate_prior_tokens]]

```python
generate_prior_tokens(prompt: str | list[str], height: int, width: int, image: list[list[PIL.Image.Image]] | None = None, device: typing.Optional[torch.device] = None, generator: typing.Optional[torch.Generator] = None)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L321)

**Parameter:**

prompt : Satu prompt atau daftar prompt

height : Tinggi gambar target

width : Lebar gambar target

image : Input gambar ternormalisasi sebagai List[List[PIL.Image]]. Seharusnya divalidasi terlebih dahulu menggunakan _validate_and_normalize_images() sebelum memanggil metode ini.

device : Perangkat target

generator : Generator acak untuk reproduktibilitas

**Mengembalikan:** `Tuple of`

- prior_token_ids: Tensor dengan bentuk (batch_size, num_tokens) berisi token prior yang di-upsample
- prior_token_image_ids_per_sample: Daftar tensor, satu per sampel. Setiap tensor berisi id token prior yang di-upsample untuk semua gambar kondisi dalam sampel tersebut. None untuk t2i.
- source_image_grid_thw_per_sample: Daftar tensor, satu per sampel. Setiap tensor memiliki bentuk (num_condition_images, 3) dengan info grid yang di-upsample. None untuk t2i.

Generate token sebelumnya untuk model DiT menggunakan model AR.

#### get_glyph_texts[[diffusers.GlmImagePipeline.get_glyph_texts]]

```python
get_glyph_texts(prompt)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/glm_image/pipeline_glm_image.py#L476)

Ekstrak teks glyph dari prompt. Mengembalikan daftar dari daftar untuk pemrosesan batch.

## GlmImagePipelineOutput[[diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput]]

#### diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput[[diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput]]

```python
diffusers.pipelines.glm_image.pipeline_output.GlmImagePipelineOutput(images: list[PIL.Image.Image] | numpy.ndarray)
```

[Sumber](https://github.com/huggingface/diffusers/blob/v0.43.0/src/diffusers/pipelines/glm_image/pipeline_output.py#L10)

**Parameter:**

images (`List[PIL.Image.Image]` atau `np.ndarray`) : Daftar gambar PIL yang telah didenois dengan panjang `batch_size` atau array numpy dengan bentuk `(batch_size, height, width, num_channels)`. Gambar PIL atau array numpy menyajikan gambar-gambar yang telah didenois dari pipeline difusi.

Kelas output untuk pipeline CogView3.