first release

.gitignore

@@ -0,0 +1,4 @@
+**/__pycache__
+flagged/
+models/
+static/

app.py

@@ -1,7 +1,15 @@
 import gradio as gr
+import utils
+from config import KINETICS_600_LABELS, MODEL
 
-def greet(name):
-    return "Hello " + name + "!!"
+def get_predictions(video_path):
+    video, frame_list = utils.preprocess_video(video_path)
+    model = MODEL
+    probs = model(video)
+    labels = utils.get_top_k(probs, label_map=KINETICS_600_LABELS)
+    return labels
 
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
+label = gr.components.Label(num_top_classes=5)
+vd = gr.components.Video()
+iface = gr.Interface(fn=get_predictions, inputs=vd, outputs=label)
+iface.launch(debug=True)

config.py

@@ -0,0 +1,49 @@
+import tensorflow as tf
+import tensorflow_hub as hub
+from keras.models import load_model
+from pathlib import Path
+import numpy as np
+import config
+import os
+
+
+FRAME_HT = 224
+FRAME_WD = 224
+FRAME_NUM = 8
+TENSORFLOW_HUB_URL_LABELS = "https://raw.githubusercontent.com/tensorflow/models/f8af2291cced43fc9f1d9b41ddbf772ae7b0d7d2/official/projects/movinet/files/kinetics_600_labels.txt"
+TENSORFLOW_HUB_URL_MODEL = "https://tfhub.dev/tensorflow/movinet/a2/base/kinetics-600/classification/3"
+MODEL_PATH = os.path.join(os.getcwd(), 'models', 'Activity_recognition.h5')
+
+def get_labels():
+
+    labels_path = tf.keras.utils.get_file(
+                fname=os.path.join(os.getcwd(), 'static', 'labels.txt'),
+                origin=config.TENSORFLOW_HUB_URL_LABELS
+                )
+    
+    labels_path = Path(labels_path)
+
+    lines = labels_path.read_text().splitlines()
+    KINETICS_600_LABELS = np.array([line.strip() for line in lines])
+
+    return KINETICS_600_LABELS
+
+
+def get_model():
+    encoder = hub.KerasLayer(TENSORFLOW_HUB_URL_MODEL, trainable=True)
+
+    inputs = tf.keras.layers.Input(
+                        shape=[FRAME_NUM, FRAME_HT, FRAME_WD, 3],
+                        dtype=tf.float32,
+                        name='image'
+                        )
+
+    # [batch_size, 600] 
+    outputs = encoder(dict(image=inputs))
+
+    model = tf.keras.Model(inputs, outputs, name='movinet')
+
+    return model
+
+KINETICS_600_LABELS = get_labels()
+MODEL = get_model()

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+tensorflow-cpu
+tensorflow-hub
+numpy
+opencv-python

utils.py

@@ -0,0 +1,76 @@
+import tensorflow as tf
+import cv2
+import os
+import numpy as np
+from pathlib import Path
+import config
+
+
+
+
+
+def preprocess_video(video_path : str) :
+  # load the video
+  video_capture = cv2.VideoCapture(video_path)
+
+  # the number of frames in the original video
+  original_number_of_frames = video_capture.get(cv2.CAP_PROP_FRAME_COUNT)
+
+  # gap between two consecutive frames to capture
+  frame_interval = int(original_number_of_frames / config.FRAME_NUM)
+
+  new_video , frame_list = [] , []
+  for i in range(0, config.FRAME_NUM  ):
+    video_capture.set(cv2.CAP_PROP_POS_FRAMES, i*frame_interval)
+    success, frame = video_capture.read()
+
+    if not success :
+       print("video loading failed")
+    
+    frame_list.append(frame)
+    # Resize the Frame to fixed height and width.
+    resized_frame = cv2.resize(frame, (config.FRAME_HT, config.FRAME_WD))
+    
+    # Normalize the resized frame by dividing it with 255 so that each pixel value then lies between 0 and 1
+    normalized_frame = resized_frame / 255
+    
+    # Append the normalized frame into the frames list
+    new_video.append(normalized_frame)
+
+  new_video_array = np.asarray(new_video)
+
+  input_tensor = tf.expand_dims(new_video_array, axis=0)
+
+
+  video_capture.release()
+
+  return input_tensor, frame_list
+
+
+# Get top_k labels and probabilities
+def get_top_k(probs, label_map,k=5 ):
+    """Outputs the top k model labels and probabilities on the given video.
+
+    Args:
+        probs: probability tensor of shape (num_frames, num_classes) that represents
+        the probability of each class on each frame.
+        k: the number of top predictions to select.
+        label_map: a list of labels to map logit indices to label strings.
+
+    Returns:
+        a tuple of the top-k labels and probabilities.
+    """
+    # Sort predictions to find top_k
+    indices = tf.argsort(probs, direction='DESCENDING').numpy()[0][:k]
+    # collect the labels of top_k predictions
+    labels = tf.gather(label_map, indices).numpy()
+    # decode lablels
+    labels = [label.decode('utf8') for label in labels]
+    # top_k probabilities of the predictions
+    top_probs = tf.gather(probs[0], indices).numpy()
+    
+    output = dict()
+    for label, prob in zip(labels, top_probs):
+        output[label] = float(prob) / 100
+    print(output)
+    return output