[라이트 머신러닝] Session 14. LDA를 통한 지도학습방식 데이터 압축

선형 판별 분석(Linear Discriminant Analysis)은 규제가 없는 모델에서 오버피팅 정도를 줄이고 계산 효율정을 높이기 위해 사용되는 특성추출 기법입니다.

LDA의 개념은 PCA와 상당히 유사합니다. PCA가 데이터셋의 분산이 최대인 성분축을 찾는 것이 목표라면 LDA는 클래스를 최적으로 구분할 수 있는 특성 부분 공간을 찾는 것입니다.

1. 주성분 분석 vs 선형 판별 분석

PCA와 LDA 모두 데이터셋의 차원 개수를 줄이는 선형 변환 기법이지만 PCA는 비지도, LDA는 지도학습이라는 점에서 다릅니다. 여기서 여러분은 LDA가 클래스 구분을 위해 특성 부분 공간을 찾는 것이기 때문에 더 분류에 뛰어나다고 생각하실 수 있는데요, 사실은 그렇지는 않습니다.

마르티네스는 PCA를 통한 전처리가 특성 이미지 인식 작업에 더 뛰어난 분류 결과를 낸다고 보고하였습니다. 예를 들어 두 개의 클래스 레이블이 있다고 가정해볼까요?

위 그림에서 x 축, LD1에 투영되는 선형 판별 벡터는 두 가지 클래스를 잘 구분해줍니다. 하지만 y축, LD2로 투영되는 선형 판별 백터는 분산은 잡아내나 클래스 판별 정보가 없어 좋은 선형 판별 벡터는 아닙니다.

LDA는 데이터가 정규분포라고 가정합니다. 그리고 클래스는 동일한 공분산 행렬을 갖고 샘플은 서로 통계적으로 독립이라고 가정합니다. 하지만 이 가정들이 조금 위반된다고 하더라도 LDA는 차원축소를 잘 수행합니다.

2. 선형 판별 분석의 내부 동작 방식

PCA와 마찬가지로 LDA의 단계를 요약해보도록 하겠습니다.

1. d차원 데이터셋을 표준화 전처리합니다. (d = 특성개수)

2. 각 클래승 대해 d차원 평균 벡터를 계산합니다.

3. 클래스 간의 산포 행렬(scatter matrix) S(B)와 클래스 내부의 산포행렬 S(W)를 구성합니다.

4. S(W)의 역행렬과 S(B)의 곱행렬의 고유벡터와 고윳값을 계산합니다.

5. 고윳값을 내림차순으로 정렬해 순서를 매깁니다.

6. 고윳값이 가장 큰 k개의 고유벡터를 선택해 d * k 차원의 변환행렬 W를 구합니다.

7. 변환 행렬 W를 사용해 새로운 특성 부분 공간으로 투영합니다.

   이 과정이 굉장히 낯익죠? LDA는 행렬을 고윳값과 고유벡터로 분해해서 새로운 저처원 특성 공간을 구성한다는 점에서 매우 PCA와 비슷합니다. 물론 LDA는 2단계에서 평균 벡터를 만들 때 클래스 레이블 정보를 사용하고, 레이블 별로 데이터를 나누어 평균을 구한다는 점에서 다르지만요.

3. 산포 행렬 계산

이전 세션 PCA에서 1의 과정은 이미 해두었기 때문에, 평균 벡터 계산부터 해보도록 하겠습니다. 평균 벡터를 사용해 클래스 간 산포 행렬과 클래스 내부의 산포 행렬을 구성합니다. 평균 벡터 m은 클래스 i의 샘플에 대한 평균값 뮤를 저장합니다.

이렇게 하면 세 개의 편균 벡터가 만들어집니다. (Wine 데이터셋 기준, 클래스가 3개!)

np.set\_printoptions(precision=4)

mean\_vecs = \[\]  
for label in range(1, 4):  
[mean\_vecs.append(np.mean(X\_train\_std\[y\_train](mean_vecs.append(np.mean(X_train_std%5By_train) == label\], axis=0))  
print('MV %s: %s\\n' % (label, mean\_vecs\[label - 1\]))  

평균 벡터를 사용해서 클래스 내부 산포 행렬 S(W)를 계산할 수 있습니다.

여기에 개별 클래스 i의 산포행렬 S(i)를 계산할 수 있습니다.

d = 13 # 특성의 수  
S\_W = [np.zeros((d,](np.zeros((d,) d))  
for label, mv in zip(range(1, 4), mean\_vecs):  
class\_scatter = [np.zeros((d,](np.zeros((d,) d)) # scatter matrix for each class  
for row in X\_train\_std\[y\_train == label\]:  
row, mv = row.reshape(d, 1), mv.reshape(d, 1) # make column vectors  
class\_scatter += (row - mv).dot((row - mv).T)  
S\_W += class\_scatter # sum class scatter matrices

print('클래스 내의 산포 행렬: %sx%s' % ([S\_W.shape\[0\],](S_W.shape%5B0%5D,) [S\_W.shape\[1\]))](S_W.shape%5B1%5D)))  

산포 행렬을 계산할 때에는 훈련 세트의 클래스 레이블이 균등하게 분포되어 있다고 가정합니다. 하지만 클래스 레이블 개수를 출력하면 이 가정이 틀렸다는 것을 알 수 있습니다.

print('클래스 레이블 분포: %s'  
% np.bincount(y\_train)\[1:\])  

개별 산포 행렬을 전체에 더하기 전에 스케일을 조정해주어야 합니다. 산포 행렬을 클래스 샘플 개수로 나누면 산포 행렬을 계산하는 게 공분산 행렬을 계산하는 것과 같음을 알 수 있습니다. 즉, 공분산 행렬은 산포 행렬의 정규화 버전입니다!

d = 13 # 특성의 수  
S\_W = [np.zeros((d,](np.zeros((d,) d))  
for label, mv in zip(range(1, 4), mean\_vecs):  
class\_scatter = [np.cov(X\_train\_std\[y\_train](np.cov(X_train_std%5By_train) == label\].T, bias=True)  
S\_W += class\_scatter  
print('스케일 조정된 클래스 내의 산포 행렬: %sx%s' % ([S\_W.shape\[0\],](S_W.shape%5B0%5D,)  
[S\_W.shape\[1\]))](S_W.shape%5B1%5D)))  

클래스 내부의 산포 행렬을 계산한 다음, 다음 단계로 클래스 간의 산포행렬을 계산합니다. 여기서 m은 모든 클래스의 샘플을 포함해 계산한 전체 평균입니다.

mean\_overall = [np.mean(X\_train\_std,](np.mean(X_train_std,) axis=0)  
mean\_overall = mean\_overall.reshape(d, 1) # 열 벡터로 만들기  
d = 13 # 특성의 수  
S\_B = [np.zeros((d,](np.zeros((d,) d))  
for i, mean\_vec in enumerate(mean\_vecs):  
n = X\_train\[y\_train == i + 1, :\].shape\[0\]  
mean\_vec = mean\_vec.reshape(d, 1) # 열 벡터로 만들기  
S\_B += n \* (mean\_vec - mean\_overall).dot((mean\_vec - mean\_overall).T)

print('클래스 간의 산포 행렬: %sx%s' % ([S\_B.shape\[0\],](S_B.shape%5B0%5D,) [S\_B.shape\[1\]))](S_B.shape%5B1%5D)))  

4. 새로운 특성 부분 공간을 위해 선형 판별 벡터 선택

남은 단계는 PCA와 유사합니다. 이제 공분산 행렬의 고윳값을 분해하는 대신 행렬 S(W)의 역행렬과 S(B)의 곱행렬의 고윳값을 계산해주면 됩니다. 그리고 고윳값을 내림차순으로 정렬합니다.

eigen\_vals, eigen\_vecs = [np.linalg.eig(np.linalg.inv(S\_W).dot(S\_B))](np.linalg.eig(np.linalg.inv(S_W).dot(S_B)))

...

(고윳값, 고유벡터) 튜플의 리스트를 만듭니다.  
eigen\_pairs = \[([np.abs(eigen\_vals\[i\]),](np.abs(eigen_vals%5Bi%5D),) eigen\_vecs\[:, i\])  
for i in range(len(eigen\_vals))\]

# (고윳값, 고유벡터) 튜플을 큰 값에서 작은 값 순서대로 정렬합니다.

eigen\_pairs = sorted(eigen\_pairs, key=lambda k: k\[0\], reverse=True)

# 고윳값의 역순으로 올바르게 정렬되었는지 확인합니다.

print('내림차순의 고윳값:\\n')  
for eigen\_val in eigen\_pairs:  
print(eigen\_val\[0\])  

LDA에서 선형 판별 벡터는 최대 c-1개 입니다. c는 클래스 레이블 개수입니다.

이제 선형 판별 벡터로 찾은 클래스 판별 정보를 측정하기 위해 고윳값 내림차순으로 선형 판별 벡터를 그려보겠습니다.

tot = sum([eigen\_vals.real)](eigen_vals.real))  
discr = \[(i / tot) for i in sorted([eigen\_vals.real,](eigen_vals.real,) reverse=True)\]  
cum\_discr = [np.cumsum(discr)](np.cumsum(discr))

[plt.bar(range(1,](plt.bar(range(1,) 14), discr, alpha=0.5, align='center',  
label='individual "discriminability"')  
[plt.step(range(1,](plt.step(range(1,) 14), cum\_discr, where='mid',  
label='cumulative "discriminability"')  
[plt.ylabel('](plt.ylabel(')"discriminability" ratio')  
[plt.xlabel('Linear](plt.xlabel('Linear) Discriminants')  
[plt.ylim(\[-0.1,](plt.ylim(%5B-0.1,) 1.1\])  
[plt.legend(loc='best')](plt.legend(loc='best'))  
plt.tight\_layout()  
[plt.show()](plt.show())  

그래프에서 확인할 수 있듯 두 개의 선형 판별 벡터가 Wine 데이터 셋의 정보량의 100%를 담당합니다.

이제 두 개의 판별 벡터를 열로 만들어 변환 행렬 W로 만들어주면 됩니다.

w = [np.hstack((eigen\_pairs\[0\]\[1\]\[:,](np.hstack((eigen_pairs%5B0%5D%5B1%5D%5B:,) np.newaxis\].real,  
eigen\_pairs\[1\]\[1\]\[:, np.newaxis\].real))  
print('행렬 W:\\n', w)  

5. 새로운 특성 공간으로 투영

이제 변환 행렬 W를 훈련 세트에 곱해 데이터를 변환해줍니다.

X\_train\_lda = [X\_train\_std.dot(w)](X_train_std.dot(w))  
colors = \['r', 'b', 'g'\]  
markers = \['s', 'x', 'o'\]

for l, c, m in zip([np.unique(y\_train),](np.unique(y_train),) colors, markers):  
plt.scatter(X\_train\_lda\[y\_train == l, 0\],  
X\_train\_lda\[y\_train == l, 1\] \* (-1),  
c=c, label=l, marker=m)

[plt.xlabel('LD](plt.xlabel('LD) 1')  
[plt.ylabel('LD](plt.ylabel('LD) 2')  
[plt.legend(loc='lower](plt.legend(loc='lower) right')  
plt.tight\_layout()  
[plt.show()](plt.show())  

위 그림과 같이 세 개의 와인 클래스를 새로운 부분공간에 투영하였습니다. 이제 선형적으로 구분할 수 있습니다!

6. 사이킷런의 LDA

지금까지 단계별로 LDA를 구현해보았으니 이제 사이킷런으로 구현된 LDA 클래스를 보도록 하겠습니다.

from sklearn.discriminant\_analysis import LinearDiscriminantAnalysis as LDA

lda = LDA(n\_components=2)  
X\_train\_lda = lda.fit\_transform(X\_train\_std, y\_train)  
...

from sklearn.linear\_model import LogisticRegression  
lr = LogisticRegression(solver='liblinear', multi\_class='auto')  
lr = [lr.fit(X\_train\_lda,](lr.fit(X_train_lda,) y\_train)

plot\_decision\_regions(X\_train\_lda, y\_train, classifier=lr)  
[plt.xlabel('LD](plt.xlabel('LD) 1')  
[plt.ylabel('LD](plt.ylabel('LD) 2')  
[plt.legend(loc='lower](plt.legend(loc='lower) left')  
plt.tight\_layout()  
[plt.show()](plt.show())  

LDA로 변환한 저차원 훈련 데이터셋에 분류기를 동작시켰을 때, 클래스 2의 샘플 하나를 제대로 분류하지 못한 것을 확인할 수 있습니다. 이때 규제강도를 살짝 낮추어 모든 샘플을 분류하도록 할 수 있지만, 일단 테스트 세트의 결과를 볼까요?

X\_test\_lda = lda.transform(X\_test\_std)

plot\_decision\_regions(X\_test\_lda, y\_test, classifier=lr)  
[plt.xlabel('LD](plt.xlabel('LD) 1')  
[plt.ylabel('LD](plt.ylabel('LD) 2')  
[plt.legend(loc='lower](plt.legend(loc='lower) left')  
plt.tight\_layout()  
[plt.show()](plt.show())  

그래프에서 볼 수 있듯 분류기가 테스트 세트를 완벽하게 분류했습니다. 이 경우에는 굳이 과대적합의 위험을 올리면서까지 규제를 강화할 필요가 없습니다.

 

 마지막으로 정리를 한 번 해볼까요? LDA는 PCA와 상당히 유사합니다. 다만 LDA의 목적은 클래스 분리를 최대화하는 주축을 찾는 것이고, 지도학습이라 클래스 레이블이 있다는 점이죠. 등장한 산포행렬은 공분산 행렬의 정규화 전 단계이고, 선형 판별 벡터는 클레스 레이블의 개수 - 1보다 클 수 없습니다. PCA처럼 변환 행렬을 만들고 곱셈으로 데이터를 변환해주죠.

---

 여기까지 선형 판별 분석 LDA를 알아보았습니다. PCA와 정말 유사하죠? 안 보고 오신 분들은 이전 세션의 PCA를 꼭 확인하고 오시기를 추천드립니다. 다음 세션 15에서도 PCA와 연결된 커널 PCA를 다룰 예정이니, 13, 14, 15번은 함께 읽는 것을 추천드립니다. 다음 세션에서 봬요!