Upload 10 files

app.py

@@ -0,0 +1,76 @@
+### 1. Imports and class names setup ### 
+import gradio as gr
+import os
+import torch
+from model import create_effnetb0_model
+from timeit import default_timer as timer
+from typing import Tuple, Dict
+from torchvision import transforms
+
+# Setup class names
+class_names = ["Happy", "Disgusted", "Suprised","Angry","Neutral","Sad","Fearful"]
+
+# Create EffNetB2 model
+effnetb0, effnetb0_transforms = create_effnetb0_model(
+    num_classes=7, # len(class_names) would also work
+)
+
+# Load saved weights
+
+
+# Load saved weights
+effnetb0.load_state_dict(
+    torch.load(
+        f="models/efficientnet_b0.pth",
+        map_location=torch.device("cpu"),  # load to CPU
+    )
+)
+
+### 3. Predict function ###
+
+# Create predict function
+def predict(img) -> Tuple[Dict, float]:
+    """Transforms and performs a prediction on img and returns prediction and time taken.
+    """
+    # Start the timer
+    start_time = timer()
+    
+    # Transform the target image and add a batch dimension
+    img = effnetb0_transforms(img).unsqueeze(0)
+    
+    # Put model into evaluation mode and turn on inference mode
+    effnetb0.eval()
+    with torch.inference_mode():
+        # Pass the transformed image through the model and turn the prediction logits into prediction probabilities
+        pred_probs = torch.softmax(effnetb0(img), dim=1)
+    
+    # Create a prediction label and prediction probability dictionary for each prediction class (this is the required format for Gradio's output parameter)
+    pred_labels_and_probs = {class_names[i]: float(pred_probs[0][i]) for i in range(len(class_names))}
+    
+    # Calculate the prediction time
+    pred_time = round(timer() - start_time, 5)
+    
+    # Return the prediction dictionary and prediction time 
+    return pred_labels_and_probs, pred_time
+
+example_list = [["examples/" + example] for example in os.listdir("examples")]
+
+### 4. Gradio app ###
+
+# Create title, description and article strings
+title = "Emotion Detection App 😀😐😰😞🤢😲😡"
+description = "An EfficientNetB0 computer vision model to classify images of emotions: Happy, Neutral, Sad, fearful, Angry, Suprised, Disgusted."
+article = "Reference: [09. PyTorch Model Deployment](https://www.learnpytorch.io/09_pytorch_model_deployment/)."
+
+import gradio as gr
+
+demo = gr.Interface(fn=predict, # mapping function from input to output
+                    inputs=gr.Image(type="pil"), # what are the inputs?
+                    outputs=[gr.Label(num_top_classes=7, label="Predictions"), # what are the outputs?
+                             gr.Number(label="Prediction time (s)")], # our fn has two outputs, therefore we have two outputs
+                    # Create examples list from "examples/" directory
+                    examples=example_list, 
+                    title=title,
+                    description=description,
+                    article=article).launch()
+

facial-detection.ipynb

@@ -0,0 +1,524 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
+    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
+   },
+   "outputs": [],
+   "source": [
+    "\n",
+    "import numpy as np \n",
+    "import pandas as pd \n",
+    "import cv2\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
+    "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a"
+   },
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('../input/facial-expression/fer2013.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(df.iloc[0]['pixels'].split())\n",
+    "# 48 * 48"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "label_map = ['Anger', 'Neutral', 'Fear', 'Happy', 'Sad', 'Surprise']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img = df.iloc[0]['pixels'].split()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img = [int(i) for i in img]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "type(img[0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img = np.array(img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img = img.reshape(48,48)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.imshow(img, cmap='gray')\n",
+    "plt.xlabel(df.iloc[0]['emotion'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = []\n",
+    "y = []"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def getData(path):\n",
+    "    anger = 0\n",
+    "    fear = 0\n",
+    "    sad = 0\n",
+    "    happy = 0\n",
+    "    surprise = 0\n",
+    "    neutral = 0\n",
+    "    df = pd.read_csv(path)\n",
+    "    \n",
+    "    X = []\n",
+    "    y = []    \n",
+    "    \n",
+    "    for i in range(len(df)):\n",
+    "        if df.iloc[i]['emotion'] != 1:\n",
+    "            if df.iloc[i]['emotion'] == 0:\n",
+    "                if anger <= 4000:            \n",
+    "                    y.append(df.iloc[i]['emotion'])\n",
+    "                    im = df.iloc[i]['pixels']\n",
+    "                    im = [int(x) for x in im.split()]\n",
+    "                    X.append(im)\n",
+    "                    anger += 1\n",
+    "                else:\n",
+    "                    pass\n",
+    "                \n",
+    "            if df.iloc[i]['emotion'] == 2:\n",
+    "                if fear <= 4000:            \n",
+    "                    y.append(df.iloc[i]['emotion'])\n",
+    "                    im = df.iloc[i]['pixels']\n",
+    "                    im = [int(x) for x in im.split()]\n",
+    "                    X.append(im)\n",
+    "                    fear += 1\n",
+    "                else:\n",
+    "                    pass\n",
+    "                \n",
+    "            if df.iloc[i]['emotion'] == 3:\n",
+    "                if happy <= 4000:            \n",
+    "                    y.append(df.iloc[i]['emotion'])\n",
+    "                    im = df.iloc[i]['pixels']\n",
+    "                    im = [int(x) for x in im.split()]\n",
+    "                    X.append(im)\n",
+    "                    happy += 1\n",
+    "                else:\n",
+    "                    pass\n",
+    "                \n",
+    "            if df.iloc[i]['emotion'] == 4:\n",
+    "                if sad <= 4000:            \n",
+    "                    y.append(df.iloc[i]['emotion'])\n",
+    "                    im = df.iloc[i]['pixels']\n",
+    "                    im = [int(x) for x in im.split()]\n",
+    "                    X.append(im)\n",
+    "                    sad += 1\n",
+    "                else:\n",
+    "                    pass\n",
+    "                \n",
+    "            if df.iloc[i]['emotion'] == 5:\n",
+    "                if surprise <= 4000:            \n",
+    "                    y.append(df.iloc[i]['emotion'])\n",
+    "                    im = df.iloc[i]['pixels']\n",
+    "                    im = [int(x) for x in im.split()]\n",
+    "                    X.append(im)\n",
+    "                    surprise += 1\n",
+    "                else:\n",
+    "                    pass\n",
+    "                \n",
+    "            if df.iloc[i]['emotion'] == 6:\n",
+    "                if neutral <= 4000:            \n",
+    "                    y.append(df.iloc[i]['emotion'])\n",
+    "                    im = df.iloc[i]['pixels']\n",
+    "                    im = [int(x) for x in im.split()]\n",
+    "                    X.append(im)\n",
+    "                    neutral += 1\n",
+    "                else:\n",
+    "                    pass\n",
+    "\n",
+    "            \n",
+    "            \n",
+    "    return X, y  \n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X, y = getData('../input/facial-expression/fer2013.csv')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.unique(y, return_counts=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = np.array(X)/255.0\n",
+    "y = np.array(y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X.shape, y.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_o = []\n",
+    "for i in y:\n",
+    "    if i != 6:\n",
+    "        y_o.append(i)\n",
+    "        \n",
+    "    else:\n",
+    "        y_o.append(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "np.unique(y_o, return_counts=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "for i in range(5):\n",
+    "    r = np.random.randint((1), 24000, 1)[0]\n",
+    "    plt.figure()\n",
+    "    plt.imshow(X[r].reshape(48,48), cmap='gray')\n",
+    "    plt.xlabel(label_map[y_o[r]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = X.reshape(len(X), 48, 48, 1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# no_of_images, height, width, coloar_map"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from keras.utils import to_categorical\n",
+    "y_new = to_categorical(y_o, num_classes=6)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "len(y_o), y_new.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y_o[150], y_new[150]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from keras.models import Sequential\n",
+    "from keras.layers import Dense , Activation , Dropout ,Flatten\n",
+    "from keras.layers.convolutional import Conv2D\n",
+    "from keras.layers.convolutional import MaxPooling2D\n",
+    "from keras.metrics import categorical_accuracy\n",
+    "from keras.models import model_from_json\n",
+    "from keras.callbacks import ModelCheckpoint\n",
+    "from keras.optimizers import *\n",
+    "from keras.layers.normalization import BatchNormalization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = Sequential()\n",
+    "\n",
+    "\n",
+    "input_shape = (48,48,1)\n",
+    "\n",
+    "\n",
+    "model.add(Conv2D(64, (5, 5), input_shape=input_shape,activation='relu', padding='same'))\n",
+    "model.add(Conv2D(64, (5, 5), padding='same'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Activation('relu'))\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "\n",
+    "\n",
+    "model.add(Conv2D(128, (5, 5),activation='relu',padding='same'))\n",
+    "model.add(Conv2D(128, (5, 5),padding='same'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(Activation('relu'))\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "\n",
+    "model.add(Conv2D(256, (3, 3),activation='relu',padding='same'))\n",
+    "model.add(Conv2D(256, (3, 3),activation='relu',padding='same'))\n",
+    "model.add(BatchNormalization())\n",
+    "model.add(MaxPooling2D(pool_size=(2, 2)))\n",
+    "\n",
+    "## (15, 15) --->  30\n",
+    "model.add(Flatten())\n",
+    "model.add(Dense(6, activation='softmax'))\n",
+    "\n",
+    "model.compile(loss='categorical_crossentropy', metrics=['accuracy'],optimizer='adam')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.fit(X, y_new, epochs=22, batch_size=64, shuffle=True, validation_split=0.2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.save('model.h5')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_img = cv2.imread('../input/happy-img-test/pexels-andrea-piacquadio-941693.jpg', 0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_img.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_img = cv2.resize(test_img, (48,48))\n",
+    "test_img.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_img = test_img.reshape(1,48,48,1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.predict(test_img)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# label_map = ['Anger', 'Neutral', 'Fear', 'Happy', 'Sad', 'Surprise']"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.8.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

facial-detection.py

@@ -0,0 +1,374 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# In[ ]:
+
+
+
+import numpy as np 
+import pandas as pd 
+import cv2
+
+
+# In[ ]:
+
+
+df = pd.read_csv('../input/facial-expression/fer2013.csv')
+
+
+# In[ ]:
+
+
+df.head()
+
+
+# In[ ]:
+
+
+len(df.iloc[0]['pixels'].split())
+# 48 * 48
+
+
+# In[ ]:
+
+
+label_map = ['Anger', 'Neutral', 'Fear', 'Happy', 'Sad', 'Surprise']
+
+
+# In[ ]:
+
+
+import matplotlib.pyplot as plt
+
+
+# In[ ]:
+
+
+img = df.iloc[0]['pixels'].split()
+
+
+# In[ ]:
+
+
+img = [int(i) for i in img]
+
+
+# In[ ]:
+
+
+type(img[0])
+
+
+# In[ ]:
+
+
+len(img)
+
+
+# In[ ]:
+
+
+img = np.array(img)
+
+
+# In[ ]:
+
+
+img = img.reshape(48,48)
+
+
+# In[ ]:
+
+
+img.shape
+
+
+# In[ ]:
+
+
+plt.imshow(img, cmap='gray')
+plt.xlabel(df.iloc[0]['emotion'])
+
+
+# In[ ]:
+
+
+X = []
+y = []
+
+
+# In[ ]:
+
+
+def getData(path):
+    anger = 0
+    fear = 0
+    sad = 0
+    happy = 0
+    surprise = 0
+    neutral = 0
+    df = pd.read_csv(path)
+    
+    X = []
+    y = []    
+    
+    for i in range(len(df)):
+        if df.iloc[i]['emotion'] != 1:
+            if df.iloc[i]['emotion'] == 0:
+                if anger <= 4000:            
+                    y.append(df.iloc[i]['emotion'])
+                    im = df.iloc[i]['pixels']
+                    im = [int(x) for x in im.split()]
+                    X.append(im)
+                    anger += 1
+                else:
+                    pass
+                
+            if df.iloc[i]['emotion'] == 2:
+                if fear <= 4000:            
+                    y.append(df.iloc[i]['emotion'])
+                    im = df.iloc[i]['pixels']
+                    im = [int(x) for x in im.split()]
+                    X.append(im)
+                    fear += 1
+                else:
+                    pass
+                
+            if df.iloc[i]['emotion'] == 3:
+                if happy <= 4000:            
+                    y.append(df.iloc[i]['emotion'])
+                    im = df.iloc[i]['pixels']
+                    im = [int(x) for x in im.split()]
+                    X.append(im)
+                    happy += 1
+                else:
+                    pass
+                
+            if df.iloc[i]['emotion'] == 4:
+                if sad <= 4000:            
+                    y.append(df.iloc[i]['emotion'])
+                    im = df.iloc[i]['pixels']
+                    im = [int(x) for x in im.split()]
+                    X.append(im)
+                    sad += 1
+                else:
+                    pass
+                
+            if df.iloc[i]['emotion'] == 5:
+                if surprise <= 4000:            
+                    y.append(df.iloc[i]['emotion'])
+                    im = df.iloc[i]['pixels']
+                    im = [int(x) for x in im.split()]
+                    X.append(im)
+                    surprise += 1
+                else:
+                    pass
+                
+            if df.iloc[i]['emotion'] == 6:
+                if neutral <= 4000:            
+                    y.append(df.iloc[i]['emotion'])
+                    im = df.iloc[i]['pixels']
+                    im = [int(x) for x in im.split()]
+                    X.append(im)
+                    neutral += 1
+                else:
+                    pass
+
+            
+            
+    return X, y  
+    
+
+
+# In[ ]:
+
+
+X, y = getData('../input/facial-expression/fer2013.csv')
+
+
+# In[ ]:
+
+
+np.unique(y, return_counts=True)
+
+
+# In[ ]:
+
+
+X = np.array(X)/255.0
+y = np.array(y)
+
+
+# In[ ]:
+
+
+X.shape, y.shape
+
+
+# In[ ]:
+
+
+y_o = []
+for i in y:
+    if i != 6:
+        y_o.append(i)
+        
+    else:
+        y_o.append(1)
+
+
+# In[ ]:
+
+
+np.unique(y_o, return_counts=True)
+
+
+# In[ ]:
+
+
+for i in range(5):
+    r = np.random.randint((1), 24000, 1)[0]
+    plt.figure()
+    plt.imshow(X[r].reshape(48,48), cmap='gray')
+    plt.xlabel(label_map[y_o[r]])
+
+
+# In[ ]:
+
+
+X = X.reshape(len(X), 48, 48, 1)
+
+
+# In[ ]:
+
+
+# no_of_images, height, width, coloar_map
+
+
+# In[ ]:
+
+
+X.shape
+
+
+# In[ ]:
+
+
+from keras.utils import to_categorical
+y_new = to_categorical(y_o, num_classes=6)
+
+
+# In[ ]:
+
+
+len(y_o), y_new.shape
+
+
+# In[ ]:
+
+
+y_o[150], y_new[150]
+
+
+# In[ ]:
+
+
+from keras.models import Sequential
+from keras.layers import Dense , Activation , Dropout ,Flatten
+from keras.layers.convolutional import Conv2D
+from keras.layers.convolutional import MaxPooling2D
+from keras.metrics import categorical_accuracy
+from keras.models import model_from_json
+from keras.callbacks import ModelCheckpoint
+from keras.optimizers import *
+from keras.layers.normalization import BatchNormalization
+
+
+# In[ ]:
+
+
+model = Sequential()
+
+
+input_shape = (48,48,1)
+
+
+model.add(Conv2D(64, (5, 5), input_shape=input_shape,activation='relu', padding='same'))
+model.add(Conv2D(64, (5, 5), padding='same'))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+
+
+model.add(Conv2D(128, (5, 5),activation='relu',padding='same'))
+model.add(Conv2D(128, (5, 5),padding='same'))
+model.add(BatchNormalization())
+model.add(Activation('relu'))
+model.add(MaxPooling2D(pool_size=(2, 2)))
+
+model.add(Conv2D(256, (3, 3),activation='relu',padding='same'))
+model.add(Conv2D(256, (3, 3),activation='relu',padding='same'))
+model.add(BatchNormalization())
+model.add(MaxPooling2D(pool_size=(2, 2)))
+
+## (15, 15) --->  30
+model.add(Flatten())
+model.add(Dense(6, activation='softmax'))
+
+model.compile(loss='categorical_crossentropy', metrics=['accuracy'],optimizer='adam')
+
+
+# In[ ]:
+
+
+model.fit(X, y_new, epochs=22, batch_size=64, shuffle=True, validation_split=0.2)
+
+
+# In[ ]:
+
+
+model.save('model.h5')
+
+
+# In[ ]:
+
+
+import cv2
+
+
+# In[ ]:
+
+
+test_img = cv2.imread('../input/happy-img-test/pexels-andrea-piacquadio-941693.jpg', 0)
+
+
+# In[ ]:
+
+
+test_img.shape
+
+
+# In[ ]:
+
+
+test_img = cv2.resize(test_img, (48,48))
+test_img.shape
+
+
+# In[ ]:
+
+
+test_img = test_img.reshape(1,48,48,1)
+
+
+# In[ ]:
+
+
+model.predict(test_img)
+
+
+# In[ ]:
+
+
+# label_map = ['Anger', 'Neutral', 'Fear', 'Happy', 'Sad', 'Surprise']
+

model.py

@@ -0,0 +1,34 @@
+import torch
+import torchvision
+
+from torch import nn
+
+
+def create_effnetb0_model(num_classes:int=7, 
+                          seed:int=42):
+    """Creates an EfficientNetB2 feature extractor model and transforms.
+    Args:
+        num_classes (int, optional): number of classes in the classifier head. 
+            Defaults to 3.
+        seed (int, optional): random seed value. Defaults to 42.
+    Returns:
+        model (torch.nn.Module): EffNetB2 feature extractor model. 
+        transforms (torchvision.transforms): EffNetB2 image transforms.
+    """
+    # Create EffNetB2 pretrained weights, transforms and model
+    weights = torchvision.models.EfficientNet_B0_Weights.DEFAULT
+    transforms = weights.transforms()
+    model = torchvision.models.efficientnet_b0(weights=weights)
+
+    # Freeze all layers in base model
+    for param in model.parameters():
+        param.requires_grad = False
+
+    # Change classifier head with random seed for reproducibility
+    torch.manual_seed(seed)
+    model.classifier = nn.Sequential(
+        nn.Dropout(p=0.3, inplace=True),
+        nn.Linear(in_features=1280, out_features=num_classes),
+    )
+    
+    return model, transforms

models/checkpoint.pth

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

models/efficientnet_b0.pth

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

requirements.txt

@@ -0,0 +1,4 @@
+torch==1.13.0
+torchvision==0.14.0
+gradio==3.1.4
+