Visualizando 64 dimensões

Parte da seção Aprendizado não supervisionado do Journey de Machine Learning da Coddy. Lição 29 de 51.

Este capítulo aplica o PCA a dígitos escritos à mão. Ao final, você reduz uma imagem digitalizada a alguns números e a reconstrói:

Um 9 escrito à mão reconstruído cinco vezes: com 2 números, um borrão cinza; com 5 e 10, um 9 aproximado; com 20, um 9 nítido; e, por último, a imagem digitalizada real de 64 pixels

Primeiro, veja. Uma imagem digitalizada tem 64 pixels, e nenhum gráfico tem 64 eixos, então o PCA os reduz 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))

Não há normalizador aqui: cada pixel compartilha uma unidade, com tinta de 0 a 16.

Digitalizações de dígitos como pontos em dois componentes, cada dígito identificado no centro: os 0 na parte inferior, os 4 bem à direita, os 3 bem à esquerda, os outros dígitos em grupos entre eles, alguns sobrepostos

O PCA nunca viu y; ele apenas colore os pontos. Ainda assim, cada dígito se reúne em sua própria região: a estrutura estava nos pixels.

Desafio

Médio

Um aplicativo de caligrafia para crianças quer saber quais dígitos elas podem confundir. O programa lê alguns dígitos, digitados juntos como 358, em chosen.

Reduza todas as 1.797 digitalizações a 2 números cada com PCA, em points.
Crie um gráfico de dispersão com as digitalizações de cada dígito escolhido, identificado pelo dígito. Adicione uma legenda e exiba o gráfico.
Chame report_closest(points, y, chosen).

Para 046, ele imprime:

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

e desenha isto. Então, Coddy descreve seu gráfico:

Um gráfico de dispersão intitulado Dígitos que se parecem com uma legenda: os zeros embaixo à esquerda, os seis embaixo no meio, os quatros em cima à direita, os seis encostando nos quatros

Experimente você mesmo

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


# De Measuring Similarity: imprime os dois dígitos escolhidos cujos centros estão mais próximos no 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 imagens: 64 pixels cada em X, o dígito representado em y
digits = load_digits()
X = digits.data
y = digits.target

# Os dígitos a comparar, digitados juntos, como 358
chosen = []
for ch in input():
    chosen.append(int(ch))

# Não altere as linhas abaixo
fig, ax = plt.subplots()
ax.set_title("Digits that look alike")
ax.set_xlabel("Component 1")
ax.set_ylabel("Component 2")

# Escreva seu código abaixo