Create app.py

app.py

@@ -0,0 +1,114 @@
+import cv2
+import numpy as np
+
+def extract_frames(video_path, frame_skip=3, num_frames=30):
+    """
+    Extract frames from the video for analysis.
+    
+    video_path: str, path to the video file
+    frame_skip: int, number of frames to skip between detections (e.g., skip every 3rd frame)
+    num_frames: int, number of frames to extract for analysis
+
+    Returns: 
+    - frames_list: List of processed video frames
+    """
+    frames_list = []
+    cap = cv2.VideoCapture(video_path)
+    
+    frame_counter = 0
+    while frame_counter < num_frames:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        # Skip frames based on the frame_skip value
+        if frame_counter % frame_skip == 0:
+            # Preprocess frame (resize, normalize, etc.)
+            resized_frame = cv2.resize(frame, (224, 224))  # Resizing to 224x224
+            normalized_frame = resized_frame / 255.0  # Normalizing to [0, 1]
+            frames_list.append(normalized_frame)
+        
+        frame_counter += 1
+    
+    cap.release()
+    return np.array(frames_list)
+
+# Example usage
+video_path = 'path_to_video.mp4'
+frames = extract_frames(video_path, frame_skip=3, num_frames=30)
+import torch
+import cv2
+
+# Load YOLOv5 model (from Hugging Face or directly from Ultralytics)
+model = torch.hub.load('ultralytics/yolov5', 'yolov5m')
+
+def detect_objects_in_frame(frame):
+    results = model(frame)  # Running YOLOv5 on the frame
+    return results
+
+def process_video_for_detection(video_path):
+    cap = cv2.VideoCapture(video_path)
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        # Detect objects using YOLOv5
+        results = detect_objects_in_frame(frame)
+        
+        # Show or process the detection results
+        results.show()  # Display the detected frame
+        
+        # Break the loop on pressing 'q'
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+    
+    cap.release()
+    cv2.destroyAllWindows()
+
+# Example usage
+process_video_for_detection('path_to_video.mp4')
+import tensorflow as tf
+from tensorflow.keras.models import Model
+from tensorflow.keras.layers import Input, Dense
+from tensorflow.keras.optimizers import Adam
+
+# Build an autoencoder model
+def build_autoencoder(input_shape):
+    input_layer = Input(shape=input_shape)
+    encoded = Dense(128, activation='relu')(input_layer)
+    encoded = Dense(64, activation='relu')(encoded)
+    decoded = Dense(128, activation='relu')(encoded)
+    decoded = Dense(input_shape[0], activation='sigmoid')(decoded)
+    
+    autoencoder = Model(input_layer, decoded)
+    autoencoder.compile(optimizer=Adam(), loss='mean_squared_error')
+    
+    return autoencoder
+
+# Train the autoencoder on normal (non-abnormal) frames
+def train_autoencoder(frames):
+    model = build_autoencoder(frames.shape[1:])
+    model.fit(frames, frames, epochs=10, batch_size=32, shuffle=True)
+    return model
+
+# Predict anomalies by comparing reconstruction error
+def detect_anomalies(autoencoder, frames):
+    reconstructed = autoencoder.predict(frames)
+    reconstruction_error = np.mean(np.abs(reconstructed - frames), axis=(1,2,3))  # Mean error per frame
+    return reconstruction_error
+import gradio as gr
+
+def predict(video):
+    video_path = video.name
+    frames = extract_frames(video_path)
+    # Call your detection functions here
+    anomaly_detection_result = detect_anomalies(autoencoder, frames)
+    
+    if anomaly_detection_result > threshold:  # Set a threshold for anomaly
+        return "Abnormal behavior detected!"
+    else:
+        return "Normal behavior detected"
+
+iface = gr.Interface(fn=predict, inputs=gr.inputs.Video(), outputs=gr.outputs.Textbox())
+iface.launch()