Add files using upload-large-folder tool

Helios-main/example/toy_data/toy_filter.json

@@ -0,0 +1,46 @@
+[
+  {
+    "cut": [
+      0,
+      81
+    ],
+    "crop": [
+      0,
+      832,
+      0,
+      480
+    ],
+    "fps": 24.0,
+    "num_frames": 81,
+    "resolution": {
+      "height": 480,
+      "width": 832
+    },
+    "cap": [
+      "A stunning mid-afternoon landscape photograph with a low camera angle, showcasing several giant wooly mammoths treading through a snowy meadow. Their long, wooly fur gently billows in the brisk wind as they move, creating a sense of natural movement. Snow-covered trees and dramatic snow-capped mountains loom in the distance, adding to the majestic setting. Wispy clouds and a high sun cast a warm glow over the scene, enhancing the serene and awe-inspiring atmosphere. The depth of field brings out the detailed textures of the mammoths and the snowy environment, capturing every nuance of these prehistoric giants in breathtaking clarity."
+    ],
+    "path": "videos/2_240_ori81.mp4"
+  },
+  {
+    "cut": [
+      0,
+      129
+    ],
+    "crop": [
+      0,
+      832,
+      0,
+      480
+    ],
+    "fps": 24.0,
+    "num_frames": 129,
+    "resolution": {
+      "height": 480,
+      "width": 832
+    },
+    "cap": [
+      "An old man in blue jeans and a white T-shirt takes a leisurely stroll along a bustling street in Mumbai, India, during a breathtaking sunset. He walks with a gentle sway, his weathered face reflecting the warm hues of the setting sun. His hands rest casually in his pockets, and he appears content and at peace. The background features a vibrant mix of colorful buildings, street vendors, and pedestrians, with the sky painted in shades of orange, pink, and purple. The photo has a nostalgic and documentary style, capturing the essence of a serene moment amidst the city's energy. A medium shot with a soft focus on the old man."
+    ],
+    "path": "videos/239_120_ori129.mp4"
+  }
+]

Helios-main/helios/dataset/dataloader_dmd.py

@@ -0,0 +1,531 @@
+import os
+import pickle
+import random
+from collections import defaultdict
+
+import torch
+from einops import rearrange
+from torch.utils.data import Dataset, Sampler
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        gan_folders=None,
+        ode_folders=None,
+        text_folders=None,
+        is_use_gt_history=False,
+        return_secondary=False,
+        force_rebuild=False,
+        single_res=True,
+        single_length=True,
+        single_num_frame=81,
+        single_height=384,
+        single_width=640,
+        seed=42,
+    ):
+        self.is_use_gt_history = is_use_gt_history
+        self.return_secondary = return_secondary
+        self.force_rebuild = force_rebuild
+        self.base_seed = seed
+        self._epoch = 0
+
+        self.single_res = single_res
+        self.single_length = single_length
+        self.single_num_frame = single_num_frame
+        self.single_height = single_height
+        self.single_width = single_width
+
+        self.gan_samples = self._init_samples(gan_folders, "gan")
+        self.ode_samples = self._init_samples(ode_folders, "ode")
+        self.text_samples = self._init_samples(text_folders, "text")
+
+        self._align_sample_counts()
+
+    def _init_samples(self, folders, data_type):
+        if folders is None:
+            return []
+
+        folders = [folders] if isinstance(folders, str) else folders
+        samples = []
+
+        for folder in folders:
+            cache_file = os.path.join(folder, f"{data_type}_dataset_cache.pkl")
+            folder_samples = self._process_folder(folder, cache_file, data_type)
+            samples.extend(folder_samples)
+
+        return samples
+
+    def _align_sample_counts(self, is_log=True):
+        lengths = {"gan": len(self.gan_samples), "ode": len(self.ode_samples), "text": len(self.text_samples)}
+
+        non_empty_lengths = {k: v for k, v in lengths.items() if v > 0}
+        if not non_empty_lengths:
+            return
+        max_length = max(non_empty_lengths.values())
+
+        if is_log:
+            print(f"\nAligning sample counts to max: {max_length}")
+            print(f"Original counts - GAN: {lengths['gan']}, ODE: {lengths['ode']}, TEXT: {lengths['text']}")
+
+        random.seed(self.base_seed)
+
+        if self.gan_samples and len(self.gan_samples) < max_length:
+            self.gan_samples = self._expand_samples(self.gan_samples, max_length, "GAN")
+
+        if self.ode_samples and len(self.ode_samples) < max_length:
+            self.ode_samples = self._expand_samples(self.ode_samples, max_length, "ODE")
+
+        if self.text_samples and len(self.text_samples) < max_length:
+            self.text_samples = self._expand_samples(self.text_samples, max_length, "TEXT")
+
+        if is_log:
+            print(
+                f"Aligned counts - GAN: {len(self.gan_samples)}, ODE: {len(self.ode_samples)}, TEXT: {len(self.text_samples)}\n"
+            )
+
+    def _expand_samples(self, samples, target_length, data_type):
+        original_length = len(samples)
+        expanded_samples = samples.copy()
+
+        while len(expanded_samples) < target_length:
+            random_sample = random.choice(samples)
+            expanded_samples.append(random_sample)
+
+        print(f"{data_type}: Expanded from {original_length} to {len(expanded_samples)} samples")
+        return expanded_samples
+
+    def _process_folder(self, folder, cache_file, data_type):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            # if os.path.exists(cache_file):
+            #     os.remove(cache_file)
+            print(f"{data_type.upper()}: Building metadata cache for folder: {folder}")
+            folder_samples = self._build_folder_metadata(folder, data_type)
+
+            if not self.force_rebuild:
+                print(f"{data_type.upper()}: Saving metadata cache for folder: {folder}")
+                with open(cache_file, "wb") as f:
+                    pickle.dump({"samples": folder_samples}, f)
+
+            print(f"{data_type.upper()}: Cached {len(folder_samples)} samples from {folder}")
+        else:
+            print(f"{data_type.upper()}: Loading cached metadata from: {folder}")
+            with open(cache_file, "rb") as f:
+                folder_samples = pickle.load(f)["samples"]
+            print(f"{data_type.upper()}: Loaded {len(folder_samples)} samples from cache: {folder}")
+
+        return folder_samples
+
+    def _build_folder_metadata(self, folder, data_type):
+        feature_files = [f for f in os.listdir(folder) if f.endswith(".pt")]
+        samples = []
+
+        print(f"{data_type.upper()}: Processing {len(feature_files)} files in {folder}...")
+        for i, feature_file in enumerate(feature_files):
+            if i % 10000 == 0:
+                print(f"  {data_type.upper()}: Processed {i}/{len(feature_files)} files")
+
+            feature_path = os.path.join(folder, feature_file)
+
+            # TODO hard code here now
+            if data_type == "gan":
+                parts = feature_file.split("_")
+                num_frame = int(parts[-3])
+                height = int(parts[-2])
+                width = int(parts[-1].replace(".pt", ""))
+
+                if self.is_use_gt_history:
+                    if (height, width) not in [(self.single_height, self.single_width)]:
+                        continue
+                else:
+                    if (num_frame, height, width) not in [
+                        (self.single_num_frame, self.single_height, self.single_width)
+                    ]:
+                        continue
+
+            samples.append(
+                {
+                    "uttid": os.path.splitext(os.path.basename(feature_file))[0],
+                    "dataset_name": folder.rstrip("/"),
+                    "file_path": feature_path,
+                }
+            )
+
+        return samples
+
+    def prepare_stage1_latent(self, vae_latent, idx, base_vae_latent=None, return_secondary=False):
+        self.is_keep_x0 = (True,)
+        self.history_sizes = [16, 2, 1]
+        self.num_rollout_sections = 9
+
+        source_latent = base_vae_latent if base_vae_latent is not None else vae_latent
+
+        x0_latent = None
+        if self.is_keep_x0:
+            x0_latent = source_latent[0, :, :1, :, :].clone()
+        total_sections = source_latent.shape[0]
+        latent_window_size = source_latent.shape[2]
+        history_window_size = sum(self.history_sizes)
+        section_size = history_window_size + latent_window_size
+
+        temp_source_latent = rearrange(source_latent, "b c t h w -> c (b t) h w")
+        zero_padding_source = torch.zeros(
+            temp_source_latent.shape[0],
+            history_window_size,
+            temp_source_latent.shape[2],
+            temp_source_latent.shape[3],
+            device=temp_source_latent.device,
+            dtype=temp_source_latent.dtype,
+        )
+        continue_source_latent = torch.cat([zero_padding_source, temp_source_latent], dim=1)
+
+        temp_vae_latent = rearrange(vae_latent, "b c t h w -> c (b t) h w")
+        zero_padding_vae = torch.zeros(
+            temp_vae_latent.shape[0],
+            history_window_size,
+            temp_vae_latent.shape[2],
+            temp_vae_latent.shape[3],
+            device=temp_vae_latent.device,
+            dtype=temp_vae_latent.dtype,
+        )
+        continue_vae_latent = torch.cat([zero_padding_vae, temp_vae_latent], dim=1)
+
+        sample_seed = self.base_seed + self._epoch * 1000000 + idx
+        choice_idx = torch.randint(
+            0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed)
+        ).item()
+        if choice_idx == 0 and x0_latent is not None:
+            x0_latent = torch.zeros_like(x0_latent)
+
+        start_indice = choice_idx * latent_window_size
+        end_indice = start_indice + section_size
+
+        history_latent = continue_source_latent[:, start_indice : start_indice + history_window_size, :, :]
+        target_latent = continue_vae_latent[:, start_indice + history_window_size : end_indice, :, :]
+
+        x0_latent_2 = None
+        history_latent_2 = None
+        target_latent_2 = None
+        if return_secondary:
+            sample_seed_2 = self.base_seed + self._epoch * 1000000 + idx + 999999
+            choice_idx_2 = torch.randint(
+                0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed_2)
+            ).item()
+
+            x0_latent_2 = None
+            if self.is_keep_x0:
+                x0_latent_2 = source_latent[0, :, :1, :, :].clone()
+                if choice_idx_2 == 0:
+                    x0_latent_2 = torch.zeros_like(x0_latent_2)
+
+            start_indice_2 = choice_idx_2 * latent_window_size
+            end_indice_2 = start_indice_2 + section_size
+
+            history_latent_2 = continue_source_latent[:, start_indice_2 : start_indice_2 + history_window_size, :, :]
+            target_latent_2 = continue_vae_latent[:, start_indice_2 + history_window_size : end_indice_2, :, :]
+
+        return (x0_latent, history_latent, target_latent), (x0_latent_2, history_latent_2, target_latent_2)
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+        random.seed(self.base_seed + epoch)
+        self._align_sample_counts(is_log=False)
+
+    def __len__(self):
+        return max(len(self.gan_samples), len(self.ode_samples), len(self.text_samples))
+
+    def __getitem__(self, idx):
+        while True:
+            try:
+                output_dict = {}
+
+                if self.gan_samples:
+                    gan_sample = self.gan_samples[idx]
+                    gan_feature = torch.load(gan_sample["file_path"], map_location="cpu", weights_only=False)
+                    if self.is_use_gt_history:
+                        (
+                            (x0_latent, history_latent, target_latent),
+                            (x0_latent_2, history_latent_2, target_latent_2),
+                        ) = self.prepare_stage1_latent(
+                            gan_feature["vae_latent"],
+                            idx,
+                            return_secondary=self.return_secondary,
+                        )
+                        output_dict.update(
+                            {
+                                "gan_uttid": gan_sample["uttid"],
+                                "gan_dataset_name": gan_sample["dataset_name"],
+                                "gan_vae_latents": target_latent,
+                                "gan_x0_latents": x0_latent,
+                                "gan_history_latents": history_latent,
+                                "gan_vae_latents_2": target_latent_2,
+                                "gan_x0_latents_2": x0_latent_2,
+                                "gan_history_latents_2": history_latent_2,
+                                "gan_prompt_raws": gan_feature["prompt_raw"],
+                                "gan_prompt_embeds": gan_feature["prompt_embed"],
+                            }
+                        )
+                    else:
+                        output_dict.update(
+                            {
+                                "gan_uttid": gan_sample["uttid"],
+                                "gan_dataset_name": gan_sample["dataset_name"],
+                                "gan_vae_latents": gan_feature["vae_latent"],
+                                "gan_prompt_raws": gan_feature["prompt_raw"],
+                                "gan_prompt_embeds": gan_feature["prompt_embed"],
+                            }
+                        )
+                    gan_sample = None
+                    gan_feature = None
+                    del gan_sample
+                    del gan_feature
+
+                if self.ode_samples:
+                    ode_sample = self.ode_samples[idx]
+                    ode_feature = torch.load(ode_sample["file_path"], map_location="cpu", weights_only=False)
+                    output_dict.update(
+                        {
+                            "ode_uttid": ode_sample["uttid"],
+                            "ode_dataset_name": ode_sample["dataset_name"],
+                            "ode_latent_window_size": ode_feature["latent_window_size"],
+                            "ode_latents": ode_feature["ode_latents"],
+                            "ode_prompt_raws": ode_feature["prompt_raw"],
+                            "ode_prompt_embeds": ode_feature["prompt_embed"][0],
+                        }
+                    )
+                    ode_sample = None
+                    ode_feature = None
+                    del ode_sample
+                    del ode_feature
+
+                if self.text_samples:
+                    text_sample = self.text_samples[idx]
+                    text_feature = torch.load(text_sample["file_path"], map_location="cpu", weights_only=False)
+                    output_dict.update(
+                        {
+                            "text_uttid": text_sample["uttid"],
+                            "text_dataset_name": text_sample["dataset_name"],
+                            "text_prompt_raws": text_feature["prompt_raw"],
+                            "text_prompt_embeds": text_feature["prompt_embed"],
+                        }
+                    )
+                    text_sample = None
+                    text_feature = None
+                    del text_sample
+                    del text_feature
+
+                return output_dict
+
+            except Exception as e:
+                idx = random.randint(0, len(self) - 1)
+                print(f"Error loading sample at idx {idx}, retrying... Error: {e}")
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        dataset_sampling_ratios={},
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        # Get all indices
+        all_indices = list(range(len(self.dataset)))
+
+        # Global shuffle before sharding (important for distributed consistency)
+        if self.shuffle:
+            perm = torch.randperm(len(all_indices), generator=self.generator).tolist()
+            all_indices = [all_indices[i] for i in perm]
+
+        # Shard indices for this SP group
+        sp_group_indices = self._shard_indices_for_sp_group(all_indices)
+
+        # Create batches
+        for i in range(0, len(sp_group_indices), self.batch_size):
+            batch = sp_group_indices[i : i + self.batch_size]
+            if len(batch) == self.batch_size or not self.drop_last:
+                yield batch
+
+    def __len__(self):
+        # Total samples in dataset
+        total_samples = len(self.dataset)
+
+        # Account for SP group sharding
+        sp_group_samples = total_samples // self.num_sp_groups
+        if not self.drop_last and total_samples % self.num_sp_groups != 0:
+            sp_group_samples += 1
+
+        # Calculate number of batches
+        total_batches = sp_group_samples // self.batch_size
+        if not self.drop_last and sp_group_samples % self.batch_size != 0:
+            total_batches += 1
+
+        return total_batches
+
+
+def collate_fn(batch):
+    return {
+        key: torch.stack([d[key] for d in batch])
+        if isinstance(batch[0][key], torch.Tensor)
+        else [d[key] for d in batch]
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    dataloader_num_workers = 8
+    batch_size = 2
+    num_train_epochs = 2
+    seed = 0
+
+    gan_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/gan_latents/ultravideo/clips_long_960",
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/gan_latents/ultravideo/clips_short_960",
+    ]
+    ode_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/ode_pairs/vidprom_filtered_extended",
+    ]
+    text_folder = [
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/text-embedding/mixkit_filter",
+        "/mnt/hdfs/data/ysh_new/userful_things_wan/text-embedding/vidprom_filtered_extended",
+    ]
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        gan_folders=gan_folder,
+        ode_folders=ode_folder,
+        text_folders=text_folder,
+        is_use_gt_history=True,
+        force_rebuild=True,
+        seed=seed,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=True,
+        seed=seed,
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(
+        dataset,
+        batch_sampler=sampler,
+        collate_fn=collate_fn,
+        num_workers=dataloader_num_workers,
+        prefetch_factor=2 if dataloader_num_workers > 0 else None,
+    )
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    print("Testing dataloader...")
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            gan_uttid = batch["gan_uttid"]
+            ode_uttid = batch["ode_uttid"]
+            text_uttid = batch["text_uttid"]
+
+            # Get feature
+            # For GAN
+            gan_vae_latents = batch["gan_vae_latents"]
+            gan_prompt_raws = batch["gan_prompt_raws"]
+            gan_prompt_embeds = batch["gan_prompt_embeds"]
+            print(gan_vae_latents.shape, gan_prompt_embeds.shape, gan_prompt_raws)
+
+            # For ODE
+            ode_prompt_raws = batch["ode_prompt_raws"]
+            ode_prompt_embeds = batch["ode_prompt_embeds"]
+            print(ode_prompt_embeds.shape, ode_prompt_raws)
+
+            # For Text
+            text_prompt_raws = batch["text_prompt_raws"]
+            text_prompt_embeds = batch["text_prompt_embeds"]
+            print(text_prompt_embeds.shape, text_prompt_raws)
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                print(f"  Batch size: {len(gan_uttid)}")
+                print(f"  Uttids: {gan_uttid}, {ode_uttid}, {text_uttid}")
+                print(
+                    f"  Data Name: {batch['gan_dataset_name']}, {batch['ode_dataset_name']}, {batch['text_dataset_name']}"
+                )
+
+            for dataset_name in batch["gan_dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+    print("实际采样统计:", dict(dataset_counts))

Helios-main/helios/dataset/dataloader_history_latents_dist.py

@@ -0,0 +1,685 @@
+import os
+import pickle
+import random
+from collections import defaultdict
+
+import torch
+from einops import rearrange
+from torch.utils.data import Dataset, Sampler
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        feature_folders,
+        history_sizes=[16, 2, 1],
+        is_keep_x0=True,
+        force_rebuild=False,
+        return_all_vae_latent=False,
+        return_prompt_raw=False,
+        num_rollout_sections=3,
+        single_res=False,
+        single_height=384,
+        single_width=640,
+        seed=42,
+    ):
+        self.history_sizes = history_sizes
+        self.is_keep_x0 = is_keep_x0
+        self.force_rebuild = force_rebuild
+        self.return_all_vae_latent = return_all_vae_latent
+        self.return_prompt_raw = return_prompt_raw
+        self.num_rollout_sections = num_rollout_sections
+        self.single_res = single_res
+        self.single_height = single_height
+        self.single_width = single_width
+        assert self.is_keep_x0, "is_keep_x0 need to be True now!"
+
+        self.base_seed = seed
+        self._epoch = 0
+
+        if isinstance(feature_folders, str):
+            self.feature_folders = [feature_folders]
+        else:
+            self.feature_folders = feature_folders
+
+        self.samples = []
+        self.buckets = defaultdict(list)
+
+        for folder in self.feature_folders:
+            cache_file = os.path.join(folder, "dataset_cache.pkl")
+            self._process_folder(folder, cache_file)
+
+    def _process_folder(self, folder, cache_file):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            print(f"Building metadata cache for folder: {folder}")
+            folder_samples, folder_buckets = self._build_folder_metadata(folder)
+
+            print(f"Saving metadata cache for folder: {folder}")
+            cached_data = {"samples": folder_samples, "buckets": folder_buckets}
+            if not self.force_rebuild:
+                with open(cache_file, "wb") as f:
+                    pickle.dump(cached_data, f)
+            print(f"Cached {len(folder_samples)} samples from {folder}\n")
+        else:
+            print(f"Loading cached metadata from: {folder}")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            folder_samples = cached_data["samples"]
+            folder_buckets = cached_data["buckets"]
+            print(f"Loaded {len(folder_samples)} samples from cache: {folder}\n")
+
+        sample_idx_offset = len(self.samples)
+        self.samples.extend(folder_samples)
+
+        for bucket_key, indices in folder_buckets.items():
+            adjusted_indices = [idx + sample_idx_offset for idx in indices]
+            self.buckets[bucket_key].extend(adjusted_indices)
+
+    def _build_folder_metadata(self, folder):
+        feature_files = [f for f in os.listdir(folder) if f.endswith(".pt")]
+        samples = []
+        buckets = defaultdict(list)
+        sample_idx = 0
+
+        print(f"Processing {len(feature_files)} files in {folder}...")
+
+        for i, feature_file in enumerate(feature_files):
+            if i % 10000 == 0:
+                print(f"  Processed {i}/{len(feature_files)} files")
+
+            feature_path = os.path.join(folder, feature_file)
+
+            # Parse filename
+            parts = feature_file.split("_")
+            uttid = "_".join(parts[:-3])
+            num_frame = int(parts[-3])
+            height = int(parts[-2])
+            width = int(parts[-1].replace(".pt", ""))
+
+            # keep length >= 121
+            if num_frame < 121:
+                continue
+
+            # keep resolution
+            allowed_resolutions = [
+                (self.single_height, self.single_width),
+                (self.single_height // 2, self.single_width // 2),
+                (self.single_height // 4, self.single_width // 4),
+            ]
+            if self.single_res and (height, width) not in allowed_resolutions:
+                continue
+
+            bucket_key = (num_frame, height, width)
+
+            sample_info = {
+                "uttid": uttid,
+                "dataset_name": folder.rstrip("/"),
+                "file_path": feature_path,
+                "bucket_key": bucket_key,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+            }
+
+            samples.append(sample_info)
+            buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+        return samples, buckets
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def prepare_stage1_latent(self, vae_latent, idx, base_vae_latent=None):
+        source_latent = base_vae_latent if base_vae_latent is not None else vae_latent
+
+        x0_latent = None
+        if self.is_keep_x0:
+            x0_latent = source_latent[0, :, :1, :, :].clone()
+        total_sections = source_latent.shape[0]
+        latent_window_size = source_latent.shape[2]
+        history_window_size = sum(self.history_sizes)
+        section_size = history_window_size + latent_window_size
+
+        temp_source_latent = rearrange(source_latent, "b c t h w -> c (b t) h w")
+        zero_padding_source = torch.zeros(
+            temp_source_latent.shape[0],
+            history_window_size,
+            temp_source_latent.shape[2],
+            temp_source_latent.shape[3],
+            device=temp_source_latent.device,
+            dtype=temp_source_latent.dtype,
+        )
+        continue_source_latent = torch.cat([zero_padding_source, temp_source_latent], dim=1)
+
+        temp_vae_latent = rearrange(vae_latent, "b c t h w -> c (b t) h w")
+        zero_padding_vae = torch.zeros(
+            temp_vae_latent.shape[0],
+            history_window_size,
+            temp_vae_latent.shape[2],
+            temp_vae_latent.shape[3],
+            device=temp_vae_latent.device,
+            dtype=temp_vae_latent.dtype,
+        )
+        continue_vae_latent = torch.cat([zero_padding_vae, temp_vae_latent], dim=1)
+
+        sample_seed = self.base_seed + self._epoch * 1000000 + idx
+        choice_idx = torch.randint(
+            0, total_sections, (1,), generator=torch.Generator().manual_seed(sample_seed)
+        ).item()
+        if choice_idx == 0 and x0_latent is not None:
+            x0_latent = torch.zeros_like(x0_latent)
+
+        clean_all_vae_latent = None
+        if self.return_all_vae_latent:
+            max_start_idx = total_sections - self.num_rollout_sections
+            if max_start_idx < 0:
+                raise ValueError(
+                    f"Not enough sections: total_sections={total_sections}, num_rollout_sections={self.num_rollout_sections}"
+                )
+            start_section_idx = random.randint(0, max_start_idx)
+            start_indice = start_section_idx * latent_window_size
+            end_indice = start_indice + history_window_size + self.num_rollout_sections * latent_window_size
+            clean_all_vae_latent = continue_source_latent[:, start_indice:end_indice, :, :]
+
+        start_indice = choice_idx * latent_window_size
+        end_indice = start_indice + section_size
+
+        history_latent = continue_source_latent[:, start_indice : start_indice + history_window_size, :, :]
+        target_latent = continue_vae_latent[:, start_indice + history_window_size : end_indice, :, :]
+
+        return x0_latent, history_latent, target_latent, clean_all_vae_latent
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        anchor_f = self.samples[idx]["num_frame"]
+        anchor_h = self.samples[idx]["height"]
+        anchor_w = self.samples[idx]["width"]
+        while True:
+            sample_info = self.samples[idx]
+
+            if (
+                anchor_f != sample_info["num_frame"]
+                or anchor_h != sample_info["height"]
+                or anchor_w != sample_info["width"]
+            ):
+                idx = random.randint(0, len(self.samples) - 1)
+                print("Try to find a same dim sample, retrying...")
+                continue
+
+            try:
+                base_vae_latent = None
+                if (anchor_h, anchor_w) in [
+                    (self.single_height // 2, self.single_width // 2),
+                    (self.single_height // 4, self.single_width // 4),
+                ]:
+                    base_file_path = (
+                        sample_info["file_path"]
+                        .replace("/mid", "")
+                        .replace("/low", "")
+                        .replace(
+                            f"{self.single_height // 2}_{self.single_width // 2}",
+                            f"{self.single_height}_{self.single_width}",
+                        )
+                        .replace(
+                            f"{self.single_height // 4}_{self.single_width // 4}",
+                            f"{self.single_height}_{self.single_width}",
+                        )
+                    )
+                    base_vae_latent = torch.load(base_file_path, map_location="cpu", weights_only=False)["vae_latent"]
+
+                feature_data = torch.load(sample_info["file_path"], map_location="cpu", weights_only=False)
+                x0_latent, history_latent, target_latent, clean_all_vae_latent = self.prepare_stage1_latent(
+                    feature_data["vae_latent"], idx, base_vae_latent
+                )
+                if self.return_prompt_raw:
+                    prompt_raws = feature_data["prompt_raw"]
+                break
+            except Exception:
+                idx = random.randint(0, len(self.samples) - 1)
+                print(f"Error loading {sample_info['file_path']}, retrying...")
+                file_name = os.path.basename(sample_info["file_path"])
+                txt_name = f"{file_name}.txt"
+                with open(txt_name, "w") as f:
+                    f.write(sample_info["file_path"] + "\n")
+
+        output_dict = {
+            "uttid": sample_info["uttid"],
+            "bucket_key": sample_info["bucket_key"],
+            "dataset_name": sample_info["dataset_name"],
+            "num_frame": sample_info["num_frame"],
+            "height": sample_info["height"],
+            "width": sample_info["width"],
+            "x0_latents": x0_latent,
+            "history_latents": history_latent,
+            "target_latents": target_latent,
+            "clean_all_latents": clean_all_vae_latent,
+            "prompt_embeds": feature_data["prompt_embed"],
+            "prompt_attention_masks": feature_data.get("prompt_attention_mask", None),
+        }
+
+        if self.return_prompt_raw:
+            output_dict["prompt_raws"] = prompt_raws
+
+        return output_dict
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        dataset_sampling_ratios=None,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+        self.dataset_sampling_ratios = (
+            {key.rstrip("/"): value for key, value in dataset_sampling_ratios.items()}
+            if dataset_sampling_ratios is not None
+            else {}
+        )
+        self._prepare_dataset_buckets()
+
+    def _prepare_dataset_buckets(self):
+        self.dataset_buckets = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            dataset_groups = {}
+            for idx in sample_indices:
+                dataset_name = self.dataset.samples[idx]["dataset_name"]
+                if dataset_name not in dataset_groups:
+                    dataset_groups[dataset_name] = []
+                dataset_groups[dataset_name].append(idx)
+            self.dataset_buckets[bucket_key] = dataset_groups
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups, similar to DP_SP_BatchSampler.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def _apply_global_ratio_sampling(self):
+        if not self.dataset_sampling_ratios:
+            return
+
+        dataset_sample_map = {}
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            for dataset_name, indices in dataset_groups.items():
+                if dataset_name not in dataset_sample_map:
+                    dataset_sample_map[dataset_name] = {"indices": [], "buckets": []}
+                dataset_sample_map[dataset_name]["indices"].extend(indices)
+                dataset_sample_map[dataset_name]["buckets"].extend([bucket_key] * len(indices))
+
+        total_samples = sum(len(info["indices"]) for info in dataset_sample_map.values())
+        total_ratio = sum(self.dataset_sampling_ratios.values())
+
+        sampled_dataset_map = {}
+        for dataset_name, info in dataset_sample_map.items():
+            if dataset_name in self.dataset_sampling_ratios:
+                ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                target_samples = max(1, int(total_samples * ratio))
+
+                indices = info["indices"]
+                buckets = info["buckets"]
+
+                if len(indices) >= target_samples:
+                    selected = torch.randperm(len(indices), generator=self.generator)[:target_samples].tolist()
+                    sampled_indices = [indices[i] for i in selected]
+                    sampled_buckets = [buckets[i] for i in selected]
+                else:
+                    sampled_indices = []
+                    sampled_buckets = []
+                    remaining = target_samples
+
+                    while remaining > 0:
+                        repeat_count = min(remaining, len(indices))
+                        selected = torch.randperm(len(indices), generator=self.generator)[:repeat_count].tolist()
+                        sampled_indices.extend([indices[i] for i in selected])
+                        sampled_buckets.extend([buckets[i] for i in selected])
+                        remaining -= repeat_count
+
+                sampled_dataset_map[dataset_name] = {"indices": sampled_indices, "buckets": sampled_buckets}
+            else:
+                sampled_dataset_map[dataset_name] = info
+
+        new_dataset_buckets = {}
+        for bucket_key in self.dataset_buckets.keys():
+            new_dataset_buckets[bucket_key] = {}
+
+        for dataset_name, info in sampled_dataset_map.items():
+            indices = info["indices"]
+            buckets = info["buckets"]
+
+            for idx, bucket_key in zip(indices, buckets):
+                if dataset_name not in new_dataset_buckets[bucket_key]:
+                    new_dataset_buckets[bucket_key][dataset_name] = []
+                new_dataset_buckets[bucket_key][dataset_name].append(idx)
+
+        self.dataset_buckets = new_dataset_buckets
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        if self.dataset_sampling_ratios:
+            self._apply_global_ratio_sampling()
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            balanced_indices = self._create_balanced_indices(dataset_groups)
+
+            # Global shuffle before sharding (important for distributed consistency)
+            if self.shuffle:
+                perm = torch.randperm(len(balanced_indices), generator=self.generator).tolist()
+                balanced_indices = [balanced_indices[i] for i in perm]
+
+            # Shard indices for this SP group
+            sp_group_indices = self._shard_indices_for_sp_group(balanced_indices)
+
+            batches = []
+            for i in range(0, len(sp_group_indices), self.batch_size):
+                batch = sp_group_indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def _create_balanced_indices(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def _equal_sampling(self, dataset_groups):
+        all_indices = []
+        dataset_names = list(dataset_groups.keys())
+
+        if len(dataset_names) <= 1:
+            return sum(dataset_groups.values(), [])
+
+        min_samples = min(len(indices) for indices in dataset_groups.values())
+
+        for dataset_name, indices in dataset_groups.items():
+            if len(indices) > min_samples:
+                selected = torch.randperm(len(indices), generator=self.generator)[:min_samples].tolist()
+                sampled_indices = [indices[i] for i in selected]
+            else:
+                sampled_indices = indices
+            all_indices.extend(sampled_indices)
+
+        return all_indices
+
+    def _ratio_sampling(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def __len__(self):
+        if self.dataset_sampling_ratios:
+            temp_generator = torch.Generator()
+            temp_generator.manual_seed(self.seed)
+
+            dataset_sample_map = {}
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                for dataset_name, indices in dataset_groups.items():
+                    if dataset_name not in dataset_sample_map:
+                        dataset_sample_map[dataset_name] = []
+                    dataset_sample_map[dataset_name].extend(indices)
+
+            total_samples = sum(len(indices) for indices in dataset_sample_map.values())
+            total_ratio = sum(self.dataset_sampling_ratios.values())
+
+            sampled_total = 0
+            for dataset_name, indices in dataset_sample_map.items():
+                if dataset_name in self.dataset_sampling_ratios:
+                    ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                    target_samples = max(1, int(total_samples * ratio))
+                    sampled_total += target_samples
+                else:
+                    sampled_total += len(indices)
+
+            # Account for SP group sharding
+            sp_group_samples = sampled_total // self.num_sp_groups
+            if not self.drop_last and sampled_total % self.num_sp_groups != 0:
+                sp_group_samples += 1
+
+            total_batches = sp_group_samples // self.batch_size
+            if not self.drop_last and sp_group_samples % self.batch_size != 0:
+                total_batches += 1
+            return total_batches
+        else:
+            total_batches = 0
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                balanced_indices = self._create_balanced_indices(dataset_groups)
+
+                # Account for SP group sharding
+                sp_group_size = len(balanced_indices) // self.num_sp_groups
+                if not self.drop_last and len(balanced_indices) % self.num_sp_groups != 0:
+                    sp_group_size += 1
+
+                num_batches = sp_group_size // self.batch_size
+                if not self.drop_last and sp_group_size % self.batch_size != 0:
+                    num_batches += 1
+                total_batches += num_batches
+            return total_batches
+
+
+def collate_fn(batch):
+    return {
+        key: torch.stack([d[key] for d in batch])
+        if isinstance(batch[0][key], torch.Tensor)
+        else [d[key] for d in batch]
+        for key in batch[0]
+    }
+
+
+if __name__ == "__main__":
+    import torch.distributed.checkpoint as dcp
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    feature_folder = [
+        "demo_data/ultravideo-long",
+    ]
+    dataloader_num_workers = 0
+    batch_size = 2
+    num_train_epochs = 2
+    seed = 0
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset_ratios = {}
+    # dataset_ratios = {
+    #     "demo_data/ultravideo-long": 0.9,
+    # }
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        feature_folder,
+        force_rebuild=True,
+        return_all_vae_latent=True,
+        return_prompt_raw=True,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+        seed=seed,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=True,
+        dataset_sampling_ratios=dataset_ratios,
+        seed=seed,
+        # num_sp_groups=get_world_size() // get_sp_world_size(),
+        # sp_world_size=get_sp_world_size(),
+        # global_rank=get_world_rank(),
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(
+        dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=dataloader_num_workers
+    )
+
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+    if checkpoint_dirs:
+        latest_checkpoint = max(checkpoint_dirs, key=lambda x: int(x.split("-")[1]))
+        checkpoint_path = os.path.join(output_dir, latest_checkpoint)
+        print(f"Found checkpoint: {checkpoint_path}")
+
+        accelerator.load_state(checkpoint_path)
+        global_step = int(latest_checkpoint.split("-")[1])
+        first_epoch = global_step // num_update_steps_per_epoch
+
+        states = {
+            "dataloader": dataloader,
+        }
+        dcp_dir = os.path.join(checkpoint_path, "distributed_checkpoint")
+        dcp.load(states, checkpoint_id=dcp_dir)
+
+        print(f"Resuming from step {global_step}, epoch {first_epoch}")
+
+    print("Testing dataloader...")
+    step = global_step
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            uttid = batch["uttid"]
+            num_frame = batch["num_frame"]
+            height = batch["height"]
+            width = batch["width"]
+            bucket_key = batch["bucket_key"]
+
+            # Get feature
+            x0_latents = batch["x0_latents"]
+            history_latents = batch["history_latents"]
+            target_latents = batch["target_latents"]
+            prompt_embeds = batch["prompt_embeds"]
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                # print(f"  Data Name: {batch['dataset_name']}")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  X0 latent shape: {x0_latents.shape}")
+                print(f"  History latent shape: {history_latents.shape}")
+                print(f"  Context latent shape: {target_latents.shape}")
+                print(f"  Prompt embed shape: {prompt_embeds.shape}")
+                # print(f"  Prompt attention mask shape: {prompt_attention_masks.shape}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            for dataset_name in batch["dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+            # if step == 20:
+            #     checkpoint_dir = f"checkpoint-{step}"
+            #     save_path = os.path.join(output_dir, checkpoint_dir)
+            #     os.makedirs(save_path, exist_ok=True)
+
+            #     if accelerator.is_main_process:
+            #         print(f"Saving checkpoint at step {step}")
+
+            #         accelerator.save_state(save_path)
+
+            #     print(accelerator.process_index, accelerator.num_processes)
+            #     states = {
+            #         "dataloader": dataloader,
+            #     }
+            #     dcp_dir = os.path.join(save_path, "distributed_checkpoint")
+            #     dcp.save(states, checkpoint_id=dcp_dir)
+
+    print("实际采样统计:", dict(dataset_counts))

Helios-main/helios/dataset/dataloader_mp4_dist.py

@@ -0,0 +1,854 @@
+import json
+import os
+import pickle
+import random
+from collections import defaultdict
+from typing import Optional
+
+import pandas as pd
+import torch
+import torchvision
+from torch.utils.data import Dataset, Sampler
+from video_reader import PyVideoReader
+
+from diffusers.training_utils import free_memory
+from diffusers.utils import export_to_video
+
+
+resolution_bucket_options = {
+    640: [
+        (768, 320),
+        (768, 384),
+        (640, 384),
+        (768, 512),
+        (576, 448),
+        (512, 512),
+        (448, 576),
+        (512, 768),
+        (384, 640),
+        (384, 768),
+        (320, 768),
+    ],
+}
+
+length_bucket_options = {
+    1: [
+        501,
+        481,
+        461,
+        441,
+        421,
+        401,
+        381,
+        361,
+        341,
+        321,
+        301,
+        281,
+        261,
+        241,
+        221,
+        193,
+        181,
+        161,
+        141,
+        121,
+        101,
+        81,
+        61,
+        41,
+        21,
+    ],
+    2: [193, 177, 161, 156, 145, 133, 129, 121, 113, 109, 97, 85, 81, 73, 65, 61, 49, 37, 25],
+}
+
+
+def find_nearest_resolution_bucket(h, w, resolution=640):
+    min_metric = float("inf")
+    best_bucket = None
+    for bucket_h, bucket_w in resolution_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
+
+
+def find_nearest_length_bucket(length, stride=1):
+    buckets = length_bucket_options[stride]
+    min_bucket = min(buckets)
+    if length < min_bucket:
+        return length
+    valid_buckets = [bucket for bucket in buckets if bucket <= length]
+    return max(valid_buckets)
+
+
+def read_cut_crop_and_resize(
+    video_path, f_prime, h_prime, w_prime, stride=1, start_frame=None, end_frame=None, crop=None
+):
+    frame_indices = list(range(start_frame, end_frame, stride))
+    assert len(frame_indices) == f_prime
+
+    vr = PyVideoReader(video_path, threads=0)  # 0 means auto (let ffmpeg pick the optimal number)
+    frames = torch.from_numpy(vr.get_batch(frame_indices)).float()
+
+    frames = (frames / 127.5) - 1
+    video = frames.permute(0, 3, 1, 2)
+
+    s_x, e_x, s_y, e_y = crop
+    video = video[:, :, s_y:e_y, s_x:e_x]
+
+    frames, channels, h, w = video.shape
+    aspect_ratio_original = h / w
+    aspect_ratio_target = h_prime / w_prime
+
+    if aspect_ratio_original >= aspect_ratio_target:
+        new_h = int(w * aspect_ratio_target)
+        top = (h - new_h) // 2
+        bottom = top + new_h
+        left = 0
+        right = w
+    else:
+        new_w = int(h / aspect_ratio_target)
+        left = (w - new_w) // 2
+        right = left + new_w
+        top = 0
+        bottom = h
+
+    # Crop the video
+    cropped_video = video[:, :, top:bottom, left:right]
+    # Resize the cropped video
+    resized_video = torchvision.transforms.functional.resize(cropped_video, (h_prime, w_prime))
+    return resized_video
+
+
+def save_frames(frame_raw, fps=24, video_path="1.mp4"):
+    save_list = []
+    for frame in frame_raw:
+        frame = (frame + 1) / 2 * 255
+        frame = torchvision.transforms.transforms.ToPILImage()(frame.to(torch.uint8)).convert("RGB")
+        save_list.append(frame)
+        frame = None
+        del frame
+    export_to_video(save_list, video_path, fps=fps)
+
+    save_list = None
+    del save_list
+    free_memory()
+
+
+class BucketedFeatureDataset(Dataset):
+    def __init__(
+        self,
+        json_files,
+        video_folders,
+        stride=1,
+        base_fps=None,
+        resolution=640,
+        force_rebuild=True,
+        single_res=False,
+        single_length=False,
+        single_num_frame=81,
+        single_height=384,
+        single_width=640,
+        multi_res=False,
+        id_token: Optional[str] = None,
+    ):
+        self.stride = stride
+        self.base_fps = base_fps
+        self.resolution = resolution
+        self.force_rebuild = force_rebuild
+        self.single_res = single_res
+        self.single_height = single_height
+        self.single_width = single_width
+        self.single_length = single_length
+        self.single_num_frame = single_num_frame
+        self.multi_res = multi_res
+        self.id_token = id_token or ""
+        self._epoch = 0
+
+        if isinstance(json_files, str):
+            self.json_files = [json_files]
+        else:
+            self.json_files = json_files
+
+        if isinstance(video_folders, str):
+            self.video_folders = [video_folders]
+        else:
+            self.video_folders = video_folders
+
+        assert len(self.json_files) == len(self.video_folders), (
+            f"json_files ({len(self.json_files)}) and video_folders ({len(self.video_folders)}) must have the same length"
+        )
+
+        self.samples = []
+        self.buckets = defaultdict(list)
+
+        for json_file, video_folder in zip(self.json_files, self.video_folders):
+            cache_file = json_file.replace(".json", "_cache.pkl").replace(".csv", "_cache.pkl")
+            self._process_json_file(json_file, video_folder, cache_file)
+
+    def _process_json_file(self, json_file, video_folder, cache_file):
+        if self.force_rebuild or not os.path.exists(cache_file):
+            if os.path.exists(cache_file):
+                print(f"Remove {cache_file}")
+                os.remove(cache_file)
+            print(f"Building metadata cache for file: {json_file}")
+            print(f"  Video folder: {video_folder}")
+            file_samples, file_buckets = self._build_file_metadata(json_file, video_folder)
+
+            print(f"Saving metadata cache to: {cache_file}")
+            cached_data = {"samples": file_samples, "buckets": file_buckets}
+            with open(cache_file, "wb") as f:
+                pickle.dump(cached_data, f)
+            print(f"Cached {len(file_samples)} samples from {json_file}\n")
+        else:
+            print(f"Loading cached metadata from: {cache_file}")
+            with open(cache_file, "rb") as f:
+                cached_data = pickle.load(f)
+            file_samples = cached_data["samples"]
+            file_buckets = cached_data["buckets"]
+            print(f"Loaded {len(file_samples)} samples from cache: {cache_file}\n")
+
+        sample_idx_offset = len(self.samples)
+        self.samples.extend(file_samples)
+
+        for bucket_key, indices in file_buckets.items():
+            adjusted_indices = [idx + sample_idx_offset for idx in indices]
+            self.buckets[bucket_key].extend(adjusted_indices)
+
+    def _build_file_metadata(self, json_file, video_folder):
+        with open(json_file, "r") as f:
+            data = json.load(f)
+
+        print(f"Scanning video folder: {video_folder}")
+        existing_videos = set()
+        for root, dirs, files in os.walk(video_folder):
+            for file in files:
+                if file.endswith(".mp4"):
+                    rel_path = os.path.relpath(os.path.join(root, file), video_folder)
+                    existing_videos.add(rel_path)
+        print(f"Found {len(existing_videos)} video files")
+
+        df = pd.DataFrame(
+            [
+                {
+                    "cut": item["cut"],
+                    "crop": item["crop"],
+                    "path": item["path"],
+                    "num_frames": item["num_frames"],
+                    "width": item["resolution"]["width"],
+                    "height": item["resolution"]["height"],
+                    "fps": item["fps"],
+                    "cap": item["cap"],
+                }
+                for item in data
+            ]
+        )
+
+        samples = []
+        buckets = defaultdict(list)
+        sample_idx = 0
+
+        print(f"Processing {len(df)} records from {json_file} with stride={self.stride}...")
+        for i, row in df.iterrows():
+            if i % 10000 == 0:
+                print(f"  Processed {i}/{len(df)} records")
+
+            video_file = (
+                row["path"]
+                .replace("videos_clip_v1_20241111/", "")
+                .replace("videos_clip_v2_20241111/", "")
+                .replace("videos_clip_v4_20241111/", "")
+            )
+            if video_file not in existing_videos:
+                print("bad video!")
+                continue
+            video_path = os.path.join(video_folder, video_file)
+
+            cut_start_frame = row["cut"][0]
+            cut_end_frame = row["cut"][1]
+            num_frame = cut_end_frame - cut_start_frame
+
+            if self.single_length:
+                if num_frame < self.single_num_frame:
+                    continue
+            else:
+                if num_frame < 121:
+                    continue
+
+            uttid = os.path.basename(video_file).replace(".mp4", "") + f"_{cut_start_frame}-{cut_end_frame}"
+            fps = row["fps"]
+
+            crop = row["crop"]
+            width = crop[1] - crop[0]
+            height = crop[3] - crop[2]
+
+            prompt = row["cap"][0]
+
+            # TODO need to be checked
+            effective_num_frame = (num_frame + self.stride - 1) // self.stride
+            bucket_num_frame = find_nearest_length_bucket(effective_num_frame, stride=self.stride)
+            bucket_height, bucket_width = find_nearest_resolution_bucket(height, width, resolution=self.resolution)
+
+            if self.single_res or self.multi_res:
+                allowed_resolutions = [(self.single_height, self.single_width)]
+                if self.multi_res:
+                    allowed_resolutions.extend(
+                        [
+                            (self.single_height // 2, self.single_width // 2),
+                            (self.single_height // 4, self.single_width // 4),
+                        ]
+                    )
+                if (bucket_height, bucket_width) not in allowed_resolutions:
+                    print("continue res")
+                    continue
+                bucket_height, bucket_width = random.choice(allowed_resolutions)
+
+            if self.single_length:
+                bucket_num_frame = self.single_num_frame
+
+            if self.base_fps is not None:
+                stride = max(int(fps / self.base_fps), 1)
+                required_frames = bucket_num_frame * stride
+                if required_frames >= num_frame:
+                    print("continue frame")
+                    continue
+            else:
+                stride = self.stride
+
+            bucket_key = (bucket_num_frame, bucket_height, bucket_width)
+
+            sample_info = {
+                "uttid": uttid,
+                "dataset_name": json_file.rstrip("/"),
+                "video_folder": video_folder,
+                "video_path": video_path,
+                "bucket_key": bucket_key,
+                "prompt": self.id_token + prompt,
+                "fps": fps,
+                "stride": stride,
+                "effective_num_frame": effective_num_frame,
+                "num_frame": num_frame,
+                "height": height,
+                "width": width,
+                "bucket_num_frame": bucket_num_frame,
+                "bucket_height": bucket_height,
+                "bucket_width": bucket_width,
+                "cut_start_frame": cut_start_frame,
+                "cut_end_frame": cut_end_frame,
+                "crop": crop,
+            }
+
+            samples.append(sample_info)
+            buckets[bucket_key].append(sample_idx)
+            sample_idx += 1
+
+        return samples, buckets
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        anchor_h = self.samples[idx]["bucket_height"]
+        anchor_w = self.samples[idx]["bucket_width"]
+        anchor_f = self.samples[idx]["bucket_num_frame"]
+
+        max_retries = 1000
+        retry_count = 0
+
+        while retry_count < max_retries:
+            sample_info = self.samples[idx]
+
+            if (
+                anchor_h != sample_info["bucket_height"]
+                or anchor_w != sample_info["bucket_width"]
+                or anchor_f != sample_info["bucket_num_frame"]
+            ):
+                idx = random.randint(0, len(self.samples) - 1)
+                retry_count += 1
+                continue
+
+            try:
+                stride = sample_info["stride"]
+                cut_start_frame = sample_info["cut_start_frame"]
+                cut_end_frame = sample_info["cut_end_frame"]
+                bucket_num_frame = sample_info["bucket_num_frame"]
+
+                max_start_frame = cut_end_frame - bucket_num_frame * stride
+                if max_start_frame < cut_start_frame:
+                    start_frame = cut_start_frame
+                else:
+                    start_frame = random.randint(cut_start_frame, max_start_frame)
+                end_frame = start_frame + bucket_num_frame * stride
+
+                video_data = read_cut_crop_and_resize(
+                    video_path=sample_info["video_path"],
+                    f_prime=sample_info["bucket_num_frame"],
+                    h_prime=sample_info["bucket_height"],
+                    w_prime=sample_info["bucket_width"],
+                    stride=stride,
+                    start_frame=start_frame,
+                    end_frame=end_frame,
+                    crop=sample_info["crop"],
+                )
+
+                return {
+                    "uttid": sample_info["uttid"],
+                    "bucket_key": sample_info["bucket_key"],
+                    "dataset_name": sample_info["dataset_name"],
+                    "video_metadata": {
+                        "num_frames": sample_info["bucket_num_frame"],
+                        "height": sample_info["bucket_height"],
+                        "width": sample_info["bucket_width"],
+                        "fps": sample_info["fps"],
+                        "stride": stride,
+                        "effective_num_frame": sample_info["effective_num_frame"],
+                    },
+                    "videos": video_data,
+                    "prompts": sample_info["prompt"],
+                    "first_frames_images": (video_data[0] + 1) / 2 * 255,
+                }
+            except Exception as e:
+                print(f"Error loading {sample_info['video_path']}: {e}")
+                idx = random.randint(0, len(self.samples) - 1)
+                retry_count += 1
+
+        print(f"Failed to load sample after {max_retries} retries, returning None")
+        return None
+
+
+class BucketedSampler(Sampler):
+    def __init__(
+        self,
+        dataset,
+        batch_size,
+        drop_last=False,
+        shuffle=True,
+        seed=42,
+        dataset_sampling_ratios=None,
+        num_sp_groups=1,
+        sp_world_size=1,
+        global_rank=0,
+    ):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.drop_last = drop_last
+        self.shuffle = shuffle
+        self.seed = seed
+        self.generator = torch.Generator()
+        self.buckets = dataset.buckets
+        self._epoch = 0
+
+        # Distributed parameters
+        self.num_sp_groups = num_sp_groups
+        self.sp_world_size = sp_world_size
+        self.global_rank = global_rank
+        self.ith_sp_group = self.global_rank // self.sp_world_size
+
+        self.dataset_sampling_ratios = (
+            {key.rstrip("/"): value for key, value in dataset_sampling_ratios.items()}
+            if dataset_sampling_ratios is not None
+            else {}
+        )
+        self._prepare_dataset_buckets()
+
+    def _prepare_dataset_buckets(self):
+        self.dataset_buckets = {}
+
+        for bucket_key, sample_indices in self.buckets.items():
+            dataset_groups = {}
+            for idx in sample_indices:
+                dataset_name = self.dataset.samples[idx]["dataset_name"]
+                if dataset_name not in dataset_groups:
+                    dataset_groups[dataset_name] = []
+                dataset_groups[dataset_name].append(idx)
+            self.dataset_buckets[bucket_key] = dataset_groups
+
+    def set_epoch(self, epoch):
+        self._epoch = epoch
+
+    def _shard_indices_for_sp_group(self, indices):
+        """
+        Shard indices across SP groups, similar to DP_SP_BatchSampler.
+        Each SP group gets a disjoint subset of the data.
+        """
+        if self.num_sp_groups == 1:
+            return indices
+
+        # Convert to tensor if it's a list
+        if isinstance(indices, list):
+            indices_tensor = torch.tensor(indices, dtype=torch.long)
+        else:
+            indices_tensor = indices
+
+        # Pad indices if necessary to make it divisible by num_sp_groups
+        total_size = len(indices_tensor)
+        if total_size % self.num_sp_groups != 0:
+            if not self.drop_last:
+                padding_size = self.num_sp_groups - (total_size % self.num_sp_groups)
+                indices_tensor = torch.cat([indices_tensor, indices_tensor[:padding_size]])
+        else:
+            # If drop_last, truncate to be divisible
+            if self.drop_last:
+                truncate_size = (total_size // self.num_sp_groups) * self.num_sp_groups
+                indices_tensor = indices_tensor[:truncate_size]
+
+        # Shard: each SP group gets every num_sp_groups-th element
+        sp_group_indices = indices_tensor[self.ith_sp_group :: self.num_sp_groups]
+
+        return sp_group_indices.tolist()
+
+    def _apply_global_ratio_sampling(self):
+        if not self.dataset_sampling_ratios:
+            return
+
+        dataset_sample_map = {}
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            for dataset_name, indices in dataset_groups.items():
+                if dataset_name not in dataset_sample_map:
+                    dataset_sample_map[dataset_name] = {"indices": [], "buckets": []}
+                dataset_sample_map[dataset_name]["indices"].extend(indices)
+                dataset_sample_map[dataset_name]["buckets"].extend([bucket_key] * len(indices))
+
+        total_samples = sum(len(info["indices"]) for info in dataset_sample_map.values())
+        total_ratio = sum(self.dataset_sampling_ratios.values())
+
+        sampled_dataset_map = {}
+        for dataset_name, info in dataset_sample_map.items():
+            if dataset_name in self.dataset_sampling_ratios:
+                ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                target_samples = max(1, int(total_samples * ratio))
+
+                indices = info["indices"]
+                buckets = info["buckets"]
+
+                if len(indices) >= target_samples:
+                    selected = torch.randperm(len(indices), generator=self.generator)[:target_samples].tolist()
+                    sampled_indices = [indices[i] for i in selected]
+                    sampled_buckets = [buckets[i] for i in selected]
+                else:
+                    sampled_indices = []
+                    sampled_buckets = []
+                    remaining = target_samples
+
+                    while remaining > 0:
+                        repeat_count = min(remaining, len(indices))
+                        selected = torch.randperm(len(indices), generator=self.generator)[:repeat_count].tolist()
+                        sampled_indices.extend([indices[i] for i in selected])
+                        sampled_buckets.extend([buckets[i] for i in selected])
+                        remaining -= repeat_count
+
+                sampled_dataset_map[dataset_name] = {"indices": sampled_indices, "buckets": sampled_buckets}
+            else:
+                sampled_dataset_map[dataset_name] = info
+
+        new_dataset_buckets = {}
+        for bucket_key in self.dataset_buckets.keys():
+            new_dataset_buckets[bucket_key] = {}
+
+        for dataset_name, info in sampled_dataset_map.items():
+            indices = info["indices"]
+            buckets = info["buckets"]
+
+            for idx, bucket_key in zip(indices, buckets):
+                if dataset_name not in new_dataset_buckets[bucket_key]:
+                    new_dataset_buckets[bucket_key][dataset_name] = []
+                new_dataset_buckets[bucket_key][dataset_name].append(idx)
+
+        self.dataset_buckets = new_dataset_buckets
+
+    def __iter__(self):
+        # Use epoch-level seed for reproducibility
+        epoch_seed = self.seed + self._epoch
+        self.generator.manual_seed(epoch_seed)
+
+        if self.dataset_sampling_ratios:
+            self._apply_global_ratio_sampling()
+
+        bucket_iterators = {}
+        bucket_batches = {}
+
+        for bucket_key, dataset_groups in self.dataset_buckets.items():
+            balanced_indices = self._create_balanced_indices(dataset_groups)
+
+            # Global shuffle before sharding (important for distributed consistency)
+            if self.shuffle:
+                perm = torch.randperm(len(balanced_indices), generator=self.generator).tolist()
+                balanced_indices = [balanced_indices[i] for i in perm]
+
+            # Shard indices for this SP group
+            sp_group_indices = self._shard_indices_for_sp_group(balanced_indices)
+
+            batches = []
+            for i in range(0, len(sp_group_indices), self.batch_size):
+                batch = sp_group_indices[i : i + self.batch_size]
+                if len(batch) == self.batch_size or not self.drop_last:
+                    batches.append(batch)
+
+            if batches:
+                bucket_batches[bucket_key] = batches
+                bucket_iterators[bucket_key] = iter(batches)
+
+        remaining_buckets = list(bucket_iterators.keys())
+
+        while remaining_buckets:
+            idx = torch.randint(len(remaining_buckets), (1,), generator=self.generator).item()
+            bucket_key = remaining_buckets[idx]
+            bucket_iter = bucket_iterators[bucket_key]
+
+            try:
+                batch = next(bucket_iter)
+                yield batch
+            except StopIteration:
+                remaining_buckets.remove(bucket_key)
+
+    def _create_balanced_indices(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def _equal_sampling(self, dataset_groups):
+        all_indices = []
+        dataset_names = list(dataset_groups.keys())
+
+        if len(dataset_names) <= 1:
+            return sum(dataset_groups.values(), [])
+
+        min_samples = min(len(indices) for indices in dataset_groups.values())
+
+        for dataset_name, indices in dataset_groups.items():
+            if len(indices) > min_samples:
+                selected = torch.randperm(len(indices), generator=self.generator)[:min_samples].tolist()
+                sampled_indices = [indices[i] for i in selected]
+            else:
+                sampled_indices = indices
+            all_indices.extend(sampled_indices)
+
+        return all_indices
+
+    def _ratio_sampling(self, dataset_groups):
+        return sum(dataset_groups.values(), [])
+
+    def __len__(self):
+        if self.dataset_sampling_ratios:
+            temp_generator = torch.Generator()
+            temp_generator.manual_seed(self.seed)
+
+            dataset_sample_map = {}
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                for dataset_name, indices in dataset_groups.items():
+                    if dataset_name not in dataset_sample_map:
+                        dataset_sample_map[dataset_name] = []
+                    dataset_sample_map[dataset_name].extend(indices)
+
+            total_samples = sum(len(indices) for indices in dataset_sample_map.values())
+            total_ratio = sum(self.dataset_sampling_ratios.values())
+
+            sampled_total = 0
+            for dataset_name, indices in dataset_sample_map.items():
+                if dataset_name in self.dataset_sampling_ratios:
+                    ratio = self.dataset_sampling_ratios[dataset_name] / total_ratio
+                    target_samples = max(1, int(total_samples * ratio))
+                    sampled_total += target_samples
+                else:
+                    sampled_total += len(indices)
+
+            # Account for SP group sharding
+            sp_group_samples = sampled_total // self.num_sp_groups
+            if not self.drop_last and sampled_total % self.num_sp_groups != 0:
+                sp_group_samples += 1
+
+            total_batches = sp_group_samples // self.batch_size
+            if not self.drop_last and sp_group_samples % self.batch_size != 0:
+                total_batches += 1
+            return total_batches
+        else:
+            total_batches = 0
+            for bucket_key, dataset_groups in self.dataset_buckets.items():
+                balanced_indices = self._create_balanced_indices(dataset_groups)
+
+                # Account for SP group sharding
+                sp_group_size = len(balanced_indices) // self.num_sp_groups
+                if not self.drop_last and len(balanced_indices) % self.num_sp_groups != 0:
+                    sp_group_size += 1
+
+                num_batches = sp_group_size // self.batch_size
+                if not self.drop_last and sp_group_size % self.batch_size != 0:
+                    num_batches += 1
+                total_batches += num_batches
+            return total_batches
+
+
+def collate_fn(batch):
+    batch = [item for item in batch if item is not None]
+
+    if len(batch) == 0:
+        return None
+
+    def collate_dict(data_list):
+        if isinstance(data_list[0], dict):
+            return {key: collate_dict([d[key] for d in data_list]) for key in data_list[0]}
+        elif isinstance(data_list[0], torch.Tensor):
+            return torch.stack(data_list)
+        else:
+            return data_list
+
+    return {key: collate_dict([d[key] for d in batch]) for key in batch[0]}
+
+
+if __name__ == "__main__":
+    import torch.distributed.checkpoint as dcp
+    from accelerate import Accelerator
+    from torchdata.stateful_dataloader import StatefulDataLoader
+
+    json_file = [
+        "opensoraplan/jsons/video_mixkit_513f_1997.json",
+    ]
+    video_folder = [
+        "opensoraplan/videos",
+    ]
+    stride = 1
+    batch_size = 2
+    num_train_epochs = 1
+    seed = 0
+    num_workers = 8
+    output_dir = "accelerate_checkpoints"
+    checkpoint_dirs = (
+        [
+            d
+            for d in os.listdir(output_dir)
+            if d.startswith("checkpoint-") and os.path.isdir(os.path.join(output_dir, d))
+        ]
+        if os.path.exists(output_dir)
+        else []
+    )
+
+    dataset_ratios = {}
+    # dataset_ratios = {
+    #     "/mnt/hdfs/data/ysh_new/userful_things_wan/open-sora-plan-istock/istock_v4/latents": 0.9,
+    #     "/mnt/hdfs/data/ysh_new/userful_things_wan/sekai/sekai-real-walking-hq-193/latents_stride1": 0.1
+    # }
+
+    accelerator = Accelerator()
+    print(accelerator.process_index, accelerator.num_processes)
+
+    dataset = BucketedFeatureDataset(
+        json_files=json_file,
+        video_folders=video_folder,
+        stride=stride,
+        force_rebuild=False,
+        resolution=640,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+        single_length=True,
+        single_num_frame=81,
+        multi_res=True,
+    )
+    sampler = BucketedSampler(
+        dataset,
+        batch_size=batch_size,
+        drop_last=True,
+        shuffle=False,
+        dataset_sampling_ratios=dataset_ratios,
+        seed=seed,
+        # num_sp_groups=get_world_size() // get_sp_world_size(),
+        # sp_world_size=get_sp_world_size(),
+        # global_rank=get_world_rank(),
+        num_sp_groups=accelerator.num_processes // 1,
+        sp_world_size=1,
+        global_rank=accelerator.process_index,
+    )
+    dataloader = StatefulDataLoader(dataset, batch_sampler=sampler, collate_fn=collate_fn, num_workers=num_workers)
+
+    print(len(dataset), len(dataloader))
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+
+    step = 0
+    global_step = 0
+    first_epoch = 0
+    num_update_steps_per_epoch = len(dataloader)
+    if checkpoint_dirs:
+        latest_checkpoint = max(checkpoint_dirs, key=lambda x: int(x.split("-")[1]))
+        checkpoint_path = os.path.join(output_dir, latest_checkpoint)
+        print(f"Found checkpoint: {checkpoint_path}")
+
+        accelerator.load_state(checkpoint_path)
+        global_step = int(latest_checkpoint.split("-")[1])
+        first_epoch = global_step // num_update_steps_per_epoch
+
+        states = {
+            "dataloader": dataloader,
+        }
+        dcp_dir = os.path.join(checkpoint_path, "distributed_checkpoint")
+        dcp.load(states, checkpoint_id=dcp_dir)
+
+        print(f"Resuming from step {global_step}, epoch {first_epoch}")
+
+    print("Testing dataloader...")
+    step = global_step
+    dataset_counts = defaultdict(int)
+    for epoch in range(first_epoch, num_train_epochs):
+        sampler.set_epoch(epoch)
+        dataset.set_epoch(epoch)
+        for i, batch in enumerate(dataloader):
+            # Get metadata
+            uttid = batch["uttid"]
+            bucket_key = batch["bucket_key"]
+            num_frame = batch["video_metadata"]["num_frames"]
+            height = batch["video_metadata"]["height"]
+            width = batch["video_metadata"]["width"]
+
+            # Get feature
+            video_data = batch["videos"]
+            prompt = batch["prompts"]
+            first_frames_images = batch["first_frames_images"]
+            first_frames_images = [torchvision.transforms.ToPILImage()(x.to(torch.uint8)) for x in first_frames_images]
+
+            # save_frames(video_data[0].squeeze(0), video_path="1.mp4")
+            # import pdb;pdb.set_trace()
+
+            if accelerator.process_index == 0:
+                # print info
+                print(f" Step {step}:")
+                print(f"  Batch {i}:")
+                # print(f"  Data Name: {batch['dataset_name']}")
+                print(f"  Batch size: {len(uttid)}")
+                print(f"  Uttids: {uttid}")
+                print(f"  Dimensions - frames: {num_frame[0]}, height: {height[0]}, width: {width[0]}")
+                print(f"  Bucket key: {bucket_key[0]}")
+                print(f"  Videos shape: {video_data.shape}")
+                print(f"  Cpation: {prompt}")
+
+                # verify
+                assert all(nf == num_frame[0] for nf in num_frame), "Frame numbers not consistent in batch"
+                assert all(h == height[0] for h in height), "Heights not consistent in batch"
+                assert all(w == width[0] for w in width), "Widths not consistent in batch"
+
+                print("  ✓ Batch dimensions are consistent")
+
+            for dataset_name in batch["dataset_name"]:
+                dataset_counts[dataset_name] += 1
+
+            step += 1
+
+            # if step == 20:
+            #     checkpoint_dir = f"checkpoint-{step}"
+            #     save_path = os.path.join(output_dir, checkpoint_dir)
+            #     os.makedirs(save_path, exist_ok=True)
+
+            #     if accelerator.is_main_process:
+            #         print(f"Saving checkpoint at step {step}")
+
+            #         accelerator.save_state(save_path)
+
+            #     print(accelerator.process_index, accelerator.num_processes)
+            #     states = {
+            #         "dataloader": dataloader,
+            #     }
+            #     dcp_dir = os.path.join(save_path, "distributed_checkpoint")
+            #     dcp.save(states, checkpoint_id=dcp_dir)
+
+    print("实际采样统计:", dict(dataset_counts))

Helios-main/helios/pipelines/pipeline_output.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+
+import torch
+
+from diffusers.utils import BaseOutput
+
+
+@dataclass
+class HeliosPipelineOutput(BaseOutput):
+    r"""
+    Output class for Helios pipelines.
+
+    Args:
+        frames (`torch.Tensor`, `np.ndarray`, or List[List[PIL.Image.Image]]):
+            List of video outputs - It can be a nested list of length `batch_size,` with each sub-list containing
+            denoised PIL image sequences of length `num_frames.` It can also be a NumPy array or Torch tensor of shape
+            `(batch_size, num_frames, channels, height, width)`.
+    """
+
+    frames: torch.Tensor

Helios-main/helios/scheduler/scheduling_helios.py

@@ -0,0 +1,1056 @@
+import math
+from dataclasses import dataclass
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from diffusers.utils import BaseOutput, deprecate
+
+
+@dataclass
+class HeliosSchedulerOutput(BaseOutput):
+    """
+    Output class for the scheduler's `step` function output.
+
+    Args:
+        prev_sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` for images):
+            Computed sample `(x_{t-1})` of previous timestep. `prev_sample` should be used as next model input in the
+            denoising loop.
+    """
+
+    prev_sample: torch.FloatTensor
+    model_outputs: torch.FloatTensor
+    last_sample: torch.FloatTensor
+    this_order: int
+
+
+class HeliosScheduler(SchedulerMixin, ConfigMixin):
+    """
+    Euler scheduler.
+
+    This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic
+    methods the library implements for all schedulers such as loading and saving.
+
+    Args:
+        num_train_timesteps (`int`, defaults to 1000):
+            The number of diffusion steps to train the model.
+        timestep_spacing (`str`, defaults to `"linspace"`):
+            The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and
+            Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.
+        shift (`float`, defaults to 1.0):
+            The shift value for the timestep schedule.
+    """
+
+    _compatibles = []
+    order = 1
+
+    @register_to_config
+    def __init__(
+        self,
+        num_train_timesteps: int = 1000,
+        shift: float = 1.0,  # Following Stable diffusion 3,
+        stages: int = 3,
+        stage_range: List = [0, 1 / 3, 2 / 3, 1],
+        gamma: float = 1 / 3,
+        # For UniPC
+        thresholding: bool = False,
+        prediction_type: str = "flow_prediction",
+        solver_order: int = 2,
+        predict_x0: bool = True,
+        solver_type: str = "bh2",
+        lower_order_final: bool = True,
+        disable_corrector: List[int] = [],
+        solver_p: SchedulerMixin = None,
+        use_flow_sigmas: bool = True,
+        version: str = "v1",
+    ):
+        self.version = version
+        self.timestep_ratios = {}  # The timestep ratio for each stage
+        self.timesteps_per_stage = {}  # The detailed timesteps per stage (fix max and min per stage)
+        self.sigmas_per_stage = {}  # always uniform [1000, 0]
+        self.start_sigmas = {}  # for start point / upsample renoise
+        self.end_sigmas = {}  # for end point
+        self.ori_start_sigmas = {}
+
+        # self.init_sigmas()
+        self.init_sigmas_for_each_stage()
+        self.sigma_min = self.sigmas[-1].item()
+        self.sigma_max = self.sigmas[0].item()
+        self.gamma = gamma
+
+        if solver_type not in ["bh1", "bh2"]:
+            if solver_type in ["midpoint", "heun", "logrho"]:
+                self.register_to_config(solver_type="bh2")
+            else:
+                raise NotImplementedError(f"{solver_type} is not implemented for {self.__class__}")
+
+        self.predict_x0 = predict_x0
+        self.model_outputs = [None] * solver_order
+        self.timestep_list = [None] * solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = disable_corrector
+        self.solver_p = solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def init_sigmas(self):
+        """
+        initialize the global timesteps and sigmas
+        """
+        num_train_timesteps = self.config.num_train_timesteps
+        shift = self.config.shift
+
+        alphas = np.linspace(1, 1 / num_train_timesteps, num_train_timesteps + 1)
+        sigmas = 1.0 - alphas
+        sigmas = np.flip(shift * sigmas / (1 + (shift - 1) * sigmas))[:-1].copy()
+        sigmas = torch.from_numpy(sigmas)
+        timesteps = (sigmas * num_train_timesteps).clone()
+
+        self._step_index = None
+        self._begin_index = None
+        self.timesteps = timesteps
+        self.sigmas = sigmas.to("cpu")  # to avoid too much CPU/GPU communication
+
+    def init_sigmas_for_each_stage(self):
+        """
+        Init the timesteps for each stage
+        """
+        self.init_sigmas()
+
+        stage_distance = []
+        stages = self.config.stages
+        training_steps = self.config.num_train_timesteps
+        stage_range = self.config.stage_range
+
+        # Init the start and end point of each stage
+        for i_s in range(stages):
+            # To decide the start and ends point
+            start_indice = int(stage_range[i_s] * training_steps)
+            start_indice = max(start_indice, 0)
+            end_indice = int(stage_range[i_s + 1] * training_steps)
+            end_indice = min(end_indice, training_steps)
+            start_sigma = self.sigmas[start_indice].item()
+            end_sigma = self.sigmas[end_indice].item() if end_indice < training_steps else 0.0
+            self.ori_start_sigmas[i_s] = start_sigma
+
+            if i_s != 0:
+                ori_sigma = 1 - start_sigma
+                gamma = self.config.gamma
+                corrected_sigma = (1 / (math.sqrt(1 + (1 / gamma)) * (1 - ori_sigma) + ori_sigma)) * ori_sigma
+                # corrected_sigma = 1 / (2 - ori_sigma) * ori_sigma
+                start_sigma = 1 - corrected_sigma
+
+            stage_distance.append(start_sigma - end_sigma)
+            self.start_sigmas[i_s] = start_sigma
+            self.end_sigmas[i_s] = end_sigma
+
+            if self.version == "v2":
+                new_start_indice = (
+                    len(self.sigmas) - torch.searchsorted(self.sigmas.flip(0), start_sigma, right=True)
+                ).item()
+                self.sigmas_per_stage[i_s] = self.sigmas[new_start_indice:end_indice]
+                self.timesteps_per_stage[i_s] = self.timesteps[new_start_indice:end_indice]
+
+        if self.version == "v2":
+            return
+
+        # Determine the ratio of each stage according to flow length
+        tot_distance = sum(stage_distance)
+        for i_s in range(stages):
+            if i_s == 0:
+                start_ratio = 0.0
+            else:
+                start_ratio = sum(stage_distance[:i_s]) / tot_distance
+            if i_s == stages - 1:
+                end_ratio = 0.9999999999999999
+            else:
+                end_ratio = sum(stage_distance[: i_s + 1]) / tot_distance
+
+            self.timestep_ratios[i_s] = (start_ratio, end_ratio)
+
+        # Determine the timesteps and sigmas for each stage
+        for i_s in range(stages):
+            timestep_ratio = self.timestep_ratios[i_s]
+            # timestep_max = self.timesteps[int(timestep_ratio[0] * training_steps)]
+            timestep_max = min(self.timesteps[int(timestep_ratio[0] * training_steps)], 999)
+            timestep_min = self.timesteps[min(int(timestep_ratio[1] * training_steps), training_steps - 1)]
+            timesteps = np.linspace(timestep_max, timestep_min, training_steps + 1)
+            self.timesteps_per_stage[i_s] = (
+                timesteps[:-1] if isinstance(timesteps, torch.Tensor) else torch.from_numpy(timesteps[:-1])
+            )
+            stage_sigmas = np.linspace(0.999, 0, training_steps + 1)
+            self.sigmas_per_stage[i_s] = torch.from_numpy(stage_sigmas[:-1])
+
+    @property
+    def step_index(self):
+        """
+        The index counter for current timestep. It will increase 1 after each scheduler step.
+        """
+        return self._step_index
+
+    @property
+    def begin_index(self):
+        """
+        The index for the first timestep. It should be set from pipeline with `set_begin_index` method.
+        """
+        return self._begin_index
+
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler.set_begin_index
+    def set_begin_index(self, begin_index: int = 0):
+        """
+        Sets the begin index for the scheduler. This function should be run from pipeline before the inference.
+
+        Args:
+            begin_index (`int`):
+                The begin index for the scheduler.
+        """
+        self._begin_index = begin_index
+
+    def _sigma_to_t(self, sigma):
+        return sigma * self.config.num_train_timesteps
+
+    def set_timesteps(
+        self,
+        num_inference_steps: int,
+        stage_index: int,
+        device: Union[str, torch.device] = None,
+    ):
+        """
+        Setting the timesteps and sigmas for each stage
+        """
+        self.num_inference_steps = num_inference_steps
+        self.init_sigmas()
+
+        if self.version == "v1":
+            stage_timesteps = self.timesteps_per_stage[stage_index]
+            timestep_max = stage_timesteps[0].item()
+            timestep_min = stage_timesteps[-1].item()
+
+            timesteps = np.linspace(
+                timestep_max,
+                timestep_min,
+                num_inference_steps,
+            )
+            self.timesteps = torch.from_numpy(timesteps).to(device=device)
+
+            stage_sigmas = self.sigmas_per_stage[stage_index]
+            sigma_max = stage_sigmas[0].item()
+            sigma_min = stage_sigmas[-1].item()
+
+            ratios = np.linspace(sigma_max, sigma_min, num_inference_steps)
+            sigmas = torch.from_numpy(ratios).to(device=device)
+            self.sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)])
+        else:
+            total_steps = len(self.timesteps_per_stage[stage_index])
+            indices = np.linspace(0, total_steps - 1, num_inference_steps, dtype=int)
+
+            self.timesteps = self.timesteps_per_stage[stage_index][indices].to(device=device)
+
+            if stage_index == (self.config.stages - 1):
+                sigmas = self.sigmas_per_stage[stage_index][indices].to(device=device)
+                self.sigmas = torch.cat([sigmas, torch.zeros(1, device=sigmas.device)])
+            else:
+                sigmas = self.sigmas_per_stage[stage_index][indices].to(device=device)
+                self.sigmas = torch.cat(
+                    [sigmas, torch.tensor([self.ori_start_sigmas[stage_index + 1]], device=sigmas.device)]
+                )
+
+        self._step_index = None
+        self.reset_scheduler_history()
+
+    def index_for_timestep(self, timestep, schedule_timesteps=None):
+        if schedule_timesteps is None:
+            schedule_timesteps = self.timesteps
+
+        indices = (schedule_timesteps == timestep).nonzero()
+
+        # The sigma index that is taken for the **very** first `step`
+        # is always the second index (or the last index if there is only 1)
+        # This way we can ensure we don't accidentally skip a sigma in
+        # case we start in the middle of the denoising schedule (e.g. for image-to-image)
+        pos = 1 if len(indices) > 1 else 0
+
+        return indices[pos].item()
+
+    def _init_step_index(self, timestep):
+        if self.begin_index is None:
+            if isinstance(timestep, torch.Tensor):
+                timestep = timestep.to(self.timesteps.device)
+            self._step_index = self.index_for_timestep(timestep)
+        else:
+            self._step_index = self._begin_index
+
+    def step(
+        self,
+        model_output: torch.FloatTensor,
+        timestep: Union[float, torch.FloatTensor] = None,
+        sample: torch.FloatTensor = None,
+        generator: Optional[torch.Generator] = None,
+        sigma: Optional[torch.FloatTensor] = None,
+        sigma_next: Optional[torch.FloatTensor] = None,
+        return_dict: bool = True,
+    ) -> Union[HeliosSchedulerOutput, Tuple]:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion
+        process from the learned model outputs (most often the predicted noise).
+
+        Args:
+            model_output (`torch.FloatTensor`):
+                The direct output from learned diffusion model.
+            timestep (`float`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.FloatTensor`):
+                A current instance of a sample created by the diffusion process.
+            generator (`torch.Generator`, *optional*):
+                A random number generator.
+            return_dict (`bool`):
+                Whether or not to return a [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or
+                tuple.
+
+        Returns:
+            [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] or `tuple`:
+                If return_dict is `True`, [`~schedulers.scheduling_euler_discrete.EulerDiscreteSchedulerOutput`] is
+                returned, otherwise a tuple is returned where the first element is the sample tensor.
+        """
+
+        assert (sigma is None) == (sigma_next is None), "sigma and sigma_next must both be None or both be not None"
+
+        if sigma is None and sigma_next is None:
+            if (
+                isinstance(timestep, int)
+                or isinstance(timestep, torch.IntTensor)
+                or isinstance(timestep, torch.LongTensor)
+            ):
+                raise ValueError(
+                    (
+                        "Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to"
+                        " `EulerDiscreteScheduler.step()` is not supported. Make sure to pass"
+                        " one of the `scheduler.timesteps` as a timestep."
+                    ),
+                )
+
+        if self.step_index is None:
+            self._step_index = 0
+
+        # Upcast to avoid precision issues when computing prev_sample
+        sample = sample.to(torch.float32)
+
+        if sigma is None and sigma_next is None:
+            sigma = self.sigmas[self.step_index]
+            sigma_next = self.sigmas[self.step_index + 1]
+
+        prev_sample = sample + (sigma_next - sigma) * model_output
+
+        # Cast sample back to model compatible dtype
+        prev_sample = prev_sample.to(model_output.dtype)
+
+        # upon completion increase step index by one
+        self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample,)
+
+        return HeliosSchedulerOutput(prev_sample=prev_sample)
+
+    # ---------------------------------- UniPC ----------------------------------
+    # Copied from diffusers.schedulers.scheduling_dpmsolver_multistep.DPMSolverMultistepScheduler._sigma_to_alpha_sigma_t
+    def _sigma_to_alpha_sigma_t(self, sigma):
+        if self.config.use_flow_sigmas:
+            alpha_t = 1 - sigma
+            sigma_t = torch.clamp(sigma, min=1e-8)
+        else:
+            alpha_t = 1 / ((sigma**2 + 1) ** 0.5)
+            sigma_t = sigma * alpha_t
+
+        return alpha_t, sigma_t
+
+    def convert_model_output(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        r"""
+        Convert the model output to the corresponding type the UniPC algorithm needs.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model.
+            timestep (`int`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+
+        Returns:
+            `torch.Tensor`:
+                The converted model output.
+        """
+        timestep = args[0] if len(args) > 0 else kwargs.pop("timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if timestep is not None:
+            deprecate(
+                "timesteps",
+                "1.0.0",
+                "Passing `timesteps` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        flag = False
+        if sigma is None:
+            flag = True
+            sigma = self.sigmas[self.step_index]
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma)
+
+        if self.predict_x0:
+            if self.config.prediction_type == "epsilon":
+                x0_pred = (sample - sigma_t * model_output) / alpha_t
+            elif self.config.prediction_type == "sample":
+                x0_pred = model_output
+            elif self.config.prediction_type == "v_prediction":
+                x0_pred = alpha_t * sample - sigma_t * model_output
+            elif self.config.prediction_type == "flow_prediction":
+                if flag:
+                    sigma_t = self.sigmas[self.step_index]
+                else:
+                    sigma_t = sigma
+                x0_pred = sample - sigma_t * model_output
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, "
+                    "`v_prediction`, or `flow_prediction` for the UniPCMultistepScheduler."
+                )
+
+            if self.config.thresholding:
+                x0_pred = self._threshold_sample(x0_pred)
+
+            return x0_pred
+        else:
+            if self.config.prediction_type == "epsilon":
+                return model_output
+            elif self.config.prediction_type == "sample":
+                epsilon = (sample - alpha_t * model_output) / sigma_t
+                return epsilon
+            elif self.config.prediction_type == "v_prediction":
+                epsilon = alpha_t * model_output + sigma_t * sample
+                return epsilon
+            else:
+                raise ValueError(
+                    f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
+                    " `v_prediction` for the UniPCMultistepScheduler."
+                )
+
+    def multistep_uni_p_bh_update(
+        self,
+        model_output: torch.Tensor,
+        *args,
+        sample: torch.Tensor = None,
+        order: int = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniP (B(h) version). Alternatively, `self.solver_p` is used if is specified.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from the learned diffusion model at the current timestep.
+            prev_timestep (`int`):
+                The previous discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+            order (`int`):
+                The order of UniP at this timestep (corresponds to the *p* in UniPC-p).
+
+        Returns:
+            `torch.Tensor`:
+                The sample tensor at the previous timestep.
+        """
+        prev_timestep = args[0] if len(args) > 0 else kwargs.pop("prev_timestep", None)
+        if sample is None:
+            if len(args) > 1:
+                sample = args[1]
+            else:
+                raise ValueError("missing `sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 2:
+                order = args[2]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if prev_timestep is not None:
+            deprecate(
+                "prev_timestep",
+                "1.0.0",
+                "Passing `prev_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+        model_output_list = self.model_outputs
+
+        s0 = self.timestep_list[-1]
+        m0 = model_output_list[-1]
+        x = sample
+
+        if self.solver_p:
+            x_t = self.solver_p.step(model_output, s0, x).prev_sample
+            return x_t
+
+        if sigma_next is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index + 1], self.sigmas[self.step_index]
+        else:
+            sigma_t, sigma_s0 = sigma_next, sigma
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - i
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        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=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)  # (B, K)
+            # for order 2, we use a simplified version
+            if order == 2:
+                rhos_p = torch.tensor([0.5], dtype=x.dtype, device=device)
+            else:
+                rhos_p = torch.linalg.solve(R[:-1, :-1], b[:-1]).to(device).to(x.dtype)
+        else:
+            D1s = None
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - alpha_t * B_h * pred_res
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                pred_res = torch.einsum("k,bkc...->bc...", rhos_p, D1s)
+            else:
+                pred_res = 0
+            x_t = x_t_ - sigma_t * B_h * pred_res
+
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def multistep_uni_c_bh_update(
+        self,
+        this_model_output: torch.Tensor,
+        *args,
+        last_sample: torch.Tensor = None,
+        this_sample: torch.Tensor = None,
+        order: int = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        **kwargs,
+    ) -> torch.Tensor:
+        """
+        One step for the UniC (B(h) version).
+
+        Args:
+            this_model_output (`torch.Tensor`):
+                The model outputs at `x_t`.
+            this_timestep (`int`):
+                The current timestep `t`.
+            last_sample (`torch.Tensor`):
+                The generated sample before the last predictor `x_{t-1}`.
+            this_sample (`torch.Tensor`):
+                The generated sample after the last predictor `x_{t}`.
+            order (`int`):
+                The `p` of UniC-p at this step. The effective order of accuracy should be `order + 1`.
+
+        Returns:
+            `torch.Tensor`:
+                The corrected sample tensor at the current timestep.
+        """
+        this_timestep = args[0] if len(args) > 0 else kwargs.pop("this_timestep", None)
+        if last_sample is None:
+            if len(args) > 1:
+                last_sample = args[1]
+            else:
+                raise ValueError("missing `last_sample` as a required keyword argument")
+        if this_sample is None:
+            if len(args) > 2:
+                this_sample = args[2]
+            else:
+                raise ValueError("missing `this_sample` as a required keyword argument")
+        if order is None:
+            if len(args) > 3:
+                order = args[3]
+            else:
+                raise ValueError("missing `order` as a required keyword argument")
+        if this_timestep is not None:
+            deprecate(
+                "this_timestep",
+                "1.0.0",
+                "Passing `this_timestep` is deprecated and has no effect as model output conversion is now handled via an internal counter `self.step_index`",
+            )
+
+        model_output_list = self.model_outputs
+
+        m0 = model_output_list[-1]
+        x = last_sample
+        x_t = this_sample
+        model_t = this_model_output
+
+        if sigma_before is None and sigma is None:
+            sigma_t, sigma_s0 = self.sigmas[self.step_index], self.sigmas[self.step_index - 1]
+        else:
+            sigma_t, sigma_s0 = sigma, sigma_before
+        alpha_t, sigma_t = self._sigma_to_alpha_sigma_t(sigma_t)
+        alpha_s0, sigma_s0 = self._sigma_to_alpha_sigma_t(sigma_s0)
+
+        lambda_t = torch.log(alpha_t) - torch.log(sigma_t)
+        lambda_s0 = torch.log(alpha_s0) - torch.log(sigma_s0)
+
+        h = lambda_t - lambda_s0
+        device = this_sample.device
+
+        rks = []
+        D1s = []
+        for i in range(1, order):
+            si = self.step_index - (i + 1)
+            mi = model_output_list[-(i + 1)]
+            alpha_si, sigma_si = self._sigma_to_alpha_sigma_t(self.sigmas[si])
+            lambda_si = torch.log(alpha_si) - torch.log(sigma_si)
+            rk = (lambda_si - lambda_s0) / h
+            rks.append(rk)
+            D1s.append((mi - m0) / rk)
+
+        rks.append(1.0)
+        rks = torch.tensor(rks, device=device)
+
+        R = []
+        b = []
+
+        hh = -h if self.predict_x0 else h
+        h_phi_1 = torch.expm1(hh)  # h\phi_1(h) = e^h - 1
+        h_phi_k = h_phi_1 / hh - 1
+
+        factorial_i = 1
+
+        if self.config.solver_type == "bh1":
+            B_h = hh
+        elif self.config.solver_type == "bh2":
+            B_h = torch.expm1(hh)
+        else:
+            raise NotImplementedError()
+
+        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=device)
+
+        if len(D1s) > 0:
+            D1s = torch.stack(D1s, dim=1)
+        else:
+            D1s = None
+
+        # for order 1, we use a simplified version
+        if order == 1:
+            rhos_c = torch.tensor([0.5], dtype=x.dtype, device=device)
+        else:
+            rhos_c = torch.linalg.solve(R, b).to(device).to(x.dtype)
+
+        if self.predict_x0:
+            x_t_ = sigma_t / sigma_s0 * x - alpha_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - alpha_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        else:
+            x_t_ = alpha_t / alpha_s0 * x - sigma_t * h_phi_1 * m0
+            if D1s is not None:
+                corr_res = torch.einsum("k,bkc...->bc...", rhos_c[:-1], D1s)
+            else:
+                corr_res = 0
+            D1_t = model_t - m0
+            x_t = x_t_ - sigma_t * B_h * (corr_res + rhos_c[-1] * D1_t)
+        x_t = x_t.to(x.dtype)
+        return x_t
+
+    def step_unipc(
+        self,
+        model_output: torch.Tensor,
+        timestep: Union[int, torch.Tensor] = None,
+        sample: torch.Tensor = None,
+        return_dict: bool = True,
+        model_outputs: list = None,
+        timestep_list: list = None,
+        sigma_before: torch.Tensor = None,
+        sigma: torch.Tensor = None,
+        sigma_next: torch.Tensor = None,
+        cus_step_index: int = None,
+        cus_lower_order_num: int = None,
+        cus_this_order: int = None,
+        cus_last_sample: torch.Tensor = None,
+    ) -> Union[HeliosSchedulerOutput, Tuple]:
+        """
+        Predict the sample from the previous timestep by reversing the SDE. This function propagates the sample with
+        the multistep UniPC.
+
+        Args:
+            model_output (`torch.Tensor`):
+                The direct output from learned diffusion model.
+            timestep (`int`):
+                The current discrete timestep in the diffusion chain.
+            sample (`torch.Tensor`):
+                A current instance of a sample created by the diffusion process.
+            return_dict (`bool`):
+                Whether or not to return a [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`.
+
+        Returns:
+            [`~schedulers.scheduling_utils.SchedulerOutput`] or `tuple`:
+                If return_dict is `True`, [`~schedulers.scheduling_utils.SchedulerOutput`] is returned, otherwise a
+                tuple is returned where the first element is the sample tensor.
+
+        """
+        # don't change
+        # print(len(self.model_outputs), len(self.timestep_list), self.disable_corrector, self.solver_p, self._begin_index)
+
+        if self.num_inference_steps is None:
+            raise ValueError(
+                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
+            )
+
+        if cus_step_index is None:
+            if self.step_index is None:
+                self._step_index = 0
+        else:
+            self._step_index = cus_step_index
+
+        if cus_lower_order_num is not None:
+            self.lower_order_nums = cus_lower_order_num
+
+        if cus_this_order is not None:
+            self.this_order = cus_this_order
+
+        if cus_last_sample is not None:
+            self.last_sample = cus_last_sample
+
+        use_corrector = (
+            self.step_index > 0 and self.step_index - 1 not in self.disable_corrector and self.last_sample is not None
+        )
+
+        # Convert model output using the proper conversion method
+        model_output_convert = self.convert_model_output(model_output, sample=sample, sigma=sigma)
+
+        if model_outputs is not None and timestep_list is not None:
+            self.model_outputs = model_outputs[:-1]
+            self.timestep_list = timestep_list[:-1]
+
+        # print("1", self.step_index, self.timestep_list)
+
+        if use_corrector:
+            sample = self.multistep_uni_c_bh_update(
+                this_model_output=model_output_convert,
+                last_sample=self.last_sample,
+                this_sample=sample,
+                order=self.this_order,
+                sigma_before=sigma_before,
+                sigma=sigma,
+            )
+
+        if model_outputs is not None and timestep_list is not None:
+            model_outputs[-1] = model_output_convert
+            self.model_outputs = model_outputs[1:]
+            self.timestep_list = timestep_list[1:]
+        else:
+            for i in range(self.config.solver_order - 1):
+                self.model_outputs[i] = self.model_outputs[i + 1]
+                self.timestep_list[i] = self.timestep_list[i + 1]
+            self.model_outputs[-1] = model_output_convert
+            self.timestep_list[-1] = timestep
+
+        if self.config.lower_order_final:
+            this_order = min(self.config.solver_order, len(self.timesteps) - self.step_index)
+        else:
+            this_order = self.config.solver_order
+        self.this_order = min(this_order, self.lower_order_nums + 1)  # warmup for multistep
+        assert self.this_order > 0
+
+        # change
+        # print("2", self.step_index, self.timestep_list, self.lower_order_nums, self.this_order, "\n")
+        # print(self._step_index, self.lower_order_nums, use_corrector, self.this_order, self.lower_order_nums)
+        # 0 1 False 1 1
+        # 1 2  True 2 2
+        # 2 2  True 2 2
+        # 3 2  True 2 2
+        # 4 2  True 2 2
+        # 5 2  True 2 2
+        # 6 2  True 2 2
+        # 7 2  True 2 2
+        # 8 2  True 2 2
+        # 9 2  True 1 2
+
+        self.last_sample = sample
+        prev_sample = self.multistep_uni_p_bh_update(
+            model_output=model_output,  # pass the original non-converted model output, in case solver-p is used
+            sample=sample,
+            order=self.this_order,
+            sigma=sigma,
+            sigma_next=sigma_next,
+        )
+
+        if cus_lower_order_num is None:
+            if self.lower_order_nums < self.config.solver_order:
+                self.lower_order_nums += 1
+
+        # upon completion increase step index by one
+        if cus_step_index is None:
+            self._step_index += 1
+
+        if not return_dict:
+            return (prev_sample, model_outputs, self.last_sample, self.this_order)
+
+        return HeliosSchedulerOutput(
+            prev_sample=prev_sample,
+            model_outputs=model_outputs,
+            last_sample=self.last_sample,
+            this_order=self.this_order,
+        )
+
+    def reset_scheduler_history(self):
+        self.model_outputs = [None] * self.config.solver_order
+        self.timestep_list = [None] * self.config.solver_order
+        self.lower_order_nums = 0
+        self.disable_corrector = self.config.disable_corrector
+        self.solver_p = self.config.solver_p
+        self.last_sample = None
+        self._step_index = None
+        self._begin_index = None
+
+    def __len__(self):
+        return self.config.num_train_timesteps
+
+
+if __name__ == "__main__":
+    device = "cuda"
+
+    # ---------------------- For dynamic shifting ----------------------
+    from examples.scheduling_unipc_multistep_latest import UniPCMultistepScheduler
+
+    scheduler_official = UniPCMultistepScheduler.from_pretrained("BestWishYsh/Helios-Base", subfolder="scheduler")
+    scheduler_official.set_timesteps(num_inference_steps=50)
+    scheduler_official.timesteps
+    scheduler_official.sigmas
+
+    # # Official
+    # from scheduling_flow_match_euler_discrete_official import FlowMatchEulerDiscreteScheduler
+    # scheduler_official = FlowMatchEulerDiscreteScheduler(num_train_timesteps=1000, shift=3.0)
+    # scheduler_official.set_timesteps(num_inference_steps=50, sigmas=None)
+    # scheduler_official.timesteps
+    # scheduler_official.sigmas
+
+    # import sys
+    # sys.path.append("../../")
+    # from helios.utils.utils_helios_base import apply_schedule_shift
+
+    # sigmas = apply_schedule_shift(scheduler_official.sigmas, torch.ones([2, 16, 21, 48, 80]), mu=3)
+    # timesteps = sigmas[:-1] * 1000.0
+
+    # import copy
+    # from diffusers.training_utils import compute_density_for_timestep_sampling
+
+    # def get_sigmas(timesteps, n_dim=4, device="cpu", dtype=torch.float32):
+    #     sigmas = noise_scheduler_copy.sigmas.to(device=device, dtype=dtype)
+    #     schedule_timesteps = noise_scheduler_copy.timesteps.to(device)
+    #     timesteps = timesteps.to(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
+
+    # noise_scheduler_copy = copy.deepcopy(scheduler_official)
+
+    # # Sample noise that we'll add to the latents
+    # model_input = torch.ones([2, 16, 9, 88, 68])
+    # noise = torch.randn_like(model_input)
+    # bsz = model_input.shape[0]
+
+    # # Sample a random timestep for each image
+    # # for weighting schemes where we sample timesteps non-uniformly
+    # u = compute_density_for_timestep_sampling(
+    #     weighting_scheme="logit_normal", batch_size=bsz, logit_mean=0.0, logit_std=1.0, mode_scale=1.29
+    # )
+    # indices = (u * noise_scheduler_copy.config.num_train_timesteps).long()
+    # timesteps = noise_scheduler_copy.timesteps[indices].to(device=model_input.device)
+
+    # # Add noise according to flow matching.
+    # # zt = (1 - texp) * x + texp * z1
+    # sigmas = get_sigmas(timesteps, n_dim=model_input.ndim, dtype=model_input.dtype)
+
+    # import sys
+    # sys.path.append("../../")
+    # from helios.utils.utils_helios_base import apply_schedule_shift
+
+    # sigmas = apply_schedule_shift(sigmas, noise)  # torch.Size([2, 1, 1, 1, 1])
+    # timesteps = sigmas * 1000.0  # rescale to [0, 1000.0)
+    # while timesteps.ndim > 1:
+    #     timesteps = timesteps.squeeze(-1)
+    # ---------------------- For dynamic shifting ----------------------
+
+    # ---------------------- For timestep shifting ----------------------
+    stages = 3
+    timestep_shift = 1.0
+    stage_range = [0, 1 / 3, 2 / 3, 1]
+    scheduler_gamma = 1 / 3
+    version = "v1"
+    scheduler = HeliosScheduler(
+        shift=timestep_shift, stages=stages, stage_range=stage_range, gamma=scheduler_gamma, version=version
+    )
+    print(
+        f"The start sigmas and end sigmas of each stage is Start: {scheduler.start_sigmas}, End: {scheduler.end_sigmas}, Ori_start: {scheduler.ori_start_sigmas}"
+    )
+
+    i_s = 1
+    stage2_num_inference_steps_list = [3, 3, 3]
+    scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s)
+    scheduler.timesteps.to(dtype=torch.float32)
+    scheduler.sigmas.to(dtype=torch.float32)
+
+    # stages = 2
+    # timestep_shift = 3.0
+    # stage_range = [0, 1 / 2, 1]
+    # scheduler_gamma = 1 / 3
+    # version = "v2"
+    # scheduler = HeliosScheduler(
+    #     shift=timestep_shift, stages=stages, stage_range=stage_range, gamma=scheduler_gamma, version=version
+    # )
+    # print(
+    #     f"The start sigmas and end sigmas of each stage is Start: {scheduler.start_sigmas}, End: {scheduler.end_sigmas}, Ori_start: {scheduler.ori_start_sigmas}"
+    # )
+
+    # i_s = 1
+    # stage2_num_inference_steps_list = [10, 10]
+    # scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s)
+    # scheduler.timesteps.to(dtype=torch.float32)
+    # scheduler.sigmas.to(dtype=torch.float32)
+
+    # scheduler.timesteps_per_stage[0]
+    # scheduler.sigmas_per_stage[0]
+    # shift1: (999, 743.5120) -> (743.2563, 385.9723) -> (385.6146, 1.3846)
+    # shift3: (999, 957.3958) -> (957.3542, 828.9170) -> (828.7885, 3.8198)
+
+    # timesteps_1 = np.linspace(1, 1000 - 1, 1000, dtype=np.float32)[::-1].copy()
+    # timesteps_1 = torch.from_numpy(timesteps_1).to(dtype=torch.float32)
+    # sigmas_1 = timesteps_1 / 1000
+    # sigmas_1 = apply_schedule_shift(sigmas_1, torch.ones([2, 16, 21, 48, 80]), mu=3)
+    # timesteps_2 = sigmas_1 * 1000
+
+    # import pdb;pdb.set_trace()
+    # temp_sigmas = apply_schedule_shift(scheduler.timesteps / 1000, torch.ones([2, 16, 21, 48, 80]), mu=3)
+    # temp_timesteps = temp_sigmas * 1000
+    # while temp_timesteps.ndim > 1:
+    #     temp_timesteps = temp_timesteps.squeeze(-1)
+    # temp_timesteps = temp_timesteps[:-1]
+
+    # # very important here!
+    # timesteps = temp_timesteps
+    # # self.scheduler.sigmas = temp_sigmas
+    # scheduler.timesteps = temp_timesteps
+
+    # ---------------------- For timestep shifting ----------------------
+
+    # ---------------------- For dynamic shifting ----------------------
+
+    # ---------------------- For per step sigmas & timesteps ----------------------
+    # scheduler = HeliosScheduler(shift=3.0, stages=stages, stage_range=stage_range, gamma=scheduler_gamma)
+    # stage2_num_inference_steps_list = [10, 10, 10]
+    # i_s = 0
+    # scheduler.set_timesteps(stage2_num_inference_steps_list[i_s], i_s)
+    # scheduler.timesteps_per_stage[0]
+    # scheduler.sigmas_per_stage[0]
+    # scheduler.timesteps
+    # scheduler.sigmas
+    # ---------------------- For per step sigmas & timesteps ----------------------
+
+    # ---------------------- For Custom step ----------------------
+    # timesteps = scheduler.timesteps
+    # noise_pred = torch.randn([2, 16, 10, 48, 80], device=device)
+    # latents = torch.randn([2, 16, 10, 48, 80], device=device)
+    # for i, t in enumerate(timesteps):
+    #     print(i, t)
+    #     # latents = scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+    #     latents = scheduler.step_custom_unipc(noise_pred, t, latents, return_dict=False)[0]
+
+    # def upsample_tensor(tensor, scale_factor=2):
+    #     return torch.nn.functional.interpolate(
+    #         tensor, scale_factor=scale_factor, mode="trilinear", align_corners=False
+    #     )
+
+    # stage2_num_inference_steps_list = [10, 10, 10]
+    # noise_pred = torch.randn([2, 16, 10, 12, 20], device=device)
+    # latents = torch.randn([2, 16, 10, 12, 20], device=device)
+    # for stage, num_steps in enumerate(stage2_num_inference_steps_list):
+    #     print(f"stage: {stage}, num_steps: {num_steps}")
+    #     if stage > 0:
+    #         latents = upsample_tensor(latents, scale_factor=2)
+    #         noise_pred = upsample_tensor(noise_pred, scale_factor=2)
+
+    #     scheduler.set_timesteps(num_steps, stage)
+    #     timesteps = scheduler.timesteps
+
+    #     print(f"Timesteps for stage {stage + 1}: {timesteps}")
+
+    #     for i, t in enumerate(timesteps):
+    #         # print(i, t, latents.shape)
+    #         # latents = scheduler.step(noise_pred, t, latents, return_dict=False)[0]
+    #         latents = scheduler.step_unipc(noise_pred, t, latents, return_dict=False)[0]
+    # ---------------------- For Custom step ----------------------

Helios-main/scripts/inference/experiment_interactive/README.md

@@ -0,0 +1,3 @@
+# <u>Interactive Pipeline</u> by *Helios*
+
+⚠️ This feature is still under development — results may not always meet expectations.

Helios-main/scripts/inference/experiment_interactive/helios-base_t2v.sh

@@ -0,0 +1,27 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Base" \
+    --transformer_path "BestWishYsh/Helios-Base" \
+    --sample_type "t2v" \
+    --num_frames 1452 \
+    --fps 24 \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --guidance_scale 5.0 \
+    --enable_compile \
+    --use_interpolate_prompt \
+    --interpolation_steps 3 \
+    --interactive_prompt_csv_path "example/prompt_interactive_helios.csv" \
+    --interpolate_time 7 \
+    --output_folder "./output_helios/helios-base"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --use_cfg_zero_star \
+    # --use_zero_init \
+    # --zero_steps 1 \

Helios-main/scripts/inference/experiment_interactive/helios-distilled_t2v.sh

@@ -0,0 +1,26 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Distilled" \
+    --transformer_path "BestWishYsh/Helios-Distilled" \
+    --sample_type "t2v" \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --num_frames 1452 \
+    --guidance_scale 1.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 2 2 2 \
+    --is_amplify_first_chunk \
+    --enable_compile \
+    --interpolation_steps 3 \
+    --interactive_prompt_csv_path "example/prompt_interactive_helios.csv" \
+    --interpolate_time 7 \
+    --output_folder "./output_helios/helios-distilled"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 1 1 1 \

Helios-main/scripts/inference/experiment_interactive/helios-mid_t2v.sh

@@ -0,0 +1,28 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Mid" \
+    --transformer_path "BestWishYsh/Helios-Mid" \
+    --sample_type "t2v" \
+    --num_frames 1452 \
+    --fps 24 \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --guidance_scale 5.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 20 20 20 \
+    --use_zero_init \
+    --zero_steps 1 \
+    --enable_compile \
+    --interpolation_steps 3 \
+    --interactive_prompt_csv_path "example/prompt_interactive_helios.csv" \
+    --interpolate_time 7 \
+    --output_folder "./output_helios/helios-mid"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 17 17 17 \

Helios-main/scripts/inference/helios-base_i2v.sh

@@ -0,0 +1,26 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Base" \
+    --transformer_path "BestWishYsh/Helios-Base" \
+    --sample_type "i2v" \
+    --num_frames 99 \
+    --fps 24 \
+    --image_path "example/wave.jpg" \
+    --image_noise_sigma_min 0.111 \
+    --image_noise_sigma_max 0.135 \
+    --prompt "A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and respect for nature’s might." \
+    --guidance_scale 5.0 \
+    --enable_compile \
+    --output_folder "./output_helios/helios-base"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --use_cfg_zero_star \
+    # --use_zero_init \
+    # --zero_steps 1 \

Helios-main/scripts/inference/helios-base_t2v.sh

@@ -0,0 +1,23 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Base" \
+    --transformer_path "BestWishYsh/Helios-Base" \
+    --sample_type "t2v" \
+    --num_frames 99 \
+    --fps 24 \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --guidance_scale 5.0 \
+    --enable_compile \
+    --output_folder "./output_helios/helios-base"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --use_cfg_zero_star \
+    # --use_zero_init \
+    # --zero_steps 1 \

Helios-main/scripts/inference/helios-base_v2v.sh

@@ -0,0 +1,26 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Base" \
+    --transformer_path "BestWishYsh/Helios-Base" \
+    --sample_type "v2v" \
+    --num_frames 99 \
+    --fps 24 \
+    --video_path "example/car.mp4" \
+    --video_noise_sigma_min 0.111 \
+    --video_noise_sigma_max 0.135 \
+    --prompt "A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery." \
+    --guidance_scale 5.0 \
+    --enable_compile \
+    --output_folder "./output_helios/helios-base"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --use_cfg_zero_star \
+    # --use_zero_init \
+    # --zero_steps 1 \

Helios-main/scripts/inference/helios-distilled_i2v.sh

@@ -0,0 +1,27 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Distilled" \
+    --transformer_path "BestWishYsh/Helios-Distilled" \
+    --sample_type "i2v" \
+    --num_frames 240 \
+    --fps 24 \
+    --image_path "example/wave.jpg" \
+    --image_noise_sigma_min 0.111 \
+    --image_noise_sigma_max 0.135 \
+    --prompt "A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and respect for nature’s might." \
+    --guidance_scale 1.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 2 2 2 \
+    --is_amplify_first_chunk \
+    --enable_compile \
+    --output_folder "./output_helios/helios-distilled"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 1 1 1 \

Helios-main/scripts/inference/helios-distilled_t2v.sh

@@ -0,0 +1,24 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Distilled" \
+    --transformer_path "BestWishYsh/Helios-Distilled" \
+    --sample_type "t2v" \
+    --num_frames 240 \
+    --fps 24 \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --guidance_scale 1.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 2 2 2 \
+    --is_amplify_first_chunk \
+    --enable_compile \
+    --output_folder "./output_helios/helios-distilled"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 1 1 1 \

Helios-main/scripts/inference/helios-distilled_v2v.sh

@@ -0,0 +1,27 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Distilled" \
+    --transformer_path "BestWishYsh/Helios-Distilled" \
+    --sample_type "v2v" \
+    --num_frames 240 \
+    --fps 24 \
+    --video_path "example/car.mp4" \
+    --video_noise_sigma_min 0.111 \
+    --video_noise_sigma_max 0.135 \
+    --prompt "A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery." \
+    --guidance_scale 1.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 2 2 2 \
+    --is_amplify_first_chunk \
+    --enable_compile \
+    --output_folder "./output_helios/helios-distilled"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 1 1 1 \

Helios-main/scripts/inference/helios-mid_i2v.sh

@@ -0,0 +1,28 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Mid" \
+    --transformer_path "BestWishYsh/Helios-Mid" \
+    --sample_type "i2v" \
+    --num_frames 99 \
+    --fps 24 \
+    --image_path "example/wave.jpg" \
+    --image_noise_sigma_min 0.111 \
+    --image_noise_sigma_max 0.135 \
+    --prompt "A towering emerald wave surges forward, its crest curling with raw power and energy. Sunlight glints off the translucent water, illuminating the intricate textures and deep green hues within the wave’s body. A thick spray erupts from the breaking crest, casting a misty veil that dances above the churning surface. As the perspective widens, the immense scale of the wave becomes apparent, revealing the restless expanse of the ocean stretching beyond. The scene captures the ocean’s untamed beauty and relentless force, with every droplet and ripple shimmering in the light. The dynamic motion and vivid colors evoke both awe and respect for nature’s might." \
+    --guidance_scale 5.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 20 20 20 \
+    --use_zero_init \
+    --zero_steps 1 \
+    --enable_compile \
+    --output_folder "./output_helios/helios-mid"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 17 17 17 \

Helios-main/scripts/inference/helios-mid_t2v.sh

@@ -0,0 +1,25 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Mid" \
+    --transformer_path "BestWishYsh/Helios-Mid" \
+    --sample_type "t2v" \
+    --num_frames 99 \
+    --fps 24 \
+    --prompt "A vibrant tropical fish swimming gracefully among colorful coral reefs in a clear, turquoise ocean. The fish has bright blue and yellow scales with a small, distinctive orange spot on its side, its fins moving fluidly. The coral reefs are alive with a variety of marine life, including small schools of colorful fish and sea turtles gliding by. The water is crystal clear, allowing for a view of the sandy ocean floor below. The reef itself is adorned with a mix of hard and soft corals in shades of red, orange, and green. The photo captures the fish from a slightly elevated angle, emphasizing its lively movements and the vivid colors of its surroundings. A close-up shot with dynamic movement." \
+    --guidance_scale 5.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 20 20 20 \
+    --use_zero_init \
+    --zero_steps 1 \
+    --enable_compile \
+    --output_folder "./output_helios/helios-mid"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 17 17 17 \

Helios-main/scripts/inference/helios-mid_v2v.sh

@@ -0,0 +1,28 @@
+# Example: Running inference with 2-GPU parallelism
+# CUDA_VISIBLE_DEVICES=0,1 torchrun --nproc_per_node 2 infer_helios.py \
+#     --enable_parallelism \
+#     --cp_backend "ulysses" \   #  ["ring", "ulysses", "unified", "ulysses_anything"]
+
+CUDA_VISIBLE_DEVICES=0 python infer_helios.py \
+    --base_model_path "BestWishYsh/Helios-Mid" \
+    --transformer_path "BestWishYsh/Helios-Mid" \
+    --sample_type "v2v" \
+    --num_frames 99 \
+    --fps 24 \
+    --video_path "example/car.mp4" \
+    --video_noise_sigma_min 0.111 \
+    --video_noise_sigma_max 0.135 \
+    --prompt "A bright yellow Lamborghini Huracn Tecnica speeds along a curving mountain road, surrounded by lush green trees under a partly cloudy sky. The car's sleek design and vibrant color stand out against the natural backdrop, emphasizing its dynamic movement. The road curves gently, with a guardrail visible on one side, adding depth to the scene. The motion blur captures the sense of speed and energy, creating a thrilling and exhilarating atmosphere. A front-facing shot from a slightly elevated angle, highlighting the car's aggressive stance and the surrounding greenery." \
+    --guidance_scale 5.0 \
+    --is_enable_stage2 \
+    --pyramid_num_inference_steps_list 20 20 20 \
+    --use_zero_init \
+    --zero_steps 1 \
+    --enable_compile \
+    --output_folder "./output_helios/helios-mid"
+
+
+    # --enable_low_vram_mode \
+    # --group_offloading_type "leaf_level" \  # ["leaf_level", "block_level"]
+    # --num_blocks_per_group
+    # --pyramid_num_inference_steps_list 17 17 17 \

Helios-main/scripts/training/README.md

@@ -0,0 +1,37 @@
+# <u>Training Details</u> by *Helios*
+
+
+## 🎉 Overview
+
+We use a three-stage progressive pipeline, all the setting can be found [here](./configs). Stage-1 (Base) performs architectural adaptation: we apply Unified History Injection, Easy Anti-Drifting, and Multi-Term Memory Patchification to convert the bidirectional pretrained model into an autoregressive generator. Stage-2 (Mid) targets token compression by introducing Pyramid Unified Predictor Corrector, which aggressively reduces the number of noisy tokens and thus the overall computation. Stage-3 (Distilled) applies Adversarial Hierarchical Distillation, reducing the sampling steps from 50 to 3 and eliminating the need for classifier-free guidance (CFG). Throughout training, we apply dynamic shifting to all timestep-dependent operations to match the noise schedule to the latent size. For Stages 1 and 2, training is further divided into two phases: a high learning-rate phase for rapid convergence, followed by a low learning-rate phase for refinement.
+
+<div align=center>
+  <img src="https://raw.githubusercontent.com/PKU-YuanGroup/Helios-Page/main/figures/training_configs.png">
+</div>
+
+### Data Preparation
+
+Please refer to [this guide](../..//tools/offload_data/README.md) for how to obtain the training data required by Helios. And we prepare a toy training data [here](https://huggingface.co/BestWishYsh/HeliosBench-Weights/tree/main/demo_data).
+
+### Run the model
+
+```bash
+# Use DDP
+bash scripts/training/train_ddp.sh
+
+# or
+
+# Use DeepSpeed
+bash scripts/training/train_deepspeed.sh
+```
+
+Training configuration can be adjusted in `./configs`. You can use `./compare_yaml.py` to check for configuration completeness or differences between stages.
+
+### Model Merging
+
+After training, you can use this [script](../..//tools/merge_lora_for_helios.py) to merge all the checkpoints and obtain the final safetensors file, similar to [this](https://huggingface.co/BestWishYsh/Helios-Distilled/tree/main/transformer).
+
+
+## 💡 Important
+
+Based on the findings in [issue #38](https://github.com/PKU-YuanGroup/Helios/issues/38), we have identified several areas with potential for further improving Helios's performance. These include fixing the train-inference inconsistency in i2v to address the issue where i2v tends to produce very slow motion at the beginning, as well as fully enabling Easy Anti-Drifting to enhance Helios's resistance to quality degradation over time. For the relevant configuration details, please refer to [correct.yaml](./configs/correct.yaml).

Helios-main/scripts/training/compare_yaml.py

@@ -0,0 +1,65 @@
+import yaml
+
+
+def compare_yaml(file1_path, file2_path):
+    with open(file1_path, "r") as f1:
+        yaml1 = yaml.safe_load(f1)
+
+    with open(file2_path, "r") as f2:
+        yaml2 = yaml.safe_load(f2)
+
+    missing_keys = []
+    different_values = []
+
+    compare_dict(yaml1, yaml2, "", missing_keys, different_values)
+
+    print("=" * 60)
+    print("Missing Keys")
+    print("=" * 60)
+    if missing_keys:
+        for diff in missing_keys:
+            print(diff)
+    else:
+        print("None")
+
+    print("\n" + "=" * 60)
+    print("Different Values")
+    print("=" * 60)
+    if different_values:
+        for diff in different_values:
+            print(diff)
+    else:
+        print("None")
+
+    print("\n" + "=" * 60)
+    print(f"Total: {len(missing_keys)} missing keys, {len(different_values)} different values")
+    print("=" * 60)
+
+
+def compare_dict(dict1, dict2, path, missing_keys, different_values):
+    all_keys = set(dict1.keys()) | set(dict2.keys())
+
+    for key in all_keys:
+        current_path = f"{path}.{key}" if path else key
+
+        if key not in dict2:
+            missing_keys.append(f"[{current_path}] Only in file1: {dict1[key]}")
+        elif key not in dict1:
+            missing_keys.append(f"[{current_path}] Only in file2: {dict2[key]}")
+        else:
+            val1, val2 = dict1[key], dict2[key]
+
+            if isinstance(val1, dict) and isinstance(val2, dict):
+                compare_dict(val1, val2, current_path, missing_keys, different_values)
+            elif isinstance(val1, list) and isinstance(val2, list):
+                if val1 != val2:
+                    different_values.append(f"[{current_path}]\n  File1: {val1}\n  File2: {val2}")
+            elif val1 != val2:
+                different_values.append(f"[{current_path}]\n  File1: {val1}\n  File2: {val2}")
+
+
+if __name__ == "__main__":
+    compare_yaml(
+        "configs/stage_1_init.yaml",
+        "configs/stage_1_post.yaml",
+    )

Helios-main/scripts/training/configs/correct.yaml

@@ -0,0 +1,27 @@
+validation_config:
+  # ------------------------------------------------------------------------------------------------------------------------------------
+  # ------- During validation/inference, enabling use_dynamic_shifting" yields better results.
+  use_dynamic_shifting: true
+  time_shift_type: "exponential"   # ["exponential", "linear"]
+  # ------------------------------------------------------------------------------------------------------------------------------------
+
+training_config:
+  # ------------------------------------------------------------------------------------------------------------------------------------
+  # ------- Regarding the issue that I2V tends to produce very slow motion at the beginning:
+  # ------- During training, we did not construct the corresponding history context format (i.e., first-frame anchor + last-frame), 
+  # ------- which means the current I2V inference relies heavily on the model’s zero-shot capability.
+  # ------- Incorporating this data format during training should significantly improve performance.
+  random_drop_i2v_ratio: 0.1                 # should be changed according to valiation
+  # ------------------------------------------------------------------------------------------------------------------------------------
+  # 
+  # ------------------------------------------------------------------------------------------------------------------------------------
+  # ------- Easy Anit-Drifting (Noise + Blur + Saturation): We actually missed fully turning this on when we trained Helios-Base 
+  # ------- and Helios-Mid. But based on our ablation experiments on Helios-Distilled, it definitely helps mitigate degradation.
+  corrupt_mode_history: "random"
+  downsample_min_corrupt_ratio_history: 0.9  # should be changed according to valiation
+  downsample_max_corrupt_ratio_history: 1.0  # should be changed according to valiation
+  is_add_saturation: true
+  saturation_ratio_clean_prob: 0.1           # should be changed according to valiation
+  saturation_ratio_min: 0.3                  # should be changed according to valiation
+  saturation_ratio_max: 1.7                  # should be changed according to valiation
+  # ------------------------------------------------------------------------------------------------------------------------------------

Helios-main/scripts/training/configs/stage_1_init.yaml

@@ -0,0 +1,182 @@
+output_dir: ablation_stage_1_init
+logging_dir: logs
+seed: 43
+
+
+report_to:
+  tracker_name: Wan-Train
+  wandb_name: ablation_stage_1_init
+  report_to: wandb
+
+
+data_config:
+  # ---- Base ----
+  use_shuffle: true
+  pin_memory: true
+  persistent_workers: true
+  force_rebuild: true
+  single_res: true
+  single_height: 384
+  single_width: 640
+  dataloader_num_workers: 8
+  prefetch_factor: 2
+  caption_dropout_p: 0
+  id_token: ""
+  instance_data_root:
+    - "demo_data/ultravideo-long"
+  # ---- Stage 1 ----
+  use_stage1_dataset: true
+
+
+model_config:
+  # ---- Path ----
+  pretrained_model_name_or_path: "BestWishYsh/Helios-Base"
+  transformer_model_name_or_path: "Wan-AI/Wan2.1-T2V-14B-Diffusers"
+  load_checkpoints_custom: false
+  # load_model_path:
+  load_dcp: false
+  # load_dcp_path:
+  # ---- Vae ----
+  upcast_vae: true
+  enable_slicing: false
+  enable_tiling: false
+  # ---- Lora ----
+  lora_rank: 128
+  lora_alpha: 128.0
+  lora_dropout: 0.0
+  lora_layers: "all-linear"
+  # lora_target_modules:
+  #   - to_k
+  #   - to_q
+  #   - to_v
+  #   - to_out.0
+  #   - ffn.net.0.proj
+  #   - ffn.net.2
+  lora_exclude_modules:
+    - down
+    - up
+  # ---- Other ----
+  train_norm_layers: false
+
+
+validation_config:
+  validation_steps: 500
+  validation_height: 384
+  validation_width: 640
+  validation_max_num_frames: 99
+  validation_prompts:
+    - "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+    # - "Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field."
+    # - "A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors."
+  validation_guidance_scale: 5.0
+  validation_latent_window_size:
+    - 9
+  num_validation_videos: 1
+  num_inference_steps: 50
+  # ---- Dynamic Shifting ----
+  use_dynamic_shifting: true
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+
+
+training_config:
+  # ---- Environment ----
+  allow_tf32: false
+  gradient_checkpointing: true
+  enable_xformers_memory_efficient_attention: false
+  enable_npu_flash_attention: false
+  upcast_before_saving: false
+  offload: false
+  mixed_precision: "bf16"
+  # ---- Training Resource ----
+  max_train_steps: 1000000
+  train_batch_size: 2
+  gradient_accumulation_steps: 1
+  checkpointing_steps: 500
+  resume_from_checkpoint: "latest"
+  save_checkpoints_custom: false
+  # ---- Optimizer ----
+  learning_rate: 5e-5
+  lr_scheduler: "constant"
+  lr_warmup_steps: 500
+  optimizer: "adamw"
+  adam_beta1: 0.9
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-04
+  adam_epsilon: 1e-08
+  max_grad_norm: 1.0
+  weighting_scheme: "logit_normal"  # ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"]
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  # ---- Dynamic Shifting Parameters ----
+  use_dynamic_shifting: false
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+  base_seq_len: 256
+  max_seq_len: 4096
+  base_shift: 0.5
+  max_shift: 1.15
+  # ---- VAE Decode Parameters ----
+  vae_decode_type: "default"
+  # ---- EMA Parameters ----
+  use_ema: false
+  use_ema_validation: false
+  ema_decay: 0.999
+  ema_start_step: 250
+  ema_zero3_port: 10543
+  ema_deepspeed_config_file: "scripts/accelerate_configs/zero3.json"
+  # ---- Stage 1 Parameters ----
+  is_enable_stage1: true
+  history_sizes:
+    - 16
+    - 2
+    - 1
+  latent_window_size:
+    # - 12
+    # - 10
+    - 9
+    # - 8
+    # - 6
+    # - 5
+    # - 4
+    # - 3
+    # - 2
+    # - 1
+  is_random_drop: true
+  random_drop_v2v_ratio: 0.4
+  random_drop_t2v_ratio: 0.4
+  # 
+  corrupt_model_input: false
+  corrupt_mode_model_input: "noise"
+  corrupt_mode_prob_model_input: 0.9
+  is_frame_independent_corrupt_model_input: true
+  is_chunk_independent_corrupt_model_input: false
+  noise_corrupt_ratio_model_input: 0.33333333333333
+  noise_corrupt_clean_prob_model_input: 0.1
+  downsample_min_corrupt_ratio_model_input: 0.9
+  downsample_max_corrupt_ratio_model_input: 1.0
+  corrupt_history: true
+  corrupt_mode_history: "noise"
+  corrupt_mode_prob_history: 0.9
+  is_frame_independent_corrupt_history: true
+  is_chunk_independent_corrupt_history: false
+  noise_corrupt_ratio_history_short: 0.33333333333333
+  noise_corrupt_ratio_history_mid: 0.33333333333333
+  noise_corrupt_ratio_history_long: 0.33333333333333
+  noise_corrupt_clean_prob_history: 0.1
+  downsample_min_corrupt_ratio_history: 0.9
+  downsample_max_corrupt_ratio_history: 1.0
+  # 
+  is_amplify_history: false
+  history_scale_mode: "per_head"
+  # 
+  is_train_full_patch_embedding: false
+  is_train_lora_patch_embedding: true
+  has_multi_term_memory_patch: true
+  is_train_full_multi_term_memory_patchg: true
+  is_train_lora_multi_term_memory_patchg: false
+  zero_history_timestep: true
+  guidance_cross_attn: true
+  restrict_self_attn: false
+  is_train_restrict_lora: false
+  restrict_lora: false
+  restrict_lora_rank: 128

Helios-main/scripts/training/configs/stage_1_post.yaml

@@ -0,0 +1,183 @@
+output_dir: ablation_stage_1_post
+logging_dir: logs
+seed: 44
+
+
+report_to:
+  tracker_name: Wan-Train
+  wandb_name: ablation_stage_1_post
+  report_to: wandb
+
+
+data_config:
+  # ---- Base ----
+  use_shuffle: true
+  pin_memory: true
+  persistent_workers: true
+  force_rebuild: true
+  single_res: true
+  single_height: 384
+  single_width: 640
+  dataloader_num_workers: 8
+  prefetch_factor: 2
+  caption_dropout_p: 0
+  id_token: ""
+  instance_data_root:
+    - "demo_data/ultravideo-long"
+  # ---- Stage 1 ----
+  use_stage1_dataset: true
+
+
+model_config:
+  # ---- Path ----
+  pretrained_model_name_or_path: "BestWishYsh/Helios-Base"
+  transformer_model_name_or_path: "BestWishYsh/Helios-Base"
+  subfolder: "transformer_init"
+  load_checkpoints_custom: false
+  # load_model_path:
+  load_dcp: false
+  # load_dcp_path:
+  # ---- Vae ----
+  upcast_vae: true
+  enable_slicing: false
+  enable_tiling: false
+  # ---- Lora ----
+  lora_rank: 128
+  lora_alpha: 128.0
+  lora_dropout: 0.0
+  lora_layers: "all-linear"
+  # lora_target_modules:
+  #   - to_k
+  #   - to_q
+  #   - to_v
+  #   - to_out.0
+  #   - ffn.net.0.proj
+  #   - ffn.net.2
+  lora_exclude_modules:
+    - down
+    - up
+  # ---- Other ----
+  train_norm_layers: false
+
+
+validation_config:
+  validation_steps: 500
+  validation_height: 384
+  validation_width: 640
+  validation_max_num_frames: 99
+  validation_prompts:
+    - "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+    # - "Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field."
+    # - "A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors."
+  validation_guidance_scale: 5.0
+  validation_latent_window_size:
+    - 9
+  num_validation_videos: 1
+  num_inference_steps: 50
+  # ---- Dynamic Shifting ----
+  use_dynamic_shifting: true
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+
+
+training_config:
+  # ---- Environment ----
+  allow_tf32: false
+  gradient_checkpointing: true
+  enable_xformers_memory_efficient_attention: false
+  enable_npu_flash_attention: false
+  upcast_before_saving: false
+  offload: false
+  mixed_precision: "bf16"
+  # ---- Training Resource ----
+  max_train_steps: 1000000
+  train_batch_size: 2
+  gradient_accumulation_steps: 1
+  checkpointing_steps: 500
+  resume_from_checkpoint: "latest"
+  save_checkpoints_custom: false
+  # ---- Optimizer ----
+  learning_rate: 3e-5
+  lr_scheduler: "constant"
+  lr_warmup_steps: 500
+  optimizer: "adamw"
+  adam_beta1: 0.9
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-04
+  adam_epsilon: 1e-08
+  max_grad_norm: 1.0
+  weighting_scheme: "logit_normal"  # ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"]
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  # ---- Dynamic Shifting Parameters ----
+  use_dynamic_shifting: false
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+  base_seq_len: 256
+  max_seq_len: 4096
+  base_shift: 0.5
+  max_shift: 1.15
+  # ---- VAE Decode Parameters ----
+  vae_decode_type: "default"
+  # ---- EMA Parameters ----
+  use_ema: false
+  use_ema_validation: false
+  ema_decay: 0.999
+  ema_start_step: 250
+  ema_zero3_port: 10543
+  ema_deepspeed_config_file: "scripts/accelerate_configs/zero3.json"
+  # ---- Stage 1 Parameters ----
+  is_enable_stage1: true
+  history_sizes:
+    - 16
+    - 2
+    - 1
+  latent_window_size:
+    # - 12
+    # - 10
+    - 9
+    # - 8
+    # - 6
+    # - 5
+    # - 4
+    # - 3
+    # - 2
+    # - 1
+  is_random_drop: true
+  random_drop_v2v_ratio: 0.4
+  random_drop_t2v_ratio: 0.4
+  # 
+  corrupt_model_input: false
+  corrupt_mode_model_input: "noise"
+  corrupt_mode_prob_model_input: 0.9
+  is_frame_independent_corrupt_model_input: true
+  is_chunk_independent_corrupt_model_input: false
+  noise_corrupt_ratio_model_input: 0.33333333333333
+  noise_corrupt_clean_prob_model_input: 0.1
+  downsample_min_corrupt_ratio_model_input: 0.9
+  downsample_max_corrupt_ratio_model_input: 1.0
+  corrupt_history: true
+  corrupt_mode_history: "noise"
+  corrupt_mode_prob_history: 0.9
+  is_frame_independent_corrupt_history: true
+  is_chunk_independent_corrupt_history: false
+  noise_corrupt_ratio_history_short: 0.33333333333333
+  noise_corrupt_ratio_history_mid: 0.33333333333333
+  noise_corrupt_ratio_history_long: 0.33333333333333
+  noise_corrupt_clean_prob_history: 0.1
+  downsample_min_corrupt_ratio_history: 0.9
+  downsample_max_corrupt_ratio_history: 1.0
+  # 
+  is_amplify_history: false
+  history_scale_mode: "per_head"
+  # 
+  is_train_full_patch_embedding: false
+  is_train_lora_patch_embedding: true
+  has_multi_term_memory_patch: true
+  is_train_full_multi_term_memory_patchg: true
+  is_train_lora_multi_term_memory_patchg: false
+  zero_history_timestep: true
+  guidance_cross_attn: true
+  restrict_self_attn: false
+  is_train_restrict_lora: false
+  restrict_lora: false
+  restrict_lora_rank: 128

Helios-main/scripts/training/configs/stage_2_init.yaml

@@ -0,0 +1,202 @@
+output_dir: ablation_stage_2_init
+logging_dir: logs
+seed: 45
+
+
+report_to:
+  tracker_name: Wan-Train
+  wandb_name: ablation_stage_2_init
+  report_to: wandb
+
+
+data_config:
+  # ---- Base ----
+  use_shuffle: true
+  pin_memory: true
+  persistent_workers: true
+  force_rebuild: true
+  single_res: true
+  single_height: 384
+  single_width: 640
+  dataloader_num_workers: 8
+  prefetch_factor: 2
+  caption_dropout_p: 0
+  id_token: ""
+  instance_data_root:
+    - "demo_data/ultravideo-long"
+  # ---- Stage 1 ----
+  use_stage1_dataset: true
+
+
+model_config:
+  # ---- Path ----
+  pretrained_model_name_or_path: "BestWishYsh/Helios-Base"
+  transformer_model_name_or_path: "BestWishYsh/Helios-Base"
+  load_checkpoints_custom: false
+  # load_model_path:
+  load_dcp: false
+  # load_dcp_path:
+  # ---- Vae ----
+  upcast_vae: true
+  enable_slicing: false
+  enable_tiling: false
+  # ---- Lora ----
+  lora_rank: 256
+  lora_alpha: 256.0
+  lora_dropout: 0.0
+  lora_layers: "all-linear"
+  # lora_target_modules:
+  #   - to_k
+  #   - to_q
+  #   - to_v
+  #   - to_out.0
+  #   - ffn.net.0.proj
+  #   - ffn.net.2
+  lora_exclude_modules:
+    - down
+    - up
+  # ---- Other ----
+  train_norm_layers: false
+
+
+validation_config:
+  validation_steps: 500
+  validation_height: 384
+  validation_width: 640
+  validation_max_num_frames: 99
+  validation_prompts:
+    - "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+    # - "Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field."
+    # - "A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors."
+  validation_guidance_scale: 5.0
+  validation_latent_window_size:
+    - 9
+  num_validation_videos: 1
+  # ---- Dynamic Shifting ----
+  use_dynamic_shifting: true
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+  # ---- Stage 2 ----
+  stage2_simulated_inference_steps:
+    - 20
+    - 20
+    - 20
+
+
+training_config:
+  # ---- Environment ----
+  allow_tf32: false
+  gradient_checkpointing: true
+  enable_xformers_memory_efficient_attention: false
+  enable_npu_flash_attention: false
+  upcast_before_saving: false
+  offload: false
+  mixed_precision: "bf16"
+  # ---- Training Resource ----
+  max_train_steps: 1000000
+  train_batch_size: 1
+  gradient_accumulation_steps: 1
+  checkpointing_steps: 500
+  resume_from_checkpoint: "latest"
+  save_checkpoints_custom: false
+  # ---- Optimizer ----
+  learning_rate: 1e-4
+  lr_scheduler: "constant_with_warmup"
+  lr_warmup_steps: 1000
+  optimizer: "adamw"
+  adam_beta1: 0.9
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-04
+  adam_epsilon: 1e-08
+  max_grad_norm: 1.0
+  weighting_scheme: "none"  # ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"]
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  # ---- Dynamic Shifting Parameters ----
+  use_dynamic_shifting: false
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+  base_seq_len: 256
+  max_seq_len: 4096
+  base_shift: 0.5
+  max_shift: 1.15
+  # ---- VAE Decode Parameters ----
+  vae_decode_type: "default"
+  # ---- EMA Parameters ----
+  use_ema: false
+  use_ema_validation: false
+  ema_decay: 0.999
+  ema_start_step: 250
+  ema_zero3_port: 10543
+  ema_deepspeed_config_file: "scripts/accelerate_configs/zero3.json"
+  # ---- Stage 1 Parameters ----
+  is_enable_stage1: true
+  history_sizes:
+    - 16
+    - 2
+    - 1
+  latent_window_size:
+    # - 12
+    # - 10
+    - 9
+    # - 8
+    # - 6
+    # - 5
+    # - 4
+    # - 3
+    # - 2
+    # - 1
+  is_random_drop: true
+  random_drop_v2v_ratio: 0.4
+  random_drop_t2v_ratio: 0.4
+  # 
+  corrupt_model_input: false
+  corrupt_mode_model_input: "noise"
+  corrupt_mode_prob_model_input: 0.9
+  is_frame_independent_corrupt_model_input: true
+  is_chunk_independent_corrupt_model_input: false
+  noise_corrupt_ratio_model_input: 0.33333333333333
+  noise_corrupt_clean_prob_model_input: 0.1
+  downsample_min_corrupt_ratio_model_input: 0.9
+  downsample_max_corrupt_ratio_model_input: 1.0
+  corrupt_history: true
+  corrupt_mode_history: "noise"
+  corrupt_mode_prob_history: 0.9
+  is_frame_independent_corrupt_history: true
+  is_chunk_independent_corrupt_history: false
+  noise_corrupt_ratio_history_short: 0.33333333333333
+  noise_corrupt_ratio_history_mid: 0.33333333333333
+  noise_corrupt_ratio_history_long: 0.33333333333333
+  noise_corrupt_clean_prob_history: 0.1
+  downsample_min_corrupt_ratio_history: 0.9
+  downsample_max_corrupt_ratio_history: 1.0
+  # 
+  is_amplify_history: false
+  history_scale_mode: "per_head"
+  # 
+  is_train_full_patch_embedding: false
+  is_train_lora_patch_embedding: false
+  has_multi_term_memory_patch: true
+  is_train_full_multi_term_memory_patchg: false
+  is_train_lora_multi_term_memory_patchg: false
+  zero_history_timestep: true
+  guidance_cross_attn: true
+  restrict_self_attn: false
+  is_train_restrict_lora: false
+  restrict_lora: false
+  restrict_lora_rank: 128
+  # ---- Stage 2 Parameters ----
+  is_enable_stage2: true
+  is_navit_pyramid: true
+  stage2_num_stages: 3
+  stage2_timestep_shift: 1.0
+  stage2_scheduler_gamma: 0.333333333333333333333333333333333   # Approximate value of 1/3
+  stage2_stage_range:
+    - 0
+    - 0.333333333333333333333333333333333   # Approximate value of 1/3
+    - 0.666666666666666666666666666666666   # Approximate value of 2/3
+    - 1
+  stage2_sample_ratios: 
+    - 1
+    - 2
+    - 1
+  efficient_sample: false

Helios-main/scripts/training/configs/stage_2_post.yaml

@@ -0,0 +1,203 @@
+output_dir: ablation_stage_2_post
+logging_dir: logs
+seed: 46
+
+
+report_to:
+  tracker_name: Wan-Train
+  wandb_name: ablation_stage_2_post
+  report_to: wandb
+
+
+data_config:
+  # ---- Base ----
+  use_shuffle: true
+  pin_memory: true
+  persistent_workers: true
+  force_rebuild: true
+  single_res: true
+  single_height: 384
+  single_width: 640
+  dataloader_num_workers: 8
+  prefetch_factor: 2
+  caption_dropout_p: 0
+  id_token: ""
+  instance_data_root:
+    - "demo_data/ultravideo-long"
+  # ---- Stage 1 ----
+  use_stage1_dataset: true
+
+
+model_config:
+  # ---- Path ----
+  pretrained_model_name_or_path: "BestWishYsh/Helios-Base"
+  transformer_model_name_or_path: "BestWishYsh/Helios-Mid"
+  subfolder: "transformer_init"
+  load_checkpoints_custom: false
+  # load_model_path:
+  load_dcp: false
+  # load_dcp_path:
+  # ---- Vae ----
+  upcast_vae: true
+  enable_slicing: false
+  enable_tiling: false
+  # ---- Lora ----
+  lora_rank: 256
+  lora_alpha: 256.0
+  lora_dropout: 0.0
+  lora_layers: "all-linear"
+  # lora_target_modules:
+  #   - to_k
+  #   - to_q
+  #   - to_v
+  #   - to_out.0
+  #   - ffn.net.0.proj
+  #   - ffn.net.2
+  lora_exclude_modules:
+    - down
+    - up
+  # ---- Other ----
+  train_norm_layers: false
+
+
+validation_config:
+  validation_steps: 500
+  validation_height: 384
+  validation_width: 640
+  validation_max_num_frames: 99
+  validation_prompts:
+    - "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+    # - "Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field."
+    # - "A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors."
+  validation_guidance_scale: 5.0
+  validation_latent_window_size:
+    - 9
+  num_validation_videos: 1
+  # ---- Dynamic Shifting ----
+  use_dynamic_shifting: true
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+  # ---- Stage 2 ----
+  stage2_simulated_inference_steps:
+    - 20
+    - 20
+    - 20
+
+
+training_config:
+  # ---- Environment ----
+  allow_tf32: false
+  gradient_checkpointing: true
+  enable_xformers_memory_efficient_attention: false
+  enable_npu_flash_attention: false
+  upcast_before_saving: false
+  offload: false
+  mixed_precision: "bf16"
+  # ---- Training Resource ----
+  max_train_steps: 1000000
+  train_batch_size: 1
+  gradient_accumulation_steps: 1
+  checkpointing_steps: 500
+  resume_from_checkpoint: "latest"
+  save_checkpoints_custom: false
+  # ---- Optimizer ----
+  learning_rate: 3e-5
+  lr_scheduler: "constant_with_warmup"
+  lr_warmup_steps: 500
+  optimizer: "adamw"
+  adam_beta1: 0.9
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-04
+  adam_epsilon: 1e-08
+  max_grad_norm: 1.0
+  weighting_scheme: "none"  # ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"]
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  # ---- Dynamic Shifting Parameters ----
+  use_dynamic_shifting: false
+  time_shift_type: "exponential"  # ["exponential", "linear"]
+  base_seq_len: 256
+  max_seq_len: 4096
+  base_shift: 0.5
+  max_shift: 1.15
+  # ---- VAE Decode Parameters ----
+  vae_decode_type: "default"
+  # ---- EMA Parameters ----
+  use_ema: false
+  use_ema_validation: false
+  ema_decay: 0.999
+  ema_start_step: 250
+  ema_zero3_port: 10543
+  ema_deepspeed_config_file: "scripts/accelerate_configs/zero3.json"
+  # ---- Stage 1 Parameters ----
+  is_enable_stage1: true
+  history_sizes:
+    - 16
+    - 2
+    - 1
+  latent_window_size:
+    # - 12
+    # - 10
+    - 9
+    # - 8
+    # - 6
+    # - 5
+    # - 4
+    # - 3
+    # - 2
+    # - 1
+  is_random_drop: true
+  random_drop_v2v_ratio: 0.4
+  random_drop_t2v_ratio: 0.4
+  # 
+  corrupt_model_input: false
+  corrupt_mode_model_input: "noise"
+  corrupt_mode_prob_model_input: 0.9
+  is_frame_independent_corrupt_model_input: true
+  is_chunk_independent_corrupt_model_input: false
+  noise_corrupt_ratio_model_input: 0.33333333333333
+  noise_corrupt_clean_prob_model_input: 0.1
+  downsample_min_corrupt_ratio_model_input: 0.9
+  downsample_max_corrupt_ratio_model_input: 1.0
+  corrupt_history: true
+  corrupt_mode_history: "noise"
+  corrupt_mode_prob_history: 0.9
+  is_frame_independent_corrupt_history: true
+  is_chunk_independent_corrupt_history: false
+  noise_corrupt_ratio_history_short: 0.33333333333333
+  noise_corrupt_ratio_history_mid: 0.33333333333333
+  noise_corrupt_ratio_history_long: 0.33333333333333
+  noise_corrupt_clean_prob_history: 0.1
+  downsample_min_corrupt_ratio_history: 0.9
+  downsample_max_corrupt_ratio_history: 1.0
+  # 
+  is_amplify_history: false
+  history_scale_mode: "per_head"
+  # 
+  is_train_full_patch_embedding: false
+  is_train_lora_patch_embedding: true
+  has_multi_term_memory_patch: true
+  is_train_full_multi_term_memory_patchg: false
+  is_train_lora_multi_term_memory_patchg: true
+  zero_history_timestep: true
+  guidance_cross_attn: true
+  restrict_self_attn: false
+  is_train_restrict_lora: false
+  restrict_lora: false
+  restrict_lora_rank: 128
+  # ---- Stage 2 Parameters ----
+  is_enable_stage2: true
+  is_navit_pyramid: true
+  stage2_num_stages: 3
+  stage2_timestep_shift: 1.0
+  stage2_scheduler_gamma: 0.333333333333333333333333333333333   # Approximate value of 1/3
+  stage2_stage_range:
+    - 0
+    - 0.333333333333333333333333333333333   # Approximate value of 1/3
+    - 0.666666666666666666666666666666666   # Approximate value of 2/3
+    - 1
+  stage2_sample_ratios: 
+    - 1
+    - 1
+    - 1
+  efficient_sample: false

Helios-main/scripts/training/configs/stage_3_ode.yaml

@@ -0,0 +1,229 @@
+output_dir: ablation_stage_3_ode
+logging_dir: logs
+seed: 47
+
+
+report_to:
+  tracker_name: Wan-Train
+  wandb_name: ablation_stage_3_ode
+  report_to: wandb
+
+
+data_config:
+  # ---- Base ----
+  use_shuffle: true
+  pin_memory: true
+  persistent_workers: true
+  force_rebuild: true
+  single_res: true
+  single_height: 384
+  single_width: 640
+  dataloader_num_workers: 8
+  prefetch_factor: 1
+  caption_dropout_p: 0
+  id_token: ""
+  # ---- Stage 1 ----
+  use_stage1_dataset: false
+  # ---- Stage 3 ----
+  use_stage3_dataset: true
+  ode_data_root:
+    - "demo_data/vidprom_filtered_extended"
+
+
+model_config:
+  # ---- Path ----
+  pretrained_model_name_or_path: "BestWishYsh/Helios-Base"
+  transformer_model_name_or_path: "BestWishYsh/Helios-Mid"
+  load_checkpoints_custom: false
+  # load_model_path:
+  load_dcp: false
+  # load_dcp_path:
+  # ---- Vae ----
+  upcast_vae: true
+  enable_slicing: false
+  enable_tiling: false
+  # ---- Lora ----
+  lora_rank: 256
+  lora_alpha: 256.0
+  lora_dropout: 0.0
+  lora_layers: "all-linear"
+  # lora_target_modules:
+  #   - to_k
+  #   - to_q
+  #   - to_v
+  #   - to_out.0
+  #   - ffn.net.0.proj
+  #   - ffn.net.2
+  lora_exclude_modules:
+    - down
+    - up
+  # ---- Other ----
+  train_norm_layers: false
+
+
+validation_config:
+  validation_steps: 500
+  validation_height: 384
+  validation_width: 640
+  validation_max_num_frames: 99
+  validation_prompts:
+    - "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+    # - "Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field."
+    # - "A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors."
+  validation_guidance_scale: 1.0
+  validation_latent_window_size:
+    - 9
+  num_validation_videos: 1
+  num_inference_steps: 6
+  # ---- Dynamic Shifting ----
+  use_dynamic_shifting: true
+  time_shift_type: "linear"  # ["exponential", "linear"]
+  # ---- Pyramid ----
+  stage2_simulated_inference_steps:
+    - 2
+    - 2
+    - 2
+
+
+training_config:
+  # ---- Environment ----
+  allow_tf32: false
+  gradient_checkpointing: true
+  enable_xformers_memory_efficient_attention: false
+  enable_npu_flash_attention: false
+  upcast_before_saving: false
+  offload: false
+  mixed_precision: "bf16"
+  # ---- Training Resource ----
+  max_train_steps: 1000000
+  train_batch_size: 1
+  gradient_accumulation_steps: 1
+  checkpointing_steps: 250
+  resume_from_checkpoint: "latest"
+  save_checkpoints_custom: true
+  # ---- Optimizer ----
+  learning_rate: 2.0e-06
+  lr_scheduler: "constant"
+  lr_warmup_steps: 500
+  optimizer: "adamw"
+  adam_beta1: 0.0
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-03
+  adam_epsilon: 1e-08
+  max_grad_norm: 10.0
+  weighting_scheme: "none"  # ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"]
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  # ---- Dynamic Shifting Parameters ----
+  use_dynamic_shifting: true
+  time_shift_type: "linear"
+  base_seq_len: 256
+  max_seq_len: 4096
+  base_shift: 0.5
+  max_shift: 1.15
+  # ---- VAE Decode Parameters ----
+  vae_decode_type: "default"
+  # ---- EMA Parameters ----
+  use_ema: true
+  use_ema_validation: false
+  ema_decay: 0.99
+  ema_start_step: 250
+  ema_zero3_port: 10543
+  ema_deepspeed_config_file: "scripts/accelerate_configs/zero3.json"
+  # ---- Stage 1 Parameters ----
+  is_enable_stage1: true
+  history_sizes:
+    - 16
+    - 2
+    - 1
+  latent_window_size:
+    # - 12
+    # - 10
+    - 9
+    # - 8
+    # - 6
+    # - 5
+    # - 4
+    # - 3
+    # - 2
+    # - 1
+  is_amplify_history: false
+  history_scale_mode: "per_head"
+  # 
+  is_train_full_patch_embedding: false
+  is_train_lora_patch_embedding: false
+  has_multi_term_memory_patch: true
+  is_train_full_multi_term_memory_patchg: false
+  is_train_lora_multi_term_memory_patchg: true
+  zero_history_timestep: true
+  guidance_cross_attn: true
+  restrict_self_attn: false
+  is_train_restrict_lora: false
+  restrict_lora: false
+  restrict_lora_rank: 128
+  # ---- Stage 2 Parameters ----
+  is_enable_stage2: true
+  is_navit_pyramid: false
+  stage2_num_stages: 3
+  stage2_timestep_shift: 1.0
+  stage2_scheduler_gamma: 0.333333333333333333333333333333333   # Approximate value of 1/3
+  stage2_stage_range:
+    - 0
+    - 0.333333333333333333333333333333333   # Approximate value of 1/3
+    - 0.666666666666666666666666666666666   # Approximate value of 2/3
+    - 1
+  stage2_sample_ratios: 
+    - 1
+    - 1
+    - 1
+  efficient_sample: false
+  # ---- Stage 3 VRAM Parameters ----
+  dmd_is_low_vram_mode: true
+  # ---- Stage 3 Parameters ----
+  log_iters: 250
+  no_visualize: false
+  is_train_dmd: false
+  max_grad_norm_critic: 10.0
+  dmd_generator_deepspeed_config: scripts/accelerate_configs/zero2.json
+  dmd_critic_deepspeed_config: scripts/accelerate_configs/zero2.json
+  critic_learning_rate: 4.0e-07
+  dfake_gen_update_ratio: 5
+  dmd_denoising_step_list:
+    - 1000
+    - 750
+    - 500
+    - 250
+  num_critic_input_frames: 9
+  dmd_timestep_shift: 5.0
+  dmd_last_step_only: false
+  dmd_last_section_grad_only: false
+  dmd_teacher_forcing: false
+  dmd_teacher_forcing_ratio: 0.2
+  fake_guidance_scale: 0.0
+  real_guidance_scale: 3.0
+  # ---- VAE Re-Encode ----
+  is_dmd_vae_decode: false
+  # ---- Multi Stage Backward Simulated ----
+  is_multi_pyramid_stage_backward_simulated: false
+  # ---- ODE Regression Parameters ----
+  is_use_ode_regression: true
+  is_only_ode_regression: true
+  ode_regression_weight: 80.0
+  # ---- Cold Start Parameters ----
+  is_enable_cold_start: false
+  cold_start_step: 2000
+  stage_cold_start_step: 2000
+  # ---- Dynamic Timestep ----
+  generator_is_forcing_low_renoise: false
+  generator_dynamic_alpha: 4.0
+  generator_dynamic_beta: 1.5
+  generator_dynamic_sample_type: "uniform"
+  generator_dynamic_step: 1000
+  # ---- Dynamic ODE Section ----
+  ode_num_latent_sections_min: 3
+  ode_num_latent_sections_max: 3
+  ode_dynamic_alpha: 1.5
+  ode_dynamic_beta: 4.0
+  ode_dynamic_sample_type: "uniform"
+  ode_dynamic_step: 2000

Helios-main/scripts/training/configs/stage_3_post.yaml

@@ -0,0 +1,300 @@
+output_dir: ablation_stage_3_post
+logging_dir: logs
+seed: 49
+
+
+report_to:
+  tracker_name: Wan-Train
+  wandb_name: ablation_stage_3_post
+  report_to: wandb
+
+
+data_config:
+  # ---- Base ----
+  use_shuffle: true
+  pin_memory: true
+  persistent_workers: true
+  force_rebuild: true
+  single_res: true
+  single_height: 384
+  single_width: 640
+  dataloader_num_workers: 8
+  prefetch_factor: 1
+  caption_dropout_p: 0
+  id_token: ""
+  # ---- Stage 1 ----
+  use_stage1_dataset: false
+  # ---- Stage 3 ----
+  use_stage3_dataset: true
+  gan_data_root:
+    - "demo_data/ultravideo-long"
+
+
+model_config:
+  # ---- Path ----
+  pretrained_model_name_or_path: "BestWishYsh/Helios-Base"
+  transformer_model_name_or_path: "BestWishYsh/Helios-Distilled"
+  subfolder: "transformer_ode"
+  real_score_model_name_or_path: "BestWishYsh/Helios-Base"
+  load_checkpoints_custom: false
+  # load_model_path:
+  load_dcp: false
+  # load_dcp_path:
+  # ---- Vae ----
+  upcast_vae: true
+  enable_slicing: false
+  enable_tiling: false
+  # ---- Lora ----
+  lora_rank: 256
+  lora_alpha: 256.0
+  lora_dropout: 0.0
+  lora_layers: "all-linear"
+  # lora_target_modules:
+  #   - to_k
+  #   - to_q
+  #   - to_v
+  #   - to_out.0
+  #   - ffn.net.0.proj
+  #   - ffn.net.2
+  lora_exclude_modules:
+    - down
+    - up
+  # ---- Other ----
+  train_norm_layers: false
+  # ---- DMD ----
+  critic_lora_rank: 256
+  critic_lora_alpha: 256.0
+  critic_lora_dropout: 0.0
+  # ---- Reward Parameters ----
+  reward_model_name_or_path: "/mnt/bn/yufan-dev-my/ysh_new/Ckpts/Videoreward"
+
+
+validation_config:
+  validation_steps: 500
+  validation_height: 384
+  validation_width: 640
+  validation_max_num_frames: 99
+  validation_prompts:
+    - "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+    # - "Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field."
+    # - "A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors."
+  validation_guidance_scale: 1.0
+  validation_latent_window_size:
+    - 9
+  num_validation_videos: 1
+  num_inference_steps: 6
+  # ---- Dynamic Shifting ----
+  use_dynamic_shifting: true
+  time_shift_type: "linear"  # ["exponential", "linear"]
+  # ---- Pyramid ----
+  stage2_simulated_inference_steps:
+    - 2
+    - 2
+    - 2
+
+
+training_config:
+  # ---- Environment ----
+  allow_tf32: false
+  gradient_checkpointing: true
+  enable_xformers_memory_efficient_attention: false
+  enable_npu_flash_attention: false
+  upcast_before_saving: false
+  offload: false
+  mixed_precision: "bf16"
+  # ---- Training Resource ----
+  max_train_steps: 1000000
+  train_batch_size: 1
+  gradient_accumulation_steps: 1
+  checkpointing_steps: 250
+  resume_from_checkpoint: "latest"
+  save_checkpoints_custom: false
+  # ---- Optimizer ----
+  learning_rate: 2.0e-06
+  lr_scheduler: "constant"
+  lr_warmup_steps: 500
+  optimizer: "adamw"
+  adam_beta1: 0.0
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-03
+  adam_epsilon: 1e-08
+  max_grad_norm: 10.0
+  weighting_scheme: "none"  # ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"]
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  # ---- Dynamic Shifting Parameters ----
+  use_dynamic_shifting: true
+  time_shift_type: "linear"
+  base_seq_len: 256
+  max_seq_len: 4096
+  base_shift: 0.5
+  max_shift: 1.15
+  # ---- VAE Decode Parameters ----
+  vae_decode_type: "default"
+  # ---- EMA Parameters ----
+  use_ema: true
+  use_ema_validation: false
+  ema_decay: 0.99
+  ema_start_step: 750
+  ema_zero3_port: 10543
+  ema_deepspeed_config_file: "scripts/accelerate_configs/zero3.json"
+  # ---- Stage 1 Parameters ----
+  is_enable_stage1: true
+  history_sizes:
+    - 16
+    - 2
+    - 1
+  latent_window_size:
+    # - 12
+    # - 10
+    - 9
+    # - 8
+    # - 6
+    # - 5
+    # - 4
+    # - 3
+    # - 2
+    # - 1
+  is_random_drop: true
+  random_drop_v2v_ratio: 0.5
+  random_drop_t2v_ratio: 0.4
+  # 
+  corrupt_model_input: false
+  corrupt_mode_model_input: "noise"
+  corrupt_mode_prob_model_input: 0.9
+  is_frame_independent_corrupt_model_input: true
+  is_chunk_independent_corrupt_model_input: false
+  noise_corrupt_ratio_model_input: 0.33333333333333
+  noise_corrupt_clean_prob_model_input: 0.1
+  downsample_min_corrupt_ratio_model_input: 0.9
+  downsample_max_corrupt_ratio_model_input: 1.0
+  corrupt_history: true
+  corrupt_mode_history: "noise"
+  corrupt_mode_prob_history: 0.9
+  is_frame_independent_corrupt_history: true
+  is_chunk_independent_corrupt_history: false
+  noise_corrupt_ratio_history_short: 0.33333333333333
+  noise_corrupt_ratio_history_mid: 0.33333333333333
+  noise_corrupt_ratio_history_long: 0.33333333333333
+  noise_corrupt_clean_prob_history: 0.1
+  downsample_min_corrupt_ratio_history: 0.9
+  downsample_max_corrupt_ratio_history: 1.0
+  # 
+  is_add_saturation: true
+  saturation_ratio_clean_prob: 0.1
+  saturation_ratio_min: 0.3
+  saturation_ratio_max: 1.7
+  # 
+  is_amplify_history: false
+  history_scale_mode: "per_head"
+  # 
+  is_train_full_patch_embedding: false
+  is_train_lora_patch_embedding: false
+  has_multi_term_memory_patch: true
+  is_train_full_multi_term_memory_patchg: false
+  is_train_lora_multi_term_memory_patchg: true
+  zero_history_timestep: true
+  guidance_cross_attn: true
+  restrict_self_attn: false
+  is_train_restrict_lora: false
+  restrict_lora: false
+  restrict_lora_rank: 128
+  # ---- Stage 2 Parameters ----
+  is_enable_stage2: true
+  is_navit_pyramid: false
+  stage2_num_stages: 3
+  stage2_timestep_shift: 1.0
+  stage2_scheduler_gamma: 0.333333333333333333333333333333333   # Approximate value of 1/3
+  stage2_stage_range:
+    - 0
+    - 0.333333333333333333333333333333333   # Approximate value of 1/3
+    - 0.666666666666666666666666666666666   # Approximate value of 2/3
+    - 1
+  stage2_sample_ratios: 
+    - 1
+    - 1
+    - 1
+  efficient_sample: false
+  # ---- Stage 3 VRAM Parameters ----
+  dmd_is_low_vram_mode: true
+  is_gan_low_vram_mode: true
+  dmd_is_offload_grad: false
+  # ---- Stage 3 Parameters ----
+  log_iters: 125
+  no_visualize: false
+  is_train_dmd: true
+  max_grad_norm_critic: 10.0
+  dmd_generator_deepspeed_config: scripts/accelerate_configs/zero2.json
+  dmd_critic_deepspeed_config: scripts/accelerate_configs/zero2.json
+  critic_learning_rate: 4.0e-07
+  dfake_gen_update_ratio: 5
+  dmd_denoising_step_list:
+    - 1000
+    - 750
+    - 500
+    - 250
+  num_critic_input_frames: 9
+  dmd_timestep_shift: 5.0
+  dmd_last_step_only: false
+  dmd_last_section_grad_only: false
+  dmd_teacher_forcing: false
+  dmd_teacher_forcing_ratio: 0.2
+  fake_guidance_scale: 0.0
+  real_guidance_scale: 3.0
+  # ---- GT History Parameters ----
+  is_use_gt_history: true
+  use_gt_history_ratio: 1.0
+  # ---- VAE Re-Encode ----
+  is_dmd_vae_decode: false
+  # ---- Multi Stage Backward Simulated ----
+  is_multi_pyramid_stage_backward_simulated: false
+  is_amplify_first_chunk: true
+  # ---- GAN Parameters ----
+  is_use_gan: false
+  gan_start_step: 1000
+  is_separate_gan_grad: false
+  is_use_gan_hooks: true
+  is_use_gan_final: true
+  gan_cond_map_dim: 768
+  gan_hooks:
+    - 5
+    - 15
+    - 25
+    - 35
+  gan_g_weight: 5e-2
+  gan_d_weight: 1e-2
+  aprox_r1: true
+  aprox_r2: true
+  r1_weight: 100.0
+  r2_weight: 0.0
+  r1_sigma: 0.1
+  r2_sigma: 0.1
+  # ---- Cold Start Parameters ----
+  is_enable_cold_start: false
+  cold_start_step: 2000
+  stage_cold_start_step: 2000
+  # ---- Dynamic Timestep ----
+  generator_is_forcing_low_renoise: false
+  generator_dynamic_alpha: 4.0
+  generator_dynamic_beta: 1.5
+  generator_dynamic_sample_type: "beta"
+  generator_dynamic_step: 500
+  critic_dynamic_alpha: 4.0
+  critic_dynamic_beta: 1.5
+  critic_dynamic_sample_type: "uniform"
+  critic_dynamic_step: 500
+  # ---- Dynamic DMD Section ----
+  dmd_num_latent_sections_min: 1
+  dmd_num_latent_sections_max: 1
+  dmd_dynamic_alpha: 1.5
+  dmd_dynamic_beta: 4.0
+  dmd_dynamic_sample_type: "uniform"
+  dmd_dynamic_step: 500
+  # ---- Dynamic ODE Section ----
+  ode_num_latent_sections_min: 3
+  ode_num_latent_sections_max: 3
+  ode_dynamic_alpha: 1.5
+  ode_dynamic_beta: 4.0
+  ode_dynamic_sample_type: "uniform"
+  ode_dynamic_step: 500

Helios-main/scripts/training/configs/stage_3_post_gan_version.yaml

@@ -0,0 +1,300 @@
+output_dir: ablation_stage_3_post_gan_version
+logging_dir: logs
+seed: 49
+
+
+report_to:
+  tracker_name: Wan-Train
+  wandb_name: ablation_stage_3_post_gan_version
+  report_to: wandb
+
+
+data_config:
+  # ---- Base ----
+  use_shuffle: true
+  pin_memory: true
+  persistent_workers: true
+  force_rebuild: true
+  single_res: true
+  single_height: 384
+  single_width: 640
+  dataloader_num_workers: 8
+  prefetch_factor: 1
+  caption_dropout_p: 0
+  id_token: ""
+  # ---- Stage 1 ----
+  use_stage1_dataset: false
+  # ---- Stage 3 ----
+  use_stage3_dataset: true
+  gan_data_root:
+    - "demo_data/ultravideo-long"
+
+
+model_config:
+  # ---- Path ----
+  pretrained_model_name_or_path: "BestWishYsh/Helios-Base"
+  transformer_model_name_or_path: "BestWishYsh/Helios-Distilled"
+  subfolder: "transformer_ode"
+  real_score_model_name_or_path: "BestWishYsh/Helios-Base"
+  load_checkpoints_custom: false
+  # load_model_path:
+  load_dcp: false
+  # load_dcp_path:
+  # ---- Vae ----
+  upcast_vae: true
+  enable_slicing: false
+  enable_tiling: false
+  # ---- Lora ----
+  lora_rank: 256
+  lora_alpha: 256.0
+  lora_dropout: 0.0
+  lora_layers: "all-linear"
+  # lora_target_modules:
+  #   - to_k
+  #   - to_q
+  #   - to_v
+  #   - to_out.0
+  #   - ffn.net.0.proj
+  #   - ffn.net.2
+  lora_exclude_modules:
+    - down
+    - up
+  # ---- Other ----
+  train_norm_layers: false
+  # ---- DMD ----
+  critic_lora_rank: 256
+  critic_lora_alpha: 256.0
+  critic_lora_dropout: 0.0
+  # ---- Reward Parameters ----
+  reward_model_name_or_path: "/mnt/bn/yufan-dev-my/ysh_new/Ckpts/Videoreward"
+
+
+validation_config:
+  validation_steps: 500
+  validation_height: 384
+  validation_width: 640
+  validation_max_num_frames: 99
+  validation_prompts:
+    - "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+    # - "Several giant wooly mammoths approach treading through a snowy meadow, their long wooly fur lightly blows in the wind as they walk, snow covered trees and dramatic snow capped mountains in the distance, mid afternoon light with wispy clouds and a sun high in the distance creates a warm glow, the low camera view is stunning capturing the large furry mammal with beautiful photography, depth of field."
+    # - "A movie trailer featuring the adventures of the 30 year old space man wearing a red wool knitted motorcycle helmet, blue sky, salt desert, cinematic style, shot on 35mm film, vivid colors."
+  validation_guidance_scale: 1.0
+  validation_latent_window_size:
+    - 9
+  num_validation_videos: 1
+  num_inference_steps: 6
+  # ---- Dynamic Shifting ----
+  use_dynamic_shifting: true
+  time_shift_type: "linear"  # ["exponential", "linear"]
+  # ---- Pyramid ----
+  stage2_simulated_inference_steps:
+    - 2
+    - 2
+    - 2
+
+
+training_config:
+  # ---- Environment ----
+  allow_tf32: false
+  gradient_checkpointing: true
+  enable_xformers_memory_efficient_attention: false
+  enable_npu_flash_attention: false
+  upcast_before_saving: false
+  offload: false
+  mixed_precision: "bf16"
+  # ---- Training Resource ----
+  max_train_steps: 1000000
+  train_batch_size: 1
+  gradient_accumulation_steps: 1
+  checkpointing_steps: 250
+  resume_from_checkpoint: "latest"
+  save_checkpoints_custom: false
+  # ---- Optimizer ----
+  learning_rate: 2.0e-06
+  lr_scheduler: "constant"
+  lr_warmup_steps: 500
+  optimizer: "adamw"
+  adam_beta1: 0.0
+  adam_beta2: 0.999
+  adam_weight_decay: 1e-03
+  adam_epsilon: 1e-08
+  max_grad_norm: 10.0
+  weighting_scheme: "none"  # ["sigma_sqrt", "logit_normal", "mode", "cosmap", "none"]
+  logit_mean: 0.0
+  logit_std: 1.0
+  mode_scale: 1.29
+  # ---- Dynamic Shifting Parameters ----
+  use_dynamic_shifting: true
+  time_shift_type: "linear"
+  base_seq_len: 256
+  max_seq_len: 4096
+  base_shift: 0.5
+  max_shift: 1.15
+  # ---- VAE Decode Parameters ----
+  vae_decode_type: "default"
+  # ---- EMA Parameters ----
+  use_ema: true
+  use_ema_validation: false
+  ema_decay: 0.99
+  ema_start_step: 750
+  ema_zero3_port: 10543
+  ema_deepspeed_config_file: "scripts/accelerate_configs/zero3.json"
+  # ---- Stage 1 Parameters ----
+  is_enable_stage1: true
+  history_sizes:
+    - 16
+    - 2
+    - 1
+  latent_window_size:
+    # - 12
+    # - 10
+    - 9
+    # - 8
+    # - 6
+    # - 5
+    # - 4
+    # - 3
+    # - 2
+    # - 1
+  is_random_drop: true
+  random_drop_v2v_ratio: 0.5
+  random_drop_t2v_ratio: 0.4
+  # 
+  corrupt_model_input: false
+  corrupt_mode_model_input: "noise"
+  corrupt_mode_prob_model_input: 0.9
+  is_frame_independent_corrupt_model_input: true
+  is_chunk_independent_corrupt_model_input: false
+  noise_corrupt_ratio_model_input: 0.33333333333333
+  noise_corrupt_clean_prob_model_input: 0.1
+  downsample_min_corrupt_ratio_model_input: 0.9
+  downsample_max_corrupt_ratio_model_input: 1.0
+  corrupt_history: true
+  corrupt_mode_history: "random"
+  corrupt_mode_prob_history: 0.9
+  is_frame_independent_corrupt_history: true
+  is_chunk_independent_corrupt_history: false
+  noise_corrupt_ratio_history_short: 0.33333333333333
+  noise_corrupt_ratio_history_mid: 0.33333333333333
+  noise_corrupt_ratio_history_long: 0.33333333333333
+  noise_corrupt_clean_prob_history: 0.1
+  downsample_min_corrupt_ratio_history: 0.9
+  downsample_max_corrupt_ratio_history: 1.0
+  # 
+  is_add_saturation: true
+  saturation_ratio_clean_prob: 0.1
+  saturation_ratio_min: 0.3
+  saturation_ratio_max: 1.7
+  # 
+  is_amplify_history: false
+  history_scale_mode: "per_head"
+  # 
+  is_train_full_patch_embedding: false
+  is_train_lora_patch_embedding: false
+  has_multi_term_memory_patch: true
+  is_train_full_multi_term_memory_patchg: false
+  is_train_lora_multi_term_memory_patchg: true
+  zero_history_timestep: true
+  guidance_cross_attn: true
+  restrict_self_attn: false
+  is_train_restrict_lora: false
+  restrict_lora: false
+  restrict_lora_rank: 128
+  # ---- Stage 2 Parameters ----
+  is_enable_stage2: true
+  is_navit_pyramid: false
+  stage2_num_stages: 3
+  stage2_timestep_shift: 1.0
+  stage2_scheduler_gamma: 0.333333333333333333333333333333333   # Approximate value of 1/3
+  stage2_stage_range:
+    - 0
+    - 0.333333333333333333333333333333333   # Approximate value of 1/3
+    - 0.666666666666666666666666666666666   # Approximate value of 2/3
+    - 1
+  stage2_sample_ratios: 
+    - 1
+    - 1
+    - 1
+  efficient_sample: false
+  # ---- Stage 3 VRAM Parameters ----
+  dmd_is_low_vram_mode: true
+  is_gan_low_vram_mode: true
+  dmd_is_offload_grad: false
+  # ---- Stage 3 Parameters ----
+  log_iters: 125
+  no_visualize: false
+  is_train_dmd: true
+  max_grad_norm_critic: 10.0
+  dmd_generator_deepspeed_config: scripts/accelerate_configs/zero2.json
+  dmd_critic_deepspeed_config: scripts/accelerate_configs/zero2.json
+  critic_learning_rate: 4.0e-07
+  dfake_gen_update_ratio: 5
+  dmd_denoising_step_list:
+    - 1000
+    - 750
+    - 500
+    - 250
+  num_critic_input_frames: 9
+  dmd_timestep_shift: 5.0
+  dmd_last_step_only: false
+  dmd_last_section_grad_only: false
+  dmd_teacher_forcing: false
+  dmd_teacher_forcing_ratio: 0.2
+  fake_guidance_scale: 0.0
+  real_guidance_scale: 3.0
+  # ---- GT History Parameters ----
+  is_use_gt_history: true
+  use_gt_history_ratio: 1.0
+  # ---- VAE Re-Encode ----
+  is_dmd_vae_decode: false
+  # ---- Multi Stage Backward Simulated ----
+  is_multi_pyramid_stage_backward_simulated: false
+  is_amplify_first_chunk: true
+  # ---- GAN Parameters ----
+  is_use_gan: true
+  gan_start_step: 1000
+  is_separate_gan_grad: false
+  is_use_gan_hooks: true
+  is_use_gan_final: true
+  gan_cond_map_dim: 768
+  gan_hooks:
+    - 5
+    - 15
+    - 25
+    - 35
+  gan_g_weight: 5e-2
+  gan_d_weight: 1e-2
+  aprox_r1: true
+  aprox_r2: true
+  r1_weight: 100.0
+  r2_weight: 0.0
+  r1_sigma: 0.1
+  r2_sigma: 0.1
+  # ---- Cold Start Parameters ----
+  is_enable_cold_start: false
+  cold_start_step: 2000
+  stage_cold_start_step: 2000
+  # ---- Dynamic Timestep ----
+  generator_is_forcing_low_renoise: false
+  generator_dynamic_alpha: 4.0
+  generator_dynamic_beta: 1.5
+  generator_dynamic_sample_type: "beta"
+  generator_dynamic_step: 500
+  critic_dynamic_alpha: 4.0
+  critic_dynamic_beta: 1.5
+  critic_dynamic_sample_type: "uniform"
+  critic_dynamic_step: 500
+  # ---- Dynamic DMD Section ----
+  dmd_num_latent_sections_min: 1
+  dmd_num_latent_sections_max: 1
+  dmd_dynamic_alpha: 1.5
+  dmd_dynamic_beta: 4.0
+  dmd_dynamic_sample_type: "uniform"
+  dmd_dynamic_step: 500
+  # ---- Dynamic ODE Section ----
+  ode_num_latent_sections_min: 3
+  ode_num_latent_sections_max: 3
+  ode_dynamic_alpha: 1.5
+  ode_dynamic_beta: 4.0
+  ode_dynamic_sample_type: "uniform"
+  ode_dynamic_step: 500

Helios-main/tools/gradio/comparison/gradio_compare_diff-ablation.py

@@ -0,0 +1,536 @@
+import os
+import re
+
+import gradio as gr
+
+
+def parse_video_name(filename):
+    """Parse video filename to extract step and index"""
+    match = re.match(r".*?(\d+)_(\d+)\.mp4$", filename)
+    if match:
+        step = int(match.group(1))
+        idx = int(match.group(2))
+        return step, idx
+    return None, None
+
+
+def get_video_list(folder_path):
+    """Get all mp4 videos from the folder"""
+    if not os.path.exists(folder_path):
+        return []
+
+    videos = []
+    for file in os.listdir(folder_path):
+        if file.endswith(".mp4"):
+            step, idx = parse_video_name(file)
+            if step is not None:
+                videos.append({"filename": file, "step": step, "idx": idx, "path": os.path.join(folder_path, file)})
+
+    # Sort by step and idx
+    videos.sort(key=lambda x: (x["step"], x["idx"]))
+    return videos
+
+
+def create_video_mapping(videos):
+    """Create mapping from (step, idx) to filename"""
+    mapping = {}
+    for video in videos:
+        key = (video["step"], video["idx"])
+        mapping[key] = video["filename"]
+    return mapping
+
+
+def get_step_idx_mapping(common_keys):
+    """Extract step and idx mapping from common (step, idx) keys"""
+    step_idx_map = {}  # {step: [idx1, idx2, ...]}
+    all_steps = set()
+    all_indices = set()
+
+    for step, idx in common_keys:
+        all_steps.add(step)
+        all_indices.add(idx)
+        if step not in step_idx_map:
+            step_idx_map[step] = []
+        step_idx_map[step].append(idx)
+
+    # Sort
+    for step in step_idx_map:
+        step_idx_map[step].sort()
+
+    return sorted(all_steps), sorted(all_indices), step_idx_map
+
+
+def load_videos(folder1, folder2):
+    """Load videos from two folders and match them"""
+    if not folder1 or not folder2:
+        return (
+            None,
+            None,
+            "Please enter two folder paths",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    videos1 = get_video_list(folder1)
+    videos2 = get_video_list(folder2)
+
+    if not videos1:
+        return (
+            None,
+            None,
+            "No video files found in folder 1",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+    if not videos2:
+        return (
+            None,
+            None,
+            "No video files found in folder 2",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    # Create mapping from (step, idx) to filename
+    video_map1 = create_video_mapping(videos1)
+    video_map2 = create_video_mapping(videos2)
+
+    # Find common (step, idx) combinations
+    common_keys = sorted(set(video_map1.keys()) & set(video_map2.keys()))
+
+    if not common_keys:
+        # Show detailed info for debugging
+        steps1 = {v["step"] for v in videos1}
+        steps2 = {v["step"] for v in videos2}
+        info = "No matching videos found between the two folders\n"
+        info += f"Folder 1 steps: {sorted(steps1)}\n"
+        info += f"Folder 2 steps: {sorted(steps2)}\n"
+        info += f"Common steps: {sorted(steps1 & steps2)}"
+        return (
+            None,
+            None,
+            info,
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    # Get all steps and indices
+    all_steps, all_indices, step_idx_map = get_step_idx_mapping(common_keys)
+
+    # Load first video
+    first_key = common_keys[0]
+    first_step, first_idx = first_key
+
+    filename1 = video_map1[first_key]
+    filename2 = video_map2[first_key]
+
+    video1_path = os.path.join(folder1, filename1)
+    video2_path = os.path.join(folder2, filename2)
+
+    info = f"Found {len(common_keys)} matching videos\n"
+    info += f"Current: Step {first_step}, Index {first_idx}\n"
+    info += f"Folder 1: {filename1}\n"
+    info += f"Folder 2: {filename2}"
+
+    # Get available indices for current step
+    available_indices = step_idx_map.get(first_step, [])
+
+    progress = f"1 / {len(common_keys)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(choices=all_steps, value=first_step),
+        gr.update(choices=available_indices, value=first_idx),
+        gr.update(interactive=first_step > all_steps[0]),
+        gr.update(interactive=first_step < all_steps[-1]),
+        gr.update(interactive=first_idx > available_indices[0] if available_indices else False),
+        gr.update(interactive=first_idx < available_indices[-1] if available_indices else False),
+        progress,
+        video_map1,
+        video_map2,
+        step_idx_map,
+    )
+
+
+def update_available_indices(selected_step, step_idx_map):
+    """Update available index list"""
+    if not step_idx_map or selected_step is None:
+        return gr.update(choices=[], value=None)
+
+    available_indices = step_idx_map.get(selected_step, [])
+    first_idx = available_indices[0] if available_indices else None
+
+    return gr.update(choices=available_indices, value=first_idx)
+
+
+def update_videos_from_selectors(folder1, folder2, selected_step, selected_idx, video_map1, video_map2, step_idx_map):
+    """Update videos based on selected step and idx"""
+    if selected_step is None or selected_idx is None:
+        return None, None, "Please select step and index", gr.update(), gr.update(), gr.update(), gr.update(), ""
+
+    key = (selected_step, selected_idx)
+
+    if key not in video_map1 or key not in video_map2:
+        return (
+            None,
+            None,
+            f"Video not found for Step {selected_step}, Index {selected_idx}",
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    filename1 = video_map1[key]
+    filename2 = video_map2[key]
+
+    video1_path = os.path.join(folder1, filename1)
+    video2_path = os.path.join(folder2, filename2)
+
+    info = f"Current: Step {selected_step}, Index {selected_idx}\n"
+    info += f"Folder 1: {filename1}\n"
+    info += f"Folder 2: {filename2}"
+
+    # Get all steps and indices for current step
+    all_steps = sorted(step_idx_map.keys())
+    available_indices = step_idx_map.get(selected_step, [])
+
+    # Update button states
+    prev_step_interactive = selected_step > all_steps[0]
+    next_step_interactive = selected_step < all_steps[-1]
+    prev_idx_interactive = selected_idx > available_indices[0] if available_indices else False
+    next_idx_interactive = selected_idx < available_indices[-1] if available_indices else False
+
+    # Calculate current video number
+    all_keys = sorted(set(video_map1.keys()) & set(video_map2.keys()))
+    current_idx = all_keys.index(key) + 1
+    progress = f"{current_idx} / {len(all_keys)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(interactive=prev_step_interactive),
+        gr.update(interactive=next_step_interactive),
+        gr.update(interactive=prev_idx_interactive),
+        gr.update(interactive=next_idx_interactive),
+        progress,
+    )
+
+
+def navigate_step(folder1, folder2, current_step, current_idx, video_map1, video_map2, step_idx_map, direction):
+    """Navigate to previous or next step"""
+    if not step_idx_map or current_step is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    all_steps = sorted(step_idx_map.keys())
+    current_step_idx = all_steps.index(current_step)
+
+    if direction == "prev":
+        new_step_idx = max(0, current_step_idx - 1)
+    else:  # next
+        new_step_idx = min(len(all_steps) - 1, current_step_idx + 1)
+
+    new_step = all_steps[new_step_idx]
+
+    # Get first available index for new step
+    available_indices = step_idx_map.get(new_step, [])
+    new_idx = available_indices[0] if available_indices else current_idx
+
+    return update_videos_from_selectors(folder1, folder2, new_step, new_idx, video_map1, video_map2, step_idx_map) + (
+        new_step,
+        new_idx,
+    )
+
+
+def navigate_idx(folder1, folder2, current_step, current_idx, video_map1, video_map2, step_idx_map, direction):
+    """Navigate to previous or next index"""
+    if not step_idx_map or current_step is None or current_idx is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    available_indices = step_idx_map.get(current_step, [])
+    if not available_indices or current_idx not in available_indices:
+        return (
+            None,
+            None,
+            "Index not in list",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    current_idx_pos = available_indices.index(current_idx)
+
+    if direction == "prev":
+        new_idx_pos = max(0, current_idx_pos - 1)
+    else:  # next
+        new_idx_pos = min(len(available_indices) - 1, current_idx_pos + 1)
+
+    new_idx = available_indices[new_idx_pos]
+
+    return update_videos_from_selectors(
+        folder1, folder2, current_step, new_idx, video_map1, video_map2, step_idx_map
+    ) + (current_step, new_idx)
+
+
+# Create Gradio interface
+with gr.Blocks(title="Video Comparison Tool") as demo:
+    gr.Markdown("# Video Comparison Tool")
+    gr.Markdown(
+        "Enter two folder paths to automatically match and compare videos with the same naming (matched by step and index, ignoring filename prefix)"
+    )
+
+    # Store state
+    video_map1_state = gr.State({})
+    video_map2_state = gr.State({})
+    step_idx_map_state = gr.State({})
+
+    with gr.Row():
+        folder1_input = gr.Textbox(label="Folder 1 Path", placeholder="/path/to/folder1", scale=2)
+        folder2_input = gr.Textbox(label="Folder 2 Path", placeholder="/path/to/folder2", scale=2)
+
+    load_btn = gr.Button("Load Videos", variant="primary")
+
+    info_text = gr.Textbox(label="Info", interactive=False, lines=4)
+
+    # Step navigation controls
+    with gr.Row():
+        prev_step_btn = gr.Button("⬅️ Previous Step", interactive=False, scale=1)
+        step_selector = gr.Dropdown(label="Select Step", choices=[], interactive=True, scale=2)
+        next_step_btn = gr.Button("Next Step ➡️", interactive=False, scale=1)
+
+    # Index navigation controls
+    with gr.Row():
+        prev_idx_btn = gr.Button("⬅️ Previous Index", interactive=False, scale=1)
+        idx_selector = gr.Dropdown(label="Select Index", choices=[], interactive=True, scale=2)
+        next_idx_btn = gr.Button("Next Index ➡️", interactive=False, scale=1)
+
+    progress_text = gr.Textbox(label="Progress", value="0 / 0", interactive=False)
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Folder 1")
+            video1 = gr.Video(label="Video 1", autoplay=True, loop=True)
+
+        with gr.Column():
+            gr.Markdown("### Folder 2")
+            video2 = gr.Video(label="Video 2", autoplay=True, loop=True)
+
+    # Event bindings
+    load_btn.click(
+        fn=load_videos,
+        inputs=[folder1_input, folder2_input],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            step_selector,
+            idx_selector,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+    )
+
+    # When step changes, update available indices
+    step_selector.change(
+        fn=update_available_indices, inputs=[step_selector, step_idx_map_state], outputs=[idx_selector]
+    ).then(
+        fn=update_videos_from_selectors,
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[video1, video2, info_text, prev_step_btn, next_step_btn, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    # When index changes, update videos
+    idx_selector.change(
+        fn=update_videos_from_selectors,
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[video1, video2, info_text, prev_step_btn, next_step_btn, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    # Step navigation buttons
+    prev_step_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_step(f1, f2, s, i, vm1, vm2, sim, "prev"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    next_step_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_step(f1, f2, s, i, vm1, vm2, sim, "next"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    # Index navigation buttons
+    prev_idx_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_idx(f1, f2, s, i, vm1, vm2, sim, "prev"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    next_idx_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_idx(f1, f2, s, i, vm1, vm2, sim, "next"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True, allowed_paths=["0_ablation_videos"])

Helios-main/tools/gradio/comparison/gradio_compare_diff-ckpt.py

@@ -0,0 +1,547 @@
+import os
+import re
+
+import gradio as gr
+
+
+def parse_video_name(filename):
+    """Parse video filename to extract step and index"""
+    # Match checkpoint-{step}_{idx}.mp4 format
+    match = re.match(r"checkpoint-(\d+)_(\d+)\.mp4$", filename)
+    if match:
+        step = int(match.group(1))
+        idx = int(match.group(2))
+        return step, idx
+    return None, None
+
+
+def get_video_list(folder_path):
+    """Get all mp4 videos from folder"""
+    if not os.path.exists(folder_path):
+        return []
+
+    videos = []
+    for file in os.listdir(folder_path):
+        if file.endswith(".mp4"):
+            step, idx = parse_video_name(file)
+            if step is not None:
+                videos.append({"filename": file, "step": step, "idx": idx, "path": os.path.join(folder_path, file)})
+
+    # Sort by step and idx
+    videos.sort(key=lambda x: (x["step"], x["idx"]))
+    return videos
+
+
+def create_video_mapping(videos):
+    """Create (step, idx) -> filename mapping"""
+    mapping = {}
+    for video in videos:
+        key = (video["step"], video["idx"])
+        mapping[key] = video["filename"]
+    return mapping
+
+
+def get_step_idx_mapping(common_keys):
+    """Extract step and idx mapping from common (step, idx) keys"""
+    step_idx_map = {}  # {step: [idx1, idx2, ...]}
+    all_steps = set()
+    all_indices = set()
+
+    for step, idx in common_keys:
+        all_steps.add(step)
+        all_indices.add(idx)
+        if step not in step_idx_map:
+            step_idx_map[step] = []
+        step_idx_map[step].append(idx)
+
+    # Sort
+    for step in step_idx_map:
+        step_idx_map[step].sort()
+
+    return sorted(all_steps), sorted(all_indices), step_idx_map
+
+
+def load_videos(folder1, folder2):
+    """Load videos from both folders and match them"""
+    if not folder1 or not folder2:
+        return (
+            None,
+            None,
+            "Please enter both folder paths",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    videos1 = get_video_list(folder1)
+    videos2 = get_video_list(folder2)
+
+    if not videos1:
+        return (
+            None,
+            None,
+            f"No video files found in folder 1 (total {len(os.listdir(folder1)) if os.path.exists(folder1) else 0} files)",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+    if not videos2:
+        return (
+            None,
+            None,
+            f"No video files found in folder 2 (total {len(os.listdir(folder2)) if os.path.exists(folder2) else 0} files)",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    # Create (step, idx) to filename mapping
+    video_map1 = create_video_mapping(videos1)
+    video_map2 = create_video_mapping(videos2)
+
+    # Find common (step, idx) combinations
+    common_keys = sorted(set(video_map1.keys()) & set(video_map2.keys()))
+
+    if not common_keys:
+        # Show detailed information for debugging
+        steps1 = {v["step"] for v in videos1}
+        steps2 = {v["step"] for v in videos2}
+        info = "No matching videos found in both folders\n"
+        info += f"Folder 1: {len(videos1)} videos found\n"
+        info += f"Folder 2: {len(videos2)} videos found\n"
+        info += f"Folder 1 steps: {sorted(steps1)}\n"
+        info += f"Folder 2 steps: {sorted(steps2)}\n"
+        info += f"Common steps: {sorted(steps1 & steps2)}"
+        return (
+            None,
+            None,
+            info,
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+            {},
+        )
+
+    # Get all steps and indices
+    all_steps, all_indices, step_idx_map = get_step_idx_mapping(common_keys)
+
+    # Load first video
+    first_key = common_keys[0]
+    first_step, first_idx = first_key
+
+    filename1 = video_map1[first_key]
+    filename2 = video_map2[first_key]
+
+    video1_path = os.path.join(folder1, filename1)
+    video2_path = os.path.join(folder2, filename2)
+
+    info = f"Found {len(common_keys)} matching video pairs\n"
+    info += f"Folder 1: {len(videos1)} videos\n"
+    info += f"Folder 2: {len(videos2)} videos\n"
+    info += f"Current: Step {first_step}, Index {first_idx}\n"
+    info += f"File 1: {filename1}\n"
+    info += f"File 2: {filename2}"
+
+    # Get available indices for current step
+    available_indices = step_idx_map.get(first_step, [])
+
+    progress = f"1 / {len(common_keys)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(choices=all_steps, value=first_step),
+        gr.update(choices=available_indices, value=first_idx),
+        gr.update(interactive=first_step > all_steps[0]),
+        gr.update(interactive=first_step < all_steps[-1]),
+        gr.update(interactive=first_idx > available_indices[0] if available_indices else False),
+        gr.update(interactive=first_idx < available_indices[-1] if available_indices else False),
+        progress,
+        video_map1,
+        video_map2,
+        step_idx_map,
+    )
+
+
+def update_available_indices(selected_step, step_idx_map):
+    """Update available index list"""
+    if not step_idx_map or selected_step is None:
+        return gr.update(choices=[], value=None)
+
+    available_indices = step_idx_map.get(selected_step, [])
+    first_idx = available_indices[0] if available_indices else None
+
+    return gr.update(choices=available_indices, value=first_idx)
+
+
+def update_videos_from_selectors(folder1, folder2, selected_step, selected_idx, video_map1, video_map2, step_idx_map):
+    """Update videos based on selected step and idx"""
+    if selected_step is None or selected_idx is None:
+        return None, None, "Please select step and index", gr.update(), gr.update(), gr.update(), gr.update(), ""
+
+    key = (selected_step, selected_idx)
+
+    if key not in video_map1 or key not in video_map2:
+        return (
+            None,
+            None,
+            f"Video not found for Step {selected_step}, Index {selected_idx}",
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    filename1 = video_map1[key]
+    filename2 = video_map2[key]
+
+    video1_path = os.path.join(folder1, filename1)
+    video2_path = os.path.join(folder2, filename2)
+
+    info = f"Current: Step {selected_step}, Index {selected_idx}\n"
+    info += f"File 1: {filename1}\n"
+    info += f"File 2: {filename2}"
+
+    # Get all steps and indices for current step
+    all_steps = sorted(step_idx_map.keys())
+    available_indices = step_idx_map.get(selected_step, [])
+
+    # Update button states
+    prev_step_interactive = selected_step > all_steps[0]
+    next_step_interactive = selected_step < all_steps[-1]
+    prev_idx_interactive = selected_idx > available_indices[0] if available_indices else False
+    next_idx_interactive = selected_idx < available_indices[-1] if available_indices else False
+
+    # Calculate current video position
+    all_keys = sorted(set(video_map1.keys()) & set(video_map2.keys()))
+    current_idx = all_keys.index(key) + 1
+    progress = f"{current_idx} / {len(all_keys)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(interactive=prev_step_interactive),
+        gr.update(interactive=next_step_interactive),
+        gr.update(interactive=prev_idx_interactive),
+        gr.update(interactive=next_idx_interactive),
+        progress,
+    )
+
+
+def navigate_step(folder1, folder2, current_step, current_idx, video_map1, video_map2, step_idx_map, direction):
+    """Navigate to previous or next step"""
+    if not step_idx_map or current_step is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    all_steps = sorted(step_idx_map.keys())
+    current_step_idx = all_steps.index(current_step)
+
+    if direction == "prev":
+        new_step_idx = max(0, current_step_idx - 1)
+    else:  # next
+        new_step_idx = min(len(all_steps) - 1, current_step_idx + 1)
+
+    new_step = all_steps[new_step_idx]
+
+    # Get first available index for new step
+    available_indices = step_idx_map.get(new_step, [])
+    new_idx = available_indices[0] if available_indices else current_idx
+
+    return update_videos_from_selectors(folder1, folder2, new_step, new_idx, video_map1, video_map2, step_idx_map) + (
+        new_step,
+        new_idx,
+    )
+
+
+def navigate_idx(folder1, folder2, current_step, current_idx, video_map1, video_map2, step_idx_map, direction):
+    """Navigate to previous or next index"""
+    if not step_idx_map or current_step is None or current_idx is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    available_indices = step_idx_map.get(current_step, [])
+    if not available_indices or current_idx not in available_indices:
+        return (
+            None,
+            None,
+            "Index not in list",
+            current_step,
+            current_idx,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    current_idx_pos = available_indices.index(current_idx)
+
+    if direction == "prev":
+        new_idx_pos = max(0, current_idx_pos - 1)
+    else:  # next
+        new_idx_pos = min(len(available_indices) - 1, current_idx_pos + 1)
+
+    new_idx = available_indices[new_idx_pos]
+
+    return update_videos_from_selectors(
+        folder1, folder2, current_step, new_idx, video_map1, video_map2, step_idx_map
+    ) + (current_step, new_idx)
+
+
+# Create Gradio interface
+with gr.Blocks(title="Video Comparison Tool") as demo:
+    gr.Markdown("# Video Comparison Tool")
+    gr.Markdown(
+        "Enter two folder paths to automatically match and compare checkpoint-{step}_{idx}.mp4 format video files"
+    )
+
+    # Store state
+    video_map1_state = gr.State({})
+    video_map2_state = gr.State({})
+    step_idx_map_state = gr.State({})
+
+    with gr.Row():
+        folder1_input = gr.Textbox(label="Folder 1 Path", placeholder="/path/to/folder1", scale=2)
+        folder2_input = gr.Textbox(label="Folder 2 Path", placeholder="/path/to/folder2", scale=2)
+
+    load_btn = gr.Button("Load Videos", variant="primary")
+
+    info_text = gr.Textbox(label="Information", interactive=False, lines=6)
+
+    # Step navigation controls
+    with gr.Row():
+        prev_step_btn = gr.Button("⬅️ Previous Step", interactive=False, scale=1)
+        step_selector = gr.Dropdown(label="Select Step", choices=[], interactive=True, scale=2)
+        next_step_btn = gr.Button("Next Step ➡️", interactive=False, scale=1)
+
+    # Index navigation controls
+    with gr.Row():
+        prev_idx_btn = gr.Button("⬅️ Previous Index", interactive=False, scale=1)
+        idx_selector = gr.Dropdown(label="Select Index", choices=[], interactive=True, scale=2)
+        next_idx_btn = gr.Button("Next Index ➡️", interactive=False, scale=1)
+
+    progress_text = gr.Textbox(label="Progress", value="0 / 0", interactive=False)
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Folder 1")
+            video1 = gr.Video(label="Video 1", autoplay=True, loop=True)
+
+        with gr.Column():
+            gr.Markdown("### Folder 2")
+            video2 = gr.Video(label="Video 2", autoplay=True, loop=True)
+
+    # Event bindings
+    load_btn.click(
+        fn=load_videos,
+        inputs=[folder1_input, folder2_input],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            step_selector,
+            idx_selector,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+    )
+
+    # When step changes, update available indices
+    step_selector.change(
+        fn=update_available_indices, inputs=[step_selector, step_idx_map_state], outputs=[idx_selector]
+    ).then(
+        fn=update_videos_from_selectors,
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[video1, video2, info_text, prev_step_btn, next_step_btn, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    # When index changes, update videos
+    idx_selector.change(
+        fn=update_videos_from_selectors,
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[video1, video2, info_text, prev_step_btn, next_step_btn, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    # Step navigation buttons
+    prev_step_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_step(f1, f2, s, i, vm1, vm2, sim, "prev"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    next_step_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_step(f1, f2, s, i, vm1, vm2, sim, "next"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    # Index navigation buttons
+    prev_idx_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_idx(f1, f2, s, i, vm1, vm2, sim, "prev"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+    next_idx_btn.click(
+        fn=lambda f1, f2, s, i, vm1, vm2, sim: navigate_idx(f1, f2, s, i, vm1, vm2, sim, "next"),
+        inputs=[
+            folder1_input,
+            folder2_input,
+            step_selector,
+            idx_selector,
+            video_map1_state,
+            video_map2_state,
+            step_idx_map_state,
+        ],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_step_btn,
+            next_step_btn,
+            prev_idx_btn,
+            next_idx_btn,
+            progress_text,
+            step_selector,
+            idx_selector,
+        ],
+    )
+
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        allowed_paths=[
+            "0_ablation_videos",
+            "ablation_stage3_1_warmup",
+        ],
+    )

Helios-main/tools/gradio/comparison/gradio_compare_diff-video.py

@@ -0,0 +1,450 @@
+import os
+import re
+
+import gradio as gr
+
+
+def parse_video_name(filename):
+    """Parse video filename to extract step and index"""
+    # Match checkpoint-{step}_{idx}.mp4 format
+    match = re.match(r"checkpoint-(\d+)_(\d+)\.mp4$", filename)
+    if match:
+        step = int(match.group(1))
+        idx = int(match.group(2))
+        return step, idx
+    return None, None
+
+
+def get_video_list(folder_path):
+    """Get all mp4 videos from folder"""
+    if not os.path.exists(folder_path):
+        return []
+
+    videos = []
+    for file in os.listdir(folder_path):
+        if file.endswith(".mp4"):
+            step, idx = parse_video_name(file)
+            if step is not None:
+                videos.append({"filename": file, "step": step, "idx": idx, "path": os.path.join(folder_path, file)})
+
+    # Sort by step and idx
+    videos.sort(key=lambda x: (x["step"], x["idx"]))
+    return videos
+
+
+def create_video_mapping(videos):
+    """Create (step, idx) -> filename mapping"""
+    mapping = {}
+    for video in videos:
+        key = (video["step"], video["idx"])
+        mapping[key] = video["filename"]
+    return mapping
+
+
+def get_step_idx_info(video_map):
+    """Extract step and idx information from video mapping"""
+    all_steps = set()
+    all_indices = set()
+    idx_step_map = {}  # {idx: [step1, step2, ...]}
+
+    for step, idx in video_map.keys():
+        all_steps.add(step)
+        all_indices.add(idx)
+        if idx not in idx_step_map:
+            idx_step_map[idx] = []
+        idx_step_map[idx].append(step)
+
+    # Sort
+    for idx in idx_step_map:
+        idx_step_map[idx].sort()
+
+    return sorted(all_steps), sorted(all_indices), idx_step_map
+
+
+def load_videos(folder_path):
+    """Load videos from folder"""
+    if not folder_path:
+        return (
+            None,
+            None,
+            "Please enter folder path",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+        )
+
+    videos = get_video_list(folder_path)
+
+    if not videos:
+        return (
+            None,
+            None,
+            f"No video files found in folder ({len(os.listdir(folder_path)) if os.path.exists(folder_path) else 0} files total)",
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+        )
+
+    # Create (step, idx) to filename mapping
+    video_map = create_video_mapping(videos)
+
+    # Get all step and index information
+    all_steps, all_indices, idx_step_map = get_step_idx_info(video_map)
+
+    # Filter indices with at least 2 steps
+    valid_indices = [idx for idx in all_indices if len(idx_step_map[idx]) >= 2]
+
+    if not valid_indices:
+        info = (
+            f"Found {len(videos)} videos, but no comparable videos (need at least 2 different steps for same index)\n"
+        )
+        info += f"Steps: {all_steps}\n"
+        info += f"Indices: {all_indices}"
+        return (
+            None,
+            None,
+            info,
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(choices=[], value=None),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            gr.update(interactive=False),
+            "0 / 0",
+            {},
+            {},
+        )
+
+    # Select first valid index and its first two steps
+    first_idx = valid_indices[0]
+    available_steps = idx_step_map[first_idx]
+    step1 = available_steps[0]
+    step2 = available_steps[1] if len(available_steps) > 1 else available_steps[0]
+
+    # Load videos
+    filename1 = video_map.get((step1, first_idx))
+    filename2 = video_map.get((step2, first_idx))
+
+    video1_path = os.path.join(folder_path, filename1) if filename1 else None
+    video2_path = os.path.join(folder_path, filename2) if filename2 else None
+
+    info = f"Found {len(videos)} videos, {len(valid_indices)} comparable indices\n"
+    info += f"Current Index: {first_idx}\n"
+    info += f"Step1: {step1} - {filename1}\n"
+    info += f"Step2: {step2} - {filename2}"
+
+    progress = f"1 / {len(valid_indices)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(choices=valid_indices, value=first_idx),
+        gr.update(choices=available_steps, value=step1),
+        gr.update(choices=available_steps, value=step2),
+        gr.update(interactive=first_idx > valid_indices[0]),
+        gr.update(interactive=first_idx < valid_indices[-1]),
+        gr.update(interactive=True),
+        gr.update(interactive=True),
+        progress,
+        video_map,
+        idx_step_map,
+    )
+
+
+def update_videos(folder_path, selected_idx, selected_step1, selected_step2, video_map, idx_step_map):
+    """Update videos based on selected idx and two steps"""
+    if selected_idx is None or selected_step1 is None or selected_step2 is None:
+        return None, None, "Please select index and steps", gr.update(), gr.update(), gr.update(), gr.update(), ""
+
+    key1 = (selected_step1, selected_idx)
+    key2 = (selected_step2, selected_idx)
+
+    filename1 = video_map.get(key1)
+    filename2 = video_map.get(key2)
+
+    if not filename1 or not filename2:
+        return (
+            None,
+            None,
+            f"Complete video pair not found: Index {selected_idx}, Step1 {selected_step1}, Step2 {selected_step2}",
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    video1_path = os.path.join(folder_path, filename1)
+    video2_path = os.path.join(folder_path, filename2)
+
+    info = f"Current Index: {selected_idx}\n"
+    info += f"Step1: {selected_step1} - {filename1}\n"
+    info += f"Step2: {selected_step2} - {filename2}"
+
+    # Get all valid indices
+    all_indices = [idx for idx in idx_step_map.keys() if len(idx_step_map[idx]) >= 2]
+    all_indices.sort()
+
+    # Update button states
+    prev_idx_interactive = selected_idx > all_indices[0] if all_indices else False
+    next_idx_interactive = selected_idx < all_indices[-1] if all_indices else False
+
+    # Calculate progress
+    current_pos = all_indices.index(selected_idx) + 1 if selected_idx in all_indices else 0
+    progress = f"{current_pos} / {len(all_indices)}"
+
+    return (
+        video1_path,
+        video2_path,
+        info,
+        gr.update(interactive=prev_idx_interactive),
+        gr.update(interactive=next_idx_interactive),
+        gr.update(),
+        gr.update(),
+        progress,
+    )
+
+
+def update_available_steps(selected_idx, idx_step_map):
+    """Update available steps list for current index"""
+    if not idx_step_map or selected_idx is None:
+        return gr.update(choices=[], value=None), gr.update(choices=[], value=None)
+
+    available_steps = idx_step_map.get(selected_idx, [])
+    first_step = available_steps[0] if available_steps else None
+    second_step = available_steps[1] if len(available_steps) > 1 else first_step
+
+    return (
+        gr.update(choices=available_steps, value=first_step),
+        gr.update(choices=available_steps, value=second_step),
+    )
+
+
+def navigate_idx(folder_path, current_idx, step1, step2, video_map, idx_step_map, direction):
+    """Navigate to previous or next index"""
+    if not idx_step_map or current_idx is None:
+        return (
+            None,
+            None,
+            "Please load videos first",
+            current_idx,
+            step1,
+            step2,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    # Get all valid indices
+    all_indices = [idx for idx in idx_step_map.keys() if len(idx_step_map[idx]) >= 2]
+    all_indices.sort()
+
+    if current_idx not in all_indices:
+        return (
+            None,
+            None,
+            "Current Index invalid",
+            current_idx,
+            step1,
+            step2,
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "",
+        )
+
+    current_idx_pos = all_indices.index(current_idx)
+
+    if direction == "prev":
+        new_idx_pos = max(0, current_idx_pos - 1)
+    else:  # next
+        new_idx_pos = min(len(all_indices) - 1, current_idx_pos + 1)
+
+    new_idx = all_indices[new_idx_pos]
+
+    # Get available steps for new index
+    available_steps = idx_step_map.get(new_idx, [])
+    new_step1 = available_steps[0] if available_steps else step1
+    new_step2 = available_steps[1] if len(available_steps) > 1 else available_steps[0]
+
+    result = update_videos(folder_path, new_idx, new_step1, new_step2, video_map, idx_step_map)
+    return result + (new_idx, new_step1, new_step2)
+
+
+# Create Gradio interface
+with gr.Blocks(title="Video Comparison Tool - Different Step Comparison") as demo:
+    gr.Markdown("# Video Comparison Tool - Different Step Comparison")
+    gr.Markdown(
+        "Enter folder path to compare videos of same index at different steps (checkpoint-{step}_{idx}.mp4 format)"
+    )
+
+    # Store state
+    video_map_state = gr.State({})
+    idx_step_map_state = gr.State({})
+
+    folder_input = gr.Textbox(label="Folder Path", placeholder="/path/to/folder", scale=2)
+
+    load_btn = gr.Button("Load Videos", variant="primary")
+
+    info_text = gr.Textbox(label="Information", interactive=False, lines=5)
+
+    # Index navigation controls
+    with gr.Row():
+        prev_idx_btn = gr.Button("⬅️ Previous Index", interactive=False, scale=1)
+        idx_selector = gr.Dropdown(label="Select Index", choices=[], interactive=True, scale=2)
+        next_idx_btn = gr.Button("Next Index ➡️", interactive=False, scale=1)
+
+    # Step selectors
+    with gr.Row():
+        step1_selector = gr.Dropdown(label="Select Step1 (Left)", choices=[], interactive=True, scale=1)
+        step2_selector = gr.Dropdown(label="Select Step2 (Right)", choices=[], interactive=True, scale=1)
+
+    progress_text = gr.Textbox(label="Progress", value="0 / 0", interactive=False)
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Step 1")
+            video1 = gr.Video(label="Video 1", autoplay=True, loop=True)
+
+        with gr.Column():
+            gr.Markdown("### Step 2")
+            video2 = gr.Video(label="Video 2", autoplay=True, loop=True)
+
+    # Event binding
+    load_btn.click(
+        fn=load_videos,
+        inputs=[folder_input],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            idx_selector,
+            step1_selector,
+            step2_selector,
+            prev_idx_btn,
+            next_idx_btn,
+            gr.State(),
+            gr.State(),
+            progress_text,
+            video_map_state,
+            idx_step_map_state,
+        ],
+    )
+
+    # When index changes, update available steps and videos
+    def handle_idx_change(folder_path, selected_idx, video_map, idx_step_map):
+        """Handle index change - update steps and videos together"""
+        if not idx_step_map or selected_idx is None:
+            return (
+                None,
+                None,
+                "Please select index",
+                gr.update(choices=[], value=None),
+                gr.update(choices=[], value=None),
+                gr.update(),
+                gr.update(),
+                "",
+            )
+
+        # Get available steps for new index
+        available_steps = idx_step_map.get(selected_idx, [])
+        new_step1 = available_steps[0] if available_steps else None
+        new_step2 = available_steps[1] if len(available_steps) > 1 else available_steps[0]
+
+        # Update videos with new steps
+        result = update_videos(folder_path, selected_idx, new_step1, new_step2, video_map, idx_step_map)
+
+        return (
+            result[0],  # video1
+            result[1],  # video2
+            result[2],  # info
+            gr.update(choices=available_steps, value=new_step1),  # step1_selector
+            gr.update(choices=available_steps, value=new_step2),  # step2_selector
+            result[3],  # prev_idx_btn
+            result[4],  # next_idx_btn
+            result[7],  # progress
+        )
+
+    idx_selector.change(
+        fn=handle_idx_change,
+        inputs=[folder_input, idx_selector, video_map_state, idx_step_map_state],
+        outputs=[video1, video2, info_text, step1_selector, step2_selector, prev_idx_btn, next_idx_btn, progress_text],
+    )
+
+    step1_selector.select(
+        fn=update_videos,
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[video1, video2, info_text, prev_idx_btn, next_idx_btn, gr.State(), gr.State(), progress_text],
+    )
+
+    step2_selector.select(
+        fn=update_videos,
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[video1, video2, info_text, prev_idx_btn, next_idx_btn, gr.State(), gr.State(), progress_text],
+    )
+
+    # Index navigation buttons
+    prev_idx_btn.click(
+        fn=lambda f, i, s1, s2, vm, ism: navigate_idx(f, i, s1, s2, vm, ism, "prev"),
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_idx_btn,
+            next_idx_btn,
+            gr.State(),
+            gr.State(),
+            progress_text,
+            idx_selector,
+            step1_selector,
+            step2_selector,
+        ],
+    )
+
+    next_idx_btn.click(
+        fn=lambda f, i, s1, s2, vm, ism: navigate_idx(f, i, s1, s2, vm, ism, "next"),
+        inputs=[folder_input, idx_selector, step1_selector, step2_selector, video_map_state, idx_step_map_state],
+        outputs=[
+            video1,
+            video2,
+            info_text,
+            prev_idx_btn,
+            next_idx_btn,
+            gr.State(),
+            gr.State(),
+            progress_text,
+            idx_selector,
+            step1_selector,
+            step2_selector,
+        ],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch(
+        share=True,
+        allowed_paths=[
+            "0_ablation_videos",
+            "ablation_stage3_1_warmup",
+        ],
+    )

Helios-main/tools/offload_data/README.md

@@ -0,0 +1,93 @@
+# <u>Data Preprocessing Pipeline</u> by *Helios*
+This repository describes the data preprocessing pipeline used in the [Helios](https://arxiv.org/abs/2603.04379) paper. And we prepare a toy training data [here](https://huggingface.co/BestWishYsh/HeliosBench-Weights/tree/main/demo_data).
+
+
+## ⚙️ Requirements and Installation
+
+
+### Environment
+
+```bash
+# Activate conda environment
+conda activate helios
+```
+
+## 🗝️ Usage
+
+### Step 1 - Prepare Metadata and Organize Videos
+
+To train your own video generation model, create JSON files following this [format](./example/toy_data/toy_filter.json):
+
+```
+[
+    {
+        "cut": [0, 81],
+        "crop": [0, 832, 0, 480],
+        "fps": 24.0,
+        "num_frames": 81,
+        "resolution": {
+        "height": 480,
+        "width": 832
+        },
+        "cap": [
+        "A stunning mid-afternoon ..."
+        ],
+        "path": "videos/2_240_ori81.mp4"
+    },
+    {
+        "cut": [0, 81],
+        ...
+    }
+...
+]
+```
+
+and arrange video files following this [structure](./example):
+
+```
+📦 example/
+├── 📂 toy_data/
+│   ├── 📂 videos
+│   │   ├── 2_240_ori81.mp4
+│   │   ├── 239_120_ori129.mp4.mp4
+│   │   └── ...
+│   └── 📄 toy_data_1.json
+│
+├── 📂 toy_data_2/
+│   │   ├── A.mp4
+│   │   ├── B.mp4
+│   │   └── ...
+│   └── 📄 toy_data_2.json
+...
+```
+
+### Step 2 - Prepare Autoregressive Real Data
+
+These data can be used for training Stage-1, Stage-2, and Stage-3.
+
+```bash
+# Remember to modify the input and output paths before running
+bash get_short-latents.py
+```
+
+### Step 3 - Prepare Autoregressive ODE Data
+
+These data can only be used for training Stage-3.
+
+```bash
+# Remember to modify the input and output paths before running
+bash get_ode-pairs.sh
+```
+
+### (Optional) Step 4 - Prepare Text Data 
+
+If you want to use the [Self-Forcing](https://github.com/guandeh17/Self-Forcing) training approach, prepare text embeddings:
+
+```bash
+# Remember to modify the input and output paths before running
+bash get_text-embedding.sh
+```
+
+## 🔒 Acknowledgement
+
+* This project wouldn't be possible without the following open-sourced repositories: [OpenSora Plan](https://github.com/PKU-YuanGroup/Open-Sora-Plan), [OpenSora](https://github.com/hpcaitech/Open-Sora), [Video-Dataset-Scripts](https://github.com/huggingface/video-dataset-scripts)

Helios-main/tools/offload_data/get_long-latents.py

@@ -0,0 +1,329 @@
+import argparse
+import os
+
+import torch
+import torch.distributed as dist
+import torchvision.transforms as transforms
+from accelerate import Accelerator
+from helios.dataset.dataloader_mp4_dist import BucketedFeatureDataset, BucketedSampler, collate_fn
+from helios.utils.utils_base import encode_prompt
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoTokenizer, UMT5EncoderModel
+
+from diffusers import AutoencoderKLWan
+from diffusers.training_utils import free_memory
+
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+
+def main(
+    rank,
+    world_size,
+    global_rank,
+    stride,
+    batch_size,
+    dataloader_num_workers,
+    json_file,
+    video_folder,
+    output_latent_folder,
+    pretrained_model_name_or_path,
+    resolution=640,
+):
+    weight_dtype = torch.bfloat16
+    device = rank
+    seed = 42
+
+    # Load the tokenizers
+    tokenizer = AutoTokenizer.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer",
+    )
+    text_encoder = UMT5EncoderModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        torch_dtype=weight_dtype,
+    )
+    vae = AutoencoderKLWan.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+
+    latents_mean = torch.tensor(vae.config.latents_mean).view(1, vae.config.z_dim, 1, 1, 1).to(device, weight_dtype)
+    latents_std = 1.0 / torch.tensor(vae.config.latents_std).view(1, vae.config.z_dim, 1, 1, 1).to(
+        device, weight_dtype
+    )
+
+    vae.eval()
+    vae.requires_grad_(False)
+    text_encoder.eval()
+    text_encoder.requires_grad_(False)
+
+    vae = vae.to(device)
+    text_encoder = text_encoder.to(device)
+
+    # dist.barrier()
+    dataset = BucketedFeatureDataset(
+        json_files=json_file,
+        video_folders=video_folder,
+        stride=stride,
+        force_rebuild=False,
+        resolution=resolution,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+        single_length=True,
+        single_num_frame=81,
+    )
+    sampler = BucketedSampler(dataset, batch_size=batch_size, drop_last=False, shuffle=True, seed=seed)
+    dataloader = DataLoader(
+        dataset,
+        batch_sampler=sampler,
+        collate_fn=collate_fn,
+        num_workers=dataloader_num_workers,
+        pin_memory=True,
+        prefetch_factor=2 if dataloader_num_workers != 0 else None,
+        # persistent_workers=True if dataloader_num_workers > 0 else False,
+    )
+
+    print(len(dataset), len(dataloader))
+    accelerator = Accelerator()
+    dataloader = accelerator.prepare(dataloader)
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+    print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+    sampler.set_epoch(0)
+    if rank == 0:
+        pbar = tqdm(total=len(dataloader), desc="Processing")
+    # dist.barrier()
+    for idx, batch in enumerate(dataloader):
+        if batch is None or batch["videos"] is None:
+            print("None batch, continuing")
+            continue
+        free_memory()
+
+        valid_indices = []
+        valid_uttids = []
+        valid_num_frames = []
+        valid_heights = []
+        valid_widths = []
+        valid_videos = []
+        valid_prompts = []
+        valid_first_frames_images = []
+
+        if batch["uttid"] is None:
+            print("None batch, contiuning")
+            continue
+
+        for i, (uttid, num_frame, height, width) in enumerate(
+            zip(
+                batch["uttid"],
+                batch["video_metadata"]["num_frames"],
+                batch["video_metadata"]["height"],
+                batch["video_metadata"]["width"],
+            )
+        ):
+            os.makedirs(output_latent_folder, exist_ok=True)
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            if not os.path.exists(output_path):
+                valid_indices.append(i)
+                valid_uttids.append(uttid)
+                valid_num_frames.append(num_frame)
+                valid_heights.append(height)
+                valid_widths.append(width)
+                valid_videos.append(batch["videos"][i])
+                valid_prompts.append(batch["prompts"][i])
+                valid_first_frames_images.append(batch["first_frames_images"][i])
+            else:
+                print(f"skipping {uttid}")
+
+        if not valid_indices:
+            print("skipping entire batch!")
+            if rank == 0:
+                pbar.update(1)
+                pbar.set_postfix({"batch": idx})
+            continue
+
+        batch = None
+        del batch
+        free_memory()
+
+        batch = {
+            "uttid": valid_uttids,
+            "video_metadata": {"num_frames": valid_num_frames, "height": valid_heights, "width": valid_widths},
+            "videos": torch.stack(valid_videos),
+            "prompts": valid_prompts,
+            "first_frames_images": torch.stack(valid_first_frames_images),
+        }
+
+        if len(batch["uttid"]) == 0:
+            print("All samples in this batch are already processed, skipping!")
+            continue
+
+        with torch.no_grad():
+            # Get Vae feature
+            pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+            vae_latents = vae.encode(pixel_values).latent_dist.sample()
+            vae_latents = (vae_latents - latents_mean) * latents_std
+
+            # Encode prompts
+            prompts = batch["prompts"]
+            prompt_embeds, prompt_attention_mask = encode_prompt(
+                tokenizer=tokenizer,
+                text_encoder=text_encoder,
+                prompt=prompts,
+                device=device,
+            )
+
+            image_tensor = batch["first_frames_images"]
+            images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+
+        for (
+            uttid,
+            num_frame,
+            height,
+            width,
+            cur_vae_latent,
+            cur_prompt_embed,
+            cur_prompt_attention_mask,
+            cur_first_frames_image,
+            cur_prompt,
+        ) in zip(
+            batch["uttid"],
+            batch["video_metadata"]["num_frames"],
+            batch["video_metadata"]["height"],
+            batch["video_metadata"]["width"],
+            vae_latents,
+            prompt_embeds,
+            prompt_attention_mask,
+            images,
+            prompts,
+        ):
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            temp_to_save = {
+                "vae_latent": cur_vae_latent.cpu().detach(),
+                "prompt_embed": cur_prompt_embed.cpu().detach(),
+                # "prompt_attention_mask": cur_prompt_attention_mask.cpu().detach(),
+                "first_frames_image": cur_first_frames_image,
+                "prompt_raw": cur_prompt,
+            }
+            try:
+                torch.save(temp_to_save, output_path)
+            except Exception:
+                continue
+            print(f"save latent to: {output_path}")
+
+        if rank == 0:
+            pbar.update(1)
+            pbar.set_postfix({"batch": idx})
+
+        pixel_values = None
+        prompts = None
+        image_tensor = None
+        images = None
+        vae_latents = None
+        vae_latents_2 = None
+        image_embeds = None
+        prompt_embeds = None
+        batch = None
+        valid_indices = None
+        valid_uttids = None
+        valid_num_frames = None
+        valid_heights = None
+        valid_widths = None
+        valid_videos = None
+        valid_prompts = None
+        valid_first_frames_images = None
+        temp_to_save = None
+
+        del pixel_values
+        del prompts
+        del image_tensor
+        del images
+        del vae_latents
+        del vae_latents_2
+        del image_embeds
+        del batch
+        del valid_indices
+        del valid_uttids
+        del valid_num_frames
+        del valid_heights
+        del valid_widths
+        del valid_videos
+        del valid_prompts
+        del valid_first_frames_images
+        del temp_to_save
+
+        free_memory()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Script for running model training and data processing.")
+    parser.add_argument("--dataloader_num_workers", type=int, default=8, help="Number of workers for data loading")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default="BestWishYsh/Helios-Base",
+        help="Pretrained model path",
+    )
+    args = parser.parse_args()
+
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    base_video_path = "example"
+    video_paths = [
+        "toy_data",
+    ]
+
+    base_output_latent_path = "example/toy_data/latents_long"
+    output_latent_paths = [
+        "toy_data",
+    ]
+
+    base_csv_paths = [
+        "example",
+    ]
+    csv_paths = [
+        "toy_data/toy_filter.json",
+    ]
+
+    resolutions = [640]
+    strides = [1]
+    batch_sizes = [4]
+
+    for stride, batch_size, base_csv_path, csv_path, video_path, output_latent_path, cur_resolution in zip(
+        strides, batch_sizes, base_csv_paths, csv_paths, video_paths, output_latent_paths, resolutions
+    ):
+        json_file = os.path.join(base_csv_path, csv_path)
+        video_folder = os.path.join(base_video_path, video_path)
+        output_latent_folder = os.path.join(base_output_latent_path, output_latent_path)
+
+        main(
+            rank=device,
+            world_size=world_size,
+            global_rank=global_rank,
+            stride=stride,
+            batch_size=batch_size,
+            dataloader_num_workers=args.dataloader_num_workers,
+            json_file=json_file,
+            video_folder=video_folder,
+            output_latent_folder=output_latent_folder,
+            pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+            resolution=cur_resolution,
+        )
+
+    dist.barrier()
+    dist.destroy_process_group()

Helios-main/tools/offload_data/get_long-latents.sh

@@ -0,0 +1,64 @@
+export OMNISTORE_LOAD_STRICT_MODE=0
+export OMNISTORE_LOGGING_LEVEL=ERROR
+#################################################################
+## Torch
+#################################################################
+export TOKENIZERS_PARALLELISM=false
+export TORCH_LOGS="+dynamo,recompiles,graph_breaks"
+export TORCHDYNAMO_VERBOSE=1
+export TORCH_NCCL_ENABLE_MONITORING=1
+export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,garbage_collection_threshold:0.9"
+#################################################################
+
+
+#################################################################
+## NCCL
+#################################################################
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=$ARNOLD_RDMA_DEVICE
+export NCCL_SOCKET_IFNAME=eth0
+export NCCL_SOCKET_TIMEOUT=3600000
+
+export NCCL_DEBUG=WARN  # disable the verbose NCCL logs
+export NCCL_P2P_DISABLE=0
+export NCCL_IB_DISABLE=0  # was 1
+export NCCL_SHM_DISABLE=0  # was 1
+export NCCL_P2P_LEVEL=NVL
+
+export NCCL_PXN_DISABLE=0
+export NCCL_NET_GDR_LEVEL=2
+export NCCL_IB_QPS_PER_CONNECTION=4
+export NCCL_IB_TC=160
+export NCCL_IB_TIMEOUT=22
+#################################################################
+
+#################################################################
+## DIST
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+MASTER_PORT=${ports[0]}
+NNODES=$ARNOLD_WORKER_NUM
+NODE_RANK=$ARNOLD_ID
+GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+
+# export CUDA_VISIBLE_DEVICES=1
+# MASTER_PORT=12345
+# GPUS_PER_NODE=1
+# NNODES=1
+# NODE_RANK=0
+
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+if [ ! -z $RDZV_BACKEND ]; then
+    DISTRIBUTED_ARGS="${DISTRIBUTED_ARGS} --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_id 9863 --rdzv_backend c10d"
+    export NCCL_SHM_DISABLE=1
+fi
+
+echo -e "\033[31mDISTRIBUTED_ARGS: ${DISTRIBUTED_ARGS}\033[0m"
+
+#################################################################
+# 
+torchrun $DISTRIBUTED_ARGS \
+    tools/offload_data/get_long-latents.py

Helios-main/tools/offload_data/get_ode-pairs.py

@@ -0,0 +1,421 @@
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+import argparse
+from pathlib import Path
+
+import torch
+import torch.distributed as dist
+from accelerate import Accelerator
+from helios.modules.helios_kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from helios.modules.transformer_helios import HeliosTransformer3DModel
+from helios.pipelines.pipeline_helios_ode import HeliosPipeline
+from helios.scheduler.scheduling_helios import HeliosScheduler
+from helios.utils.utils_base import encode_prompt, load_extra_components
+from torch.utils.data import DataLoader, Dataset
+from tqdm import tqdm
+
+from diffusers.models import AutoencoderKLWan
+
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+
+def check_file_exists(args):
+    basename, idx, line, output_folder = args
+    uttid = f"{basename}_{idx:05d}"
+    output_path = os.path.join(output_folder, f"{uttid}.pt")
+    if os.path.exists(output_path):
+        return None, None
+    return line.strip(), uttid
+
+
+def prepare_dataset_on_rank0(txt_file, output_folder, rank):
+    while True:
+        try:
+            if rank == 0:
+                basename = Path(txt_file).stem
+                output_dir = Path(output_folder)
+
+                existing_files = set()
+                if output_dir.exists():
+                    existing_files = {f.name for f in output_dir.iterdir() if f.is_file()}
+
+                prompts = []
+                uttids = []
+
+                with open(txt_file, "r") as f:
+                    for idx, line in enumerate(f):
+                        if not line.strip():
+                            continue
+
+                        uttid = f"{basename}_{idx:05d}"
+                        filename = f"{uttid}.pt"
+
+                        if filename not in existing_files:
+                            prompts.append(line.strip())
+                            uttids.append(uttid)
+
+                data_to_broadcast = [prompts, uttids]
+            else:
+                data_to_broadcast = [None, None]
+
+            dist.broadcast_object_list(data_to_broadcast, src=0)
+            break
+        except Exception:
+            continue
+
+    return data_to_broadcast[0], data_to_broadcast[1]
+
+
+class PromptDataset(Dataset):
+    def __init__(self, prompts, uttids):
+        self.prompts = prompts
+        self.uttids = uttids
+
+    def __len__(self):
+        return len(self.prompts)
+
+    def __getitem__(self, idx):
+        return {"prompt": self.prompts[idx], "uttid": self.uttids[idx]}
+
+
+def main():
+    args = parse_args()
+
+    # =============== Environment ===============
+    batch_size = 1
+    dataloader_num_workers = 8
+    feature_folders = [
+        "example/vidprom_first_1k.txt",
+    ]
+    output_folders = [
+        "example/toy_data/ode_pairs/vidprom_filtered_extended",
+    ]
+
+    if args.weight_dtype == "fp32":
+        args.weight_dtype = torch.float32
+    elif args.weight_dtype == "fp16":
+        args.weight_dtype = torch.float16
+    else:
+        args.weight_dtype = torch.bfloat16
+
+    setup_distributed_env()
+
+    rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+
+    accelerator = Accelerator()
+
+    # =============== Prepare Model ===============
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        args.transformer_path,
+        subfolder="transformer",
+        torch_dtype=args.weight_dtype,
+        use_default_loader=args.use_default_loader,
+    )
+    transformer = replace_rmsnorm_with_fp32(transformer)
+    transformer = replace_all_norms_with_flash_norms(transformer)
+    replace_rope_with_flash_rope()
+    vae = AutoencoderKLWan.from_pretrained(args.base_model_path, subfolder="vae", torch_dtype=torch.float32)
+    if args.is_enable_stage2:
+        scheduler = HeliosScheduler(
+            shift=args.stage2_timestep_shift,
+            stages=args.stage2_num_stages,
+            stage_range=args.stage2_stage_range,
+            gamma=args.stage2_scheduler_gamma,
+        )
+        pipe = HeliosPipeline.from_pretrained(
+            args.base_model_path,
+            transformer=transformer,
+            vae=vae,
+            scheduler=scheduler,
+            torch_dtype=args.weight_dtype,
+        )
+    else:
+        pipe = HeliosPipeline.from_pretrained(
+            args.base_model_path, transformer=transformer, vae=vae, torch_dtype=args.weight_dtype
+        )
+    pipe = pipe.to(device)
+
+    if args.lora_path is not None:
+        pipe.load_lora_weights(args.lora_path, adapter_name="default")
+        pipe.set_adapters(["default"], adapter_weights=[1.0])
+
+        if args.partial_path is not None:
+            if not hasattr(args, "training_config"):
+                from argparse import Namespace
+
+                args.training_config = Namespace()
+            args.training_config.is_enable_stage1 = True
+            args.training_config.restrict_self_attn = True
+            args.training_config.is_amplify_history = True
+            args.training_config.is_use_gan = True
+            load_extra_components(args, transformer, args.partial_path)
+
+    if args.vae_decode_type == "once":
+        pipe.vae.enable_tiling()
+
+    transformer.eval()
+    transformer.requires_grad_(False)
+    vae.eval()
+    vae.requires_grad_(False)
+
+    transformer.to(device)
+    vae.to(device)
+    pipe.to(device)
+
+    for feature_folder, output_folder in zip(feature_folders, output_folders):
+        print(f"Process {feature_folder} !")
+
+        os.makedirs(output_folder, exist_ok=True)
+        prompts, uttids = prepare_dataset_on_rank0(feature_folder, output_folder, rank)
+        dataset = PromptDataset(prompts, uttids)
+        dataloader = DataLoader(
+            dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=dataloader_num_workers,
+            prefetch_factor=2 if dataloader_num_workers > 0 else None,
+            pin_memory=True,
+            drop_last=False,
+        )
+        dataloader = accelerator.prepare(dataloader)
+        print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+        print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+        if len(dataloader) == 0:
+            continue
+
+        # =============== Main Loop ===============
+        if rank == 0:
+            pbar = tqdm(total=len(dataloader), desc="Processing")
+
+        for i, batch in enumerate(dataloader):
+            assert len(batch["uttid"]) == 1
+            uttid = batch["uttid"][0]
+            prompt_raw = batch["prompt"][0]
+
+            output_path = os.path.join(output_folder, f"{uttid}.pt")
+            if os.path.exists(output_path):
+                if rank == 0:
+                    print(f"Skipping existing file: {output_path}")
+                    pbar.update(1)
+                continue
+
+            with torch.no_grad():
+                prompt_embed, _ = encode_prompt(
+                    tokenizer=pipe.tokenizer,
+                    text_encoder=pipe.text_encoder,
+                    prompt=prompt_raw,
+                    device=device,
+                )
+
+                all_sections_ode = pipe(
+                    prompt=prompt_raw,
+                    negative_prompt=args.negative_prompt,
+                    height=args.height,
+                    width=args.width,
+                    num_frames=args.num_frames,  # 73 109 145 181 215
+                    num_inference_steps=50,
+                    guidance_scale=args.guidance_scale,
+                    generator=torch.Generator(device="cuda").manual_seed(args.seed),
+                    output_type="latent",
+                    vae_decode_type=args.vae_decode_type,
+                    # stage 1
+                    history_sizes=[16, 2, 1],
+                    latent_window_size=args.latent_window_size,
+                    is_keep_x0=True,
+                    use_dynamic_shifting=args.use_dynamic_shifting,
+                    time_shift_type=args.time_shift_type,
+                    # stage 2
+                    is_enable_stage2=args.is_enable_stage2,
+                    stage2_num_stages=args.stage2_num_stages,
+                    stage2_num_inference_steps_list=args.stage2_num_inference_steps_list,
+                    scheduler_type="unipc",
+                    # cfg zero
+                    use_cfg_zero_star=args.use_cfg_zero_star,
+                    use_zero_init=args.use_zero_init,
+                    zero_steps=args.zero_steps,
+                )
+
+            # (Pdb) len(all_sections_ode)
+            # 264 -> % 8 == 0
+            # 231 -> % 7 == 0
+            # 198 -> % 6 == 0
+            # 165 -> % 5 == 0
+            # (Pdb) len(all_sections_ode[0])
+            # 3
+            # (Pdb) all_sections_ode[0][0].keys()
+            # dict_keys(['latents', 'timesteps', 'noise_pred'])
+            # (Pdb) all_sections_ode[0][0]["timesteps"].shape
+            # torch.Size([20]
+            # (Pdb) all_sections_ode[0][0]["latents"].shape
+            # torch.Size([20, 1, 16, 9, 12, 20])
+            # (Pdb) all_sections_ode[0][0]["noise_pred"].shape
+            # torch.Size([20, 1, 16, 9, 12, 20])
+
+            processed_sections_ode = []
+            for idx, section in enumerate(all_sections_ode):
+                processed_section = []
+                for iidx, item in enumerate(section):
+                    if idx == 0:
+                        if iidx == 0:
+                            selected_target_timesteps = [998.5342, 902.2183, 833.9636, 783.0660]
+                        elif iidx == 1:
+                            selected_target_timesteps = [742.8216, 640.0038, 547.1926, 462.9951]
+                        elif iidx == 2:
+                            selected_target_timesteps = [385.4137, 328.6249, 253.9905, 151.5308]
+                    else:
+                        if iidx == 0:
+                            selected_target_timesteps = [998.5342, 833.9636]
+                        elif iidx == 1:
+                            selected_target_timesteps = [742.8216, 547.1926]
+                        elif iidx == 2:
+                            selected_target_timesteps = [385.4137, 253.9905]
+
+                    indices = []
+                    actual_timesteps = item["timesteps"]
+                    for target_t in selected_target_timesteps:
+                        diffs = torch.abs(actual_timesteps - target_t)
+                        closest_idx = torch.argmin(diffs).item()
+                        indices.append(closest_idx)
+                    latents_indices = indices + [-1]
+
+                    rocessed_item = {
+                        "latents": item["latents"][latents_indices],
+                        "timesteps": item["timesteps"][indices],
+                    }
+
+                    processed_section.append(rocessed_item)
+                processed_sections_ode.append(processed_section)
+            all_sections_ode = processed_sections_ode
+
+            temp_to_save = {
+                "latent_window_size": args.latent_window_size,
+                "prompt_raw": prompt_raw,
+                "prompt_embed": prompt_embed,
+                "ode_latents": all_sections_ode,
+            }
+            torch.save(temp_to_save, output_path)
+            print(f"save latent to: {output_path}")
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate video with model")
+
+    # === Model paths ===
+    parser.add_argument("--base_model_path", type=str, default="BestWishYsh/Helios-Base")
+    parser.add_argument(
+        "--transformer_path",
+        type=str,
+        default="BestWishYsh/Helios-Mid",
+    )
+    parser.add_argument(
+        "--lora_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument(
+        "--partial_path",
+        type=str,
+        default=None,
+    )
+    parser.add_argument("--use_default_loader", action="store_true")
+
+    # === Generation parameters ===
+    # environment
+    parser.add_argument(
+        "--sample_type",
+        type=str,
+        default="t2v",
+        choices=["t2v", "i2v", "v2v"],
+    )
+    parser.add_argument(
+        "--weight_dtype",
+        type=str,
+        default="bf16",
+        choices=["bf16", "fp16", "fp32"],
+        help="Data type for model weights.",
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Seed for random number generator.")
+    # base
+    parser.add_argument("--height", type=int, default=384)
+    parser.add_argument("--width", type=int, default=640)
+    parser.add_argument("--num_frames", type=int, default=165)
+    parser.add_argument("--num_inference_steps", type=int, default=50)
+    parser.add_argument("--guidance_scale", type=float, default=5.0)
+    parser.add_argument("--use_dynamic_shifting", action="store_true")
+    parser.add_argument(
+        "--time_shift_type",
+        type=str,
+        default="linear",
+        choices=["exponential", "linear"],
+    )
+    parser.add_argument("--vae_decode_type", type=str, default="default", choices=["default", "once", "default_fast"])
+    # stage 1
+    parser.add_argument("--latent_window_size", type=int, default=9)
+    # stage 2
+    parser.add_argument("--is_enable_stage2", action="store_true")
+    parser.add_argument("--stage2_timestep_shift", type=float, default=1.0)
+    parser.add_argument("--stage2_scheduler_gamma", type=float, default=1 / 3)
+    parser.add_argument("--stage2_stage_range", type=int, nargs="+", default=[0, 1 / 3, 2 / 3, 1])
+    parser.add_argument("--stage2_num_stages", type=int, default=3)
+    parser.add_argument("--stage2_num_inference_steps_list", type=int, nargs="+", default=[20, 20, 20])
+    # cfg zero
+    parser.add_argument("--use_cfg_zero_star", action="store_true")
+    parser.add_argument("--use_zero_init", action="store_true")
+    parser.add_argument("--zero_steps", type=int, default=1)
+
+    # === Prompts ===
+    parser.add_argument(
+        "--negative_prompt",
+        type=str,
+        default="Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards",
+    )
+    parser.add_argument(
+        "--prompt_txt_path",
+        type=str,
+        default=None,
+    )
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    # from diffusers import AutoencoderKLWan
+    # from diffusers.video_processor import VideoProcessor
+    # from diffusers.utils import export_to_video
+
+    # device = "cuda"
+    # pretrained_model_name_or_path = "BestWishYsh/Helios-Base"
+    # vae = AutoencoderKLWan.from_pretrained(
+    #     pretrained_model_name_or_path,
+    #     subfolder="vae",
+    #     torch_dtype=torch.float32,
+    # ).to(device)
+    # vae.eval()
+    # vae.requires_grad_(False)
+
+    # vae_scale_factor_spatial = vae.spatial_compression_ratio
+    # video_processor = VideoProcessor(vae_scale_factor=vae_scale_factor_spatial)
+    # latents_mean = torch.tensor(vae.config.latents_mean).view(1, vae.config.z_dim, 1, 1, 1)
+    # latents_std = 1.0 / torch.tensor(vae.config.latents_std).view(1, vae.config.z_dim, 1, 1, 1)
+
+    # x1 = torch.load("/mnt/hdfs/data/ysh_new/userful_things_wan/ode_pairs/vidprom_filtered_extended/vidprom_filtered_extended_00011.pt", map_location="cpu")
+    # vae_latents = x1["ode_latents"][-1][-1]["latents"][-1] / latents_std + latents_mean
+    # vae_latents = vae_latents.to(device=device, dtype=vae.dtype)
+    # video = vae.decode(vae_latents, return_dict=False)[0]
+    # video = video_processor.postprocess_video(video, output_type="pil")
+    # export_to_video(video[0], "output_wan.mp4", fps=30)
+
+    main()

Helios-main/tools/offload_data/get_ode-pairs.sh

@@ -0,0 +1,69 @@
+export OMNISTORE_LOAD_STRICT_MODE=0
+export OMNISTORE_LOGGING_LEVEL=ERROR
+#################################################################
+## Torch
+#################################################################
+export TOKENIZERS_PARALLELISM=false
+export TORCH_LOGS="+dynamo,recompiles,graph_breaks"
+export TORCHDYNAMO_VERBOSE=1
+export TORCH_NCCL_ENABLE_MONITORING=1
+export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,garbage_collection_threshold:0.9"
+#################################################################
+
+
+#################################################################
+## NCCL
+#################################################################
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=$ARNOLD_RDMA_DEVICE
+export NCCL_SOCKET_IFNAME=eth0
+export NCCL_SOCKET_TIMEOUT=3600000
+
+export NCCL_DEBUG=WARN  # disable the verbose NCCL logs
+export NCCL_P2P_DISABLE=0
+export NCCL_IB_DISABLE=0  # was 1
+export NCCL_SHM_DISABLE=0  # was 1
+export NCCL_P2P_LEVEL=NVL
+
+export NCCL_PXN_DISABLE=0
+export NCCL_NET_GDR_LEVEL=2
+export NCCL_IB_QPS_PER_CONNECTION=4
+export NCCL_IB_TC=160
+export NCCL_IB_TIMEOUT=22
+#################################################################
+
+#################################################################
+## DIST
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+MASTER_PORT=${ports[0]}
+NNODES=$ARNOLD_WORKER_NUM
+NODE_RANK=$ARNOLD_ID
+GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+
+# export CUDA_VISIBLE_DEVICES=1
+# MASTER_PORT=12345
+# GPUS_PER_NODE=1
+# NNODES=1
+# NODE_RANK=0
+
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+if [ ! -z $RDZV_BACKEND ]; then
+    DISTRIBUTED_ARGS="${DISTRIBUTED_ARGS} --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_id 9863 --rdzv_backend c10d"
+    export NCCL_SHM_DISABLE=1
+fi
+
+echo -e "\033[31mDISTRIBUTED_ARGS: ${DISTRIBUTED_ARGS}\033[0m"
+
+#################################################################
+# 
+torchrun $DISTRIBUTED_ARGS \
+    tools/offload_data/get_ode-pairs.py \
+    --use_dynamic_shifting \
+    --time_shift_type "linear" \
+    --use_default_loader \
+    --is_enable_stage2 \
+    --num_frames 165

Helios-main/tools/offload_data/get_short-latents.py

@@ -0,0 +1,341 @@
+import argparse
+import os
+
+import torch
+import torch.distributed as dist
+import torchvision.transforms as transforms
+from accelerate import Accelerator
+from helios.dataset.dataloader_mp4_dist import BucketedFeatureDataset, BucketedSampler, collate_fn
+from helios.utils.utils_base import encode_prompt
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+from transformers import AutoTokenizer, UMT5EncoderModel
+
+from diffusers import AutoencoderKLWan
+from diffusers.training_utils import free_memory
+
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+
+def cleanup_distributed_env():
+    dist.destroy_process_group()
+
+
+def main(
+    rank,
+    world_size,
+    global_rank,
+    stride,
+    batch_size,
+    dataloader_num_workers,
+    json_file,
+    video_folder,
+    output_latent_folder,
+    pretrained_model_name_or_path,
+    resolution=640,
+):
+    weight_dtype = torch.bfloat16
+    device = rank
+    seed = 42
+
+    # Load the tokenizers
+    tokenizer = AutoTokenizer.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="tokenizer",
+    )
+    text_encoder = UMT5EncoderModel.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="text_encoder",
+        torch_dtype=weight_dtype,
+    )
+    vae = AutoencoderKLWan.from_pretrained(
+        pretrained_model_name_or_path,
+        subfolder="vae",
+        torch_dtype=torch.float32,
+    )
+
+    latents_mean = torch.tensor(vae.config.latents_mean).view(1, vae.config.z_dim, 1, 1, 1).to(device, weight_dtype)
+    latents_std = 1.0 / torch.tensor(vae.config.latents_std).view(1, vae.config.z_dim, 1, 1, 1).to(
+        device, weight_dtype
+    )
+
+    vae.eval()
+    vae.requires_grad_(False)
+    text_encoder.eval()
+    text_encoder.requires_grad_(False)
+
+    vae = vae.to(device)
+    text_encoder = text_encoder.to(device)
+
+    # dist.barrier()
+    dataset = BucketedFeatureDataset(
+        json_files=json_file,
+        video_folders=video_folder,
+        stride=stride,
+        force_rebuild=False,
+        resolution=resolution,
+        single_res=True,
+        single_height=384,
+        single_width=640,
+    )
+    sampler = BucketedSampler(dataset, batch_size=batch_size, drop_last=False, shuffle=True, seed=seed)
+    dataloader = DataLoader(
+        dataset,
+        batch_sampler=sampler,
+        collate_fn=collate_fn,
+        num_workers=dataloader_num_workers,
+        pin_memory=True,
+        prefetch_factor=2 if dataloader_num_workers != 0 else None,
+        # persistent_workers=True if dataloader_num_workers > 0 else False,
+    )
+
+    print(len(dataset), len(dataloader))
+    accelerator = Accelerator()
+    dataloader = accelerator.prepare(dataloader)
+    print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+    print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+    sampler.set_epoch(0)
+    if rank == 0:
+        pbar = tqdm(total=len(dataloader), desc="Processing")
+    # dist.barrier()
+    for idx, batch in enumerate(dataloader):
+        if batch is None or batch["videos"] is None:
+            print("None batch, continuing")
+            continue
+        free_memory()
+
+        valid_indices = []
+        valid_uttids = []
+        valid_num_frames = []
+        valid_heights = []
+        valid_widths = []
+        valid_videos = []
+        valid_prompts = []
+        valid_first_frames_images = []
+
+        if batch["uttid"] is None:
+            print("None batch, contiuning")
+            continue
+
+        for i, (uttid, num_frame, height, width) in enumerate(
+            zip(
+                batch["uttid"],
+                batch["video_metadata"]["num_frames"],
+                batch["video_metadata"]["height"],
+                batch["video_metadata"]["width"],
+            )
+        ):
+            os.makedirs(output_latent_folder, exist_ok=True)
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            if not os.path.exists(output_path):
+                valid_indices.append(i)
+                valid_uttids.append(uttid)
+                valid_num_frames.append(num_frame)
+                valid_heights.append(height)
+                valid_widths.append(width)
+                valid_videos.append(batch["videos"][i])
+                valid_prompts.append(batch["prompts"][i])
+                valid_first_frames_images.append(batch["first_frames_images"][i])
+            else:
+                print(f"skipping {uttid}")
+
+        if not valid_indices:
+            print("skipping entire batch!")
+            if rank == 0:
+                pbar.update(1)
+                pbar.set_postfix({"batch": idx})
+            continue
+
+        batch = None
+        del batch
+        free_memory()
+
+        batch = {
+            "uttid": valid_uttids,
+            "video_metadata": {"num_frames": valid_num_frames, "height": valid_heights, "width": valid_widths},
+            "videos": torch.stack(valid_videos),
+            "prompts": valid_prompts,
+            "first_frames_images": torch.stack(valid_first_frames_images),
+        }
+
+        if len(batch["uttid"]) == 0:
+            print("All samples in this batch are already processed, skipping!")
+            continue
+
+        with torch.no_grad():
+            # Get Vae feature
+            pixel_values = batch["videos"].permute(0, 2, 1, 3, 4).to(dtype=vae.dtype, device=device)
+
+            latent_window_size = 9
+            frame_window_size = (latent_window_size - 1) * 4 + 1
+            num_latent_frames = pixel_values.shape[2]
+            num_chunk_to_encode = num_latent_frames // frame_window_size
+
+            history_latent_list = []
+            for i in range(num_chunk_to_encode):
+                start_idx = i * frame_window_size
+                end_idx = start_idx + frame_window_size
+                cur_pixel_values = pixel_values[:, :, start_idx:end_idx, :, :]
+                with torch.no_grad():
+                    cur_latent = vae.encode(cur_pixel_values).latent_dist.sample()
+                    cur_latent = (cur_latent - latents_mean) * latents_std
+                history_latent_list.append(cur_latent)
+            vae_latents = torch.stack(history_latent_list, dim=1)
+
+            # Encode prompts
+            prompts = batch["prompts"]
+            prompt_embeds, prompt_attention_mask = encode_prompt(
+                tokenizer=tokenizer,
+                text_encoder=text_encoder,
+                prompt=prompts,
+                device=device,
+            )
+
+            image_tensor = batch["first_frames_images"]
+            images = [transforms.ToPILImage()(x.to(torch.uint8)) for x in image_tensor]
+
+        for (
+            uttid,
+            num_frame,
+            height,
+            width,
+            cur_vae_latent,
+            cur_prompt_embed,
+            cur_prompt_attention_mask,
+            cur_first_frames_image,
+            cur_prompt,
+        ) in zip(
+            batch["uttid"],
+            batch["video_metadata"]["num_frames"],
+            batch["video_metadata"]["height"],
+            batch["video_metadata"]["width"],
+            vae_latents,
+            prompt_embeds,
+            prompt_attention_mask,
+            images,
+            prompts,
+        ):
+            output_path = os.path.join(output_latent_folder, f"{uttid}_{num_frame}_{height}_{width}.pt")
+            temp_to_save = {
+                "vae_latent": cur_vae_latent.cpu().detach(),
+                "prompt_embed": cur_prompt_embed.cpu().detach(),
+                # "prompt_attention_mask": cur_prompt_attention_mask.cpu().detach(),
+                "first_frames_image": cur_first_frames_image,
+                "prompt_raw": cur_prompt,
+            }
+            try:
+                torch.save(temp_to_save, output_path)
+            except Exception:
+                continue
+            print(f"save latent to: {output_path}")
+
+        if rank == 0:
+            pbar.update(1)
+            pbar.set_postfix({"batch": idx})
+
+        pixel_values = None
+        prompts = None
+        image_tensor = None
+        images = None
+        vae_latents = None
+        vae_latents_2 = None
+        image_embeds = None
+        prompt_embeds = None
+        batch = None
+        valid_indices = None
+        valid_uttids = None
+        valid_num_frames = None
+        valid_heights = None
+        valid_widths = None
+        valid_videos = None
+        valid_prompts = None
+        valid_first_frames_images = None
+        temp_to_save = None
+
+        del pixel_values
+        del prompts
+        del image_tensor
+        del images
+        del vae_latents
+        del vae_latents_2
+        del image_embeds
+        del batch
+        del valid_indices
+        del valid_uttids
+        del valid_num_frames
+        del valid_heights
+        del valid_widths
+        del valid_videos
+        del valid_prompts
+        del valid_first_frames_images
+        del temp_to_save
+
+        free_memory()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Script for running model training and data processing.")
+    parser.add_argument("--dataloader_num_workers", type=int, default=8, help="Number of workers for data loading")
+    parser.add_argument(
+        "--pretrained_model_name_or_path",
+        type=str,
+        default="BestWishYsh/Helios-Base",
+        help="Pretrained model path",
+    )
+    args = parser.parse_args()
+
+    setup_distributed_env()
+
+    global_rank = dist.get_rank()
+    local_rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+    world_size = dist.get_world_size()
+
+    base_video_path = "example"
+    video_paths = [
+        "toy_data",
+    ]
+
+    base_output_latent_path = "example/toy_data/latents_short"
+    output_latent_paths = [
+        "toy_data",
+    ]
+
+    base_csv_paths = [
+        "example",
+    ]
+    csv_paths = [
+        "toy_data/toy_filter.json",
+    ]
+
+    resolutions = [640]
+    strides = [1]
+    batch_sizes = [4]
+
+    for stride, batch_size, base_csv_path, csv_path, video_path, output_latent_path, cur_resolution in zip(
+        strides, batch_sizes, base_csv_paths, csv_paths, video_paths, output_latent_paths, resolutions
+    ):
+        json_file = os.path.join(base_csv_path, csv_path)
+        video_folder = os.path.join(base_video_path, video_path)
+        output_latent_folder = os.path.join(base_output_latent_path, output_latent_path)
+
+        main(
+            rank=device,
+            world_size=world_size,
+            global_rank=global_rank,
+            stride=stride,
+            batch_size=batch_size,
+            dataloader_num_workers=args.dataloader_num_workers,
+            json_file=json_file,
+            video_folder=video_folder,
+            output_latent_folder=output_latent_folder,
+            pretrained_model_name_or_path=args.pretrained_model_name_or_path,
+            resolution=cur_resolution,
+        )
+
+    dist.barrier()
+    dist.destroy_process_group()

Helios-main/tools/offload_data/get_short-latents.sh

@@ -0,0 +1,64 @@
+export OMNISTORE_LOAD_STRICT_MODE=0
+export OMNISTORE_LOGGING_LEVEL=ERROR
+#################################################################
+## Torch
+#################################################################
+export TOKENIZERS_PARALLELISM=false
+export TORCH_LOGS="+dynamo,recompiles,graph_breaks"
+export TORCHDYNAMO_VERBOSE=1
+export TORCH_NCCL_ENABLE_MONITORING=1
+export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,garbage_collection_threshold:0.9"
+#################################################################
+
+
+#################################################################
+## NCCL
+#################################################################
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=$ARNOLD_RDMA_DEVICE
+export NCCL_SOCKET_IFNAME=eth0
+export NCCL_SOCKET_TIMEOUT=3600000
+
+export NCCL_DEBUG=WARN  # disable the verbose NCCL logs
+export NCCL_P2P_DISABLE=0
+export NCCL_IB_DISABLE=0  # was 1
+export NCCL_SHM_DISABLE=0  # was 1
+export NCCL_P2P_LEVEL=NVL
+
+export NCCL_PXN_DISABLE=0
+export NCCL_NET_GDR_LEVEL=2
+export NCCL_IB_QPS_PER_CONNECTION=4
+export NCCL_IB_TC=160
+export NCCL_IB_TIMEOUT=22
+#################################################################
+
+#################################################################
+## DIST
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+MASTER_PORT=${ports[0]}
+NNODES=$ARNOLD_WORKER_NUM
+NODE_RANK=$ARNOLD_ID
+GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+
+# export CUDA_VISIBLE_DEVICES=1
+# MASTER_PORT=12345
+# GPUS_PER_NODE=1
+# NNODES=1
+# NODE_RANK=0
+
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+if [ ! -z $RDZV_BACKEND ]; then
+    DISTRIBUTED_ARGS="${DISTRIBUTED_ARGS} --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_id 9863 --rdzv_backend c10d"
+    export NCCL_SHM_DISABLE=1
+fi
+
+echo -e "\033[31mDISTRIBUTED_ARGS: ${DISTRIBUTED_ARGS}\033[0m"
+
+#################################################################
+# 
+torchrun $DISTRIBUTED_ARGS \
+    tools/offload_data/get_short-latents.py

Helios-main/tools/offload_data/get_text-embedding.py

@@ -0,0 +1,256 @@
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+import argparse
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import torch
+import torch.distributed as dist
+from accelerate import Accelerator
+from helios.utils.utils_base import encode_prompt
+from torch.utils.data import DataLoader, Dataset
+from tqdm import tqdm
+from transformers import AutoTokenizer, UMT5EncoderModel
+
+
+def setup_distributed_env():
+    dist.init_process_group(backend="nccl")
+    torch.cuda.set_device(int(os.environ["LOCAL_RANK"]))
+
+
+def check_file_exists(args):
+    basename, idx, line, output_folder = args
+    uttid = f"{basename}_{idx:05d}"
+    output_path = os.path.join(output_folder, f"{uttid}.pt")
+    if os.path.exists(output_path):
+        return None, None
+    return line.strip(), uttid
+
+
+def prepare_dataset_on_rank0(txt_file, output_folder, rank):
+    while True:
+        try:
+            if rank == 0:
+                basename = Path(txt_file).stem
+                output_dir = Path(output_folder)
+
+                existing_files = set()
+                if output_dir.exists():
+                    existing_files = {f.name for f in output_dir.iterdir() if f.is_file()}
+
+                prompts = []
+                uttids = []
+
+                with open(txt_file, "r") as f:
+                    for idx, line in enumerate(f):
+                        if not line.strip():
+                            continue
+
+                        uttid = f"{basename}_{idx:05d}"
+                        filename = f"{uttid}.pt"
+
+                        if filename not in existing_files:
+                            prompts.append(line.strip())
+                            uttids.append(uttid)
+
+                data_to_broadcast = [prompts, uttids]
+            else:
+                data_to_broadcast = [None, None]
+
+            dist.broadcast_object_list(data_to_broadcast, src=0)
+            break
+        except Exception:
+            continue
+
+    return data_to_broadcast[0], data_to_broadcast[1]
+
+
+class PromptDataset(Dataset):
+    def __init__(self, prompts, uttids):
+        self.prompts = prompts
+        self.uttids = uttids
+
+    def __len__(self):
+        return len(self.prompts)
+
+    def __getitem__(self, idx):
+        return {"prompt": self.prompts[idx], "uttid": self.uttids[idx]}
+
+
+def save_single_file(uttid, output_path, prompt_raw, prompt_embed):
+    temp_to_save = {
+        "prompt_raw": prompt_raw,
+        "prompt_embed": prompt_embed,
+    }
+
+    try:
+        torch.save(temp_to_save, output_path, pickle_protocol=4)
+        return f"✓ Saved: {output_path}"
+    except Exception as e:
+        return f"✗ Failed to save {uttid}: {str(e)}"
+
+
+def main():
+    save_executor = ThreadPoolExecutor(max_workers=8)
+    save_futures = []
+
+    args = parse_args()
+
+    # =============== Environment ===============
+    batch_size = 16
+    dataloader_num_workers = 8
+    feature_folders = [
+        "example/vidprom_first_1k.txt",
+    ]
+    output_folders = [
+        "example/toy_data/text-embedding/vidprom_filtered_extended",
+    ]
+
+    if args.weight_dtype == "fp32":
+        args.weight_dtype = torch.float32
+    elif args.weight_dtype == "fp16":
+        args.weight_dtype = torch.float16
+    else:
+        args.weight_dtype = torch.bfloat16
+
+    setup_distributed_env()
+
+    rank = int(os.environ["LOCAL_RANK"])
+    device = torch.cuda.current_device()
+
+    accelerator = Accelerator()
+
+    # =============== Prepare Model ===============
+    weight_dtype = torch.bfloat16
+    tokenizer = AutoTokenizer.from_pretrained(
+        args.base_model_path,
+        subfolder="tokenizer",
+    )
+    text_encoder = UMT5EncoderModel.from_pretrained(
+        args.base_model_path,
+        subfolder="text_encoder",
+        dtype=weight_dtype,
+    )
+
+    text_encoder.eval()
+    text_encoder.requires_grad_(False)
+    text_encoder = text_encoder.to(device)
+
+    for feature_folder, output_folder in zip(feature_folders, output_folders):
+        print(f"Process {feature_folder} !")
+
+        os.makedirs(output_folder, exist_ok=True)
+        prompts, uttids = prepare_dataset_on_rank0(feature_folder, output_folder, rank)
+        dataset = PromptDataset(prompts, uttids)
+        dataloader = DataLoader(
+            dataset,
+            batch_size=batch_size,
+            shuffle=False,
+            num_workers=dataloader_num_workers,
+            prefetch_factor=2 if dataloader_num_workers > 0 else None,
+            pin_memory=True,
+            drop_last=False,
+        )
+        dataloader = accelerator.prepare(dataloader)
+        print(f"Dataset size: {len(dataset)}, Dataloader batches: {len(dataloader)}")
+        print(f"Process index: {accelerator.process_index}, World size: {accelerator.num_processes}")
+
+        if len(dataloader) == 0:
+            continue
+
+        # =============== Main Loop ===============
+        if rank == 0:
+            pbar = tqdm(total=len(dataloader), desc="Processing")
+
+        for i, batch in enumerate(dataloader):
+            batch_size = len(batch["uttid"])
+            uttids = batch["uttid"]
+            prompts_raw = batch["prompt"]
+
+            files_to_process = []
+            indices_to_process = []
+
+            for idx, uttid in enumerate(uttids):
+                output_path = os.path.join(output_folder, f"{uttid}.pt")
+                if os.path.exists(output_path):
+                    if rank == 0:
+                        print(f"Skipping existing file: {output_path}")
+                else:
+                    files_to_process.append((uttid, output_path))
+                    indices_to_process.append(idx)
+
+            if len(files_to_process) == 0:
+                if rank == 0:
+                    pbar.update(1)
+                continue
+
+            prompts_to_encode = [prompts_raw[idx] for idx in indices_to_process]
+
+            with torch.no_grad():
+                prompt_embeds, _ = encode_prompt(
+                    tokenizer=tokenizer,
+                    text_encoder=text_encoder,
+                    prompt=prompts_to_encode,
+                    device=device,
+                )
+
+            for idx, (uttid, output_path) in enumerate(files_to_process):
+                prompt_embed_cpu = prompt_embeds[idx].cpu().clone()
+
+                future = save_executor.submit(
+                    save_single_file, uttid, output_path, prompts_to_encode[idx], prompt_embed_cpu
+                )
+                save_futures.append(future)
+
+            if len(save_futures) > 100:
+                completed_futures = [f for f in save_futures if f.done()]
+
+                if rank == 0:
+                    for future in completed_futures:
+                        try:
+                            result = future.result()
+                            print(result)
+                        except Exception as e:
+                            print(f"Save task error: {e}")
+
+                save_futures = [f for f in save_futures if not f.done()]
+
+            if rank == 0:
+                pbar.update(1)
+
+        if rank == 0:
+            pbar.close()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate video with model")
+
+    # === Model paths ===
+    parser.add_argument("--base_model_path", type=str, default="BestWishYsh/Helios-Base")
+
+    # === Generation parameters ===
+    parser.add_argument(
+        "--weight_dtype",
+        type=str,
+        default="bf16",
+        choices=["bf16", "fp16", "fp32"],
+        help="Data type for model weights.",
+    )
+    parser.add_argument("--seed", type=int, default=42, help="Seed for random number generator.")
+
+    # === Prompts ===
+    parser.add_argument(
+        "--negative_prompt",
+        type=str,
+        default="Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards",
+    )
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    main()

Helios-main/tools/offload_data/get_text-embedding.sh

@@ -0,0 +1,64 @@
+export OMNISTORE_LOAD_STRICT_MODE=0
+export OMNISTORE_LOGGING_LEVEL=ERROR
+#################################################################
+## Torch
+#################################################################
+export TOKENIZERS_PARALLELISM=false
+export TORCH_LOGS="+dynamo,recompiles,graph_breaks"
+export TORCHDYNAMO_VERBOSE=1
+export TORCH_NCCL_ENABLE_MONITORING=1
+export PYTORCH_CUDA_ALLOC_CONF="expandable_segments:True,garbage_collection_threshold:0.9"
+#################################################################
+
+
+#################################################################
+## NCCL
+#################################################################
+export NCCL_IB_GID_INDEX=3
+export NCCL_IB_HCA=$ARNOLD_RDMA_DEVICE
+export NCCL_SOCKET_IFNAME=eth0
+export NCCL_SOCKET_TIMEOUT=3600000
+
+export NCCL_DEBUG=WARN  # disable the verbose NCCL logs
+export NCCL_P2P_DISABLE=0
+export NCCL_IB_DISABLE=0  # was 1
+export NCCL_SHM_DISABLE=0  # was 1
+export NCCL_P2P_LEVEL=NVL
+
+export NCCL_PXN_DISABLE=0
+export NCCL_NET_GDR_LEVEL=2
+export NCCL_IB_QPS_PER_CONNECTION=4
+export NCCL_IB_TC=160
+export NCCL_IB_TIMEOUT=22
+#################################################################
+
+#################################################################
+## DIST
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+MASTER_PORT=${ports[0]}
+NNODES=$ARNOLD_WORKER_NUM
+NODE_RANK=$ARNOLD_ID
+GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+
+# export CUDA_VISIBLE_DEVICES=1
+# MASTER_PORT=12345
+# GPUS_PER_NODE=1
+# NNODES=1
+# NODE_RANK=0
+
+WORLD_SIZE=$(($GPUS_PER_NODE*$NNODES))
+
+DISTRIBUTED_ARGS="--nproc_per_node $GPUS_PER_NODE --nnodes $NNODES --node_rank $NODE_RANK --master_addr $MASTER_ADDR --master_port $MASTER_PORT"
+if [ ! -z $RDZV_BACKEND ]; then
+    DISTRIBUTED_ARGS="${DISTRIBUTED_ARGS} --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_id 9863 --rdzv_backend c10d"
+    export NCCL_SHM_DISABLE=1
+fi
+
+echo -e "\033[31mDISTRIBUTED_ARGS: ${DISTRIBUTED_ARGS}\033[0m"
+
+#################################################################
+# 
+torchrun $DISTRIBUTED_ARGS \
+    tools/offload_data/get_text-embedding.py

Helios-main/tools/others/benchmark/benchmark_compile_performance.py

@@ -0,0 +1,234 @@
+import os
+import sys
+import time
+from datetime import datetime
+
+import torch
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+from helios.modules.kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_rmsnorm_with_fp32,
+    replace_rope_with_flash_rope,
+)
+from helios.modules.transformer_helios import HeliosTransformer3DModel
+from helios.pipelines.pipeline_wan import WanPipeline
+
+from diffusers import AutoencoderKLWan
+
+
+class DualLogger:
+    """同时输出到控制台和文件的日志器"""
+
+    def __init__(self, filename):
+        self.file = open(filename, "w", encoding="utf-8")
+        self.stdout = sys.stdout
+
+    def write(self, message):
+        self.stdout.write(message)  # 输出到控制台
+        self.file.write(message)  # 写入文件
+        self.file.flush()  # 实时刷新
+
+    def flush(self):
+        self.stdout.flush()
+        self.file.flush()
+
+    def close(self):
+        self.file.close()
+
+
+def setup_pipeline(model_id, compile_config=None):
+    """设置pipeline"""
+    print(f"\n{'=' * 60}")
+    print(f"设置 Pipeline: {compile_config['name'] if compile_config else 'No Compile'}")
+    print(f"{'=' * 60}")
+
+    # 加载模型
+    transformer = HeliosTransformer3DModel.from_pretrained(
+        model_id, subfolder="transformer", torch_dtype=torch.bfloat16, use_default_loader=True
+    )
+    transformer = replace_rmsnorm_with_fp32(transformer)
+    transformer = replace_all_norms_with_flash_norms(transformer)
+    replace_rope_with_flash_rope()
+
+    vae = AutoencoderKLWan.from_pretrained(model_id, subfolder="vae", torch_dtype=torch.float32)
+    pipe = WanPipeline.from_pretrained(model_id, vae=vae, transformer=transformer, torch_dtype=torch.bfloat16)
+
+    pipe.transformer.set_attention_backend("_flash_3_hub")
+    pipe.to("cuda")
+
+    # 应用compile配置
+    if compile_config:
+        print(f"应用编译配置: {compile_config['kwargs']}")
+        pipe.transformer.compile(**compile_config["kwargs"])
+
+    return pipe
+
+
+def run_benchmark(pipe, prompt, negative_prompt, num_runs=3, warmup=1):
+    """运行基准测试"""
+    times = []
+
+    # Warmup
+    print(f"\n预热运行 {warmup} 次...")
+    for i in range(warmup):
+        print(f"  预热 {i + 1}/{warmup}")
+        _ = pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=384,
+            width=640,
+            num_frames=45,
+            guidance_scale=5.0,
+            num_inference_steps=50,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+        ).frames[0]
+        torch.cuda.empty_cache()
+
+    # 实际测试
+    print(f"\n开始基准测试 {num_runs} 次...")
+    for i in range(num_runs):
+        print(f"  运行 {i + 1}/{num_runs}")
+        start = time.time()
+        torch.cuda.synchronize()
+
+        _ = pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            height=384,
+            width=640,
+            num_frames=45,
+            guidance_scale=5.0,
+            num_inference_steps=50,
+            generator=torch.Generator(device="cuda").manual_seed(42),
+        ).frames[0]
+
+        torch.cuda.synchronize()
+        elapsed = time.time() - start
+        times.append(elapsed)
+        print(f"    耗时: {elapsed:.2f}秒")
+        torch.cuda.empty_cache()
+
+    return times
+
+
+def main():
+    # 创建日志文件
+    # timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    log_filename = "benchmark_compile_results.txt"
+
+    # 创建双输出日志器
+    logger = DualLogger(log_filename)
+    original_stdout = sys.stdout
+    sys.stdout = logger
+
+    try:
+        # 打印测试信息
+        print("=" * 80)
+        print("PyTorch Compile 模式基准测试")
+        print(f"测试时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"PyTorch 版本: {torch.__version__}")
+        print(f"CUDA 版本: {torch.version.cuda}")
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print("=" * 80)
+
+        model_id = "Wan-AI/Wan2.1-T2V-1.3B-Diffusers"
+
+        prompt = "A stylish woman walks down a Tokyo street filled with warm glowing neon and animated city signage. She wears a black leather jacket, a long red dress, and black boots, and carries a black purse. She wears sunglasses and red lipstick. She walks confidently and casually. The street is damp and reflective, creating a mirror effect of the colorful lights. Many pedestrians walk about."
+        negative_prompt = "Bright tones, overexposed, static, blurred details, subtitles, style, works, paintings, images, static, overall gray, worst quality, low quality, JPEG compression residue, ugly, incomplete, extra fingers, poorly drawn hands, poorly drawn faces, deformed, disfigured, misshapen limbs, fused fingers, still picture, messy background, three legs, many people in the background, walking backwards"
+
+        # 定义不同的compile配置
+        compile_configs = [
+            {"name": "No Compile (Baseline)", "kwargs": None},
+            {"name": "Default Compile", "kwargs": {}},
+            {"name": "Fullgraph Only", "kwargs": {"fullgraph": True}},
+            {
+                "name": "Max-Autotune-No-Cudagraphs + Dynamic",
+                "kwargs": {"mode": "max-autotune-no-cudagraphs", "dynamic": True},
+            },
+            {"name": "Max-Autotune + Fullgraph", "kwargs": {"mode": "max-autotune", "fullgraph": True}},
+            {"name": "Max-Autotune", "kwargs": {"mode": "max-autotune"}},
+            {"name": "Reduce-Overhead", "kwargs": {"mode": "reduce-overhead"}},
+            {"name": "Default Mode", "kwargs": {"mode": "default"}},
+        ]
+
+        results = {}
+
+        # 测试每个配置
+        for config in compile_configs:
+            try:
+                # 清理GPU内存
+                torch.cuda.empty_cache()
+
+                # 设置pipeline
+                if config["kwargs"] is None:
+                    pipe = setup_pipeline(model_id, None)
+                else:
+                    pipe = setup_pipeline(model_id, config)
+
+                # 运行基准测试
+                times = run_benchmark(pipe, prompt, negative_prompt, num_runs=3, warmup=1)
+                results[config["name"]] = times
+
+                # 删除pipeline释放内存
+                del pipe
+                torch.cuda.empty_cache()
+
+            except Exception as e:
+                print(f"\n❌ 配置 '{config['name']}' 失败: {str(e)}")
+                results[config["name"]] = None
+
+        # 打印结果摘要
+        print("\n" + "=" * 80)
+        print("基准测试结果摘要")
+        print("=" * 80)
+        print(f"{'配置':<45} {'平均时间(秒)':<15} {'最小时间(秒)':<15} {'最大时间(秒)':<15}")
+        print("-" * 80)
+
+        sorted_results = []
+        for name, times in results.items():
+            if times:
+                avg_time = sum(times) / len(times)
+                min_time = min(times)
+                max_time = max(times)
+                sorted_results.append((name, avg_time, min_time, max_time, times))
+                print(f"{name:<45} {avg_time:<15.2f} {min_time:<15.2f} {max_time:<15.2f}")
+            else:
+                print(f"{name:<45} {'FAILED':<15} {'FAILED':<15} {'FAILED':<15}")
+
+        # 按平均时间排序
+        if sorted_results:
+            sorted_results.sort(key=lambda x: x[1])
+            print("\n" + "=" * 80)
+            print("速度排名 (从快到慢)")
+            print("=" * 80)
+            baseline_time = sorted_results[-1][1]
+            for rank, (name, avg_time, min_time, max_time, times) in enumerate(sorted_results, 1):
+                speedup = baseline_time / avg_time if avg_time > 0 else 0
+                print(f"\n{rank}. {name}")
+                print(f"   平均时间: {avg_time:.2f}秒")
+                print(f"   相对最慢提速: {speedup:.2f}x")
+                print(f"   详细时间: {[f'{t:.2f}s' for t in times]}")
+
+        print("\n" + "=" * 80)
+        print(f"测试完成! 结果已保存到: {log_filename}")
+        print("=" * 80)
+
+    except Exception as e:
+        print(f"\n❌ 测试过程出错: {str(e)}")
+        import traceback
+
+        traceback.print_exc()
+
+    finally:
+        # 恢复标准输出并关闭文件
+        sys.stdout = original_stdout
+        logger.close()
+        print(f"\n✅ 测试完成! 结果已保存到: {log_filename}")
+
+
+if __name__ == "__main__":
+    main()

Helios-main/tools/others/benchmark/benchmark_compile_results.txt

@@ -0,0 +1,269 @@
+================================================================================
+PyTorch Compile 模式基准测试
+测试时间: 2026-01-25 16:09:44
+PyTorch 版本: 2.7.1+cu126
+CUDA 版本: 12.6
+GPU: NVIDIA H100 80GB HBM3
+================================================================================
+
+============================================================
+设置 Pipeline: No Compile
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 17.15秒
+  运行 2/3
+    耗时: 17.14秒
+  运行 3/3
+    耗时: 17.19秒
+
+============================================================
+设置 Pipeline: Default Compile
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.80秒
+  运行 2/3
+    耗时: 12.79秒
+  运行 3/3
+    耗时: 12.79秒
+
+============================================================
+设置 Pipeline: Fullgraph Only
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'fullgraph': True}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.79秒
+  运行 2/3
+    耗时: 12.80秒
+  运行 3/3
+    耗时: 12.80秒
+
+============================================================
+设置 Pipeline: Max-Autotune-No-Cudagraphs + Dynamic
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'max-autotune-no-cudagraphs', 'dynamic': True}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.61秒
+  运行 2/3
+    耗时: 12.63秒
+  运行 3/3
+    耗时: 12.63秒
+
+============================================================
+设置 Pipeline: Max-Autotune + Fullgraph
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'max-autotune', 'fullgraph': True}
+
+预热运行 1 次...
+  预热 1/1
+
+❌ 配置 'Max-Autotune + Fullgraph' 失败: Skip calling `torch.compiler.disable()`d function
+  Explanation: Skip calling function `<function flash_rms_layernorm at 0x7fe108a128e0>` since it was wrapped with `torch.compiler.disable`
+  Hint: Remove the `torch.compiler.disable` call
+
+  Developer debug context: <function flash_rms_layernorm at 0x7fe108a128e0>
+
+
+from user code:
+   File "transformer_helios.py", line 999, in forward
+    attn_output = self.attn1(
+  File "transformer_helios.py", line 737, in forward
+    return self.processor(
+  File "transformer_helios.py", line 360, in __call__
+    query = attn.norm_q(query)
+  File "/usr/local/lib/python3.11/dist-packages/torch/nn/modules/module.py", line 1762, in _call_impl
+    return forward_call(*args, **kwargs)
+  File "kernels/triton_norm.py", line 29, in <lambda>
+    module.forward = (lambda self, x: flash_rms_layernorm(self, x)).__get__(module, module.__class__)
+
+Set TORCHDYNAMO_VERBOSE=1 for the internal stack trace (please do this especially if you're reporting a bug to PyTorch). For even more developer context, set TORCH_LOGS="+dynamo"
+
+
+============================================================
+设置 Pipeline: Max-Autotune
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'max-autotune'}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 13.02秒
+  运行 2/3
+    耗时: 13.02秒
+  运行 3/3
+    耗时: 13.03秒
+
+============================================================
+设置 Pipeline: Reduce-Overhead
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'reduce-overhead'}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 13.24秒
+  运行 2/3
+    耗时: 13.24秒
+  运行 3/3
+    耗时: 13.26秒
+
+============================================================
+设置 Pipeline: Default Mode
+============================================================
+Patched 120 FP32_RMSNorm modules
+
+Patched 30 Flash_LayerNorm modules
+
+Patched 120 Flash_RMSNorm modules
+
+Patched Flash_RoPE globally
+
+应用编译配置: {'mode': 'default'}
+
+预热运行 1 次...
+  预热 1/1
+
+开始基准测试 3 次...
+  运行 1/3
+    耗时: 12.74秒
+  运行 2/3
+    耗时: 12.68秒
+  运行 3/3
+    耗时: 12.75秒
+
+================================================================================
+基准测试结果摘要
+================================================================================
+配置                                            平均时间(秒)         最小时间(秒)         最大时间(秒)        
+--------------------------------------------------------------------------------
+No Compile (Baseline)                         17.16           17.14           17.19          
+Default Compile                               12.79           12.79           12.80          
+Fullgraph Only                                12.80           12.79           12.80          
+Max-Autotune-No-Cudagraphs + Dynamic          12.62           12.61           12.63          
+Max-Autotune + Fullgraph                      FAILED          FAILED          FAILED         
+Max-Autotune                                  13.02           13.02           13.03          
+Reduce-Overhead                               13.25           13.24           13.26          
+Default Mode                                  12.72           12.68           12.75          
+
+================================================================================
+速度排名 (从快到慢)
+================================================================================
+
+1. Max-Autotune-No-Cudagraphs + Dynamic
+   平均时间: 12.62秒
+   相对最慢提速: 1.36x
+   详细时间: ['12.61s', '12.63s', '12.63s']
+
+2. Default Mode
+   平均时间: 12.72秒
+   相对最慢提速: 1.35x
+   详细时间: ['12.74s', '12.68s', '12.75s']
+
+3. Default Compile
+   平均时间: 12.79秒
+   相对最慢提速: 1.34x
+   详细时间: ['12.80s', '12.79s', '12.79s']
+
+4. Fullgraph Only
+   平均时间: 12.80秒
+   相对最慢提速: 1.34x
+   详细时间: ['12.79s', '12.80s', '12.80s']
+
+5. Max-Autotune
+   平均时间: 13.02秒
+   相对最慢提速: 1.32x
+   详细时间: ['13.02s', '13.02s', '13.03s']
+
+6. Reduce-Overhead
+   平均时间: 13.25秒
+   相对最慢提速: 1.30x
+   详细时间: ['13.24s', '13.24s', '13.26s']
+
+7. No Compile (Baseline)
+   平均时间: 17.16秒
+   相对最慢提速: 1.00x
+   详细时间: ['17.15s', '17.14s', '17.19s']
+
+================================================================================
+测试完成! 结果已保存到: compile_benchmark_results_20260125_160944.txt
+================================================================================

Helios-main/tools/others/benchmark/benchmark_patchification_performance.py

@@ -0,0 +1,381 @@
+import os
+
+
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+import json
+import time
+from datetime import datetime
+
+import torch
+
+from diffusers import WanTransformer3DModel
+
+
+# 加载transformer
+model_id = "Wan-AI/Wan2.1-T2V-14B-Diffusers"
+transformer = WanTransformer3DModel.from_pretrained(model_id, subfolder="transformer", torch_dtype=torch.bfloat16)
+transformer.enable_gradient_checkpointing()
+transformer.set_attention_backend("_flash_3_hub")
+transformer.to("cuda")
+
+noise_per_token = 960
+noise_total_token = noise_per_token * 9
+
+his_tokens = [960, 1920, 3840, 5760, 7680, 9600, 11520, 13440, 15360, 17280]
+his_tokens_naive = [960, 1920, 2160, 2190, 2220, 2250, 2280, 2310, 2340, 2370]
+
+benchmark_results = {
+    "timestamp": datetime.now().isoformat(),
+    "noise_total_token": noise_total_token,
+    "experiments": [],
+}
+
+
+def create_dummy_inputs(transformer, num_frames, height=384, width=640, requires_grad=False):
+    """创建transformer的dummy输入"""
+    batch_size = 1
+    device = transformer.device
+    dtype = transformer.dtype
+
+    # hidden_states: [B, C, F, H, W]
+    in_channels = transformer.config.in_channels
+    latent_h = height // 8
+    latent_w = width // 8
+    latent_f = num_frames
+
+    hidden_states = torch.randn(
+        batch_size, in_channels, latent_f, latent_h, latent_w, device=device, dtype=dtype, requires_grad=requires_grad
+    )
+
+    # timestep
+    timestep = torch.tensor([999], device=device, dtype=torch.long)
+    timestep = timestep.expand(batch_size)
+
+    # encoder_hidden_states
+    seq_len = 512
+    hidden_dim = 4096
+    encoder_hidden_states = torch.randn(batch_size, seq_len, hidden_dim, device=device, dtype=dtype)
+
+    return hidden_states, timestep, encoder_hidden_states
+
+
+def measure_inference_speed(transformer, hidden_states, timestep, encoder_hidden_states, num_runs=10):
+    """测量推理速度(单步)"""
+    try:
+        # 预热
+        for _ in range(3):
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=True,
+                )
+        torch.cuda.synchronize()
+
+        # 正式测速
+        times = []
+        for _ in range(num_runs):
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=True,
+                )
+
+            torch.cuda.synchronize()
+            end_time = time.time()
+            times.append(end_time - start_time)
+
+        return {
+            "avg_time_s": round(sum(times) / len(times), 4),
+            "min_time_s": round(min(times), 4),
+            "max_time_s": round(max(times), 4),
+            "std_time_s": round(torch.std(torch.tensor(times)).item(), 4),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量推理显存"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        # Forward (推理模式)
+        torch.cuda.reset_peak_memory_stats()
+        with torch.no_grad():
+            _ = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=True,
+                attention_kwargs=None,
+            )
+        torch.cuda.synchronize()
+
+        inference_peak = torch.cuda.max_memory_allocated() / 1024**3
+        inference_mem_diff = inference_peak - mem_before
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "inference_peak_gb": round(inference_peak, 3),
+            "inference_mem_diff_gb": round(inference_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量训练显存(包含backward)"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        # Forward + Backward (训练模式)
+        torch.cuda.reset_peak_memory_stats()
+
+        # Forward
+        output = transformer(
+            hidden_states=hidden_states,
+            timestep=timestep,
+            encoder_hidden_states=encoder_hidden_states,
+            return_dict=True,
+            attention_kwargs=None,
+        )
+
+        # 创建一个简单的loss并backward
+        loss = output.sample.sum()
+        loss.backward()
+
+        torch.cuda.synchronize()
+
+        training_peak = torch.cuda.max_memory_allocated() / 1024**3
+        training_mem_diff = training_peak - mem_before
+
+        # 清理梯度
+        transformer.zero_grad(set_to_none=True)
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "training_peak_gb": round(training_peak, 3),
+            "training_mem_diff_gb": round(training_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            transformer.zero_grad(set_to_none=True)
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def warmup(transformer, num_runs=3):
+    """预热"""
+    print("🔥 Warming up...")
+    for i in range(num_runs):
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(transformer, num_frames=5)
+        with torch.no_grad():
+            _ = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=True,
+            )
+        print(f"  Warmup {i + 1}/{num_runs} done")
+    torch.cuda.empty_cache()
+    print("✅ Warmup completed\n")
+
+
+def run_experiment(his_tokens_list, experiment_name):
+    """运行完整实验"""
+    results = []
+
+    for his_token in his_tokens_list:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+
+        total_token = his_token + noise_total_token
+        num_frames = round((total_token / noise_per_token - 1) * 4 + 1)
+
+        print(f"\n{'=' * 60}")
+        print(f"{experiment_name} | tokens: {his_token} | frames: {int(num_frames)}")
+        print(f"{'=' * 60}")
+
+        result = {
+            "his_token": his_token,
+            "total_token": total_token,
+            "num_frames": int(num_frames),
+        }
+
+        # 1. 测推理速度 (不需要梯度)
+        print("📊 Measuring inference speed...")
+        try:
+            hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+                transformer, num_frames, requires_grad=False
+            )
+            speed_stats = measure_inference_speed(transformer, hidden_states, timestep, encoder_hidden_states)
+
+            if speed_stats["status"] == "OOM":
+                print("   ❌ OOM - Skipping remaining tests for this config")
+                result.update({"speed_status": "OOM", "inference_status": "SKIPPED", "training_status": "SKIPPED"})
+                results.append(result)
+                del hidden_states, timestep, encoder_hidden_states
+                torch.cuda.empty_cache()
+                continue
+            else:
+                print(
+                    f"   Avg: {speed_stats['avg_time_s']:.4f}s | "
+                    f"Min: {speed_stats['min_time_s']:.4f}s | "
+                    f"Max: {speed_stats['max_time_s']:.4f}s"
+                )
+                result.update(speed_stats)
+
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+            result["speed_status"] = "ERROR"
+            torch.cuda.empty_cache()
+
+        # 2. 测推理显存 (不需要梯度)
+        print("💾 Measuring inference memory...")
+        try:
+            hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+                transformer, num_frames, requires_grad=False
+            )
+            inference_mem_stats = measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+            if inference_mem_stats["status"] == "OOM":
+                print("   ❌ OOM - Skipping training test")
+                result.update(inference_mem_stats)
+                result["training_status"] = "SKIPPED"
+                results.append(result)
+                del hidden_states, timestep, encoder_hidden_states
+                torch.cuda.empty_cache()
+                continue
+            else:
+                print(
+                    f"   Peak: {inference_mem_stats['inference_peak_gb']:.3f} GB | "
+                    f"Diff: {inference_mem_stats['inference_mem_diff_gb']:.3f} GB"
+                )
+                result.update(inference_mem_stats)
+
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+            result["inference_status"] = "ERROR"
+            torch.cuda.empty_cache()
+
+        # 3. 测训练显存 (需要梯度)
+        print("🔥 Measuring training memory...")
+        try:
+            hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+                transformer, num_frames, requires_grad=True
+            )
+            training_mem_stats = measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+            if training_mem_stats["status"] == "OOM":
+                print("   ❌ OOM")
+                result.update(training_mem_stats)
+            else:
+                print(
+                    f"   Peak: {training_mem_stats['training_peak_gb']:.3f} GB | "
+                    f"Diff: {training_mem_stats['training_mem_diff_gb']:.3f} GB"
+                )
+                result.update(training_mem_stats)
+
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"   ❌ Error: {e}")
+            result["training_status"] = "ERROR"
+            torch.cuda.empty_cache()
+
+        results.append(result)
+
+    return results
+
+
+# 运行实验
+warmup(transformer)
+
+print("\n" + "=" * 80)
+print("STANDARD EXPERIMENT")
+print("=" * 80)
+results_standard = run_experiment(his_tokens, "Standard")
+
+print("\n" + "=" * 80)
+print("NAIVE EXPERIMENT")
+print("=" * 80)
+results_naive = run_experiment(his_tokens_naive, "Naive")
+
+# 保存结果
+benchmark_results["experiments"] = [
+    {"name": "standard", "results": results_standard},
+    {"name": "naive", "results": results_naive},
+]
+
+output_file = "benchmark_patchification_results.json"
+with open(output_file, "w") as f:
+    json.dump(benchmark_results, f, indent=2)
+
+print("\n" + "=" * 80)
+print(f"✅ Results saved to {output_file}")
+print("=" * 80)
+
+# 打印汇总表格
+print("\n" + "=" * 80)
+print("BENCHMARK SUMMARY")
+print("=" * 80)
+
+for exp in benchmark_results["experiments"]:
+    print(f"\n=== {exp['name'].upper()} ===")
+    print(f"{'Tokens':>6} {'Frames':>6} {'Speed(s)':>10} {'Infer(GB)':>11} {'Train(GB)':>11} {'Status':>10}")
+    print("-" * 72)
+    for r in exp["results"]:
+        speed_str = f"{r.get('avg_time_s', 0):.4f}s" if r.get("status") == "success" else "N/A"
+        infer_str = f"{r.get('inference_mem_diff_gb', 0):.3f}" if r.get("inference_peak_gb") else "N/A"
+        train_str = f"{r.get('training_mem_diff_gb', 0):.3f}" if r.get("training_peak_gb") else "N/A"
+
+        # 判断整体状态
+        if r.get("speed_status") == "OOM":
+            status = "OOM"
+        elif r.get("training_status") == "OOM":
+            status = "OOM(train)"
+        elif r.get("status") == "success":
+            status = "OK"
+        else:
+            status = "PARTIAL"
+
+        print(f"{r['his_token']:6d} {r['num_frames']:6d} {speed_str:>10} {infer_str:>11} {train_str:>11} {status:>10}")
+
+print("\n" + "=" * 80)
+print("Legend:")
+print("  Speed(s)   - Average inference time per step")
+print("  Infer(GB)  - Memory usage during inference (forward only)")
+print("  Train(GB)  - Memory usage during training (forward + backward)")
+print("  Status     - OK/OOM/OOM(train)/PARTIAL")
+print("=" * 80)

Helios-main/tools/others/benchmark/benchmark_patchification_results.json

@@ -0,0 +1,309 @@
+{
+  "timestamp": "2026-02-06T05:34:36.528673",
+  "noise_total_token": 8640,
+  "experiments": [
+    {
+      "name": "standard",
+      "results": [
+        {
+          "his_token": 960,
+          "total_token": 9600,
+          "num_frames": 37,
+          "avg_time_s": 4.1635,
+          "min_time_s": 4.1583,
+          "max_time_s": 4.1741,
+          "std_time_s": 0.0041,
+          "status": "success",
+          "mem_before_gb": 26.787,
+          "inference_peak_gb": 30.565,
+          "inference_mem_diff_gb": 3.778,
+          "training_peak_gb": 68.509,
+          "training_mem_diff_gb": 41.722
+        },
+        {
+          "his_token": 1920,
+          "total_token": 10560,
+          "num_frames": 41,
+          "avg_time_s": 4.7998,
+          "min_time_s": 4.798,
+          "max_time_s": 4.8031,
+          "std_time_s": 0.0013,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.001,
+          "inference_mem_diff_gb": 4.182,
+          "training_peak_gb": 70.252,
+          "training_mem_diff_gb": 43.433
+        },
+        {
+          "his_token": 3840,
+          "total_token": 12480,
+          "num_frames": 49,
+          "avg_time_s": 6.1835,
+          "min_time_s": 6.1744,
+          "max_time_s": 6.1921,
+          "std_time_s": 0.0049,
+          "status": "success",
+          "mem_before_gb": 26.82,
+          "inference_peak_gb": 31.815,
+          "inference_mem_diff_gb": 4.995,
+          "training_peak_gb": 73.733,
+          "training_mem_diff_gb": 46.913
+        },
+        {
+          "his_token": 5760,
+          "total_token": 14400,
+          "num_frames": 57,
+          "avg_time_s": 7.7019,
+          "min_time_s": 7.6963,
+          "max_time_s": 7.7083,
+          "std_time_s": 0.0039,
+          "status": "OOM",
+          "mem_before_gb": 26.821,
+          "inference_peak_gb": 32.628,
+          "inference_mem_diff_gb": 5.808,
+          "error": "CUDA out of memory. Tried to allocate 1.04 GiB. GPU 0 has a total capacity of 79.11 GiB of which 196.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 75.12 GiB is allocated by PyTorch, and 3.04 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 7680,
+          "total_token": 16320,
+          "num_frames": 65,
+          "avg_time_s": 9.3743,
+          "min_time_s": 9.3587,
+          "max_time_s": 9.3922,
+          "std_time_s": 0.0092,
+          "status": "OOM",
+          "mem_before_gb": 26.822,
+          "inference_peak_gb": 33.442,
+          "inference_mem_diff_gb": 6.621,
+          "error": "CUDA out of memory. Tried to allocate 1.19 GiB. GPU 0 has a total capacity of 79.11 GiB of which 108.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 77.18 GiB is allocated by PyTorch, and 1.07 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 9600,
+          "total_token": 18240,
+          "num_frames": 73,
+          "avg_time_s": 11.2228,
+          "min_time_s": 11.2066,
+          "max_time_s": 11.2309,
+          "std_time_s": 0.0076,
+          "status": "OOM",
+          "mem_before_gb": 26.823,
+          "inference_peak_gb": 34.256,
+          "inference_mem_diff_gb": 7.434,
+          "error": "CUDA out of memory. Tried to allocate 1.34 GiB. GPU 0 has a total capacity of 79.11 GiB of which 868.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 75.75 GiB is allocated by PyTorch, and 1.76 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 11520,
+          "total_token": 20160,
+          "num_frames": 81,
+          "avg_time_s": 13.2451,
+          "min_time_s": 13.2332,
+          "max_time_s": 13.251,
+          "std_time_s": 0.0055,
+          "status": "OOM",
+          "mem_before_gb": 26.824,
+          "inference_peak_gb": 35.071,
+          "inference_mem_diff_gb": 8.248,
+          "error": "CUDA out of memory. Tried to allocate 1.48 GiB. GPU 0 has a total capacity of 79.11 GiB of which 608.56 MiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 75.14 GiB is allocated by PyTorch, and 2.62 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 13440,
+          "total_token": 22080,
+          "num_frames": 89,
+          "avg_time_s": 15.2558,
+          "min_time_s": 15.24,
+          "max_time_s": 15.2622,
+          "std_time_s": 0.0081,
+          "status": "OOM",
+          "mem_before_gb": 26.825,
+          "inference_peak_gb": 35.885,
+          "inference_mem_diff_gb": 9.06,
+          "error": "CUDA out of memory. Tried to allocate 1.63 GiB. GPU 0 has a total capacity of 79.11 GiB of which 1.36 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 74.19 GiB is allocated by PyTorch, and 2.80 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 15360,
+          "total_token": 24000,
+          "num_frames": 97,
+          "avg_time_s": 17.5647,
+          "min_time_s": 17.5502,
+          "max_time_s": 17.5807,
+          "std_time_s": 0.0095,
+          "status": "OOM",
+          "mem_before_gb": 26.825,
+          "inference_peak_gb": 36.699,
+          "inference_mem_diff_gb": 9.873,
+          "error": "CUDA out of memory. Tried to allocate 1.78 GiB. GPU 0 has a total capacity of 79.11 GiB of which 1.39 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 74.90 GiB is allocated by PyTorch, and 2.07 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        },
+        {
+          "his_token": 17280,
+          "total_token": 25920,
+          "num_frames": 105,
+          "avg_time_s": 20.0106,
+          "min_time_s": 19.9988,
+          "max_time_s": 20.0365,
+          "std_time_s": 0.012,
+          "status": "OOM",
+          "mem_before_gb": 26.826,
+          "inference_peak_gb": 37.512,
+          "inference_mem_diff_gb": 10.686,
+          "error": "CUDA out of memory. Tried to allocate 1.92 GiB. GPU 0 has a total capacity of 79.11 GiB of which 1.18 GiB is free. Including non-PyTorch memory, this process has 0 bytes memory in use. Of the allocated memory 70.20 GiB is allocated by PyTorch, and 6.99 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True to avoid fragmentation.  See documentation for Memory Management  (https://pytorch.org/docs/stable/notes/cuda.html#environment-variables)"
+        }
+      ]
+    },
+    {
+      "name": "naive",
+      "results": [
+        {
+          "his_token": 960,
+          "total_token": 9600,
+          "num_frames": 37,
+          "avg_time_s": 4.1671,
+          "min_time_s": 4.1616,
+          "max_time_s": 4.171,
+          "std_time_s": 0.0032,
+          "status": "success",
+          "mem_before_gb": 26.818,
+          "inference_peak_gb": 30.595,
+          "inference_mem_diff_gb": 3.777,
+          "training_peak_gb": 68.509,
+          "training_mem_diff_gb": 41.69
+        },
+        {
+          "his_token": 1920,
+          "total_token": 10560,
+          "num_frames": 41,
+          "avg_time_s": 4.8,
+          "min_time_s": 4.7986,
+          "max_time_s": 4.8014,
+          "std_time_s": 0.0009,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.001,
+          "inference_mem_diff_gb": 4.182,
+          "training_peak_gb": 70.252,
+          "training_mem_diff_gb": 43.433
+        },
+        {
+          "his_token": 2160,
+          "total_token": 10800,
+          "num_frames": 42,
+          "avg_time_s": 4.9164,
+          "min_time_s": 4.9075,
+          "max_time_s": 4.9335,
+          "std_time_s": 0.0082,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2190,
+          "total_token": 10830,
+          "num_frames": 42,
+          "avg_time_s": 4.9196,
+          "min_time_s": 4.9037,
+          "max_time_s": 4.9359,
+          "std_time_s": 0.0105,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2220,
+          "total_token": 10860,
+          "num_frames": 42,
+          "avg_time_s": 4.9201,
+          "min_time_s": 4.9098,
+          "max_time_s": 4.9369,
+          "std_time_s": 0.0086,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2250,
+          "total_token": 10890,
+          "num_frames": 42,
+          "avg_time_s": 4.9168,
+          "min_time_s": 4.9079,
+          "max_time_s": 4.9294,
+          "std_time_s": 0.0073,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2280,
+          "total_token": 10920,
+          "num_frames": 42,
+          "avg_time_s": 4.9187,
+          "min_time_s": 4.9082,
+          "max_time_s": 4.9277,
+          "std_time_s": 0.0058,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.105,
+          "inference_mem_diff_gb": 4.286,
+          "training_peak_gb": 70.689,
+          "training_mem_diff_gb": 43.87
+        },
+        {
+          "his_token": 2310,
+          "total_token": 10950,
+          "num_frames": 43,
+          "avg_time_s": 5.1375,
+          "min_time_s": 5.1308,
+          "max_time_s": 5.1426,
+          "std_time_s": 0.0039,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.205,
+          "inference_mem_diff_gb": 4.386,
+          "training_peak_gb": 71.118,
+          "training_mem_diff_gb": 44.298
+        },
+        {
+          "his_token": 2340,
+          "total_token": 10980,
+          "num_frames": 43,
+          "avg_time_s": 5.1378,
+          "min_time_s": 5.1338,
+          "max_time_s": 5.1434,
+          "std_time_s": 0.0036,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.205,
+          "inference_mem_diff_gb": 4.386,
+          "training_peak_gb": 71.118,
+          "training_mem_diff_gb": 44.298
+        },
+        {
+          "his_token": 2370,
+          "total_token": 11010,
+          "num_frames": 43,
+          "avg_time_s": 5.1388,
+          "min_time_s": 5.1317,
+          "max_time_s": 5.1453,
+          "std_time_s": 0.0051,
+          "status": "success",
+          "mem_before_gb": 26.819,
+          "inference_peak_gb": 31.205,
+          "inference_mem_diff_gb": 4.386,
+          "training_peak_gb": 71.118,
+          "training_mem_diff_gb": 44.298
+        }
+      ]
+    }
+  ]
+}

Helios-main/tools/others/benchmark/benchmark_triton_performance.py

@@ -0,0 +1,659 @@
+import os
+
+
+os.environ["HF_ENABLE_PARALLEL_LOADING"] = "yes"
+os.environ["DIFFUSERS_ENABLE_HUB_KERNELS"] = "yes"
+
+import json
+import time
+from datetime import datetime
+
+import torch
+from helios.modules.kernels import (
+    replace_all_norms_with_flash_norms,
+    replace_linear_with_tiled_linear,
+    replace_rope_with_flash_rope,
+)
+from helios.modules.transformer_helios import HeliosTransformer3DModel
+
+from diffusers.training_utils import free_memory
+
+
+# ============================================================================
+# 配置参数
+# ============================================================================
+model_id = "Wan-AI/Wan2.1-T2V-14B-Diffusers"
+TEST_NUM_FRAMES = 21
+NUM_SPEED_RUNS = 10  # 速度测试的运行次数
+HEIGHT = 384
+WIDTH = 640
+
+benchmark_results = {
+    "timestamp": datetime.now().isoformat(),
+    "test_config": {"num_frames": TEST_NUM_FRAMES, "height": HEIGHT, "width": WIDTH, "num_speed_runs": NUM_SPEED_RUNS},
+    "experiments": [],
+}
+
+
+# ============================================================================
+# 辅助函数
+# ============================================================================
+def create_dummy_inputs(transformer, num_frames, height=384, width=640, requires_grad=False):
+    """创建transformer的dummy输入"""
+    batch_size = 1
+    device = transformer.device
+    dtype = transformer.dtype
+
+    in_channels = transformer.config.in_channels
+    latent_h = height // 8
+    latent_w = width // 8
+    latent_f = num_frames
+
+    hidden_states = torch.randn(
+        batch_size, in_channels, latent_f, latent_h, latent_w, device=device, dtype=dtype, requires_grad=requires_grad
+    )
+
+    timestep = torch.tensor([999], device=device, dtype=torch.long)
+    timestep = timestep.expand(batch_size)
+
+    seq_len = 512
+    hidden_dim = 4096
+    encoder_hidden_states = torch.randn(batch_size, seq_len, hidden_dim, device=device, dtype=dtype)
+
+    return hidden_states, timestep, encoder_hidden_states
+
+
+def measure_inference_speed(transformer, hidden_states, timestep, encoder_hidden_states, num_runs=10):
+    """测量推理速度"""
+    try:
+        # 预热
+        for _ in range(3):
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=False,
+                )[0]
+        torch.cuda.synchronize()
+
+        # 正式测速
+        times = []
+        for _ in range(num_runs):
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            with torch.no_grad():
+                _ = transformer(
+                    hidden_states=hidden_states,
+                    timestep=timestep,
+                    encoder_hidden_states=encoder_hidden_states,
+                    return_dict=False,
+                )[0]
+
+            torch.cuda.synchronize()
+            end_time = time.time()
+            times.append(end_time - start_time)
+
+        return {
+            "avg_time_s": round(sum(times) / len(times), 4),
+            "min_time_s": round(min(times), 4),
+            "max_time_s": round(max(times), 4),
+            "std_time_s": round(torch.std(torch.tensor(times)).item(), 4),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量推理显存"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        free_memory()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        torch.cuda.reset_peak_memory_stats()
+        with torch.no_grad():
+            _ = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=False,
+                attention_kwargs=None,
+            )[0]
+        torch.cuda.synchronize()
+
+        inference_peak = torch.cuda.max_memory_allocated() / 1024**3
+        inference_mem_diff = inference_peak - mem_before
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "inference_peak_gb": round(inference_peak, 3),
+            "inference_mem_diff_gb": round(inference_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_training_speed(transformer, hidden_states, timestep, encoder_hidden_states, num_runs=10):
+    """测量训练速度(forward + backward)"""
+    try:
+        # 预热
+        for _ in range(3):
+            output = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=False,
+            )[0]
+            loss = output.sum()
+            loss.backward()
+            transformer.zero_grad(set_to_none=True)
+        torch.cuda.synchronize()
+
+        # 正式测速
+        times = []
+        for _ in range(num_runs):
+            torch.cuda.synchronize()
+            start_time = time.time()
+
+            output = transformer(
+                hidden_states=hidden_states,
+                timestep=timestep,
+                encoder_hidden_states=encoder_hidden_states,
+                return_dict=False,
+            )[0]
+            loss = output.sum()
+            loss.backward()
+            transformer.zero_grad(set_to_none=True)
+
+            torch.cuda.synchronize()
+            end_time = time.time()
+            times.append(end_time - start_time)
+
+        return {
+            "avg_time_s": round(sum(times) / len(times), 4),
+            "min_time_s": round(min(times), 4),
+            "max_time_s": round(max(times), 4),
+            "std_time_s": round(torch.std(torch.tensor(times)).item(), 4),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            transformer.zero_grad(set_to_none=True)
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states):
+    """测量训练显存(forward + backward)"""
+    try:
+        torch.cuda.reset_peak_memory_stats()
+        torch.cuda.empty_cache()
+        free_memory()
+        torch.cuda.synchronize()
+        mem_before = torch.cuda.memory_allocated() / 1024**3
+
+        torch.cuda.reset_peak_memory_stats()
+
+        output = transformer(
+            hidden_states=hidden_states,
+            timestep=timestep,
+            encoder_hidden_states=encoder_hidden_states,
+            return_dict=False,
+            attention_kwargs=None,
+        )[0]
+
+        loss = output.sum()
+        loss.backward()
+
+        torch.cuda.synchronize()
+
+        training_peak = torch.cuda.max_memory_allocated() / 1024**3
+        training_mem_diff = training_peak - mem_before
+
+        transformer.zero_grad(set_to_none=True)
+
+        return {
+            "mem_before_gb": round(mem_before, 3),
+            "training_peak_gb": round(training_peak, 3),
+            "training_mem_diff_gb": round(training_mem_diff, 3),
+            "status": "success",
+        }
+    except RuntimeError as e:
+        if "out of memory" in str(e).lower():
+            torch.cuda.empty_cache()
+            free_memory()
+            transformer.zero_grad(set_to_none=True)
+            return {"status": "OOM", "error": str(e)}
+        else:
+            raise
+
+
+def run_single_config(transformer, config_name, num_frames):
+    """运行单个配置的完整测试"""
+    print(f"\n{'=' * 70}")
+    print(f"Testing: {config_name}")
+    print(f"{'=' * 70}")
+
+    result = {"config": config_name, "num_frames": num_frames}
+
+    # 1. 测推理速度
+    print("📊 Measuring inference speed...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=False
+        )
+        speed_stats = measure_inference_speed(
+            transformer, hidden_states, timestep, encoder_hidden_states, NUM_SPEED_RUNS
+        )
+
+        if speed_stats["status"] == "OOM":
+            print("   ❌ OOM - Skipping remaining tests")
+            result.update(
+                {
+                    "inference_speed_status": "OOM",
+                    "inference_memory_status": "SKIPPED",
+                    "training_speed_status": "SKIPPED",
+                    "training_memory_status": "SKIPPED",
+                }
+            )
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+            free_memory()
+            return result
+        else:
+            print(
+                f"   ✓ Avg: {speed_stats['avg_time_s']:.4f}s | "
+                f"Min: {speed_stats['min_time_s']:.4f}s | "
+                f"Max: {speed_stats['max_time_s']:.4f}s"
+            )
+            result.update(
+                {
+                    "inference_speed_avg_s": speed_stats["avg_time_s"],
+                    "inference_speed_min_s": speed_stats["min_time_s"],
+                    "inference_speed_max_s": speed_stats["max_time_s"],
+                    "inference_speed_std_s": speed_stats["std_time_s"],
+                    "inference_speed_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["inference_speed_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    # 2. 测推理显存
+    print("💾 Measuring inference memory...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=False
+        )
+        mem_stats = measure_inference_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+        if mem_stats["status"] == "OOM":
+            print("   ❌ OOM - Skipping training tests")
+            result.update(
+                {
+                    "inference_memory_status": "OOM",
+                    "training_speed_status": "SKIPPED",
+                    "training_memory_status": "SKIPPED",
+                }
+            )
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+            free_memory()
+            return result
+        else:
+            print(
+                f"   ✓ Peak: {mem_stats['inference_peak_gb']:.3f} GB | "
+                f"Diff: {mem_stats['inference_mem_diff_gb']:.3f} GB"
+            )
+            result.update(
+                {
+                    "inference_memory_peak_gb": mem_stats["inference_peak_gb"],
+                    "inference_memory_diff_gb": mem_stats["inference_mem_diff_gb"],
+                    "inference_memory_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["inference_memory_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    # 3. 测训练速度
+    print("⚡ Measuring training speed...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=True
+        )
+        train_speed_stats = measure_training_speed(
+            transformer, hidden_states, timestep, encoder_hidden_states, NUM_SPEED_RUNS
+        )
+
+        if train_speed_stats["status"] == "OOM":
+            print("   ❌ OOM")
+            result.update({"training_speed_status": "OOM", "training_memory_status": "SKIPPED"})
+            del hidden_states, timestep, encoder_hidden_states
+            torch.cuda.empty_cache()
+            free_memory()
+            return result
+        else:
+            print(
+                f"   ✓ Avg: {train_speed_stats['avg_time_s']:.4f}s | "
+                f"Min: {train_speed_stats['min_time_s']:.4f}s | "
+                f"Max: {train_speed_stats['max_time_s']:.4f}s"
+            )
+            result.update(
+                {
+                    "training_speed_avg_s": train_speed_stats["avg_time_s"],
+                    "training_speed_min_s": train_speed_stats["min_time_s"],
+                    "training_speed_max_s": train_speed_stats["max_time_s"],
+                    "training_speed_std_s": train_speed_stats["std_time_s"],
+                    "training_speed_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["training_speed_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    # 4. 测训练显存
+    print("🔥 Measuring training memory...")
+    try:
+        hidden_states, timestep, encoder_hidden_states = create_dummy_inputs(
+            transformer, num_frames, HEIGHT, WIDTH, requires_grad=True
+        )
+        train_mem_stats = measure_training_memory(transformer, hidden_states, timestep, encoder_hidden_states)
+
+        if train_mem_stats["status"] == "OOM":
+            print("   ❌ OOM")
+            result["training_memory_status"] = "OOM"
+        else:
+            print(
+                f"   ✓ Peak: {train_mem_stats['training_peak_gb']:.3f} GB | "
+                f"Diff: {train_mem_stats['training_mem_diff_gb']:.3f} GB"
+            )
+            result.update(
+                {
+                    "training_memory_peak_gb": train_mem_stats["training_peak_gb"],
+                    "training_memory_diff_gb": train_mem_stats["training_mem_diff_gb"],
+                    "training_memory_status": "success",
+                }
+            )
+
+        del hidden_states, timestep, encoder_hidden_states
+        torch.cuda.empty_cache()
+        free_memory()
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+        result["training_memory_status"] = "ERROR"
+        torch.cuda.empty_cache()
+        free_memory()
+
+    return result
+
+
+# ============================================================================
+# 主测试流程
+# ============================================================================
+print("=" * 70)
+print("OPTIMIZATION BENCHMARK - SAME LENGTH COMPARISON")
+print("=" * 70)
+print(f"Model: {model_id}")
+print(f"Test frames: {TEST_NUM_FRAMES}")
+print(f"Resolution: {HEIGHT}x{WIDTH}")
+print(f"Speed test runs: {NUM_SPEED_RUNS}")
+print("=" * 70)
+
+# ============================================================================
+# 配置1: 原始模型
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 1/5: BASELINE (No optimizations)")
+print("=" * 70)
+
+transformer_baseline = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_baseline.enable_gradient_checkpointing()
+transformer_baseline.set_attention_backend("_flash_3_hub")
+transformer_baseline.to("cuda")
+
+result_baseline = run_single_config(transformer_baseline, "Baseline", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_baseline)
+
+del transformer_baseline
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置2: 只替换 TiledLinear
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 2/5: TiledLinear only")
+print("=" * 70)
+
+transformer_tiled = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_tiled.enable_gradient_checkpointing()
+transformer_tiled.set_attention_backend("_flash_3_hub")
+transformer_tiled = replace_linear_with_tiled_linear(transformer_tiled)
+transformer_tiled.to("cuda")
+
+result_tiled = run_single_config(transformer_tiled, "TiledLinear", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_tiled)
+
+transformer_tiled = None
+del transformer_tiled
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置3: 只替换 FlashNorm
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 3/5: FlashNorm only")
+print("=" * 70)
+
+transformer_flashnorm = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_flashnorm.enable_gradient_checkpointing()
+transformer_flashnorm.set_attention_backend("_flash_3_hub")
+transformer_flashnorm = replace_all_norms_with_flash_norms(transformer_flashnorm)
+transformer_flashnorm.to("cuda")
+
+result_flashnorm = run_single_config(transformer_flashnorm, "FlashNorm", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_flashnorm)
+
+transformer_flashnorm = None
+del transformer_flashnorm
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置4: 只替换 FlashRoPE
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 4/5: FlashRoPE only")
+print("=" * 70)
+
+transformer_flashrope = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_flashrope.enable_gradient_checkpointing()
+transformer_flashrope.set_attention_backend("_flash_3_hub")
+transformer_flashrope.to("cuda")
+
+# FlashRoPE 是全局替换,不可逆
+replace_rope_with_flash_rope()
+
+result_flashrope = run_single_config(transformer_flashrope, "FlashRoPE", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_flashrope)
+
+transformer_flashrope = None
+del transformer_flashrope
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 配置5: FlashNorm + FlashRoPE
+# ============================================================================
+print("\n" + "=" * 70)
+print("CONFIG 5/5: FlashNorm + FlashRoPE")
+print("=" * 70)
+
+transformer_combined = HeliosTransformer3DModel.from_pretrained(
+    model_id,
+    subfolder="transformer",
+    torch_dtype=torch.bfloat16,
+    use_default_loader=True,
+)
+transformer_combined.enable_gradient_checkpointing()
+transformer_combined.set_attention_backend("_flash_3_hub")
+transformer_combined = replace_all_norms_with_flash_norms(transformer_combined)
+transformer_combined.to("cuda")
+
+# FlashRoPE 已经在配置4中全局替换
+replace_rope_with_flash_rope()
+
+result_combined = run_single_config(transformer_combined, "FlashNorm+FlashRoPE", TEST_NUM_FRAMES)
+benchmark_results["experiments"].append(result_combined)
+
+transformer_combined = None
+del transformer_combined
+torch.cuda.empty_cache()
+free_memory()
+
+# ============================================================================
+# 保存结果
+# ============================================================================
+output_file = "benchmark_triton_results.json"
+with open(output_file, "w") as f:
+    json.dump(benchmark_results, f, indent=2)
+
+print("\n" + "=" * 70)
+print(f"✅ Results saved to {output_file}")
+print("=" * 70)
+
+# ============================================================================
+# 打印汇总表格
+# ============================================================================
+print("\n" + "=" * 70)
+print("BENCHMARK SUMMARY")
+print("=" * 70)
+
+# 表头
+print(f"\n{'Config':<20} {'InfSpeed(s)':>12} {'InfMem(GB)':>12} {'TrainSpeed(s)':>14} {'TrainMem(GB)':>13}")
+print("-" * 75)
+
+# 打印每个配置的结果
+for exp in benchmark_results["experiments"]:
+    config = exp["config"]
+
+    # 推理速度
+    inf_speed = (
+        f"{exp.get('inference_speed_avg_s', 0):.4f}" if exp.get("inference_speed_status") == "success" else "N/A"
+    )
+
+    # 推理显存
+    inf_mem = (
+        f"{exp.get('inference_memory_diff_gb', 0):.3f}" if exp.get("inference_memory_status") == "success" else "N/A"
+    )
+
+    # 训练速度
+    train_speed = (
+        f"{exp.get('training_speed_avg_s', 0):.4f}" if exp.get("training_speed_status") == "success" else "N/A"
+    )
+
+    # 训练显存
+    train_mem = (
+        f"{exp.get('training_memory_diff_gb', 0):.3f}" if exp.get("training_memory_status") == "success" else "N/A"
+    )
+
+    print(f"{config:<20} {inf_speed:>12} {inf_mem:>12} {train_speed:>14} {train_mem:>13}")
+
+# 计算加速比(如果baseline成功)
+baseline_result = benchmark_results["experiments"][0]
+if baseline_result.get("inference_speed_status") == "success":
+    baseline_inf_speed = baseline_result["inference_speed_avg_s"]
+    baseline_train_speed = baseline_result.get("training_speed_avg_s", None)
+
+    print("\n" + "=" * 70)
+    print("SPEEDUP vs BASELINE")
+    print("=" * 70)
+    print(f"{'Config':<20} {'InfSpeedup':>12} {'TrainSpeedup':>14}")
+    print("-" * 50)
+
+    for exp in benchmark_results["experiments"]:
+        config = exp["config"]
+
+        # 推理加速比
+        if exp.get("inference_speed_status") == "success":
+            speedup_inf = baseline_inf_speed / exp["inference_speed_avg_s"]
+            speedup_inf_str = f"{speedup_inf:.2f}x"
+        else:
+            speedup_inf_str = "N/A"
+
+        # 训练加速比
+        if exp.get("training_speed_status") == "success" and baseline_train_speed:
+            speedup_train = baseline_train_speed / exp["training_speed_avg_s"]
+            speedup_train_str = f"{speedup_train:.2f}x"
+        else:
+            speedup_train_str = "N/A"
+
+        print(f"{config:<20} {speedup_inf_str:>12} {speedup_train_str:>14}")
+
+print("\n" + "=" * 70)
+print("Legend:")
+print("  InfSpeed   - Inference time (forward only)")
+print("  InfMem     - Inference memory usage")
+print("  TrainSpeed - Training time (forward + backward)")
+print("  TrainMem   - Training memory usage")
+print("  Speedup    - Relative to baseline (higher is better)")
+print("=" * 70)

Helios-main/tools/others/benchmark/benchmark_triton_results_helios.json

@@ -0,0 +1,111 @@
+{
+  "timestamp": "2026-02-06T09:14:11.892609",
+  "test_config": {
+    "num_frames": 13,
+    "height": 384,
+    "width": 640,
+    "num_speed_runs": 10
+  },
+  "experiments": [
+    {
+      "config": "Baseline",
+      "num_frames": 13,
+      "inference_speed_avg_s": 1.083,
+      "inference_speed_min_s": 1.0801,
+      "inference_speed_max_s": 1.088,
+      "inference_speed_std_s": 0.0027,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.777,
+      "inference_memory_diff_gb": 2.993,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 4.302,
+      "training_speed_min_s": 4.2982,
+      "training_speed_max_s": 4.3088,
+      "training_speed_std_s": 0.0031,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 60.792,
+      "training_memory_diff_gb": 33.978,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "TiledLinear",
+      "num_frames": 13,
+      "inference_speed_avg_s": 1.1279,
+      "inference_speed_min_s": 1.1222,
+      "inference_speed_max_s": 1.1307,
+      "inference_speed_std_s": 0.0024,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.807,
+      "inference_memory_diff_gb": 2.992,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 4.8691,
+      "training_speed_min_s": 4.8631,
+      "training_speed_max_s": 4.8769,
+      "training_speed_std_s": 0.0035,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 60.867,
+      "training_memory_diff_gb": 34.052,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashNorm",
+      "num_frames": 13,
+      "inference_speed_avg_s": 0.9742,
+      "inference_speed_min_s": 0.9724,
+      "inference_speed_max_s": 0.9762,
+      "inference_speed_std_s": 0.0011,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.777,
+      "inference_memory_diff_gb": 2.993,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 3.8406,
+      "training_speed_min_s": 3.8371,
+      "training_speed_max_s": 3.8455,
+      "training_speed_std_s": 0.0025,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 59.703,
+      "training_memory_diff_gb": 32.888,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashRoPE",
+      "num_frames": 13,
+      "inference_speed_avg_s": 1.0208,
+      "inference_speed_min_s": 1.0183,
+      "inference_speed_max_s": 1.0252,
+      "inference_speed_std_s": 0.0021,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.807,
+      "inference_memory_diff_gb": 2.992,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 4.0924,
+      "training_speed_min_s": 4.0881,
+      "training_speed_max_s": 4.099,
+      "training_speed_std_s": 0.0044,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 60.817,
+      "training_memory_diff_gb": 34.002,
+      "training_memory_status": "success"
+    },
+    {
+      "config": "FlashNorm+FlashRoPE",
+      "num_frames": 13,
+      "inference_speed_avg_s": 0.9093,
+      "inference_speed_min_s": 0.9073,
+      "inference_speed_max_s": 0.9115,
+      "inference_speed_std_s": 0.0016,
+      "inference_speed_status": "success",
+      "inference_memory_peak_gb": 29.807,
+      "inference_memory_diff_gb": 2.992,
+      "inference_memory_status": "success",
+      "training_speed_avg_s": 3.5968,
+      "training_speed_min_s": 3.5889,
+      "training_speed_max_s": 3.6009,
+      "training_speed_std_s": 0.004,
+      "training_speed_status": "success",
+      "training_memory_peak_gb": 59.728,
+      "training_memory_diff_gb": 32.913,
+      "training_memory_status": "success"
+    }
+  ]
+}