added stuff

.gitignore

@@ -0,0 +1,76 @@
+# auth-tokens
+*.json
+
+# gradio
+app/flagged
+*.h5
+*.pkl
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/

Dockerfile

@@ -0,0 +1,7 @@
+from python:3.10.11-slim-bullseye
+WORKDIR /app
+COPY requirements.txt .
+RUN apt-get update && apt-get upgrade -y
+RUN pip install -r requirements.txt
+RUN cd app
+CMD ["gradio", "app.py"]

README.md

@@ -1,13 +1,15 @@
 ---
-title: Antisomnus
+title: antisomnus
 emoji: 🔥
 colorFrom: pink
 colorTo: indigo
 sdk: gradio
 sdk_version: 3.27.0
 app_file: app.py
-pinned: false
+pinned: true
 license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+=======
+# antisomnus - Driver Drowsiness Detection

app/app.py

@@ -0,0 +1,69 @@
+"""
+    app.py
+"""
+import os
+import sys
+from pathlib import Path
+import gradio as gr
+import numpy as np
+import mediapipe as mp
+import tensorflow as tf
+import cv2
+
+# Add the path to the model directory
+path = Path(os.getcwd())
+sys.path.insert(0,str(path.parent.absolute())+"/model/data")
+from mp_process import process_mp_img
+
+
+model = tf.keras.models.load_model(str(path.parent.absolute())+"/model/training/saved_models/en_model_v0.h5")
+
+def preprocess_frame(frame):
+    """
+    Preprocess the frame to be compatible with the model
+    """
+    frame = cv2.resize(frame, (224,224), interpolation = cv2.INTER_AREA)
+    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    frame = frame / 255.0
+    return np.expand_dims(frame, axis=0)
+
+
+def detect_drowsiness(frame):
+    """
+    returns features and/or processed image
+    """
+    annotated_img, eye_feature, mouth_feature, mp_drowsy = process_mp_img(frame)
+    # Preprocess the frame
+    preprocessed_frame = preprocess_frame(frame)
+    # Make predictions using the model
+    prediction = model.predict(preprocessed_frame)
+    # Threshold the prediction to classify drowsiness
+    model_drowsy = prediction[0][0] >= 0.5
+
+    # Return the result
+    return annotated_img, "Drowsy" if not model_drowsy else "Awake", "Drowsy" if mp_drowsy else "Awake",eye_feature, mouth_feature
+
+
+
+
+# Define the input component as an Image component
+input_image = gr.inputs.Image(shape=(480, 640), source="webcam", label="live feed")
+
+# Define the output components as an Image and a Label component
+output_image = gr.components.Image(label="Drowsiness Detection")
+output_model = gr.components.Label(label="Drowsiness Status - en_model_v0.h5")
+output_mp = gr.components.Label(label="Drowsiness Status - MediaPipe")
+output_eye = gr.components.Textbox(label="Eye Aspect Ratio")
+output_mouth = gr.components.Textbox(label="Mouth Aspect Ratio")
+
+
+iface = gr.Interface(
+    fn=detect_drowsiness,
+    inputs=input_image,
+    title="antisomnus - driver drowsiness detection",
+    outputs=[output_image,output_model, output_mp, output_eye, output_mouth],
+    capture_session=True,
+)
+
+# Launch the Gradio interface
+iface.launch(share=True)

docker-compose.yml

@@ -0,0 +1,13 @@
+name: driver_drowsiness_detection
+version: '0.1'
+
+services:
+  app:
+    image: driver_drowsiness_detection
+    build: .
+    ports:
+      - 127.0.0.1:7860:3000
+    volumes:
+      - ./app:/app/app
+      - ./model/data:/app/model/data
+      - ./model/training/saved_models:/app/model/training/saved_models

model/data/mp_process.py

@@ -0,0 +1,139 @@
+import cv2
+import math
+import random
+import numpy as np
+import mediapipe as mp
+
+from scipy.spatial.distance import euclidean as dist
+from sklearn.preprocessing import LabelEncoder, MinMaxScaler
+
+# feature definitions
+
+
+DIMS = (224,224,3) # dimensions of the image
+RIGHT = [[33, 133], [160, 144], [159, 145], [158, 153]] # right eye landmark positions
+LEFT = [[263, 362], [387, 373], [386, 374], [385, 380]] # left eye landmark positions
+MOUTH = [[61, 291], [39, 181], [0, 17], [269, 405]] # mouth landmark coordinates
+
+EYE_AR_THRESH = 0.45
+PROB_THRESH = 0.3
+EYE_AR_CONSEC_FRAMES = 15
+
+MOUTH_AR_THRESH = 0.33
+MOUTH_AR_CONSEC_FRAMES = 20
+
+MP_FACE_DETECTION = mp.solutions.face_detection
+MP_DRAWING = mp.solutions.drawing_utils
+MP_DRAWING_STYLES = mp.solutions.drawing_styles
+MP_FACE_MESH = mp.solutions.face_mesh
+DRAWING_SPEC = MP_DRAWING.DrawingSpec(thickness=1, circle_radius=1)
+
+def get_ear(landmarks,eye):
+    ''' Calculate the ratio of the eye length to eye width. 
+    :param landmarks: Face Landmarks returned from FaceMesh MediaPipe model
+    :param eye: List containing positions which correspond to the eye
+    :return: Eye aspect ratio value
+    '''
+    N1 = dist(landmarks[eye[1][0]], landmarks[eye[1][1]])
+    N2 = dist(landmarks[eye[2][0]], landmarks[eye[2][1]])
+    N3 = dist(landmarks[eye[3][0]], landmarks[eye[3][1]])
+    D = dist(landmarks[eye[0][0]], landmarks[eye[0][1]])
+    return (N1 + N2 + N3) / (3 * D)
+
+def get_eye_feature(landmarks):
+    ''' Calculate the eye feature as the average of the eye aspect ratio for the two eyes
+    :param landmarks: Face Landmarks returned from FaceMesh MediaPipe model
+    :return: Eye feature value
+    '''
+    return (get_ear(landmarks,LEFT) + get_ear(landmarks,RIGHT))
+
+def get_mouth_feature(landmarks):
+    ''' Calculate mouth feature as the ratio of the mouth length to mouth width
+    :param landmarks: Face Landmarks returned from FaceMesh MediaPipe model
+    :return: Mouth feature value
+    '''
+    n_1 = dist(landmarks[MOUTH[1][0]], landmarks[MOUTH[1][1]])
+    n_2 = dist(landmarks[MOUTH[2][0]], landmarks[MOUTH[2][1]])
+    n_3 = dist(landmarks[MOUTH[3][0]], landmarks[MOUTH[3][1]])
+    dst = dist(landmarks[MOUTH[0][0]], landmarks[MOUTH[0][1]])
+    return (n_1 + n_2 + n_3)/(3*dst)
+
+# image processing
+
+
+def process_mp_img(frame):
+    """
+    returns features and/or processed image
+    """
+    with MP_FACE_MESH.FaceMesh(
+        min_detection_confidence=0.3,
+        min_tracking_confidence=0.8) as face_mesh:
+        # convert the img to RGB and process it with MediaPipe Face Detection
+        results = face_mesh.process(cv2.cvtColor(frame,cv2.COLOR_BGR2RGB))
+
+        if results.multi_face_landmarks is not None:
+            landmark_pos = []
+            for i, data in enumerate(results.multi_face_landmarks[0].landmark):
+                landmark_pos.append([data.x, data.y, data.z])
+            landmark_pos = np.array(landmark_pos)
+
+            # draw face detections of each face
+            annotated_img = frame.copy()
+            for face_landmarks in results.multi_face_landmarks:
+                # Calculate eye and mouth features
+                eye_feature = get_eye_feature(landmark_pos)
+                mouth_feature = get_mouth_feature(landmark_pos)
+
+                # Binary classification: drowsy (1) or non-drowsy (0)
+                drowsy = (eye_feature <= EYE_AR_THRESH) or (mouth_feature > MOUTH_AR_THRESH)       
+                # face mesh
+                MP_DRAWING.draw_landmarks(
+                    image=annotated_img,
+                    landmark_list=face_landmarks,
+                    connections=MP_FACE_MESH.FACEMESH_TESSELATION,
+                    landmark_drawing_spec=None,
+                    connection_drawing_spec=MP_DRAWING_STYLES
+                    .get_default_face_mesh_tesselation_style()
+                )
+                # eyes and mouth regions
+                MP_DRAWING.draw_landmarks(
+                    image=annotated_img,
+                    landmark_list=face_landmarks,
+                    connections=MP_FACE_MESH.FACEMESH_CONTOURS,
+                    landmark_drawing_spec=None,
+                    connection_drawing_spec=MP_DRAWING_STYLES
+                    .get_default_face_mesh_contours_style()
+                )
+    return annotated_img, eye_feature, mouth_feature, drowsy
+
+
+
+def mediapipe_process(frames):
+    """
+    Process all videos using MediaPipe and returns a 
+    dictionary with the eye and mouth features in 
+    the format {frame_number: {"eye_feature":0, "mouth_feature":0, "drowsy":0}}
+    """
+    mp_features = {}
+    eye_features_all = []
+    mouth_features_all = []
+    # Extract eye and mouth features for all videos
+    for frame in frames:
+        mp_features[frame] = {"eye_feature": 0, "mouth_feature": 0, "drowsy": 0}
+        _,eye_feature,mouth_feature,drowsy = process_mp_img(frame)
+        mp_features[frame]["eye_feature"] = eye_feature
+        mp_features[frame]["mouth_feature"] = mouth_feature
+        mp_features[frame]["drowsy"] = drowsy
+        eye_features_all.append(eye_feature)
+        mouth_features_all.append(mouth_feature)
+
+    # Calculate mean and standard deviation for normalization
+    eye_mean, eye_std = np.mean(eye_features_all), np.std(eye_features_all)
+    mouth_mean, mouth_std = np.mean(mouth_features_all), np.std(mouth_features_all)
+
+    # Normalize eye and mouth features for all videos
+    for frame,features in mp_features.items():
+        features["eye_feature"] = (features["eye_feature"] - eye_mean) / eye_std
+        features[frame]["mouth_feature"] = (features["mouth_feature"] - mouth_mean) / mouth_std
+
+    return mp_features

model/data/process_data.py

@@ -0,0 +1,167 @@
+"""
+Module: example_module.py
+
+This module provides functionality for processing video files and extracting
+frame images. The primary function, `process_video_files`, is responsible for
+downloading video files, converting them to frame images, and uploading the
+frames back to the specified storage location.
+
+Functions:
+    - process_video_files(bucket_name: str) -> None
+    - splice_video_to_frames(bucket_name: str, video_blob: Blob) -> None
+
+Author: Rohit Nair
+License: MIT License
+Date: 2023-03-22
+Version: 1.0.0
+"""
+
+import os
+import tempfile
+import pickle
+import numpy as np
+import cv2
+from google.cloud import storage
+
+# Initialize Google Cloud Storage client
+storage_client = storage.Client()
+
+# Set the bucket name
+BUCKET_NAME = "antisomnus-bucket"
+bucket = storage_client.get_bucket(BUCKET_NAME)
+
+
+class Image:
+    def __init__(self,frame,dimensions:tuple):
+        self.frame = frame
+        self.height, self.width, self.depth = dimensions
+    
+    def load_and_prep_image(self,scale=False):
+        frame_rgb = cv2.Color(self.frame,cv2.COLOR_BGR2RGB)
+        _, encoded_frame = cv2.imencode('.png',frame_rgb)
+        encoded_frame_bytes = encoded_frame.tobytes()
+        tensor_frame = tf.io.decode_image(encoded_frame_bytes)
+        tensor_frame = tf.image.resize(tensor_frame,(self.height,self.width))
+        if scale:
+            return tensor_frame/255.
+        else:
+            return tensor_frame
+
+
+class DriverDrowsinessDataset:
+    """
+        DriverDrowsinessDataset
+    """
+    def __init__(self, _data_dir, _label_dir):
+        self.data_dir = _data_dir
+        self.label_dir = _label_dir
+
+    def get_labels(self,vid_name):
+        """
+        retrieves the labels for a video file
+        """
+        vid_name = vid_name.split("/")[-1].split(".")[0]
+        label_file_name = self.label_dir + "/" + vid_name +  "_drowsiness.txt"
+
+        # get the blob
+        label_blob = bucket.blob(label_file_name)
+
+        # download the blob to a temporary file
+        label_file = tempfile.NamedTemporaryFile(delete=False)
+        label_blob.download_to_filename(label_file.name)
+
+        # read the label file
+        labels = np.genfromtxt(label_file.name,delimiter=1,dtype=int)
+
+        # clean up
+        label_file.close()
+        os.unlink(label_file.name)
+
+        return labels
+
+    def unpkl_data(self):
+        """get the pickled file with the data from the storage bucket and return the unpickled data"""
+        # get the blob
+        try:
+            blob = bucket.blob("training_data/training_data.pkl")
+            blob.download_to_filename("data.pkl")
+        except Exception as download_error:
+            print(download_error)
+            return False
+
+        return True
+
+    def show_data(self,file):
+        """
+        shows data
+        """
+        with open(file, 'rb') as pkl:
+            data_dict = pickle.load(pkl)
+        return data_dict
+
+    def get_all_data(self) -> bool:
+        """
+        retrieves all the data in the form of a dictionary mapping image names to
+        their corresponding labels
+        format: {image_name: (image, label)}
+        """
+        img_label_data = {}
+        # get a list of all files in the folder that ends with .avi
+        blobs = [blob for blob in
+                storage_client.list_blobs(BUCKET_NAME, prefix=self.data_dir)
+                if blob.name.endswith(".avi")]
+
+        blob_count = len(blobs)
+
+        if blob_count == 0:
+            print("No video files found in the bucket.")
+            return False
+        else:
+            print(f"Found {blob_count} video files in the bucket.")
+
+        for blob in blobs:
+            print(f"Processing video file {blob.name}...{blob_count} more to go")
+            # Download the video to a temporary file
+            video_file = tempfile.NamedTemporaryFile(delete=False)
+            blob.download_to_filename(video_file.name)
+            labels = self.get_labels(blob.name)
+
+            # Read the video and split it into frames
+            cap = cv2.VideoCapture(video_file.name)
+            frame_number = 0
+            while frame_number < len(labels):
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                print(f"Processing frame {frame_number}...")
+
+                # Save the frame in a dictionary
+                img_label_data[frame_number] = (frame, labels[frame_number])
+                frame_number += 1
+
+            # Clean up
+            video_file.close()
+            os.unlink(video_file.name)
+            cap.release()
+            #cv2.destroyAllWindows()
+            blob_count -= 1
+
+            # Delete the video file from Google Cloud Storage
+            # print(f"Deleting video file {blob.name}...")
+            # blob.delete()
+            # blob_count -= 1
+        # save img_label_data as a pickle file to the bucket
+
+        with open('data.pkl', 'wb') as file:
+            pickle.dump(img_label_data, file, protocol=pickle.HIGHEST_PROTOCOL)
+        img_label_data_blob = bucket.blob("training_data/training_data.pkl")
+        img_label_data_blob.upload_from_filename('data.pkl')
+
+        print("Done processing all video files.")
+
+        return True
+
+
+if __name__ == "__main__":
+    data = DriverDrowsinessDataset('training_data','training_data/labels')
+    data.get_all_data()

model/training/model_training.ipynb

@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "zsh:1: command not found: nvidia-smi\n"
+     ]
+    }
+   ],
+   "source": [
+    "!nvidia-smi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import datetime\n",
+    "import pickle\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import sys\n",
+    "\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from tensorflow.keras import layers\n",
+    "from tensorflow.keras.layers.experimental import preprocessing\n",
+    "\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import confusion_matrix\n",
+    "\n",
+    "sys.path.insert(0,\"/home/ubuntu/code/DDD/model/data\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from process_data import Image, DriverDrowsinessDataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def plot_images(images, classes, class_true, class_pred=None,smooth=True):\n",
+    "    assert len(images) == len(class_true)\n",
+    "    fig, axes = plt.subplots(3, 3)\n",
+    "    if class_pred is None:\n",
+    "        hspace = 0.3\n",
+    "    else:\n",
+    "        hspace = 0.6\n",
+    "    fig.subplots_adjust(hspace=hspace, wspace=0.3)\n",
+    "    if smooth:\n",
+    "        interpolation = 'spline16'\n",
+    "    else:\n",
+    "        interpolation = 'nearest'\n",
+    "    for i, ax in enumerate(axes.flat):\n",
+    "        if i < len(images):\n",
+    "            ax.imshow(images[i], interpolation=interpolation)\n",
+    "            cls_true_name = classes[class_true[i]]\n",
+    "            if class_pred is None:\n",
+    "                xlabel = \"True: {0}\".format(class_true[i])\n",
+    "            else:\n",
+    "                class_pred_name = classes[class_pred[i]]\n",
+    "                xlabel = \"True: {0}\\nPred: {1}\".format(cls_true_name, class_pred_name)\n",
+    "            ax.set_xlabel(xlabel)\n",
+    "        ax.set_xticks([])\n",
+    "        ax.set_yticks([])\n",
+    "    plt.show()\n",
+    "\n",
+    "def print_confusion_matrix(classes,class_test,class_pred):\n",
+    "    \"\"\"\n",
+    "    prints the confusion matrix. class_pred is the array of all predicted classes of each image.\n",
+    "    \"\"\"\n",
+    "    cm = confusion_matrix(y_true=class_test, y_pred=class_pred)\n",
+    "    print(\"Confusion matrix:\")\n",
+    "    print(cm)\n",
+    "    for i, class_name in enumerate(classes):\n",
+    "        print(\"({0}) {1}\".format(i, class_name))\n",
+    "\n",
+    "def plot_training_history(model):\n",
+    "    # Get the classification accuracy and loss-value\n",
+    "    # for the training-set.\n",
+    "    acc = model.history['accuracy']\n",
+    "    loss = model.history['loss']\n",
+    "\n",
+    "    # Get it for the validation-set (we only use the test-set).\n",
+    "    val_acc = model.history['val_accuracy']\n",
+    "    val_loss = model.history['val_loss']\n",
+    "\n",
+    "    # Plot the accuracy and loss-values for the training-set.\n",
+    "    plt.plot(acc, linestyle='-', color='b', label='Training Acc.')\n",
+    "    plt.plot(loss, 'o', color='b', label='Training Loss')\n",
+    "    \n",
+    "    # Plot it for the test-set.\n",
+    "    plt.plot(val_acc, linestyle='--', color='r', label='Test Acc.')\n",
+    "    plt.plot(val_loss, 'o', color='r', label='Test Loss')\n",
+    "\n",
+    "    # Plot title and legend.\n",
+    "    plt.title('Training and Test Accuracy')\n",
+    "    plt.legend()\n",
+    "\n",
+    "    # Ensure the plot shows correctly.\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(0, 0, 0, 0, 0)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "DIMS = (224,224,3)\n",
+    "BATCH_SIZE = 32\n",
+    "\n",
+    "with open(\"../data/data.pkl\",\"rb\") as f:\n",
+    "    dataset = pickle.load(f)\n",
+    "\n",
+    "frames,labels = zip(*dataset.values())\n",
+    "\n",
+    "# preprocess all frames\n",
+    "frames = np.array([Image.load_and_prep_image(frame,dimensions=(DIMS[0],DIMS[1])) for frame in frames])\n",
+    "\n",
+    "X_train, X_val, y_train, y_val = train_test_split(frames,labels,test_size=0.2, random_state=42)\n",
+    "\n",
+    "X_train, X_val = np.array(X_train), np.array(X_val)\n",
+    "y_train, y_val = np.array(y_train), np.array(y_val)\n",
+    "\n",
+    "def data_generator(X,y,batch_size):\n",
+    "    num_samples = len(X)\n",
+    "    while True:\n",
+    "        indices = np.arange(num_samples)\n",
+    "        np.random.shuffle(indices)\n",
+    "\n",
+    "        for start_idx in range(0, num_samples, batch_size):\n",
+    "            batch_indices = indices[start_idx:start_idx + batch_size]\n",
+    "            X_batch, y_batch = X[batch_indices], y[batch_indices]\n",
+    "            yield X_batch, y_batch\n",
+    "\n",
+    "def create_tensorboard_callback(dir_name, experiment_name):\n",
+    "    log_dir = dir_name + \"/\" + experiment_name + \"/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
+    "    tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir)\n",
+    "    print(f\"Saving TensorBoard log files to: {log_dir}\")\n",
+    "    return tensorboard_callback"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "train_generator = data_generator(X_train, y_train, BATCH_SIZE)\n",
+    "val_generator = data_generator(X_val, y_val, BATCH_SIZE)\n",
+    "\n",
+    "data_augmentation = keras.Sequential([\n",
+    "    layers.experimental.preprocessing.RandomFlip(\"horizontal\", input_shape=DIMS),\n",
+    "    layers.experimental.preprocessing.RandomRotation(0.2),\n",
+    "    layers.experimental.preprocessing.RandomZoom(0.2),\n",
+    "    layers.experimental.preprocessing.RandomHeight(0.2),\n",
+    "    layers.experimental.preprocessing.RandomWidth(0.2),\n",
+    "], name=\"data_augmentation\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "BASE_MODEL = tf.keras.applications.EfficientNetV2B0(\n",
+    "    input_shape=DIMS,\n",
+    "    include_top=False,\n",
+    "    weights=\"imagenet\",\n",
+    ")\n",
+    "\n",
+    "def EfficientNet(input_shape=DIMS,base_model=BASE_MODEL, num_classes=2):\n",
+    "    # freeze the base model layers\n",
+    "    for layer in base_model.layers:\n",
+    "        layer.trainable = False\n",
+    "    \n",
+    "    # create input layer\n",
+    "    inputs = keras.Input(shape=input_shape, name=\"input_layer\")\n",
+    "    x = data_augmentation(inputs)\n",
+    "    x = base_model(x, training=False)\n",
+    "    x = layers.GlobalAveragePooling2D(name=\"global_average_pooling_layer\")(x)\n",
+    "    x = layers.Dense(1024, activation=\"relu\", name=\"dense_layer\")(x)\n",
+    "    x = layers.Dropout(0.7, name=\"dropout_layer\")(x)\n",
+    "    outputs = layers.Dense(num_classes, activation=\"sigmoid\", name=\"output_layer\")(x)\n",
+    "\n",
+    "\n",
+    "    # create a new model with the EfficientNetV2B0 base model and a GlobalAveragePooling2D layer. assess model performance with metrics such as accuracy, loss, and f1 score\n",
+    "    model = keras.Model(inputs, outputs, name=\"EfficientNet\")\n",
+    "    model.compile(\n",
+    "        optimizer=keras.optimizers.Adam(),\n",
+    "        loss=\"binary_crossentropy\",\n",
+    "        metrics=[\"accuracy\",keras.metrics.Precision(),keras.metrics.Recall(),keras.metrics.AUC()]\n",
+    "    )\n",
+    "    return model\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = EfficientNet()\n",
+    "model.summary()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(model.layers[3].dtype)\n",
+    "print(model.layers[3].dtype_policy)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = model.fit(train_generator,\n",
+    "                  epochs=10,\n",
+    "                  steps_per_epoch=len(X_train)//BATCH_SIZE,validation_data=val_generator,\n",
+    "                  validation_steps=len(X_val)//BATCH_SIZE,\n",
+    "                  callbacks=[create_tensorboard_callback(\"logs\",\"EfficientNetV2B0\")])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.save(\"en_model_v1.h5\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "notebook",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.6"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

model/training/saved_models/README.md

@@ -0,0 +1,2 @@
+# Index of Models
+1. [en_model_v0](en_model_v0.h5) --> 04:14:2023:03:53:45

requirements.txt

@@ -0,0 +1,10 @@
+gradio
+opencv-python-headless
+numpy
+polars
+seaborn
+matplotlib
+scikit-learn
+scipy
+tensorflow
+mediapipe