init

README.md

@@ -1,3 +1,136 @@
----
-license: mit
----
+---
+license: mit
+task_categories:
+- image-to-video
+tags:
+- video-generation
+- motion-control
+- point-trajectory
+---
+
+# MoveBench of Wan-Move
+
+<p align="center">
+    <img src="assets/wan-move-logo.png" alt="Stanford-Alpaca" style="width: 100%; min-width: 300px; display: block; margin: auto;">
+<p>
+
+# Wan-Move: Motion-controllable Video Generation via Latent Trajectory Guidance
+
+[![Paper](https://img.shields.io/badge/ArXiv-Paper-brown)](https://arxiv.org/abs/xx)
+[![Code](https://img.shields.io/badge/GitHub-Code-blue)](https://github.com/ali-vilab/Wan-Move)
+[![Model](https://img.shields.io/badge/HuggingFace-Model-yellow)](https://huggingface.co/Ruihang/Wan-Move-14B-480P)
+[![Model](https://img.shields.io/badge/ModelScope-Model-violet)](https://www.modelscope.cn/models/Ruihang/Wan-Move-14B-480P)
+[![Model](https://img.shields.io/badge/HuggingFace-MoveBench-cyan)](https://huggingface.co/Ruihang/MoveBench)
+[![Video](https://img.shields.io/badge/YouTube-Video-red)](https://www.youtube.com/watch?v=_5Cy7Z2NQJQ)
+[![Website](https://img.shields.io/badge/Demo-Page-bron)](https://ruihang-chu.github.io/Wan-Move.html)
+
+
+
+## MoveBench: A Comprehensive and Well-Curated Benchmark to Access Motion Control in Videos
+
+
+MoveBench evaluates fine-grained point-level motion control in generated videos. We categorize the video library from [Pexels](https://www.pexels.com/videos/) into 54 content categories, 10-25 videos each, giving rise to 1018 cases to ensure a broad scenario coverage. All video clips maintain a 5-second duration to facilitate evaluation of long-range dynamics. Every clip is paired with detailed motion annotations for a single object. Addtional 192 clips have motion annotations for multiple objects. We ensure annotation quality by developing an interactive labeling pipeline, marrying annotation precision with automated scalability.
+
+ Welcome everyone to use it!
+
+
+
+
+## Statistics
+
+<p align="center" style="border-radius: 10px">
+  <img src="assets/construction.png" width="100%" alt="logo"/>
+<strong>The contruction pipeline of MoveBench </strong>
+</p>
+
+<p align="center" style="border-radius: 10px">
+  <img src="assets/statistics_1.png" width="100%" alt="logo"/>
+<strong>Balanced sample number per video category </strong>
+</p>
+
+<p align="center" style="border-radius: 10px">
+  <img src="assets/statistics_2.png" width="100%" alt="logo"/>
+<strong>Comparison with related benchmarks </strong>
+</p>
+
+## Download
+
+
+Download MoveBench from Hugging Face:
+``` sh
+huggingface-cli download Ruihang/MoveBench --local-dir ./MoveBench
+```
+
+Extract the files below:
+``` sh
+tar -xzvf en.tar.gz
+tar -xzvf zh.tar.gz
+```
+
+The file structure will be:
+
+```
+MoveBench
+├── en             # English version
+│   ├── single_track.txt
+│   ├── multi_track.txt
+│   ├── first_frame
+│   │   ├── Pexels_videoid_0.jpg
+│   │   ├── Pexels_videoid_1.jpg
+│   │   ├── ...
+│   ├── video
+│   │   ├── Pexels_videoid_0.mp4
+│   │   ├── Pexels_videoid_1.mp4
+│   │   ├── ...
+│   ├── track
+│   │   ├── single
+│   │   │   ├── Pexels_videoid_0_tracks.npy
+│   │   │   ├── Pexels_videoid_0_visibility.npy
+│   │   │   ├── ...
+│   │   ├── multi
+│   │   │   ├── Pexels_videoid_0_tracks.npy
+│   │   │   ├── Pexels_videoid_0_visibility.npy
+│   │   │   ├── ...
+├── zh             # Chinese version
+│   ├── single_track.txt
+│   ├── multi_track.txt
+│   ├── first_frame
+│   │   ├── Pexels_videoid_0.jpg
+│   │   ├── Pexels_videoid_1.jpg
+│   │   ├── ...
+│   ├── video
+│   │   ├── Pexels_videoid_0.mp4
+│   │   ├── Pexels_videoid_1.mp4
+│   │   ├── ...
+│   ├── track
+│   │   ├── single
+│   │   │   ├── Pexels_videoid_0_tracks.npy
+│   │   │   ├── Pexels_videoid_0_visibility.npy
+│   │   │   ├── ...
+│   │   ├── multi
+│   │   │   ├── Pexels_videoid_0_tracks.npy
+│   │   │   ├── Pexels_videoid_0_visibility.npy
+│   │   │   ├── ...
+├── bench.py   # Evaluation script
+├── utils      # Evaluation code modules
+```
+
+
+For evaluation, please refer to [Wan-Move](https://github.com/ali-vilab/Wan-Move) code base. Enjoy it!
+
+<!-- 
+## Citation
+If you find our work helpful, please cite us.
+
+```
+@article{wan2025,
+      title={Wan: Open and Advanced Large-Scale Video Generative Models}, 
+      author={Team Wan and Ang Wang and Baole Ai and Bin Wen and Chaojie Mao and Chen-Wei Xie and Di Chen and Feiwu Yu and Haiming Zhao and Jianxiao Yang and Jianyuan Zeng and Jiayu Wang and Jingfeng Zhang and Jingren Zhou and Jinkai Wang and Jixuan Chen and Kai Zhu and Kang Zhao and Keyu Yan and Lianghua Huang and Mengyang Feng and Ningyi Zhang and Pandeng Li and Pingyu Wu and Ruihang Chu and Ruili Feng and Shiwei Zhang and Siyang Sun and Tao Fang and Tianxing Wang and Tianyi Gui and Tingyu Weng and Tong Shen and Wei Lin and Wei Wang and Wei Wang and Wenmeng Zhou and Wente Wang and Wenting Shen and Wenyuan Yu and Xianzhong Shi and Xiaoming Huang and Xin Xu and Yan Kou and Yangyu Lv and Yifei Li and Yijing Liu and Yiming Wang and Yingya Zhang and Yitong Huang and Yong Li and You Wu and Yu Liu and Yulin Pan and Yun Zheng and Yuntao Hong and Yupeng Shi and Yutong Feng and Zeyinzi Jiang and Zhen Han and Zhi-Fan Wu and Ziyu Liu},
+      journal = {arXiv preprint arXiv:2503.20314},
+      year={2025}
+}
+``` -->
+
+
+## Contact Us
+If you would like to leave a message to our research teams, feel free to drop me an [Email]([email protected]).

bench.py

@@ -0,0 +1,228 @@
+import os
+os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
+import re
+import json
+
+import numpy as np
+from PIL import Image
+import torch
+from torchvision import transforms
+from tqdm import tqdm
+
+from utils import (
+    calculate_psnr,
+    calculate_ssim,
+    calculate_fvd,
+    calculate_epe,
+    calculate_lpips,
+    calculate_fid,
+    calculate_clip_I,
+    save_video_frames,
+    preprocess
+)
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+def preprocess_in_chunks(all_raw_videos, all_gen_videos, batch_size, target_resolution=(224, 224)):
+
+    processed_raw_chunks = []
+    processed_gen_chunks = []
+
+    for i in range(0, len(all_raw_videos), batch_size):
+        raw_chunk_videos = torch.cat(all_raw_videos[i:i + batch_size], dim=0)  # (batch_size * T, C, H, W)
+        gen_chunk_videos = torch.cat(all_gen_videos[i:i + batch_size], dim=0)
+        
+        raw_chunk_processed = preprocess(raw_chunk_videos, target_resolution)  # 返回 (batch_size, C, T, H', W')
+        gen_chunk_processed = preprocess(gen_chunk_videos, target_resolution)  # 同上
+
+        processed_raw_chunks.append(raw_chunk_processed)
+        processed_gen_chunks.append(gen_chunk_processed)
+
+    processed_raw = torch.cat(processed_raw_chunks, dim=0)
+    processed_gen = torch.cat(processed_gen_chunks, dim=0)
+
+    return processed_raw, processed_gen
+
+class NumpyEncoder(json.JSONEncoder):
+    """ Custom encoder for numpy data types """
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super().default(obj)
+
+def get_min_max_frame(frames_dir):
+    frame_pattern = re.compile(r'^(.*?)_frame_(\d+)\.png$')
+    max_frames = {}
+
+    for filename in os.listdir(frames_dir):
+        if not filename.endswith('.png'):
+            continue
+        match = frame_pattern.match(filename)
+        if not match:
+            continue
+        video_name, frame_num = match.groups()
+        frame_num = int(frame_num)
+        current_max = max_frames.get(video_name, -1)
+        if frame_num > current_max:
+            max_frames[video_name] = frame_num
+
+    return min(max_frames.values()) if max_frames else 0
+
+def main():
+    # raw_root = "gt/en"
+    # gen_root = "results/en"
+    raw_root = "gt/zh"
+    gen_root = "results/zh"
+    
+    raw_frame_dir = f"{raw_root}_frames"
+    gen_frame_dir = f"{gen_root}_frames"
+    
+    if not os.path.exists(raw_frame_dir):
+        raw_frame_num = save_video_frames(raw_root, raw_frame_dir)
+    else:
+        raw_frame_num = get_min_max_frame(raw_frame_dir)
+
+    if not os.path.exists(gen_frame_dir):
+        gen_frame_num = save_video_frames(gen_root, gen_frame_dir)
+    else:
+        gen_frame_num = get_min_max_frame(gen_frame_dir)
+        
+    print(f"Evaluating with frame count: {gen_frame_num}")
+    assert gen_frame_num <= raw_frame_num, "Generated frames exceed raw frames count"
+    
+    video_names = sorted([name for name in os.listdir(gen_root) if name.endswith('.mp4')])
+    
+    scores = {
+        "clip": [],
+        "epe": [],
+        "lpips": [],
+        "ssim": [],
+        "psnr": [],
+    }
+    all_raw_videos, all_gen_videos = [], []
+
+    with torch.no_grad():
+        progress_bar = tqdm(video_names, desc="Processing videos")
+
+        for video_name in progress_bar:
+            base_name = video_name.replace(".mp4", "")
+            clip, lpips, ssim, psnr = [], [], [], []
+            raw_video, gen_video = [], []
+
+            for frame_idx in range(gen_frame_num):
+            # for frame_idx in range(16):
+                raw_path = f"{raw_frame_dir}/{base_name}_frame_{frame_idx}.png"
+                gen_path = f"{gen_frame_dir}/{base_name}_frame_{frame_idx}.png"
+
+                try:
+                    raw_img = Image.open(raw_path)
+                    gen_img = Image.open(gen_path)
+                except FileNotFoundError:
+                    break
+
+
+                # Align the size
+                if raw_img.size != gen_img.size:
+                    gen_img = gen_img.resize(raw_img.size)
+
+                # Calculate metrics
+                clip.append(calculate_clip_I(raw_img, gen_img))
+                
+                raw_tensor = transforms.ToTensor()(raw_img).unsqueeze(0)
+                gen_tensor = transforms.ToTensor()(gen_img).unsqueeze(0)
+                
+                raw_video.append(raw_tensor)
+                gen_video.append(gen_tensor)
+                
+                psnr.append(calculate_psnr(raw_tensor, gen_tensor).item())
+                ssim.append(calculate_ssim(raw_tensor, gen_tensor).item())
+                lpips.append(calculate_lpips(
+                    raw_tensor.sub(0.5).div(0.5),
+                    gen_tensor.sub(0.5).div(0.5)
+                ).item())
+
+            if not raw_video:
+                continue
+
+            # Process video-level metrics
+            raw_video = torch.cat(raw_video)
+            gen_video = torch.cat(gen_video)
+            all_raw_videos.append(raw_video.unsqueeze(0))
+            all_gen_videos.append(gen_video.unsqueeze(0))
+            
+            epe = calculate_epe(raw_video, gen_video).item()
+            
+            scores["clip"].append(np.mean(clip))
+            scores["epe"].append(epe)
+            scores["lpips"].append(np.mean(lpips))
+            scores["ssim"].append(np.mean(ssim))
+            scores["psnr"].append(np.mean(psnr))
+            
+            # Update progress_bar
+            current_means = {
+                k: round(np.mean(v), 2) 
+                for k, v in scores.items() 
+                if isinstance(v, list) and len(v) > 0
+            }
+            progress_bar.set_postfix(current_means)
+
+        # FID
+        try:
+            fid = calculate_fid(raw_frame_dir, gen_frame_dir)
+        except Exception as e:
+            print(f"[WARN] FID calculation failed: {e}")
+        else:
+            scores["fid"] = fid
+        
+        # FVD
+        processed_raw_chunks = []
+        processed_gen_chunks = []
+
+        batch_size = 20
+        TARGET_RESOLUTION = (224, 224)
+
+
+        for i in tqdm(range(0, len(all_raw_videos), batch_size)):
+
+            raw_chunk_videos = torch.cat(all_raw_videos[i:i + batch_size]).mul(255).clamp(0, 255).byte().numpy()
+            gen_chunk_videos = torch.cat(all_gen_videos[i:i + batch_size]).mul(255).clamp(0, 255).byte().numpy()
+            raw_chunk_videos = raw_chunk_videos.transpose(0, 1, 3, 4, 2)  # [N, T, H, W, C]
+            gen_chunk_videos = gen_chunk_videos.transpose(0, 1, 3, 4, 2)
+            
+            raw_chunk_processed = preprocess(raw_chunk_videos, TARGET_RESOLUTION)
+            gen_chunk_processed = preprocess(gen_chunk_videos, TARGET_RESOLUTION)
+
+            processed_raw_chunks.append(raw_chunk_processed)
+            processed_gen_chunks.append(gen_chunk_processed)
+
+        all_raw = torch.cat(processed_raw_chunks, dim=0)
+        all_gen = torch.cat(processed_gen_chunks, dim=0)
+        
+        fvd = calculate_fvd(all_raw, all_gen)
+        scores["fvd"] = fvd
+
+        
+        # Generate final results
+        final_scores = {
+            k: np.mean(v) if isinstance(v, list) else v
+            for k, v in scores.items()
+        }
+        
+        print("\nEvaluation Results:")
+        for k, v in final_scores.items():
+            print(f"{k.upper():<8}: {v:.4f}")
+        
+        results = {
+            "raw_scores": scores,
+            "final_scores": final_scores
+        }
+        with open("evaluation_results.json", "w") as f:
+            json.dump(results, f, indent=4, cls=NumpyEncoder)
+        print("\nResults saved to evaluation_results.json")
+
+if __name__ == "__main__":
+    main()

en.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d0196c7c5c51fd83b777e57db679ed340d11ba46bf3892e8f38dcd33a0eef67
+size 666265297

utils/__init__.py

@@ -0,0 +1,8 @@
+from .clip import calculate_clip_I
+from .epe import calculate_epe
+from .fid import calculate_fid
+from .fvd import calculate_fvd, preprocess
+from .lpips import calculate_lpips
+from .ssim_psnr import calculate_ssim, calculate_psnr
+
+from .video import save_video_frames 

utils/clip.py

@@ -0,0 +1,29 @@
+ 
+from tqdm import tqdm
+from PIL import Image
+import torch
+import os
+import numpy as np
+ 
+from transformers import CLIPProcessor, CLIPModel
+ 
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+model = CLIPModel.from_pretrained("openai/clip-vit-large-patch14").to(device)
+processor = CLIPProcessor.from_pretrained("openai/clip-vit-large-patch14")
+ 
+def calculate_clip_I(image1, image2):
+
+    inputs1 = processor(images=image1, return_tensors="pt").to(device)
+    inputs2 = processor(images=image2, return_tensors="pt").to(device)
+
+    with torch.no_grad():
+        image_features1 = model.get_image_features(**inputs1)
+        image_features2 = model.get_image_features(**inputs2)
+
+    image_features1 /= image_features1.norm(dim=-1, keepdim=True)
+    image_features2 /= image_features2.norm(dim=-1, keepdim=True)
+
+    similarity = torch.matmul(image_features1, image_features2.T).cpu().numpy()[0][0]
+    
+    return similarity

utils/epe.py

@@ -0,0 +1,45 @@
+import os
+import numpy as np
+import torch
+import matplotlib.pyplot as plt
+import torchvision.transforms.functional as F
+torch.backends.cudnn.benchmark = True
+torch.backends.cudnn.enabled=False
+torch.backends.cudnn.deterministic = True
+
+from torchvision.models.optical_flow import Raft_Large_Weights
+
+weights = Raft_Large_Weights.DEFAULT
+transforms = weights.transforms()
+
+
+def preprocess(source_batch, target_batch):
+    source_batch = F.resize(source_batch, size=[480, 832], antialias=False)
+    target_batch = F.resize(target_batch, size=[480, 832], antialias=False)
+    return transforms(source_batch, target_batch)
+
+from torchvision.models.optical_flow import raft_large
+
+# If you can, run this example on a GPU, it will be a lot faster.
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+model = raft_large(weights=Raft_Large_Weights.DEFAULT, progress=False).to(device)
+model = model.eval()
+
+def calculate_epe(img1_batch, img2_batch):
+    # img [N, C, H, W]
+    
+    # first calculate the op of img1 and img2
+    img1_source, img1_target = preprocess(img1_batch[:-1], img1_batch[1:])
+    img2_source, img2_target = preprocess(img2_batch[:-1], img2_batch[1:])
+    
+    # op
+    img1_flows = model(img1_source.to(device).contiguous(), img1_target.to(device).contiguous())[-1]  # [N, 2, H, W]
+    img2_flows = model(img2_source.to(device).contiguous(), img2_target.to(device).contiguous())[-1]
+    
+    # epe
+    diff = img1_flows - img2_flows  
+    epe = torch.norm(diff, p=2, dim=1)
+    mean_epe = epe.mean()
+    
+    return mean_epe.cpu().numpy()

utils/fid.py

@@ -0,0 +1,16 @@
+import torch
+import torchvision
+import torchvision.transforms as transforms
+from pytorch_fid import fid_score
+
+
+def calculate_fid(real_images_folder, generated_images_folder):
+
+    fid_value = fid_score.calculate_fid_given_paths(
+        paths=[real_images_folder, generated_images_folder],
+        batch_size=50,
+        device="cuda",
+        dims=2048,
+    )
+    
+    return fid_value

utils/fvd.py

@@ -0,0 +1,142 @@
+import argparse
+import numpy as np
+
+import torch
+import torch.nn.functional as F
+import torch.utils.data as data
+
+from .pytorch_i3d import InceptionI3d
+import os
+
+from sklearn.metrics.pairwise import polynomial_kernel
+
+MAX_BATCH = 10
+FVD_SAMPLE_SIZE = 2048
+TARGET_RESOLUTION = (224, 224)
+
+def preprocess(videos, target_resolution):
+    # videos in {0, ..., 255} as np.uint8 array
+    b, t, h, w, c = videos.shape
+    all_frames = torch.FloatTensor(videos).flatten(end_dim=1) # (b * t, h, w, c)
+    all_frames = all_frames.permute(0, 3, 1, 2).contiguous() # (b * t, c, h, w)
+    resized_videos = F.interpolate(all_frames, size=target_resolution,
+                                   mode='bilinear', align_corners=False)
+    resized_videos = resized_videos.view(b, t, c, *target_resolution)
+    output_videos = resized_videos.transpose(1, 2).contiguous() # (b, c, t, *)
+    scaled_videos = 2. * output_videos / 255. - 1 # [-1, 1]
+    return scaled_videos
+
+def get_fvd_logits(videos, i3d, device):
+    videos = preprocess(videos, TARGET_RESOLUTION)
+    embeddings = get_logits(i3d, videos, device)
+    return embeddings
+
+def load_fvd_model(device):
+    i3d = InceptionI3d(400, in_channels=3).to(device)
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    i3d_path = os.path.join(current_dir, 'weights', 'i3d_pretrained_400.pt')
+    i3d.load_state_dict(torch.load(i3d_path, map_location=device))
+    i3d.eval()
+    return i3d
+
+
+# https://github.com/tensorflow/gan/blob/de4b8da3853058ea380a6152bd3bd454013bf619/tensorflow_gan/python/eval/classifier_metrics.py#L161
+def _symmetric_matrix_square_root(mat, eps=1e-10):
+    u, s, v = torch.svd(mat)
+    si = torch.where(s < eps, s, torch.sqrt(s))
+    return torch.matmul(torch.matmul(u, torch.diag(si)), v.t())
+
+# https://github.com/tensorflow/gan/blob/de4b8da3853058ea380a6152bd3bd454013bf619/tensorflow_gan/python/eval/classifier_metrics.py#L400
+def trace_sqrt_product(sigma, sigma_v):
+    sqrt_sigma = _symmetric_matrix_square_root(sigma)
+    sqrt_a_sigmav_a = torch.matmul(sqrt_sigma, torch.matmul(sigma_v, sqrt_sigma))
+    return torch.trace(_symmetric_matrix_square_root(sqrt_a_sigmav_a))
+
+# https://discuss.pytorch.org/t/covariance-and-gradient-support/16217/2
+def cov(m, rowvar=False):
+    '''Estimate a covariance matrix given data.
+
+    Covariance indicates the level to which two variables vary together.
+    If we examine N-dimensional samples, `X = [x_1, x_2, ... x_N]^T`,
+    then the covariance matrix element `C_{ij}` is the covariance of
+    `x_i` and `x_j`. The element `C_{ii}` is the variance of `x_i`.
+
+    Args:
+        m: A 1-D or 2-D array containing multiple variables and observations.
+            Each row of `m` represents a variable, and each column a single
+            observation of all those variables.
+        rowvar: If `rowvar` is True, then each row represents a
+            variable, with observations in the columns. Otherwise, the
+            relationship is transposed: each column represents a variable,
+            while the rows contain observations.
+
+    Returns:
+        The covariance matrix of the variables.
+    '''
+    if m.dim() > 2:
+        raise ValueError('m has more than 2 dimensions')
+    if m.dim() < 2:
+        m = m.view(1, -1)
+    if not rowvar and m.size(0) != 1:
+        m = m.t()
+
+    fact = 1.0 / (m.size(1) - 1) # unbiased estimate
+    m_center = m - torch.mean(m, dim=1, keepdim=True)
+    mt = m_center.t()  # if complex: mt = m.t().conj()
+    return fact * m_center.matmul(mt).squeeze()
+
+
+def frechet_distance(x1, x2):
+    x1 = x1.flatten(start_dim=1)
+    x2 = x2.flatten(start_dim=1)
+    m, m_w = x1.mean(dim=0), x2.mean(dim=0)
+    sigma, sigma_w = cov(x1, rowvar=False), cov(x2, rowvar=False)
+
+    sqrt_trace_component = trace_sqrt_product(sigma, sigma_w)
+    trace = torch.trace(sigma + sigma_w) - 2.0 * sqrt_trace_component
+
+    mean = torch.sum((m - m_w) ** 2)
+    fd = trace + mean
+    return fd
+
+
+def polynomial_mmd(X, Y):
+    m = X.shape[0]
+    n = Y.shape[0]
+    # compute kernels
+    K_XX = polynomial_kernel(X)
+    K_YY = polynomial_kernel(Y)
+    K_XY = polynomial_kernel(X, Y)
+    # compute mmd distance
+    K_XX_sum = (K_XX.sum() - np.diagonal(K_XX).sum()) / (m * (m - 1))
+    K_YY_sum = (K_YY.sum() - np.diagonal(K_YY).sum()) / (n * (n - 1))
+    K_XY_sum = K_XY.sum() / (m * n)
+    mmd = K_XX_sum + K_YY_sum - 2 * K_XY_sum
+    return mmd
+
+
+
+def get_logits(i3d, videos, device):
+    # assert videos.shape[0] % MAX_BATCH == 0
+    with torch.no_grad():
+        logits = []
+        for i in range(0, videos.shape[0], MAX_BATCH):
+            batch = videos[i:i + MAX_BATCH].to(device)
+            logits.append(i3d(batch))
+        logits = torch.cat(logits, dim=0)
+        return logits
+
+
+# def compute_fvd(real, samples, i3d, device=torch.device('cpu')):
+def compute_fvd(real, samples, i3d, device=torch.device('cuda')):
+    # real, samples are (N, T, H, W, C) numpy arrays in np.uint8
+    # real, samples = preprocess(real, (224, 224)), preprocess(samples, (224, 224))
+    first_embed = get_logits(i3d, real, device)
+    second_embed = get_logits(i3d, samples, device)
+
+    return frechet_distance(first_embed, second_embed)
+
+i3d = load_fvd_model(device=torch.device('cuda'))
+
+def calculate_fvd(real, samples):
+    return compute_fvd(real, samples, i3d, device=torch.device('cuda')).cpu().numpy()

utils/lpips.py

@@ -0,0 +1,13 @@
+import torch
+import numpy as np
+import lpips
+loss_fn_vgg = lpips.LPIPS(net='vgg') # closer to "traditional" perceptual loss, when used for optimization
+
+
+# img0 = torch.zeros(1,3,64,64) # image should be RGB, IMPORTANT: normalized to [-1,1]
+# img1 = torch.zeros(1,3,64,64)
+# d = loss_fn_vgg(img0, img1)
+
+def calculate_lpips(img1, img2):
+    lpips_score = loss_fn_vgg(img1, img2).cpu().numpy()
+    return np.squeeze(lpips_score)

utils/pytorch_i3d.py

@@ -0,0 +1,372 @@
+# https://github.com/piergiaj/pytorch-i3d
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.autograd import Variable
+
+import numpy as np
+
+import os
+import sys
+from collections import OrderedDict
+
+
+class MaxPool3dSamePadding(nn.MaxPool3d):
+
+    def compute_pad(self, dim, s):
+        if s % self.stride[dim] == 0:
+            return max(self.kernel_size[dim] - self.stride[dim], 0)
+        else:
+            return max(self.kernel_size[dim] - (s % self.stride[dim]), 0)
+
+    def forward(self, x):
+        # compute 'same' padding
+        (batch, channel, t, h, w) = x.size()
+        #print t,h,w
+        out_t = np.ceil(float(t) / float(self.stride[0]))
+        out_h = np.ceil(float(h) / float(self.stride[1]))
+        out_w = np.ceil(float(w) / float(self.stride[2]))
+        #print out_t, out_h, out_w
+        pad_t = self.compute_pad(0, t)
+        pad_h = self.compute_pad(1, h)
+        pad_w = self.compute_pad(2, w)
+        #print pad_t, pad_h, pad_w
+
+        pad_t_f = pad_t // 2
+        pad_t_b = pad_t - pad_t_f
+        pad_h_f = pad_h // 2
+        pad_h_b = pad_h - pad_h_f
+        pad_w_f = pad_w // 2
+        pad_w_b = pad_w - pad_w_f
+
+        pad = (pad_w_f, pad_w_b, pad_h_f, pad_h_b, pad_t_f, pad_t_b)
+        #print x.size()
+        #print pad
+        x = F.pad(x, pad)
+        return super(MaxPool3dSamePadding, self).forward(x)
+
+
+class Unit3D(nn.Module):
+
+    def __init__(self, in_channels,
+                 output_channels,
+                 kernel_shape=(1, 1, 1),
+                 stride=(1, 1, 1),
+                 padding=0,
+                 activation_fn=F.relu,
+                 use_batch_norm=True,
+                 use_bias=False,
+                 name='unit_3d'):
+
+        """Initializes Unit3D module."""
+        super(Unit3D, self).__init__()
+
+        self._output_channels = output_channels
+        self._kernel_shape = kernel_shape
+        self._stride = stride
+        self._use_batch_norm = use_batch_norm
+        self._activation_fn = activation_fn
+        self._use_bias = use_bias
+        self.name = name
+        self.padding = padding
+
+        self.conv3d = nn.Conv3d(in_channels=in_channels,
+                                out_channels=self._output_channels,
+                                kernel_size=self._kernel_shape,
+                                stride=self._stride,
+                                padding=0, # we always want padding to be 0 here. We will dynamically pad based on input size in forward function
+                                bias=self._use_bias)
+
+        if self._use_batch_norm:
+            self.bn = nn.BatchNorm3d(self._output_channels, eps=1e-5, momentum=0.001)
+
+    def compute_pad(self, dim, s):
+        if s % self._stride[dim] == 0:
+            return max(self._kernel_shape[dim] - self._stride[dim], 0)
+        else:
+            return max(self._kernel_shape[dim] - (s % self._stride[dim]), 0)
+
+
+    def forward(self, x):
+        # compute 'same' padding
+        (batch, channel, t, h, w) = x.size()
+        #print t,h,w
+        out_t = np.ceil(float(t) / float(self._stride[0]))
+        out_h = np.ceil(float(h) / float(self._stride[1]))
+        out_w = np.ceil(float(w) / float(self._stride[2]))
+        #print out_t, out_h, out_w
+        pad_t = self.compute_pad(0, t)
+        pad_h = self.compute_pad(1, h)
+        pad_w = self.compute_pad(2, w)
+        #print pad_t, pad_h, pad_w
+
+        pad_t_f = pad_t // 2
+        pad_t_b = pad_t - pad_t_f
+        pad_h_f = pad_h // 2
+        pad_h_b = pad_h - pad_h_f
+        pad_w_f = pad_w // 2
+        pad_w_b = pad_w - pad_w_f
+
+        pad = (pad_w_f, pad_w_b, pad_h_f, pad_h_b, pad_t_f, pad_t_b)
+        #print x.size()
+        #print pad
+        x = F.pad(x, pad)
+        #print x.size()
+
+        x = self.conv3d(x)
+        if self._use_batch_norm:
+            x = self.bn(x)
+        if self._activation_fn is not None:
+            x = self._activation_fn(x)
+        return x
+
+
+
+class InceptionModule(nn.Module):
+    def __init__(self, in_channels, out_channels, name):
+        super(InceptionModule, self).__init__()
+
+        self.b0 = Unit3D(in_channels=in_channels, output_channels=out_channels[0], kernel_shape=[1, 1, 1], padding=0,
+                         name=name+'/Branch_0/Conv3d_0a_1x1')
+        self.b1a = Unit3D(in_channels=in_channels, output_channels=out_channels[1], kernel_shape=[1, 1, 1], padding=0,
+                          name=name+'/Branch_1/Conv3d_0a_1x1')
+        self.b1b = Unit3D(in_channels=out_channels[1], output_channels=out_channels[2], kernel_shape=[3, 3, 3],
+                          name=name+'/Branch_1/Conv3d_0b_3x3')
+        self.b2a = Unit3D(in_channels=in_channels, output_channels=out_channels[3], kernel_shape=[1, 1, 1], padding=0,
+                          name=name+'/Branch_2/Conv3d_0a_1x1')
+        self.b2b = Unit3D(in_channels=out_channels[3], output_channels=out_channels[4], kernel_shape=[3, 3, 3],
+                          name=name+'/Branch_2/Conv3d_0b_3x3')
+        self.b3a = MaxPool3dSamePadding(kernel_size=[3, 3, 3],
+                                stride=(1, 1, 1), padding=0)
+        self.b3b = Unit3D(in_channels=in_channels, output_channels=out_channels[5], kernel_shape=[1, 1, 1], padding=0,
+                          name=name+'/Branch_3/Conv3d_0b_1x1')
+        self.name = name
+
+    def forward(self, x):
+        b0 = self.b0(x)
+        b1 = self.b1b(self.b1a(x))
+        b2 = self.b2b(self.b2a(x))
+        b3 = self.b3b(self.b3a(x))
+        return torch.cat([b0,b1,b2,b3], dim=1)
+
+
+class InceptionI3d(nn.Module):
+    """Inception-v1 I3D architecture.
+    The model is introduced in:
+        Quo Vadis, Action Recognition? A New Model and the Kinetics Dataset
+        Joao Carreira, Andrew Zisserman
+        https://arxiv.org/pdf/1705.07750v1.pdf.
+    See also the Inception architecture, introduced in:
+        Going deeper with convolutions
+        Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed,
+        Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, Andrew Rabinovich.
+        http://arxiv.org/pdf/1409.4842v1.pdf.
+    """
+
+    # Endpoints of the model in order. During construction, all the endpoints up
+    # to a designated `final_endpoint` are returned in a dictionary as the
+    # second return value.
+    VALID_ENDPOINTS = (
+        'Conv3d_1a_7x7',
+        'MaxPool3d_2a_3x3',
+        'Conv3d_2b_1x1',
+        'Conv3d_2c_3x3',
+        'MaxPool3d_3a_3x3',
+        'Mixed_3b',
+        'Mixed_3c',
+        'MaxPool3d_4a_3x3',
+        'Mixed_4b',
+        'Mixed_4c',
+        'Mixed_4d',
+        'Mixed_4e',
+        'Mixed_4f',
+        'MaxPool3d_5a_2x2',
+        'Mixed_5b',
+        'Mixed_5c',
+        'Logits',
+        'Predictions',
+    )
+
+    FEAT_ENDPOINTS = (
+        'Conv3d_1a_7x7',
+        'Conv3d_2c_3x3',
+        'Mixed_3c',
+        'Mixed_4f',
+        'Mixed_5c',
+    )
+    def __init__(self, 
+        num_classes=400, 
+        spatial_squeeze=True,
+        final_endpoint='Logits',
+        name='inception_i3d', 
+        in_channels=3,
+        dropout_keep_prob=0.5,
+        is_coinrun=False,
+        ):
+        """Initializes I3D model instance.
+        Args:
+          num_classes: The number of outputs in the logit layer (default 400, which
+              matches the Kinetics dataset).
+          spatial_squeeze: Whether to squeeze the spatial dimensions for the logits
+              before returning (default True).
+          final_endpoint: The model contains many possible endpoints.
+              `final_endpoint` specifies the last endpoint for the model to be built
+              up to. In addition to the output at `final_endpoint`, all the outputs
+              at endpoints up to `final_endpoint` will also be returned, in a
+              dictionary. `final_endpoint` must be one of
+              InceptionI3d.VALID_ENDPOINTS (default 'Logits').
+          name: A string (optional). The name of this module.
+        Raises:
+          ValueError: if `final_endpoint` is not recognized.
+        """
+
+        if final_endpoint not in self.VALID_ENDPOINTS:
+            raise ValueError('Unknown final endpoint %s' % final_endpoint)
+
+        super(InceptionI3d, self).__init__()
+        self._num_classes = num_classes
+        self._spatial_squeeze = spatial_squeeze
+        self._final_endpoint = final_endpoint
+        self.logits = None
+        self.is_coinrun = is_coinrun
+
+        if self._final_endpoint not in self.VALID_ENDPOINTS:
+            raise ValueError('Unknown final endpoint %s' % self._final_endpoint)
+
+        self.end_points = {}
+        end_point = 'Conv3d_1a_7x7'
+        self.end_points[end_point] = Unit3D(in_channels=in_channels, output_channels=64, kernel_shape=[7, 7, 7],
+                                            stride=(1 if is_coinrun else 2, 2, 2), padding=(3,3,3),  name=name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'MaxPool3d_2a_3x3'
+        self.end_points[end_point] = MaxPool3dSamePadding(kernel_size=[1, 3, 3], stride=(1, 2, 2),
+                                                             padding=0)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Conv3d_2b_1x1'
+        self.end_points[end_point] = Unit3D(in_channels=64, output_channels=64, kernel_shape=[1, 1, 1], padding=0,
+                                       name=name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Conv3d_2c_3x3'
+        self.end_points[end_point] = Unit3D(in_channels=64, output_channels=192, kernel_shape=[3, 3, 3], padding=1,
+                                       name=name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'MaxPool3d_3a_3x3'
+        self.end_points[end_point] = MaxPool3dSamePadding(kernel_size=[1, 3, 3], stride=(1, 2, 2),
+                                                             padding=0)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_3b'
+        self.end_points[end_point] = InceptionModule(192, [64,96,128,16,32,32], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_3c'
+        self.end_points[end_point] = InceptionModule(256, [128,128,192,32,96,64], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'MaxPool3d_4a_3x3'
+        self.end_points[end_point] = MaxPool3dSamePadding(kernel_size=[1 if is_coinrun else 3, 3, 3], stride=(1 if is_coinrun else 2, 2, 2),
+                                                             padding=0)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_4b'
+        self.end_points[end_point] = InceptionModule(128+192+96+64, [192,96,208,16,48,64], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_4c'
+        self.end_points[end_point] = InceptionModule(192+208+48+64, [160,112,224,24,64,64], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_4d'
+        self.end_points[end_point] = InceptionModule(160+224+64+64, [128,128,256,24,64,64], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_4e'
+        self.end_points[end_point] = InceptionModule(128+256+64+64, [112,144,288,32,64,64], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_4f'
+        self.end_points[end_point] = InceptionModule(112+288+64+64, [256,160,320,32,128,128], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'MaxPool3d_5a_2x2'
+        self.end_points[end_point] = MaxPool3dSamePadding(kernel_size=[2, 2, 2], stride=(1 if is_coinrun else 2, 2, 2),
+                                                             padding=0)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_5b'
+        self.end_points[end_point] = InceptionModule(256+320+128+128, [256,160,320,32,128,128], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Mixed_5c'
+        self.end_points[end_point] = InceptionModule(256+320+128+128, [384,192,384,48,128,128], name+end_point)
+        if self._final_endpoint == end_point: return
+
+        end_point = 'Logits'
+        self.avg_pool = nn.AvgPool3d(kernel_size=[1, 8, 8] if is_coinrun else [2, 7, 7],
+                                     stride=(1, 1, 1))
+        self.dropout = nn.Dropout(dropout_keep_prob)
+        self.logits = Unit3D(in_channels=384+384+128+128, output_channels=self._num_classes,
+                             kernel_shape=[1, 1, 1],
+                             padding=0,
+                             activation_fn=None,
+                             use_batch_norm=False,
+                             use_bias=True,
+                             name='logits')
+
+        self.build()
+
+
+    def replace_logits(self, num_classes):
+        self._num_classes = num_classes
+        self.logits = Unit3D(in_channels=384+384+128+128, output_channels=self._num_classes,
+                             kernel_shape=[1, 1, 1],
+                             padding=0,
+                             activation_fn=None,
+                             use_batch_norm=False,
+                             use_bias=True,
+                             name='logits')
+
+
+    def build(self):
+        for k in self.end_points.keys():
+            self.add_module(k, self.end_points[k])
+
+    def forward(self, x):
+        for end_point in self.VALID_ENDPOINTS:
+            if end_point in self.end_points:
+                x = self._modules[end_point](x) # use _modules to work with dataparallel
+
+        x = self.logits(self.dropout(self.avg_pool(x)))
+        if self._spatial_squeeze:
+            logits = x.squeeze(3).squeeze(3)
+        logits = logits.mean(dim=2)
+        # logits is batch X time X classes, which is what we want to work with
+        return logits
+
+
+    def extract_features(self, x):
+        for end_point in self.VALID_ENDPOINTS:
+            if end_point in self.end_points:
+                x = self._modules[end_point](x)
+        return self.avg_pool(x)
+
+
+    def extract_pre_pool_features(self, x):
+        for end_point in self.VALID_ENDPOINTS:
+            if end_point in self.end_points:
+                x = self._modules[end_point](x)
+        return x
+
+
+    def extract_features_multiscale(self, x):
+        xs = []
+        for end_point in self.VALID_ENDPOINTS:
+            if end_point in self.end_points:
+                x = self._modules[end_point](x)
+                if end_point in self.FEAT_ENDPOINTS:
+                    xs.append(x)
+        return xs

utils/ssim_psnr.py

@@ -0,0 +1,140 @@
+import torch
+import torch.nn.functional as F
+from math import exp
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+def gaussian(window_size, sigma):
+    gauss = torch.Tensor([exp(-(x - window_size//2)**2/float(2*sigma**2)) for x in range(window_size)])
+    return gauss/gauss.sum()
+
+
+def create_window(window_size, channel=1):
+    _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
+    _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0).to(device)
+    window = _2D_window.expand(channel, 1, window_size, window_size).contiguous()
+    return window
+
+
+def create_window_3d(window_size, channel=1):
+    _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
+    _2D_window = _1D_window.mm(_1D_window.t())
+    _3D_window = _2D_window.unsqueeze(2) @ (_1D_window.t())
+    window = _3D_window.expand(1, channel, window_size, window_size, window_size).contiguous().to(device)
+    return window
+
+
+def ssim(img1, img2, window_size=11, window=None, size_average=True, full=False, val_range=None):
+    if val_range is None:
+        if torch.max(img1) > 128:
+            max_val = 255
+        else:
+            max_val = 1
+
+        if torch.min(img1) < -0.5:
+            min_val = -1
+        else:
+            min_val = 0
+        L = max_val - min_val
+    else:
+        L = val_range
+
+    padd = 0
+    (_, channel, height, width) = img1.size()
+    if window is None:
+        real_size = min(window_size, height, width)
+        window = create_window(real_size, channel=channel).to(img1.device)
+
+    mu1 = F.conv2d(F.pad(img1, (5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=channel)
+    mu2 = F.conv2d(F.pad(img2, (5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=channel)
+
+    mu1_sq = mu1.pow(2)
+    mu2_sq = mu2.pow(2)
+    mu1_mu2 = mu1 * mu2
+
+    sigma1_sq = F.conv2d(F.pad(img1 * img1, (5, 5, 5, 5), 'replicate'), window, padding=padd, groups=channel) - mu1_sq
+    sigma2_sq = F.conv2d(F.pad(img2 * img2, (5, 5, 5, 5), 'replicate'), window, padding=padd, groups=channel) - mu2_sq
+    sigma12 = F.conv2d(F.pad(img1 * img2, (5, 5, 5, 5), 'replicate'), window, padding=padd, groups=channel) - mu1_mu2
+
+    C1 = (0.01 * L) ** 2
+    C2 = (0.03 * L) ** 2
+
+    v1 = 2.0 * sigma12 + C2
+    v2 = sigma1_sq + sigma2_sq + C2
+    cs = torch.mean(v1 / v2)
+
+    ssim_map = ((2 * mu1_mu2 + C1) * v1) / ((mu1_sq + mu2_sq + C1) * v2)
+
+    if size_average:
+        ret = ssim_map.mean()
+    else:
+        ret = ssim_map.mean(1).mean(1).mean(1)
+
+    if full:
+        return ret, cs
+    return ret
+
+
+def calculate_ssim(img1, img2, window_size=11, window=None, size_average=True, full=False, val_range=None):
+    if val_range is None:
+        if torch.max(img1) > 128:
+            max_val = 255
+        else:
+            max_val = 1
+
+        if torch.min(img1) < -0.5:
+            min_val = -1
+        else:
+            min_val = 0
+        L = max_val - min_val
+    else:
+        L = val_range
+
+    padd = 0
+    (_, _, height, width) = img1.size()
+    if window is None:
+        real_size = min(window_size, height, width)
+        window = create_window_3d(real_size, channel=1).to(img1.device)
+
+    img1 = img1.unsqueeze(1)
+    img2 = img2.unsqueeze(1)
+
+    mu1 = F.conv3d(F.pad(img1, (5, 5, 5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=1)
+    mu2 = F.conv3d(F.pad(img2, (5, 5, 5, 5, 5, 5), mode='replicate'), window, padding=padd, groups=1)
+
+    mu1_sq = mu1.pow(2)
+    mu2_sq = mu2.pow(2)
+    mu1_mu2 = mu1 * mu2
+
+    sigma1_sq = F.conv3d(F.pad(img1 * img1, (5, 5, 5, 5, 5, 5), 'replicate'), window, padding=padd, groups=1) - mu1_sq
+    sigma2_sq = F.conv3d(F.pad(img2 * img2, (5, 5, 5, 5, 5, 5), 'replicate'), window, padding=padd, groups=1) - mu2_sq
+    sigma12 = F.conv3d(F.pad(img1 * img2, (5, 5, 5, 5, 5, 5), 'replicate'), window, padding=padd, groups=1) - mu1_mu2
+
+    C1 = (0.01 * L) ** 2
+    C2 = (0.03 * L) ** 2
+
+    v1 = 2.0 * sigma12 + C2
+    v2 = sigma1_sq + sigma2_sq + C2
+    cs = torch.mean(v1 / v2)
+
+    ssim_map = ((2 * mu1_mu2 + C1) * v1) / ((mu1_sq + mu2_sq + C1) * v2)
+
+    if size_average:
+        ret = ssim_map.mean()
+    else:
+        ret = ssim_map.mean(1).mean(1).mean(1)
+
+    if full:
+        return ret, cs
+    return ret.detach().cpu().numpy()
+
+
+
+def calculate_psnr(img1, img2):
+    psnr = -10 * torch.log10(((img1 - img2) * (img1 - img2)).mean())
+    return psnr.detach().cpu().numpy()
+
+
+def calculate_ie(img1, img2):
+    ie = torch.abs(torch.round(img1 * 255.0) - torch.round(img2 * 255.0)).mean()
+    return ie.detach().cpu().numpy()

utils/video.py

@@ -0,0 +1,51 @@
+import os
+import cv2
+from tqdm import tqdm
+
+def save_video_frames(input_dir, output_dir):
+
+    os.makedirs(output_dir, exist_ok=True)
+    
+    dir_frame_idx = None
+    for filename in tqdm(os.listdir(input_dir)):
+        if filename.lower().endswith('.mp4'):
+            video_path = os.path.join(input_dir, filename)
+            
+            base_name = os.path.splitext(filename)[0]
+            
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                print(f"Warning: Cannot open {video_path}")
+                continue
+
+            frame_idx = 0
+            while True:
+                ret, frame = cap.read()
+                
+                if not ret:
+                    break
+                
+                output_filename = f"{base_name}_frame_{frame_idx}.png"
+                output_path = os.path.join(output_dir, output_filename)
+                
+                if not cv2.imwrite(output_path, frame):
+                    print(f"Warnning: Cannot write {output_path}")
+                
+                frame_idx += 1
+
+            cap.release()
+            
+            if dir_frame_idx == None:
+                dir_frame_idx = frame_idx
+            else:
+                if dir_frame_idx != frame_idx:
+                    print(f"Warning: {video_path} has {frame_idx} frames, but {dir_frame_idx} frames in {input_dir}")
+                dir_frame_idx = min(dir_frame_idx, frame_idx)
+                
+    return dir_frame_idx
+
+if __name__ == "__main__":
+    save_video_frames(
+        input_dir="aaa",
+        output_dir="bbb"
+    )

utils/weights/i3d_pretrained_400.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55095f049e706479d48e221adcdb145b2b9dc930ba28b081ed72367ffaa32343
+size 50939526

zh.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65989a137e1f7f227f2cd0161288529d00521663077706aac521498ca2bec49c
+size 666270320