Clustering de visages utilisant l'algorithme de Whispers chinois

Question

J'essaie d'utiliser l'algorithme de chuchotement chinois pour le regroupement de visages. J'ai utilisé dlib et python pour extraire des caractéristiques pour chaque face et mappé en 128 D comme décrit par Davisking à https://github.com/davisking/dlib/blob/master/examples/dnn_face_recognition_ex.cpp.

Ensuite, j'ai construit un graphique en suivant les instructions qui y sont données. J'ai implémenté l'algorithme des chuchotements chinois et appliqué à ce graphe. Quelqu'un peut-il me dire quelle erreur j'ai faite? Quelqu'un peut-il télécharger le code python pour le regroupement des visages en utilisant l'algorithme des chuchotements chinois? Voici mon code de chuchotements chinois:

import networkx as nx 
import random 
from random import shuffle 
import math 
def chinese_whispers(nodes,edges,iterations): 
    G = nx.Graph() 
    G.add_nodes_from(nodes) 
    #print(G.node) 
    for n, v in enumerate(nodes): 
     G.node[n]['class'] = v 
     #print(n,v) 
    G.add_edges_from(edges) 
    #gn=G.nodes() 
    #for node in gn: 
    #print((node,G[node],G.node,G.node[node])) 
    #(0, {16: {'weight': 0.49846761956907698}, 14: {'weight': 0.55778036559581601}, 7: {'weight': 0.43902511314524784}}, {'class': 0}) 
    for z in range(0, iterations): 
     gn = G.nodes() 
    # I randomize the nodes to give me an arbitrary start point 
     shuffle(gn) 
     for node in gn: 
      neighs = G[node] 
      classes = {} 
     # do an inventory of the given nodes neighbours and edge weights 
      for ne in neighs: 
       if isinstance(ne, int): 
        key=G.node[ne]['class'] 
        if key in classes: 
         classes[key] += G[node][ne]['weight'] 
        else: 
         classes[key] = G[node][ne]['weight'] 
     # find the class with the highest edge weight sum 

      max = 0 
      maxclass = 0 
      for c in classes: 
       if classes[c] > max: 
        max = classes[c] 
        maxclass = c 
     # set the class of target node to the winning local class 
      G.node[node]['class'] = maxclass 

    n_clusters = [] 
    for node in G.nodes(): 
     n_clusters.append(G.node[node]['class']) 
    return(n_clusters) 

Voici le code d'extraction de caractéristiques du visage et le codage de chaque faces en 128 D et vecteur de construction de ces graphique pour appliquer chuchotements chinois. Je ne comprends pas ce que je fais mal. Est-ce que quelqu'un peut m'aider à ce sujet? Merci d'avance.

Answer 1

J'ai utilisé dlib pour les mêmes tâches de discrimination de visage. J'ai trouvé le SVM de Scikit-learn avec les noyaux RBF pour donner de bons résultats en termes de précision. Vous pouvez essayer GridSearchCV pour régler le classificateur SVM pour les meilleures valeurs C et gamma.

from sklearn import svm 
from sklearn.metrics import confusion_matrix, accuracy_score 
from sklearn.preprocessing import LabelEncoder 
from sklearn.model_selection import train_test_split 
from sklearn.metrics import classification_report 
from sklearn.model_selection import GridSearchCV 

# reps is a list of all faces embeddings (array of 128D vectors) 
# labels is a list of all face labels (['bob', 'mary'...] etc) 

X_train, X_test, y_train, y_test = train_test_split(
    reps, labels, test_size=0.3, random_state=0) 

le = LabelEncoder().fit(labels) 

# Set the parameters by cross-validation 
tuned_parameters = [{'kernel': ['rbf'], 'gamma': [1, 10, 100], 
        'C': [0.1, 1, 10, 100, 1000]} 
        ] 

scores = ['precision', 'recall'] 

for score in scores: 
    _LOGGER.info("# Tuning hyper-parameters for %s" % score) 

    clf = GridSearchCV(svm.SVC(C=1), tuned_parameters, cv=5, 
         scoring='%s_macro' % score) 

    stime = time.time() 
    clf.fit(X_train, y_train) 
    etime = time.time() - stime 
    _LOGGER.info("Fitting took %s seconds" % time.strftime("%H:%M:%S", time.gmtime(etime))) 

    _LOGGER.info("Best parameters set found on development set:") 

    _LOGGER.info(clf.best_params_) 

    _LOGGER.info("Grid scores on development set:") 

    means = clf.cv_results_['mean_test_score'] 
    stds = clf.cv_results_['std_test_score'] 
    for mean, std, params in zip(means, stds, clf.cv_results_['params']): 
     _LOGGER.info("%0.3f (+/-%0.03f) for %r" 
        % (mean, std * 2, params)) 

    _LOGGER.info("Detailed classification report:") 

    _LOGGER.info("The model is trained on the full development set.") 
    _LOGGER.info("The scores are computed on the full evaluation set.") 

    y_true, y_pred = y_test, clf.predict(X_test) 
    _LOGGER.info(classification_report(y_true, y_pred)) 

    _LOGGER.info("Accuracy : %.2f" % (accuracy_score(y_true, y_pred) * 100.0))