Posts MNIST로 해보는 PCA와 kNN
Post
Cancel

MNIST로 해보는 PCA와 kNN

1. MNIST


1.1 MNIST란

  • NIST는 미국 국립표준기술연구소(National Institute of Standards and Technology)의 약자입니다. 여기서 진행한 미션 중에 손글씨 데이터를 모았는데, 그중 숫자로 된 데이터를 MNIST라고 합니다.
  • 28 * 28 픽셀의 0 ~ 9 사이의 숫자 이미지와 레이블로 구성된 데이터 셋
  • 머신러닝 공부하는 사람들이 입문용으로 사용을 많이함
  • 60000개의 훈련용 셋과 10000개의 실험용 셋트로 구성되어있음
  • 데이터는 kaggle에 있습니다. https://www.kaggle.com/oddrationale/mnist-in-csv


2. PCA와 kNN 실습해보기


2.1 데이터 로드

1
2
3
4
5
6
import pandas as pd

df_train = pd.read_csv('https://media.githubusercontent.com/media/hmkim312/datas/main/mnist/mnist_train.csv')
df_test = pd.read_csv('https://media.githubusercontent.com/media/hmkim312/datas/main/mnist/mnist_test.csv')

df_train.shape, df_test.shape
1
((60000, 785), (10000, 785))


2.2 train 데이터의 모양

1
df_train.head()
label1x11x21x31x41x51x61x71x81x9...28x1928x2028x2128x2228x2328x2428x2528x2628x2728x28
05000000000...0000000000
10000000000...0000000000
24000000000...0000000000
31000000000...0000000000
49000000000...0000000000

5 rows × 785 columns


2.3 test 데이터의 모양

1
df_test.head()
label1x11x21x31x41x51x61x71x81x9...28x1928x2028x2128x2228x2328x2428x2528x2628x2728x28
07000000000...0000000000
12000000000...0000000000
21000000000...0000000000
30000000000...0000000000
44000000000...0000000000

5 rows × 785 columns


2.4 데이터 정리

1
2
3
4
5
6
7
8
9
import numpy as np

X_train = np.array(df_train.iloc[:, 1:])
y_train = np.array(df_train['label'])

X_test = np.array(df_test.iloc[:,1:])
y_test = np.array(df_test['label'])

X_train.shape, y_train.shape, X_test.shape, y_test.shape
1
((60000, 784), (60000,), (10000, 784), (10000,))
  • X_train, y_train, X_test, y_test로 데이터를 정리
  • label이 y값임


2.5 랜덤하게 16개를 뽑아서 생김새 보기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import random
import matplotlib.pyplot as plt

samples = random.choices(population=range(0, 60000), k=16)

plt.figure(figsize=(14, 12))

for idx, n in enumerate(samples):
    plt.subplot(4, 4, idx + 1)
    plt.imshow(X_train[n].reshape(28, 28),
               cmap='Greys', interpolation='nearest')
    plt.title(y_train[n])

plt.show()

  • 사람들이 손으로 쓴 글씨로, 헷갈리게 생긴 글씨도 있긴하다


2.6 kNN으로 학습하기

1
2
3
4
5
6
7
from sklearn.neighbors import KNeighborsClassifier
import time

start_time = time.time()
clf = KNeighborsClassifier(n_neighbors= 5)
clf.fit(X_train, y_train)
print('Fit time : ', time.time() - start_time)
1
Fit time :  12.099517345428467
  • kNN은 따로 학습을 하는 모델은 아니기에 시간이 오래걸리진 않는다


2.7 kNN 성능 확인

1
2
3
4
5
6
from sklearn.metrics import accuracy_score

start_time = time.time()
pred = clf.predict(X_test)
print('Fit time : ', time.time() - start_time)
print(accuracy_score(y_test, pred))
1
2
Fit time :  663.8233301639557
0.9688
  • 학습 시간이 너무 오래걸린다


2.8 kNN의 단점 - 차원의 저주

  • kNN에서 중요한 것은 차원의 저주(Curse of Dimensionality) 이다.
  • kNN은 차원이 증가하면 feature(머신러닝, 딥러닝에서 input 변수)가 많아지면 학습 데이터의 수가 차원의 수보다 적어져 성능이 저하되는 현상이 생긴다.
  • 위의 말은 차원이 증가할수록 개별 차원 내 학습할 데이터 수가 적어지는 현상이 발생하게 되는 이야기이다.
  • 이는 공간에 채울 데이터가 많이 필요하고 거리를 계산하는 kNN 알고리즘 특성 상, 거리가 멀어지며 ‘근접’ 이라는 개념이 옅어지게 된다.
  • 또한 데이터의 차원이 증가하게 되면 데이터의 거리는 (유클리드거리를 사용한다면) 기하급수적으로 늘어나게 된되며 이는 데이터의 부피가 커진다라는 표현을 사용하기도 한다.
  • 차원을 축소시키거나 데이터를 많이 획득하는 방식으로 해결


2.9 차원의 저주를 해결하기 위해 PCA로 차원을 줄여줌

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from sklearn.pipeline import Pipeline
from sklearn.decomposition import PCA
from sklearn.model_selection import GridSearchCV, StratifiedKFold

pipe = Pipeline([
    ('pca', PCA()),
    ('clf', KNeighborsClassifier()),
])

parameters = {
    'pca__n_components' : [2, 5, 10],
    'clf__n_neighbors' : [5, 10, 15]
}

kf = StratifiedKFold(n_splits=5, shuffle= True, random_state= 13)
grid = GridSearchCV(pipe, parameters, cv = kf, n_jobs= -1, verbose=1)
grid.fit(X_train, y_train)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Fitting 5 folds for each of 9 candidates, totalling 45 fits


[Parallel(n_jobs=-1)]: Using backend LokyBackend with 16 concurrent workers.
[Parallel(n_jobs=-1)]: Done  45 out of  45 | elapsed:   34.6s finished





GridSearchCV(cv=StratifiedKFold(n_splits=5, random_state=13, shuffle=True),
             estimator=Pipeline(steps=[('pca', PCA()),
                                       ('clf', KNeighborsClassifier())]),
             n_jobs=-1,
             param_grid={'clf__n_neighbors': [5, 10, 15],
                         'pca__n_components': [2, 5, 10]},
             verbose=1)


2.10 best score

1
2
3
4
5
print('Best scroe : %0.3f' %grid.best_score_)
print('Best parameters set:')
best_parameters = grid.best_estimator_.get_params()
for param_name in sorted(parameters.keys()):
    print('\t%s: %r'%(param_name, best_parameters[param_name]))
1
2
3
4
Best scroe : 0.931
Best parameters set:
	clf__n_neighbors: 10
	pca__n_components: 10


2.11 pca를 하여 차원 축소를 한 Accuracy

1
accuracy_score(y_test, grid.best_estimator_.predict(X_test))
1
0.9286
  • 약 0.928의 Accuracy를 가진다.
  • 학습 시간도 얼마 걸리지 않았음


2.12 Confusion_matrix로 결과 확인

1
2
3
4
5
def results(y_pred, y_test):
    from sklearn.metrics import classification_report, confusion_matrix
    print(classification_report(y_test, y_pred))
    
results(grid.predict(X_train), y_train)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
              precision    recall  f1-score   support

           0       0.96      0.98      0.97      5923
           1       0.98      0.99      0.98      6742
           2       0.96      0.96      0.96      5958
           3       0.94      0.90      0.92      6131
           4       0.94      0.93      0.93      5842
           5       0.93      0.94      0.93      5421
           6       0.96      0.98      0.97      5918
           7       0.96      0.95      0.96      6265
           8       0.92      0.91      0.91      5851
           9       0.90      0.91      0.90      5949

    accuracy                           0.94     60000
   macro avg       0.94      0.94      0.94     60000
weighted avg       0.94      0.94      0.94     60000
  • 골고루 잘 맞추고 있는것을 확인 가능


2.13 숫자 확인

1
2
3
4
5
6
7
n = 700
plt.grid(False)
plt.imshow(X_test[n].reshape(28,28), cmap ='Greys',interpolation='nearest')
plt.show()

print('Answer is: ', grid.best_estimator_.predict(X_test[n].reshape(1,784)))
print('Real Label is :', y_test[n])

1
2
Answer is:  [1]
Real Label is : 1


2.14 틀린 데이터 확인을 위한 전처리

1
2
preds = grid.best_estimator_.predict(X_test)
preds
1
array([7, 2, 1, ..., 4, 5, 6])
1
y_test
1
array([7, 2, 1, ..., 4, 5, 6])


2.15 틀린 데이터 그림으로 확인

1
2
3
4
5
6
7
8
9
10
11
12
13
wrong_results = X_test[y_test != preds]
samples = random.choices(population=range(0, wrong_results.shape[0]), k=16)

plt.figure(figsize=(14, 12))

for idx, n in enumerate(samples):
    plt.grid(False)
    plt.subplot(4, 4, idx + 1)
    plt.imshow(wrong_results[n].reshape(28, 28),
               cmap='Greys', interpolation='nearest')
    plt.title(grid.best_estimator_.predict(wrong_results[n].reshape(1,784))[0])
    
plt.show()

  • 그림의 타이틀은 잘못 예측한 값이다.
  • 헷갈릴만한 숫자들이 생각보다 있다.
This post is licensed under CC BY 4.0 by the author.

HAR로 해보는 PCA

강아지와 고양이 분류기 on PCA

Comments powered by Disqus.