Image Loading and Preprocessing

To load images for face recognition tasks, we use torchvision's ImageFolder dataset:

from torchvision import datasets, transforms
from torch.utils.data import DataLoader

transform = transforms.Compose([
    transforms.Resize((512, 512)),
    transforms.ToTensor()
])
dataset = datasets.ImageFolder(data_directory, transform=transform)

Dataset Structure and Properties

The ImageFolder dataset organizes images in class-specific subdirectories and provides:

• dataset[index][0]: Tensor representation of the image
• dataset[index][1]: Corresponding class label
• dataset.samples: List of (file_path, class_index) tuples
• len(dataset): Total number of samples

DataLoader Configuration

DataLoader enables efficient batch processing:

def custom_collate(batch):
    return batch[0]

loader = DataLoader(
    dataset,
    batch_size=32,
    num_workers=4,
    collate_fn=custom_collate
)

Face Detection with MTCNN

MTCNN (Multi-task Cascaded Convolutional Networks) detects and aligns faces:

from facenet_pytorch import MTCNN

detector = MTCNN(
    image_size=160,
    margin=0,
    min_face_size=20,
    thresholds=[0.6, 0.7, 0.7],
    factor=0.709,
    post_process=True,
    device='cuda' if torch.cuda.is_available() else 'cpu'
)

Face Cropping Process

Process images and save cropped faces:

for batch_idx, (images, save_paths) in enumerate(loader):
    detector(images, save_path=save_paths)
    print(f'Processed batch {batch_idx + 1}/{len(loader)}')

Face Recognition with InceptionResnetV1

Extract facial embeddings using pre-trained models:

from facenet_pytorch import InceptionResnetV1

feature_extractor = InceptionResnetV1(pretrained='vggface2').eval()

embeddings = []
identities = []
label_mapping = {v: k for k, v in dataset.class_to_idx.items()}

for image_tensor, label_idx in loader:
    detected_face, confidence = detector(image_tensor, return_prob=True)
    if detected_face is not None and confidence > 0.9:
        embedding = feature_extractor(detected_face.unsqueeze(0))
        embeddings.append(embedding.detach())
        identities.append(label_mapping[label_idx])

Storing Embedding Data

recognition_data = [embeddings, identities]
torch.save(recognition_data, 'face_embeddings.pt')

Face Matching and Identification

Compare new face embeddings against stored database:

from PIL import Image

def identify_face(query_image_path, database_path):
    query_img = Image.open(query_image_path)
    query_face, confidence_score = detector(query_img, return_prob=True)
    
    if query_face is None:
        return "No face detected"
    
    query_embedding = feature_extractor(query_face.unsqueeze(0)).detach()
    stored_embeddings, stored_names = torch.load(database_path)
    
    distances = []
    for stored_embed in stored_embeddings:
        distance = torch.dist(query_embedding, stored_embed).item()
        distances.append(distance)
    
    min_distance_idx = distances.index(min(distances))
    return stored_names[min_distance_idx]

result = identify_face('query_face.jpg', 'face_embeddings.pt')
print(f"Identified as: {result}")

Similarity Measurement Techniques

Various distance metrics can be used for embedding comparison:

• Euclidean Distance (L2 norm): torch.dist(emb1, emb2, p=2)
• Manhattan Distance (L1 norm): torch.dist(emb1, emb2, p=1)
• Cosine Similarity: torch.nn.functional.cosine_similarity(emb1, emb2)

Advanced Recognition Approaches

Modern face recognition systems often employ:

• ArcFace: Additive angular margin loss for improved discrimination
• Contrastive learning: Maximizing inter-class differences while minimizing intra-class varaitions
• Metric learning: Learning optimal distance metrics for face matching