update

classifier.py

@@ -1,20 +1,28 @@
 import os
-import pickle
-import numpy as np
-from PIL import Image
+import joblib
 from huggingface_hub import hf_hub_download
 
+from geometry import extract_features
+from landmarks import get_landmarks
+
 REPO_ID = "codernotme/kataria_optical"
-MODEL_PATH = "face_shape_means.pkl"
-IMG_SIZE = (64, 64)
+MODEL_PATH = "face_shape_model.pkl"
+
+# Global model cache
+_model = None
+
+
+def _get_feature_vector(features):
+    return [
+        features.get("lw_ratio", 0),
+        features.get("jaw_ratio", 0),
+        features.get("forehead_ratio", 0),
+    ]
 
-# Global model cache (dictionary of mean vectors)
-_means = None
 
 def load_model():
-    global _means
-    if _means is None:
-        # Check local first
+    global _model
+    if _model is None:
         local_path = MODEL_PATH
         if not os.path.exists(local_path):
             try:
@@ -25,77 +33,46 @@ def load_model():
                 return None
 
         try:
-            with open(local_path, "rb") as f:
-                _means = pickle.load(f)
-            print("Loaded Mean Face vectors.")
+            _model = joblib.load(local_path)
+            print("Loaded face shape model.")
         except Exception as e:
             print(f"Failed to load model: {e}")
-    return _means
+    return _model
 
 
 def classify_face_shape(image_input):
     """
-    Classifies face shape using Mean Face (Centroid) classification.
-    
+    Classifies face shape using the trained SVM model.
+
     Args:
-        image_input: PIL Image or numpy array.
-    
+        image_input: File path, PIL Image, or numpy array.
+
     Returns:
         dict: Sorted dictionary of probabilities.
     """
-    means = load_model()
-    
-    if means is None or image_input is None:
+    model = load_model()
+
+    if model is None or image_input is None:
         return {"Unknown": 1.0}
 
     try:
-        # Preprocess: Resize to 64x64, Grayscale, Flatten
-        if isinstance(image_input, np.ndarray):
-             # Helper to convert numpy (if passed from somewhere else) to PIL for consistent resize
-             img = Image.fromarray(image_input)
-        else:
-             img = image_input
-
-        # Ensuring grayscale and resize
-        img = img.convert("L").resize(IMG_SIZE)
-        input_vector = np.array(img).flatten()
-        
-        # Calculate Cosine Similarity to each class mean
-        # Cosine Sim = (A . B) / (||A|| * ||B||)
-        scores = {}
-        input_norm = np.linalg.norm(input_vector)
-        if input_norm == 0:
+        landmarks = get_landmarks(image_input)
+        feats = extract_features(landmarks)
+        vector = _get_feature_vector(feats)
+
+        probabilities = model.predict_proba([vector])[0]
+        labels = list(getattr(model, "classes_", []))
+        if not labels:
             return {"Unknown": 1.0}
-            
-        for label, mean_vector in means.items():
-            mean_norm = np.linalg.norm(mean_vector)
-            if mean_norm == 0:
-                similarity = 0
-            else:
-                similarity = np.dot(input_vector, mean_vector) / (input_norm * mean_norm)
-            
-            scores[label] = similarity
-            
-        # Softmax directly on similarity scores?
-        # Similarity is between -1 and 1 (usually 0 to 1 for images).
-        # We can treat similarity as a logit or just normalize.
-        # Let's use simple normalization if all are positive.
-        
-        min_score = min(scores.values())
-        if min_score < 0:
-            # Shift to positive
-            scores = {k: v - min_score for k, v in scores.items()}
-            
-        total_score = sum(scores.values())
-        if total_score == 0:
-            total_score = 1
-        
-        probabilities = {k: round(float(v / total_score), 4) for k, v in scores.items()}
-        
-        # Sort by probability descending
-        return dict(sorted(probabilities.items(), key=lambda item: item[1], reverse=True))
-
-        
+
+        scores = {
+            str(label): round(float(score), 4)
+            for label, score in zip(labels, probabilities)
+        }
+        total_score = sum(scores.values()) or 1
+        scores = {k: round(float(v / total_score), 4) for k, v in scores.items()}
+        return dict(sorted(scores.items(), key=lambda item: item[1], reverse=True))
+
     except Exception as e:
         print(f"Prediction error: {e}")
         return {"Error": 1.0}

detect.py

@@ -89,7 +89,7 @@ def _blend_probabilities(primary, secondary, alpha=0.55):
 
 def detect_face_shape(image_path):
     """
-    Detects face shape using PIL and trained Mean Face model.
+    Detects face shape using PIL and trained SVM model.
     """
     from PIL import Image
     from landmarks import get_landmarks

hf_upload.py

@@ -10,7 +10,7 @@ repo_id = "codernotme/kataria_optical"
 
 # 2. Upload only the necessary model files
 files_to_upload = {
-    "face_shape_means.pkl": "face_shape_means.pkl",
+    "face_shape_model.pkl": "face_shape_model.pkl",
     "lbfmodel.yaml": "lbfmodel.yaml"
 }
 

landmarks.py

@@ -50,16 +50,26 @@ def _get_face_cascade():
     return _face_cascade
 
 
-def get_landmarks(image_path):
+def get_landmarks(image_input):
     """
     Extracts 68 face landmarks using OpenCV FacemarkLBF.
     Returns a list/array of (x, y) coordinates.
     """
     facemark = _get_facemark()
 
-    image = cv2.imread(image_path)
-    if image is None:
-        raise ValueError(f"Could not read image: {image_path}")
+    if isinstance(image_input, str):
+        image = cv2.imread(image_input)
+        if image is None:
+            raise ValueError(f"Could not read image: {image_input}")
+    else:
+        if hasattr(image_input, "mode"):
+            image = cv2.cvtColor(np.array(image_input), cv2.COLOR_RGB2BGR)
+        else:
+            image = np.array(image_input)
+            if image.ndim == 3 and image.shape[2] == 3:
+                image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
+        if image is None or image.size == 0:
+            raise ValueError("Could not read image data.")
     
     gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
     

requirements.txt

@@ -8,5 +8,5 @@ requests
 Pillow
 scipy
 huggingface_hub
-
-huggingface_hub
+joblib
+scikit-learn