Completado de Rostros con Estimadores de Multi-Salida

Introducción

Esta práctica demuestra cómo utilizar estimadores con múltiples salidas para completar imágenes. El objetivo es predecir la mitad inferior de un rostro a partir de su mitad superior. Se utilizarán diferentes algoritmos, como árboles aleatorizados extremos, k-vecinos más cercanos, regresión lineal y regresión con cresta, para completar la mitad inferior de los rostros. Las caras completadas se compararán con las caras originales para evaluar el rendimiento de los algoritmos.

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.

Cargar los datos

El primer paso es cargar el conjunto de datos de rostros Olivetti, que contiene 400 imágenes en escala de grises de 64x64 píxeles cada una. Los datos se dividen en conjuntos de entrenamiento y prueba. El conjunto de entrenamiento contiene los rostros de 30 personas, y el conjunto de prueba contiene los rostros de las personas restantes. Para esta práctica, probaremos los algoritmos en un subconjunto de cinco personas.

## Cargar los conjuntos de datos de rostros
data, targets = fetch_olivetti_faces(return_X_y=True)

train = data[targets < 30]
test = data[targets >= 30]  ## Probar en personas independientes

## Probar en un subconjunto de personas
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]
## Mitad superior de los rostros
X_train = train[:, : (n_pixels + 1) // 2]
## Mitad inferior de los rostros
y_train = train[:, n_pixels // 2 :]
X_test = test[:, : (n_pixels + 1) // 2]
y_test = test[:, n_pixels // 2 :]

Ajustar los estimadores

El segundo paso es ajustar los estimadores con múltiples salidas a los datos de entrenamiento. Utilizaremos cuatro algoritmos diferentes: árboles aleatorizados extremos, k-vecinos más cercanos, regresión lineal y regresión con cresta. Los estimadores predecirán la mitad inferior de los rostros a partir de la mitad superior.

## Ajustar los estimadores
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)

Graficar los rostros completados

El último paso es graficar los rostros completados para cada algoritmo y compararlos con los rostros originales. Los rostros originales se muestran en la primera columna, y los rostros completados se muestran en las columnas siguientes para cada algoritmo. El rendimiento de los algoritmos se puede evaluar comparando los rostros completados con los rostros originales.

## Graficar los rostros completados
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()

Resumen

Esta práctica demostró cómo utilizar estimadores con múltiples salidas para completar imágenes. Utilizamos cuatro algoritmos diferentes para predecir la mitad inferior de un rostro a partir de la mitad superior. El rendimiento de los algoritmos se evaluó comparando los rostros completados con los rostros originales.