script.py

import pandas as pd
from datasets import load_dataset
import numpy as np
import tqdm.auto as tqdm
import os
import io
import torch
import time
import av
import torch
import numpy as np

# Import your model and anything else you want
# You can even install other packages included in your repo
# However, during the evaluation the container will not have access to the internet.
# So you must include everything you need in your model repo.


import torch

# from torchcodec.decoders import VideoDecoder

# def preprocess_v1(file_like):
#     file_like.seek(0)
#     decoder = VideoDecoder(file_like)
#     frames = decoder[0:-1:20]
#     frames = frames.float() / 255.0
#     return frames


def preprocess(file_like):
    # Open the video file
    file_like.seek(0)
    container = av.open(file_like)
    frames = []
    every = 10
    for i, frame in enumerate(container.decode(video=0)):
        if i % every == 0:
            frame_array = frame.to_ndarray(format="rgb24")
            frame_tensor = torch.from_numpy(frame_array).permute(2, 0, 1).float()
            frames.append(frame_tensor)

    video_tensor = torch.stack(frames)
    return video_tensor


class Model(torch.nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.fc1 = torch.nn.Linear(10, 5)
        self.threshold = 0.0

    def forward(self, x):
        ## generates a random float the same size as x
        return torch.randn(x.shape[0]).to(x.device)


# load the dataset. dataset will be automatically downloaded to /tmp/data during evaluation
DATASET_PATH = "/tmp/data"
dataset_remote = load_dataset(DATASET_PATH, split="test", streaming=True)


# load your model
device = "cuda:0"
model = Model().to(device)


# iterate over the dataset
out = []
for el in tqdm.tqdm(dataset_remote):

    # start_time = time.time()

    # each element is a dict
    # el["video"]["bytes"] contains bytes from reading the raw file
    # el["video"]["path"] containts the filename. This is just for reference and you cant actually load it

    # if you are using libraries that expect a file. You can use BytesIO object
    try:
        file_like = io.BytesIO(el["video"]["bytes"])
        tensor = preprocess(file_like)

        with torch.no_grad():
            # soft decision (such as log likelihood score)
            # positive score correspond to synthetic prediction
            # negative score correspond to real prediction
            score = model(tensor[None].to(device)).cpu().item()

            # we require a hard decision to be submited. so you need to pick a threshold
            pred = "generated" if score > model.threshold else "real"

        # append your prediction
        # "id" and "pred" are required. "score" will not be used in scoring but we encourage you to include it. We'll use it for analysis of the results

        out.append(dict(id=el["id"], pred=pred, score=score))
    except Exception as e:
        print(e)
        print("failed", el["id"])
        out.append(dict(id=el["id"]))

# save the final result and that's it
pd.DataFrame(out).to_csv("submission.csv", index=False)