Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+submission.csv

README.md

@@ -0,0 +1,4 @@
+# SAFE Example Submission
+
+The key requirements is to have a `script.py` file in the top level directory of the repo.
+

requirements.txt

@@ -0,0 +1,7 @@
+torch
+av
+torchvision
+torchcodec
+datasets
+pandas
+tqdm

script.py

@@ -0,0 +1,102 @@
+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)