Visualizar 64 dimensiones

Parte de la sección Aprendizaje no supervisado del Journey de Machine Learning de Coddy. Lección 29 de 51.

Este capítulo pone PCA en práctica con dígitos escritos a mano. Al terminarlo, reducirás un escaneo a unos pocos números y lo reconstruirás:

Un 9 escrito a mano, reconstruido cinco veces: con 2 números, un borrón gris; con 5 y 10, un 9 aproximado; con 20, un 9 nítido; y al final, el escaneo real de 64 píxeles

Primero, mira. Un escaneo tiene 64 píxeles, y ningún gráfico tiene 64 ejes, así que PCA los comprime a 2:

digits = load_digits()
X = digits.data
y = digits.target
points = PCA(n_components=2).fit_transform(X)
for d in range(10):
    ax.scatter(points[y == d, 0], points[y == d, 1], label=str(d))

Aquí no hay ningún escalador: todos los píxeles comparten una unidad, con tinta de 0 a 16.

Escaneos de dígitos como puntos en dos componentes, cada dígito etiquetado en su centro: los 0 abajo, los 4 muy a la derecha, los 3 muy a la izquierda, los demás dígitos en grupos entre ellos, algunos superpuestos

PCA nunca vio y; solo colorea los puntos. Sin embargo, cada dígito se agrupa en su propia zona: la estructura estaba en los píxeles.

Desafío

Intermedio

Una aplicación de escritura a mano para niños quiere saber qué dígitos podrían confundir los niños. El programa lee algunos dígitos, escritos juntos como 358, en chosen.

Reduce los 1,797 escaneos a 2 números cada uno con PCA, en points.
Representa en un diagrama de dispersión los escaneos de cada dígito elegido, etiquetados con el dígito. Añade una leyenda y muestra el gráfico.
Llama a report_closest(points, y, chosen).

Para 046, imprime:

Closest on the map: 4 and 6 (13.6 apart)

y dibuja esto. Después, Coddy describe tu gráfico:

Un diagrama de dispersión titulado Dígitos que se parecen, con una leyenda: los 0 abajo a la izquierda, los 6 abajo en el centro, los 4 arriba a la derecha, y los 6 rozando los 4

Pruébalo tú mismo

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA


# De Measuring Similarity: muestra los dos dígitos elegidos cuyos centros están más cerca entre sí en el mapa
def report_closest(points, y, chosen):
    best = -1
    for i in range(len(chosen)):
        for j in range(i + 1, len(chosen)):
            a = points[y == chosen[i]].mean(axis=0)
            b = points[y == chosen[j]].mean(axis=0)
            dist = np.sqrt(((a - b) ** 2).sum())
            if best == -1 or dist < best:
                best = dist
                pair = (chosen[i], chosen[j])
    print(f"Closest on the map: {pair[0]} and {pair[1]} ({best:.1f} apart)")


# 1,797 imágenes escaneadas: 64 píxeles cada una en X; el dígito dibujado, en y
digits = load_digits()
X = digits.data
y = digits.target

# Los dígitos que se van a comparar, escritos juntos como 358
chosen = []
for ch in input():
    chosen.append(int(ch))

# No cambies las líneas siguientes
fig, ax = plt.subplots()
ax.set_title("Digits that look alike")
ax.set_xlabel("Component 1")
ax.set_ylabel("Component 2")

# Escribe tu código a continuación