Add files using upload-large-folder tool

Helios-main/eval/playground/results/all_models_merged.json

@@ -0,0 +1,31 @@
+{
+  "num_models": 1,
+  "score_type": "rating",
+  "metrics": [
+    "aesthetic",
+    "drifting_aesthetic",
+    "drifting_motion_smoothness",
+    "drifting_naturalness",
+    "drifting_semantic",
+    "motion_amplitude",
+    "motion_smoothness",
+    "naturalness",
+    "semantic",
+    "total_weighted_rating"
+  ],
+  "models": {
+    "toy-video": {
+      "aesthetic": 9,
+      "motion_amplitude": 3,
+      "motion_smoothness": 10,
+      "naturalness": 7,
+      "semantic": 8,
+      "drifting_aesthetic": 8,
+      "drifting_motion_smoothness": 10,
+      "drifting_naturalness": 10,
+      "drifting_semantic": 10,
+      "total_weighted_rating": 8.247
+    }
+  },
+  "rating_scale": 10
+}

Helios-main/eval/playground/results/toy-video/aesthetic_results.json

@@ -0,0 +1,17 @@
+{
+  "metric": "aesthetic",
+  "average_score": 0.6564263701438904,
+  "num_videos": 2,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "aesthetic_score": 0.6802743077278137
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "aesthetic_score": 0.632578432559967
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/drifting_aesthetic_results.json

@@ -0,0 +1,22 @@
+{
+  "metric": "drifting_aesthetic",
+  "description": "Start-end contrast of aesthetic (first/last 15% frames)",
+  "average_drift_score": 0.027865678071975708,
+  "num_videos": 2,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "drift_aesthetic_score": 0.002410709857940674,
+      "start_aesthetic_score": 0.6802361011505127,
+      "end_aesthetic_score": 0.677825391292572
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "drift_aesthetic_score": 0.05332064628601074,
+      "start_aesthetic_score": 0.6535003185272217,
+      "end_aesthetic_score": 0.6001796722412109
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/drifting_motion_smoothness_results.json

@@ -0,0 +1,22 @@
+{
+  "metric": "drifting_motion_smoothness",
+  "description": "Start-end contrast of motion smoothness (first/last 15% frames)",
+  "average_drift_score": 0.0009624073235373065,
+  "num_videos": 2,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "drift_motion_smoothness_score": 0.0016874511579993978,
+      "start_motion_smoothness_score": 0.9880413336530265,
+      "end_motion_smoothness_score": 0.9897287848110259
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "drift_motion_smoothness_score": 0.0002373634890752152,
+      "start_motion_smoothness_score": 0.9948747067013198,
+      "end_motion_smoothness_score": 0.995112070190395
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/drifting_naturalness_results.json

@@ -0,0 +1,27 @@
+{
+  "metric": "drifting_naturalness",
+  "description": "Start-end contrast of naturalness (first/last 15% frames)",
+  "average_drift_score": 0.0,
+  "num_videos": 2,
+  "model_name": "gpt-5.2-2025-12-11",
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "drift_naturalness_score": 0.0,
+      "start_naturalness_score": 0.0,
+      "end_naturalness_score": 0.0,
+      "start_raw_score": "1",
+      "end_raw_score": "1"
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "drift_naturalness_score": 0.0,
+      "start_naturalness_score": 0.75,
+      "end_naturalness_score": 0.75,
+      "start_raw_score": "4",
+      "end_raw_score": "4"
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/drifting_semantic_results.json

@@ -0,0 +1,24 @@
+{
+  "metric": "drifting_semantic",
+  "description": "Start-end contrast of semantic consistency (first/last 15% frames)",
+  "average_drift_score": 0.006637156009674072,
+  "num_videos": 2,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "prompt": "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.",
+      "drift_semantic_score": 0.0044051408767700195,
+      "start_semantic_score": 0.2939550578594208,
+      "end_semantic_score": 0.2983601987361908
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "prompt": "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.",
+      "drift_semantic_score": 0.008869171142578125,
+      "start_semantic_score": 0.2703956365585327,
+      "end_semantic_score": 0.2615264654159546
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/merged_results.json

@@ -0,0 +1,74 @@
+{
+  "rating_scale": 10,
+  "summary": {
+    "non_drifting": {
+      "aesthetic": {
+        "name": "Aesthetic",
+        "raw_score": 0.6564263701438904,
+        "normalized_score": 0.6564263701438904,
+        "rating": 9,
+        "num_videos": 2
+      },
+      "motion_amplitude": {
+        "name": "Motion Amplitude",
+        "raw_score": 0.12899818271398544,
+        "normalized_score": 0.12899818271398544,
+        "rating": 3,
+        "num_videos": 2
+      },
+      "motion_smoothness": {
+        "name": "Motion Smoothness",
+        "raw_score": 0.9922347277689807,
+        "normalized_score": 0.9922347277689807,
+        "rating": 10,
+        "num_videos": 2
+      },
+      "naturalness": {
+        "name": "Naturalness",
+        "raw_score": 0.5,
+        "normalized_score": 0.5,
+        "rating": 7,
+        "num_videos": 2
+      },
+      "semantic": {
+        "name": "Semantic",
+        "raw_score": 0.2817579507827759,
+        "normalized_score": 0.2817579507827759,
+        "rating": 8,
+        "num_videos": 2
+      }
+    },
+    "drifting": {
+      "drifting_aesthetic": {
+        "name": "Drifting Aesthetic",
+        "raw_score": 0.027865678071975708,
+        "normalized_score": 0.027865678071975708,
+        "rating": 8,
+        "num_videos": 2
+      },
+      "drifting_motion_smoothness": {
+        "name": "Drifting Motion Smoothness",
+        "raw_score": 0.0009624073235373065,
+        "normalized_score": 0.0009624073235373065,
+        "rating": 10,
+        "num_videos": 2
+      },
+      "drifting_naturalness": {
+        "name": "Drifting Naturalness",
+        "raw_score": 0.0,
+        "normalized_score": 0.0,
+        "rating": 10,
+        "num_videos": 2
+      },
+      "drifting_semantic": {
+        "name": "Drifting Semantic",
+        "raw_score": 0.006637156009674072,
+        "normalized_score": 0.006637156009674072,
+        "rating": 10,
+        "num_videos": 2
+      }
+    },
+    "total_weighted_rating": 8.247
+  },
+  "per_video": {}
+}

Helios-main/eval/playground/results/toy-video/motion_amplitude_results.json

@@ -0,0 +1,17 @@
+{
+  "metric": "motion_fb",
+  "average_score": 0.12899818271398544,
+  "num_videos": 2,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "motion_fb": 0.19912056624889374
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "motion_fb": 0.05887579917907715
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/motion_smoothness_results.json

@@ -0,0 +1,17 @@
+{
+  "metric": "motion_smoothness",
+  "average_score": 0.9922347277689807,
+  "num_videos": 2,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "motion_smoothness_score": 0.9896801291593404
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "motion_smoothness_score": 0.9947893263786209
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/naturalness_results.json

@@ -0,0 +1,21 @@
+{
+  "metric": "naturalness",
+  "average_score": 0.5,
+  "num_videos": 2,
+  "model_name": "gpt-5.2-2025-12-11",
+  "num_frames_per_video": 16,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "naturalness_score": 0.25,
+      "raw_score": "2"
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "naturalness_score": 0.75,
+      "raw_score": "4"
+    }
+  ]
+}

Helios-main/eval/playground/results/toy-video/semantic_results.json

@@ -0,0 +1,19 @@
+{
+  "metric": "semantic",
+  "average_score": 0.2817579507827759,
+  "num_videos": 2,
+  "per_video_results": [
+    {
+      "id": 2,
+      "video_name": "2_240_ori81.mp4",
+      "prompt": "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.",
+      "semantic_score": 0.29471662640571594
+    },
+    {
+      "id": 239,
+      "video_name": "239_120_ori129.mp4",
+      "prompt": "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.",
+      "semantic_score": 0.2687992751598358
+    }
+  ]
+}

Helios-main/eval/utils/third_party/amt/benchmarks/xiph.py

@@ -0,0 +1,117 @@
+import argparse
+import glob
+import os
+import os.path as osp
+import sys
+
+import cv2
+import numpy as np
+import torch
+import tqdm
+from omegaconf import OmegaConf
+
+
+sys.path.append(".")
+from metrics.psnr_ssim import calculate_psnr, calculate_ssim
+
+from utils.build_utils import build_from_cfg
+from utils.utils import InputPadder, img2tensor, read
+
+
+parser = argparse.ArgumentParser(
+    prog="AMT",
+    description="Xiph evaluation",
+)
+parser.add_argument("-c", "--config", default="cfgs/AMT-S.yaml")
+parser.add_argument("-p", "--ckpt", default="pretrained/amt-s.pth")
+parser.add_argument("-r", "--root", default="data/xiph")
+args = parser.parse_args()
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+cfg_path = args.config
+ckpt_path = args.ckpt
+root = args.root
+
+network_cfg = OmegaConf.load(cfg_path).network
+network_name = network_cfg.name
+model = build_from_cfg(network_cfg)
+ckpt = torch.load(ckpt_path)
+model.load_state_dict(ckpt["state_dict"], False)
+model = model.to(device)
+model.eval()
+
+############################################# Prepare Dataset #############################################
+download_links = [
+    "https://media.xiph.org/video/derf/ElFuente/Netflix_BoxingPractice_4096x2160_60fps_10bit_420.y4m",
+    "https://media.xiph.org/video/derf/ElFuente/Netflix_Crosswalk_4096x2160_60fps_10bit_420.y4m",
+    "https://media.xiph.org/video/derf/Chimera/Netflix_DrivingPOV_4096x2160_60fps_10bit_420.y4m",
+    "https://media.xiph.org/video/derf/ElFuente/Netflix_FoodMarket_4096x2160_60fps_10bit_420.y4m",
+    "https://media.xiph.org/video/derf/ElFuente/Netflix_FoodMarket2_4096x2160_60fps_10bit_420.y4m",
+    "https://media.xiph.org/video/derf/ElFuente/Netflix_RitualDance_4096x2160_60fps_10bit_420.y4m",
+    "https://media.xiph.org/video/derf/ElFuente/Netflix_SquareAndTimelapse_4096x2160_60fps_10bit_420.y4m",
+    "https://media.xiph.org/video/derf/ElFuente/Netflix_Tango_4096x2160_60fps_10bit_420.y4m",
+]
+file_list = [
+    "BoxingPractice",
+    "Crosswalk",
+    "DrivingPOV",
+    "FoodMarket",
+    "FoodMarket2",
+    "RitualDance",
+    "SquareAndTimelapse",
+    "Tango",
+]
+
+for file_name, link in zip(file_list, download_links):
+    data_dir = osp.join(root, file_name)
+    if osp.exists(data_dir) is False:
+        os.makedirs(data_dir)
+    if len(glob.glob(f"{data_dir}/*.png")) < 100:
+        os.system(f"ffmpeg -i {link} -pix_fmt rgb24 -vframes 100 {data_dir}/%03d.png")
+############################################### Prepare End ###############################################
+
+
+divisor = 32
+scale_factor = 0.5
+for category in ["resized-2k", "cropped-4k"]:
+    psnr_list = []
+    ssim_list = []
+    pbar = tqdm.tqdm(file_list, total=len(file_list))
+    for flie_name in pbar:
+        dir_name = osp.join(root, flie_name)
+        for intFrame in range(2, 99, 2):
+            img0 = read(f"{dir_name}/{intFrame - 1:03d}.png")
+            img1 = read(f"{dir_name}/{intFrame + 1:03d}.png")
+            imgt = read(f"{dir_name}/{intFrame:03d}.png")
+
+            if category == "resized-2k":
+                img0 = cv2.resize(src=img0, dsize=(2048, 1080), fx=0.0, fy=0.0, interpolation=cv2.INTER_AREA)
+                img1 = cv2.resize(src=img1, dsize=(2048, 1080), fx=0.0, fy=0.0, interpolation=cv2.INTER_AREA)
+                imgt = cv2.resize(src=imgt, dsize=(2048, 1080), fx=0.0, fy=0.0, interpolation=cv2.INTER_AREA)
+
+            elif category == "cropped-4k":
+                img0 = img0[540:-540, 1024:-1024, :]
+                img1 = img1[540:-540, 1024:-1024, :]
+                imgt = imgt[540:-540, 1024:-1024, :]
+            img0 = img2tensor(img0).to(device)
+            imgt = img2tensor(imgt).to(device)
+            img1 = img2tensor(img1).to(device)
+            embt = torch.tensor(1 / 2).float().view(1, 1, 1, 1).to(device)
+
+            padder = InputPadder(img0.shape, divisor)
+            img0, img1 = padder.pad(img0, img1)
+
+            with torch.no_grad():
+                imgt_pred = model(img0, img1, embt, scale_factor=scale_factor, eval=True)["imgt_pred"]
+                imgt_pred = padder.unpad(imgt_pred)
+
+            psnr = calculate_psnr(imgt_pred, imgt)
+            ssim = calculate_ssim(imgt_pred, imgt)
+
+            avg_psnr = np.mean(psnr_list)
+            avg_ssim = np.mean(ssim_list)
+            psnr_list.append(psnr)
+            ssim_list.append(ssim)
+            desc_str = f"[{network_name}/Xiph] [{category}/{flie_name}] psnr: {avg_psnr:.02f}, ssim: {avg_ssim:.04f}"
+
+            pbar.set_description_str(desc_str)

Helios-main/eval/utils/third_party/amt/cfgs/AMT-G.yaml

@@ -0,0 +1,62 @@
+exp_name: floloss1e-2_300epoch_bs24_lr1p5e-4
+seed: 2023
+epochs: 300
+distributed: true
+lr: 1.5e-4
+lr_min: 2e-5
+weight_decay: 0.0
+resume_state: null
+save_dir: work_dir
+eval_interval: 1
+
+network:
+  name: networks.AMT-G.Model
+  params:
+    corr_radius: 3
+    corr_lvls: 4
+    num_flows: 5
+data:
+  train: 
+    name: datasets.vimeo_datasets.Vimeo90K_Train_Dataset
+    params: 
+      dataset_dir: data/vimeo_triplet
+  val:
+    name: datasets.vimeo_datasets.Vimeo90K_Test_Dataset
+    params: 
+      dataset_dir: data/vimeo_triplet
+  train_loader:
+    batch_size: 24
+    num_workers: 12
+  val_loader:
+    batch_size: 24
+    num_workers: 3
+
+logger:
+  use_wandb: true  
+  resume_id: null
+
+losses:
+  - {
+    name: losses.loss.CharbonnierLoss,
+    nickname: l_rec,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+  - {
+    name: losses.loss.TernaryLoss,
+    nickname: l_ter,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+  - {
+    name: losses.loss.MultipleFlowLoss,
+    nickname: l_flo,
+    params: {
+      loss_weight: 0.005,
+      keys: [flow0_pred, flow1_pred, flow]
+    }
+  }

Helios-main/eval/utils/third_party/amt/cfgs/AMT-L.yaml

@@ -0,0 +1,62 @@
+exp_name: floloss1e-2_300epoch_bs24_lr2e-4
+seed: 2023
+epochs: 300
+distributed: true
+lr: 2e-4
+lr_min: 2e-5
+weight_decay: 0.0
+resume_state: null
+save_dir: work_dir
+eval_interval: 1
+
+network:
+  name: networks.AMT-L.Model
+  params:
+    corr_radius: 3
+    corr_lvls: 4
+    num_flows: 5
+data:
+  train: 
+    name: datasets.vimeo_datasets.Vimeo90K_Train_Dataset
+    params: 
+      dataset_dir: data/vimeo_triplet
+  val:
+    name: datasets.vimeo_datasets.Vimeo90K_Test_Dataset
+    params: 
+      dataset_dir: data/vimeo_triplet
+  train_loader:
+    batch_size: 24
+    num_workers: 12
+  val_loader:
+    batch_size: 24
+    num_workers: 3
+
+logger:
+  use_wandb: true  
+  resume_id: null
+
+losses:
+  - {
+    name: losses.loss.CharbonnierLoss,
+    nickname: l_rec,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+  - {
+    name: losses.loss.TernaryLoss,
+    nickname: l_ter,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+  - {
+    name: losses.loss.MultipleFlowLoss,
+    nickname: l_flo,
+    params: {
+      loss_weight: 0.002,
+      keys: [flow0_pred, flow1_pred, flow]
+    }
+  }

Helios-main/eval/utils/third_party/amt/cfgs/AMT-S_gopro.yaml

@@ -0,0 +1,56 @@
+exp_name: wofloloss_400epoch_bs24_lr2e-4
+seed: 2023
+epochs: 400
+distributed: true
+lr: 2e-4
+lr_min: 2e-5
+weight_decay: 0.0
+resume_state: null
+save_dir: work_dir
+eval_interval: 1
+
+network:
+  name: networks.AMT-S.Model
+  params:
+    corr_radius: 3
+    corr_lvls: 4
+    num_flows: 3
+
+data:
+  train: 
+    name: datasets.gopro_datasets.GoPro_Train_Dataset
+    params: 
+      dataset_dir: data/GOPRO
+  val:
+    name: datasets.gopro_datasets.GoPro_Test_Dataset
+    params: 
+      dataset_dir: data/GOPRO
+  train_loader:
+    batch_size: 24
+    num_workers: 12
+  val_loader:
+    batch_size: 24
+    num_workers: 3
+
+logger:
+  use_wandb: false  
+  resume_id: null
+
+losses:
+  - {
+    name: losses.loss.CharbonnierLoss,
+    nickname: l_rec,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+  - {
+    name: losses.loss.TernaryLoss,
+    nickname: l_ter,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+

Helios-main/eval/utils/third_party/amt/cfgs/IFRNet.yaml

@@ -0,0 +1,67 @@
+exp_name: floloss1e-2_geoloss1e-2_300epoch_bs24_lr1e-4
+seed: 2023
+epochs: 300
+distributed: true
+lr: 1e-4
+lr_min: 1e-5
+weight_decay: 1e-6
+resume_state: null
+save_dir: work_dir
+eval_interval: 1
+
+network:
+  name: networks.IFRNet.Model
+
+data:
+  train: 
+    name: datasets.datasets.Vimeo90K_Train_Dataset
+    params: 
+      dataset_dir: data/vimeo_triplet
+  val:
+    name: datasets.datasets.Vimeo90K_Test_Dataset
+    params: 
+      dataset_dir: data/vimeo_triplet
+  train_loader:
+    batch_size: 24
+    num_workers: 12
+  val_loader:
+    batch_size: 24
+    num_workers: 3
+
+logger:
+  use_wandb: true 
+  resume_id: null
+
+losses:
+  - {
+    name: losses.loss.CharbonnierLoss,
+    nickname: l_rec,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+  - {
+    name: losses.loss.TernaryLoss,
+    nickname: l_ter,
+    params: {
+      loss_weight: 1.0,
+      keys: [imgt_pred, imgt]
+    }
+  }
+  - {
+    name: losses.loss.IFRFlowLoss,
+    nickname: l_flo,
+    params: {
+      loss_weight: 0.01,
+      keys: [flow0_pred, flow1_pred, flow]
+    }
+  }
+  - {
+    name: losses.loss.GeometryLoss,
+    nickname: l_geo,
+    params: {
+      loss_weight: 0.01,
+      keys: [ft_pred, ft_gt]
+    }
+  }

Helios-main/eval/utils/third_party/amt/flow_generation/gen_flow.py

@@ -0,0 +1,76 @@
+import argparse
+import os
+import os.path as osp
+import sys
+
+import torch
+
+
+sys.path.append(".")
+from flow_generation.liteflownet.run import estimate
+
+from utils.utils import read, write
+
+
+parser = argparse.ArgumentParser(
+    prog="AMT",
+    description="Flow generation",
+)
+parser.add_argument("-r", "--root", default="data/vimeo_triplet")
+args = parser.parse_args()
+
+vimeo90k_dir = args.root
+vimeo90k_sequences_dir = osp.join(vimeo90k_dir, "sequences")
+vimeo90k_flow_dir = osp.join(vimeo90k_dir, "flow")
+
+
+def pred_flow(img1, img2):
+    img1 = torch.from_numpy(img1).float().permute(2, 0, 1) / 255.0
+    img2 = torch.from_numpy(img2).float().permute(2, 0, 1) / 255.0
+
+    flow = estimate(img1, img2)
+
+    flow = flow.permute(1, 2, 0).cpu().numpy()
+    return flow
+
+
+print("Built Flow Path")
+if not osp.exists(vimeo90k_flow_dir):
+    os.makedirs(vimeo90k_flow_dir)
+
+for sequences_path in sorted(os.listdir(vimeo90k_sequences_dir)):
+    vimeo90k_sequences_path_dir = osp.join(vimeo90k_sequences_dir, sequences_path)
+    vimeo90k_flow_path_dir = osp.join(vimeo90k_flow_dir, sequences_path)
+    if not osp.exists(vimeo90k_flow_path_dir):
+        os.mkdir(vimeo90k_flow_path_dir)
+
+    for sequences_id in sorted(os.listdir(vimeo90k_sequences_path_dir)):
+        vimeo90k_flow_id_dir = osp.join(vimeo90k_flow_path_dir, sequences_id)
+        if not osp.exists(vimeo90k_flow_id_dir):
+            os.mkdir(vimeo90k_flow_id_dir)
+
+for sequences_path in sorted(os.listdir(vimeo90k_sequences_dir)):
+    vimeo90k_sequences_path_dir = os.path.join(vimeo90k_sequences_dir, sequences_path)
+    vimeo90k_flow_path_dir = os.path.join(vimeo90k_flow_dir, sequences_path)
+
+    for sequences_id in sorted(os.listdir(vimeo90k_sequences_path_dir)):
+        vimeo90k_sequences_id_dir = os.path.join(vimeo90k_sequences_path_dir, sequences_id)
+        vimeo90k_flow_id_dir = os.path.join(vimeo90k_flow_path_dir, sequences_id)
+
+        img0_path = vimeo90k_sequences_id_dir + "/im1.png"
+        imgt_path = vimeo90k_sequences_id_dir + "/im2.png"
+        img1_path = vimeo90k_sequences_id_dir + "/im3.png"
+        flow_t0_path = vimeo90k_flow_id_dir + "/flow_t0.flo"
+        flow_t1_path = vimeo90k_flow_id_dir + "/flow_t1.flo"
+
+        img0 = read(img0_path)
+        imgt = read(imgt_path)
+        img1 = read(img1_path)
+
+        flow_t0 = pred_flow(imgt, img0)
+        flow_t1 = pred_flow(imgt, img1)
+
+        write(flow_t0_path, flow_t0)
+        write(flow_t1_path, flow_t1)
+
+    print("Written Sequences {}".format(sequences_path))

Helios-main/eval/utils/third_party/amt/flow_generation/liteflownet/README.md

@@ -0,0 +1,45 @@
+# pytorch-liteflownet
+This is a personal reimplementation of LiteFlowNet [1] using PyTorch. Should you be making use of this work, please cite the paper accordingly. Also, make sure to adhere to the <a href="https://github.com/twhui/LiteFlowNet#license-and-citation">licensing terms</a> of the authors. Should you be making use of this particular implementation, please acknowledge it appropriately [2].
+
+<a href="https://arxiv.org/abs/1805.07036" rel="Paper"><img src="http://www.arxiv-sanity.com/static/thumbs/1805.07036v1.pdf.jpg" alt="Paper" width="100%"></a>
+
+For the original Caffe version of this work, please see: https://github.com/twhui/LiteFlowNet
+<br />
+Other optical flow implementations from me: [pytorch-pwc](https://github.com/sniklaus/pytorch-pwc), [pytorch-unflow](https://github.com/sniklaus/pytorch-unflow), [pytorch-spynet](https://github.com/sniklaus/pytorch-spynet)
+
+## setup
+The correlation layer is implemented in CUDA using CuPy, which is why CuPy is a required dependency. It can be installed using `pip install cupy` or alternatively using one of the provided [binary packages](https://docs.cupy.dev/en/stable/install.html#installing-cupy) as outlined in the CuPy repository. If you would like to use Docker, you can take a look at [this](https://github.com/sniklaus/pytorch-liteflownet/pull/43) pull request to get started.
+
+## usage
+To run it on your own pair of images, use the following command. You can choose between three models, please make sure to see their paper / the code for more details.
+
+```
+python run.py --model default --one ./images/one.png --two ./images/two.png --out ./out.flo
+```
+
+I am afraid that I cannot guarantee that this reimplementation is correct. However, it produced results pretty much identical to the implementation of the original authors in the examples that I tried. There are some numerical deviations that stem from differences in the `DownsampleLayer` of Caffe and the `torch.nn.functional.interpolate` function of PyTorch. Please feel free to contribute to this repository by submitting issues and pull requests.
+
+## comparison
+<p align="center"><img src="comparison/comparison.gif?raw=true" alt="Comparison"></p>
+
+## license
+As stated in the <a href="https://github.com/twhui/LiteFlowNet#license-and-citation">licensing terms</a> of the authors of the paper, their material is provided for research purposes only. Please make sure to further consult their licensing terms.
+
+## references
+```
+[1]  @inproceedings{Hui_CVPR_2018,
+         author = {Tak-Wai Hui and Xiaoou Tang and Chen Change Loy},
+         title = {{LiteFlowNet}: A Lightweight Convolutional Neural Network for Optical Flow Estimation},
+         booktitle = {IEEE Conference on Computer Vision and Pattern Recognition},
+         year = {2018}
+     }
+```
+
+```
+[2]  @misc{pytorch-liteflownet,
+         author = {Simon Niklaus},
+         title = {A Reimplementation of {LiteFlowNet} Using {PyTorch}},
+         year = {2019},
+         howpublished = {\url{https://github.com/sniklaus/pytorch-liteflownet}}
+    }
+```

Helios-main/eval/utils/third_party/amt/flow_generation/liteflownet/correlation/README.md

@@ -0,0 +1 @@
+This is an adaptation of the FlowNet2 implementation in order to compute cost volumes. Should you be making use of this work, please make sure to adhere to the licensing terms of the original authors. Should you be making use or modify this particular implementation, please acknowledge it appropriately.

Helios-main/eval/utils/third_party/amt/flow_generation/liteflownet/correlation/correlation.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python
+
+import math
+import re
+
+import cupy
+import torch
+
+
+kernel_Correlation_rearrange = """
+    extern "C" __global__ void kernel_Correlation_rearrange(
+        const int n,
+        const float* input,
+        float* output
+    ) {
+      int intIndex = (blockIdx.x * blockDim.x) + threadIdx.x;
+      if (intIndex >= n) {
+        return;
+      }
+      int intSample = blockIdx.z;
+      int intChannel = blockIdx.y;
+      float fltValue = input[(((intSample * SIZE_1(input)) + intChannel) * SIZE_2(input) * SIZE_3(input)) + intIndex];
+      __syncthreads();
+      int intPaddedY = (intIndex / SIZE_3(input)) + 3*{{intStride}};
+      int intPaddedX = (intIndex % SIZE_3(input)) + 3*{{intStride}};
+      int intRearrange = ((SIZE_3(input) + 6*{{intStride}}) * intPaddedY) + intPaddedX;
+      output[(((intSample * SIZE_1(output) * SIZE_2(output)) + intRearrange) * SIZE_1(input)) + intChannel] = fltValue;
+    }
+"""
+
+kernel_Correlation_updateOutput = """
+    extern "C" __global__ void kernel_Correlation_updateOutput(
+      const int n,
+      const float* rbot0,
+      const float* rbot1,
+      float* top
+    ) {
+      extern __shared__ char patch_data_char[];
+      float *patch_data = (float *)patch_data_char;
+      // First (upper left) position of kernel upper-left corner in current center position of neighborhood in image 1
+      int x1 = (blockIdx.x + 3) * {{intStride}};
+      int y1 = (blockIdx.y + 3) * {{intStride}};
+      int item = blockIdx.z;
+      int ch_off = threadIdx.x;
+      // Load 3D patch into shared shared memory
+      for (int j = 0; j < 1; j++) { // HEIGHT
+        for (int i = 0; i < 1; i++) { // WIDTH
+          int ji_off = (j + i) * SIZE_3(rbot0);
+          for (int ch = ch_off; ch < SIZE_3(rbot0); ch += 32) { // CHANNELS
+            int idx1 = ((item * SIZE_1(rbot0) + y1+j) * SIZE_2(rbot0) + x1+i) * SIZE_3(rbot0) + ch;
+            int idxPatchData = ji_off + ch;
+            patch_data[idxPatchData] = rbot0[idx1];
+          }
+        }
+      }
+      __syncthreads();
+      __shared__ float sum[32];
+      // Compute correlation
+      for (int top_channel = 0; top_channel < SIZE_1(top); top_channel++) {
+        sum[ch_off] = 0;
+        int s2o = (top_channel % 7 - 3) * {{intStride}};
+        int s2p = (top_channel / 7 - 3) * {{intStride}};
+        for (int j = 0; j < 1; j++) { // HEIGHT
+          for (int i = 0; i < 1; i++) { // WIDTH
+            int ji_off = (j + i) * SIZE_3(rbot0);
+            for (int ch = ch_off; ch < SIZE_3(rbot0); ch += 32) { // CHANNELS
+              int x2 = x1 + s2o;
+              int y2 = y1 + s2p;
+              int idxPatchData = ji_off + ch;
+              int idx2 = ((item * SIZE_1(rbot0) + y2+j) * SIZE_2(rbot0) + x2+i) * SIZE_3(rbot0) + ch;
+              sum[ch_off] += patch_data[idxPatchData] * rbot1[idx2];
+            }
+          }
+        }
+        __syncthreads();
+        if (ch_off == 0) {
+          float total_sum = 0;
+          for (int idx = 0; idx < 32; idx++) {
+            total_sum += sum[idx];
+          }
+          const int sumelems = SIZE_3(rbot0);
+          const int index = ((top_channel*SIZE_2(top) + blockIdx.y)*SIZE_3(top))+blockIdx.x;
+          top[index + item*SIZE_1(top)*SIZE_2(top)*SIZE_3(top)] = total_sum / (float)sumelems;
+        }
+      }
+    }
+"""
+
+kernel_Correlation_updateGradOne = """
+    #define ROUND_OFF 50000
+    extern "C" __global__ void kernel_Correlation_updateGradOne(
+      const int n,
+      const int intSample,
+      const float* rbot0,
+      const float* rbot1,
+      const float* gradOutput,
+      float* gradOne,
+      float* gradTwo
+    ) { for (int intIndex = (blockIdx.x * blockDim.x) + threadIdx.x; intIndex < n; intIndex += blockDim.x * gridDim.x) {
+      int n = intIndex % SIZE_1(gradOne); // channels
+      int l = (intIndex / SIZE_1(gradOne)) % SIZE_3(gradOne) + 3*{{intStride}}; // w-pos
+      int m = (intIndex / SIZE_1(gradOne) / SIZE_3(gradOne)) % SIZE_2(gradOne) + 3*{{intStride}}; // h-pos
+      // round_off is a trick to enable integer division with ceil, even for negative numbers
+      // We use a large offset, for the inner part not to become negative.
+      const int round_off = ROUND_OFF;
+      const int round_off_s1 = {{intStride}} * round_off;
+      // We add round_off before_s1 the int division and subtract round_off after it, to ensure the formula matches ceil behavior:
+      int xmin = (l - 3*{{intStride}} + round_off_s1 - 1) / {{intStride}} + 1 - round_off; // ceil (l - 3*{{intStride}}) / {{intStride}}
+      int ymin = (m - 3*{{intStride}} + round_off_s1 - 1) / {{intStride}} + 1 - round_off; // ceil (l - 3*{{intStride}}) / {{intStride}}
+      // Same here:
+      int xmax = (l - 3*{{intStride}} + round_off_s1) / {{intStride}} - round_off; // floor (l - 3*{{intStride}}) / {{intStride}}
+      int ymax = (m - 3*{{intStride}} + round_off_s1) / {{intStride}} - round_off; // floor (m - 3*{{intStride}}) / {{intStride}}
+      float sum = 0;
+      if (xmax>=0 && ymax>=0 && (xmin<=SIZE_3(gradOutput)-1) && (ymin<=SIZE_2(gradOutput)-1)) {
+        xmin = max(0,xmin);
+        xmax = min(SIZE_3(gradOutput)-1,xmax);
+        ymin = max(0,ymin);
+        ymax = min(SIZE_2(gradOutput)-1,ymax);
+        for (int p = -3; p <= 3; p++) {
+          for (int o = -3; o <= 3; o++) {
+            // Get rbot1 data:
+            int s2o = {{intStride}} * o;
+            int s2p = {{intStride}} * p;
+            int idxbot1 = ((intSample * SIZE_1(rbot0) + (m+s2p)) * SIZE_2(rbot0) + (l+s2o)) * SIZE_3(rbot0) + n;
+            float bot1tmp = rbot1[idxbot1]; // rbot1[l+s2o,m+s2p,n]
+            // Index offset for gradOutput in following loops:
+            int op = (p+3) * 7 + (o+3); // index[o,p]
+            int idxopoffset = (intSample * SIZE_1(gradOutput) + op);
+            for (int y = ymin; y <= ymax; y++) {
+              for (int x = xmin; x <= xmax; x++) {
+                int idxgradOutput = (idxopoffset * SIZE_2(gradOutput) + y) * SIZE_3(gradOutput) + x; // gradOutput[x,y,o,p]
+                sum += gradOutput[idxgradOutput] * bot1tmp;
+              }
+            }
+          }
+        }
+      }
+      const int sumelems = SIZE_1(gradOne);
+      const int bot0index = ((n * SIZE_2(gradOne)) + (m-3*{{intStride}})) * SIZE_3(gradOne) + (l-3*{{intStride}});
+      gradOne[bot0index + intSample*SIZE_1(gradOne)*SIZE_2(gradOne)*SIZE_3(gradOne)] = sum / (float)sumelems;
+    } }
+"""
+
+kernel_Correlation_updateGradTwo = """
+    #define ROUND_OFF 50000
+    extern "C" __global__ void kernel_Correlation_updateGradTwo(
+      const int n,
+      const int intSample,
+      const float* rbot0,
+      const float* rbot1,
+      const float* gradOutput,
+      float* gradOne,
+      float* gradTwo
+    ) { for (int intIndex = (blockIdx.x * blockDim.x) + threadIdx.x; intIndex < n; intIndex += blockDim.x * gridDim.x) {
+      int n = intIndex % SIZE_1(gradTwo); // channels
+      int l = (intIndex / SIZE_1(gradTwo)) % SIZE_3(gradTwo) + 3*{{intStride}}; // w-pos
+      int m = (intIndex / SIZE_1(gradTwo) / SIZE_3(gradTwo)) % SIZE_2(gradTwo) + 3*{{intStride}}; // h-pos
+      // round_off is a trick to enable integer division with ceil, even for negative numbers
+      // We use a large offset, for the inner part not to become negative.
+      const int round_off = ROUND_OFF;
+      const int round_off_s1 = {{intStride}} * round_off;
+      float sum = 0;
+      for (int p = -3; p <= 3; p++) {
+        for (int o = -3; o <= 3; o++) {
+          int s2o = {{intStride}} * o;
+          int s2p = {{intStride}} * p;
+          //Get X,Y ranges and clamp
+          // We add round_off before_s1 the int division and subtract round_off after it, to ensure the formula matches ceil behavior:
+          int xmin = (l - 3*{{intStride}} - s2o + round_off_s1 - 1) / {{intStride}} + 1 - round_off; // ceil (l - 3*{{intStride}} - s2o) / {{intStride}}
+          int ymin = (m - 3*{{intStride}} - s2p + round_off_s1 - 1) / {{intStride}} + 1 - round_off; // ceil (l - 3*{{intStride}} - s2o) / {{intStride}}
+          // Same here:
+          int xmax = (l - 3*{{intStride}} - s2o + round_off_s1) / {{intStride}} - round_off; // floor (l - 3*{{intStride}} - s2o) / {{intStride}}
+          int ymax = (m - 3*{{intStride}} - s2p + round_off_s1) / {{intStride}} - round_off; // floor (m - 3*{{intStride}} - s2p) / {{intStride}}
+          if (xmax>=0 && ymax>=0 && (xmin<=SIZE_3(gradOutput)-1) && (ymin<=SIZE_2(gradOutput)-1)) {
+            xmin = max(0,xmin);
+            xmax = min(SIZE_3(gradOutput)-1,xmax);
+            ymin = max(0,ymin);
+            ymax = min(SIZE_2(gradOutput)-1,ymax);
+            // Get rbot0 data:
+            int idxbot0 = ((intSample * SIZE_1(rbot0) + (m-s2p)) * SIZE_2(rbot0) + (l-s2o)) * SIZE_3(rbot0) + n;
+            float bot0tmp = rbot0[idxbot0]; // rbot1[l+s2o,m+s2p,n]
+            // Index offset for gradOutput in following loops:
+            int op = (p+3) * 7 + (o+3); // index[o,p]
+            int idxopoffset = (intSample * SIZE_1(gradOutput) + op);
+            for (int y = ymin; y <= ymax; y++) {
+              for (int x = xmin; x <= xmax; x++) {
+                int idxgradOutput = (idxopoffset * SIZE_2(gradOutput) + y) * SIZE_3(gradOutput) + x; // gradOutput[x,y,o,p]
+                sum += gradOutput[idxgradOutput] * bot0tmp;
+              }
+            }
+          }
+        }
+      }
+      const int sumelems = SIZE_1(gradTwo);
+      const int bot1index = ((n * SIZE_2(gradTwo)) + (m-3*{{intStride}})) * SIZE_3(gradTwo) + (l-3*{{intStride}});
+      gradTwo[bot1index + intSample*SIZE_1(gradTwo)*SIZE_2(gradTwo)*SIZE_3(gradTwo)] = sum / (float)sumelems;
+    } }
+"""
+
+
+def cupy_kernel(strFunction, objVariables):
+    strKernel = globals()[strFunction].replace("{{intStride}}", str(objVariables["intStride"]))
+
+    while True:
+        objMatch = re.search(r"(SIZE_)([0-4])(\()([^\)]*)(\))", strKernel)
+
+        if objMatch is None:
+            break
+        # end
+
+        intArg = int(objMatch.group(2))
+
+        strTensor = objMatch.group(4)
+        intSizes = objVariables[strTensor].size()
+
+        strKernel = strKernel.replace(
+            objMatch.group(),
+            str(intSizes[intArg] if not torch.is_tensor(intSizes[intArg]) else intSizes[intArg].item()),
+        )
+    # end
+
+    while True:
+        objMatch = re.search(r"(VALUE_)([0-4])(\()([^\)]+)(\))", strKernel)
+
+        if objMatch is None:
+            break
+        # end
+
+        intArgs = int(objMatch.group(2))
+        strArgs = objMatch.group(4).split(",")
+
+        strTensor = strArgs[0]
+        intStrides = objVariables[strTensor].stride()
+        strIndex = [
+            "(("
+            + strArgs[intArg + 1].replace("{", "(").replace("}", ")").strip()
+            + ")*"
+            + str(intStrides[intArg] if not torch.is_tensor(intStrides[intArg]) else intStrides[intArg].item())
+            + ")"
+            for intArg in range(intArgs)
+        ]
+
+        strKernel = strKernel.replace(objMatch.group(0), strTensor + "[" + str.join("+", strIndex) + "]")
+    # end
+
+    return strKernel
+
+
+# end
+
+
+@cupy.memoize(for_each_device=True)
+def cupy_launch(strFunction, strKernel):
+    return cupy.cuda.compile_with_cache(strKernel).get_function(strFunction)
+
+
+# end
+
+
+class _FunctionCorrelation(torch.autograd.Function):
+    @staticmethod
+    def forward(self, one, two, intStride):
+        rbot0 = one.new_zeros(
+            [one.shape[0], one.shape[2] + (6 * intStride), one.shape[3] + (6 * intStride), one.shape[1]]
+        )
+        rbot1 = one.new_zeros(
+            [one.shape[0], one.shape[2] + (6 * intStride), one.shape[3] + (6 * intStride), one.shape[1]]
+        )
+
+        self.intStride = intStride
+
+        one = one.contiguous()
+        assert one.is_cuda
+        two = two.contiguous()
+        assert two.is_cuda
+
+        output = one.new_zeros(
+            [one.shape[0], 49, int(math.ceil(one.shape[2] / intStride)), int(math.ceil(one.shape[3] / intStride))]
+        )
+
+        if one.is_cuda:
+            n = one.shape[2] * one.shape[3]
+            cupy_launch(
+                "kernel_Correlation_rearrange",
+                cupy_kernel(
+                    "kernel_Correlation_rearrange", {"intStride": self.intStride, "input": one, "output": rbot0}
+                ),
+            )(
+                grid=(int((n + 16 - 1) / 16), one.shape[1], one.shape[0]),
+                block=(16, 1, 1),
+                args=[cupy.int32(n), one.data_ptr(), rbot0.data_ptr()],
+            )
+
+            n = two.shape[2] * two.shape[3]
+            cupy_launch(
+                "kernel_Correlation_rearrange",
+                cupy_kernel(
+                    "kernel_Correlation_rearrange", {"intStride": self.intStride, "input": two, "output": rbot1}
+                ),
+            )(
+                grid=(int((n + 16 - 1) / 16), two.shape[1], two.shape[0]),
+                block=(16, 1, 1),
+                args=[cupy.int32(n), two.data_ptr(), rbot1.data_ptr()],
+            )
+
+            n = output.shape[1] * output.shape[2] * output.shape[3]
+            cupy_launch(
+                "kernel_Correlation_updateOutput",
+                cupy_kernel(
+                    "kernel_Correlation_updateOutput",
+                    {"intStride": self.intStride, "rbot0": rbot0, "rbot1": rbot1, "top": output},
+                ),
+            )(
+                grid=(output.shape[3], output.shape[2], output.shape[0]),
+                block=(32, 1, 1),
+                shared_mem=one.shape[1] * 4,
+                args=[cupy.int32(n), rbot0.data_ptr(), rbot1.data_ptr(), output.data_ptr()],
+            )
+
+        elif not one.is_cuda:
+            raise NotImplementedError()
+
+        # end
+
+        self.save_for_backward(one, two, rbot0, rbot1)
+
+        return output
+
+    # end
+
+    @staticmethod
+    def backward(self, gradOutput):
+        one, two, rbot0, rbot1 = self.saved_tensors
+
+        gradOutput = gradOutput.contiguous()
+        assert gradOutput.is_cuda
+
+        gradOne = (
+            one.new_zeros([one.shape[0], one.shape[1], one.shape[2], one.shape[3]])
+            if self.needs_input_grad[0]
+            else None
+        )
+        gradTwo = (
+            one.new_zeros([one.shape[0], one.shape[1], one.shape[2], one.shape[3]])
+            if self.needs_input_grad[1]
+            else None
+        )
+
+        if one.is_cuda:
+            if gradOne is not None:
+                for intSample in range(one.shape[0]):
+                    n = one.shape[1] * one.shape[2] * one.shape[3]
+                    cupy_launch(
+                        "kernel_Correlation_updateGradOne",
+                        cupy_kernel(
+                            "kernel_Correlation_updateGradOne",
+                            {
+                                "intStride": self.intStride,
+                                "rbot0": rbot0,
+                                "rbot1": rbot1,
+                                "gradOutput": gradOutput,
+                                "gradOne": gradOne,
+                                "gradTwo": None,
+                            },
+                        ),
+                    )(
+                        grid=(int((n + 512 - 1) / 512), 1, 1),
+                        block=(512, 1, 1),
+                        args=[
+                            cupy.int32(n),
+                            intSample,
+                            rbot0.data_ptr(),
+                            rbot1.data_ptr(),
+                            gradOutput.data_ptr(),
+                            gradOne.data_ptr(),
+                            None,
+                        ],
+                    )
+                # end
+            # end
+
+            if gradTwo is not None:
+                for intSample in range(one.shape[0]):
+                    n = one.shape[1] * one.shape[2] * one.shape[3]
+                    cupy_launch(
+                        "kernel_Correlation_updateGradTwo",
+                        cupy_kernel(
+                            "kernel_Correlation_updateGradTwo",
+                            {
+                                "intStride": self.intStride,
+                                "rbot0": rbot0,
+                                "rbot1": rbot1,
+                                "gradOutput": gradOutput,
+                                "gradOne": None,
+                                "gradTwo": gradTwo,
+                            },
+                        ),
+                    )(
+                        grid=(int((n + 512 - 1) / 512), 1, 1),
+                        block=(512, 1, 1),
+                        args=[
+                            cupy.int32(n),
+                            intSample,
+                            rbot0.data_ptr(),
+                            rbot1.data_ptr(),
+                            gradOutput.data_ptr(),
+                            None,
+                            gradTwo.data_ptr(),
+                        ],
+                    )
+                # end
+            # end
+
+        elif not one.is_cuda:
+            raise NotImplementedError()
+
+        # end
+
+        return gradOne, gradTwo, None
+
+    # end
+
+
+# end
+
+
+def FunctionCorrelation(tenOne, tenTwo, intStride):
+    return _FunctionCorrelation.apply(tenOne, tenTwo, intStride)
+
+
+# end
+
+
+class ModuleCorrelation(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    # end
+
+    def forward(self, tenOne, tenTwo, intStride):
+        return _FunctionCorrelation.apply(tenOne, tenTwo, intStride)
+
+    # end
+
+
+# end

Helios-main/eval/utils/third_party/amt/flow_generation/liteflownet/run.py

@@ -0,0 +1,602 @@
+#!/usr/bin/env python
+
+import getopt
+import math
+import sys
+
+import numpy
+import PIL
+import PIL.Image
+import torch
+
+
+try:
+    from .correlation import correlation  # the custom cost volume layer
+except Exception:
+    sys.path.insert(0, "./correlation")
+    import correlation  # you should consider upgrading python
+# end
+
+##########################################################
+
+assert int(str("").join(torch.__version__.split(".")[0:2])) >= 13  # requires at least pytorch version 1.3.0
+
+torch.set_grad_enabled(False)  # make sure to not compute gradients for computational performance
+
+torch.backends.cudnn.enabled = True  # make sure to use cudnn for computational performance
+
+##########################################################
+
+arguments_strModel = "default"  # 'default', or 'kitti', or 'sintel'
+arguments_strOne = "./images/one.png"
+arguments_strTwo = "./images/two.png"
+arguments_strOut = "./out.flo"
+
+for strOption, strArgument in getopt.getopt(
+    sys.argv[1:], "", [strParameter[2:] + "=" for strParameter in sys.argv[1::2]]
+)[0]:
+    if strOption == "--model" and strArgument != "":
+        arguments_strModel = strArgument  # which model to use
+    if strOption == "--one" and strArgument != "":
+        arguments_strOne = strArgument  # path to the first frame
+    if strOption == "--two" and strArgument != "":
+        arguments_strTwo = strArgument  # path to the second frame
+    if strOption == "--out" and strArgument != "":
+        arguments_strOut = strArgument  # path to where the output should be stored
+# end
+
+##########################################################
+
+backwarp_tenGrid = {}
+
+
+def backwarp(tenInput, tenFlow):
+    if str(tenFlow.shape) not in backwarp_tenGrid:
+        tenHor = (
+            torch.linspace(-1.0 + (1.0 / tenFlow.shape[3]), 1.0 - (1.0 / tenFlow.shape[3]), tenFlow.shape[3])
+            .view(1, 1, 1, -1)
+            .repeat(1, 1, tenFlow.shape[2], 1)
+        )
+        tenVer = (
+            torch.linspace(-1.0 + (1.0 / tenFlow.shape[2]), 1.0 - (1.0 / tenFlow.shape[2]), tenFlow.shape[2])
+            .view(1, 1, -1, 1)
+            .repeat(1, 1, 1, tenFlow.shape[3])
+        )
+
+        backwarp_tenGrid[str(tenFlow.shape)] = torch.cat([tenHor, tenVer], 1).cuda()
+    # end
+
+    tenFlow = torch.cat(
+        [
+            tenFlow[:, 0:1, :, :] / ((tenInput.shape[3] - 1.0) / 2.0),
+            tenFlow[:, 1:2, :, :] / ((tenInput.shape[2] - 1.0) / 2.0),
+        ],
+        1,
+    )
+
+    return torch.nn.functional.grid_sample(
+        input=tenInput,
+        grid=(backwarp_tenGrid[str(tenFlow.shape)] + tenFlow).permute(0, 2, 3, 1),
+        mode="bilinear",
+        padding_mode="zeros",
+        align_corners=False,
+    )
+
+
+# end
+
+##########################################################
+
+
+class Network(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+        class Features(torch.nn.Module):
+            def __init__(self):
+                super().__init__()
+
+                self.netOne = torch.nn.Sequential(
+                    torch.nn.Conv2d(in_channels=3, out_channels=32, kernel_size=7, stride=1, padding=3),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                )
+
+                self.netTwo = torch.nn.Sequential(
+                    torch.nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, stride=2, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                )
+
+                self.netThr = torch.nn.Sequential(
+                    torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=2, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                )
+
+                self.netFou = torch.nn.Sequential(
+                    torch.nn.Conv2d(in_channels=64, out_channels=96, kernel_size=3, stride=2, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=96, out_channels=96, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                )
+
+                self.netFiv = torch.nn.Sequential(
+                    torch.nn.Conv2d(in_channels=96, out_channels=128, kernel_size=3, stride=2, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                )
+
+                self.netSix = torch.nn.Sequential(
+                    torch.nn.Conv2d(in_channels=128, out_channels=192, kernel_size=3, stride=2, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                )
+
+            # end
+
+            def forward(self, tenInput):
+                tenOne = self.netOne(tenInput)
+                tenTwo = self.netTwo(tenOne)
+                tenThr = self.netThr(tenTwo)
+                tenFou = self.netFou(tenThr)
+                tenFiv = self.netFiv(tenFou)
+                tenSix = self.netSix(tenFiv)
+
+                return [tenOne, tenTwo, tenThr, tenFou, tenFiv, tenSix]
+
+            # end
+
+        # end
+
+        class Matching(torch.nn.Module):
+            def __init__(self, intLevel):
+                super().__init__()
+
+                self.fltBackwarp = [0.0, 0.0, 10.0, 5.0, 2.5, 1.25, 0.625][intLevel]
+
+                if intLevel != 2:
+                    self.netFeat = torch.nn.Sequential()
+
+                elif intLevel == 2:
+                    self.netFeat = torch.nn.Sequential(
+                        torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=1, stride=1, padding=0),
+                        torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    )
+
+                # end
+
+                if intLevel == 6:
+                    self.netUpflow = None
+
+                elif intLevel != 6:
+                    self.netUpflow = torch.nn.ConvTranspose2d(
+                        in_channels=2, out_channels=2, kernel_size=4, stride=2, padding=1, bias=False, groups=2
+                    )
+
+                # end
+
+                if intLevel >= 4:
+                    self.netUpcorr = None
+
+                elif intLevel < 4:
+                    self.netUpcorr = torch.nn.ConvTranspose2d(
+                        in_channels=49, out_channels=49, kernel_size=4, stride=2, padding=1, bias=False, groups=49
+                    )
+
+                # end
+
+                self.netMain = torch.nn.Sequential(
+                    torch.nn.Conv2d(in_channels=49, out_channels=128, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(
+                        in_channels=32,
+                        out_channels=2,
+                        kernel_size=[0, 0, 7, 5, 5, 3, 3][intLevel],
+                        stride=1,
+                        padding=[0, 0, 3, 2, 2, 1, 1][intLevel],
+                    ),
+                )
+
+            # end
+
+            def forward(self, tenOne, tenTwo, tenFeaturesOne, tenFeaturesTwo, tenFlow):
+                tenFeaturesOne = self.netFeat(tenFeaturesOne)
+                tenFeaturesTwo = self.netFeat(tenFeaturesTwo)
+
+                if tenFlow is not None:
+                    tenFlow = self.netUpflow(tenFlow)
+                # end
+
+                if tenFlow is not None:
+                    tenFeaturesTwo = backwarp(tenInput=tenFeaturesTwo, tenFlow=tenFlow * self.fltBackwarp)
+                # end
+
+                if self.netUpcorr is None:
+                    tenCorrelation = torch.nn.functional.leaky_relu(
+                        input=correlation.FunctionCorrelation(
+                            tenOne=tenFeaturesOne, tenTwo=tenFeaturesTwo, intStride=1
+                        ),
+                        negative_slope=0.1,
+                        inplace=False,
+                    )
+
+                elif self.netUpcorr is not None:
+                    tenCorrelation = self.netUpcorr(
+                        torch.nn.functional.leaky_relu(
+                            input=correlation.FunctionCorrelation(
+                                tenOne=tenFeaturesOne, tenTwo=tenFeaturesTwo, intStride=2
+                            ),
+                            negative_slope=0.1,
+                            inplace=False,
+                        )
+                    )
+
+                # end
+
+                return (tenFlow if tenFlow is not None else 0.0) + self.netMain(tenCorrelation)
+
+            # end
+
+        # end
+
+        class Subpixel(torch.nn.Module):
+            def __init__(self, intLevel):
+                super().__init__()
+
+                self.fltBackward = [0.0, 0.0, 10.0, 5.0, 2.5, 1.25, 0.625][intLevel]
+
+                if intLevel != 2:
+                    self.netFeat = torch.nn.Sequential()
+
+                elif intLevel == 2:
+                    self.netFeat = torch.nn.Sequential(
+                        torch.nn.Conv2d(in_channels=32, out_channels=64, kernel_size=1, stride=1, padding=0),
+                        torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    )
+
+                # end
+
+                self.netMain = torch.nn.Sequential(
+                    torch.nn.Conv2d(
+                        in_channels=[0, 0, 130, 130, 194, 258, 386][intLevel],
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=1,
+                        padding=1,
+                    ),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(
+                        in_channels=32,
+                        out_channels=2,
+                        kernel_size=[0, 0, 7, 5, 5, 3, 3][intLevel],
+                        stride=1,
+                        padding=[0, 0, 3, 2, 2, 1, 1][intLevel],
+                    ),
+                )
+
+            # end
+
+            def forward(self, tenOne, tenTwo, tenFeaturesOne, tenFeaturesTwo, tenFlow):
+                tenFeaturesOne = self.netFeat(tenFeaturesOne)
+                tenFeaturesTwo = self.netFeat(tenFeaturesTwo)
+
+                if tenFlow is not None:
+                    tenFeaturesTwo = backwarp(tenInput=tenFeaturesTwo, tenFlow=tenFlow * self.fltBackward)
+                # end
+
+                return (tenFlow if tenFlow is not None else 0.0) + self.netMain(
+                    torch.cat([tenFeaturesOne, tenFeaturesTwo, tenFlow], 1)
+                )
+
+            # end
+
+        # end
+
+        class Regularization(torch.nn.Module):
+            def __init__(self, intLevel):
+                super().__init__()
+
+                self.fltBackward = [0.0, 0.0, 10.0, 5.0, 2.5, 1.25, 0.625][intLevel]
+
+                self.intUnfold = [0, 0, 7, 5, 5, 3, 3][intLevel]
+
+                if intLevel >= 5:
+                    self.netFeat = torch.nn.Sequential()
+
+                elif intLevel < 5:
+                    self.netFeat = torch.nn.Sequential(
+                        torch.nn.Conv2d(
+                            in_channels=[0, 0, 32, 64, 96, 128, 192][intLevel],
+                            out_channels=128,
+                            kernel_size=1,
+                            stride=1,
+                            padding=0,
+                        ),
+                        torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    )
+
+                # end
+
+                self.netMain = torch.nn.Sequential(
+                    torch.nn.Conv2d(
+                        in_channels=[0, 0, 131, 131, 131, 131, 195][intLevel],
+                        out_channels=128,
+                        kernel_size=3,
+                        stride=1,
+                        padding=1,
+                    ),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=64, out_channels=32, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                    torch.nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, stride=1, padding=1),
+                    torch.nn.LeakyReLU(inplace=False, negative_slope=0.1),
+                )
+
+                if intLevel >= 5:
+                    self.netDist = torch.nn.Sequential(
+                        torch.nn.Conv2d(
+                            in_channels=32,
+                            out_channels=[0, 0, 49, 25, 25, 9, 9][intLevel],
+                            kernel_size=[0, 0, 7, 5, 5, 3, 3][intLevel],
+                            stride=1,
+                            padding=[0, 0, 3, 2, 2, 1, 1][intLevel],
+                        )
+                    )
+
+                elif intLevel < 5:
+                    self.netDist = torch.nn.Sequential(
+                        torch.nn.Conv2d(
+                            in_channels=32,
+                            out_channels=[0, 0, 49, 25, 25, 9, 9][intLevel],
+                            kernel_size=([0, 0, 7, 5, 5, 3, 3][intLevel], 1),
+                            stride=1,
+                            padding=([0, 0, 3, 2, 2, 1, 1][intLevel], 0),
+                        ),
+                        torch.nn.Conv2d(
+                            in_channels=[0, 0, 49, 25, 25, 9, 9][intLevel],
+                            out_channels=[0, 0, 49, 25, 25, 9, 9][intLevel],
+                            kernel_size=(1, [0, 0, 7, 5, 5, 3, 3][intLevel]),
+                            stride=1,
+                            padding=(0, [0, 0, 3, 2, 2, 1, 1][intLevel]),
+                        ),
+                    )
+
+                # end
+
+                self.netScaleX = torch.nn.Conv2d(
+                    in_channels=[0, 0, 49, 25, 25, 9, 9][intLevel], out_channels=1, kernel_size=1, stride=1, padding=0
+                )
+                self.netScaleY = torch.nn.Conv2d(
+                    in_channels=[0, 0, 49, 25, 25, 9, 9][intLevel], out_channels=1, kernel_size=1, stride=1, padding=0
+                )
+
+            # eny
+
+            def forward(self, tenOne, tenTwo, tenFeaturesOne, tenFeaturesTwo, tenFlow):
+                tenDifference = (
+                    ((tenOne - backwarp(tenInput=tenTwo, tenFlow=tenFlow * self.fltBackward)) ** 2)
+                    .sum(1, True)
+                    .sqrt()
+                    .detach()
+                )
+
+                tenDist = self.netDist(
+                    self.netMain(
+                        torch.cat(
+                            [
+                                tenDifference,
+                                tenFlow
+                                - tenFlow.view(tenFlow.shape[0], 2, -1).mean(2, True).view(tenFlow.shape[0], 2, 1, 1),
+                                self.netFeat(tenFeaturesOne),
+                            ],
+                            1,
+                        )
+                    )
+                )
+                tenDist = (tenDist**2).neg()
+                tenDist = (tenDist - tenDist.max(1, True)[0]).exp()
+
+                tenDivisor = tenDist.sum(1, True).reciprocal()
+
+                tenScaleX = (
+                    self.netScaleX(
+                        tenDist
+                        * torch.nn.functional.unfold(
+                            input=tenFlow[:, 0:1, :, :],
+                            kernel_size=self.intUnfold,
+                            stride=1,
+                            padding=int((self.intUnfold - 1) / 2),
+                        ).view_as(tenDist)
+                    )
+                    * tenDivisor
+                )
+                tenScaleY = (
+                    self.netScaleY(
+                        tenDist
+                        * torch.nn.functional.unfold(
+                            input=tenFlow[:, 1:2, :, :],
+                            kernel_size=self.intUnfold,
+                            stride=1,
+                            padding=int((self.intUnfold - 1) / 2),
+                        ).view_as(tenDist)
+                    )
+                    * tenDivisor
+                )
+
+                return torch.cat([tenScaleX, tenScaleY], 1)
+
+            # end
+
+        # end
+
+        self.netFeatures = Features()
+        self.netMatching = torch.nn.ModuleList([Matching(intLevel) for intLevel in [2, 3, 4, 5, 6]])
+        self.netSubpixel = torch.nn.ModuleList([Subpixel(intLevel) for intLevel in [2, 3, 4, 5, 6]])
+        self.netRegularization = torch.nn.ModuleList([Regularization(intLevel) for intLevel in [2, 3, 4, 5, 6]])
+
+        self.load_state_dict(
+            {
+                strKey.replace("module", "net"): tenWeight
+                for strKey, tenWeight in torch.hub.load_state_dict_from_url(
+                    url="http://content.sniklaus.com/github/pytorch-liteflownet/network-"
+                    + arguments_strModel
+                    + ".pytorch"
+                ).items()
+            }
+        )
+        # self.load_state_dict(torch.load('./liteflownet/network-default.pth'))
+
+    # end
+
+    def forward(self, tenOne, tenTwo):
+        tenOne[:, 0, :, :] = tenOne[:, 0, :, :] - 0.411618
+        tenOne[:, 1, :, :] = tenOne[:, 1, :, :] - 0.434631
+        tenOne[:, 2, :, :] = tenOne[:, 2, :, :] - 0.454253
+
+        tenTwo[:, 0, :, :] = tenTwo[:, 0, :, :] - 0.410782
+        tenTwo[:, 1, :, :] = tenTwo[:, 1, :, :] - 0.433645
+        tenTwo[:, 2, :, :] = tenTwo[:, 2, :, :] - 0.452793
+
+        tenFeaturesOne = self.netFeatures(tenOne)
+        tenFeaturesTwo = self.netFeatures(tenTwo)
+
+        tenOne = [tenOne]
+        tenTwo = [tenTwo]
+
+        for intLevel in [1, 2, 3, 4, 5]:
+            tenOne.append(
+                torch.nn.functional.interpolate(
+                    input=tenOne[-1],
+                    size=(tenFeaturesOne[intLevel].shape[2], tenFeaturesOne[intLevel].shape[3]),
+                    mode="bilinear",
+                    align_corners=False,
+                )
+            )
+            tenTwo.append(
+                torch.nn.functional.interpolate(
+                    input=tenTwo[-1],
+                    size=(tenFeaturesTwo[intLevel].shape[2], tenFeaturesTwo[intLevel].shape[3]),
+                    mode="bilinear",
+                    align_corners=False,
+                )
+            )
+        # end
+
+        tenFlow = None
+
+        for intLevel in [-1, -2, -3, -4, -5]:
+            tenFlow = self.netMatching[intLevel](
+                tenOne[intLevel], tenTwo[intLevel], tenFeaturesOne[intLevel], tenFeaturesTwo[intLevel], tenFlow
+            )
+            tenFlow = self.netSubpixel[intLevel](
+                tenOne[intLevel], tenTwo[intLevel], tenFeaturesOne[intLevel], tenFeaturesTwo[intLevel], tenFlow
+            )
+            tenFlow = self.netRegularization[intLevel](
+                tenOne[intLevel], tenTwo[intLevel], tenFeaturesOne[intLevel], tenFeaturesTwo[intLevel], tenFlow
+            )
+        # end
+
+        return tenFlow * 20.0
+
+    # end
+
+
+# end
+
+netNetwork = None
+
+##########################################################
+
+
+def estimate(tenOne, tenTwo):
+    global netNetwork
+
+    if netNetwork is None:
+        netNetwork = Network().cuda().eval()
+    # end
+
+    assert tenOne.shape[1] == tenTwo.shape[1]
+    assert tenOne.shape[2] == tenTwo.shape[2]
+
+    intWidth = tenOne.shape[2]
+    intHeight = tenOne.shape[1]
+
+    # assert(intWidth == 1024) # remember that there is no guarantee for correctness, comment this line out if you acknowledge this and want to continue
+    # assert(intHeight == 436) # remember that there is no guarantee for correctness, comment this line out if you acknowledge this and want to continue
+
+    tenPreprocessedOne = tenOne.cuda().view(1, 3, intHeight, intWidth)
+    tenPreprocessedTwo = tenTwo.cuda().view(1, 3, intHeight, intWidth)
+
+    intPreprocessedWidth = int(math.floor(math.ceil(intWidth / 32.0) * 32.0))
+    intPreprocessedHeight = int(math.floor(math.ceil(intHeight / 32.0) * 32.0))
+
+    tenPreprocessedOne = torch.nn.functional.interpolate(
+        input=tenPreprocessedOne,
+        size=(intPreprocessedHeight, intPreprocessedWidth),
+        mode="bilinear",
+        align_corners=False,
+    )
+    tenPreprocessedTwo = torch.nn.functional.interpolate(
+        input=tenPreprocessedTwo,
+        size=(intPreprocessedHeight, intPreprocessedWidth),
+        mode="bilinear",
+        align_corners=False,
+    )
+
+    tenFlow = torch.nn.functional.interpolate(
+        input=netNetwork(tenPreprocessedOne, tenPreprocessedTwo),
+        size=(intHeight, intWidth),
+        mode="bilinear",
+        align_corners=False,
+    )
+
+    tenFlow[:, 0, :, :] *= float(intWidth) / float(intPreprocessedWidth)
+    tenFlow[:, 1, :, :] *= float(intHeight) / float(intPreprocessedHeight)
+
+    return tenFlow[0, :, :, :].cpu()
+
+
+# end
+
+##########################################################
+
+if __name__ == "__main__":
+    tenOne = torch.FloatTensor(
+        numpy.ascontiguousarray(
+            numpy.array(PIL.Image.open(arguments_strOne))[:, :, ::-1].transpose(2, 0, 1).astype(numpy.float32)
+            * (1.0 / 255.0)
+        )
+    )
+    tenTwo = torch.FloatTensor(
+        numpy.ascontiguousarray(
+            numpy.array(PIL.Image.open(arguments_strTwo))[:, :, ::-1].transpose(2, 0, 1).astype(numpy.float32)
+            * (1.0 / 255.0)
+        )
+    )
+
+    tenOutput = estimate(tenOne, tenTwo)
+
+    objOutput = open(arguments_strOut, "wb")
+
+    numpy.array([80, 73, 69, 72], numpy.uint8).tofile(objOutput)
+    numpy.array([tenOutput.shape[2], tenOutput.shape[1]], numpy.int32).tofile(objOutput)
+    numpy.array(tenOutput.numpy().transpose(1, 2, 0), numpy.float32).tofile(objOutput)
+
+    objOutput.close()
+# end

Helios-main/eval/utils/third_party/amt/networks/blocks/feat_enc.py

@@ -0,0 +1,335 @@
+import torch
+import torch.nn as nn
+
+
+class BottleneckBlock(nn.Module):
+    def __init__(self, in_planes, planes, norm_fn="group", stride=1):
+        super(BottleneckBlock, self).__init__()
+
+        self.conv1 = nn.Conv2d(in_planes, planes // 4, kernel_size=1, padding=0)
+        self.conv2 = nn.Conv2d(planes // 4, planes // 4, kernel_size=3, padding=1, stride=stride)
+        self.conv3 = nn.Conv2d(planes // 4, planes, kernel_size=1, padding=0)
+        self.relu = nn.ReLU(inplace=True)
+
+        num_groups = planes // 8
+
+        if norm_fn == "group":
+            self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes // 4)
+            self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes // 4)
+            self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+            if not stride == 1:
+                self.norm4 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+
+        elif norm_fn == "batch":
+            self.norm1 = nn.BatchNorm2d(planes // 4)
+            self.norm2 = nn.BatchNorm2d(planes // 4)
+            self.norm3 = nn.BatchNorm2d(planes)
+            if not stride == 1:
+                self.norm4 = nn.BatchNorm2d(planes)
+
+        elif norm_fn == "instance":
+            self.norm1 = nn.InstanceNorm2d(planes // 4)
+            self.norm2 = nn.InstanceNorm2d(planes // 4)
+            self.norm3 = nn.InstanceNorm2d(planes)
+            if not stride == 1:
+                self.norm4 = nn.InstanceNorm2d(planes)
+
+        elif norm_fn == "none":
+            self.norm1 = nn.Sequential()
+            self.norm2 = nn.Sequential()
+            self.norm3 = nn.Sequential()
+            if not stride == 1:
+                self.norm4 = nn.Sequential()
+
+        if stride == 1:
+            self.downsample = None
+
+        else:
+            self.downsample = nn.Sequential(nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm4)
+
+    def forward(self, x):
+        y = x
+        y = self.relu(self.norm1(self.conv1(y)))
+        y = self.relu(self.norm2(self.conv2(y)))
+        y = self.relu(self.norm3(self.conv3(y)))
+
+        if self.downsample is not None:
+            x = self.downsample(x)
+
+        return self.relu(x + y)
+
+
+class ResidualBlock(nn.Module):
+    def __init__(self, in_planes, planes, norm_fn="group", stride=1):
+        super(ResidualBlock, self).__init__()
+
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, padding=1, stride=stride)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1)
+        self.relu = nn.ReLU(inplace=True)
+
+        num_groups = planes // 8
+
+        if norm_fn == "group":
+            self.norm1 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+            self.norm2 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+            if not stride == 1:
+                self.norm3 = nn.GroupNorm(num_groups=num_groups, num_channels=planes)
+
+        elif norm_fn == "batch":
+            self.norm1 = nn.BatchNorm2d(planes)
+            self.norm2 = nn.BatchNorm2d(planes)
+            if not stride == 1:
+                self.norm3 = nn.BatchNorm2d(planes)
+
+        elif norm_fn == "instance":
+            self.norm1 = nn.InstanceNorm2d(planes)
+            self.norm2 = nn.InstanceNorm2d(planes)
+            if not stride == 1:
+                self.norm3 = nn.InstanceNorm2d(planes)
+
+        elif norm_fn == "none":
+            self.norm1 = nn.Sequential()
+            self.norm2 = nn.Sequential()
+            if not stride == 1:
+                self.norm3 = nn.Sequential()
+
+        if stride == 1:
+            self.downsample = None
+
+        else:
+            self.downsample = nn.Sequential(nn.Conv2d(in_planes, planes, kernel_size=1, stride=stride), self.norm3)
+
+    def forward(self, x):
+        y = x
+        y = self.relu(self.norm1(self.conv1(y)))
+        y = self.relu(self.norm2(self.conv2(y)))
+
+        if self.downsample is not None:
+            x = self.downsample(x)
+
+        return self.relu(x + y)
+
+
+class SmallEncoder(nn.Module):
+    def __init__(self, output_dim=128, norm_fn="batch", dropout=0.0):
+        super(SmallEncoder, self).__init__()
+        self.norm_fn = norm_fn
+
+        if self.norm_fn == "group":
+            self.norm1 = nn.GroupNorm(num_groups=8, num_channels=32)
+
+        elif self.norm_fn == "batch":
+            self.norm1 = nn.BatchNorm2d(32)
+
+        elif self.norm_fn == "instance":
+            self.norm1 = nn.InstanceNorm2d(32)
+
+        elif self.norm_fn == "none":
+            self.norm1 = nn.Sequential()
+
+        self.conv1 = nn.Conv2d(3, 32, kernel_size=7, stride=2, padding=3)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        self.in_planes = 32
+        self.layer1 = self._make_layer(32, stride=1)
+        self.layer2 = self._make_layer(64, stride=2)
+        self.layer3 = self._make_layer(96, stride=2)
+
+        self.dropout = None
+        if dropout > 0:
+            self.dropout = nn.Dropout2d(p=dropout)
+
+        self.conv2 = nn.Conv2d(96, output_dim, kernel_size=1)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)):
+                if m.weight is not None:
+                    nn.init.constant_(m.weight, 1)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, dim, stride=1):
+        layer1 = BottleneckBlock(self.in_planes, dim, self.norm_fn, stride=stride)
+        layer2 = BottleneckBlock(dim, dim, self.norm_fn, stride=1)
+        layers = (layer1, layer2)
+
+        self.in_planes = dim
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        # if input is list, combine batch dimension
+        is_list = isinstance(x, tuple) or isinstance(x, list)
+        if is_list:
+            batch_dim = x[0].shape[0]
+            x = torch.cat(x, dim=0)
+
+        x = self.conv1(x)
+        x = self.norm1(x)
+        x = self.relu1(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.conv2(x)
+
+        if self.training and self.dropout is not None:
+            x = self.dropout(x)
+
+        if is_list:
+            x = torch.split(x, [batch_dim, batch_dim], dim=0)
+
+        return x
+
+
+class BasicEncoder(nn.Module):
+    def __init__(self, output_dim=128, norm_fn="batch", dropout=0.0):
+        super(BasicEncoder, self).__init__()
+        self.norm_fn = norm_fn
+
+        if self.norm_fn == "group":
+            self.norm1 = nn.GroupNorm(num_groups=8, num_channels=64)
+
+        elif self.norm_fn == "batch":
+            self.norm1 = nn.BatchNorm2d(64)
+
+        elif self.norm_fn == "instance":
+            self.norm1 = nn.InstanceNorm2d(64)
+
+        elif self.norm_fn == "none":
+            self.norm1 = nn.Sequential()
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        self.in_planes = 64
+        self.layer1 = self._make_layer(64, stride=1)
+        self.layer2 = self._make_layer(72, stride=2)
+        self.layer3 = self._make_layer(128, stride=2)
+
+        # output convolution
+        self.conv2 = nn.Conv2d(128, output_dim, kernel_size=1)
+
+        self.dropout = None
+        if dropout > 0:
+            self.dropout = nn.Dropout2d(p=dropout)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)):
+                if m.weight is not None:
+                    nn.init.constant_(m.weight, 1)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, dim, stride=1):
+        layer1 = ResidualBlock(self.in_planes, dim, self.norm_fn, stride=stride)
+        layer2 = ResidualBlock(dim, dim, self.norm_fn, stride=1)
+        layers = (layer1, layer2)
+
+        self.in_planes = dim
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        # if input is list, combine batch dimension
+        is_list = isinstance(x, tuple) or isinstance(x, list)
+        if is_list:
+            batch_dim = x[0].shape[0]
+            x = torch.cat(x, dim=0)
+
+        x = self.conv1(x)
+        x = self.norm1(x)
+        x = self.relu1(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+
+        x = self.conv2(x)
+
+        if self.training and self.dropout is not None:
+            x = self.dropout(x)
+
+        if is_list:
+            x = torch.split(x, [batch_dim, batch_dim], dim=0)
+
+        return x
+
+
+class LargeEncoder(nn.Module):
+    def __init__(self, output_dim=128, norm_fn="batch", dropout=0.0):
+        super(LargeEncoder, self).__init__()
+        self.norm_fn = norm_fn
+
+        if self.norm_fn == "group":
+            self.norm1 = nn.GroupNorm(num_groups=8, num_channels=64)
+
+        elif self.norm_fn == "batch":
+            self.norm1 = nn.BatchNorm2d(64)
+
+        elif self.norm_fn == "instance":
+            self.norm1 = nn.InstanceNorm2d(64)
+
+        elif self.norm_fn == "none":
+            self.norm1 = nn.Sequential()
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        self.in_planes = 64
+        self.layer1 = self._make_layer(64, stride=1)
+        self.layer2 = self._make_layer(112, stride=2)
+        self.layer3 = self._make_layer(160, stride=2)
+        self.layer3_2 = self._make_layer(160, stride=1)
+
+        # output convolution
+        self.conv2 = nn.Conv2d(self.in_planes, output_dim, kernel_size=1)
+
+        self.dropout = None
+        if dropout > 0:
+            self.dropout = nn.Dropout2d(p=dropout)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d, nn.GroupNorm)):
+                if m.weight is not None:
+                    nn.init.constant_(m.weight, 1)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, dim, stride=1):
+        layer1 = ResidualBlock(self.in_planes, dim, self.norm_fn, stride=stride)
+        layer2 = ResidualBlock(dim, dim, self.norm_fn, stride=1)
+        layers = (layer1, layer2)
+
+        self.in_planes = dim
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        # if input is list, combine batch dimension
+        is_list = isinstance(x, tuple) or isinstance(x, list)
+        if is_list:
+            batch_dim = x[0].shape[0]
+            x = torch.cat(x, dim=0)
+
+        x = self.conv1(x)
+        x = self.norm1(x)
+        x = self.relu1(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer3_2(x)
+
+        x = self.conv2(x)
+
+        if self.training and self.dropout is not None:
+            x = self.dropout(x)
+
+        if is_list:
+            x = torch.split(x, [batch_dim, batch_dim], dim=0)
+
+        return x

Helios-main/eval/utils/third_party/amt/networks/blocks/ifrnet.py

@@ -0,0 +1,115 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from utils.third_party.amt.utils.flow_utils import warp
+
+
+def resize(x, scale_factor):
+    return F.interpolate(x, scale_factor=scale_factor, mode="bilinear", align_corners=False)
+
+
+def convrelu(in_channels, out_channels, kernel_size=3, stride=1, padding=1, dilation=1, groups=1, bias=True):
+    return nn.Sequential(
+        nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding, dilation, groups, bias=bias),
+        nn.PReLU(out_channels),
+    )
+
+
+class ResBlock(nn.Module):
+    def __init__(self, in_channels, side_channels, bias=True):
+        super(ResBlock, self).__init__()
+        self.side_channels = side_channels
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1, bias=bias), nn.PReLU(in_channels)
+        )
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(side_channels, side_channels, kernel_size=3, stride=1, padding=1, bias=bias),
+            nn.PReLU(side_channels),
+        )
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1, bias=bias), nn.PReLU(in_channels)
+        )
+        self.conv4 = nn.Sequential(
+            nn.Conv2d(side_channels, side_channels, kernel_size=3, stride=1, padding=1, bias=bias),
+            nn.PReLU(side_channels),
+        )
+        self.conv5 = nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1, bias=bias)
+        self.prelu = nn.PReLU(in_channels)
+
+    def forward(self, x):
+        out = self.conv1(x)
+
+        res_feat = out[:, : -self.side_channels, ...]
+        side_feat = out[:, -self.side_channels :, :, :]
+        side_feat = self.conv2(side_feat)
+        out = self.conv3(torch.cat([res_feat, side_feat], 1))
+
+        res_feat = out[:, : -self.side_channels, ...]
+        side_feat = out[:, -self.side_channels :, :, :]
+        side_feat = self.conv4(side_feat)
+        out = self.conv5(torch.cat([res_feat, side_feat], 1))
+
+        out = self.prelu(x + out)
+        return out
+
+
+class Encoder(nn.Module):
+    def __init__(self, channels, large=False):
+        super(Encoder, self).__init__()
+        self.channels = channels
+        prev_ch = 3
+        for idx, ch in enumerate(channels, 1):
+            k = 7 if large and idx == 1 else 3
+            p = 3 if k == 7 else 1
+            self.register_module(
+                f"pyramid{idx}", nn.Sequential(convrelu(prev_ch, ch, k, 2, p), convrelu(ch, ch, 3, 1, 1))
+            )
+            prev_ch = ch
+
+    def forward(self, in_x):
+        fs = []
+        for idx in range(len(self.channels)):
+            out_x = getattr(self, f"pyramid{idx + 1}")(in_x)
+            fs.append(out_x)
+            in_x = out_x
+        return fs
+
+
+class InitDecoder(nn.Module):
+    def __init__(self, in_ch, out_ch, skip_ch) -> None:
+        super().__init__()
+        self.convblock = nn.Sequential(
+            convrelu(in_ch * 2 + 1, in_ch * 2),
+            ResBlock(in_ch * 2, skip_ch),
+            nn.ConvTranspose2d(in_ch * 2, out_ch + 4, 4, 2, 1, bias=True),
+        )
+
+    def forward(self, f0, f1, embt):
+        h, w = f0.shape[2:]
+        embt = embt.repeat(1, 1, h, w)
+        out = self.convblock(torch.cat([f0, f1, embt], 1))
+        flow0, flow1 = torch.chunk(out[:, :4, ...], 2, 1)
+        ft_ = out[:, 4:, ...]
+        return flow0, flow1, ft_
+
+
+class IntermediateDecoder(nn.Module):
+    def __init__(self, in_ch, out_ch, skip_ch) -> None:
+        super().__init__()
+        self.convblock = nn.Sequential(
+            convrelu(in_ch * 3 + 4, in_ch * 3),
+            ResBlock(in_ch * 3, skip_ch),
+            nn.ConvTranspose2d(in_ch * 3, out_ch + 4, 4, 2, 1, bias=True),
+        )
+
+    def forward(self, ft_, f0, f1, flow0_in, flow1_in):
+        f0_warp = warp(f0, flow0_in)
+        f1_warp = warp(f1, flow1_in)
+        f_in = torch.cat([ft_, f0_warp, f1_warp, flow0_in, flow1_in], 1)
+        out = self.convblock(f_in)
+        flow0, flow1 = torch.chunk(out[:, :4, ...], 2, 1)
+        ft_ = out[:, 4:, ...]
+        flow0 = flow0 + 2.0 * resize(flow0_in, scale_factor=2.0)
+        flow1 = flow1 + 2.0 * resize(flow1_in, scale_factor=2.0)
+        return flow0, flow1, ft_

Helios-main/eval/utils/third_party/amt/networks/blocks/multi_flow.py

@@ -0,0 +1,65 @@
+import torch
+import torch.nn as nn
+
+from utils.third_party.amt.networks.blocks.ifrnet import (
+    ResBlock,
+    convrelu,
+    resize,
+)
+from utils.third_party.amt.utils.flow_utils import warp
+
+
+def multi_flow_combine(comb_block, img0, img1, flow0, flow1, mask=None, img_res=None, mean=None):
+    """
+    A parallel implementation of multiple flow field warping
+    comb_block: An nn.Seqential object.
+    img shape: [b, c, h, w]
+    flow shape: [b, 2*num_flows, h, w]
+    mask (opt):
+        If 'mask' is None, the function conduct a simple average.
+    img_res (opt):
+        If 'img_res' is None, the function adds zero instead.
+    mean (opt):
+        If 'mean' is None, the function adds zero instead.
+    """
+    b, c, h, w = flow0.shape
+    num_flows = c // 2
+    flow0 = flow0.reshape(b, num_flows, 2, h, w).reshape(-1, 2, h, w)
+    flow1 = flow1.reshape(b, num_flows, 2, h, w).reshape(-1, 2, h, w)
+
+    mask = mask.reshape(b, num_flows, 1, h, w).reshape(-1, 1, h, w) if mask is not None else None
+    img_res = img_res.reshape(b, num_flows, 3, h, w).reshape(-1, 3, h, w) if img_res is not None else 0
+    img0 = torch.stack([img0] * num_flows, 1).reshape(-1, 3, h, w)
+    img1 = torch.stack([img1] * num_flows, 1).reshape(-1, 3, h, w)
+    mean = torch.stack([mean] * num_flows, 1).reshape(-1, 1, 1, 1) if mean is not None else 0
+
+    img0_warp = warp(img0, flow0)
+    img1_warp = warp(img1, flow1)
+    img_warps = mask * img0_warp + (1 - mask) * img1_warp + mean + img_res
+    img_warps = img_warps.reshape(b, num_flows, 3, h, w)
+    imgt_pred = img_warps.mean(1) + comb_block(img_warps.view(b, -1, h, w))
+    return imgt_pred
+
+
+class MultiFlowDecoder(nn.Module):
+    def __init__(self, in_ch, skip_ch, num_flows=3):
+        super(MultiFlowDecoder, self).__init__()
+        self.num_flows = num_flows
+        self.convblock = nn.Sequential(
+            convrelu(in_ch * 3 + 4, in_ch * 3),
+            ResBlock(in_ch * 3, skip_ch),
+            nn.ConvTranspose2d(in_ch * 3, 8 * num_flows, 4, 2, 1, bias=True),
+        )
+
+    def forward(self, ft_, f0, f1, flow0, flow1):
+        n = self.num_flows
+        f0_warp = warp(f0, flow0)
+        f1_warp = warp(f1, flow1)
+        out = self.convblock(torch.cat([ft_, f0_warp, f1_warp, flow0, flow1], 1))
+        delta_flow0, delta_flow1, mask, img_res = torch.split(out, [2 * n, 2 * n, n, 3 * n], 1)
+        mask = torch.sigmoid(mask)
+
+        flow0 = delta_flow0 + 2.0 * resize(flow0, scale_factor=2.0).repeat(1, self.num_flows, 1, 1)
+        flow1 = delta_flow1 + 2.0 * resize(flow1, scale_factor=2.0).repeat(1, self.num_flows, 1, 1)
+
+        return flow0, flow1, mask, img_res

Helios-main/eval/utils/third_party/amt/networks/blocks/raft.py

@@ -0,0 +1,213 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def resize(x, scale_factor):
+    return F.interpolate(x, scale_factor=scale_factor, mode="bilinear", align_corners=False)
+
+
+def bilinear_sampler(img, coords, mask=False):
+    """Wrapper for grid_sample, uses pixel coordinates"""
+    H, W = img.shape[-2:]
+    xgrid, ygrid = coords.split([1, 1], dim=-1)
+    xgrid = 2 * xgrid / (W - 1) - 1
+    ygrid = 2 * ygrid / (H - 1) - 1
+
+    grid = torch.cat([xgrid, ygrid], dim=-1)
+    img = F.grid_sample(img, grid, align_corners=True)
+
+    if mask:
+        mask = (xgrid > -1) & (ygrid > -1) & (xgrid < 1) & (ygrid < 1)
+        return img, mask.float()
+
+    return img
+
+
+def coords_grid(batch, ht, wd, device):
+    coords = torch.meshgrid(torch.arange(ht, device=device), torch.arange(wd, device=device), indexing="ij")
+    coords = torch.stack(coords[::-1], dim=0).float()
+    return coords[None].repeat(batch, 1, 1, 1)
+
+
+class SmallUpdateBlock(nn.Module):
+    def __init__(self, cdim, hidden_dim, flow_dim, corr_dim, fc_dim, corr_levels=4, radius=3, scale_factor=None):
+        super(SmallUpdateBlock, self).__init__()
+        cor_planes = corr_levels * (2 * radius + 1) ** 2
+        self.scale_factor = scale_factor
+
+        self.convc1 = nn.Conv2d(2 * cor_planes, corr_dim, 1, padding=0)
+        self.convf1 = nn.Conv2d(4, flow_dim * 2, 7, padding=3)
+        self.convf2 = nn.Conv2d(flow_dim * 2, flow_dim, 3, padding=1)
+        self.conv = nn.Conv2d(corr_dim + flow_dim, fc_dim, 3, padding=1)
+
+        self.gru = nn.Sequential(
+            nn.Conv2d(fc_dim + 4 + cdim, hidden_dim, 3, padding=1),
+            nn.LeakyReLU(negative_slope=0.1, inplace=True),
+            nn.Conv2d(hidden_dim, hidden_dim, 3, padding=1),
+        )
+
+        self.feat_head = nn.Sequential(
+            nn.Conv2d(hidden_dim, hidden_dim, 3, padding=1),
+            nn.LeakyReLU(negative_slope=0.1, inplace=True),
+            nn.Conv2d(hidden_dim, cdim, 3, padding=1),
+        )
+
+        self.flow_head = nn.Sequential(
+            nn.Conv2d(hidden_dim, hidden_dim, 3, padding=1),
+            nn.LeakyReLU(negative_slope=0.1, inplace=True),
+            nn.Conv2d(hidden_dim, 4, 3, padding=1),
+        )
+
+        self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
+
+    def forward(self, net, flow, corr):
+        net = resize(net, 1 / self.scale_factor) if self.scale_factor is not None else net
+        cor = self.lrelu(self.convc1(corr))
+        flo = self.lrelu(self.convf1(flow))
+        flo = self.lrelu(self.convf2(flo))
+        cor_flo = torch.cat([cor, flo], dim=1)
+        inp = self.lrelu(self.conv(cor_flo))
+        inp = torch.cat([inp, flow, net], dim=1)
+
+        out = self.gru(inp)
+        delta_net = self.feat_head(out)
+        delta_flow = self.flow_head(out)
+
+        if self.scale_factor is not None:
+            delta_net = resize(delta_net, scale_factor=self.scale_factor)
+            delta_flow = self.scale_factor * resize(delta_flow, scale_factor=self.scale_factor)
+
+        return delta_net, delta_flow
+
+
+class BasicUpdateBlock(nn.Module):
+    def __init__(
+        self,
+        cdim,
+        hidden_dim,
+        flow_dim,
+        corr_dim,
+        corr_dim2,
+        fc_dim,
+        corr_levels=4,
+        radius=3,
+        scale_factor=None,
+        out_num=1,
+    ):
+        super(BasicUpdateBlock, self).__init__()
+        cor_planes = corr_levels * (2 * radius + 1) ** 2
+
+        self.scale_factor = scale_factor
+        self.convc1 = nn.Conv2d(2 * cor_planes, corr_dim, 1, padding=0)
+        self.convc2 = nn.Conv2d(corr_dim, corr_dim2, 3, padding=1)
+        self.convf1 = nn.Conv2d(4, flow_dim * 2, 7, padding=3)
+        self.convf2 = nn.Conv2d(flow_dim * 2, flow_dim, 3, padding=1)
+        self.conv = nn.Conv2d(flow_dim + corr_dim2, fc_dim, 3, padding=1)
+
+        self.gru = nn.Sequential(
+            nn.Conv2d(fc_dim + 4 + cdim, hidden_dim, 3, padding=1),
+            nn.LeakyReLU(negative_slope=0.1, inplace=True),
+            nn.Conv2d(hidden_dim, hidden_dim, 3, padding=1),
+        )
+
+        self.feat_head = nn.Sequential(
+            nn.Conv2d(hidden_dim, hidden_dim, 3, padding=1),
+            nn.LeakyReLU(negative_slope=0.1, inplace=True),
+            nn.Conv2d(hidden_dim, cdim, 3, padding=1),
+        )
+
+        self.flow_head = nn.Sequential(
+            nn.Conv2d(hidden_dim, hidden_dim, 3, padding=1),
+            nn.LeakyReLU(negative_slope=0.1, inplace=True),
+            nn.Conv2d(hidden_dim, 4 * out_num, 3, padding=1),
+        )
+
+        self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
+
+    def forward(self, net, flow, corr):
+        net = resize(net, 1 / self.scale_factor) if self.scale_factor is not None else net
+        cor = self.lrelu(self.convc1(corr))
+        cor = self.lrelu(self.convc2(cor))
+        flo = self.lrelu(self.convf1(flow))
+        flo = self.lrelu(self.convf2(flo))
+        cor_flo = torch.cat([cor, flo], dim=1)
+        inp = self.lrelu(self.conv(cor_flo))
+        inp = torch.cat([inp, flow, net], dim=1)
+
+        out = self.gru(inp)
+        delta_net = self.feat_head(out)
+        delta_flow = self.flow_head(out)
+
+        if self.scale_factor is not None:
+            delta_net = resize(delta_net, scale_factor=self.scale_factor)
+            delta_flow = self.scale_factor * resize(delta_flow, scale_factor=self.scale_factor)
+        return delta_net, delta_flow
+
+
+class BidirCorrBlock:
+    def __init__(self, fmap1, fmap2, num_levels=4, radius=4):
+        self.num_levels = num_levels
+        self.radius = radius
+        self.corr_pyramid = []
+        self.corr_pyramid_T = []
+
+        corr = BidirCorrBlock.corr(fmap1, fmap2)
+        batch, h1, w1, dim, h2, w2 = corr.shape
+        corr_T = corr.clone().permute(0, 4, 5, 3, 1, 2)
+
+        corr = corr.reshape(batch * h1 * w1, dim, h2, w2)
+        corr_T = corr_T.reshape(batch * h2 * w2, dim, h1, w1)
+
+        self.corr_pyramid.append(corr)
+        self.corr_pyramid_T.append(corr_T)
+
+        for _ in range(self.num_levels - 1):
+            corr = F.avg_pool2d(corr, 2, stride=2)
+            corr_T = F.avg_pool2d(corr_T, 2, stride=2)
+            self.corr_pyramid.append(corr)
+            self.corr_pyramid_T.append(corr_T)
+
+    def __call__(self, coords0, coords1):
+        r = self.radius
+        coords0 = coords0.permute(0, 2, 3, 1)
+        coords1 = coords1.permute(0, 2, 3, 1)
+        assert coords0.shape == coords1.shape, f"coords0 shape: [{coords0.shape}] is not equal to [{coords1.shape}]"
+        batch, h1, w1, _ = coords0.shape
+
+        out_pyramid = []
+        out_pyramid_T = []
+        for i in range(self.num_levels):
+            corr = self.corr_pyramid[i]
+            corr_T = self.corr_pyramid_T[i]
+
+            dx = torch.linspace(-r, r, 2 * r + 1, device=coords0.device)
+            dy = torch.linspace(-r, r, 2 * r + 1, device=coords0.device)
+            delta = torch.stack(torch.meshgrid(dy, dx, indexing="ij"), axis=-1)
+            delta_lvl = delta.view(1, 2 * r + 1, 2 * r + 1, 2)
+
+            centroid_lvl_0 = coords0.reshape(batch * h1 * w1, 1, 1, 2) / 2**i
+            centroid_lvl_1 = coords1.reshape(batch * h1 * w1, 1, 1, 2) / 2**i
+            coords_lvl_0 = centroid_lvl_0 + delta_lvl
+            coords_lvl_1 = centroid_lvl_1 + delta_lvl
+
+            corr = bilinear_sampler(corr, coords_lvl_0)
+            corr_T = bilinear_sampler(corr_T, coords_lvl_1)
+            corr = corr.view(batch, h1, w1, -1)
+            corr_T = corr_T.view(batch, h1, w1, -1)
+            out_pyramid.append(corr)
+            out_pyramid_T.append(corr_T)
+
+        out = torch.cat(out_pyramid, dim=-1)
+        out_T = torch.cat(out_pyramid_T, dim=-1)
+        return out.permute(0, 3, 1, 2).contiguous().float(), out_T.permute(0, 3, 1, 2).contiguous().float()
+
+    @staticmethod
+    def corr(fmap1, fmap2):
+        batch, dim, ht, wd = fmap1.shape
+        fmap1 = fmap1.view(batch, dim, ht * wd)
+        fmap2 = fmap2.view(batch, dim, ht * wd)
+
+        corr = torch.matmul(fmap1.transpose(1, 2), fmap2)
+        corr = corr.view(batch, ht, wd, 1, ht, wd)
+        return corr / torch.sqrt(torch.tensor(dim).float())

Helios-main/eval/utils/third_party/amt/scripts/benchmark_arbitrary.sh

@@ -0,0 +1,5 @@
+CFG=$1
+CKPT=$2
+
+python benchmarks/gopro.py -c $CFG -p $CKPT
+python benchmarks/adobe240.py -c $CFG -p $CKPT

Helios-main/eval/utils/third_party/amt/scripts/benchmark_fixed.sh

@@ -0,0 +1,7 @@
+CFG=$1
+CKPT=$2
+
+python benchmarks/vimeo90k.py -c $CFG -p $CKPT
+python benchmarks/ucf101.py -c $CFG -p $CKPT
+python benchmarks/snu_film.py -c $CFG -p $CKPT
+python benchmarks/xiph.py -c $CFG -p $CKPT

Helios-main/helios/modules/helios_kernels/__init__.py

@@ -0,0 +1,5 @@
+from .attention_dispatch import attn_varlen_func, create_navit_attention_masks
+from .fp32_rmsnorm import replace_rmsnorm_with_fp32
+from .tiled_linear import replace_linear_with_tiled_linear
+from .triton_norm import replace_all_norms_with_flash_norms
+from .triton_rope import replace_rope_with_flash_rope

Helios-main/helios/modules/helios_kernels/attention_dispatch.py

@@ -0,0 +1,167 @@
+import torch
+from kernels import get_kernel
+
+
+try:
+    # FA3 Only support Hopper (SM90, H100/H800)
+    major, _ = torch.cuda.get_device_capability()
+    if major < 9:
+        raise RuntimeError("FA3 requires Hopper (SM90+), current GPU not supported")
+    flash_attn3 = get_kernel("kernels-community/flash-attn3")
+    flash_attn_func = flash_attn3.flash_attn_func
+    flash_attn_varlen_func = flash_attn3.flash_attn_varlen_func
+    print("Flash Attn 3 is installed!")
+except (ImportError, RuntimeError):
+    try:
+        flash_attn2 = get_kernel("kernels-community/flash-attn2")
+        flash_attn_func = flash_attn2.flash_attn_func
+        flash_attn_varlen_func = flash_attn2.flash_attn_varlen_func
+        print("Flash Attn 2 is installed!")
+    except ImportError:
+        print("Flash Attn 2 / 3 is not installed!")
+        flash_attn_varlen_func = None
+        flash_attn_func = None
+
+
+try:
+    # raise NotImplementedError
+    from sageattention import sageattn, sageattn_varlen
+
+    print("Sage Attn is installed!")
+except ImportError:
+    print("Sage Attn is not installed!")
+    sageattn_varlen = None
+    sageattn = None
+
+try:
+    # raise NotImplementedError
+    from xformers.ops import memory_efficient_attention as xformers_attn_func
+
+    print("Xformers is installed!")
+except ImportError:
+    print("Xformers is not installed!")
+    xformers_attn_func = None
+
+
+def create_navit_attention_masks(
+    batch_size: int,
+    original_context_length_list: list,
+    history_context_length: int,
+    encoder_hidden_states_seq_len: int,
+    device: torch.device,
+    restrict_self_attn: bool = False,
+    guidance_cross_attn: bool = False,
+):
+    # For navit_hidden_attention_mask
+    if restrict_self_attn:
+        cu_seqlens_q = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_q.append(cu_seqlens_q[-1] + length)
+        cu_seqlens_q = torch.tensor(cu_seqlens_q, device=device, dtype=torch.int32)
+        max_seqlen_q = max(original_context_length_list)
+
+        cu_seqlens_kv = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_kv.append(cu_seqlens_kv[-1] + length + history_context_length)
+        cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+        max_seqlen_kv = max(original_context_length_list) + history_context_length
+    else:
+        cu_seqlens_kv = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_kv.append(cu_seqlens_kv[-1] + length + history_context_length)
+        cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+        max_seqlen_kv = max(original_context_length_list) + history_context_length
+        cu_seqlens_q = cu_seqlens_kv
+        max_seqlen_q = max_seqlen_kv
+    navit_hidden_attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv
+
+    # For navit_history_hidden_attention_mask
+    navit_history_hidden_attention_mask = None
+    if restrict_self_attn:
+        cu_seqlens_kv = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cu_seqlens_kv.append(cu_seqlens_kv[-1] + history_context_length)
+        cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+        max_seqlen_kv = history_context_length
+        cu_seqlens_q = cu_seqlens_kv
+        max_seqlen_q = max_seqlen_kv
+        navit_history_hidden_attention_mask = cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv
+
+    # For navit_encoder_attention_mask
+    if guidance_cross_attn:
+        cross_cu_seqlens_q = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cross_cu_seqlens_q.append(cross_cu_seqlens_q[-1] + length)
+        cross_cu_seqlens_q = torch.tensor(cross_cu_seqlens_q, device=device, dtype=torch.int32)
+        cross_max_seqlen_q = max(original_context_length_list)
+    else:
+        cross_cu_seqlens_q = [0]
+        for _ in range(batch_size):
+            for length in original_context_length_list:
+                cross_cu_seqlens_q.append(cross_cu_seqlens_q[-1] + length + history_context_length)
+        cross_cu_seqlens_q = torch.tensor(cross_cu_seqlens_q, device=device, dtype=torch.int32)
+        cross_cu_seqlens_q[0] = 0
+        cross_max_seqlen_q = max(original_context_length_list) + history_context_length
+
+    cu_seqlens_kv = [0]
+    for _ in range(batch_size):
+        for length in original_context_length_list:
+            cu_seqlens_kv.append(cu_seqlens_kv[-1] + encoder_hidden_states_seq_len)
+    cu_seqlens_kv = torch.tensor(cu_seqlens_kv, device=device, dtype=torch.int32)
+    max_seqlen_kv = encoder_hidden_states_seq_len
+    navit_encoder_attention_mask = cross_cu_seqlens_q, cu_seqlens_kv, cross_max_seqlen_q, max_seqlen_kv
+
+    return navit_hidden_attention_mask, navit_encoder_attention_mask, navit_history_hidden_attention_mask
+
+
+@torch.compiler.disable
+def _flash_attn_wrapper(q, k, v):
+    return flash_attn_func(q, k, v)
+
+
+@torch.compiler.disable
+def _flash_attn_varlen_wrapper(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv):
+    return flash_attn_varlen_func(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+
+
+def attn_varlen_func(q, k, v, attention_mask=None):
+    if attention_mask is None:
+        if flash_attn_func is not None:
+            x = _flash_attn_wrapper(q, k, v)
+            return x
+
+        if sageattn is not None:
+            x = sageattn(q, k, v, tensor_layout="NHD")
+            return x
+
+        if xformers_attn_func is not None:
+            x = xformers_attn_func(q, k, v)
+            return x
+
+        x = torch.nn.functional.scaled_dot_product_attention(
+            q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2)
+        ).transpose(1, 2)
+        return x
+
+    B, L, H, C = q.shape
+
+    q = q.flatten(0, 1)
+    k = k.flatten(0, 1)
+    v = v.flatten(0, 1)
+
+    cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv = attention_mask
+    if flash_attn_varlen_func is not None:
+        x = _flash_attn_varlen_wrapper(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+    elif sageattn_varlen is not None:
+        x = sageattn_varlen(q, k, v, cu_seqlens_q, cu_seqlens_kv, max_seqlen_q, max_seqlen_kv)
+    else:
+        raise NotImplementedError("No Attn Installed!")
+
+    x = x.unflatten(0, (B, L))
+
+    return x

Helios-main/helios/modules/helios_kernels/tiled_linear.py

@@ -0,0 +1,399 @@
+import functools
+import math
+from typing import Callable, List, Optional
+
+import torch
+import torch.nn as nn
+
+from diffusers.models.activations import GEGLU, GELU, ApproximateGELU, LinearActivation, SwiGLU
+from diffusers.utils import deprecate
+
+
+# ------------------------------- replace funtion -------------------------------
+
+
+def replace_linear_with_tiled_linear(model, num_shards=None, patch_by_names=True, patch_by_types=True):
+    target_names = ["to_q", "to_k", "to_v", "add_k_proj", "add_v_proj"]
+    target_types = ["FeedForward"]
+
+    patched_count = 0
+
+    def tiled_forward(self, x):
+        compute_params = list(self.parameters())
+        return apply_tiled_linear(
+            fn=lambda module, input: module._original_forward(input),
+            mlp_module=self,
+            x=x,
+            num_shards=num_shards,
+            compute_params=compute_params,
+        )
+
+    for name, module in model.named_modules():
+        layer_name = name.rsplit(".", 1)[-1] if "." in name else name
+        module_type = type(module).__name__
+
+        should_patch = False
+        if patch_by_types and module_type in target_types:
+            should_patch = True
+        if patch_by_names and layer_name in target_names and isinstance(module, torch.nn.Linear):
+            should_patch = True
+
+        if should_patch:
+            module._original_forward = module.forward
+            module.forward = tiled_forward.__get__(module, module.__class__)
+            patched_count += 1
+            # print(f"  Patched {module_type}: {name}")
+
+    print(f"Patched {patched_count} FeedForward modules with TiledMLP\n")
+    return model
+
+
+# ------------------------------- Tiled MLP -------------------------------
+
+
+def ensure_contiguous(fn):
+    @functools.wraps(fn)
+    def wrapper(ctx, *args, **kwargs):
+        def maybe_to_contiguous(x):
+            return x.contiguous() if isinstance(x, torch.Tensor) else x
+
+        args = [maybe_to_contiguous(arg) for arg in args]
+        kwargs = {k: maybe_to_contiguous(v) for k, v in kwargs.items()}
+        return fn(ctx, *args, **kwargs)
+
+    return wrapper
+
+
+class TiledLinear(torch.autograd.Function):
+    """
+    Based on DeepSpeed's TiledMLP:
+    https://github.com/deepspeedai/DeepSpeed/blob/v0.18.2/deepspeed/runtime/sequence_parallel/ulysses_sp.py#L838
+
+    Perform a tiled MLP computation to massively reduce memory usage needed to compute MLP
+    when using very long sequence lengths.
+
+    This module re-computes `forward` in the `backward`. So the `forward` occurs twice each iteration.
+    And if you're using activation checkpointing it then occurs thrice.
+
+    Args:
+        fn: the function to call on sharded inputs (e.g., mlp.forward)
+        mlp_module: the MLP nn.Module object
+        x: the input to MLP.forward (hidden_states)
+        shards: how many shards to use
+        compute_params: a list of weights engaged in the compute
+
+    Returns:
+        the computed hidden_states
+    """
+
+    @staticmethod
+    @ensure_contiguous
+    def forward(
+        ctx,
+        fn: Callable,
+        mlp_module: torch.nn.Module,
+        x: torch.Tensor,
+        shards: int,
+        compute_params: Optional[List[torch.nn.Parameter]] = None,
+    ) -> torch.Tensor:
+        ctx.fn = fn
+        ctx.mlp_module = mlp_module
+        ctx.shards = shards
+        ctx.save_for_backward(x)
+
+        # x.shape could be [bs, seqlen, hidden_size] or [seqlen, hidden_size] (moe experts)
+        x_shards = list(torch.chunk(x, chunks=shards, dim=-2))
+        with torch.no_grad():
+            output_shards = [fn(mlp_module, x_shard) for x_shard in x_shards]
+        output_unsharded = torch.cat(output_shards, dim=-2)
+
+        return output_unsharded
+
+    @staticmethod
+    @ensure_contiguous
+    def backward(ctx, *grads) -> tuple:
+        fn = ctx.fn
+        (x,) = ctx.saved_tensors
+        mlp_module = ctx.mlp_module
+        shards = ctx.shards
+
+        x_requires_grad = x.requires_grad
+        x = x.detach()
+        # detach() unsets x.requires_grad, so restore it
+        x.requires_grad_(x_requires_grad)
+
+        # x.shape could be [bs, seqlen, hidden_size] or [seqlen, hidden_size] (moe experts)
+        hidden_size = x.shape[-1]
+        x_shape_orig = x.shape
+
+        # flatten bs+seqlen to avoid having stride issues when narrowing into seqlen w/ bs>1
+        x = x.view(-1, hidden_size)
+        incoming_grad = grads[0].view(-1, hidden_size)
+        x_grad = torch.zeros_like(x)
+
+        x_shards = list(torch.chunk(x, chunks=shards, dim=0))
+
+        trainable_params = [p for p in mlp_module.parameters() if p.requires_grad]
+
+        for i, x_shard in enumerate(x_shards):
+            x_shard = x_shard.detach().requires_grad_(x_requires_grad)
+
+            shard_step = x_shards[i].shape[0]
+            shard_offset = i * x_shards[0].shape[0]
+
+            incoming_grad_shard = incoming_grad.narrow(0, shard_offset, shard_step).view_as(x_shard)
+
+            with torch.enable_grad():
+                output = fn(mlp_module, x_shard)
+
+            grads_tuple = torch.autograd.grad(
+                outputs=output,
+                inputs=[x_shard] + trainable_params,
+                grad_outputs=incoming_grad_shard,
+                allow_unused=True,
+                retain_graph=False,
+            )
+
+            x_grad.narrow(0, shard_offset, shard_step).copy_(grads_tuple[0])
+
+            for param, grad in zip(trainable_params, grads_tuple[1:]):
+                if grad is not None:
+                    if param.grad is None:
+                        param.grad = grad
+                    else:
+                        param.grad.add_(grad)
+
+        # unflatten
+        x_grad = x_grad.view(x_shape_orig)
+
+        return (None, None, x_grad, None, None)
+
+
+def apply_tiled_linear(
+    fn: Callable,
+    mlp_module: torch.nn.Module,
+    x: torch.Tensor,
+    num_shards: Optional[int] = None,
+    compute_params: Optional[List[torch.nn.Parameter]] = None,
+) -> torch.Tensor:
+    """
+    Apply tiled MLP computation for memory efficiency.
+
+    Args:
+        fn: the function to call on sharded inputs (e.g., lambda module, x: module(x))
+        mlp_module: the MLP nn.Module object
+        x: the input tensor with shape [bs, seqlen, hidden_size] or [seqlen, hidden_size]
+        num_shards: number of shards to use. If None, automatically calculated as ceil(seqlen / hidden_size)
+        compute_params: list of parameters for DeepSpeed ZeRO optimization
+
+    Returns:
+        output tensor with the same shape as input
+    """
+    if num_shards is None:
+        # x.shape could be [bs, seqlen, hidden_size] or [seqlen, hidden_size]
+        hidden_size = x.shape[-1]
+        seqlen = x.shape[-2]
+        num_shards = math.ceil(seqlen / hidden_size)
+
+    # Ensure num_shards is at least 1
+    num_shards = max(1, num_shards)
+
+    return TiledLinear.apply(
+        fn,
+        mlp_module,
+        x,
+        num_shards,
+        compute_params,
+    )
+
+
+# ------------------------------- Tiled FeedForward -------------------------------
+class FeedForward(nn.Module):
+    r"""
+    A feed-forward layer.
+
+    Parameters:
+        dim (`int`): The number of channels in the input.
+        dim_out (`int`, *optional*): The number of channels in the output. If not given, defaults to `dim`.
+        mult (`int`, *optional*, defaults to 4): The multiplier to use for the hidden dimension.
+        dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use.
+        activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to be used in feed-forward.
+        final_dropout (`bool` *optional*, defaults to False): Apply a final dropout.
+        bias (`bool`, defaults to True): Whether to use a bias in the linear layer.
+    """
+
+    def __init__(
+        self,
+        dim: int,
+        dim_out: Optional[int] = None,
+        mult: int = 4,
+        dropout: float = 0.0,
+        activation_fn: str = "geglu",
+        final_dropout: bool = False,
+        inner_dim=None,
+        bias: bool = True,
+    ):
+        super().__init__()
+        if inner_dim is None:
+            inner_dim = int(dim * mult)
+        dim_out = dim_out if dim_out is not None else dim
+
+        if activation_fn == "gelu":
+            act_fn = GELU(dim, inner_dim, bias=bias)
+        if activation_fn == "gelu-approximate":
+            act_fn = GELU(dim, inner_dim, approximate="tanh", bias=bias)
+        elif activation_fn == "geglu":
+            act_fn = GEGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "geglu-approximate":
+            act_fn = ApproximateGELU(dim, inner_dim, bias=bias)
+        elif activation_fn == "swiglu":
+            act_fn = SwiGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "linear-silu":
+            act_fn = LinearActivation(dim, inner_dim, bias=bias, activation="silu")
+
+        self.net = nn.ModuleList([])
+        # project in
+        self.net.append(act_fn)
+        # project dropout
+        self.net.append(nn.Dropout(dropout))
+        # project out
+        self.net.append(nn.Linear(inner_dim, dim_out, bias=bias))
+        # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
+        if final_dropout:
+            self.net.append(nn.Dropout(dropout))
+
+    def forward(self, hidden_states: torch.Tensor, *args, **kwargs) -> torch.Tensor:
+        if len(args) > 0 or kwargs.get("scale", None) is not None:
+            deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
+            deprecate("scale", "1.0.0", deprecation_message)
+        for module in self.net:
+            hidden_states = module(hidden_states)
+        return hidden_states
+
+
+class TiledFeedForward(nn.Module):
+    """
+    Memory-efficient FeedForward using tiled computation (diffusers compatible)
+    Args:
+        dim: Input dimension
+        dim_out: Output dimension (default: dim)
+        mult: Multiplier for inner dimension (default: 4)
+        dropout: Dropout probability
+        activation_fn: Activation function ('geglu', 'gelu', 'gelu-approximate')
+        final_dropout: Apply dropout at the end
+        inner_dim: Inner dimension (overrides mult if provided)
+        bias: Use bias in linear layers
+        num_shards: Number of shards for tiling (None = auto)
+    """
+
+    def __init__(
+        self,
+        dim: int,
+        dim_out: Optional[int] = None,
+        mult: int = 4,
+        dropout: float = 0.0,
+        activation_fn: str = "geglu",
+        final_dropout: bool = False,
+        inner_dim: Optional[int] = None,
+        bias: bool = True,
+        num_shards: Optional[int] = None,
+    ):
+        super().__init__()
+
+        # Calculate dimensions
+        if inner_dim is None:
+            inner_dim = int(dim * mult)
+        dim_out = dim_out if dim_out is not None else dim
+
+        self.dim = dim
+        self.inner_dim = inner_dim
+        self.dim_out = dim_out
+        self.activation_fn = activation_fn
+        self.num_shards = num_shards
+
+        if activation_fn == "gelu":
+            act_fn = GELU(dim, inner_dim, bias=bias)
+        if activation_fn == "gelu-approximate":
+            act_fn = GELU(dim, inner_dim, approximate="tanh", bias=bias)
+        elif activation_fn == "geglu":
+            act_fn = GEGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "geglu-approximate":
+            act_fn = ApproximateGELU(dim, inner_dim, bias=bias)
+        elif activation_fn == "swiglu":
+            act_fn = SwiGLU(dim, inner_dim, bias=bias)
+        elif activation_fn == "linear-silu":
+            act_fn = LinearActivation(dim, inner_dim, bias=bias, activation="silu")
+
+        self.net = nn.ModuleList([])
+        # project in
+        self.net.append(act_fn)
+        # project dropout
+        self.net.append(nn.Dropout(dropout))
+        # project out
+        self.net.append(nn.Linear(inner_dim, dim_out, bias=bias))
+        # FF as used in Vision Transformer, MLP-Mixer, etc. have a final dropout
+        if final_dropout:
+            self.net.append(nn.Dropout(dropout))
+
+    def _mlp_forward(self, module, x):
+        """Internal MLP forward for tiled computation"""
+        for layer in module.net:
+            x = layer(x)
+        return x
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        """
+        Forward pass with tiled computation
+        Args:
+            hidden_states: [batch_size, seq_len, dim] or [seq_len, dim]
+        Returns:
+            Output tensor with same shape as input (but last dim = dim_out)
+        """
+        # Collect compute parameters
+        compute_params = list(self.parameters())
+
+        return apply_tiled_linear(
+            fn=self._mlp_forward,
+            mlp_module=self,
+            x=hidden_states,
+            num_shards=self.num_shards,
+            compute_params=compute_params,
+        )
+
+
+if __name__ == "__main__":
+    import torch
+    import torch.nn as nn
+
+    # 设置随机种子保证可重复性
+    torch.manual_seed(42)
+
+    # 创建测试输入
+    batch_size, seq_len, hidden_dim = 2, 1024, 768
+    x = torch.randn(batch_size, seq_len, hidden_dim, requires_grad=True)
+
+    # 方法1: replace
+    model1 = FeedForward(dim=hidden_dim)
+    # model1 = replace_linear_with_tiled_linear(model1, num_shards=4)
+    out1 = model1(x)
+    loss1 = out1.sum()
+    loss1.backward()
+    grad1 = x.grad.clone()
+
+    # 方法2: TiledFeedForward
+    x.grad = None
+    # model2 = TiledFeedForward(dim=hidden_dim, num_shards=4)
+    model2 = FeedForward(dim=hidden_dim)
+    model2 = replace_linear_with_tiled_linear(model2, num_shards=4)
+    # 复制权重确保完全一致
+    model2.load_state_dict(model1.state_dict(), strict=True)
+    out2 = model2(x)
+    loss2 = out2.sum()
+    loss2.backward()
+    grad2 = x.grad.clone()
+
+    # 比较结果
+    print(f"Output diff: {(out1 - out2).abs().max().item()}")
+    print(f"Gradient diff: {(grad1 - grad2).abs().max().item()}")
+    print(f"Output allclose: {torch.allclose(out1, out2, atol=1e-6)}")
+    print(f"Gradient allclose: {torch.allclose(grad1, grad2, atol=1e-6)}")

Helios-main/helios/modules/helios_kernels/triton_norm.py

@@ -0,0 +1,413 @@
+import torch
+import triton
+import triton.language as tl
+
+from diffusers.models.normalization import FP32LayerNorm, LayerNorm, RMSNorm
+
+from .fp32_rmsnorm import FP32RMSNorm
+from .utils import calculate_settings, torch_gpu_device
+
+
+# ------------------------------- replace funtion -------------------------------
+
+
+def replace_all_norms_with_flash_norms(model):
+    patched_count = {"LayerNorm": 0, "RMSNorm": 0}
+
+    for name, module in model.named_modules():
+        if isinstance(module, (LayerNorm, FP32LayerNorm)):
+            if hasattr(module, "elementwise_affine") and module.elementwise_affine:
+                module.forward = (lambda self, x: flash_layernorm(self, x)).__get__(module, module.__class__)
+                patched_count["LayerNorm"] += 1
+
+        if isinstance(module, (torch.nn.RMSNorm, RMSNorm, FP32RMSNorm)):
+            module.forward = (lambda self, x: flash_rms_layernorm(self, x)).__get__(module, module.__class__)
+            patched_count["RMSNorm"] += 1
+
+    print(f"Patched {patched_count['LayerNorm']} Flash_LayerNorm modules\n")
+    print(f"Patched {patched_count['RMSNorm']} Flash_RMSNorm modules\n")
+
+    return model
+
+
+# ------------------------------- layer norm -------------------------------
+
+
+@triton.jit
+def layernorm_forward(
+    Y,
+    Y_row_stride,
+    X,
+    X_row_stride,
+    W,
+    b,
+    r,
+    mu,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    Y += row_idx * Y_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx
+    mu += row_idx
+
+    # According to https://pytorch.org/torchtune/stable/_modules/torchtune/modules/layer_norm.html#Fp32LayerNorm, all modules
+    # are in float32!
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+    b_row = tl.load(b + col_offsets, mask=mask, other=0).to(tl.float32)
+
+    mean_X = tl.sum(X_row, axis=0) / n_cols
+    # (X[0] - mean) == -mean so we need to mask it out
+    XX = tl.where(mask, X_row - mean_X, 0)
+    row_var = tl.sum(XX * XX, axis=0) / n_cols
+    inv_var = tl.math.rsqrt(row_var + eps)
+    tl.store(r, inv_var)
+    tl.store(mu, mean_X)
+    output = (XX * inv_var) * W_row + b_row
+    tl.store(Y + col_offsets, output, mask=mask)
+
+
+@triton.jit
+def layernorm_backward(
+    dY,
+    dY_row_stride,
+    X,
+    X_row_stride,
+    W,
+    b,
+    r,
+    mu,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    # Approximately follows https://github.com/karpathy/llm.c/blob/master/doc/layernorm/layernorm.md
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    dY += row_idx * dY_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx
+    mu += row_idx
+
+    # According to https://pytorch.org/torchtune/stable/_modules/torchtune/modules/layer_norm.html#Fp32LayerNorm, all modules
+    # are in float32!
+    dY_row = tl.load(dY + col_offsets, mask=mask, other=0).to(tl.float32)
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+    # b_row = tl.load(b + col_offsets, mask = mask, other = 0).to(tl.float32)
+
+    inv_var = tl.load(r).to(tl.float32)
+    mean = tl.load(mu).to(tl.float32)
+    normed = (X_row - mean) * inv_var
+    dY_W = dY_row * W_row
+    dX_row = dY_W - tl.sum(dY_W, axis=0) / n_cols - normed * tl.sum(dY_W * normed, axis=0) / n_cols
+    dX_row = dX_row * inv_var
+    tl.store(dY + col_offsets, dX_row, mask=mask)
+
+
+class Flash_Layernorm(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, X, W, b, eps):
+        shape = X.shape
+        dim = shape[-1]
+        X = X.view(-1, dim)
+        n_rows, n_cols = X.shape
+        BLOCK_SIZE, num_warps = calculate_settings(n_cols)
+        device = X.device
+        Y = torch.empty((n_rows, n_cols), dtype=X.dtype, device=device)
+        r = torch.empty(n_rows, dtype=torch.float32, device=device)
+        mu = torch.empty(n_rows, dtype=torch.float32, device=device)
+
+        with torch_gpu_device(device):
+            layernorm_forward[(n_rows,)](
+                Y,
+                Y.stride(0),
+                X,
+                X.stride(0),
+                W,
+                b,
+                r,
+                mu,
+                n_cols,
+                eps,
+                BLOCK_SIZE=BLOCK_SIZE,
+                num_warps=num_warps,
+            )
+        ctx.eps = eps
+        ctx.BLOCK_SIZE = BLOCK_SIZE
+        ctx.num_warps = num_warps
+        ctx.save_for_backward(X, W, b, r, mu)
+        return Y.view(*shape)
+
+    @staticmethod
+    def backward(ctx, dY):
+        shape = dY.shape
+        dim = shape[-1]
+        dY = dY.view(-1, dim)
+        X, W, b, r, mu = ctx.saved_tensors
+        n_rows, n_cols = dY.shape
+
+        with torch_gpu_device(dY.device):
+            layernorm_backward[(n_rows,)](
+                dY,
+                dY.stride(0),
+                X,
+                X.stride(0),
+                W,
+                b,
+                r,
+                mu,
+                n_cols,
+                ctx.eps,
+                BLOCK_SIZE=ctx.BLOCK_SIZE,
+                num_warps=ctx.num_warps,
+            )
+        dX = dY.view(*shape)
+        return dX, None, None, None, None
+
+
+def flash_layernorm(layernorm, X):
+    assert layernorm.elementwise_affine is True
+    W = layernorm.weight
+    bias = layernorm.bias
+    eps = layernorm.variance_epsilon if hasattr(layernorm, "variance_epsilon") else layernorm.eps
+    out = Flash_Layernorm.apply(X, W, bias, eps)
+    return out
+
+
+# ------------------------------- layer norm -------------------------------
+
+
+# ------------------------------- rms norm -------------------------------
+
+
+@triton.jit
+def _rms_layernorm_forward(
+    Y,
+    Y_row_stride: tl.constexpr,
+    X,
+    X_row_stride: tl.constexpr,
+    W,
+    W_row_stride: tl.constexpr,
+    r,
+    r_row_stride: tl.constexpr,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    Flash RMS Layernorm kernel
+    Inspiration from a Triton tutorial:
+    https://triton-lang.org/main/getting-started/tutorials/05-layer-norm.html
+    """
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    Y += row_idx * Y_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx * r_row_stride
+
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0)  # .to(tl.float32)
+
+    row_var = tl.sum(X_row * X_row, axis=0) / n_cols
+    inv_var = tl.math.rsqrt(row_var + eps)
+    tl.store(r, inv_var)
+    normed = X_row * inv_var
+    normed = normed.to(W_row.dtype)  # Exact copy from HF
+    output = normed * W_row
+    tl.store(Y + col_offsets, output, mask=mask)
+
+
+def _rms_layernorm_backward(
+    dY,
+    dY_row_stride: tl.constexpr,
+    dX,
+    dX_row_stride: tl.constexpr,
+    X,
+    X_row_stride: tl.constexpr,
+    W,
+    W_row_stride: tl.constexpr,
+    r,
+    r_row_stride: tl.constexpr,
+    # dW, dW_row_stride,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    GEMMA: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    """
+    Flash RMS Layernorm kernel for the backward pass
+    Inspiration from a Triton tutorial:
+    https://triton-lang.org/main/getting-started/tutorials/05-layer-norm.html
+    """
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    dY += row_idx * dY_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx * r_row_stride
+
+    if GEMMA:
+        dX += row_idx * dY_row_stride
+    else:
+        dX = dY
+
+    dY_row = tl.load(dY + col_offsets, mask=mask, other=0).to(tl.float32)
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+
+    # Get saved row variance
+    inv_var = tl.load(r).to(tl.float32)
+    normed = X_row * inv_var
+
+    if GEMMA:
+        dY_W = dY_row * (W_row + 1.0)
+    else:
+        dY_W = dY_row * W_row
+
+    rowsum_dY_normed = tl.sum(dY_W * normed, axis=0)
+    output = inv_var / n_cols * (n_cols * dY_W - normed * rowsum_dY_normed)
+    tl.store(dX + col_offsets, output, mask=mask)
+
+
+_rms_layernorm_backward = triton.jit(_rms_layernorm_backward)
+_rms_layernorm_backward = triton.heuristics(
+    {
+        "GEMMA": lambda args: bool(args["GEMMA"]),
+    }
+)(_rms_layernorm_backward)
+
+
+@triton.jit
+def _gemma_rms_layernorm_forward(
+    Y,
+    Y_row_stride: tl.constexpr,
+    X,
+    X_row_stride: tl.constexpr,
+    W,
+    W_row_stride: tl.constexpr,
+    r,
+    r_row_stride: tl.constexpr,
+    n_cols: tl.constexpr,
+    eps: tl.constexpr,
+    BLOCK_SIZE: tl.constexpr,
+):
+    # Copies https://github.com/google-deepmind/gemma/blob/main/gemma/layers.py#L31
+    # and https://github.com/keras-team/keras-nlp/blob/v0.8.2/keras_nlp/models/gemma/rms_normalization.py#L33
+    # exactly. Essentially all in float32!
+    row_idx = tl.program_id(0)
+    col_offsets = tl.arange(0, BLOCK_SIZE)
+    mask = col_offsets < n_cols
+
+    Y += row_idx * Y_row_stride
+    X += row_idx * X_row_stride
+    r += row_idx * r_row_stride
+
+    X_row = tl.load(X + col_offsets, mask=mask, other=0).to(tl.float32)
+    W_row = tl.load(W + col_offsets, mask=mask, other=0).to(tl.float32)
+
+    row_var = tl.sum(X_row * X_row, axis=0) / n_cols
+    inv_var = tl.math.rsqrt(row_var + eps)
+    tl.store(r, inv_var)
+    normed = X_row * inv_var
+    output = normed * (W_row + 1.0)
+
+    tl.store(Y + col_offsets, output, mask=mask)
+
+
+class Flash_RMS_Layernorm(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, X: torch.Tensor, W: torch.Tensor, eps: float, gemma: bool = False):
+        shape = X.shape
+        dim: int = shape[-1]
+        X = X.reshape(-1, dim)
+        n_rows: int
+        n_cols: int
+        n_rows, n_cols = X.shape
+        BLOCK_SIZE: int
+        num_warps: int
+        BLOCK_SIZE, num_warps = calculate_settings(n_cols)
+        device = X.device
+
+        Y = torch.empty((n_rows, n_cols), dtype=X.dtype, device=device)
+        r = torch.empty(n_rows, dtype=torch.float32, device=device)
+
+        fx = _gemma_rms_layernorm_forward if gemma else _rms_layernorm_forward
+        with torch_gpu_device(device):
+            fx[(n_rows,)](
+                Y,
+                Y.stride(0),
+                X,
+                X.stride(0),
+                W,
+                W.stride(0),
+                r,
+                r.stride(0),
+                n_cols,
+                eps,
+                BLOCK_SIZE=BLOCK_SIZE,
+                num_warps=num_warps,
+            )
+        ctx.eps = eps
+        ctx.BLOCK_SIZE = BLOCK_SIZE
+        ctx.num_warps = num_warps
+        ctx.GEMMA = gemma
+        ctx.save_for_backward(X, W, r)
+        return Y.view(*shape)
+
+    @staticmethod
+    def backward(ctx, dY: torch.Tensor):
+        shape = dY.shape
+        dim: int = shape[-1]
+        dY = dY.reshape(-1, dim)
+        X, W, r = ctx.saved_tensors
+        n_rows: int
+        n_cols: int
+        n_rows, n_cols = dY.shape
+        # dW = X
+        dX = torch.empty_like(dY) if ctx.GEMMA else dY
+
+        with torch_gpu_device(dY.device):
+            _rms_layernorm_backward[(n_rows,)](
+                dY,
+                dY.stride(0),
+                dX,
+                dX.stride(0),
+                X,
+                X.stride(0),
+                W,
+                W.stride(0),
+                r,
+                r.stride(0),
+                # dW, dW.stride(0),
+                n_cols,
+                ctx.eps,
+                GEMMA=ctx.GEMMA,
+                BLOCK_SIZE=ctx.BLOCK_SIZE,
+                num_warps=ctx.num_warps,
+            )
+        dX = dX.view(*shape)
+        return dX, None, None, None
+
+
+# [TODO] Unsure why RMS Layernorm is not torch.compiling properly
+@torch.compiler.disable
+def flash_rms_layernorm(layernorm, X: torch.Tensor, gemma: bool = False):
+    W: torch.Tensor = layernorm.weight
+    eps: float = layernorm.variance_epsilon if hasattr(layernorm, "variance_epsilon") else layernorm.eps
+    out = Flash_RMS_Layernorm.apply(X, W, eps, gemma)
+    return out
+
+
+# ------------------------------- rms norm -------------------------------

Helios-main/helios/modules/helios_kernels/utils.py

@@ -0,0 +1,70 @@
+from contextlib import nullcontext
+
+import torch
+import triton
+
+
+def get_device_type():
+    if torch.cuda.is_available():
+        try:
+            if torch.version.hip is not None:
+                return "hip"
+        except AttributeError:
+            pass
+        return "cuda"
+
+    try:
+        if hasattr(torch, "xpu") and torch.xpu.is_available():
+            return "xpu"
+    except (AttributeError, RuntimeError):
+        pass
+
+    return "cpu"
+
+
+def get_device_count(device_type):
+    if device_type == "cuda" or device_type == "hip":
+        return torch.cuda.device_count()
+    elif device_type == "xpu":
+        try:
+            return torch.xpu.device_count()
+        except (AttributeError, RuntimeError):
+            return 0
+    return 0
+
+
+MAX_FUSED_SIZE: int = 65536
+next_power_of_2 = triton.next_power_of_2
+DEVICE_TYPE = get_device_type()
+DEVICE_COUNT = get_device_count(DEVICE_TYPE)
+
+if DEVICE_COUNT > 1:
+    if DEVICE_TYPE in ("cuda", "hip"):
+        torch_gpu_device = torch.cuda.device
+    elif DEVICE_TYPE == "xpu":
+        torch_gpu_device = torch.xpu.device
+else:
+
+    def torch_gpu_device(device):
+        return nullcontext()
+
+
+def calculate_settings(
+    n: int,
+) -> (
+    int,
+    int,
+):
+    BLOCK_SIZE: int = next_power_of_2(n)
+    if BLOCK_SIZE > MAX_FUSED_SIZE:
+        raise RuntimeError(
+            f"Cannot launch Triton kernel since n = {n} exceeds the maximum CUDA blocksize = {MAX_FUSED_SIZE}."
+        )
+    num_warps: int = 4
+    if BLOCK_SIZE >= 32768:
+        num_warps = 32
+    elif BLOCK_SIZE >= 8192:
+        num_warps = 16
+    elif BLOCK_SIZE >= 2048:
+        num_warps = 8
+    return BLOCK_SIZE, num_warps

Helios-main/scripts/accelerate_configs/multi_node_example_zero2.yaml

@@ -0,0 +1,14 @@
+compute_environment: LOCAL_MACHINE
+distributed_type: DEEPSPEED
+deepspeed_config:
+ deepspeed_config_file: scripts/accelerate_configs/zero2.json
+ deepspeed_multinode_launcher: standard
+fsdp_config: {}
+machine_rank: 0
+main_training_function: main
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

Helios-main/scripts/accelerate_configs/multi_node_example_zero3.yaml

@@ -0,0 +1,14 @@
+compute_environment: LOCAL_MACHINE
+distributed_type: DEEPSPEED
+deepspeed_config:
+ deepspeed_config_file: scripts/accelerate_configs/zero3.json
+ deepspeed_multinode_launcher: standard
+fsdp_config: {}
+machine_rank: 0
+main_training_function: main
+rdzv_backend: static
+same_network: true
+tpu_env: []
+tpu_use_cluster: false
+tpu_use_sudo: false
+use_cpu: false

Helios-main/scripts/accelerate_configs/scheduler_config.json

@@ -0,0 +1,28 @@
+{
+  "_class_name": "UniPCMultistepScheduler",
+  "_diffusers_version": "0.33.0.dev0",
+  "beta_end": 0.02,
+  "beta_schedule": "linear",
+  "beta_start": 0.0001,
+  "disable_corrector": [],
+  "dynamic_thresholding_ratio": 0.995,
+  "final_sigmas_type": "zero",
+  "flow_shift": 3.0,
+  "lower_order_final": true,
+  "num_train_timesteps": 1000,
+  "predict_x0": true,
+  "prediction_type": "flow_prediction",
+  "rescale_betas_zero_snr": false,
+  "sample_max_value": 1.0,
+  "solver_order": 2,
+  "solver_p": null,
+  "solver_type": "bh2",
+  "steps_offset": 0,
+  "thresholding": false,
+  "timestep_spacing": "linspace",
+  "trained_betas": null,
+  "use_beta_sigmas": false,
+  "use_exponential_sigmas": false,
+  "use_flow_sigmas": true,
+  "use_karras_sigmas": false
+}

Helios-main/scripts/accelerate_configs/zero2.json

@@ -0,0 +1,25 @@
+{
+    "fp16": {
+        "enabled": false,
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "communication_data_type": "fp32",
+    "gradient_clipping": 1.0,
+    "train_micro_batch_size_per_gpu": "auto",
+    "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "zero_optimization": {
+        "stage": 2,
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "reduce_bucket_size": 1e9,
+        "allgather_bucket_size": 536870912
+    }
+}

Helios-main/scripts/accelerate_configs/zero3.json

@@ -0,0 +1,30 @@
+{
+    "fp16": {
+        "enabled": false,
+        "loss_scale": 0,
+        "loss_scale_window": 1000,
+        "initial_scale_power": 16,
+        "hysteresis": 2,
+        "min_loss_scale": 1
+    },
+    "bf16": {
+        "enabled": "auto"
+    },
+    "communication_data_type": "fp32",
+    "gradient_clipping": 1.0,
+    "train_micro_batch_size_per_gpu": "auto",
+    "train_batch_size": "auto",
+    "gradient_accumulation_steps": "auto",
+    "zero_optimization": {
+        "stage": 3,
+        "overlap_comm": true,
+        "contiguous_gradients": true,
+        "stage3_gather_16bit_weights_on_model_save": true,
+        "sub_group_size": 536870912,
+        "reduce_bucket_size": 536870912,
+        "stage3_prefetch_bucket_size": 536870912,
+        "stage3_param_persistence_threshold": 524288,
+        "stage3_max_live_parameters": 536870912,
+        "stage3_max_reuse_distance": 536870912
+    }
+}

Helios-main/scripts/training/train_ddp.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+export WANDB_MODE="offline"
+export WANDB_API_KEY=""
+export TOKENIZERS_PARALLELISM=true
+
+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 ',' ' '`)
+# export MASTER_PORT=${ports[0]}
+# NNODES=$ARNOLD_WORKER_NUM
+# NODE_RANK=$ARNOLD_ID
+# GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+# # 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"
+
+#################################################################
+## ACCELERATE CONFIG
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+export MASTER_PORT=${ports[0]}
+NUM_MACHINES=$ARNOLD_WORKER_NUM
+MACHINE_RANK=$ARNOLD_ID
+NUM_PROCESSES_PER_MACHINE=$ARNOLD_WORKER_GPU
+
+# export CUDA_VISIBLE_DEVICES=0
+# NUM_PROCESSES_PER_MACHINE=1
+# NUM_MACHINES=1
+# MACHINE_RANK=0
+
+ACCELERATE_ARGS="--num_machines $NUM_MACHINES --machine_rank $MACHINE_RANK --num_processes $((NUM_PROCESSES_PER_MACHINE*NUM_MACHINES)) --main_process_ip $MASTER_ADDR --main_process_port $MASTER_PORT"
+
+echo -e "\033[31mACCELERATE_ARGS: ${ACCELERATE_ARGS}\033[0m"
+
+accelerate launch \
+    $ACCELERATE_ARGS \
+    train_helios.py \
+    --config scripts/training/configs/stage_1_init.yaml \
+    2>&1 | tee ./train.log
+
+# accelerate launch \
+#     $ACCELERATE_ARGS \
+#     --config_file scripts/accelerate_configs/multi_node_example_zero2.yaml \
+#     train_helios.py \
+#     --config scripts/training/configs/stage_1_init.yaml \
+#     2>&1 | tee ./train.log

Helios-main/scripts/training/train_deepspeed.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+export WANDB_MODE="offline"
+export WANDB_API_KEY=""
+export TOKENIZERS_PARALLELISM=true
+
+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 ',' ' '`)
+# export MASTER_PORT=${ports[0]}
+# NNODES=$ARNOLD_WORKER_NUM
+# NODE_RANK=$ARNOLD_ID
+# GPUS_PER_NODE=$ARNOLD_WORKER_GPU
+# # 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"
+
+#################################################################
+## ACCELERATE CONFIG
+#################################################################
+MASTER_ADDR=$ARNOLD_WORKER_0_HOST
+ports=(`echo $METIS_WORKER_0_PORT | tr ',' ' '`)
+export MASTER_PORT=${ports[0]}
+NUM_MACHINES=$ARNOLD_WORKER_NUM
+MACHINE_RANK=$ARNOLD_ID
+NUM_PROCESSES_PER_MACHINE=$ARNOLD_WORKER_GPU
+
+# export CUDA_VISIBLE_DEVICES=0
+# NUM_PROCESSES_PER_MACHINE=1
+# NUM_MACHINES=1
+# MACHINE_RANK=0
+
+ACCELERATE_ARGS="--num_machines $NUM_MACHINES --machine_rank $MACHINE_RANK --num_processes $((NUM_PROCESSES_PER_MACHINE*NUM_MACHINES)) --main_process_ip $MASTER_ADDR --main_process_port $MASTER_PORT"
+
+echo -e "\033[31mACCELERATE_ARGS: ${ACCELERATE_ARGS}\033[0m"
+
+# accelerate launch \
+#     $ACCELERATE_ARGS \
+#     train_helios.py \
+#     --config scripts/training/configs/stage_3_post.yaml \
+#     2>&1 | tee ./train.log
+
+accelerate launch \
+    $ACCELERATE_ARGS \
+    --config_file scripts/accelerate_configs/multi_node_example_zero2.yaml \
+    train_helios.py \
+    --config scripts/training/configs/stage_3_post.yaml \
+    2>&1 | tee ./train.log

LongLive-main/configs/default_config.yaml

@@ -0,0 +1,21 @@
+independent_first_frame: false
+warp_denoising_step: false
+weight_decay: 0.01
+same_step_across_blocks: true
+discriminator_lr_multiplier: 1.0
+last_step_only: false
+i2v: false
+num_training_frames: 21
+gc_interval: 100
+context_noise: 0
+causal: true
+
+ckpt_step: 0
+prompt_name: MovieGenVideoBench
+prompt_path: prompts/MovieGenVideoBench.txt
+eval_first_n: 64
+num_samples: 1
+height: 480
+width: 832
+num_frames: 81
+max_iters: 10000

LongLive-main/configs/longlive_inference.yaml

@@ -0,0 +1,36 @@
+denoising_step_list:
+- 1000
+- 750
+- 500
+- 250
+warp_denoising_step: true # need to remove - 0 in denoising_step_list if warp_denoising_step is true
+num_frame_per_block: 3
+model_name: Wan2.1-T2V-1.3B
+model_kwargs:
+  local_attn_size: 12
+  timestep_shift: 5.0
+  sink_size: 3
+
+
+# inference
+data_path: longlive_models/prompts/vidprom_filtered_extended.txt
+output_folder: videos/long
+inference_iter: -1
+num_output_frames: 120
+use_ema: false
+seed: 0
+num_samples: 1
+save_with_index: true
+global_sink: true
+context_noise: 0
+
+generator_ckpt: longlive_models/models/longlive_base.pt
+lora_ckpt: longlive_models/models/lora.pt
+
+adapter:
+  type: "lora"
+  rank: 256                    # LoRA rank (typical values: 8, 16, 32, 64)
+  alpha: 256                   # LoRA alpha (typically same as rank, but can be different)
+  dropout: 0.0                # LoRA dropout rate
+  dtype: "bfloat16"          # Data type for LoRA parameters: "bfloat16", "float16", "float32"
+  verbose: false              # Whether to print all target module names

LongLive-main/configs/longlive_inference_infinity.yaml

@@ -0,0 +1,36 @@
+denoising_step_list:
+- 1000
+- 750
+- 500
+- 250
+warp_denoising_step: true # need to remove - 0 in denoising_step_list if warp_denoising_step is true
+num_frame_per_block: 3
+model_name: Wan2.1-T2V-1.3B
+model_kwargs:
+  local_attn_size: 12
+  timestep_shift: 5.0
+  sink_size: 3
+  use_infinite_attention: true
+
+# inference
+data_path: longlive_models/prompts/vidprom_filtered_extended.txt
+output_folder: videos/long_infinity
+inference_iter: -1
+num_output_frames: 1050
+use_ema: false
+seed: 0
+num_samples: 1
+save_with_index: true
+global_sink: true
+context_noise: 0
+
+generator_ckpt: longlive_models/models/longlive_base.pt
+lora_ckpt: longlive_models/models/lora.pt
+
+adapter:
+  type: "lora"
+  rank: 256                    # LoRA rank (typical values: 8, 16, 32, 64)
+  alpha: 256                   # LoRA alpha (typically same as rank, but can be different)
+  dropout: 0.0                # LoRA dropout rate
+  dtype: "bfloat16"          # Data type for LoRA parameters: "bfloat16", "float16", "float32"
+  verbose: false              # Whether to print all target module names

LongLive-main/configs/longlive_interactive_inference.yaml

@@ -0,0 +1,38 @@
+# Architecture
+denoising_step_list:
+- 1000
+- 750
+- 500
+- 250
+warp_denoising_step: true # need to remove - 0 in denoising_step_list if warp_denoising_step is true
+num_frame_per_block: 3
+model_name: Wan2.1-T2V-1.3B
+model_kwargs:
+  local_attn_size: 12
+  timestep_shift: 5.0
+  sink_size: 3
+
+
+# Inference
+data_path: longlive_models/prompts/interactive_example.jsonl
+output_folder: videos/interactive
+inference_iter: -1
+num_output_frames: 240
+use_ema: false
+seed: 1
+num_samples: 1
+save_with_index: true
+switch_frame_indices: 40, 80, 120, 160, 200
+global_sink: true
+context_noise: 0
+
+generator_ckpt: longlive_models/models/longlive_base.pt
+lora_ckpt: longlive_models/models/lora.pt
+
+adapter:
+  type: "lora"
+  rank: 256                    # LoRA rank (typical values: 8, 16, 32, 64)
+  alpha: 256                   # LoRA alpha (typically same as rank, but can be different)
+  dropout: 0.0                # LoRA dropout rate
+  dtype: "bfloat16"          # Data type for LoRA parameters: "bfloat16", "float16", "float32"
+  verbose: false              # Whether to print all target module names

LongLive-main/configs/longlive_train_init.yaml

@@ -0,0 +1,70 @@
+generator_ckpt: checkpoints/ode_init.pt
+generator_fsdp_wrap_strategy: size
+real_score_fsdp_wrap_strategy: size
+fake_score_fsdp_wrap_strategy: size
+# real_name: Wan2.1-T2V-1.3B
+real_name: Wan2.1-T2V-14B
+fake_name: Wan2.1-T2V-1.3B
+text_encoder_fsdp_wrap_strategy: size
+denoising_step_list:
+- 1000
+- 750
+- 500
+- 250
+warp_denoising_step: true # need to remove - 0 in denoising_step_list if warp_denoising_step is true
+ts_schedule: false
+num_train_timestep: 1000
+timestep_shift: 5.0
+guidance_scale: 3.0
+denoising_loss_type: flow
+mixed_precision: true
+seed: 0
+wandb_key: YOUR_WANDB_KEY
+wandb_entity: YOUR_WANDB_ENTITY
+wandb_project: YOUR_WANDB_PROJECT
+sharding_strategy: hybrid_full
+lr: 2.0e-06
+lr_critic: 4.0e-07
+beta1: 0.0
+beta2: 0.999
+beta1_critic: 0.0
+beta2_critic: 0.999
+data_path: prompts/vidprom_filtered_extended.txt
+batch_size: 1
+gradient_accumulation_steps: 1
+ema_weight: 0.99
+ema_start_step: 200
+total_batch_size: 64
+log_iters: 100
+max_checkpoints: 5
+max_iters: 700
+
+negative_prompt: '色调艳丽，过曝，静态，细节模糊不清，字幕，风格，作品，画作，画面，静止，整体发灰，最差质量，低质量，JPEG压缩残留，丑陋的，残缺的，多余的手指，画得不好的手部，画得不好的脸部，畸形的，毁容的，形态畸形的肢体，手指融合，静止不动的画面，杂乱的背景，三条腿，背景人很多，倒着走'
+dfake_gen_update_ratio: 5
+image_or_video_shape:
+- 1
+- 21 # unused in sequential training
+- 16
+- 60
+- 104
+distribution_loss: dmd
+trainer: score_distillation
+gradient_checkpointing: true
+num_frame_per_block: 3
+load_raw_video: false
+model_kwargs:
+  timestep_shift: 5.0
+  local_attn_size: 12
+  sink_size: 3
+
+# Visualization
+vis_interval: 200
+vis_ema: false
+vis_video_lengths:
+- 21
+val_batch_size: 1
+val_data_path: prompts/vidprom_filtered_extended.txt
+
+min_num_training_frames: 21
+num_training_frames: 21
+slice_last_frames: 21

LongLive-main/configs/longlive_train_long.yaml

@@ -0,0 +1,104 @@
+generator_ckpt: checkpoints/longlive_init.pt
+generator_fsdp_wrap_strategy: size
+real_score_fsdp_wrap_strategy: size
+fake_score_fsdp_wrap_strategy: size
+# real_name: Wan2.1-T2V-1.3B
+real_name: Wan2.1-T2V-14B
+fake_name: Wan2.1-T2V-1.3B
+text_encoder_fsdp_wrap_strategy: size
+denoising_step_list:
+- 1000
+- 750
+- 500
+- 250
+warp_denoising_step: true # need to remove - 0 in denoising_step_list if warp_denoising_step is true
+ts_schedule: false
+num_train_timestep: 1000
+timestep_shift: 5.0
+guidance_scale: 3.0
+denoising_loss_type: flow
+mixed_precision: true
+seed: 0
+wandb_key: YOUR_WANDB_KEY
+wandb_entity: YOUR_WANDB_ENTITY
+wandb_project: YOUR_WANDB_PROJECT
+sharding_strategy: hybrid_full
+lr: 1.0e-05
+lr_critic: 2.0e-06
+beta1: 0.0
+beta2: 0.999
+beta1_critic: 0.0
+beta2_critic: 0.999
+data_path: prompts/vidprom_filtered_extended.txt
+switch_prompt_path: prompts/vidprom_filtered_extended_switch.txt
+batch_size: 1
+gradient_accumulation_steps: 1
+ema_weight: 0.99
+ema_start_step: 200
+total_batch_size: 64
+log_iters: 50
+max_checkpoints: 3
+max_iters: 3000
+
+negative_prompt: '色调艳丽，过曝，静态，细节模糊不清，字幕，风格，作品，画作，画面，静止，整体发灰，最差质量，低质量，JPEG压缩残留，丑陋的，残缺的，多余的手指，画得不好的手部，画得不好的脸部，畸形的，毁容的，形态畸形的肢体，手指融合，静止不动的画面，杂乱的背景，三条腿，背景人很多，倒着走'
+dfake_gen_update_ratio: 5
+image_or_video_shape:
+- 1
+- 240 # unused in streaming training
+- 16
+- 60
+- 104
+distribution_loss: dmd_switch
+global_sink: false
+trainer: score_distillation
+gradient_checkpointing: true
+num_frame_per_block: 3
+load_raw_video: false
+model_kwargs:
+  timestep_shift: 5.0
+  local_attn_size: 12
+  sink_size: 3
+
+# Visualization
+vis_interval: 500
+vis_ema: false
+vis_video_lengths:
+- 240
+val_batch_size: 1
+val_data_path: prompts/vidprom_filtered_extended.txt
+val_switch_prompt_path: prompts/vidprom_filtered_extended_switch.txt
+
+slice_last_frames: 21
+
+switch_mode: random_choice
+switch_choices:
+- 21
+- 39
+- 57
+- 75
+- 93
+- 111
+- 129
+- 147
+- 165
+- 183
+- 201
+
+streaming_training: true
+streaming_chunk_size: 21
+streaming_max_length: 240
+
+streaming_min_new_frame: 18
+train_first_chunk: true
+
+last_step_only: false
+
+## LoRA Configuration
+adapter:
+  type: "lora"
+  rank: 256                    # LoRA rank (typical values: 8, 16, 32, 64)
+  alpha: 256                   # LoRA alpha (typically same as rank, but can be different)
+  dropout: 0.0                # LoRA dropout rate
+  dtype: "bfloat16"          # Data type for LoRA parameters: "bfloat16", "float16", "float32"
+  apply_to_critic: true       # Whether to apply LoRA to critic/fake_score model
+  verbose: true              # Whether to print all target module names

LongLive-main/docs/FLASH_ATTENTION_3_AND_HOPPER_SUPPORT.md

@@ -0,0 +1,103 @@
+# Flash Attention 3 and Hopper GPU Support
+
+This document describes the Flash Attention 3 (FA3) integration and extended Hopper GPU support in LongLive.
+
+## Overview
+
+LongLive supports both Flash Attention 2 (FA2) and Flash Attention 3 (FA3) for efficient attention computation. FA3 is automatically enabled on Hopper architecture GPUs (Compute Capability 9.0+), providing improved performance.
+
+## Supported Hardware
+
+### Hopper Architecture GPUs (FA3 Enabled)
+- **NVIDIA H100** - Data center GPU
+- **NVIDIA H800** - China-specific variant
+- **NVIDIA H20** - China-specific variant
+
+All Hopper GPUs share Compute Capability 9.0, which is the requirement for FA3.
+
+### Other GPUs (FA2 Fallback)
+- **NVIDIA A100** - Ampere architecture (Compute Capability 8.0)
+- **NVIDIA A800** - Ampere architecture (Compute Capability 8.0)
+- Other CUDA-capable GPUs with FA2 support
+
+## Design Choices
+
+### 1. GPU Detection via Compute Capability
+
+Instead of relying on device name string matching (which would miss H800/H20), we detect Hopper GPUs using CUDA Compute Capability:
+
+```python
+def is_hopper_gpu():
+    if torch.cuda.is_available():
+        major, _ = torch.cuda.get_device_capability()
+        return major >= 9  # Hopper Compute Capability == 9.0
+    return False
+```
+
+**Rationale:**
+- Device names vary across vendors and regions (H100, H800, H20, etc.)
+- Compute Capability is a reliable, standardized way to identify GPU architecture
+- All Hopper GPUs report `major=9` regardless of their marketing name
+
+### 2. FA3 Return Value Handling
+
+Flash Attention 3's `flash_attn_varlen_func` has a different return signature than FA2:
+
+| Version | Return Value |
+|---------|--------------|
+| FA2 | `(output, softmax_lse, ...)` - tuple, use `[0]` to get output |
+| FA3 | `output` - tensor directly |
+
+The code correctly handles this difference:
+
+```python
+# FA3 path - direct tensor return
+x = flash_attn_interface.flash_attn_varlen_func(...).unflatten(0, (b, lq))
+
+# FA2 path - tuple return (handled in else branch)
+x = flash_attn.flash_attn_varlen_func(...).unflatten(0, (b, lq))
+```
+
+### 3. Automatic Fallback
+
+The system gracefully falls back to FA2 when FA3 is unavailable:
+- If `flash_attn_interface` module is not installed
+- If running on non-Hopper GPU
+- If user explicitly requests FA2 via `version=2` parameter
+
+A warning is issued when FA3 is explicitly requested but unavailable.
+
+## Usage
+
+### Automatic Selection (Recommended)
+
+By default, LongLive automatically selects the optimal attention implementation:
+
+```python
+from wan.modules.attention import attention
+
+# FA3 will be used on Hopper GPUs, FA2 otherwise
+output = attention(q, k, v)
+```
+
+### Explicit Version Selection
+
+You can force a specific Flash Attention version:
+
+```python
+# Force FA2 (useful for debugging or compatibility)
+output = attention(q, k, v, fa_version=2)
+
+# Request FA3 (falls back to FA2 with warning if unavailable)
+output = attention(q, k, v, fa_version=3)
+```
+
+## Installation
+
+### Flash Attention 3 (Hopper GPUs)
+
+```bash
+git clone https://github.com/Dao-AILab/flash-attention.git
+cd flash-attention/hopper
+python setup.py install
+```