initial commit

app.py

@@ -0,0 +1,101 @@
+import gradio as gr
+import warnings
+import os
+from classifier import Classifier
+warnings.filterwarnings('ignore')
+
+video_examples = [os.path.join(os.path.dirname(__file__),
+                               "examples/group_test.mp4")]
+
+img_examples = [["examples/group_test.png"],
+                ["examples/smile-1.png"],
+                ["examples/smile-2.png"],
+                ["examples/angry-1.png"],
+                ["examples/sad-1.png"],
+                ["examples/sad-2.png"]]
+
+
+def predict(video_in, image_in_video, image_in_img):
+
+    if video_in == None and image_in_video == None and image_in_img == None:
+        raise gr.Error("Please upload a video or image.")
+
+    if image_in_video or image_in_img:
+        img_path = image_in_video or image_in_img
+        fname, fext = os.path.splitext(img_path)
+
+        if fext == ".mp4":
+            classifier = Classifier(is_image=False, input_path=img_path)
+        else:
+            classifier = Classifier(is_image=True, input_path=img_path)
+
+        output_path, pred_time = classifier.run()
+        gr.Markdown(f"Total prediction time: ", pred_time)
+        return output_path, pred_time
+
+    if video_in:
+        fname, fext = os.path.splitext(video_in)
+        if fext == ".mp4":
+            classifier = Classifier(is_image=False, input_path=video_in)
+        else:
+            classifier = Classifier(is_image=True, input_path=video_in)
+
+        output_path, pred_time = classifier.run()
+        gr.Markdown(f"Total prediction time: ", pred_time)
+        return output_path, pred_time
+
+
+def toggle(choice):
+    if choice == "webcam":
+        return gr.update(visible=True, value=None), gr.update(visible=False, value=None)
+    else:
+        return gr.update(visible=False, value=None), gr.update(visible=True, value=None)
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("### Video or Image? WebCam or Upload?""")
+    with gr.Tab("Video") as tab:
+        with gr.Row():
+            with gr.Column():
+                video_or_file_opt = gr.Radio(["webcam", "upload"], value="webcam",
+                                             label="How would you like to upload your video?")
+                video_in = gr.Video(
+                    format='mp4', source="webcam", include_audio=False)
+                video_or_file_opt.change(fn=lambda s: gr.update(source=s, value=None), inputs=video_or_file_opt,
+                                         outputs=video_in, queue=False, show_progress=False)
+            with gr.Column():
+                video_out = gr.Video(format='mp4')
+
+        run_btn = gr.Button("Predict")
+        run_btn.click(fn=predict, inputs=[video_in], outputs=[video_out])
+        gr.Examples(fn=predict, examples=video_examples, inputs=[
+                    video_in], outputs=[video_out])
+
+    with gr.Tab("Image"):
+        with gr.Row():
+            with gr.Column():
+                image_or_file_opt = gr.Radio(["webcam", "upload"], value="webcam",
+                                             label="How would you like to upload your image?")
+                image_in_video = gr.Image(source="webcam", type="filepath")
+                image_in_img = gr.Image(
+                    source="upload", visible=False, type="filepath")
+
+                image_or_file_opt.change(fn=toggle, inputs=[image_or_file_opt],
+                                         outputs=[image_in_video, image_in_img], queue=False, show_progress=False)
+            with gr.Column():
+                image_out = gr.Image()
+
+        run_btn = gr.Button("Predict")
+
+        pred_tbox = gr.Textbox(label="Prediction Time")
+        run_btn.click(fn=predict, inputs=[
+                      image_in_img, image_in_video], outputs=[image_out, pred_tbox])
+
+        gr.Examples(fn=predict,
+                    examples=img_examples,
+                    inputs=[image_in_img, image_in_video],
+                    outputs=[image_out, pred_tbox])
+
+
+demo.queue()
+demo.launch()

classifier.py

@@ -0,0 +1,78 @@
+import cv2
+import os
+import numpy as np
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.models import load_model
+import time
+
+
+class Classifier:
+    def __init__(self, is_image, input_path):
+        self.is_image = is_image
+        self.counter = 0
+
+        self.classifier = load_model('models/model.h5')
+        self.face_detector = cv2.CascadeClassifier(
+            'models/haarcascade_frontalface_default.xml')
+        cv2.ocl.setUseOpenCL(False)
+
+        self.labels = {0: "Angry", 1: "Disgusted", 2: "Fearful",
+                       3: "Happy", 4: "Neutral", 5: "Sad", 6: "Surprised"}
+
+        self.input_path = input_path
+        self.output_path = "result/" + self.input_path.split('/')[-1]
+        os.makedirs("result", exist_ok=True)
+
+        print("Models have been loaded")
+    # def get_model(self):
+    #     model = load_model(model_path, compile=False)
+    #     model.compile(optimizer=Adam(learning_rate=1e-3),
+    #                 loss='categorical_crossentropy', metrics=['accuracy'])
+
+    def predict(self, frame):
+
+        faces = self.face_detector.detectMultiScale(
+            frame, scaleFactor=1.3, minNeighbors=5)
+
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        for (x, y, w, h) in faces:
+            cv2.rectangle(frame, (x, y-50), (x+w, y+h+10), (255, 0, 0), 2)
+            roi_gray = gray[y:y + h, x:x + w]
+            cropped_img = np.expand_dims(np.expand_dims(
+                cv2.resize(roi_gray, (48, 48)), -1), 0)
+            prediction = self.classifier.predict(cropped_img)
+            maxindex = int(np.argmax(prediction))
+            cv2.putText(frame, self.labels[maxindex], (x+20, y-60),
+                        cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 0, 255), 2, cv2.LINE_AA)
+
+        return frame
+
+    def run(self):
+        start_time = time.time()
+        if self.is_image:
+            image_arr = cv2.imread(self.input_path)
+            predicted_frame = self.predict(frame=image_arr)
+            cv2.imwrite(self.output_path, predicted_frame)
+        else:
+            cap = cv2.VideoCapture(self.input_path)
+
+            # Get video properties
+            frame_width = int(cap.get(3))
+            frame_height = int(cap.get(4))
+            fps = int(cap.get(5))
+
+            # Define the codec and create a VideoWriter object to save the output video as .MOV
+            fourcc = cv2.VideoWriter_fourcc('a', 'v', 'c', '1')
+            out = cv2.VideoWriter(self.output_path, fourcc, fps,
+                                  (frame_width, frame_height))
+
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+
+                predicted_frame = self.predict(frame=frame)
+                out.write(predicted_frame)
+
+        total_time = str(round(time.time() - start_time, 3)) + "s"
+        return self.output_path, total_time

main.py

@@ -0,0 +1,13 @@
+from fastapi import FastAPI
+import gradio as gr
+from app import demo
+
+
+app = FastAPI()
+
+
+@app.get('/')
+async def root():
+    return "Gradio app is running at /gradio", 200
+
+app = gr.mount_gradio_app(app, demo, path='/gradio')

requirements.txt

@@ -0,0 +1,4 @@
+gradio
+numpy 
+tensorflow
+opencv