Upload train.py with huggingface_hub

train.py

@@ -0,0 +1,596 @@
+import sys,os
+current_dir = os.path.dirname(__file__)
+sys.path.append(os.path.abspath(os.path.join(current_dir, '..')))
+import argparse
+import copy
+import logging
+import math
+import os
+from contextlib import contextmanager
+import functools
+import torch
+import torch.utils.checkpoint
+import transformers
+from accelerate import Accelerator
+from accelerate.logging import get_logger
+from accelerate.utils import set_seed
+from packaging import version
+from peft import LoraConfig
+from tqdm.auto import tqdm
+from transformers import CLIPTokenizer, PretrainedConfig, T5TokenizerFast
+from src.hook import save_model_hook,load_model_hook
+import diffusers
+from diffusers import (
+    AutoencoderKL,
+    FlowMatchEulerDiscreteScheduler,
+    FluxPipeline,
+)
+from src.SubjectGeniusTransformer2DModel import SubjectGeniusTransformer2DModel
+from diffusers.optimization import get_scheduler
+from diffusers.training_utils import cast_training_params, compute_density_for_timestep_sampling, compute_loss_weighting_for_sd3
+from diffusers.utils import check_min_version, is_wandb_available
+from diffusers.utils.import_utils import is_xformers_available
+from src.dataloader import get_dataset,prepare_dataset,collate_fn
+if is_wandb_available():
+    pass
+from src.text_encoder import encode_prompt
+from datetime import datetime
+# Will error if the minimal version of diffusers is not installed. Remove at your own risks.
+check_min_version("0.32.0.dev0")
+
+logger = get_logger(__name__, log_level="INFO")
+
+
+@contextmanager
+def preserve_requires_grad(model):
+    # 备份 requires_grad 状态
+    requires_grad_backup = {name: param.requires_grad for name, param in model.named_parameters()}
+    yield
+    # 恢复 requires_grad 状态
+    for name, param in model.named_parameters():
+        param.requires_grad = requires_grad_backup[name]
+def load_text_encoders(class_one, class_two):
+    text_encoder_one = class_one.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder", revision=args.revision, variant=args.variant
+    )
+    text_encoder_two = class_two.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="text_encoder_2", revision=args.revision, variant=args.variant
+    )
+    return text_encoder_one, text_encoder_two
+
+def encode_images(pixels: torch.Tensor, vae: torch.nn.Module, weight_dtype):
+    pixel_latents = vae.encode(pixels.to(vae.dtype)).latent_dist.sample()
+    pixel_latents = (pixel_latents - vae.config.shift_factor) * vae.config.scaling_factor
+    return pixel_latents.to(weight_dtype)
+
+
+def import_model_class_from_model_name_or_path(
+    pretrained_model_name_or_path: str, revision: str, subfolder: str = "text_encoder"
+):
+    text_encoder_config = PretrainedConfig.from_pretrained(
+        pretrained_model_name_or_path, subfolder=subfolder, revision=revision
+    )
+    model_class = text_encoder_config.architectures[0]
+    if model_class == "CLIPTextModel":
+        from transformers import CLIPTextModel
+
+        return CLIPTextModel
+    elif model_class == "T5EncoderModel":
+        from transformers import T5EncoderModel
+
+        return T5EncoderModel
+    else:
+        raise ValueError(f"{model_class} is not supported.")
+
+
+def parse_args(input_args=None):
+    parser = argparse.ArgumentParser(description="training script.")
+    parser.add_argument( "--pretrained_model_name_or_path",type=str,default="ckpt/FLUX.1-schnell")
+    parser.add_argument("--transformer",type=str,default="ckpt/FLUX.1-schnell",)
+    parser.add_argument("--work_dir",type=str,default="output/train_result",)
+    parser.add_argument("--output_denoising_lora",type=str,default="depth_canny_union",)
+    parser.add_argument("--pretrained_condition_lora_dir",type=str,default="ckpt/Condition_LoRA",)
+    parser.add_argument("--training_adapter",type=str,default="ckpt/FLUX.1-schnell-training-adapter",)
+    parser.add_argument("--checkpointing_steps",type=int,default=1,)
+    parser.add_argument("--resume_from_checkpoint",type=str,default=None,)
+    parser.add_argument("--rank",type=int,default=4,help="The dimension of the LoRA rank.")
+
+    parser.add_argument("--dataset_name",type=str,default=[
+            "dataset/split_SubjectSpatial200K/train",
+            "dataset/split_SubjectSpatial200K/Collection3/train",
+        ],
+    )
+    parser.add_argument("--image_column", type=str, default="image",)
+    parser.add_argument("--bbox_column",type=str,default="bbox",)
+    parser.add_argument("--canny_column",type=str,default="canny",)
+    parser.add_argument("--depth_column",type=str,default="depth",)
+    parser.add_argument("--condition_types",type=str,nargs='+',default=["depth","canny"],)
+
+    parser.add_argument("--max_sequence_length",type=int,default=512,help="Maximum sequence length to use with with the T5 text encoder")
+    parser.add_argument("--mixed_precision",type=str,default="bf16", choices=["no", "fp16", "bf16"],)
+    parser.add_argument("--cache_dir",type=str,default="cache",)
+    parser.add_argument("--seed", type=int, default=0, help="A seed for reproducible training.")
+    parser.add_argument("--resolution",type=int,default=512,)
+    parser.add_argument("--train_batch_size", type=int, default=1)
+    parser.add_argument("--num_train_epochs", type=int, default=None)
+    parser.add_argument("--max_train_steps", type=int, default=30000,)
+    parser.add_argument("--gradient_accumulation_steps",type=int,default=2)
+
+    parser.add_argument("--learning_rate",type=float,default=1e-4)
+    parser.add_argument("--scale_lr",action="store_true",default=False,)
+    parser.add_argument("--lr_scheduler",type=str,default="cosine",
+                        choices=["linear", "cosine", "cosine_with_restarts", "polynomial","constant", "constant_with_warmup"])
+    parser.add_argument("--lr_warmup_steps", type=int, default=500,)
+    parser.add_argument("--weighting_scheme",type=str,default="none",
+        choices=["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"],
+        help=('We default to the "none" weighting scheme for uniform sampling and uniform loss'),
+    )
+    parser.add_argument("--dataloader_num_workers",type=int,default=0)
+    parser.add_argument("--adam_beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_beta2", type=float, default=0.999, help="The beta2 parameter for the Adam optimizer.")
+    parser.add_argument("--adam_weight_decay", type=float, default=1e-2, help="Weight decay to use.")
+    parser.add_argument("--adam_epsilon", type=float, default=1e-08, help="Epsilon value for the Adam optimizer")
+    parser.add_argument("--max_grad_norm", default=1.0, type=float, help="Max gradient norm.")
+    parser.add_argument("--local_rank", type=int, default=-1, help="For distributed training: local_rank")
+    parser.add_argument("--enable_xformers_memory_efficient_attention", default=True)
+
+    args = parser.parse_args()
+    args.revision = None
+    args.variant = None
+    args.work_dir = os.path.join(args.work_dir,f"{datetime.now().strftime("%y_%m_%d-%H:%M")}")
+    env_local_rank = int(os.environ.get("LOCAL_RANK", -1))
+    if env_local_rank != -1 and env_local_rank != args.local_rank:
+        args.local_rank = env_local_rank
+    return args
+
+
+def main(args):
+    accelerator = Accelerator(
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        mixed_precision=args.mixed_precision,
+    )
+
+    # Make one log on every process with the configuration for debugging.
+    logging.basicConfig(
+        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
+        datefmt="%m/%d/%Y %H:%M:%S",
+        level=logging.INFO,
+    )
+    logger.info(accelerator.state, main_process_only=False)
+    if accelerator.is_local_main_process:
+        transformers.utils.logging.set_verbosity_warning()
+        diffusers.utils.logging.set_verbosity_info()
+    else:
+        transformers.utils.logging.set_verbosity_error()
+        diffusers.utils.logging.set_verbosity_error()
+
+    # If passed along, set the training seed now.
+    if args.seed is not None:
+        set_seed(args.seed)
+
+    # Handle the repository creation
+    if accelerator.is_main_process:
+        os.makedirs(args.work_dir, exist_ok=True)
+
+    # For mixed precision training we cast all non-trainable weights (vae, non-lora text_encoder and non-lora unet) to half-precision
+    # as these weights are only used for inference, keeping weights in full precision is not required.
+    weight_dtype = torch.float32
+    if accelerator.mixed_precision == "fp16":
+        weight_dtype = torch.float16
+    elif accelerator.mixed_precision == "bf16":
+        weight_dtype = torch.bfloat16
+
+    # Load the tokenizers
+    tokenizer_one = CLIPTokenizer.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="tokenizer",
+        revision=args.revision,
+    )
+    tokenizer_two = T5TokenizerFast.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="tokenizer_2",
+        revision=args.revision,
+    )
+
+    # import correct text encoder classes
+    text_encoder_cls_one = import_model_class_from_model_name_or_path(
+        args.pretrained_model_name_or_path, args.revision, subfolder="text_encoder"
+    )
+    text_encoder_cls_two = import_model_class_from_model_name_or_path(
+        args.pretrained_model_name_or_path, args.revision, subfolder="text_encoder_2"
+    )
+
+    # Load scheduler and models
+    noise_scheduler = FlowMatchEulerDiscreteScheduler.from_pretrained(
+        args.pretrained_model_name_or_path, subfolder="scheduler"
+    )
+    noise_scheduler_copy = copy.deepcopy(noise_scheduler)
+
+    text_encoder_one, text_encoder_two = load_text_encoders(text_encoder_cls_one, text_encoder_cls_two)
+    text_encoder_one = text_encoder_one.to(accelerator.device, dtype=weight_dtype)
+    text_encoder_two = text_encoder_two.to(accelerator.device, dtype=weight_dtype)
+
+    vae = AutoencoderKL.from_pretrained(
+        args.pretrained_model_name_or_path,
+        subfolder="vae",
+        revision=args.revision,
+        variant=args.variant,
+    ).to(accelerator.device, dtype=weight_dtype)
+    vae_scale_factor = 2 ** (len(vae.config.block_out_channels) - 1)
+
+
+    transformer = SubjectGeniusTransformer2DModel.from_pretrained(
+        pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+        subfolder="transformer",
+        revision=args.revision,
+        variant=args.variant
+    ).to(accelerator.device, dtype=weight_dtype)
+    # load lora !!!!!
+    lora_names = args.condition_types
+    for condition_type in lora_names:
+        transformer.load_lora_adapter(f"{args.pretrained_condition_lora_dir}/{condition_type}.safetensors", adapter_name=condition_type)
+
+    transformer.load_lora_adapter(f"{args.training_adapter}/pytorch_lora_weights.safetensors", adapter_name="schnell_assistant")
+
+    logger.info("All models loaded successfully")
+    # freeze parameters of models to save more memory
+    transformer.requires_grad_(False)
+    vae.requires_grad_(False)
+    text_encoder_one.requires_grad_(False)
+    text_encoder_two.requires_grad_(False)
+
+    logger.info("All models keeps requires_grad = False")
+
+    single_transformer_blocks_lora = [
+        f"single_transformer_blocks.{i}.proj_out"
+        for i in range(len(transformer.single_transformer_blocks))
+    ] + [
+        f"single_transformer_blocks.{i}.proj_mlp"
+        for i in range(len(transformer.single_transformer_blocks))
+    ]
+
+    transformer_lora_config = LoraConfig(
+        r=args.rank,
+        lora_alpha=args.rank,
+        init_lora_weights="gaussian",
+        target_modules=[
+            "x_embedder",
+            "norm1.linear",
+            "attn.to_q",
+            "attn.to_k",
+            "attn.to_v",
+            "attn.to_out.0",
+            "ff.net.2",
+            "norm.linear",
+        ]+single_transformer_blocks_lora,
+    )
+    transformer.add_adapter(transformer_lora_config,adapter_name=args.output_denoising_lora)
+    logger.info(f"Trainable lora: {args.output_denoising_lora} is loaded successfully")
+    # hook
+    accelerator.register_save_state_pre_hook(functools.partial(save_model_hook,wanted_model=transformer,accelerator=accelerator,adapter_names=[args.output_denoising_lora]))
+    accelerator.register_load_state_pre_hook(functools.partial(load_model_hook,wanted_model=transformer,accelerator=accelerator,adapter_names=[args.output_denoising_lora]))
+    logger.info("Hooks for save and load is ok.")
+
+    if args.enable_xformers_memory_efficient_attention:
+        if is_xformers_available():
+            import xformers
+
+            xformers_version = version.parse(xformers.__version__)
+            if xformers_version == version.parse("0.0.16"):
+                logger.warning(
+                    "xFormers 0.0.16 cannot be used for training in some GPUs. If you observe problems during training, please update xFormers to at least 0.0.17. See https://huggingface.co/docs/diffusers/main/en/optimization/xformers for more details."
+                )
+            transformer.enable_xformers_memory_efficient_attention()
+        else:
+            raise ValueError("xformers is not available. Make sure it is installed correctly")
+
+
+    if args.scale_lr:
+        args.learning_rate = args.learning_rate * args.gradient_accumulation_steps * args.train_batch_size * accelerator.num_processes
+
+    # Make sure the trainable params are in float32.
+    if args.mixed_precision == "fp16":
+        # only upcast trainable parameters (LoRA) into fp32
+        cast_training_params(transformer, dtype=torch.float32)
+
+    transformer_lora_parameters = list(filter(lambda p: p.requires_grad, transformer.parameters()))
+
+    # Initialize the optimizer
+    optimizer_cls = torch.optim.AdamW
+
+    optimizer = optimizer_cls(
+        transformer_lora_parameters,
+        lr=args.learning_rate,
+        betas=(args.adam_beta1, args.adam_beta2),
+        weight_decay=args.adam_weight_decay,
+        eps=args.adam_epsilon,
+    )
+    logger.info("Optimizer initialized successfully.")
+
+    # Preprocessing the datasets.
+    train_dataset = get_dataset(args)
+    train_dataset = prepare_dataset(train_dataset, vae_scale_factor, accelerator, args)
+
+    # DataLoaders creation:
+    train_dataloader = torch.utils.data.DataLoader(
+        train_dataset,
+        shuffle=True,
+        collate_fn=collate_fn,
+        batch_size=args.train_batch_size,
+        num_workers=args.dataloader_num_workers,
+    )
+    logger.info("Training dataset and Dataloader initialized successfully.")
+
+    tokenizers = [tokenizer_one, tokenizer_two]
+    text_encoders = [text_encoder_one, text_encoder_two]
+
+    def compute_text_embeddings(prompt, text_encoders, tokenizers):
+        with torch.no_grad():
+            prompt_embeds, pooled_prompt_embeds, text_ids = encode_prompt(
+                text_encoders, tokenizers, prompt, args.max_sequence_length
+            )
+            prompt_embeds = prompt_embeds.to(accelerator.device)
+            pooled_prompt_embeds = pooled_prompt_embeds.to(accelerator.device)
+            text_ids = text_ids.to(accelerator.device)
+        return prompt_embeds, pooled_prompt_embeds, text_ids
+
+
+    # Scheduler and math around the number of training steps.
+    # Check the PR https://github.com/huggingface/diffusers/pull/8312 for detailed explanation.
+    num_warmup_steps_for_scheduler = args.lr_warmup_steps * accelerator.num_processes
+    if args.max_train_steps is None:
+        len_train_dataloader_after_sharding = math.ceil(len(train_dataloader) / accelerator.num_processes)
+        num_update_steps_per_epoch = math.ceil(len_train_dataloader_after_sharding / args.gradient_accumulation_steps)
+        num_training_steps_for_scheduler = (
+            args.num_train_epochs * num_update_steps_per_epoch * accelerator.num_processes
+        )
+    else:
+        num_training_steps_for_scheduler = args.max_train_steps * accelerator.num_processes
+
+    lr_scheduler = get_scheduler(
+        args.lr_scheduler,
+        optimizer=optimizer,
+        num_warmup_steps=num_warmup_steps_for_scheduler,
+        num_training_steps=num_training_steps_for_scheduler,
+    )
+    logger.info(f"lr_scheduler:{args.lr_scheduler} initialized successfully.")
+
+    with preserve_requires_grad(transformer):
+        transformer.set_adapters([i for i in lora_names] + [args.output_denoising_lora] + ["schnell_assistant"])
+    logger.info(f"Set Adapters:{[i for i in lora_names] + [args.output_denoising_lora] + ["schnell_assistant"]}")
+
+    # Prepare everything with our `accelerator`.
+    transformer, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
+        transformer, optimizer, train_dataloader, lr_scheduler
+    )
+
+    # We need to recalculate our total training steps as the size of the training dataloader may have changed.
+    num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps)
+    if args.max_train_steps is None:
+        args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch
+        if num_training_steps_for_scheduler != args.max_train_steps * accelerator.num_processes:
+            logger.warning(
+                f"The length of the 'train_dataloader' after 'accelerator.prepare' ({len(train_dataloader)}) does not match "
+                f"the expected length ({len_train_dataloader_after_sharding}) when the learning rate scheduler was created. "
+                f"This inconsistency may result in the learning rate scheduler not functioning properly."
+            )
+    # Afterwards we recalculate our number of training epochs
+    args.num_train_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch)
+
+    # We need to initialize the trackers we use, and also store our configuration.
+    # The trackers initializes automatically on the main process.
+    if accelerator.is_main_process:
+        accelerator.init_trackers("SubjectGenius", config=vars(args))
+
+    # Train!
+    total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps
+
+    logger.info("***** Running training *****")
+    logger.info(f"  Num examples = {len(train_dataset)}")
+    logger.info(f"  Num Epochs = {args.num_train_epochs}")
+    logger.info(f"  Instantaneous batch size per device = {args.train_batch_size}")
+    logger.info(f"  Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}")
+    logger.info(f"  Gradient Accumulation steps = {args.gradient_accumulation_steps}")
+    logger.info(f"  Total optimization steps = {args.max_train_steps}")
+    global_step = 0
+    first_epoch = 0
+
+    # Potentially load in the weights and states from a previous save
+    if args.resume_from_checkpoint:
+        if args.resume_from_checkpoint != "latest":
+            path = os.path.basename(args.resume_from_checkpoint)
+        else:
+            # Get the most recent checkpoint
+            dirs = os.listdir(args.work_dir)
+            dirs = [d for d in dirs if d.startswith("checkpoint")]
+            dirs = sorted(dirs, key=lambda x: int(x.split("-")[1]))
+            path = dirs[-1] if len(dirs) > 0 else None
+
+        if path is None:
+            accelerator.print(
+                f"Checkpoint '{args.resume_from_checkpoint}' does not exist. Starting a new training run."
+            )
+            args.resume_from_checkpoint = None
+            initial_global_step = 0
+        else:
+            accelerator.print(f"Resuming from checkpoint {path}")
+            accelerator.load_state(os.path.join(args.work_dir, path))
+            global_step = int(path.split("-")[1])
+            initial_global_step = global_step
+            first_epoch = global_step // num_update_steps_per_epoch
+    else:
+        initial_global_step = 0
+
+    progress_bar = tqdm(
+        range(0, args.max_train_steps),
+        initial=initial_global_step,
+        desc="Steps",
+        # Only show the progress bar once on each machine.
+        disable=not accelerator.is_local_main_process,
+    )
+
+    def get_sigmas(timesteps, n_dim=4, dtype=torch.float32):
+        sigmas = noise_scheduler_copy.sigmas.to(device=accelerator.device, dtype=dtype)
+        schedule_timesteps = noise_scheduler_copy.timesteps.to(accelerator.device)
+        timesteps = timesteps.to(accelerator.device)
+        step_indices = [(schedule_timesteps == t).nonzero().item() for t in timesteps]
+
+        sigma = sigmas[step_indices].flatten()
+        while len(sigma.shape) < n_dim:
+            sigma = sigma.unsqueeze(-1)
+        return sigma
+
+    for epoch in range(first_epoch, args.num_train_epochs):
+        transformer.train()
+        for step, batch in enumerate(train_dataloader):
+            with torch.no_grad():
+                prompts = batch["descriptions"]
+                prompt_embeds, pooled_prompt_embeds, text_ids = compute_text_embeddings(
+                    prompts, text_encoders, tokenizers
+                )
+                # 1.1 Convert images to latent space.
+                latent_image = encode_images(pixels=batch["pixel_values"],vae=vae,weight_dtype=weight_dtype)
+                # 1.2 Get positional id.
+                latent_image_ids = FluxPipeline._prepare_latent_image_ids(
+                    latent_image.shape[0],
+                    latent_image.shape[2] // 2,
+                    latent_image.shape[3] // 2,
+                    accelerator.device,
+                    weight_dtype,
+                )
+                # 2.1 Convert Conditions to latent space list.
+                # 2.2 Get Conditions positional id list.
+                # 2.3 Get Conditions types string list.
+                # (bs, cond_num, c, h, w) -> [cond_num, (bs, c, h ,w)]
+                condition_latents = list(torch.unbind(batch["condition_latents"], dim=1))
+                # [cond_num, (len ,3) ]
+                condition_ids = []
+                # [cond_num]
+                condition_types = batch["condition_types"][0]
+                for i,images_per_condition in enumerate(condition_latents):
+                    # i means condition No.i.
+                    # images_per_condition = (bs, c, h ,w)
+                    images_per_condition = encode_images(pixels=images_per_condition,vae=vae,weight_dtype=weight_dtype)
+                    cond_ids = FluxPipeline._prepare_latent_image_ids(
+                        images_per_condition.shape[0],
+                        images_per_condition.shape[2] // 2,
+                        images_per_condition.shape[3] // 2,
+                        accelerator.device,
+                        weight_dtype,
+                    )
+                    if condition_types[i] == "subject":
+                        cond_ids[:, 2] += images_per_condition.shape[2] // 2
+                    condition_ids.append(cond_ids)
+                    condition_latents[i] = images_per_condition
+
+                # 3 Sample noise that we'll add to the latents
+                noise = torch.randn_like(latent_image)
+                bsz = latent_image.shape[0]
+
+                # 4 Sample a random timestep for each image
+                u = compute_density_for_timestep_sampling(
+                    weighting_scheme=args.weighting_scheme,
+                    batch_size=bsz,
+                )
+                indices = (u * noise_scheduler_copy.config.num_train_timesteps).long()
+                timesteps = noise_scheduler_copy.timesteps[indices].to(device=accelerator.device)
+
+                # 5 Add noise according to flow matching.
+                # zt = (1 - texp) * x + texp * z1
+                sigmas = get_sigmas(timesteps, n_dim=latent_image.ndim, dtype=latent_image.dtype)
+                noisy_model_input = (1.0 - sigmas) * latent_image + sigmas * noise
+
+                # 6.1 pack noisy_model_input
+                packed_noisy_model_input = FluxPipeline._pack_latents(
+                    noisy_model_input,
+                    batch_size=latent_image.shape[0],
+                    num_channels_latents=latent_image.shape[1],
+                    height=latent_image.shape[2],
+                    width=latent_image.shape[3],
+                )
+                # 6.2 pack Conditions latents
+                for i, images_per_condition in enumerate(condition_latents):
+                    condition_latents[i] = FluxPipeline._pack_latents(
+                        images_per_condition,
+                        batch_size=latent_image.shape[0],
+                        num_channels_latents=latent_image.shape[1],
+                        height=latent_image.shape[2],
+                        width=latent_image.shape[3],
+                    )
+
+                # 7 handle guidance
+                if accelerator.unwrap_model(transformer).config.guidance_embeds:
+                    guidance = torch.tensor([args.guidance_scale], device=accelerator.device)
+                    guidance = guidance.expand(latent_image.shape[0])
+                else:
+                    guidance = None
+            with accelerator.accumulate(transformer):
+                # 8 Predict the noise residual
+                model_pred = transformer(
+                    model_config={},
+                    # Inputs of the condition (new feature)
+                    condition_latents=condition_latents,
+                    condition_ids=condition_ids,
+                    condition_type_ids=None,
+                    condition_types = condition_types,
+                    # Inputs to the original transformer
+                    hidden_states=packed_noisy_model_input,
+                    timestep=timesteps / 1000,
+                    guidance=guidance,
+                    pooled_projections=pooled_prompt_embeds,
+                    encoder_hidden_states=prompt_embeds,
+                    txt_ids=text_ids,
+                    img_ids=latent_image_ids,
+                    return_dict=False,
+                )[0]
+                model_pred = FluxPipeline._unpack_latents(
+                    model_pred,
+                    height=noisy_model_input.shape[2] * vae_scale_factor,
+                    width=noisy_model_input.shape[3] * vae_scale_factor,
+                    vae_scale_factor=vae_scale_factor,
+                )
+                # these weighting schemes use a uniform timestep sampling
+                # and instead post-weight the loss
+                weighting = compute_loss_weighting_for_sd3(weighting_scheme=args.weighting_scheme, sigmas=sigmas)
+                # flow matching loss
+                target = noise - latent_image
+
+                loss = torch.mean(
+                    (weighting.float() * (model_pred.float() - target.float()) ** 2).reshape(target.shape[0], -1),
+                    1,
+                )
+                loss = loss.mean()
+
+                accelerator.backward(loss)
+
+                if accelerator.sync_gradients:
+                    params_to_clip = transformer.parameters()
+                    accelerator.clip_grad_norm_(params_to_clip, args.max_grad_norm)
+                optimizer.step()
+                lr_scheduler.step()
+                optimizer.zero_grad()
+
+            # Checks if the accelerator has performed an optimization step behind the scenes
+            if accelerator.sync_gradients:
+                progress_bar.update(1)
+                global_step += 1
+                if accelerator.is_main_process:
+                    if global_step % args.checkpointing_steps == 0:
+                        save_path = os.path.join(args.work_dir, f"checkpoint-{global_step}")
+                        accelerator.save_state(save_path)
+                        logger.info(f"Saved state to {save_path}")
+            logs = {"step_loss": loss.detach().item(), "lr": lr_scheduler.get_last_lr()[0]}
+            progress_bar.set_postfix(**logs)
+            accelerator.log(logs, step=global_step)
+
+            if global_step >= args.max_train_steps:
+                break
+
+    accelerator.wait_for_everyone()
+    accelerator.end_training()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    main(args)
+