Artigo escrito por Pedro Interaminense
Em diversos problemas que envolvem Inteligência Artificial e grandes volumes de dados, podem surgir problemas relacionados ao tempo de processamento, uso excessivo de recursos computacionais e modelos menos precisos. No entanto, com o avanço da mineração de dados, é possível lidar com esses problemas utilizando técnicas de redução de dimensionalidade, que ajudam a simplificar o conjunto de dados e melhorar a eficiência e precisão dos modelos de aprendizado de máquina.
Ao diminuir a dimensão dos seus dados, você tem como objetivo deixar o treinamento dos dados mais rápidos e auxiliar para o encontro de uma boa solução para o problema proposto. Entretanto, após a execução da redução perdemos algumas informações, o que implica dizer que o modelo pode mitigar sua potencialidade sem que haja uma forte razão. Então, a primeira coisa é tentar treinar seu modelo com os dados originais antes de considerar a redução da dimensionalidade.
Neste artigo vamos abordar de forma conceitual e prática três algoritmos de Redução de dimensionalidade: PCA, t_SNE, Truncated SVD.
PCA
É um procedimento numérico que tenta encontrar uma combinação linear de variáveis originais que melhor capturem a variância dos dados. Em outras palavras, o PCA tenta projetar os dados em um espaço de menor dimensão, mantendo o máximo de informação possível. Com isso, ele é baseado em álgebra linear e usa a decomposição de valores singulares (SVD) para calcular as componentes principais.
A análise de componentes principais (PCA) gera informações que permitem que você mantenha os componentes mais relevantes ao mesmo tempo em que preserva os segmentos mais importantes do conjunto geral de dados. Assim, há uma vantagem adicional, já que cada um dos novos destaques ou segmentos gerados após a aplicação do PCA são, em geral, independentes uns dos outros.
t-SNE
É uma técnica de redução de dimensionalidade não linear que age de forma indireta, sendo comumente adequada para conjunto de dados de alta dimensão. A t-SNE é um procedimento probabilístico que tenta preservar a estrutura de vizinhança dos dados originais em um espaço de menor dimensão. Em vez de focar na variância, o t-SNE tenta encontrar uma distribuição de probabilidade que reflita a semelhança entre pares de pontos nos dados originais. Além disso, utiliza a distribuição t-student para modelar a distribuição de probabilidade e usa uma abordagem iterativa para otimizar a projeção dos dados.
A t-SNE tem um maior uso em problemas de manipulação de imagens, PNL, informação genômica e preparação do discurso. A técnica pode ser implementada pelo mapeamento das informações multidimensionais para um espaço de menor dimensão e pesquisa padrões que podem gerar informações; de uma forma mais simples ele incorpora os pontos de uma dimensão superior para uma dimensão inferior tentando preservar a vizinhança daquele ponto.
Diferença entre PCA e t-SNE
Apesar de ambos serem técnicas de redução de dimensionalidade, em suma, algumas diferenças podem ser notadas quando utilizarem da mesma.
1º) O t-SNE tem um maior tempo de execução se for aplicado há um conjunto de milhões de observações, além de ser computacionalmente caro. Já o PCA finaliza a atividade em um menor período de tempo.
2º) Há uma diferença nos procedimentos: o PCA é um procedimento numérico, enquanto o t-SNE é um procedimento probabilístico, ou seja, o PCA se concentra na variância dos dados e o t-SNE se concentra na semelhança entre pares de pontos nos dados originais.
3º) O PCA é sensível a outliers e o t-SNE sabe lidar melhor com esse problema.
4º) Ele tenta preservar a estrutura global dos dados, o t-SNE tenta preservar a estrutura local (cluster) de dados.
Truncated SVD
O Truncated SVD também é uma técnica de redução de dimensionalidade, mais utilizada em dados com um alto número de valores missings ou com dados esparsos, como por exemplo: sistema de recomendação de produtos em que cada usuário comenta ou classifica um produto, porém uma grande quantidade de clientes não utilizam desse meio, dessa forma, gerando valores “zero” nos dados.
O SVD utiliza a fatoração de matriz semelhante ao PCA, mas a diferença é que a Análise de Componentes Principais utiliza matriz de covariância.
A SVD truncada com matriz de dados fatorada explicada como o número de colunas são iguais ao truncamento. Também ele exclui os dígitos após a casa decimal para diminuir o valor dos dígitos flutuantes matematicamente. Por exemplo, 3,349 pode ser truncado para 3,5.
Parte prática
Biblioteca
import numpy as np
import pandas as pd
from dfply import*Coleta de Dados
df_train = pd.read_csv('train.csv')
df_train >>head(3)| Id | Home Ownership | Annual Income | Years in current job | Tax Liens | Number of Open Accounts | Years of Credit History | Maximum Open Credit | Number of Credit Problems | Months since last delinquent | Bankruptcies | Purpose | Term | Current Loan Amount | Current Credit Balance | Monthly Debt | Credit Score | Credit Default | |
| 0 | 0 | Own Home | 482087.0 | NaN | 0.0 | 11.0 | 26.3 | 685960.0 | 1.0 | NaN | 1.0 | debt consolidation | Short Term | 99999999.0 | 47386.0 | 7914.0 | 749.0 | 0 |
| 1 | 1 | Own Home | 1025487.0 | 10+ years | 0.0 | 15.0 | 15.3 | 1181730.0 | 0.0 | NaN | 0.0 | debt consolidation | Long Term | 264968.0 | 394972.0 | 18373.0 | 737.0 | 1 |
| 2 | 2 | Home Mortgage | 751412.0 | 8 years | 0.0 | 11.0 | 35.0 | 1182434.0 | 0.0 | NaN | 0.0 | debt consolidation | Short Term | 99999999.0 | 308389.0 | 13651.0 | 742.0 | 0 |
O Credit Default é categoria de inadimplência no banco, na qual, 0 = bom pagador e 1 = inadimplente.
Encoder
Para lidar com as variáveis nominais (categóricas) vamos utilizar o Label Encoder, assim transformando em variáveis binárias.
from sklearn import preprocessing
label_encoder = preprocessing.LabelEncoder()
df_train['Home Ownership'] = label_encoder.fit_transform(df_train['Home Ownership'])
df_train['Purpose'] = label_encoder.fit_transform(df_train['Purpose'])
df_train['Term'] = label_encoder.fit_transform(df_train['Term'])
#c41a1adf_train['Years in current job'] = label_encoder.fit_transform(df_train['Years in current job'])Preenchendo valores NaN
df_train.fillna(-99999, inplace=True)Separando as variáveis X e Y
X = df_train.drop('Credit Default', axis=1)
y = df_train['Credit Default']from sklearn.model_selection import train_test_split
x_treino, x_teste, y_treino, y_teste = train_test_split(X, y, test_size = 0.7, random_state = 0)from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)import time
from sklearn.manifold import TSNE
from sklearn.decomposition import PCA, TruncatedSVD
# Implementação do T-SNE
t0 = time.time()
X_reduced_tsne = TSNE(n_components=2, random_state=42).fit_transform(X_scaled)
t1 = time.time()
print("T-SNE took {:.2} s".format(t1 - t0))
# Implementação do PCA
t0 = time.time()
X_reduced_pca = PCA(n_components=2, random_state=42).fit_transform(X_scaled)
t1 = time.time()
print("PCA took {:.2} s".format(t1 - t0))
# TruncatedSVD
t0 = time.time()
X_reduced_svd = TruncatedSVD(n_components=2, algorithm='randomized', random_state=42).fit_transform(X_scaled)
t1 =time.time()
print("Truncated SVD took {:.2} s".format(t1 - t0))T-SNE took 1.1e+02 s
PCA took 2.2 s
Truncated SVD took 0.047 s
Criando Scatter Plot das dimensões reduzidas
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
f, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(24,6))
# labels = ['No Fraud', 'Fraud']
f.suptitle('Clusters que utilizam a Redução de Dimenensionalidade', fontsize=14)
blue_patch = mpatches.Patch(color='#0A0AFF', label='Não inadimplente')
red_patch = mpatches.Patch(color='#AF0000', label='Inadimplente')
# t-SNE scatter plot
ax1.scatter(X_reduced_tsne[:,0], X_reduced_tsne[:,1], c=(y == 0), cmap='coolwarm', label='Não Fraude', linewidths=2)
ax1.scatter(X_reduced_tsne[:,0], X_reduced_tsne[:,1], c=(y == 1), cmap='coolwarm', label='Fraude', linewidths=2)
ax1.set_title('t-SNE', fontsize=14)
ax1.grid(True)
ax1.legend(handles=[blue_patch, red_patch])
# PCA scatter plot
ax2.scatter(X_reduced_pca[:,0], X_reduced_pca[:,1], c=(y == 0), cmap='coolwarm', label='Não Fraude', linewidths=2)
ax2.scatter(X_reduced_pca[:,0], X_reduced_pca[:,1], c=(y == 1), cmap='coolwarm', label='Fraude', linewidths=2)
ax2.set_title('PCA', fontsize=14)
ax2.grid(True)
ax2.legend(handles=[blue_patch, red_patch])
# TruncatedSVD scatter plot
ax3.scatter(X_reduced_svd[:,0], X_reduced_svd[:,1], c=(y == 0), cmap='coolwarm', label='Não Fraude', linewidths=2)
ax3.scatter(X_reduced_svd[:,0], X_reduced_svd[:,1], c=(y == 1), cmap='coolwarm', label='Fraude', linewidths=2)
ax3.set_title('Truncated SVD', fontsize=14)
ax3.grid(True)
ax3.legend(handles=[blue_patch, red_patch])
plt.show()
A diminuição das dimensões geram dados menos esparsos e reduzir as informações nem sempre estamos reduzindo a habilidade de predição (por isso ele é importante).
Referências
Chicago. Chollet, Francois. 2017. Deep Learning with Python. New York, NY: Manning Publications.
Provost, Foster, Fawcett, Tom. (2013). Data Science for Business: What You Need to Know about Data Mining and Data-Analytic Thinking . Sebastopol, California: O’Reilly.
https://medium.com/@lucasgmpaiva1/redu%C3%A7%C3%A3o-de-dimensionalidade-6b98b360ff6a
https://lvdmaaten.github.io/tsne/
https://www.geeksforgeeks.org/difference-between-pca-vs-t-sne/
