Graficar Parches de Rostros del Diccionario

Introducción

Esta práctica demuestra cómo utilizar la API de scikit-learn para procesar un gran conjunto de datos de caras y aprender un conjunto de parches de imágenes de 20 x 20 que representan caras. El aspecto clave de esta práctica es el uso del aprendizaje en línea, donde cargamos y procesamos imágenes una por una y extraemos 50 parches aleatorios de cada imagen. Acumulamos 500 parches (de 10 imágenes) y luego ejecutamos el método partial_fit del objeto KMeans en línea, MiniBatchKMeans.

Consejos sobre la VM

Una vez que se haya iniciado la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de las operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje sus comentarios después de la sesión y lo resolveremos rápidamente para usted.

Skills Graph

Cargar los datos

Primero cargamos el conjunto de datos de caras Olivetti desde scikit-learn.

from sklearn import datasets

faces = datasets.fetch_olivetti_faces()

Aprender el diccionario de imágenes

Utilizamos MiniBatchKMeans para aprender el diccionario de imágenes. Establecemos el número de clusters en 81, configuramos un estado aleatorio y habilitamos el modo detallado. Luego creamos un búfer para almacenar los parches y recorremos cada imagen del conjunto de datos. Extraemos 50 parches de cada imagen y rediseñamos los datos. A continuación, agregamos los datos al búfer e incrementamos el índice. Si el índice es múltiplo de 10, concatenamos el búfer y ejecutamos partial_fit en los datos. Si el índice es múltiplo de 100, imprimimos un mensaje indicando el número de parches que se han ajustado hasta el momento.

import time
import numpy as np
from sklearn.cluster import MiniBatchKMeans
from sklearn.feature_extraction.image import extract_patches_2d

print("Learning the dictionary... ")
rng = np.random.RandomState(0)
kmeans = MiniBatchKMeans(n_clusters=81, random_state=rng, verbose=True, n_init=3)
patch_size = (20, 20)

buffer = []
t0 = time.time()

## The online learning part: cycle over the whole dataset 6 times
index = 0
for _ in range(6):
    for img in faces.images:
        data = extract_patches_2d(img, patch_size, max_patches=50, random_state=rng)
        data = np.reshape(data, (len(data), -1))
        buffer.append(data)
        index += 1
        if index % 10 == 0:
            data = np.concatenate(buffer, axis=0)
            data -= np.mean(data, axis=0)
            data /= np.std(data, axis=0)
            kmeans.partial_fit(data)
            buffer = []
        if index % 100 == 0:
            print("Partial fit of %4i out of %i" % (index, 6 * len(faces.images)))

dt = time.time() - t0
print("done in %.2fs." % dt)

Graficar los resultados

Finalmente, graficamos los parches de caras y mostramos el tiempo de entrenamiento.

import matplotlib.pyplot as plt

plt.figure(figsize=(4.2, 4))
for i, patch in enumerate(kmeans.cluster_centers_):
    plt.subplot(9, 9, i + 1)
    plt.imshow(patch.reshape(patch_size), cmap=plt.cm.gray, interpolation="nearest")
    plt.xticks(())
    plt.yticks(())


plt.suptitle(
    "Patches of faces\nTrain time %.1fs on %d patches" % (dt, 8 * len(faces.images)),
    fontsize=16,
)
plt.subplots_adjust(0.08, 0.02, 0.92, 0.85, 0.08, 0.23)

plt.show()

Resumen

En esta práctica, demostramos cómo utilizar el aprendizaje en línea para procesar un gran conjunto de datos de caras y aprender un conjunto de parches de imágenes que representan caras. Utilizamos MiniBatchKMeans para aprender el diccionario de imágenes y graficamos los resultados.