차원축소 - LDA, SVD, NMF

 

 

 

LDA(Linear Discriminant Analysis)¶

 

 

지도 학습의 분류에서 사용하기 쉽도록 개별 클래스를 분별할 수 있는 기준을 최대한 유지하면서 차원을 축소한다

특정 공간상에서 클래스 분리를 최대화하는 축을 찾기 위해 클래스 간 분산과 클래스 내부 분산의 비율을 최대화하는 방식으로 차원을 축소

 

 

붓꽃 데이터 세트에 LDA 적용하기¶

 

In [2]:

# 붓꽃 데이터 세트를 로드하고 표준 정규 분포로 스케일링

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris

iris = load_iris() # 데이터 불러오기
iris_scaled = StandardScaler().fit_transform(iris.data) # 데이터의 feature를 스케일링 진횅

 

 

2개의 컴포넌트로 붓꽃 데이터를 LDA 변환

클래스의 결정 값이 변환시 필요 -> 다음 LDA 객체의 fit()메서드를 호출할 때 결정값이 입력됐음에 유의(지도학습)

 

In [3]:

lda = LinearDiscriminantAnalysis(n_components = 2) # lda 객체 생성
lda.fit(iris_scaled, iris.target) # lda 학습(스케일링 데이터, 결정값(target))
iris_lda = lda.transform(iris_scaled)

print(iris_lda.shape)

 

 

(150, 2)

 

In [4]:

# LDA 변환된 입력 데이터 값을 2차원 평면에 품종별로 표현

import pandas as pd
import matplotlib.pyplot as plt

lda_columns = ['lda_component_1', 'lda_component_2']
iris_df_lda = pd.DataFrame(iris_lda, columns = lda_columns)
iris_df_lda['target'] = iris.target

# setosa는 세모, versicolor는 네모, virginica는 동그라미로 표현

markers = ['^', 's', 'o']

# setosa의 targat값은 0, versicolor는 1, virginica는 2
# 각 target별로 다른 모양으로 산점도로 표시

for i, marker in enumerate(markers):
    x_axis_data = iris_df_lda[iris_df_lda['target'] == i]['lda_component_1']
    y_axis_data = iris_df_lda[iris_df_lda['target'] == i]['lda_component_2']
    
    plt.scatter(x_axis_data, y_axis_data, marker = marker, label = iris.target_names[i])
    
plt.legend()
plt.xlabel('lda_component_1')
plt.ylabel('lda_component_2')

 

Out[4]:

Text(0, 0.5, 'lda_component_2')

 

 

 

SVD(Singular Value Decomposition)¶

 

 

행렬 분해 기법을 이용

정방행렬뿐 아니라 행과 열의 크기가 다른 행렬도 적용 가능

일반적인 SVD는 m X n 크기의 행렬 A를 다음과 같이 분해한다

$A = U \sum{V ^ T}$

SVD는 특이값 분해로 불리며 행렬 U, V에 속한 벡터는 특이 벡터, 모든 특이 벡터는 서로 직교

$\sum$은 대각행렬로 행렬의 대각에 위치한 값만 0이 아니고 나머지 위치의 값은 모두 0

=> A의 차원이 m X n일 때, U의 차원을 m X p, $\sum$의 차원을 p X p, $V^T$의 차원을 p X n으오 분해

 

In [6]:

# 넘파이의 SVD 모듈 임포트

import numpy as np
from numpy.linalg import svd

# 4X4 랜덤 행렬 a 생성
np.random.seed(121)
a = np.random.randn(4, 4)
print(np.round(a, 3))

 

 

[[-0.212 -0.285 -0.574 -0.44 ]
 [-0.33   1.184  1.615  0.367]
 [-0.014  0.63   1.71  -1.327]
 [ 0.402 -0.191  1.404 -1.969]]

 

 

생성된 a행렬에 SVD를 적용해 U, sigma, Vt를 도출

 

In [9]:

U, Sigma, Vt = svd(a)
print(U.shape, Sigma.shape, Vt.shape)
print('\nU matrix : \n', np.round(U, 3))
print('\nSigma matrix : \n', np.round(Sigma, 3)) # 대각에 위치한 값만 0이 아니고, 그렇지 않은 경우는 모두 0이므로 0이 아닌 값의 경우만 1차원 행렬로 표시
print('\nVt matrix : \n', np.round(Vt, 3))

 

 

(4, 4) (4,) (4, 4)

U matrix : 
 [[-0.079 -0.318  0.867  0.376]
 [ 0.383  0.787  0.12   0.469]
 [ 0.656  0.022  0.357 -0.664]
 [ 0.645 -0.529 -0.328  0.444]]

Sigma matrix : 
 [3.423 2.023 0.463 0.079]

Vt matrix : 
 [[ 0.041  0.224  0.786 -0.574]
 [-0.2    0.562  0.37   0.712]
 [-0.778  0.395 -0.333 -0.357]
 [-0.593 -0.692  0.366  0.189]]

 

In [14]:

# 분해된 U, Sigma, Vt를 다시 원본 행렬로 복원
# sigma의 경우 0이 아닌 값만 1차원으로 추출했으므로 다시 0을 포함한 대칭행렬로 변환한 뒤에 내적을 수행
# sigma를 다시 0으로 포함한 대칭행렬로 변환

Sigma_mat = np.diag(Sigma)
print(np.round(Sigma_mat, 3))

print()

a_ = np.dot(np.dot(U, Sigma_mat), Vt) # 내적
print(np.round(a_, 3))

 

 

[[3.423 0.    0.    0.   ]
 [0.    2.023 0.    0.   ]
 [0.    0.    0.463 0.   ]
 [0.    0.    0.    0.079]]

[[-0.212 -0.285 -0.574 -0.44 ]
 [-0.33   1.184  1.615  0.367]
 [-0.014  0.63   1.71  -1.327]
 [ 0.402 -0.191  1.404 -1.969]]

 

 

데이터 세트가 로우 간 의존성이 있을 경우 어떻게 sigma값이 변하고 이에 다른 차원 축소가 진행될 수 있는지 확인

 

In [15]:

a[2] = a[0] + a[1]
a[3] = a[0]
print(np.round(a, 3))

 

 

[[-0.212 -0.285 -0.574 -0.44 ]
 [-0.33   1.184  1.615  0.367]
 [-0.542  0.899  1.041 -0.073]
 [-0.212 -0.285 -0.574 -0.44 ]]

 

In [16]:

# 다시 SVD를 수행해 Sigma값 확인

U, Sigma, Vt = svd(a)
print(U.shape, Sigma.shape, Vt.shape)
print('\nSigma Value : \n', np.round(Sigma, 3))

 

 

 

(4, 4) (4,) (4, 4)

Sigma Value : 
 [2.663 0.807 0.    0.   ]

 

 

이번에는 U, Sigma, Vt의 전체 데이터를 이용하지 않고 Sigma의 0에 대응되는 U, Sigma, Vt의 데이터를 제외하고 복원

-> Sigma의 경우 앞의 2개 요소만 0이 아니므로 U 행렬 중 선행 두 개의 열만 추출하고 Vt의 경우는 선행 두 개의 행말 추출해 복원

 

In [18]:

# U의 행렬의 경우 Sigma와 내적을 수행하므로 Sigma의 앞 2행에 대응되는 앞 2열만 추출

U_ = U[:, :2]
Sigma_ = np.diag(Sigma[:2])

# V 전치 행렬의 경우는 앞 2행만 추출
Vt_ = Vt[:2]
print(U_.shape, Sigma_.shape, Vt_.shape)

print()

# U, Sigma, Vt의 내적을 수행하며, 다시 원본 행렬 복원
a_ = np.dot(np.dot(U_, Sigma_), Vt_)
print(np.round(a_, 3))

 

 

(4, 2) (2, 2) (2, 4)

[[-0.212 -0.285 -0.574 -0.44 ]
 [-0.33   1.184  1.615  0.367]
 [-0.542  0.899  1.041 -0.073]
 [-0.212 -0.285 -0.574 -0.44 ]]

 

 

Truncated SVD를 이용해 행렬을 분해

$\sum$ 행렬에 있는 대각 원소, 즉 특이값 중 상위 일부 데이터만 추출해 분해

 

In [21]:

import numpy as np
from scipy.sparse.linalg import svds
from scipy.linalg import svd

# 원본 행렬을 출력하고 SVD를 적용할 경우 U, Sigma, Vt의 차원 확인
np.random.seed(121)
matrix = np.random.random((6, 6))
print('원본 행렬 : \n', matrix)
U, Sigma, Vt = svd(matrix, full_matrices = False)
print('\n 분해 행렬 차원 : ', U.shape, Sigma.shape, Vt.shape)


# Truncated SVD로 Sigma 행렬의 특이값을 4개로 하여 Truncated SVD 수행
num_components = 4
U_tr, Sigma_tr, Vt_tr = svds(matrix, k = num_components)
print('\nTruncated SVD 분해 행렬 차원 : ', U_tr.shape, Sigma_tr.shape, Vt_tr.shape)
print('\nTruncated SVD Sigma 값 행렬 : ', Sigma_tr)
matrix_tr = np.dot(np.dot(U_tr, np.diag(Sigma_tr)), Vt_tr) # output of TruncatedSVD

print('\nTruncated SVD로 분해 후 복원 행렬 : \n', matrix_tr)

 

 

원본 행렬 : 
 [[0.11133083 0.21076757 0.23296249 0.15194456 0.83017814 0.40791941]
 [0.5557906  0.74552394 0.24849976 0.9686594  0.95268418 0.48984885]
 [0.01829731 0.85760612 0.40493829 0.62247394 0.29537149 0.92958852]
 [0.4056155  0.56730065 0.24575605 0.22573721 0.03827786 0.58098021]
 [0.82925331 0.77326256 0.94693849 0.73632338 0.67328275 0.74517176]
 [0.51161442 0.46920965 0.6439515  0.82081228 0.14548493 0.01806415]]

 분해 행렬 차원 :  (6, 6) (6,) (6, 6)

Truncated SVD 분해 행렬 차원 :  (6, 4) (4,) (4, 6)

Truncated SVD Sigma 값 행렬 :  [0.55463089 0.83865238 0.88116505 3.2535007 ]

Truncated SVD로 분해 후 복원 행렬 : 
 [[0.19222941 0.21792946 0.15951023 0.14084013 0.81641405 0.42533093]
 [0.44874275 0.72204422 0.34594106 0.99148577 0.96866325 0.4754868 ]
 [0.12656662 0.88860729 0.30625735 0.59517439 0.28036734 0.93961948]
 [0.23989012 0.51026588 0.39697353 0.27308905 0.05971563 0.57156395]
 [0.83806144 0.78847467 0.93868685 0.72673231 0.6740867  0.73812389]
 [0.59726589 0.47953891 0.56613544 0.80746028 0.13135039 0.03479656]]

 

 

=> Truncated SVD로 분해된 행렬로 다시 복원할 경우 완벽하게 복원되지 않고 근사적으로 복원됨

 

 

사이킷런 TruncatedSVD 클래스를 이용한 변환¶

 

 

fit(), transform()을 호출해 원본 데이터를 몇 개의 주요 컴포넌트(Truncated SVD의 K컴포넌트 수)로 차원을 축소해 변환

 

In [22]:

from sklearn.decomposition import TruncatedSVD, PCA
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

iris = load_iris()
iris_ftrs = iris.data
# 2개의 주요 컴포넌트로 TruncatedSVD변환
tsvd = TruncatedSVD(n_components = 2)
tsvd.fit(iris_ftrs)
iris_tsvd = tsvd.transform(iris_ftrs)

# 산점도 2차원으로 TruncatedSVD 변환된 데이터 표현, 품종을 색깔로 구분
plt.scatter(x = iris_tsvd[:, 0], y = iris_tsvd[:, 1], c = iris.target)
plt.xlabel('TruncatedSVD Component1')
plt.ylabel('TruncatedSVD Component2')

 

Out[22]:

Text(0, 0.5, 'TruncatedSVD Component2')

 

 

 

붓꽃 데이터를 스케일링으로 변환한 뒤에 TruncatedSVD 실행

 

In [24]:

from sklearn.preprocessing import StandardScaler

# 붓꽃 데이터를 StandardScaler로 변환
scaler = StandardScaler()
iris_scaled = scaler.fit_transform(iris_ftrs) # iris_ftrs : iris데이터의 feature

# 스케일링된 데이터를 기반으로 TruncatedSVD 변환 수행
tsvd = TruncatedSVD(n_components = 2)
tsvd.fit(iris_scaled)
iris_tsvd = tsvd.transform(iris_scaled)

# 스케일링된 데이터를 기반으로 PCA 변환 수행
pca = PCA(n_components = 2)
pca.fit(iris_scaled)
iris_pca = pca.transform(iris_scaled)

# TruncatedSVd 변환 데이터를 왼족에 PCA 변환 데이터를 오른쪽에 표현
fig, (ax1, ax2) = plt.subplots(figsize = (9, 4), ncols = 2)
ax1.scatter(x = iris_tsvd[:, 0], y = iris_tsvd[:, 1], c = iris.target)
ax2.scatter(x = iris_pca[:, 0], y = iris_pca[:, 1], c = iris.target)
ax1.set_title('Truncated SVD Transformed')
ax2.set_title('PCA Transformed')

 

Out[24]:

Text(0.5, 1.0, 'PCA Transformed')

 

 

 

두 개의 변환 행렬 값과 원본 속성별 컴포넌트 비율값을 실제로 서로 비교해 보면 거의 같음을 알 수 있다

 

In [25]:

print((iris_pca - iris_tsvd).mean())
print((pca.components_ - tsvd.components_).mean())

 

 

2.3422698965565777e-15
3.903127820947816e-18

 

 

NMF(Non - Negative Matrix Factorization)¶

 

 

Truncated SVD와 같이 낮은 랭크를 통한 행랼 근사 방식의 변형

원본 행렬 내의 모든 원소 값이 모두 양수라는 게 보장된다면 다음과 같이 좀 더 간단하게 두 개의 기반 양수 행렬로 분해될 수 있는 기법을 지칭(V ~ W X H (~ : 근삿값))

 

 

붓꽃 데이터를 NMF를 이용해 2개의 컴포넌트로 변환하고 이를 시각화 하기

 

In [30]:

from sklearn.decomposition import NMF
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

iris = load_iris()
iris_ftrs = iris.data
nmf = NMF(n_components = 2)
nmf.fit(iris_ftrs)
iris_nmf = nmf.transform(iris_ftrs)

print(iris_nmf[:5])

plt.scatter(x = iris_nmf[:, 0], y = iris_nmf[:, 1], c = iris.target)
plt.xlabel('NMF Component1')
plt.ylabel('NMF Component2')

 

 

[[0.41349967 0.10467301]
 [0.36544877 0.14097835]
 [0.37779974 0.10188458]
 [0.34998054 0.14896392]
 [0.41589583 0.0953063 ]]

Out[30]:

Text(0, 0.5, 'NMF Component2')