first commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,90 @@
+---
+license: mit
+language:
+- en
+base_model:
+- rife
+pipeline_tag: frame 
+tags:
+- Image
+- SuperResolution
+---
+
+# RIFE
+
+This version of RIFE has been converted to run on the Axera NPU using **w16a16** quantization.
+
+This model has been optimized with the following LoRA: 
+
+Compatible with Pulsar2 version: 4.2
+
+## Convert tools links:
+
+For those who are interested in model conversion, you can try to export axmodel through 
+
+- [The repo of AXera Platform](https://github.com/AXERA-TECH/ax-samples), which you can get the detail of guide
+
+- [Pulsar2 Link, How to Convert ONNX to axmodel](https://pulsar2-docs.readthedocs.io/en/latest/pulsar2/introduction.html) 
+
+
+## Support Platform
+
+- AX650
+  - [M4N-Dock(爱芯派Pro)](https://wiki.sipeed.com/hardware/zh/maixIV/m4ndock/m4ndock.html)
+  - [M.2 Accelerator card](https://axcl-docs.readthedocs.io/zh-cn/latest/doc_guide_hardware.html)
+- AX630C
+  - [爱芯派2](https://axera-pi-2-docs-cn.readthedocs.io/zh-cn/latest/index.html)
+  - [Module-LLM](https://docs.m5stack.com/zh_CN/module/Module-LLM)
+  - [LLM630 Compute Kit](https://docs.m5stack.com/zh_CN/core/LLM630%20Compute%20Kit)
+  
+|Chips|model|cost|
+|--|--|--|
+|AX650|RIFE|200 ms|
+
+## How to use
+
+Download all files from this repository to the device
+
+```
+
+root@ax650:~/rife# tree
+.
+|-- model
+|   `-- rife_x2_720p.onnx
+|   `-- rife_x2_720p.axmodel
+|`-- run_onnx.py
+|`-- run_axmodel.py
+|`-- ms_ssim.py
+|`-- build_config.json
+|`-- requirements.txt
+
+
+
+```
+
+### Inference
+
+Input Data:
+|-- video
+|   `-- demo.mp4
+
+#### Inference with AX650 Host, such as M4N-Dock(爱芯派Pro)
+
+```
+root@ax650 ~/rife #python3 run_axmodel.py --model ./rife_x2_720p.axmodel --video ./demo.mp4
+[INFO] Available providers:  ['AxEngineExecutionProvider']
+[INFO] Using provider: AxEngineExecutionProvider
+[INFO] Chip type: ChipType.MC50
+[INFO] VNPU type: VNPUType.DISABLED
+[INFO] Engine version: 2.12.0s
+[INFO] Model type: 2 (triple core)
+[INFO] Compiler version: 4.2 77cdc0c2
+input name: onnx::Slice_0
+demo.mp4, 128.0 frames in total, 25.0FPS to 50.0FPS
+The audio will be merged after interpolation process
+ 99%|██████████████████████████████████████▋| 127/128.0 [01:38<00:00,  1.29it/s]
+
+```
+
+Output:
+[INFO]: 

build_config.json

@@ -0,0 +1,51 @@
+{
+  "input": "./rife_x2_720p.onnx",
+  "output_dir": "./output",
+  "output_name": "rife_x2_720p.axmodel",
+  "work_dir": "",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "onnx_opt": {
+    "disable_onnx_optimization": false,
+    "model_check": false,
+   },
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "DEFAULT",
+        "calibration_dataset": "1.zip",
+        "calibration_format": "Numpy",
+        "calibration_size": 10,
+        "calibration_mean": [0, 0, 0, 0, 0, 0],
+        "calibration_std": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+      }
+    ],
+    "layer_configs":[
+      {
+        "start_tensor_names": ["DEFAULT"],
+        "end_tensor_names": ["DEFAULT"],
+        "data_type": "U16",
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "Reference"
+  },
+  "input_processors": [
+    {
+      "tensor_name": "DEFAULT",
+      "src_dtype": "FP32",
+    }
+  ],
+  "output_processors": [
+    {
+      "tensor_name": "DEFAULT"
+    }
+  ],
+  "compiler": {
+    "check": 0
+  }
+}
+

ms_ssim.py

@@ -0,0 +1,200 @@
+import torch
+import torch.nn.functional as F
+from math import exp
+import numpy as np
+
+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):
+    # Value range can be different from 255. Other common ranges are 1 (sigmoid) and 2 (tanh).
+    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(img1, window, padding=padd, groups=channel)
+    # mu2 = F.conv2d(img2, window, padding=padd, groups=channel)
+    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)  # contrast sensitivity
+
+    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 ssim_matlab(img1, img2, window_size=11, window=None, size_average=True, full=False, val_range=None):
+    # Value range can be different from 255. Other common ranges are 1 (sigmoid) and 2 (tanh).
+    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)
+        # Channel is set to 1 since we consider color images as volumetric images
+
+    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)  # contrast sensitivity
+
+    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 msssim(img1, img2, window_size=11, size_average=True, val_range=None, normalize=False):
+    device = img1.device
+    weights = torch.FloatTensor([0.0448, 0.2856, 0.3001, 0.2363, 0.1333]).to(device)
+    levels = weights.size()[0]
+    mssim = []
+    mcs = []
+    for _ in range(levels):
+        sim, cs = ssim(img1, img2, window_size=window_size, size_average=size_average, full=True, val_range=val_range)
+        mssim.append(sim)
+        mcs.append(cs)
+
+        img1 = F.avg_pool2d(img1, (2, 2))
+        img2 = F.avg_pool2d(img2, (2, 2))
+
+    mssim = torch.stack(mssim)
+    mcs = torch.stack(mcs)
+
+    # Normalize (to avoid NaNs during training unstable models, not compliant with original definition)
+    if normalize:
+        mssim = (mssim + 1) / 2
+        mcs = (mcs + 1) / 2
+
+    pow1 = mcs ** weights
+    pow2 = mssim ** weights
+    # From Matlab implementation https://ece.uwaterloo.ca/~z70wang/research/iwssim/
+    output = torch.prod(pow1[:-1] * pow2[-1])
+    return output
+
+
+# Classes to re-use window
+class SSIM(torch.nn.Module):
+    def __init__(self, window_size=11, size_average=True, val_range=None):
+        super(SSIM, self).__init__()
+        self.window_size = window_size
+        self.size_average = size_average
+        self.val_range = val_range
+
+        # Assume 3 channel for SSIM
+        self.channel = 3
+        self.window = create_window(window_size, channel=self.channel)
+
+    def forward(self, img1, img2):
+        (_, channel, _, _) = img1.size()
+
+        if channel == self.channel and self.window.dtype == img1.dtype:
+            window = self.window
+        else:
+            window = create_window(self.window_size, channel).to(img1.device).type(img1.dtype)
+            self.window = window
+            self.channel = channel
+
+        _ssim = ssim(img1, img2, window=window, window_size=self.window_size, size_average=self.size_average)
+        dssim = (1 - _ssim) / 2
+        return dssim
+
+class MSSSIM(torch.nn.Module):
+    def __init__(self, window_size=11, size_average=True, channel=3):
+        super(MSSSIM, self).__init__()
+        self.window_size = window_size
+        self.size_average = size_average
+        self.channel = channel
+
+    def forward(self, img1, img2):
+        return msssim(img1, img2, window_size=self.window_size, size_average=self.size_average)

requirements.txt

@@ -0,0 +1,5 @@
+numpy>=1.16, <=1.23.5
+tqdm>=4.35.0
+torch>=1.3.0
+opencv-python>=4.1.2
+torchvision>=0.7.0

run_axmodel.py

@@ -0,0 +1,233 @@
+import os
+import cv2
+import time
+import argparse
+import numpy as np
+import axengine as axe
+import _thread
+import torch
+import torch.nn.functional as F
+import ms_ssim
+
+from tqdm import tqdm
+from queue import Queue, Empty
+
+parser = argparse.ArgumentParser(description='Interpolation for a pair of images')
+parser.add_argument('--video', dest='video', type=str, default='./demo.mp4')
+parser.add_argument('--output', dest='output', type=str, default=None)
+parser.add_argument('--img', dest='img', type=str, default=None)
+parser.add_argument('--montage', dest='montage', action='store_true', help='montage origin video')
+parser.add_argument('--model', dest='model', type=str, default=None, help='directory with trained model files')
+parser.add_argument('--fp16', dest='fp16', action='store_true', help='fp16 mode for faster and more lightweight inference on cards with Tensor Cores')
+parser.add_argument('--UHD', dest='UHD', action='store_true', help='support 4k video')
+parser.add_argument('--scale', dest='scale', type=float, default=1.0, help='Try scale=0.5 for 4k video')
+parser.add_argument('--skip', dest='skip', action='store_true', help='whether to remove static frames before processing')
+parser.add_argument('--fps', dest='fps', type=int, default=None)
+parser.add_argument('--png', dest='png', action='store_true', help='whether to vid_out png format vid_outs')
+parser.add_argument('--ext', dest='ext', type=str, default='mp4', help='vid_out video extension')
+parser.add_argument('--exp', dest='exp', type=int, default=1)
+parser.add_argument('--multi', dest='multi', type=int, default=2)
+
+def read_video(video_path):
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise IOError(f"Cannot open video: {video_path}")
+    try:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)  
+            yield frame
+    finally:
+        cap.release()
+    
+def clear_write_buffer(user_args, write_buffer, vid_out):
+    cnt = 0
+    while True:
+        item = write_buffer.get()
+        if item is None:
+            break
+        if user_args.png:
+            cv2.imwrite('vid_out/{:0>7d}.png'.format(cnt), item[:, :, ::-1])
+            cnt += 1
+        else:
+            vid_out.write(item[:, :, ::-1])
+
+def build_read_buffer(user_args, read_buffer, videogen):
+    try:
+        for frame in videogen:
+            if not user_args.img is None:
+                frame = cv2.imread(os.path.join(user_args.img, frame), cv2.IMREAD_UNCHANGED)[:, :, ::-1].copy()
+            if user_args.montage:
+                frame = frame[:, left: left + w]
+            read_buffer.put(frame)
+    except:
+        pass
+    read_buffer.put(None)
+    
+def pad_image(img, padding):
+    if(args.fp16):
+        return F.pad(img, padding).half()
+    else:
+        return F.pad(img, padding)
+    
+def run(args):
+    '''onnx inference'''
+    # model
+    session = axe.InferenceSession(args.model, providers=['AxEngineExecutionProvider'])
+    output_names = [x.name for x in session.get_outputs()]
+    input_name = session.get_inputs()[0].name 
+    
+    # video
+    videoCapture = cv2.VideoCapture(args.video)
+    fps = videoCapture.get(cv2.CAP_PROP_FPS)
+    tot_frame = videoCapture.get(cv2.CAP_PROP_FRAME_COUNT)
+    videoCapture.release()
+    if args.fps is None:
+        fpsNotAssigned = True
+        args.fps = fps * args.multi
+    else:
+        fpsNotAssigned = False
+    videogen = read_video(args.video)
+    lastframe = next(videogen)
+    fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
+    video_path_wo_ext, ext = os.path.splitext(args.video)
+    print('{}.{}, {} frames in total, {}FPS to {}FPS'.format(video_path_wo_ext, args.ext, tot_frame, fps, args.fps))
+    if args.png == False and fpsNotAssigned == True:
+        print("The audio will be merged after interpolation process")
+    else:
+        print("Will not merge audio because using png or fps flag!")
+
+    # 
+    h, w, _ = lastframe.shape
+    vid_out_name = None
+    vid_out = None
+    if args.png:
+        if not os.path.exists('vid_out'):
+            os.mkdir('vid_out')
+    else:
+        if args.output is not None:
+            vid_out_name = args.output
+        else:
+            vid_out_name = '{}_{}X_{}fps.{}'.format(video_path_wo_ext, args.multi, int(np.round(args.fps)), args.ext)
+        vid_out = cv2.VideoWriter(vid_out_name, fourcc, args.fps, (w, h))
+    
+    tmp = max(128, int(128 / args.scale))
+    ph = ((h - 1) // tmp + 1) * tmp
+    pw = ((w - 1) // tmp + 1) * tmp
+    #padding = (0, pw - w, 0, ph - h)
+    padding = ((0, 0), (0, 0), (0, ph - h), (0, pw - w))
+    pbar = tqdm(total=tot_frame, ncols=80)
+    
+    write_buffer = Queue(maxsize=500)
+    read_buffer = Queue(maxsize=500)
+    _thread.start_new_thread(build_read_buffer, (args, read_buffer, videogen))
+    _thread.start_new_thread(clear_write_buffer, (args, write_buffer, vid_out))
+
+    #device = 'cpu'
+    #I1 = torch.from_numpy(np.transpose(lastframe, (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.
+    I1 = np.expand_dims(np.transpose(lastframe, (2,0,1)), 0).astype(np.float32) / 255.
+    I1 = np.pad(I1, padding)
+    
+    temp = None # save lastframe when processing static frame
+    while True:
+        if temp is not None:
+            frame = temp
+            temp = None
+        else:
+            frame = read_buffer.get()
+        if frame is None:
+            break
+        I0 = I1
+        #I1 = torch.from_numpy(np.transpose(frame, (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.
+        I1 = np.expand_dims(np.transpose(frame, (2,0,1)), 0).astype(np.float32) / 255.
+        I1 = np.pad(I1, padding)
+
+        I0_small = F.interpolate(torch.from_numpy(I0).float(), (32, 32), mode='bilinear', align_corners=False)
+        I1_small = F.interpolate(torch.from_numpy(I1).float(), (32, 32), mode='bilinear', align_corners=False)
+        ssim = ms_ssim.ssim_matlab(I0_small[:, :3], I1_small[:, :3])
+
+        break_flag = False
+        if ssim > 0.996:  #0.996
+            frame = read_buffer.get() # read a new frame
+            if frame is None:
+                break_flag = True
+                frame = lastframe
+            else:
+                temp = frame
+            #I1 = torch.from_numpy(np.transpose(frame, (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.
+            I1 = np.expand_dims(np.transpose(frame, (2,0,1)), 0).astype(np.float32) / 255.
+            I1 = np.pad(I1, padding)
+
+            #imgs = torch.cat((I0, I1), 1).cpu().numpy()
+            imgs = np.concatenate((I0, I1), axis=1)
+            I1 = session.run(output_names, {input_name: imgs})
+
+            #I1 = torch.from_numpy(I1[-1])
+            I1 = np.array(I1[-1])
+            I1_small = F.interpolate(torch.from_numpy(I1).float(), (32, 32), mode='bilinear', align_corners=False)
+            ssim = ms_ssim.ssim_matlab(I0_small[:, :3], I1_small[:, :3])
+            #frame = (I1[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)[:h, :w]
+            frame = np.clip(I1[0] * 255, 0, 255).astype(np.uint8).transpose(1, 2, 0)[:h, :w]
+            
+        if ssim < 0.2:
+            output = []
+            for i in range(args.multi - 1):
+                output.append(I0)
+            '''
+            output = []
+            step = 1 / args.multi
+            alpha = 0
+            for i in range(args.multi - 1):
+                alpha += step
+                beta = 1-alpha
+                output.append(torch.from_numpy(np.transpose((cv2.addWeighted(frame[:, :, ::-1], alpha, lastframe[:, :, ::-1], beta, 0)[:, :, ::-1].copy()), (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.)
+            '''
+        else:
+            imgs = np.concatenate((I0, I1), axis=1)
+            output = [session.run(output_names, {input_name: imgs})[-1]]
+
+        if args.montage:
+            write_buffer.put(np.concatenate((lastframe, lastframe), 1))
+            for mid in output:
+                #mid = (((mid[0] * 255.).byte().cpu().numpy().transpose(1, 2, 0)))
+                mid = np.clip(mid[0] * 255, 0, 255).astype(np.uint8).transpose(1, 2, 0)
+                write_buffer.put(np.concatenate((lastframe, mid[:h, :w]), 1))
+        else:
+            write_buffer.put(lastframe)
+            for mid in output:
+                #mid = (((mid[0] * 255.).byte().cpu().numpy().transpose(1, 2, 0)))
+                mid = np.clip(mid[0] * 255, 0, 255).astype(np.uint8).transpose(1, 2, 0)
+                write_buffer.put(mid[:h, :w])
+        pbar.update(1)
+        lastframe = frame
+        if break_flag:
+            break
+        
+    if args.montage:
+        write_buffer.put(np.concatenate((lastframe, lastframe), 1))
+    else:
+        write_buffer.put(lastframe)      
+    write_buffer.put(None)
+
+    while(not write_buffer.empty()):
+        time.sleep(0.1)
+    pbar.close()
+    if not vid_out is None:
+        vid_out.release()
+        
+if __name__ == '__main__':
+    args = parser.parse_args()
+    if args.exp != 1:
+        args.multi = (2 ** args.exp)
+    assert (not args.video is None or not args.img is None)
+    if args.skip:
+        print("skip flag is abandoned, please refer to issue #207.")
+    if args.UHD and args.scale==1.0:
+        args.scale = 0.5
+    assert args.scale in [0.25, 0.5, 1.0, 2.0, 4.0]
+    if not args.img is None:
+        args.png = True
+        
+    run(args)

run_onnx.py

@@ -0,0 +1,233 @@
+import os
+import cv2
+import time
+import argparse
+import numpy as np
+import onnxruntime as ort
+import _thread
+import torch
+import torch.nn.functional as F
+import ms_ssim
+
+from tqdm import tqdm
+from queue import Queue, Empty
+
+parser = argparse.ArgumentParser(description='Interpolation for a pair of images')
+parser.add_argument('--video', dest='video', type=str, default='./demo.mp4')
+parser.add_argument('--output', dest='output', type=str, default=None)
+parser.add_argument('--img', dest='img', type=str, default=None)
+parser.add_argument('--montage', dest='montage', action='store_true', help='montage origin video')
+parser.add_argument('--model', dest='model', type=str, default=None, help='directory with trained model files')
+parser.add_argument('--fp16', dest='fp16', action='store_true', help='fp16 mode for faster and more lightweight inference on cards with Tensor Cores')
+parser.add_argument('--UHD', dest='UHD', action='store_true', help='support 4k video')
+parser.add_argument('--scale', dest='scale', type=float, default=1.0, help='Try scale=0.5 for 4k video')
+parser.add_argument('--skip', dest='skip', action='store_true', help='whether to remove static frames before processing')
+parser.add_argument('--fps', dest='fps', type=int, default=None)
+parser.add_argument('--png', dest='png', action='store_true', help='whether to vid_out png format vid_outs')
+parser.add_argument('--ext', dest='ext', type=str, default='mp4', help='vid_out video extension')
+parser.add_argument('--exp', dest='exp', type=int, default=1)
+parser.add_argument('--multi', dest='multi', type=int, default=2)
+
+def read_video(video_path):
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise IOError(f"Cannot open video: {video_path}")
+    try:
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)  
+            yield frame
+    finally:
+        cap.release()
+    
+def clear_write_buffer(user_args, write_buffer, vid_out):
+    cnt = 0
+    while True:
+        item = write_buffer.get()
+        if item is None:
+            break
+        if user_args.png:
+            cv2.imwrite('vid_out/{:0>7d}.png'.format(cnt), item[:, :, ::-1])
+            cnt += 1
+        else:
+            vid_out.write(item[:, :, ::-1])
+
+def build_read_buffer(user_args, read_buffer, videogen):
+    try:
+        for frame in videogen:
+            if not user_args.img is None:
+                frame = cv2.imread(os.path.join(user_args.img, frame), cv2.IMREAD_UNCHANGED)[:, :, ::-1].copy()
+            if user_args.montage:
+                frame = frame[:, left: left + w]
+            read_buffer.put(frame)
+    except:
+        pass
+    read_buffer.put(None)
+    
+def pad_image(img, padding):
+    if(args.fp16):
+        return F.pad(img, padding).half()
+    else:
+        return F.pad(img, padding)
+    
+def run(args):
+    '''onnx inference'''
+    # model
+    session = ort.InferenceSession(args.model, providers=['CPUExecutionProvider'])
+    output_names = [x.name for x in session.get_outputs()]
+    input_name = session.get_inputs()[0].name 
+    
+    # video
+    videoCapture = cv2.VideoCapture(args.video)
+    fps = videoCapture.get(cv2.CAP_PROP_FPS)
+    tot_frame = videoCapture.get(cv2.CAP_PROP_FRAME_COUNT)
+    videoCapture.release()
+    if args.fps is None:
+        fpsNotAssigned = True
+        args.fps = fps * args.multi
+    else:
+        fpsNotAssigned = False
+    videogen = read_video(args.video)
+    lastframe = next(videogen)
+    fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
+    video_path_wo_ext, ext = os.path.splitext(args.video)
+    print('{}.{}, {} frames in total, {}FPS to {}FPS'.format(video_path_wo_ext, args.ext, tot_frame, fps, args.fps))
+    if args.png == False and fpsNotAssigned == True:
+        print("The audio will be merged after interpolation process")
+    else:
+        print("Will not merge audio because using png or fps flag!")
+
+    # 
+    h, w, _ = lastframe.shape
+    vid_out_name = None
+    vid_out = None
+    if args.png:
+        if not os.path.exists('vid_out'):
+            os.mkdir('vid_out')
+    else:
+        if args.output is not None:
+            vid_out_name = args.output
+        else:
+            vid_out_name = '{}_{}X_{}fps.{}'.format(video_path_wo_ext, args.multi, int(np.round(args.fps)), args.ext)
+        vid_out = cv2.VideoWriter(vid_out_name, fourcc, args.fps, (w, h))
+    
+    tmp = max(128, int(128 / args.scale))
+    ph = ((h - 1) // tmp + 1) * tmp
+    pw = ((w - 1) // tmp + 1) * tmp
+    #padding = (0, pw - w, 0, ph - h)
+    padding = ((0, 0), (0, 0), (0, ph - h), (0, pw - w))
+    pbar = tqdm(total=tot_frame, ncols=80)
+    
+    write_buffer = Queue(maxsize=500)
+    read_buffer = Queue(maxsize=500)
+    _thread.start_new_thread(build_read_buffer, (args, read_buffer, videogen))
+    _thread.start_new_thread(clear_write_buffer, (args, write_buffer, vid_out))
+
+    #device = 'cpu'
+    #I1 = torch.from_numpy(np.transpose(lastframe, (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.
+    I1 = np.expand_dims(np.transpose(lastframe, (2,0,1)), 0).astype(np.float32) / 255.
+    I1 = np.pad(I1, padding)
+    
+    temp = None # save lastframe when processing static frame
+    while True:
+        if temp is not None:
+            frame = temp
+            temp = None
+        else:
+            frame = read_buffer.get()
+        if frame is None:
+            break
+        I0 = I1
+        #I1 = torch.from_numpy(np.transpose(frame, (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.
+        I1 = np.expand_dims(np.transpose(frame, (2,0,1)), 0).astype(np.float32) / 255.
+        I1 = np.pad(I1, padding)
+
+        I0_small = F.interpolate(torch.from_numpy(I0).float(), (32, 32), mode='bilinear', align_corners=False)
+        I1_small = F.interpolate(torch.from_numpy(I1).float(), (32, 32), mode='bilinear', align_corners=False)
+        ssim = ms_ssim.ssim_matlab(I0_small[:, :3], I1_small[:, :3])
+
+        break_flag = False
+        if ssim > 0.996:  #0.996
+            frame = read_buffer.get() # read a new frame
+            if frame is None:
+                break_flag = True
+                frame = lastframe
+            else:
+                temp = frame
+            #I1 = torch.from_numpy(np.transpose(frame, (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.
+            I1 = np.expand_dims(np.transpose(frame, (2,0,1)), 0).astype(np.float32) / 255.
+            I1 = np.pad(I1, padding)
+
+            #imgs = torch.cat((I0, I1), 1).cpu().numpy()
+            imgs = np.concatenate((I0, I1), axis=1)
+            I1 = session.run(output_names, {input_name: imgs})
+
+            #I1 = torch.from_numpy(I1[-1])
+            I1 = np.array(I1[-1])
+            I1_small = F.interpolate(torch.from_numpy(I1).float(), (32, 32), mode='bilinear', align_corners=False)
+            ssim = ms_ssim.ssim_matlab(I0_small[:, :3], I1_small[:, :3])
+            #frame = (I1[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)[:h, :w]
+            frame = np.clip(I1[0] * 255, 0, 255).astype(np.uint8).transpose(1, 2, 0)[:h, :w]
+            
+        if ssim < 0.2:
+            output = []
+            for i in range(args.multi - 1):
+                output.append(I0)
+            '''
+            output = []
+            step = 1 / args.multi
+            alpha = 0
+            for i in range(args.multi - 1):
+                alpha += step
+                beta = 1-alpha
+                output.append(torch.from_numpy(np.transpose((cv2.addWeighted(frame[:, :, ::-1], alpha, lastframe[:, :, ::-1], beta, 0)[:, :, ::-1].copy()), (2,0,1))).to(device, non_blocking=True).unsqueeze(0).float() / 255.)
+            '''
+        else:
+            imgs = np.concatenate((I0, I1), axis=1)
+            output = [session.run(output_names, {input_name: imgs})[-1]]
+
+        if args.montage:
+            write_buffer.put(np.concatenate((lastframe, lastframe), 1))
+            for mid in output:
+                #mid = (((mid[0] * 255.).byte().cpu().numpy().transpose(1, 2, 0)))
+                mid = np.clip(mid[0] * 255, 0, 255).astype(np.uint8).transpose(1, 2, 0)
+                write_buffer.put(np.concatenate((lastframe, mid[:h, :w]), 1))
+        else:
+            write_buffer.put(lastframe)
+            for mid in output:
+                #mid = (((mid[0] * 255.).byte().cpu().numpy().transpose(1, 2, 0)))
+                mid = np.clip(mid[0] * 255, 0, 255).astype(np.uint8).transpose(1, 2, 0)
+                write_buffer.put(mid[:h, :w])
+        pbar.update(1)
+        lastframe = frame
+        if break_flag:
+            break
+        
+    if args.montage:
+        write_buffer.put(np.concatenate((lastframe, lastframe), 1))
+    else:
+        write_buffer.put(lastframe)      
+    write_buffer.put(None)
+
+    while(not write_buffer.empty()):
+        time.sleep(0.1)
+    pbar.close()
+    if not vid_out is None:
+        vid_out.release()
+        
+if __name__ == '__main__':
+    args = parser.parse_args()
+    if args.exp != 1:
+        args.multi = (2 ** args.exp)
+    assert (not args.video is None or not args.img is None)
+    if args.skip:
+        print("skip flag is abandoned, please refer to issue #207.")
+    if args.UHD and args.scale==1.0:
+        args.scale = 0.5
+    assert args.scale in [0.25, 0.5, 1.0, 2.0, 4.0]
+    if not args.img is None:
+        args.png = True
+        
+    run(args)