Add files using upload-large-folder tool

src/musubi_tuner/dataset/audio_quota_sampler.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import os
+import random
+from typing import Any, Dict, List, Optional
+
+import torch
+
+
+class AudioQuotaIndexSampler(torch.utils.data.Sampler[int]):
+    """Opt-in sampler that enforces a minimum audio-batch quota per accumulation window."""
+
+    def __init__(
+        self,
+        *,
+        audio_indices: List[int],
+        non_audio_indices: List[int],
+        accumulation_steps: int,
+        min_audio_batches_per_accum: int,
+        seed: int,
+    ) -> None:
+        if accumulation_steps < 1:
+            raise ValueError(f"accumulation_steps must be >= 1, got {accumulation_steps}")
+        if min_audio_batches_per_accum < 0:
+            raise ValueError(
+                f"min_audio_batches_per_accum must be >= 0, got {min_audio_batches_per_accum}"
+            )
+        if min_audio_batches_per_accum > accumulation_steps:
+            raise ValueError(
+                "min_audio_batches_per_accum must be <= gradient_accumulation_steps "
+                f"(got {min_audio_batches_per_accum} > {accumulation_steps})"
+            )
+
+        self.audio_indices = list(audio_indices)
+        self.non_audio_indices = list(non_audio_indices)
+        self.accumulation_steps = int(accumulation_steps)
+        self.min_audio_batches_per_accum = int(min_audio_batches_per_accum)
+        self.seed = int(seed)
+        self.epoch = 0
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = int(epoch)
+
+    def update_groups(self, audio_indices: List[int], non_audio_indices: List[int]) -> None:
+        self.audio_indices = list(audio_indices)
+        self.non_audio_indices = list(non_audio_indices)
+
+    def __len__(self) -> int:
+        return len(self.audio_indices) + len(self.non_audio_indices)
+
+    def __iter__(self):
+        rng = random.Random(self.seed + self.epoch)
+        self.epoch += 1
+
+        audio = self.audio_indices.copy()
+        non_audio = self.non_audio_indices.copy()
+        rng.shuffle(audio)
+        rng.shuffle(non_audio)
+
+        ai = 0
+        ni = 0
+        total = len(audio) + len(non_audio)
+        ordered: List[int] = []
+
+        while (ai + ni) < total:
+            slots = min(self.accumulation_steps, total - (ai + ni))
+            audio_now = min(self.min_audio_batches_per_accum, slots, len(audio) - ai)
+
+            required_non_audio = slots - audio_now
+            available_non_audio = len(non_audio) - ni
+            if available_non_audio < required_non_audio:
+                extra_audio_needed = required_non_audio - available_non_audio
+                audio_now = min(slots, audio_now + extra_audio_needed, len(audio) - ai)
+
+            non_audio_now = slots - audio_now
+            window = audio[ai : ai + audio_now] + non_audio[ni : ni + non_audio_now]
+            ai += audio_now
+            ni += non_audio_now
+
+            missing = slots - len(window)
+            if missing > 0 and ai < len(audio):
+                take = min(missing, len(audio) - ai)
+                window.extend(audio[ai : ai + take])
+                ai += take
+                missing -= take
+            if missing > 0 and ni < len(non_audio):
+                take = min(missing, len(non_audio) - ni)
+                window.extend(non_audio[ni : ni + take])
+                ni += take
+
+            rng.shuffle(window)
+            ordered.extend(window)
+
+        return iter(ordered)
+
+
+class AudioProbabilityIndexSampler(torch.utils.data.Sampler[int]):
+    """Opt-in sampler that draws from audio/non-audio pools using a target probability."""
+
+    def __init__(
+        self,
+        *,
+        audio_indices: List[int],
+        non_audio_indices: List[int],
+        audio_batch_probability: float,
+        seed: int,
+    ) -> None:
+        if not (0.0 <= audio_batch_probability <= 1.0):
+            raise ValueError(
+                f"audio_batch_probability must be in [0, 1], got {audio_batch_probability}"
+            )
+
+        self.audio_indices = list(audio_indices)
+        self.non_audio_indices = list(non_audio_indices)
+        self.audio_batch_probability = float(audio_batch_probability)
+        self.seed = int(seed)
+        self.epoch = 0
+
+    def set_epoch(self, epoch: int) -> None:
+        self.epoch = int(epoch)
+
+    def update_groups(self, audio_indices: List[int], non_audio_indices: List[int]) -> None:
+        self.audio_indices = list(audio_indices)
+        self.non_audio_indices = list(non_audio_indices)
+
+    def __len__(self) -> int:
+        return len(self.audio_indices) + len(self.non_audio_indices)
+
+    def __iter__(self):
+        rng = random.Random(self.seed + self.epoch)
+        self.epoch += 1
+
+        audio = self.audio_indices.copy()
+        non_audio = self.non_audio_indices.copy()
+        rng.shuffle(audio)
+        rng.shuffle(non_audio)
+
+        ai = 0
+        ni = 0
+        total = len(audio) + len(non_audio)
+        ordered: List[int] = []
+
+        while len(ordered) < total:
+            audio_remaining = ai < len(audio)
+            non_audio_remaining = ni < len(non_audio)
+
+            if audio_remaining and non_audio_remaining:
+                choose_audio = rng.random() < self.audio_batch_probability
+                if choose_audio:
+                    ordered.append(audio[ai])
+                    ai += 1
+                else:
+                    ordered.append(non_audio[ni])
+                    ni += 1
+            elif audio_remaining:
+                ordered.append(audio[ai])
+                ai += 1
+            elif non_audio_remaining:
+                ordered.append(non_audio[ni])
+                ni += 1
+            else:
+                break
+
+        return iter(ordered)
+
+
+def sync_dataset_group_epoch_without_loading(dataset_group, target_epoch: int, logger=None) -> None:
+    datasets = getattr(dataset_group, "datasets", None)
+    if datasets is None:
+        return
+
+    for dataset in datasets:
+        current = getattr(dataset, "current_epoch", None)
+        shuffle_fn = getattr(dataset, "shuffle_buckets", None)
+        if current is None or not callable(shuffle_fn):
+            continue
+
+        if target_epoch > current:
+            for _ in range(target_epoch - current):
+                dataset.current_epoch += 1
+                shuffle_fn()
+        elif target_epoch < current:
+            if logger is not None:
+                logger.warning(
+                    "epoch is not incremented. current_epoch: %s, epoch: %s",
+                    current,
+                    target_epoch,
+                )
+            dataset.current_epoch = target_epoch
+
+
+def _batch_has_audio_from_batch_manager(
+    batch_manager: Any,
+    local_idx: int,
+    exists_cache: Dict[str, bool],
+) -> bool:
+    bucket_reso, batch_idx = batch_manager.bucket_batch_indices[local_idx]
+    bucket = batch_manager.buckets[bucket_reso]
+    start = batch_idx * batch_manager.batch_size
+    end = min(start + batch_manager.batch_size, len(bucket))
+
+    for item_info in bucket[start:end]:
+        audio_cache_path = getattr(item_info, "audio_latent_cache_path", None)
+        if not audio_cache_path:
+            continue
+
+        exists = exists_cache.get(audio_cache_path)
+        if exists is None:
+            exists = os.path.exists(audio_cache_path)
+            exists_cache[audio_cache_path] = exists
+        if exists:
+            return True
+
+    return False
+
+
+def split_concat_indices_by_audio(dataset_group) -> tuple[List[int], List[int]]:
+    datasets = getattr(dataset_group, "datasets", None)
+    if datasets is None:
+        total = len(dataset_group)
+        return [], list(range(total))
+
+    audio_indices: List[int] = []
+    non_audio_indices: List[int] = []
+    global_offset = 0
+    exists_cache: Dict[str, bool] = {}
+
+    for dataset in datasets:
+        dataset_len = len(dataset)
+        batch_manager = getattr(dataset, "batch_manager", None)
+
+        if batch_manager is None:
+            non_audio_indices.extend(range(global_offset, global_offset + dataset_len))
+            global_offset += dataset_len
+            continue
+
+        for local_idx in range(dataset_len):
+            global_idx = global_offset + local_idx
+            if _batch_has_audio_from_batch_manager(batch_manager, local_idx, exists_cache):
+                audio_indices.append(global_idx)
+            else:
+                non_audio_indices.append(global_idx)
+
+        global_offset += dataset_len
+
+    return audio_indices, non_audio_indices
+
+
+def build_audio_sampler(
+    *,
+    dataset_group,
+    gradient_accumulation_steps: int,
+    min_audio_batches_per_accum: int = 0,
+    audio_batch_probability: Optional[float] = None,
+    seed: int = 0,
+) -> tuple[Optional[torch.utils.data.Sampler[int]], Optional[str], Dict[str, Any]]:
+    """Build an opt-in audio-aware sampler.
+
+    Returns:
+        (sampler, mode, stats)
+        - sampler: None when both controls are disabled
+        - mode: "quota", "probability", or None
+        - stats: includes audio/non-audio counts and effective control values
+    """
+    stats: Dict[str, Any] = {}
+    min_audio_batches_per_accum = int(min_audio_batches_per_accum or 0)
+
+    if audio_batch_probability is not None:
+        audio_batch_probability = float(audio_batch_probability)
+        if not (0.0 <= audio_batch_probability <= 1.0):
+            raise ValueError(f"audio_batch_probability must be in [0, 1], got {audio_batch_probability}")
+
+    if min_audio_batches_per_accum > 0 and audio_batch_probability is not None:
+        raise ValueError(
+            "--min_audio_batches_per_accum and --audio_batch_probability are mutually exclusive. "
+            "Set only one of them."
+        )
+
+    if min_audio_batches_per_accum <= 0 and audio_batch_probability is None:
+        return None, None, stats
+
+    if min_audio_batches_per_accum > 0 and min_audio_batches_per_accum > int(gradient_accumulation_steps):
+        raise ValueError(
+            "min_audio_batches_per_accum must be <= gradient_accumulation_steps "
+            f"(got {min_audio_batches_per_accum} > {gradient_accumulation_steps})"
+        )
+
+    audio_indices, non_audio_indices = split_concat_indices_by_audio(dataset_group)
+    if len(audio_indices) == 0:
+        if min_audio_batches_per_accum > 0:
+            raise ValueError(
+                "--min_audio_batches_per_accum is set, but no audio-bearing batches were found in the training dataset."
+            )
+        raise ValueError("--audio_batch_probability is set, but no audio-bearing batches were found in the training dataset.")
+
+    stats["audio_batches"] = len(audio_indices)
+    stats["non_audio_batches"] = len(non_audio_indices)
+
+    if min_audio_batches_per_accum > 0:
+        sampler = AudioQuotaIndexSampler(
+            audio_indices=audio_indices,
+            non_audio_indices=non_audio_indices,
+            accumulation_steps=int(gradient_accumulation_steps),
+            min_audio_batches_per_accum=min_audio_batches_per_accum,
+            seed=int(seed),
+        )
+        stats["min_audio_batches_per_accum"] = min_audio_batches_per_accum
+        stats["accumulation_steps"] = int(gradient_accumulation_steps)
+        return sampler, "quota", stats
+
+    sampler = AudioProbabilityIndexSampler(
+        audio_indices=audio_indices,
+        non_audio_indices=non_audio_indices,
+        audio_batch_probability=float(audio_batch_probability),
+        seed=int(seed),
+    )
+    stats["audio_batch_probability"] = float(audio_batch_probability)
+    return sampler, "probability", stats

src/musubi_tuner/dataset/config_utils.py

@@ -0,0 +1,703 @@
+import argparse
+from dataclasses import (
+    asdict,
+    dataclass,
+    fields,
+)
+import functools
+import random
+from textwrap import dedent, indent
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from typing import List, Optional, Sequence, Tuple, Union, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from multiprocessing.sharedctypes import Synchronized
+
+SharedEpoch = Optional["Synchronized[int]"]
+
+
+import toml
+import voluptuous
+from voluptuous import Any, ExactSequence, MultipleInvalid, Object, Optional as VOptional, Schema
+
+from musubi_tuner.dataset.image_video_dataset import DatasetGroup, ImageDataset, VideoDataset, AudioDataset
+
+import logging
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+@dataclass
+class BaseDatasetParams:
+    resolution: Tuple[int, int] = (960, 544)
+    enable_bucket: bool = False
+    bucket_no_upscale: bool = False
+    caption_extension: Optional[str] = None
+    batch_size: int = 1
+    num_repeats: int = 1
+    video_loss_weight: Optional[float] = None
+    audio_loss_weight: Optional[float] = None
+    cache_directory: Optional[str] = None
+    reference_cache_directory: Optional[str] = None
+    reference_audio_cache_directory: Optional[str] = None
+    separate_audio_buckets: bool = False
+    cache_only: bool = False
+    debug_dataset: bool = False
+    architecture: str = "no_default"  # short style like "hv" or "wan"
+
+
+@dataclass
+class ImageDatasetParams(BaseDatasetParams):
+    image_directory: Optional[str] = None
+    image_jsonl_file: Optional[str] = None
+    control_directory: Optional[str] = None
+    multiple_target: Optional[bool] = False
+
+    # FramePack dependent parameters
+    fp_latent_window_size: Optional[int] = 9
+    fp_1f_clean_indices: Optional[Sequence[int]] = None
+    fp_1f_target_index: Optional[int] = None
+    fp_1f_no_post: Optional[bool] = False
+
+    no_resize_control: Optional[bool] = False  # if True, control images are not resized to target resolution
+    control_resolution: Optional[Tuple[int, int]] = None  # if set, control images are resized to this resolution
+
+
+@dataclass
+class VideoDatasetParams(BaseDatasetParams):
+    video_directory: Optional[str] = None
+    video_jsonl_file: Optional[str] = None
+    control_directory: Optional[str] = None
+    reference_directory: Optional[str] = None
+    reference_audio_directory: Optional[str] = None
+    target_frames: Sequence[int] = (1,)
+    frame_extraction: Optional[str] = "head"
+    frame_stride: Optional[int] = 1
+    frame_sample: Optional[int] = 1
+    max_frames: Optional[int] = 129
+    source_fps: Optional[float] = None
+    target_fps: Optional[float] = None
+
+    # FramePack dependent parameters
+    fp_latent_window_size: Optional[int] = 9
+
+
+@dataclass
+class AudioDatasetParams(BaseDatasetParams):
+    audio_directory: Optional[str] = None
+    audio_jsonl_file: Optional[str] = None
+    audio_bucket_strategy: str = "pad"  # "pad" (default) or "truncate"
+    audio_bucket_interval: float = 2.0  # bucket step in seconds
+
+
+@dataclass
+class DatasetBlueprint:
+    dataset_type: str  # "image", "video", "audio"
+    params: Union[ImageDatasetParams, VideoDatasetParams, AudioDatasetParams]
+
+
+@dataclass
+class DatasetGroupBlueprint:
+    datasets: Sequence[DatasetBlueprint]
+
+
+@dataclass
+class Blueprint:
+    dataset_group: DatasetGroupBlueprint
+
+
+class ConfigSanitizer:
+    # @curry
+    @staticmethod
+    def __validate_and_convert_twodim(klass, value: Sequence) -> Tuple:
+        Schema(ExactSequence([klass, klass]))(value)
+        return tuple(value)
+
+    # @curry
+    @staticmethod
+    def __validate_and_convert_scalar_or_twodim(klass, value: Union[float, Sequence]) -> Tuple:
+        Schema(Any(klass, ExactSequence([klass, klass])))(value)
+        try:
+            Schema(klass)(value)
+            return (value, value)
+        except:
+            return ConfigSanitizer.__validate_and_convert_twodim(klass, value)
+
+    # datasets schema
+    DATASET_ASCENDABLE_SCHEMA = {
+        "caption_extension": str,
+        "batch_size": int,
+        "num_repeats": int,
+        "resolution": functools.partial(__validate_and_convert_scalar_or_twodim.__func__, int),
+        "enable_bucket": bool,
+        "bucket_no_upscale": bool,
+        "video_loss_weight": float,
+        "audio_loss_weight": float,
+        "cache_directory": str,
+        "reference_cache_directory": str,
+        "reference_audio_cache_directory": str,
+        "separate_audio_buckets": bool,
+        "cache_only": bool,
+    }
+    IMAGE_DATASET_DISTINCT_SCHEMA = {
+        "image_directory": str,
+        "image_jsonl_file": str,
+        "control_directory": str,
+        "multiple_target": bool,
+        "fp_latent_window_size": int,
+        "fp_1f_clean_indices": [int],
+        "fp_1f_target_index": int,
+        "fp_1f_no_post": bool,
+        "no_resize_control": bool,
+        "control_resolution": functools.partial(__validate_and_convert_scalar_or_twodim.__func__, int),
+    }
+    AUDIO_DATASET_DISTINCT_SCHEMA = {
+        "audio_directory": str,
+        "audio_jsonl_file": str,
+        "audio_bucket_strategy": str,
+        "audio_bucket_interval": float,
+    }
+    VIDEO_DATASET_DISTINCT_SCHEMA = {
+        "video_directory": str,
+        "video_jsonl_file": str,
+        "control_directory": str,
+        "reference_directory": str,
+        "reference_audio_directory": str,
+        "target_frames": [int],
+        "frame_extraction": str,
+        "frame_stride": int,
+        "frame_sample": int,
+        "max_frames": int,
+        "source_fps": float,
+        "target_fps": float,
+        "fp_latent_window_size": int,
+    }
+
+    # options handled by argparse but not handled by user config
+    ARGPARSE_SPECIFIC_SCHEMA = {
+        "debug_dataset": bool,
+    }
+
+    def __init__(self) -> None:
+        self.image_dataset_schema = self.__merge_dict(
+            self.DATASET_ASCENDABLE_SCHEMA,
+            self.IMAGE_DATASET_DISTINCT_SCHEMA,
+        )
+        self.audio_dataset_schema = self.__merge_dict(
+            self.DATASET_ASCENDABLE_SCHEMA,
+            self.AUDIO_DATASET_DISTINCT_SCHEMA,
+        )
+        self.video_dataset_schema = self.__merge_dict(
+            self.DATASET_ASCENDABLE_SCHEMA,
+            self.VIDEO_DATASET_DISTINCT_SCHEMA,
+        )
+
+        def validate_flex_dataset(dataset_config: dict):
+            if "audio_directory" in dataset_config or "audio_jsonl_file" in dataset_config:
+                return Schema(self.audio_dataset_schema)(dataset_config)
+            if "video_directory" in dataset_config or "video_jsonl_file" in dataset_config:
+                return Schema(self.video_dataset_schema)(dataset_config)
+            else:
+                return Schema(self.image_dataset_schema)(dataset_config)
+
+        self.dataset_schema = validate_flex_dataset
+
+        self.general_schema = self.__merge_dict(
+            self.DATASET_ASCENDABLE_SCHEMA,
+        )
+        self.user_config_validator = Schema(
+            {
+                "general": self.general_schema,
+                "datasets": [self.dataset_schema],
+                VOptional("validation_datasets"): [self.dataset_schema],
+            }
+        )
+        self.argparse_schema = self.__merge_dict(
+            self.ARGPARSE_SPECIFIC_SCHEMA,
+        )
+        self.argparse_config_validator = Schema(Object(self.argparse_schema), extra=voluptuous.ALLOW_EXTRA)
+
+    def sanitize_user_config(self, user_config: dict) -> dict:
+        try:
+            return self.user_config_validator(user_config)
+        except MultipleInvalid:
+            # TODO: clarify the error message
+            logger.error("Invalid user config / ユーザ設定の形式が正しくないようです")
+            raise
+
+    # NOTE: In nature, argument parser result is not needed to be sanitize
+    #   However this will help us to detect program bug
+    def sanitize_argparse_namespace(self, argparse_namespace: argparse.Namespace) -> argparse.Namespace:
+        try:
+            return self.argparse_config_validator(argparse_namespace)
+        except MultipleInvalid:
+            # XXX: this should be a bug
+            logger.error(
+                "Invalid cmdline parsed arguments. This should be a bug. / コマンドラインのパース結果が正しくないようです。プログラムのバグの可能性が高いです。"
+            )
+            raise
+
+    # NOTE: value would be overwritten by latter dict if there is already the same key
+    @staticmethod
+    def __merge_dict(*dict_list: dict) -> dict:
+        merged = {}
+        for schema in dict_list:
+            # merged |= schema
+            for k, v in schema.items():
+                merged[k] = v
+        return merged
+
+
+class BlueprintGenerator:
+    BLUEPRINT_PARAM_NAME_TO_CONFIG_OPTNAME = {}
+
+    def __init__(self, sanitizer: ConfigSanitizer):
+        self.sanitizer = sanitizer
+
+    # runtime_params is for parameters which is only configurable on runtime, such as tokenizer
+    def generate(self, user_config: dict, argparse_namespace: argparse.Namespace, **runtime_params) -> Blueprint:
+        sanitized_user_config = self.sanitizer.sanitize_user_config(user_config)
+        sanitized_argparse_namespace = self.sanitizer.sanitize_argparse_namespace(argparse_namespace)
+
+        argparse_config = {k: v for k, v in vars(sanitized_argparse_namespace).items() if v is not None}
+        general_config = sanitized_user_config.get("general", {})
+
+        dataset_blueprints = []
+        for dataset_config in sanitized_user_config.get("datasets", []):
+            is_audio_dataset = "audio_directory" in dataset_config or "audio_jsonl_file" in dataset_config
+            is_image_dataset = "image_directory" in dataset_config or "image_jsonl_file" in dataset_config
+            if is_audio_dataset:
+                dataset_params_klass = AudioDatasetParams
+                dataset_type = "audio"
+            elif is_image_dataset:
+                dataset_params_klass = ImageDatasetParams
+                dataset_type = "image"
+            else:
+                dataset_params_klass = VideoDatasetParams
+                dataset_type = "video"
+
+            params = self.generate_params_by_fallbacks(
+                dataset_params_klass, [dataset_config, general_config, argparse_config, runtime_params]
+            )
+            dataset_blueprints.append(DatasetBlueprint(dataset_type, params))
+
+        dataset_group_blueprint = DatasetGroupBlueprint(dataset_blueprints)
+
+        return Blueprint(dataset_group_blueprint)
+
+    @staticmethod
+    def generate_params_by_fallbacks(param_klass, fallbacks: Sequence[dict]):
+        name_map = BlueprintGenerator.BLUEPRINT_PARAM_NAME_TO_CONFIG_OPTNAME
+        search_value = BlueprintGenerator.search_value
+        default_params = asdict(param_klass())
+        param_names = default_params.keys()
+
+        params = {name: search_value(name_map.get(name, name), fallbacks, default_params.get(name)) for name in param_names}
+
+        return param_klass(**params)
+
+    @staticmethod
+    def search_value(key: str, fallbacks: Sequence[dict], default_value=None):
+        for cand in fallbacks:
+            value = cand.get(key)
+            if value is not None:
+                return value
+
+        return default_value
+
+
+# if training is True, it will return a dataset group for training, otherwise for caching
+def generate_dataset_group_by_blueprint(
+    dataset_group_blueprint: DatasetGroupBlueprint,
+    training: bool = False,
+    num_timestep_buckets: Optional[int] = None,
+    shared_epoch: SharedEpoch = None,
+) -> DatasetGroup:
+    datasets: List[Union[ImageDataset, VideoDataset, AudioDataset]] = []
+
+    for dataset_blueprint in dataset_group_blueprint.datasets:
+        if dataset_blueprint.dataset_type == "audio":
+            dataset_klass = AudioDataset
+        elif dataset_blueprint.dataset_type == "image":
+            dataset_klass = ImageDataset
+        else:
+            dataset_klass = VideoDataset
+
+        dataset = dataset_klass(**asdict(dataset_blueprint.params))
+        datasets.append(dataset)
+
+    # assertion
+    cache_directories = [dataset.cache_directory for dataset in datasets]
+    num_of_unique_cache_directories = len(set(cache_directories))
+    if num_of_unique_cache_directories != len(cache_directories):
+        raise ValueError(
+            "cache directory should be unique for each dataset (note that cache directory is image/video directory if not specified)"
+            + " / cache directory は各データセットごとに異なる必要があります（指定されていない場合はimage/video directoryが使われるので注意）"
+        )
+
+    # print info
+    info = ""
+    for i, dataset in enumerate(datasets):
+        is_image_dataset = isinstance(dataset, ImageDataset)
+        is_audio_dataset = isinstance(dataset, AudioDataset)
+        info += dedent(
+            f"""\
+      [Dataset {i}]
+        dataset_type: {"audio" if is_audio_dataset else "image" if is_image_dataset else "video"}
+        resolution: {dataset.resolution}
+        batch_size: {dataset.batch_size}
+        num_repeats: {dataset.num_repeats}
+        video_loss_weight: {getattr(dataset, "video_loss_weight", None)}
+        audio_loss_weight: {getattr(dataset, "audio_loss_weight", None)}
+        caption_extension: "{dataset.caption_extension}"
+        enable_bucket: {dataset.enable_bucket}
+        bucket_no_upscale: {dataset.bucket_no_upscale}
+        separate_audio_buckets: {getattr(dataset, "separate_audio_buckets", False)}
+        cache_only: {getattr(dataset, "cache_only", False)}
+        cache_directory: "{dataset.cache_directory}"
+        debug_dataset: {dataset.debug_dataset}
+    """
+        )
+
+        if is_audio_dataset:
+            info += indent(
+                dedent(
+                    f"""\
+        audio_directory: "{dataset.audio_directory}"
+        audio_jsonl_file: "{dataset.audio_jsonl_file}"
+        audio_bucket_strategy: {getattr(dataset, "audio_bucket_strategy", "pad")}
+        audio_bucket_interval: {getattr(dataset, "audio_bucket_interval", 2.0)}
+    \n"""
+                ),
+                "    ",
+            )
+        elif is_image_dataset:
+            info += indent(
+                dedent(
+                    f"""\
+        image_directory: "{dataset.image_directory}"
+        image_jsonl_file: "{dataset.image_jsonl_file}"
+        control_directory: "{dataset.control_directory}"
+        multiple_target: {dataset.multiple_target}
+        fp_latent_window_size: {dataset.fp_latent_window_size}
+        fp_1f_clean_indices: {dataset.fp_1f_clean_indices}
+        fp_1f_target_index: {dataset.fp_1f_target_index}
+        fp_1f_no_post: {dataset.fp_1f_no_post}
+        no_resize_control: {dataset.no_resize_control}
+        control_resolution: {dataset.control_resolution}
+    \n"""
+                ),
+                "    ",
+            )
+        else:
+            info += indent(
+                dedent(
+                    f"""\
+        video_directory: "{dataset.video_directory}"
+        video_jsonl_file: "{dataset.video_jsonl_file}"
+        control_directory: "{dataset.control_directory}"
+        reference_directory: "{getattr(dataset, 'reference_directory', None)}"
+        reference_audio_directory: "{getattr(dataset, 'reference_audio_directory', None)}"
+        reference_audio_cache_directory: "{getattr(dataset, 'reference_audio_cache_directory', None)}"
+        target_frames: {dataset.target_frames}
+        frame_extraction: {dataset.frame_extraction}
+        frame_stride: {dataset.frame_stride}
+        frame_sample: {dataset.frame_sample}
+        max_frames: {dataset.max_frames}
+        source_fps: {dataset.source_fps}
+        target_fps: {getattr(dataset, "target_fps", None)}
+        fp_latent_window_size: {dataset.fp_latent_window_size}
+    \n"""
+                ),
+                "    ",
+            )
+    logger.info(f"{info}")
+
+    # make buckets first because it determines the length of dataset
+    # and set the same seed for all datasets
+    seed = random.randint(0, 2**31)  # actual seed is seed + epoch_no
+    for i, dataset in enumerate(datasets):
+        # logger.info(f"[Dataset {i}]")
+        dataset.set_seed(seed, shared_epoch)
+        if training:
+            dataset.prepare_for_training(num_timestep_buckets=num_timestep_buckets)
+
+    return DatasetGroup(datasets)
+
+
+def _manifest_params_with_cache_only(dataset_type: str, params: dict) -> dict:
+    params = dict(params)
+
+    if not params.get("cache_directory"):
+        if dataset_type == "audio":
+            params["cache_directory"] = params.get("audio_directory")
+        elif dataset_type == "image":
+            params["cache_directory"] = params.get("image_directory")
+        else:
+            params["cache_directory"] = params.get("video_directory")
+
+    if not params.get("cache_directory"):
+        raise ValueError(
+            f"cache_directory is required to create a cache-only manifest for {dataset_type} datasets. "
+            "Set cache_directory in dataset config."
+        )
+
+    params["cache_only"] = True
+
+    # Strip source references to guarantee source-free training from manifest.
+    if dataset_type == "audio":
+        params["audio_directory"] = None
+        params["audio_jsonl_file"] = None
+    elif dataset_type == "image":
+        params["image_directory"] = None
+        params["image_jsonl_file"] = None
+        params["control_directory"] = None
+        params["multiple_target"] = False
+    else:
+        params["video_directory"] = None
+        params["video_jsonl_file"] = None
+        params["control_directory"] = None
+        params["reference_directory"] = None
+        params["reference_audio_directory"] = None
+
+    return params
+
+
+def _blueprint_to_manifest_entries(dataset_group_blueprint: DatasetGroupBlueprint) -> list[dict]:
+    entries: list[dict] = []
+    for dataset_blueprint in dataset_group_blueprint.datasets:
+        params = _manifest_params_with_cache_only(dataset_blueprint.dataset_type, asdict(dataset_blueprint.params))
+        entries.append(
+            {
+                "dataset_type": dataset_blueprint.dataset_type,
+                "params": params,
+            }
+        )
+    return entries
+
+
+def create_cache_only_dataset_manifest(
+    user_config: dict,
+    argparse_namespace: argparse.Namespace,
+    architecture: str,
+    source_dataset_config: Optional[Union[str, Path]] = None,
+) -> dict:
+    blueprint_generator = BlueprintGenerator(ConfigSanitizer())
+    blueprint = blueprint_generator.generate(user_config, argparse_namespace, architecture=architecture)
+
+    manifest: dict = {
+        "format": "musubi_tuner_dataset_manifest",
+        "version": 1,
+        "architecture": architecture,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "datasets": _blueprint_to_manifest_entries(blueprint.dataset_group),
+    }
+
+    if source_dataset_config is not None:
+        manifest["source_dataset_config"] = str(source_dataset_config)
+
+    if user_config.get("validation_datasets"):
+        validation_user_config = {
+            "general": user_config.get("general", {}),
+            "datasets": user_config.get("validation_datasets", []),
+        }
+        validation_blueprint = blueprint_generator.generate(
+            validation_user_config,
+            argparse_namespace,
+            architecture=architecture,
+        )
+        manifest["validation_datasets"] = _blueprint_to_manifest_entries(validation_blueprint.dataset_group)
+
+    return manifest
+
+
+def save_dataset_manifest(manifest: dict, manifest_path: Union[str, Path]) -> Path:
+    path = Path(manifest_path)
+    if path.parent and not path.parent.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(manifest, f, indent=2)
+    return path
+
+
+def load_dataset_manifest(manifest_path: Union[str, Path]) -> dict:
+    path = Path(manifest_path)
+    if not path.is_file():
+        raise ValueError(f"dataset manifest not found: {path}")
+
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            manifest = json.load(f)
+    except Exception as e:
+        raise ValueError(f"failed to load dataset manifest: {path}") from e
+
+    if not isinstance(manifest, dict):
+        raise ValueError(f"invalid dataset manifest format: {path}")
+    if manifest.get("version") != 1:
+        raise ValueError(f"unsupported dataset manifest version: {manifest.get('version')}")
+    if not isinstance(manifest.get("datasets"), list):
+        raise ValueError(f"dataset manifest must contain a datasets array: {path}")
+
+    return manifest
+
+
+def _normalize_manifest_params(params: dict) -> dict:
+    normalized = dict(params)
+    if isinstance(normalized.get("resolution"), list):
+        normalized["resolution"] = tuple(normalized["resolution"])
+    if isinstance(normalized.get("control_resolution"), list):
+        normalized["control_resolution"] = tuple(normalized["control_resolution"])
+    if isinstance(normalized.get("target_frames"), list):
+        normalized["target_frames"] = tuple(normalized["target_frames"])
+    return normalized
+
+
+def _manifest_entries_to_blueprint(entries: Sequence[dict], default_architecture: Optional[str] = None) -> DatasetGroupBlueprint:
+    dataset_blueprints: list[DatasetBlueprint] = []
+    for i, entry in enumerate(entries):
+        dataset_type = entry.get("dataset_type")
+        params = entry.get("params")
+        if dataset_type not in {"audio", "image", "video"}:
+            raise ValueError(f"invalid dataset_type in manifest entry {i}: {dataset_type}")
+        if not isinstance(params, dict):
+            raise ValueError(f"manifest entry {i} has invalid params")
+
+        if dataset_type == "audio":
+            dataset_params_klass = AudioDatasetParams
+        elif dataset_type == "image":
+            dataset_params_klass = ImageDatasetParams
+        else:
+            dataset_params_klass = VideoDatasetParams
+
+        normalized_params = _normalize_manifest_params(params)
+        normalized_params["cache_only"] = True
+        if default_architecture and normalized_params.get("architecture") in {None, "no_default"}:
+            normalized_params["architecture"] = default_architecture
+
+        valid_fields = {f.name for f in fields(dataset_params_klass)}
+        filtered_params = {k: v for k, v in normalized_params.items() if k in valid_fields}
+        dataset_params = dataset_params_klass(**filtered_params)
+        dataset_blueprints.append(DatasetBlueprint(dataset_type, dataset_params))
+
+    return DatasetGroupBlueprint(dataset_blueprints)
+
+
+def generate_dataset_group_by_manifest(
+    manifest: dict,
+    split: str = "train",
+    training: bool = False,
+    num_timestep_buckets: Optional[int] = None,
+    shared_epoch: SharedEpoch = None,
+) -> Optional[DatasetGroup]:
+    if split not in {"train", "validation"}:
+        raise ValueError(f"invalid manifest split: {split}")
+
+    key = "datasets" if split == "train" else "validation_datasets"
+    entries = manifest.get(key, [])
+    if not entries:
+        return None
+
+    default_architecture = manifest.get("architecture")
+    dataset_group_blueprint = _manifest_entries_to_blueprint(entries, default_architecture=default_architecture)
+    return generate_dataset_group_by_blueprint(
+        dataset_group_blueprint,
+        training=training,
+        num_timestep_buckets=num_timestep_buckets,
+        shared_epoch=shared_epoch,
+    )
+
+
+def load_user_config(file: str) -> dict:
+    file: Path = Path(file)
+    if not file.is_file():
+        raise ValueError(f"file not found / ファイルが見つかりません: {file}")
+
+    if file.name.lower().endswith(".json"):
+        try:
+            with open(file, "r", encoding="utf-8") as f:
+                config = json.load(f)
+        except Exception:
+            logger.error(
+                f"Error on parsing JSON config file. Please check the format. / JSON 形式の設定ファイルの読み込みに失敗しました。文法が正しいか確認してください。: {file}"
+            )
+            raise
+    elif file.name.lower().endswith(".toml"):
+        try:
+            config = toml.load(file)
+        except Exception:
+            logger.error(
+                f"Error on parsing TOML config file. Please check the format. / TOML 形式の設定ファイルの読み込みに失敗しました。文法が正しいか確認してください。: {file}"
+            )
+            raise
+    else:
+        raise ValueError(f"not supported config file format / 対応していない設定ファイルの形式です: {file}")
+
+    deprecated_key_map = {
+        "flux_kontext_no_resize_control": "no_resize_control",
+        "qwen_image_edit_no_resize_control": "no_resize_control",
+        "qwen_image_edit_control_resolution": "control_resolution",
+    }
+
+    def normalize_deprecated_keys(section: dict, section_name: str) -> None:
+        for old_key, new_key in deprecated_key_map.items():
+            if old_key not in section:
+                continue
+            if new_key in section:
+                logger.warning(
+                    f"Deprecated config key '{old_key}' is ignored because '{new_key}' is already set in {section_name}."
+                )
+            else:
+                section[new_key] = section[old_key]
+                logger.warning(f"Deprecated config key '{old_key}' found in {section_name}; use '{new_key}' instead.")
+            del section[old_key]
+
+    general_config = config.get("general")
+    if isinstance(general_config, dict):
+        normalize_deprecated_keys(general_config, "general")
+
+    datasets_config = config.get("datasets", [])
+    if isinstance(datasets_config, list):
+        for idx, dataset_config in enumerate(datasets_config):
+            if isinstance(dataset_config, dict):
+                normalize_deprecated_keys(dataset_config, f"datasets[{idx}]")
+
+    return config
+
+
+# for config test
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("dataset_config")
+    config_args, remain = parser.parse_known_args()
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--debug_dataset", action="store_true")
+    argparse_namespace = parser.parse_args(remain)
+
+    logger.info("[argparse_namespace]")
+    logger.info(f"{vars(argparse_namespace)}")
+
+    user_config = load_user_config(config_args.dataset_config)
+
+    logger.info("")
+    logger.info("[user_config]")
+    logger.info(f"{user_config}")
+
+    sanitizer = ConfigSanitizer()
+    sanitized_user_config = sanitizer.sanitize_user_config(user_config)
+
+    logger.info("")
+    logger.info("[sanitized_user_config]")
+    logger.info(f"{sanitized_user_config}")
+
+    blueprint = BlueprintGenerator(sanitizer).generate(user_config, argparse_namespace)
+
+    logger.info("")
+    logger.info("[blueprint]")
+    logger.info(f"{blueprint}")
+
+    dataset_group = generate_dataset_group_by_blueprint(blueprint.dataset_group)

src/musubi_tuner/dataset/dataset_config.md

@@ -0,0 +1,3 @@
+This document has been moved to [`docs/dataset_config.md`](../../../docs/dataset_config.md).
+
+このドキュメントは[`docs/dataset_config.md`](../../../docs/dataset_config.md)に移動しました。

src/musubi_tuner/flux/flux_models.py

@@ -0,0 +1,1065 @@
+# copy from FLUX repo: https://github.com/black-forest-labs/flux
+# license: Apache-2.0 License
+
+
+import math
+import os
+import time
+from concurrent.futures import Future, ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Union
+
+import torch
+from einops import rearrange
+from torch import Tensor, nn
+from torch.utils.checkpoint import checkpoint
+
+from musubi_tuner.modules.custom_offloading_utils import ModelOffloader
+from musubi_tuner.hunyuan_model.attention import attention as hunyuan_attention
+
+
+import logging
+
+from musubi_tuner.utils.model_utils import create_cpu_offloading_wrapper
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+# USE_REENTRANT = True
+
+
+@dataclass
+class FluxParams:
+    in_channels: int
+    vec_in_dim: int
+    context_in_dim: int
+    hidden_size: int
+    mlp_ratio: float
+    num_heads: int
+    depth: int
+    depth_single_blocks: int
+    axes_dim: list[int]
+    theta: int
+    qkv_bias: bool
+    guidance_embed: bool
+
+
+# region autoencoder
+
+
+@dataclass
+class AutoEncoderParams:
+    resolution: int
+    in_channels: int
+    ch: int
+    out_ch: int
+    ch_mult: list[int]
+    num_res_blocks: int
+    z_channels: int
+    scale_factor: float
+    shift_factor: float
+
+
+def swish(x: Tensor) -> Tensor:
+    return x * torch.sigmoid(x)
+
+
+class AttnBlock(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.in_channels = in_channels
+
+        self.norm = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+
+        self.q = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.k = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.v = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.proj_out = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+
+    def attention(self, h_: Tensor) -> Tensor:
+        h_ = self.norm(h_)
+        q = self.q(h_)
+        k = self.k(h_)
+        v = self.v(h_)
+
+        b, c, h, w = q.shape
+        q = rearrange(q, "b c h w -> b 1 (h w) c").contiguous()
+        k = rearrange(k, "b c h w -> b 1 (h w) c").contiguous()
+        v = rearrange(v, "b c h w -> b 1 (h w) c").contiguous()
+        h_ = nn.functional.scaled_dot_product_attention(q, k, v)
+
+        return rearrange(h_, "b 1 (h w) c -> b c h w", h=h, w=w, c=c, b=b)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x + self.proj_out(self.attention(x))
+
+
+class ResnetBlock(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.in_channels = in_channels
+        out_channels = in_channels if out_channels is None else out_channels
+        self.out_channels = out_channels
+
+        self.norm1 = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        self.norm2 = nn.GroupNorm(num_groups=32, num_channels=out_channels, eps=1e-6, affine=True)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        if self.in_channels != self.out_channels:
+            self.nin_shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x):
+        h = x
+        h = self.norm1(h)
+        h = swish(h)
+        h = self.conv1(h)
+
+        h = self.norm2(h)
+        h = swish(h)
+        h = self.conv2(h)
+
+        if self.in_channels != self.out_channels:
+            x = self.nin_shortcut(x)
+
+        return x + h
+
+
+class Downsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        # no asymmetric padding in torch conv, must do it ourselves
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=2, padding=0)
+
+    def forward(self, x: Tensor):
+        pad = (0, 1, 0, 1)
+        x = nn.functional.pad(x, pad, mode="constant", value=0)
+        x = self.conv(x)
+        return x
+
+
+class Upsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor):
+        x = nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
+        x = self.conv(x)
+        return x
+
+
+class Encoder(nn.Module):
+    def __init__(
+        self,
+        resolution: int,
+        in_channels: int,
+        ch: int,
+        ch_mult: list[int],
+        num_res_blocks: int,
+        z_channels: int,
+    ):
+        super().__init__()
+        self.ch = ch
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        # downsampling
+        self.conv_in = nn.Conv2d(in_channels, self.ch, kernel_size=3, stride=1, padding=1)
+
+        curr_res = resolution
+        in_ch_mult = (1,) + tuple(ch_mult)
+        self.in_ch_mult = in_ch_mult
+        self.down = nn.ModuleList()
+        block_in = self.ch
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_in = ch * in_ch_mult[i_level]
+            block_out = ch * ch_mult[i_level]
+            for _ in range(self.num_res_blocks):
+                block.append(ResnetBlock(in_channels=block_in, out_channels=block_out))
+                block_in = block_out
+            down = nn.Module()
+            down.block = block
+            down.attn = attn
+            if i_level != self.num_resolutions - 1:
+                down.downsample = Downsample(block_in)
+                curr_res = curr_res // 2
+            self.down.append(down)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+
+        # end
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, 2 * z_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        # downsampling
+        hs = [self.conv_in(x)]
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](hs[-1])
+                if len(self.down[i_level].attn) > 0:
+                    h = self.down[i_level].attn[i_block](h)
+                hs.append(h)
+            if i_level != self.num_resolutions - 1:
+                hs.append(self.down[i_level].downsample(hs[-1]))
+
+        # middle
+        h = hs[-1]
+        h = self.mid.block_1(h)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h)
+        # end
+        h = self.norm_out(h)
+        h = swish(h)
+        h = self.conv_out(h)
+        return h
+
+
+class Decoder(nn.Module):
+    def __init__(
+        self,
+        ch: int,
+        out_ch: int,
+        ch_mult: list[int],
+        num_res_blocks: int,
+        in_channels: int,
+        resolution: int,
+        z_channels: int,
+    ):
+        super().__init__()
+        self.ch = ch
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.ffactor = 2 ** (self.num_resolutions - 1)
+
+        # compute in_ch_mult, block_in and curr_res at lowest res
+        block_in = ch * ch_mult[self.num_resolutions - 1]
+        curr_res = resolution // 2 ** (self.num_resolutions - 1)
+        self.z_shape = (1, z_channels, curr_res, curr_res)
+
+        # z to block_in
+        self.conv_in = nn.Conv2d(z_channels, block_in, kernel_size=3, stride=1, padding=1)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+
+        # upsampling
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_out = ch * ch_mult[i_level]
+            for _ in range(self.num_res_blocks + 1):
+                block.append(ResnetBlock(in_channels=block_in, out_channels=block_out))
+                block_in = block_out
+            up = nn.Module()
+            up.block = block
+            up.attn = attn
+            if i_level != 0:
+                up.upsample = Upsample(block_in)
+                curr_res = curr_res * 2
+            self.up.insert(0, up)  # prepend to get consistent order
+
+        # end
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, out_ch, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, z: Tensor) -> Tensor:
+        # z to block_in
+        h = self.conv_in(z)
+
+        # middle
+        h = self.mid.block_1(h)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h)
+
+        # upsampling
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks + 1):
+                h = self.up[i_level].block[i_block](h)
+                if len(self.up[i_level].attn) > 0:
+                    h = self.up[i_level].attn[i_block](h)
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+
+        # end
+        h = self.norm_out(h)
+        h = swish(h)
+        h = self.conv_out(h)
+        return h
+
+
+class DiagonalGaussian(nn.Module):
+    def __init__(self, sample: bool = True, chunk_dim: int = 1):
+        super().__init__()
+        self.sample = sample
+        self.chunk_dim = chunk_dim
+
+    def forward(self, z: Tensor) -> Tensor:
+        mean, logvar = torch.chunk(z, 2, dim=self.chunk_dim)
+        if self.sample:
+            std = torch.exp(0.5 * logvar)
+            return mean + std * torch.randn_like(mean)
+        else:
+            return mean
+
+
+class AutoEncoder(nn.Module):
+    def __init__(self, params: AutoEncoderParams):
+        super().__init__()
+        self.encoder = Encoder(
+            resolution=params.resolution,
+            in_channels=params.in_channels,
+            ch=params.ch,
+            ch_mult=params.ch_mult,
+            num_res_blocks=params.num_res_blocks,
+            z_channels=params.z_channels,
+        )
+        self.decoder = Decoder(
+            resolution=params.resolution,
+            in_channels=params.in_channels,
+            ch=params.ch,
+            out_ch=params.out_ch,
+            ch_mult=params.ch_mult,
+            num_res_blocks=params.num_res_blocks,
+            z_channels=params.z_channels,
+        )
+        self.reg = DiagonalGaussian()
+
+        self.scale_factor = params.scale_factor
+        self.shift_factor = params.shift_factor
+
+    @property
+    def device(self) -> torch.device:
+        return next(self.parameters()).device
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
+    def encode(self, x: Tensor) -> Tensor:
+        z = self.reg(self.encoder(x))
+        z = self.scale_factor * (z - self.shift_factor)
+        return z
+
+    def decode(self, z: Tensor) -> Tensor:
+        z = z / self.scale_factor + self.shift_factor
+        return self.decoder(z)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.decode(self.encode(x))
+
+
+# endregion
+# region config
+
+
+@dataclass
+class ModelSpec:
+    params: FluxParams
+    ae_params: AutoEncoderParams
+    # ckpt_path: str | None
+    # ae_path: str | None
+    # repo_id: str | None
+    # repo_flow: str | None
+    # repo_ae: str | None
+
+
+configs_flux_dev_context = ModelSpec(
+    # repo_id="black-forest-labs/FLUX.1-Kontext-dev",
+    # repo_flow="flux1-kontext-dev.safetensors",
+    # repo_ae="ae.safetensors",
+    params=FluxParams(
+        in_channels=64,
+        # out_channels=64,
+        vec_in_dim=768,
+        context_in_dim=4096,
+        hidden_size=3072,
+        mlp_ratio=4.0,
+        num_heads=24,
+        depth=19,
+        depth_single_blocks=38,
+        axes_dim=[16, 56, 56],
+        theta=10_000,
+        qkv_bias=True,
+        guidance_embed=True,
+    ),
+    ae_params=AutoEncoderParams(
+        resolution=256,
+        in_channels=3,
+        ch=128,
+        out_ch=3,
+        ch_mult=[1, 2, 4, 4],
+        num_res_blocks=2,
+        z_channels=16,
+        scale_factor=0.3611,
+        shift_factor=0.1159,
+    ),
+)
+
+T5XXL_MAX_LENGTH = 512
+
+# endregion
+
+# region math
+
+
+def attention(
+    q: Tensor,
+    k: Tensor,
+    v: Tensor,
+    pe: Tensor,
+    attn_mask: Optional[Tensor] = None,
+    attn_mode: str = "torch",
+    split_attn: bool = False,
+    control_lengths: Optional[list[int]] = None,
+) -> Tensor:
+    assert attn_mask is None, "attn_mask is not supported in flux attention"
+
+    q, k = apply_rope(q, k, pe)
+
+    # x = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask)
+    # x = rearrange(x, "B H L D -> B L (H D)")
+
+    if control_lengths is not None:
+        max_control_length = max(control_lengths)
+        min_control_length = min(control_lengths)
+    else:
+        max_control_length = 0
+        min_control_length = 0
+
+    if split_attn or max_control_length != min_control_length:
+        if control_lengths is None or max_control_length == min_control_length:
+            # normal split attention, no trimming
+            total_len = torch.tensor([q.shape[-2]] * q.shape[0], dtype=torch.long)  # (sequence length, sequence length ...)
+        else:
+            # split attention with different control lengths, trim to each control length
+            max_control_length = max(control_lengths)
+            total_len = torch.tensor([q.shape[-2] - max_control_length + cl for cl in control_lengths], dtype=torch.long)
+        # print(f"Max control length: {max_control_length}, control lengths: {control_lengths}, total_len: {total_len}")
+    else:
+        # inference time or same length for all controls
+        total_len = None
+
+    q = q.transpose(1, 2)  # B, H, L, D -> B, L, H, D
+    k = k.transpose(1, 2)  # B, H, L, D -> B, L, H, D
+    v = v.transpose(1, 2)  # B, H, L, D -> B, L, H, D
+    x = hunyuan_attention([q, k, v], mode=attn_mode, total_len=total_len)  # B, L, D
+
+    return x
+
+
+def rope(pos: Tensor, dim: int, theta: int) -> Tensor:
+    assert dim % 2 == 0
+    scale = torch.arange(0, dim, 2, dtype=torch.float64, device=pos.device) / dim
+    omega = 1.0 / (theta**scale)
+    out = torch.einsum("...n,d->...nd", pos, omega)
+    out = torch.stack([torch.cos(out), -torch.sin(out), torch.sin(out), torch.cos(out)], dim=-1)
+    out = rearrange(out, "b n d (i j) -> b n d i j", i=2, j=2)
+    return out.float()
+
+
+def apply_rope(xq: Tensor, xk: Tensor, freqs_cis: Tensor) -> tuple[Tensor, Tensor]:
+    xq_ = xq.float().reshape(*xq.shape[:-1], -1, 1, 2)
+    xk_ = xk.float().reshape(*xk.shape[:-1], -1, 1, 2)
+    xq_out = freqs_cis[..., 0] * xq_[..., 0] + freqs_cis[..., 1] * xq_[..., 1]
+    xk_out = freqs_cis[..., 0] * xk_[..., 0] + freqs_cis[..., 1] * xk_[..., 1]
+    return xq_out.reshape(*xq.shape).type_as(xq), xk_out.reshape(*xk.shape).type_as(xk)
+
+
+# endregion
+
+
+# region layers
+
+
+class EmbedND(nn.Module):
+    def __init__(self, dim: int, theta: int, axes_dim: list[int]):
+        super().__init__()
+        self.dim = dim
+        self.theta = theta
+        self.axes_dim = axes_dim
+
+    def forward(self, ids: Tensor) -> Tensor:
+        n_axes = ids.shape[-1]
+        emb = torch.cat(
+            [rope(ids[..., i], self.axes_dim[i], self.theta) for i in range(n_axes)],
+            dim=-3,
+        )
+
+        return emb.unsqueeze(1)
+
+
+def timestep_embedding(t: Tensor, dim, max_period=10000, time_factor: float = 1000.0):
+    """
+    Create sinusoidal timestep embeddings.
+    :param t: a 1-D Tensor of N indices, one per batch element.
+                      These may be fractional.
+    :param dim: the dimension of the output.
+    :param max_period: controls the minimum frequency of the embeddings.
+    :return: an (N, D) Tensor of positional embeddings.
+    """
+    t = time_factor * t
+    half = dim // 2
+    freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half).to(t.device)
+
+    args = t[:, None].float() * freqs[None]
+    embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+    if dim % 2:
+        embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+    if torch.is_floating_point(t):
+        embedding = embedding.to(t)
+    return embedding
+
+
+class MLPEmbedder(nn.Module):
+    def __init__(self, in_dim: int, hidden_dim: int):
+        super().__init__()
+        self.in_layer = nn.Linear(in_dim, hidden_dim, bias=True)
+        self.silu = nn.SiLU()
+        self.out_layer = nn.Linear(hidden_dim, hidden_dim, bias=True)
+
+        self.gradient_checkpointing = False
+
+    def enable_gradient_checkpointing(self):
+        self.gradient_checkpointing = True
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+
+    def _forward(self, x: Tensor) -> Tensor:
+        return self.out_layer(self.silu(self.in_layer(x)))
+
+    def forward(self, *args, **kwargs):
+        if self.training and self.gradient_checkpointing:
+            return checkpoint(self._forward, *args, use_reentrant=False, **kwargs)
+        else:
+            return self._forward(*args, **kwargs)
+
+    # def forward(self, x):
+    #     if self.training and self.gradient_checkpointing:
+    #         def create_custom_forward(func):
+    #             def custom_forward(*inputs):
+    #                 return func(*inputs)
+    #             return custom_forward
+    #         return torch.utils.checkpoint.checkpoint(create_custom_forward(self._forward), x, use_reentrant=USE_REENTRANT)
+    #     else:
+    #         return self._forward(x)
+
+
+class RMSNorm(torch.nn.Module):
+    def __init__(self, dim: int):
+        super().__init__()
+        self.scale = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: Tensor):
+        x_dtype = x.dtype
+        x = x.float()
+        rrms = torch.rsqrt(torch.mean(x**2, dim=-1, keepdim=True) + 1e-6)
+        # return (x * rrms).to(dtype=x_dtype) * self.scale
+        return ((x * rrms) * self.scale.float()).to(dtype=x_dtype)
+
+
+class QKNorm(torch.nn.Module):
+    def __init__(self, dim: int):
+        super().__init__()
+        self.query_norm = RMSNorm(dim)
+        self.key_norm = RMSNorm(dim)
+
+    def forward(self, q: Tensor, k: Tensor, v: Tensor) -> tuple[Tensor, Tensor]:
+        q = self.query_norm(q)
+        k = self.key_norm(k)
+        return q.to(v), k.to(v)
+
+
+class SelfAttention(nn.Module):
+    def __init__(self, dim: int, num_heads: int = 8, qkv_bias: bool = False):
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.norm = QKNorm(head_dim)
+        self.proj = nn.Linear(dim, dim)
+
+    # this is not called from DoubleStreamBlock/SingleStreamBlock because they uses attention function directly
+    def forward(self, x: Tensor, pe: Tensor) -> Tensor:
+        qkv = self.qkv(x)
+        q, k, v = rearrange(qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads)
+        q, k = self.norm(q, k, v)
+        x = attention(q, k, v, pe=pe)
+        x = self.proj(x)
+        return x
+
+
+@dataclass
+class ModulationOut:
+    shift: Tensor
+    scale: Tensor
+    gate: Tensor
+
+
+class Modulation(nn.Module):
+    def __init__(self, dim: int, double: bool):
+        super().__init__()
+        self.is_double = double
+        self.multiplier = 6 if double else 3
+        self.lin = nn.Linear(dim, self.multiplier * dim, bias=True)
+
+    def forward(self, vec: Tensor) -> tuple[ModulationOut, ModulationOut | None]:
+        out = self.lin(nn.functional.silu(vec))[:, None, :].chunk(self.multiplier, dim=-1)
+
+        return (
+            ModulationOut(*out[:3]),
+            ModulationOut(*out[3:]) if self.is_double else None,
+        )
+
+
+class DoubleStreamBlock(nn.Module):
+    def __init__(
+        self,
+        hidden_size: int,
+        num_heads: int,
+        mlp_ratio: float,
+        qkv_bias: bool = False,
+        attn_mode: str = "torch",
+        split_attn: bool = False,
+    ):
+        super().__init__()
+
+        mlp_hidden_dim = int(hidden_size * mlp_ratio)
+        self.num_heads = num_heads
+        self.hidden_size = hidden_size
+        self.attn_mode = attn_mode
+        self.split_attn = split_attn
+
+        self.img_mod = Modulation(hidden_size, double=True)
+        self.img_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.img_attn = SelfAttention(dim=hidden_size, num_heads=num_heads, qkv_bias=qkv_bias)
+
+        self.img_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.img_mlp = nn.Sequential(
+            nn.Linear(hidden_size, mlp_hidden_dim, bias=True),
+            nn.GELU(approximate="tanh"),
+            nn.Linear(mlp_hidden_dim, hidden_size, bias=True),
+        )
+
+        self.txt_mod = Modulation(hidden_size, double=True)
+        self.txt_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.txt_attn = SelfAttention(dim=hidden_size, num_heads=num_heads, qkv_bias=qkv_bias)
+
+        self.txt_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.txt_mlp = nn.Sequential(
+            nn.Linear(hidden_size, mlp_hidden_dim, bias=True),
+            nn.GELU(approximate="tanh"),
+            nn.Linear(mlp_hidden_dim, hidden_size, bias=True),
+        )
+
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False):
+        self.gradient_checkpointing = True
+        self.activation_cpu_offloading = activation_cpu_offloading
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def _forward(
+        self, img: Tensor, txt: Tensor, vec: Tensor, pe: Tensor, control_lengths: Optional[list[int]] = None
+    ) -> tuple[Tensor, Tensor]:
+        img_mod1, img_mod2 = self.img_mod(vec)
+        txt_mod1, txt_mod2 = self.txt_mod(vec)
+
+        # prepare image for attention
+        img_modulated = self.img_norm1(img)
+        img_modulated = (1 + img_mod1.scale) * img_modulated + img_mod1.shift
+        img_qkv = self.img_attn.qkv(img_modulated)
+        img_q, img_k, img_v = rearrange(img_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads)
+        img_q, img_k = self.img_attn.norm(img_q, img_k, img_v)
+
+        # prepare txt for attention
+        txt_modulated = self.txt_norm1(txt)
+        txt_modulated = (1 + txt_mod1.scale) * txt_modulated + txt_mod1.shift
+        txt_qkv = self.txt_attn.qkv(txt_modulated)
+        txt_q, txt_k, txt_v = rearrange(txt_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads)
+        txt_q, txt_k = self.txt_attn.norm(txt_q, txt_k, txt_v)
+
+        # run actual attention
+        q = torch.cat((txt_q, img_q), dim=2)
+        k = torch.cat((txt_k, img_k), dim=2)
+        v = torch.cat((txt_v, img_v), dim=2)
+
+        # attention mask is not supported in flux
+        attn = attention(q, k, v, pe=pe, attn_mode=self.attn_mode, split_attn=self.split_attn, control_lengths=control_lengths)
+        txt_attn, img_attn = attn[:, : txt.shape[1]], attn[:, txt.shape[1] :]
+
+        # calculate the img blocks
+        img = torch.addcmul(img, img_mod1.gate, self.img_attn.proj(img_attn))
+        img = torch.addcmul(img, img_mod2.gate, self.img_mlp((1 + img_mod2.scale) * self.img_norm2(img) + img_mod2.shift))
+        # calculate the txt blocks
+        txt = torch.addcmul(txt, txt_mod1.gate, self.txt_attn.proj(txt_attn))
+        txt = torch.addcmul(txt, txt_mod2.gate, self.txt_mlp((1 + txt_mod2.scale) * self.txt_norm2(txt) + txt_mod2.shift))
+        return img, txt
+
+    def forward(
+        self, img: Tensor, txt: Tensor, vec: Tensor, pe: Tensor, control_lengths: Optional[list[int]] = None
+    ) -> tuple[Tensor, Tensor]:
+        if self.training and self.gradient_checkpointing:
+            forward_fn = self._forward
+            if self.activation_cpu_offloading:
+                forward_fn = create_cpu_offloading_wrapper(forward_fn, self.img_mlp[0].weight.device)
+            return checkpoint(forward_fn, img, txt, vec, pe, control_lengths, use_reentrant=False)
+        else:
+            return self._forward(img, txt, vec, pe, control_lengths)
+
+
+class SingleStreamBlock(nn.Module):
+    """
+    A DiT block with parallel linear layers as described in
+    https://arxiv.org/abs/2302.05442 and adapted modulation interface.
+    """
+
+    def __init__(
+        self,
+        hidden_size: int,
+        num_heads: int,
+        mlp_ratio: float = 4.0,
+        qk_scale: float | None = None,
+        attn_mode: str = "torch",
+        split_attn: bool = False,
+    ):
+        super().__init__()
+        self.hidden_dim = hidden_size
+        self.num_heads = num_heads
+        head_dim = hidden_size // num_heads
+        self.scale = qk_scale or head_dim**-0.5
+        self.attn_mode = attn_mode
+        self.split_attn = split_attn
+
+        self.mlp_hidden_dim = int(hidden_size * mlp_ratio)
+        # qkv and mlp_in
+        self.linear1 = nn.Linear(hidden_size, hidden_size * 3 + self.mlp_hidden_dim)
+        # proj and mlp_out
+        self.linear2 = nn.Linear(hidden_size + self.mlp_hidden_dim, hidden_size)
+
+        self.norm = QKNorm(head_dim)
+
+        self.hidden_size = hidden_size
+        self.pre_norm = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+
+        self.mlp_act = nn.GELU(approximate="tanh")
+        self.modulation = Modulation(hidden_size, double=False)
+
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False):
+        self.gradient_checkpointing = True
+        self.activation_cpu_offloading = activation_cpu_offloading
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def _forward(self, x: Tensor, vec: Tensor, pe: Tensor, control_lengths: Optional[list[int]] = None) -> Tensor:
+        mod, _ = self.modulation(vec)
+        x_mod = (1 + mod.scale) * self.pre_norm(x) + mod.shift
+        qkv, mlp = torch.split(self.linear1(x_mod), [3 * self.hidden_size, self.mlp_hidden_dim], dim=-1)
+
+        q, k, v = rearrange(qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads)
+        q, k = self.norm(q, k, v)
+
+        # compute attention
+        attn = attention(q, k, v, pe=pe, attn_mode=self.attn_mode, split_attn=self.split_attn, control_lengths=control_lengths)
+
+        # compute activation in mlp stream, cat again and run second linear layer
+        output = self.linear2(torch.cat((attn, self.mlp_act(mlp)), 2))
+        return torch.addcmul(x, mod.gate, output)
+
+    def forward(self, x: Tensor, vec: Tensor, pe: Tensor, control_lengths: Optional[list[int]] = None) -> Tensor:
+        if self.training and self.gradient_checkpointing:
+            forward_fn = self._forward
+            if self.activation_cpu_offloading:
+                forward_fn = create_cpu_offloading_wrapper(forward_fn, self.linear1.weight.device)
+            return checkpoint(forward_fn, x, vec, pe, control_lengths, use_reentrant=False)
+        else:
+            return self._forward(x, vec, pe, control_lengths)
+
+
+class LastLayer(nn.Module):
+    def __init__(self, hidden_size: int, patch_size: int, out_channels: int):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, patch_size * patch_size * out_channels, bias=True)
+        self.adaLN_modulation = nn.Sequential(nn.SiLU(), nn.Linear(hidden_size, 2 * hidden_size, bias=True))
+
+    def forward(self, x: Tensor, vec: Tensor) -> Tensor:
+        shift, scale = self.adaLN_modulation(vec).chunk(2, dim=1)
+        x = (1 + scale[:, None, :]) * self.norm_final(x) + shift[:, None, :]
+        x = self.linear(x)
+        return x
+
+
+# endregion
+
+
+class Flux(nn.Module):
+    """
+    Transformer model for flow matching on sequences.
+    """
+
+    def __init__(self, params: FluxParams, attn_mode: str = "flash", split_attn: bool = False) -> None:
+        super().__init__()
+
+        self.params = params
+        self.in_channels = params.in_channels
+        self.out_channels = self.in_channels
+        if params.hidden_size % params.num_heads != 0:
+            raise ValueError(f"Hidden size {params.hidden_size} must be divisible by num_heads {params.num_heads}")
+        pe_dim = params.hidden_size // params.num_heads
+        if sum(params.axes_dim) != pe_dim:
+            raise ValueError(f"Got {params.axes_dim} but expected positional dim {pe_dim}")
+        self.hidden_size = params.hidden_size
+        self.num_heads = params.num_heads
+
+        self.attn_mode = attn_mode
+        self.split_attn = split_attn
+
+        self.pe_embedder = EmbedND(dim=pe_dim, theta=params.theta, axes_dim=params.axes_dim)
+        self.img_in = nn.Linear(self.in_channels, self.hidden_size, bias=True)
+        self.time_in = MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size)
+        self.vector_in = MLPEmbedder(params.vec_in_dim, self.hidden_size)
+        self.guidance_in = MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size) if params.guidance_embed else nn.Identity()
+        self.txt_in = nn.Linear(params.context_in_dim, self.hidden_size)
+
+        self.double_blocks = nn.ModuleList(
+            [
+                DoubleStreamBlock(
+                    self.hidden_size,
+                    self.num_heads,
+                    mlp_ratio=params.mlp_ratio,
+                    qkv_bias=params.qkv_bias,
+                    attn_mode=self.attn_mode,
+                    split_attn=self.split_attn,
+                )
+                for _ in range(params.depth)
+            ]
+        )
+
+        self.single_blocks = nn.ModuleList(
+            [
+                SingleStreamBlock(
+                    self.hidden_size,
+                    self.num_heads,
+                    mlp_ratio=params.mlp_ratio,
+                    attn_mode=self.attn_mode,
+                    split_attn=self.split_attn,
+                )
+                for _ in range(params.depth_single_blocks)
+            ]
+        )
+
+        self.final_layer = LastLayer(self.hidden_size, 1, self.out_channels)
+
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+        self.blocks_to_swap = None
+
+        self.offloader_double = None
+        self.offloader_single = None
+        self.num_double_blocks = len(self.double_blocks)
+        self.num_single_blocks = len(self.single_blocks)
+
+    def get_model_type(self) -> str:
+        return "flux"
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    @property
+    def dtype(self):
+        return next(self.parameters()).dtype
+
+    def fp8_optimization(
+        self, state_dict: dict[str, torch.Tensor], device: torch.device, move_to_device: bool, use_scaled_mm: bool = False
+    ) -> int:
+        """
+        Optimize the model state_dict with fp8.
+
+        Args:
+            state_dict (dict[str, torch.Tensor]):
+                The state_dict of the model.
+            device (torch.device):
+                The device to calculate the weight.
+            move_to_device (bool):
+                Whether to move the weight to the device after optimization.
+        """
+        TARGET_KEYS = ["single_blocks", "double_blocks"]
+        EXCLUDE_KEYS = [
+            "norm",
+            "mod",
+        ]
+
+        from musubi_tuner.modules.fp8_optimization_utils import apply_fp8_monkey_patch, optimize_state_dict_with_fp8
+
+        # inplace optimization
+        state_dict = optimize_state_dict_with_fp8(state_dict, device, TARGET_KEYS, EXCLUDE_KEYS, move_to_device=move_to_device)
+
+        # apply monkey patching
+        apply_fp8_monkey_patch(self, state_dict, use_scaled_mm=use_scaled_mm)
+
+        return state_dict
+
+    def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False):
+        self.gradient_checkpointing = True
+        self.activation_cpu_offloading = activation_cpu_offloading
+
+        self.time_in.enable_gradient_checkpointing()
+        self.vector_in.enable_gradient_checkpointing()
+        if self.guidance_in.__class__ != nn.Identity:
+            self.guidance_in.enable_gradient_checkpointing()
+
+        for block in self.double_blocks + self.single_blocks:
+            block.enable_gradient_checkpointing(activation_cpu_offloading)
+
+        print(f"FLUX: Gradient checkpointing enabled. Activation CPU offloading: {activation_cpu_offloading}")
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+
+        self.time_in.disable_gradient_checkpointing()
+        self.vector_in.disable_gradient_checkpointing()
+        if self.guidance_in.__class__ != nn.Identity:
+            self.guidance_in.disable_gradient_checkpointing()
+
+        for block in self.double_blocks + self.single_blocks:
+            block.disable_gradient_checkpointing()
+
+        print("FLUX: Gradient checkpointing disabled.")
+
+    def enable_block_swap(self, num_blocks: int, device: torch.device, supports_backward: bool, use_pinned_memory: bool = False):
+        self.blocks_to_swap = num_blocks
+        double_blocks_to_swap = num_blocks // 2
+        single_blocks_to_swap = (num_blocks - double_blocks_to_swap) * 2 + 1
+
+        assert double_blocks_to_swap <= self.num_double_blocks - 2 and single_blocks_to_swap <= self.num_single_blocks - 2, (
+            f"Cannot swap more than {self.num_double_blocks - 2} double blocks and {self.num_single_blocks - 2} single blocks. "
+            f"Requested {double_blocks_to_swap} double blocks and {single_blocks_to_swap} single blocks."
+        )
+
+        self.offloader_double = ModelOffloader(
+            "double", self.double_blocks, self.num_double_blocks, double_blocks_to_swap, supports_backward, device, use_pinned_memory  # , debug=True
+        )
+        self.offloader_single = ModelOffloader(
+            "single", self.single_blocks, self.num_single_blocks, single_blocks_to_swap, supports_backward, device, use_pinned_memory  # , debug=True
+        )
+        print(
+            f"FLUX: Block swap enabled. Swapping {num_blocks} blocks, double blocks: {double_blocks_to_swap}, single blocks: {single_blocks_to_swap}."
+        )
+
+    def switch_block_swap_for_inference(self):
+        if self.blocks_to_swap:
+            self.offloader_double.set_forward_only(True)
+            self.offloader_single.set_forward_only(True)
+            self.prepare_block_swap_before_forward()
+            print(f"FLUX: Block swap set to forward only.")
+
+    def switch_block_swap_for_training(self):
+        if self.blocks_to_swap:
+            self.offloader_double.set_forward_only(False)
+            self.offloader_single.set_forward_only(False)
+            self.prepare_block_swap_before_forward()
+            print(f"FLUX: Block swap set to forward and backward.")
+
+    def move_to_device_except_swap_blocks(self, device: torch.device):
+        # assume model is on cpu. do not move blocks to device to reduce temporary memory usage
+        if self.blocks_to_swap:
+            save_double_blocks = self.double_blocks
+            save_single_blocks = self.single_blocks
+            self.double_blocks = None
+            self.single_blocks = None
+
+        self.to(device)
+
+        if self.blocks_to_swap:
+            self.double_blocks = save_double_blocks
+            self.single_blocks = save_single_blocks
+
+    def prepare_block_swap_before_forward(self):
+        if self.blocks_to_swap is None or self.blocks_to_swap == 0:
+            return
+        self.offloader_double.prepare_block_devices_before_forward(self.double_blocks)
+        self.offloader_single.prepare_block_devices_before_forward(self.single_blocks)
+
+    def forward(
+        self,
+        img: Tensor,
+        img_ids: Tensor,
+        txt: Tensor,
+        txt_ids: Tensor,
+        timesteps: Tensor,
+        y: Tensor,
+        guidance: Tensor | None = None,
+        control_lengths: Optional[list[int]] = None,
+    ) -> Tensor:
+        if img.ndim != 3 or txt.ndim != 3:
+            raise ValueError("Input img and txt tensors must have 3 dimensions.")
+
+        # running on sequences img
+        img = self.img_in(img)
+        vec = self.time_in(timestep_embedding(timesteps, 256))
+        if self.params.guidance_embed:
+            if guidance is None:
+                raise ValueError("Didn't get guidance strength for guidance distilled model.")
+            vec = vec + self.guidance_in(timestep_embedding(guidance, 256))
+        vec = vec + self.vector_in(y)
+        txt = self.txt_in(txt)
+
+        ids = torch.cat((txt_ids, img_ids), dim=1)
+        pe = self.pe_embedder(ids)
+
+        input_device = img.device
+        for block_idx, block in enumerate(self.double_blocks):
+            if self.blocks_to_swap:
+                self.offloader_double.wait_for_block(block_idx)
+
+            img, txt = block(img=img, txt=txt, vec=vec, pe=pe, control_lengths=control_lengths)
+
+            if self.blocks_to_swap:
+                self.offloader_double.submit_move_blocks_forward(self.double_blocks, block_idx)
+
+        img = torch.cat((txt, img), 1)
+
+        for block_idx, block in enumerate(self.single_blocks):
+            if self.blocks_to_swap:
+                self.offloader_single.wait_for_block(block_idx)
+
+            img = block(img, vec=vec, pe=pe, control_lengths=control_lengths)
+
+            if self.blocks_to_swap:
+                self.offloader_single.submit_move_blocks_forward(self.single_blocks, block_idx)
+
+        img = img[:, txt.shape[1] :, ...]
+
+        if img.device != input_device:
+            img = img.to(input_device)
+
+        img = self.final_layer(img, vec)  # (N, T, patch_size ** 2 * out_channels)
+
+        return img

src/musubi_tuner/flux/flux_utils.py

@@ -0,0 +1,408 @@
+import json
+import math
+from PIL import Image
+from typing import Optional, Union
+import einops
+import numpy as np
+import torch
+from transformers import CLIPConfig, CLIPTextModel, T5Config, T5EncoderModel, CLIPTokenizer, T5Tokenizer
+from accelerate import init_empty_weights
+
+from musubi_tuner.flux import flux_models
+from musubi_tuner.utils import image_utils
+from musubi_tuner.utils.safetensors_utils import load_safetensors
+from musubi_tuner.utils.train_utils import get_lin_function
+
+import logging
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+CLIP_L_TOKENIZER_ID = "openai/clip-vit-large-patch14"
+T5_XXL_TOKENIZER_ID = "google/t5-v1_1-xxl"
+
+# copy from https://github.com/black-forest-labs/flux/blob/main/src/flux/util.py
+PREFERED_KONTEXT_RESOLUTIONS = [
+    (672, 1568),
+    (688, 1504),
+    (720, 1456),
+    (752, 1392),
+    (800, 1328),
+    (832, 1248),
+    (880, 1184),
+    (944, 1104),
+    (1024, 1024),
+    (1104, 944),
+    (1184, 880),
+    (1248, 832),
+    (1328, 800),
+    (1392, 752),
+    (1456, 720),
+    (1504, 688),
+    (1568, 672),
+]
+
+
+def preprocess_control_image(
+    control_image_path: str, resize_to_prefered: bool = True
+) -> tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]:
+    """
+    Preprocess the control image for the model. See `preprocess_image` for details.
+    Args:
+        control_image_path (str): Path to the control image.
+    Returns:
+        Tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]: same as `preprocess_image`.
+    """
+    # find appropriate bucket for the image size. reference: https://github.com/black-forest-labs/flux/blob/main/src/flux/sampling.py
+    control_image = Image.open(control_image_path)
+    width, height = control_image.size
+    aspect_ratio = width / height
+
+    if resize_to_prefered:
+        # Kontext is trained on specific resolutions, using one of them is recommended
+        _, bucket_width, bucket_height = min((abs(aspect_ratio - w / h), w, h) for w, h in PREFERED_KONTEXT_RESOLUTIONS)
+        control_latent_width = int(bucket_width / 16)
+        control_latent_height = int(bucket_height / 16)
+        bucket_width = control_latent_width * 16
+        bucket_height = control_latent_height * 16
+    else:
+        # use the original image size, but make sure it's divisible by 16
+        control_latent_width = int(math.floor(width / 16))
+        control_latent_height = int(math.floor(height / 16))
+        bucket_width = control_latent_width * 16
+        bucket_height = control_latent_height * 16
+        control_image = control_image.crop((0, 0, bucket_width, bucket_height))
+
+    return image_utils.preprocess_image(control_image, bucket_width, bucket_height)
+
+
+def is_fp8(dt):
+    return dt in [torch.float8_e4m3fn, torch.float8_e4m3fnuz, torch.float8_e5m2, torch.float8_e5m2fnuz]
+
+
+def prepare_img_ids(batch_size: int, packed_latent_height: int, packed_latent_width: int, is_ctrl: bool = False) -> torch.Tensor:
+    img_ids = torch.zeros(packed_latent_height, packed_latent_width, 3)
+    img_ids[..., 1] = img_ids[..., 1] + torch.arange(packed_latent_height)[:, None]
+    img_ids[..., 2] = img_ids[..., 2] + torch.arange(packed_latent_width)[None, :]
+    if is_ctrl:
+        img_ids[..., 0] = 1
+    img_ids = einops.repeat(img_ids, "h w c -> b (h w) c", b=batch_size)
+    return img_ids
+
+
+def time_shift(mu: float, sigma: float, t: torch.Tensor):
+    return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
+
+
+def get_schedule(
+    num_steps: int,
+    image_seq_len: int,
+    base_shift: float = 0.5,
+    max_shift: float = 1.15,
+    shift_value: Optional[float] = None,
+) -> list[float]:
+    # shifting the schedule to favor high timesteps for higher signal images
+    # extra step for zero
+    timesteps = torch.linspace(1, 0, num_steps + 1)
+
+    if shift_value is None:
+        # eastimate mu based on linear estimation between two points
+        mu = get_lin_function(y1=base_shift, y2=max_shift)(image_seq_len)
+        timesteps = time_shift(mu, 1.0, timesteps)
+    else:
+        # logits_norm = torch.randn((1,), device=device)
+        # timesteps = logits_norm.sigmoid()
+        # timesteps = (timesteps * shift_value) / (1 + (shift_value - 1) * timesteps)
+
+        timesteps = torch.linspace(1, 0, num_steps + 1)
+        sigmas = timesteps
+        sigmas = shift_value * sigmas / (1 + (shift_value - 1) * sigmas)
+        timesteps = sigmas
+
+    return timesteps.tolist()
+
+
+def load_flow_model(
+    ckpt_path: str,
+    dtype: Optional[torch.dtype],
+    device: Union[str, torch.device],
+    disable_mmap: bool = False,
+    attn_mode: str = "torch",
+    split_attn: bool = False,
+    loading_device: Optional[Union[str, torch.device]] = None,
+    fp8_scaled: bool = False,
+) -> flux_models.Flux:
+    if loading_device is None:
+        loading_device = device
+
+    device = torch.device(device)
+    loading_device = torch.device(loading_device) if loading_device is not None else device
+    flux_kontext_loading_device = loading_device if not fp8_scaled else torch.device("cpu")
+
+    # build model
+    with init_empty_weights():
+        params = flux_models.configs_flux_dev_context.params
+
+        model = flux_models.Flux(params, attn_mode, split_attn)
+        if dtype is not None:
+            model = model.to(dtype)
+
+    # load_sft doesn't support torch.device
+    logger.info(f"Loading state dict from {ckpt_path} to {flux_kontext_loading_device}")
+    sd = load_safetensors(ckpt_path, device=flux_kontext_loading_device, disable_mmap=disable_mmap, dtype=dtype)
+
+    # if the key has annoying prefix, remove it
+    for key in list(sd.keys()):
+        new_key = key.replace("model.diffusion_model.", "")
+        if new_key == key:
+            break  # the model doesn't have annoying prefix
+        sd[new_key] = sd.pop(key)
+
+    # if fp8_scaled is True, convert the model to fp8
+    if fp8_scaled:
+        # fp8 optimization: calculate on CUDA, move back to CPU if loading_device is CPU (block swap)
+        logger.info("Optimizing model weights to fp8. This may take a while.")
+        sd = model.fp8_optimization(sd, device, move_to_device=loading_device.type == "cpu")
+
+        if loading_device.type != "cpu":
+            # make sure all the model weights are on the loading_device
+            logger.info(f"Moving weights to {loading_device}")
+            for key in sd.keys():
+                sd[key] = sd[key].to(loading_device)
+
+    info = model.load_state_dict(sd, strict=True, assign=True)
+    logger.info(f"Loaded Flux: {info}")
+    return model
+
+
+def load_ae(
+    ckpt_path: str, dtype: torch.dtype, device: Union[str, torch.device], disable_mmap: bool = False
+) -> flux_models.AutoEncoder:
+    logger.info("Building AutoEncoder")
+    with init_empty_weights():
+        # dev and schnell have the same AE params
+        ae = flux_models.AutoEncoder(flux_models.configs_flux_dev_context.ae_params).to(dtype)
+
+    logger.info(f"Loading state dict from {ckpt_path}")
+    sd = load_safetensors(ckpt_path, device=str(device), disable_mmap=disable_mmap, dtype=dtype)
+    info = ae.load_state_dict(sd, strict=True, assign=True)
+    logger.info(f"Loaded AE: {info}")
+    return ae
+
+
+def load_clip_l(
+    ckpt_path: Optional[str],
+    dtype: torch.dtype,
+    device: Union[str, torch.device],
+    disable_mmap: bool = False,
+    state_dict: Optional[dict] = None,
+) -> tuple[CLIPTokenizer, CLIPTextModel]:
+    logger.info("Building CLIP-L")
+    CLIPL_CONFIG = {
+        "_name_or_path": "clip-vit-large-patch14/",
+        "architectures": ["CLIPModel"],
+        "initializer_factor": 1.0,
+        "logit_scale_init_value": 2.6592,
+        "model_type": "clip",
+        "projection_dim": 768,
+        # "text_config": {
+        "_name_or_path": "",
+        "add_cross_attention": False,
+        "architectures": None,
+        "attention_dropout": 0.0,
+        "bad_words_ids": None,
+        "bos_token_id": 0,
+        "chunk_size_feed_forward": 0,
+        "cross_attention_hidden_size": None,
+        "decoder_start_token_id": None,
+        "diversity_penalty": 0.0,
+        "do_sample": False,
+        "dropout": 0.0,
+        "early_stopping": False,
+        "encoder_no_repeat_ngram_size": 0,
+        "eos_token_id": 2,
+        "finetuning_task": None,
+        "forced_bos_token_id": None,
+        "forced_eos_token_id": None,
+        "hidden_act": "quick_gelu",
+        "hidden_size": 768,
+        "id2label": {"0": "LABEL_0", "1": "LABEL_1"},
+        "initializer_factor": 1.0,
+        "initializer_range": 0.02,
+        "intermediate_size": 3072,
+        "is_decoder": False,
+        "is_encoder_decoder": False,
+        "label2id": {"LABEL_0": 0, "LABEL_1": 1},
+        "layer_norm_eps": 1e-05,
+        "length_penalty": 1.0,
+        "max_length": 20,
+        "max_position_embeddings": 77,
+        "min_length": 0,
+        "model_type": "clip_text_model",
+        "no_repeat_ngram_size": 0,
+        "num_attention_heads": 12,
+        "num_beam_groups": 1,
+        "num_beams": 1,
+        "num_hidden_layers": 12,
+        "num_return_sequences": 1,
+        "output_attentions": False,
+        "output_hidden_states": False,
+        "output_scores": False,
+        "pad_token_id": 1,
+        "prefix": None,
+        "problem_type": None,
+        "projection_dim": 768,
+        "pruned_heads": {},
+        "remove_invalid_values": False,
+        "repetition_penalty": 1.0,
+        "return_dict": True,
+        "return_dict_in_generate": False,
+        "sep_token_id": None,
+        "task_specific_params": None,
+        "temperature": 1.0,
+        "tie_encoder_decoder": False,
+        "tie_word_embeddings": True,
+        "tokenizer_class": None,
+        "top_k": 50,
+        "top_p": 1.0,
+        "torch_dtype": None,
+        "torchscript": False,
+        "transformers_version": "4.16.0.dev0",
+        "use_bfloat16": False,
+        "vocab_size": 49408,
+        "hidden_act": "gelu",
+        "hidden_size": 1280,
+        "intermediate_size": 5120,
+        "num_attention_heads": 20,
+        "num_hidden_layers": 32,
+        # },
+        # "text_config_dict": {
+        "hidden_size": 768,
+        "intermediate_size": 3072,
+        "num_attention_heads": 12,
+        "num_hidden_layers": 12,
+        "projection_dim": 768,
+        # },
+        # "torch_dtype": "float32",
+        # "transformers_version": None,
+    }
+    config = CLIPConfig(**CLIPL_CONFIG)
+    with init_empty_weights():
+        clip = CLIPTextModel._from_config(config)
+
+    if state_dict is not None:
+        sd = state_dict
+    else:
+        logger.info(f"Loading state dict from {ckpt_path}")
+        sd = load_safetensors(ckpt_path, device=str(device), disable_mmap=disable_mmap, dtype=dtype)
+    info = clip.load_state_dict(sd, strict=True, assign=True)
+    logger.info(f"Loaded CLIP-L: {info}")
+    clip.to(device)
+
+    if dtype is not None:
+        if is_fp8(dtype):
+            logger.info(f"prepare CLIP-L for fp8: set to {dtype}, set embeddings to {torch.bfloat16}")
+            clip.to(dtype)  # fp8
+            clip.text_model.embeddings.to(dtype=torch.bfloat16)
+        else:
+            logger.info(f"Setting CLIP-L to dtype: {dtype}")
+            clip.to(dtype)
+
+    tokenizer = CLIPTokenizer.from_pretrained(CLIP_L_TOKENIZER_ID)
+    return tokenizer, clip
+
+
+def load_t5xxl(
+    ckpt_path: str,
+    dtype: Optional[torch.dtype],
+    device: Union[str, torch.device],
+    disable_mmap: bool = False,
+    state_dict: Optional[dict] = None,
+) -> tuple[T5Tokenizer, T5EncoderModel]:
+    T5_CONFIG_JSON = """
+{
+  "architectures": [
+    "T5EncoderModel"
+  ],
+  "classifier_dropout": 0.0,
+  "d_ff": 10240,
+  "d_kv": 64,
+  "d_model": 4096,
+  "decoder_start_token_id": 0,
+  "dense_act_fn": "gelu_new",
+  "dropout_rate": 0.1,
+  "eos_token_id": 1,
+  "feed_forward_proj": "gated-gelu",
+  "initializer_factor": 1.0,
+  "is_encoder_decoder": true,
+  "is_gated_act": true,
+  "layer_norm_epsilon": 1e-06,
+  "model_type": "t5",
+  "num_decoder_layers": 24,
+  "num_heads": 64,
+  "num_layers": 24,
+  "output_past": true,
+  "pad_token_id": 0,
+  "relative_attention_max_distance": 128,
+  "relative_attention_num_buckets": 32,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float16",
+  "transformers_version": "4.41.2",
+  "use_cache": true,
+  "vocab_size": 32128
+}
+"""
+    config = json.loads(T5_CONFIG_JSON)
+    config = T5Config(**config)
+    with init_empty_weights():
+        t5xxl = T5EncoderModel._from_config(config)
+
+    if state_dict is not None:
+        sd = state_dict
+    else:
+        logger.info(f"Loading state dict from {ckpt_path}")
+        sd = load_safetensors(ckpt_path, device=str(device), disable_mmap=disable_mmap, dtype=dtype)
+    info = t5xxl.load_state_dict(sd, strict=True, assign=True)
+    logger.info(f"Loaded T5xxl: {info}")
+    t5xxl.to(device)
+
+    if dtype is not None:
+        if is_fp8(dtype):
+            logger.info(f"prepare T5xxl for fp8: set to {dtype}")
+
+            def prepare_fp8(text_encoder, target_dtype):
+                def forward_hook(module):
+                    def forward(hidden_states):
+                        hidden_gelu = module.act(module.wi_0(hidden_states))
+                        hidden_linear = module.wi_1(hidden_states)
+                        hidden_states = hidden_gelu * hidden_linear
+                        hidden_states = module.dropout(hidden_states)
+
+                        hidden_states = module.wo(hidden_states)
+                        return hidden_states
+
+                    return forward
+
+                for module in text_encoder.modules():
+                    if module.__class__.__name__ in ["T5LayerNorm", "Embedding"]:
+                        # print("set", module.__class__.__name__, "to", target_dtype)
+                        module.to(target_dtype)
+                    if module.__class__.__name__ in ["T5DenseGatedActDense"]:
+                        # print("set", module.__class__.__name__, "hooks")
+                        module.forward = forward_hook(module)
+
+            t5xxl.to(dtype)
+            prepare_fp8(t5xxl.encoder, torch.bfloat16)
+        else:
+            logger.info(f"Setting T5xxl to dtype: {dtype}")
+            t5xxl.to(dtype)
+
+    # Load tokenizer
+    tokenizer = T5Tokenizer.from_pretrained(T5_XXL_TOKENIZER_ID)
+    return tokenizer, t5xxl
+
+
+def get_t5xxl_actual_dtype(t5xxl: T5EncoderModel) -> torch.dtype:
+    # nn.Embedding is the first layer, but it could be casted to bfloat16 or float32
+    return t5xxl.encoder.block[0].layer[0].SelfAttention.q.weight.dtype

src/musubi_tuner/flux_2/flux2_models.py

@@ -0,0 +1,1020 @@
+# # copy from FLUX repo: https://github.com/black-forest-labs/flux
+# # license: Apache-2.0 License
+import math
+from dataclasses import dataclass, field
+
+import torch
+from einops import rearrange
+from torch import Tensor, nn
+from torch.utils.checkpoint import checkpoint
+
+from musubi_tuner.modules.attention import AttentionParams
+from musubi_tuner.modules.custom_offloading_utils import ModelOffloader
+from musubi_tuner.modules.attention import attention as unified_attention
+
+from musubi_tuner.utils.model_utils import create_cpu_offloading_wrapper
+
+# import logging
+# logger = logging.getLogger(__name__)
+# logging.basicConfig(level=logging.INFO)
+
+# USE_REENTRANT = True
+
+FP8_OPTIMIZATION_TARGET_KEYS = ["double_blocks", "single_blocks"]
+FP8_OPTIMIZATION_EXCLUDE_KEYS = ["norm", "pe_embedder", "time_in", "_modulation"]
+
+
+@dataclass
+class Flux2Params:
+    in_channels: int = 128  # packed latent channels
+    context_in_dim: int = 15360
+    hidden_size: int = 6144
+    num_heads: int = 48
+    depth: int = 8
+    depth_single_blocks: int = 48
+    axes_dim: list[int] = field(default_factory=lambda: [32, 32, 32, 32])
+    theta: int = 2000
+    mlp_ratio: float = 3.0
+    use_guidance_embed: bool = True
+
+
+@dataclass
+class Klein9BParams(Flux2Params):
+    context_in_dim: int = 12288
+    hidden_size: int = 4096
+    num_heads: int = 32
+    depth: int = 8
+    depth_single_blocks: int = 24
+    axes_dim: list[int] = field(default_factory=lambda: [32, 32, 32, 32])
+    theta: int = 2000
+    mlp_ratio: float = 3.0
+    use_guidance_embed: bool = False
+
+
+@dataclass
+class Klein4BParams(Flux2Params):
+    context_in_dim: int = 7680
+    hidden_size: int = 3072
+    num_heads: int = 24
+    depth: int = 5
+    depth_single_blocks: int = 20
+    axes_dim: list[int] = field(default_factory=lambda: [32, 32, 32, 32])
+    theta: int = 2000
+    mlp_ratio: float = 3.0
+    use_guidance_embed: bool = False
+
+
+# region autoencoder
+
+
+@dataclass
+class AutoEncoderParams:
+    resolution: int = 256
+    in_channels: int = 3
+    ch: int = 128
+    out_ch: int = 3
+    ch_mult: list[int] = field(default_factory=lambda: [1, 2, 4, 4])
+    num_res_blocks: int = 2
+    z_channels: int = 32
+
+
+def swish(x: Tensor) -> Tensor:
+    return x * torch.sigmoid(x)
+
+
+class AttnBlock(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.in_channels = in_channels
+
+        self.norm = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+
+        self.q = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.k = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.v = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+        self.proj_out = nn.Conv2d(in_channels, in_channels, kernel_size=1)
+
+    def attention(self, h_: Tensor) -> Tensor:
+        h_ = self.norm(h_)
+        q = self.q(h_)
+        k = self.k(h_)
+        v = self.v(h_)
+
+        b, c, h, w = q.shape
+        q = rearrange(q, "b c h w -> b 1 (h w) c").contiguous()
+        k = rearrange(k, "b c h w -> b 1 (h w) c").contiguous()
+        v = rearrange(v, "b c h w -> b 1 (h w) c").contiguous()
+        h_ = nn.functional.scaled_dot_product_attention(q, k, v)
+
+        return rearrange(h_, "b 1 (h w) c -> b c h w", h=h, w=w, c=c, b=b)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return x + self.proj_out(self.attention(x))
+
+
+class ResnetBlock(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int):
+        super().__init__()
+        self.in_channels = in_channels
+        out_channels = in_channels if out_channels is None else out_channels
+        self.out_channels = out_channels
+
+        self.norm1 = nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
+        self.conv1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        self.norm2 = nn.GroupNorm(num_groups=32, num_channels=out_channels, eps=1e-6, affine=True)
+        self.conv2 = nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)
+        if self.in_channels != self.out_channels:
+            self.nin_shortcut = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x):
+        h = x
+        h = self.norm1(h)
+        h = swish(h)
+        h = self.conv1(h)
+
+        h = self.norm2(h)
+        h = swish(h)
+        h = self.conv2(h)
+
+        if self.in_channels != self.out_channels:
+            x = self.nin_shortcut(x)
+
+        return x + h
+
+
+class Downsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        # no asymmetric padding in torch conv, must do it ourselves
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=2, padding=0)
+
+    def forward(self, x: Tensor):
+        pad = (0, 1, 0, 1)
+        x = nn.functional.pad(x, pad, mode="constant", value=0)
+        x = self.conv(x)
+        return x
+
+
+class Upsample(nn.Module):
+    def __init__(self, in_channels: int):
+        super().__init__()
+        self.conv = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor):
+        x = nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
+        x = self.conv(x)
+        return x
+
+
+class Encoder(nn.Module):
+    def __init__(
+        self,
+        resolution: int,
+        in_channels: int,
+        ch: int,
+        ch_mult: list[int],
+        num_res_blocks: int,
+        z_channels: int,
+    ):
+        super().__init__()
+        self.quant_conv = torch.nn.Conv2d(2 * z_channels, 2 * z_channels, 1)
+        self.ch = ch
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        # downsampling
+        self.conv_in = nn.Conv2d(in_channels, self.ch, kernel_size=3, stride=1, padding=1)
+
+        curr_res = resolution
+        in_ch_mult = (1,) + tuple(ch_mult)
+        self.in_ch_mult = in_ch_mult
+        self.down = nn.ModuleList()
+        block_in = self.ch
+        for i_level in range(self.num_resolutions):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_in = ch * in_ch_mult[i_level]
+            block_out = ch * ch_mult[i_level]
+            for _ in range(self.num_res_blocks):
+                block.append(ResnetBlock(in_channels=block_in, out_channels=block_out))
+                block_in = block_out
+            down = nn.Module()
+            down.block = block
+            down.attn = attn
+            if i_level != self.num_resolutions - 1:
+                down.downsample = Downsample(block_in)
+                curr_res = curr_res // 2
+            self.down.append(down)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+
+        # end
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, 2 * z_channels, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        # downsampling
+        hs = [self.conv_in(x)]
+        for i_level in range(self.num_resolutions):
+            for i_block in range(self.num_res_blocks):
+                h = self.down[i_level].block[i_block](hs[-1])
+                if len(self.down[i_level].attn) > 0:
+                    h = self.down[i_level].attn[i_block](h)
+                hs.append(h)
+            if i_level != self.num_resolutions - 1:
+                hs.append(self.down[i_level].downsample(hs[-1]))
+
+        # middle
+        h = hs[-1]
+        h = self.mid.block_1(h)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h)
+        # end
+        h = self.norm_out(h)
+        h = swish(h)
+        h = self.conv_out(h)
+        h = self.quant_conv(h)
+        return h
+
+
+class Decoder(nn.Module):
+    def __init__(
+        self,
+        ch: int,
+        out_ch: int,
+        ch_mult: list[int],
+        num_res_blocks: int,
+        in_channels: int,
+        resolution: int,
+        z_channels: int,
+    ):
+        super().__init__()
+        self.post_quant_conv = torch.nn.Conv2d(z_channels, z_channels, 1)
+        self.ch = ch
+        self.num_resolutions = len(ch_mult)
+        self.num_res_blocks = num_res_blocks
+        self.resolution = resolution
+        self.in_channels = in_channels
+        self.ffactor = 2 ** (self.num_resolutions - 1)
+
+        # compute in_ch_mult, block_in and curr_res at lowest res
+        block_in = ch * ch_mult[self.num_resolutions - 1]
+        curr_res = resolution // 2 ** (self.num_resolutions - 1)
+        self.z_shape = (1, z_channels, curr_res, curr_res)
+
+        # z to block_in
+        self.conv_in = nn.Conv2d(z_channels, block_in, kernel_size=3, stride=1, padding=1)
+
+        # middle
+        self.mid = nn.Module()
+        self.mid.block_1 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+        self.mid.attn_1 = AttnBlock(block_in)
+        self.mid.block_2 = ResnetBlock(in_channels=block_in, out_channels=block_in)
+
+        # upsampling
+        self.up = nn.ModuleList()
+        for i_level in reversed(range(self.num_resolutions)):
+            block = nn.ModuleList()
+            attn = nn.ModuleList()
+            block_out = ch * ch_mult[i_level]
+            for _ in range(self.num_res_blocks + 1):
+                block.append(ResnetBlock(in_channels=block_in, out_channels=block_out))
+                block_in = block_out
+            up = nn.Module()
+            up.block = block
+            up.attn = attn
+            if i_level != 0:
+                up.upsample = Upsample(block_in)
+                curr_res = curr_res * 2
+            self.up.insert(0, up)  # prepend to get consistent order
+
+        # end
+        self.norm_out = nn.GroupNorm(num_groups=32, num_channels=block_in, eps=1e-6, affine=True)
+        self.conv_out = nn.Conv2d(block_in, out_ch, kernel_size=3, stride=1, padding=1)
+
+    def forward(self, z: Tensor) -> Tensor:
+        z = self.post_quant_conv(z)
+
+        # get dtype for proper tracing
+        upscale_dtype = next(self.up.parameters()).dtype
+
+        # z to block_in
+        h = self.conv_in(z)
+
+        # middle
+        h = self.mid.block_1(h)
+        h = self.mid.attn_1(h)
+        h = self.mid.block_2(h)
+
+        # cast to proper dtype
+        h = h.to(upscale_dtype)
+        # upsampling
+        for i_level in reversed(range(self.num_resolutions)):
+            for i_block in range(self.num_res_blocks + 1):
+                h = self.up[i_level].block[i_block](h)
+                if len(self.up[i_level].attn) > 0:
+                    h = self.up[i_level].attn[i_block](h)
+            if i_level != 0:
+                h = self.up[i_level].upsample(h)
+
+        # end
+        h = self.norm_out(h)
+        h = swish(h)
+        h = self.conv_out(h)
+        return h
+
+
+class AutoEncoder(nn.Module):
+    def __init__(self, params: AutoEncoderParams):
+        super().__init__()
+        self.params = params
+        self.encoder = Encoder(
+            resolution=params.resolution,
+            in_channels=params.in_channels,
+            ch=params.ch,
+            ch_mult=params.ch_mult,
+            num_res_blocks=params.num_res_blocks,
+            z_channels=params.z_channels,
+        )
+        self.decoder = Decoder(
+            resolution=params.resolution,
+            in_channels=params.in_channels,
+            ch=params.ch,
+            out_ch=params.out_ch,
+            ch_mult=params.ch_mult,
+            num_res_blocks=params.num_res_blocks,
+            z_channels=params.z_channels,
+        )
+
+        self.bn_eps = 1e-4
+        self.bn_momentum = 0.1
+        self.ps = [2, 2]
+        self.bn = torch.nn.BatchNorm2d(
+            math.prod(self.ps) * params.z_channels,
+            eps=self.bn_eps,
+            momentum=self.bn_momentum,
+            affine=False,
+            track_running_stats=True,
+        )
+
+    def normalize(self, z):
+        self.bn.eval()
+        return self.bn(z)
+
+    def inv_normalize(self, z):
+        self.bn.eval()
+        s = torch.sqrt(self.bn.running_var.view(1, -1, 1, 1) + self.bn_eps)
+        m = self.bn.running_mean.view(1, -1, 1, 1)
+        return z * s + m
+
+    def encode(self, x: Tensor) -> Tensor:
+        moments = self.encoder(x)
+        mean = torch.chunk(moments, 2, dim=1)[0]
+
+        z = rearrange(
+            mean,
+            "... c (i pi) (j pj)  -> ... (c pi pj) i j",
+            pi=self.ps[0],
+            pj=self.ps[1],
+        )
+        z = self.normalize(z)
+        return z
+
+    def decode(self, z: Tensor) -> Tensor:
+        z = self.inv_normalize(z)
+        z = rearrange(
+            z,
+            "... (c pi pj) i j -> ... c (i pi) (j pj)",
+            pi=self.ps[0],
+            pj=self.ps[1],
+        )
+        dec = self.decoder(z)
+        return dec
+
+    @property
+    def device(self) -> torch.device:
+        return next(self.parameters()).device
+
+    @property
+    def dtype(self) -> torch.dtype:
+        return next(self.parameters()).dtype
+
+
+# endregion
+
+# region model
+
+
+class Flux2(nn.Module):
+    def __init__(self, params: Flux2Params, attn_mode: str = "flash", split_attn: bool = False) -> None:
+        super().__init__()
+
+        self.in_channels = params.in_channels
+        self.out_channels = params.in_channels
+        if params.hidden_size % params.num_heads != 0:
+            raise ValueError(f"Hidden size {params.hidden_size} must be divisible by num_heads {params.num_heads}")
+        pe_dim = params.hidden_size // params.num_heads
+        if sum(params.axes_dim) != pe_dim:
+            raise ValueError(f"Got {params.axes_dim} but expected positional dim {pe_dim}")
+        self.hidden_size = params.hidden_size
+        self.num_heads = params.num_heads
+
+        self.pe_embedder = EmbedND(dim=pe_dim, theta=params.theta, axes_dim=params.axes_dim)
+        self.img_in = nn.Linear(self.in_channels, self.hidden_size, bias=False)
+        self.time_in = MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size, disable_bias=True)
+        self.txt_in = nn.Linear(params.context_in_dim, self.hidden_size, bias=False)
+
+        self.use_guidance_embed = params.use_guidance_embed
+        if self.use_guidance_embed:
+            self.guidance_in = MLPEmbedder(in_dim=256, hidden_dim=self.hidden_size, disable_bias=True)
+
+        self.attn_mode = attn_mode
+        self.split_attn = split_attn
+
+        self.double_blocks = nn.ModuleList(
+            [DoubleStreamBlock(self.hidden_size, self.num_heads, mlp_ratio=params.mlp_ratio) for _ in range(params.depth)]
+        )
+        self.single_blocks = nn.ModuleList(
+            [
+                SingleStreamBlock(self.hidden_size, self.num_heads, mlp_ratio=params.mlp_ratio)
+                for _ in range(params.depth_single_blocks)
+            ]
+        )
+
+        self.double_stream_modulation_img = Modulation(self.hidden_size, double=True, disable_bias=True)
+        self.double_stream_modulation_txt = Modulation(self.hidden_size, double=True, disable_bias=True)
+        self.single_stream_modulation = Modulation(self.hidden_size, double=False, disable_bias=True)
+
+        self.final_layer = LastLayer(self.hidden_size, self.out_channels)
+
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+        self.blocks_to_swap = None
+
+        self.offloader_double = None
+        self.offloader_single = None
+        self.num_double_blocks = len(self.double_blocks)
+        self.num_single_blocks = len(self.single_blocks)
+
+    def get_model_type(self) -> str:
+        return "flux_2"
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    @property
+    def dtype(self):
+        return next(self.parameters()).dtype
+
+    def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False):
+        self.gradient_checkpointing = True
+        self.activation_cpu_offloading = activation_cpu_offloading
+
+        self.time_in.enable_gradient_checkpointing()
+        if self.use_guidance_embed and self.guidance_in.__class__ != nn.Identity:
+            self.guidance_in.enable_gradient_checkpointing()
+
+        for block in self.double_blocks + self.single_blocks:
+            block.enable_gradient_checkpointing(activation_cpu_offloading)
+
+        print(f"FLUX2: Gradient checkpointing enabled. Activation CPU offloading: {activation_cpu_offloading}")
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+
+        self.time_in.disable_gradient_checkpointing()
+        if self.use_guidance_embed and self.guidance_in.__class__ != nn.Identity:
+            self.guidance_in.disable_gradient_checkpointing()
+
+        for block in self.double_blocks + self.single_blocks:
+            block.disable_gradient_checkpointing()
+
+        print("FLUX2: Gradient checkpointing disabled.")
+
+    def enable_block_swap(self, num_blocks: int, device: torch.device, supports_backward: bool, use_pinned_memory: bool = False):
+        self.blocks_to_swap = num_blocks
+        if num_blocks <= 0:
+            double_blocks_to_swap = 0
+            single_blocks_to_swap = 0
+        elif self.num_double_blocks == 0:
+            double_blocks_to_swap = 0
+            single_blocks_to_swap = num_blocks
+        elif self.num_single_blocks == 0:
+            double_blocks_to_swap = num_blocks
+            single_blocks_to_swap = 0
+        else:
+            swap_ratio = self.num_single_blocks / self.num_double_blocks
+            double_blocks_to_swap = int(round(num_blocks / (1.0 + swap_ratio / 2.0)))
+            single_blocks_to_swap = int(round(double_blocks_to_swap * swap_ratio))
+
+            # adjust if we exceed available blocks
+            if self.num_double_blocks * 2 < self.num_single_blocks:
+                while double_blocks_to_swap >= 1 and double_blocks_to_swap > self.num_double_blocks - 2:
+                    double_blocks_to_swap -= 1
+                    single_blocks_to_swap += 2
+            else:
+                while single_blocks_to_swap >= 2 and single_blocks_to_swap > self.num_single_blocks - 2:
+                    single_blocks_to_swap -= 2
+                    double_blocks_to_swap += 1
+
+            if double_blocks_to_swap == 0 and single_blocks_to_swap == 0:
+                if self.num_single_blocks >= self.num_double_blocks:
+                    single_blocks_to_swap = 1
+                else:
+                    double_blocks_to_swap = 1
+
+        assert double_blocks_to_swap <= self.num_double_blocks - 2 and single_blocks_to_swap <= self.num_single_blocks - 2, (
+            f"Cannot swap more than {self.num_double_blocks - 2} double blocks and {self.num_single_blocks - 2} single blocks. "
+            f"Requested {double_blocks_to_swap} double blocks and {single_blocks_to_swap} single blocks."
+        )
+
+        self.offloader_double = ModelOffloader(
+            "double",
+            self.double_blocks,
+            self.num_double_blocks,
+            double_blocks_to_swap,
+            supports_backward,
+            device,
+            use_pinned_memory,
+            # , debug=True
+        )
+        self.offloader_single = ModelOffloader(
+            "single",
+            self.single_blocks,
+            self.num_single_blocks,
+            single_blocks_to_swap,
+            supports_backward,
+            device,
+            use_pinned_memory,
+            # , debug=True
+        )
+        print(
+            f"FLUX: Block swap enabled. Swapping {num_blocks} blocks, double blocks: {double_blocks_to_swap}, single blocks: {single_blocks_to_swap}."
+        )
+
+    def switch_block_swap_for_inference(self):
+        if self.blocks_to_swap:
+            self.offloader_double.set_forward_only(True)
+            self.offloader_single.set_forward_only(True)
+            self.prepare_block_swap_before_forward()
+            print("FLUX: Block swap set to forward only.")
+
+    def switch_block_swap_for_training(self):
+        if self.blocks_to_swap:
+            self.offloader_double.set_forward_only(False)
+            self.offloader_single.set_forward_only(False)
+            self.prepare_block_swap_before_forward()
+            print("FLUX: Block swap set to forward and backward.")
+
+    def move_to_device_except_swap_blocks(self, device: torch.device):
+        # assume model is on cpu. do not move blocks to device to reduce temporary memory usage
+        if self.blocks_to_swap:
+            save_double_blocks = self.double_blocks
+            save_single_blocks = self.single_blocks
+            self.double_blocks = nn.ModuleList()
+            self.single_blocks = nn.ModuleList()
+
+        self.to(device)
+
+        if self.blocks_to_swap:
+            self.double_blocks = save_double_blocks
+            self.single_blocks = save_single_blocks
+
+    def prepare_block_swap_before_forward(self):
+        if self.blocks_to_swap is None or self.blocks_to_swap == 0:
+            return
+        self.offloader_double.prepare_block_devices_before_forward(self.double_blocks)
+        self.offloader_single.prepare_block_devices_before_forward(self.single_blocks)
+
+    def forward(self, x: Tensor, x_ids: Tensor, timesteps: Tensor, ctx: Tensor, ctx_ids: Tensor, guidance: Tensor | None) -> Tensor:
+        num_txt_tokens = ctx.shape[1]
+
+        timestep_emb = timestep_embedding(timesteps, 256)
+        del timesteps
+        vec = self.time_in(timestep_emb)
+        del timestep_emb
+        if self.use_guidance_embed:
+            guidance_emb = timestep_embedding(guidance, 256)
+            vec = vec + self.guidance_in(guidance_emb)
+            del guidance_emb
+
+        double_block_mod_img = self.double_stream_modulation_img(vec)
+        double_block_mod_txt = self.double_stream_modulation_txt(vec)
+        single_block_mod, _ = self.single_stream_modulation(vec)
+
+        img = self.img_in(x)
+        del x
+        txt = self.txt_in(ctx)
+        del ctx
+        pe_x = self.pe_embedder(x_ids)
+        del x_ids
+        pe_ctx = self.pe_embedder(ctx_ids)
+        del ctx_ids
+
+        attn_params = AttentionParams.create_attention_params(self.attn_mode, self.split_attn)  # No attention mask
+
+        for block_idx, block in enumerate(self.double_blocks):
+            if self.blocks_to_swap:
+                self.offloader_double.wait_for_block(block_idx)
+
+            img, txt = block(img, txt, pe_x, pe_ctx, double_block_mod_img, double_block_mod_txt, attn_params)
+
+            if self.blocks_to_swap:
+                self.offloader_double.submit_move_blocks_forward(self.double_blocks, block_idx)
+
+        del double_block_mod_img, double_block_mod_txt
+
+        img = torch.cat((txt, img), dim=1)
+        del txt
+        pe = torch.cat((pe_ctx, pe_x), dim=2)
+        del pe_ctx, pe_x
+
+        for block_idx, block in enumerate(self.single_blocks):
+            if self.blocks_to_swap:
+                self.offloader_single.wait_for_block(block_idx)
+
+            img = block(img, pe, single_block_mod, attn_params)
+
+            if self.blocks_to_swap:
+                self.offloader_single.submit_move_blocks_forward(self.single_blocks, block_idx)
+
+        del single_block_mod, pe
+
+        img = img.to(vec.device)  # move to gpu if gradient checkpointing cpu offloading is used
+
+        img = img[:, num_txt_tokens:, ...]
+
+        img = self.final_layer(img, vec)
+        return img
+
+
+class SelfAttention(nn.Module):
+    def __init__(self, dim: int, num_heads: int = 8):
+        super().__init__()
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.qkv = nn.Linear(dim, dim * 3, bias=False)
+
+        self.norm = QKNorm(head_dim)
+        self.proj = nn.Linear(dim, dim, bias=False)
+
+
+class SiLUActivation(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.gate_fn = nn.SiLU()
+
+    def forward(self, x: Tensor) -> Tensor:
+        x1, x2 = x.chunk(2, dim=-1)
+        return self.gate_fn(x1) * x2
+
+
+class Modulation(nn.Module):
+    def __init__(self, dim: int, double: bool, disable_bias: bool = False):
+        super().__init__()
+        self.is_double = double
+        self.multiplier = 6 if double else 3
+        self.lin = nn.Linear(dim, self.multiplier * dim, bias=not disable_bias)
+
+    def forward(self, vec: torch.Tensor):
+        org_dtype = vec.dtype
+        vec = vec.to(torch.float32)  # for numerical stability
+        out = self.lin(nn.functional.silu(vec))
+        if out.ndim == 2:
+            out = out[:, None, :]
+        out = out.to(org_dtype)
+        out = out.chunk(self.multiplier, dim=-1)
+        return out[:3], out[3:] if self.is_double else None
+
+
+class LastLayer(nn.Module):
+    def __init__(self, hidden_size: int, out_channels: int):
+        super().__init__()
+        self.norm_final = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.linear = nn.Linear(hidden_size, out_channels, bias=False)
+        self.adaLN_modulation = nn.Sequential(nn.SiLU(), nn.Linear(hidden_size, 2 * hidden_size, bias=False))
+
+    def forward(self, x: torch.Tensor, vec: torch.Tensor) -> torch.Tensor:
+        org_dtype = x.dtype
+        vec = vec.to(torch.float32)  # for numerical stability
+        mod = self.adaLN_modulation(vec)
+        shift, scale = mod.chunk(2, dim=-1)
+        if shift.ndim == 2:
+            shift = shift[:, None, :]
+            scale = scale[:, None, :]
+        x = x.to(torch.float32)  # for numerical stability
+        x = (1 + scale) * self.norm_final(x) + shift
+        x = self.linear(x)
+        return x.to(org_dtype)
+
+
+class SingleStreamBlock(nn.Module):
+    def __init__(self, hidden_size: int, num_heads: int, mlp_ratio: float = 4.0):
+        super().__init__()
+
+        self.hidden_dim = hidden_size
+        self.num_heads = num_heads
+        head_dim = hidden_size // num_heads
+        self.scale = head_dim**-0.5
+        self.mlp_hidden_dim = int(hidden_size * mlp_ratio)
+        self.mlp_mult_factor = 2
+
+        self.linear1 = nn.Linear(hidden_size, hidden_size * 3 + self.mlp_hidden_dim * self.mlp_mult_factor, bias=False)
+        self.linear2 = nn.Linear(hidden_size + self.mlp_hidden_dim, hidden_size, bias=False)
+
+        self.norm = QKNorm(head_dim)
+        self.hidden_size = hidden_size
+        self.pre_norm = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.mlp_act = SiLUActivation()
+
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False):
+        self.gradient_checkpointing = True
+        self.activation_cpu_offloading = activation_cpu_offloading
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def _forward(self, x: Tensor, pe: Tensor, mod: tuple[Tensor, Tensor], attn_params: AttentionParams) -> Tensor:
+        mod_shift, mod_scale, mod_gate = mod
+        del mod
+        x_mod = (1 + mod_scale) * self.pre_norm(x) + mod_shift
+        del mod_scale, mod_shift
+
+        qkv, mlp = torch.split(self.linear1(x_mod), [3 * self.hidden_size, self.mlp_hidden_dim * self.mlp_mult_factor], dim=-1)
+
+        q, k, v = rearrange(qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads)
+        del qkv
+        q, k = self.norm(q, k, v)
+
+        qkv_list = [q, k, v]
+        del q, k, v
+        attn = attention(qkv_list, pe, attn_params)
+        del qkv_list, pe
+
+        # compute activation in mlp stream, cat again and run second linear layer
+        output = self.linear2(torch.cat((attn, self.mlp_act(mlp)), 2))
+        return x + mod_gate * output
+
+    def forward(self, x: Tensor, pe: Tensor, mod: tuple[Tensor, Tensor], attn_params: AttentionParams) -> Tensor:
+        if self.training and self.gradient_checkpointing:
+            forward_fn = self._forward
+            if self.activation_cpu_offloading:
+                forward_fn = create_cpu_offloading_wrapper(forward_fn, self.linear1.weight.device)
+            return checkpoint(forward_fn, x, pe, mod, attn_params, use_reentrant=False)
+        else:
+            return self._forward(x, pe, mod, attn_params)
+
+
+class DoubleStreamBlock(nn.Module):
+    def __init__(self, hidden_size: int, num_heads: int, mlp_ratio: float):
+        super().__init__()
+        mlp_hidden_dim = int(hidden_size * mlp_ratio)
+        self.num_heads = num_heads
+        assert hidden_size % num_heads == 0, f"{hidden_size=} must be divisible by {num_heads=}"
+
+        self.hidden_size = hidden_size
+        self.img_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.mlp_mult_factor = 2
+
+        self.img_attn = SelfAttention(dim=hidden_size, num_heads=num_heads)
+        self.img_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.img_mlp = nn.Sequential(
+            nn.Linear(hidden_size, mlp_hidden_dim * self.mlp_mult_factor, bias=False),
+            SiLUActivation(),
+            nn.Linear(mlp_hidden_dim, hidden_size, bias=False),
+        )
+
+        self.txt_norm1 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.txt_attn = SelfAttention(dim=hidden_size, num_heads=num_heads)
+        self.txt_norm2 = nn.LayerNorm(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.txt_mlp = nn.Sequential(
+            nn.Linear(hidden_size, mlp_hidden_dim * self.mlp_mult_factor, bias=False),
+            SiLUActivation(),
+            nn.Linear(mlp_hidden_dim, hidden_size, bias=False),
+        )
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def enable_gradient_checkpointing(self, activation_cpu_offloading: bool = False):
+        self.gradient_checkpointing = True
+        self.activation_cpu_offloading = activation_cpu_offloading
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+
+    def _forward(
+        self,
+        img: Tensor,
+        txt: Tensor,
+        pe: Tensor,
+        pe_ctx: Tensor,
+        mod_img: tuple[Tensor, Tensor],
+        mod_txt: tuple[Tensor, Tensor],
+        attn_params: AttentionParams,
+    ) -> tuple[Tensor, Tensor]:
+        img_mod1, img_mod2 = mod_img
+        txt_mod1, txt_mod2 = mod_txt
+        del mod_img, mod_txt
+
+        img_mod1_shift, img_mod1_scale, img_mod1_gate = img_mod1
+        img_mod2_shift, img_mod2_scale, img_mod2_gate = img_mod2
+        txt_mod1_shift, txt_mod1_scale, txt_mod1_gate = txt_mod1
+        txt_mod2_shift, txt_mod2_scale, txt_mod2_gate = txt_mod2
+        del img_mod1, img_mod2, txt_mod1, txt_mod2
+
+        # prepare image for attention
+        img_modulated = self.img_norm1(img)
+        img_modulated = (1 + img_mod1_scale) * img_modulated + img_mod1_shift
+        del img_mod1_scale, img_mod1_shift
+
+        img_qkv = self.img_attn.qkv(img_modulated)
+        del img_modulated
+        img_q, img_k, img_v = rearrange(img_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads)
+        del img_qkv
+        img_q, img_k = self.img_attn.norm(img_q, img_k, img_v)
+
+        # prepare txt for attention
+        txt_modulated = self.txt_norm1(txt)
+        txt_modulated = (1 + txt_mod1_scale) * txt_modulated + txt_mod1_shift
+        del txt_mod1_scale, txt_mod1_shift
+        txt_qkv = self.txt_attn.qkv(txt_modulated)
+        del txt_modulated
+        txt_q, txt_k, txt_v = rearrange(txt_qkv, "B L (K H D) -> K B H L D", K=3, H=self.num_heads)
+        del txt_qkv
+        txt_q, txt_k = self.txt_attn.norm(txt_q, txt_k, txt_v)
+
+        txt_len = txt_q.shape[2]
+        q = torch.cat((txt_q, img_q), dim=2)
+        del txt_q, img_q
+        k = torch.cat((txt_k, img_k), dim=2)
+        del txt_k, img_k
+        v = torch.cat((txt_v, img_v), dim=2)
+        del txt_v, img_v
+
+        pe = torch.cat((pe_ctx, pe), dim=2)
+        del pe_ctx
+        qkv_list = [q, k, v]
+        del q, k, v
+        attn = attention(qkv_list, pe, attn_params)
+        del qkv_list, pe
+        txt_attn, img_attn = attn[:, :txt_len], attn[:, txt_len:]
+        del attn
+
+        # calculate the img blocks
+        img = img + img_mod1_gate * self.img_attn.proj(img_attn)
+        del img_mod1_gate, img_attn
+        img = img + img_mod2_gate * self.img_mlp((1 + img_mod2_scale) * (self.img_norm2(img)) + img_mod2_shift)
+        del img_mod2_gate, img_mod2_scale, img_mod2_shift
+
+        # calculate the txt blocks
+        txt = txt + txt_mod1_gate * self.txt_attn.proj(txt_attn)
+        del txt_mod1_gate, txt_attn
+        txt = txt + txt_mod2_gate * self.txt_mlp((1 + txt_mod2_scale) * (self.txt_norm2(txt)) + txt_mod2_shift)
+        del txt_mod2_gate, txt_mod2_scale, txt_mod2_shift
+        return img, txt
+
+    def forward(
+        self,
+        img: Tensor,
+        txt: Tensor,
+        pe: Tensor,
+        pe_ctx: Tensor,
+        mod_img: tuple[Tensor, Tensor],
+        mod_txt: tuple[Tensor, Tensor],
+        attn_params: AttentionParams,
+    ) -> tuple[Tensor, Tensor]:
+        if self.training and self.gradient_checkpointing:
+            forward_fn = self._forward
+            if self.activation_cpu_offloading:
+                forward_fn = create_cpu_offloading_wrapper(forward_fn, self.img_mlp[0].weight.device)
+            return checkpoint(forward_fn, img, txt, pe, pe_ctx, mod_img, mod_txt, attn_params, use_reentrant=False)
+        else:
+            return self._forward(img, txt, pe, pe_ctx, mod_img, mod_txt, attn_params)
+
+
+class MLPEmbedder(nn.Module):
+    def __init__(self, in_dim: int, hidden_dim: int, disable_bias: bool = False):
+        super().__init__()
+        self.in_layer = nn.Linear(in_dim, hidden_dim, bias=not disable_bias)
+        self.silu = nn.SiLU()
+        self.out_layer = nn.Linear(hidden_dim, hidden_dim, bias=not disable_bias)
+        self.gradient_checkpointing = False
+
+    def enable_gradient_checkpointing(self):
+        self.gradient_checkpointing = True
+
+    def disable_gradient_checkpointing(self):
+        self.gradient_checkpointing = False
+
+    def _forward(self, x: Tensor) -> Tensor:
+        return self.out_layer(self.silu(self.in_layer(x)))
+
+    def forward(self, *args, **kwargs):
+        if self.training and self.gradient_checkpointing:
+            return checkpoint(self._forward, *args, use_reentrant=False, **kwargs)
+        else:
+            return self._forward(*args, **kwargs)
+
+
+class EmbedND(nn.Module):
+    def __init__(self, dim: int, theta: int, axes_dim: list[int]):
+        super().__init__()
+        self.dim = dim
+        self.theta = theta
+        self.axes_dim = axes_dim
+
+    def forward(self, ids: Tensor) -> Tensor:
+        emb = torch.cat([rope(ids[..., i], self.axes_dim[i], self.theta) for i in range(len(self.axes_dim))], dim=-3)
+        return emb.unsqueeze(1)
+
+
+def timestep_embedding(t: Tensor, dim, max_period=10000, time_factor: float = 1000.0):
+    """
+    Create sinusoidal timestep embeddings.
+    :param t: a 1-D Tensor of N indices, one per batch element.
+                      These may be fractional.
+    :param dim: the dimension of the output.
+    :param max_period: controls the minimum frequency of the embeddings.
+    :return: an (N, D) Tensor of positional embeddings.
+    """
+    t = time_factor * t
+    half = dim // 2
+    freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, device=t.device, dtype=torch.float32) / half)
+
+    args = t[:, None].float() * freqs[None]
+    embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+    if dim % 2:
+        embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+    if torch.is_floating_point(t):
+        embedding = embedding.to(t)
+    return embedding
+
+
+class RMSNorm(torch.nn.Module):
+    def __init__(self, dim: int):
+        super().__init__()
+        self.scale = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: Tensor):
+        x_dtype = x.dtype
+        x = x.float()
+        rrms = torch.rsqrt(torch.mean(x**2, dim=-1, keepdim=True) + 1e-6)
+        return (x * rrms).to(dtype=x_dtype) * self.scale
+
+
+class QKNorm(torch.nn.Module):
+    def __init__(self, dim: int):
+        super().__init__()
+        self.query_norm = RMSNorm(dim)
+        self.key_norm = RMSNorm(dim)
+
+    def forward(self, q: Tensor, k: Tensor, v: Tensor) -> tuple[Tensor, Tensor]:
+        q = self.query_norm(q)
+        k = self.key_norm(k)
+        return q.to(v), k.to(v)
+
+
+def attention(qkv_list: list[Tensor], pe: Tensor, attn_params: AttentionParams) -> Tensor:
+    q, k, v = qkv_list
+    del qkv_list
+    q, k = apply_rope(q, k, pe)
+
+    q = q.transpose(1, 2)  # B, H, L, D -> B, L, H, D
+    k = k.transpose(1, 2)  # B, H, L, D -> B, L, H, D
+    v = v.transpose(1, 2)  # B, H, L, D -> B, L, H, D
+    qkv_list = [q, k, v]
+    del q, k, v
+    x = unified_attention(qkv_list, attn_params=attn_params)
+    return x
+
+
+def rope(pos: Tensor, dim: int, theta: int) -> Tensor:
+    assert dim % 2 == 0
+    scale = torch.arange(0, dim, 2, dtype=torch.float64, device=pos.device) / dim
+    omega = 1.0 / (theta**scale)
+    out = torch.einsum("...n,d->...nd", pos, omega)
+    out = torch.stack([torch.cos(out), -torch.sin(out), torch.sin(out), torch.cos(out)], dim=-1)
+    out = rearrange(out, "b n d (i j) -> b n d i j", i=2, j=2)
+    return out.float()
+
+
+def apply_rope(xq: Tensor, xk: Tensor, freqs_cis: Tensor) -> tuple[Tensor, Tensor]:
+    xq_ = xq.float().reshape(*xq.shape[:-1], -1, 1, 2)
+    xk_ = xk.float().reshape(*xk.shape[:-1], -1, 1, 2)
+    xq_out = freqs_cis[..., 0] * xq_[..., 0] + freqs_cis[..., 1] * xq_[..., 1]
+    xk_out = freqs_cis[..., 0] * xk_[..., 0] + freqs_cis[..., 1] * xk_[..., 1]
+    return xq_out.reshape(*xq.shape).type_as(xq), xk_out.reshape(*xk.shape).type_as(xk)
+
+
+# endregion

src/musubi_tuner/flux_2/flux2_utils.py

@@ -0,0 +1,816 @@
+import argparse
+import json
+import numpy as np
+import torch
+import math
+
+
+from dataclasses import dataclass
+from accelerate import init_empty_weights
+from einops import rearrange
+from PIL import Image
+from typing import Optional, Tuple, Union
+from torch import Tensor
+from torch import nn
+from transformers import (
+    Mistral3ForConditionalGeneration,
+    Mistral3Config,
+    AutoProcessor,
+    Qwen2Tokenizer,
+    Qwen3ForCausalLM,
+)
+from tqdm import tqdm
+
+from musubi_tuner.dataset.image_video_dataset import (
+    ARCHITECTURE_FLUX_2_DEV,
+    ARCHITECTURE_FLUX_2_DEV_FULL,
+    ARCHITECTURE_FLUX_2_KLEIN_4B,
+    ARCHITECTURE_FLUX_2_KLEIN_4B_FULL,
+    ARCHITECTURE_FLUX_2_KLEIN_9B,
+    ARCHITECTURE_FLUX_2_KLEIN_9B_FULL,
+    BucketSelector,
+)
+from musubi_tuner.modules.fp8_optimization_utils import apply_fp8_monkey_patch
+from musubi_tuner.utils import image_utils
+from musubi_tuner.utils.lora_utils import load_safetensors_with_lora_and_fp8
+from musubi_tuner.zimage.zimage_utils import load_qwen3
+
+from .flux2_models import Flux2, Flux2Params, Klein4BParams, Klein9BParams
+
+from musubi_tuner.flux_2 import flux2_models
+from musubi_tuner.utils.safetensors_utils import load_split_weights
+
+import logging
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+M3_TOKENIZER_ID = "mistralai/Mistral-Small-3.1-24B-Instruct-2503"
+OUTPUT_LAYERS_MISTRAL = [10, 20, 30]
+OUTPUT_LAYERS_QWEN3 = [9, 18, 27]
+MAX_LENGTH = 512
+UPSAMPLING_MAX_IMAGE_SIZE = 768**2
+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."""
+
+
+@dataclass(frozen=True)
+class Flux2ModelInfo:
+    params: Flux2Params
+    defaults: dict[str, float | int]
+    fixed_params: set[str]
+    guidance_distilled: bool
+    architecture: str
+    architecture_full: str
+    qwen_variant: Optional[str] = None  # None for Mistral
+
+
+FLUX2_MODEL_INFO = {
+    "klein-4b": Flux2ModelInfo(
+        params=Klein4BParams(),
+        qwen_variant="4B",
+        defaults={"guidance": 1.0, "num_steps": 4},
+        fixed_params={"guidance", "num_steps"},
+        guidance_distilled=True,
+        architecture=ARCHITECTURE_FLUX_2_KLEIN_4B,
+        architecture_full=ARCHITECTURE_FLUX_2_KLEIN_4B_FULL,
+    ),
+    "klein-base-4b": Flux2ModelInfo(
+        params=Klein4BParams(),
+        qwen_variant="4B",
+        defaults={"guidance": 4.0, "num_steps": 50},
+        fixed_params=set(),
+        guidance_distilled=False,
+        architecture=ARCHITECTURE_FLUX_2_KLEIN_4B,
+        architecture_full=ARCHITECTURE_FLUX_2_KLEIN_4B_FULL,
+    ),
+    "klein-9b": Flux2ModelInfo(
+        params=Klein9BParams(),
+        qwen_variant="8B",
+        defaults={"guidance": 1.0, "num_steps": 4},
+        fixed_params={"guidance", "num_steps"},
+        guidance_distilled=True,
+        architecture=ARCHITECTURE_FLUX_2_KLEIN_9B,
+        architecture_full=ARCHITECTURE_FLUX_2_KLEIN_9B_FULL,
+    ),
+    "klein-base-9b": Flux2ModelInfo(
+        params=Klein9BParams(),
+        qwen_variant="8B",
+        defaults={"guidance": 4.0, "num_steps": 50},
+        fixed_params=set(),
+        guidance_distilled=False,
+        architecture=ARCHITECTURE_FLUX_2_KLEIN_9B,
+        architecture_full=ARCHITECTURE_FLUX_2_KLEIN_9B_FULL,
+    ),
+    "dev": Flux2ModelInfo(
+        params=Flux2Params(),
+        defaults={"guidance": 4.0, "num_steps": 50},
+        fixed_params=set(),
+        guidance_distilled=True,
+        architecture=ARCHITECTURE_FLUX_2_DEV,
+        architecture_full=ARCHITECTURE_FLUX_2_DEV_FULL,
+    ),
+}
+
+
+def add_model_version_args(parser: argparse.ArgumentParser):
+    choices = list(FLUX2_MODEL_INFO.keys())
+    parser.add_argument("--model_version", type=str, default="dev", choices=choices, help="model version")
+
+
+def is_fp8(dt):
+    return dt in [torch.float8_e4m3fn, torch.float8_e4m3fnuz, torch.float8_e5m2, torch.float8_e5m2fnuz]
+
+
+def compress_time(t_ids: Tensor) -> Tensor:
+    assert t_ids.ndim == 1
+    t_ids_max = torch.max(t_ids)
+    t_remap = torch.zeros((t_ids_max + 1,), device=t_ids.device, dtype=t_ids.dtype)
+    t_unique_sorted_ids = torch.unique(t_ids, sorted=True)
+    t_remap[t_unique_sorted_ids] = torch.arange(len(t_unique_sorted_ids), device=t_ids.device, dtype=t_ids.dtype)
+    t_ids_compressed = t_remap[t_ids]
+    return t_ids_compressed
+
+
+def scatter_ids(x: Tensor, x_ids: Tensor) -> list[Tensor]:
+    """
+    using position ids to scatter tokens into place
+    """
+    x_list = []
+    t_coords = []
+    for data, pos in zip(x, x_ids):
+        _, ch = data.shape  # noqa: F841
+        t_ids = pos[:, 0].to(torch.int64)
+        h_ids = pos[:, 1].to(torch.int64)
+        w_ids = pos[:, 2].to(torch.int64)
+
+        t_ids_cmpr = compress_time(t_ids)
+
+        t = torch.max(t_ids_cmpr) + 1
+        h = torch.max(h_ids) + 1
+        w = torch.max(w_ids) + 1
+
+        flat_ids = t_ids_cmpr * w * h + h_ids * w + w_ids
+
+        out = torch.zeros((t * h * w, ch), device=data.device, dtype=data.dtype)
+        out.scatter_(0, flat_ids.unsqueeze(1).expand(-1, ch), data)
+
+        x_list.append(rearrange(out, "(t h w) c -> 1 c t h w", t=t, h=h, w=w))
+        t_coords.append(torch.unique(t_ids, sorted=True))
+    return x_list
+
+
+def pack_control_latent(control_latent: list[Tensor] | None) -> tuple[Optional[Tensor], Optional[Tensor]]:
+    if control_latent is None:
+        return None, None
+
+    scale = 10
+    ndim = control_latent[0].ndim  # 3 or 4
+
+    # Create time offsets for each reference
+    t_off = [scale + scale * t for t in torch.arange(0, len(control_latent))]
+    t_off = [t.view(-1) for t in t_off]
+
+    # Process with position IDs
+    ref_tokens, ref_ids = listed_prc_img(control_latent, t_coord=t_off)  # list[(HW, C)], list[(HW, 4)]
+
+    # Concatenate all references along sequence dimension
+    cat_dimension = 0 if ndim == 3 else 1
+    ref_tokens = torch.cat(ref_tokens, dim=cat_dimension)  # (total_ref_tokens, C) or (B, total_ref_tokens, C)
+    ref_ids = torch.cat(ref_ids, dim=cat_dimension)  # (total_ref_tokens, 4) or (B, total_ref_tokens, 4)
+
+    # Add batch dimension
+    if ndim == 3:
+        ref_tokens = ref_tokens.unsqueeze(0)  # (1, total_ref_tokens, C)
+        ref_ids = ref_ids.unsqueeze(0)  # (1, total_ref_tokens, 4)
+    return ref_tokens, ref_ids
+
+
+def prc_txt(x: Tensor, t_coord: Tensor | None = None) -> tuple[Tensor, Tensor]:
+    _l = x.shape[-2]
+
+    coords = {
+        "t": torch.arange(1) if t_coord is None else t_coord,
+        "h": torch.arange(1),  # dummy dimension
+        "w": torch.arange(1),  # dummy dimension
+        "l": torch.arange(_l),
+    }
+    x_ids = torch.cartesian_prod(coords["t"], coords["h"], coords["w"], coords["l"])
+    if x.ndim == 3:
+        x_ids = x_ids.unsqueeze(0).expand(x.shape[0], -1, -1)  # (B, L, 4)
+    return x, x_ids.to(x.device)
+
+
+# This function doesn't work properly, because t_coord is per-sample, but we need per-subsequence within sample
+# kept for reference
+# def batched_wrapper(fn):
+#     def batched_prc(x: Tensor, t_coord: Tensor | None = None) -> tuple[Tensor, Tensor]:
+#         results = []
+#         for i in range(len(x)):
+#             results.append(fn(x[i], t_coord[i] if t_coord is not None else None))
+#         x, x_ids = zip(*results)
+#         return torch.stack(x), torch.stack(x_ids)
+#     return batched_prc
+
+
+def listed_wrapper(fn):
+    def listed_prc(x: list[Tensor], t_coord: list[Tensor] | None = None) -> tuple[list[Tensor], list[Tensor]]:
+        results = []
+        for i in range(len(x)):
+            results.append(fn(x[i], t_coord[i] if t_coord is not None else None))
+        x, x_ids = zip(*results)
+        return list(x), list(x_ids)
+
+    return listed_prc
+
+
+def prc_img(x: Tensor, t_coord: Tensor | None = None) -> tuple[Tensor, Tensor]:
+    # x: (C, H, W) or (B, C, H, W)
+    h = x.shape[-2]
+    w = x.shape[-1]
+    x_coords = {
+        "t": torch.arange(1) if t_coord is None else t_coord,
+        "h": torch.arange(h),
+        "w": torch.arange(w),
+        "l": torch.arange(1),
+    }
+    x_ids = torch.cartesian_prod(x_coords["t"], x_coords["h"], x_coords["w"], x_coords["l"])
+    x = rearrange(x, "c h w -> (h w) c") if x.ndim == 3 else rearrange(x, "b c h w -> b (h w) c")
+    if x.ndim == 3:  # after rearrange
+        x_ids = x_ids.unsqueeze(0).expand(x.shape[0], -1, -1)  # (B, HW, 4)
+    return x, x_ids.to(x.device)
+
+
+listed_prc_img = listed_wrapper(prc_img)
+# batched_prc_img = batched_wrapper(prc_img)
+# batched_prc_txt = batched_wrapper(prc_txt)
+
+
+# This function is used from Mistral3Embedder
+def cap_pixels(img: Image.Image | list[Image.Image], k):
+    if isinstance(img, list):
+        return [cap_pixels(_img, k) for _img in img]
+    w, h = img.size
+    pixel_count = w * h
+
+    if pixel_count <= k:
+        return img
+
+    # Scaling factor to reduce total pixels below K
+    scale = math.sqrt(k / pixel_count)
+    new_w = int(w * scale)
+    new_h = int(h * scale)
+
+    return img.resize((new_w, new_h), Image.Resampling.LANCZOS)
+
+
+def preprocess_control_image(
+    control_image_path: str, limit_size: Optional[Tuple[int, int]] = None
+) -> tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]:
+    """
+    Preprocess the control image for the model. See `preprocess_image` for details.
+
+    Args:
+        control_image_path (str): Path to the control image.
+        limit_size (Optional[Tuple[int, int]]): Limit the size for resizing with (width, height).
+            If None or larger than the control image size, only resizing to the nearest bucket size and cropping is performed.
+
+    Returns:
+        Tuple[torch.Tensor, np.ndarray, Optional[np.ndarray]]: A tuple containing:
+            - control_image_tensor (torch.Tensor): The preprocessed control image tensor for the model. NCHW format.
+            - control_image_np (np.ndarray): The preprocessed control image as a NumPy array for conditioning. HWC format.
+            - None: Placeholder for compatibility (no additional data returned).
+    """
+    control_image = Image.open(control_image_path)
+
+    if limit_size is None or limit_size[0] * limit_size[1] >= control_image.size[0] * control_image.size[1]:  # No resizing needed
+        # All FLUX 2 architectures require dimensions to be multiples of 16
+        resize_size = BucketSelector.calculate_bucket_resolution(
+            control_image.size, control_image.size, architecture=ARCHITECTURE_FLUX_2_DEV
+        )
+    else:
+        resize_size = limit_size
+
+    control_image_tensor, control_image_np, _ = image_utils.preprocess_image(control_image, *resize_size, handle_alpha=False)
+    return control_image_tensor, control_image_np, None
+
+
+def generalized_time_snr_shift(t: Tensor, mu: float, sigma: float) -> Tensor:
+    return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
+
+
+def get_schedule(num_steps: int, image_seq_len: int, flow_shift: Optional[float] = None) -> list[float]:
+    mu = compute_empirical_mu(image_seq_len, num_steps)
+    timesteps = torch.linspace(1, 0, num_steps + 1)
+    if flow_shift is not None:
+        timesteps = (timesteps * flow_shift) / (1 + (flow_shift - 1) * timesteps)
+    else:
+        timesteps = generalized_time_snr_shift(timesteps, mu, 1.0)
+    return timesteps.tolist()
+
+
+def compute_empirical_mu(image_seq_len: int, num_steps: int) -> float:
+    a1, b1 = 8.73809524e-05, 1.89833333
+    a2, b2 = 0.00016927, 0.45666666
+
+    if image_seq_len > 4300:
+        mu = a2 * image_seq_len + b2
+        return float(mu)
+
+    m_200 = a2 * image_seq_len + b2
+    m_10 = a1 * image_seq_len + b1
+
+    a = (m_200 - m_10) / 190.0
+    b = m_200 - 200.0 * a
+    mu = a * num_steps + b
+
+    return float(mu)
+
+
+def denoise(
+    model: Flux2,
+    # model input
+    img: Tensor,
+    img_ids: Tensor,
+    txt: Tensor,
+    txt_ids: Tensor,
+    # sampling parameters
+    timesteps: list[float],
+    guidance: float,
+    # extra img tokens (sequence-wise)
+    img_cond_seq: Tensor | None = None,
+    img_cond_seq_ids: Tensor | None = None,
+):
+    guidance_vec = torch.full((img.shape[0],), guidance, device=img.device, dtype=img.dtype)
+    for t_curr, t_prev in zip(tqdm(timesteps[:-1]), timesteps[1:]):
+        t_vec = torch.full((img.shape[0],), t_curr, dtype=img.dtype, device=img.device)
+        img_input = img
+        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)
+
+        with torch.no_grad(), torch.autocast(device_type=img.device.type, dtype=img.dtype):
+            pred = model(x=img_input, x_ids=img_input_ids, timesteps=t_vec, ctx=txt, ctx_ids=txt_ids, guidance=guidance_vec)
+
+        if img_input_ids is not None:
+            pred = pred[:, : img.shape[1]]
+
+        img = img + (t_prev - t_curr) * pred
+
+    return img
+
+
+def vanilla_guidance(x: torch.Tensor, cfg_val: float) -> torch.Tensor:
+    x_u, x_c = x.chunk(2)
+    x = x_u + cfg_val * (x_c - x_u)
+    return x
+
+
+def denoise_cfg(
+    model: Flux2,
+    img: Tensor,
+    img_ids: Tensor,
+    txt: Tensor,
+    txt_ids: Tensor,
+    uncond_txt: Tensor,
+    uncond_txt_ids: Tensor,
+    timesteps: list[float],
+    guidance: float,
+    img_cond_seq: Tensor | None = None,
+    img_cond_seq_ids: Tensor | None = None,
+):
+    for t_curr, t_prev in zip(tqdm(timesteps[:-1]), timesteps[1:]):
+        t_vec = torch.full((img.shape[0],), t_curr, dtype=img.dtype, device=img.device)
+
+        img_input = img
+        img_input_ids = img_ids
+        if img_cond_seq is not None:
+            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)
+
+        with torch.no_grad(), torch.autocast(device_type=img.device.type, dtype=img.dtype):
+            pred_cond = model(x=img_input, x_ids=img_input_ids, timesteps=t_vec, ctx=txt, ctx_ids=txt_ids, guidance=None)
+            pred_uncond = model(
+                x=img_input, x_ids=img_input_ids, timesteps=t_vec, ctx=uncond_txt, ctx_ids=uncond_txt_ids, guidance=None
+            )
+
+        if img_cond_seq is not None:
+            pred_cond = pred_cond[:, : img.shape[1]]
+            pred_uncond = pred_uncond[:, : img.shape[1]]
+
+        pred = pred_uncond + guidance * (pred_cond - pred_uncond)
+        img = img + (t_prev - t_curr) * pred
+
+    return img
+
+
+def concatenate_images(
+    images: list[Image.Image],
+) -> Image.Image:
+    """
+    Concatenate a list of PIL images horizontally with center alignment and white background.
+    """
+
+    # If only one image, return a copy of it
+    if len(images) == 1:
+        return images[0].copy()
+
+    # Convert all images to RGB if not already
+    images = [img.convert("RGB") if img.mode != "RGB" else img for img in images]
+
+    # Calculate dimensions for horizontal concatenation
+    total_width = sum(img.width for img in images)
+    max_height = max(img.height for img in images)
+
+    # Create new image with white background
+    background_color = (255, 255, 255)
+    new_img = Image.new("RGB", (total_width, max_height), background_color)
+
+    # Paste images with center alignment
+    x_offset = 0
+    for img in images:
+        y_offset = (max_height - img.height) // 2
+        new_img.paste(img, (x_offset, y_offset))
+        x_offset += img.width
+
+    return new_img
+
+
+def load_flow_model(
+    device: Union[str, torch.device],
+    model_version_info: Flux2ModelInfo,
+    dit_path: str,
+    attn_mode: str,
+    split_attn: bool,
+    loading_device: Union[str, torch.device],
+    dit_weight_dtype: Optional[torch.dtype] = None,
+    fp8_scaled: bool = False,
+    lora_weights_list: Optional[dict[str, torch.Tensor]] = None,
+    lora_multipliers: Optional[list[float]] = None,
+    disable_numpy_memmap: bool = False,
+) -> flux2_models.Flux2:
+    # dit_weight_dtype is None for fp8_scaled
+    assert (not fp8_scaled and dit_weight_dtype is not None) or (fp8_scaled and dit_weight_dtype is None)
+
+    device = torch.device(device)
+    loading_device = torch.device(loading_device)
+
+    # build model
+    with init_empty_weights():
+        params = model_version_info.params
+        model = flux2_models.Flux2(params, attn_mode, split_attn)
+        if dit_weight_dtype is not None:
+            model.to(dit_weight_dtype)
+
+    # load model weights with dynamic fp8 optimization and LoRA merging if needed
+    logger.info(f"Loading DiT model from {dit_path}, device={loading_device}")
+    sd = load_safetensors_with_lora_and_fp8(
+        model_files=dit_path,
+        lora_weights_list=lora_weights_list,
+        lora_multipliers=lora_multipliers,
+        fp8_optimization=fp8_scaled,
+        calc_device=device,
+        move_to_device=(loading_device == device),
+        dit_weight_dtype=dit_weight_dtype,
+        target_keys=flux2_models.FP8_OPTIMIZATION_TARGET_KEYS,
+        exclude_keys=flux2_models.FP8_OPTIMIZATION_EXCLUDE_KEYS,
+        disable_numpy_memmap=disable_numpy_memmap,
+    )
+
+    if fp8_scaled:
+        apply_fp8_monkey_patch(model, sd, use_scaled_mm=False)
+
+        if loading_device.type != "cpu":
+            # make sure all the model weights are on the loading_device
+            logger.info(f"Moving weights to {loading_device}")
+            for key in sd.keys():
+                sd[key] = sd[key].to(loading_device)
+
+    info = model.load_state_dict(sd, strict=True, assign=True)
+    logger.info(f"Loaded Flux 2: {info}")
+
+    return model
+
+
+def load_ae(
+    ckpt_path: str, dtype: torch.dtype, device: Union[str, torch.device], disable_mmap: bool = False
+) -> flux2_models.AutoEncoder:
+    logger.info("Building AutoEncoder")
+    with init_empty_weights():
+        # dev and schnell have the same AE params
+        ae = flux2_models.AutoEncoder(flux2_models.AutoEncoderParams()).to(dtype)
+
+    logger.info(f"Loading state dict from {ckpt_path}")
+    sd = load_split_weights(ckpt_path, device=str(device), disable_mmap=disable_mmap, dtype=dtype)
+    info = ae.load_state_dict(sd, strict=True, assign=True)
+    logger.info(f"Loaded AE: {info}")
+    return ae
+
+
+class Mistral3Embedder(nn.Module):
+    def __init__(
+        self,
+        ckpt_path: str,
+        dtype: Optional[torch.dtype],
+        device: Union[str, torch.device],
+        disable_mmap: bool = False,
+        state_dict: Optional[dict] = None,
+    ) -> tuple[AutoProcessor, Mistral3ForConditionalGeneration]:
+        super().__init__()
+
+        M3_CONFIG_JSON = """
+{
+  "architectures": [
+    "Mistral3ForConditionalGeneration"
+  ],
+  "dtype": "bfloat16",
+  "image_token_index": 10,
+  "model_type": "mistral3",
+  "multimodal_projector_bias": false,
+  "projector_hidden_act": "gelu",
+  "spatial_merge_size": 2,
+  "text_config": {
+    "attention_dropout": 0.0,
+    "dtype": "bfloat16",
+    "head_dim": 128,
+    "hidden_act": "silu",
+    "hidden_size": 5120,
+    "initializer_range": 0.02,
+    "intermediate_size": 32768,
+    "max_position_embeddings": 131072,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_hidden_layers": 40,
+    "num_key_value_heads": 8,
+    "rms_norm_eps": 1e-05,
+    "rope_theta": 1000000000.0,
+    "sliding_window": null,
+    "use_cache": true,
+    "vocab_size": 131072
+  },
+  "transformers_version": "4.57.1",
+  "vision_config": {
+    "attention_dropout": 0.0,
+    "dtype": "bfloat16",
+    "head_dim": 64,
+    "hidden_act": "silu",
+    "hidden_size": 1024,
+    "image_size": 1540,
+    "initializer_range": 0.02,
+    "intermediate_size": 4096,
+    "model_type": "pixtral",
+    "num_attention_heads": 16,
+    "num_channels": 3,
+    "num_hidden_layers": 24,
+    "patch_size": 14,
+    "rope_theta": 10000.0
+  },
+  "vision_feature_layer": -1
+}
+"""
+        config = json.loads(M3_CONFIG_JSON)
+        config = Mistral3Config(**config)
+        with init_empty_weights():
+            self.mistral3 = Mistral3ForConditionalGeneration._from_config(config)
+
+        if state_dict is not None:
+            sd = state_dict
+        else:
+            logger.info(f"Loading state dict from {ckpt_path}")
+            sd = load_split_weights(ckpt_path, device=str(device), disable_mmap=disable_mmap, dtype=dtype)
+
+        # if the key has annoying prefix, remove it
+        for key in list(sd.keys()):
+            new_key = key.replace("language_model.lm_", "lm_")
+            new_key = new_key.replace("language_model.model.", "model.language_model.")
+            new_key = new_key.replace("multi_modal_projector.", "model.multi_modal_projector.")
+            new_key = new_key.replace("vision_tower.", "model.vision_tower.")
+            sd[new_key] = sd.pop(key)
+
+        info = self.mistral3.load_state_dict(sd, strict=True, assign=True)
+        logger.info(f"Loaded Mistral 3: {info}")
+        self.mistral3.to(device)
+
+        if dtype is not None:
+            if is_fp8(dtype):
+                logger.info(f"prepare Mistral 3 for fp8: set to {dtype}")
+                raise NotImplementedError(f"Mistral 3 {dtype}")  # TODO
+            else:
+                logger.info(f"Setting Mistral 3 to dtype: {dtype}")
+                self.mistral3.to(dtype)
+
+        # Load tokenizer
+        self.tokenizer = AutoProcessor.from_pretrained(M3_TOKENIZER_ID, use_fast=False)
+
+    @property
+    def dtype(self):
+        return self.mistral3.dtype
+
+    @property
+    def device(self):
+        return self.mistral3.device
+
+    def to(self, *args, **kwargs):
+        return self.mistral3.to(*args, **kwargs)
+
+    def forward(self, txt: list[str]):
+        if not isinstance(txt, list):
+            txt = [txt]
+
+        # Format input messages
+        messages_batch = self.format_input(txt=txt)
+
+        # Process all messages at once
+        # with image processing a too short max length can throw an error in here.
+        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_LENGTH,
+        )
+
+        # Move to device
+        input_ids = inputs["input_ids"].to(self.mistral3.device)
+        attention_mask = inputs["attention_mask"].to(self.mistral3.device)
+
+        # Forward pass through the model
+        output = self.mistral3(
+            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)
+        return rearrange(out, "b c l d -> b l (c d)")
+
+    @staticmethod
+    def _validate_and_process_images(img: list[list[Image.Image]] | list[Image.Image]) -> list[list[Image.Image]]:
+        # Simple validation: ensure it's a list of PIL images or list of lists of PIL images
+        if not img:
+            return []
+
+        # Check if it's a list of lists or a list of images
+        if isinstance(img[0], Image.Image):
+            # It's a list of images, convert to list of lists
+            img = [[im] for im in img]
+
+        # potentially concatenate multiple images to reduce the size
+        img = [[concatenate_images(img_i)] if len(img_i) > 1 else img_i for img_i in img]
+
+        # cap the pixels
+        img = [[cap_pixels(img_i, UPSAMPLING_MAX_IMAGE_SIZE) for img_i in img_i] for img_i in img]
+        return img
+
+    def format_input(
+        self,
+        txt: list[str],
+        system_message: str = SYSTEM_MESSAGE,
+        img: list[Image.Image] | list[list[Image.Image]] | None = None,
+    ) -> list[list[dict]]:
+        """
+        Format a batch of text prompts into the conversation format expected by apply_chat_template.
+        Optionally, add images to the input.
+
+        Args:
+            txt: List of text prompts
+            system_message: System message to use (default: CREATIVE_SYSTEM_MESSAGE)
+            img: List of images to add to the input.
+
+        Returns:
+            List of conversations, where each conversation is a list of message dicts
+        """
+        # 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]
+
+        if img is None or len(img) == 0:
+            return [
+                [
+                    {
+                        "role": "system",
+                        "content": [{"type": "text", "text": system_message}],
+                    },
+                    {"role": "user", "content": [{"type": "text", "text": prompt}]},
+                ]
+                for prompt in cleaned_txt
+            ]
+        else:
+            assert len(img) == len(txt), "Number of images must match number of prompts"
+            img = self._validate_and_process_images(img)
+
+            messages = [
+                [
+                    {
+                        "role": "system",
+                        "content": [{"type": "text", "text": system_message}],
+                    },
+                ]
+                for _ in cleaned_txt
+            ]
+
+            for i, (el, images) in enumerate(zip(messages, img)):
+                # optionally add the images per batch element.
+                if images is not None:
+                    el.append(
+                        {
+                            "role": "user",
+                            "content": [{"type": "image", "image": image_obj} for image_obj in images],
+                        }
+                    )
+                # add the text.
+                el.append(
+                    {
+                        "role": "user",
+                        "content": [{"type": "text", "text": cleaned_txt[i]}],
+                    }
+                )
+
+            return messages
+
+
+class Qwen3Embedder(nn.Module):
+    def __init__(
+        self,
+        tokenizer: Qwen2Tokenizer,
+        model: Qwen3ForCausalLM,
+    ):
+        super().__init__()
+
+        self.model = model
+        self.tokenizer = tokenizer
+        self.max_length = MAX_LENGTH
+
+    @property
+    def dtype(self):
+        return self.model.dtype
+
+    @property
+    def device(self):
+        return self.model.device
+
+    def to(self, *args, **kwargs):
+        # FIXME: chainging dtype not supported yet
+        return self.model.to(*args, **kwargs)
+
+    def forward(self, txt: list[str]):
+        all_input_ids = []
+        all_attention_masks = []
+
+        for prompt in txt:
+            messages = [{"role": "user", "content": prompt}]
+            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=self.max_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(self.model.device)
+        attention_mask = torch.cat(all_attention_masks, dim=0).to(self.model.device)
+
+        output = self.model(
+            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)
+        return rearrange(out, "b c l d -> b l (c d)")
+
+
+def load_text_embedder(
+    model_version_info: Flux2ModelInfo,
+    ckpt_path: str,
+    dtype: Optional[torch.dtype],
+    device: Union[str, torch.device],
+    disable_mmap: bool = False,
+    state_dict: Optional[dict] = None,
+) -> Union[Mistral3Embedder, Qwen3Embedder]:
+    if model_version_info.qwen_variant is None:
+        return Mistral3Embedder(ckpt_path, dtype, device, disable_mmap, state_dict)
+
+    variant = model_version_info.qwen_variant
+    is_8b = variant == "8B"
+    tokenizer_id = "Qwen/Qwen3-8B" if is_8b else "Qwen/Qwen3-4B"
+    tokenizer, qwen3 = load_qwen3(ckpt_path, dtype, device, disable_mmap, state_dict, is_8b=is_8b, tokenizer_id=tokenizer_id)
+    return Qwen3Embedder(tokenizer, qwen3)

src/musubi_tuner/flux_kontext_cache_latents.py

@@ -0,0 +1,135 @@
+import logging
+from typing import List
+
+import numpy as np
+import torch
+
+from musubi_tuner.dataset import config_utils
+from musubi_tuner.dataset.config_utils import BlueprintGenerator, ConfigSanitizer
+from musubi_tuner.dataset.image_video_dataset import (
+    ItemInfo,
+    ARCHITECTURE_FLUX_KONTEXT,
+    save_latent_cache_flux_kontext,
+)
+from musubi_tuner.flux import flux_utils
+from musubi_tuner.flux import flux_models
+import musubi_tuner.cache_latents as cache_latents
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+def preprocess_contents_flux_kontext(batch: List[ItemInfo]) -> tuple[torch.Tensor, List[List[np.ndarray]]]:
+    # item.content: target image (H, W, C)
+    # item.control_content: list of images (H, W, C), the length of the list is 1 for FLUX.1 Kontext
+
+    # Stack batch into target tensor (B,H,W,C) in RGB order and control images list of tensors (H, W, C)
+    contents = []
+    controls = []
+    for item in batch:
+        contents.append(torch.from_numpy(item.content))  # target image
+
+        if isinstance(item.control_content[0], np.ndarray):
+            control_image = item.control_content[0]  # np.ndarray
+            control_image = control_image[..., :3]  # ensure RGB, remove alpha if present
+        else:
+            control_image = item.control_content[0]  # PIL.Image
+            control_image = control_image.convert("RGB")  # convert to RGB if RGBA
+        controls.append(torch.from_numpy(np.array(control_image)))
+
+    contents = torch.stack(contents, dim=0)  # B, H, W, C
+    contents = contents.permute(0, 3, 1, 2)  # B, H, W, C -> B, C, H, W
+    contents = contents / 127.5 - 1.0  # normalize to [-1, 1]
+
+    # we can stack controls because they are all the same size (bucketed)
+    controls = torch.stack(controls, dim=0)  # B, H, W, C
+    controls = controls.permute(0, 3, 1, 2)  # B, H, W, C -> B, C, H, W
+    controls = controls / 127.5 - 1.0  # normalize to [-1, 1]
+
+    return contents, controls
+
+
+def encode_and_save_batch(ae: flux_models.AutoEncoder, batch: List[ItemInfo]):
+    # item.content: target image (H, W, C)
+    # item.control_content: list of images (H, W, C)
+
+    # assert all items in the batch have the one control content
+    if not all(len(item.control_content) == 1 for item in batch):
+        raise ValueError("FLUX.1 Kontext requires exactly one control content per item.")
+
+    # _, _, contents, content_masks = preprocess_contents(batch)
+    contents, controls = preprocess_contents_flux_kontext(batch)
+
+    with torch.no_grad():
+        latents = ae.encode(contents.to(ae.device, dtype=ae.dtype))  # B, C, H, W
+        control_latents = ae.encode(controls.to(ae.device, dtype=ae.dtype))  # B, C, H, W
+
+    # save cache for each item in the batch
+    for b, item in enumerate(batch):
+        target_latent = latents[b]  # C, H, W. Target latents for this image (ground truth)
+        control_latent = control_latents[b]  # C, H, W
+
+        print(
+            f"Saving cache for item {item.item_key} at {item.latent_cache_path}. control latents shape: {control_latent.shape}, target latents shape: {target_latent.shape}"
+        )
+
+        # save cache (file path is inside item.latent_cache_path pattern), remove batch dim
+        save_latent_cache_flux_kontext(
+            item_info=item,
+            latent=target_latent,  # Ground truth for this image
+            control_latent=control_latent,  # Control latent for this image
+        )
+
+
+# def flux_kontext_setup_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+#     return parser
+
+
+def main():
+    parser = cache_latents.setup_parser_common()
+    parser = cache_latents.hv_setup_parser(parser)  # VAE
+    # parser = flux_kontext_setup_parser(parser)
+
+    args = parser.parse_args()
+
+    if args.disable_cudnn_backend:
+        logger.info("Disabling cuDNN PyTorch backend.")
+        torch.backends.cudnn.enabled = False
+
+    if args.vae_dtype is not None:
+        raise ValueError("VAE dtype is not supported in FLUX.1 Kontext.")
+
+    device = args.device if hasattr(args, "device") and args.device else ("cuda" if torch.cuda.is_available() else "cpu")
+    device = torch.device(device)
+
+    # Load dataset config
+    blueprint_generator = BlueprintGenerator(ConfigSanitizer())
+    logger.info(f"Load dataset config from {args.dataset_config}")
+    user_config = config_utils.load_user_config(args.dataset_config)
+    blueprint = blueprint_generator.generate(user_config, args, architecture=ARCHITECTURE_FLUX_KONTEXT)
+    train_dataset_group = config_utils.generate_dataset_group_by_blueprint(blueprint.dataset_group)
+
+    datasets = train_dataset_group.datasets
+
+    if args.debug_mode is not None:
+        cache_latents.show_datasets(
+            datasets, args.debug_mode, args.console_width, args.console_back, args.console_num_images, fps=16
+        )
+        return
+
+    assert args.vae is not None, "ae checkpoint is required"
+
+    logger.info(f"Loading AE model from {args.vae}")
+    ae = flux_utils.load_ae(args.vae, dtype=torch.float32, device=device, disable_mmap=True)
+    ae.to(device)
+
+    # encoding closure
+    def encode(batch: List[ItemInfo]):
+        encode_and_save_batch(ae, batch)
+
+    # reuse core loop from cache_latents with no change
+    cache_latents.encode_datasets(datasets, encode, args)
+
+
+if __name__ == "__main__":
+    main()

src/musubi_tuner/flux_kontext_cache_text_encoder_outputs.py

@@ -0,0 +1,123 @@
+import argparse
+
+import torch
+from transformers import CLIPTextModel, T5EncoderModel, CLIPTokenizer, T5Tokenizer
+
+from musubi_tuner.dataset import config_utils
+from musubi_tuner.dataset.config_utils import BlueprintGenerator, ConfigSanitizer
+
+from musubi_tuner.dataset.image_video_dataset import (
+    ARCHITECTURE_FLUX_KONTEXT,
+    ItemInfo,
+    save_text_encoder_output_cache_flux_kontext,
+)
+
+from musubi_tuner.flux import flux_models
+from musubi_tuner.flux import flux_utils
+import musubi_tuner.cache_text_encoder_outputs as cache_text_encoder_outputs
+import logging
+
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+def encode_and_save_batch(
+    tokenizer1: T5Tokenizer,
+    text_encoder1: T5EncoderModel,
+    tokenizer2: CLIPTokenizer,
+    text_encoder2: CLIPTextModel,
+    batch: list[ItemInfo],
+    device: torch.device,
+):
+    prompts = [item.caption for item in batch]
+    # print(prompts)
+
+    # encode prompt
+    t5_tokens = tokenizer1(
+        prompts,
+        max_length=flux_models.T5XXL_MAX_LENGTH,
+        padding="max_length",
+        return_length=False,
+        return_overflowing_tokens=False,
+        truncation=True,
+        return_tensors="pt",
+    )["input_ids"]
+    l_tokens = tokenizer2(prompts, max_length=77, padding="max_length", truncation=True, return_tensors="pt")["input_ids"]
+
+    with torch.autocast(device_type=device.type, dtype=text_encoder1.dtype), torch.no_grad():
+        t5_vec = text_encoder1(input_ids=t5_tokens.to(text_encoder1.device), attention_mask=None, output_hidden_states=False)[
+            "last_hidden_state"
+        ]
+        assert torch.isnan(t5_vec).any() == False, "T5 vector contains NaN values"
+        t5_vec = t5_vec.cpu()
+
+    with torch.autocast(device_type=device.type, dtype=text_encoder2.dtype), torch.no_grad():
+        clip_l_pooler = text_encoder2(l_tokens.to(text_encoder2.device))["pooler_output"]
+        clip_l_pooler = clip_l_pooler.cpu()
+
+    # save prompt cache
+    for item, t5_vec, clip_ctx in zip(batch, t5_vec, clip_l_pooler):
+        save_text_encoder_output_cache_flux_kontext(item, t5_vec, clip_ctx)
+
+
+def main():
+    parser = cache_text_encoder_outputs.setup_parser_common()
+    parser = flux_kontext_setup_parser(parser)
+
+    args = parser.parse_args()
+
+    device = args.device if args.device is not None else "cuda" if torch.cuda.is_available() else "cpu"
+    device = torch.device(device)
+
+    # Load dataset config
+    blueprint_generator = BlueprintGenerator(ConfigSanitizer())
+    logger.info(f"Load dataset config from {args.dataset_config}")
+    user_config = config_utils.load_user_config(args.dataset_config)
+    blueprint = blueprint_generator.generate(user_config, args, architecture=ARCHITECTURE_FLUX_KONTEXT)
+    train_dataset_group = config_utils.generate_dataset_group_by_blueprint(blueprint.dataset_group)
+
+    datasets = train_dataset_group.datasets
+
+    # prepare cache files and paths: all_cache_files_for_dataset = exisiting cache files, all_cache_paths_for_dataset = all cache paths in the dataset
+    all_cache_files_for_dataset, all_cache_paths_for_dataset = cache_text_encoder_outputs.prepare_cache_files_and_paths(datasets)
+
+    # Load T5 and CLIP text encoders
+    t5_dtype = torch.float8e4m3fn if args.fp8_t5 else torch.bfloat16
+    tokenizer1, text_encoder1 = flux_utils.load_t5xxl(args.text_encoder1, dtype=t5_dtype, device=device, disable_mmap=True)
+    tokenizer2, text_encoder2 = flux_utils.load_clip_l(args.text_encoder2, dtype=torch.bfloat16, device=device, disable_mmap=True)
+
+    # Encode with T5 and CLIP text encoders
+    logger.info("Encoding with T5 and CLIP text encoders")
+
+    def encode_for_text_encoder(batch: list[ItemInfo]):
+        nonlocal tokenizer1, text_encoder1, tokenizer2, text_encoder2
+        encode_and_save_batch(tokenizer1, text_encoder1, tokenizer2, text_encoder2, batch, device)
+
+    cache_text_encoder_outputs.process_text_encoder_batches(
+        args.num_workers,
+        args.skip_existing,
+        args.batch_size,
+        datasets,
+        all_cache_files_for_dataset,
+        all_cache_paths_for_dataset,
+        encode_for_text_encoder,
+    )
+    del text_encoder1
+    del text_encoder2
+
+    # remove cache files not in dataset
+    cache_text_encoder_outputs.post_process_cache_files(
+        datasets, all_cache_files_for_dataset, all_cache_paths_for_dataset, args.keep_cache
+    )
+
+
+def flux_kontext_setup_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    parser.add_argument("--text_encoder1", type=str, default=None, required=True, help="text encoder (T5XXL) checkpoint path")
+    parser.add_argument("--text_encoder2", type=str, default=None, required=True, help="text encoder 2 (CLIP-L) checkpoint path")
+    parser.add_argument("--fp8_t5", action="store_true", help="use fp8 for Text Encoder model")
+    return parser
+
+
+if __name__ == "__main__":
+    main()

src/musubi_tuner/flux_kontext_generate_image.py

@@ -0,0 +1,1183 @@
+import argparse
+from importlib.util import find_spec
+import random
+import os
+import time
+import copy
+from typing import Tuple, Optional, List, Any, Dict
+
+from einops import rearrange
+import torch
+from safetensors.torch import load_file, save_file
+from safetensors import safe_open
+from tqdm import tqdm
+
+from musubi_tuner.flux import flux_utils
+from musubi_tuner.flux.flux_utils import load_flow_model
+from musubi_tuner.flux import flux_models
+from musubi_tuner.utils import model_utils
+
+lycoris_available = find_spec("lycoris") is not None
+
+from musubi_tuner.networks import lora_flux
+from musubi_tuner.utils.device_utils import clean_memory_on_device
+from musubi_tuner.hv_generate_video import get_time_flag, save_images_grid, setup_parser_compile, synchronize_device
+from musubi_tuner.wan_generate_video import merge_lora_weights
+
+import logging
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+class GenerationSettings:
+    def __init__(self, device: torch.device, dit_weight_dtype: Optional[torch.dtype] = None):
+        self.device = device
+        self.dit_weight_dtype = dit_weight_dtype  # not used currently because model may be optimized
+
+
+def parse_args() -> argparse.Namespace:
+    """parse command line arguments"""
+    parser = argparse.ArgumentParser(description="FLUX.1 Kontext inference script")
+
+    # WAN arguments
+    # parser.add_argument("--ckpt_dir", type=str, default=None, help="The path to the checkpoint directory (Wan 2.1 official).")
+    # parser.add_argument(
+    #     "--sample_solver", type=str, default="unipc", choices=["unipc", "dpm++", "vanilla"], help="The solver used to sample."
+    # )
+
+    parser.add_argument("--dit", type=str, default=None, help="DiT directory or path")
+    parser.add_argument("--vae", type=str, default=None, help="AE directory or path")
+    parser.add_argument("--text_encoder1", type=str, required=True, help="Text Encoder 1 (T5) directory or path")
+    parser.add_argument("--text_encoder2", type=str, required=True, help="Text Encoder 2 (CLIP-L) directory or path")
+
+    # LoRA
+    parser.add_argument("--lora_weight", type=str, nargs="*", required=False, default=None, help="LoRA weight path")
+    parser.add_argument("--lora_multiplier", type=float, nargs="*", default=1.0, help="LoRA multiplier")
+    parser.add_argument("--include_patterns", type=str, nargs="*", default=None, help="LoRA module include patterns")
+    parser.add_argument("--exclude_patterns", type=str, nargs="*", default=None, help="LoRA module exclude patterns")
+    parser.add_argument(
+        "--save_merged_model",
+        type=str,
+        default=None,
+        help="Save merged model to path. If specified, no inference will be performed.",
+    )
+
+    # inference
+    parser.add_argument("--prompt", type=str, default=None, help="prompt for generation")
+    parser.add_argument("--image_size", type=int, nargs=2, default=[256, 256], help="image size, height and width")
+    parser.add_argument("--control_image_path", type=str, default=None, help="path to control (reference) image for Kontext.")
+    parser.add_argument("--no_resize_control", action="store_true", help="do not resize control image")
+    parser.add_argument("--infer_steps", type=int, default=25, help="number of inference steps, default is 25")
+    parser.add_argument("--save_path", type=str, required=True, help="path to save generated video")
+    parser.add_argument("--seed", type=int, default=None, help="Seed for evaluation.")
+    # parser.add_argument(
+    #     "--cpu_noise", action="store_true", help="Use CPU to generate noise (compatible with ComfyUI). Default is False."
+    # )
+    parser.add_argument(
+        "--embedded_cfg_scale", type=float, default=2.5, help="Embeded CFG scale (distilled CFG Scale), default is 2.5"
+    )
+    # parser.add_argument("--video_path", type=str, default=None, help="path to video for video2video inference")
+    # parser.add_argument(
+    #     "--image_path",
+    #     type=str,
+    #     default=None,
+    #     help="path to image for image2video inference. If `;;;` is used, it will be used as section images. The notation is same as `--prompt`.",
+    # )
+
+    # Flow Matching
+    parser.add_argument(
+        "--flow_shift",
+        type=float,
+        default=None,
+        help="Shift factor for flow matching schedulers. Default is None (FLUX.1 default).",
+    )
+
+    parser.add_argument("--fp8", action="store_true", help="use fp8 for DiT model")
+    parser.add_argument("--fp8_scaled", action="store_true", help="use scaled fp8 for DiT, only for fp8")
+    # parser.add_argument("--fp8_fast", action="store_true", help="Enable fast FP8 arithmetic (RTX 4XXX+), only for fp8_scaled")
+
+    parser.add_argument("--fp8_t5", action="store_true", help="use fp8 for Text Encoder 1 (T5)")
+    parser.add_argument(
+        "--device", type=str, default=None, help="device to use for inference. If None, use CUDA if available, otherwise use CPU"
+    )
+    parser.add_argument(
+        "--attn_mode",
+        type=str,
+        default="torch",
+        choices=["flash", "torch", "sageattn", "xformers", "sdpa"],  #  "flash2", "flash3",
+        help="attention mode",
+    )
+    parser.add_argument("--blocks_to_swap", type=int, default=0, help="number of blocks to swap in the model")
+    parser.add_argument(
+        "--use_pinned_memory_for_block_swap",
+        action="store_true",
+        help="use pinned memory for block swapping, which may speed up data transfer between CPU and GPU but uses more shared GPU memory on Windows",
+    )
+    parser.add_argument(
+        "--output_type",
+        type=str,
+        default="images",
+        choices=["images", "latent", "latent_images"],
+        help="output type",
+    )
+    parser.add_argument("--no_metadata", action="store_true", help="do not save metadata")
+    parser.add_argument("--latent_path", type=str, nargs="*", default=None, help="path to latent for decode. no inference")
+    parser.add_argument(
+        "--lycoris", action="store_true", help=f"use lycoris for inference{'' if lycoris_available else ' (not available)'}"
+    )
+    setup_parser_compile(parser)
+
+    # New arguments for batch and interactive modes
+    parser.add_argument("--from_file", type=str, default=None, help="Read prompts from a file")
+    parser.add_argument("--interactive", action="store_true", help="Interactive mode: read prompts from console")
+
+    args = parser.parse_args()
+
+    # Validate arguments
+    if args.from_file and args.interactive:
+        raise ValueError("Cannot use both --from_file and --interactive at the same time")
+
+    if args.latent_path is None or len(args.latent_path) == 0:
+        if args.prompt is None and not args.from_file and not args.interactive:
+            raise ValueError("Either --prompt, --from_file or --interactive must be specified")
+
+    if args.lycoris and not lycoris_available:
+        raise ValueError("install lycoris: https://github.com/KohakuBlueleaf/LyCORIS")
+
+    return args
+
+
+def parse_prompt_line(line: str) -> Dict[str, Any]:
+    """Parse a prompt line into a dictionary of argument overrides
+
+    Args:
+        line: Prompt line with options
+
+    Returns:
+        Dict[str, Any]: Dictionary of argument overrides
+    """
+    # TODO common function with hv_train_network.line_to_prompt_dict
+    parts = line.split(" --")
+    prompt = parts[0].strip()
+
+    # Create dictionary of overrides
+    overrides = {"prompt": prompt}
+
+    for part in parts[1:]:
+        if not part.strip():
+            continue
+        option_parts = part.split(" ", 1)
+        option = option_parts[0].strip()
+        value = option_parts[1].strip() if len(option_parts) > 1 else ""
+
+        # Map options to argument names
+        if option == "w":
+            overrides["image_size_width"] = int(value)
+        elif option == "h":
+            overrides["image_size_height"] = int(value)
+        elif option == "d":
+            overrides["seed"] = int(value)
+        elif option == "s":
+            overrides["infer_steps"] = int(value)
+        # elif option == "g" or option == "l":
+        #     overrides["guidance_scale"] = float(value)
+        elif option == "fs":
+            overrides["flow_shift"] = float(value)
+        elif option == "i":
+            overrides["image_path"] = value
+        # elif option == "im":
+        #     overrides["image_mask_path"] = value
+        # elif option == "cn":
+        #     overrides["control_path"] = value
+        # elif option == "n":
+        #     overrides["negative_prompt"] = value
+        elif option == "ci":  # control_image_path
+            overrides["control_image_path"] = value
+
+    return overrides
+
+
+def apply_overrides(args: argparse.Namespace, overrides: Dict[str, Any]) -> argparse.Namespace:
+    """Apply overrides to args
+
+    Args:
+        args: Original arguments
+        overrides: Dictionary of overrides
+
+    Returns:
+        argparse.Namespace: New arguments with overrides applied
+    """
+    args_copy = copy.deepcopy(args)
+
+    for key, value in overrides.items():
+        if key == "image_size_width":
+            args_copy.image_size[1] = value
+        elif key == "image_size_height":
+            args_copy.image_size[0] = value
+        else:
+            setattr(args_copy, key, value)
+
+    return args_copy
+
+
+def check_inputs(args: argparse.Namespace) -> Tuple[int, int]:
+    """Validate video size and length
+
+    Args:
+        args: command line arguments
+
+    Returns:
+        Tuple[int, int]: (height, width)
+    """
+    height = args.image_size[0]
+    width = args.image_size[1]
+
+    if height % 16 != 0 or width % 16 != 0:
+        raise ValueError(f"`height` and `width` have to be divisible by 16 but are {height} and {width}.")
+
+    return height, width
+
+
+# region DiT model
+
+
+def load_dit_model(args: argparse.Namespace, device: torch.device) -> flux_models.Flux:
+    """load DiT model
+
+    Args:
+        args: command line arguments
+        device: device to use
+        dit_dtype: data type for the model
+        dit_weight_dtype: data type for the model weights. None for as-is
+
+    Returns:
+        flux_models.Flux: DiT model
+    """
+    loading_device = "cpu"
+    if args.blocks_to_swap == 0 and not args.fp8_scaled and args.lora_weight is None:
+        loading_device = device
+
+    # do not fp8 optimize because we will merge LoRA weights
+    model = load_flow_model(
+        ckpt_path=args.dit,
+        dtype=None,
+        device=loading_device,
+        disable_mmap=True,
+        attn_mode=args.attn_mode,
+        split_attn=False,
+    )
+
+    return model
+
+
+def optimize_model(model: flux_models.Flux, args: argparse.Namespace, device: torch.device) -> None:
+    """optimize the model (FP8 conversion, device move etc.)
+
+    Args:
+        model: dit model
+        args: command line arguments
+        device: device to use
+    """
+    if args.fp8_scaled:
+        # load state dict as-is and optimize to fp8
+        state_dict = model.state_dict()
+
+        # if no blocks to swap, we can move the weights to GPU after optimization on GPU (omit redundant CPU->GPU copy)
+        move_to_device = args.blocks_to_swap == 0  # if blocks_to_swap > 0, we will keep the model on CPU
+        state_dict = model.fp8_optimization(state_dict, device, move_to_device, use_scaled_mm=False)  # args.fp8_fast)
+
+        info = model.load_state_dict(state_dict, strict=True, assign=True)
+        logger.info(f"Loaded FP8 optimized weights: {info}")
+
+        if args.blocks_to_swap == 0:
+            model.to(device)  # make sure all parameters are on the right device (e.g. RoPE etc.)
+    else:
+        # simple cast to dit_dtype
+        target_dtype = None  # load as-is (dit_weight_dtype == dtype of the weights in state_dict)
+        target_device = None
+
+        if args.fp8:
+            target_dtype = torch.float8e4m3fn
+
+        if args.blocks_to_swap == 0:
+            logger.info(f"Move model to device: {device}")
+            target_device = device
+
+        if target_device is not None and target_dtype is not None:
+            model.to(target_device, target_dtype)  # move and cast  at the same time. this reduces redundant copy operations
+
+    if args.blocks_to_swap > 0:
+        logger.info(f"Enable swap {args.blocks_to_swap} blocks to CPU from device: {device}")
+        model.enable_block_swap(
+            args.blocks_to_swap, device, supports_backward=False, use_pinned_memory=args.use_pinned_memory_for_block_swap
+        )
+        model.move_to_device_except_swap_blocks(device)
+        model.prepare_block_swap_before_forward()
+    else:
+        # make sure the model is on the right device
+        model.to(device)
+
+    if args.compile:
+        model = model_utils.compile_transformer(
+            args, model, [model.double_blocks, model.single_blocks], disable_linear=args.blocks_to_swap > 0
+        )
+
+    model.eval().requires_grad_(False)
+    clean_memory_on_device(device)
+
+
+# endregion
+
+
+def decode_latent(ae: flux_models.AutoEncoder, latent: torch.Tensor, device: torch.device) -> torch.Tensor:
+    logger.info("Decoding image...")
+    if latent.ndim == 3:
+        latent = latent.unsqueeze(0)  # add batch dimension
+
+    ae.to(device)
+    with torch.no_grad():
+        pixels = ae.decode(latent.to(device))  # decode to pixels
+    pixels = pixels.to("cpu")
+    ae.to("cpu")
+
+    logger.info(f"Decoded. Pixel shape {pixels.shape}")
+    return pixels[0]  # remove batch dimension
+
+
+def prepare_image_inputs(args: argparse.Namespace, device: torch.device, ae: flux_models.AutoEncoder) -> Dict[str, Any]:
+    """Prepare image-related inputs for Kontext: AE encoding."""
+    height, width = check_inputs(args)
+
+    if args.control_image_path is not None:
+        control_image_tensor, _, _ = flux_utils.preprocess_control_image(args.control_image_path, not args.no_resize_control)
+
+        # AE encoding
+        logger.info("Encoding control image to latent space with AE")
+        ae_original_device = ae.device
+        ae.to(device)
+
+        with torch.no_grad():
+            control_latent = ae.encode(control_image_tensor.to(device, dtype=ae.dtype))
+        control_latent = control_latent.to(torch.bfloat16).to("cpu")
+
+        ae.to(ae_original_device)  # Move VAE back to its original device
+        clean_memory_on_device(device)
+
+        control_latent = control_latent.cpu()
+    else:
+        control_latent = None
+
+    return {"height": height, "width": width, "control_latent": control_latent}
+
+
+def prepare_text_inputs(
+    args: argparse.Namespace,
+    device: torch.device,
+    shared_models: Optional[Dict] = None,
+) -> Dict[str, Any]:
+    """Prepare text-related inputs for I2V: LLM and TextEncoder encoding."""
+
+    # load text encoder: conds_cache holds cached encodings for prompts without padding
+    conds_cache = {}
+    if shared_models is not None:
+        tokenizer1, text_encoder1 = shared_models.get("tokenizer1"), shared_models.get("text_encoder1")
+        tokenizer2, text_encoder2 = shared_models.get("tokenizer2"), shared_models.get("text_encoder2")
+        if "conds_cache" in shared_models:  # Use shared cache if available
+            conds_cache = shared_models["conds_cache"]
+        # text_encoder1 and text_encoder2 are on device (batched inference) or CPU (interactive inference)
+    else:  # Load if not in shared_models
+        # T5XXL is float16 by default, but it causes NaN values in some cases, so we use bfloat16 (or fp8 if specified)
+        t5_dtype = torch.float8e4m3fn if args.fp8_t5 else torch.bfloat16
+        tokenizer1, text_encoder1 = flux_utils.load_t5xxl(args.text_encoder1, dtype=t5_dtype, device=device, disable_mmap=True)
+        tokenizer2, text_encoder2 = flux_utils.load_clip_l(
+            args.text_encoder2, dtype=torch.bfloat16, device=device, disable_mmap=True
+        )
+
+    # Store original devices to move back later if they were shared. This does nothing if shared_models is None
+    text_encoder1_original_device = text_encoder1.device if text_encoder1 else None
+    text_encoder2_original_device = text_encoder2.device if text_encoder2 else None
+
+    logger.info("Encoding prompt with Text Encoders")
+
+    # Ensure text_encoder1 and text_encoder2 are not None before proceeding
+    if not text_encoder1 or not text_encoder2 or not tokenizer1 or not tokenizer2:
+        raise ValueError("Text encoders or tokenizers are not loaded properly.")
+
+    # Define a function to move models to device if needed
+    # This is to avoid moving models if not needed, especially in interactive mode
+    model_is_moved = False
+
+    def move_models_to_device_if_needed():
+        nonlocal model_is_moved
+        nonlocal shared_models
+
+        if model_is_moved:
+            return
+        model_is_moved = True
+
+        logger.info(f"Moving DiT and Text Encoders to appropriate device: {device} or CPU")
+        if shared_models and "model" in shared_models:  # DiT model is shared
+            if args.blocks_to_swap > 0:
+                logger.info("Waiting for 5 seconds to finish block swap")
+                time.sleep(5)
+            model = shared_models["model"]
+            model.to("cpu")
+            clean_memory_on_device(device)  # clean memory on device before moving models
+
+        text_encoder1.to(device)
+        text_encoder2.to(device)
+
+    prompt = args.prompt
+    if prompt in conds_cache:
+        t5_vec, clip_l_pooler = conds_cache[prompt]
+    else:
+        move_models_to_device_if_needed()
+
+        t5_tokens = tokenizer1(
+            prompt,
+            max_length=flux_models.T5XXL_MAX_LENGTH,
+            padding="max_length",
+            return_length=False,
+            return_overflowing_tokens=False,
+            truncation=True,
+            return_tensors="pt",
+        )["input_ids"]
+        l_tokens = tokenizer2(prompt, max_length=77, padding="max_length", truncation=True, return_tensors="pt")["input_ids"]
+
+        with torch.autocast(device_type=device.type, dtype=text_encoder1.dtype), torch.no_grad():
+            t5_vec = text_encoder1(input_ids=t5_tokens.to(text_encoder1.device), attention_mask=None, output_hidden_states=False)[
+                "last_hidden_state"
+            ]
+            assert torch.isnan(t5_vec).any() == False, "T5 vector contains NaN values"
+            t5_vec = t5_vec.cpu()
+
+        with torch.autocast(device_type=device.type, dtype=text_encoder2.dtype), torch.no_grad():
+            clip_l_pooler = text_encoder2(l_tokens.to(text_encoder2.device))["pooler_output"]
+            clip_l_pooler = clip_l_pooler.cpu()
+
+        conds_cache[prompt] = (t5_vec, clip_l_pooler)
+
+    if not (shared_models and "text_encoder1" in shared_models):  # if loaded locally
+        del tokenizer1, text_encoder1, tokenizer2, text_encoder2
+    else:  # if shared, move back to original device (likely CPU)
+        if text_encoder1:
+            text_encoder1.to(text_encoder1_original_device)
+        if text_encoder2:
+            text_encoder2.to(text_encoder2_original_device)
+
+    clean_memory_on_device(device)
+
+    arg_c = {"t5_vec": t5_vec, "clip_l_pooler": clip_l_pooler, "prompt": prompt}
+
+    return arg_c
+
+
+def prepare_i2v_inputs(
+    args: argparse.Namespace,
+    device: torch.device,
+    ae: flux_models.AutoEncoder,
+    shared_models: Optional[Dict] = None,
+) -> Tuple[int, int, Dict[str, Any], Optional[torch.Tensor]]:
+    """Prepare inputs for image2video generation: image encoding, text encoding, and AE encoding.
+
+    Args:
+        args: command line arguments
+        device: device to use
+        ae: AE model instance
+        shared_models: dictionary containing pre-loaded models (mainly for DiT)
+
+    Returns:
+        Tuple[int, int, Dict[str, Any], Optional[torch.Tensor]]: (height, width, context, end_latent)
+    """
+    # prepare image inputs
+    image_inputs = prepare_image_inputs(args, device, ae)
+    control_latent = image_inputs["control_latent"]
+
+    # prepare text inputs
+    context = prepare_text_inputs(args, device, shared_models)
+
+    return image_inputs["height"], image_inputs["width"], context, control_latent
+
+
+def generate(
+    args: argparse.Namespace,
+    gen_settings: GenerationSettings,
+    shared_models: Optional[Dict] = None,
+    precomputed_image_data: Optional[Dict] = None,
+    precomputed_text_data: Optional[Dict] = None,
+) -> tuple[Optional[flux_models.AutoEncoder], torch.Tensor]:  # AE can be Optional
+    """main function for generation
+
+    Args:
+        args: command line arguments
+        shared_models: dictionary containing pre-loaded models (mainly for DiT)
+        precomputed_image_data: Optional dictionary with precomputed image data
+        precomputed_text_data: Optional dictionary with precomputed text data
+
+    Returns:
+        tuple: (flux_models.AutoEncoder model (vae) or None, torch.Tensor generated latent)
+    """
+    device, dit_weight_dtype = (gen_settings.device, gen_settings.dit_weight_dtype)
+    vae_instance_for_return = None
+
+    # prepare seed
+    seed = args.seed if args.seed is not None else random.randint(0, 2**32 - 1)
+    args.seed = seed  # set seed to args for saving
+
+    if precomputed_image_data is not None and precomputed_text_data is not None:
+        logger.info("Using precomputed image and text data.")
+        height = precomputed_image_data["height"]
+        width = precomputed_image_data["width"]
+        control_latent = precomputed_image_data["control_latent"]
+
+        context = precomputed_text_data
+
+        # VAE is not loaded here if data is precomputed; decoding VAE is handled by caller (e.g., process_batch_prompts)
+        # vae_instance_for_return remains None
+    else:
+        # Load VAE if not precomputed (for single/interactive mode)
+        # shared_models for single/interactive might contain text/image encoders, but not VAE after `load_shared_models` change.
+        # So, VAE will be loaded here for single/interactive.
+        logger.info("No precomputed data. Preparing image and text inputs.")
+        if shared_models and "ae" in shared_models:  # Should not happen with new load_shared_models
+            vae_instance_for_return = shared_models["ae"]
+        else:
+            # the dtype of VAE weights is float32, but we can load it as bfloat16 for better performance in future
+            vae_instance_for_return = flux_utils.load_ae(args.vae, dtype=torch.float32, device=device, disable_mmap=True)
+
+        height, width, context, control_latent = prepare_i2v_inputs(args, device, vae_instance_for_return, shared_models)
+
+    if shared_models is None or "model" not in shared_models:
+        # load DiT model
+        model = load_dit_model(args, device)
+
+        # merge LoRA weights
+        if args.lora_weight is not None and len(args.lora_weight) > 0:
+            merge_lora_weights(
+                lora_flux,
+                model,
+                args.lora_weight,
+                args.lora_multiplier,
+                args.include_patterns,
+                args.exclude_patterns,
+                device,
+                args.lycoris,
+                args.save_merged_model,
+            )
+
+            # if we only want to save the model, we can skip the rest
+            if args.save_merged_model:
+                return None, None
+
+        # optimize model: fp8 conversion, block swap etc.
+        optimize_model(model, args, device)
+
+        if shared_models is not None:
+            shared_models["model"] = model
+    else:
+        # use shared model
+        model: flux_models.Flux = shared_models["model"]
+        model.move_to_device_except_swap_blocks(device)  # Handles block swap correctly
+        model.prepare_block_swap_before_forward()
+
+    # set random generator
+    seed_g = torch.Generator(device="cpu")
+    seed_g.manual_seed(seed)
+
+    logger.info(f"Image size: {height}x{width} (HxW), infer_steps: {args.infer_steps}")
+
+    # image generation ######
+
+    # def get_latent_mask(mask_image: Image.Image) -> torch.Tensor:
+    #     if mask_image.mode != "L":
+    #         mask_image = mask_image.convert("L")
+    #     mask_image = mask_image.resize((width // 8, height // 8), Image.LANCZOS)
+    #     mask_image = np.array(mask_image)  # PIL to numpy, HWC
+    #     mask_image = torch.from_numpy(mask_image).float() / 255.0  # 0 to 1.0, HWC
+    #     mask_image = mask_image.squeeze(-1)  # HWC -> HW
+    #     mask_image = mask_image.unsqueeze(0).unsqueeze(0).unsqueeze(0)  # HW -> 111HW (BCFHW)
+    #     mask_image = mask_image.to(torch.float32)
+    #     return mask_image
+
+    logger.info(f"Prompt: {context['prompt']}")
+
+    t5_vec = context["t5_vec"].to(device, dtype=torch.bfloat16)
+    clip_l_pooler = context["clip_l_pooler"].to(device, dtype=torch.bfloat16)
+
+    txt_ids = torch.zeros(t5_vec.shape[0], t5_vec.shape[1], 3, device=t5_vec.device)
+
+    # make first noise with packed shape
+    # original: b,16,2*h//16,2*w//16, packed: b,h//16*w//16,16*2*2
+    packed_latent_height, packed_latent_width = height // 16, width // 16
+    noise_dtype = torch.float32
+    noise = torch.randn(
+        1,
+        packed_latent_height * packed_latent_width,
+        16 * 2 * 2,
+        dtype=noise_dtype,
+        generator=seed_g,
+        device="cpu",
+    ).to(device, dtype=torch.bfloat16)
+
+    img_ids = flux_utils.prepare_img_ids(1, packed_latent_height, packed_latent_width).to(device)
+
+    # image ids are the same as base image with the first dimension set to 1 instead of 0
+    if control_latent is not None:
+        # pack control_latent
+        ctrl_packed_height = control_latent.shape[2] // 2
+        ctrl_packed_width = control_latent.shape[3] // 2
+        control_latent = rearrange(control_latent, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=2, pw=2)
+        control_latent_ids = flux_utils.prepare_img_ids(1, ctrl_packed_height, ctrl_packed_width, is_ctrl=True).to(device)
+
+        control_latent = control_latent.to(device, dtype=torch.bfloat16)
+    else:
+        control_latent_ids = None
+
+    # denoise
+    timesteps = flux_utils.get_schedule(
+        num_steps=args.infer_steps, image_seq_len=packed_latent_height * packed_latent_width, shift_value=args.flow_shift
+    )
+
+    guidance = args.embedded_cfg_scale
+    x = noise
+
+    # logger.info(f"guidance: {guidance}, timesteps: {timesteps}")
+    guidance_vec = torch.full((x.shape[0],), guidance, device=x.device, dtype=x.dtype)
+
+    for t_curr, t_prev in zip(tqdm(timesteps[:-1]), timesteps[1:]):
+        t_vec = torch.full((x.shape[0],), t_curr, dtype=x.dtype, device=x.device)
+
+        img_input = x
+        img_input_ids = img_ids
+        if control_latent is not None:
+            # if control_latent is provided, concatenate it to the input
+            img_input = torch.cat((img_input, control_latent), dim=1)
+            img_input_ids = torch.cat((img_input_ids, control_latent_ids), dim=1)
+
+        with torch.no_grad():
+            pred = model(
+                img=img_input,
+                img_ids=img_input_ids,
+                txt=t5_vec,
+                txt_ids=txt_ids,
+                y=clip_l_pooler,
+                timesteps=t_vec,
+                guidance=guidance_vec,
+            )
+        pred = pred[:, : x.shape[1]]
+
+        x = x + (t_prev - t_curr) * pred
+
+    # unpack
+    x = x.float()
+    x = rearrange(x, "b (h w) (c ph pw) -> b c (h ph) (w pw)", h=packed_latent_height, w=packed_latent_width, ph=2, pw=2)
+
+    return vae_instance_for_return, x
+
+
+def save_latent(latent: torch.Tensor, args: argparse.Namespace, height: int, width: int) -> str:
+    """Save latent to file
+
+    Args:
+        latent: Latent tensor
+        args: command line arguments
+        height: height of frame
+        width: width of frame
+
+    Returns:
+        str: Path to saved latent file
+    """
+    save_path = args.save_path
+    os.makedirs(save_path, exist_ok=True)
+    time_flag = get_time_flag()
+
+    seed = args.seed
+
+    latent_path = f"{save_path}/{time_flag}_{seed}_latent.safetensors"
+
+    if args.no_metadata:
+        metadata = None
+    else:
+        metadata = {
+            "seeds": f"{seed}",
+            "prompt": f"{args.prompt}",
+            "height": f"{height}",
+            "width": f"{width}",
+            "infer_steps": f"{args.infer_steps}",
+            "embedded_cfg_scale": f"{args.embedded_cfg_scale}",
+        }
+        # if args.negative_prompt is not None:
+        #     metadata["negative_prompt"] = f"{args.negative_prompt}"
+
+    sd = {"latent": latent.contiguous()}
+    save_file(sd, latent_path, metadata=metadata)
+    logger.info(f"Latent saved to: {latent_path}")
+
+    return latent_path
+
+
+def save_images(sample: torch.Tensor, args: argparse.Namespace, original_base_name: Optional[str] = None) -> str:
+    """Save images to directory
+
+    Args:
+        sample: Video tensor
+        args: command line arguments
+        original_base_name: Original base name (if latents are loaded from files)
+
+    Returns:
+        str: Path to saved images directory
+    """
+    save_path = args.save_path
+    os.makedirs(save_path, exist_ok=True)
+    time_flag = get_time_flag()
+
+    seed = args.seed
+    original_name = "" if original_base_name is None else f"_{original_base_name}"
+    image_name = f"{time_flag}_{seed}{original_name}"
+    sample = sample.unsqueeze(0).unsqueeze(2)  # C,HW -> BCTHW, where B=1, C=3, T=1
+    save_images_grid(sample, save_path, image_name, rescale=True, create_subdir=False)
+    logger.info(f"Sample images saved to: {save_path}/{image_name}")
+
+    return f"{save_path}/{image_name}"
+
+
+def save_output(
+    args: argparse.Namespace,
+    ae: flux_models.AutoEncoder,  # Expect a VAE instance for decoding
+    latent: torch.Tensor,
+    device: torch.device,
+    original_base_names: Optional[List[str]] = None,
+) -> None:
+    """save output
+
+    Args:
+        args: command line arguments
+        vae: VAE model
+        latent: latent tensor
+        device: device to use
+        original_base_names: original base names (if latents are loaded from files)
+    """
+    height, width = latent.shape[-2], latent.shape[-1]  # BCTHW
+    height *= 8
+    width *= 8
+    # print(f"Saving output. Latent shape {latent.shape}; pixel shape {height}x{width}")
+    if args.output_type == "latent" or args.output_type == "latent_images":
+        # save latent
+        save_latent(latent, args, height, width)
+    if args.output_type == "latent":
+        return
+
+    if ae is None:
+        logger.error("AE is None, cannot decode latents for saving video/images.")
+        return
+
+    video = decode_latent(ae, latent, device)
+
+    if args.output_type == "images" or args.output_type == "latent_images":
+        # save images
+        original_name = "" if original_base_names is None else f"_{original_base_names[0]}"
+        save_images(video, args, original_name)
+
+
+def preprocess_prompts_for_batch(prompt_lines: List[str], base_args: argparse.Namespace) -> List[Dict]:
+    """Process multiple prompts for batch mode
+
+    Args:
+        prompt_lines: List of prompt lines
+        base_args: Base command line arguments
+
+    Returns:
+        List[Dict]: List of prompt data dictionaries
+    """
+    prompts_data = []
+
+    for line in prompt_lines:
+        line = line.strip()
+        if not line or line.startswith("#"):  # Skip empty lines and comments
+            continue
+
+        # Parse prompt line and create override dictionary
+        prompt_data = parse_prompt_line(line)
+        logger.info(f"Parsed prompt data: {prompt_data}")
+        prompts_data.append(prompt_data)
+
+    return prompts_data
+
+
+def load_shared_models(args: argparse.Namespace) -> Dict:
+    """Load shared models for batch processing or interactive mode.
+    Models are loaded to CPU to save memory. VAE is NOT loaded here.
+    DiT model is also NOT loaded here, handled by process_batch_prompts or generate.
+
+    Args:
+        args: Base command line arguments
+
+    Returns:
+        Dict: Dictionary of shared models (text/image encoders)
+    """
+    shared_models = {}
+    # Load text encoders to CPU
+    t5_dtype = torch.float8e4m3fn if args.fp8_t5 else torch.bfloat16
+    tokenizer1, text_encoder1 = flux_utils.load_t5xxl(args.text_encoder1, dtype=t5_dtype, device="cpu", disable_mmap=True)
+    tokenizer2, text_encoder2 = flux_utils.load_clip_l(args.text_encoder2, dtype=torch.bfloat16, device="cpu", disable_mmap=True)
+
+    shared_models["tokenizer1"] = tokenizer1
+    shared_models["text_encoder1"] = text_encoder1
+    shared_models["tokenizer2"] = tokenizer2
+    shared_models["text_encoder2"] = text_encoder2
+
+    return shared_models
+
+
+def process_batch_prompts(prompts_data: List[Dict], args: argparse.Namespace) -> None:
+    """Process multiple prompts with model reuse and batched precomputation
+
+    Args:
+        prompts_data: List of prompt data dictionaries
+        args: Base command line arguments
+    """
+    if not prompts_data:
+        logger.warning("No valid prompts found")
+        return
+
+    gen_settings = get_generation_settings(args)
+    device = gen_settings.device
+
+    # 1. Precompute Image Data (AE and Image Encoders)
+    logger.info("Loading AE and Image Encoders for batch image preprocessing...")
+    ae_for_batch = flux_utils.load_ae(args.vae, dtype=torch.float32, device=device, disable_mmap=True)
+
+    all_precomputed_image_data = []
+    all_prompt_args_list = [apply_overrides(args, pd) for pd in prompts_data]  # Create all arg instances first
+
+    logger.info("Preprocessing images and AE encoding for all prompts...")
+
+    # AE and Image Encoder to device for this phase, because we do not want to offload them to CPU
+    ae_for_batch.to(device)
+
+    for i, prompt_args_item in enumerate(all_prompt_args_list):
+        logger.info(f"Image preprocessing for prompt {i + 1}/{len(all_prompt_args_list)}: {prompt_args_item.prompt}")
+        # prepare_image_inputs will move ae/image_encoder to device temporarily
+        image_data = prepare_image_inputs(prompt_args_item, device, ae_for_batch)
+        all_precomputed_image_data.append(image_data)
+
+    # Models should be back on GPU because prepare_image_inputs moved them to the original device
+    ae_for_batch.to("cpu")  # Move AE back to CPU
+    clean_memory_on_device(device)
+
+    # 2. Precompute Text Data (Text Encoders)
+    logger.info("Loading Text Encoders for batch text preprocessing...")
+
+    # Text Encoders loaded to CPU by load_text_encoder1/2
+    t5_dtype = torch.float8e4m3fn if args.fp8_t5 else torch.bfloat16
+    tokenizer1_batch, text_encoder1_batch = flux_utils.load_t5xxl(
+        args.text_encoder1, dtype=t5_dtype, device=device, disable_mmap=True
+    )
+    tokenizer2_batch, text_encoder2_batch = flux_utils.load_clip_l(
+        args.text_encoder2, dtype=torch.bfloat16, device=device, disable_mmap=True
+    )
+
+    # Text Encoders to device for this phase
+    text_encoder2_batch.to(device)  # Moved into prepare_text_inputs logic
+
+    all_precomputed_text_data = []
+    conds_cache_batch = {}
+
+    logger.info("Preprocessing text and LLM/TextEncoder encoding for all prompts...")
+    temp_shared_models_txt = {
+        "tokenizer1": tokenizer1_batch,
+        "text_encoder1": text_encoder1_batch,  # on GPU
+        "tokenizer2": tokenizer2_batch,
+        "text_encoder2": text_encoder2_batch,  # on GPU
+        "conds_cache": conds_cache_batch,
+    }
+
+    for i, prompt_args_item in enumerate(all_prompt_args_list):
+        logger.info(f"Text preprocessing for prompt {i + 1}/{len(all_prompt_args_list)}: {prompt_args_item.prompt}")
+        # prepare_text_inputs will move text_encoders to device temporarily
+        text_data = prepare_text_inputs(prompt_args_item, device, temp_shared_models_txt)
+        all_precomputed_text_data.append(text_data)
+
+    # Models should be removed from device after prepare_text_inputs
+    del tokenizer1_batch, text_encoder1_batch, tokenizer2_batch, text_encoder2_batch, temp_shared_models_txt, conds_cache_batch
+    clean_memory_on_device(device)
+
+    # 3. Load DiT Model once
+    logger.info("Loading DiT model for batch generation...")
+    # Use args from the first prompt for DiT loading (LoRA etc. should be consistent for a batch)
+    first_prompt_args = all_prompt_args_list[0]
+    dit_model = load_dit_model(first_prompt_args, device)  # Load directly to target device if possible
+
+    if first_prompt_args.lora_weight is not None and len(first_prompt_args.lora_weight) > 0:
+        logger.info("Merging LoRA weights into DiT model...")
+        merge_lora_weights(
+            lora_flux,
+            dit_model,
+            first_prompt_args.lora_weight,
+            first_prompt_args.lora_multiplier,
+            first_prompt_args.include_patterns,
+            first_prompt_args.exclude_patterns,
+            device,
+            first_prompt_args.lycoris,
+            first_prompt_args.save_merged_model,
+        )
+        if first_prompt_args.save_merged_model:
+            logger.info("Merged DiT model saved. Skipping generation.")
+            del dit_model
+            clean_memory_on_device(device)
+            return
+
+    logger.info("Optimizing DiT model...")
+    optimize_model(dit_model, first_prompt_args, device)  # Handles device placement, fp8 etc.
+
+    shared_models_for_generate = {"model": dit_model}  # Pass DiT via shared_models
+
+    all_latents = []
+
+    logger.info("Generating latents for all prompts...")
+    with torch.no_grad():
+        for i, prompt_args_item in enumerate(all_prompt_args_list):
+            current_image_data = all_precomputed_image_data[i]
+            current_text_data = all_precomputed_text_data[i]
+
+            logger.info(f"Generating latent for prompt {i + 1}/{len(all_prompt_args_list)}: {prompt_args_item.prompt}")
+            try:
+                # generate is called with precomputed data, so it won't load VAE/Text/Image encoders.
+                # It will use the DiT model from shared_models_for_generate.
+                # The VAE instance returned by generate will be None here.
+                _, latent = generate(
+                    prompt_args_item, gen_settings, shared_models_for_generate, current_image_data, current_text_data
+                )
+
+                if latent is None:  # and prompt_args_item.save_merged_model:  # Should be caught earlier
+                    continue
+
+                # Save latent if needed (using data from precomputed_image_data for H/W)
+                if prompt_args_item.output_type in ["latent", "latent_images"]:
+                    height = current_image_data["height"]
+                    width = current_image_data["width"]
+                    save_latent(latent, prompt_args_item, height, width)
+
+                all_latents.append(latent)
+            except Exception as e:
+                logger.error(f"Error generating latent for prompt: {prompt_args_item.prompt}. Error: {e}", exc_info=True)
+                all_latents.append(None)  # Add placeholder for failed generations
+                continue
+
+    # Free DiT model
+    logger.info("Releasing DiT model from memory...")
+    if args.blocks_to_swap > 0:
+        logger.info("Waiting for 5 seconds to finish block swap")
+        time.sleep(5)
+
+    del shared_models_for_generate["model"]
+    del dit_model
+    clean_memory_on_device(device)
+    synchronize_device(device)  # Ensure memory is freed before loading VAE for decoding
+
+    # 4. Decode latents and save outputs (using vae_for_batch)
+    if args.output_type != "latent":
+        logger.info("Decoding latents to videos/images using batched VAE...")
+        ae_for_batch.to(device)  # Move VAE to device for decoding
+
+        for i, latent in enumerate(all_latents):
+            if latent is None:  # Skip failed generations
+                logger.warning(f"Skipping decoding for prompt {i + 1} due to previous error.")
+                continue
+
+            current_args = all_prompt_args_list[i]
+            logger.info(f"Decoding output {i + 1}/{len(all_latents)} for prompt: {current_args.prompt}")
+
+            # if args.output_type is "latent_images", we already saved latent above.
+            # so we skip saving latent here.
+            if current_args.output_type == "latent_images":
+                current_args.output_type = "images"
+
+            # save_output expects latent to be [BCTHW] or [CTHW]. generate returns [BCTHW] (batch size 1).
+            # latent[0] is correct if generate returns it with batch dim.
+            # The latent from generate is (1, C, T, H, W)
+            save_output(current_args, ae_for_batch, latent[0], device)  # Pass vae_for_batch
+
+        ae_for_batch.to("cpu")  # Move VAE back to CPU
+
+    del ae_for_batch
+    clean_memory_on_device(device)
+
+
+def process_interactive(args: argparse.Namespace) -> None:
+    """Process prompts in interactive mode
+
+    Args:
+        args: Base command line arguments
+    """
+    gen_settings = get_generation_settings(args)
+    device = gen_settings.device
+    shared_models = load_shared_models(args)
+    shared_models["conds_cache"] = {}  # Initialize empty cache for interactive mode
+
+    print("Interactive mode. Enter prompts (Ctrl+D or Ctrl+Z (Windows) to exit):")
+
+    try:
+        import prompt_toolkit
+    except ImportError:
+        logger.warning("prompt_toolkit not found. Using basic input instead.")
+        prompt_toolkit = None
+
+    if prompt_toolkit:
+        session = prompt_toolkit.PromptSession()
+
+        def input_line(prompt: str) -> str:
+            return session.prompt(prompt)
+
+    else:
+
+        def input_line(prompt: str) -> str:
+            return input(prompt)
+
+    try:
+        while True:
+            try:
+                line = input_line("> ")
+                if not line.strip():
+                    continue
+                if len(line.strip()) == 1 and line.strip() in ["\x04", "\x1a"]:  # Ctrl+D or Ctrl+Z with prompt_toolkit
+                    raise EOFError  # Exit on Ctrl+D or Ctrl+Z
+
+                # Parse prompt
+                prompt_data = parse_prompt_line(line)
+                prompt_args = apply_overrides(args, prompt_data)
+
+                # Generate latent
+                # For interactive, precomputed data is None. shared_models contains text/image encoders.
+                # generate will load VAE internally.
+                returned_vae, latent = generate(prompt_args, gen_settings, shared_models)
+
+                # # If not one_frame_inference, move DiT model to CPU after generation
+                # if prompt_args.blocks_to_swap > 0:
+                #     logger.info("Waiting for 5 seconds to finish block swap")
+                #     time.sleep(5)
+                # model = shared_models.get("model")
+                # model.to("cpu")  # Move DiT model to CPU after generation
+
+                # Save latent and video
+                # returned_vae from generate will be used for decoding here.
+                save_output(prompt_args, returned_vae, latent[0], device)
+
+            except KeyboardInterrupt:
+                print("\nInterrupted. Continue (Ctrl+D or Ctrl+Z (Windows) to exit)")
+                continue
+
+    except EOFError:
+        print("\nExiting interactive mode")
+
+
+def get_generation_settings(args: argparse.Namespace) -> GenerationSettings:
+    device = torch.device(args.device)
+
+    dit_weight_dtype = None  # default
+    if args.fp8_scaled:
+        dit_weight_dtype = None  # various precision weights, so don't cast to specific dtype
+    elif args.fp8:
+        dit_weight_dtype = torch.float8_e4m3fn
+
+    logger.info(f"Using device: {device}, DiT weight weight precision: {dit_weight_dtype}")
+
+    gen_settings = GenerationSettings(device=device, dit_weight_dtype=dit_weight_dtype)
+    return gen_settings
+
+
+def main():
+    # Parse arguments
+    args = parse_args()
+
+    # Check if latents are provided
+    latents_mode = args.latent_path is not None and len(args.latent_path) > 0
+
+    # Set device
+    device = args.device if args.device is not None else "cuda" if torch.cuda.is_available() else "cpu"
+    device = torch.device(device)
+    logger.info(f"Using device: {device}")
+    args.device = device
+
+    if latents_mode:
+        # Original latent decode mode
+        original_base_names = []
+        latents_list = []
+        seeds = []
+
+        # assert len(args.latent_path) == 1, "Only one latent path is supported for now"
+
+        for latent_path in args.latent_path:
+            original_base_names.append(os.path.splitext(os.path.basename(latent_path))[0])
+            seed = 0
+
+            if os.path.splitext(latent_path)[1] != ".safetensors":
+                latents = torch.load(latent_path, map_location="cpu")
+            else:
+                latents = load_file(latent_path)["latent"]
+                with safe_open(latent_path, framework="pt") as f:
+                    metadata = f.metadata()
+                if metadata is None:
+                    metadata = {}
+                logger.info(f"Loaded metadata: {metadata}")
+
+                if "seeds" in metadata:
+                    seed = int(metadata["seeds"])
+                if "height" in metadata and "width" in metadata:
+                    height = int(metadata["height"])
+                    width = int(metadata["width"])
+                    args.image_size = [height, width]
+
+            seeds.append(seed)
+            logger.info(f"Loaded latent from {latent_path}. Shape: {latents.shape}")
+
+            if latents.ndim == 5:  # [BCTHW]
+                latents = latents.squeeze(0)  # [CTHW]
+
+            latents_list.append(latents)
+
+        # latent = torch.stack(latents_list, dim=0)  # [N, ...], must be same shape
+
+        for i, latent in enumerate(latents_list):
+            args.seed = seeds[i]
+
+            ae = flux_utils.load_ae(args.vae, dtype=torch.float32, device=device, disable_mmap=True)
+            save_output(args, ae, latent, device, original_base_names)
+
+    elif args.from_file:
+        # Batch mode from file
+
+        # Read prompts from file
+        with open(args.from_file, "r", encoding="utf-8") as f:
+            prompt_lines = f.readlines()
+
+        # Process prompts
+        prompts_data = preprocess_prompts_for_batch(prompt_lines, args)
+        process_batch_prompts(prompts_data, args)
+
+    elif args.interactive:
+        # Interactive mode
+        process_interactive(args)
+
+    else:
+        # Single prompt mode (original behavior)
+
+        # Generate latent
+        gen_settings = get_generation_settings(args)
+        # For single mode, precomputed data is None, shared_models is None.
+        # generate will load all necessary models (VAE, Text/Image Encoders, DiT).
+        returned_vae, latent = generate(args, gen_settings)
+        # print(f"Generated latent shape: {latent.shape}")
+        # if args.save_merged_model:
+        #     return
+
+        # Save latent and video
+        # returned_vae from generate will be used for decoding here.
+        save_output(args, returned_vae, latent[0], device)
+
+    logger.info("Done!")
+
+
+if __name__ == "__main__":
+    main()

src/musubi_tuner/flux_kontext_train_network.py

@@ -0,0 +1,405 @@
+import argparse
+from typing import Optional
+
+
+from einops import rearrange
+import torch
+from tqdm import tqdm
+from accelerate import Accelerator
+
+from musubi_tuner.dataset.image_video_dataset import ARCHITECTURE_FLUX_KONTEXT, ARCHITECTURE_FLUX_KONTEXT_FULL
+from musubi_tuner.flux import flux_models, flux_utils
+from musubi_tuner.hv_train_network import (
+    NetworkTrainer,
+    load_prompts,
+    clean_memory_on_device,
+    setup_parser_common,
+    read_config_from_file,
+)
+
+import logging
+
+from musubi_tuner.utils import model_utils
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+class FluxKontextNetworkTrainer(NetworkTrainer):
+    def __init__(self):
+        super().__init__()
+
+    # region model specific
+
+    @property
+    def architecture(self) -> str:
+        return ARCHITECTURE_FLUX_KONTEXT
+
+    @property
+    def architecture_full_name(self) -> str:
+        return ARCHITECTURE_FLUX_KONTEXT_FULL
+
+    def handle_model_specific_args(self, args):
+        self.dit_dtype = torch.float16 if args.mixed_precision == "fp16" else torch.bfloat16
+        self._i2v_training = False
+        self._control_training = False  # this means video training, not control image training
+        self.default_guidance_scale = 2.5  # embeded guidance scale for inference
+
+    def process_sample_prompts(
+        self,
+        args: argparse.Namespace,
+        accelerator: Accelerator,
+        sample_prompts: str,
+    ):
+        device = accelerator.device
+
+        logger.info(f"cache Text Encoder outputs for sample prompt: {sample_prompts}")
+        prompts = load_prompts(sample_prompts)
+
+        # Load T5 and CLIP text encoders
+        t5_dtype = torch.float8e4m3fn if args.fp8_t5 else torch.bfloat16
+        tokenizer1, text_encoder1 = flux_utils.load_t5xxl(args.text_encoder1, dtype=t5_dtype, device=device, disable_mmap=True)
+        tokenizer2, text_encoder2 = flux_utils.load_clip_l(
+            args.text_encoder2, dtype=torch.bfloat16, device=device, disable_mmap=True
+        )
+
+        # Encode with T5 and CLIP text encoders
+        logger.info("Encoding with T5 and CLIP text encoders")
+
+        sample_prompts_te_outputs = {}  # (prompt) -> (t5, clip)
+        with torch.amp.autocast(device_type=device.type, dtype=t5_dtype), torch.no_grad():
+            for prompt_dict in prompts:
+                prompt = prompt_dict.get("prompt", "")
+                if prompt is None or prompt in sample_prompts_te_outputs:
+                    continue
+
+                # encode prompt
+                logger.info(f"cache Text Encoder outputs for prompt: {prompt}")
+
+                t5_tokens = tokenizer1(
+                    prompt,
+                    max_length=flux_models.T5XXL_MAX_LENGTH,
+                    padding="max_length",
+                    return_length=False,
+                    return_overflowing_tokens=False,
+                    truncation=True,
+                    return_tensors="pt",
+                )["input_ids"]
+                l_tokens = tokenizer2(prompt, max_length=77, padding="max_length", truncation=True, return_tensors="pt")[
+                    "input_ids"
+                ]
+
+                with torch.autocast(device_type=device.type, dtype=text_encoder1.dtype), torch.no_grad():
+                    t5_vec = text_encoder1(
+                        input_ids=t5_tokens.to(text_encoder1.device), attention_mask=None, output_hidden_states=False
+                    )["last_hidden_state"]
+                    assert torch.isnan(t5_vec).any() == False, "T5 vector contains NaN values"
+                    t5_vec = t5_vec.cpu()
+
+                with torch.autocast(device_type=device.type, dtype=text_encoder2.dtype), torch.no_grad():
+                    clip_l_pooler = text_encoder2(l_tokens.to(text_encoder2.device))["pooler_output"]
+                    clip_l_pooler = clip_l_pooler.cpu()
+
+                # save prompt cache
+                sample_prompts_te_outputs[prompt] = (t5_vec, clip_l_pooler)
+
+        del tokenizer1, text_encoder1, tokenizer2, text_encoder2
+        clean_memory_on_device(device)
+
+        # prepare sample parameters
+        sample_parameters = []
+        for prompt_dict in prompts:
+            prompt_dict_copy = prompt_dict.copy()
+
+            prompt = prompt_dict.get("prompt", "")
+            prompt_dict_copy["t5_vec"] = sample_prompts_te_outputs[prompt][0]
+            prompt_dict_copy["clip_l_pooler"] = sample_prompts_te_outputs[prompt][1]
+
+            sample_parameters.append(prompt_dict_copy)
+
+        clean_memory_on_device(accelerator.device)
+
+        return sample_parameters
+
+    def do_inference(
+        self,
+        accelerator,
+        args,
+        sample_parameter,
+        vae,
+        dit_dtype,
+        transformer,
+        discrete_flow_shift,
+        sample_steps,
+        width,
+        height,
+        frame_count,
+        generator,
+        do_classifier_free_guidance,
+        guidance_scale,
+        cfg_scale,
+        image_path=None,
+        control_video_path=None,
+    ):
+        """architecture dependent inference"""
+        model: flux_models.Flux = transformer
+        device = accelerator.device
+
+        # Get embeddings
+        t5_vec = sample_parameter["t5_vec"].to(device=device, dtype=torch.bfloat16)
+        clip_l_pooler = sample_parameter["clip_l_pooler"].to(device=device, dtype=torch.bfloat16)
+
+        txt_ids = torch.zeros(t5_vec.shape[0], t5_vec.shape[1], 3, device=t5_vec.device)
+
+        # Initialize latents
+        packed_latent_height, packed_latent_width = height // 16, width // 16
+        noise_dtype = torch.float32
+        noise = torch.randn(
+            1,
+            packed_latent_height * packed_latent_width,
+            16 * 2 * 2,
+            generator=generator,
+            dtype=noise_dtype,
+            device=device,
+        ).to(device, dtype=torch.bfloat16)
+
+        img_ids = flux_utils.prepare_img_ids(1, packed_latent_height, packed_latent_width).to(device)
+
+        vae.to(device)
+        vae.eval()
+
+        # prepare control latent
+        control_latent = None
+        control_latent_ids = None
+        if "control_image_path" in sample_parameter:
+            control_image_path = sample_parameter["control_image_path"][0]  # only use the first control image
+            control_image_tensor, _, _ = flux_utils.preprocess_control_image(control_image_path, resize_to_prefered=False)
+
+            with torch.no_grad():
+                control_latent = vae.encode(control_image_tensor.to(device, dtype=vae.dtype))
+
+            # pack control_latent
+            ctrl_packed_height = control_latent.shape[2] // 2
+            ctrl_packed_width = control_latent.shape[3] // 2
+            control_latent = rearrange(control_latent, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=2, pw=2)
+            control_latent_ids = flux_utils.prepare_img_ids(1, ctrl_packed_height, ctrl_packed_width, is_ctrl=True).to(device)
+
+            control_latent = control_latent.to(torch.bfloat16)
+
+        vae.to("cpu")
+        clean_memory_on_device(device)
+
+        # denoise
+        discrete_flow_shift = discrete_flow_shift if discrete_flow_shift != 0 else None  # None means no shift
+        timesteps = flux_utils.get_schedule(
+            num_steps=sample_steps, image_seq_len=packed_latent_height * packed_latent_width, shift_value=discrete_flow_shift
+        )
+
+        x = noise
+        del noise
+        guidance_vec = torch.full((x.shape[0],), guidance_scale, device=x.device, dtype=x.dtype)
+
+        for t_curr, t_prev in zip(tqdm(timesteps[:-1]), timesteps[1:]):
+            t_vec = torch.full((x.shape[0],), t_curr, dtype=x.dtype, device=x.device)
+
+            img_input = x
+            img_input_ids = img_ids
+            if control_latent is not None:
+                # if control_latent is provided, concatenate it to the input
+                img_input = torch.cat((img_input, control_latent), dim=1)
+                img_input_ids = torch.cat((img_input_ids, control_latent_ids), dim=1)
+
+            with torch.no_grad():
+                pred = model(
+                    img=img_input,
+                    img_ids=img_input_ids,
+                    txt=t5_vec,
+                    txt_ids=txt_ids,
+                    y=clip_l_pooler,
+                    timesteps=t_vec,
+                    guidance=guidance_vec,
+                )
+            pred = pred[:, : x.shape[1]]
+
+            x = x + (t_prev - t_curr) * pred
+
+        # unpack
+        x = x.float()
+        x = rearrange(x, "b (h w) (c ph pw) -> b c (h ph) (w pw)", h=packed_latent_height, w=packed_latent_width, ph=2, pw=2)
+        latent = x.to(vae.dtype)
+        del x
+
+        # Move VAE to the appropriate device for sampling
+        vae.to(device)
+        vae.eval()
+
+        # Decode latents to video
+        logger.info(f"Decoding video from latents: {latent.shape}")
+        with torch.no_grad():
+            pixels = vae.decode(latent)  # decode to pixels
+        del latent
+
+        logger.info("Decoding complete")
+        pixels = pixels.to(torch.float32).cpu()
+        pixels = (pixels / 2 + 0.5).clamp(0, 1)  # -1 to 1 -> 0 to 1
+
+        vae.to("cpu")
+        clean_memory_on_device(device)
+
+        pixels = pixels.unsqueeze(2)  # add a dummy dimension for video frames, B C H W -> B C 1 H W
+        return pixels
+
+    def load_vae(self, args: argparse.Namespace, vae_dtype: torch.dtype, vae_path: str):
+        vae_path = args.vae
+
+        logger.info(f"Loading AE model from {vae_path}")
+        ae = flux_utils.load_ae(vae_path, dtype=torch.float32, device="cpu", disable_mmap=True)
+        return ae
+
+    def load_transformer(
+        self,
+        accelerator: Accelerator,
+        args: argparse.Namespace,
+        dit_path: str,
+        attn_mode: str,
+        split_attn: bool,
+        loading_device: str,
+        dit_weight_dtype: Optional[torch.dtype],
+    ):
+        model = flux_utils.load_flow_model(
+            ckpt_path=args.dit,
+            dtype=None,
+            device=loading_device,
+            disable_mmap=True,
+            attn_mode=attn_mode,
+            split_attn=split_attn,
+            loading_device=loading_device,
+            fp8_scaled=args.fp8_scaled,
+        )
+        return model
+
+    def compile_transformer(self, args, transformer):
+        transformer: flux_models.Flux = transformer
+        return model_utils.compile_transformer(
+            args, transformer, [transformer.double_blocks, transformer.single_blocks], disable_linear=self.blocks_to_swap > 0
+        )
+
+    def scale_shift_latents(self, latents):
+        return latents
+
+    def call_dit(
+        self,
+        args: argparse.Namespace,
+        accelerator: Accelerator,
+        transformer,
+        latents: torch.Tensor,
+        batch: dict[str, torch.Tensor],
+        noise: torch.Tensor,
+        noisy_model_input: torch.Tensor,
+        timesteps: torch.Tensor,
+        network_dtype: torch.dtype,
+    ):
+        model: flux_models.Flux = transformer
+
+        bsize = latents.shape[0]
+        latents = batch["latents"]  # B, C, H, W
+        control_latents = batch["latents_control"]  # B, C, H, W
+
+        # pack latents
+        packed_latent_height = latents.shape[2] // 2
+        packed_latent_width = latents.shape[3] // 2
+        noisy_model_input = rearrange(noisy_model_input, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=2, pw=2)
+
+        img_ids = flux_utils.prepare_img_ids(bsize, packed_latent_height, packed_latent_width)
+
+        # pack control latents
+        packed_control_latent_height = control_latents.shape[2] // 2
+        packed_control_latent_width = control_latents.shape[3] // 2
+        control_latents = rearrange(control_latents, "b c (h ph) (w pw) -> b (h w) (c ph pw)", ph=2, pw=2)
+        control_latent_lengths = [control_latents.shape[1]] * bsize
+
+        control_ids = flux_utils.prepare_img_ids(bsize, packed_control_latent_height, packed_control_latent_width, is_ctrl=True)
+
+        # context
+        t5_vec = batch["t5_vec"]  # B, T, D
+        clip_l_pooler = batch["clip_l_pooler"]  # B, T, D
+        txt_ids = torch.zeros(t5_vec.shape[0], t5_vec.shape[1], 3, device=accelerator.device)
+
+        # ensure the hidden state will require grad
+        if args.gradient_checkpointing:
+            noisy_model_input.requires_grad_(True)
+            control_latents.requires_grad_(True)
+            t5_vec.requires_grad_(True)
+            clip_l_pooler.requires_grad_(True)
+
+        # call DiT
+        noisy_model_input = noisy_model_input.to(device=accelerator.device, dtype=network_dtype)
+        img_ids = img_ids.to(device=accelerator.device)
+        control_latents = control_latents.to(device=accelerator.device, dtype=network_dtype)
+        control_ids = control_ids.to(device=accelerator.device)
+        t5_vec = t5_vec.to(device=accelerator.device, dtype=network_dtype)
+        clip_l_pooler = clip_l_pooler.to(device=accelerator.device, dtype=network_dtype)
+
+        # use 1.0 as guidance scale for FLUX.1 Kontext training
+        guidance_vec = torch.full((bsize,), 1.0, device=accelerator.device, dtype=network_dtype)
+
+        img_input = torch.cat((noisy_model_input, control_latents), dim=1)
+        img_input_ids = torch.cat((img_ids, control_ids), dim=1)
+
+        timesteps = timesteps / 1000.0
+        model_pred = model(
+            img=img_input,
+            img_ids=img_input_ids,
+            txt=t5_vec,
+            txt_ids=txt_ids,
+            y=clip_l_pooler,
+            timesteps=timesteps,
+            guidance=guidance_vec,
+            control_lengths=control_latent_lengths,
+        )
+        model_pred = model_pred[:, : noisy_model_input.shape[1]]  # remove control latents
+
+        # unpack latents
+        model_pred = rearrange(
+            model_pred, "b (h w) (c ph pw) -> b c (h ph) (w pw)", h=packed_latent_height, w=packed_latent_width, ph=2, pw=2
+        )
+
+        # flow matching loss
+        target = noise - latents
+
+        return model_pred, target
+
+    # endregion model specific
+
+
+def flux_kontext_setup_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    """Flux-Kontext specific parser setup"""
+    parser.add_argument("--fp8_scaled", action="store_true", help="use scaled fp8 for DiT / DiTにスケーリングされたfp8を使う")
+    parser.add_argument("--text_encoder1", type=str, default=None, help="text encoder (T5) checkpoint path")
+    parser.add_argument("--fp8_t5", action="store_true", help="use fp8 for Text Encoder model")
+    parser.add_argument(
+        "--text_encoder2",
+        type=str,
+        default=None,
+        help="text encoder (CLIP) checkpoint path, optional. If training I2V model, this is required",
+    )
+    return parser
+
+
+def main():
+    parser = setup_parser_common()
+    parser = flux_kontext_setup_parser(parser)
+
+    args = parser.parse_args()
+    args = read_config_from_file(args, parser)
+
+    args.dit_dtype = None  # set from mixed_precision
+    if args.vae_dtype is None:
+        args.vae_dtype = "bfloat16"  # make bfloat16 as default for VAE
+
+    trainer = FluxKontextNetworkTrainer()
+    trainer.train(args)
+
+
+if __name__ == "__main__":
+    main()

src/musubi_tuner/fpack_cache_latents.py

@@ -0,0 +1,501 @@
+import argparse
+import logging
+import math
+import os
+from typing import List
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from tqdm import tqdm
+from transformers import SiglipImageProcessor, SiglipVisionModel
+
+from musubi_tuner.dataset import config_utils
+from musubi_tuner.dataset.config_utils import BlueprintGenerator, ConfigSanitizer
+from musubi_tuner.dataset.image_video_dataset import BaseDataset, ItemInfo, save_latent_cache_framepack, ARCHITECTURE_FRAMEPACK
+from musubi_tuner.frame_pack import hunyuan
+from musubi_tuner.frame_pack.framepack_utils import load_image_encoders, load_vae
+from musubi_tuner.hunyuan_model.autoencoder_kl_causal_3d import AutoencoderKLCausal3D
+from musubi_tuner.frame_pack.clip_vision import hf_clip_vision_encode
+import musubi_tuner.cache_latents as cache_latents
+from musubi_tuner.cache_latents import preprocess_contents
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+def encode_and_save_batch(
+    vae: AutoencoderKLCausal3D,
+    feature_extractor: SiglipImageProcessor,
+    image_encoder: SiglipVisionModel,
+    batch: List[ItemInfo],
+    vanilla_sampling: bool = False,
+    one_frame: bool = False,
+    one_frame_no_2x: bool = False,
+    one_frame_no_4x: bool = False,
+):
+    """Encode a batch of original RGB videos and save FramePack section caches."""
+    if one_frame:
+        encode_and_save_batch_one_frame(
+            vae, feature_extractor, image_encoder, batch, vanilla_sampling, one_frame_no_2x, one_frame_no_4x
+        )
+        return
+
+    latent_window_size = batch[0].fp_latent_window_size  # all items should have the same window size
+
+    # Stack batch into tensor (B,C,F,H,W) in RGB order
+    contents = torch.stack([torch.from_numpy(item.content) for item in batch])
+    if len(contents.shape) == 4:
+        contents = contents.unsqueeze(1)  # B, H, W, C -> B, F, H, W, C
+
+    contents = contents.permute(0, 4, 1, 2, 3).contiguous()  # B, C, F, H, W
+    contents = contents.to(vae.device, dtype=vae.dtype)
+    contents = contents / 127.5 - 1.0  # normalize to [-1, 1]
+
+    height, width = contents.shape[3], contents.shape[4]
+    if height < 8 or width < 8:
+        item = batch[0]  # other items should have the same size
+        raise ValueError(f"Image or video size too small: {item.item_key} and {len(batch) - 1} more, size: {item.original_size}")
+
+    # calculate latent frame count from original frame count (4n+1)
+    latent_f = (batch[0].frame_count - 1) // 4 + 1
+
+    # calculate the total number of sections (excluding the first frame, divided by window size)
+    total_latent_sections = math.floor((latent_f - 1) / latent_window_size)
+    if total_latent_sections < 1:
+        min_frames_needed = latent_window_size * 4 + 1
+        raise ValueError(
+            f"Not enough frames for FramePack: {batch[0].frame_count} frames ({latent_f} latent frames), minimum required: {min_frames_needed} frames ({latent_window_size + 1} latent frames)"
+        )
+
+    # actual latent frame count (aligned to section boundaries)
+    latent_f_aligned = total_latent_sections * latent_window_size + 1 if not one_frame else 1
+
+    # actual video frame count
+    frame_count_aligned = (latent_f_aligned - 1) * 4 + 1
+    if frame_count_aligned != batch[0].frame_count:
+        logger.info(
+            f"Frame count mismatch: required={frame_count_aligned} != actual={batch[0].frame_count}, trimming to {frame_count_aligned}"
+        )
+        contents = contents[:, :, :frame_count_aligned, :, :]
+
+    latent_f = latent_f_aligned  # Update to the aligned value
+
+    # VAE encode (list of tensor -> stack)
+    latents = hunyuan.vae_encode(contents, vae)  # include scaling factor
+    latents = latents.to("cpu")  # (B, C, latent_f, H/8, W/8)
+
+    # Vision encoding per‑item (once)
+    images = np.stack([item.content[0] for item in batch], axis=0)  # B, H, W, C
+
+    # encode image with image encoder
+    image_embeddings = []
+    with torch.no_grad():
+        for image in images:
+            if image.shape[-1] == 4:
+                image = image[..., :3]
+            image_encoder_output = hf_clip_vision_encode(image, feature_extractor, image_encoder)
+            image_embeddings.append(image_encoder_output.last_hidden_state)
+    image_embeddings = torch.cat(image_embeddings, dim=0)  # B, LEN, 1152
+    image_embeddings = image_embeddings.to("cpu")  # Save memory
+
+    if not vanilla_sampling:
+        # padding is reversed for inference (future to past)
+        latent_paddings = list(reversed(range(total_latent_sections)))
+        # Note: The padding trick for inference. See the paper for details.
+        if total_latent_sections > 4:
+            latent_paddings = [3] + [2] * (total_latent_sections - 3) + [1, 0]
+
+        for b, item in enumerate(batch):
+            original_latent_cache_path = item.latent_cache_path
+            video_lat = latents[b : b + 1]  # keep batch dim, 1, C, F, H, W
+
+            # emulate inference step (history latents)
+            # Note: In inference, history_latents stores *generated* future latents.
+            # Here, for caching, we just need its shape and type for clean_* tensors.
+            # The actual content doesn't matter much as clean_* will be overwritten.
+            history_latents = torch.zeros(
+                (1, video_lat.shape[1], 1 + 2 + 16, video_lat.shape[3], video_lat.shape[4]), dtype=video_lat.dtype
+            )  # C=16 for HY
+
+            latent_f_index = latent_f - latent_window_size  # Start from the last section
+            section_index = total_latent_sections - 1
+
+            for latent_padding in latent_paddings:
+                is_last_section = section_index == 0  # the last section in inference order == the first section in time
+                latent_padding_size = latent_padding * latent_window_size
+                if is_last_section:
+                    assert latent_f_index == 1, "Last section should be starting from frame 1"
+
+                # indices generation (same as inference)
+                indices = torch.arange(0, sum([1, latent_padding_size, latent_window_size, 1, 2, 16])).unsqueeze(0)
+                (
+                    clean_latent_indices_pre,  # Index for start_latent
+                    blank_indices,  # Indices for padding (future context in inference)
+                    latent_indices,  # Indices for the target latents to predict
+                    clean_latent_indices_post,  # Index for the most recent history frame
+                    clean_latent_2x_indices,  # Indices for the next 2 history frames
+                    clean_latent_4x_indices,  # Indices for the next 16 history frames
+                ) = indices.split([1, latent_padding_size, latent_window_size, 1, 2, 16], dim=1)
+
+                # Indices for clean_latents (start + recent history)
+                clean_latent_indices = torch.cat([clean_latent_indices_pre, clean_latent_indices_post], dim=1)
+
+                # clean latents preparation (emulating inference)
+                clean_latents_pre = video_lat[:, :, 0:1, :, :]  # Always the first frame (start_latent)
+                clean_latents_post, clean_latents_2x, clean_latents_4x = history_latents[:, :, : 1 + 2 + 16, :, :].split(
+                    [1, 2, 16], dim=2
+                )
+                clean_latents = torch.cat([clean_latents_pre, clean_latents_post], dim=2)  # Combine start frame + placeholder
+
+                # Target latents for this section (ground truth)
+                target_latents = video_lat[:, :, latent_f_index : latent_f_index + latent_window_size, :, :]
+
+                # save cache (file path is inside item.latent_cache_path pattern), remove batch dim
+                item.latent_cache_path = append_section_idx_to_latent_cache_path(original_latent_cache_path, section_index)
+                save_latent_cache_framepack(
+                    item_info=item,
+                    latent=target_latents.squeeze(0),  # Ground truth for this section
+                    latent_indices=latent_indices.squeeze(0),  # Indices for the ground truth section
+                    clean_latents=clean_latents.squeeze(0),  # Start frame + history placeholder
+                    clean_latent_indices=clean_latent_indices.squeeze(0),  # Indices for start frame + history placeholder
+                    clean_latents_2x=clean_latents_2x.squeeze(0),  # History placeholder
+                    clean_latent_2x_indices=clean_latent_2x_indices.squeeze(0),  # Indices for history placeholder
+                    clean_latents_4x=clean_latents_4x.squeeze(0),  # History placeholder
+                    clean_latent_4x_indices=clean_latent_4x_indices.squeeze(0),  # Indices for history placeholder
+                    image_embeddings=image_embeddings[b],
+                )
+
+                if is_last_section:  # If this was the first section generated in inference (time=0)
+                    # History gets the start frame + the generated first section
+                    generated_latents_for_history = video_lat[:, :, : latent_window_size + 1, :, :]
+                else:
+                    # History gets the generated current section
+                    generated_latents_for_history = target_latents  # Use true latents as stand-in for generated
+
+                history_latents = torch.cat([generated_latents_for_history, history_latents], dim=2)
+
+                section_index -= 1
+                latent_f_index -= latent_window_size
+
+    else:
+        # Vanilla Sampling Logic
+        for b, item in enumerate(batch):
+            original_latent_cache_path = item.latent_cache_path
+            video_lat = latents[b : b + 1]  # Keep batch dim: 1, C, F_aligned, H, W
+            img_emb = image_embeddings[b]  # LEN, 1152
+
+            for section_index in range(total_latent_sections):
+                target_start_f = section_index * latent_window_size + 1
+                target_end_f = target_start_f + latent_window_size
+                target_latents = video_lat[:, :, target_start_f:target_end_f, :, :]
+                start_latent = video_lat[:, :, 0:1, :, :]
+
+                # Clean latents preparation (Vanilla)
+                clean_latents_total_count = 1 + 2 + 16
+                history_latents = torch.zeros(
+                    size=(1, 16, clean_latents_total_count, video_lat.shape[-2], video_lat.shape[-1]),
+                    device=video_lat.device,
+                    dtype=video_lat.dtype,
+                )
+
+                history_start_f = 0
+                video_start_f = target_start_f - clean_latents_total_count
+                copy_count = clean_latents_total_count
+                if video_start_f < 0:
+                    history_start_f = -video_start_f
+                    copy_count = clean_latents_total_count - history_start_f
+                    video_start_f = 0
+                if copy_count > 0:
+                    history_latents[:, :, history_start_f:] = video_lat[:, :, video_start_f : video_start_f + copy_count, :, :]
+
+                # indices generation (Vanilla): copy from FramePack-F1
+                indices = torch.arange(0, sum([1, 16, 2, 1, latent_window_size])).unsqueeze(0)
+                (
+                    clean_latent_indices_start,
+                    clean_latent_4x_indices,
+                    clean_latent_2x_indices,
+                    clean_latent_1x_indices,
+                    latent_indices,
+                ) = indices.split([1, 16, 2, 1, latent_window_size], dim=1)
+                clean_latent_indices = torch.cat([clean_latent_indices_start, clean_latent_1x_indices], dim=1)
+
+                clean_latents_4x, clean_latents_2x, clean_latents_1x = history_latents.split([16, 2, 1], dim=2)
+                clean_latents = torch.cat([start_latent, clean_latents_1x], dim=2)
+
+                # Save cache
+                item.latent_cache_path = append_section_idx_to_latent_cache_path(original_latent_cache_path, section_index)
+                save_latent_cache_framepack(
+                    item_info=item,
+                    latent=target_latents.squeeze(0),
+                    latent_indices=latent_indices.squeeze(0),  # Indices for target section i
+                    clean_latents=clean_latents.squeeze(0),  # Past clean frames
+                    clean_latent_indices=clean_latent_indices.squeeze(0),  # Indices for clean_latents_pre/post
+                    clean_latents_2x=clean_latents_2x.squeeze(0),  # Past clean frames (2x)
+                    clean_latent_2x_indices=clean_latent_2x_indices.squeeze(0),  # Indices for clean_latents_2x
+                    clean_latents_4x=clean_latents_4x.squeeze(0),  # Past clean frames (4x)
+                    clean_latent_4x_indices=clean_latent_4x_indices.squeeze(0),  # Indices for clean_latents_4x
+                    image_embeddings=img_emb,
+                    # Note: We don't explicitly save past_offset_indices,
+                    # but its size influences the absolute values in other indices.
+                )
+
+
+def encode_and_save_batch_one_frame(
+    vae: AutoencoderKLCausal3D,
+    feature_extractor: SiglipImageProcessor,
+    image_encoder: SiglipVisionModel,
+    batch: List[ItemInfo],
+    vanilla_sampling: bool = False,
+    one_frame_no_2x: bool = False,
+    one_frame_no_4x: bool = False,
+):
+    # item.content: target image (H, W, C)
+    # item.control_content: list of images (H, W, C)
+    _, _, contents, content_masks = preprocess_contents(batch)
+    contents = contents.to(vae.device, dtype=vae.dtype)  # B, C, F, H, W
+
+    # VAE encode: we need to encode one frame at a time because VAE encoder has stride=4 for the time dimension except for the first frame.
+    latents = [hunyuan.vae_encode(contents[:, :, idx : idx + 1], vae).to("cpu") for idx in range(contents.shape[2])]
+    latents = torch.cat(latents, dim=2)  # B, C, F, H/8, W/8
+
+    # apply alphas to latents
+    for b, item in enumerate(batch):
+        for i, content_mask in enumerate(content_masks[b]):
+            if content_mask is not None:
+                # apply mask to the latents
+                # print(f"Applying content mask for item {item.item_key}, frame {i}")
+                latents[b : b + 1, :, i : i + 1] *= content_mask
+
+    # Vision encoding per‑item (once): use control content because it is the start image
+    images = [item.control_content[0] for item in batch]  # list of [H, W, C]
+
+    # encode image with image encoder
+    image_embeddings = []
+    with torch.no_grad():
+        for image in images:
+            if image.shape[-1] == 4:
+                image = image[..., :3]
+            image_encoder_output = hf_clip_vision_encode(image, feature_extractor, image_encoder)
+            image_embeddings.append(image_encoder_output.last_hidden_state)
+    image_embeddings = torch.cat(image_embeddings, dim=0)  # B, LEN, 1152
+    image_embeddings = image_embeddings.to("cpu")  # Save memory
+
+    # save cache for each item in the batch
+    for b, item in enumerate(batch):
+        # indices generation (same as inference): each item may have different clean_latent_indices, so we generate them per item
+        clean_latent_indices = item.fp_1f_clean_indices  # list of indices for clean latents
+        if clean_latent_indices is None or len(clean_latent_indices) == 0:
+            logger.warning(
+                f"Item {item.item_key} has no clean_latent_indices defined, using default indices for one frame training."
+            )
+            clean_latent_indices = [0]
+
+        if not item.fp_1f_no_post:
+            clean_latent_indices = clean_latent_indices + [1 + item.fp_latent_window_size]
+        clean_latent_indices = torch.Tensor(clean_latent_indices).long()  #  N
+
+        latent_index = torch.Tensor([item.fp_1f_target_index]).long()  #  1
+
+        # zero values is not needed to cache even if one_frame_no_2x or 4x is False
+        clean_latents_2x = None
+        clean_latents_4x = None
+
+        if one_frame_no_2x:
+            clean_latent_2x_indices = None
+        else:
+            index = 1 + item.fp_latent_window_size + 1
+            clean_latent_2x_indices = torch.arange(index, index + 2)  #  2
+
+        if one_frame_no_4x:
+            clean_latent_4x_indices = None
+        else:
+            index = 1 + item.fp_latent_window_size + 1 + 2
+            clean_latent_4x_indices = torch.arange(index, index + 16)  #  16
+
+        # clean latents preparation (emulating inference)
+        clean_latents = latents[b, :, :-1]  # C, F, H, W
+        if not item.fp_1f_no_post:
+            # If zero post is enabled, we need to add a zero frame at the end
+            clean_latents = F.pad(clean_latents, (0, 0, 0, 0, 0, 1), value=0.0)  # C, F+1, H, W
+
+        # Target latents for this section (ground truth)
+        target_latents = latents[b, :, -1:]  # C, 1, H, W
+
+        print(f"Saving cache for item {item.item_key} at {item.latent_cache_path}. no_post: {item.fp_1f_no_post}")
+        print(f"  Clean latent indices: {clean_latent_indices}, latent index: {latent_index}")
+        print(f"  Clean latents: {clean_latents.shape}, target latents: {target_latents.shape}")
+        print(f"  Clean latents 2x indices: {clean_latent_2x_indices}, clean latents 4x indices: {clean_latent_4x_indices}")
+        print(
+            f"  Clean latents 2x: {clean_latents_2x.shape if clean_latents_2x is not None else 'None'}, "
+            f"Clean latents 4x: {clean_latents_4x.shape if clean_latents_4x is not None else 'None'}"
+        )
+        print(f"  Image embeddings: {image_embeddings[b].shape}")
+
+        # save cache (file path is inside item.latent_cache_path pattern), remove batch dim
+        save_latent_cache_framepack(
+            item_info=item,
+            latent=target_latents,  # Ground truth for this section
+            latent_indices=latent_index,  # Indices for the ground truth section
+            clean_latents=clean_latents,  # Start frame + history placeholder
+            clean_latent_indices=clean_latent_indices,  # Indices for start frame + history placeholder
+            clean_latents_2x=clean_latents_2x,  # History placeholder
+            clean_latent_2x_indices=clean_latent_2x_indices,  # Indices for history placeholder
+            clean_latents_4x=clean_latents_4x,  # History placeholder
+            clean_latent_4x_indices=clean_latent_4x_indices,  # Indices for history placeholder
+            image_embeddings=image_embeddings[b],
+        )
+
+
+def framepack_setup_parser(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+    parser.add_argument("--image_encoder", type=str, required=True, help="Image encoder (CLIP) checkpoint path or directory")
+    parser.add_argument(
+        "--f1",
+        action="store_true",
+        help="Generate cache for F1 model (vanilla (autoregressive) sampling) instead of Inverted anti-drifting (plain FramePack)",
+    )
+    parser.add_argument(
+        "--one_frame",
+        action="store_true",
+        help="Generate cache for one frame training (single frame, single section). latent_window_size is used as the index of the target frame.",
+    )
+    parser.add_argument(
+        "--one_frame_no_2x",
+        action="store_true",
+        help="Do not use clean_latents_2x and clean_latent_2x_indices for one frame training.",
+    )
+    parser.add_argument(
+        "--one_frame_no_4x",
+        action="store_true",
+        help="Do not use clean_latents_4x and clean_latent_4x_indices for one frame training.",
+    )
+    return parser
+
+
+def main():
+    parser = cache_latents.setup_parser_common()
+    parser = cache_latents.hv_setup_parser(parser)  # VAE
+    parser = framepack_setup_parser(parser)
+
+    args = parser.parse_args()
+
+    if args.disable_cudnn_backend:
+        logger.info("Disabling cuDNN PyTorch backend.")
+        torch.backends.cudnn.enabled = False
+
+    if args.vae_dtype is not None:
+        raise ValueError("VAE dtype is not supported in FramePack")
+    # if args.batch_size != 1:
+    #     args.batch_size = 1
+    #     logger.info("Batch size is set to 1 for FramePack.")
+
+    device = args.device if hasattr(args, "device") and args.device else ("cuda" if torch.cuda.is_available() else "cpu")
+    device = torch.device(device)
+
+    # Load dataset config
+    blueprint_generator = BlueprintGenerator(ConfigSanitizer())
+    logger.info(f"Load dataset config from {args.dataset_config}")
+    user_config = config_utils.load_user_config(args.dataset_config)
+    blueprint = blueprint_generator.generate(user_config, args, architecture=ARCHITECTURE_FRAMEPACK)
+    train_dataset_group = config_utils.generate_dataset_group_by_blueprint(blueprint.dataset_group)
+
+    datasets = train_dataset_group.datasets
+
+    if args.debug_mode is not None:
+        cache_latents.show_datasets(
+            datasets, args.debug_mode, args.console_width, args.console_back, args.console_num_images, fps=16
+        )
+        return
+
+    assert args.vae is not None, "vae checkpoint is required"
+
+    logger.info(f"Loading VAE model from {args.vae}")
+    vae = load_vae(args.vae, args.vae_chunk_size, args.vae_spatial_tile_sample_min_size, args.vae_tiling, device=device)
+    vae.to(device)
+
+    logger.info(f"Loading image encoder from {args.image_encoder}")
+    feature_extractor, image_encoder = load_image_encoders(args)
+    image_encoder.eval()
+    image_encoder.to(device)
+
+    logger.info(f"Cache generation mode: {'Vanilla Sampling' if args.f1 else 'Inference Emulation'}")
+
+    # encoding closure
+    def encode(batch: List[ItemInfo]):
+        encode_and_save_batch(
+            vae, feature_extractor, image_encoder, batch, args.f1, args.one_frame, args.one_frame_no_2x, args.one_frame_no_4x
+        )
+
+    # reuse core loop from cache_latents with no change
+    encode_datasets_framepack(datasets, encode, args)
+
+
+def append_section_idx_to_latent_cache_path(latent_cache_path: str, section_idx: int) -> str:
+    tokens = latent_cache_path.split("_")
+    tokens[-3] = f"{tokens[-3]}-{section_idx:04d}"  # append section index to "frame_pos-count"
+    return "_".join(tokens)
+
+
+def encode_datasets_framepack(datasets: list[BaseDataset], encode: callable, args: argparse.Namespace):
+    num_workers = args.num_workers if args.num_workers is not None else max(1, os.cpu_count() - 1)
+    for i, dataset in enumerate(datasets):
+        logger.info(f"Encoding dataset [{i}]")
+        all_latent_cache_paths = []
+        for _, batch in tqdm(dataset.retrieve_latent_cache_batches(num_workers)):
+            batch: list[ItemInfo] = batch  # type: ignore
+
+            # make sure content has 3 channels
+            for item in batch:
+                if isinstance(item.content, np.ndarray):
+                    if item.content.shape[-1] == 4:
+                        item.content = item.content[..., :3]
+                else:
+                    item.content = [img[..., :3] if img.shape[-1] == 4 else img for img in item.content]
+
+            # latent_cache_path is "{basename}_{w:04d}x{h:04d}_{self.architecture}.safetensors"
+            # For video dataset,we expand it to "{basename}_{section_idx:04d}_{w:04d}x{h:04d}_{self.architecture}.safetensors"
+            filtered_batch = []
+            for item in batch:
+                if item.frame_count is None:
+                    # image dataset
+                    all_latent_cache_paths.append(item.latent_cache_path)
+                    all_existing = os.path.exists(item.latent_cache_path)
+                else:
+                    latent_f = (item.frame_count - 1) // 4 + 1
+                    num_sections = max(1, math.floor((latent_f - 1) / item.fp_latent_window_size))  # min 1 section
+                    all_existing = True
+                    for sec in range(num_sections):
+                        p = append_section_idx_to_latent_cache_path(item.latent_cache_path, sec)
+                        all_latent_cache_paths.append(p)
+                        all_existing = all_existing and os.path.exists(p)
+
+                if not all_existing:  # if any section cache is missing
+                    filtered_batch.append(item)
+
+            if args.skip_existing:
+                if len(filtered_batch) == 0:  # all sections exist
+                    logger.info(f"All sections exist for {batch[0].item_key}, skipping")
+                    continue
+                batch = filtered_batch  # update batch to only missing sections
+
+            bs = args.batch_size if args.batch_size is not None else len(batch)
+            for i in range(0, len(batch), bs):
+                encode(batch[i : i + bs])
+
+        # normalize paths
+        all_latent_cache_paths = [os.path.normpath(p) for p in all_latent_cache_paths]
+        all_latent_cache_paths = set(all_latent_cache_paths)
+
+        # remove old cache files not in the dataset
+        all_cache_files = dataset.get_all_latent_cache_files()
+        for cache_file in all_cache_files:
+            if os.path.normpath(cache_file) not in all_latent_cache_paths:
+                if args.keep_cache:
+                    logger.info(f"Keep cache file not in the dataset: {cache_file}")
+                else:
+                    os.remove(cache_file)
+                    logger.info(f"Removed old cache file: {cache_file}")
+
+
+if __name__ == "__main__":
+    main()

src/musubi_tuner/frame_pack/bucket_tools.py

@@ -0,0 +1,29 @@
+bucket_options = {
+    640: [
+        (416, 960),
+        (448, 864),
+        (480, 832),
+        (512, 768),
+        (544, 704),
+        (576, 672),
+        (608, 640),
+        (640, 608),
+        (672, 576),
+        (704, 544),
+        (768, 512),
+        (832, 480),
+        (864, 448),
+        (960, 416),
+    ],
+}
+
+
+def find_nearest_bucket(h, w, resolution=640):
+    min_metric = float("inf")
+    best_bucket = None
+    for bucket_h, bucket_w in bucket_options[resolution]:
+        metric = abs(h * bucket_w - w * bucket_h)
+        if metric <= min_metric:
+            min_metric = metric
+            best_bucket = (bucket_h, bucket_w)
+    return best_bucket

src/musubi_tuner/frame_pack/clip_vision.py

@@ -0,0 +1,13 @@
+import numpy as np
+
+
+def hf_clip_vision_encode(image, feature_extractor, image_encoder):
+    assert isinstance(image, np.ndarray)
+    assert image.ndim == 3 and image.shape[2] == 3
+    assert image.dtype == np.uint8
+
+    preprocessed = feature_extractor.preprocess(images=image, return_tensors="pt")
+    preprocessed = preprocessed.to(device=image_encoder.device, dtype=image_encoder.dtype)
+    image_encoder_output = image_encoder(**preprocessed)
+
+    return image_encoder_output

src/musubi_tuner/frame_pack/framepack_utils.py

@@ -0,0 +1,274 @@
+import os
+import logging
+from typing import Optional, Union
+
+from accelerate import init_empty_weights
+import torch
+from safetensors.torch import load_file
+from transformers import (
+    LlamaTokenizerFast,
+    LlamaConfig,
+    LlamaModel,
+    CLIPTokenizer,
+    CLIPTextModel,
+    CLIPConfig,
+    SiglipImageProcessor,
+    SiglipVisionModel,
+    SiglipVisionConfig,
+)
+
+from musubi_tuner.utils.safetensors_utils import load_split_weights
+from musubi_tuner.hunyuan_model.vae import load_vae as hunyuan_load_vae
+
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+def load_vae(
+    vae_path: str,
+    vae_chunk_size: Optional[int],
+    vae_spatial_tile_sample_min_size: Optional[int],
+    vae_tiling: bool,
+    device: Union[str, torch.device],
+):
+    # single file and directory (contains 'vae') support
+    if os.path.isdir(vae_path):
+        vae_path = os.path.join(vae_path, "vae", "diffusion_pytorch_model.safetensors")
+    else:
+        vae_path = vae_path
+
+    vae_dtype = torch.float16  # if vae_dtype is None else str_to_dtype(vae_dtype)
+    vae, _, s_ratio, t_ratio = hunyuan_load_vae(vae_dtype=vae_dtype, device=device, vae_path=vae_path)
+    vae.eval()
+    # vae_kwargs = {"s_ratio": s_ratio, "t_ratio": t_ratio}
+
+    # set chunk_size to CausalConv3d recursively
+    chunk_size = vae_chunk_size
+    if chunk_size is not None:
+        vae.set_chunk_size_for_causal_conv_3d(chunk_size)
+        logger.info(f"Set chunk_size to {chunk_size} for CausalConv3d")
+
+    if vae_spatial_tile_sample_min_size is not None:
+        vae.enable_spatial_tiling(True)
+        vae.tile_sample_min_size = vae_spatial_tile_sample_min_size
+        vae.tile_latent_min_size = vae_spatial_tile_sample_min_size // 8
+        logger.info(f"Enabled spatial tiling with min size {vae_spatial_tile_sample_min_size}")
+    elif vae_tiling:
+        vae.enable_spatial_tiling(True)
+
+    return vae
+
+
+# region Text Encoders
+
+# Text Encoder configs are copied from HunyuanVideo repo
+
+LLAMA_CONFIG = {
+    "architectures": ["LlamaModel"],
+    "attention_bias": False,
+    "attention_dropout": 0.0,
+    "bos_token_id": 128000,
+    "eos_token_id": 128001,
+    "head_dim": 128,
+    "hidden_act": "silu",
+    "hidden_size": 4096,
+    "initializer_range": 0.02,
+    "intermediate_size": 14336,
+    "max_position_embeddings": 8192,
+    "mlp_bias": False,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_hidden_layers": 32,
+    "num_key_value_heads": 8,
+    "pretraining_tp": 1,
+    "rms_norm_eps": 1e-05,
+    "rope_scaling": None,
+    "rope_theta": 500000.0,
+    "tie_word_embeddings": False,
+    "torch_dtype": "float16",
+    "transformers_version": "4.46.3",
+    "use_cache": True,
+    "vocab_size": 128320,
+}
+
+CLIP_CONFIG = {
+    #   "_name_or_path": "/raid/aryan/llava-llama-3-8b-v1_1-extracted/text_encoder_2",
+    "architectures": ["CLIPTextModel"],
+    "attention_dropout": 0.0,
+    "bos_token_id": 0,
+    "dropout": 0.0,
+    "eos_token_id": 2,
+    "hidden_act": "quick_gelu",
+    "hidden_size": 768,
+    "initializer_factor": 1.0,
+    "initializer_range": 0.02,
+    "intermediate_size": 3072,
+    "layer_norm_eps": 1e-05,
+    "max_position_embeddings": 77,
+    "model_type": "clip_text_model",
+    "num_attention_heads": 12,
+    "num_hidden_layers": 12,
+    "pad_token_id": 1,
+    "projection_dim": 768,
+    "torch_dtype": "float16",
+    "transformers_version": "4.48.0.dev0",
+    "vocab_size": 49408,
+}
+
+
+def load_text_encoder1(
+    args, fp8_llm: Optional[bool] = False, device: Optional[Union[str, torch.device]] = None
+) -> tuple[LlamaTokenizerFast, LlamaModel]:
+    # single file, split file and directory (contains 'text_encoder') support
+    logger.info("Loading text encoder 1 tokenizer")
+    tokenizer1 = LlamaTokenizerFast.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder="tokenizer")
+
+    logger.info(f"Loading text encoder 1 from {args.text_encoder1}")
+    if os.path.isdir(args.text_encoder1):
+        # load from directory, configs are in the directory
+        text_encoder1 = LlamaModel.from_pretrained(args.text_encoder1, subfolder="text_encoder", torch_dtype=torch.float16)
+    else:
+        # load from file, we create the model with the appropriate config
+        config = LlamaConfig(**LLAMA_CONFIG)
+        with init_empty_weights():
+            text_encoder1 = LlamaModel._from_config(config, torch_dtype=torch.float16)
+
+        state_dict = load_split_weights(args.text_encoder1)
+
+        # support weights from ComfyUI
+        if "model.embed_tokens.weight" in state_dict:
+            for key in list(state_dict.keys()):
+                if key.startswith("model."):
+                    new_key = key.replace("model.", "")
+                    state_dict[new_key] = state_dict[key]
+                    del state_dict[key]
+        if "tokenizer" in state_dict:
+            state_dict.pop("tokenizer")
+        if "lm_head.weight" in state_dict:
+            state_dict.pop("lm_head.weight")
+
+        # # support weights from ComfyUI
+        # if "tokenizer" in state_dict:
+        #     state_dict.pop("tokenizer")
+
+        text_encoder1.load_state_dict(state_dict, strict=True, assign=True)
+
+    if fp8_llm:
+        org_dtype = text_encoder1.dtype
+        logger.info(f"Moving and casting text encoder to {device} and torch.float8_e4m3fn")
+        text_encoder1.to(device=device, dtype=torch.float8_e4m3fn)
+
+        # prepare LLM for fp8
+        def prepare_fp8(llama_model: LlamaModel, target_dtype):
+            def forward_hook(module):
+                def forward(hidden_states):
+                    input_dtype = hidden_states.dtype
+                    hidden_states = hidden_states.to(torch.float32)
+                    variance = hidden_states.pow(2).mean(-1, keepdim=True)
+                    hidden_states = hidden_states * torch.rsqrt(variance + module.variance_epsilon)
+                    return module.weight.to(input_dtype) * hidden_states.to(input_dtype)
+
+                return forward
+
+            for module in llama_model.modules():
+                if module.__class__.__name__ in ["Embedding"]:
+                    # print("set", module.__class__.__name__, "to", target_dtype)
+                    module.to(target_dtype)
+                if module.__class__.__name__ in ["LlamaRMSNorm"]:
+                    # print("set", module.__class__.__name__, "hooks")
+                    module.forward = forward_hook(module)
+
+        prepare_fp8(text_encoder1, org_dtype)
+    else:
+        text_encoder1.to(device)
+
+    text_encoder1.eval()
+    return tokenizer1, text_encoder1
+
+
+def load_text_encoder2(args) -> tuple[CLIPTokenizer, CLIPTextModel]:
+    # single file and directory (contains 'text_encoder_2') support
+    logger.info("Loading text encoder 2 tokenizer")
+    tokenizer2 = CLIPTokenizer.from_pretrained("hunyuanvideo-community/HunyuanVideo", subfolder="tokenizer_2")
+
+    logger.info(f"Loading text encoder 2 from {args.text_encoder2}")
+    if os.path.isdir(args.text_encoder2):
+        # load from directory, configs are in the directory
+        text_encoder2 = CLIPTextModel.from_pretrained(args.text_encoder2, subfolder="text_encoder_2", torch_dtype=torch.float16)
+    else:
+        # we only have one file, so we can load it directly
+        config = CLIPConfig(**CLIP_CONFIG)
+        with init_empty_weights():
+            text_encoder2 = CLIPTextModel._from_config(config, torch_dtype=torch.float16)
+
+        state_dict = load_file(args.text_encoder2)
+
+        text_encoder2.load_state_dict(state_dict, strict=True, assign=True)
+
+    text_encoder2.eval()
+    return tokenizer2, text_encoder2
+
+
+# endregion
+
+# region image encoder
+
+# Siglip configs are copied from FramePack repo
+FEATURE_EXTRACTOR_CONFIG = {
+    "do_convert_rgb": None,
+    "do_normalize": True,
+    "do_rescale": True,
+    "do_resize": True,
+    "image_mean": [0.5, 0.5, 0.5],
+    "image_processor_type": "SiglipImageProcessor",
+    "image_std": [0.5, 0.5, 0.5],
+    "processor_class": "SiglipProcessor",
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {"height": 384, "width": 384},
+}
+IMAGE_ENCODER_CONFIG = {
+    "_name_or_path": "/home/lvmin/.cache/huggingface/hub/models--black-forest-labs--FLUX.1-Redux-dev/snapshots/1282f955f706b5240161278f2ef261d2a29ad649/image_encoder",
+    "architectures": ["SiglipVisionModel"],
+    "attention_dropout": 0.0,
+    "hidden_act": "gelu_pytorch_tanh",
+    "hidden_size": 1152,
+    "image_size": 384,
+    "intermediate_size": 4304,
+    "layer_norm_eps": 1e-06,
+    "model_type": "siglip_vision_model",
+    "num_attention_heads": 16,
+    "num_channels": 3,
+    "num_hidden_layers": 27,
+    "patch_size": 14,
+    "torch_dtype": "bfloat16",
+    "transformers_version": "4.46.2",
+}
+
+
+# TODO do not take args, take only necessary parameters
+def load_image_encoders(args):
+    logger.info("Loading image encoder feature extractor")
+    feature_extractor = SiglipImageProcessor(**FEATURE_EXTRACTOR_CONFIG)
+
+    # single file, split file and directory (contains 'image_encoder') support
+    logger.info(f"Loading image encoder from {args.image_encoder}")
+    if os.path.isdir(args.image_encoder):
+        # load from directory, configs are in the directory
+        image_encoder = SiglipVisionModel.from_pretrained(args.image_encoder, subfolder="image_encoder", torch_dtype=torch.float16)
+    else:
+        # load from file, we create the model with the appropriate config
+        config = SiglipVisionConfig(**IMAGE_ENCODER_CONFIG)
+        with init_empty_weights():
+            image_encoder = SiglipVisionModel._from_config(config, torch_dtype=torch.float16)
+
+        state_dict = load_file(args.image_encoder)
+
+        image_encoder.load_state_dict(state_dict, strict=True, assign=True)
+
+    image_encoder.eval()
+    return feature_extractor, image_encoder
+
+
+# endregion

src/musubi_tuner/frame_pack/hunyuan.py

@@ -0,0 +1,134 @@
+# original code: https://github.com/lllyasviel/FramePack
+# original license: Apache-2.0
+
+import torch
+
+# from diffusers.pipelines.hunyuan_video.pipeline_hunyuan_video import DEFAULT_PROMPT_TEMPLATE
+# from diffusers_helper.utils import crop_or_pad_yield_mask
+from musubi_tuner.hunyuan_model.autoencoder_kl_causal_3d import AutoencoderKLCausal3D
+from musubi_tuner.hunyuan_model.text_encoder import PROMPT_TEMPLATE
+
+
+@torch.no_grad()
+def encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2, max_length=256, custom_system_prompt=None):
+    assert isinstance(prompt, str)
+
+    prompt = [prompt]
+
+    # LLAMA
+
+    # We can verify crop_start by checking the token count of the prompt:
+    # custom_system_prompt = (
+    #     "Describe the video by detailing the following aspects: "
+    #     "1. The main content and theme of the video."
+    #     "2. The color, shape, size, texture, quantity, text, and spatial relationships of the objects."
+    #     "3. Actions, events, behaviors temporal relationships, physical movement changes of the objects."
+    #     "4. background environment, light, style and atmosphere."
+    #     "5. camera angles, movements, and transitions used in the video:"
+    # )
+    if custom_system_prompt is None:
+        prompt_llama = [PROMPT_TEMPLATE["dit-llm-encode-video"]["template"].format(p) for p in prompt]
+        crop_start = PROMPT_TEMPLATE["dit-llm-encode-video"]["crop_start"]
+    else:
+        # count tokens for custom_system_prompt
+        full_prompt = f"<|start_header_id|>system<|end_header_id|>\n\n{custom_system_prompt}<|eot_id|><|start_header_id|>user<|end_header_id|>\n\n"
+        print(f"Custom system prompt: {full_prompt}")
+        system_prompt_tokens = tokenizer(full_prompt, return_tensors="pt", truncation=True).input_ids[0].shape[0]
+        print(f"Custom system prompt token count: {system_prompt_tokens}")
+        prompt_llama = [full_prompt + p + "<|eot_id|>" for p in prompt]
+        crop_start = system_prompt_tokens
+
+    llama_inputs = tokenizer(
+        prompt_llama,
+        padding="max_length",
+        max_length=max_length + crop_start,
+        truncation=True,
+        return_tensors="pt",
+        return_length=False,
+        return_overflowing_tokens=False,
+        return_attention_mask=True,
+    )
+
+    llama_input_ids = llama_inputs.input_ids.to(text_encoder.device)
+    llama_attention_mask = llama_inputs.attention_mask.to(text_encoder.device)
+    llama_attention_length = int(llama_attention_mask.sum())
+
+    llama_outputs = text_encoder(
+        input_ids=llama_input_ids,
+        attention_mask=llama_attention_mask,
+        output_hidden_states=True,
+    )
+
+    llama_vec = llama_outputs.hidden_states[-3][:, crop_start:llama_attention_length]
+    # llama_vec_remaining = llama_outputs.hidden_states[-3][:, llama_attention_length:]
+    llama_attention_mask = llama_attention_mask[:, crop_start:llama_attention_length]
+
+    assert torch.all(llama_attention_mask.bool())
+
+    # CLIP
+
+    clip_l_input_ids = tokenizer_2(
+        prompt,
+        padding="max_length",
+        max_length=77,
+        truncation=True,
+        return_overflowing_tokens=False,
+        return_length=False,
+        return_tensors="pt",
+    ).input_ids
+    clip_l_pooler = text_encoder_2(clip_l_input_ids.to(text_encoder_2.device), output_hidden_states=False).pooler_output
+
+    return llama_vec, clip_l_pooler
+
+
+@torch.no_grad()
+def vae_decode_fake(latents):
+    latent_rgb_factors = [
+        [-0.0395, -0.0331, 0.0445],
+        [0.0696, 0.0795, 0.0518],
+        [0.0135, -0.0945, -0.0282],
+        [0.0108, -0.0250, -0.0765],
+        [-0.0209, 0.0032, 0.0224],
+        [-0.0804, -0.0254, -0.0639],
+        [-0.0991, 0.0271, -0.0669],
+        [-0.0646, -0.0422, -0.0400],
+        [-0.0696, -0.0595, -0.0894],
+        [-0.0799, -0.0208, -0.0375],
+        [0.1166, 0.1627, 0.0962],
+        [0.1165, 0.0432, 0.0407],
+        [-0.2315, -0.1920, -0.1355],
+        [-0.0270, 0.0401, -0.0821],
+        [-0.0616, -0.0997, -0.0727],
+        [0.0249, -0.0469, -0.1703],
+    ]  # From comfyui
+
+    latent_rgb_factors_bias = [0.0259, -0.0192, -0.0761]
+
+    weight = torch.tensor(latent_rgb_factors, device=latents.device, dtype=latents.dtype).transpose(0, 1)[:, :, None, None, None]
+    bias = torch.tensor(latent_rgb_factors_bias, device=latents.device, dtype=latents.dtype)
+
+    images = torch.nn.functional.conv3d(latents, weight, bias=bias, stride=1, padding=0, dilation=1, groups=1)
+    images = images.clamp(0.0, 1.0)
+
+    return images
+
+
+@torch.no_grad()
+def vae_decode(latents, vae, image_mode=False) -> torch.Tensor:
+    latents = latents / vae.config.scaling_factor
+
+    if not image_mode:
+        image = vae.decode(latents.to(device=vae.device, dtype=vae.dtype)).sample
+    else:
+        latents = latents.to(device=vae.device, dtype=vae.dtype).unbind(2)
+        image = [vae.decode(l.unsqueeze(2)).sample for l in latents]
+        image = torch.cat(image, dim=2)
+
+    return image
+
+
+@torch.no_grad()
+def vae_encode(image, vae: AutoencoderKLCausal3D) -> torch.Tensor:
+    latents = vae.encode(image.to(device=vae.device, dtype=vae.dtype)).latent_dist.sample()
+    latents = latents * vae.config.scaling_factor
+    return latents

src/musubi_tuner/frame_pack/hunyuan_video_packed.py

@@ -0,0 +1,2141 @@
+# original code: https://github.com/lllyasviel/FramePack
+# original license: Apache-2.0
+
+import glob
+import math
+import numbers
+import os
+from types import SimpleNamespace
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import torch
+import einops
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+from musubi_tuner.modules.custom_offloading_utils import ModelOffloader
+from musubi_tuner.utils.lora_utils import load_safetensors_with_lora_and_fp8
+from musubi_tuner.utils.model_utils import create_cpu_offloading_wrapper
+from musubi_tuner.utils.safetensors_utils import load_split_weights
+from musubi_tuner.modules.fp8_optimization_utils import apply_fp8_monkey_patch, optimize_state_dict_with_fp8
+from accelerate import init_empty_weights
+
+try:
+    # raise NotImplementedError
+    from xformers.ops import memory_efficient_attention as xformers_attn_func
+
+    print("Xformers is installed!")
+except:
+    print("Xformers is not installed!")
+    xformers_attn_func = None
+
+try:
+    # raise NotImplementedError
+    from flash_attn import flash_attn_varlen_func, flash_attn_func
+
+    print("Flash Attn is installed!")
+except:
+    print("Flash Attn is not installed!")
+    flash_attn_varlen_func = None
+    flash_attn_func = None
+
+try:
+    # raise NotImplementedError
+    from sageattention import sageattn_varlen, sageattn
+
+    print("Sage Attn is installed!")
+except:
+    print("Sage Attn is not installed!")
+    sageattn_varlen = None
+    sageattn = None
+
+
+import logging
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+# region diffusers
+
+# copied from diffusers with some modifications to minimize dependencies
+# original code: https://github.com/huggingface/diffusers/
+# original license: Apache-2.0
+
+ACT2CLS = {
+    "swish": nn.SiLU,
+    "silu": nn.SiLU,
+    "mish": nn.Mish,
+    "gelu": nn.GELU,
+    "relu": nn.ReLU,
+}
+
+
+def get_activation(act_fn: str) -> nn.Module:
+    """Helper function to get activation function from string.
+
+    Args:
+        act_fn (str): Name of activation function.
+
+    Returns:
+        nn.Module: Activation function.
+    """
+
+    act_fn = act_fn.lower()
+    if act_fn in ACT2CLS:
+        return ACT2CLS[act_fn]()
+    else:
+        raise ValueError(f"activation function {act_fn} not found in ACT2FN mapping {list(ACT2CLS.keys())}")
+
+
+def get_timestep_embedding(
+    timesteps: torch.Tensor,
+    embedding_dim: int,
+    flip_sin_to_cos: bool = False,
+    downscale_freq_shift: float = 1,
+    scale: float = 1,
+    max_period: int = 10000,
+):
+    """
+    This matches the implementation in Denoising Diffusion Probabilistic Models: Create sinusoidal timestep embeddings.
+
+    Args
+        timesteps (torch.Tensor):
+            a 1-D Tensor of N indices, one per batch element. These may be fractional.
+        embedding_dim (int):
+            the dimension of the output.
+        flip_sin_to_cos (bool):
+            Whether the embedding order should be `cos, sin` (if True) or `sin, cos` (if False)
+        downscale_freq_shift (float):
+            Controls the delta between frequencies between dimensions
+        scale (float):
+            Scaling factor applied to the embeddings.
+        max_period (int):
+            Controls the maximum frequency of the embeddings
+    Returns
+        torch.Tensor: an [N x dim] Tensor of positional embeddings.
+    """
+    assert len(timesteps.shape) == 1, "Timesteps should be a 1d-array"
+
+    half_dim = embedding_dim // 2
+    exponent = -math.log(max_period) * torch.arange(start=0, end=half_dim, dtype=torch.float32, device=timesteps.device)
+    exponent = exponent / (half_dim - downscale_freq_shift)
+
+    emb = torch.exp(exponent)
+    emb = timesteps[:, None].float() * emb[None, :]
+
+    # scale embeddings
+    emb = scale * emb
+
+    # concat sine and cosine embeddings
+    emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=-1)
+
+    # flip sine and cosine embeddings
+    if flip_sin_to_cos:
+        emb = torch.cat([emb[:, half_dim:], emb[:, :half_dim]], dim=-1)
+
+    # zero pad
+    if embedding_dim % 2 == 1:
+        emb = torch.nn.functional.pad(emb, (0, 1, 0, 0))
+    return emb
+
+
+class TimestepEmbedding(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        time_embed_dim: int,
+        act_fn: str = "silu",
+        out_dim: int = None,
+        post_act_fn: Optional[str] = None,
+        cond_proj_dim=None,
+        sample_proj_bias=True,
+    ):
+        super().__init__()
+
+        self.linear_1 = nn.Linear(in_channels, time_embed_dim, sample_proj_bias)
+
+        if cond_proj_dim is not None:
+            self.cond_proj = nn.Linear(cond_proj_dim, in_channels, bias=False)
+        else:
+            self.cond_proj = None
+
+        self.act = get_activation(act_fn)
+
+        if out_dim is not None:
+            time_embed_dim_out = out_dim
+        else:
+            time_embed_dim_out = time_embed_dim
+        self.linear_2 = nn.Linear(time_embed_dim, time_embed_dim_out, sample_proj_bias)
+
+        if post_act_fn is None:
+            self.post_act = None
+        else:
+            self.post_act = get_activation(post_act_fn)
+
+    def forward(self, sample, condition=None):
+        if condition is not None:
+            sample = sample + self.cond_proj(condition)
+        sample = self.linear_1(sample)
+
+        if self.act is not None:
+            sample = self.act(sample)
+
+        sample = self.linear_2(sample)
+
+        if self.post_act is not None:
+            sample = self.post_act(sample)
+        return sample
+
+
+class Timesteps(nn.Module):
+    def __init__(self, num_channels: int, flip_sin_to_cos: bool, downscale_freq_shift: float, scale: int = 1):
+        super().__init__()
+        self.num_channels = num_channels
+        self.flip_sin_to_cos = flip_sin_to_cos
+        self.downscale_freq_shift = downscale_freq_shift
+        self.scale = scale
+
+    def forward(self, timesteps):
+        t_emb = get_timestep_embedding(
+            timesteps,
+            self.num_channels,
+            flip_sin_to_cos=self.flip_sin_to_cos,
+            downscale_freq_shift=self.downscale_freq_shift,
+            scale=self.scale,
+        )
+        return t_emb
+
+
+class FP32SiLU(nn.Module):
+    r"""
+    SiLU activation function with input upcasted to torch.float32.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, inputs: torch.Tensor) -> torch.Tensor:
+        return F.silu(inputs.float(), inplace=False).to(inputs.dtype)
+
+
+class GELU(nn.Module):
+    r"""
+    GELU activation function with tanh approximation support with `approximate="tanh"`.
+
+    Parameters:
+        dim_in (`int`): The number of channels in the input.
+        dim_out (`int`): The number of channels in the output.
+        approximate (`str`, *optional*, defaults to `"none"`): If `"tanh"`, use tanh approximation.
+        bias (`bool`, defaults to True): Whether to use a bias in the linear layer.
+    """
+
+    def __init__(self, dim_in: int, dim_out: int, approximate: str = "none", bias: bool = True):
+        super().__init__()
+        self.proj = nn.Linear(dim_in, dim_out, bias=bias)
+        self.approximate = approximate
+
+    def gelu(self, gate: torch.Tensor) -> torch.Tensor:
+        # if gate.device.type == "mps" and is_torch_version("<", "2.0.0"):
+        #     # fp16 gelu not supported on mps before torch 2.0
+        #     return F.gelu(gate.to(dtype=torch.float32), approximate=self.approximate).to(dtype=gate.dtype)
+        return F.gelu(gate, approximate=self.approximate)
+
+    def forward(self, hidden_states):
+        hidden_states = self.proj(hidden_states)
+        hidden_states = self.gelu(hidden_states)
+        return hidden_states
+
+
+class PixArtAlphaTextProjection(nn.Module):
+    """
+    Projects caption embeddings. Also handles dropout for classifier-free guidance.
+
+    Adapted from https://github.com/PixArt-alpha/PixArt-alpha/blob/master/diffusion/model/nets/PixArt_blocks.py
+    """
+
+    def __init__(self, in_features, hidden_size, out_features=None, act_fn="gelu_tanh"):
+        super().__init__()
+        if out_features is None:
+            out_features = hidden_size
+        self.linear_1 = nn.Linear(in_features=in_features, out_features=hidden_size, bias=True)
+        if act_fn == "gelu_tanh":
+            self.act_1 = nn.GELU(approximate="tanh")
+        elif act_fn == "silu":
+            self.act_1 = nn.SiLU()
+        elif act_fn == "silu_fp32":
+            self.act_1 = FP32SiLU()
+        else:
+            raise ValueError(f"Unknown activation function: {act_fn}")
+        self.linear_2 = nn.Linear(in_features=hidden_size, out_features=out_features, bias=True)
+
+    def forward(self, caption):
+        hidden_states = self.linear_1(caption)
+        hidden_states = self.act_1(hidden_states)
+        hidden_states = self.linear_2(hidden_states)
+        return hidden_states
+
+
+class LayerNormFramePack(nn.LayerNorm):
+    # casting to dtype of input tensor is added
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return torch.nn.functional.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps).to(x)
+
+
+class FP32LayerNormFramePack(nn.LayerNorm):
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        origin_dtype = x.dtype
+        return torch.nn.functional.layer_norm(
+            x.float(),
+            self.normalized_shape,
+            self.weight.float() if self.weight is not None else None,
+            self.bias.float() if self.bias is not None else None,
+            self.eps,
+        ).to(origin_dtype)
+
+
+class RMSNormFramePack(nn.Module):
+    r"""
+    RMS Norm as introduced in https://arxiv.org/abs/1910.07467 by Zhang et al.
+
+    Args:
+        dim (`int`): Number of dimensions to use for `weights`. Only effective when `elementwise_affine` is True.
+        eps (`float`): Small value to use when calculating the reciprocal of the square-root.
+        elementwise_affine (`bool`, defaults to `True`):
+            Boolean flag to denote if affine transformation should be applied.
+        bias (`bool`, defaults to False): If also training the `bias` param.
+    """
+
+    def __init__(self, dim, eps: float, elementwise_affine: bool = True, bias: bool = False):
+        super().__init__()
+
+        self.eps = eps
+        self.elementwise_affine = elementwise_affine
+
+        if isinstance(dim, numbers.Integral):
+            dim = (dim,)
+
+        self.dim = torch.Size(dim)
+
+        self.weight = None
+        self.bias = None
+
+        if elementwise_affine:
+            self.weight = nn.Parameter(torch.ones(dim))
+            if bias:
+                self.bias = nn.Parameter(torch.zeros(dim))
+
+    def forward(self, hidden_states):
+        input_dtype = hidden_states.dtype
+        variance = hidden_states.to(torch.float32).pow(2).mean(-1, keepdim=True)
+        hidden_states = hidden_states * torch.rsqrt(variance + self.eps)
+
+        if self.weight is None:
+            return hidden_states.to(input_dtype)
+
+        return hidden_states.to(input_dtype) * self.weight.to(input_dtype)
+
+
+class AdaLayerNormContinuousFramePack(nn.Module):
+    r"""
+    Adaptive normalization layer with a norm layer (layer_norm or rms_norm).
+
+    Args:
+        embedding_dim (`int`): Embedding dimension to use during projection.
+        conditioning_embedding_dim (`int`): Dimension of the input condition.
+        elementwise_affine (`bool`, defaults to `True`):
+            Boolean flag to denote if affine transformation should be applied.
+        eps (`float`, defaults to 1e-5): Epsilon factor.
+        bias (`bias`, defaults to `True`): Boolean flag to denote if bias should be use.
+        norm_type (`str`, defaults to `"layer_norm"`):
+            Normalization layer to use. Values supported: "layer_norm", "rms_norm".
+    """
+
+    def __init__(
+        self,
+        embedding_dim: int,
+        conditioning_embedding_dim: int,
+        # NOTE: It is a bit weird that the norm layer can be configured to have scale and shift parameters
+        # because the output is immediately scaled and shifted by the projected conditioning embeddings.
+        # Note that AdaLayerNorm does not let the norm layer have scale and shift parameters.
+        # However, this is how it was implemented in the original code, and it's rather likely you should
+        # set `elementwise_affine` to False.
+        elementwise_affine=True,
+        eps=1e-5,
+        bias=True,
+        norm_type="layer_norm",
+    ):
+        super().__init__()
+        self.silu = nn.SiLU()
+        self.linear = nn.Linear(conditioning_embedding_dim, embedding_dim * 2, bias=bias)
+        if norm_type == "layer_norm":
+            self.norm = LayerNormFramePack(embedding_dim, eps, elementwise_affine, bias)
+        elif norm_type == "rms_norm":
+            self.norm = RMSNormFramePack(embedding_dim, eps, elementwise_affine)
+        else:
+            raise ValueError(f"unknown norm_type {norm_type}")
+
+    def forward(self, x, conditioning_embedding):
+        emb = self.linear(self.silu(conditioning_embedding))
+        scale, shift = emb.chunk(2, dim=1)
+        x = self.norm(x) * (1 + scale)[:, None, :] + shift[:, None, :]
+        return x
+
+
+class LinearActivation(nn.Module):
+    def __init__(self, dim_in: int, dim_out: int, bias: bool = True, activation: str = "silu"):
+        super().__init__()
+
+        self.proj = nn.Linear(dim_in, dim_out, bias=bias)
+        self.activation = get_activation(activation)
+
+    def forward(self, hidden_states):
+        hidden_states = self.proj(hidden_states)
+        return self.activation(hidden_states)
+
+
+class FeedForward(nn.Module):
+    r"""
+    A feed-forward layer.
+
+    Parameters:
+        dim (`int`): The number of channels in the input.
+        dim_out (`int`, *optional*): The number of channels in the output. If not given, defaults to `dim`.
+        mult (`int`, *optional*, defaults to 4): The multiplier to use for the hidden dimension.
+        dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use.
+        activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to be used in feed-forward.
+        final_dropout (`bool` *optional*, defaults to False): Apply a final dropout.
+        bias (`bool`, defaults to True): Whether to use a bias in the linear layer.
+    """
+
+    def __init__(
+        self,
+        dim: int,
+        dim_out: Optional[int] = None,
+        mult: int = 4,
+        dropout: float = 0.0,
+        activation_fn: str = "geglu",
+        final_dropout: bool = False,
+        inner_dim=None,
+        bias: bool = True,
+    ):
+        super().__init__()
+        if inner_dim is None:
+            inner_dim = int(dim * mult)
+        dim_out = dim_out if dim_out is not None else dim
+
+        # if activation_fn == "gelu":
+        #     act_fn = GELU(dim, inner_dim, bias=bias)
+        if activation_fn == "gelu-approximate":
+            act_fn = GELU(dim, inner_dim, approximate="tanh", bias=bias)
+        # elif activation_fn == "geglu":
+        #     act_fn = GEGLU(dim, inner_dim, bias=bias)
+        # elif activation_fn == "geglu-approximate":
+        #     act_fn = ApproximateGELU(dim, inner_dim, bias=bias)
+        # elif activation_fn == "swiglu":
+        #     act_fn = SwiGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "linear-silu":
+            act_fn = LinearActivation(dim, inner_dim, bias=bias, activation="silu")
+        else:
+            raise ValueError(f"Unknown activation function: {activation_fn}")
+
+        self.net = nn.ModuleList([])
+        # project in
+        self.net.append(act_fn)
+        # project dropout
+        self.net.append(nn.Dropout(dropout))
+        # project out
+        self.net.append(nn.Linear(inner_dim, dim_out, bias=bias))
+        # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
+        if final_dropout:
+            self.net.append(nn.Dropout(dropout))
+
+    def forward(self, hidden_states: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        if len(args) > 0 or kwargs.get("scale", None) is not None:
+            # deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
+            # deprecate("scale", "1.0.0", deprecation_message)
+            raise ValueError("scale is not supported in this version. Please remove it.")
+        for module in self.net:
+            hidden_states = module(hidden_states)
+        return hidden_states
+
+
+# @maybe_allow_in_graph
+class Attention(nn.Module):
+    r"""
+    Minimal copy of Attention class from diffusers.
+    """
+
+    def __init__(
+        self,
+        query_dim: int,
+        cross_attention_dim: Optional[int] = None,
+        heads: int = 8,
+        dim_head: int = 64,
+        bias: bool = False,
+        qk_norm: Optional[str] = None,
+        added_kv_proj_dim: Optional[int] = None,
+        eps: float = 1e-5,
+        processor: Optional[any] = None,
+        out_dim: int = None,
+        context_pre_only=None,
+        pre_only=False,
+    ):
+        super().__init__()
+        self.inner_dim = out_dim if out_dim is not None else dim_head * heads
+        self.inner_kv_dim = self.inner_dim  # if kv_heads is None else dim_head * kv_heads
+        self.query_dim = query_dim
+        self.use_bias = bias
+        self.cross_attention_dim = cross_attention_dim if cross_attention_dim is not None else query_dim
+        self.out_dim = out_dim if out_dim is not None else query_dim
+        self.out_context_dim = query_dim
+        self.context_pre_only = context_pre_only
+        self.pre_only = pre_only
+
+        self.scale = dim_head**-0.5
+        self.heads = out_dim // dim_head if out_dim is not None else heads
+
+        self.added_kv_proj_dim = added_kv_proj_dim
+
+        if qk_norm is None:
+            self.norm_q = None
+            self.norm_k = None
+        elif qk_norm == "rms_norm":
+            self.norm_q = RMSNormFramePack(dim_head, eps=eps)
+            self.norm_k = RMSNormFramePack(dim_head, eps=eps)
+        else:
+            raise ValueError(
+                f"unknown qk_norm: {qk_norm}. Should be one of None, 'layer_norm', 'fp32_layer_norm', 'layer_norm_across_heads', 'rms_norm', 'rms_norm_across_heads', 'l2'."
+            )
+
+        self.to_q = nn.Linear(query_dim, self.inner_dim, bias=bias)
+        self.to_k = nn.Linear(self.cross_attention_dim, self.inner_kv_dim, bias=bias)
+        self.to_v = nn.Linear(self.cross_attention_dim, self.inner_kv_dim, bias=bias)
+
+        self.added_proj_bias = True  # added_proj_bias
+        if self.added_kv_proj_dim is not None:
+            self.add_k_proj = nn.Linear(added_kv_proj_dim, self.inner_kv_dim, bias=True)
+            self.add_v_proj = nn.Linear(added_kv_proj_dim, self.inner_kv_dim, bias=True)
+            if self.context_pre_only is not None:
+                self.add_q_proj = nn.Linear(added_kv_proj_dim, self.inner_dim, bias=True)
+        else:
+            self.add_q_proj = None
+            self.add_k_proj = None
+            self.add_v_proj = None
+
+        if not self.pre_only:
+            self.to_out = nn.ModuleList([])
+            self.to_out.append(nn.Linear(self.inner_dim, self.out_dim, bias=True))
+            # self.to_out.append(nn.Dropout(dropout))
+            self.to_out.append(nn.Identity())  # dropout=0.0
+        else:
+            self.to_out = None
+
+        if self.context_pre_only is not None and not self.context_pre_only:
+            self.to_add_out = nn.Linear(self.inner_dim, self.out_context_dim, bias=True)
+        else:
+            self.to_add_out = None
+
+        if qk_norm is not None and added_kv_proj_dim is not None:
+            if qk_norm == "rms_norm":
+                self.norm_added_q = RMSNormFramePack(dim_head, eps=eps)
+                self.norm_added_k = RMSNormFramePack(dim_head, eps=eps)
+            else:
+                raise ValueError(f"unknown qk_norm: {qk_norm}. Should be one of `None,'layer_norm','fp32_layer_norm','rms_norm'`")
+        else:
+            self.norm_added_q = None
+            self.norm_added_k = None
+
+        # set attention processor
+        # We use the AttnProcessor2_0 by default when torch 2.x is used which uses
+        # torch.nn.functional.scaled_dot_product_attention for native Flash/memory_efficient_attention
+        if processor is None:
+            processor = AttnProcessor2_0()
+        self.set_processor(processor)
+
+    def set_processor(self, processor: any) -> None:
+        self.processor = processor
+
+    def get_processor(self) -> any:
+        return self.processor
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        **cross_attention_kwargs,
+    ) -> torch.Tensor:
+        return self.processor(
+            self,
+            hidden_states,
+            encoder_hidden_states=encoder_hidden_states,
+            attention_mask=attention_mask,
+            **cross_attention_kwargs,
+        )
+
+    def prepare_attention_mask(
+        self, attention_mask: torch.Tensor, target_length: int, batch_size: int, out_dim: int = 3
+    ) -> torch.Tensor:
+        r"""
+        Prepare the attention mask for the attention computation.
+
+        Args:
+            attention_mask (`torch.Tensor`):
+                The attention mask to prepare.
+            target_length (`int`):
+                The target length of the attention mask. This is the length of the attention mask after padding.
+            batch_size (`int`):
+                The batch size, which is used to repeat the attention mask.
+            out_dim (`int`, *optional*, defaults to `3`):
+                The output dimension of the attention mask. Can be either `3` or `4`.
+
+        Returns:
+            `torch.Tensor`: The prepared attention mask.
+        """
+        head_size = self.heads
+        if attention_mask is None:
+            return attention_mask
+
+        current_length: int = attention_mask.shape[-1]
+        if current_length != target_length:
+            if attention_mask.device.type == "mps":
+                # HACK: MPS: Does not support padding by greater than dimension of input tensor.
+                # Instead, we can manually construct the padding tensor.
+                padding_shape = (attention_mask.shape[0], attention_mask.shape[1], target_length)
+                padding = torch.zeros(padding_shape, dtype=attention_mask.dtype, device=attention_mask.device)
+                attention_mask = torch.cat([attention_mask, padding], dim=2)
+            else:
+                # TODO: for pipelines such as stable-diffusion, padding cross-attn mask:
+                #       we want to instead pad by (0, remaining_length), where remaining_length is:
+                #       remaining_length: int = target_length - current_length
+                # TODO: re-enable tests/models/test_models_unet_2d_condition.py#test_model_xattn_padding
+                attention_mask = F.pad(attention_mask, (0, target_length), value=0.0)
+
+        if out_dim == 3:
+            if attention_mask.shape[0] < batch_size * head_size:
+                attention_mask = attention_mask.repeat_interleave(head_size, dim=0, output_size=attention_mask.shape[0] * head_size)
+        elif out_dim == 4:
+            attention_mask = attention_mask.unsqueeze(1)
+            attention_mask = attention_mask.repeat_interleave(head_size, dim=1, output_size=attention_mask.shape[1] * head_size)
+
+        return attention_mask
+
+
+class AttnProcessor2_0:
+    r"""
+    Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0).
+    """
+
+    def __init__(self):
+        if not hasattr(F, "scaled_dot_product_attention"):
+            raise ImportError("AttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")
+
+    def __call__(
+        self,
+        attn: Attention,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: Optional[torch.Tensor] = None,
+        attention_mask: Optional[torch.Tensor] = None,
+        temb: Optional[torch.Tensor] = None,
+        *args,
+        **kwargs,
+    ) -> torch.Tensor:
+        input_ndim = hidden_states.ndim
+
+        if input_ndim == 4:
+            batch_size, channel, height, width = hidden_states.shape
+            hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)
+
+        batch_size, sequence_length, _ = hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape
+
+        if attention_mask is not None:
+            attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
+            # scaled_dot_product_attention expects attention_mask shape to be
+            # (batch, heads, source_length, target_length)
+            attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])
+
+        query = attn.to_q(hidden_states)
+        query_dtype = query.dtype  # store dtype before potentially deleting query
+
+        if encoder_hidden_states is None:
+            encoder_hidden_states = hidden_states
+
+        key = attn.to_k(encoder_hidden_states)
+        value = attn.to_v(encoder_hidden_states)
+
+        inner_dim = key.shape[-1]
+        head_dim = inner_dim // attn.heads
+
+        query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+        key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+        value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
+
+        if attn.norm_q is not None:
+            query = attn.norm_q(query)
+        if attn.norm_k is not None:
+            key = attn.norm_k(key)
+
+        # the output of sdp = (batch, num_heads, seq_len, head_dim)
+        hidden_states = F.scaled_dot_product_attention(query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False)
+        del query, key, value, attention_mask  # free memory
+
+        hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
+        hidden_states = hidden_states.to(query_dtype)  # use stored dtype
+
+        # linear proj
+        hidden_states = attn.to_out[0](hidden_states)
+        # dropout
+        hidden_states = attn.to_out[1](hidden_states)
+
+        if input_ndim == 4:
+            hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width)
+
+        return hidden_states
+
+
+# endregion diffusers
+
+
+def pad_for_3d_conv(x, kernel_size):
+    b, c, t, h, w = x.shape
+    pt, ph, pw = kernel_size
+    pad_t = (pt - (t % pt)) % pt
+    pad_h = (ph - (h % ph)) % ph
+    pad_w = (pw - (w % pw)) % pw
+    return torch.nn.functional.pad(x, (0, pad_w, 0, pad_h, 0, pad_t), mode="replicate")
+
+
+def center_down_sample_3d(x, kernel_size):
+    # pt, ph, pw = kernel_size
+    # cp = (pt * ph * pw) // 2
+    # xp = einops.rearrange(x, 'b c (t pt) (h ph) (w pw) -> (pt ph pw) b c t h w', pt=pt, ph=ph, pw=pw)
+    # xc = xp[cp]
+    # return xc
+    return torch.nn.functional.avg_pool3d(x, kernel_size, stride=kernel_size)
+
+
+def get_cu_seqlens(text_mask, img_len):
+    batch_size = text_mask.shape[0]
+    text_len = text_mask.sum(dim=1)
+    max_len = text_mask.shape[1] + img_len
+
+    cu_seqlens = torch.zeros([2 * batch_size + 1], dtype=torch.int32, device=text_mask.device)  # ensure device match
+
+    for i in range(batch_size):
+        s = text_len[i] + img_len
+        s1 = i * max_len + s
+        s2 = (i + 1) * max_len
+        cu_seqlens[2 * i + 1] = s1
+        cu_seqlens[2 * i + 2] = s2
+
+    seq_len = text_len + img_len
+    return cu_seqlens, seq_len
+
+
+def apply_rotary_emb_transposed(x, freqs_cis):
+    cos, sin = freqs_cis.unsqueeze(-2).chunk(2, dim=-1)
+    del freqs_cis
+    x_real, x_imag = x.unflatten(-1, (-1, 2)).unbind(-1)
+    x_rotated = torch.stack([-x_imag, x_real], dim=-1).flatten(3)
+    del x_real, x_imag
+    return (x.float() * cos + x_rotated.float() * sin).to(x.dtype)
+
+
+def attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len, attn_mode=None, split_attn=False):
+    # q,k,v: [batch_size, seqlen, heads, head_dim]
+    if cu_seqlens_q is None and cu_seqlens_kv is None and max_seqlen_q is None and max_seqlen_kv is None:
+        if attn_mode == "sageattn" or attn_mode is None and sageattn is not None:
+            x = sageattn(q, k, v, tensor_layout="NHD")
+            return x
+
+        if attn_mode == "flash" or attn_mode is None and flash_attn_func is not None:
+            x = flash_attn_func(q, k, v)
+            return x
+
+        if attn_mode == "xformers" or attn_mode is None and xformers_attn_func is not None:
+            x = xformers_attn_func(q, k, v)
+            return x
+
+        x = torch.nn.functional.scaled_dot_product_attention(q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)).transpose(
+            1, 2
+        )
+        return x
+    if split_attn:
+        if attn_mode == "sageattn" or attn_mode is None and sageattn is not None:
+            x = []
+            for i in range(q.size(0)):
+                seq_len_i = seq_len[i]
+                x_i = sageattn(q[i : i + 1, :seq_len_i], k[i : i + 1, :seq_len_i], v[i : i + 1, :seq_len_i], tensor_layout="NHD")
+                if seq_len_i < max_seqlen_q:
+                    x_i = torch.nn.functional.pad(x_i, (0, 0, 0, 0, 0, max_seqlen_q - seq_len_i), mode="constant", value=0.0)
+                x.append(x_i)
+            x = torch.cat(x, dim=0)
+            return x
+
+        if attn_mode == "flash" or attn_mode is None and flash_attn_func is not None:
+            x = []
+            for i in range(q.size(0)):
+                seq_len_i = seq_len[i]
+                x_i = flash_attn_func(q[i : i + 1, :seq_len_i], k[i : i + 1, :seq_len_i], v[i : i + 1, :seq_len_i])
+                if seq_len_i < max_seqlen_q:
+                    x_i = torch.nn.functional.pad(x_i, (0, 0, 0, 0, 0, max_seqlen_q - seq_len_i), mode="constant", value=0.0)
+                x.append(x_i)
+            x = torch.cat(x, dim=0)
+            return x
+
+        if attn_mode == "xformers" or attn_mode is None and xformers_attn_func is not None:
+            x = []
+            for i in range(q.size(0)):
+                seq_len_i = seq_len[i]
+                x_i = xformers_attn_func(q[i : i + 1, :seq_len_i], k[i : i + 1, :seq_len_i], v[i : i + 1, :seq_len_i])
+                if seq_len_i < max_seqlen_q:
+                    x_i = torch.nn.functional.pad(x_i, (0, 0, 0, 0, 0, max_seqlen_q - seq_len_i), mode="constant", value=0.0)
+                x.append(x_i)
+            x = torch.cat(x, dim=0)
+            return x
+
+        assert (
+            attn_mode is None or attn_mode == "torch"
+        ), f"Unsupported attention mode: {attn_mode}. Supported modes: 'sageattn', 'flash', 'xformers', 'torch'."
+        q = q.transpose(1, 2)
+        k = k.transpose(1, 2)
+        v = v.transpose(1, 2)
+        x = []
+        for i in range(q.size(0)):
+            seq_len_i = seq_len[i]
+            x_i = torch.nn.functional.scaled_dot_product_attention(
+                q[i : i + 1, :, :seq_len_i], k[i : i + 1, :, :seq_len_i], v[i : i + 1, :, :seq_len_i]
+            )
+            if seq_len_i < max_seqlen_q:
+                x_i = torch.nn.functional.pad(x_i, (0, 0, 0, max_seqlen_q - seq_len_i, 0, 0), mode="constant", value=0.0)
+            x.append(x_i)
+        x = torch.cat(x, dim=0)
+        x = x.transpose(1, 2)
+        return x
+
+    batch_size = q.shape[0]
+    q = q.view(q.shape[0] * q.shape[1], *q.shape[2:])
+    k = k.view(k.shape[0] * k.shape[1], *k.shape[2:])
+    v = v.view(v.shape[0] * v.shape[1], *v.shape[2:])
+    if attn_mode == "sageattn" or attn_mode is None and sageattn_varlen is not None:
+        x = sageattn_varlen(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+        del q, k, v  # free memory
+    elif attn_mode == "flash" or attn_mode is None and flash_attn_varlen_func is not None:
+        x = flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+        del q, k, v  # free memory
+    else:
+        raise NotImplementedError("No Attn Installed or batch_size > 1 is not supported in this configuration. Try `--split_attn`.")
+    x = x.view(batch_size, max_seqlen_q, *x.shape[1:])
+    return x
+
+
+class HunyuanAttnProcessorFlashAttnDouble:
+    def __call__(
+        self,
+        attn: Attention,
+        hidden_states,
+        encoder_hidden_states,
+        attention_mask,
+        image_rotary_emb,
+        attn_mode: Optional[str] = None,
+        split_attn: Optional[bool] = False,
+    ):
+        cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len = attention_mask
+
+        # Project image latents
+        query = attn.to_q(hidden_states)
+        key = attn.to_k(hidden_states)
+        value = attn.to_v(hidden_states)
+        del hidden_states  # free memory
+
+        query = query.unflatten(2, (attn.heads, -1))
+        key = key.unflatten(2, (attn.heads, -1))
+        value = value.unflatten(2, (attn.heads, -1))
+
+        query = attn.norm_q(query)
+        key = attn.norm_k(key)
+
+        query = apply_rotary_emb_transposed(query, image_rotary_emb)
+        key = apply_rotary_emb_transposed(key, image_rotary_emb)
+        del image_rotary_emb  # free memory
+
+        # Project context (text/encoder) embeddings
+        encoder_query = attn.add_q_proj(encoder_hidden_states)
+        encoder_key = attn.add_k_proj(encoder_hidden_states)
+        encoder_value = attn.add_v_proj(encoder_hidden_states)
+        txt_length = encoder_hidden_states.shape[1]  # store length before deleting
+        del encoder_hidden_states  # free memory
+
+        encoder_query = encoder_query.unflatten(2, (attn.heads, -1))
+        encoder_key = encoder_key.unflatten(2, (attn.heads, -1))
+        encoder_value = encoder_value.unflatten(2, (attn.heads, -1))
+
+        encoder_query = attn.norm_added_q(encoder_query)
+        encoder_key = attn.norm_added_k(encoder_key)
+
+        # Concatenate image and context q, k, v
+        query = torch.cat([query, encoder_query], dim=1)
+        key = torch.cat([key, encoder_key], dim=1)
+        value = torch.cat([value, encoder_value], dim=1)
+        del encoder_query, encoder_key, encoder_value  # free memory
+
+        hidden_states_attn = attn_varlen_func(
+            query,
+            key,
+            value,
+            cu_seqlens_q,
+            cu_seqlens_kv,
+            max_seqlen_q,
+            max_seqlen_kv,
+            seq_len,
+            attn_mode=attn_mode,
+            split_attn=split_attn,
+        )
+        del query, key, value  # free memory
+        hidden_states_attn = hidden_states_attn.flatten(-2)
+
+        hidden_states, encoder_hidden_states = hidden_states_attn[:, :-txt_length], hidden_states_attn[:, -txt_length:]
+        del hidden_states_attn  # free memory
+
+        # Apply output projections
+        hidden_states = attn.to_out[0](hidden_states)
+        hidden_states = attn.to_out[1](hidden_states)  # Dropout/Identity
+        encoder_hidden_states = attn.to_add_out(encoder_hidden_states)
+
+        return hidden_states, encoder_hidden_states
+
+
+class HunyuanAttnProcessorFlashAttnSingle:
+    def __call__(
+        self,
+        attn: Attention,
+        hidden_states,
+        encoder_hidden_states,
+        attention_mask,
+        image_rotary_emb,
+        attn_mode: Optional[str] = None,
+        split_attn: Optional[bool] = False,
+    ):
+        cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len = attention_mask
+        txt_length = encoder_hidden_states.shape[1]  # Store text length
+
+        # Concatenate image and context inputs
+        hidden_states_cat = torch.cat([hidden_states, encoder_hidden_states], dim=1)
+        del hidden_states, encoder_hidden_states  # free memory
+
+        # Project concatenated inputs
+        query = attn.to_q(hidden_states_cat)
+        key = attn.to_k(hidden_states_cat)
+        value = attn.to_v(hidden_states_cat)
+        del hidden_states_cat  # free memory
+
+        query = query.unflatten(2, (attn.heads, -1))
+        key = key.unflatten(2, (attn.heads, -1))
+        value = value.unflatten(2, (attn.heads, -1))
+
+        query = attn.norm_q(query)
+        key = attn.norm_k(key)
+
+        query = torch.cat([apply_rotary_emb_transposed(query[:, :-txt_length], image_rotary_emb), query[:, -txt_length:]], dim=1)
+        key = torch.cat([apply_rotary_emb_transposed(key[:, :-txt_length], image_rotary_emb), key[:, -txt_length:]], dim=1)
+        del image_rotary_emb  # free memory
+
+        hidden_states = attn_varlen_func(
+            query,
+            key,
+            value,
+            cu_seqlens_q,
+            cu_seqlens_kv,
+            max_seqlen_q,
+            max_seqlen_kv,
+            seq_len,
+            attn_mode=attn_mode,
+            split_attn=split_attn,
+        )
+        del query, key, value  # free memory
+        hidden_states = hidden_states.flatten(-2)
+
+        hidden_states, encoder_hidden_states = hidden_states[:, :-txt_length], hidden_states[:, -txt_length:]
+
+        return hidden_states, encoder_hidden_states
+
+
+class CombinedTimestepGuidanceTextProjEmbeddings(nn.Module):
+    def __init__(self, embedding_dim, pooled_projection_dim):
+        super().__init__()
+
+        self.time_proj = Timesteps(num_channels=256, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.timestep_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim)
+        self.guidance_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim)
+        self.text_embedder = PixArtAlphaTextProjection(pooled_projection_dim, embedding_dim, act_fn="silu")
+
+    def forward(self, timestep, guidance, pooled_projection):
+        timesteps_proj = self.time_proj(timestep)
+        timesteps_emb = self.timestep_embedder(timesteps_proj.to(dtype=pooled_projection.dtype))
+
+        guidance_proj = self.time_proj(guidance)
+        guidance_emb = self.guidance_embedder(guidance_proj.to(dtype=pooled_projection.dtype))
+
+        time_guidance_emb = timesteps_emb + guidance_emb
+
+        pooled_projections = self.text_embedder(pooled_projection)
+        conditioning = time_guidance_emb + pooled_projections
+
+        return conditioning
+
+
+class CombinedTimestepTextProjEmbeddings(nn.Module):
+    def __init__(self, embedding_dim, pooled_projection_dim):
+        super().__init__()
+
+        self.time_proj = Timesteps(num_channels=256, flip_sin_to_cos=True, downscale_freq_shift=0)
+        self.timestep_embedder = TimestepEmbedding(in_channels=256, time_embed_dim=embedding_dim)
+        self.text_embedder = PixArtAlphaTextProjection(pooled_projection_dim, embedding_dim, act_fn="silu")
+
+    def forward(self, timestep, pooled_projection):
+        timesteps_proj = self.time_proj(timestep)
+        timesteps_emb = self.timestep_embedder(timesteps_proj.to(dtype=pooled_projection.dtype))
+
+        pooled_projections = self.text_embedder(pooled_projection)
+
+        conditioning = timesteps_emb + pooled_projections
+
+        return conditioning
+
+
+class HunyuanVideoAdaNorm(nn.Module):
+    def __init__(self, in_features: int, out_features: Optional[int] = None) -> None:
+        super().__init__()
+
+        out_features = out_features or 2 * in_features
+        self.linear = nn.Linear(in_features, out_features)
+        self.nonlinearity = nn.SiLU()
+
+    def forward(self, temb: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        temb = self.linear(self.nonlinearity(temb))
+        gate_msa, gate_mlp = temb.chunk(2, dim=-1)
+        gate_msa, gate_mlp = gate_msa.unsqueeze(1), gate_mlp.unsqueeze(1)
+        return gate_msa, gate_mlp
+
+
+class HunyuanVideoIndividualTokenRefinerBlock(nn.Module):
+    def __init__(
+        self,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        mlp_width_ratio: float = 4.0,
+        mlp_drop_rate: float = 0.0,
+        attention_bias: bool = True,
+    ) -> None:
+        super().__init__()
+
+        hidden_size = num_attention_heads * attention_head_dim
+
+        self.norm1 = LayerNormFramePack(hidden_size, elementwise_affine=True, eps=1e-6)
+        self.attn = Attention(
+            query_dim=hidden_size,
+            cross_attention_dim=None,
+            heads=num_attention_heads,
+            dim_head=attention_head_dim,
+            bias=attention_bias,
+        )
+
+        self.norm2 = LayerNormFramePack(hidden_size, elementwise_affine=True, eps=1e-6)
+        self.ff = FeedForward(hidden_size, mult=mlp_width_ratio, activation_fn="linear-silu", dropout=mlp_drop_rate)
+
+        self.norm_out = HunyuanVideoAdaNorm(hidden_size, 2 * hidden_size)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        norm_hidden_states = self.norm1(hidden_states)
+
+        # Self-attention
+        attn_output = self.attn(
+            hidden_states=norm_hidden_states,
+            encoder_hidden_states=None,
+            attention_mask=attention_mask,
+        )
+        del norm_hidden_states  # free memory
+
+        gate_msa, gate_mlp = self.norm_out(temb)
+        hidden_states = torch.addcmul(hidden_states, attn_output, gate_msa)
+        del attn_output, gate_msa  # free memory
+
+        ff_output = self.ff(self.norm2(hidden_states))
+        hidden_states = torch.addcmul(hidden_states, ff_output, gate_mlp)
+        del ff_output, gate_mlp  # free memory
+
+        return hidden_states
+
+
+class HunyuanVideoIndividualTokenRefiner(nn.Module):
+    def __init__(
+        self,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        num_layers: int,
+        mlp_width_ratio: float = 4.0,
+        mlp_drop_rate: float = 0.0,
+        attention_bias: bool = True,
+    ) -> None:
+        super().__init__()
+
+        self.refiner_blocks = nn.ModuleList(
+            [
+                HunyuanVideoIndividualTokenRefinerBlock(
+                    num_attention_heads=num_attention_heads,
+                    attention_head_dim=attention_head_dim,
+                    mlp_width_ratio=mlp_width_ratio,
+                    mlp_drop_rate=mlp_drop_rate,
+                    attention_bias=attention_bias,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+    ) -> torch.Tensor:
+        self_attn_mask = None
+        if attention_mask is not None:
+            batch_size = attention_mask.shape[0]
+            seq_len = attention_mask.shape[1]
+            attention_mask = attention_mask.to(hidden_states.device).bool()
+            self_attn_mask_1 = attention_mask.view(batch_size, 1, 1, seq_len).repeat(1, 1, seq_len, 1)
+            self_attn_mask_2 = self_attn_mask_1.transpose(2, 3)
+            self_attn_mask = (self_attn_mask_1 & self_attn_mask_2).bool()
+            self_attn_mask[:, :, :, 0] = True
+
+        for block in self.refiner_blocks:
+            hidden_states = block(hidden_states, temb, self_attn_mask)
+
+        return hidden_states
+
+
+class HunyuanVideoTokenRefiner(nn.Module):
+    def __init__(
+        self,
+        in_channels: int,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        num_layers: int,
+        mlp_ratio: float = 4.0,
+        mlp_drop_rate: float = 0.0,
+        attention_bias: bool = True,
+    ) -> None:
+        super().__init__()
+
+        hidden_size = num_attention_heads * attention_head_dim
+
+        self.time_text_embed = CombinedTimestepTextProjEmbeddings(embedding_dim=hidden_size, pooled_projection_dim=in_channels)
+        self.proj_in = nn.Linear(in_channels, hidden_size, bias=True)
+        self.token_refiner = HunyuanVideoIndividualTokenRefiner(
+            num_attention_heads=num_attention_heads,
+            attention_head_dim=attention_head_dim,
+            num_layers=num_layers,
+            mlp_width_ratio=mlp_ratio,
+            mlp_drop_rate=mlp_drop_rate,
+            attention_bias=attention_bias,
+        )
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        timestep: torch.LongTensor,
+        attention_mask: Optional[torch.LongTensor] = None,
+    ) -> torch.Tensor:
+        if attention_mask is None:
+            pooled_projections = hidden_states.mean(dim=1)
+        else:
+            original_dtype = hidden_states.dtype
+            mask_float = attention_mask.float().unsqueeze(-1)
+            pooled_projections = (hidden_states * mask_float).sum(dim=1) / mask_float.sum(dim=1)
+            pooled_projections = pooled_projections.to(original_dtype)
+
+        temb = self.time_text_embed(timestep, pooled_projections)
+        del pooled_projections  # free memory
+
+        hidden_states = self.proj_in(hidden_states)
+        hidden_states = self.token_refiner(hidden_states, temb, attention_mask)
+        del temb, attention_mask  # free memory
+
+        return hidden_states
+
+
+class HunyuanVideoRotaryPosEmbed(nn.Module):
+    def __init__(self, rope_dim, theta):
+        super().__init__()
+        self.DT, self.DY, self.DX = rope_dim
+        self.theta = theta
+        self.h_w_scaling_factor = 1.0
+
+    @torch.no_grad()
+    def get_frequency(self, dim, pos):
+        T, H, W = pos.shape
+        freqs = 1.0 / (self.theta ** (torch.arange(0, dim, 2, dtype=torch.float32, device=pos.device)[: (dim // 2)] / dim))
+        freqs = torch.outer(freqs, pos.reshape(-1)).unflatten(-1, (T, H, W)).repeat_interleave(2, dim=0)
+        return freqs.cos(), freqs.sin()
+
+    @torch.no_grad()
+    def forward_inner(self, frame_indices, height, width, device):
+        GT, GY, GX = torch.meshgrid(
+            frame_indices.to(device=device, dtype=torch.float32),
+            torch.arange(0, height, device=device, dtype=torch.float32) * self.h_w_scaling_factor,
+            torch.arange(0, width, device=device, dtype=torch.float32) * self.h_w_scaling_factor,
+            indexing="ij",
+        )
+
+        FCT, FST = self.get_frequency(self.DT, GT)
+        del GT  # free memory
+        FCY, FSY = self.get_frequency(self.DY, GY)
+        del GY  # free memory
+        FCX, FSX = self.get_frequency(self.DX, GX)
+        del GX  # free memory
+
+        result = torch.cat([FCT, FCY, FCX, FST, FSY, FSX], dim=0)
+        del FCT, FCY, FCX, FST, FSY, FSX  # free memory
+
+        # Return result already on the correct device
+        return result  # Shape (2 * total_dim / 2, T, H, W) -> (total_dim, T, H, W)
+
+    @torch.no_grad()
+    def forward(self, frame_indices, height, width, device):
+        frame_indices = frame_indices.unbind(0)
+        results = [self.forward_inner(f, height, width, device) for f in frame_indices]
+        results = torch.stack(results, dim=0)
+        return results
+
+
+class AdaLayerNormZero(nn.Module):
+    def __init__(self, embedding_dim: int, norm_type="layer_norm", bias=True):
+        super().__init__()
+        self.silu = nn.SiLU()
+        self.linear = nn.Linear(embedding_dim, 6 * embedding_dim, bias=bias)
+        if norm_type == "layer_norm":
+            self.norm = LayerNormFramePack(embedding_dim, elementwise_affine=False, eps=1e-6)
+        else:
+            raise ValueError(f"unknown norm_type {norm_type}")
+
+    def forward(
+        self, x: torch.Tensor, emb: Optional[torch.Tensor] = None
+    ) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        emb = emb.unsqueeze(-2)
+        emb = self.linear(self.silu(emb))
+        shift_msa, scale_msa, gate_msa, shift_mlp, scale_mlp, gate_mlp = emb.chunk(6, dim=-1)
+        x = self.norm(x) * (1 + scale_msa) + shift_msa
+        return x, gate_msa, shift_mlp, scale_mlp, gate_mlp
+
+
+class AdaLayerNormZeroSingle(nn.Module):
+    def __init__(self, embedding_dim: int, norm_type="layer_norm", bias=True):
+        super().__init__()
+
+        self.silu = nn.SiLU()
+        self.linear = nn.Linear(embedding_dim, 3 * embedding_dim, bias=bias)
+        if norm_type == "layer_norm":
+            self.norm = LayerNormFramePack(embedding_dim, elementwise_affine=False, eps=1e-6)
+        else:
+            raise ValueError(f"unknown norm_type {norm_type}")
+
+    def forward(
+        self,
+        x: torch.Tensor,
+        emb: Optional[torch.Tensor] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        emb = emb.unsqueeze(-2)
+        emb = self.linear(self.silu(emb))
+        shift_msa, scale_msa, gate_msa = emb.chunk(3, dim=-1)
+        x = self.norm(x) * (1 + scale_msa) + shift_msa
+        return x, gate_msa
+
+
+class AdaLayerNormContinuous(nn.Module):
+    def __init__(
+        self,
+        embedding_dim: int,
+        conditioning_embedding_dim: int,
+        elementwise_affine=True,
+        eps=1e-5,
+        bias=True,
+        norm_type="layer_norm",
+    ):
+        super().__init__()
+        self.silu = nn.SiLU()
+        self.linear = nn.Linear(conditioning_embedding_dim, embedding_dim * 2, bias=bias)
+        if norm_type == "layer_norm":
+            self.norm = LayerNormFramePack(embedding_dim, eps, elementwise_affine, bias)
+        else:
+            raise ValueError(f"unknown norm_type {norm_type}")
+
+    def forward(self, x: torch.Tensor, emb: torch.Tensor) -> torch.Tensor:
+        emb = emb.unsqueeze(-2)
+        emb = self.linear(self.silu(emb))
+        scale, shift = emb.chunk(2, dim=-1)
+        del emb  # free memory
+        x = self.norm(x) * (1 + scale) + shift
+        return x
+
+
+class HunyuanVideoSingleTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        mlp_ratio: float = 4.0,
+        qk_norm: str = "rms_norm",
+        attn_mode: Optional[str] = None,
+        split_attn: Optional[bool] = False,
+    ) -> None:
+        super().__init__()
+
+        hidden_size = num_attention_heads * attention_head_dim
+        mlp_dim = int(hidden_size * mlp_ratio)
+        self.attn_mode = attn_mode
+        self.split_attn = split_attn
+
+        # Attention layer (pre_only=True means no output projection in Attention module itself)
+        self.attn = Attention(
+            query_dim=hidden_size,
+            cross_attention_dim=None,
+            dim_head=attention_head_dim,
+            heads=num_attention_heads,
+            out_dim=hidden_size,
+            bias=True,
+            processor=HunyuanAttnProcessorFlashAttnSingle(),
+            qk_norm=qk_norm,
+            eps=1e-6,
+            pre_only=True,  # Crucial: Attn processor will return raw attention output
+        )
+
+        self.norm = AdaLayerNormZeroSingle(hidden_size, norm_type="layer_norm")
+        self.proj_mlp = nn.Linear(hidden_size, mlp_dim)
+        self.act_mlp = nn.GELU(approximate="tanh")
+        self.proj_out = nn.Linear(hidden_size + mlp_dim, hidden_size)
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        image_rotary_emb: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+    ) -> torch.Tensor:
+        text_seq_length = encoder_hidden_states.shape[1]
+        hidden_states = torch.cat([hidden_states, encoder_hidden_states], dim=1)
+        del encoder_hidden_states  # free memory
+
+        residual = hidden_states
+
+        # 1. Input normalization
+        norm_hidden_states, gate = self.norm(hidden_states, emb=temb)
+        mlp_hidden_states = self.act_mlp(self.proj_mlp(norm_hidden_states))
+
+        norm_hidden_states, norm_encoder_hidden_states = (
+            norm_hidden_states[:, :-text_seq_length, :],
+            norm_hidden_states[:, -text_seq_length:, :],
+        )
+
+        # 2. Attention
+        attn_output, context_attn_output = self.attn(
+            hidden_states=norm_hidden_states,
+            encoder_hidden_states=norm_encoder_hidden_states,
+            attention_mask=attention_mask,
+            image_rotary_emb=image_rotary_emb,
+            attn_mode=self.attn_mode,
+            split_attn=self.split_attn,
+        )
+        attn_output = torch.cat([attn_output, context_attn_output], dim=1)
+        del norm_hidden_states, norm_encoder_hidden_states, context_attn_output  # free memory
+        del image_rotary_emb
+
+        # 3. Modulation and residual connection
+        hidden_states = torch.cat([attn_output, mlp_hidden_states], dim=2)
+        del attn_output, mlp_hidden_states  # free memory
+        hidden_states = gate * self.proj_out(hidden_states)
+        hidden_states = hidden_states + residual
+
+        hidden_states, encoder_hidden_states = (
+            hidden_states[:, :-text_seq_length, :],
+            hidden_states[:, -text_seq_length:, :],
+        )
+        return hidden_states, encoder_hidden_states
+
+
+class HunyuanVideoTransformerBlock(nn.Module):
+    def __init__(
+        self,
+        num_attention_heads: int,
+        attention_head_dim: int,
+        mlp_ratio: float,
+        qk_norm: str = "rms_norm",
+        attn_mode: Optional[str] = None,
+        split_attn: Optional[bool] = False,
+    ) -> None:
+        super().__init__()
+
+        hidden_size = num_attention_heads * attention_head_dim
+        self.attn_mode = attn_mode
+        self.split_attn = split_attn
+
+        self.norm1 = AdaLayerNormZero(hidden_size, norm_type="layer_norm")
+        self.norm1_context = AdaLayerNormZero(hidden_size, norm_type="layer_norm")
+
+        self.attn = Attention(
+            query_dim=hidden_size,
+            cross_attention_dim=None,
+            added_kv_proj_dim=hidden_size,
+            dim_head=attention_head_dim,
+            heads=num_attention_heads,
+            out_dim=hidden_size,
+            context_pre_only=False,
+            bias=True,
+            processor=HunyuanAttnProcessorFlashAttnDouble(),
+            qk_norm=qk_norm,
+            eps=1e-6,
+        )
+
+        self.norm2 = LayerNormFramePack(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.ff = FeedForward(hidden_size, mult=mlp_ratio, activation_fn="gelu-approximate")
+
+        self.norm2_context = LayerNormFramePack(hidden_size, elementwise_affine=False, eps=1e-6)
+        self.ff_context = FeedForward(hidden_size, mult=mlp_ratio, activation_fn="gelu-approximate")
+
+    def forward(
+        self,
+        hidden_states: torch.Tensor,
+        encoder_hidden_states: torch.Tensor,
+        temb: torch.Tensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        freqs_cis: Optional[Tuple[torch.Tensor, torch.Tensor]] = None,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        # 1. Input normalization
+        norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1(hidden_states, emb=temb)
+        norm_encoder_hidden_states, c_gate_msa, c_shift_mlp, c_scale_mlp, c_gate_mlp = self.norm1_context(
+            encoder_hidden_states, emb=temb
+        )
+
+        # 2. Joint attention
+        attn_output, context_attn_output = self.attn(
+            hidden_states=norm_hidden_states,
+            encoder_hidden_states=norm_encoder_hidden_states,
+            attention_mask=attention_mask,
+            image_rotary_emb=freqs_cis,
+            attn_mode=self.attn_mode,
+            split_attn=self.split_attn,
+        )
+        del norm_hidden_states, norm_encoder_hidden_states, freqs_cis  # free memory
+
+        # 3. Modulation and residual connection
+        hidden_states = torch.addcmul(hidden_states, attn_output, gate_msa)
+        del attn_output, gate_msa  # free memory
+        encoder_hidden_states = torch.addcmul(encoder_hidden_states, context_attn_output, c_gate_msa)
+        del context_attn_output, c_gate_msa  # free memory
+
+        norm_hidden_states = self.norm2(hidden_states)
+        norm_encoder_hidden_states = self.norm2_context(encoder_hidden_states)
+
+        norm_hidden_states = norm_hidden_states * (1 + scale_mlp) + shift_mlp
+        del shift_mlp, scale_mlp  # free memory
+        norm_encoder_hidden_states = torch.addcmul(c_shift_mlp, norm_encoder_hidden_states, (1 + c_scale_mlp))
+        del c_shift_mlp, c_scale_mlp  # free memory
+
+        # 4. Feed-forward
+        ff_output = self.ff(norm_hidden_states)
+        del norm_hidden_states  # free memory
+        context_ff_output = self.ff_context(norm_encoder_hidden_states)
+        del norm_encoder_hidden_states  # free memory
+
+        hidden_states = torch.addcmul(hidden_states, gate_mlp, ff_output)
+        del ff_output, gate_mlp  # free memory
+        encoder_hidden_states = torch.addcmul(encoder_hidden_states, c_gate_mlp, context_ff_output)
+        del context_ff_output, c_gate_mlp  # free memory
+
+        return hidden_states, encoder_hidden_states
+
+
+class ClipVisionProjection(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super().__init__()
+        self.up = nn.Linear(in_channels, out_channels * 3)
+        self.down = nn.Linear(out_channels * 3, out_channels)
+
+    def forward(self, x):
+        projected_x = self.down(nn.functional.silu(self.up(x)))
+        return projected_x
+
+
+class HunyuanVideoPatchEmbed(nn.Module):
+    def __init__(self, patch_size, in_chans, embed_dim):
+        super().__init__()
+        self.proj = nn.Conv3d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
+
+
+class HunyuanVideoPatchEmbedForCleanLatents(nn.Module):
+    def __init__(self, inner_dim):
+        super().__init__()
+        self.proj = nn.Conv3d(16, inner_dim, kernel_size=(1, 2, 2), stride=(1, 2, 2))
+        self.proj_2x = nn.Conv3d(16, inner_dim, kernel_size=(2, 4, 4), stride=(2, 4, 4))
+        self.proj_4x = nn.Conv3d(16, inner_dim, kernel_size=(4, 8, 8), stride=(4, 8, 8))
+
+    @torch.no_grad()
+    def initialize_weight_from_another_conv3d(self, another_layer):
+        weight = another_layer.weight.detach().clone()
+        bias = another_layer.bias.detach().clone()
+
+        sd = {
+            "proj.weight": weight.clone(),
+            "proj.bias": bias.clone(),
+            "proj_2x.weight": einops.repeat(weight, "b c t h w -> b c (t tk) (h hk) (w wk)", tk=2, hk=2, wk=2) / 8.0,
+            "proj_2x.bias": bias.clone(),
+            "proj_4x.weight": einops.repeat(weight, "b c t h w -> b c (t tk) (h hk) (w wk)", tk=4, hk=4, wk=4) / 64.0,
+            "proj_4x.bias": bias.clone(),
+        }
+
+        sd = {k: v.clone() for k, v in sd.items()}
+
+        self.load_state_dict(sd)
+        return
+
+
+FP8_OPTIMIZATION_TARGET_KEYS = ["transformer_blocks", "single_transformer_blocks"]
+FP8_OPTIMIZATION_EXCLUDE_KEYS = ["norm"]  # Exclude norm layers (e.g., LayerNorm, RMSNorm) from FP8
+
+
+class HunyuanVideoTransformer3DModelPacked(nn.Module):  # (PreTrainedModelMixin, GenerationMixin,
+    # ModelMixin, ConfigMixin, PeftAdapterMixin, FromOriginalModelMixin):
+    # @register_to_config
+    def __init__(
+        self,
+        in_channels: int = 16,
+        out_channels: int = 16,
+        num_attention_heads: int = 24,
+        attention_head_dim: int = 128,
+        num_layers: int = 20,
+        num_single_layers: int = 40,
+        num_refiner_layers: int = 2,
+        mlp_ratio: float = 4.0,
+        patch_size: int = 2,
+        patch_size_t: int = 1,
+        qk_norm: str = "rms_norm",
+        guidance_embeds: bool = True,
+        text_embed_dim: int = 4096,
+        pooled_projection_dim: int = 768,
+        rope_theta: float = 256.0,
+        rope_axes_dim: Tuple[int] = (16, 56, 56),
+        has_image_proj=False,
+        image_proj_dim=1152,
+        has_clean_x_embedder=False,
+        attn_mode: Optional[str] = None,
+        split_attn: Optional[bool] = False,
+    ) -> None:
+        super().__init__()
+
+        inner_dim = num_attention_heads * attention_head_dim
+        out_channels = out_channels or in_channels
+        self.config_patch_size = patch_size
+        self.config_patch_size_t = patch_size_t
+
+        # 1. Latent and condition embedders
+        self.x_embedder = HunyuanVideoPatchEmbed((patch_size_t, patch_size, patch_size), in_channels, inner_dim)
+        self.context_embedder = HunyuanVideoTokenRefiner(
+            text_embed_dim, num_attention_heads, attention_head_dim, num_layers=num_refiner_layers
+        )
+        self.time_text_embed = CombinedTimestepGuidanceTextProjEmbeddings(inner_dim, pooled_projection_dim)
+
+        self.clean_x_embedder = None
+        self.image_projection = None
+
+        # 2. RoPE
+        self.rope = HunyuanVideoRotaryPosEmbed(rope_axes_dim, rope_theta)
+
+        # 3. Dual stream transformer blocks
+        self.attn_mode = attn_mode
+        self.split_attn = split_attn
+        self.transformer_blocks = nn.ModuleList(
+            [
+                HunyuanVideoTransformerBlock(
+                    num_attention_heads,
+                    attention_head_dim,
+                    mlp_ratio=mlp_ratio,
+                    qk_norm=qk_norm,
+                    attn_mode=attn_mode,
+                    split_attn=split_attn,
+                )
+                for _ in range(num_layers)
+            ]
+        )
+
+        # 4. Single stream transformer blocks
+        self.single_transformer_blocks = nn.ModuleList(
+            [
+                HunyuanVideoSingleTransformerBlock(
+                    num_attention_heads,
+                    attention_head_dim,
+                    mlp_ratio=mlp_ratio,
+                    qk_norm=qk_norm,
+                    attn_mode=attn_mode,
+                    split_attn=split_attn,
+                )
+                for _ in range(num_single_layers)
+            ]
+        )
+
+        # 5. Output projection
+        self.norm_out = AdaLayerNormContinuous(inner_dim, inner_dim, elementwise_affine=False, eps=1e-6)
+        self.proj_out = nn.Linear(inner_dim, patch_size_t * patch_size * patch_size * out_channels)
+
+        self.inner_dim = inner_dim
+        self.use_gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+        self.enable_teacache = False
+
+        # if has_image_proj:
+        #     self.install_image_projection(image_proj_dim)
+        self.image_projection = ClipVisionProjection(in_channels=image_proj_dim, out_channels=self.inner_dim)
+        # self.config["has_image_proj"] = True
+        # self.config["image_proj_dim"] = in_channels
+
+        # if has_clean_x_embedder:
+        #     self.install_clean_x_embedder()
+        self.clean_x_embedder = HunyuanVideoPatchEmbedForCleanLatents(self.inner_dim)
+        # self.config["has_clean_x_embedder"] = True
+
+        self.high_quality_fp32_output_for_inference = True  # False # change default to True
+
+        # Block swapping attributes (initialized to None)
+        self.blocks_to_swap = None
+        self.offloader_double = None
+        self.offloader_single = None
+
+        # RoPE scaling
+        self.rope_scaling_timestep_threshold: Optional[int] = None  # scale RoPE above this timestep
+        self.rope_scaling_factor: float = 1.0  # RoPE scaling factor
+
+    @property
+    def device(self):
+        return next(self.parameters()).device
+
+    @property
+    def dtype(self):
+        return next(self.parameters()).dtype
+
+    def enable_gradient_checkpointing(self, activation_cpu_offloading=False):
+        self.use_gradient_checkpointing = True
+        self.activation_cpu_offloading = activation_cpu_offloading
+        print(
+            f"Gradient checkpointing enabled for HunyuanVideoTransformer3DModelPacked. Activation CPU offloading: {activation_cpu_offloading}"
+        )  # Logging
+
+    def disable_gradient_checkpointing(self):
+        self.use_gradient_checkpointing = False
+        self.activation_cpu_offloading = False
+        print("Gradient checkpointing disabled for HunyuanVideoTransformer3DModelPacked.")  # Logging
+
+    def initialize_teacache(self, enable_teacache=True, num_steps=25, rel_l1_thresh=0.15):
+        self.enable_teacache = enable_teacache
+        self.cnt = 0
+        self.num_steps = num_steps
+        self.rel_l1_thresh = rel_l1_thresh  # 0.1 for 1.6x speedup, 0.15 for 2.1x speedup
+        self.accumulated_rel_l1_distance = 0
+        self.previous_modulated_input = None
+        self.previous_residual = None
+        self.teacache_rescale_func = np.poly1d([7.33226126e02, -4.01131952e02, 6.75869174e01, -3.14987800e00, 9.61237896e-02])
+        if enable_teacache:
+            print(f"TeaCache enabled: num_steps={num_steps}, rel_l1_thresh={rel_l1_thresh}")
+        else:
+            print("TeaCache disabled.")
+
+    def gradient_checkpointing_method(self, block, *args):
+        if self.use_gradient_checkpointing:
+            if self.activation_cpu_offloading:
+                block = create_cpu_offloading_wrapper(block, self.proj_out.weight.device)
+            result = torch.utils.checkpoint.checkpoint(block, *args, use_reentrant=False)
+        else:
+            result = block(*args)
+        return result
+
+    def enable_block_swap(self, num_blocks: int, device: torch.device, supports_backward: bool, use_pinned_memory: bool = False):
+        self.blocks_to_swap = num_blocks
+        self.num_double_blocks = len(self.transformer_blocks)
+        self.num_single_blocks = len(self.single_transformer_blocks)
+        double_blocks_to_swap = num_blocks // 2
+        single_blocks_to_swap = (num_blocks - double_blocks_to_swap) * 2 + 1
+
+        assert double_blocks_to_swap <= self.num_double_blocks - 1 and single_blocks_to_swap <= self.num_single_blocks - 1, (
+            f"Cannot swap more than {self.num_double_blocks - 1} double blocks and {self.num_single_blocks - 1} single blocks. "
+            f"Requested {double_blocks_to_swap} double blocks and {single_blocks_to_swap} single blocks."
+        )
+
+        self.offloader_double = ModelOffloader(
+            "double",
+            self.transformer_blocks,
+            self.num_double_blocks,
+            double_blocks_to_swap,
+            supports_backward,
+            device,
+            use_pinned_memory,
+            # debug=True # Optional debugging
+        )
+        self.offloader_single = ModelOffloader(
+            "single",
+            self.single_transformer_blocks,
+            self.num_single_blocks,
+            single_blocks_to_swap,
+            supports_backward,
+            device,  # , debug=True
+            use_pinned_memory,
+        )
+        print(
+            f"HunyuanVideoTransformer3DModelPacked: Block swap enabled. Swapping {num_blocks} blocks, "
+            + f"double blocks: {double_blocks_to_swap}, single blocks: {single_blocks_to_swap}, supports_backward: {supports_backward}."
+        )
+
+    def switch_block_swap_for_inference(self):
+        if self.blocks_to_swap and self.blocks_to_swap > 0:
+            self.offloader_double.set_forward_only(True)
+            self.offloader_single.set_forward_only(True)
+            self.prepare_block_swap_before_forward()
+            print(f"HunyuanVideoTransformer3DModelPacked: Block swap set to forward only.")
+
+    def switch_block_swap_for_training(self):
+        if self.blocks_to_swap and self.blocks_to_swap > 0:
+            self.offloader_double.set_forward_only(False)
+            self.offloader_single.set_forward_only(False)
+            self.prepare_block_swap_before_forward()
+            print(f"HunyuanVideoTransformer3DModelPacked: Block swap set to forward and backward.")
+
+    def move_to_device_except_swap_blocks(self, device: torch.device):
+        # assume model is on cpu. do not move blocks to device to reduce temporary memory usage
+        if self.blocks_to_swap:
+            saved_double_blocks = self.transformer_blocks
+            saved_single_blocks = self.single_transformer_blocks
+            self.transformer_blocks = None
+            self.single_transformer_blocks = None
+
+        self.to(device)
+
+        if self.blocks_to_swap:
+            self.transformer_blocks = saved_double_blocks
+            self.single_transformer_blocks = saved_single_blocks
+
+    def prepare_block_swap_before_forward(self):
+        if self.blocks_to_swap is None or self.blocks_to_swap == 0:
+            return
+        self.offloader_double.prepare_block_devices_before_forward(self.transformer_blocks)
+        self.offloader_single.prepare_block_devices_before_forward(self.single_transformer_blocks)
+
+    def enable_rope_scaling(self, timestep_threshold: Optional[int], rope_scaling_factor: float = 1.0):
+        if timestep_threshold is not None and rope_scaling_factor > 0:
+            self.rope_scaling_timestep_threshold = timestep_threshold
+            self.rope_scaling_factor = rope_scaling_factor
+            logger.info(f"RoPE scaling enabled: threshold={timestep_threshold}, scaling_factor={rope_scaling_factor}.")
+        else:
+            self.rope_scaling_timestep_threshold = None
+            self.rope_scaling_factor = 1.0
+            self.rope.h_w_scaling_factor = 1.0  # reset to default
+            logger.info("RoPE scaling disabled.")
+
+    def process_input_hidden_states(
+        self,
+        latents,
+        latent_indices=None,
+        clean_latents=None,
+        clean_latent_indices=None,
+        clean_latents_2x=None,
+        clean_latent_2x_indices=None,
+        clean_latents_4x=None,
+        clean_latent_4x_indices=None,
+    ):
+        hidden_states = self.gradient_checkpointing_method(self.x_embedder.proj, latents)
+        B, C, T, H, W = hidden_states.shape
+
+        if latent_indices is None:
+            latent_indices = torch.arange(0, T).unsqueeze(0).expand(B, -1)
+
+        hidden_states = hidden_states.flatten(2).transpose(1, 2)
+
+        rope_freqs = self.rope(frame_indices=latent_indices, height=H, width=W, device=hidden_states.device)
+        rope_freqs = rope_freqs.flatten(2).transpose(1, 2)
+
+        if clean_latents is not None and clean_latent_indices is not None:
+            clean_latents = clean_latents.to(hidden_states)
+            clean_latents = self.gradient_checkpointing_method(self.clean_x_embedder.proj, clean_latents)
+            clean_latents = clean_latents.flatten(2).transpose(1, 2)
+
+            clean_latent_rope_freqs = self.rope(frame_indices=clean_latent_indices, height=H, width=W, device=clean_latents.device)
+            clean_latent_rope_freqs = clean_latent_rope_freqs.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([clean_latents, hidden_states], dim=1)
+            rope_freqs = torch.cat([clean_latent_rope_freqs, rope_freqs], dim=1)
+
+        if clean_latents_2x is not None and clean_latent_2x_indices is not None:
+            clean_latents_2x = clean_latents_2x.to(hidden_states)
+            clean_latents_2x = pad_for_3d_conv(clean_latents_2x, (2, 4, 4))
+            clean_latents_2x = self.gradient_checkpointing_method(self.clean_x_embedder.proj_2x, clean_latents_2x)
+            clean_latents_2x = clean_latents_2x.flatten(2).transpose(1, 2)
+
+            clean_latent_2x_rope_freqs = self.rope(
+                frame_indices=clean_latent_2x_indices, height=H, width=W, device=clean_latents_2x.device
+            )
+            clean_latent_2x_rope_freqs = pad_for_3d_conv(clean_latent_2x_rope_freqs, (2, 2, 2))
+            clean_latent_2x_rope_freqs = center_down_sample_3d(clean_latent_2x_rope_freqs, (2, 2, 2))
+            clean_latent_2x_rope_freqs = clean_latent_2x_rope_freqs.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([clean_latents_2x, hidden_states], dim=1)
+            rope_freqs = torch.cat([clean_latent_2x_rope_freqs, rope_freqs], dim=1)
+
+        if clean_latents_4x is not None and clean_latent_4x_indices is not None:
+            clean_latents_4x = clean_latents_4x.to(hidden_states)
+            clean_latents_4x = pad_for_3d_conv(clean_latents_4x, (4, 8, 8))
+            clean_latents_4x = self.gradient_checkpointing_method(self.clean_x_embedder.proj_4x, clean_latents_4x)
+            clean_latents_4x = clean_latents_4x.flatten(2).transpose(1, 2)
+
+            clean_latent_4x_rope_freqs = self.rope(
+                frame_indices=clean_latent_4x_indices, height=H, width=W, device=clean_latents_4x.device
+            )
+            clean_latent_4x_rope_freqs = pad_for_3d_conv(clean_latent_4x_rope_freqs, (4, 4, 4))
+            clean_latent_4x_rope_freqs = center_down_sample_3d(clean_latent_4x_rope_freqs, (4, 4, 4))
+            clean_latent_4x_rope_freqs = clean_latent_4x_rope_freqs.flatten(2).transpose(1, 2)
+
+            hidden_states = torch.cat([clean_latents_4x, hidden_states], dim=1)
+            rope_freqs = torch.cat([clean_latent_4x_rope_freqs, rope_freqs], dim=1)
+
+        return hidden_states, rope_freqs
+
+    def forward(
+        self,
+        hidden_states,
+        timestep,
+        encoder_hidden_states,
+        encoder_attention_mask,
+        pooled_projections,
+        guidance,
+        latent_indices=None,
+        clean_latents=None,
+        clean_latent_indices=None,
+        clean_latents_2x=None,
+        clean_latent_2x_indices=None,
+        clean_latents_4x=None,
+        clean_latent_4x_indices=None,
+        image_embeddings=None,
+        attention_kwargs=None,
+        return_dict=True,
+    ):
+
+        if attention_kwargs is None:
+            attention_kwargs = {}
+
+        # RoPE scaling: must be done before processing hidden states
+        if self.rope_scaling_timestep_threshold is not None:
+            if timestep >= self.rope_scaling_timestep_threshold:
+                self.rope.h_w_scaling_factor = self.rope_scaling_factor
+            else:
+                self.rope.h_w_scaling_factor = 1.0
+
+        batch_size, num_channels, num_frames, height, width = hidden_states.shape
+        p, p_t = self.config_patch_size, self.config_patch_size_t
+        post_patch_num_frames = num_frames // p_t
+        post_patch_height = height // p
+        post_patch_width = width // p
+        original_context_length = post_patch_num_frames * post_patch_height * post_patch_width
+
+        input_device = hidden_states.device
+
+        hidden_states, rope_freqs = self.process_input_hidden_states(
+            hidden_states,
+            latent_indices,
+            clean_latents,
+            clean_latent_indices,
+            clean_latents_2x,
+            clean_latent_2x_indices,
+            clean_latents_4x,
+            clean_latent_4x_indices,
+        )
+        del (
+            latent_indices,
+            clean_latents,
+            clean_latent_indices,
+            clean_latents_2x,
+            clean_latent_2x_indices,
+            clean_latents_4x,
+            clean_latent_4x_indices,
+        )  # free memory
+
+        temb = self.gradient_checkpointing_method(self.time_text_embed, timestep, guidance, pooled_projections)
+        encoder_hidden_states = self.gradient_checkpointing_method(
+            self.context_embedder, encoder_hidden_states, timestep, encoder_attention_mask
+        )
+
+        if self.image_projection is not None:
+            assert image_embeddings is not None, "You must use image embeddings!"
+            extra_encoder_hidden_states = self.gradient_checkpointing_method(self.image_projection, image_embeddings)
+            extra_attention_mask = torch.ones(
+                (batch_size, extra_encoder_hidden_states.shape[1]),
+                dtype=encoder_attention_mask.dtype,
+                device=encoder_attention_mask.device,
+            )
+
+            # must cat before (not after) encoder_hidden_states, due to attn masking
+            encoder_hidden_states = torch.cat([extra_encoder_hidden_states, encoder_hidden_states], dim=1)
+            encoder_attention_mask = torch.cat([extra_attention_mask, encoder_attention_mask], dim=1)
+            del extra_encoder_hidden_states, extra_attention_mask  # free memory
+
+        with torch.no_grad():
+            if batch_size == 1 and not self.split_attn:
+                # When batch size is 1, we do not need any masks or var-len funcs since cropping is mathematically same to what we want
+                # If they are not same, then their impls are wrong. Ours are always the correct one.
+                text_len = encoder_attention_mask.sum().item()
+                encoder_hidden_states = encoder_hidden_states[:, :text_len]
+                attention_mask = None, None, None, None, None
+            else:
+                # If batch size = 1 and split_attn is True, it will be same as above
+                img_seq_len = hidden_states.shape[1]
+                txt_seq_len = encoder_hidden_states.shape[1]
+
+                cu_seqlens_q, seq_len = get_cu_seqlens(encoder_attention_mask, img_seq_len)
+                cu_seqlens_kv = cu_seqlens_q
+                max_seqlen_q = img_seq_len + txt_seq_len
+                max_seqlen_kv = max_seqlen_q
+
+                attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len
+                del cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len  # free memory
+        del encoder_attention_mask  # free memory
+
+        if self.enable_teacache:
+            modulated_inp = self.transformer_blocks[0].norm1(hidden_states, emb=temb)[0]
+
+            if self.cnt == 0 or self.cnt == self.num_steps - 1:
+                should_calc = True
+                self.accumulated_rel_l1_distance = 0
+            else:
+                curr_rel_l1 = (
+                    ((modulated_inp - self.previous_modulated_input).abs().mean() / self.previous_modulated_input.abs().mean())
+                    .cpu()
+                    .item()
+                )
+                self.accumulated_rel_l1_distance += self.teacache_rescale_func(curr_rel_l1)
+                should_calc = self.accumulated_rel_l1_distance >= self.rel_l1_thresh
+
+                if should_calc:
+                    self.accumulated_rel_l1_distance = 0
+
+            self.previous_modulated_input = modulated_inp
+            self.cnt += 1
+
+            if self.cnt == self.num_steps:
+                self.cnt = 0
+
+            if not should_calc:
+                hidden_states = hidden_states + self.previous_residual
+            else:
+                ori_hidden_states = hidden_states.clone()
+
+                for block_id, block in enumerate(self.transformer_blocks):
+                    hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
+                        block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
+                    )
+
+                for block_id, block in enumerate(self.single_transformer_blocks):
+                    hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
+                        block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
+                    )
+
+                self.previous_residual = hidden_states - ori_hidden_states
+                del ori_hidden_states  # free memory
+        else:
+            for block_id, block in enumerate(self.transformer_blocks):
+                if self.blocks_to_swap:
+                    self.offloader_double.wait_for_block(block_id)
+
+                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
+                    block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
+                )
+
+                if self.blocks_to_swap:
+                    self.offloader_double.submit_move_blocks_forward(self.transformer_blocks, block_id)
+
+            for block_id, block in enumerate(self.single_transformer_blocks):
+                if self.blocks_to_swap:
+                    self.offloader_single.wait_for_block(block_id)
+
+                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
+                    block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
+                )
+
+                if self.blocks_to_swap:
+                    self.offloader_single.submit_move_blocks_forward(self.single_transformer_blocks, block_id)
+
+        del attention_mask, rope_freqs  # free memory
+        del encoder_hidden_states  # free memory
+
+        hidden_states = self.gradient_checkpointing_method(self.norm_out, hidden_states, temb)
+
+        hidden_states = hidden_states[:, -original_context_length:, :]
+
+        if self.high_quality_fp32_output_for_inference:
+            hidden_states = hidden_states.to(dtype=torch.float32)
+            if self.proj_out.weight.dtype != torch.float32:
+                self.proj_out.to(dtype=torch.float32)
+
+        hidden_states = self.gradient_checkpointing_method(self.proj_out, hidden_states)
+
+        if hidden_states.device != input_device:
+            hidden_states = hidden_states.to(input_device)
+
+        hidden_states = einops.rearrange(
+            hidden_states,
+            "b (t h w) (c pt ph pw) -> b c (t pt) (h ph) (w pw)",
+            t=post_patch_num_frames,
+            h=post_patch_height,
+            w=post_patch_width,
+            pt=p_t,
+            ph=p,
+            pw=p,
+        )
+
+        if return_dict:
+            # return Transformer2DModelOutput(sample=hidden_states)
+            return SimpleNamespace(sample=hidden_states)
+
+        return (hidden_states,)
+
+    def fp8_optimization(
+        self, state_dict: dict[str, torch.Tensor], device: torch.device, move_to_device: bool, use_scaled_mm: bool = False
+    ) -> dict[str, torch.Tensor]:  # Return type hint added
+        """
+        Optimize the model state_dict with fp8.
+
+        Args:
+            state_dict (dict[str, torch.Tensor]):
+                The state_dict of the model.
+            device (torch.device):
+                The device to calculate the weight.
+            move_to_device (bool):
+                Whether to move the weight to the device after optimization.
+            use_scaled_mm (bool):
+                Whether to use scaled matrix multiplication for FP8.
+        """
+
+        # inplace optimization
+        state_dict = optimize_state_dict_with_fp8(
+            state_dict, device, FP8_OPTIMIZATION_TARGET_KEYS, FP8_OPTIMIZATION_EXCLUDE_KEYS, move_to_device=move_to_device
+        )
+
+        # apply monkey patching
+        apply_fp8_monkey_patch(self, state_dict, use_scaled_mm=use_scaled_mm)
+
+        return state_dict
+
+
+def load_packed_model(
+    device: Union[str, torch.device],
+    dit_path: str,
+    attn_mode: str,
+    loading_device: Union[str, torch.device],
+    fp8_scaled: bool = False,
+    split_attn: bool = False,
+    for_inference: bool = False,
+    lora_weights_list: Optional[Dict[str, torch.Tensor]] = None,
+    lora_multipliers: Optional[List[float]] = None,
+    disable_numpy_memmap: bool = False,
+) -> HunyuanVideoTransformer3DModelPacked:
+    """
+    Load a packed DiT model from a given path.
+    If fp8_scaled is True, the model will be optimized to fp8 dynamically.
+
+    Args:
+        device (Union[str, torch.device]): The device to calculate etc. (usually "cuda").
+        dit_path (str): The path to the DiT model file or directory.
+        attn_mode (str): The attention mode to use.
+        loading_device (Union[str, torch.device]): The device to load the model weights to.
+        fp8_scaled (bool): Whether to optimize the model weights to fp8.
+        split_attn (bool): Whether to use split attention.
+        for_inference (bool): Whether to create the model for inference.
+        lora_weights_list (Optional[Dict[str, torch.Tensor]]): List of state_dicts for LoRA weights.
+        lora_multipliers (Optional[List[float]]): List of multipliers for LoRA weights.
+        disable_numpy_memmap (bool): Whether to disable numpy memory mapping when loading weights.
+
+    Returns:
+        HunyuanVideoTransformer3DModelPacked: The loaded DiT model.
+    """
+
+    # TODO support split_attn
+    device = torch.device(device)
+    loading_device = torch.device(loading_device)
+
+    if os.path.isdir(dit_path):
+        # we don't support from_pretrained for now, so loading safetensors directly
+        safetensor_files = glob.glob(os.path.join(dit_path, "*.safetensors"))
+        if len(safetensor_files) == 0:
+            raise ValueError(f"Cannot find safetensors file in {dit_path}")
+        # sort by name and take the first one
+        safetensor_files.sort()
+        dit_path = safetensor_files[0]
+
+    with init_empty_weights():
+        logger.info(f"Creating HunyuanVideoTransformer3DModelPacked")
+
+        # import here to avoid circular import issues
+        from musubi_tuner.frame_pack.hunyuan_video_packed_inference import HunyuanVideoTransformer3DModelPackedInference
+
+        model_class = HunyuanVideoTransformer3DModelPackedInference if for_inference else HunyuanVideoTransformer3DModelPacked
+        model = model_class(
+            attention_head_dim=128,
+            guidance_embeds=True,
+            has_clean_x_embedder=True,
+            has_image_proj=True,
+            image_proj_dim=1152,
+            in_channels=16,
+            mlp_ratio=4.0,
+            num_attention_heads=24,
+            num_layers=20,
+            num_refiner_layers=2,
+            num_single_layers=40,
+            out_channels=16,
+            patch_size=2,
+            patch_size_t=1,
+            pooled_projection_dim=768,
+            qk_norm="rms_norm",
+            rope_axes_dim=(16, 56, 56),
+            rope_theta=256.0,
+            text_embed_dim=4096,
+            attn_mode=attn_mode,
+            split_attn=split_attn,
+        )
+
+    # load model weights with dynamic fp8 optimization and LoRA merging if needed
+    logger.info(f"Loading DiT model from {dit_path}, device={loading_device}")
+
+    sd = load_safetensors_with_lora_and_fp8(
+        model_files=dit_path,
+        lora_weights_list=lora_weights_list,
+        lora_multipliers=lora_multipliers,
+        fp8_optimization=fp8_scaled,
+        calc_device=device,
+        move_to_device=(loading_device == device),
+        target_keys=FP8_OPTIMIZATION_TARGET_KEYS,
+        exclude_keys=FP8_OPTIMIZATION_EXCLUDE_KEYS,
+        disable_numpy_memmap=disable_numpy_memmap,
+    )
+
+    if fp8_scaled:
+        apply_fp8_monkey_patch(model, sd, use_scaled_mm=False)
+
+        if loading_device.type != "cpu":
+            # make sure all the model weights are on the loading_device
+            logger.info(f"Moving weights to {loading_device}")
+            for key in sd.keys():
+                sd[key] = sd[key].to(loading_device)
+
+    info = model.load_state_dict(sd, strict=True, assign=True)
+    logger.info(f"Loaded DiT model from {dit_path}, info={info}")
+
+    return model

src/musubi_tuner/frame_pack/hunyuan_video_packed_inference.py

@@ -0,0 +1,340 @@
+# Inference model for Hunyuan Video Packed
+# We do not want to break the training accidentally, so we use a separate file for inference model.
+
+# MagCache: modified from https://github.com/Zehong-Ma/MagCache/blob/main/MagCache4HunyuanVideo/magcache_sample_video.py
+
+from types import SimpleNamespace
+from typing import Optional
+import einops
+import numpy as np
+import torch
+from torch.nn import functional as F
+from musubi_tuner.frame_pack.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked, get_cu_seqlens
+
+import logging
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+class HunyuanVideoTransformer3DModelPackedInference(HunyuanVideoTransformer3DModelPacked):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.enable_magcache = False
+
+    def initialize_magcache(
+        self,
+        enable: bool = True,
+        retention_ratio: float = 0.2,
+        mag_ratios: Optional[list[float]] = None,
+        magcache_thresh: float = 0.24,
+        K: int = 6,
+        calibration: bool = False,
+    ):
+        if mag_ratios is None:
+            # Copy from original MagCache
+            mag_ratios = np.array(
+                [1.0]
+                + [
+                    1.06971,
+                    1.29073,
+                    1.11245,
+                    1.09596,
+                    1.05233,
+                    1.01415,
+                    1.05672,
+                    1.00848,
+                    1.03632,
+                    1.02974,
+                    1.00984,
+                    1.03028,
+                    1.00681,
+                    1.06614,
+                    1.05022,
+                    1.02592,
+                    1.01776,
+                    1.02985,
+                    1.00726,
+                    1.03727,
+                    1.01502,
+                    1.00992,
+                    1.03371,
+                    0.9976,
+                    1.02742,
+                    1.0093,
+                    1.01869,
+                    1.00815,
+                    1.01461,
+                    1.01152,
+                    1.03082,
+                    1.0061,
+                    1.02162,
+                    1.01999,
+                    0.99063,
+                    1.01186,
+                    1.0217,
+                    0.99947,
+                    1.01711,
+                    0.9904,
+                    1.00258,
+                    1.00878,
+                    0.97039,
+                    0.97686,
+                    0.94315,
+                    0.97728,
+                    0.91154,
+                    0.86139,
+                    0.76592,
+                ]
+            )
+        self.enable_magcache = enable
+        self.calibration = calibration
+        self.retention_ratio = retention_ratio
+        self.default_mag_ratios = mag_ratios
+        self.magcache_thresh = magcache_thresh
+        self.K = K
+        self.reset_magcache()
+
+    def reset_magcache(self, num_steps: int = 50):
+        if not self.enable_magcache:
+            return
+
+        def nearest_interp(src_array, target_length):
+            src_length = len(src_array)
+            if target_length == 1:
+                return np.array([src_array[-1]])
+
+            scale = (src_length - 1) / (target_length - 1)
+            mapped_indices = np.round(np.arange(target_length) * scale).astype(int)
+            return np.array(src_array)[mapped_indices]
+
+        if not self.calibration and num_steps != len(self.default_mag_ratios):
+            logger.info(f"Interpolating mag_ratios from {len(self.default_mag_ratios)} to {num_steps} steps.")
+            self.mag_ratios = nearest_interp(self.default_mag_ratios, num_steps)
+        else:
+            self.mag_ratios = self.default_mag_ratios
+
+        self.cnt = 0
+        self.num_steps = num_steps
+        self.residual_cache = None
+        self.accumulated_ratio = 1.0
+        self.accumulated_steps = 0
+        self.accumulated_err = 0
+        self.norm_ratio = []
+        self.norm_std = []
+        self.cos_dis = []
+
+    def get_calibration_data(self) -> tuple[list[float], list[float], list[float]]:
+        if not self.enable_magcache or not self.calibration:
+            raise ValueError("MagCache is not enabled or calibration is not set.")
+        return self.norm_ratio, self.norm_std, self.cos_dis
+
+    def forward(self, *args, **kwargs):
+        # Forward pass for inference
+        if self.enable_magcache:
+            return self.magcache_forward(*args, **kwargs, calibration=self.calibration)
+        else:
+            return super().forward(*args, **kwargs)
+
+    def magcache_forward(
+        self,
+        hidden_states,
+        timestep,
+        encoder_hidden_states,
+        encoder_attention_mask,
+        pooled_projections,
+        guidance,
+        latent_indices=None,
+        clean_latents=None,
+        clean_latent_indices=None,
+        clean_latents_2x=None,
+        clean_latent_2x_indices=None,
+        clean_latents_4x=None,
+        clean_latent_4x_indices=None,
+        image_embeddings=None,
+        attention_kwargs=None,
+        return_dict=True,
+        calibration=False,
+    ):
+        if attention_kwargs is None:
+            attention_kwargs = {}
+
+        # RoPE scaling: must be done before processing hidden states
+        if self.rope_scaling_timestep_threshold is not None:
+            if timestep >= self.rope_scaling_timestep_threshold:
+                self.rope.h_w_scaling_factor = self.rope_scaling_factor
+            else:
+                self.rope.h_w_scaling_factor = 1.0
+
+        batch_size, num_channels, num_frames, height, width = hidden_states.shape
+        p, p_t = self.config_patch_size, self.config_patch_size_t
+        post_patch_num_frames = num_frames // p_t
+        post_patch_height = height // p
+        post_patch_width = width // p
+        original_context_length = post_patch_num_frames * post_patch_height * post_patch_width
+
+        hidden_states, rope_freqs = self.process_input_hidden_states(
+            hidden_states,
+            latent_indices,
+            clean_latents,
+            clean_latent_indices,
+            clean_latents_2x,
+            clean_latent_2x_indices,
+            clean_latents_4x,
+            clean_latent_4x_indices,
+        )
+        del (
+            latent_indices,
+            clean_latents,
+            clean_latent_indices,
+            clean_latents_2x,
+            clean_latent_2x_indices,
+            clean_latents_4x,
+            clean_latent_4x_indices,
+        )  # free memory
+
+        temb = self.gradient_checkpointing_method(self.time_text_embed, timestep, guidance, pooled_projections)
+        encoder_hidden_states = self.gradient_checkpointing_method(
+            self.context_embedder, encoder_hidden_states, timestep, encoder_attention_mask
+        )
+
+        if self.image_projection is not None:
+            assert image_embeddings is not None, "You must use image embeddings!"
+            extra_encoder_hidden_states = self.gradient_checkpointing_method(self.image_projection, image_embeddings)
+            extra_attention_mask = torch.ones(
+                (batch_size, extra_encoder_hidden_states.shape[1]),
+                dtype=encoder_attention_mask.dtype,
+                device=encoder_attention_mask.device,
+            )
+
+            # must cat before (not after) encoder_hidden_states, due to attn masking
+            encoder_hidden_states = torch.cat([extra_encoder_hidden_states, encoder_hidden_states], dim=1)
+            encoder_attention_mask = torch.cat([extra_attention_mask, encoder_attention_mask], dim=1)
+            del extra_encoder_hidden_states, extra_attention_mask  # free memory
+
+        with torch.no_grad():
+            if batch_size == 1:
+                # When batch size is 1, we do not need any masks or var-len funcs since cropping is mathematically same to what we want
+                # If they are not same, then their impls are wrong. Ours are always the correct one.
+                text_len = encoder_attention_mask.sum().item()
+                encoder_hidden_states = encoder_hidden_states[:, :text_len]
+                attention_mask = None, None, None, None, None
+            else:
+                img_seq_len = hidden_states.shape[1]
+                txt_seq_len = encoder_hidden_states.shape[1]
+
+                cu_seqlens_q, seq_len = get_cu_seqlens(encoder_attention_mask, img_seq_len)
+                cu_seqlens_kv = cu_seqlens_q
+                max_seqlen_q = img_seq_len + txt_seq_len
+                max_seqlen_kv = max_seqlen_q
+
+                attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len
+                del cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv, seq_len  # free memory
+        del encoder_attention_mask  # free memory
+
+        if self.enable_teacache:
+            raise NotImplementedError("TEACache is not implemented for inference model.")
+
+        skip_forward = False
+        if (
+            self.enable_magcache
+            and not calibration
+            and self.cnt >= max(int(self.retention_ratio * self.num_steps), 1)
+            and self.cnt < self.num_steps - 1
+        ):
+            cur_mag_ratio = self.mag_ratios[self.cnt]
+            self.accumulated_ratio = self.accumulated_ratio * cur_mag_ratio
+            cur_skip_err = np.abs(1 - self.accumulated_ratio)
+            self.accumulated_err += cur_skip_err
+            self.accumulated_steps += 1
+            if self.accumulated_err <= self.magcache_thresh and self.accumulated_steps <= self.K:
+                skip_forward = True
+            else:
+                self.accumulated_ratio = 1.0
+                self.accumulated_steps = 0
+                self.accumulated_err = 0
+
+        if skip_forward:
+            # uncomment the following line to debug
+            # print(
+            #     f"Skipping forward pass at step {self.cnt}, accumulated ratio: {self.accumulated_ratio:.4f}, "
+            #     f"accumulated error: {self.accumulated_err:.4f}, accumulated steps: {self.accumulated_steps}"
+            # )
+            hidden_states = hidden_states + self.residual_cache
+        else:
+            ori_hidden_states = hidden_states
+
+            for block_id, block in enumerate(self.transformer_blocks):
+                if self.blocks_to_swap:
+                    self.offloader_double.wait_for_block(block_id)
+
+                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
+                    block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
+                )
+
+                if self.blocks_to_swap:
+                    self.offloader_double.submit_move_blocks_forward(self.transformer_blocks, block_id)
+
+            for block_id, block in enumerate(self.single_transformer_blocks):
+                if self.blocks_to_swap:
+                    self.offloader_single.wait_for_block(block_id)
+
+                hidden_states, encoder_hidden_states = self.gradient_checkpointing_method(
+                    block, hidden_states, encoder_hidden_states, temb, attention_mask, rope_freqs
+                )
+
+                if self.blocks_to_swap:
+                    self.offloader_single.submit_move_blocks_forward(self.single_transformer_blocks, block_id)
+
+            if self.enable_magcache:
+                cur_residual = hidden_states - ori_hidden_states
+                if calibration and self.cnt >= 1:
+                    norm_ratio = ((cur_residual.norm(dim=-1) / self.residual_cache.norm(dim=-1)).mean()).item()
+                    norm_std = (cur_residual.norm(dim=-1) / self.residual_cache.norm(dim=-1)).std().item()
+                    cos_dis = (1 - F.cosine_similarity(cur_residual, self.residual_cache, dim=-1, eps=1e-8)).mean().item()
+                    self.norm_ratio.append(round(norm_ratio, 5))
+                    self.norm_std.append(round(norm_std, 5))
+                    self.cos_dis.append(round(cos_dis, 5))
+                    logger.info(f"time: {self.cnt}, norm_ratio: {norm_ratio}, norm_std: {norm_std}, cos_dis: {cos_dis}")
+                self.residual_cache = cur_residual
+
+            del ori_hidden_states  # free memory
+
+        del attention_mask, rope_freqs  # free memory
+        del encoder_hidden_states  # free memory
+
+        hidden_states = self.gradient_checkpointing_method(self.norm_out, hidden_states, temb)
+
+        hidden_states = hidden_states[:, -original_context_length:, :]
+
+        if self.high_quality_fp32_output_for_inference:
+            hidden_states = hidden_states.to(dtype=torch.float32)
+            if self.proj_out.weight.dtype != torch.float32:
+                self.proj_out.to(dtype=torch.float32)
+
+        hidden_states = self.gradient_checkpointing_method(self.proj_out, hidden_states)
+
+        hidden_states = einops.rearrange(
+            hidden_states,
+            "b (t h w) (c pt ph pw) -> b c (t pt) (h ph) (w pw)",
+            t=post_patch_num_frames,
+            h=post_patch_height,
+            w=post_patch_width,
+            pt=p_t,
+            ph=p,
+            pw=p,
+        )
+
+        if self.enable_magcache:
+            self.cnt += 1
+            if self.cnt >= self.num_steps:
+                self.cnt = 0
+                self.accumulated_ratio = 1.0
+                self.accumulated_steps = 0
+                self.accumulated_err = 0
+
+        if return_dict:
+            # return Transformer2DModelOutput(sample=hidden_states)
+            return SimpleNamespace(sample=hidden_states)
+
+        return (hidden_states,)

src/musubi_tuner/frame_pack/k_diffusion_hunyuan.py

@@ -0,0 +1,128 @@
+# original code: https://github.com/lllyasviel/FramePack
+# original license: Apache-2.0
+
+import torch
+import math
+
+# from diffusers_helper.k_diffusion.uni_pc_fm import sample_unipc
+# from diffusers_helper.k_diffusion.wrapper import fm_wrapper
+# from diffusers_helper.utils import repeat_to_batch_size
+from musubi_tuner.frame_pack.uni_pc_fm import sample_unipc
+from musubi_tuner.frame_pack.wrapper import fm_wrapper
+from musubi_tuner.frame_pack.utils import repeat_to_batch_size
+
+
+def flux_time_shift(t, mu=1.15, sigma=1.0):
+    return math.exp(mu) / (math.exp(mu) + (1 / t - 1) ** sigma)
+
+
+def calculate_flux_mu(context_length, x1=256, y1=0.5, x2=4096, y2=1.15, exp_max=7.0):
+    k = (y2 - y1) / (x2 - x1)
+    b = y1 - k * x1
+    mu = k * context_length + b
+    mu = min(mu, math.log(exp_max))
+    return mu
+
+
+def get_flux_sigmas_from_mu(n, mu):
+    sigmas = torch.linspace(1, 0, steps=n + 1)
+    sigmas = flux_time_shift(sigmas, mu=mu)
+    return sigmas
+
+
+# @torch.inference_mode()
+def sample_hunyuan(
+    transformer,
+    sampler="unipc",
+    initial_latent=None,
+    concat_latent=None,
+    strength=1.0,
+    width=512,
+    height=512,
+    frames=16,
+    real_guidance_scale=1.0,
+    distilled_guidance_scale=6.0,
+    guidance_rescale=0.0,
+    shift=None,
+    num_inference_steps=25,
+    batch_size=None,
+    generator=None,
+    prompt_embeds=None,
+    prompt_embeds_mask=None,
+    prompt_poolers=None,
+    negative_prompt_embeds=None,
+    negative_prompt_embeds_mask=None,
+    negative_prompt_poolers=None,
+    dtype=torch.bfloat16,
+    device=None,
+    negative_kwargs=None,
+    callback=None,
+    **kwargs,
+):
+    device = device or transformer.device
+
+    if batch_size is None:
+        batch_size = int(prompt_embeds.shape[0])
+
+    latents = torch.randn(
+        (batch_size, 16, (frames + 3) // 4, height // 8, width // 8), generator=generator, device=generator.device
+    ).to(device=device, dtype=torch.float32)
+
+    B, C, T, H, W = latents.shape
+    seq_length = T * H * W // 4  # 9*80*80//4 = 14400
+
+    if shift is None:
+        mu = calculate_flux_mu(seq_length, exp_max=7.0)  # 1.9459... if seq_len is large, mu is clipped.
+    else:
+        mu = math.log(shift)
+
+    sigmas = get_flux_sigmas_from_mu(num_inference_steps, mu).to(device)
+
+    k_model = fm_wrapper(transformer)
+
+    if initial_latent is not None:
+        sigmas = sigmas * strength
+        first_sigma = sigmas[0].to(device=device, dtype=torch.float32)
+        initial_latent = initial_latent.to(device=device, dtype=torch.float32)
+        latents = initial_latent.float() * (1.0 - first_sigma) + latents.float() * first_sigma
+
+    if concat_latent is not None:
+        concat_latent = concat_latent.to(latents)
+
+    distilled_guidance = torch.tensor([distilled_guidance_scale * 1000.0] * batch_size).to(device=device, dtype=dtype)
+
+    prompt_embeds = repeat_to_batch_size(prompt_embeds, batch_size)
+    prompt_embeds_mask = repeat_to_batch_size(prompt_embeds_mask, batch_size)
+    prompt_poolers = repeat_to_batch_size(prompt_poolers, batch_size)
+    negative_prompt_embeds = repeat_to_batch_size(negative_prompt_embeds, batch_size)
+    negative_prompt_embeds_mask = repeat_to_batch_size(negative_prompt_embeds_mask, batch_size)
+    negative_prompt_poolers = repeat_to_batch_size(negative_prompt_poolers, batch_size)
+    concat_latent = repeat_to_batch_size(concat_latent, batch_size)
+
+    sampler_kwargs = dict(
+        dtype=dtype,
+        cfg_scale=real_guidance_scale,
+        cfg_rescale=guidance_rescale,
+        concat_latent=concat_latent,
+        positive=dict(
+            pooled_projections=prompt_poolers,
+            encoder_hidden_states=prompt_embeds,
+            encoder_attention_mask=prompt_embeds_mask,
+            guidance=distilled_guidance,
+            **kwargs,
+        ),
+        negative=dict(
+            pooled_projections=negative_prompt_poolers,
+            encoder_hidden_states=negative_prompt_embeds,
+            encoder_attention_mask=negative_prompt_embeds_mask,
+            guidance=distilled_guidance,
+            **(kwargs if negative_kwargs is None else {**kwargs, **negative_kwargs}),
+        ),
+    )
+
+    if sampler == "unipc":
+        results = sample_unipc(k_model, latents, sigmas, extra_args=sampler_kwargs, disable=False, callback=callback)
+    else:
+        raise NotImplementedError(f"Sampler {sampler} is not supported.")
+
+    return results

src/musubi_tuner/frame_pack/uni_pc_fm.py

@@ -0,0 +1,144 @@
+# Better Flow Matching UniPC by Lvmin Zhang
+# (c) 2025
+# CC BY-SA 4.0
+# Attribution-ShareAlike 4.0 International Licence
+
+
+import torch
+
+from tqdm.auto import trange
+
+
+def expand_dims(v, dims):
+    return v[(...,) + (None,) * (dims - 1)]
+
+
+class FlowMatchUniPC:
+    def __init__(self, model, extra_args, variant="bh1"):
+        self.model = model
+        self.variant = variant
+        self.extra_args = extra_args
+
+    def model_fn(self, x, t):
+        return self.model(x, t, **self.extra_args)
+
+    def update_fn(self, x, model_prev_list, t_prev_list, t, order):
+        assert order <= len(model_prev_list)
+        dims = x.dim()
+
+        t_prev_0 = t_prev_list[-1]
+        lambda_prev_0 = -torch.log(t_prev_0)
+        lambda_t = -torch.log(t)
+        model_prev_0 = model_prev_list[-1]
+
+        h = lambda_t - lambda_prev_0
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            t_prev_i = t_prev_list[-(i + 1)]
+            model_prev_i = model_prev_list[-(i + 1)]
+            lambda_prev_i = -torch.log(t_prev_i)
+            rk = ((lambda_prev_i - lambda_prev_0) / h)[0]
+            rks.append(rk)
+            D1s.append((model_prev_i - model_prev_0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=x.device)
+
+        R = []
+        b = []
+
+        hh = -h[0]
+        h_phi_1 = torch.expm1(hh)
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.variant == "bh1":
+            B_h = hh
+        elif self.variant == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError("Bad variant!")
+
+        for i in range(1, order + 1):
+            R.append(torch.pow(rks, i - 1))
+            b.append(h_phi_k * factorial_i / B_h)
+            factorial_i *= i + 1
+            h_phi_k = h_phi_k / hh - 1 / factorial_i
+
+        R = torch.stack(R)
+        b = torch.tensor(b, device=x.device)
+
+        use_predictor = len(D1s) > 0
+
+        if use_predictor:
+            D1s = torch.stack(D1s, dim=1)
+            if order == 2:
+                rhos_p = torch.tensor([0.5], device=b.device)
+            else:
+                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1])
+        else:
+            D1s = None
+            rhos_p = None
+
+        if order == 1:
+            rhos_c = torch.tensor([0.5], device=b.device)
+        else:
+            rhos_c = torch.linalg.solve(R, b)
+
+        x_t_ = expand_dims(t / t_prev_0, dims) * x - expand_dims(h_phi_1, dims) * model_prev_0
+
+        if use_predictor:
+            pred_res = torch.tensordot(D1s, rhos_p, dims=([1], [0]))
+        else:
+            pred_res = 0
+
+        x_t = x_t_ - expand_dims(B_h, dims) * pred_res
+        model_t = self.model_fn(x_t, t)
+
+        if D1s is not None:
+            corr_res = torch.tensordot(D1s, rhos_c[:-1], dims=([1], [0]))
+        else:
+            corr_res = 0
+
+        D1_t = model_t - model_prev_0
+        x_t = x_t_ - expand_dims(B_h, dims) * (corr_res + rhos_c[-1] * D1_t)
+
+        return x_t, model_t
+
+    def sample(self, x, sigmas, callback=None, disable_pbar=False):
+        order = min(3, len(sigmas) - 2)
+        model_prev_list, t_prev_list = [], []
+        for i in trange(len(sigmas) - 1, disable=disable_pbar):
+            vec_t = sigmas[i].expand(x.shape[0])
+
+            with torch.no_grad():
+                if i == 0:
+                    model_prev_list = [self.model_fn(x, vec_t)]
+                    t_prev_list = [vec_t]
+                elif i < order:
+                    init_order = i
+                    x, model_x = self.update_fn(x, model_prev_list, t_prev_list, vec_t, init_order)
+                    model_prev_list.append(model_x)
+                    t_prev_list.append(vec_t)
+                else:
+                    x, model_x = self.update_fn(x, model_prev_list, t_prev_list, vec_t, order)
+                    model_prev_list.append(model_x)
+                    t_prev_list.append(vec_t)
+
+            model_prev_list = model_prev_list[-order:]
+            t_prev_list = t_prev_list[-order:]
+
+            if callback is not None:
+                callback({"x": x, "i": i, "denoised": model_prev_list[-1]})
+
+        return model_prev_list[-1]
+
+
+def sample_unipc(model, noise, sigmas, extra_args=None, callback=None, disable=False, variant="bh1"):
+    assert variant in ["bh1", "bh2"]
+    return FlowMatchUniPC(model, extra_args=extra_args, variant=variant).sample(
+        noise, sigmas=sigmas, callback=callback, disable_pbar=disable
+    )

src/musubi_tuner/frame_pack/utils.py

@@ -0,0 +1,616 @@
+import os
+import cv2
+import json
+import random
+import glob
+import torch
+import einops
+import numpy as np
+import datetime
+import torchvision
+
+from PIL import Image
+
+
+def min_resize(x, m):
+    if x.shape[0] < x.shape[1]:
+        s0 = m
+        s1 = int(float(m) / float(x.shape[0]) * float(x.shape[1]))
+    else:
+        s0 = int(float(m) / float(x.shape[1]) * float(x.shape[0]))
+        s1 = m
+    new_max = max(s1, s0)
+    raw_max = max(x.shape[0], x.shape[1])
+    if new_max < raw_max:
+        interpolation = cv2.INTER_AREA
+    else:
+        interpolation = cv2.INTER_LANCZOS4
+    y = cv2.resize(x, (s1, s0), interpolation=interpolation)
+    return y
+
+
+def d_resize(x, y):
+    H, W, C = y.shape
+    new_min = min(H, W)
+    raw_min = min(x.shape[0], x.shape[1])
+    if new_min < raw_min:
+        interpolation = cv2.INTER_AREA
+    else:
+        interpolation = cv2.INTER_LANCZOS4
+    y = cv2.resize(x, (W, H), interpolation=interpolation)
+    return y
+
+
+def resize_and_center_crop(image, target_width, target_height):
+    if target_height == image.shape[0] and target_width == image.shape[1]:
+        return image
+
+    pil_image = Image.fromarray(image)
+    original_width, original_height = pil_image.size
+    scale_factor = max(target_width / original_width, target_height / original_height)
+    resized_width = int(round(original_width * scale_factor))
+    resized_height = int(round(original_height * scale_factor))
+    resized_image = pil_image.resize((resized_width, resized_height), Image.LANCZOS)
+    left = (resized_width - target_width) / 2
+    top = (resized_height - target_height) / 2
+    right = (resized_width + target_width) / 2
+    bottom = (resized_height + target_height) / 2
+    cropped_image = resized_image.crop((left, top, right, bottom))
+    return np.array(cropped_image)
+
+
+def resize_and_center_crop_pytorch(image, target_width, target_height):
+    B, C, H, W = image.shape
+
+    if H == target_height and W == target_width:
+        return image
+
+    scale_factor = max(target_width / W, target_height / H)
+    resized_width = int(round(W * scale_factor))
+    resized_height = int(round(H * scale_factor))
+
+    resized = torch.nn.functional.interpolate(image, size=(resized_height, resized_width), mode="bilinear", align_corners=False)
+
+    top = (resized_height - target_height) // 2
+    left = (resized_width - target_width) // 2
+    cropped = resized[:, :, top : top + target_height, left : left + target_width]
+
+    return cropped
+
+
+def resize_without_crop(image, target_width, target_height):
+    if target_height == image.shape[0] and target_width == image.shape[1]:
+        return image
+
+    pil_image = Image.fromarray(image)
+    resized_image = pil_image.resize((target_width, target_height), Image.LANCZOS)
+    return np.array(resized_image)
+
+
+def just_crop(image, w, h):
+    if h == image.shape[0] and w == image.shape[1]:
+        return image
+
+    original_height, original_width = image.shape[:2]
+    k = min(original_height / h, original_width / w)
+    new_width = int(round(w * k))
+    new_height = int(round(h * k))
+    x_start = (original_width - new_width) // 2
+    y_start = (original_height - new_height) // 2
+    cropped_image = image[y_start : y_start + new_height, x_start : x_start + new_width]
+    return cropped_image
+
+
+def write_to_json(data, file_path):
+    temp_file_path = file_path + ".tmp"
+    with open(temp_file_path, "wt", encoding="utf-8") as temp_file:
+        json.dump(data, temp_file, indent=4)
+    os.replace(temp_file_path, file_path)
+    return
+
+
+def read_from_json(file_path):
+    with open(file_path, "rt", encoding="utf-8") as file:
+        data = json.load(file)
+    return data
+
+
+def get_active_parameters(m):
+    return {k: v for k, v in m.named_parameters() if v.requires_grad}
+
+
+def cast_training_params(m, dtype=torch.float32):
+    result = {}
+    for n, param in m.named_parameters():
+        if param.requires_grad:
+            param.data = param.to(dtype)
+            result[n] = param
+    return result
+
+
+def separate_lora_AB(parameters, B_patterns=None):
+    parameters_normal = {}
+    parameters_B = {}
+
+    if B_patterns is None:
+        B_patterns = [".lora_B.", "__zero__"]
+
+    for k, v in parameters.items():
+        if any(B_pattern in k for B_pattern in B_patterns):
+            parameters_B[k] = v
+        else:
+            parameters_normal[k] = v
+
+    return parameters_normal, parameters_B
+
+
+def set_attr_recursive(obj, attr, value):
+    attrs = attr.split(".")
+    for name in attrs[:-1]:
+        obj = getattr(obj, name)
+    setattr(obj, attrs[-1], value)
+    return
+
+
+def print_tensor_list_size(tensors):
+    total_size = 0
+    total_elements = 0
+
+    if isinstance(tensors, dict):
+        tensors = tensors.values()
+
+    for tensor in tensors:
+        total_size += tensor.nelement() * tensor.element_size()
+        total_elements += tensor.nelement()
+
+    total_size_MB = total_size / (1024**2)
+    total_elements_B = total_elements / 1e9
+
+    print(f"Total number of tensors: {len(tensors)}")
+    print(f"Total size of tensors: {total_size_MB:.2f} MB")
+    print(f"Total number of parameters: {total_elements_B:.3f} billion")
+    return
+
+
+@torch.no_grad()
+def batch_mixture(a, b=None, probability_a=0.5, mask_a=None):
+    batch_size = a.size(0)
+
+    if b is None:
+        b = torch.zeros_like(a)
+
+    if mask_a is None:
+        mask_a = torch.rand(batch_size) < probability_a
+
+    mask_a = mask_a.to(a.device)
+    mask_a = mask_a.reshape((batch_size,) + (1,) * (a.dim() - 1))
+    result = torch.where(mask_a, a, b)
+    return result
+
+
+@torch.no_grad()
+def zero_module(module):
+    for p in module.parameters():
+        p.detach().zero_()
+    return module
+
+
+@torch.no_grad()
+def supress_lower_channels(m, k, alpha=0.01):
+    data = m.weight.data.clone()
+
+    assert int(data.shape[1]) >= k
+
+    data[:, :k] = data[:, :k] * alpha
+    m.weight.data = data.contiguous().clone()
+    return m
+
+
+def freeze_module(m):
+    if not hasattr(m, "_forward_inside_frozen_module"):
+        m._forward_inside_frozen_module = m.forward
+    m.requires_grad_(False)
+    m.forward = torch.no_grad()(m.forward)
+    return m
+
+
+def get_latest_safetensors(folder_path):
+    safetensors_files = glob.glob(os.path.join(folder_path, "*.safetensors"))
+
+    if not safetensors_files:
+        raise ValueError("No file to resume!")
+
+    latest_file = max(safetensors_files, key=os.path.getmtime)
+    latest_file = os.path.abspath(os.path.realpath(latest_file))
+    return latest_file
+
+
+def generate_random_prompt_from_tags(tags_str, min_length=3, max_length=32):
+    tags = tags_str.split(", ")
+    tags = random.sample(tags, k=min(random.randint(min_length, max_length), len(tags)))
+    prompt = ", ".join(tags)
+    return prompt
+
+
+def interpolate_numbers(a, b, n, round_to_int=False, gamma=1.0):
+    numbers = a + (b - a) * (np.linspace(0, 1, n) ** gamma)
+    if round_to_int:
+        numbers = np.round(numbers).astype(int)
+    return numbers.tolist()
+
+
+def uniform_random_by_intervals(inclusive, exclusive, n, round_to_int=False):
+    edges = np.linspace(0, 1, n + 1)
+    points = np.random.uniform(edges[:-1], edges[1:])
+    numbers = inclusive + (exclusive - inclusive) * points
+    if round_to_int:
+        numbers = np.round(numbers).astype(int)
+    return numbers.tolist()
+
+
+def soft_append_bcthw(history, current, overlap=0):
+    if overlap <= 0:
+        return torch.cat([history, current], dim=2)
+
+    assert history.shape[2] >= overlap, f"History length ({history.shape[2]}) must be >= overlap ({overlap})"
+    assert current.shape[2] >= overlap, f"Current length ({current.shape[2]}) must be >= overlap ({overlap})"
+
+    weights = torch.linspace(1, 0, overlap, dtype=history.dtype, device=history.device).view(1, 1, -1, 1, 1)
+    blended = weights * history[:, :, -overlap:] + (1 - weights) * current[:, :, :overlap]
+    output = torch.cat([history[:, :, :-overlap], blended, current[:, :, overlap:]], dim=2)
+
+    return output.to(history)
+
+
+def save_bcthw_as_mp4(x, output_filename, fps=10):
+    b, c, t, h, w = x.shape
+
+    per_row = b
+    for p in [6, 5, 4, 3, 2]:
+        if b % p == 0:
+            per_row = p
+            break
+
+    os.makedirs(os.path.dirname(os.path.abspath(os.path.realpath(output_filename))), exist_ok=True)
+    x = torch.clamp(x.float(), -1.0, 1.0) * 127.5 + 127.5
+    x = x.detach().cpu().to(torch.uint8)
+    x = einops.rearrange(x, "(m n) c t h w -> t (m h) (n w) c", n=per_row)
+    torchvision.io.write_video(output_filename, x, fps=fps, video_codec="libx264", options={"crf": "0"})
+
+    # write tensor as .pt file
+    torch.save(x, output_filename.replace(".mp4", ".pt"))
+
+    return x
+
+
+def save_bcthw_as_png(x, output_filename):
+    os.makedirs(os.path.dirname(os.path.abspath(os.path.realpath(output_filename))), exist_ok=True)
+    x = torch.clamp(x.float(), -1.0, 1.0) * 127.5 + 127.5
+    x = x.detach().cpu().to(torch.uint8)
+    x = einops.rearrange(x, "b c t h w -> c (b h) (t w)")
+    torchvision.io.write_png(x, output_filename)
+    return output_filename
+
+
+def save_bchw_as_png(x, output_filename):
+    os.makedirs(os.path.dirname(os.path.abspath(os.path.realpath(output_filename))), exist_ok=True)
+    x = torch.clamp(x.float(), -1.0, 1.0) * 127.5 + 127.5
+    x = x.detach().cpu().to(torch.uint8)
+    x = einops.rearrange(x, "b c h w -> c h (b w)")
+    torchvision.io.write_png(x, output_filename)
+    return output_filename
+
+
+def add_tensors_with_padding(tensor1, tensor2):
+    if tensor1.shape == tensor2.shape:
+        return tensor1 + tensor2
+
+    shape1 = tensor1.shape
+    shape2 = tensor2.shape
+
+    new_shape = tuple(max(s1, s2) for s1, s2 in zip(shape1, shape2))
+
+    padded_tensor1 = torch.zeros(new_shape)
+    padded_tensor2 = torch.zeros(new_shape)
+
+    padded_tensor1[tuple(slice(0, s) for s in shape1)] = tensor1
+    padded_tensor2[tuple(slice(0, s) for s in shape2)] = tensor2
+
+    result = padded_tensor1 + padded_tensor2
+    return result
+
+
+def print_free_mem():
+    torch.cuda.empty_cache()
+    free_mem, total_mem = torch.cuda.mem_get_info(0)
+    free_mem_mb = free_mem / (1024**2)
+    total_mem_mb = total_mem / (1024**2)
+    print(f"Free memory: {free_mem_mb:.2f} MB")
+    print(f"Total memory: {total_mem_mb:.2f} MB")
+    return
+
+
+def print_gpu_parameters(device, state_dict, log_count=1):
+    summary = {"device": device, "keys_count": len(state_dict)}
+
+    logged_params = {}
+    for i, (key, tensor) in enumerate(state_dict.items()):
+        if i >= log_count:
+            break
+        logged_params[key] = tensor.flatten()[:3].tolist()
+
+    summary["params"] = logged_params
+
+    print(str(summary))
+    return
+
+
+def visualize_txt_as_img(width, height, text, font_path="font/DejaVuSans.ttf", size=18):
+    from PIL import Image, ImageDraw, ImageFont
+
+    txt = Image.new("RGB", (width, height), color="white")
+    draw = ImageDraw.Draw(txt)
+    font = ImageFont.truetype(font_path, size=size)
+
+    if text == "":
+        return np.array(txt)
+
+    # Split text into lines that fit within the image width
+    lines = []
+    words = text.split()
+    current_line = words[0]
+
+    for word in words[1:]:
+        line_with_word = f"{current_line} {word}"
+        if draw.textbbox((0, 0), line_with_word, font=font)[2] <= width:
+            current_line = line_with_word
+        else:
+            lines.append(current_line)
+            current_line = word
+
+    lines.append(current_line)
+
+    # Draw the text line by line
+    y = 0
+    line_height = draw.textbbox((0, 0), "A", font=font)[3]
+
+    for line in lines:
+        if y + line_height > height:
+            break  # stop drawing if the next line will be outside the image
+        draw.text((0, y), line, fill="black", font=font)
+        y += line_height
+
+    return np.array(txt)
+
+
+def blue_mark(x):
+    x = x.copy()
+    c = x[:, :, 2]
+    b = cv2.blur(c, (9, 9))
+    x[:, :, 2] = ((c - b) * 16.0 + b).clip(-1, 1)
+    return x
+
+
+def green_mark(x):
+    x = x.copy()
+    x[:, :, 2] = -1
+    x[:, :, 0] = -1
+    return x
+
+
+def frame_mark(x):
+    x = x.copy()
+    x[:64] = -1
+    x[-64:] = -1
+    x[:, :8] = 1
+    x[:, -8:] = 1
+    return x
+
+
+@torch.inference_mode()
+def pytorch2numpy(imgs):
+    results = []
+    for x in imgs:
+        y = x.movedim(0, -1)
+        y = y * 127.5 + 127.5
+        y = y.detach().float().cpu().numpy().clip(0, 255).astype(np.uint8)
+        results.append(y)
+    return results
+
+
+@torch.inference_mode()
+def numpy2pytorch(imgs):
+    h = torch.from_numpy(np.stack(imgs, axis=0)).float() / 127.5 - 1.0
+    h = h.movedim(-1, 1)
+    return h
+
+
+@torch.no_grad()
+def duplicate_prefix_to_suffix(x, count, zero_out=False):
+    if zero_out:
+        return torch.cat([x, torch.zeros_like(x[:count])], dim=0)
+    else:
+        return torch.cat([x, x[:count]], dim=0)
+
+
+def weighted_mse(a, b, weight):
+    return torch.mean(weight.float() * (a.float() - b.float()) ** 2)
+
+
+def clamped_linear_interpolation(x, x_min, y_min, x_max, y_max, sigma=1.0):
+    x = (x - x_min) / (x_max - x_min)
+    x = max(0.0, min(x, 1.0))
+    x = x**sigma
+    return y_min + x * (y_max - y_min)
+
+
+def expand_to_dims(x, target_dims):
+    return x.view(*x.shape, *([1] * max(0, target_dims - x.dim())))
+
+
+def repeat_to_batch_size(tensor: torch.Tensor, batch_size: int):
+    if tensor is None:
+        return None
+
+    first_dim = tensor.shape[0]
+
+    if first_dim == batch_size:
+        return tensor
+
+    if batch_size % first_dim != 0:
+        raise ValueError(f"Cannot evenly repeat first dim {first_dim} to match batch_size {batch_size}.")
+
+    repeat_times = batch_size // first_dim
+
+    return tensor.repeat(repeat_times, *[1] * (tensor.dim() - 1))
+
+
+def dim5(x):
+    return expand_to_dims(x, 5)
+
+
+def dim4(x):
+    return expand_to_dims(x, 4)
+
+
+def dim3(x):
+    return expand_to_dims(x, 3)
+
+
+def crop_or_pad_yield_mask(x, length):
+    B, F, C = x.shape
+    device = x.device
+    dtype = x.dtype
+
+    if F < length:
+        y = torch.zeros((B, length, C), dtype=dtype, device=device)
+        mask = torch.zeros((B, length), dtype=torch.bool, device=device)
+        y[:, :F, :] = x
+        mask[:, :F] = True
+        return y, mask
+
+    return x[:, :length, :], torch.ones((B, length), dtype=torch.bool, device=device)
+
+
+def extend_dim(x, dim, minimal_length, zero_pad=False):
+    original_length = int(x.shape[dim])
+
+    if original_length >= minimal_length:
+        return x
+
+    if zero_pad:
+        padding_shape = list(x.shape)
+        padding_shape[dim] = minimal_length - original_length
+        padding = torch.zeros(padding_shape, dtype=x.dtype, device=x.device)
+    else:
+        idx = (slice(None),) * dim + (slice(-1, None),) + (slice(None),) * (len(x.shape) - dim - 1)
+        last_element = x[idx]
+        padding = last_element.repeat_interleave(minimal_length - original_length, dim=dim)
+
+    return torch.cat([x, padding], dim=dim)
+
+
+def lazy_positional_encoding(t, repeats=None):
+    if not isinstance(t, list):
+        t = [t]
+
+    from diffusers.models.embeddings import get_timestep_embedding
+
+    te = torch.tensor(t)
+    te = get_timestep_embedding(timesteps=te, embedding_dim=256, flip_sin_to_cos=True, downscale_freq_shift=0.0, scale=1.0)
+
+    if repeats is None:
+        return te
+
+    te = te[:, None, :].expand(-1, repeats, -1)
+
+    return te
+
+
+def state_dict_offset_merge(A, B, C=None):
+    result = {}
+    keys = A.keys()
+
+    for key in keys:
+        A_value = A[key]
+        B_value = B[key].to(A_value)
+
+        if C is None:
+            result[key] = A_value + B_value
+        else:
+            C_value = C[key].to(A_value)
+            result[key] = A_value + B_value - C_value
+
+    return result
+
+
+def state_dict_weighted_merge(state_dicts, weights):
+    if len(state_dicts) != len(weights):
+        raise ValueError("Number of state dictionaries must match number of weights")
+
+    if not state_dicts:
+        return {}
+
+    total_weight = sum(weights)
+
+    if total_weight == 0:
+        raise ValueError("Sum of weights cannot be zero")
+
+    normalized_weights = [w / total_weight for w in weights]
+
+    keys = state_dicts[0].keys()
+    result = {}
+
+    for key in keys:
+        result[key] = state_dicts[0][key] * normalized_weights[0]
+
+        for i in range(1, len(state_dicts)):
+            state_dict_value = state_dicts[i][key].to(result[key])
+            result[key] += state_dict_value * normalized_weights[i]
+
+    return result
+
+
+def group_files_by_folder(all_files):
+    grouped_files = {}
+
+    for file in all_files:
+        folder_name = os.path.basename(os.path.dirname(file))
+        if folder_name not in grouped_files:
+            grouped_files[folder_name] = []
+        grouped_files[folder_name].append(file)
+
+    list_of_lists = list(grouped_files.values())
+    return list_of_lists
+
+
+def generate_timestamp():
+    now = datetime.datetime.now()
+    timestamp = now.strftime("%y%m%d_%H%M%S")
+    milliseconds = f"{int(now.microsecond / 1000):03d}"
+    random_number = random.randint(0, 9999)
+    return f"{timestamp}_{milliseconds}_{random_number}"
+
+
+def write_PIL_image_with_png_info(image, metadata, path):
+    from PIL.PngImagePlugin import PngInfo
+
+    png_info = PngInfo()
+    for key, value in metadata.items():
+        png_info.add_text(key, value)
+
+    image.save(path, "PNG", pnginfo=png_info)
+    return image
+
+
+def torch_safe_save(content, path):
+    torch.save(content, path + "_tmp")
+    os.replace(path + "_tmp", path)
+    return path
+
+
+def move_optimizer_to_device(optimizer, device):
+    for state in optimizer.state.values():
+        for k, v in state.items():
+            if isinstance(v, torch.Tensor):
+                state[k] = v.to(device)

src/musubi_tuner/frame_pack/wrapper.py

@@ -0,0 +1,55 @@
+import torch
+
+
+def append_dims(x, target_dims):
+    return x[(...,) + (None,) * (target_dims - x.ndim)]
+
+
+def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=1.0):
+    if guidance_rescale == 0:
+        return noise_cfg
+
+    std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)
+    std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)
+    noise_pred_rescaled = noise_cfg * (std_text / std_cfg)
+    noise_cfg = guidance_rescale * noise_pred_rescaled + (1.0 - guidance_rescale) * noise_cfg
+    return noise_cfg
+
+
+def fm_wrapper(transformer, t_scale=1000.0):
+    def k_model(x, sigma, **extra_args):
+        dtype = extra_args["dtype"]
+        cfg_scale = extra_args["cfg_scale"]
+        cfg_rescale = extra_args["cfg_rescale"]
+        concat_latent = extra_args["concat_latent"]
+
+        original_dtype = x.dtype
+        sigma = sigma.float()
+
+        x = x.to(dtype)
+        timestep = sigma * t_scale  # sigma is already float32
+
+        if concat_latent is None:
+            hidden_states = x
+        else:
+            hidden_states = torch.cat([x, concat_latent.to(x)], dim=1)
+
+        pred_positive = transformer(hidden_states=hidden_states, timestep=timestep, return_dict=False, **extra_args["positive"])[
+            0
+        ].float()
+
+        if cfg_scale == 1.0:
+            pred_negative = torch.zeros_like(pred_positive)
+        else:
+            pred_negative = transformer(
+                hidden_states=hidden_states, timestep=timestep, return_dict=False, **extra_args["negative"]
+            )[0].float()
+
+        pred_cfg = pred_negative + cfg_scale * (pred_positive - pred_negative)
+        pred = rescale_noise_cfg(pred_cfg, pred_positive, guidance_rescale=cfg_rescale)
+
+        x0 = x.float() - pred.float() * append_dims(sigma, x.ndim)
+
+        return x0.to(dtype=original_dtype)
+
+    return k_model

src/musubi_tuner/gui/config_manager.py

@@ -0,0 +1,105 @@
+import os
+
+
+class ConfigManager:
+    def __init__(self):
+        self.models = {
+            "Z-Image-Turbo": {
+                "resolution": (1024, 1024),
+                "vae_subpath": ["vae", "ae.safetensors"],
+                "te1_subpath": ["text_encoders", "qwen_3_4b.safetensors"],
+                "te2_subpath": None,
+                "dit_subpath": ["diffusion_models", "z_image_de_turbo_v1_bf16.safetensors"],
+                "training_base": {
+                    "learning_rate": 1e-3,
+                    "default_num_steps": 500,
+                    "save_every_n_epochs": 1,
+                    "discrete_flow_shift": 2.0,
+                    "mixed_precision": "bf16",
+                    "gradient_checkpointing": True,
+                    "fp8_scaled": True,
+                    "fp8_llm": True,
+                },
+                "vram_settings": {
+                    "12": {"batch_size": 1, "block_swap": 0, "fp8_scaled": True, "fp8_llm": True},
+                    "16": {"batch_size": 2, "block_swap": 0, "fp8_scaled": True, "fp8_llm": False},
+                    "24": {"batch_size": 1, "block_swap": 0, "fp8_scaled": False, "fp8_llm": False},
+                    "32": {"batch_size": 2, "block_swap": 0, "fp8_scaled": False, "fp8_llm": False},
+                    ">32": {"batch_size": 8, "block_swap": 0, "fp8_scaled": False, "fp8_llm": False},
+                },
+            },
+            "Qwen-Image": {
+                "resolution": (1328, 1328),
+                "vae_subpath": ["vae", "qwen_image_vae.safetensors"],
+                "te1_subpath": ["text_encoders", "qwen_2.5_vl_7b.safetensors"],
+                "te2_subpath": None,
+                "dit_subpath": ["diffusion_models", "qwen_image_bf16.safetensors"],
+                "training_base": {
+                    "learning_rate": 1e-3,
+                    "default_num_steps": 1000,
+                    "save_every_n_epochs": 1,
+                    "discrete_flow_shift": 2.2,
+                    "mixed_precision": "bf16",
+                    "gradient_checkpointing": True,
+                    "fp8_scaled": True,
+                    "fp8_llm": True,
+                },
+                "vram_settings": {
+                    "12": {"batch_size": 1, "block_swap": 46, "fp8_scaled": True, "fp8_llm": True},
+                    "16": {"batch_size": 1, "block_swap": 34, "fp8_scaled": True, "fp8_llm": True},
+                    "24": {"batch_size": 1, "block_swap": 10, "fp8_scaled": True, "fp8_llm": False},
+                    "32": {"batch_size": 2, "block_swap": 0, "fp8_scaled": True, "fp8_llm": False},
+                    ">32": {"batch_size": 2, "block_swap": 0, "fp8_scaled": False, "fp8_llm": False},
+                },
+            },
+        }
+
+    def get_resolution(self, model_name):
+        return self.models.get(model_name, {}).get("resolution", (1024, 1024))
+
+    def get_batch_size(self, model_name, vram_size):
+        # Default to "16" if vram_size is not provided or invalid, as a safe middle ground
+        if not vram_size:
+            vram_size = "16"
+
+        vram_conf = self.models.get(model_name, {}).get("vram_settings", {}).get(vram_size, {})
+        return vram_conf.get("batch_size", 1)
+
+    def get_preprocessing_paths(self, model_name, comfy_models_dir):
+        conf = self.models.get(model_name, {})
+        vae = conf.get("vae_subpath")
+        te1 = conf.get("te1_subpath")
+        te2 = conf.get("te2_subpath")
+
+        def join_path(subpath):
+            if subpath and comfy_models_dir:
+                return os.path.join(comfy_models_dir, *subpath)
+            return ""
+
+        return join_path(vae), join_path(te1), join_path(te2)
+
+    def get_training_defaults(self, model_name, vram_size, comfy_models_dir):
+        conf = self.models.get(model_name, {})
+        base = conf.get("training_base", {}).copy()
+
+        if not vram_size:
+            vram_size = "16"
+
+        # Merge VRAM settings
+        vram_conf = conf.get("vram_settings", {}).get(vram_size, {})
+        # Only take relevant keys for training params (block_swap), ignore batch_size as it's for dataset
+        if "block_swap" in vram_conf:
+            base["block_swap"] = vram_conf["block_swap"]
+        if "fp8_llm" in vram_conf:
+            base["fp8_llm"] = vram_conf["fp8_llm"]
+        if "fp8_scaled" in vram_conf:
+            base["fp8_scaled"] = vram_conf["fp8_scaled"]
+
+        # DiT path
+        dit_sub = conf.get("dit_subpath")
+        if dit_sub and comfy_models_dir:
+            base["dit_path"] = os.path.join(comfy_models_dir, *dit_sub)
+        else:
+            base["dit_path"] = ""
+
+        return base

src/musubi_tuner/gui/gui.ja.md

@@ -0,0 +1,444 @@
+[English](./gui.md) | [日本語](./gui.ja.md)
+
+# Musubi Tuner GUI - ユーザーガイド
+
+このガイドでは、Musubi Tuner GUIのセットアップと使用方法について説明します。Z-Image-TurboやQwen-Imageなどの画像生成モデルでLoRAを学習できます。
+
+## 目次
+
+1. [必要な環境](#必要な環境)
+2. [必要なソフトウェアのインストール](#必要なソフトウェアのインストール)
+3. [Musubi Tunerのインストール](#musubi-tunerのインストール)
+4. [GUIの起動](#guiの起動)
+5. [作業手順ガイド](#作業手順ガイド)
+6. [各項目の説明](#各項目の説明)
+7. [トラブルシューティング](#トラブルシューティング)
+
+---
+
+## 必要な環境
+
+始める前に、以下を確認してください：
+
+- NVIDIA GPU搭載のWindows PC（VRAM 12GB以上推奨、VRAM+メインRAMで64GB以上推奨）
+- インターネット接続
+- ComfyUIがインストール済みで、必要なモデル（VAE、Text Encoder、DiT）がダウンロード済みであること
+
+---
+
+## 必要なソフトウェアのインストール
+
+### ステップ1：Pythonのインストール
+
+Musubi TunerにはPython 3.10、3.11、または3.12が必要です。システムにインストールされていない場合は、以下の手順でインストールしてください。
+
+1. Pythonの公式サイトにアクセス：https://www.python.org/downloads/
+2. Python 3.10、3.11、または3.12の、Windows用 64ビットインストーラーをダウンロード（互換性の観点から **Python 3.12** を推奨）
+3. インストーラーを実行
+4. **重要**：「Install Now」をクリックする前に、**「Add Python to PATH」にチェック**を入れてください
+5. インストールを完了
+
+**インストールの確認**：コマンドプロンプトを開き（`Win + R`を押して`cmd`と入力し、Enterを押す）、以下を実行：
+```
+python --version
+```
+`Python 3.12.x`のように表示されれば成功です。
+
+### ステップ2：Gitのインストール
+
+GitはMusubi Tunerのソースコードをダウンロードするために必要です。システムにインストールされていない場合は、以下の手順でインストールしてください。
+
+1. Gitのサイトにアクセス：https://git-scm.com/downloads/win
+2. Windowsインストーラーをダウンロード
+3. デフォルト設定のままインストーラーを実行（「Next」をクリックし続ける）
+4. インストールを完了
+
+**インストールの確認**：コマンドプロンプトで以下を実行：
+```
+git --version
+```
+`git version 2.x.x`のように表示されれば成功です。
+
+### ステップ3：uvのインストール
+
+uvは依存関係の管理を簡単にする最新のPythonパッケージマネージャーです。
+
+1. 管理者のコマンドプロンプトを開く
+2. 以下のコマンドを実行：
+```
+powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+3. 変更を反映させるため、**コマンドプロンプトを閉じて再度開く**（通常のコマンドプロンプト）
+
+**インストールの確認**：新しいコマンドプロンプトで以下を実行：
+```
+uv --version
+```
+`uv 0.x.x`のように表示されれば成功です。
+
+---
+
+## Musubi Tunerのインストール
+
+### ステップ1：ソースコードのダウンロード
+
+1. コマンドプロンプトを開く
+2. Musubi Tunerをインストールしたいフォルダに移動。例：
+   ```
+   cd C:\Users\YourName\Documents
+   ```
+3. リポジトリをクローン：
+   ```
+   git clone https://github.com/kohya-ss/musubi-tuner.git
+   ```
+4. フォルダに移動：
+   ```
+   cd musubi-tuner
+   ```
+
+### ステップ2：初回セットアップ（自動）
+
+GUIを初めて実行すると、uvが自動的にPyTorchを含むすべての必要な依存関係をダウンロード・インストールします。これには数分かかる場合があります。
+
+---
+
+## GUIの起動
+
+コマンドプロンプトを開き、musubi-tunerフォルダに移動して、CUDAバージョンに応じて以下のいずれかのコマンドを実行します：
+
+### CUDA 12.4の場合（安定したバージョン）
+
+```
+uv run --extra cu124 --extra gui python src/musubi_tuner/gui/gui.py
+```
+
+### CUDA 12.8の場合（新しいGPU向け）
+
+```
+uv run --extra cu128 --extra gui python src/musubi_tuner/gui/gui.py
+```
+
+**注意**：どのCUDAバージョンを使うか分からない場合は、まず`cu124`を試してください。
+
+起動後、GUIは以下のようなURLを表示します：
+```
+Running on local URL:  http://127.0.0.1:7860
+```
+
+このURLをWebブラウザで開いてGUIにアクセスします。
+
+**ヒント**：より簡単にGUIを起動するために、バッチファイル（`.bat`）を作成できます：
+
+1. `musubi-tuner`フォルダに`launch_gui.bat`というファイルを作成
+2. 以下の内容を追加：
+   ```batch
+   @echo off
+   cd /d "%~dp0"
+   uv run --extra cu124 --extra gui python src/musubi_tuner/gui/gui.py
+   pause
+   ```
+3. バッチファイルをダブルクリックしてGUIを起動
+
+---
+
+## 作業手順ガイド
+
+GUIは上から下へ、作業を完了すべき順序で配置されています。
+
+### ステップの概要
+
+1. **プロジェクト設定** - プロジェクトフォルダの作成または読み込み
+2. **モデル選択** - モデルアーキテクチャの選択とモデルパスの設定
+3. **データセット設定** - 学習解像度とバッチサイズの設定
+4. **前処理** - latentとtext encoderの事前キャッシュ
+5. **学習** - 学習パラメータの設定と学習の開始
+6. **後処理** - ComfyUI用にLoRAを変換（必要な場合）
+
+---
+
+### ステップ1：プロジェクト設定
+
+1. **Project Directory（プロジェクトディレクトリ）**：プロジェクトフォルダのフルパスを入力（例：`C:\MyProjects\my_lora_project`）
+2. **「Initialize / Load Project」** をクリック
+
+これにより：
+- プロジェクトフォルダが存在しない場合は作成されます
+- 学習画像用の`training`サブフォルダが作成されます
+- 以前使用したプロジェクトの場合、設定が読み込まれます
+
+**初期化後**、`training`フォルダに学習データを配置してください：
+- 画像ファイル（`.jpg`、`.png`など）
+- キャプションファイル（画像と同じファイル名で、拡張子は`.txt`）
+
+例：
+```
+my_lora_project/
+  training/
+    image001.jpg
+    image001.txt
+    image002.png
+    image002.txt
+```
+
+---
+
+### ステップ2：モデル選択
+
+1. **Model Architecture（モデルアーキテクチャ）**：学習したいモデルを選択
+   - `Z-Image-Turbo` - 高速な学習、BaseモデルがリリースされていないためLoRA学習がやや不安定
+   - `Qwen-Image` - より高品質、VRAMをより多く使用
+
+2. **VRAM Size（VRAMサイズ）**：GPUのVRAMサイズを選択
+   - バッチサイズやブロックスワップなどの推奨設定に影響します
+
+3. **ComfyUI Models Directory（ComfyUIモデルディレクトリ）**：ComfyUIの`models`フォルダのパスを入力
+   - 例：`C:\ComfyUI\models`
+   - このフォルダには`vae`、`text_encoders`、`diffusion_models`サブフォルダが含まれている必要があります
+   - 必要なモデルは[こちら](#使用するモデル一覧)を参考にしてください
+
+4. **「Validate ComfyUI Models Directory」** をクリックしてフォルダ構造を確認
+
+---
+
+### ステップ3：データセット設定
+
+1. **「Set Recommended Resolution & Batch Size」** をクリックして、選択したモデルとVRAMに応じた推奨値を自動入力
+2. 必要に応じて調整：
+   - **Resolution（解像度）Width/Height**：学習画像の解像度
+   - **Batch Size（バッチサイズ）**：一度に処理する画像数（大きいほど高速だがVRAMを多く使用）
+3. **「Generate Dataset Config」** をクリックして設定ファイルを作成
+
+生成された設定はボタン下のプレビューエリアに表示されます。
+
+---
+
+### ステップ4：前処理
+
+学習前に、latentとtext encoderの出力をキャッシュする必要があります。これにより、画像とキャプションがモデルが使用できる形式に変換されます。
+
+1. **「Set Default Paths」** をクリックして、ComfyUIディレクトリに基づいてモデルパスを自動入力
+2. パスが正しいことを確認：
+   - **VAE Path**：VAEモデルへのパス
+   - **Text Encoder 1 Path**：テキストエンコーダーモデルへのパス
+   - **Text Encoder 2 Path**：（一部のモデルのみ、空の場合もあります）
+
+3. **「Cache Latents」** をクリックして完了を待つ
+   - 画像をlatent空間にエンコードします
+   - ログ出力で進捗を確認できます
+
+4. **「Cache Text Encoder Outputs」** をクリックして完了を待つ
+   - キャプションをembeddingにエンコードします
+   - テキストエンコーダーの読み込みがあるため、初回は時間がかかる場合があります
+
+---
+
+### ステップ5：学習
+
+1. **「Set Recommended Parameters」** をクリックして、モデルとVRAMに応じた学習設定を自動入力
+
+2. **必須設定の確認**：
+   - **Base Model / DiT Path**：ベースとなるdiffusionモデル（DiT）へのパス（推奨ボタンをクリックすると自動入力）
+   - **Output Name**：LoRAファイルの名前（例：`my_character_lora`）
+
+3. **基本パラメータ**（デフォルト値を使用可能）：
+   - **LoRA Dim**：LoRAのランク/次元（4-32、大きいほど容量が増えるがファイルサイズも増加）
+   - **Learning Rate**：学習速度（デフォルト：1e-3 (0.001)、学習が不安定な場合は1e-4程度まで減少させることを推奨）
+   - **Epochs**：全画像での学習回数。デフォルトは画像数に基づいて調整されます。過学習になる場合は減少させてください。
+   - **Save Every N Epochs**：チェックポイントを保存する頻度
+
+4. **詳細パラメータ**（「Advanced Parameters」アコーディオンを展開）：
+   - **Discrete Flow Shift**：デノイジングのどのステップを重視するか（モデル固有のデフォルト値を使用することを推奨）
+   - **Block Swap**：モデルレイヤーをCPUにオフロード（VRAMが限られている場合に使用）
+   - **Mixed Precision**：精度モード（bf16推奨）
+   - **Gradient Checkpointing**：VRAM使用量を削減
+   - **FP8オプション**：さらなるメモリ最適化
+
+5. **サンプル画像生成**（オプション）：
+   - **「Generate sample images during training」** を有効にして進捗を確認
+   - 学習内容を表すサンプルプロンプトを入力
+   - サンプル画像のサイズと生成頻度を設定
+
+6. **「Start Training」** をクリックして開始
+   - 学習進捗を表示する新しいコマンドウィンドウが開きます
+   - 学習の進捗は新しいウィンドウに表示されます
+   - GUIには学習が開始されたことを確認するメッセージが表示されます
+
+---
+
+### ステップ6：後処理（オプション）
+
+Z-ImageのLoRAは、ComfyUIで使用するために変換が必要です。以下の手順に従ってください。
+
+1. **「Set Default Paths」** をクリックして、出力名に基づいてパスを自動入力
+2. パスを確認：
+   - **Input LoRA Path**：学習済みLoRAへのパス
+   - **Output ComfyUI LoRA Path**：変換後のLoRAの保存先
+3. **「Convert to ComfyUI Format」** をクリック
+
+---
+
+## 使用するモデル一覧
+
+### Z-Image-Turbo
+
+text-encodersとvaeモデルファイルは、[こちら](https://huggingface.co/Comfy-Org/z_image_turbo) の `split_files` 以下の適切なディレクトリからダウンロードしてください。
+
+| 種類 | モデルファイル |
+|----------------------|--------------|
+| diffusion-models        | safetensors ostris氏の[De-Turbo](https://huggingface.co/ostris/Z-Image-De-Turbo)から z_image_de_turbo_v1_bf16.safetensors を使用|
+| text-encoders       | qwen_3_4b.safetensors |
+| VAE                 | ae.safetensors |
+
+### Qwen-Image
+
+[こちら](https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI)の`split_files`以下の適切なディレクトリから必要なモデルファイルをダウンロードしてください。
+
+| 種類                | モデルファイル               |
+|----------------------|-----------------------------|
+| diffusion-models        | qwen_image_bf16.safetensors |
+| text-encoders       | qwen_2.5_vl_7b.safetensors |
+| VAE | qwen_image_vae.safetensors |
+
+---
+
+## 各項目の説明
+
+### プロジェクト設定
+
+| 項目 | 説明 |
+|------|------|
+| Project Directory | 学習プロジェクトのルートフォルダ。すべてのデータと出力がここに保存されます。 |
+
+### モデル設定
+
+| 項目 | 説明 |
+|------|------|
+| Model Architecture | LoRAを学習するベースモデル。Z-Image-Turboは高速、Qwen-Imageはより高品質。 |
+| VRAM Size | GPUのビデオメモリ。推奨バッチサイズやメモリ最適化設定に影響します。 |
+| ComfyUI Models Directory | 必要なモデルファイルが含まれるComfyUIの`models`フォルダへのパス。 |
+
+### データセット設定
+
+| 項目 | 説明 |
+|------|------|
+| Resolution (W/H) | 学習解像度。画像はこのサイズにリサイズ/クロップされます。 |
+| Batch Size | 同時に処理する画像数。大きいほど高速ですが、VRAMをより多く使用します。 |
+
+### 前処理
+
+| 項目 | 説明 |
+|------|------|
+| VAE Path | 画像をlatent空間にエンコードするVAEモデルファイルへのパス。 |
+| Text Encoder 1 Path | メインのテキストエンコーダーモデルへのパス。 |
+| Text Encoder 2 Path | セカンダリのテキストエンコーダーへのパス（モデルによって必要な場合）。 |
+
+### 学習パラメータ
+
+| 項目 | 説明 |
+|------|------|
+| Base Model / DiT Path | ベースとなるdiffusionモデル（DiT）へのパス。 |
+| Output Name | 保存されるLoRAファイルのベース名（拡張子なし）。 |
+| LoRA Dim | LoRAのランク/次元。大きいほど詳細をキャプチャできますが、ファイルサイズも増加。一般的な値：4、8、16、32。 |
+| Learning Rate | 学習速度。大きいほど速く学習しますが、オーバーシュートする可能性があります。デフォルト：1e-3（0.001）。 |
+| Epochs | 全学習画像を何回学習するか。 |
+| Save Every N Epochs | チェックポイントを保存する頻度。サンプル画像の生成頻度も制御します。 |
+| Discrete Flow Shift | 学習のダイナミクスに影響するflow matchingパラメータ。モデル固有のデフォルト値が推奨されます。 |
+| Block Swap | CPUにオフロードするtransformerブロック数。VRAMが限られている場合に使用。大きいほどVRAM使用量が減りますが、学習が遅くなります。 |
+| Mixed Precision | 浮動小数点精度。最新のGPUではbf16を推奨。 |
+| Gradient Checkpointing | 一部の値を再計算することでVRAM使用量を削減。やや遅くなりますが、メモリ使用量が減少。 |
+| FP8 Scaled | ベースモデルにFP8精度を使用。品質への影響を最小限に抑えてメモリを削減。 |
+| FP8 LLM | テキストエンコーダー（LLM）にFP8精度を使用。さらにメモリ使用量を削減。 |
+| Additional Arguments | 上級ユーザー向けの追加コマンドライン引数。 |
+
+### サンプル画像生成
+
+| 項目 | 説明 |
+|------|------|
+| Generate sample images | 学習中にサンプル画像を生成するかどうか。 |
+| Sample Prompt | サンプル画像を生成するために使用するテキストプロンプト。 |
+| Negative Prompt | サンプル画像で避けたい内容。 |
+| Sample Width/Height | サンプル画像の解像度。 |
+| Sample Every N Epochs | サンプルを生成する頻度。 |
+
+### 後処理
+
+| 項目 | 説明 |
+|------|------|
+| Input LoRA Path | 学習済みLoRAファイル（Musubi Tuner形式）へのパス。 |
+| Output ComfyUI LoRA Path | 変換後のLoRA（ComfyUI形式）の保存先。 |
+
+---
+
+## トラブルシューティング
+
+### 「Python is not recognized」と表示される
+- インストール時に「Add Python to PATH」にチェックを入れたか確認
+- このオプションを有効にしてPythonを再インストールしてみる
+- または、手動でPythonをシステムのPATHに追加
+
+### 「uv is not recognized」と表示される
+- uvをインストールした後、コマンドプロンプトを閉じて再度開く
+- インストールコマンドを再度実行してみる
+
+### CUDAエラーまたはメモリ不足
+- GUIでより小さいVRAMサイズを選択して、より控えめな設定を取得
+- Block Swapを有効にして一部の計算をCPUにオフロード
+- バッチサイズを1に減らす
+- FP8オプションを有効にしてさらにメモリを節約
+
+### 学習スクリプトがすぐエラーで終了する
+- エラーメッセージを確認
+- すべてのパスが正しいか確認
+- 前処理（Cache LatentsとCache Text Encoder）が正常に完了したか確認
+
+### 学習が遅い
+- Block Swapが有効な場合、学習は遅くなります（VRAMが限られている場合は想定内）
+- VRAMが不足し、共有VRAMが使用されると、パフォーマンスが大幅に低下します。fp8オプションの使用、Block Swapを大きくする、バッチサイズを減らすなど、メモリ使用量を減らす方法を試してください。
+- GPU（CPUではなく）を使用していることを確認
+- GPUドライバーが最新であることを確認
+
+### 「Model not found」エラー
+- ComfyUIモデルディレクトリが正しいか確認
+- 必要なモデルがダウンロードされているか確認
+- モデルのファイル名がGUIが期待するものと一致しているか確認（正確なファイル名はconfig_manager.pyを参照）
+
+### GUIが起動しない
+- 正しいディレクトリ（musubi-tunerフォルダ）にいることを確認
+- 正しいuvコマンドを使用していることを確認（CUDAバージョンに注意）
+
+---
+
+## プロジェクトフォルダの構造
+
+GUIを使用した後、プロジェクトフォルダは以下のようになります：
+
+```
+my_lora_project/
+  training/           # 学習画像とキャプション
+    image001.jpg
+    image001.txt
+    ...
+  cache/              # 前処理済みデータ（自動作成）
+    latent_cache/
+    text_encoder_cache/
+  models/             # 学習済みLoRAファイル（自動作成）
+    my_lora.safetensors
+    my_lora_comfy.safetensors
+    sample/           # 学習中に生成されたサンプル画像
+  logs/               # TensorBoardログ（自動作成）
+  dataset_config.toml # データセット設定（自動作成）
+  musubi_project.toml # GUIプロジェクト設定（自動作成）
+  sample_prompt.txt   # サンプルプロンプトファイル（有効時に自動作成）
+```
+
+---
+
+## 次のステップ
+
+LoRAを学習した後：
+
+1. ComfyUIで使用する必要がある場合（Z-ImageのLoRAは変換が必要）は、後処理セクションで変換
+2. 変換したLoRAをComfyUIの`models/loras`フォルダにコピー
+3. ComfyUIでLoRA loaderノードを使用して読み込み
+
+より高度な学習オプションやコマンドライン��の使用方法については、`docs`フォルダ内のMusubi Tunerのメインドキュメントを参照してください。

src/musubi_tuner/gui/gui.md

@@ -0,0 +1,444 @@
+[English](./gui.md) | [日本語](./gui.ja.md)
+
+# Musubi Tuner GUI - User Guide
+
+This guide will help you set up and use the Musubi Tuner GUI for training LoRA models with image generation architectures like Z-Image-Turbo and Qwen-Image.
+
+## Table of Contents
+
+1. [Prerequisites](#prerequisites)
+2. [Installing Required Software](#installing-required-software)
+3. [Installing Musubi Tuner](#installing-musubi-tuner)
+4. [Launching the GUI](#launching-the-gui)
+5. [Workflow Guide](#workflow-guide)
+6. [Field Descriptions](#field-descriptions)
+7. [Troubleshooting](#troubleshooting)
+
+---
+
+## Prerequisites
+
+Before you begin, make sure you have:
+
+- A Windows PC with an NVIDIA GPU (12GB+ VRAM recommended, 64GB+ VRAM + main RAM recommended)
+- Internet connection
+- ComfyUI installed with the required models (VAE, Text Encoder, DiT)
+
+---
+
+## Installing Required Software
+
+### Step 1: Install Python
+
+Musubi Tuner requires Python 3.10, 3.11, or 3.12. If you don't have it installed, follow these steps:
+
+1. Go to the official Python website: https://www.python.org/downloads/
+2. Download Python 3.10, 3.11, or 3.12 Windows 64-bit installer (we recommend **Python 3.12** for best compatibility)
+3. Run the installer
+4. **IMPORTANT**: Check the box that says **"Add Python to PATH"** before clicking "Install Now"
+5. Complete the installation
+
+**Verify installation**: Open Command Prompt (press `Win + R`, type `cmd`, press Enter) and run:
+```
+python --version
+```
+You should see something like `Python 3.12.x`.
+
+### Step 2: Install Git
+
+Git is needed to download the Musubi Tuner source code. If you don't have it installed, follow these steps:
+
+1. Go to the Git website: https://git-scm.com/downloads/win
+2. Download the Windows installer
+3. Run the installer with default settings (keep clicking "Next")
+4. Complete the installation
+
+**Verify installation**: In Command Prompt, run:
+```
+git --version
+```
+You should see something like `git version 2.x.x`.
+
+### Step 3: Install uv
+
+uv is a modern Python package manager that simplifies dependency management.
+
+1. Open Command Prompt as Administrator
+2. Run the following command:
+```
+powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+```
+3. **Close and reopen** Command Prompt (normal, non-administrator) for the changes to take effect
+
+**Verify installation**: In a new Command Prompt, run:
+```
+uv --version
+```
+You should see something like `uv 0.x.x`.
+
+---
+
+## Installing Musubi Tuner
+
+### Step 1: Download the Source Code
+
+1. Open Command Prompt
+2. Navigate to a folder where you want to install Musubi Tuner. For example:
+   ```
+   cd C:\Users\YourName\Documents
+   ```
+3. Clone the repository:
+   ```
+   git clone https://github.com/kohya-ss/musubi-tuner.git
+   ```
+4. Navigate into the folder:
+   ```
+   cd musubi-tuner
+   ```
+
+### Step 2: First-Time Setup (Automatic)
+
+The first time you run the GUI, uv will automatically download and install all required dependencies including PyTorch. This may take several minutes.
+
+---
+
+## Launching the GUI
+
+Open Command Prompt, navigate to the musubi-tuner folder, and run one of the following commands based on your CUDA version:
+
+### For CUDA 12.4 (Stable version)
+
+```
+uv run --extra cu124 --extra gui python src/musubi_tuner/gui/gui.py
+```
+
+### For CUDA 12.8 (Newer GPUs)
+
+```
+uv run --extra cu128 --extra gui python src/musubi_tuner/gui/gui.py
+```
+
+**Note**: If you're unsure which CUDA version to use, try `cu124` first.
+
+After launching, the GUI will start and display a URL like:
+```
+Running on local URL:  http://127.0.0.1:7860
+```
+
+Open this URL in your web browser to access the GUI.
+
+**Tip**: You can create a batch file (`.bat`) to launch the GUI more easily:
+
+1. Create a file named `launch_gui.bat` in the `musubi-tuner` folder
+2. Add the following content:
+   ```batch
+   @echo off
+   cd /d "%~dp0"
+   uv run --extra cu124 --extra gui python src/musubi_tuner/gui/gui.py
+   pause
+   ```
+3. Double-click the batch file to launch the GUI
+
+---
+
+## Workflow Guide
+
+The GUI is organized from top to bottom in the order you should complete each step.
+
+### Overview of Steps
+
+1. **Project Setup** - Create or open a project folder
+2. **Model Selection** - Choose the model architecture and set up model paths
+3. **Dataset Configuration** - Configure training resolution and batch size
+4. **Preprocessing** - Cache latents and text encoder outputs
+5. **Training** - Configure and start the training process
+6. **Post-Processing** - Convert LoRA for ComfyUI (if needed)
+
+---
+
+### Step 1: Project Setup
+
+1. **Project Directory**: Enter the full path to your project folder (e.g., `C:\MyProjects\my_lora_project`)
+2. Click **"Initialize / Load Project"**
+
+This will:
+- Create the project folder if it doesn't exist
+- Create a `training` subfolder for your training images
+- Load previous settings if the project was used before
+
+**After initialization**, place your training data in the `training` folder:
+- Image files (`.jpg`, `.png`, etc.)
+- Caption files (same filename as the image, but with `.txt` extension)
+
+Example:
+```
+my_lora_project/
+  training/
+    image001.jpg
+    image001.txt
+    image002.png
+    image002.txt
+```
+
+---
+
+### Step 2: Model Selection
+
+1. **Model Architecture**: Select the model you want to train
+   - `Z-Image-Turbo` - Faster training; LoRA training may be slightly unstable because the Base model is not released yet
+   - `Qwen-Image` - Higher quality, requires more VRAM
+
+2. **VRAM Size**: Select your GPU's VRAM size
+   - This affects recommended settings like batch size and block swap
+
+3. **ComfyUI Models Directory**: Enter the path to your ComfyUI `models` folder
+   - Example: `C:\ComfyUI\models`
+   - This folder should contain `vae`, `text_encoders`, and `diffusion_models` subfolders
+   - Required models can be found in the [Required Model Files](#required-model-files) section below
+
+4. Click **"Validate ComfyUI Models Directory"** to verify the folder structure
+
+---
+
+### Step 3: Dataset Configuration
+
+1. Click **"Set Recommended Resolution & Batch Size"** to auto-fill recommended values for your selected model and VRAM
+2. Adjust if needed:
+   - **Resolution (Width/Height)**: Training image resolution
+   - **Batch Size**: Number of images processed at once (higher = faster but more VRAM)
+3. Click **"Generate Dataset Config"** to create the configuration file
+
+The generated configuration will appear in the preview area below the button.
+
+---
+
+### Step 4: Preprocessing
+
+Before training, you need to cache the latents and text encoder outputs. This converts your images and captions into a format the model can use.
+
+1. Click **"Set Default Paths"** to auto-fill model paths based on your ComfyUI directory
+2. Verify the paths are correct:
+   - **VAE Path**: Path to the VAE model
+   - **Text Encoder 1 Path**: Path to the text encoder model
+   - **Text Encoder 2 Path**: (Only for some models, may be empty)
+
+3. Click **"Cache Latents"** and wait for it to complete
+   - This encodes your images into latent space
+   - Watch the log output for progress
+
+4. Click **"Cache Text Encoder Outputs"** and wait for it to complete
+   - This encodes your captions into embeddings
+   - This may take a while for the first run as the text encoder is loaded
+
+---
+
+### Step 5: Training
+
+1. Click **"Set Recommended Parameters"** to auto-fill training settings for your model and VRAM
+
+2. **Configure Required Settings**:
+   - **Base Model / DiT Path**: Path to the diffusion model (auto-filled if you click the recommended button)
+   - **Output Name**: Name for your LoRA file (e.g., `my_character_lora`)
+
+3. **Basic Parameters** (can use defaults):
+   - **LoRA Dim**: LoRA rank/dimension (4-32, higher = more capacity but larger file)
+   - **Learning Rate**: How fast the model learns (default: 1e-3 (0.001), can decrease if training is unstable)
+   - **Epochs**: Number of times to train on all images. Default is adjusted based on image count; reduce if overfitting occurs.
+   - **Save Every N Epochs**: How often to save checkpoints
+
+4. **Advanced Parameters** (expand "Advanced Parameters" accordion):
+   - **Discrete Flow Shift**: Which denoising step to emphasize (model-specific defaults recommended)
+   - **Block Swap**: Offloads model layers to CPU (use if VRAM is limited)
+   - **Mixed Precision**: Precision mode (bf16 recommended)
+   - **Gradient Checkpointing**: Reduces VRAM usage
+   - **FP8 options**: Further memory optimization
+
+5. **Sample Image Generation** (optional):
+   - Enable **"Generate sample images during training"** to see progress
+   - Enter a sample prompt that represents what you're training
+   - Set the sample image size and frequency
+
+6. Click **"Start Training"** to begin
+   - A new command window will open showing training progress
+   - Training progress is displayed in the new window
+   - The GUI will show a message confirming training has started
+
+---
+
+### Step 6: Post-Processing (Optional)
+
+Z-Image LoRAs need to be converted for use in ComfyUI. Follow these steps:
+
+1. Click **"Set Default Paths"** to auto-fill paths based on your output name
+2. Verify the paths:
+   - **Input LoRA Path**: Path to your trained LoRA
+   - **Output ComfyUI LoRA Path**: Where to save the converted LoRA
+3. Click **"Convert to ComfyUI Format"**
+
+---
+
+## Required Model Files
+
+### Z-Image-Turbo
+
+For text encoder and VAE model files, download them from the appropriate directory under `split_files` here: https://huggingface.co/Comfy-Org/z_image_turbo
+
+| Type | Model file |
+|------|------------|
+| diffusion-models | Use `z_image_de_turbo_v1_bf16.safetensors` from ostris's [De-Turbo](https://huggingface.co/ostris/Z-Image-De-Turbo) |
+| text-encoders | `qwen_3_4b.safetensors` |
+| VAE | `ae.safetensors` |
+
+### Qwen-Image
+
+Download the required model files from the appropriate directory under `split_files` here: https://huggingface.co/Comfy-Org/Qwen-Image_ComfyUI
+
+| Type | Model file |
+|------|------------|
+| diffusion-models | `qwen_image_bf16.safetensors` |
+| text-encoders | `qwen_2.5_vl_7b.safetensors` |
+| VAE | `qwen_image_vae.safetensors` |
+
+---
+
+## Field Descriptions
+
+### Project Settings
+
+| Field | Description |
+|-------|-------------|
+| Project Directory | Root folder for your training project. All data and outputs will be stored here. |
+
+### Model Settings
+
+| Field | Description |
+|-------|-------------|
+| Model Architecture | The base model to train a LoRA for. Z-Image-Turbo is faster; Qwen-Image produces higher quality. |
+| VRAM Size | Your GPU's video memory. Affects recommended batch size and memory optimization settings. |
+| ComfyUI Models Directory | Path to ComfyUI's `models` folder containing the required model files. |
+
+### Dataset Settings
+
+| Field | Description |
+|-------|-------------|
+| Resolution (W/H) | Training resolution. Images will be resized/cropped to this size. |
+| Batch Size | Number of images processed simultaneously. Higher values train faster but use more VRAM. |
+
+### Preprocessing
+
+| Field | Description |
+|-------|-------------|
+| VAE Path | Path to the VAE model file used to encode images into latent space. |
+| Text Encoder 1 Path | Path to the main text encoder model. |
+| Text Encoder 2 Path | Path to secondary text encoder (if required by the model). |
+
+### Training Parameters
+
+| Field | Description |
+|-------|-------------|
+| Base Model / DiT Path | Path to the base diffusion model (DiT). |
+| Output Name | Base name for saved LoRA files (without extension). |
+| LoRA Dim | LoRA rank/dimension. Higher values capture more detail but create larger files. Common values: 4, 8, 16, 32. |
+| Learning Rate | Speed of training. Higher = faster learning but may overshoot. Default: 1e-3 (0.001). |
+| Epochs | Number of complete passes through all training images. |
+| Save Every N Epochs | Frequency of checkpoint saves. Also controls sample image generation frequency. |
+| Discrete Flow Shift | Flow matching parameter that affects training dynamics. Model-specific defaults are recommended. |
+| Block Swap | Number of transformer blocks to offload to CPU. Use when VRAM is limited. Higher = less VRAM but slower. |
+| Mixed Precision | Floating-point precision. bf16 recommended for modern GPUs. |
+| Gradient Checkpointing | Reduces VRAM usage by recomputing some values. Slightly slower but uses less memory. |
+| FP8 Scaled | Use FP8 precision for the base model. Reduces memory with minimal quality loss. |
+| FP8 LLM | Use FP8 precision for the text encoder (LLM). Further reduces memory usage. |
+| Additional Arguments | Extra command-line arguments for advanced users. |
+
+### Sample Image Generation
+
+| Field | Description |
+|-------|-------------|
+| Generate sample images | Enable to generate sample images during training. |
+| Sample Prompt | Text prompt used to generate sample images. |
+| Negative Prompt | What to avoid in sample images. |
+| Sample Width/Height | Resolution for sample images. |
+| Sample Every N Epochs | How often to generate samples. |
+
+### Post-Processing
+
+| Field | Description |
+|-------|-------------|
+| Input LoRA Path | Path to the trained LoRA file (in Musubi Tuner format). |
+| Output ComfyUI LoRA Path | Where to save the converted LoRA (in ComfyUI format). |
+
+---
+
+## Troubleshooting
+
+### "Python is not recognized"
+- Make sure you checked "Add Python to PATH" during installation
+- Try reinstalling Python with this option enabled
+- Or manually add Python to your system PATH
+
+### "uv is not recognized"
+- Close and reopen Command Prompt after installing uv
+- Try running the installation command again
+
+### CUDA errors or out of memory
+- Select a smaller VRAM size in the GUI to get more conservative settings
+- Enable Block Swap to offload some computation to CPU
+- Reduce batch size to 1
+- Enable FP8 options for additional memory savings
+
+### Training script exits with errors immediately
+- Check the error message for clues
+- Check if all paths are correct
+- Make sure preprocessing (Cache Latents and Cache Text Encoder) completed successfully
+
+### Slow training
+- If Block Swap is enabled, training will be slower (this is expected when VRAM is limited)
+- If VRAM is insufficient and shared VRAM is being used, performance will degrade significantly. Try reducing memory usage by using FP8 options, increasing Block Swap, or lowering batch size.
+- Make sure you're using a GPU (not CPU)
+- Check that your GPU drivers are up to date
+
+### "Model not found" errors
+- Verify that your ComfyUI models directory is correct
+- Make sure you have downloaded the required models
+- Check that the model filenames match what the GUI expects (see config_manager.py for exact filenames)
+
+### GUI won't start
+- Make sure you're in the correct directory (musubi-tuner folder)
+- Make sure you're using the correct uv command (check your CUDA version)
+
+---
+
+## Project Folder Structure
+
+After using the GUI, your project folder will look like this:
+
+```
+my_lora_project/
+  training/           # Your training images and captions
+    image001.jpg
+    image001.txt
+    ...
+  cache/              # Preprocessed data (auto-created)
+    latent_cache/
+    text_encoder_cache/
+  models/             # Trained LoRA files (auto-created)
+    my_lora.safetensors
+    my_lora_comfy.safetensors
+    sample/           # Sample images generated during training
+  logs/               # TensorBoard logs (auto-created)
+  dataset_config.toml # Dataset configuration (auto-created)
+  musubi_project.toml # GUI Project settings (auto-created)
+  sample_prompt.txt   # Sample prompt file (auto-created if enabled)
+```
+
+---
+
+## Next Steps
+
+After training your LoRA:
+
+1. If you need to use it in ComfyUI (Z-Image LoRAs need conversion), convert it using the Post-Processing section
+2. Copy the converted LoRA to your ComfyUI `models/loras` folder
+3. Load it in ComfyUI using a LoRA loader node
+
+For more advanced training options and command-line usage, refer to the main Musubi Tuner documentation in the `docs` folder.

src/musubi_tuner/gui/gui.py

@@ -0,0 +1,1134 @@
+import glob
+import gradio as gr
+import os
+import toml
+from musubi_tuner.gui.config_manager import ConfigManager
+from musubi_tuner.gui.i18n_data import I18N_DATA
+
+config_manager = ConfigManager()
+
+
+i18n = gr.I18n(en=I18N_DATA["en"], ja=I18N_DATA["ja"])
+
+
+def construct_ui():
+    # I18N doesn't work for gr.Blocks title
+    # with gr.Blocks(title=i18n("app_title")) as demo:
+    with gr.Blocks(title="Musubi Tuner GUI") as demo:
+        gr.Markdown(i18n("app_header"))
+        gr.Markdown(i18n("app_desc"))
+
+        with gr.Accordion(i18n("acc_project"), open=True):
+            gr.Markdown(i18n("desc_project"))
+            with gr.Row():
+                project_dir = gr.Textbox(label=i18n("lbl_proj_dir"), placeholder=i18n("ph_proj_dir"), max_lines=1)
+
+            # Placeholder for project initialization or loading
+            init_btn = gr.Button(i18n("btn_init_project"))
+            project_status = gr.Markdown("")
+
+        with gr.Accordion(i18n("acc_model"), open=False):
+            gr.Markdown(i18n("desc_model"))
+            with gr.Row():
+                model_arch = gr.Dropdown(
+                    label=i18n("lbl_model_arch"),
+                    choices=[
+                        "Qwen-Image",
+                        "Z-Image-Turbo",
+                    ],
+                    value="Qwen-Image",
+                )
+                vram_size = gr.Dropdown(label=i18n("lbl_vram"), choices=["12", "16", "24", "32", ">32"], value="24")
+
+            with gr.Row():
+                comfy_models_dir = gr.Textbox(label=i18n("lbl_comfy_dir"), placeholder=i18n("ph_comfy_dir"), max_lines=1)
+
+            # Validation for ComfyUI models directory
+            models_status = gr.Markdown("")
+            validate_models_btn = gr.Button(i18n("btn_validate_models"))
+
+            # Placeholder for Dataset Settings (Step 3)
+            gr.Markdown(i18n("header_dataset"))
+            gr.Markdown(i18n("desc_dataset"))
+            with gr.Row():
+                set_rec_settings_btn = gr.Button(i18n("btn_rec_res_batch"))
+            with gr.Row():
+                resolution_w = gr.Number(label=i18n("lbl_res_w"), value=1024, precision=0)
+                resolution_h = gr.Number(label=i18n("lbl_res_h"), value=1024, precision=0)
+                batch_size = gr.Number(label=i18n("lbl_batch_size"), value=1, precision=0)
+
+            gen_toml_btn = gr.Button(i18n("btn_gen_config"))
+            dataset_status = gr.Markdown("")
+            toml_preview = gr.Code(label=i18n("lbl_toml_preview"), interactive=False)
+
+            def load_project_settings(project_path):
+                settings = {}
+                try:
+                    settings_path = os.path.join(project_path, "musubi_project.toml")
+                    if os.path.exists(settings_path):
+                        with open(settings_path, "r", encoding="utf-8") as f:
+                            settings = toml.load(f)
+                except Exception as e:
+                    print(f"Error loading project settings: {e}")
+                return settings
+
+            def load_dataset_config_content(project_path):
+                content = ""
+                try:
+                    config_path = os.path.join(project_path, "dataset_config.toml")
+                    if os.path.exists(config_path):
+                        with open(config_path, "r", encoding="utf-8") as f:
+                            content = f.read()
+                except Exception as e:
+                    print(f"Error reading dataset config: {e}")
+                return content
+
+            def save_project_settings(project_path, **kwargs):
+                try:
+                    # Load existing settings to support partial updates
+                    settings = load_project_settings(project_path)
+                    # Update with new values
+                    settings.update(kwargs)
+
+                    settings_path = os.path.join(project_path, "musubi_project.toml")
+                    with open(settings_path, "w", encoding="utf-8") as f:
+                        toml.dump(settings, f)
+                except Exception as e:
+                    print(f"Error saving project settings: {e}")
+
+            def init_project(path):
+                if not path:
+                    return (
+                        "Please enter a project directory path.",
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                    )
+                try:
+                    os.makedirs(os.path.join(path, "training"), exist_ok=True)
+
+                    # Load settings if available
+                    settings = load_project_settings(path)
+                    new_model = settings.get("model_arch", "Qwen-Image")
+                    new_vram = settings.get("vram_size", "16")
+                    new_comfy = settings.get("comfy_models_dir", "")
+                    new_w = settings.get("resolution_w", 1328)
+                    new_h = settings.get("resolution_h", 1328)
+                    new_batch = settings.get("batch_size", 1)
+                    new_vae = settings.get("vae_path", "")
+                    new_te1 = settings.get("text_encoder1_path", "")
+                    new_te2 = settings.get("text_encoder2_path", "")
+
+                    # Training params
+                    new_dit = settings.get("dit_path", "")
+                    new_out_nm = settings.get("output_name", "my_lora")
+                    new_dim = settings.get("network_dim", 4)
+                    new_lr = settings.get("learning_rate", 1e-4)
+                    new_epochs = settings.get("num_epochs", 16)
+                    new_save_n = settings.get("save_every_n_epochs", 1)
+                    new_flow = settings.get("discrete_flow_shift", 2.0)
+                    new_swap = settings.get("block_swap", 0)
+                    new_use_pinned_memory_for_block_swap = settings.get("use_pinned_memory_for_block_swap", False)
+                    new_prec = settings.get("mixed_precision", "bf16")
+                    new_grad_cp = settings.get("gradient_checkpointing", True)
+                    new_fp8_s = settings.get("fp8_scaled", True)
+                    new_fp8_l = settings.get("fp8_llm", True)
+                    new_add_args = settings.get("additional_args", "")
+
+                    # Sample image params
+                    new_sample_enable = settings.get("sample_images", False)
+                    new_sample_every_n = settings.get("sample_every_n_epochs", 1)
+                    new_sample_prompt = settings.get("sample_prompt", "")
+                    new_sample_negative = settings.get("sample_negative_prompt", "")
+                    new_sample_w = settings.get("sample_w", new_w)
+                    new_sample_h = settings.get("sample_h", new_h)
+
+                    # Post-processing params
+                    new_in_lora = settings.get("input_lora_path", "")
+                    new_out_comfy = settings.get("output_comfy_lora_path", "")
+
+                    # Load dataset config content
+                    preview_content = load_dataset_config_content(path)
+
+                    msg = f"Project initialized at {path}. "
+                    if settings:
+                        msg += " Settings loaded."
+                    msg += " 'training' folder ready. Configure the dataset in the 'training' folder. Images and caption files (same name as image, extension is '.txt') should be placed in the 'training' folder."
+                    msg += "\n\nプロジェクトが初期化されました。"
+                    if settings:
+                        msg += "設定が読み込まれました。"
+                    msg += "'training' フォルダが準備されました。画像とキャプションファイル（画像と同じファイル名で拡張子は '.txt'）を配置してください。"
+
+                    return (
+                        msg,
+                        new_model,
+                        new_vram,
+                        new_comfy,
+                        new_w,
+                        new_h,
+                        new_batch,
+                        preview_content,
+                        new_vae,
+                        new_te1,
+                        new_te2,
+                        new_dit,
+                        new_out_nm,
+                        new_dim,
+                        new_lr,
+                        new_epochs,
+                        new_save_n,
+                        new_flow,
+                        new_swap,
+                        new_use_pinned_memory_for_block_swap,
+                        new_prec,
+                        new_grad_cp,
+                        new_fp8_s,
+                        new_fp8_l,
+                        new_add_args,
+                        new_sample_enable,
+                        new_sample_every_n,
+                        new_sample_prompt,
+                        new_sample_negative,
+                        new_sample_w,
+                        new_sample_h,
+                        new_in_lora,
+                        new_out_comfy,
+                    )
+                except Exception as e:
+                    return (
+                        f"Error initializing project: {str(e)}",
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                        gr.update(),
+                    )
+
+            def generate_config(project_path, w, h, batch, model_val, vram_val, comfy_val, vae_val, te1_val, te2_val):
+                if not project_path:
+                    return "Error: Project directory not specified.\nエラー: プロジェクトディレクトリが指定されていません。", ""
+
+                # Save project settings first
+                save_project_settings(
+                    project_path,
+                    model_arch=model_val,
+                    vram_size=vram_val,
+                    comfy_models_dir=comfy_val,
+                    resolution_w=w,
+                    resolution_h=h,
+                    batch_size=batch,
+                    vae_path=vae_val,
+                    text_encoder1_path=te1_val,
+                    text_encoder2_path=te2_val,
+                )
+
+                # Normalize paths
+                project_path = os.path.abspath(project_path)
+                image_dir = os.path.join(project_path, "training").replace("\\", "/")
+                cache_dir = os.path.join(project_path, "cache").replace("\\", "/")
+
+                toml_content = f"""# Auto-generated by Musubi Tuner GUI
+
+[general]
+resolution = [{int(w)}, {int(h)}]
+caption_extension = ".txt"
+batch_size = {int(batch)}
+enable_bucket = true
+bucket_no_upscale = false
+
+[[datasets]]
+image_directory = "{image_dir}"
+cache_directory = "{cache_dir}"
+num_repeats = 1
+"""
+                try:
+                    config_path = os.path.join(project_path, "dataset_config.toml")
+                    with open(config_path, "w", encoding="utf-8") as f:
+                        f.write(toml_content)
+                    return f"Successfully generated config at / 設定ファイルが作成されました: {config_path}", toml_content
+                except Exception as e:
+                    return f"Error generating config / 設定ファイルの生成に失敗しました: {str(e)}", ""
+
+        with gr.Accordion(i18n("acc_preprocessing"), open=False):
+            gr.Markdown(i18n("desc_preprocessing"))
+            with gr.Row():
+                set_preprocessing_defaults_btn = gr.Button(i18n("btn_set_paths"))
+            with gr.Row():
+                vae_path = gr.Textbox(label=i18n("lbl_vae_path"), placeholder=i18n("ph_vae_path"), max_lines=1)
+                text_encoder1_path = gr.Textbox(label=i18n("lbl_te1_path"), placeholder=i18n("ph_te1_path"), max_lines=1)
+                text_encoder2_path = gr.Textbox(label=i18n("lbl_te2_path"), placeholder=i18n("ph_te2_path"), max_lines=1)
+
+            with gr.Row():
+                cache_latents_btn = gr.Button(i18n("btn_cache_latents"))
+                cache_text_btn = gr.Button(i18n("btn_cache_text"))
+
+            # Simple output area for caching logs
+            caching_output = gr.Textbox(label=i18n("lbl_cache_log"), lines=10, interactive=False)
+
+            def validate_models_dir(path):
+                if not path:
+                    return "Please enter a ComfyUI models directory. / ComfyUIのmodelsディレクトリを入力してください。"
+
+                required_subdirs = ["diffusion_models", "vae", "text_encoders"]
+                missing = []
+                for d in required_subdirs:
+                    if not os.path.exists(os.path.join(path, d)):
+                        missing.append(d)
+
+                if missing:
+                    return f"Error: Missing subdirectories in models folder / modelsフォルダに以下のサブディレクトリ��見つかりません: {', '.join(missing)}"
+
+                return "Valid ComfyUI models directory structure found / 有効なComfyUI modelsディレクトリ構造が見つかりました。"
+
+            def set_recommended_settings(project_path, model_arch, vram_val):
+                w, h = config_manager.get_resolution(model_arch)
+                recommended_batch_size = config_manager.get_batch_size(model_arch, vram_val)
+
+                if project_path:
+                    save_project_settings(project_path, resolution_w=w, resolution_h=h, batch_size=recommended_batch_size)
+                return w, h, recommended_batch_size
+
+            def set_preprocessing_defaults(project_path, comfy_models_dir, model_arch):
+                if not comfy_models_dir:
+                    return gr.update(), gr.update(), gr.update()
+
+                vae_default, te1_default, te2_default = config_manager.get_preprocessing_paths(model_arch, comfy_models_dir)
+                if not te2_default:
+                    te2_default = ""  # Ensure empty string for text input
+
+                if project_path:
+                    save_project_settings(
+                        project_path, vae_path=vae_default, text_encoder1_path=te1_default, text_encoder2_path=te2_default
+                    )
+
+                return vae_default, te1_default, te2_default
+
+            def set_training_defaults(project_path, comfy_models_dir, model_arch, vram_val):
+                # Get number of images from project_path to adjust num_epochs later
+                cache_dir = os.path.join(project_path, "cache")
+                pattern = "*" + ("_qi" if model_arch == "Qwen-Image" else "_zi") + ".safetensors"
+                num_images = len(glob.glob(os.path.join(cache_dir, pattern))) if os.path.exists(cache_dir) else 0
+
+                # Get training defaults from config manager
+                defaults = config_manager.get_training_defaults(model_arch, vram_val, comfy_models_dir)
+
+                # Adjust num_epochs based on number of images (simple heuristic)
+                default_num_steps = defaults.get("default_num_steps", 1000)
+                if num_images > 0:
+                    adjusted_epochs = max(1, int((default_num_steps / num_images)))
+                else:
+                    adjusted_epochs = 16  # Fallback default
+                sample_every_n_epochs = (adjusted_epochs // 4) if adjusted_epochs >= 4 else 1
+
+                dit_default = defaults.get("dit_path", "")
+                dim = defaults.get("network_dim", 4)
+                lr = defaults.get("learning_rate", 1e-4)
+                epochs = adjusted_epochs
+                save_n = defaults.get("save_every_n_epochs", 1)
+                flow = defaults.get("discrete_flow_shift", 2.0)
+                swap = defaults.get("block_swap", 0)
+                use_pinned_memory_for_block_swap = defaults.get("use_pinned_memory_for_block_swap", False)
+                prec = defaults.get("mixed_precision", "bf16")
+                grad_cp = defaults.get("gradient_checkpointing", True)
+                fp8_s = defaults.get("fp8_scaled", True)
+                fp8_l = defaults.get("fp8_llm", True)
+
+                sample_w_default, sample_h_default = config_manager.get_resolution(model_arch)
+
+                if project_path:
+                    save_project_settings(
+                        project_path,
+                        dit_path=dit_default,
+                        network_dim=dim,
+                        learning_rate=lr,
+                        num_epochs=epochs,
+                        save_every_n_epochs=save_n,
+                        discrete_flow_shift=flow,
+                        block_swap=swap,
+                        use_pinned_memory_for_block_swap=use_pinned_memory_for_block_swap,
+                        mixed_precision=prec,
+                        gradient_checkpointing=grad_cp,
+                        fp8_scaled=fp8_s,
+                        fp8_llm=fp8_l,
+                        vram_size=vram_val,  # Ensure VRAM size is saved
+                        sample_every_n_epochs=sample_every_n_epochs,
+                        sample_w=sample_w_default,
+                        sample_h=sample_h_default,
+                    )
+
+                return (
+                    dit_default,
+                    dim,
+                    lr,
+                    epochs,
+                    save_n,
+                    flow,
+                    swap,
+                    use_pinned_memory_for_block_swap,
+                    prec,
+                    grad_cp,
+                    fp8_s,
+                    fp8_l,
+                    sample_every_n_epochs,
+                    sample_w_default,
+                    sample_h_default,
+                )
+
+            def set_post_processing_defaults(project_path, output_nm):
+                if not project_path or not output_nm:
+                    return gr.update(), gr.update()
+
+                models_dir = os.path.join(project_path, "models")
+                in_lora = os.path.join(models_dir, f"{output_nm}.safetensors")
+                out_lora = os.path.join(models_dir, f"{output_nm}_comfy.safetensors")
+
+                save_project_settings(project_path, input_lora_path=in_lora, output_comfy_lora_path=out_lora)
+
+                return in_lora, out_lora
+
+            import subprocess
+            import sys
+
+            def run_command(command):
+                try:
+                    process = subprocess.Popen(
+                        command,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.STDOUT,
+                        shell=True,
+                        text=True,
+                        encoding="utf-8",
+                        creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
+                    )
+
+                    output_log = command + "\n\n"
+                    for line in process.stdout:
+                        output_log += line
+                        yield output_log
+
+                    process.wait()
+                    if process.returncode != 0:
+                        output_log += (
+                            f"\nError: Process exited with code / プロセスが次のコードでエラー終了しました: {process.returncode}"
+                        )
+                        yield output_log
+                    else:
+                        output_log += "\nProcess completed successfully / プロセスが正常に完了しました"
+                        yield output_log
+
+                except Exception as e:
+                    yield f"Error executing command / コマンドの実行中にエラーが発生しました: {str(e)}"
+
+            def cache_latents(project_path, vae_path_val, te1, te2, model, comfy, w, h, batch, vram_val):
+                if not project_path:
+                    yield "Error: Project directory not set. / プロジェクトディレクトリが設定されていません。"
+                    return
+
+                # Save settings first
+                save_project_settings(
+                    project_path,
+                    model_arch=model,
+                    comfy_models_dir=comfy,
+                    resolution_w=w,
+                    resolution_h=h,
+                    batch_size=batch,
+                    vae_path=vae_path_val,
+                    text_encoder1_path=te1,
+                    text_encoder2_path=te2,
+                )
+
+                if not vae_path_val:
+                    yield "Error: VAE path not set. / VAEのパスが設定されていません。"
+                    return
+
+                if not os.path.exists(vae_path_val):
+                    yield f"Error: VAE model not found at / 指定されたパスにVAEモデルが見つかりません: {vae_path_val}"
+                    return
+
+                config_path = os.path.join(project_path, "dataset_config.toml")
+                if not os.path.exists(config_path):
+                    yield f"Error: dataset_config.toml not found in {project_path}. Please generate it first. / dataset_config.tomlが {project_path} に見つかりません。先に設定ファイルを生成してください。"
+                    return
+
+                script_name = "zimage_cache_latents.py"
+                if model == "Qwen-Image":
+                    script_name = "qwen_image_cache_latents.py"
+
+                script_path = os.path.join("src", "musubi_tuner", script_name)
+
+                cmd = [sys.executable, script_path, "--dataset_config", config_path, "--vae", vae_path_val]
+
+                # Placeholder for argument modification
+                if model == "Z-Image-Turbo":
+                    pass
+                elif model == "Qwen-Image":
+                    pass
+
+                command_str = " ".join(cmd)
+                yield f"Starting Latent Caching. Please wait for the first log to appear. / Latentのキャッシュを開始します。最初のログが表示されるまでにしばらくかかります。\nCommand: {command_str}\n\n"
+
+                yield from run_command(command_str)
+
+            def cache_text_encoder(project_path, te1_path_val, te2_path_val, vae, model, comfy, w, h, batch, vram_val):
+                if not project_path:
+                    yield "Error: Project directory not set. / プロジェクトディレクトリが設定されていません。"
+                    return
+
+                # Save settings first
+                save_project_settings(
+                    project_path,
+                    model_arch=model,
+                    comfy_models_dir=comfy,
+                    resolution_w=w,
+                    resolution_h=h,
+                    batch_size=batch,
+                    vae_path=vae,
+                    text_encoder1_path=te1_path_val,
+                    text_encoder2_path=te2_path_val,
+                )
+
+                if not te1_path_val:
+                    yield "Error: Text Encoder 1 path not set. / Text Encoder 1のパスが設定されていません。"
+                    return
+
+                if not os.path.exists(te1_path_val):
+                    yield f"Error: Text Encoder 1 model not found at / 指定されたパスにText Encoder 1モデルが見つかりません: {te1_path_val}"
+                    return
+
+                # Z-Image only uses te1 for now, but keeping te2 in signature if needed later or for other models
+
+                config_path = os.path.join(project_path, "dataset_config.toml")
+                if not os.path.exists(config_path):
+                    yield f"Error: dataset_config.toml not found in {project_path}. Please generate it first. / dataset_config.tomlが {project_path} に見つかりません。先に設定ファイルを生成してください。"
+                    return
+
+                script_name = "zimage_cache_text_encoder_outputs.py"
+                if model == "Qwen-Image":
+                    script_name = "qwen_image_cache_text_encoder_outputs.py"
+
+                script_path = os.path.join("src", "musubi_tuner", script_name)
+
+                cmd = [
+                    sys.executable,
+                    script_path,
+                    "--dataset_config",
+                    config_path,
+                    "--text_encoder",
+                    te1_path_val,
+                    "--batch_size",
+                    "1",  # Conservative default
+                ]
+
+                # Model-specific argument modification
+                if model == "Z-Image-Turbo":
+                    pass
+                elif model == "Qwen-Image":
+                    # Add --fp8_vl for low VRAM (16GB or less)
+                    if vram_val in ["12", "16"]:
+                        cmd.append("--fp8_vl")
+
+                command_str = " ".join(cmd)
+                yield f"Starting Text Encoder Caching. Please wait for the first log to appear. / Text Encoderのキャッシュを開始します。最初のログが表示されるまでにしばらくかかります。\nCommand: {command_str}\n\n"
+
+                yield from run_command(command_str)
+
+        with gr.Accordion(i18n("acc_training"), open=False):
+            gr.Markdown(i18n("desc_training_basic"))
+            training_model_info = gr.Markdown(i18n("desc_training_zimage"))
+
+            with gr.Row():
+                set_training_defaults_btn = gr.Button(i18n("btn_rec_params"))
+            with gr.Row():
+                dit_path = gr.Textbox(label=i18n("lbl_dit_path"), placeholder=i18n("ph_dit_path"), max_lines=1)
+
+            with gr.Row():
+                output_name = gr.Textbox(label=i18n("lbl_output_name"), value="my_lora", max_lines=1)
+
+            with gr.Group():
+                gr.Markdown(i18n("header_basic_params"))
+                with gr.Row():
+                    network_dim = gr.Number(label=i18n("lbl_dim"), value=4)
+                    learning_rate = gr.Number(label=i18n("lbl_lr"), value=1e-4)
+                    num_epochs = gr.Number(label=i18n("lbl_epochs"), value=16)
+                    save_every_n_epochs = gr.Number(label=i18n("lbl_save_every"), value=1)
+
+            with gr.Group():
+                with gr.Row():
+                    discrete_flow_shift = gr.Number(label=i18n("lbl_flow_shift"), value=2.0)
+                    block_swap = gr.Slider(label=i18n("lbl_block_swap"), minimum=0, maximum=60, step=1, value=0)
+                    use_pinned_memory_for_block_swap = gr.Checkbox(
+                        label=i18n("lbl_use_pinned_memory_for_block_swap"),
+                        value=False,
+                    )
+
+                with gr.Accordion(i18n("accordion_advanced"), open=False):
+                    gr.Markdown(i18n("desc_training_detailed"))
+
+                with gr.Row():
+                    mixed_precision = gr.Dropdown(label=i18n("lbl_mixed_precision"), choices=["bf16", "fp16", "no"], value="bf16")
+                    gradient_checkpointing = gr.Checkbox(label=i18n("lbl_grad_cp"), value=True)
+
+                with gr.Row():
+                    fp8_scaled = gr.Checkbox(label=i18n("lbl_fp8_scaled"), value=True)
+                    fp8_llm = gr.Checkbox(label=i18n("lbl_fp8_llm"), value=True)
+
+            with gr.Group():
+                gr.Markdown(i18n("header_sample_images"))
+                sample_images = gr.Checkbox(label=i18n("lbl_enable_sample"), value=False)
+                with gr.Row():
+                    sample_prompt = gr.Textbox(label=i18n("lbl_sample_prompt"), placeholder=i18n("ph_sample_prompt"))
+                with gr.Row():
+                    sample_negative_prompt = gr.Textbox(
+                        label=i18n("lbl_sample_negative_prompt"),
+                        placeholder=i18n("ph_sample_negative_prompt"),
+                    )
+                with gr.Row():
+                    sample_w = gr.Number(label=i18n("lbl_sample_w"), value=1024, precision=0)
+                    sample_h = gr.Number(label=i18n("lbl_sample_h"), value=1024, precision=0)
+                    sample_every_n = gr.Number(label=i18n("lbl_sample_every_n"), value=1, precision=0)
+
+            with gr.Accordion(i18n("accordion_additional"), open=False):
+                gr.Markdown(i18n("desc_additional_args"))
+                additional_args = gr.Textbox(label=i18n("lbl_additional_args"), placeholder=i18n("ph_additional_args"))
+
+            training_status = gr.Markdown("")
+            start_training_btn = gr.Button(i18n("btn_start_training"), variant="primary")
+
+        with gr.Accordion(i18n("acc_post_processing"), open=False):
+            gr.Markdown(i18n("desc_post_proc"))
+            with gr.Row():
+                set_post_proc_defaults_btn = gr.Button(i18n("btn_set_paths"))
+            with gr.Row():
+                input_lora = gr.Textbox(label=i18n("lbl_input_lora"), placeholder=i18n("ph_input_lora"), max_lines=1)
+                output_comfy_lora = gr.Textbox(label=i18n("lbl_output_comfy"), placeholder=i18n("ph_output_comfy"), max_lines=1)
+
+            convert_btn = gr.Button(i18n("btn_convert"))
+            conversion_log = gr.Textbox(label=i18n("lbl_conversion_log"), lines=5, interactive=False)
+
+        def convert_lora_to_comfy(project_path, input_path, output_path, model, comfy, w, h, batch, vae, te1, te2):
+            if not project_path:
+                yield "Error: Project directory not set. / プロジェクトディレクトリが設定されていません。"
+                return
+
+            # Save settings
+            save_project_settings(
+                project_path,
+                model_arch=model,
+                comfy_models_dir=comfy,
+                resolution_w=w,
+                resolution_h=h,
+                batch_size=batch,
+                vae_path=vae,
+                text_encoder1_path=te1,
+                text_encoder2_path=te2,
+                input_lora_path=input_path,
+                output_comfy_lora_path=output_path,
+            )
+
+            if not input_path or not output_path:
+                yield "Error: Input and Output paths must be specified. / 入力・出力パスを指定してください。"
+                return
+
+            if not os.path.exists(input_path):
+                yield f"Error: Input file not found at {input_path} / 入力ファイルが見つかりません: {input_path}"
+                return
+
+            # Script path
+            script_path = os.path.join("src", "musubi_tuner", "networks", "convert_z_image_lora_to_comfy.py")
+            if not os.path.exists(script_path):
+                yield f"Error: Conversion script not found at {script_path} / 変換スクリプトが見つかりません: {script_path}"
+                return
+
+            cmd = [sys.executable, script_path, input_path, output_path]
+
+            command_str = " ".join(cmd)
+            yield f"Starting Conversion. / 変換を開始します。\nCommand: {command_str}\n\n"
+
+            yield from run_command(command_str)
+
+        def start_training(
+            project_path,
+            model,
+            dit,
+            vae,
+            te1,
+            output_nm,
+            dim,
+            lr,
+            epochs,
+            save_n,
+            flow_shift,
+            swap,
+            use_pinned_memory_for_block_swap,
+            prec,
+            grad_cp,
+            fp8_s,
+            fp8_l,
+            add_args,
+            should_sample_images,
+            sample_every_n,
+            sample_prompt_val,
+            sample_negative_prompt_val,
+            sample_w_val,
+            sample_h_val,
+        ):
+            import shlex
+
+            if not project_path:
+                return "Error: Project directory not set. / プロジェクトディレクトリが設定されていません。"
+            if not dit:
+                return "Error: Base Model / DiT Path not set. / Base Model / DiTのパスが設定されていません。"
+            if not os.path.exists(dit):
+                return f"Error: Base Model / DiT file not found at {dit} / Base Model / DiTファイルが見つかりません: {dit}"
+            if not vae:
+                return "Error: VAE Path not set (configure in Preprocessing). / VAEのパスが設定されていません (Preprocessingで設定してください)。"
+            if not te1:
+                return "Error: Text Encoder 1 Path not set (configure in Preprocessing). / Text Encoder 1のパスが設定されていません (Preprocessingで設定してください)。"
+
+            dataset_config = os.path.join(project_path, "dataset_config.toml")
+            if not os.path.exists(dataset_config):
+                return "Error: dataset_config.toml not found. Please generate it. / dataset_config.toml が見つかりません。生成してください。"
+
+            output_dir = os.path.join(project_path, "models")
+            logging_dir = os.path.join(project_path, "logs")
+
+            # Save settings
+            save_project_settings(
+                project_path,
+                dit_path=dit,
+                output_name=output_nm,
+                network_dim=dim,
+                learning_rate=lr,
+                num_epochs=epochs,
+                save_every_n_epochs=save_n,
+                discrete_flow_shift=flow_shift,
+                block_swap=swap,
+                use_pinned_memory_for_block_swap=use_pinned_memory_for_block_swap,
+                mixed_precision=prec,
+                gradient_checkpointing=grad_cp,
+                fp8_scaled=fp8_s,
+                fp8_llm=fp8_l,
+                vae_path=vae,
+                text_encoder1_path=te1,
+                additional_args=add_args,
+                sample_images=should_sample_images,
+                sample_every_n_epochs=sample_every_n,
+                sample_prompt=sample_prompt_val,
+                sample_negative_prompt=sample_negative_prompt_val,
+                sample_w=sample_w_val,
+                sample_h=sample_h_val,
+            )
+
+            # Model specific command modification
+            if model == "Z-Image-Turbo":
+                arch_name = "zimage"
+            elif model == "Qwen-Image":
+                arch_name = "qwen_image"
+
+            # Construct command for cmd /c to run and then pause
+            # We assume 'accelerate' is in the PATH.
+            script_path = os.path.join("src", "musubi_tuner", f"{arch_name}_train_network.py")
+
+            # Inner command list - arguments for accelerate launch
+            inner_cmd = [
+                "accelerate",
+                "launch",
+                # accelerate args: we don't configure default_config.yaml, so we need to specify all here
+                "--num_cpu_threads_per_process",
+                "1",
+                "--mixed_precision",
+                prec,
+                "--dynamo_backend=no",
+                "--gpu_ids",
+                "all",
+                "--machine_rank",
+                "0",
+                "--main_training_function",
+                "main",
+                "--num_machines",
+                "1",
+                "--num_processes",
+                "1",
+                # script and its args
+                script_path,
+                "--dit",
+                dit,
+                "--vae",
+                vae,
+                "--text_encoder",
+                te1,
+                "--dataset_config",
+                dataset_config,
+                "--output_dir",
+                output_dir,
+                "--output_name",
+                output_nm,
+                "--network_module",
+                f"networks.lora_{arch_name}",
+                "--network_dim",
+                str(int(dim)),
+                "--optimizer_type",
+                "adamw8bit",
+                "--learning_rate",
+                str(lr),
+                "--max_train_epochs",
+                str(int(epochs)),
+                "--save_every_n_epochs",
+                str(int(save_n)),
+                "--timestep_sampling",
+                "shift",
+                "--weighting_scheme",
+                "none",
+                "--discrete_flow_shift",
+                str(flow_shift),
+                "--max_data_loader_n_workers",
+                "2",
+                "--persistent_data_loader_workers",
+                "--seed",
+                "42",
+                "--logging_dir",
+                logging_dir,
+                "--log_with",
+                "tensorboard",
+            ]
+
+            # Sample image generation options
+            if should_sample_images:
+                sample_prompt_path = os.path.join(project_path, "sample_prompt.txt")
+                templates = {
+                    # prompt, negative prompt, width, height, flow shift, steps, CFG scale, seed
+                    "Qwen-Image": "{prompt} --n {neg} --w {w} --h {h} --fs 2.2 --s 20 --l 4.0 --d 1234",
+                    "Z-Image-Turbo": "{prompt} --n {neg} --w {w} --h {h} --fs 3.0 --s 20 --l 5.0 --d 1234",
+                }
+                template = templates.get(model, templates["Z-Image-Turbo"])
+                prompt_str = (sample_prompt_val or "").replace("\n", " ").strip()
+                neg_str = (sample_negative_prompt_val or "").replace("\n", " ").strip()
+                try:
+                    w_int = int(sample_w_val)
+                    h_int = int(sample_h_val)
+                except Exception:
+                    return "Error: Sample width/height must be integers. / サンプル画像の幅と高さは整数で指定してください。"
+
+                line = template.format(prompt=prompt_str, neg=neg_str, w=w_int, h=h_int)
+                try:
+                    with open(sample_prompt_path, "w", encoding="utf-8") as f:
+                        f.write(line + "\n")
+                except Exception as e:
+                    return f"Error writing sample_prompt.txt / sample_prompt.txt の作成に失敗しました: {str(e)}"
+
+                inner_cmd.extend(
+                    [
+                        "--sample_prompts",
+                        sample_prompt_path,
+                        "--sample_at_first",
+                        "--sample_every_n_epochs",
+                        str(int(sample_every_n)),
+                    ]
+                )
+
+            if prec != "no":
+                inner_cmd.extend(["--mixed_precision", prec])
+
+            if grad_cp:
+                inner_cmd.append("--gradient_checkpointing")
+
+            if fp8_s:
+                inner_cmd.append("--fp8_base")
+                inner_cmd.append("--fp8_scaled")
+
+            if fp8_l:
+                if model == "Z-Image-Turbo":
+                    inner_cmd.append("--fp8_llm")
+                elif model == "Qwen-Image":
+                    inner_cmd.append("--fp8_vl")
+
+            if swap > 0:
+                inner_cmd.extend(["--blocks_to_swap", str(int(swap))])
+                if use_pinned_memory_for_block_swap:
+                    inner_cmd.append("--use_pinned_memory_for_block_swap")
+
+            inner_cmd.append("--sdpa")
+            inner_cmd.append("--split_attn")
+
+            # Model specific command modification
+            if model == "Z-Image-Turbo":
+                pass
+            elif model == "Qwen-Image":
+                pass
+
+            # Parse and append additional args
+            if add_args:
+                try:
+                    split_args = shlex.split(add_args)
+                    inner_cmd.extend(split_args)
+                except Exception as e:
+                    return f"Error parsing additional arguments / 追加引数の解析に失敗しました: {str(e)}"
+
+            # Construct the full command string for cmd /c
+            # list2cmdline will quote arguments as needed for Windows
+            inner_cmd_str = subprocess.list2cmdline(inner_cmd)
+
+            # Chain commands: Run training -> echo message -> pause >nul (hides default message)
+            final_cmd_str = f"{inner_cmd_str} & echo. & echo Training finished. Press any key to close this window... 学習が完了しました。このウィンドウを閉じるには任意のキーを押してください。 & pause >nul"
+
+            try:
+                # Open in new console window
+                flags = subprocess.CREATE_NEW_CONSOLE if os.name == "nt" else 0
+                # Pass explicit 'cmd', '/c', string to ensure proper execution
+                subprocess.Popen(["cmd", "/c", final_cmd_str], creationflags=flags, shell=False)
+                return f"Training started in a new window! / 新しいウィンドウで学習が開始されました！\nCommand: {inner_cmd_str}"
+            except Exception as e:
+                return f"Error starting training / 学習の開始に失敗しました: {str(e)}"
+
+        def update_model_info(model):
+            if model == "Z-Image-Turbo":
+                return i18n("desc_training_zimage")
+            elif model == "Qwen-Image":
+                return i18n("desc_qwen_notes")
+            return ""
+
+        # Event wiring moved to end to prevent UnboundLocalError
+        init_btn.click(
+            fn=init_project,
+            inputs=[project_dir],
+            outputs=[
+                project_status,
+                model_arch,
+                vram_size,
+                comfy_models_dir,
+                resolution_w,
+                resolution_h,
+                batch_size,
+                toml_preview,
+                vae_path,
+                text_encoder1_path,
+                text_encoder2_path,
+                dit_path,
+                output_name,
+                network_dim,
+                learning_rate,
+                num_epochs,
+                save_every_n_epochs,
+                discrete_flow_shift,
+                block_swap,
+                use_pinned_memory_for_block_swap,
+                mixed_precision,
+                gradient_checkpointing,
+                fp8_scaled,
+                fp8_llm,
+                additional_args,
+                sample_images,
+                sample_every_n,
+                sample_prompt,
+                sample_negative_prompt,
+                sample_w,
+                sample_h,
+                input_lora,
+                output_comfy_lora,
+            ],
+        )
+
+        model_arch.change(fn=update_model_info, inputs=[model_arch], outputs=[training_model_info])
+
+        gen_toml_btn.click(
+            fn=generate_config,
+            inputs=[
+                project_dir,
+                resolution_w,
+                resolution_h,
+                batch_size,
+                model_arch,
+                vram_size,
+                comfy_models_dir,
+                vae_path,
+                text_encoder1_path,
+                text_encoder2_path,
+            ],
+            outputs=[dataset_status, toml_preview],
+        )
+
+        validate_models_btn.click(fn=validate_models_dir, inputs=[comfy_models_dir], outputs=[models_status])
+
+        set_rec_settings_btn.click(
+            fn=set_recommended_settings,
+            inputs=[project_dir, model_arch, vram_size],
+            outputs=[resolution_w, resolution_h, batch_size],
+        )
+
+        set_preprocessing_defaults_btn.click(
+            fn=set_preprocessing_defaults,
+            inputs=[project_dir, comfy_models_dir, model_arch],
+            outputs=[vae_path, text_encoder1_path, text_encoder2_path],
+        )
+
+        set_post_proc_defaults_btn.click(
+            fn=set_post_processing_defaults, inputs=[project_dir, output_name], outputs=[input_lora, output_comfy_lora]
+        )
+
+        set_training_defaults_btn.click(
+            fn=set_training_defaults,
+            inputs=[project_dir, comfy_models_dir, model_arch, vram_size],
+            outputs=[
+                dit_path,
+                network_dim,
+                learning_rate,
+                num_epochs,
+                save_every_n_epochs,
+                discrete_flow_shift,
+                block_swap,
+                use_pinned_memory_for_block_swap,
+                mixed_precision,
+                gradient_checkpointing,
+                fp8_scaled,
+                fp8_llm,
+                sample_every_n,
+                sample_w,
+                sample_h,
+            ],
+        )
+
+        cache_latents_btn.click(
+            fn=cache_latents,
+            inputs=[
+                project_dir,
+                vae_path,
+                text_encoder1_path,
+                text_encoder2_path,
+                model_arch,
+                comfy_models_dir,
+                resolution_w,
+                resolution_h,
+                batch_size,
+                vram_size,
+            ],
+            outputs=[caching_output],
+        )
+
+        cache_text_btn.click(
+            fn=cache_text_encoder,
+            inputs=[
+                project_dir,
+                text_encoder1_path,
+                text_encoder2_path,
+                vae_path,
+                model_arch,
+                comfy_models_dir,
+                resolution_w,
+                resolution_h,
+                batch_size,
+                vram_size,
+            ],
+            outputs=[caching_output],
+        )
+
+        start_training_btn.click(
+            fn=start_training,
+            inputs=[
+                project_dir,
+                model_arch,
+                dit_path,
+                vae_path,
+                text_encoder1_path,
+                output_name,
+                network_dim,
+                learning_rate,
+                num_epochs,
+                save_every_n_epochs,
+                discrete_flow_shift,
+                block_swap,
+                use_pinned_memory_for_block_swap,
+                mixed_precision,
+                gradient_checkpointing,
+                fp8_scaled,
+                fp8_llm,
+                additional_args,
+                sample_images,
+                sample_every_n,
+                sample_prompt,
+                sample_negative_prompt,
+                sample_w,
+                sample_h,
+            ],
+            outputs=[training_status],
+        )
+
+        convert_btn.click(
+            fn=convert_lora_to_comfy,
+            inputs=[
+                project_dir,
+                input_lora,
+                output_comfy_lora,
+                model_arch,
+                comfy_models_dir,
+                resolution_w,
+                resolution_h,
+                batch_size,
+                vae_path,
+                text_encoder1_path,
+                text_encoder2_path,
+            ],
+            outputs=[conversion_log],
+        )
+
+    return demo
+
+
+if __name__ == "__main__":
+    demo = construct_ui()
+    demo.launch(i18n=i18n)

src/musubi_tuner/gui/gui_implementation_plan.md

@@ -0,0 +1,97 @@
+※このファイルはGUIの実装方針をAI Agentに説明するためのドキュメントです。
+
+## GUIの実装方針
+
+Musubi Tunerの学習スクリプトの、非常にシンプルなGUIを実装します。対象ユーザーのレベルは、Python、gitとuvはインストール、起動できるが、仮想環境 (venv) の作成、起動はちょっと難しい、くらいを想定します。
+
+### GUIの実装
+
+`src/musubi_tuner/gui` フォルダに `gui.py` を配置します。Gradioを使用します。
+
+起動は `uv run gui` 等で行います（PyTorchやCUDAバージョンの考慮など、オプション等を別途検討）。
+
+### GUIの構成
+
+単純なひとつの画面のみで構成し、上から下に、順に作業の手順にあわせて配置します。
+
+1. プロジェクト設定
+
+プロジェクトフォルダを指定します。プロジェクトフォルダについては後述。
+
+この時点で`training`フォルダを（もし存在しなければ）自動的に作成します。
+
+2. モデルアーキテクチャの選択とモデルディレクトリ選択
+
+Qwen-Image、Z-Image-Turboなどのモデルアーキテクチャを選択します。最初は画像生成モデルのみ対応を予定し、Z-Image-TurboとQwen-Imageを対象に実装します。
+
+また学習時の推奨パラメータ等を適切に設定するため、VRAMサイズを選択します。
+
+モデルディレクトリは、ComfyUI の `models` フォルダをユーザーに指定してもらいます。
+
+3. データセット設定
+
+学習解像度等を指定しデータセット設定ファイルを作成します。
+
+学習解像度はモデルに応じた推奨解像度を自動設定するボタンを用意します。解像度以外は、バッチサイズのみ指定可能とします。
+
+4. 前処理
+
+学習データの前処理、具体的にはlatentの事前キャッシュと、text encoderの事前キャッシュを行います。モデルに応じたデフォルトのパスを指定するボタンを用意します。
+
+5. 学習
+
+いくつかのパラメータを指定し、学習を開始します。
+
+- LoRA出力名
+- 学習率
+- 学習エポック数
+- 何エポックごとに保存するか（サンプル画像生成も同じタイミング）
+- Discrete Flow Shiftの値
+- Block Swapを有効にするか、有効にする場合のブロック数
+- 任意指定のコマンドライン引数
+
+※ 学習のバッチサイズはデータセット設定で指定済み。
+
+各パラメータについて、モデルとVRAMサイズに応じた推奨値を自動設定するボタンを用意します。
+
+進捗管理は行わず、プロセスの死活監視だけ行います。進捗の確認はユーザーにコマンドプロンプトのウィンドウで確認してもらいます。
+
+6. ポスト処理
+
+ComfyUI用へのLoRA変換などを必要に応じて行います。デフォルトのパスを指定するボタンを用意します。
+
+### プロジェクトフォルダの構成
+
+簡単にするため、プロジェクトフォルダ内の設定ファイル名、サブフォルダ名はすべて固定します。
+
+```
++ training : 学習用画像を配置するフォルダ、GUIスクリプトが自動作成します。
++ cache : latentとtext encoderの事前キャッシュを配置するフォルダ（キャッシュ処理で自動的に作成されます）
++ models : 学習結果のLoRAモデルが配置されるフォルダ（学習開始で自動的に作成されます）
+    + sample : Musubi Tunerが学習中のサンプル生成画像を出力するフォルダ
++ dataset_config.toml : データセット設定ファイル、GUIスクリプトが自動作成します。
++ musubi_project.toml : GUIのプロジェクト設定（選択したモデルや解像度など）を保存するファイル。
+```
+
+`training`フォルダには、Musubi Tunerの形式、つまり画像 (\*.jpg/pngなど)  ＋ キャプションファイル（basenameが同じで、拡張子が.txt）を、ユーザーが配置します。データセット設定のステップで存在確認を行い、なければエラー表示します。
+
+### プロジェクト設定の保存
+
+`musubi_project.toml` に以下の項目等を保存し、次回読み込み時に復元します。
+
+- 選択したモデルアーキテクチャ (`model_arch`)
+- ComfyUIモデルディレクトリ (`comfy_models_dir`)
+- 解像度 (`resolution_w`, `resolution_h`)
+- バッチサイズ (`batch_size`)
+
+これにより、プロジェクトを開き直した際もスムーズに作業を再開できます。
+
+### モデル、VRAMサイズに応じた推奨値等の管理
+
+`config_manager.py` に、モデル、VRAMサイズに応じた推奨値等を管理するクラスを実装します。
+
+### 国際化 (Internationalization / i18n)
+
+GradioのI18n機能 (`gr.I18n`) を使用して、GUIのテキストを多言語対応（英語・日本語）します。
+`i18n` 辞書に言語ごとのテキストを定義し、GUI構築時に参照するようにします。
+ユーザーのブラウザ設定などに基づいて言語が切り替わる想定です。

src/musubi_tuner/gui/i18n_data.py

@@ -0,0 +1,186 @@
+# UI Text Dictionary for potential i18n
+# I18N Configuration
+I18N_DATA = {
+    "en": {
+        "app_title": "Musubi Tuner GUI",
+        "app_header": "# Musubi Tuner GUI",
+        "app_desc": "A simple frontend for training LoRA models with Musubi Tuner.",
+        "acc_project": "1. Project Settings",
+        "desc_project": "All working files will be created under this directory.",
+        "lbl_proj_dir": "Project Working Directory",
+        "ph_proj_dir": "Absolute path to your project folder",
+        "btn_init_project": "Initialize/Load Project",
+        "acc_model": "2. Model & Dataset Configuration",
+        "desc_model": "Choose the model architecture and specify the ComfyUI models directory.",
+        "lbl_model_arch": "Model Architecture",
+        "lbl_vram": "VRAM Size (GB)",
+        "lbl_comfy_dir": "ComfyUI Models Directory",
+        "ph_comfy_dir": "Absolute path to ComfyUI/models",
+        "btn_validate_models": "Validate Models Directory",
+        "header_dataset": "### 3. Dataset Settings",
+        "desc_dataset": "Configure the resolution and batch size for the dataset. Regenerate the dataset config if you change resolution or batch size.",
+        "btn_rec_res_batch": "Set Recommended Resolution & Batch Size",
+        "lbl_res_w": "Resolution Width",
+        "lbl_res_h": "Resolution Height",
+        "lbl_batch_size": "Batch Size",
+        "btn_gen_config": "Generate Dataset Config",
+        "lbl_toml_preview": "TOML Preview",
+        "acc_preprocessing": "4. Preprocessing",
+        "desc_preprocessing": "Pre-calculate latents and text encoder outputs required for training.",
+        "btn_set_paths": "Set Default Paths",
+        "lbl_vae_path": "VAE Path",
+        "ph_vae_path": "Path to VAE model",
+        "lbl_te1_path": "Text Encoder 1 Path",
+        "ph_te1_path": "Path to Text Encoder 1",
+        "lbl_te2_path": "Text Encoder 2 Path",
+        "ph_te2_path": "Path to Text Encoder 2 (Optional)",
+        "btn_cache_latents": "Cache Latents",
+        "btn_cache_text": "Cache Text Encoder Outputs",
+        "lbl_cache_log": "Caching Log Output",
+        "acc_training": "5. Training",
+        "desc_training_basic": "Configure the training parameters. If you train with the same name again, the previous LoRA will be overwritten.",
+        "desc_training_zimage": "Recommended: Use **bf16** for mixed precision. Because the base model has not been released yet, please use `z_image_de_turbo_v1_bf16.safetensors` as the base model.",
+        "btn_rec_params": "Set Recommended Parameters",
+        "lbl_dit_path": "Base Model / DiT Path",
+        "ph_dit_path": "Path to DiT model",
+        "lbl_output_name": "Output LoRA Name",
+        "header_basic_params": "### Basic Parameters",
+        "lbl_dim": "LoRA Rank (Dim)",
+        "lbl_lr": "Learning Rate",
+        "lbl_epochs": "Epochs",
+        "lbl_save_every": "Save Every N Epochs",
+        "accordion_advanced": "Advanced Parameters",
+        "desc_training_detailed": """
+### Detailed Explanation
+- **Learning Rate**: Controls how much the model weights are updated during training. Lower values are safer but slower.
+- **Epochs**: One complete pass through the entire training dataset.
+- **Save Every N Epochs**: How often to save the model and generate sample images.
+- **Discrete Flow Shift**: A parameter specific to flow matching models.
+- **Block Swap**: Offloads model blocks to CPU to save VRAM. Higher values save more VRAM but slow down training. Using pinned memory can speed up Block Swap (64GB+ system RAM recommended).
+- **Mixed Precision**: fp16 and bf16 are both supported; which is better depends on the model architecture. For bf16, RTX30xx or higher is required.
+- **Gradient Checkpointing**: Saves VRAM by recomputing activations during backward pass.
+- **FP8**: Further reduces memory usage by using 8-bit floating point arithmetic.
+""",
+        "lbl_flow_shift": "Discrete Flow Shift",
+        "lbl_block_swap": "Block Swap (Z-Image: 0-28, Qwen: 0-58)",
+        "lbl_use_pinned_memory_for_block_swap": "Use Pinned Memory for Block Swap",
+        "lbl_mixed_precision": "Mixed Precision",
+        "lbl_grad_cp": "Gradient Checkpointing",
+        "lbl_fp8_scaled": "FP8 Scaled (DiT) - Enables --fp8_base and --fp8_scaled",
+        "lbl_fp8_llm": "FP8 LLM/VLM (Text Encoder)",
+        "header_sample_images": "### Sample Image Generation",
+        "lbl_enable_sample": "Generate Sample Images During Training",
+        "lbl_sample_every_n": "Generate Sample Every N Epochs",
+        "lbl_sample_prompt": "Sample Prompt",
+        "ph_sample_prompt": "Prompt for sample generation",
+        "lbl_sample_negative_prompt": "Sample Negative Prompt",
+        "ph_sample_negative_prompt": "Negative prompt for sample generation",
+        "lbl_sample_w": "Sample Width",
+        "lbl_sample_h": "Sample Height",
+        "accordion_additional": "Additional Options",
+        "desc_additional_args": "Enter any additional command line arguments here. They will be appended to the training command.",
+        "lbl_additional_args": "Additional Optional Arguments",
+        "ph_additional_args": "--arg value --flag",
+        "btn_start_training": "Start Training (New Window)",
+        "acc_post_processing": "6. Post-Processing",
+        "desc_post_proc": "Convert Z-Image LoRA to ComfyUI format.",
+        "lbl_input_lora": "Input LoRA Path",
+        "ph_input_lora": "Path to trained .safetensors file",
+        "lbl_output_comfy": "Output ComfyUI LoRA Path",
+        "ph_output_comfy": "Path to save converted model",
+        "btn_convert": "Convert to ComfyUI Format",
+        "lbl_conversion_log": "Conversion Log",
+        "desc_qwen_notes": "Qwen-Image specific notes here.",
+    },
+    "ja": {
+        "app_title": "Musubi Tuner GUI",
+        "app_header": "# Musubi Tuner GUI",
+        "app_desc": "Musubi TunerでLoRAモデルを学習するためのシンプルなフロントエンドです。",
+        "acc_project": "1. プロジェクト設定",
+        "desc_project": "すべての作業ファイルはこのディレクトリ下に作成されます。",
+        "lbl_proj_dir": "プロジェクト作業ディレクトリ",
+        "ph_proj_dir": "プロジェクトフォルダへの絶対パス",
+        "btn_init_project": "プロジェクトを初期化/読み込み",
+        "acc_model": "2. モデル＆データセット設定",
+        "desc_model": "モデルアーキテクチャを選択し、ComfyUIのモデルディレクトリを指定してください。",
+        "lbl_model_arch": "モデルアーキテクチャ",
+        "lbl_vram": "VRAMサイズ (GB)",
+        "lbl_comfy_dir": "ComfyUI モデルディレクトリ",
+        "ph_comfy_dir": "ComfyUI/models への絶対パス",
+        "btn_validate_models": "モデルディレクトリを検証",
+        "header_dataset": "### 3. データセット設定",
+        "desc_dataset": "データセットの解像度とバッチサイズを設定してください。解像度やバッチサイズを変えた場合は、データセット設定を再生成してください。",
+        "btn_rec_res_batch": "推奨解像度とバッチサイズを設定",
+        "lbl_res_w": "解像度 幅",
+        "lbl_res_h": "解像度 高さ",
+        "lbl_batch_size": "バッチサイズ",
+        "btn_gen_config": "データセット設定(TOML)を生成",
+        "lbl_toml_preview": "TOML プレビュー",
+        "acc_preprocessing": "4. 前処理 (Preprocessing)",
+        "desc_preprocessing": "学習に必要となるLatentsとテキストエンコーダーの出力を事前計算します。",
+        "btn_set_paths": "デフォルトパスを設定",
+        "lbl_vae_path": "VAE パス",
+        "ph_vae_path": "VAEモデルへのパス",
+        "lbl_te1_path": "テキストエンコーダー1 パス",
+        "ph_te1_path": "テキストエンコーダー1へのパス",
+        "lbl_te2_path": "テキストエンコーダー2 パス",
+        "ph_te2_path": "テキストエンコーダー2へのパス (オプション)",
+        "btn_cache_latents": "Latentsをキャッシュ",
+        "btn_cache_text": "テキストエンコーダー出力をキャッシュ",
+        "lbl_cache_log": "キャッシュログ出力",
+        "acc_training": "5. 学習 (Training)",
+        "desc_training_basic": "学習パラメータを設定してください。学習後、同じ名前で学習すると前のLoRAが上書きされます。",
+        "desc_training_zimage": "推奨: 混合精度には **bf16** を使用してください。Baseモデルがリリースされていないため、ostris氏の `z_image_de_turbo_v1_bf16.safetensors` を使用してください。",
+        "btn_rec_params": "推奨パラメータを設定",
+        "lbl_dit_path": "ベースモデル / DiT パス",
+        "ph_dit_path": "DiTモデルへのパス",
+        "lbl_output_name": "出力 LoRA 名",
+        "header_basic_params": "### 基本パラメータ",
+        "lbl_dim": "LoRAランク (Dim)",
+        "lbl_lr": "学習率 (Learning Rate)",
+        "lbl_epochs": "エポック数 (Epochs)",
+        "lbl_save_every": "Nエポックごとに保存",
+        "accordion_advanced": "詳細パラメータ",
+        "desc_training_detailed": """
+### 詳細説明
+- **学習率 (Learning Rate)**: 学習中にモデルの重みをどれくらい更新するかを制御します。低い値の方が安全ですが、学習が遅くなります。
+- **エポック数 (Epochs)**: 学習データセット全体を通す回数です。
+- **保存頻度 (Save Every N Epochs)**: モデルの保存とサンプル生成を行う頻度です。
+- **Discrete Flow Shift**: Flow Matchingモデル特有のパラメータです。
+- **Block Swap**: VRAMを節約するためにモデルブロックをCPUにオフロードします。値を大きくするとVRAMを節約できますが、学習が遅くなります。共有メモリを使うとBlock Swapが高速化されます（64GB以上のメインRAMを推奨）。
+- **混合精度 (Mixed Precision)**: モデルアーキテクチャによりfp16とbf16のどちらが適しているかは異なります。bf16はRTX30xx以降のGPUが必要です。
+- **Gradient Checkpointing**: Backwardパス中にアクティベーションを再計算することでVRAMを節約します。
+- **FP8**: 8ビット浮動小数点演算を使用することでメモリ使用量をさらに削減します。
+""",
+        "lbl_flow_shift": "Discrete Flow Shift",
+        "lbl_block_swap": "Block Swap (Z-Image: 0-28, Qwen: 0-58)",
+        "lbl_use_pinned_memory_for_block_swap": "Block Swapに共有メモリを使う",
+        "lbl_mixed_precision": "混合精度 (Mixed Precision)",
+        "lbl_grad_cp": "Gradient Checkpointing",
+        "lbl_fp8_scaled": "FP8 Scaled (DiT) - --fp8_base と --fp8_scaled を有効化",
+        "lbl_fp8_llm": "FP8 LLM/VLM (テキストエンコーダー)",
+        "header_sample_images": "### サンプル画像生成",
+        "lbl_enable_sample": "学習中にサンプル画像を生成する",
+        "lbl_sample_every_n": "Nエポックごとにサンプルを生成",
+        "lbl_sample_prompt": "サンプル画像プロンプト",
+        "ph_sample_prompt": "サンプル生成用のプロンプト",
+        "lbl_sample_negative_prompt": "サンプル画像ネガティブプロンプト",
+        "ph_sample_negative_prompt": "サンプル生成用のネガティブプロンプト",
+        "lbl_sample_w": "サンプル画像 幅",
+        "lbl_sample_h": "サンプル画像 高さ",
+        "accordion_additional": "追加オプション",
+        "desc_additional_args": "追加のコマンドライン引数を入力してください。これらは学習コマンドに追加されます。",
+        "lbl_additional_args": "追加のオプション引数",
+        "ph_additional_args": "--arg value --flag",
+        "btn_start_training": "学習を開始 (新しいウィンドウが開きます)",
+        "acc_post_processing": "6. 後処理 (Post-Processing)",
+        "desc_post_proc": "Z-Image LoRAをComfyUI形式に変換します。",
+        "lbl_input_lora": "入力 LoRA パス",
+        "ph_input_lora": "学習済み .safetensors ファイルへのパス",
+        "lbl_output_comfy": "出力 ComfyUI LoRA パス",
+        "ph_output_comfy": "変換後のモデルの保存先パス",
+        "btn_convert": "ComfyUI形式に変換",
+        "lbl_conversion_log": "変換ログ",
+        "desc_qwen_notes": "Qwen-Image 特有の注意点。",
+    },
+}

src/musubi_tuner/gui_dashboard/__init__.py

@@ -0,0 +1,10 @@
+from musubi_tuner.gui_dashboard.metrics_writer import MetricsWriter
+from musubi_tuner.gui_dashboard.server import start_server
+
+
+def create_metrics_writer(run_dir: str, flush_every: int = 10) -> MetricsWriter:
+    return MetricsWriter(run_dir, flush_every=flush_every)
+
+
+def start_gui_server(run_dir: str, host: str = "0.0.0.0", port: int = 7860):
+    return start_server(run_dir, host=host, port=port)

src/musubi_tuner/gui_dashboard/command_builder.py

@@ -0,0 +1,881 @@
+"""Convert ProjectConfig into CLI argument lists for subprocess launch."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from musubi_tuner.gui_dashboard.project_schema import ProjectConfig
+from musubi_tuner.gui_dashboard.toml_export import (
+    _write_slider_toml,
+    build_slider_toml_path,
+    export_dataset_toml,
+)
+
+
+def _find_script(name: str) -> str:
+    """Find a script in the musubi_tuner package."""
+    import musubi_tuner
+    pkg_dir = Path(musubi_tuner.__file__).parent
+    script = pkg_dir / name
+    if script.exists():
+        return str(script)
+    raise FileNotFoundError(f"Script not found: {name}")
+
+
+def build_cache_latents_cmd(config: ProjectConfig) -> list[str]:
+    """Build CLI args for ltx2_cache_latents.py."""
+    toml_path = export_dataset_toml(config)
+    c = config.caching
+
+    cmd = [
+        sys.executable,
+        _find_script("ltx2_cache_latents.py"),
+        "--dataset_config", str(toml_path),
+        "--ltx2_checkpoint", c.ltx2_checkpoint,
+        "--ltx2_mode", c.ltx2_mode,
+    ]
+
+    if c.vae_dtype:
+        cmd += ["--vae_dtype", c.vae_dtype]
+    if c.device:
+        cmd += ["--device", c.device]
+    if c.skip_existing:
+        cmd.append("--skip_existing")
+    if c.keep_cache:
+        cmd.append("--keep_cache")
+    if c.num_workers is not None:
+        cmd += ["--num_workers", str(c.num_workers)]
+    if c.vae_chunk_size is not None:
+        cmd += ["--vae_chunk_size", str(c.vae_chunk_size)]
+    if c.vae_spatial_tile_size is not None:
+        cmd += ["--vae_spatial_tile_size", str(c.vae_spatial_tile_size)]
+    if c.vae_spatial_tile_overlap is not None:
+        cmd += ["--vae_spatial_tile_overlap", str(c.vae_spatial_tile_overlap)]
+    if c.vae_temporal_tile_size is not None:
+        cmd += ["--vae_temporal_tile_size", str(c.vae_temporal_tile_size)]
+    if c.vae_temporal_tile_overlap is not None:
+        cmd += ["--vae_temporal_tile_overlap", str(c.vae_temporal_tile_overlap)]
+
+    # Reference (V2V)
+    if c.reference_frames != 1:
+        cmd += ["--reference_frames", str(c.reference_frames)]
+    if c.reference_downscale != 1:
+        cmd += ["--reference_downscale", str(c.reference_downscale)]
+
+    # Audio source options
+    if c.ltx2_mode in ("av", "audio"):
+        cmd += ["--ltx2_audio_source", c.ltx2_audio_source]
+        if c.ltx2_audio_source == "audio_files" and c.ltx2_audio_dir:
+            cmd += ["--ltx2_audio_dir", c.ltx2_audio_dir]
+            if c.ltx2_audio_ext:
+                cmd += ["--ltx2_audio_ext", c.ltx2_audio_ext]
+        if c.ltx2_audio_dtype:
+            cmd += ["--ltx2_audio_dtype", c.ltx2_audio_dtype]
+        if c.audio_only_sequence_resolution != 64:
+            cmd += ["--audio_only_sequence_resolution", str(c.audio_only_sequence_resolution)]
+
+    # I2V latent precaching
+    if c.precache_sample_latents and c.sample_prompts:
+        cmd.append("--precache_sample_latents")
+        cmd += ["--sample_prompts", c.sample_prompts]
+        if c.sample_latents_cache:
+            cmd += ["--sample_latents_cache", c.sample_latents_cache]
+
+    if c.quantize_device:
+        cmd += ["--quantize_device", c.quantize_device]
+    if c.save_dataset_manifest:
+        cmd += ["--save_dataset_manifest", c.save_dataset_manifest]
+
+    return cmd
+
+
+def build_cache_text_cmd(config: ProjectConfig) -> list[str]:
+    """Build CLI args for ltx2_cache_text_encoder_outputs.py."""
+    toml_path = export_dataset_toml(config)
+    c = config.caching
+
+    cmd = [
+        sys.executable,
+        _find_script("ltx2_cache_text_encoder_outputs.py"),
+        "--dataset_config", str(toml_path),
+        "--ltx2_checkpoint", c.ltx2_checkpoint,
+        "--gemma_root", c.gemma_root,
+        "--ltx2_mode", c.ltx2_mode,
+    ]
+
+    if c.gemma_safetensors:
+        cmd += ["--gemma_safetensors", c.gemma_safetensors]
+    if c.ltx2_text_encoder_checkpoint:
+        cmd += ["--ltx2_text_encoder_checkpoint", c.ltx2_text_encoder_checkpoint]
+    if c.mixed_precision != "no":
+        cmd += ["--mixed_precision", c.mixed_precision]
+    if c.skip_existing:
+        cmd.append("--skip_existing")
+    if c.keep_cache:
+        cmd.append("--keep_cache")
+    if c.num_workers is not None:
+        cmd += ["--num_workers", str(c.num_workers)]
+    if c.gemma_load_in_8bit:
+        cmd.append("--gemma_load_in_8bit")
+    if c.gemma_load_in_4bit:
+        cmd.append("--gemma_load_in_4bit")
+        cmd += ["--gemma_bnb_4bit_quant_type", c.gemma_bnb_4bit_quant_type]
+    if c.gemma_bnb_4bit_disable_double_quant:
+        cmd.append("--gemma_bnb_4bit_disable_double_quant")
+    if c.gemma_bnb_4bit_compute_dtype != "auto":
+        cmd += ["--gemma_bnb_4bit_compute_dtype", c.gemma_bnb_4bit_compute_dtype]
+
+    # Precaching
+    if c.precache_sample_prompts and c.sample_prompts:
+        cmd.append("--precache_sample_prompts")
+        cmd += ["--sample_prompts", c.sample_prompts]
+        if c.sample_prompts_cache:
+            cmd += ["--sample_prompts_cache", c.sample_prompts_cache]
+    if c.precache_preservation_prompts:
+        cmd.append("--precache_preservation_prompts")
+        if c.preservation_prompts_cache:
+            cmd += ["--preservation_prompts_cache", c.preservation_prompts_cache]
+        if c.blank_preservation:
+            cmd.append("--blank_preservation")
+        if c.dop:
+            cmd.append("--dop")
+            if c.dop_class_prompt:
+                cmd += ["--dop_class_prompt", c.dop_class_prompt]
+
+    return cmd
+
+
+def build_inference_cmd(config: ProjectConfig) -> list[str]:
+    """Build CLI args for ltx2_generate_video.py."""
+    s = config.inference
+
+    cmd = [
+        sys.executable,
+        _find_script("ltx2_generate_video.py"),
+        "--ltx2_checkpoint", s.ltx2_checkpoint,
+        "--gemma_root", s.gemma_root,
+        "--ltx2_mode", s.ltx2_mode,
+    ]
+
+    # LoRA
+    if s.lora_weight:
+        cmd += ["--lora_weight", s.lora_weight]
+        cmd += ["--lora_multiplier", str(s.lora_multiplier)]
+
+    # Prompt
+    if s.prompt:
+        cmd += ["--prompt", s.prompt]
+    if s.negative_prompt:
+        cmd += ["--negative_prompt", s.negative_prompt]
+    if s.from_file:
+        cmd += ["--from_file", s.from_file]
+
+    # Sampling params
+    cmd += ["--height", str(s.height)]
+    cmd += ["--width", str(s.width)]
+    cmd += ["--frame_count", str(s.frame_count)]
+    cmd += ["--frame_rate", str(s.frame_rate)]
+    cmd += ["--sample_steps", str(s.sample_steps)]
+    cmd += ["--guidance_scale", str(s.guidance_scale)]
+    if s.cfg_scale is not None:
+        cmd += ["--cfg_scale", str(s.cfg_scale)]
+    cmd += ["--discrete_flow_shift", str(s.discrete_flow_shift)]
+    if s.seed is not None:
+        cmd += ["--seed", str(s.seed)]
+
+    # Precision
+    if s.mixed_precision != "no":
+        cmd += ["--mixed_precision", s.mixed_precision]
+    cmd += ["--attn_mode", s.attn_mode]
+    if s.fp8_base:
+        cmd.append("--fp8_base")
+    if s.fp8_scaled:
+        cmd.append("--fp8_scaled")
+
+    # Gemma quantization
+    if s.gemma_load_in_8bit:
+        cmd.append("--gemma_load_in_8bit")
+    if s.gemma_load_in_4bit:
+        cmd.append("--gemma_load_in_4bit")
+
+    # Memory
+    if s.offloading:
+        cmd.append("--offloading")
+    if s.blocks_to_swap is not None:
+        cmd += ["--blocks_to_swap", str(s.blocks_to_swap)]
+
+    # Output
+    if s.output_dir:
+        cmd += ["--output_dir", s.output_dir]
+    if s.output_name:
+        cmd += ["--output_name", s.output_name]
+
+    return cmd
+
+
+def build_training_cmd(config: ProjectConfig) -> list[str]:
+    """Build CLI args for training via accelerate launch."""
+    toml_path = export_dataset_toml(config)
+    t = config.training
+
+    # Use accelerate launch
+    cmd = [
+        sys.executable, "-m", "accelerate.commands.launch",
+        "--mixed_precision", t.mixed_precision,
+        "--num_processes", "1",
+        "--num_machines", "1",
+        _find_script("ltx2_train_network.py"),
+    ]
+
+    # Dataset
+    if t.dataset_manifest:
+        cmd += ["--dataset_manifest", t.dataset_manifest]
+    else:
+        cmd += ["--dataset_config", str(toml_path)]
+
+    # Model
+    cmd += ["--ltx2_checkpoint", t.ltx2_checkpoint]
+    if t.gemma_root:
+        cmd += ["--gemma_root", t.gemma_root]
+    if t.gemma_safetensors:
+        cmd += ["--gemma_safetensors", t.gemma_safetensors]
+    cmd += ["--ltx2_mode", t.ltx2_mode]
+    if t.ltx_version != "2.0":
+        cmd += ["--ltx_version", t.ltx_version]
+    if t.ltx_version_check_mode != "warn":
+        cmd += ["--ltx_version_check_mode", t.ltx_version_check_mode]
+    if t.fp8_base:
+        cmd.append("--fp8_base")
+    if t.fp8_scaled:
+        cmd.append("--fp8_scaled")
+    if t.flash_attn:
+        cmd.append("--flash_attn")
+    if t.sdpa:
+        cmd.append("--sdpa")
+    if t.sage_attn:
+        cmd.append("--sage_attn")
+    if t.xformers:
+        cmd.append("--xformers")
+    if t.gemma_load_in_8bit:
+        cmd.append("--gemma_load_in_8bit")
+    if t.gemma_load_in_4bit:
+        cmd.append("--gemma_load_in_4bit")
+    if t.gemma_bnb_4bit_disable_double_quant:
+        cmd.append("--gemma_bnb_4bit_disable_double_quant")
+    if t.ltx2_audio_only_model:
+        cmd.append("--ltx2_audio_only_model")
+
+    # Quantization
+    if t.nf4_base:
+        cmd.append("--nf4_base")
+        if t.nf4_block_size != 32:
+            cmd += ["--nf4_block_size", str(t.nf4_block_size)]
+    if t.loftq_init:
+        cmd.append("--loftq_init")
+        if t.loftq_iters != 2:
+            cmd += ["--loftq_iters", str(t.loftq_iters)]
+    if t.fp8_w8a8:
+        cmd.append("--fp8_w8a8")
+        if t.w8a8_mode != "int8":
+            cmd += ["--w8a8_mode", t.w8a8_mode]
+    if t.awq_calibration:
+        cmd.append("--awq_calibration")
+        if t.awq_alpha != 0.25:
+            cmd += ["--awq_alpha", str(t.awq_alpha)]
+        if t.awq_num_batches != 8:
+            cmd += ["--awq_num_batches", str(t.awq_num_batches)]
+    if t.quantize_device:
+        cmd += ["--quantize_device", t.quantize_device]
+
+    # LoRA / Network
+    if t.network_module:
+        cmd += ["--network_module", t.network_module]
+    cmd += ["--network_dim", str(t.network_dim)]
+    cmd += ["--network_alpha", str(t.network_alpha)]
+    cmd += ["--lora_target_preset", t.lora_target_preset]
+    if t.network_args:
+        cmd += ["--network_args"] + t.network_args.split()
+    if t.network_weights:
+        cmd += ["--network_weights", t.network_weights]
+    if t.network_dropout is not None:
+        cmd += ["--network_dropout", str(t.network_dropout)]
+    if t.scale_weight_norms is not None:
+        cmd += ["--scale_weight_norms", str(t.scale_weight_norms)]
+    if t.dim_from_weights:
+        cmd.append("--dim_from_weights")
+    if t.base_weights:
+        cmd += ["--base_weights"] + t.base_weights.split()
+    if t.base_weights_multiplier:
+        cmd += ["--base_weights_multiplier"] + t.base_weights_multiplier.split()
+    if t.lycoris_config:
+        cmd += ["--lycoris_config", t.lycoris_config]
+    if t.lycoris_quantized_base_check_mode != "warn":
+        cmd += ["--lycoris_quantized_base_check_mode", t.lycoris_quantized_base_check_mode]
+    if t.init_lokr_norm is not None:
+        cmd += ["--init_lokr_norm", str(t.init_lokr_norm)]
+    if t.caption_dropout_rate > 0:
+        cmd += ["--caption_dropout_rate", str(t.caption_dropout_rate)]
+    if not t.save_original_lora:
+        cmd.append("--no-save_original_lora")
+    if t.ic_lora_strategy != "auto":
+        cmd += ["--ic_lora_strategy", t.ic_lora_strategy]
+    if t.audio_ref_use_negative_positions:
+        cmd.append("--audio_ref_use_negative_positions")
+    if t.audio_ref_mask_cross_attention_to_reference:
+        cmd.append("--audio_ref_mask_cross_attention_to_reference")
+    if t.audio_ref_mask_reference_from_text_attention:
+        cmd.append("--audio_ref_mask_reference_from_text_attention")
+    if t.audio_ref_identity_guidance_scale != 0.0:
+        cmd += ["--audio_ref_identity_guidance_scale", str(t.audio_ref_identity_guidance_scale)]
+
+    # Optimizer
+    cmd += ["--learning_rate", str(t.learning_rate)]
+    cmd += ["--optimizer_type", t.optimizer_type]
+    if t.optimizer_args:
+        cmd += ["--optimizer_args"] + t.optimizer_args.split()
+    cmd += ["--lr_scheduler", t.lr_scheduler]
+    cmd += ["--lr_warmup_steps", str(t.lr_warmup_steps)]
+    if t.lr_decay_steps is not None:
+        cmd += ["--lr_decay_steps", str(t.lr_decay_steps)]
+    if t.lr_scheduler_num_cycles is not None:
+        cmd += ["--lr_scheduler_num_cycles", str(t.lr_scheduler_num_cycles)]
+    if t.lr_scheduler_power is not None:
+        cmd += ["--lr_scheduler_power", str(t.lr_scheduler_power)]
+    if t.lr_scheduler_min_lr_ratio is not None:
+        cmd += ["--lr_scheduler_min_lr_ratio", str(t.lr_scheduler_min_lr_ratio)]
+    if t.lr_scheduler_type:
+        cmd += ["--lr_scheduler_type", t.lr_scheduler_type]
+    if t.lr_scheduler_args:
+        cmd += ["--lr_scheduler_args"] + t.lr_scheduler_args.split()
+    if t.lr_scheduler_timescale is not None:
+        cmd += ["--lr_scheduler_timescale", str(t.lr_scheduler_timescale)]
+    cmd += ["--gradient_accumulation_steps", str(t.gradient_accumulation_steps)]
+    cmd += ["--max_grad_norm", str(t.max_grad_norm)]
+    if t.audio_lr is not None:
+        cmd += ["--audio_lr", str(t.audio_lr)]
+    if t.lr_args:
+        cmd += ["--lr_args"] + t.lr_args.split()
+
+    # Schedule
+    if t.max_train_epochs is not None:
+        cmd += ["--max_train_epochs", str(t.max_train_epochs)]
+    else:
+        cmd += ["--max_train_steps", str(t.max_train_steps)]
+    cmd += ["--timestep_sampling", t.timestep_sampling]
+    cmd += ["--discrete_flow_shift", str(t.discrete_flow_shift)]
+    cmd += ["--weighting_scheme", t.weighting_scheme]
+    if t.seed is not None:
+        cmd += ["--seed", str(t.seed)]
+    if t.guidance_scale is not None:
+        cmd += ["--guidance_scale", str(t.guidance_scale)]
+    if t.sigmoid_scale is not None:
+        cmd += ["--sigmoid_scale", str(t.sigmoid_scale)]
+    if t.logit_mean is not None:
+        cmd += ["--logit_mean", str(t.logit_mean)]
+    if t.logit_std is not None:
+        cmd += ["--logit_std", str(t.logit_std)]
+    if t.mode_scale is not None:
+        cmd += ["--mode_scale", str(t.mode_scale)]
+    if t.min_timestep is not None:
+        cmd += ["--min_timestep", str(t.min_timestep)]
+    if t.max_timestep is not None:
+        cmd += ["--max_timestep", str(t.max_timestep)]
+
+    # Advanced timestep
+    if t.shifted_logit_mode:
+        cmd += ["--shifted_logit_mode", t.shifted_logit_mode]
+    if t.shifted_logit_eps != 1e-3:
+        cmd += ["--shifted_logit_eps", str(t.shifted_logit_eps)]
+    if t.shifted_logit_uniform_prob != 0.1:
+        cmd += ["--shifted_logit_uniform_prob", str(t.shifted_logit_uniform_prob)]
+    if t.shifted_logit_shift is not None:
+        cmd += ["--shifted_logit_shift", str(t.shifted_logit_shift)]
+    if t.preserve_distribution_shape:
+        cmd.append("--preserve_distribution_shape")
+    if t.num_timestep_buckets is not None:
+        cmd += ["--num_timestep_buckets", str(t.num_timestep_buckets)]
+
+    # Memory
+    if t.blocks_to_swap is not None:
+        cmd += ["--blocks_to_swap", str(t.blocks_to_swap)]
+    if t.gradient_checkpointing:
+        cmd.append("--gradient_checkpointing")
+    if t.gradient_checkpointing_cpu_offload:
+        cmd.append("--gradient_checkpointing_cpu_offload")
+    if t.split_attn_target:
+        cmd += ["--split_attn_target", t.split_attn_target]
+    if t.split_attn_mode:
+        cmd += ["--split_attn_mode", t.split_attn_mode]
+    if t.split_attn_chunk_size is not None:
+        cmd += ["--split_attn_chunk_size", str(t.split_attn_chunk_size)]
+    if t.blockwise_checkpointing:
+        cmd.append("--blockwise_checkpointing")
+    if t.blocks_to_checkpoint is not None:
+        cmd += ["--blocks_to_checkpoint", str(t.blocks_to_checkpoint)]
+    if t.full_fp16:
+        cmd.append("--full_fp16")
+    if t.full_bf16:
+        cmd.append("--full_bf16")
+    if t.ffn_chunk_target:
+        cmd += ["--ffn_chunk_target", t.ffn_chunk_target]
+    if t.ffn_chunk_size:
+        cmd += ["--ffn_chunk_size", str(t.ffn_chunk_size)]
+    if t.use_pinned_memory_for_block_swap:
+        cmd.append("--use_pinned_memory_for_block_swap")
+    if t.img_in_txt_in_offloading:
+        cmd.append("--img_in_txt_in_offloading")
+
+    # Compile
+    if t.compile:
+        cmd.append("--compile")
+        if t.compile_backend:
+            cmd += ["--compile_backend", t.compile_backend]
+        if t.compile_mode:
+            cmd += ["--compile_mode", t.compile_mode]
+        if t.compile_dynamic:
+            cmd.append("--compile_dynamic")
+        if t.compile_fullgraph:
+            cmd.append("--compile_fullgraph")
+        if t.compile_cache_size_limit is not None:
+            cmd += ["--compile_cache_size_limit", str(t.compile_cache_size_limit)]
+
+    # CUDA
+    if t.cuda_allow_tf32:
+        cmd.append("--cuda_allow_tf32")
+    if t.cuda_cudnn_benchmark:
+        cmd.append("--cuda_cudnn_benchmark")
+    if t.cuda_memory_fraction is not None:
+        cmd += ["--cuda_memory_fraction", str(t.cuda_memory_fraction)]
+
+    # Sampling
+    if t.sample_every_n_steps:
+        cmd += ["--sample_every_n_steps", str(t.sample_every_n_steps)]
+    if t.sample_every_n_epochs:
+        cmd += ["--sample_every_n_epochs", str(t.sample_every_n_epochs)]
+    if t.sample_prompts:
+        cmd += ["--sample_prompts", t.sample_prompts]
+    if t.use_precached_sample_prompts:
+        cmd.append("--use_precached_sample_prompts")
+    if t.sample_prompts_cache:
+        cmd += ["--sample_prompts_cache", t.sample_prompts_cache]
+    if t.use_precached_sample_latents:
+        cmd.append("--use_precached_sample_latents")
+    if t.sample_latents_cache:
+        cmd += ["--sample_latents_cache", t.sample_latents_cache]
+    cmd += ["--height", str(t.height)]
+    cmd += ["--width", str(t.width)]
+    cmd += ["--sample_num_frames", str(t.sample_num_frames)]
+    if t.sample_with_offloading:
+        cmd.append("--sample_with_offloading")
+    if t.sample_merge_audio:
+        cmd.append("--sample_merge_audio")
+    if t.sample_disable_audio:
+        cmd.append("--sample_disable_audio")
+    if t.sample_at_first:
+        cmd.append("--sample_at_first")
+    if t.sample_tiled_vae:
+        cmd.append("--sample_tiled_vae")
+    if t.sample_vae_tile_size is not None:
+        cmd += ["--sample_vae_tile_size", str(t.sample_vae_tile_size)]
+    if t.sample_vae_tile_overlap is not None:
+        cmd += ["--sample_vae_tile_overlap", str(t.sample_vae_tile_overlap)]
+    if t.sample_vae_temporal_tile_size is not None:
+        cmd += ["--sample_vae_temporal_tile_size", str(t.sample_vae_temporal_tile_size)]
+    if t.sample_vae_temporal_tile_overlap is not None:
+        cmd += ["--sample_vae_temporal_tile_overlap", str(t.sample_vae_temporal_tile_overlap)]
+    if t.sample_two_stage:
+        cmd.append("--sample_two_stage")
+        if t.spatial_upsampler_path:
+            cmd += ["--spatial_upsampler_path", t.spatial_upsampler_path]
+        if t.distilled_lora_path:
+            cmd += ["--distilled_lora_path", t.distilled_lora_path]
+        if t.sample_stage2_steps != 3:
+            cmd += ["--sample_stage2_steps", str(t.sample_stage2_steps)]
+    if t.sample_audio_only:
+        cmd.append("--sample_audio_only")
+    if t.sample_disable_flash_attn:
+        cmd.append("--sample_disable_flash_attn")
+    if not t.sample_i2v_token_timestep_mask:
+        cmd.append("--no-sample_i2v_token_timestep_mask")
+    if not t.sample_audio_subprocess:
+        cmd.append("--no-sample_audio_subprocess")
+    if t.sample_include_reference:
+        cmd.append("--sample_include_reference")
+    if t.reference_downscale != 1:
+        cmd += ["--reference_downscale", str(t.reference_downscale)]
+    if t.reference_frames != 1:
+        cmd += ["--reference_frames", str(t.reference_frames)]
+
+    # Validation
+    if t.validate_every_n_steps is not None:
+        cmd += ["--validate_every_n_steps", str(t.validate_every_n_steps)]
+    if t.validate_every_n_epochs is not None:
+        cmd += ["--validate_every_n_epochs", str(t.validate_every_n_epochs)]
+
+    # Output
+    if t.output_dir:
+        cmd += ["--output_dir", t.output_dir]
+    if t.output_name:
+        cmd += ["--output_name", t.output_name]
+    if t.save_every_n_epochs:
+        cmd += ["--save_every_n_epochs", str(t.save_every_n_epochs)]
+    if t.save_every_n_steps:
+        cmd += ["--save_every_n_steps", str(t.save_every_n_steps)]
+    if t.save_last_n_epochs is not None:
+        cmd += ["--save_last_n_epochs", str(t.save_last_n_epochs)]
+    if t.save_last_n_steps is not None:
+        cmd += ["--save_last_n_steps", str(t.save_last_n_steps)]
+    if t.save_last_n_epochs_state is not None:
+        cmd += ["--save_last_n_epochs_state", str(t.save_last_n_epochs_state)]
+    if t.save_last_n_steps_state is not None:
+        cmd += ["--save_last_n_steps_state", str(t.save_last_n_steps_state)]
+    if t.save_state:
+        cmd.append("--save_state")
+    if t.save_state_on_train_end:
+        cmd.append("--save_state_on_train_end")
+    if t.save_checkpoint_metadata:
+        cmd.append("--save_checkpoint_metadata")
+    if t.no_metadata:
+        cmd.append("--no_metadata")
+    if t.no_convert_to_comfy:
+        cmd.append("--no_convert_to_comfy")
+    if t.log_with:
+        cmd += ["--log_with", t.log_with]
+    if t.logging_dir:
+        cmd += ["--logging_dir", t.logging_dir]
+    if t.log_prefix:
+        cmd += ["--log_prefix", t.log_prefix]
+    if t.log_tracker_name:
+        cmd += ["--log_tracker_name", t.log_tracker_name]
+    if t.wandb_run_name:
+        cmd += ["--wandb_run_name", t.wandb_run_name]
+    if t.wandb_api_key:
+        cmd += ["--wandb_api_key", t.wandb_api_key]
+    if t.log_cuda_memory_every_n_steps is not None:
+        cmd += ["--log_cuda_memory_every_n_steps", str(t.log_cuda_memory_every_n_steps)]
+    if t.resume:
+        cmd += ["--resume", t.resume]
+    if t.training_comment:
+        cmd += ["--training_comment", t.training_comment]
+    if t.loss_type != "mse":
+        cmd += ["--loss_type", t.loss_type]
+    if t.loss_type in ("huber", "smooth_l1") and t.huber_delta != 1.0:
+        cmd += ["--huber_delta", str(t.huber_delta)]
+
+    # Metadata
+    if t.metadata_title:
+        cmd += ["--metadata_title", t.metadata_title]
+    if t.metadata_author:
+        cmd += ["--metadata_author", t.metadata_author]
+    if t.metadata_description:
+        cmd += ["--metadata_description", t.metadata_description]
+    if t.metadata_license:
+        cmd += ["--metadata_license", t.metadata_license]
+    if t.metadata_tags:
+        cmd += ["--metadata_tags", t.metadata_tags]
+
+    # HuggingFace upload
+    if t.huggingface_repo_id:
+        cmd += ["--huggingface_repo_id", t.huggingface_repo_id]
+    if t.huggingface_repo_type:
+        cmd += ["--huggingface_repo_type", t.huggingface_repo_type]
+    if t.huggingface_path_in_repo:
+        cmd += ["--huggingface_path_in_repo", t.huggingface_path_in_repo]
+    if t.huggingface_token:
+        cmd += ["--huggingface_token", t.huggingface_token]
+    if t.huggingface_repo_visibility:
+        cmd += ["--huggingface_repo_visibility", t.huggingface_repo_visibility]
+    if t.save_state_to_huggingface:
+        cmd.append("--save_state_to_huggingface")
+    if t.resume_from_huggingface:
+        cmd.append("--resume_from_huggingface")
+    if t.async_upload:
+        cmd.append("--async_upload")
+
+    # CREPA
+    if t.crepa:
+        cmd.append("--crepa")
+        args_parts = []
+        if t.crepa_mode != "backbone":
+            args_parts.append(f"mode={t.crepa_mode}")
+        if t.crepa_student_block_idx != 16:
+            args_parts.append(f"student_block_idx={t.crepa_student_block_idx}")
+        if t.crepa_mode == "backbone" and t.crepa_teacher_block_idx != 32:
+            args_parts.append(f"teacher_block_idx={t.crepa_teacher_block_idx}")
+        if t.crepa_mode == "dino" and t.crepa_dino_model != "dinov2_vitb14":
+            args_parts.append(f"dino_model={t.crepa_dino_model}")
+        if t.crepa_lambda != 0.1:
+            args_parts.append(f"lambda_crepa={t.crepa_lambda}")
+        if t.crepa_tau != 1.0:
+            args_parts.append(f"tau={t.crepa_tau}")
+        if t.crepa_num_neighbors != 2:
+            args_parts.append(f"num_neighbors={t.crepa_num_neighbors}")
+        if t.crepa_schedule != "constant":
+            args_parts.append(f"schedule={t.crepa_schedule}")
+        if t.crepa_warmup_steps != 0:
+            args_parts.append(f"warmup_steps={t.crepa_warmup_steps}")
+        if not t.crepa_normalize:
+            args_parts.append("normalize=false")
+        if args_parts:
+            cmd += ["--crepa_args"] + args_parts
+
+    # Self-Flow
+    if t.self_flow:
+        cmd.append("--self_flow")
+        args_parts = []
+        if t.self_flow_teacher_mode != "base":
+            args_parts.append(f"teacher_mode={t.self_flow_teacher_mode}")
+        if t.self_flow_student_block_idx != 16:
+            args_parts.append(f"student_block_idx={t.self_flow_student_block_idx}")
+        if t.self_flow_teacher_block_idx != 32:
+            args_parts.append(f"teacher_block_idx={t.self_flow_teacher_block_idx}")
+        if t.self_flow_student_block_ratio != 0.3:
+            args_parts.append(f"student_block_ratio={t.self_flow_student_block_ratio}")
+        if t.self_flow_teacher_block_ratio != 0.7:
+            args_parts.append(f"teacher_block_ratio={t.self_flow_teacher_block_ratio}")
+        if t.self_flow_student_block_stochastic_range != 0:
+            args_parts.append(f"student_block_stochastic_range={t.self_flow_student_block_stochastic_range}")
+        if t.self_flow_lambda != 0.1:
+            args_parts.append(f"lambda_self_flow={t.self_flow_lambda}")
+        if t.self_flow_mask_ratio != 0.1:
+            args_parts.append(f"mask_ratio={t.self_flow_mask_ratio}")
+        if t.self_flow_frame_level_mask:
+            args_parts.append("frame_level_mask=true")
+        if t.self_flow_mask_focus_loss:
+            args_parts.append("mask_focus_loss=true")
+        if t.self_flow_max_loss != 0.0:
+            args_parts.append(f"max_loss={t.self_flow_max_loss}")
+        if t.self_flow_teacher_momentum != 0.999:
+            args_parts.append(f"teacher_momentum={t.self_flow_teacher_momentum}")
+        if not t.self_flow_dual_timestep:
+            args_parts.append("dual_timestep=false")
+        if t.self_flow_projector_lr is not None:
+            args_parts.append(f"projector_lr={t.self_flow_projector_lr}")
+        if getattr(t, "self_flow_temporal_mode", "off") != "off":
+            args_parts.append(f"temporal_mode={t.self_flow_temporal_mode}")
+        if getattr(t, "self_flow_lambda_temporal", 0.0) != 0.0:
+            args_parts.append(f"lambda_temporal={t.self_flow_lambda_temporal}")
+        if getattr(t, "self_flow_lambda_delta", 0.0) != 0.0:
+            args_parts.append(f"lambda_delta={t.self_flow_lambda_delta}")
+        if getattr(t, "self_flow_temporal_tau", 1.0) != 1.0:
+            args_parts.append(f"temporal_tau={t.self_flow_temporal_tau}")
+        if getattr(t, "self_flow_num_neighbors", 2) != 2:
+            args_parts.append(f"num_neighbors={t.self_flow_num_neighbors}")
+        if getattr(t, "self_flow_temporal_granularity", "frame") != "frame":
+            args_parts.append(f"temporal_granularity={t.self_flow_temporal_granularity}")
+        if getattr(t, "self_flow_patch_spatial_radius", 0) != 0:
+            args_parts.append(f"patch_spatial_radius={t.self_flow_patch_spatial_radius}")
+        if getattr(t, "self_flow_patch_match_mode", "hard") != "hard":
+            args_parts.append(f"patch_match_mode={t.self_flow_patch_match_mode}")
+        if getattr(t, "self_flow_delta_num_steps", 1) != 1:
+            args_parts.append(f"delta_num_steps={t.self_flow_delta_num_steps}")
+        if getattr(t, "self_flow_motion_weighting", "none") != "none":
+            args_parts.append(f"motion_weighting={t.self_flow_motion_weighting}")
+        if getattr(t, "self_flow_motion_weight_strength", 0.0) != 0.0:
+            args_parts.append(f"motion_weight_strength={t.self_flow_motion_weight_strength}")
+        if getattr(t, "self_flow_temporal_schedule", "constant") != "constant":
+            args_parts.append(f"temporal_schedule={t.self_flow_temporal_schedule}")
+        if getattr(t, "self_flow_temporal_warmup_steps", 0) != 0:
+            args_parts.append(f"temporal_warmup_steps={t.self_flow_temporal_warmup_steps}")
+        if getattr(t, "self_flow_temporal_max_steps", 0) != 0:
+            args_parts.append(f"temporal_max_steps={t.self_flow_temporal_max_steps}")
+        if getattr(t, "self_flow_offload_teacher_features", False):
+            args_parts.append("offload_teacher_features=true")
+        if args_parts:
+            cmd += ["--self_flow_args"] + args_parts
+
+    # Preservation
+    if t.blank_preservation:
+        cmd.append("--blank_preservation")
+        args_parts = []
+        if t.blank_preservation_multiplier != 1.0:
+            args_parts.append(f"multiplier={t.blank_preservation_multiplier}")
+        if args_parts:
+            cmd += ["--blank_preservation_args"] + args_parts
+    if t.dop:
+        cmd.append("--dop")
+        args_parts = []
+        if t.dop_class:
+            args_parts.append(f"class={t.dop_class}")
+        if t.dop_multiplier != 1.0:
+            args_parts.append(f"multiplier={t.dop_multiplier}")
+        if args_parts:
+            cmd += ["--dop_args"] + args_parts
+    if t.prior_divergence:
+        cmd.append("--prior_divergence")
+        args_parts = []
+        if t.prior_divergence_multiplier != 0.1:
+            args_parts.append(f"multiplier={t.prior_divergence_multiplier}")
+        if args_parts:
+            cmd += ["--prior_divergence_args"] + args_parts
+    if t.use_precached_preservation:
+        cmd.append("--use_precached_preservation")
+    if t.preservation_prompts_cache:
+        cmd += ["--preservation_prompts_cache", t.preservation_prompts_cache]
+
+    # Audio features
+    if t.audio_loss_balance_mode != "none":
+        cmd += ["--audio_loss_balance_mode", t.audio_loss_balance_mode]
+        if t.audio_loss_balance_mode == "inv_freq":
+            if t.audio_loss_balance_beta != 0.01:
+                cmd += ["--audio_loss_balance_beta", str(t.audio_loss_balance_beta)]
+            if t.audio_loss_balance_eps != 0.05:
+                cmd += ["--audio_loss_balance_eps", str(t.audio_loss_balance_eps)]
+            if t.audio_loss_balance_min != 0.05:
+                cmd += ["--audio_loss_balance_min", str(t.audio_loss_balance_min)]
+            if t.audio_loss_balance_max != 4.0:
+                cmd += ["--audio_loss_balance_max", str(t.audio_loss_balance_max)]
+        if t.audio_loss_balance_ema_init != 1.0:
+            cmd += ["--audio_loss_balance_ema_init", str(t.audio_loss_balance_ema_init)]
+        if t.audio_loss_balance_mode == "ema_mag":
+            if t.audio_loss_balance_target_ratio != 0.33:
+                cmd += ["--audio_loss_balance_target_ratio", str(t.audio_loss_balance_target_ratio)]
+            if t.audio_loss_balance_ema_decay != 0.99:
+                cmd += ["--audio_loss_balance_ema_decay", str(t.audio_loss_balance_ema_decay)]
+    if t.independent_audio_timestep:
+        cmd.append("--independent_audio_timestep")
+    if t.audio_silence_regularizer:
+        cmd.append("--audio_silence_regularizer")
+        if t.audio_silence_regularizer_weight != 1.0:
+            cmd += ["--audio_silence_regularizer_weight", str(t.audio_silence_regularizer_weight)]
+    if t.audio_supervision_mode != "off":
+        cmd += ["--audio_supervision_mode", t.audio_supervision_mode]
+        if t.audio_supervision_warmup_steps != 50:
+            cmd += ["--audio_supervision_warmup_steps", str(t.audio_supervision_warmup_steps)]
+        if t.audio_supervision_check_interval != 50:
+            cmd += ["--audio_supervision_check_interval", str(t.audio_supervision_check_interval)]
+        if t.audio_supervision_min_ratio != 0.9:
+            cmd += ["--audio_supervision_min_ratio", str(t.audio_supervision_min_ratio)]
+    if t.audio_dop:
+        cmd.append("--audio_dop")
+        if t.audio_dop_multiplier != 0.5:
+            cmd += ["--audio_dop_args", f"multiplier={t.audio_dop_multiplier}"]
+    if t.audio_bucket_strategy:
+        cmd += ["--audio_bucket_strategy", t.audio_bucket_strategy]
+    if t.audio_bucket_interval is not None:
+        cmd += ["--audio_bucket_interval", str(t.audio_bucket_interval)]
+    if t.audio_only_sequence_resolution != 64:
+        cmd += ["--audio_only_sequence_resolution", str(t.audio_only_sequence_resolution)]
+    if t.min_audio_batches_per_accum > 0:
+        cmd += ["--min_audio_batches_per_accum", str(t.min_audio_batches_per_accum)]
+    if t.audio_batch_probability is not None:
+        cmd += ["--audio_batch_probability", str(t.audio_batch_probability)]
+
+    # Loss weighting
+    if t.video_loss_weight != 1.0:
+        cmd += ["--video_loss_weight", str(t.video_loss_weight)]
+    if t.audio_loss_weight != 1.0:
+        cmd += ["--audio_loss_weight", str(t.audio_loss_weight)]
+
+    # Misc
+    if t.separate_audio_buckets:
+        cmd.append("--separate_audio_buckets")
+    cmd += ["--max_data_loader_n_workers", str(t.max_data_loader_n_workers)]
+    if t.persistent_data_loader_workers:
+        cmd.append("--persistent_data_loader_workers")
+    cmd += ["--ltx2_first_frame_conditioning_p", str(t.ltx2_first_frame_conditioning_p)]
+
+    # GUI dashboard
+    cmd.append("--gui")
+
+    return cmd
+
+
+def build_slider_training_cmd(config: ProjectConfig) -> list[str]:
+    """Build CLI args for slider LoRA training via accelerate launch.
+
+    Shared settings (model, LoRA, optimizer, memory, output) are inherited
+    from the training config.  Only slider-specific values (steps, output name,
+    slider config, latent dims) come from ``config.slider``.
+    """
+    s = config.slider
+    t = config.training
+    slider_toml = _write_slider_toml(config, build_slider_toml_path(config))
+
+    cmd = [
+        sys.executable, "-m", "accelerate.commands.launch",
+        "--mixed_precision", t.mixed_precision,
+        "--num_processes", "1",
+        "--num_machines", "1",
+        _find_script("ltx2_train_slider.py"),
+    ]
+
+    # Slider config
+    cmd += ["--slider_config", str(slider_toml)]
+
+    # Model — from training config
+    cmd += ["--ltx2_checkpoint", t.ltx2_checkpoint]
+    if t.gemma_root:
+        cmd += ["--gemma_root", t.gemma_root]
+    if t.fp8_base:
+        cmd.append("--fp8_base")
+    if t.fp8_scaled:
+        cmd.append("--fp8_scaled")
+    if t.flash_attn:
+        cmd.append("--flash_attn")
+    if t.gemma_load_in_8bit:
+        cmd.append("--gemma_load_in_8bit")
+    if t.gemma_load_in_4bit:
+        cmd.append("--gemma_load_in_4bit")
+
+    # Text mode latent dimensions — slider-specific
+    if s.mode == "text":
+        cmd += ["--latent_frames", str(s.latent_frames)]
+        cmd += ["--latent_height", str(s.latent_height)]
+        cmd += ["--latent_width", str(s.latent_width)]
+
+    # LoRA — from training config
+    cmd += ["--network_dim", str(t.network_dim)]
+    cmd += ["--network_alpha", str(t.network_alpha)]
+
+    # Optimizer — from training config
+    cmd += ["--learning_rate", str(t.learning_rate)]
+    cmd += ["--optimizer_type", t.optimizer_type]
+    if t.optimizer_args:
+        cmd += ["--optimizer_args"] + t.optimizer_args.split()
+    cmd += ["--gradient_accumulation_steps", str(t.gradient_accumulation_steps)]
+    cmd += ["--max_grad_norm", str(t.max_grad_norm)]
+
+    # Schedule — slider override for steps
+    cmd += ["--max_train_steps", str(s.max_train_steps)]
+    if t.seed is not None:
+        cmd += ["--seed", str(t.seed)]
+
+    # Memory — from training config
+    if t.blocks_to_swap is not None:
+        cmd += ["--blocks_to_swap", str(t.blocks_to_swap)]
+    if t.gradient_checkpointing:
+        cmd.append("--gradient_checkpointing")
+
+    # Output — dir from training, name from slider
+    if t.output_dir:
+        cmd += ["--output_dir", t.output_dir]
+    if s.output_name:
+        cmd += ["--output_name", s.output_name]
+    if t.save_every_n_steps:
+        cmd += ["--save_every_n_steps", str(t.save_every_n_steps)]
+
+    return cmd
+
+
+def build_cache_dino_cmd(config: ProjectConfig) -> list[str]:
+    """Build CLI args for ltx2_cache_dino_features.py."""
+    toml_path = export_dataset_toml(config)
+    c = config.caching
+    t = config.training
+
+    cmd = [
+        sys.executable,
+        _find_script("ltx2_cache_dino_features.py"),
+        "--dataset_config", str(toml_path),
+        "--dino_model", t.crepa_dino_model,  # Use training model setting, not caching
+        "--dino_batch_size", str(c.dino_batch_size),
+    ]
+
+    if c.device:
+        cmd += ["--device", c.device]
+    if c.skip_existing:
+        cmd.append("--skip_existing")
+
+    return cmd

src/musubi_tuner/gui_dashboard/management_server.py

@@ -0,0 +1,146 @@
+"""Standalone management FastAPI app for the full training dashboard."""
+
+from __future__ import annotations
+
+import logging
+import mimetypes
+import os
+from pathlib import Path
+from typing import Optional
+
+# Windows registry often maps .js to text/plain — fix it
+mimetypes.add_type("application/javascript", ".js")
+mimetypes.add_type("text/css", ".css")
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse, HTMLResponse, Response
+
+from musubi_tuner.gui_dashboard.process_manager import ProcessManager
+from musubi_tuner.gui_dashboard.project_schema import ProjectConfig
+from musubi_tuner.gui_dashboard.routers import datasets, filesystem, processes, projects, stats, system
+
+logger = logging.getLogger(__name__)
+
+FRONTEND_DIST = os.path.join(os.path.dirname(__file__), "frontend", "dist")
+
+
+def create_management_app(project_path: Optional[str] = None) -> FastAPI:
+    """Create the management FastAPI application."""
+    app = FastAPI(title="LTX-2 Training Manager")
+
+    # App state
+    app.state.process_manager = ProcessManager()
+    app.state.project_config = None
+    app.state.project_path = None  # Path to the actual .json file
+
+    # Load project if path provided
+    if project_path:
+        p = Path(project_path)
+        if p.is_dir():
+            p = p / "project.json"
+        if p.exists():
+            try:
+                app.state.project_config = ProjectConfig.load(p)
+                app.state.project_path = p
+                logger.info(f"Loaded project: {p}")
+            except Exception as e:
+                logger.warning(f"Failed to load project {p}: {e}")
+
+    # Mount API routers
+    app.include_router(projects.router)
+    app.include_router(datasets.router)
+    app.include_router(processes.router)
+    app.include_router(filesystem.router)
+    app.include_router(system.router)
+    app.include_router(stats.router)
+
+    # Metrics router — dynamically bound to training output_dir
+    @app.get("/data/metrics.parquet")
+    async def get_metrics():
+        run_dir = _get_run_dir(app)
+        if not run_dir:
+            return Response(status_code=204)
+        path = os.path.join(run_dir, "dashboard", "metrics.parquet")
+        if not os.path.exists(path):
+            return Response(status_code=204)
+        return FileResponse(path, media_type="application/octet-stream")
+
+    @app.get("/data/status.json")
+    async def get_status():
+        run_dir = _get_run_dir(app)
+        if not run_dir:
+            return Response(status_code=204)
+        path = os.path.join(run_dir, "dashboard", "status.json")
+        if not os.path.exists(path):
+            return Response(status_code=204)
+        return FileResponse(path, media_type="application/json")
+
+    @app.get("/data/events.json")
+    async def get_events():
+        run_dir = _get_run_dir(app)
+        if not run_dir:
+            return Response(status_code=204)
+        path = os.path.join(run_dir, "dashboard", "events.json")
+        if not os.path.exists(path):
+            return Response(status_code=204)
+        return FileResponse(path, media_type="application/json")
+
+    @app.get("/data/samples/{file_path:path}")
+    async def get_sample(file_path: str):
+        run_dir = _get_run_dir(app)
+        if not run_dir:
+            return HTMLResponse("no training output configured", status_code=404)
+        full_path = os.path.join(run_dir, "sample", file_path)
+        if not os.path.exists(full_path):
+            return HTMLResponse("not found", status_code=404)
+        return FileResponse(full_path)
+
+    # SSE for metrics updates
+    import asyncio
+    from sse_starlette.sse import EventSourceResponse
+
+    @app.get("/sse")
+    async def sse_stream():
+        async def event_generator():
+            last_mtime = 0.0
+            while True:
+                await asyncio.sleep(2)
+                run_dir = _get_run_dir(app)
+                if not run_dir:
+                    continue
+                metrics_path = os.path.join(run_dir, "dashboard", "metrics.parquet")
+                try:
+                    mtime = os.path.getmtime(metrics_path) if os.path.exists(metrics_path) else 0.0
+                except OSError:
+                    mtime = 0.0
+                if mtime > last_mtime:
+                    last_mtime = mtime
+                    yield {"event": "update", "data": f'{{"mtime": {mtime}}}'}
+
+        return EventSourceResponse(event_generator())
+
+    # SvelteKit frontend (must be last — catches all routes)
+    if os.path.isdir(FRONTEND_DIST):
+        @app.get("/{full_path:path}")
+        async def serve_frontend(full_path: str):
+            file_path = os.path.join(FRONTEND_DIST, full_path)
+            if full_path and os.path.isfile(file_path):
+                return FileResponse(file_path)
+            return FileResponse(os.path.join(FRONTEND_DIST, "index.html"))
+    else:
+        @app.get("/")
+        async def no_frontend():
+            return HTMLResponse(
+                "<h2>LTX-2 Training Manager</h2>"
+                "<p>Frontend not built. Run <code>npm run build</code> in <code>gui_dashboard/frontend/</code></p>"
+            )
+
+    return app
+
+
+def _get_run_dir(app: FastAPI) -> Optional[str]:
+    """Get the current training output directory from project config."""
+    config: ProjectConfig | None = app.state.project_config
+    if config and config.training.output_dir:
+        return config.training.output_dir
+    return None

src/musubi_tuner/gui_dashboard/metrics_writer.py

@@ -0,0 +1,144 @@
+import json
+import os
+import threading
+import time
+from typing import Any, Optional
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+SCHEMA = pa.schema(
+    [
+        ("step", pa.int64()),
+        ("epoch", pa.int32()),
+        ("loss", pa.float32()),
+        ("avr_loss", pa.float32()),
+        ("loss_v", pa.float32()),
+        ("loss_a", pa.float32()),
+        ("lr", pa.float64()),
+        ("step_time", pa.float32()),
+    ]
+)
+
+
+class MetricsWriter:
+    """Buffered Parquet writer for training metrics.
+
+    Accumulates rows in memory and flushes to a Parquet file periodically
+    via a background daemon thread.  Also manages status.json and events.json.
+    """
+
+    def __init__(self, run_dir: str, flush_every: int = 10):
+        self.run_dir = run_dir
+        self.flush_every = flush_every
+
+        self.metrics_path = os.path.join(run_dir, "dashboard", "metrics.parquet")
+        self.status_path = os.path.join(run_dir, "dashboard", "status.json")
+        self.events_path = os.path.join(run_dir, "dashboard", "events.json")
+
+        os.makedirs(os.path.join(run_dir, "dashboard"), exist_ok=True)
+
+        self._buffer: list[dict[str, Any]] = []
+        self._lock = threading.Lock()
+        self._start_time = time.monotonic()
+        self._step_count = 0
+
+        # Initialize events file
+        if not os.path.exists(self.events_path):
+            self._write_json(self.events_path, [])
+
+        # Initialize status
+        self.update_status(step=0, max_steps=0, epoch=0, max_epochs=0, status="initializing")
+
+    # -- public API --
+
+    def log(
+        self,
+        step: int,
+        epoch: int = 0,
+        loss: float = 0.0,
+        avr_loss: float = 0.0,
+        loss_v: Optional[float] = None,
+        loss_a: Optional[float] = None,
+        lr: float = 0.0,
+        step_time: float = 0.0,
+    ):
+        row = {
+            "step": step,
+            "epoch": epoch,
+            "loss": loss,
+            "avr_loss": avr_loss,
+            "loss_v": loss_v if loss_v is not None else float("nan"),
+            "loss_a": loss_a if loss_a is not None else float("nan"),
+            "lr": lr,
+            "step_time": step_time,
+        }
+        with self._lock:
+            self._buffer.append(row)
+            self._step_count += 1
+            if len(self._buffer) >= self.flush_every:
+                self._flush_background()
+
+    def log_event(self, event_type: str, step: int, **extra):
+        entry = {"type": event_type, "step": step, "time": time.time(), **extra}
+        t = threading.Thread(target=self._append_event, args=(entry,), daemon=True)
+        t.start()
+
+    def update_status(self, **kw):
+        elapsed = time.monotonic() - self._start_time
+        speed = self._step_count / elapsed if elapsed > 0 and self._step_count > 0 else 0.0
+        status = {
+            "elapsed_sec": round(elapsed, 1),
+            "speed_steps_per_sec": round(speed, 4),
+            "time": time.time(),
+        }
+        status.update(kw)
+        t = threading.Thread(target=self._write_json, args=(self.status_path, status), daemon=True)
+        t.start()
+
+    def flush(self):
+        with self._lock:
+            if self._buffer:
+                self._do_flush(list(self._buffer))
+                self._buffer.clear()
+
+    def close(self):
+        self.flush()
+
+    # -- internals --
+
+    def _flush_background(self):
+        rows = list(self._buffer)
+        self._buffer.clear()
+        t = threading.Thread(target=self._do_flush, args=(rows,), daemon=True)
+        t.start()
+
+    def _do_flush(self, rows: list[dict]):
+        table = pa.table({col: [r[col] for r in rows] for col in SCHEMA.names}, schema=SCHEMA)
+        try:
+            if os.path.exists(self.metrics_path):
+                existing = pq.read_table(self.metrics_path, schema=SCHEMA)
+                table = pa.concat_tables([existing, table])
+            pq.write_table(table, self.metrics_path)
+        except Exception:
+            # If read fails (corrupt file), overwrite
+            pq.write_table(table, self.metrics_path)
+
+    def _append_event(self, entry: dict):
+        try:
+            events = []
+            if os.path.exists(self.events_path):
+                with open(self.events_path, "r") as f:
+                    events = json.load(f)
+            events.append(entry)
+            self._write_json(self.events_path, events)
+        except Exception:
+            pass
+
+    @staticmethod
+    def _write_json(path: str, data):
+        tmp = path + ".tmp"
+        with open(tmp, "w") as f:
+            json.dump(data, f)
+        os.replace(tmp, path)

src/musubi_tuner/gui_dashboard/process_manager.py

@@ -0,0 +1,165 @@
+"""Subprocess manager for caching and training processes."""
+
+from __future__ import annotations
+
+import logging
+import subprocess
+import sys
+import threading
+from collections import deque
+from enum import Enum
+from typing import Literal, Optional
+
+logger = logging.getLogger(__name__)
+
+ProcessType = Literal["cache_latents", "cache_text", "cache_dino", "training", "inference", "slider_training"]
+
+# Windows-specific flags for clean subprocess shutdown
+_CREATION_FLAGS = 0
+if sys.platform == "win32":
+    _CREATION_FLAGS = subprocess.CREATE_NEW_PROCESS_GROUP
+
+
+class ProcessState(str, Enum):
+    IDLE = "idle"
+    RUNNING = "running"
+    STOPPING = "stopping"
+    FINISHED = "finished"
+    ERROR = "error"
+
+
+class ManagedProcess:
+    """Wraps a subprocess with state tracking and log buffering."""
+
+    def __init__(self, cmd: list[str], cwd: Optional[str] = None):
+        self.cmd = cmd
+        self.cwd = cwd
+        self.state = ProcessState.IDLE
+        self.exit_code: Optional[int] = None
+        self.logs: deque[str] = deque(maxlen=5000)
+        self._proc: Optional[subprocess.Popen] = None
+        self._reader_thread: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+
+    def start(self):
+        with self._lock:
+            if self.state == ProcessState.RUNNING:
+                raise RuntimeError("Process already running")
+
+            self.state = ProcessState.RUNNING
+            self.exit_code = None
+            self.logs.clear()
+            self.logs.append(f"$ {' '.join(self.cmd)}\n")
+
+            self._proc = subprocess.Popen(
+                self.cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                cwd=self.cwd,
+                creationflags=_CREATION_FLAGS,
+                bufsize=1,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+            )
+
+            self._reader_thread = threading.Thread(
+                target=self._read_output, daemon=True
+            )
+            self._reader_thread.start()
+
+    def _read_output(self):
+        try:
+            assert self._proc and self._proc.stdout
+            for line in self._proc.stdout:
+                self.logs.append(line)
+            self._proc.wait()
+        except Exception as e:
+            self.logs.append(f"\n[Process reader error: {e}]\n")
+
+        with self._lock:
+            self.exit_code = self._proc.returncode if self._proc else -1
+            if self.state == ProcessState.STOPPING:
+                self.state = ProcessState.FINISHED
+            elif self.exit_code == 0:
+                self.state = ProcessState.FINISHED
+            else:
+                self.state = ProcessState.ERROR
+            self.logs.append(f"\n[Process exited with code {self.exit_code}]\n")
+
+    def terminate(self):
+        with self._lock:
+            if self.state != ProcessState.RUNNING:
+                return
+            self.state = ProcessState.STOPPING
+            self.logs.append("\n[Stopping process...]\n")
+
+        if self._proc:
+            self._proc.terminate()
+            # Wait up to 10s then force kill
+            t = threading.Thread(target=self._force_kill, daemon=True)
+            t.start()
+
+    def _force_kill(self):
+        if self._proc:
+            try:
+                self._proc.wait(timeout=10)
+            except subprocess.TimeoutExpired:
+                self.logs.append("\n[Force killing process...]\n")
+                self._proc.kill()
+
+    def get_status(self) -> dict:
+        return {
+            "state": self.state.value,
+            "exit_code": self.exit_code,
+        }
+
+    def get_logs(self, last_n: Optional[int] = None) -> list[str]:
+        if last_n is None:
+            return list(self.logs)
+        return list(self.logs)[-last_n:]
+
+
+class ProcessManager:
+    """Manages up to 3 concurrent subprocess slots."""
+
+    def __init__(self):
+        self._processes: dict[str, ManagedProcess] = {}
+        self._lock = threading.Lock()
+
+    def start(self, proc_type: ProcessType, cmd: list[str], cwd: Optional[str] = None):
+        with self._lock:
+            existing = self._processes.get(proc_type)
+            if existing and existing.state == ProcessState.RUNNING:
+                raise RuntimeError(f"{proc_type} is already running")
+
+            mp = ManagedProcess(cmd, cwd=cwd)
+            self._processes[proc_type] = mp
+
+        mp.start()
+        logger.info(f"Started {proc_type}: {' '.join(cmd[:5])}...")
+
+    def stop(self, proc_type: ProcessType):
+        with self._lock:
+            mp = self._processes.get(proc_type)
+            if not mp:
+                return
+        mp.terminate()
+
+    def get_status(self, proc_type: ProcessType) -> dict:
+        mp = self._processes.get(proc_type)
+        if not mp:
+            return {"state": ProcessState.IDLE.value, "exit_code": None}
+        return mp.get_status()
+
+    def get_logs(self, proc_type: ProcessType, last_n: Optional[int] = None) -> list[str]:
+        mp = self._processes.get(proc_type)
+        if not mp:
+            return []
+        return mp.get_logs(last_n)
+
+    def get_all_statuses(self) -> dict[str, dict]:
+        result = {}
+        for pt in ("cache_latents", "cache_text", "cache_dino", "training", "inference", "slider_training"):
+            result[pt] = self.get_status(pt)
+        return result

src/musubi_tuner/gui_dashboard/project_schema.py

@@ -0,0 +1,481 @@
+"""Pydantic v2 models for GUI dashboard project configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class GeneralConfig(BaseModel):
+    enable_bucket: bool = True
+    bucket_no_upscale: bool = True
+
+
+class DatasetEntry(BaseModel):
+    type: Literal["video", "image", "audio"] = "video"
+    directory: str = ""
+    cache_directory: str = ""
+    reference_cache_directory: str = ""
+    control_directory: str = ""
+    jsonl_file: str = ""
+    resolution_w: int = 768
+    resolution_h: int = 512
+    batch_size: int = 1
+    num_repeats: int = 1
+    caption_extension: str = ".txt"
+    # video-specific
+    target_frames: int = 33
+    frame_extraction: Literal["head", "chunk", "slide", "uniform", "full"] = "head"
+    frame_sample: Optional[int] = None
+    max_frames: Optional[int] = None
+    frame_stride: Optional[int] = None
+    source_fps: Optional[float] = None
+    target_fps: Optional[float] = None
+
+
+class DatasetConfig(BaseModel):
+    general: GeneralConfig = Field(default_factory=GeneralConfig)
+    datasets: list[DatasetEntry] = Field(default_factory=list)
+    validation_datasets: list[DatasetEntry] = Field(default_factory=list)
+
+
+class CachingConfig(BaseModel):
+    ltx2_checkpoint: str = ""
+    gemma_root: str = ""
+    gemma_safetensors: str = ""
+    ltx2_text_encoder_checkpoint: str = ""
+    ltx2_mode: Literal["video", "av", "audio"] = "video"
+    vae_dtype: Literal["float16", "bfloat16", "float32"] = "bfloat16"
+    device: str = "cuda"
+    skip_existing: bool = True
+    keep_cache: bool = False
+    num_workers: Optional[int] = None
+    # VAE tiling
+    vae_chunk_size: Optional[int] = None
+    vae_spatial_tile_size: Optional[int] = None
+    vae_spatial_tile_overlap: Optional[int] = None
+    vae_temporal_tile_size: Optional[int] = None
+    vae_temporal_tile_overlap: Optional[int] = None
+    # Gemma quantization
+    mixed_precision: Literal["no", "fp16", "bf16"] = "bf16"
+    gemma_load_in_8bit: bool = False
+    gemma_load_in_4bit: bool = False
+    gemma_bnb_4bit_quant_type: Literal["nf4", "fp4"] = "nf4"
+    gemma_bnb_4bit_disable_double_quant: bool = False
+    gemma_bnb_4bit_compute_dtype: Literal["auto", "fp16", "bf16", "fp32"] = "auto"
+    # Text encoder precaching
+    precache_sample_prompts: bool = False
+    sample_prompts: str = ""
+    sample_prompts_cache: str = ""
+    precache_preservation_prompts: bool = False
+    preservation_prompts_cache: str = ""
+    # VAE I2V latent precaching
+    precache_sample_latents: bool = False
+    sample_latents_cache: str = ""
+    blank_preservation: bool = False
+    dop: bool = False
+    dop_class_prompt: str = ""
+    # Reference (V2V)
+    reference_frames: int = 1
+    reference_downscale: int = 1
+    # Audio
+    ltx2_audio_source: Literal["video", "audio_files"] = "video"
+    ltx2_audio_dir: str = ""
+    ltx2_audio_ext: str = ".wav"
+    ltx2_audio_dtype: str = ""
+    audio_only_sequence_resolution: int = 64
+    # DINOv2 feature caching (for CREPA dino mode - model selection in training.crepa_dino_model)
+    dino_batch_size: int = 16
+    # Quantization device
+    quantize_device: Optional[str] = None
+    # Dataset manifest
+    save_dataset_manifest: str = ""
+
+
+class TrainingConfig(BaseModel):
+    # Model
+    ltx2_checkpoint: str = ""
+    gemma_root: str = ""
+    gemma_safetensors: str = ""
+    ltx2_mode: Literal["video", "av", "audio"] = "video"
+    ltx_version: Literal["2.0", "2.3"] = "2.0"
+    ltx_version_check_mode: Literal["off", "warn", "error"] = "warn"
+    fp8_base: bool = False
+    fp8_scaled: bool = False
+    flash_attn: bool = True
+    sdpa: bool = False
+    sage_attn: bool = False
+    xformers: bool = False
+    gemma_load_in_8bit: bool = False
+    gemma_load_in_4bit: bool = False
+    gemma_bnb_4bit_disable_double_quant: bool = False
+    ltx2_audio_only_model: bool = False
+
+    # Quantization
+    nf4_base: bool = False
+    nf4_block_size: int = 32
+    loftq_init: bool = False
+    loftq_iters: int = 2
+    fp8_w8a8: bool = False
+    w8a8_mode: Literal["int8", "fp8"] = "int8"
+    awq_calibration: bool = False
+    awq_alpha: float = 0.25
+    awq_num_batches: int = 8
+    quantize_device: Optional[str] = None
+
+    # LoRA / Network
+    network_module: Optional[str] = None
+    network_dim: int = 16
+    network_alpha: int = 16
+    lora_target_preset: Literal["t2v", "v2v", "audio", "full"] = "t2v"
+    network_args: str = ""
+    network_weights: str = ""
+    network_dropout: Optional[float] = None
+    scale_weight_norms: Optional[float] = None
+    dim_from_weights: bool = False
+    base_weights: str = ""
+    base_weights_multiplier: str = ""
+    lycoris_config: str = ""
+    lycoris_quantized_base_check_mode: Literal["off", "warn", "error"] = "warn"
+    init_lokr_norm: Optional[float] = None
+    caption_dropout_rate: float = 0.0
+    save_original_lora: bool = True
+    ic_lora_strategy: Literal["auto", "none", "v2v", "audio_ref_only_ic"] = "auto"
+    audio_ref_use_negative_positions: bool = False
+    audio_ref_mask_cross_attention_to_reference: bool = False
+    audio_ref_mask_reference_from_text_attention: bool = False
+    audio_ref_identity_guidance_scale: float = 0.0
+
+    # Optimizer
+    learning_rate: float = 1e-4
+    optimizer_type: str = "adamw8bit"
+    optimizer_args: str = ""
+    lr_scheduler: str = "constant_with_warmup"
+    lr_warmup_steps: int = 100
+    lr_decay_steps: Optional[int] = None
+    lr_scheduler_num_cycles: Optional[int] = None
+    lr_scheduler_power: Optional[float] = None
+    lr_scheduler_min_lr_ratio: Optional[float] = None
+    lr_scheduler_type: str = ""
+    lr_scheduler_args: str = ""
+    lr_scheduler_timescale: Optional[int] = None
+    gradient_accumulation_steps: int = 1
+    max_grad_norm: float = 1.0
+    audio_lr: Optional[float] = None
+    lr_args: str = ""
+
+    # Schedule
+    max_train_steps: int = 1600
+    max_train_epochs: Optional[int] = None
+    timestep_sampling: str = "shifted_logit_normal"
+    discrete_flow_shift: float = 1.0
+    weighting_scheme: str = "none"
+    seed: Optional[int] = None
+    guidance_scale: Optional[float] = None
+    sigmoid_scale: Optional[float] = None
+    logit_mean: Optional[float] = None
+    logit_std: Optional[float] = None
+    mode_scale: Optional[float] = None
+    min_timestep: Optional[float] = None
+    max_timestep: Optional[float] = None
+
+    # Advanced timestep
+    shifted_logit_mode: Optional[str] = None
+    shifted_logit_eps: float = 1e-3
+    shifted_logit_uniform_prob: float = 0.1
+    shifted_logit_shift: Optional[float] = None
+    preserve_distribution_shape: bool = False
+    num_timestep_buckets: Optional[int] = None
+
+    # Memory
+    blocks_to_swap: Optional[int] = None
+    gradient_checkpointing: bool = True
+    gradient_checkpointing_cpu_offload: bool = False
+    split_attn_target: Optional[str] = None
+    split_attn_mode: Optional[str] = None
+    split_attn_chunk_size: Optional[int] = None
+    blockwise_checkpointing: bool = False
+    blocks_to_checkpoint: Optional[int] = None
+    mixed_precision: str = "bf16"
+    full_fp16: bool = False
+    full_bf16: bool = False
+    ffn_chunk_target: Optional[str] = None
+    ffn_chunk_size: int = 0
+    use_pinned_memory_for_block_swap: bool = False
+    img_in_txt_in_offloading: bool = False
+
+    # Compile
+    compile: bool = False
+    compile_backend: str = "inductor"
+    compile_mode: str = ""
+    compile_dynamic: bool = False
+    compile_fullgraph: bool = False
+    compile_cache_size_limit: Optional[int] = None
+
+    # CUDA
+    cuda_allow_tf32: bool = False
+    cuda_cudnn_benchmark: bool = False
+    cuda_memory_fraction: Optional[float] = None
+
+    # Sampling
+    sample_every_n_steps: Optional[int] = None
+    sample_every_n_epochs: Optional[int] = None
+    sample_prompts: str = ""
+    use_precached_sample_prompts: bool = False
+    sample_prompts_cache: str = ""
+    use_precached_sample_latents: bool = False
+    sample_latents_cache: str = ""
+    height: int = 512
+    width: int = 768
+    sample_num_frames: int = 45
+    sample_with_offloading: bool = False
+    sample_merge_audio: bool = False
+    sample_disable_audio: bool = False
+    sample_at_first: bool = False
+    sample_tiled_vae: bool = False
+    sample_vae_tile_size: Optional[int] = None
+    sample_vae_tile_overlap: Optional[int] = None
+    sample_vae_temporal_tile_size: Optional[int] = None
+    sample_vae_temporal_tile_overlap: Optional[int] = None
+    sample_two_stage: bool = False
+    spatial_upsampler_path: str = ""
+    distilled_lora_path: str = ""
+    sample_stage2_steps: int = 3
+    sample_audio_only: bool = False
+    sample_disable_flash_attn: bool = False
+    sample_i2v_token_timestep_mask: bool = True
+    sample_audio_subprocess: bool = True
+    sample_include_reference: bool = False
+    reference_downscale: int = 1
+    reference_frames: int = 1
+
+    # Validation
+    validate_every_n_steps: Optional[int] = None
+    validate_every_n_epochs: Optional[int] = None
+
+    # Output
+    output_dir: str = ""
+    output_name: str = "ltx2_lora"
+    save_every_n_epochs: Optional[int] = None
+    save_every_n_steps: Optional[int] = None
+    save_last_n_epochs: Optional[int] = None
+    save_last_n_steps: Optional[int] = None
+    save_last_n_epochs_state: Optional[int] = None
+    save_last_n_steps_state: Optional[int] = None
+    save_state: bool = False
+    save_state_on_train_end: bool = False
+    save_checkpoint_metadata: bool = False
+    no_metadata: bool = False
+    no_convert_to_comfy: bool = False
+    log_with: Optional[str] = None
+    logging_dir: str = ""
+    log_prefix: str = ""
+    log_tracker_name: str = ""
+    wandb_run_name: str = ""
+    wandb_api_key: str = ""
+    log_cuda_memory_every_n_steps: Optional[int] = None
+    resume: str = ""
+    training_comment: str = ""
+    loss_type: Literal["mse", "mae", "l1", "huber", "smooth_l1"] = "mse"
+    huber_delta: float = 1.0
+
+    # Metadata
+    metadata_title: str = ""
+    metadata_author: str = ""
+    metadata_description: str = ""
+    metadata_license: str = ""
+    metadata_tags: str = ""
+
+    # HuggingFace upload
+    huggingface_repo_id: str = ""
+    huggingface_repo_type: str = ""
+    huggingface_path_in_repo: str = ""
+    huggingface_token: str = ""
+    huggingface_repo_visibility: str = ""
+    save_state_to_huggingface: bool = False
+    resume_from_huggingface: bool = False
+    async_upload: bool = False
+
+    # Dataset
+    dataset_manifest: str = ""
+
+    # Preservation
+    blank_preservation: bool = False
+    blank_preservation_multiplier: float = 1.0
+    dop: bool = False
+    dop_class: str = ""
+    dop_multiplier: float = 1.0
+    prior_divergence: bool = False
+    prior_divergence_multiplier: float = 0.1
+    use_precached_preservation: bool = False
+    preservation_prompts_cache: str = ""
+
+    # CREPA
+    crepa: bool = False
+    crepa_mode: Literal["backbone", "dino"] = "backbone"
+    crepa_student_block_idx: int = 16
+    crepa_teacher_block_idx: int = 32
+    crepa_dino_model: Literal["dinov2_vits14", "dinov2_vitb14", "dinov2_vitl14", "dinov2_vitg14"] = "dinov2_vitb14"
+    crepa_lambda: float = 0.1
+    crepa_tau: float = 1.0
+    crepa_num_neighbors: int = 2
+    crepa_schedule: Literal["constant", "linear", "cosine"] = "constant"
+    crepa_warmup_steps: int = 0
+    crepa_normalize: bool = True
+
+    # Self-Flow
+    self_flow: bool = False
+    self_flow_teacher_mode: Literal["base", "ema", "partial_ema"] = "base"
+    self_flow_student_block_idx: int = 16
+    self_flow_teacher_block_idx: int = 32
+    self_flow_student_block_ratio: float = 0.3
+    self_flow_teacher_block_ratio: float = 0.7
+    self_flow_student_block_stochastic_range: int = 0
+    self_flow_lambda: float = 0.1
+    self_flow_mask_ratio: float = 0.1
+    self_flow_frame_level_mask: bool = False
+    self_flow_mask_focus_loss: bool = False
+    self_flow_max_loss: float = 0.0
+    self_flow_teacher_momentum: float = 0.999
+    self_flow_dual_timestep: bool = True
+    self_flow_projector_lr: Optional[float] = None
+    self_flow_temporal_mode: Literal["off", "frame", "delta", "hybrid"] = "off"
+    self_flow_lambda_temporal: float = 0.0
+    self_flow_lambda_delta: float = 0.0
+    self_flow_temporal_tau: float = 1.0
+    self_flow_num_neighbors: int = 2
+    self_flow_temporal_granularity: Literal["frame", "patch"] = "frame"
+    self_flow_patch_spatial_radius: int = 0
+    self_flow_patch_match_mode: Literal["hard", "soft"] = "hard"
+    self_flow_delta_num_steps: int = 1
+    self_flow_motion_weighting: Literal["none", "teacher_delta"] = "none"
+    self_flow_motion_weight_strength: float = 0.0
+    self_flow_temporal_schedule: Literal["constant", "linear", "cosine"] = "constant"
+    self_flow_temporal_warmup_steps: int = 0
+    self_flow_temporal_max_steps: int = 0
+    self_flow_offload_teacher_features: bool = False
+
+    # Audio features
+    audio_loss_balance_mode: Literal["none", "inv_freq", "ema_mag"] = "none"
+    audio_loss_balance_beta: float = 0.01
+    audio_loss_balance_eps: float = 0.05
+    audio_loss_balance_min: float = 0.05
+    audio_loss_balance_max: float = 4.0
+    audio_loss_balance_ema_init: float = 1.0
+    audio_loss_balance_target_ratio: float = 0.33
+    audio_loss_balance_ema_decay: float = 0.99
+    independent_audio_timestep: bool = False
+    audio_silence_regularizer: bool = False
+    audio_silence_regularizer_weight: float = 1.0
+    audio_supervision_mode: Literal["off", "warn", "error"] = "off"
+    audio_supervision_warmup_steps: int = 50
+    audio_supervision_check_interval: int = 50
+    audio_supervision_min_ratio: float = 0.9
+    audio_dop: bool = False
+    audio_dop_multiplier: float = 0.5
+    audio_bucket_strategy: Optional[str] = None
+    audio_bucket_interval: Optional[float] = None
+    audio_only_sequence_resolution: int = 64
+    min_audio_batches_per_accum: int = 0
+    audio_batch_probability: Optional[float] = None
+
+    # Loss weighting
+    video_loss_weight: float = 1.0
+    audio_loss_weight: float = 1.0
+
+    # Misc
+    separate_audio_buckets: bool = True
+    max_data_loader_n_workers: int = 2
+    persistent_data_loader_workers: bool = True
+    ltx2_first_frame_conditioning_p: float = 0.1
+
+
+class InferenceConfig(BaseModel):
+    ltx2_checkpoint: str = ""
+    gemma_root: str = ""
+    lora_weight: str = ""
+    lora_multiplier: float = 1.0
+    prompt: str = ""
+    negative_prompt: str = ""
+    from_file: str = ""
+    output_dir: str = "output"
+    output_name: str = "ltx2_sample"
+    height: int = 512
+    width: int = 768
+    frame_count: int = 45
+    frame_rate: float = 25.0
+    sample_steps: int = 20
+    guidance_scale: float = 1.0
+    cfg_scale: Optional[float] = None
+    discrete_flow_shift: float = 5.0
+    seed: Optional[int] = None
+    mixed_precision: Literal["no", "fp16", "bf16"] = "bf16"
+    ltx2_mode: Literal["video", "av", "audio"] = "video"
+    attn_mode: str = "torch"
+    fp8_base: bool = False
+    fp8_scaled: bool = False
+    offloading: bool = False
+    blocks_to_swap: Optional[int] = None
+    gemma_load_in_8bit: bool = False
+    gemma_load_in_4bit: bool = False
+
+
+class SliderTargetConfig(BaseModel):
+    positive: str = ""
+    negative: str = ""
+    target_class: str = ""
+    weight: float = 1.0
+
+
+class SliderConfig(BaseModel):
+    model_config = ConfigDict(extra="ignore")  # old projects may have fields that moved to TrainingConfig
+
+    # Mode
+    mode: Literal["text", "reference"] = "text"
+
+    # Targets (text-only mode)
+    targets: list[SliderTargetConfig] = Field(default_factory=lambda: [SliderTargetConfig()])
+
+    # Text mode settings
+    guidance_strength: float = 1.0
+    latent_frames: int = 1
+    latent_height: int = 512
+    latent_width: int = 768
+
+    # Sampling
+    sample_slider_range: str = "-2,-1,0,1,2"
+
+    # Slider-specific overrides (empty = inherit from training config)
+    max_train_steps: int = 500
+    output_name: str = "ltx2_slider"
+
+
+class ProjectConfig(BaseModel):
+    version: int = 1
+    name: str = "New Project"
+    project_dir: str = ""
+    model_dir: str = ""  # directory where downloaded models are stored
+    dataset: DatasetConfig = Field(default_factory=DatasetConfig)
+    caching: CachingConfig = Field(default_factory=CachingConfig)
+    training: TrainingConfig = Field(default_factory=TrainingConfig)
+    inference: InferenceConfig = Field(default_factory=InferenceConfig)
+    slider: SliderConfig = Field(default_factory=SliderConfig)
+
+    @model_validator(mode='before')
+    @classmethod
+    def _migrate_sampling_key(cls, data):
+        """Backward compat: rename old 'sampling' key to 'inference'."""
+        if isinstance(data, dict) and 'sampling' in data and 'inference' not in data:
+            data['inference'] = data.pop('sampling')
+        return data
+
+    def save(self, path: Optional[Path] = None):
+        p = path or Path(self.project_dir) / "project.json"
+        p.parent.mkdir(parents=True, exist_ok=True)
+        p.write_text(self.model_dump_json(indent=2), encoding="utf-8")
+
+    @classmethod
+    def load(cls, path: Path) -> "ProjectConfig":
+        return cls.model_validate_json(path.read_text(encoding="utf-8"))

src/musubi_tuner/gui_dashboard/server.py

@@ -0,0 +1,111 @@
+import asyncio
+import logging
+import mimetypes
+import os
+import threading
+
+# Windows registry often maps .js to text/plain — fix it
+mimetypes.add_type("application/javascript", ".js")
+mimetypes.add_type("text/css", ".css")
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse, HTMLResponse, Response
+from fastapi.staticfiles import StaticFiles
+from sse_starlette.sse import EventSourceResponse
+
+logger = logging.getLogger(__name__)
+
+FRONTEND_DIST = os.path.join(os.path.dirname(__file__), "frontend", "dist")
+
+
+def create_app(run_dir: str) -> FastAPI:
+    app = FastAPI(title="Training Dashboard")
+    dashboard_dir = os.path.join(run_dir, "dashboard")
+    sample_dir = os.path.join(run_dir, "sample")
+
+    # -- data endpoints --
+
+    @app.get("/data/metrics.parquet")
+    async def get_metrics():
+        path = os.path.join(dashboard_dir, "metrics.parquet")
+        if not os.path.exists(path):
+            return Response(status_code=204)
+        return FileResponse(path, media_type="application/octet-stream")
+
+    @app.get("/data/status.json")
+    async def get_status():
+        path = os.path.join(dashboard_dir, "status.json")
+        if not os.path.exists(path):
+            return Response(status_code=204)
+        return FileResponse(path, media_type="application/json")
+
+    @app.get("/data/events.json")
+    async def get_events():
+        path = os.path.join(dashboard_dir, "events.json")
+        if not os.path.exists(path):
+            return Response(status_code=204)
+        return FileResponse(path, media_type="application/json")
+
+    # -- SSE --
+
+    @app.get("/sse")
+    async def sse_stream():
+        metrics_path = os.path.join(dashboard_dir, "metrics.parquet")
+
+        async def event_generator():
+            last_mtime = 0.0
+            while True:
+                await asyncio.sleep(2)
+                try:
+                    mtime = os.path.getmtime(metrics_path) if os.path.exists(metrics_path) else 0.0
+                except OSError:
+                    mtime = 0.0
+                if mtime > last_mtime:
+                    last_mtime = mtime
+                    yield {"event": "update", "data": f'{{"mtime": {mtime}}}'}
+
+        return EventSourceResponse(event_generator())
+
+    # -- samples static files --
+
+    if os.path.isdir(sample_dir):
+        app.mount("/data/samples", StaticFiles(directory=sample_dir), name="samples")
+    else:
+        # Create the dir so the mount doesn't fail; samples will appear later
+        os.makedirs(sample_dir, exist_ok=True)
+        app.mount("/data/samples", StaticFiles(directory=sample_dir), name="samples")
+
+    # -- SvelteKit frontend (must be last - catches all other routes) --
+
+    if os.path.isdir(FRONTEND_DIST):
+        # Serve index.html for SPA routing
+        @app.get("/{full_path:path}")
+        async def serve_frontend(full_path: str):
+            file_path = os.path.join(FRONTEND_DIST, full_path)
+            if full_path and os.path.isfile(file_path):
+                return FileResponse(file_path)
+            return FileResponse(os.path.join(FRONTEND_DIST, "index.html"))
+    else:
+        @app.get("/")
+        async def no_frontend():
+            return HTMLResponse(
+                "<h2>Training Dashboard</h2>"
+                "<p>Frontend not built. Run <code>npm run build</code> in <code>gui_dashboard/frontend/</code></p>"
+                "<p>API available at <code>/data/metrics.parquet</code>, <code>/data/status.json</code>, <code>/data/events.json</code></p>"
+            )
+
+    return app
+
+
+def start_server(run_dir: str, host: str = "0.0.0.0", port: int = 7860):
+    import uvicorn
+
+    app = create_app(run_dir)
+
+    def _run():
+        uvicorn.run(app, host=host, port=port, log_level="warning")
+
+    t = threading.Thread(target=_run, daemon=True, name="dashboard-server")
+    t.start()
+    logger.info(f"Training dashboard started at http://{host}:{port}")
+    return t

src/musubi_tuner/gui_dashboard/toml_export.py

@@ -0,0 +1,176 @@
+"""TOML serialization for dataset and slider configs."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+try:
+    import tomli_w
+except ImportError:
+    tomli_w = None
+
+try:
+    import tomllib
+except ImportError:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+from musubi_tuner.gui_dashboard.project_schema import ProjectConfig
+
+
+def _toml_value(v) -> str:
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    if isinstance(v, int):
+        return str(v)
+    if isinstance(v, float):
+        return str(v)
+    if isinstance(v, str):
+        return f'"{v}"'
+    if isinstance(v, list):
+        items = ", ".join(_toml_value(i) for i in v)
+        return f"[{items}]"
+    return str(v)
+
+
+def _write_toml_fallback(doc: dict, path: Path):
+    """Simple TOML writer for when tomli_w is not available."""
+    lines = []
+
+    if "general" in doc:
+        lines.append("[general]")
+        for k, v in doc["general"].items():
+            lines.append(f"{k} = {_toml_value(v)}")
+        lines.append("")
+
+    for section_name in ("datasets", "validation_datasets"):
+        if section_name not in doc:
+            continue
+        for entry in doc[section_name]:
+            lines.append(f"[[{section_name}]]")
+            for k, v in entry.items():
+                lines.append(f"{k} = {_toml_value(v)}")
+            lines.append("")
+
+    path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def _dataset_entry_to_dict(entry) -> dict:
+    """Convert a DatasetEntry to a TOML-ready dict."""
+    d: dict = {}
+    # Directory or JSONL source
+    if entry.jsonl_file:
+        key_prefix = {"video": "video", "image": "image", "audio": "audio"}[entry.type]
+        d[f"{key_prefix}_jsonl_file"] = entry.jsonl_file
+    else:
+        if entry.type == "video":
+            d["video_directory"] = entry.directory
+        elif entry.type == "image":
+            d["image_directory"] = entry.directory
+        elif entry.type == "audio":
+            d["audio_directory"] = entry.directory
+
+    d["cache_directory"] = entry.cache_directory
+    if entry.reference_cache_directory:
+        d["reference_cache_directory"] = entry.reference_cache_directory
+    if entry.control_directory:
+        d["control_directory"] = entry.control_directory
+    if entry.type != "audio":
+        d["resolution"] = [entry.resolution_w, entry.resolution_h]
+    d["batch_size"] = entry.batch_size
+    d["num_repeats"] = entry.num_repeats
+    d["caption_extension"] = entry.caption_extension
+
+    if entry.type == "video":
+        d["target_frames"] = [entry.target_frames]
+        d["frame_extraction"] = entry.frame_extraction
+        if entry.frame_sample is not None:
+            d["frame_sample"] = entry.frame_sample
+        if entry.max_frames is not None:
+            d["max_frames"] = entry.max_frames
+        if entry.frame_stride is not None:
+            d["frame_stride"] = entry.frame_stride
+        if entry.source_fps is not None:
+            d["source_fps"] = entry.source_fps
+        if entry.target_fps is not None:
+            d["target_fps"] = entry.target_fps
+
+    return d
+
+
+def _write_dataset_toml(config: ProjectConfig, output_path: Path) -> Path:
+    """Generate dataset_config.toml from project config and return path."""
+    doc: dict = {}
+
+    # General section
+    doc["general"] = {
+        "enable_bucket": config.dataset.general.enable_bucket,
+        "bucket_no_upscale": config.dataset.general.bucket_no_upscale,
+    }
+
+    # Datasets
+    doc["datasets"] = [_dataset_entry_to_dict(e) for e in config.dataset.datasets]
+
+    # Validation datasets
+    if config.dataset.validation_datasets:
+        doc["validation_datasets"] = [
+            _dataset_entry_to_dict(e) for e in config.dataset.validation_datasets
+        ]
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    if tomli_w is not None:
+        output_path.write_bytes(tomli_w.dumps(doc).encode("utf-8"))
+    else:
+        _write_toml_fallback(doc, output_path)
+
+    return output_path
+
+
+def build_dataset_toml_path(config: ProjectConfig) -> Path:
+    return Path(config.project_dir) / "dataset_config.toml"
+
+
+def export_dataset_toml(config: ProjectConfig) -> Path:
+    return _write_dataset_toml(config, build_dataset_toml_path(config))
+
+
+def _write_slider_toml(config: ProjectConfig, output_path: Path) -> Path:
+    """Generate slider_config.toml from project config and return path."""
+    s = config.slider
+    doc: dict = {
+        "mode": s.mode,
+        "guidance_strength": s.guidance_strength,
+    }
+
+    # Parse sample_slider_range
+    try:
+        doc["sample_slider_range"] = [float(x.strip()) for x in s.sample_slider_range.split(",")]
+    except (ValueError, AttributeError):
+        doc["sample_slider_range"] = [-2.0, -1.0, 0.0, 1.0, 2.0]
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Write TOML with targets as [[targets]] array
+    lines = []
+    for k, v in doc.items():
+        lines.append(f"{k} = {_toml_value(v)}")
+    lines.append("")
+
+    for target in s.targets:
+        lines.append("[[targets]]")
+        lines.append(f'positive = "{target.positive}"')
+        lines.append(f'negative = "{target.negative}"')
+        if target.target_class:
+            lines.append(f'target_class = "{target.target_class}"')
+        lines.append(f"weight = {target.weight}")
+        lines.append("")
+
+    output_path.write_text("\n".join(lines), encoding="utf-8")
+    return output_path
+
+
+def build_slider_toml_path(config: ProjectConfig) -> Path:
+    return Path(config.project_dir) / "slider_config.toml"

src/musubi_tuner/hunyuan_model/activation_layers.py

@@ -0,0 +1,23 @@
+import torch.nn as nn
+
+
+def get_activation_layer(act_type):
+    """get activation layer
+
+    Args:
+        act_type (str): the activation type
+
+    Returns:
+        torch.nn.functional: the activation layer
+    """
+    if act_type == "gelu":
+        return lambda: nn.GELU()
+    elif act_type == "gelu_tanh":
+        # Approximate `tanh` requires torch >= 1.13
+        return lambda: nn.GELU(approximate="tanh")
+    elif act_type == "relu":
+        return nn.ReLU
+    elif act_type == "silu":
+        return nn.SiLU
+    else:
+        raise ValueError(f"Unknown activation type: {act_type}")

src/musubi_tuner/hunyuan_model/attention.py

@@ -0,0 +1,309 @@
+import math
+
+import torch
+import torch.nn.functional as F
+
+try:
+    import flash_attn
+    from flash_attn.flash_attn_interface import _flash_attn_forward
+    from flash_attn.flash_attn_interface import flash_attn_varlen_func
+    from flash_attn.flash_attn_interface import flash_attn_func
+except ImportError:
+    flash_attn = None
+    flash_attn_varlen_func = None
+    _flash_attn_forward = None
+    flash_attn_func = None
+
+try:
+    print("Trying to import sageattention")
+    from sageattention import sageattn_varlen, sageattn
+
+    print("Successfully imported sageattention")
+except ImportError:
+    print("Failed to import sageattention")
+    sageattn_varlen = None
+    sageattn = None
+
+try:
+    import xformers.ops as xops
+except ImportError:
+    xops = None
+
+MEMORY_LAYOUT = {
+    "flash": (
+        lambda x: x.view(x.shape[0] * x.shape[1], *x.shape[2:]),
+        lambda x: x,
+    ),
+    "flash_fixlen": (
+        lambda x: x,
+        lambda x: x,
+    ),
+    "sageattn": (
+        lambda x: x.view(x.shape[0] * x.shape[1], *x.shape[2:]),
+        lambda x: x,
+    ),
+    "sageattn_fixlen": (
+        lambda x: x.transpose(1, 2),
+        lambda x: x.transpose(1, 2),
+    ),
+    "torch": (
+        lambda x: x.transpose(1, 2),
+        lambda x: x.transpose(1, 2),
+    ),
+    "xformers": (
+        lambda x: x,
+        lambda x: x,
+    ),
+    "vanilla": (
+        lambda x: x.transpose(1, 2),
+        lambda x: x.transpose(1, 2),
+    ),
+}
+
+
+def get_cu_seqlens(text_mask, img_len):
+    """Calculate cu_seqlens_q, cu_seqlens_kv using text_mask and img_len
+
+    Args:
+        text_mask (torch.Tensor): the mask of text
+        img_len (int): the length of image
+
+    Returns:
+        torch.Tensor: the calculated cu_seqlens for flash attention
+    """
+    batch_size = text_mask.shape[0]
+    text_len = text_mask.sum(dim=1)
+    max_len = text_mask.shape[1] + img_len
+
+    cu_seqlens = torch.zeros([2 * batch_size + 1], dtype=torch.int32, device="cuda")
+
+    for i in range(batch_size):
+        s = text_len[i] + img_len
+        s1 = i * max_len + s
+        s2 = (i + 1) * max_len
+        cu_seqlens[2 * i + 1] = s1
+        cu_seqlens[2 * i + 2] = s2
+
+    return cu_seqlens
+
+
+def attention(
+    q_or_qkv_list,
+    k=None,
+    v=None,
+    mode="flash",
+    drop_rate=0,
+    attn_mask=None,
+    total_len=None,
+    causal=False,
+    cu_seqlens_q=None,
+    cu_seqlens_kv=None,
+    max_seqlen_q=None,
+    max_seqlen_kv=None,
+    batch_size=1,
+):
+    """
+    Perform QKV self attention.
+
+    Args:
+        q (torch.Tensor): Query tensor with shape [b, s, a, d], where a is the number of heads.
+        k (torch.Tensor): Key tensor with shape [b, s1, a, d]
+        v (torch.Tensor): Value tensor with shape [b, s1, a, d]
+        mode (str): Attention mode. Choose from 'self_flash', 'cross_flash', 'torch', and 'vanilla'.
+        drop_rate (float): Dropout rate in attention map. (default: 0)
+        attn_mask (torch.Tensor): Attention mask with shape [b, s1] (cross_attn), or [b, a, s, s1] (torch or vanilla).
+            (default: None)
+        causal (bool): Whether to use causal attention. (default: False)
+        cu_seqlens_q (torch.Tensor): dtype torch.int32. The cumulative sequence lengths of the sequences in the batch,
+            used to index into q.
+        cu_seqlens_kv (torch.Tensor): dtype torch.int32. The cumulative sequence lengths of the sequences in the batch,
+            used to index into kv.
+        max_seqlen_q (int): The maximum sequence length in the batch of q.
+        max_seqlen_kv (int): The maximum sequence length in the batch of k and v.
+
+    Returns:
+        torch.Tensor: Output tensor after self attention with shape [b, s, ad]
+    """
+    q, k, v = q_or_qkv_list if type(q_or_qkv_list) == list else (q_or_qkv_list, k, v)
+    if type(q_or_qkv_list) == list:
+        q_or_qkv_list.clear()
+    split_attn = total_len is not None
+    if (split_attn or cu_seqlens_q is None) and mode == "sageattn":
+        mode = "sageattn_fixlen"
+    elif (split_attn or cu_seqlens_q is None) and mode == "flash":
+        mode = "flash_fixlen"
+    # print(f"Attention mode: {mode}, split_attn: {split_attn}")
+    pre_attn_layout, post_attn_layout = MEMORY_LAYOUT[mode]
+
+    # trim the sequence length to the actual length instead of attn_mask
+    if split_attn:
+        trimmed_len = q.shape[1] - total_len
+        q = [q[i : i + 1, : total_len[i]] for i in range(len(q))]
+        k = [k[i : i + 1, : total_len[i]] for i in range(len(k))]
+        v = [v[i : i + 1, : total_len[i]] for i in range(len(v))]
+        q = [pre_attn_layout(q_i) for q_i in q]
+        k = [pre_attn_layout(k_i) for k_i in k]
+        v = [pre_attn_layout(v_i) for v_i in v]
+        # print(
+        #     f"Trimming the sequence length to {total_len},trimmed_len: {trimmed_len}, q.shape: {[q_i.shape for q_i in q]}, mode: {mode}"
+        # )
+    else:
+        q = pre_attn_layout(q)
+        k = pre_attn_layout(k)
+        v = pre_attn_layout(v)
+
+    if mode == "torch":
+        if split_attn:
+            x = []
+            for i in range(len(q)):
+                x_i = F.scaled_dot_product_attention(q[i], k[i], v[i], dropout_p=drop_rate, is_causal=causal)
+                q[i], k[i], v[i] = None, None, None
+                x.append(x_i)
+            del q, k, v
+        else:
+            if attn_mask is not None and attn_mask.dtype != torch.bool:
+                attn_mask = attn_mask.to(q.dtype)
+            x = F.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask, dropout_p=drop_rate, is_causal=causal)
+            del q, k, v
+            del attn_mask
+
+    elif mode == "xformers":
+        # B, M, H, K: M is the sequence length, H is the number of heads, K is the dimension of the heads -> it is same as input dimension
+        # currently only support batch_size = 1
+        assert split_attn or cu_seqlens_q is None, "Xformers only supports splitting"
+        if split_attn:
+            x = []
+            for i in range(len(q)):
+                x_i = xops.memory_efficient_attention(q[i], k[i], v[i], p=drop_rate)  # , causal=causal)
+                q[i], k[i], v[i] = None, None, None
+                x.append(x_i)
+            del q, k, v
+        else:
+            x = xops.memory_efficient_attention(q, k, v, p=drop_rate)
+            del q, k, v
+
+    elif mode == "flash":
+        x = flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+        del q, k, v
+        # x with shape [(bxs), a, d]
+        x = x.view(batch_size, max_seqlen_q, x.shape[-2], x.shape[-1])  # reshape x to [b, s, a, d]
+
+    elif mode == "flash_fixlen":
+        if split_attn:
+            x = []
+            for i in range(len(q)):
+                # q: (batch_size, seqlen, nheads, headdim), k: (batch_size, seqlen, nheads_k, headdim), v: (batch_size, seqlen, nheads_k, headdim)
+                x_i = flash_attn_func(q[i], k[i], v[i], dropout_p=drop_rate, causal=causal)
+                q[i], k[i], v[i] = None, None, None
+                x.append(x_i)
+            del q, k, v
+        else:
+            x = flash_attn_func(q, k, v, dropout_p=drop_rate, causal=causal)
+            del q, k, v  # this causes error in compiled mode with fullgraph=True
+
+    elif mode == "sageattn":
+        x = sageattn_varlen(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+        del q, k, v
+        # x with shape [(bxs), a, d]
+        x = x.view(batch_size, max_seqlen_q, x.shape[-2], x.shape[-1])  # reshape x to [b, s, a, d]
+
+    elif mode == "sageattn_fixlen":
+        if split_attn:
+            x = []
+            for i in range(len(q)):
+                # HND seems to cause an error
+                x_i = sageattn(q[i], k[i], v[i])  # (batch_size, seq_len, head_num, head_dim)
+                q[i], k[i], v[i] = None, None, None
+                x.append(x_i)
+            del q, k, v
+        else:
+            x = sageattn(q, k, v)
+            del q, k, v
+
+    elif mode == "vanilla":
+        assert not split_attn, "Vanilla attention does not support trimming"
+        scale_factor = 1 / math.sqrt(q.size(-1))
+
+        b, a, s, _ = q.shape
+        s1 = k.size(2)
+        attn_bias = torch.zeros(b, a, s, s1, dtype=q.dtype, device=q.device)
+        if causal:
+            # Only applied to self attention
+            assert attn_mask is None, "Causal mask and attn_mask cannot be used together"
+            temp_mask = torch.ones(b, a, s, s, dtype=torch.bool, device=q.device).tril(diagonal=0)
+            attn_bias.masked_fill_(temp_mask.logical_not(), float("-inf"))
+            attn_bias.to(q.dtype)
+
+        if attn_mask is not None:
+            if attn_mask.dtype == torch.bool:
+                attn_bias.masked_fill_(attn_mask.logical_not(), float("-inf"))
+            else:
+                attn_bias += attn_mask
+
+        # TODO: Maybe force q and k to be float32 to avoid numerical overflow
+        attn = (q @ k.transpose(-2, -1)) * scale_factor
+        attn += attn_bias
+        attn = attn.softmax(dim=-1)
+        attn = torch.dropout(attn, p=drop_rate, train=True)
+        x = attn @ v
+    else:
+        raise NotImplementedError(f"Unsupported attention mode: {mode}")
+
+    if split_attn:
+        x = [post_attn_layout(x_i) for x_i in x]
+        for i in range(len(x)):
+            x[i] = F.pad(x[i], (0, 0, 0, 0, 0, trimmed_len[i]))
+        x = torch.cat(x, dim=0)
+    else:
+        x = post_attn_layout(x)
+
+    b, s, a, d = x.shape
+    x = x.reshape(b, s, -1)
+    return x
+
+
+def parallel_attention(hybrid_seq_parallel_attn, q, k, v, img_q_len, img_kv_len, cu_seqlens_q, cu_seqlens_kv):
+    attn1 = hybrid_seq_parallel_attn(
+        None,
+        q[:, :img_q_len, :, :],
+        k[:, :img_kv_len, :, :],
+        v[:, :img_kv_len, :, :],
+        dropout_p=0.0,
+        causal=False,
+        joint_tensor_query=q[:, img_q_len : cu_seqlens_q[1]],
+        joint_tensor_key=k[:, img_kv_len : cu_seqlens_kv[1]],
+        joint_tensor_value=v[:, img_kv_len : cu_seqlens_kv[1]],
+        joint_strategy="rear",
+    )
+    if flash_attn.__version__ >= "2.7.0":
+        attn2, *_ = _flash_attn_forward(
+            q[:, cu_seqlens_q[1] :],
+            k[:, cu_seqlens_kv[1] :],
+            v[:, cu_seqlens_kv[1] :],
+            dropout_p=0.0,
+            softmax_scale=q.shape[-1] ** (-0.5),
+            causal=False,
+            window_size_left=-1,
+            window_size_right=-1,
+            softcap=0.0,
+            alibi_slopes=None,
+            return_softmax=False,
+        )
+    else:
+        attn2, *_ = _flash_attn_forward(
+            q[:, cu_seqlens_q[1] :],
+            k[:, cu_seqlens_kv[1] :],
+            v[:, cu_seqlens_kv[1] :],
+            dropout_p=0.0,
+            softmax_scale=q.shape[-1] ** (-0.5),
+            causal=False,
+            window_size=(-1, -1),
+            softcap=0.0,
+            alibi_slopes=None,
+            return_softmax=False,
+        )
+    attn = torch.cat([attn1, attn2], dim=1)
+    b, s, a, d = attn.shape
+    attn = attn.reshape(b, s, -1)
+
+    return attn

src/musubi_tuner/hunyuan_model/embed_layers.py

@@ -0,0 +1,131 @@
+import math
+import torch
+import torch.nn as nn
+
+from musubi_tuner.hunyuan_model.helpers import to_2tuple
+
+
+class PatchEmbed(nn.Module):
+    """2D Image to Patch Embedding
+
+    Image to Patch Embedding using Conv2d
+
+    A convolution based approach to patchifying a 2D image w/ embedding projection.
+
+    Based on the impl in https://github.com/google-research/vision_transformer
+
+    Hacked together by / Copyright 2020 Ross Wightman
+
+    Remove the _assert function in forward function to be compatible with multi-resolution images.
+    """
+
+    def __init__(
+        self,
+        patch_size=16,
+        in_chans=3,
+        embed_dim=768,
+        norm_layer=None,
+        flatten=True,
+        bias=True,
+        dtype=None,
+        device=None,
+    ):
+        factory_kwargs = {"dtype": dtype, "device": device}
+        super().__init__()
+        patch_size = to_2tuple(patch_size)
+        self.patch_size = patch_size
+        self.flatten = flatten
+
+        self.proj = nn.Conv3d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size, bias=bias, **factory_kwargs)
+        nn.init.xavier_uniform_(self.proj.weight.view(self.proj.weight.size(0), -1))
+        if bias:
+            nn.init.zeros_(self.proj.bias)
+
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x):
+        x = self.proj(x)
+        if self.flatten:
+            x = x.flatten(2).transpose(1, 2)  # BCHW -> BNC
+        x = self.norm(x)
+        return x
+
+
+class TextProjection(nn.Module):
+    """
+    Projects text embeddings. Also handles dropout for classifier-free guidance.
+
+    Adapted from https://github.com/PixArt-alpha/PixArt-alpha/blob/master/diffusion/model/nets/PixArt_blocks.py
+    """
+
+    def __init__(self, in_channels, hidden_size, act_layer, dtype=None, device=None):
+        factory_kwargs = {"dtype": dtype, "device": device}
+        super().__init__()
+        self.linear_1 = nn.Linear(in_features=in_channels, out_features=hidden_size, bias=True, **factory_kwargs)
+        self.act_1 = act_layer()
+        self.linear_2 = nn.Linear(in_features=hidden_size, out_features=hidden_size, bias=True, **factory_kwargs)
+
+    def forward(self, caption):
+        hidden_states = self.linear_1(caption)
+        hidden_states = self.act_1(hidden_states)
+        hidden_states = self.linear_2(hidden_states)
+        return hidden_states
+
+
+def timestep_embedding(t, dim, max_period=10000):
+    """
+    Create sinusoidal timestep embeddings.
+
+    Args:
+        t (torch.Tensor): a 1-D Tensor of N indices, one per batch element. These may be fractional.
+        dim (int): the dimension of the output.
+        max_period (int): controls the minimum frequency of the embeddings.
+
+    Returns:
+        embedding (torch.Tensor): An (N, D) Tensor of positional embeddings.
+
+    .. ref_link: https://github.com/openai/glide-text2im/blob/main/glide_text2im/nn.py
+    """
+    half = dim // 2
+    freqs = torch.exp(-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half).to(device=t.device)
+    args = t[:, None].float() * freqs[None]
+    embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
+    if dim % 2:
+        embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
+    return embedding
+
+
+class TimestepEmbedder(nn.Module):
+    """
+    Embeds scalar timesteps into vector representations.
+    """
+
+    def __init__(
+        self,
+        hidden_size,
+        act_layer,
+        frequency_embedding_size=256,
+        max_period=10000,
+        out_size=None,
+        dtype=None,
+        device=None,
+    ):
+        factory_kwargs = {"dtype": dtype, "device": device}
+        super().__init__()
+        self.frequency_embedding_size = frequency_embedding_size
+        self.max_period = max_period
+        if out_size is None:
+            out_size = hidden_size
+
+        self.mlp = nn.Sequential(
+            nn.Linear(frequency_embedding_size, hidden_size, bias=True, **factory_kwargs),
+            act_layer(),
+            nn.Linear(hidden_size, out_size, bias=True, **factory_kwargs),
+        )
+        nn.init.normal_(self.mlp[0].weight, std=0.02)
+        nn.init.normal_(self.mlp[2].weight, std=0.02)
+
+    def forward(self, t):
+        t_freq = timestep_embedding(t, self.frequency_embedding_size, self.max_period).type(self.mlp[0].weight.dtype)
+        t_emb = self.mlp(t_freq)
+        return t_emb