Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+sample_image.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

README.md

@@ -1,3 +1,19 @@
----
-license: cc-by-nc-4.0
----
+# Face Shape AI
+
+FaceShapeAI predicts your **face shape** from a photo.
+
+### Try the app demo
+
+- [Face Shape Detector](https://attractivenesstest.com/face_shape)
+- [HF Space](https://huggingface.co/spaces/Rob4343/AIFaceShapeDetector).
+
+![Example](example.webp)
+
+### Run locally
+
+- `python demo.py your_photo.jpg`
+
+FaceShapeAI analyzes your photo to detect a face and extract a dense set of facial landmarks (eyes, nose, mouth, jawline, and more). It then lightly normalizes the geometry—correcting small head tilt and scaling the landmarks for consistency across images. Finally, it runs the trained model included in this repo to predict the most likely face shape and prints confidence scores for each class.
+
+
+![GitHub Repository](https://github.com/rs75/FaceShapeAI)

demo.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+import cv2
+import mediapipe as mp
+import numpy as np
+import pickle
+import argparse
+
+# Paths to model files (assumed to be in the same directory as this script)
+PROJECT_DIR = Path(__file__).parent
+MODEL_FILE = PROJECT_DIR / 'face_shape_model.pkl'
+LABEL_ENCODER_FILE = PROJECT_DIR / 'label_encoder.pkl'
+
+Keypoint = Dict[str, float]
+NormalizedLandmark = Tuple[float, float, float]
+
+
+def normalize_landmarks(keypoints: Sequence[Keypoint], width: int, height: int) -> List[NormalizedLandmark]:
+    """
+    Normalize keypoints to be centered, roll-corrected, and scaled.
+    Retains 3D coordinates (Z) but aligns to the 2D plane based on eyes.
+    
+    Returns list of tuples: [(x, y, z), ...]
+    
+    (Copied from create.py to ensure consistent preprocessing)
+    """
+    if not keypoints:
+        return []
+
+    # Convert to numpy array (N, 3)
+    landmarks = np.array([[kp["x"], kp["y"], kp["z"]] for kp in keypoints])
+    
+    # Denormalize x, y, z to pixel/aspect-correct coordinates
+    # MediaPipe Z is roughly same scale as X (relative to image width)
+    landmarks[:, 0] *= width
+    landmarks[:, 1] *= height
+    landmarks[:, 2] *= width 
+
+    # Indices for irises (refine_landmarks=True gives 478 points)
+    # 468: Left Iris Center (Subject's Left, Image Right)
+    # 473: Right Iris Center (Subject's Right, Image Left)
+    left_iris_idx = 468
+    right_iris_idx = 473
+
+    if len(landmarks) > right_iris_idx:
+        left_iris = landmarks[left_iris_idx]
+        right_iris = landmarks[right_iris_idx]
+    else:
+        # Fallback to eye corners if iris landmarks missing
+        p1 = landmarks[33]  # Left eye outer
+        p2 = landmarks[133] # Left eye inner
+        left_iris = (p1 + p2) / 2
+        p3 = landmarks[362] # Right eye inner
+        p4 = landmarks[263] # Right eye outer
+        right_iris = (p3 + p4) / 2
+
+    # 1. Centering: Move midpoint of eyes to origin
+    eye_center = (left_iris + right_iris) / 2.0
+    landmarks -= eye_center
+
+    # 2. Rotation (Roll Correction)
+    delta = left_iris - right_iris
+    dX, dY = delta[0], delta[1]
+    
+    # Calculate angle of this vector relative to horizontal
+    angle = np.arctan2(dY, dX)
+    
+    # Rotate by -angle to align with X-axis
+    c, s = np.cos(-angle), np.sin(-angle)
+    
+    # Rotation matrix around Z axis
+    R = np.array([
+        [c, -s, 0],
+        [s, c, 0],
+        [0, 0, 1]
+    ])
+    
+    landmarks = landmarks.dot(R.T)
+
+    # 3. Scaling: Scale such that inter-ocular distance is 1.0
+    dist = np.sqrt(dX**2 + dY**2)
+    if dist > 0:
+        scale = 1.0 / dist
+        landmarks *= scale
+
+    # Convert to list of tuples
+    return [(round(float(l[0]), 5), round(float(l[1]), 5), round(float(l[2]), 5)) 
+            for l in landmarks]
+
+
+def create_face_mesh(image_path: Union[str, Path]) -> Tuple[Optional[List[Keypoint]], Optional[np.ndarray]]:
+    """
+    Process image to get face mesh data using MediaPipe
+    Returns: keypoints, img_bgr or None if failed
+    
+    (Copied from create.py to ensure consistent preprocessing)
+    """
+    max_width_or_height = 512
+
+    mp_face_mesh = mp.solutions.face_mesh
+    
+    # Initialize face mesh
+    with mp_face_mesh.FaceMesh(
+            static_image_mode=True,
+            max_num_faces=1,
+            refine_landmarks=True,
+            min_detection_confidence=0.5) as face_mesh:
+        
+        # Read image from file
+        img_bgr = cv2.imread(str(image_path))
+        
+        if img_bgr is None:
+            print(f"Error: Could not read image: {image_path}")
+            return None, None
+
+        # Downscale large images to speed up inference (keep aspect ratio)
+        h, w = img_bgr.shape[:2]
+        longest = max(h, w)
+        if longest > max_width_or_height:
+            scale = max_width_or_height / float(longest)
+            new_w = max(1, int(round(w * scale)))
+            new_h = max(1, int(round(h * scale)))
+            img_bgr = cv2.resize(img_bgr, (new_w, new_h), interpolation=cv2.INTER_AREA)
+        
+        # Convert BGR to RGB for MediaPipe processing
+        img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+        
+        # Process the image
+        results = face_mesh.process(img_rgb)
+        
+        if not results.multi_face_landmarks:
+            print(f"Error: No face detected in: {image_path}")
+            return None, None
+
+        keypoints = []
+        for landmark in results.multi_face_landmarks[0].landmark:
+            keypoints.append({
+                "x": round(landmark.x, 5),
+                "y": round(landmark.y, 5),
+                "z": round(landmark.z, 5)
+            })
+        return keypoints, img_bgr
+
+
+def load_model_resources() -> Tuple[Any, Any]:
+    """Load the trained model and label encoder."""
+    if not MODEL_FILE.exists():
+        raise FileNotFoundError(f"Model file not found at {MODEL_FILE}. Please run create_model.py first.")
+    
+    if not LABEL_ENCODER_FILE.exists():
+        raise FileNotFoundError(f"Label encoder file not found at {LABEL_ENCODER_FILE}. Please run create_model.py first.")
+
+    print(f"Loading model from {MODEL_FILE}...")
+    with open(MODEL_FILE, 'rb') as f:
+        model = pickle.load(f)
+        
+    print(f"Loading label encoder from {LABEL_ENCODER_FILE}...")
+    with open(LABEL_ENCODER_FILE, 'rb') as f:
+        label_encoder = pickle.load(f)
+        
+    return model, label_encoder
+
+
+def predict_face_shape(image_path: Union[str, Path]) -> Optional[str]:
+    """
+    Main function to predict face shape for a given image.
+    """
+    # 1. Load Model
+    try:
+        model, label_encoder = load_model_resources()
+    except Exception as e:
+        print(f"Failed to load model resources: {e}")
+        return None
+
+    # 2. Process Image (Extract Landmarks)
+    print(f"Processing image: {image_path}")
+    keypoints, img_bgr = create_face_mesh(image_path)
+    
+    if keypoints is None:
+        print("Could not extract landmarks. Exiting.")
+        return None
+
+    # 3. Normalize Landmarks
+    h, w = img_bgr.shape[:2]
+    normalized_kpts = normalize_landmarks(keypoints, w, h)
+    
+    # 4. Prepare Features (Flatten and drop Z)
+    # The model expects a flattened array of [x1, y1, x2, y2, ...]
+    flattened_features: List[float] = []
+    for kp in normalized_kpts:
+        flattened_features.extend([kp[0], kp[1]])  # x, y only
+    
+    # Reshape for sklearn (1 sample, N features)
+    features_array = np.array([flattened_features])
+    
+    # 5. Predict
+    print("Running prediction...")
+    # Get probabilities
+    probas = model.predict_proba(features_array)[0]
+    # Get prediction
+    prediction_idx = model.predict(features_array)[0]
+    predicted_label = label_encoder.inverse_transform([prediction_idx])[0]
+    
+    # 6. Show Results
+    print("\n" + "="*30)
+    print(f"PREDICTED FACE SHAPE: {predicted_label.upper()}")
+    print("="*30)
+    
+    print("\nConfidence Scores:")
+    # Sort probabilities
+    class_indices = np.argsort(probas)[::-1]
+    for i in class_indices:
+        class_name = label_encoder.classes_[i]
+        score = probas[i]
+        print(f"  {class_name}: {score:.4f}")
+
+    return predicted_label
+
+
+def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
+    """
+    Parse command-line arguments.
+
+    Note: Default behavior remains to run against `sample_image.jpg` when no args are provided.
+    """
+    parser = argparse.ArgumentParser(description="Predict face shape from an image using a trained sklearn model.")
+    parser.add_argument(
+        "image",
+        nargs="?",
+        default="sample_image.jpg",
+        help="Path to the input image (default: sample_image.jpg).",
+    )
+    return parser.parse_args(argv)
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    predict_face_shape(args.image)

face_shape_model.pkl

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

label_encoder.pkl

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

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.0.0
+mediapipe==0.10.22
+Pillow>=10.0.0
+opencv-python-headless>=4.8.0
+numpy>=1.24.0
+scikit-learn>=1.3.0
+