identification.py

import os
import numpy as np
import time

def euclidean_distance_square(x1, x2):
    return np.einsum('ij,ij->i', x1, x1)[:, np.newaxis] + np.einsum('ij,ij->i', x2, x2) - 2*np.dot(x1, x2.T)

def evaluate_identification_with_modified_megaface_protocol(authorized_features_dir, unauthorized_features_dir): 
    print("Reading authorized features")
    authorized_hashids = []
    authorized_features = []
    
    count = 0
    for root, pids, feature_names in os.walk(authorized_features_dir):
        for feature_name in feature_names:
            if feature_name.endswith(".txt"):
                count += 1
                print("Reading authorized features #{:d}".format(count))
                feature_path = os.path.join(root, feature_name)
                tokens = feature_path.split('/')
                pid = tokens[-2]
                feature = np.loadtxt(feature_path)
                authorized_features.append(feature)
                hashid = hash(pid)
                authorized_hashids.append(hashid)

    authorized_hashids = np.array(authorized_hashids)
    authorized_features = np.array(authorized_features, dtype=np.float32)

    print("Reading unauthorized features")
    unauthorized_features = []
    unauthorized_feature_paths = []

    count = 0
    for root, pids, feature_names in os.walk(unauthorized_features_dir):
        for feature_name in feature_names:
            if feature_name.endswith(".txt"):
                count += 1
                print("Reading unauthorized features #{:d}".format(count))
                feature_path = os.path.join(root, feature_name)
                tokens = feature_path.split('/')
                pid = tokens[-2]
                feature = np.loadtxt(feature_path)
                unauthorized_features.append(feature)
                unauthorized_feature_paths.append(feature_path)
    unauthorized_features = np.array(unauthorized_features, dtype=np.float32)

    print("Start evaluating identification with modified megaface protocol")
    count = 0
    num_correct = 0
    for hashid in set(authorized_hashids):
        count += 1
        print("Evaluating person #{:d} with id {:s}".format(count, authorized_hashid_to_pid_map[hashid]))

        start = time.time()

        intraclass_indices = np.where(authorized_hashids == hashid)[0]
        start_idx = intraclass_indices[0]
        end_idx = intraclass_indices[-1]
        intraclass_features = authorized_features[start_idx:end_idx+1]
        authorized_interclass_features1 = authorized_features[:start_idx]
        authorized_interclass_features2 = authorized_features[end_idx+1:]

        intraclass_distances = euclidean_distance_square(intraclass_features, intraclass_features)
        authorized_interclass_distances1 = euclidean_distance_square(intraclass_features, authorized_interclass_features1)
        authorized_interclass_distances2 = euclidean_distance_square(intraclass_features, authorized_interclass_features2)
        unauthorized_interclass_distances = euclidean_distance_square(intraclass_features, unauthorized_features)

        max_intraclass_distances = np.max(intraclass_distances, axis=1)
        min_authorized_interclass_distances1 = np.min(authorized_interclass_distances1, axis=1)
        min_authorized_interclass_distances2 = np.min(authorized_interclass_distances2, axis=1)
        min_unauthorized_interclass_distances = np.min(unauthorized_interclass_distances, axis=1)

        min_interclass_distance = np.min(np.vstack([min_authorized_interclass_distances1, 
                                                    min_authorized_interclass_distances2, 
                                                    min_unauthorized_interclass_distances]), axis=0) 
        margins = min_interclass_distance - max_intraclass_distances

        best_margin = np.max(margins)
        num_correct += (best_margin >= 0)

        end = time.time()
        print("Processed {:d} photos using {:f}s".format(len(intraclass_indices), end-start))
        print("Accuracy: {:d}/{:d} = {:.4f}%".format(num_correct, count, num_correct/len(authorized_hashids)))