Descomposiciones del Conjunto de Datos de Caras

Machine LearningMachine LearningBeginner
Practicar Ahora

This tutorial is from open-source community. Access the source code

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

Esta práctica aplica diferentes métodos de descomposición matricial no supervisada (reducción de dimensionalidad) del módulo sklearn.decomposition al conjunto de datos de caras Olivetti. El conjunto de datos de caras Olivetti consta de 400 caras de tamaño 64x64 píxeles de 40 individuos, cada una capturada con diferentes expresiones faciales y condiciones de iluminación.

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 Notebook 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 su retroalimentación después de la sesión y lo resolveremos rápidamente para usted.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL sklearn(("Sklearn")) -.-> sklearn/UtilitiesandDatasetsGroup(["Utilities and Datasets"]) ml(("Machine Learning")) -.-> ml/FrameworkandSoftwareGroup(["Framework and Software"]) sklearn/UtilitiesandDatasetsGroup -.-> sklearn/datasets("Datasets") ml/FrameworkandSoftwareGroup -.-> ml/sklearn("scikit-learn") subgraph Lab Skills sklearn/datasets -.-> lab-49124{{"Descomposiciones del Conjunto de Datos de Caras"}} ml/sklearn -.-> lab-49124{{"Descomposiciones del Conjunto de Datos de Caras"}} end

Preparación del conjunto de datos

Primero, cargamos y preprocesamos el conjunto de datos de caras Olivetti. Centramos los datos para que tengan media cero, tanto globalmente (centrando todos los datos en una característica) como localmente (centrando todas las características en una muestra). También definimos una función base para representar la galería de caras.

## Carga y preprocesamiento del conjunto de datos de caras Olivetti.

import logging

from numpy.random import RandomState
import matplotlib.pyplot as plt

from sklearn.datasets import fetch_olivetti_faces
from sklearn import cluster
from sklearn import decomposition

rng = RandomState(0)

## Muestra los registros de progreso en la salida estándar
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")

faces, _ = fetch_olivetti_faces(return_X_y=True, shuffle=True, random_state=rng)
n_samples, n_features = faces.shape

## Centrado global (centrando todos los datos en una característica)
faces_centered = faces - faces.mean(axis=0)

## Centrado local (centrando todas las características en una muestra)
faces_centered -= faces_centered.mean(axis=1).reshape(n_samples, -1)

print("El conjunto de datos consta de %d caras" % n_samples)

## Define una función base para representar la galería de caras.

n_row, n_col = 2, 3
n_components = n_row * n_col
image_shape = (64, 64)


def plot_gallery(title, images, n_col=n_col, n_row=n_row, cmap=plt.cm.gray):
    fig, axs = plt.subplots(
        nrows=n_row,
        ncols=n_col,
        figsize=(2.0 * n_col, 2.3 * n_row),
        facecolor="white",
        constrained_layout=True,
    )
    fig.set_constrained_layout_pads(w_pad=0.01, h_pad=0.02, hspace=0, wspace=0)
    fig.set_edgecolor("black")
    fig.suptitle(title, size=16)
    for ax, vec in zip(axs.flat, images):
        vmax = max(vec.max(), -vec.min())
        im = ax.imshow(
            vec.reshape(image_shape),
            cmap=cmap,
            interpolation="nearest",
            vmin=-vmax,
            vmax=vmax,
        )
        ax.axis("off")

    fig.colorbar(im, ax=axs, orientation="horizontal", shrink=0.99, aspect=40, pad=0.01)
    plt.show()


## Echemos un vistazo a nuestros datos. El color gris indica valores negativos,
## el blanco indica valores positivos.

plot_gallery("Caras del conjunto de datos", faces_centered[:n_components])

Eigenfaces - PCA utilizando SVD aleatorizada

El primer método que aplicamos es PCA, que es una técnica de reducción de dimensionalidad lineal que utiliza la Descomposición en Valores Singulares (SVD) de los datos para proyectarlos a un espacio de dimensión más baja. Utilizamos SVD aleatorizada, que es una aproximación más rápida del algoritmo de SVD estándar. Representamos los primeros seis componentes principales, que se denominan eigenfaces.

## Eigenfaces - PCA utilizando SVD aleatorizada
pca_estimator = decomposition.PCA(
    n_components=n_components, svd_solver="randomized", whiten=True
)
pca_estimator.fit(faces_centered)
plot_gallery(
    "Eigenfaces - PCA using randomized SVD", pca_estimator.components_[:n_components]
)

Componentes no negativos - NMF

A continuación, aplicamos la Factorización de Matriz No Negativa (NMF), que descompone la matriz de datos en dos matrices no negativas, una que contiene los vectores base y la otra que contiene los coeficientes. Esto da como resultado una representación basada en partes de los datos.

## Componentes no negativos - NMF
nmf_estimator = decomposition.NMF(n_components=n_components, tol=5e-3)
nmf_estimator.fit(faces)  ## conjunto de datos no negativo original
plot_gallery("Componentes no negativos - NMF", nmf_estimator.components_[:n_components])

Componentes independientes - FastICA

El Análisis de Componentes Independientes (ICA) es un método para separar señales multivariadas en subcomponentes aditivos que son lo más independientes posible. Aplicamos FastICA, que es un algoritmo rápido y robusto para el ICA.

## Componentes independientes - FastICA
ica_estimator = decomposition.FastICA(
    n_components=n_components, max_iter=400, whiten="arbitrary-variance", tol=15e-5
)
ica_estimator.fit(faces_centered)
plot_gallery(
    "Componentes independientes - FastICA", ica_estimator.components_[:n_components]
)

Componentes esparsos - MiniBatchSparsePCA

La PCA esparsa es una variante de la PCA que fomenta la esparsidad en los vectores de carga, lo que da como resultado una descomposición más interpretable. Utilizamos MiniBatchSparsePCA, que es una versión más rápida de SparsePCA que es más adecuada para conjuntos de datos grandes.

## Componentes esparsos - MiniBatchSparsePCA
batch_pca_estimator = decomposition.MiniBatchSparsePCA(
    n_components=n_components, alpha=0.1, max_iter=100, batch_size=3, random_state=rng
)
batch_pca_estimator.fit(faces_centered)
plot_gallery(
    "Componentes esparsos - MiniBatchSparsePCA",
    batch_pca_estimator.components_[:n_components],
)

Aprendizaje del diccionario

El aprendizaje del diccionario es un método para encontrar una representación esparsa de los datos de entrada como una combinación de elementos simples, que forman un diccionario. Aplicamos MiniBatchDictionaryLearning, que es una versión más rápida de DictionaryLearning que es más adecuada para conjuntos de datos grandes.

## Aprendizaje del diccionario
batch_dict_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components, alpha=0.1, max_iter=50, batch_size=3, random_state=rng
)
batch_dict_estimator.fit(faces_centered)
plot_gallery("Aprendizaje del diccionario", batch_dict_estimator.components_[:n_components])

Centros de clúster - MiniBatchKMeans

El algoritmo de clustering K-means es un método para particionar un conjunto de datos en clústeres minimizando la suma de las distancias al cuadrado entre cada punto y el centroide de su clúster asignado. Aplicamos MiniBatchKMeans, que es una versión más rápida de KMeans que es más adecuada para conjuntos de datos grandes.

## Centros de clúster - MiniBatchKMeans
kmeans_estimator = cluster.MiniBatchKMeans(
    n_clusters=n_components,
    tol=1e-3,
    batch_size=20,
    max_iter=50,
    random_state=rng,
    n_init="auto",
)
kmeans_estimator.fit(faces_centered)
plot_gallery(
    "Centros de clúster - MiniBatchKMeans",
    kmeans_estimator.cluster_centers_[:n_components],
)

Componentes de Análisis Factorial - FA

El Análisis Factorial es un método para modelar la varianza en cada dirección del espacio de entrada de manera independiente (ruido heterocedástico), similar a la PCA pero con esta ventaja. Aplicamos FactorAnalysis, que es una implementación del Análisis Factorial en scikit-learn.

## Componentes de Análisis Factorial - FA
fa_estimator = decomposition.FactorAnalysis(n_components=n_components, max_iter=20)
fa_estimator.fit(faces_centered)
plot_gallery("Análisis Factorial (FA)", fa_estimator.components_[:n_components])

## --- Varianza pixel a pixel
plt.figure(figsize=(3.2, 3.6), facecolor="white", tight_layout=True)
vec = fa_estimator.noise_variance_
vmax = max(vec.max(), -vec.min())
plt.imshow(
    vec.reshape(image_shape),
    cmap=plt.cm.gray,
    interpolation="nearest",
    vmin=-vmax,
    vmax=vmax,
)
plt.axis("off")
plt.title("Varianza pixel a pixel a partir de \n Análisis Factorial (FA)", size=16, wrap=True)
plt.colorbar(orientation="horizontal", shrink=0.8, pad=0.03)
plt.show()

Descomposición: Aprendizaje del diccionario

Volvemos a aplicar MiniBatchDictionaryLearning, pero esta vez forzamos la positividad al encontrar el diccionario y/o los coeficientes de codificación.

Aprendizaje del diccionario - diccionario positivo

dict_pos_dict_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components,
    alpha=0.1,
    max_iter=50,
    batch_size=3,
    random_state=rng,
    positive_dict=True,
)
dict_pos_dict_estimator.fit(faces_centered)
plot_gallery(
    "Aprendizaje del diccionario - diccionario positivo",
    dict_pos_dict_estimator.components_[:n_components],
    cmap=plt.cm.RdBu,
)

Aprendizaje del diccionario - código positivo

dict_pos_code_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components,
    alpha=0.1,
    max_iter=50,
    batch_size=3,
    fit_algorithm="cd",
    random_state=rng,
    positive_code=True,
)
dict_pos_code_estimator.fit(faces_centered)
plot_gallery(
    "Aprendizaje del diccionario - código positivo",
    dict_pos_code_estimator.components_[:n_components],
    cmap=plt.cm.RdBu,
)

Aprendizaje del diccionario - diccionario y código positivos

dict_pos_estimator = decomposition.MiniBatchDictionaryLearning(
    n_components=n_components,
    alpha=0.1,
    max_iter=50,
    batch_size=3,
    fit_algorithm="cd",
    random_state=rng,
    positive_dict=True,
    positive_code=True,
)
dict_pos_estimator.fit(faces_centered)
plot_gallery(
    "Aprendizaje del diccionario - diccionario y código positivos",
    dict_pos_estimator.components_[:n_components],
    cmap=plt.cm.RdBu,
)

Resumen

En este laboratorio, aplicamos varios métodos de descomposición de matrices no supervisados al conjunto de datos de caras Olivetti. Utilizamos PCA, NMF, ICA, PCA Esparsa, Aprendizaje del Diccionario, Agrupamiento K-medias y Análisis Factorial para extraer diferentes tipos de características de los datos. También forzamos la positividad al encontrar el diccionario y/o los coeficientes de codificación en el método de Aprendizaje del Diccionario. En general, estos métodos pueden ser útiles para reducir la dimensionalidad de conjuntos de datos de alta dimensión y extraer características significativas para tareas posteriores como la clasificación y el agrupamiento.