Create README.md

README.md

@@ -0,0 +1,135 @@
+---
+language:
+- en
+metrics:
+- accuracy
+- f1
+- precision
+- recall
+pipeline_tag: video-classification
+tags:
+- i3d
+- pytorch
+- crime-detection
+---
+
+
+# Smart Surveillance System
+
+we leveraged a pre-trained I3D model and fine-tuned it using two strategies:
+
+Block-level tuning Adjusting and retraining groups of layers (blocks) to adapt the model to the new dataset.
+
+Layer-level tuning Fine-tuning specific layers for more granular control over feature learning.
+
+The final classification layer of the I3D model was removed and replaced with a custom output layer tailored to our binary classification task: predicting whether an activity represents a crime (1) or non-crime (0).
+
+## How Run 
+
+```python
+import torch
+import torch.nn as nn
+
+
+class UCFModel(nn.Module):
+    def __init__(self, model_name="i3d_r50"):
+        super().__init__()
+        self.model_name = model_name
+
+        self.model = torch.hub.load("facebookresearch/pytorchvideo", model_name, pretrained=True)
+
+        in_features = self.model.blocks[-1].proj.in_features
+        self.model.blocks[-1].proj = nn.Linear(in_features, 2)
+
+    def forward(self, frames):
+        return self.model(frames)
+
+```
+
+```python
+import torch
+from PIL import Image
+from huggingface_hub import hf_hub_download
+from torchvision import transforms
+
+
+inference_transform = transforms.Compose(
+    [
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+)
+
+
+class UCFInferenceByFrames:
+    def __init__(self, repo_id):
+        self.repo_id = repo_id
+
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = self.load_model()
+
+    def load_model(self):
+        model_path = hf_hub_download(repo_id=self.repo_id, filename="ucf_model.pth")
+        state_dict = torch.load(model_path)
+
+        model = UCFModel().to(device=self.device)
+        model.load_state_dict(state_dict)
+        model.eval()
+
+        return model
+
+    def inference(self, frames):
+        video_tensor_list = []
+        for frame in frames:
+            frame_pil = Image.fromarray(frame)
+            frame_tensor = inference_transform(frame_pil)
+            video_tensor_list.append(frame_tensor)
+
+        video_tensor = torch.stack(video_tensor_list)
+        video_tensor = video_tensor.permute(1, 0, 2, 3).unsqueeze(0).float()
+
+        video_tensor = video_tensor.to(self.device)
+
+        with torch.no_grad():
+            output = self.model(video_tensor)
+
+        return output.argmax(1)
+```
+
+```python
+import cv2 as cv
+import numpy as np
+
+ucf = UCFInferenceByFrames("amjad-awad/ucf-i3d-model-by-3-block-lr-0.001")
+
+def inference(ucf_model, video_path, max_frames=16):
+    cap = cv.VideoCapture(video_path)
+
+    if not cap.isOpened():
+        print("No video")
+        return
+    
+    frames = []
+
+    while True:
+        ret, frame = cap.read()
+
+        if not ret:
+            break
+
+        frames.append(frame)
+    
+    length = len(frames)
+    indices = np.linspace(0, length - 1, max_frames, dtype=int)
+    frames = [frames[i] for i in indices]
+    predict = ucf_model.inference(frames)
+
+    return "Crime" if int(predict) == 1 else "No-Crime"
+
+```
+
+```python
+predict = inference(ucf_model=ucf, video_path="YOUR_VIDEO_PATH.mp4")
+print(predict)
+```