extensions_built_in/diffusion_models/flux2/src/pipeline.py

from typing import List, Optional, Union

import numpy as np
import torch
import PIL.Image
from dataclasses import dataclass
from diffusers.image_processor import VaeImageProcessor
from diffusers.schedulers import FlowMatchEulerDiscreteScheduler
from diffusers.utils import (
    logging,
)
from diffusers.utils.torch_utils import randn_tensor
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.utils import BaseOutput
from .autoencoder import AutoEncoder
from .model import Flux2
from einops import rearrange
from transformers import AutoProcessor, Mistral3ForConditionalGeneration

from .sampling import (
    get_schedule,
    batched_prc_img,
    batched_prc_txt,
    encode_image_refs,
    scatter_ids,
)


@dataclass
class Flux2ImagePipelineOutput(BaseOutput):
    images: Union[List[PIL.Image.Image], np.ndarray]


logger = logging.get_logger(__name__)  # pylint: disable=invalid-name

SYSTEM_MESSAGE = """You are an AI that reasons about image descriptions. You give structured responses focusing on object relationships, object
attribution and actions without speculation."""
OUTPUT_LAYERS_MISTRAL = [10, 20, 30]
OUTPUT_LAYERS_QWEN3 = [9, 18, 27]
MAX_LENGTH = 512


class Flux2Pipeline(DiffusionPipeline):
    model_cpu_offload_seq = "text_encoder->transformer->vae"
    _callback_tensor_inputs = ["latents", "prompt_embeds"]

    def __init__(
        self,
        scheduler: FlowMatchEulerDiscreteScheduler,
        vae: AutoEncoder,
        text_encoder: Mistral3ForConditionalGeneration,
        tokenizer: AutoProcessor,
        transformer: Flux2,
        text_encoder_type: str = "mistral",  # "mistral" or "qwen"
        is_guidance_distilled: bool = False,
    ):
        super().__init__()

        self.register_modules(
            vae=vae,
            text_encoder=text_encoder,
            tokenizer=tokenizer,
            transformer=transformer,
            scheduler=scheduler,
        )
        self.vae_scale_factor = 16  # 8x plus 2x pixel shuffle
        self.num_channels_latents = 128
        self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
        self.default_sample_size = 64
        self.text_encoder_type = text_encoder_type
        self.is_guidance_distilled = is_guidance_distilled

    def format_input(
        self,
        txt: list[str],
    ) -> list[list[dict]]:
        # Remove [IMG] tokens from prompts to avoid Pixtral validation issues
        # when truncation is enabled. The processor counts [IMG] tokens and fails
        # if the count changes after truncation.
        cleaned_txt = [prompt.replace("[IMG]", "") for prompt in txt]

        return [
            [
                {
                    "role": "system",
                    "content": [{"type": "text", "text": SYSTEM_MESSAGE}],
                },
                {"role": "user", "content": [{"type": "text", "text": prompt}]},
            ]
            for prompt in cleaned_txt
        ]

    def _get_mistral_prompt_embeds(
        self,
        prompt: Union[str, List[str]] = None,
        device: Optional[torch.device] = None,
        dtype: Optional[torch.dtype] = None,
        max_sequence_length: int = 512,
    ):
        device = device or self._execution_device
        dtype = dtype or self.text_encoder.dtype

        if not isinstance(prompt, list):
            prompt = [prompt]

        # Format input messages
        messages_batch = self.format_input(txt=prompt)

        # Process all messages at once
        # with image processing a too short max length can throw an error in here.
        try:
            inputs = self.tokenizer.apply_chat_template(
                messages_batch,
                add_generation_prompt=False,
                tokenize=True,
                return_dict=True,
                return_tensors="pt",
                padding="max_length",
                truncation=True,
                max_length=max_sequence_length,
            )
        except ValueError as e:
            print(
                f"Error processing input: {e}, your max length is probably too short, when you have images in the input."
            )
            raise e

        # Move to device
        input_ids = inputs["input_ids"].to(device)
        attention_mask = inputs["attention_mask"].to(device)

        # Forward pass through the model
        output = self.text_encoder(
            input_ids=input_ids,
            attention_mask=attention_mask,
            output_hidden_states=True,
            use_cache=False,
        )

        out = torch.stack(
            [output.hidden_states[k] for k in OUTPUT_LAYERS_MISTRAL], dim=1
        )
        prompt_embeds = rearrange(out, "b c l d -> b l (c d)")

        # they don't return attention mask, so we create it here
        return prompt_embeds, None

    def _get_qwen_prompt_embeds(
        self,
        prompt: Union[str, List[str]] = None,
        device: Optional[torch.device] = None,
        dtype: Optional[torch.dtype] = None,
        max_sequence_length: int = 512,
    ):
        device = device or self._execution_device
        dtype = dtype or self.text_encoder.dtype

        if not isinstance(prompt, list):
            prompt = [prompt]

        all_input_ids = []
        all_attention_masks = []

        for p in prompt:
            messages = [{"role": "user", "content": p}]
            text = self.tokenizer.apply_chat_template(
                messages,
                tokenize=False,
                add_generation_prompt=True,
                enable_thinking=False,
            )

            model_inputs = self.tokenizer(
                text,
                return_tensors="pt",
                padding="max_length",
                truncation=True,
                max_length=max_sequence_length,
            )

            all_input_ids.append(model_inputs["input_ids"])
            all_attention_masks.append(model_inputs["attention_mask"])

        input_ids = torch.cat(all_input_ids, dim=0).to(device)
        attention_mask = torch.cat(all_attention_masks, dim=0).to(device)

        output = self.text_encoder(
            input_ids=input_ids,
            attention_mask=attention_mask,
            output_hidden_states=True,
            use_cache=False,
        )

        out = torch.stack([output.hidden_states[k] for k in OUTPUT_LAYERS_QWEN3], dim=1)
        prompt_embeds = rearrange(out, "b c l d -> b l (c d)")

        # they dont use attention mask
        return prompt_embeds, None

    def encode_prompt(
        self,
        prompt: Union[str, List[str]],
        device: Optional[torch.device] = None,
        num_images_per_prompt: int = 1,
        prompt_embeds: Optional[torch.Tensor] = None,
        prompt_embeds_mask: Optional[torch.Tensor] = None,
        max_sequence_length: int = 512,
    ):
        device = device or self._execution_device

        prompt = [prompt] if isinstance(prompt, str) else prompt
        batch_size = len(prompt) if prompt_embeds is None else prompt_embeds.shape[0]

        if prompt_embeds is None:
            if self.text_encoder_type == "mistral":
                prompt_embeds, prompt_embeds_mask = self._get_mistral_prompt_embeds(
                    prompt, device, max_sequence_length=max_sequence_length
                )
            elif self.text_encoder_type == "qwen":
                prompt_embeds, prompt_embeds_mask = self._get_qwen_prompt_embeds(
                    prompt, device, max_sequence_length=max_sequence_length
                )
            else:
                raise ValueError(
                    f"Unsupported text_encoder_type: {self.text_encoder_type}"
                )

        _, seq_len, _ = prompt_embeds.shape
        prompt_embeds = prompt_embeds.repeat(1, num_images_per_prompt, 1)
        prompt_embeds = prompt_embeds.view(
            batch_size * num_images_per_prompt, seq_len, -1
        )

        return prompt_embeds, prompt_embeds_mask

    def prepare_latents(
        self,
        batch_size,
        num_channels_latents,
        height,
        width,
        dtype,
        device,
        generator,
        latents=None,
    ):
        height = int(height) // self.vae_scale_factor
        width = int(width) // self.vae_scale_factor

        shape = (batch_size, num_channels_latents, height, width)

        if latents is not None:
            return latents.to(device=device, dtype=dtype)

        if isinstance(generator, list) and len(generator) != batch_size:
            raise ValueError(
                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
            )

        latents = randn_tensor(shape, generator=generator, device=device, dtype=dtype)

        return latents

    @property
    def guidance_scale(self):
        return self._guidance_scale

    @property
    def num_timesteps(self):
        return self._num_timesteps

    @property
    def current_timestep(self):
        return self._current_timestep

    @property
    def interrupt(self):
        return self._interrupt

    @torch.no_grad()
    def __call__(
        self,
        prompt: Union[str, List[str]] = None,
        negative_prompt: Optional[Union[str, List[str]]] = None,
        height: Optional[int] = None,
        width: Optional[int] = None,
        num_inference_steps: int = 50,
        guidance_scale: Optional[float] = None,
        num_images_per_prompt: int = 1,
        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
        latents: Optional[torch.Tensor] = None,
        prompt_embeds: Optional[torch.Tensor] = None,
        prompt_embeds_mask: Optional[torch.Tensor] = None,
        negative_prompt_embeds: Optional[torch.Tensor] = None,
        negative_prompt_embeds_mask: Optional[torch.Tensor] = None,
        output_type: Optional[str] = "pil",
        return_dict: bool = True,
        max_sequence_length: int = 512,
        control_img_list: Optional[List[PIL.Image.Image]] = None,
    ):
        height = height or self.default_sample_size * self.vae_scale_factor
        width = width or self.default_sample_size * self.vae_scale_factor
        do_guidance = (
            guidance_scale is not None
            and guidance_scale > 1.0
            and not self.is_guidance_distilled
        )

        self._guidance_scale = guidance_scale
        self._current_timestep = None
        self._interrupt = False

        # 2. Define call parameters
        if prompt is not None and isinstance(prompt, str):
            batch_size = 1
        elif prompt is not None and isinstance(prompt, list):
            batch_size = len(prompt)
        else:
            batch_size = prompt_embeds.shape[0]

        device = self._execution_device

        # 3. Encode the prompt

        prompt_embeds, _ = self.encode_prompt(
            prompt=prompt,
            prompt_embeds=prompt_embeds,
            prompt_embeds_mask=prompt_embeds_mask,
            device=device,
            num_images_per_prompt=num_images_per_prompt,
            max_sequence_length=max_sequence_length,
        )

        txt, txt_ids = batched_prc_txt(prompt_embeds)
        neg_txt, neg_txt_ids = None, None

        if do_guidance:
            negative_prompt_embeds, _ = self.encode_prompt(
                prompt=negative_prompt,
                prompt_embeds=negative_prompt_embeds,
                prompt_embeds_mask=negative_prompt_embeds_mask,
                device=device,
                num_images_per_prompt=num_images_per_prompt,
                max_sequence_length=max_sequence_length,
            )

            neg_txt, neg_txt_ids = batched_prc_txt(negative_prompt_embeds)

        # 4. Prepare latent variables\
        latents = self.prepare_latents(
            batch_size * num_images_per_prompt,
            self.num_channels_latents,
            height,
            width,
            prompt_embeds.dtype,
            device,
            generator,
            latents,
        )

        packed_latents, img_ids = batched_prc_img(latents)

        timesteps = get_schedule(num_inference_steps, packed_latents.shape[1])

        self._num_timesteps = len(timesteps)

        guidance_vec = torch.full(
            (packed_latents.shape[0],),
            guidance_scale,
            device=packed_latents.device,
            dtype=packed_latents.dtype,
        )

        if control_img_list is not None and len(control_img_list) > 0:
            img_cond_seq, img_cond_seq_ids = encode_image_refs(
                self.vae, control_img_list
            )
        else:
            img_cond_seq, img_cond_seq_ids = None, None

        # 6. Denoising loop
        i = 0
        with self.progress_bar(total=num_inference_steps) as progress_bar:
            for t_curr, t_prev in zip(timesteps[:-1], timesteps[1:]):
                if self.interrupt:
                    continue
                t_vec = torch.full(
                    (packed_latents.shape[0],),
                    t_curr,
                    dtype=packed_latents.dtype,
                    device=packed_latents.device,
                )

                self._current_timestep = t_curr
                img_input = packed_latents
                img_input_ids = img_ids

                if img_cond_seq is not None:
                    assert img_cond_seq_ids is not None, (
                        "You need to provide either both or neither of the sequence conditioning"
                    )
                    img_input = torch.cat((img_input, img_cond_seq), dim=1)
                    img_input_ids = torch.cat((img_input_ids, img_cond_seq_ids), dim=1)

                pred = self.transformer(
                    x=img_input,
                    x_ids=img_input_ids,
                    timesteps=t_vec,
                    ctx=txt,
                    ctx_ids=txt_ids,
                    guidance=guidance_vec,
                )

                if do_guidance:
                    pred_uncond = self.transformer(
                        x=img_input,
                        x_ids=img_input_ids,
                        timesteps=t_vec,
                        ctx=neg_txt,
                        ctx_ids=neg_txt_ids,
                        guidance=guidance_vec,
                    )
                    pred = pred_uncond + guidance_scale * (pred - pred_uncond)

                if img_cond_seq is not None:
                    pred = pred[:, : packed_latents.shape[1]]

                packed_latents = packed_latents + (t_prev - t_curr) * pred
                i += 1
                progress_bar.update(1)

        self._current_timestep = None

        # 7. Post-processing
        latents = torch.cat(scatter_ids(packed_latents, img_ids)).squeeze(2)

        if output_type == "latent":
            image = latents
        else:
            latents = latents.to(self.vae.dtype)
            image = self.vae.decode(latents).float()

            image = self.image_processor.postprocess(image, output_type=output_type)

        # Offload all models
        self.maybe_free_model_hooks()

        if not return_dict:
            return (image,)

        return Flux2ImagePipelineOutput(images=image)