NoRepeated-score

[iGuoYanjun]

Is there a plan to open-source the calculation code for NoRrepeated-score?

[zhuhz22]

# cos_sin.py


import os
import torch
import argparse
from torchvision.io import read_video
from torch.nn.functional import cosine_similarity

def process_video(video_path,theoretical_position, N, metric='cosine', mode='window_mean'):
    try:
        video, _, _ = read_video(video_path, output_format="TCHW")
    except Exception as e:
        print(f"Error reading video {video_path}: {e}")
        return None

    T = video.shape[0]
    if T == 0:
        print(f"Video {video_path} has no frames.")
        return None

    video = video.float().div(255)
    similarities = []

    if mode == 'fixed_offset':
        # 阶段1：确定初始偏移量 -------------------------
        if T < args.theoretical_position + N + 1:  # 确保至少能计算初始窗口
            print(f"Video too short ({T} frames) for fixed offset mode")
            return None

        # 计算第0帧的窗口范围
        start = max(0, 0 + args.theoretical_position - N)
        end = min(0 + args.theoretical_position + N, T-1)
        
        if start >= end:
            print(f"Invalid initial window for {video_path}")
            return None

        # 查找最相似帧
        current_frame = video[0].flatten()
        window_frames = video[start:end+1].flatten(1)

        if metric == 'cosine':
            sims = cosine_similarity(current_frame.unsqueeze(0), window_frames, dim=1)
        elif metric == 'l2':
            sims = -torch.cdist(current_frame.unsqueeze(0), window_frames, p=2)

        # 找到最相似帧的绝对位置
        best_idx = torch.argmax(sims).item()
        offset = start + best_idx - 0  # 计算偏移量

        # 阶段2：应用固定偏移量 -------------------------
        max_i = T - 1 - offset
        if max_i < 0:
            print(f"Offset {offset} too large for {T} frames")
            return None

        for i in range(0, max_i + 1):
            j = i + offset
            frame_i = video[i].flatten()
            frame_j = video[j].flatten()

            if metric == 'cosine':
                sim = cosine_similarity(frame_i.unsqueeze(0), frame_j.unsqueeze(0))
            elif metric == 'l2':
                sim = -torch.cdist(frame_i.unsqueeze(0), frame_j.unsqueeze(0), p=2)
            
            similarities.append(sim.item())

    else:
        for i in range(T):
            if i + args.theoretical_position - N >= T:
                break

            start = i + args.theoretical_position - N
            end = i + args.theoretical_position + N
            start = max(0, start)
            end = min(end, T-1)

            if start > end:
                continue

            current_frame = video[i].flatten()
            window_frames = video[start:end+1].flatten(1)

            if metric == 'cosine':
                sim = cosine_similarity(current_frame.unsqueeze(0), window_frames, dim=1)
            elif metric == 'l2':
                sim = -torch.cdist(current_frame.unsqueeze(0), window_frames, p=2)

            similarities.append(sim.mean().item())

    if not similarities:
        return None

    return sum(similarities) / len(similarities)

def main(directory,theoretical_position, N, metric, mode):
    all_means = []
    
    for root, _, files in os.walk(directory):
        for file in files:
            if file.endswith(".mp4"):
                video_path = os.path.join(root, file)
                mean = process_video(video_path,theoretical_position, N, metric, mode)
                if mean is not None:
                    print(f"{video_path}: {mean:.4f}")
                    print(mean)
                    if -mean >= 100:
                        all_means.append(1)
                    else:
                        all_means.append(0)

    if all_means:
        print(f"\nSummary ({mode} mode, {metric} metric):")
        print(f"Processed videos: {len(all_means)}")
        print(f"Global mean: {sum(all_means)/len(all_means):.4f}")
    else:
        print("\nNo valid results found")

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('--directory', type=str, required=True)
    parser.add_argument('--N', type=int, required=True)
    parser.add_argument('--theoretical_position', type=int, required=True)
    parser.add_argument('--metric', choices=['cosine', 'l2'], default='cosine')
    parser.add_argument('--mode', choices=['window_mean', 'fixed_offset'], 
                      default='fixed_offset', help='Calculation mode')
    args = parser.parse_args()
    
    main(args.directory,args.theoretical_position, args.N, args.metric, args.mode)

Usage: take HunyuanVideo for example:

• python cos_sim.py --directory {your directory} --N 12 --theoretical_position 200 --metric l2
• For NTK 2.3x: --theoretical_position is 296

[iGuoYanjun]

Thank you so much for your quick reply!