Upload 6 files

app.py

@@ -0,0 +1,80 @@
+
+from model import TinyVGG
+import cv2
+import torch
+import torchvision.transforms as transforms
+from PIL import Image
+import gradio as gr
+import os
+import numpy
+from pathlib import Path
+
+def predict(img):
+    """Transforms and performs a prediction on img and returns prediction and time taken.
+    """
+    # Create tiny_vgg model
+    model = TinyVGG(input_shape=3, # number of color channels (3 for RGB) 
+                    hidden_units=10, 
+                    output_shape=2)
+
+    # Load saved weights
+    model.load_state_dict(torch.load(f="sex_tiny_vgg_defualt_weights.pth", map_location=torch.device("cpu")))
+    transform = transforms.Compose([
+                                    transforms.Resize((64, 64)),
+                                    transforms.ToTensor(),
+                                    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+                                    ])
+    class_names = ['female', 'male']
+    input_image = cv2.imread(img)
+    input_image_rgb = cv2.cvtColor(input_image, cv2.COLOR_BGR2RGB)
+
+    # Detect faces in the input image using OpenCV
+    face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+    faces = face_cascade.detectMultiScale(input_image_rgb, scaleFactor=1.1, minNeighbors=5, minSize=(64, 64))
+
+    if len(faces) == 0:
+        return "No faces detected in the image."
+    else:
+        model.eval()
+        # Process each detected face
+        for i, (x, y, w, h) in enumerate(faces):
+            face_image = input_image[y:y+h, x:x+w]  # Extract face
+            face_image_pil = Image.fromarray(cv2.cvtColor(face_image, cv2.COLOR_BGR2RGB))  # Convert to PIL format
+            face_image_tensor = transform(face_image_pil).unsqueeze(0)  # Preprocess face for classification
+                # Put model into evaluation mode and turn on inference mode
+            with torch.inference_mode():
+                # Pass the transformed image through the model and turn the prediction logits into prediction probabilities
+                pred_probs = torch.sigmoid(model(face_image_tensor))
+            # 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))}
+            if pred_labels_and_probs['female'] >= pred_labels_and_probs['male']:
+                return f"Face {i+1}: (Female: {pred_labels_and_probs['female']})"
+            else:
+                return f"Face {i+1}: (Male: {pred_labels_and_probs['male']})"
+    return 
+
+
+
+
+
+# Create title, description and article strings
+title = "Sex Prediction "
+description = "An tiny VGG feature extractor computer vision model to classify Human Face images into male or female."
+
+# Create examples list from "examples/" directory
+example_list = [["examples/" + example] for example in os.listdir("examples")]
+
+# Create Gradio interface 
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil"),
+    outputs=[
+        gr.Label(num_top_classes=5, label="Predictions")
+    ],
+    examples=example_list,
+    title=title,
+    description=description
+)
+
+# Launch the app!
+demo.launch()

model.py

@@ -0,0 +1,44 @@
+import torch
+from torch import nn
+
+class TinyVGG(nn.Module):
+    """
+    Model architecture copying TinyVGG from: 
+    https://poloclub.github.io/cnn-explainer/
+    https://www.learnpytorch.io/04_pytorch_custom_datasets/#:~:text=class%20TinyVGG(,device)%0Amodel_0
+    """
+    def __init__(self, input_shape: int, hidden_units: int, output_shape: int) -> None:
+        super().__init__()
+        self.conv_block_1 = nn.Sequential(
+            nn.Conv2d(in_channels=input_shape, 
+                      out_channels=hidden_units, 
+                      kernel_size=3, # how big is the square that's going over the image?
+                      stride=1, # default
+                      padding=1), # options = "valid" (no padding) or "same" (output has same shape as input) or int for specific number 
+            nn.ReLU(),
+            nn.Conv2d(in_channels=hidden_units, 
+                      out_channels=hidden_units,
+                      kernel_size=3,
+                      stride=1,
+                      padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2,
+                         stride=2) # default stride value is same as kernel_size
+        )
+        self.conv_block_2 = nn.Sequential(
+            nn.Conv2d(hidden_units, hidden_units, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.Conv2d(hidden_units, hidden_units, kernel_size=3, padding=1),
+            nn.ReLU(),
+            nn.MaxPool2d(2)
+        )
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            # Where did this in_features shape come from? 
+            # It's because each layer of our network compresses and changes the shape of our inputs data.
+            nn.Linear(in_features=hidden_units*16*16,
+                      out_features=output_shape)
+        )
+    
+    def forward(self, x: torch.Tensor):
+        return self.classifier(self.conv_block_2(self.conv_block_1(x))) 

requirements.txt

@@ -0,0 +1,5 @@
+torch==2.0.1
+torchvision==0.15.2
+gradio==4.27.0
+opencv-python
+numpy

sex_tiny_vgg_defualt_weights.pth

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