Hey there, let's work through this clustering problem you're facing. You've got a dataset of 1000+ faces, using dlib's 68-point landmarks to cluster into 10 groups for faster matching—but the chin-to-nose distance metric is failing because same-person images have inconsistent landmark placements. That makes total sense; pose, expression, even slight camera angles can throw off single-distance metrics. Here's how to fix this:

Instead of relying on one narrow measurement, create a feature vector that captures the relative shape of the face, which is far more robust to intra-person variation. The key here is normalization to eliminate scale/position differences:

• Translate all landmarks so the face's center (e.g., midpoint between the two eye centers) sits at (0,0)
• Scale the entire landmark set so the interocular distance (distance between outer eye corners) is a fixed value (like 1.0)
• Flatten the normalized (x,y) coordinates of all 68 landmarks into a single vector, or compute derived metrics (like ratios of key distances: eye width to nose length, jawline curvature, etc.)

A 136-dimensional vector (68 points × 2 coordinates) is overkill for clustering and can amplify small landmark errors. Use dimensionality reduction to focus on the most meaningful variation:

• PCA: Projects your high-dimensional features into a lower-dimensional space that captures the majority of facial shape variance. This simplifies clustering and makes it more stable.
• For visualization (to sanity-check clusters), t-SNE works great, but PCA is faster for large datasets like yours.

If you're using K-Means (since you need exactly 10 clusters), make sure you're using the right settings:

• Use Euclidean distance with normalized features (since we've already accounted for scale)
• Run K-Means multiple times with different initial centroids (most libraries do this by default, but double-check) to avoid getting stuck in local minima
• Alternatively, if your clusters have irregular shapes, try Gaussian Mixture Models (GMM)—it's more flexible than K-Means and can model overlapping clusters better.

Fix the root cause of varying landmarks by standardizing your input images:

• Align faces to a canonical pose: Use dlib's built-in face alignment to warp every face to a standard frontal position. This eliminates pose-related landmark shifts for the same person.
• Filter low-quality detections: Dlib's landmark predictor isn't perfect—skip images where the face detection confidence is low, or where landmarks are clearly misaligned (you can check for outliers in landmark positions).

Don't just assume the clustering works—test it with ground truth:

• Pick a subset of images where you know which ones belong to the same person
• Check what percentage of same-person images end up in the same cluster
• Adjust your feature set or clustering parameters (like PCA component count) based on these results

Quick code snippet for normalized landmark features #

Here's how to implement the normalization step in Python with dlib:

import dlib
import numpy as np

def get_normalized_landmark_features(img_path, predictor_path):
    # Initialize dlib tools
    detector = dlib.get_frontal_face_detector()
    predictor = dlib.shape_predictor(predictor_path)
    
    # Load image and detect face
    img = dlib.load_rgb_image(img_path)
    faces = detector(img)
    if not faces:
        return None  # Skip images with no detected face
    
    # Extract landmarks
    landmarks = predictor(img, faces[0])
    landmarks_np = np.array([[p.x, p.y] for p in landmarks.parts()])
    
    # Compute face center (midpoint between eye centers)
    left_eye = landmarks_np[36:42].mean(axis=0)
    right_eye = landmarks_np[42:48].mean(axis=0)
    face_center = (left_eye + right_eye) / 2
    
    # Translate and scale landmarks
    translated = landmarks_np - face_center
    interocular_dist = np.linalg.norm(left_eye - right_eye)
    normalized = translated / interocular_dist
    
    # Return flattened feature vector
    return normalized.flatten()

Once you have these normalized features, you can feed them into PCA, then run K-Means to get your 10 clusters. This should drastically improve how well same-person images group together, since we're focusing on relative shape rather than a single fragile distance.

内容的提问来源于stack exchange，提问作者Krishna