first commit

01_pretrained_vggface2_anti_spoof_18_3_11_2_2023_facenet.pth

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

app.py

@@ -0,0 +1,79 @@
+### 1. Imports and class names setup ### 
+import gradio as gr
+import os
+import torch
+
+from model import create_vggface2_model
+from timeit import default_timer as timer
+from typing import Tuple, Dict
+
+# Setup class names
+class_names = ["real", "spoof"]
+
+# Setup device-agnostic code
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+### 2. Model and transforms preparation ###
+
+# Create EffNetB2 model
+vggface2, data_transform = create_vggface2_model(
+    num_classes=2, # len(class_names) would also work
+)
+
+# Load saved weights
+vggface2.load_state_dict(
+    torch.load(
+        f="01_pretrained_vggface2_anti_spoof_18_3_11_2_2023_facenet.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 = data_transform(img).unsqueeze(0).to(device)
+    
+    # Put model into evaluation mode and turn on inference mode
+    vggface2.eval()
+    with torch.inference_mode():
+        # Pass the transformed image through the model and turn the prediction logits into prediction probabilities
+        pred_probs = torch.softmax(vggface2(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
+
+### 4. Gradio app ###
+
+# Create title, description and article strings
+title = 'Liveness Detection System 🤖'
+description = 'A vggface2 pretrained computer vision model to classify images as spoof or real.'
+article = 'Prototype 1 for detecting liveness in an image'
+
+# Create examples list from "examples/" directory
+example_list = [["examples/" + example] for example in os.listdir("examples")]
+
+# Create the Gradio demo
+demo = gr.Interface(fn=predict, #mapping function from input to output
+                    inputs=gr.Image(type='pil'), #what are my inputs?
+                    outputs=[gr.Label(num_top_classes=2, label= 'Predictions'), #what are my outputs?
+                             gr.Number(label='Prediction time(s)')],  #our fn has 2 outputs
+                    examples=example_list,
+                    title=title,
+                    description=description,
+                    article=article)
+
+#Launch the demo! 
+demo.launch()

model.py

@@ -0,0 +1,58 @@
+import torch
+import torchvision
+from torchvision import transforms
+
+from torch import nn
+from facenet_pytorch import InceptionResnetV1
+
+def create_vggface2_model(num_classes:int=2, 
+                          seed:int=42):
+    """Creates an InceptionResnetV1 - Vggface2 model and transforms.
+
+    Args:
+        num_classes (int, optional): number of classes in the classifier head. 
+            Defaults to 2.
+        seed (int, optional): random seed value. Defaults to 42.
+
+    Returns:
+        model (torch.nn.Module): vggface2 feature extractor model. 
+        transforms (torchvision.transforms): vggface2 image transforms.
+    """
+    # load the saved model
+    model_pred = InceptionResnetV1(pretrained='vggface2' , classify = True , num_classes = 2).to(device)
+    layer_list = list(model_pred.children())[-5:] # all final layers
+    model_pred = nn.Sequential(*list(model_pred.children())[:-5])
+
+    for param in model_pred.parameters():
+        param.requires_grad = False
+
+    # Recreate the classifier layer and seed it to the target device
+    model_pred.classifier = torch.nn.Sequential(
+        torch.nn.AdaptiveAvgPool2d(output_size=1),
+        torch.nn.Dropout(p=0.6, inplace=False), 
+        Flatten(),
+        torch.nn.Linear(in_features=1792, 
+                         out_features=512, 
+                         bias=False),          
+        torch.nn.BatchNorm1d(512,
+                             eps=0.001,
+                             momentum=0.1,
+                             affine=True,
+                             track_running_stats=True),
+         torch.nn.Linear(in_features=512, 
+                         out_features=2, # same number of output units as our number of classes
+                         bias=True))
+
+    model_pred = model_pred.to(device)
+
+    # Write transform for image
+    data_transform = transforms.Compose([
+        # Resize the images to 64x64 --> RECOMENDATION FROM TRAINING FROM FACENET --> 160x160
+        transforms.Resize(size=(160, 160)),
+        # Flip the images randomly on the horizontal
+        transforms.RandomHorizontalFlip(p=0.5), # p = probability of flip, 0.5 = 50% chance
+        # Turn the image into a torch.Tensor
+        transforms.ToTensor() # this also converts all pixel values from 0 to 255 to be between 0.0 and 1.0 
+    ])
+    
+    return model_pred, data_transform

requirements.txt

@@ -0,0 +1,3 @@
+torch==1.13.1
+torchvision==0.13.0
+gradio==3.1.4