这有帮助吗？
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime22/tcppip install torch torchvision && \
git clone https://github.com/megvii-research/ECCV2022-RIFE.git && \
cd ECCV2022-RIFE && \
pip install -r requirements.txtpip install rife-ncnn-vulkan-pythongit clone https://github.com/megvii-research/ECCV2022-RIFE.git
cd ECCV2022-RIFE
pip install -r requirements.txtpython inference_video.py --exp=1 --video=input.mp4
# 输出：2x FPSpython inference_video.py --exp=2 --video=input.mp4
# 输出：4x FPSpython inference_video.py --exp=3 --video=input.mp4
# 输出：8x FPSimport torch
from model.RIFE import Model
device = torch.device("cuda")
model = Model()
model.load_model('./train_log', -1)
model.eval()
model.device()import cv2
import numpy as np
import torch
def interpolate_frames(frame1, frame2, model, num_frames=1):
"""在两张图像之间插值帧"""
# 准备张量
img0 = torch.from_numpy(frame1).permute(2, 0, 1).float() / 255.0
img1 = torch.from_numpy(frame2).permute(2, 0, 1).float() / 255.0
img0 = img0.unsqueeze(0).cuda()
img1 = img1.unsqueeze(0).cuda()
# 插值
with torch.no_grad():
middle = model.inference(img0, img1)
# 转换回去
middle = (middle[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)
return middle
# 加载帧
frame1 = cv2.imread('frame1.png')
frame2 = cv2.imread('frame2.png')
# 获取插值帧
middle_frame = interpolate_frames(frame1, frame2, model)
cv2.imwrite('interpolated.png', middle_frame)import cv2
import torch
from model.RIFE import Model
model = Model()
model.load_model('./train_log', -1)
model.eval()
model.device()
def process_video(input_path, output_path, multiplier=2):
cap = cv2.VideoCapture(input_path)
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
out = cv2.VideoWriter(
output_path,
cv2.VideoWriter_fourcc(*'mp4v'),
fps * multiplier,
(width, height)
)
ret, prev_frame = cap.read()
if not ret:
return
out.write(prev_frame)
while True:
ret, curr_frame = cap.read()
if not ret:
break
# 准备张量
img0 = torch.from_numpy(prev_frame).permute(2, 0, 1).float() / 255.0
img1 = torch.from_numpy(curr_frame).permute(2, 0, 1).float() / 255.0
img0 = img0.unsqueeze(0).cuda()
img1 = img1.unsqueeze(0).cuda()
# 生成中间帧
for i in range(multiplier - 1):
t = (i + 1) / multiplier
with torch.no_grad():
middle = model.inference(img0, img1, timestep=t)
middle = (middle[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)
out.write(middle)
out.write(curr_frame)
prev_frame = curr_frame
cap.release()
out.release()
process_video('input.mp4', 'output_60fps.mp4', multiplier=2)from rife_ncnn_vulkan import Rife
rife = Rife(gpu_id=0)
# 插值
frame1 = Image.open('frame1.png')
frame2 = Image.open('frame2.png')
middle = rife.process(frame1, frame2)
middle.save('interpolated.png')from rife_ncnn_vulkan import Rife
import cv2
from PIL import Image
rife = Rife(gpu_id=0, num_threads=4)
def interpolate_video(input_path, output_path, factor=2):
cap = cv2.VideoCapture(input_path)
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
out = cv2.VideoWriter(
output_path,
cv2.VideoWriter_fourcc(*'mp4v'),
fps * factor,
(width, height)
)
ret, prev = cap.read()
out.write(prev)
while True:
ret, curr = cap.read()
if not ret:
break
# 转换为 PIL
prev_pil = Image.fromarray(cv2.cvtColor(prev, cv2.COLOR_BGR2RGB))
curr_pil = Image.fromarray(cv2.cvtColor(curr, cv2.COLOR_BGR2RGB))
# 插值
for i in range(factor - 1):
t = (i + 1) / factor
mid = rife.process(prev_pil, curr_pil, timestep=t)
mid_cv = cv2.cvtColor(np.array(mid), cv2.COLOR_RGB2BGR)
out.write(mid_cv)
out.write(curr)
prev = curr
cap.release()
out.release()
# 原始：30 fps，10 秒 = 300 帧
# 8x 插帧：2400 帧
# 以 30 fps 播放：80 秒（慢 8 倍）
python inference_video.py --exp=3 --video=input.mp4
# 这会生成 8 倍的帧数，以原始 FPS 播放以获得慢动作效果def create_slow_motion(input_path, output_path, slowdown_factor=4):
"""创建慢动作视频"""
cap = cv2.VideoCapture(input_path)
original_fps = cap.get(cv2.CAP_PROP_FPS)
# 插值以获得更多帧
exp = int(np.log2(slowdown_factor))
interpolate_video(input_path, 'temp_interpolated.mp4', factor=slowdown_factor)
# 以原始 FPS 重新编码
cap2 = cv2.VideoCapture('temp_interpolated.mp4')
width = int(cap2.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cap2.get(cv2.CAP_PROP_FRAME_HEIGHT))
out = cv2.VideoWriter(
output_path,
cv2.VideoWriter_fourcc(*'mp4v'),
original_fps, # 保持原始 FPS
(width, height)
)
while True:
ret, frame = cap2.read()
if not ret:
break
out.write(frame)
cap.release()
cap2.release()
out.release()批处理处理
from concurrent.futures import ThreadPoolExecutor
def process_single(input_path, output_dir, factor=2):
filename = os.path.basename(input_path)
output_path = os.path.join(output_dir, f"interpolated_{filename}")
interpolate_video(input_path, output_path, factor)
return output_path
input_dir = './videos'
output_dir = './interpolated'
output_dir = "./relit"
videos = [os.path.join(input_dir, f) for f in os.listdir(input_dir)
if f.endswith(('.mp4', '.mkv', '.avi'))]
for video in videos:
result = process_single(video, output_dir, factor=2)
print(f"Completed: {result}")python inference_video.py --exp=1 --video=input.mp4 --UHD
# 以切片方式处理
from model.RIFE import Model
model = Model()
model.load_model('./train_log', -1)
model.eval()
# 为大画面设置切片大小
# model.inference 在内部处理切片
# 使用 NCNN 版本（更节省内存）
pip install rife-ncnn-vulkan-pythonfrom scenedetect import detect, ContentDetector
scenes = detect('input.mp4', ContentDetector())
# 不要在场景之间插值
for scene in scenes:
print(f"Scene: {scene[0].get_frames()} - {scene[1].get_frames()}")