Entendendo a redução de dimensionalidade

A redução de dimensionalidade é uma técnica avançada de aprendizado de máquina e análise de dados que envolve a transformação de dados de alta dimensão em um espaço de menor dimensão, mantendo o máximo possível de informações importantes. Dados de alta dimensão referem-se a conjuntos de dados com um grande número de recursos ou variáveis, o que pode representar desafios significativos para os modelos de aprendizado de máquina.

Neste tutorial, aprenderemos por que devemos usar a redução de dimensionalidade, os tipos de técnicas de redução de dimensionalidade e como aplicar essas técnicas a um conjunto de dados de imagem simples. Também visualizaremos os dados no espaço 2D e compararemos as imagens em um espaço de dimensão inferior.

Se você é novo no aprendizado de máquina e deseja dominar os conceitos de aprendizado de máquina, faça o curso Torne-se um cientista de aprendizado de máquina em Python e trabalhe para que você se torne um cientista de aprendizado de máquina.

Imagem do autor

Por que a redução da dimensionalidade?

Os dados de alta dimensão, embora ricos em informações, geralmente contêm recursos redundantes ou irrelevantes. Isso pode levar a vários problemas:

1. Maldição da dimensionalidade: À medida que o número de dimensões aumenta, os pontos de dados se tornam esparsos, o que torna mais difícil para os modelos de aprendizado de máquina encontrarem padrões.
2. Ajuste excessivo: Conjuntos de dados de alta dimensão podem fazer com que os modelos se ajustem demais, pois podem aprender o ruído em vez dos padrões subjacentes.
3. Complexidade computacional: Mais dimensões significam custos computacionais mais altos, o que pode retardar o treinamento e a inferência.
4. Desafios de visualização: A visualização de dados com mais de três dimensões dificulta a compreensão da estrutura dos dados.

A redução da dimensionalidade aborda esses problemas simplificando os dados e mantendo os recursos mais importantes. Isso não apenas melhora o desempenho do modelo, mas também torna os dados mais fáceis de interpretar e visualizar.

Linear vs. Redução de dimensionalidade não linear

As técnicas de redução de dimensionalidade também podem ser classificadas com base no fato de assumirem uma estrutura linear ou não linear nos dados.

Métodos lineares

Os métodos lineares pressupõem que os dados estejam em um subespaço linear. Essas técnicas são eficientes do ponto de vista computacional e funcionam bem quando a estrutura dos dados é inerentemente linear. 

Aqui estão alguns exemplos:

• Análise de componentes principais (PCA): identifica as direções (componentes principais) que capturam a variação máxima nos dados. Ele é amplamente usado para reduzir dimensões e, ao mesmo tempo, preservar o máximo de variação possível.
• Análise Discriminante Linear (LDA)A análise discriminante linear (LDA) é particularmente útil para tarefas de classificação, pois reduz as dimensões e preserva a separabilidade das classes.

Acompanhe a Análise de componentes principais (PCA) em Python para saber como extrair informações de dados sem supervisão usando o conjunto de dados de câncer de mama e CIFAR-10.

Métodos não lineares

Os métodos não lineares são usados quando os dados estão em um coletor não linear. Essas técnicas são mais adequadas para capturar estruturas complexas nos dados. 

Aqui estão alguns exemplos:

• t-SNE (t-Distributed Stochastic Neighbor Embedding): um método popular para visualizar dados de alta dimensão em 2D ou 3D, preservando as relações locais entre os pontos de dados. Leia nosso guia do t-SNE para saber mais.
• UMAP (Uniform Manifold Approximation and Projection): Ele é semelhante ao t-SNE, mas é mais rápido e melhor na preservação da estrutura global.
• Autoencoders: As redes neurais são usadas para compactar a representação dos dados usando aprendizado não supervisionado.

Tipos de redução de dimensionalidade

As técnicas de redução de dimensionalidade podem ser amplamente categorizadas em dois tipos: Seleção e extração de recursos.

Seleção de recursos

A seleção de recursos envolve a identificação e a retenção apenas dos recursos mais relevantes do conjunto de dados. Esse processo não transforma os dados, mas seleciona um subconjunto dos recursos originais. 

Os métodos comuns incluem:

• Métodos de filtragem: Use medidas estatísticas para classificar e selecionar recursos.
• Métodos de wrapper: Use modelos de aprendizado de máquina para avaliar subconjuntos de recursos.
• Métodos incorporados: Realizar a seleção de recursos durante o treinamento do modelo.

Extração de recursos

A extração de recursos, também conhecida como projeção de recursos, transforma os dados em um espaço de dimensão inferior, criando novos recursos que são combinações dos originais. Essa abordagem é particularmente útil quando os recursos originais são altamente correlacionados ou redundantes. 

Os métodos populares de extração de recursos incluem:

• PCA: Projeta os dados em direções de variação máxima.
• LDA: Concentra-se em maximizar a separabilidade da classe.
• Métodos não lineares: Técnicas como t-SNE, UMAP e autoencoders são usadas quando os dados estão em um coletor não linear.

Redução de dimensionalidade para dados de imagem

Neste guia, aprenderemos como aplicar técnicas de redução de dimensionalidade em Python. 

1. Trabalhando com um conjunto de dados de imagem

Começaremos importando os pacotes Python necessários e carregando o conjunto de dados de dígitos de sklearn.datasets. 

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.manifold import TSNE
from sklearn.preprocessing import StandardScaler


# Load the digits dataset
digits = load_digits()
X = digits.data   # shape (1797, 64)
y = digits.target # labels for digits (0 through 9)

print("Data shape:", X.shape)
print("Labels shape:", y.shape)Tecnologia

Esse conjunto de dados contém 1.797 imagens em escala de cinza de dígitos manuscritos (0-9), cada uma representada como uma imagem 8x8 (64 pixels). Os dados são achatados em um vetor de recursos de 64 dimensões para cada imagem.

Data shape: (1797, 64)
Labels shape: (1797,)Tecnologia

2. Visualização de imagens de amostra

Agora, visualizaremos algumas amostras do conjunto de dados para que você tenha uma melhor compreensão. Usando o Matplotlib, exibiremos imagens que foram remodeladas de volta ao formato original de grade 8x8.

def plot_digits(images, labels, n_rows=2, n_cols=5):
    fig, axes = plt.subplots(n_rows, n_cols, figsize=(10, 4))
    axes = axes.ravel()
    for i in range(n_rows * n_cols):
        axes[i].imshow(images[i].reshape(8, 8), cmap='gray')
        axes[i].set_title(f"Label: {labels[i]}")
        axes[i].axis('off')
    plt.tight_layout()
    plt.show()

plot_digits(X, y)Tecnologia

Como podemos ver, ele exibe uma grade de imagens, mostrando a aparência dos dígitos em escala de cinza de 0 a 9. 

3. Aplicação do t-SNE

O t-SNE é uma técnica popular de redução de dimensionalidade para visualizar dados de alta dimensão em 2D ou 3D. Ele é particularmente eficaz na preservação de estruturas locais nos dados.

Leia o blog Introdução ao t-SNE: Redução de dimensionalidade não linear e visualização de dados para aprender a visualizar dados de alta dimensão em um espaço de baixa dimensão usando uma técnica de redução de dimensionalidade não linear.

Antes de aplicar o t-SNE, dimensionamos os dados usando o StandardScaler para normalizar os valores dos recursos.

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)Tecnologia

Em seguida, selecionamos um subconjunto de 500 amostras para um cálculo mais rápido e executamos o algoritmo t-SNE no subconjunto. 

Aqui estão os argumentos da função TSNE com explicação: 

• n_components=2: Isso especifica que os dados serão reduzidos a duas dimensões.
• perplexity=30: A perplexidade é um hiperparâmetro importante no t-SNE que controla o equilíbrio entre os aspectos locais e globais dos dados...
• n_iter=1000: Isso define o número de iterações para otimização. Um número maior de iterações permite que o algoritmo converse melhor, mas também aumenta o tempo de computação.
• random_state=42: Isso é usado para reprodutibilidade. 

n_samples = 500
X_sub = X_scaled[:n_samples]
y_sub = y[:n_samples]

tsne = TSNE(n_components=2, 
            perplexity=30, 
            n_iter=1000, 
            random_state=42)
X_tsne = tsne.fit_transform(X_sub)

print("t-SNE result shape:", X_tsne.shape)Tecnologia

A redução da dimensionalidade foi bem-sucedida, pois agora temos 500 amostras, cada uma representada em duas dimensões.

t-SNE result shape: (500, 2)Tecnologia

4. Visualização do resultado do t-SNE

Agora, visualizamos o conjunto de dados 2D t-SNE. Cada ponto é colorido com base no rótulo do dígito, o que nos permite observar como o t-SNE separa bem as diferentes classes de dígitos.

plt.figure(figsize=(8, 6))
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], 
                      c=y_sub, cmap='jet', alpha=0.7)
plt.colorbar(scatter, label='Digit Label')
plt.title('t-SNE (2D) of Digits Dataset (500-sample)')
plt.show()Tecnologia

O t-SNE separou efetivamente os dígitos em 10 grupos distintos, com algumas sobreposições entre os grupos.

5. Comparação de imagens no espaço t-SNE

Para explorar ainda mais o espaço t-SNE, selecionamos aleatoriamente dois pontos e calculamos a distância euclidiana entre eles no espaço 2D t-SNE. Também visualizaremos as imagens para ver como elas são semelhantes.

import random

idx1, idx2 = random.sample(range(X_tsne.shape[0]), 2)

point1, point2 = X_tsne[idx1], X_tsne[idx2]
dist_tsne = np.linalg.norm(point1 - point2)

print(f"Comparing images #{idx1} and #{idx2}")
print(f"Distance in t-SNE space: {dist_tsne:.4f}")
print(f"Label of image #{idx1}: {y_sub[idx1]}")
print(f"Label of image #{idx2}: {y_sub[idx2]}")

# Plot the original images
fig, axes = plt.subplots(1, 2, figsize=(6, 3))
axes[0].imshow(X[idx1].reshape(8, 8), cmap='gray')
axes[0].set_title(f"Label: {y_sub[idx1]}")
axes[0].axis('off')

axes[1].imshow(X[idx2].reshape(8, 8), cmap='gray')
axes[1].set_title(f"Label: {y_sub[idx2]}")
axes[1].axis('off')

plt.show()Tecnologia

A distância no espaço t-SNE reflete a diferença entre as duas imagens na representação 2D reduzida.

Comparing images #291 and #90
Distance in t-SNE space: 35.7666
Label of image #291: 5
Label of image #90: 1
Tecnologia

Se você estiver tendo problemas para executar o código acima, verifique o Espaço de trabalho do DataLab para obter mais assistência.

Conclusão

A redução da dimensionalidade desempenha uma função crucial em aplicativos do mundo real, melhorando a eficiência, a precisão e a interpretabilidade dos modelos de aprendizado de máquina, além de permitir uma melhor visualização e análise de conjuntos de dados complexos. 

Neste tutorial, exploramos o conceito de redução de dimensionalidade, sua finalidade, métodos e tipos. Por fim, aprendemos a usar a técnica t-SNE para transformar dados de imagem em um espaço de dimensão inferior para visualização e análise.

Pegue a Redução de dimensionalidade em Python para que você entenda o conceito de redução da dimensionalidade de seus dados e domine as técnicas para fazer isso em Python.