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