Upload 36 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+test-video.mp4 filter=lfs diff=lfs merge=lfs -text
+test.png filter=lfs diff=lfs merge=lfs -text

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,22 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="9">
+            <item index="0" class="java.lang.String" itemvalue="tqdm" />
+            <item index="1" class="java.lang.String" itemvalue="pandas" />
+            <item index="2" class="java.lang.String" itemvalue="tensorboard" />
+            <item index="3" class="java.lang.String" itemvalue="seaborn" />
+            <item index="4" class="java.lang.String" itemvalue="tensorboardX" />
+            <item index="5" class="java.lang.String" itemvalue="sklearn" />
+            <item index="6" class="java.lang.String" itemvalue="torch" />
+            <item index="7" class="java.lang.String" itemvalue="numpy" />
+            <item index="8" class="java.lang.String" itemvalue="torchvision" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.10 (src)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (src)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/src.iml" filepath="$PROJECT_DIR$/.idea/src.iml" />
+    </modules>
+  </component>
+</project>

.idea/src.iml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+</module>

.idea/workspace.xml

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="5d6e565a-1460-4a7f-8f74-e2b5df1c6b88" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 1
+}</component>
+  <component name="ProjectId" id="2lZgqQ9N8xKvJ5dtQsXYgjs4WBz" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "dart.analysis.tool.window.visible": "false",
+    "last_opened_file_path": "D:/collage/gp/ml/future-forge/emotion-detection/face_classification/src",
+    "node.js.detected.package.eslint": "true",
+    "node.js.detected.package.tslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "settings.editor.selected.configurable": "com.jetbrains.python.configuration.PyActiveSdkModuleConfigurable",
+    "vue.rearranger.settings.migration": "true"
+  }
+}]]></component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-js-predefined-d6986cc7102b-7c0b70fcd90d-JavaScript-PY-242.21829.153" />
+        <option value="bundled-python-sdk-464836ebc622-b74155a9e76b-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-242.21829.153" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="5d6e565a-1460-4a7f-8f74-e2b5df1c6b88" name="Changes" comment="" />
+      <created>1725393203470</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1725393203470</updated>
+      <workItem from="1725393204716" duration="916000" />
+      <workItem from="1725394369496" duration="321000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+</project>

REQUIREMENTS.txt

@@ -0,0 +1,12 @@
+keras==2.10.0
+tensorflow
+pandas==1.4.4
+numpy==1.23.3
+h5py==3.7.0
+statistics==1.0.3.5
+opencv-python==4.6.0.66
+scipy==1.9.1
+matplotlib==3.5.3
+imageio==2.21.3
+scikit-image==0.19.3
+gradio==3.50.2

app.py

@@ -0,0 +1,61 @@
+import gradio as gr
+import cv2
+from extract_frames import ExtractFrames
+from get_every_fram_path import getEveryFramPath
+from main_emotion_classifier import process, process_single_image
+from grapher import createGraph
+
+def process_image(image):
+    # Process the image using your existing function
+    processed_image = process_single_image(image)
+    return processed_image
+
+def process_video(video_path):
+    # Extract frames from the video and process them
+    output_dir = ExtractFrames(video_path)
+    frame_paths = getEveryFramPath(output_dir)
+    results, most_frequent_emotion = process(frame_paths)
+
+    # Create the emotion graphs from the results
+    createGraph('data/output/results.txt')
+
+    # Return paths to the three generated graphs
+    return [
+        'data/output/emotion_bar_plot.png',
+        'data/output/emotion_stem_plot.png',
+        'data/output/emotionAVG.png'
+    ]
+
+
+def gradio_interface(file):
+    if file is None:
+        return None, None
+
+    file_type = file.name.split('.')[-1].lower()
+
+    if file_type in ['jpg', 'jpeg', 'png', 'bmp']:  # Image input
+        image = cv2.imread(file.name)
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        processed_image = process_image(image)
+        return processed_image, None
+    elif file_type in ['mp4', 'avi', 'mov', 'wmv']:  # Video input
+        graph_paths = process_video(file.name)
+        return None, graph_paths
+    else:
+        return None, None
+
+# Set up the Gradio Interface
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=gr.File(label="Upload Image or Video"),
+    outputs=[
+        gr.Image(type="numpy", label="Processed Image (for image uploads)"),
+        gr.Gallery(label="Emotion Distribution Graphs (for video uploads)", columns=3)
+    ],
+    title="Face Emotion Recognition",
+    description="Upload an image or video to analyze emotions. For images, the result will show detected faces with emotions. For videos, it will provide graphs of emotion distribution."
+)
+
+# Launch the Gradio interface
+if __name__ == "__main__":
+    iface.launch()

extract_frames.py

@@ -0,0 +1,49 @@
+import cv2
+import os
+
+def ExtractFrames(videoPath):
+    # Path to the video file
+    video_path = videoPath
+
+    # Directory to save the frames
+    output_dir = 'data/output/extracted-frames'
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Open the video file
+    video_capture = cv2.VideoCapture(video_path)
+
+    # Check if the video was opened successfully
+    if not video_capture.isOpened():
+        print(f"Error: Could not open video file {video_path}")
+    else:
+        print(f"Successfully opened video file {video_path}")
+
+    # Frame index
+    frame_index = 0
+
+    while True:
+        # Read the next frame from the video
+        success, frame = video_capture.read()
+
+        # If there are no more frames, break the loop
+        if not success:
+            print("No more frames to read or an error occurred.")
+            break
+
+        # Construct the filename for the frame
+        frame_filename = os.path.join(output_dir, f'frame_{frame_index:04d}.png')
+
+        # Save the current frame as an image file
+        cv2.imwrite(frame_filename, frame)
+
+        # Print the saved frame information
+        print(f'Saved {frame_filename}')
+
+        # Increment the frame index
+        frame_index += 1
+
+    # Release the video capture object
+    video_capture.release()
+    return output_dir
+
+    print('All frames extracted.')

get_every_fram_path.py

@@ -0,0 +1,15 @@
+import os
+
+def getEveryFramPath(directoryPath):
+    # Define the directory path
+    directory_path = directoryPath
+
+    # Get the list of all file paths
+    file_paths = []
+    for root, directories, files in os.walk(directory_path):
+        for filename in files:
+            file_paths.append(os.path.join(root, filename))
+
+    # Print the list of file paths
+    print(file_paths)
+    return file_paths

grapher.py

@@ -0,0 +1,107 @@
+import matplotlib.pyplot as plt
+import re
+import numpy as np
+from collections import defaultdict
+
+
+def createGraph(resultPath):
+    # Initialize lists to store emotions sequentially
+    emotions_list = []
+    emotion_counts = defaultdict(int)
+    emotion_scores = defaultdict(float)
+
+    # Define a regular expression pattern to match the emotion and score
+    pattern = re.compile(r"'emotion': '(\w+)', 'score': ([\d\.]+)")
+
+    # Read and parse the file
+    with open(resultPath, 'r') as file:
+        for line in file:
+            match = pattern.search(line)
+            if match:
+                emotion = match.group(1)
+                score = float(match.group(2))
+                emotions_list.append(emotion)
+                emotion_counts[emotion] += 1
+                emotion_scores[emotion] += score
+            else:
+                print(f"Skipping malformed line: {line.strip()}")
+
+    # Group emotions into positive, neutral, and negative categories
+    emotion_group_map = {
+        'happy': 'Positive',
+        'surprise': 'Positive',  # Positive emotions
+        'neutral': 'Neutral',  # Neutral emotions
+        'sad': 'Negative',
+        'angry': 'Negative',
+        'fear': 'Negative',
+        'disgust': 'Negative'  # Negative emotions
+    }
+
+    # Aggregate counts for positive, neutral, and negative categories
+    grouped_counts = defaultdict(int)
+    for emotion in emotions_list:
+        grouped_counts[emotion_group_map[emotion]] += 1
+
+    # Define the categories and their counts
+    categories = ['Positive', 'Neutral', 'Negative']
+    counts = [grouped_counts[category] for category in categories]
+
+    # **Figure 1: Bar Chart for Positive, Neutral, and Negative Emotions**
+    plt.figure(figsize=(8, 6))
+    plt.bar(categories, counts, color=['green', 'grey', 'red'], alpha=0.7)
+    plt.xlabel('Emotion Group')
+    plt.ylabel('Count')
+    plt.title('Distribution of Positive, Neutral, and Negative Emotions')
+    plt.grid(True)
+
+    # Save the bar plot
+    plt.savefig('data/output/emotion_bar_plot.png')
+
+    # **Figure 2: Stem Plot (unchanged from previous version)**
+    emotion_values = [1 if emotion_group_map[e] == 'Positive' else
+                      0 if emotion_group_map[e] == 'Neutral' else
+                      -1 for e in emotions_list]
+
+    # Prepare x-axis values (line numbers)
+    line_numbers = np.arange(1, len(emotion_values) + 1)
+
+    plt.figure(figsize=(12, 6))
+    plt.plot(line_numbers, emotion_values, color='blue', linewidth=2, linestyle='-', marker='o', alpha=0.7)
+
+    for i, emotion in enumerate(emotions_list):
+        if emotion_group_map[emotion] == 'Positive':
+            plt.axvspan(i + 0.5, i + 1.5, color='green', alpha=0.3)
+        elif emotion_group_map[emotion] == 'Neutral':
+            plt.axvspan(i + 0.5, i + 1.5, color='grey', alpha=0.3)
+        elif emotion_group_map[emotion] == 'Negative':
+            plt.axvspan(i + 0.5, i + 1.5, color='red', alpha=0.3)
+
+    plt.xlabel('Line Number')
+    plt.ylabel('Emotion Group')
+    plt.title('Emotion Type Across the File (Stem Plot)')
+    plt.ylim([-2, 2])
+    plt.grid(True)
+    plt.yticks([-1, 0, 1], ['Negative', 'Neutral', 'Positive'])
+
+    # Save the stem plot
+    plt.savefig('data/output/emotion_stem_plot.png')
+
+    # **Figure 3: Combination Bar and Line Chart for Counts and Scores (unchanged)**
+    emotions = list(emotion_counts.keys())
+    counts = [emotion_counts[e] for e in emotions]
+    average_scores = [emotion_scores[e] / emotion_counts[e] for e in emotions]
+
+    fig, ax1 = plt.subplots()
+
+    ax1.bar(emotions, counts, color='b', alpha=0.7)
+    ax1.set_xlabel('Emotion')
+    ax1.set_ylabel('Count', color='b')
+    ax1.tick_params(axis='y', labelcolor='b')
+
+    ax2 = ax1.twinx()
+    ax2.plot(emotions, average_scores, color='r', marker='o')
+    ax2.set_ylabel('Average Score', color='r')
+    ax2.tick_params(axis='y', labelcolor='r')
+
+    plt.title('Emotion Distribution and Average Scores')
+    plt.savefig('data/output/emotionAVG.png')

main_emotion_classifier.py

@@ -0,0 +1,114 @@
+import cv2
+import numpy as np
+from keras.models import load_model
+from utils.datasets import get_labels
+from utils.inference import detect_faces, apply_offsets, load_detection_model, load_image
+from utils.preprocessor import preprocess_input
+
+def most_frequent(List):
+    return max(set(List), key=List.count)
+
+def get_most_frequent_emotion(dict_):
+    emotions = []
+    for frame_nmr in dict_.keys():
+        for face_nmr in dict_[frame_nmr].keys():
+            emotions.append(dict_[frame_nmr][face_nmr]['emotion'])
+    return most_frequent(emotions)
+
+def process(imagePaths, output_filename='data/output/results.txt'):
+    detection_model_path = 'detection_models/haarcascade_frontalface_default.xml'
+    emotion_model_path = 'emotion_models/fer2013_mini_XCEPTION.102-0.66.hdf5'
+    emotion_labels = get_labels('fer2013')
+    emotion_offsets = (0, 0)
+
+    face_detection = load_detection_model(detection_model_path)
+    emotion_classifier = load_model(emotion_model_path, compile=False)
+    emotion_target_size = emotion_classifier.input_shape[1:3]
+
+    output = {}
+
+    for idx, image_path in enumerate(imagePaths):
+        gray_image = load_image(image_path, grayscale=True)
+        gray_image = np.squeeze(gray_image)
+        gray_image = gray_image.astype('uint8')
+
+        faces = detect_faces(face_detection, gray_image)
+
+        tmp = {}
+        for face_coordinates in faces:
+            face_key = tuple(face_coordinates)
+
+            x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)
+            gray_face = gray_image[y1:y2, x1:x2]
+
+            try:
+                gray_face = cv2.resize(gray_face, (emotion_target_size))
+            except:
+                continue
+
+            gray_face = preprocess_input(gray_face, True)
+            gray_face = np.expand_dims(gray_face, 0)
+            gray_face = np.expand_dims(gray_face, -1)
+            emotion_prediction = emotion_classifier.predict(gray_face)
+            emotion_label_arg = np.argmax(emotion_prediction)
+            emotion_text = emotion_labels[emotion_label_arg]
+
+            tmp[face_key] = {'emotion': emotion_text, 'score': float(np.max(emotion_prediction))}
+
+        output[image_path] = tmp
+
+    # Save results to a text file
+    with open(output_filename, 'w') as file:
+        for image_path, faces_info in output.items():
+            file.write(f"{image_path}\n")
+            for face_key, info in faces_info.items():
+                file.write(f"  {face_key}: {info}\n")
+
+    most_frequent_emotion = get_most_frequent_emotion(output)
+    return output, most_frequent_emotion
+
+# This function can be used for processing a single image
+def process_single_image(image):
+    detection_model_path = 'detection_models/haarcascade_frontalface_default.xml'
+    emotion_model_path = 'emotion_models/fer2013_mini_XCEPTION.102-0.66.hdf5'
+    emotion_labels = get_labels('fer2013')
+    emotion_offsets = (0, 0)
+
+    face_detection = load_detection_model(detection_model_path)
+    emotion_classifier = load_model(emotion_model_path, compile=False)
+    emotion_target_size = emotion_classifier.input_shape[1:3]
+
+    gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    faces = detect_faces(face_detection, gray_image)
+
+    for face_coordinates in faces:
+        x1, x2, y1, y2 = apply_offsets(face_coordinates, emotion_offsets)
+        gray_face = gray_image[y1:y2, x1:x2]
+
+        try:
+            gray_face = cv2.resize(gray_face, (emotion_target_size))
+        except:
+            continue
+
+        gray_face = preprocess_input(gray_face, True)
+        gray_face = np.expand_dims(gray_face, 0)
+        gray_face = np.expand_dims(gray_face, -1)
+        emotion_prediction = emotion_classifier.predict(gray_face)
+        emotion_label_arg = np.argmax(emotion_prediction)
+        emotion_text = emotion_labels[emotion_label_arg]
+
+        # Draw rectangle around face and label with predicted emotion
+        (x, y, w, h) = face_coordinates
+        cv2.rectangle(image, (x, y), (x+w, y+h), (0, 255, 0), 2)
+        cv2.putText(image, emotion_text, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, (0, 255, 0), 2)
+
+    return image
+
+if __name__ == "__main__":
+    # This is just for testing purposes
+    test_image_paths = ['path_to_test_image1.jpg', 'path_to_test_image2.jpg']
+    output, most_frequent_emotion = process(test_image_paths)
+    print(f"Most frequent emotion: {most_frequent_emotion}")
+    for key in output.keys():
+        print(f"Image: {key}")
+        print(output[key])

test-video.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6ebb10ed6003e13a611f7a31d5095a58cc9491e996f4f7a416e10cc51567c740
+size 3828330

utils/datasets.py

@@ -0,0 +1,149 @@
+from scipy.io import loadmat
+import pandas as pd
+import numpy as np
+from random import shuffle
+import os
+import cv2
+
+
+class DataManager(object):
+    """Class for loading fer2013 emotion classification dataset or
+        imdb gender classification dataset."""
+    def __init__(self, dataset_name='imdb',
+                 dataset_path=None, image_size=(48, 48)):
+
+        self.dataset_name = dataset_name
+        self.dataset_path = dataset_path
+        self.image_size = image_size
+        if self.dataset_path is not None:
+            self.dataset_path = dataset_path
+        elif self.dataset_name == 'imdb':
+            self.dataset_path = '../datasets/imdb_crop/imdb.mat'
+        elif self.dataset_name == 'fer2013':
+            self.dataset_path = '../datasets/fer2013/fer2013.csv'
+        elif self.dataset_name == 'KDEF':
+            self.dataset_path = '../datasets/KDEF/'
+        else:
+            raise Exception(
+                    'Incorrect dataset name, please input imdb or fer2013')
+
+    def get_data(self):
+        if self.dataset_name == 'imdb':
+            ground_truth_data = self._load_imdb()
+        elif self.dataset_name == 'fer2013':
+            ground_truth_data = self._load_fer2013()
+        elif self.dataset_name == 'KDEF':
+            ground_truth_data = self._load_KDEF()
+        return ground_truth_data
+
+    def _load_imdb(self):
+        face_score_treshold = 3
+        dataset = loadmat(self.dataset_path)
+        image_names_array = dataset['imdb']['full_path'][0, 0][0]
+        gender_classes = dataset['imdb']['gender'][0, 0][0]
+        face_score = dataset['imdb']['face_score'][0, 0][0]
+        second_face_score = dataset['imdb']['second_face_score'][0, 0][0]
+        face_score_mask = face_score > face_score_treshold
+        second_face_score_mask = np.isnan(second_face_score)
+        unknown_gender_mask = np.logical_not(np.isnan(gender_classes))
+        mask = np.logical_and(face_score_mask, second_face_score_mask)
+        mask = np.logical_and(mask, unknown_gender_mask)
+        image_names_array = image_names_array[mask]
+        gender_classes = gender_classes[mask].tolist()
+        image_names = []
+        for image_name_arg in range(image_names_array.shape[0]):
+            image_name = image_names_array[image_name_arg][0]
+            image_names.append(image_name)
+        return dict(zip(image_names, gender_classes))
+
+    def _load_fer2013(self):
+        data = pd.read_csv(self.dataset_path)
+        pixels = data['pixels'].tolist()
+        width, height = 48, 48
+        faces = []
+        for pixel_sequence in pixels:
+            face = [int(pixel) for pixel in pixel_sequence.split(' ')]
+            face = np.asarray(face).reshape(width, height)
+            face = cv2.resize(face.astype('uint8'), self.image_size)
+            faces.append(face.astype('float32'))
+        faces = np.asarray(faces)
+        faces = np.expand_dims(faces, -1)
+        emotions = pd.get_dummies(data['emotion']).as_matrix()
+        return faces, emotions
+
+    def _load_KDEF(self):
+        class_to_arg = get_class_to_arg(self.dataset_name)
+        num_classes = len(class_to_arg)
+
+        file_paths = []
+        for folder, subfolders, filenames in os.walk(self.dataset_path):
+            for filename in filenames:
+                if filename.lower().endswith(('.jpg')):
+                    file_paths.append(os.path.join(folder, filename))
+
+        num_faces = len(file_paths)
+        y_size, x_size = self.image_size
+        faces = np.zeros(shape=(num_faces, y_size, x_size))
+        emotions = np.zeros(shape=(num_faces, num_classes))
+        for file_arg, file_path in enumerate(file_paths):
+            image_array = cv2.imread(file_path, cv2.IMREAD_GRAYSCALE)
+            image_array = cv2.resize(image_array, (y_size, x_size))
+            faces[file_arg] = image_array
+            file_basename = os.path.basename(file_path)
+            file_emotion = file_basename[4:6]
+            # there are two file names in the dataset
+            # that don't match the given classes
+            try:
+                emotion_arg = class_to_arg[file_emotion]
+            except:
+                continue
+            emotions[file_arg, emotion_arg] = 1
+        faces = np.expand_dims(faces, -1)
+        return faces, emotions
+
+
+def get_labels(dataset_name):
+    if dataset_name == 'fer2013':
+        return {0: 'angry', 1: 'disgust', 2: 'fear', 3: 'happy',
+                4: 'sad', 5: 'surprise', 6: 'neutral'}
+    elif dataset_name == 'imdb':
+        return {0: 'woman', 1: 'man'}
+    elif dataset_name == 'KDEF':
+        return {0: 'AN', 1: 'DI', 2: 'AF', 3: 'HA', 4: 'SA', 5: 'SU', 6: 'NE'}
+    else:
+        raise Exception('Invalid dataset name')
+
+
+def get_class_to_arg(dataset_name='fer2013'):
+    if dataset_name == 'fer2013':
+        return {'angry': 0, 'disgust': 1, 'fear': 2, 'happy': 3, 'sad': 4,
+                'surprise': 5, 'neutral': 6}
+    elif dataset_name == 'imdb':
+        return {'woman': 0, 'man': 1}
+    elif dataset_name == 'KDEF':
+        return {'AN': 0, 'DI': 1, 'AF': 2, 'HA': 3, 'SA': 4, 'SU': 5, 'NE': 6}
+    else:
+        raise Exception('Invalid dataset name')
+
+
+def split_imdb_data(ground_truth_data, validation_split=.2, do_shuffle=False):
+    ground_truth_keys = sorted(ground_truth_data.keys())
+    if do_shuffle is not False:
+        shuffle(ground_truth_keys)
+    training_split = 1 - validation_split
+    num_train = int(training_split * len(ground_truth_keys))
+    train_keys = ground_truth_keys[:num_train]
+    validation_keys = ground_truth_keys[num_train:]
+    return train_keys, validation_keys
+
+
+def split_data(x, y, validation_split=.2):
+    num_samples = len(x)
+    num_train_samples = int((1 - validation_split)*num_samples)
+    train_x = x[:num_train_samples]
+    train_y = y[:num_train_samples]
+    val_x = x[num_train_samples:]
+    val_y = y[num_train_samples:]
+    train_data = (train_x, train_y)
+    val_data = (val_x, val_y)
+    return train_data, val_data

utils/inference.py

@@ -0,0 +1,37 @@
+import cv2
+import matplotlib.pyplot as plt
+import numpy as np
+from tensorflow.keras.utils import load_img, img_to_array
+
+def load_image(image_path, grayscale=False, target_size=None):
+    color_mode = 'grayscale' if grayscale else 'rgb'
+    pil_image = load_img(image_path, color_mode=color_mode, target_size=target_size)
+    return img_to_array(pil_image)
+
+def load_detection_model(model_path):
+    detection_model = cv2.CascadeClassifier(model_path)
+    return detection_model
+
+def detect_faces(detection_model, gray_image_array):
+    return detection_model.detectMultiScale(gray_image_array, 1.3, 5)
+
+def draw_bounding_box(face_coordinates, image_array, color):
+    x, y, w, h = face_coordinates
+    cv2.rectangle(image_array, (x, y), (x + w, y + h), color, 2)
+
+def apply_offsets(face_coordinates, offsets):
+    x, y, width, height = face_coordinates
+    x_off, y_off = offsets
+    return (x - x_off, x + width + x_off, y - y_off, y + height + y_off)
+
+def draw_text(coordinates, image_array, text, color, x_offset=0, y_offset=0,
+              font_scale=2, thickness=2):
+    x, y = coordinates[:2]
+    cv2.putText(image_array, text, (x + x_offset, y + y_offset),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                font_scale, color, thickness, cv2.LINE_AA)
+
+def get_colors(num_classes):
+    colors = plt.cm.hsv(np.linspace(0, 1, num_classes)).tolist()
+    colors = np.asarray(colors) * 255
+    return colors

utils/preprocessor.py

@@ -0,0 +1,27 @@
+import numpy as np
+from imageio import imread
+from skimage.transform import resize as imresize
+
+def preprocess_input(x, v2=True):
+    x = x.astype('float32')
+    x = x / 255.0
+    if v2:
+        x = x - 0.5
+        x = x * 2.0
+    return x
+
+
+def _imread(image_name):
+        return imread(image_name)
+
+
+def _imresize(image_array, size):
+        return imresize(image_array, size)
+
+
+def to_categorical(integer_classes, num_classes=2):
+    integer_classes = np.asarray(integer_classes, dtype='int')
+    num_samples = integer_classes.shape[0]
+    categorical = np.zeros((num_samples, num_classes))
+    categorical[np.arange(num_samples), integer_classes] = 1
+    return categorical