Complétion de visages avec des estimateurs à plusieurs sorties

Introduction

Ce laboratoire montre comment utiliser des estimateurs à plusieurs sorties pour compléter des images. L'objectif est de prédire la moitié inférieure d'un visage étant donné sa moitié supérieure. Différents algorithmes tels que les arbres extrêmement aléatoires, les k plus proches voisins, la régression linéaire et la régression ridge seront utilisés pour compléter la moitié inférieure des visages. Les visages complétés seront comparés aux visages originaux pour évaluer les performances des algorithmes.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Notebook pour accéder à Jupyter Notebook pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que Jupyter Notebook ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations de Jupyter Notebook.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez des commentaires après la session, et nous résoudrons rapidement le problème pour vous.

Charger les données

La première étape consiste à charger l'ensemble de données des visages Olivetti, qui contient 400 images en niveaux de gris de 64x64 pixels chacune. Les données sont divisées en ensembles d'entraînement et de test. L'ensemble d'entraînement contient les visages de 30 personnes, et l'ensemble de test contient les visages des personnes restantes. Pour ce laboratoire, nous testerons les algorithmes sur un sous-ensemble de cinq personnes.

## Charger les ensembles de données de visages
data, targets = fetch_olivetti_faces(return_X_y=True)

train = data[targets < 30]
test = data[targets >= 30]  ## Tester sur des personnes indépendantes

## Tester sur un sous-ensemble de personnes
n_faces = 5
rng = check_random_state(4)
face_ids = rng.randint(test.shape[0], size=(n_faces,))
test = test[face_ids, :]

n_pixels = data.shape[1]
## Première moitié des visages
X_train = train[:, : (n_pixels + 1) // 2]
## Seconde moitié des visages
y_train = train[:, n_pixels // 2 :]
X_test = test[:, : (n_pixels + 1) // 2]
y_test = test[:, n_pixels // 2 :]

Ajuster les estimateurs

La deuxième étape consiste à ajuster les estimateurs à plusieurs sorties aux données d'entraînement. Nous utiliserons quatre algorithmes différents : les arbres extrêmement aléatoires, les k plus proches voisins, la régression linéaire et la régression ridge. Les estimateurs prédiront la moitié inférieure des visages en fonction de la moitié supérieure.

## Ajuster les estimateurs
ESTIMATORS = {
    "Extra trees": ExtraTreesRegressor(
        n_estimators=10, max_features=32, random_state=0
    ),
    "K-nn": KNeighborsRegressor(),
    "Linear regression": LinearRegression(),
    "Ridge": RidgeCV(),
}

y_test_predict = dict()
for name, estimator in ESTIMATORS.items():
    estimator.fit(X_train, y_train)
    y_test_predict[name] = estimator.predict(X_test)

Tracer les visages complétés

La dernière étape consiste à tracer les visages complétés pour chaque algorithme et à les comparer avec les visages originaux. Les visages originaux sont affichés dans la première colonne, et les visages complétés sont affichés dans les colonnes suivantes pour chaque algorithme. Les performances des algorithmes peuvent être évaluées en comparant les visages complétés avec les visages originaux.

## Tracer les visages complétés
image_shape = (64, 64)

n_cols = 1 + len(ESTIMATORS)
plt.figure(figsize=(2.0 * n_cols, 2.26 * n_faces))
plt.suptitle("Face completion with multi-output estimators", size=16)

for i in range(n_faces):
    true_face = np.hstack((X_test[i], y_test[i]))

    if i:
        sub = plt.subplot(n_faces, n_cols, i * n_cols + 1)
    else:
        sub = plt.subplot(n_faces, n_cols, i * n_cols + 1, title="true faces")

    sub.axis("off")
    sub.imshow(
        true_face.reshape(image_shape), cmap=plt.cm.gray, interpolation="nearest"
    )

    for j, est in enumerate(sorted(ESTIMATORS)):
        completed_face = np.hstack((X_test[i], y_test_predict[est][i]))

        if i:
            sub = plt.subplot(n_faces, n_cols, i * n_cols + 2 + j)

        else:
            sub = plt.subplot(n_faces, n_cols, i * n_cols + 2 + j, title=est)

        sub.axis("off")
        sub.imshow(
            completed_face.reshape(image_shape),
            cmap=plt.cm.gray,
            interpolation="nearest",
        )

plt.show()

Sommaire

Ce laboratoire a montré comment utiliser des estimateurs à plusieurs sorties pour compléter des images. Nous avons utilisé quatre algorithmes différents pour prédire la moitié inférieure d'un visage en fonction de la moitié supérieure. Les performances des algorithmes ont été évaluées en comparant les visages complétés avec les visages originaux.