capa blog

Dimensionalidade

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.

) 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.

) 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.

) 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)
IdHome OwnershipAnnual IncomeYears in current jobTax LiensNumber of Open AccountsYears of Credit HistoryMaximum Open CreditNumber of Credit ProblemsMonths since last delinquentBankruptciesPurposeTermCurrent Loan AmountCurrent Credit BalanceMonthly DebtCredit ScoreCredit Default
00Own Home482087.0NaN0.011.026.3685960.01.0NaN1.0debt consolidationShort Term99999999.047386.07914.0749.00
11Own Home1025487.010+ years0.015.015.31181730.00.0NaN0.0debt consolidationLong Term264968.0394972.018373.0737.01
22Home Mortgage751412.08 years0.011.035.01182434.00.0NaN0.0debt consolidationShort Term99999999.0308389.013651.0742.00

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()
Gráfico representativo de Clusters que utilizam a Redução de Dimensionalidade

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/

Share the Post:
Compartilhar no facebook
Compartilhar no twitter
Compartilhar no linkedin

Deixe um comentário

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Related Posts