Upload README.md with huggingface_hub

README.md

@@ -0,0 +1,96 @@
+
+---
+tags:
+- image-to-image
+- pytorch
+- computer-vision
+- face-verification
+---
+# AdvancedFaceVerifyAI Model - QuantaSparkLabs
+
+This model, `AdvancedFaceVerifyAI`, is designed for multi-task facial analysis, including age prediction, gender classification, and emotion classification.
+
+## Model Architecture
+The model features a convolutional backbone followed by shared fully connected layers and separate output heads for each task.
+
+## Training Details
+-   **Dataset**: Custom Structured Synthetic Face Dataset
+-   **Number of Samples**: 8000 training, 2000 validation
+-   **Backbone**: Custom CNN architecture
+-   **Number of Epochs**: 50
+-   **Optimizer**: Adam with learning rate 0.0001
+-   **Learning Rate Scheduler**: ReduceLROnPlateau (mode='min', factor=0.5, patience=5)
+-   **Loss Functions**: 
+    -   Age: Mean Squared Error (MSE)
+    -   Gender: Cross-Entropy Loss
+    -   Emotion: Cross-Entropy Loss
+
+## Performance Metrics (Final Validation Epoch)
+-   **Gender Accuracy**: 100.00%
+-   **Emotion Accuracy**: 100.00%
+-   **Age MAE**: 0.0990
+
+## Usage
+To load and use this model (after downloading `pytorch_model.bin` from the Hugging Face repo):
+
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# Define the model architecture (as it was during training)
+class AdvancedFaceVerifyAI(nn.Module):
+    def __init__(self, num_gender_classes=2, num_emotion_classes=3):
+        super(AdvancedFaceVerifyAI, self).__init__()
+        # (Copy your model definition here from the notebook)
+        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
+        self.bn1 = nn.BatchNorm2d(32)
+        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
+        self.bn2 = nn.BatchNorm2d(64)
+        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
+        self.bn3 = nn.BatchNorm2d(128)
+        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
+        self.dropout = nn.Dropout(0.3)
+        self._to_linear = 128 * (64 // (2**3)) * (64 // (2**3))
+        self.fc1 = nn.Linear(self._to_linear, 512)
+        self.fc_bn1 = nn.BatchNorm1d(512)
+        self.fc2 = nn.Linear(512, 256)
+        self.fc_bn2 = nn.BatchNorm1d(256)
+        self.age_head = nn.Linear(256, 1)
+        self.gender_head = nn.Linear(256, num_gender_classes)
+        self.emotion_head = nn.Linear(256, num_emotion_classes)
+
+    def forward(self, x):
+        x = self.pool(F.relu(self.bn1(self.conv1(x))))
+        x = self.dropout(x)
+        x = self.pool(F.relu(self.bn2(self.conv2(x))))
+        x = self.dropout(x)
+        x = self.pool(F.relu(self.bn3(self.conv3(x))))
+        x = self.dropout(x)
+        x = x.view(-1, self._to_linear)
+        x = F.relu(self.fc_bn1(self.fc1(x)))
+        x = self.dropout(x)
+        x = F.relu(self.fc_bn2(self.fc2(x)))
+        x = self.dropout(x)
+        age_out = self.age_head(x)
+        gender_out = self.gender_head(x)
+        emotion_out = self.emotion_head(x)
+        return age_out, gender_out, emotion_out
+
+# Instantiate the model
+loaded_model = AdvancedFaceVerifyAI(num_gender_classes=2, num_emotion_classes=3)
+
+# Load the state dictionary
+# model_path = hf_hub_download(repo_id="QuantaSparkLabs/FaceVerifyAI-Advanced", filename="best_advanced_face_verify_ai_model.pth")
+loaded_model.load_state_dict(torch.load("best_advanced_face_verify_ai_model.pth", map_location=torch.device('cpu')))
+loaded_model.eval()
+
+print("Model loaded successfully!")
+
+# Example prediction (assuming 'image_tensor' is your preprocessed input image)
+# with torch.no_grad():
+#     age_pred, gender_pred, emotion_pred = loaded_model(image_tensor)
+#     print(f"Predicted Age: {age_pred.item():.2f}")
+#     print(f"Predicted Gender: {torch.argmax(gender_pred).item()}")
+#     print(f"Predicted Emotion: {torch.argmax(emotion_pred).item()}")
+```