Face recognition concept in Computer Vision - Model Metrics & Evaluation

Metrics & Evaluation - Face recognition concept

Which metric matters for Face Recognition and WHY

In face recognition, the key metrics are Precision and Recall. Precision tells us how many faces identified as a person are actually correct. Recall tells us how many faces of that person the system found out of all the faces it should find. Both matter because we want to avoid mistakes like wrongly recognizing someone (low precision) and missing a person's face (low recall). The F1 score balances these two, giving a single number to check overall performance.

Confusion Matrix for Face Recognition

      | Predicted Positive | Predicted Negative |
      |--------------------|--------------------|
      | True Positive (TP)  | False Negative (FN) |
      | False Positive (FP) | True Negative (TN)  |

      Example:
      Suppose we have 100 face images of a person.
      - TP = 85 (correctly recognized faces)
      - FN = 15 (faces missed)
      - FP = 10 (wrongly recognized as this person)
      - TN = 200 (correctly identified as not this person)

      Total samples = TP + FP + TN + FN = 85 + 10 + 200 + 15 = 310
    

Precision vs Recall Tradeoff in Face Recognition

Imagine a security system that unlocks doors using face recognition.

• High Precision: The system rarely lets in the wrong person. This is important to keep the place safe.
• High Recall: The system recognizes almost all authorized people, so they don't get locked out.

If the system focuses only on precision, it might miss some authorized people (low recall). If it focuses only on recall, it might let in some wrong people (low precision). We must find a good balance depending on what is more important.

What Good vs Bad Metrics Look Like for Face Recognition

• Good: Precision and Recall both above 90%. This means the system correctly recognizes most faces and rarely makes mistakes.
• Bad: Precision below 70% means many false recognitions. Recall below 70% means many missed faces. Either case makes the system unreliable.

Common Metrics Pitfalls in Face Recognition

• Accuracy Paradox: If most images are of different people, a model that always says "not this person" can have high accuracy but be useless.
• Data Leakage: If the same face images appear in training and testing, metrics will look better than reality.
• Overfitting: Very high training metrics but poor test metrics mean the model memorizes faces instead of learning to recognize new ones.

Self Check: Your model has 98% accuracy but 12% recall on recognizing a person's face. Is it good?

No, it is not good. The high accuracy is misleading because most images are not that person's face, so the model guesses "not this person" most of the time. The very low recall means it misses almost all faces of that person, which defeats the purpose of face recognition.

Key Result

Precision and recall are key for face recognition; high accuracy alone can be misleading.

Practice

1. What is the main goal of face recognition in computer vision?

easy

A. To convert images into black and white

B. To detect objects like cars and trees in images

C. To generate new faces from random noise

D. To identify or verify a person using their facial features

Solution

1. Step 1: Understand the purpose of face recognition

   Face recognition is designed to find out who a person is by looking at their face.

2. Step 2: Compare with other options

   Options A, B, and C describe different tasks unrelated to identifying people by faces.

3. Final Answer:

   To identify or verify a person using their facial features -> Option D

4. Quick Check:

   Face recognition = Identify person by face [OK]

Hint: Face recognition means finding who the face belongs to [OK]

Common Mistakes:

• Confusing face recognition with object detection
• Thinking face recognition creates new images
• Mixing up image color processing with recognition

2. Which of the following is the correct step to train a face recognition model?

easy

A. Collect face images with labels and train the model to learn features

B. Randomly assign labels to images without training

C. Use face images only without any labels

D. Train the model using only text data about faces

Solution

1. Step 1: Identify training requirements

   Training a face recognition model needs images and their correct labels to learn who is who.

2. Step 2: Eliminate incorrect options

   Options A, B, and D miss key parts: no labels (A), random labels (B), or no images (D), which won't train properly.

3. Final Answer:

   Collect face images with labels and train the model to learn features -> Option A

4. Quick Check:

   Training needs images + labels [OK]

Hint: Training needs labeled face images, not random or unlabeled data [OK]

Common Mistakes:

• Ignoring the need for labels during training
• Thinking unlabeled images are enough
• Confusing text data with image data for training

3. Given this Python snippet for face recognition, what will be the output?

known_faces = {"Alice": [0.1, 0.2, 0.3], "Bob": [0.4, 0.5, 0.6]}
new_face = [0.1, 0.2, 0.31]

# Simple distance check
def recognize(face):
    for name, features in known_faces.items():
        dist = sum((f - nf) ** 2 for f, nf in zip(features, face)) ** 0.5
        if dist < 0.05:
            return name
    return "Unknown"

print(recognize(new_face))

medium

A. Bob

B. Alice

C. Unknown

D. Error

Solution

1. Step 1: Calculate distance between new_face and known faces

   Distance to Alice: sqrt((0.1-0.1)^2 + (0.2-0.2)^2 + (0.3-0.31)^2) = sqrt(0 + 0 + 0.0001) = 0.01 < 0.05

2. Step 2: Check distance condition and return name

   Since distance to Alice is less than 0.05, function returns "Alice" immediately.

3. Final Answer:

   Alice -> Option B

4. Quick Check:

   Distance < 0.05 means match = Alice [OK]

Hint: Check distance to known faces; closest under threshold wins [OK]

Common Mistakes:

• Calculating distance incorrectly
• Confusing which face is closer
• Ignoring the threshold condition

4. The following code is meant to recognize a face but always returns "Unknown". What is the bug?

known_faces = {"Alice": [0.1, 0.2, 0.3]}
new_face = [0.1, 0.2, 0.3]

def recognize(face):
    for name, features in known_faces.items():
        dist = sum((f - nf) ** 2 for f, nf in zip(features, face)) ** 0.5
        if dist > 0.05:
            return name
    return "Unknown"

print(recognize(new_face))

medium

A. The new_face list has wrong length

B. The known_faces dictionary is empty

C. The distance condition should be less than 0.05, not greater

D. The function does not return anything

Solution

1. Step 1: Analyze the distance condition in the if statement

   The code returns name if distance > 0.05, but it should return if distance < 0.05 to indicate a match.

2. Step 2: Understand why it always returns "Unknown"

   Since distance is 0 (exact match), condition dist > 0.05 is false, so loop never returns name.

3. Final Answer:

   The distance condition should be less than 0.05, not greater -> Option C

4. Quick Check:

   Match if distance < threshold, not > [OK]

Hint: Match when distance is small, not large [OK]

Common Mistakes:

• Using wrong comparison operator in distance check
• Assuming empty dictionary causes issue
• Ignoring return statements in loop

5. You want to improve a face recognition system to handle many people with similar features. Which approach helps most?

hard

A. Use a deeper neural network to extract more detailed face features

B. Reduce the number of training images per person

C. Ignore feature differences and use only face color

D. Train the model without labels to save time

Solution

1. Step 1: Understand the challenge of similar faces

   When faces look alike, the model needs better features to tell them apart.

2. Step 2: Evaluate options for improving feature extraction

   A deeper neural network can learn more complex and detailed features, improving recognition accuracy.

3. Final Answer:

   Use a deeper neural network to extract more detailed face features -> Option A

4. Quick Check:

   Better features = deeper network [OK]

Hint: More complex models capture finer face details [OK]

Common Mistakes:

• Reducing training data lowers accuracy
• Ignoring features and using color is ineffective
• Training without labels prevents learning identities