어른이 프로그래머

앙상블(Ensemble) 및 랜덤 포레스트(Random Forest) 실습 - MNIST 손글씨 분류

어른이프로그래머 — Fri, 18 Feb 2022 16:00:22 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다

이번 포스트에서는 MNIST 손글씨 데이터셋을 랜덤 포레스트 모델로 학습해보고, 동시에 의사결정 트리 모델을 학습하여 두 모델의 성능 차이를 시각화하여 비교해 보겠습니다. 추가로 이때까지 배운 kNN, SVM, Decision Tree 모델들을 앙상블 하여 보팅 하는 어그리게이팅 과정을 거쳐 더 좋은 예측 모델을 생성해보는 실습까지 진행해보겠습니다. 먼저 이전 포스트에서 살펴봤으나 다시 한번 랜덤 포레스트 모델에 대해 한 줄로 요약하자면 앙상블 기법을 사용하여 여러 의사결정 트리를 배깅하여 예측하는 모델입니다. 하나의 의사결정 트리로 데이터를 학습했을 시에는 과적합의 위험성이 매우 높으며 따라서 이를 보완한 랜덤 포레스트 모델이 학습 시 더 높은 정확도를 보일 것임을 예측하며 다음의 실습 과정을 보겠습니다.

MNIST는 숫자 0에서부터 9까지를 손글씨로 작성한 고정 이미지 크기의 데이터 셋으로, 총 60,000개의 학습 및 검증 데이터와 10,000개의 테스트 데이터로 이루어져있습니다. 하나의 이미지는 28x28의 고정된 크기로 2차원 배열에서 해당 픽셀에 손글씨가 있으면 0이 아닌 가중치를 부여하는 방식으로 2차원 행렬을 쭉 펴서 784(28x28) 개의 열을 가진 1차원 행렬로 변형되어 저장되어 있습니다. 따라서 mnist.train.image의 형태를 확인해보면 shape=[55000,784] 임을 확인할 수 있습니다. 하지만 이번 실습에서 사용할 MNIST 데이터셋은 실제 예측이 아닌 정확도 시각화 및 비교에 중점을 두고 있기 때문에 28x28이 아닌 8x8 형태의 1797개, 약 1800개의 데이터셋을 가진 load_digits()를 로딩하여 사용하겠습니다. 원래의 MNIST 데이터셋 전체를 로딩하고 싶다면 아래의 코드를 사용하셔도 무방합니다.

from sklearn.datasets import fetch_openml

mnist = fetch_openml('mnist_784')
mnist.data.shape, mnist.target.shape # (70000, 784)

그렇다면 이번 실습에 사용할 MNIST 데이터 셋의 데이터 형태와 첫 번째 이미지 및 레이블을 직접 확인해보겠습니다. 첫 번째 이미지를 보면 다소 흐릿하지만 0임을 확인할 수 있으며 레이블 또한 0입니다. 이보다 중요한 점은 digit를 digit_img로 reshape 하는 과정인데, 원래의 MNIST 데이터셋에서는 이미지를 확인하기 위해 1차원으로 펴진 데이터를 2차원으로 표현하기 위해 reshape(28, 28)로 작성해야 하지만, 이번 MNIST 데이터셋의 이미지는 8x8로, 64개의 열을 가진 1차원 데이터로 펴져있기 때문에 복원할 때는 reshape(8, 8)로 작성해야 합니다. 바로 이러한 점을 확인하기 위해 바로 위에서 데이터 형태를 확인했으며, features shape: (1797, 64)에서 8x8의 이미지 크기임을 눈치채는 것이 앞으로의 코드 작성에 도움 될 것입니다.

이제 두 모델을 학습한 다음 이를 교차 검증할 함수를 만들겠습니다. 교차 검증 함수인 cross_validation()에서는 10회의 교차 검증을 통해(cv=10), 모델의 정확도를 측정한 평균값을 반환합니다. Decision Tree와 Random Forest 모델은 사이킷런에 구현되어 있으므로 별도의 하이퍼파라미터를 설정하지 않고 모델을 학습하여 교차 검증을 진행하겠습니다. 별도의 하이퍼파라미터를 설정하지 않은 이유는 Decision Tree의 과적합을 놔둔 채, 이를 보완하여 나온 Random Forest 모델과의 정확도 차이를 더욱 확연하게 보기 위함입니다.

이제 측정된 두 모델의 정확도를 판다스 형태로 시각화하겠습니다. cross_validation()에서 반환된 리스트를 담은 cv_list를 딕셔너리로 저장해 판다스의 데이터 프레임 형태로 만들어준 다음 plot()을 통해 그려보면 아래의 그래프를 볼 수 있습니다. 시각화하여 그래프를 그려보니, 두 모델의 확연한 성능 차이를 확인할 수 있습니다. 검증 횟수에 상관없이 모든 검증에서 Random Forest 모델이 Decision Tree 모델에 비해 정확도가 높았으며, Decision Tree 모델의 정확도가 다소 낮은 이유는 처음에 언급했듯 과적합이 원인임을 짐작해볼 수 있습니다. 실제로 정확도를 보면 Decision Tree는 0.822... 인 반면 Random Forest 모델은 0.948... 의 높은 정확도를 보이고 있습니다.

그렇다면 바로 다음으로 넘어가 보팅 앙상블 기법을 사용한 MNIST 손글씨 분류 실습을 해보겠습니다. MNIST 데이터셋은 위에서 이미 로딩해두었으므로 이번에는 앙상블 할 모델들(kNN, SVM, Decision Tree)을 임포트한 다음 이번에는 MNIST 데이터를 학습 데이터와 테스트 데이터로 분리하겠습니다. 이번 실습에서 살펴볼 점은 단일로 학습된 모델에 비해 앙상블한 모델의 예측 정확도가 더 향상되었는지를 살펴보는 것이 우선이므로, 먼저 단일 모델의 정확도를 측정해보겠습니다. 대신 이번에는 의사결정 트리를 학습 시 max_depth, max_features 등의 하이퍼파라미터를 설정해 과적합을 방지하고자 했으며, 모델들을 학습하고 예측하는 과정은 model.fit()과 model.predict()로 쉽게 구현할 수 있습니다.

단일 모델들의 정확도를 측정해보니 Decision Tree, kNN, SVM 모델 모두 0.8-0.9 사이의, 그렇게 높지는 않은 정확도임을 확인했습니다. 분명 이전 실습들에서 단일 모델들의 정확도는 낮지 않았는데, 이번 테스트에서 정확도가 낮게 나온 이유는 무엇이 있을까요? 먼저 1800개의 데이터를 또다시 학습 데이터와 테스트 데이터로 나누어 학습했으므로 학습 데이터가 충분하지 않았음이 하나의 이유로 예상되며 또한 학습 데이터의 특징에 따라 모델별 하이퍼파라미터를 조정해가며 다르게 설정하지 않고 보다 일반적인 하이퍼파라미터를 설정했는 것 또한 다른 이유일 수 있습니다. 하지만 이번 실습에서는 이 모델들을 앙상블 하여 보팅한 모델의 정확도를 보는 것이 중요하므로, 이러한 한계점은 인정하고 넘어가겠습니다. 앙상블한 모델에서 예측할때는 보팅 기법(어그리게이팅)을 사용합니다. 보팅은 소프트 보팅과 하드 보팅으로 나뉘며 사이킷런에서 voting classifier를 사용해 쉽게 구현할 수 있습니다. 만약 소프트 보팅을 직접 구현하고자 한다면, model.predict_proba()를 통해 가장 높은 분류값별 확률을 확인하여 구현할 수 있습니다. 실제로 SVM 모델의 첫 번째(label: 0)와 두 번째(label: 1) 데이터에 대한 분류값별 확률을 predcit_proba()를 통해 확인해보면 첫 번째 리스트에서는 0에 해당하는 9.99149483e-01이 최댓값으로 예측되었으나 두 번째 리스트에서는 9에 해당하는 3.29956631e-01이 최댓값으로 예측되었습니다. 이제 하드 보팅과 소프트 보팅을 직접 구현하여 정확도를 측정해보겠습니다. estimators에 학습된 세 모델을 입력한 다음 voting에 'hard'와 'soft'를 입력하면, 세 모델을 앙상블하여 voting 파라미터에 입력된 보팅 방식으로 학습된 모델을 얻을 수 있습니다. 사실 하드 보팅에 대해서도 만장일치일 때만 결정하는 Unanimous voting 기법과 다수결로 선택된 예측값이 전체의 50%를 넘어야 하는 Majority voting, 각각의 softmax에 대해 argmax 하여 다수결을 따르는 Plurality voting 기법 등이 있지만 voting='hard'로 설정하면 다수결의 원칙에 따라서만 decision 합니다. 하드 보팅과 소프트 보팅으로 구현한 모델의 정확도를 확인해보니 각각 0.933과 0.9로, 단일 모델들을 학습했을 때 보다 정확도가 확연히 높아졌음을 알 수 있습니다. 둘의 정확도를 더욱 시각화하여 보이기 위해 히스토그램 그래프로 표현하면 아래와 같은 결과를 얻을 수 있습니다.

하드 보팅의 정확도가 가장 높았으며 다음으로 소프트 보팅과 SVM, kNN 순으로 정확도가 높으며 Decision Tree의 정확도가 0.8로 가장 낮습니다.

이번 포스트에서는 축소화된 MNIST 데이터셋을 이용해 랜덤 포레스트 모델과 의사결정 트리의 정확도 차이를 확인했으며 kNN, SVM, Decision Tree 모델들을 단일로 학습했을 때와 이들을 보팅 앙상블 해 학습했을 때의 정확도 차이를 확인해봤습니다. 이로서 지도학습 머신러닝 분류 알고리즘에 대해 전반적으로 모두 살펴봤습니다. 다음 포스트부터는 비지도학습 중 하나인 군집화 알고리즘, k 평균 알고리즘에 대해 알아보겠습니다.

앙상블(Ensemble)과 랜덤 포레스트(Random Forest)

어른이프로그래머 — Fri, 11 Feb 2022 01:30:59 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다

이번 포스트에서는 앙상블 기법과 대표적인 앙상블 알고리즘인 랜덤 포레스트(Random Forest) 모델에 대해 알아보겠습니다.

"백지장도 맞들면 낫다"

백지장도 맞들면 낫다, 작은 힘이라도 모이면 큰 힘이 될 수 있다는 의미입니다. 이는 앙상블 기법을 그대로 표현해주는 속담으로, 앙상블 기법은 여러 분류 모델을 조합하여 더 좋은 성능을 내는 기법입니다. 조금 더 자세히 보자면 앙상블 기법은 여러 학습 알고리즘을 사용하여 구성 학습 알고리즘만으로 얻을 수 있는 것보다 더 나은 예측 성능을 얻을 수 있는 기법이지만 단일 모델에 비해 더 많은 계산이 필요합니다. 앙상블 기법은 실제 kaggle competition에서도 항상 상위에 랭크되어 있어 "The 10 main take aways fro ML conf SF"에서는 "Ensemble almost always work better"으로 소개되기도 했습니다. 백지장도 맞들면 낫다, 집단 지성, 관련된 단어들만 떠올려도 앙상블 기법에 대해서 간단히 이해할 수 있을 것입니다. 그렇다면 앙상블 기법의 유형에는 어떤 것이 있는지, 그리고 대표적인 앙상블 기법 중 하나인 랜덤 포레스트 알고리즘에 대해서 알아보겠습니다.

- 배깅(Bagging, B+agging)

배깅은 여러 명의 사람이 분야를 나누어 퀴즈를 품으로써 한 명의 사람이 퀴즈를 푸는 것보다 더 좋은 결과를 얻을 수 있는 방법입니다. 다양한 분야가 출제되는 퀴즈를 풀 때는 한 명의 사람이 전문 분야에 대해서는 정답을 맞힐지 몰라도, 전혀 모르는 분야에 대해서는 정답을 맞히지 못할 것입니다. 이를 머신러닝에 빗대어 보면 한 명의 사람이 퀴즈를 푸는 것이 과대적합 되어 있는 상태로 볼 수 있는데, 이처럼 배깅은 과대적합이 쉬운 모델에 상당히 적합한 앙상블입니다. 과대적합이 쉬운 모델을 생각하면 의사결정 트리(Decision Tree) 알고리즘이 가장 먼저 떠올릴 수 있으며, 실제로 앙상블 기법은 의사결정 알고리즘에서 많이 사용됩니다. 그렇다면 배깅의 원리를 살펴보겠습니다.

배깅은 한 가지 분류 모델을 여러 개 만들어 서로 다른 학습 데이터로 학습시킨 다음(부트스트랩, bootstrap), 동일한 테스트 데이터에 서로 다른 예측 값들을 투표를 통해 가장 높은 예측 값으로 최종 결론(어그리게이팅, aggregating)을 내리는 과정을 거칩니다. 그럼 바로 부트스트랩과 어그리게이팅에 대해 알아보겠습니다.

- 부트스트랩(Bootstrap)

부트스트랩은 데이터를 조금 편향되도록 샘플링하는 기법입니다. 부트스트랩을 사용하면 개별 분류기들에 전체 데이터를 학습하는 것이 아닌, 보통 중복을 허용해 70-80% 만의 데이터를 추출하여 학습해 학습 시 데이터의 편향을 높입니다. 부트스트랩을 왜 사용하는지를 이해하기 위해서는 먼저 편향-분산 트레이드 오프(bias-variance trade off)에 대해 이해해야 합니다. 이해를 위해 오차를 구하는 식을 변형한 아래의 식을 보겠습니다. 오차는 타깃에 대한 분산(줄일 수 없는 오차)에 분산과 편향을 더한 값입니다. 식을 보면 분산과 편향이 의미하는 바를 조금 더 이해할 수 있는데, 분산은 예측값들이 서로 얼마나 가까운지를, 편향은 예측값들이 실제값과 얼마나 차이 나는지를 나타냅니다. 이를 과대적합된 모델에 적용하면 과대적합된 모델은 학습 데이터에 대해 예측값과 실제값의 차이가 적어 편향이 적지만, 동시에 모델 복잡도가 높아지므로 편향-분산 트레이드 오프 법칙에 의해 분산이 높습니다. 즉 학습 시에는 정확도가 높게 나오지만, 학습에 사용된 적 없던 데이터의 분류에 대해서는 정확도가 낮게 나옵니다.

오차 공식 변형식과 편향-분산 트레이드 오프

보통 특정 하이퍼파라미터를 설정하지 않은 채 학습한 의사결정 트리는 과대적합된 모델이며 이때 부트스트랩을 사용하여 데이터 샘플링 시 학습 데이터의 편향을 높여 모델 복잡도를 줄이고 과대적합 위험을 줄일 수 있습니다. 위의 그래프에서 파란색 선의 편향(bias)이 높아지면 모델 복잡도가 줄어들며 빨간색 선의 분산(variance)과 만나는 점이 이전에 비해 왼쪽에 만나 오차를 줄일 수 있습니다. 이 연관 관계를 확실히 이해하면 부트스트랩을 사용하는 이유와 부트스트랩을 어떻게 사용하는 것이 효율적일 수 있을지에 대해 이해하는 것은 더욱 쉽습니다.

전체 학습 데이터가 1 ~ 9의 정수로 이루어졌다고 해보겠습니다. 학습 데이터를 train = [1, 2, 3, 4, 5, 6, 7, 8, 9]로 두고서 의사결정 트리 6개를 배깅할 경우 부트스트랩을 사용하면, 전체 9개의 학습 데이터를 총 6개의 데이터로 중복을 허용한 채 나누어 담습니다(샘플링). 위에서 이미 언급했듯이 데이터를 샘플링할 때는 전체 학습 데이터를 모두 사용하지 않고 샘플링 크기를 60 - 70%를 사용하며 중복을 허용하기 때문에 학습 데이터의 편향은 자연스럽게 높아질 것입니다. 예를 들어 총 6개의 의사결정 트리에 대한 학습 데이터를 [1, 2, 3, 4, 5, 1], [2, 3, 4, 5, 6, 2], [3, 4, 5, 6, 7, 3], [4, 5, 6, 7, 8, 4], [5, 6, 7, 8, 9, 5], [6, 7, 8, 9, 1, 6]과 같은 식으로 샘플링하면 각 분류기는 같은 의사결정 트리 모델일지라도 테스트 시에는 다른 결과를 낼 수도 있습니다.

- 어그리게이팅(Aggregating)

어그리게이팅은 여러 분류 모델이 예측한 값들을 조합하여 하나의 결론을 도출하는 과정입니다. 결론을 도출하는 과정은 투표로 이루어지며, 투표(voting)는 하드 보팅(hard voting)과 소프트 보팅(soft voting)으로 나뉩니다.

먼저 하드 보팅입니다. 하드 보팅은 학교 투표 방법과 같습니다. 학교 투표는 학급 내 모든 인원에게 동일하게 한 표씩 주어집니다. 하드 보팅도 각 분류기에서 최고의 확률을 갖는 분류 값만을 어그리게이팅하여 리턴하는 방식이며 바로 위의 예시에서 MNIST 데이터셋의 첫 번째 데이터(0)에 대해 6개의 의사 결정 트리가 [9, 6, 0, 0, 0, 0]과 같이 분류했다면 하드보팅 어그리게이팅은 최다 득표를 받은 0으로 예측합니다. 크게 어렵지 않습니다. 다음은 소프트 보팅입니다. 소프트 보팅은 데이터에 대해 분류값의 모든 확률을 계산합니다. 하드 보팅이 각 분류기에서 최고의 확률을 갖는 분류값만을 어그리게이팅 했다면, 소프트 보팅은 분류기가 데이터에 대해 분류 값 별 확률을 모두 고려하여 모든 분류기에 대해 더하여 총합이 최대인 분류 값을 결론으로 도출합니다. 예를 들어 아래의 표에서 숫자 7이 학습 데이터로 들어왔을 때 각 의사결정 트리의 분류 값 별 확률 표를 보면 의사결정 트리 1-6은 1-9에 해당하는 모든 분류값별 확률을 가지고 있으며, 이를 모두 더하여 최종 점수가 가장 높은 7을 분류 값으로 리턴하게 됩니다.

	1	2	3	4	5	6	7	8	9
d-tree 1	0.9	0.1	0	0	0	0	0	0	0
d-tree 2	0	0.8	0.1	0.1	0	0	0	0	0
d-tree 3	0	0	0.1	0	0	0	0.9	0	0
d-tree 4	0	0	0	0.1	0	0	0.9	0	0
d-tree 5	0	0	0	0	0	0	1	0	0
d-tree 6	0.4	0	0	0	0	0	0.6	0	0

분류값	확률 합	최종 점수
1	0.9 + 0.4	1.3
2	0.1 + 0.8	0.9
3	0.1 + 0.1	0.2
4	0.1 + 0.1	0.2
5	0	0
6	0	0
7	0.9 + 0.9 + 1 + 0.6	3.4
8	0	0
9	0	0

- 부스팅(Boosting)

부스팅은 여러 개의 분류기를 만들어 투표를 통해 예측값을 결정하지만 배깅이 서로 다른 알고리즘의 분류기를 한 번에 병렬적으로 학습하는 반면, 부스팅은 동일한 알고리즘의 분류기를 순차적으로 학습하여 데이터를 보강해 나가며 여러 개의 분류기를 만든 후, 테스트할 때 가중 투표를 통해 예측값을 결정합니다. 의사결정 트리를 예시로 보겠습니다. 만약 인물 사진의 성별을 구분하는 의사결정 트리를 부스팅 할 경우, 첫 번째 질문이 랜덤으로 선택되어 의사결정 트리를 학습합니다. 기존 의사결정 트리에서는 엔트로피와 정보 이득을 모두 계산하여 최적의 질문을 첫 번째 질문으로 선택했다면, 부스팅 시에는 랜덤한 질문이 선택됩니다. 이는 계산량을 줄여주며, 다음 학습 시 미흡한 분류를 찾아 학습 데이터를 보강한 다음 두 번째 의사결정 트리를 학습하면 되기 때문입니다. 예를 들어 남자 분류가 미흡했다면, 남자 사진을 학습 데이터에 추가하여 보강한 다음 두 번째 의사결정 트리를 학습합니다. 이렇게 학습한 의사결정 트리는 첫 번째 의사결정 트리와는 다른 것으로, 이 과정을 반복하여 세 번째, 네 번째 의사결정 트리를 만듭니다. 순차적으로 학습 데이터를 보강한다는 의미가 바로 이것이며, 이렇게 만들어진 분류기를 테스트할 때 가중 투표를 거칩니다. 하드 보팅에서는 모든 의사결정 트리에 한 표씩 부여되는 반면, 부스팅은 하드 보팅과 소프트 보팅 모두 존재하지만 의사결정 트리에 따라 가중치를 주어 투표가 진행됩니다. 가중 투표의 가중치는 보통 정확도로 정해지며, 아래의 표에서 세 분류기의 정확도가 각각 0.4, 0.5, 0.95로 하나의 사진을 분류할 때 두 분류기가 남자로 분류했음에도 두 분류기의 정확도를 더한 것보다 나머지 한 분류기의 정확도가 더 크기 때문에 여자로 분류됩니다.

	분류기 1	분류기 2	분류기 3
정확도	0.4	0.5	0.95

	분류기 1	분류기 2	분류기 3
분류값	남자	남자	여자

소프트 보팅의 경우도 살펴보겠습니다. 정확도를 가중치로 두어 모든 분류 확률값을 곱하여 계산하며, 이 때도 또한 여자로 분류되는 모습을 볼 수 있습니다.

	분류기 1	분류기 2	분류기 3
분류값	남자:0.7 / 여자: 0.3	남자: 0.8 / 여자: 0.2	남자: 0.1 / 여자: 0.9
가중치 (분류기 정확도)	0.4	0.5	0.95

남자	*0.40.7 + 0.50.8 + 0.950.1**	0.775
여자	*0.40.3 + 0.50.2 + 0.950.9**	1.075

- 랜덤 포레스트 (Random Forest)

마지막으로 앙상블의 대표적인 알고리즘 모델 중 하나인 랜덤 포레스트 모델에 대해 알아보겠습니다. 랜덤 포레스트는 여러 의사결정 트리를 배깅해서 예측을 실행하는 모델로, 배깅은 특히 과대적합되기 쉬운 의사결정 트리에 적용하면 성능이 월등히 나아지기 때문에 여러 개의 의사 결정 트리들에 배깅하며, 따라서 여러 나무들이 모여 있다는 개념에서 파생된 이름입니다. 랜덤 포레스트 모델에서는 배깅이 이루어지기 때문에 부트스트랩이 실행될 때 일부 데이터를 제외한 샘플링된 데이터들로 학습하게 되며, 이때 샘플링된 데이터들에서 최적의 특징을 찾아 트리를 분기하기 때문에 랜덤 포레스트 모델은 모델의 편향을 증가시켜 과대적합의 위험을 더욱 감소시킵니다. 다만 의사결정 트리에서 과적합의 위험을 줄이고자 하이퍼파라미터를 설정했을 때처럼 랜덤 포레스트 모델에서도 많은 하이퍼파라미터를 설정해주어야 하며 시간이 많이 소요된다는 단점도 있습니다. 랜덤 포레스트는 다음 MNIST 데이터 분류 실습에서 조금 더 알아볼 것이며, 이번 포스트는 여기서 마치겠습니다. 다음 포스트에서는 MNIST 손글씨 데이터 분류(이전 Fashion MNIST 분류 포스트를 보고 오시면 이해에 도움이 될 것입니다.)를 앙상블 기법을 사용했을 때와 단일 분류 모델을 비교해보고 랜덤 포레스트 모델을 사용하여 학습해보는 실습을 하겠습니다.

나이브 베이즈(Naive Bayes) 실습(3) - EDA, 영화 리뷰 긍정/부정 분류

어른이프로그래머 — Tue, 1 Feb 2022 00:00:53 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다

나이브 베이즈 마지막 실습 포스트입니다. 이번에는 영화 리뷰의 긍정과 부정을 분류해볼 것이며, 분류기로는 나이브 베이즈의 다항분포 나이브 베이즈 모델(Multinomial Naive Bayes)을 사용하겠습니다. 영화 리뷰 긍정/부정 분석 실습은 실제 네이버 영화, 카카오맵 리뷰와 관련된 것으로, 데이터 시각화 과정 및 데이터 전처리 과정에 중점을 두고 보는 것이 좋습니다. 이번 실습에서도 10개의 리뷰에 대해서만 학습할 것이므로 실제 네이버 영화 리뷰 데이터 EDA와 kaggle, bag of words meets bags of popcorn EDA을 보겠습니다. 먼저 네이버 영화 리뷰 EDA입니다. 데이터는 링크의 Naver sentiment movie corpus v1.0에 있습니다. 데이터 분석 과정입니다. 리뷰는 .txt 파일에 저장되어 있으며, 전체 데이터(ratings)를 학습 데이터(ratings_train)과 테스트 데이터(ratings_test)로 분리되어 있습니다. 파일 크기를 확인해보니, 학습 데이터만 해도 14.63MB로 굉장히 큰 사이즈입니다. 다음으로 학습 데이터의 개수를 보니 15만개로, 실제 모델 학습 시에는 이와 비슷한 혹은 이보다도 많은 데이터들이 필요합니다.

학습 데이터의 리뷰 길이를 토대로 히스토 그램을 그려 확인해보겠습니다. 히스토그램 그래프를 봤을 때 리뷰 길이는 최대 160 미만으로, 20글자 근처에 많이 분포되어 있습니다. 실제 최대, 최소, 평균, 표준편차 등을 구하여 박스플롯을 그려보면 조금 더 자세히 알 수 있습니다.

WordCloud를 적용해 그래프를 그려보면 빈도가 높은 단어가 큰 글자로 보입니다. 영화, 정말, 너무, 진짜, 그냥 등의 단어가 리뷰에 자주 사용되었음을 알 수 있습니다. 한 가지 주의할 점으로 한글 텍스트에 대해서는 기본적으로 지원하지 않기 때문에, 폰트를 다운받아 폰트 설정을 따로 해줘야합니다. 이후 학습 데이터에서 긍정과 부정의 리뷰 개수와 비율을 확인해보면, 74827개와 75173개로 반반씩 분포되어 있음을 알 수 있습니다.

이제 각 리뷰의 단어 개수로 히스토그램을 그린 다음, 마지막으로 리뷰에서 특수문자의 비율을 확인해보겠습니다. 이번 EDA 과정으로 우리는 리뷰의 긍정 부정 분포 비율, 리뷰 길이에 대한 평균, 표준편차 값, 리뷰 당 단어 개수 분포 및 특수 문자의 비율 등 다양한 정보를 얻을 수 있었습니다.

그렇다면 데이터 전처리 과정을 간단히 살펴보고, 오늘의 실습을 진행하겠습니다. 우리는 리뷰 텍스트에 대해 한글이 아닌 특수문자, 숫자 등을 제거한 다음 리뷰를 형태소 단위로 나누어(Okt) 불용어를 제거하는 작업을 진행하겠습니다. 불용어는 갖고 있는 데이터에서 유의미한 단어 토큰만을 선별하기 위해 큰 의미가 없는 단어로, 학습에 방해가 될 수 있는 단어를 일컫습니다. 불용어는 불용어를 담은 리스트를 정의해 사용할 수 있습니다.

이제 keras의 Tokenizer()를 사용해 데이터를 인덱스 벡터로 학습 데이터와 평가 데이터를 변환합니다. 이전 포스트의 스팸 메일 구분에서 CounterVectorizer()를 사용한 것과 동일한 맥락입니다. 이때까지 실제 네이버 영화 리뷰 데이터를 분석하고 전처리하는 과정을 함께 진행해봤습니다. 이제는 다항분포 나이브 베이즈를 활용해 영화 리뷰를 분류하는 작업을 진행해보겠습니다.

다항분포 나이브 베이즈 모델을 활용한 영화 리뷰 분석 과정은 이전 포스트에서 다뤘던 베르누이 나이브 베이즈 모델과 동일합니다. 실습에 사용하는 데이터는 그 수도 적을 뿐더러 위의 경우에서처럼 특수문자를 제거하는 등의 전처리 과정을 모두 거친 데이터로, 별도의 데이터 전처리 과정을 필요로 하지 않습니다. 다만 베르누이 나이브 베이즈 모델이 등장 여부에 초점을 맞춰 중복된 단어에도 1으로 표시했다면, 다항분포 나이브 베이즈 모델에서는 중복된 단어는 그 빈도 수만큼 표시합니다. 예를 들어 한 리뷰가 "이런 점은 싫지만 전체적으로 좋다. 그리고 이번 영화는 차기작이 기대된다는 점에서 좋다"라고 했다면, 긍정적인 리뷰로 봐야합니다. 이를 위해 싫다, 좋다의 실제 빈도 수가 중요한데, 베르누이 모델을 사용한다면 좋다와 싫다 모두에 1로만 치환되어 있어 분류에 힘이 듭니다. 따라서 이때는 싫다 1번, 좋다 2번으로 좋다의 비율의 더 높은 것을 토대로 긍정적인 리뷰로 분류할 수 있는 다항분포 나이브 베이즈 모델이 더 적절하다고 볼 수 있습니다. 코드에 대한 설명은 이전 포스트와 동일하므로, 한번 쭉 훑어보면 되겠습니다.

나이브 베이즈(Naive Bayes) 실습(2) - 스팸 메일 분류

어른이프로그래머 — Sun, 30 Jan 2022 18:30:56 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다

이전 포스트에서는 나이브 베이즈 분류기 중 하나인 가우시안 나이브 베이즈 모델을 사용해 꽃받침과 꽃잎 특징에 따른 붓꽃 종류를 분류해봤습니다. 이번 포스트에서는 다른 분류기인 베르누이 나이브 모델을 사용해, 수신된 이메일 중 스팸 메일을 분류해보겠습니다. 실제로 나이브 베이즈 모델은 스팸 메일 분류 등의 문서 분류에 적극 활용되고 있으며 높은 정확도를 보입니다. 이번에는 간단한 스팸 메일 분류를 위해, 학습과 테스트에 사용할 데이터들을 이메일 제목과 스팸 메일인지를 담은 레이블을 리스트로 직접 작성하여 사용하겠습니다.

spam or ham?

먼저 필요한 라이브러리를 임포트하고 학습 데이터를 작성한 다음, 그 데이터를 확인해보겠습니다. 참고로 베르누이 나이브 모델은 사이킷런 naive_bayes에 BernoulliNB로 저장되어 있으며 햄(ham) 메일은 스팸(spam) 메일이 아닌 메일입니다. 데이터를 살펴보면 이메일은 총 6개로, 스팸 메일 3개와 햄 메일 3개로 구성되어있습니다. 여느 때처럼 판다스 데이터 프레임 형식으로 변환한 다음 데이터를 확인해보겠습니다.

다음은 데이터 전처리입니다. 베르누이 나이브 베이즈 분류 모델은 숫자 데이터만 다루기 때문에, 먼저 레이블을 스팸인지 아닌지에 따라 1과 0으로 치환해줍니다. 다음에는 입력 데이터로, 베르누이 나이브 베이즈의 입력 데이터는 고정된 크기의 벡터여야 합니다. 따라서 이메일을 고정된 크기의 벡터로 치환해줍니다. 이를 위해 사이킷런의 CountVectorizer를 이용해, 전체 데이터의 모든 단어를 담은 고정된 크기의 벡터를 만들고 파라미터로 binary=True로 설정해 각각의 이메일에서 해당 이메일이 등장하는지, 등장하지 않는지를 1과 0으로 표시합니다. 베르누이 나이브 베이즈 모델에서는 등장 빈도가 중요한 것이 아니라 등장 여부에 중점을 맞추고 있기 때문에, 한 번 이상 등장했더라도 1로 표시합니다.

아래의 코드를 보면 데이터를 학습 데이터와 레이블로 분리한 다음 학습 데이터를 CountVectorizer로 변환(fit_transform)하여 베르누이 나이브 베이즈 모델의 입력값으로 사용할 인코딩 된 입력값(encoded_input)을 생성합니다. 모든 벡터의 길이는 17로, 전체 이메일의 중복을 제외한 단어 수를 세보면 17개임을 알 수 있습니다. get_features_name_out()으로 해당 인덱스에는 어떤 단어가 표시되어 있는지, 그리고 inverse_transform()으로 해당 벡터에는 어떤 단어가 있는지를 역으로 추적해봤습니다. 예를 들어 첫 번째 벡터는 6, 7, 11, 15번째 인덱스만 1의 값을 갖는데, cv.get_feature_names_out()으로 확인해보면 인덱스에 해당하는 단어들이 free, game, only, today에 매칭 됨을 알 수 있습니다.

이제 모델을 학습하겠습니다. 모델 학습은 사이킷런의 BernoulliNB()로 할 수 있습니다. 학습된 모델을 테스트하기 위해 테스트 데이터를 설정하는데, 잘 보면 테스트 데이터에는 hey, traveler 등 학습 데이터에 등장하지 않는 단어들이 보입니다. 이전 이론 포스트에서 잠시 알아봤듯이 이산적인 데이터 상에서 학습 데이터에 없는 데이터가 출현하면 확률이 0이 되는 문제점이 있습니다. 이를 방지하고자 스무딩 기법을 활용하는데, 사이킷런에 구현된 베르누이 나이브 베이즈 모델에서는 이미 디폴트로 스무딩을 지원하고 있어 문제없이 테스트를 할 수 있습니다. 다만 우리는 스무딩, 언더플로우에 대해 알아봤으므로 설사 학습 및 테스트 시 원치 않는 결과가 나왔다 할지라도 문제의 시발점이 어디였는지를 눈치챌 수 있을 것입니다.

마지막으로 작성한 테스트 데이터를 활용해 모델을 테스트하고, 정확도를 확인해보겠습니다. 단 6개의 학습 데이터로 학습한 모델임에도, 0.83의 높은 수치를 보였습니다. 조금 더 많은 학습 데이터와 데이터 전처리 과정을 거쳤다면 정확도는 한층 더 높았을 것으로 예측할 수 있습니다. 이번 포스트에서 중요한 점은 베르누이 나이브 베이즈의 모델의 입력 데이터를 위한 인코딩 작업입니다. 베르누이 나이브 베이즈 모델의 특성을 이해해, CountVectorizer의 파라미터로 binary=True를 설정하여 1과 0으로 인코딩 된 입력값을 만들었습니다. 이전 가우시안 나이브 베이즈 모델에서는 데이터를 시각화하여 데이터 분포를 본 다음, 데이터 분포가 가우시안 분포를 따르고 있음과 동시에 데이터가 이산적이지 않고 연속적이라는 특징을 활용하여 가우시안 나이브 베이즈 모델을 떠올리는 과정이 주였지만, 이번에는 그 역으로 모델의 특성에 맞게끔 데이터를 전처리하는 과정에 중점을 두고 보는 것이 좋습니다. 바로 다음 포스트로 넘어가 영화 리뷰 긍정 / 부정 분류하는 다항 분포 나이브 베이즈 모델을 실습해보겠습니다.

나이브 베이즈(Naive Bayes) 실습(1) - 붓꽃 분류

어른이프로그래머 — Sat, 29 Jan 2022 01:00:35 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다.

이번 포스트에서는 붓꽃(iris)의 꽃받침 특징을 데이터로 활용하여 붓꽃의 종류를 분류해보겠습니다. 학습 모델은 이전 포스트에서 알아본 나이브 베이즈 알고리즘 중 하나인 가우시안 나이브 베이즈 모델(Gaussian Naive Bayes)을 사용하겠습니다. 가우시안 나이브 베이즈 모델을 사용하는 이유는 붓꽃 데이터 특징들이 이산적이지 않은 연속적인 성질을 가지고 있기 때문이며, 자세한 내용은 이전 포스트를 참고해주시길 바랍니다. 붓꽃 분류는 연속적인 특징을 갖는 데이터 분류의 대표적인 예시로, 이미 사이킷런 내에 데이터가 있습니다. 우리는 사이킷런의 붓꽃(iris) 데이터를 로드하여 시각화한 다음 데이터를 다듬어 가우시안 나이브 베이즈 모델로 학습 후, 평가해보는 작업을 해보겠습니다.

우리는 이미 이전에 kNN, SVM, Decision Tree 실습에서 데이터를 불러와 학습 데이터와 테스트 데이터로 분리한 다음, 학습 데이터를 사용해 모델을 학습하고 테스트 데이터로 모델을 테스트 및 평가, 정확도 측정하는 실습을 많이 해봤습니다. 이번 Gaussian Naive Bayes 모델의 실습 코드도 이전과 별반 다르지 않습니다. 코드 또한 주석만으로도 해석할 수 있듯이 어렵지 않습니다. 붓꽃 꽃받침, 꽃잎의 높이와 너비에 대한 데이터는 sklearn에 이미 저장되어 있습니다. 따라서 로드하여 데이터를 부른 다음 상위 5개의 데이터를 확인합니다. 이때, 붓꽃(iris)의 종류(label)는 총 3가지로, setosa, versicolor, virginica가 있습니다. 하지만 원래의 데이터에는 이들이 0, 1, 2로 구분되어있으므로, 숫자로 되어있는 레이블을 실제 명칭에 매핑해줍니다. 현재까지 문제를 정의하고 데이터를 획득했으며 획득한 데이터를 사용하기 좋은 형태로 전처리했습니다. 이제 데이터를 시각화해보겠습니다. 데이터를 시각화하는 작업은 표나 그래프로 나타냈을 때 데이터의 특징 및 필요/불필요한 데이터를 알려주는 역할, 적절한 모델 선택 등 다양한 이점이 있습니다. 이번에는 붓꽃의 세 종류를 다시 데이터 프레임 형태로 만들어 각각 sepal length / width(꽃받침 높이 / 너비), petal length / width(꽃잎 높이 / 너비)의 데이터 분포를 확인해보겠습니다. 세 종류의 네 특징, 총 12개의 그래프가 그려지겠습니다. 잠시, 이전에 붓꽃이 어떻게 생겼는지 종류별로 직접 보고 가는 것도 좋을 것 같습니다. 코랩에서는 새 윈도우창을 띄워 사진을 보여주는 cv2.imshow()는 되지 않기 때문에 코랩에서 바로 출력하는 cv2_imshow()를 사용합니다. 사진 또한 깃허브의 data 디렉토리에 있으므로, 필요하시다면 다운로드하여 사용하시면 됩니다. 이 코드에 대한 설명은 추후 OpenCv()를 다룰 때 glob()와 한 번에 설명하겠습니다.

다시 돌아와 전체 데이터를 레이블 별로 나누어 세 데이터 프레임을 생성했으며, 특징마다 데이터 분포를 보고자 그래프로 그렸습니다.

물론 특징을 자세히 알아보고자 다양한 방법으로 데이터를 확인하기도 하지만, 이번에는 데이터의 분포만 확인하는 이유가 있습니다. 그 이유는 조금 있다 알아볼 것이며 데이터를 시각화하고 데이터의 특징을 알아보는 작업을 EDA(Exploratory Data Analysis, 탐색적 데이터 분석) 과정이라고 합니다. 자세한 EDA 과정은 다음의 "네이버 영화 리뷰 데이터 EDA"에서 볼 수 있습니다.

동일한 방법으로 versicolor와 virginica, 그리고 다른 특징들에 대해서도 그래프를 그려 확인해보겠습니다. plot()의 파라미터들을 간단히 짚고 넘어가겠습니다. 먼저 히스토그램 형식의 그래프를 그립니다(plot(kinds='hist')). 그 위에 데이터의 분포를 보기 위해 kde 형식의 그래프를 그리는데 이때 kde는 kernel density estimator, 커널 밀도 추정으로 쉽게는 히스토그램을 스무딩 하는 것을 말합니다. 실제 위의 그래프를 보면 파란색의 히스토그램 그래프와 궤를 같이하는 주황색 곡선을 볼 수 있는데, 이 선이 바로 kde로 그린 선입니다. 데이터의 분포와 밀집도에 의해 그려지는 것을 볼 수 있습니다. ax는 그래프의 축을, seconary_y는 2차 y축을 표시합니다. 리스트나 튜플 형태에서 한 그래프에 레이블을 둘 이상 표시하고 싶을 때, secondary_y를 True로 설정합니다. 디폴트는 False입니다.

세 종류의 붓꽃과 네 가지 특징을 모두 조합해 그래프를 모두 그려봤습니다. 이번 그래프 시각화에서 필요한 정보를 추출해보겠습니다. 주황색의 kde 형식의 그래프를 보면 12가지의 모든 그래프들이 가우시안 분포를 가깝게 따르고 있음을 알 수 있습니다. 이 점이 중요한데, 우리는 이때까지 모델을 설정한 다음 데이터를 시각화하고 데이터를 다듬었지만, 실제에서는 Raw 데이터를 시각화한 다음, 가우시안 분포를 따르고 있음을 바탕으로 가우시안 나이브 베이즈 분류기를 사용하는 것이 적절함을 추론하는 것이 중요합니다. 이제 전체 데이터를 테스트 데이터와 학습 데이터로 나눈 다음 모델을 학습하고 성능을 테스트해보겠습니다. 이 과정은 이전의 실습 포스트들에서 여러 번 다뤘기 때문에 더 자세히 다루지는 않겠습니다. 그렇다면 바로 다음 포스트로 넘어가 스팸 메일 분류 나이브 베이즈 모델을 보겠습니다. 나이브 베이즈 알고리즘은 문서 및 스팸 메일 분류 등 문서 분류에 굉장히 높은 정확도 및 실제에서도 많이 사용되고 있습니다. 이번 포스트를 읽어주셔 감사합니다.

나이브 베이즈(Naive Bayes)

어른이프로그래머 — Mon, 24 Jan 2022 21:00:05 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다

이번 포스트에서는 머신러닝 지도 학습 분류 알고리즘 중 하나인 나이브 베이즈(Naive Bayes) 알고리즘에 대해 알아보겠습니다. 이미 우리는 이전 포스트들에서 다양한 분류 알고리즘에 대해 알아봤습니다. 대표적으로 kNN은 데이터의 특성을 벡터 공간의 축으로 지정해서 데이터 간의 유클리드 거리를 토대로 분류했으며, SVM에서는 데이터를 분류하는 적절한 Decision Boundary를 찾아 데이터를 분류했습니다. 이번에 알아볼 나이브 베이즈 알고리즘은 확률 기반 알고리즘으로, 데이터를 독립적인 사건으로 가정(Naive)하고 독립 사건들을 베이즈 정리에 대입(Bayes)하여 특정 클래스에 속할 확률을 계산하여 분류합니다. 나이브 베이즈 알고리즘은 실제로 스팸 메일 분류, 문서 분류에 많이 사용되며 이외에도 감정 분석, 추천 시스템 등 다양한 분야에 사용됩니다. 그렇다면 이제 베이즈 정리는 무엇인지, 확률은 어떤 방식으로 계산되는지 보겠습니다.

아래는 나이브 베이즈를 공부하던 중 찾게된 사진입니다. 이 포스트를 다 보고나면, 셜록 홈즈의 말을 이해할 수 있을 것입니다.

출처: 위니버스 유튜브,&nbsp;&lt;셜록 S2. EP2. 베스커빌의 개&gt;

확률의 허점, 베이즈 정리

베이즈 정리를 이해하기 앞서, 책 "확률 게임"에 나오는 다음의 질문에 답해보겠습니다.

자동차 사고로 사망한 사람의 40%는 안전띠를 착용하지 않은 사람이라고 합니다. 그렇다면 반대로 자동차 사고로 사망한 사람의 60%는 안전띠를 착용했다는 의미인데, 안전띠를 착용하는 것이 더 위험하지 않나요?

우리는 당연히 이 말이 틀렸다는 것은 알지만, 그 이유에 대해서는 정확히 설명하지 못합니다. 그렇다면 아래의 표를 보겠습니다. 표는 이전 "머신러닝 모델의 성능을 알아보자" 포스트에 있는 암환자를 진단하는 시스템의 예시입니다.

실제 \ 예측	암환자	일반환자
암환자	5	50
일반환자	250	695

병원에 찾은 한 환자는 의사로부터 이런 말을 들었습니다. "우리 병원의 암환자 예측 시스템은 정확도는 70%입니다. 이 시스템으로 진단했을 때, 현재 암환자로 예측되셨습니다. 자세한 검사를 받아봐야 하겠지만, 당장 큰 걱정은 안 하셔도 됩니다. 실제로 암에 걸렸을 확률은 2%가 안되기 때문입니다." 의사는 어떤 근거로 이런 말을 할 수 있었을까요?

위의 두 질문에 대해 당장 답변하는 것은 쉽지 않을 것입니다. 답변에 앞서, 우리는 정보가 없는 상황에서 확률적으로 생각할 때 두 상황의 확률을 동일하게 생각합니다. 예를 들어 위의 예시에서 자동차 운전석에 앉은 사람이 안전벨트를 착용한 확률과 착용하지 않을 확률을 50:50으로 생각합니다. 이는 이유 불충분의 원리라고 불리며, 현실 삶에서도 빈번히 볼 수 있습니다. 또 다른 예로 주사위를 1000번 굴렸을 때, 우리는 1이 나올 횟수에 대한 기댓값을 166번으로 생각할 것입니다. 이는 논리적으로도 주사위를 굴렸을 때 1이 나올 확률이 1/6 임을 추론함과 동시에 수많은 시행을 통해서도 얻을 수 있습니다. 이때 우리가 주사위 1000번을 굴렸을 때 1이 나올 횟수에 대해 계산하기 위해 추론한 1/6의 확률을 경험적 확률(사전 확률)이라고 합니다. 이제 주사위 굴리기를 통계학에서 확률을 바라보는 두 관점인 빈도론(Frequentism)과 베이지안(Baysianism)의 입장에서 보겠습니다. 먼저 빈도론에서는 확률을 "반복 가능한 무작위 실험의 장기적인 빈도"라고 말합니다. 이 말을 해석하면 빈도론의 입장에서 주사위 굴리기에서 1이 나오는 확률은 무한히 많은 주사위 굴리기 경험을 통해 1이 나오는 빈도가 1/6에 수렴하는 객관적인 사건입니다. 따라서 빈도론은 다음과 같이 말할 것입니다. "주사위를 100번 던지면 1은 16번, 주사위를 1000번 던지면 1은 166번 등장합니다." 반면 베이지안의 입장에서 주사위 굴리기는 조금 다른 일입니다. 먼저 주관적으로 사전 확률을 정합니다. 주사위는 6면이 있으니 한 번의 시행에서 6은 1/6의 확률을 사전 확률로 정하겠습니다.. 다음 데이터를 관찰하며 가능도를 계산합니다. 이를 토대로 처음에 설정한 주관적인 확률을 보정하는 작업을 거칩니다. 가능도를 계산하고 확률을 보정하는 작업은 거치지 않았지만, 이러한 과정을 통해 베이지안은 다음과 같이 말할 것입니다. "주사위를 던지면, 1이 나온다고 1/6 확신할 수 있습니다."

조금은 이해가 되나요? 베이지안의 확률론에 대해서는 당장 이해가 어려울 수 있습니다. 고등 과정을 거치며 배운 확률은 모두 무한히 많은 실험을 통해 수렴하는 빈도론의 입장에서만 봤습니다. 하지만 무한히 많은 실험이 불가능한, 예를 들어 당장 해본 적 없는 게임에서 승리할 확률은 어떻게 될까요? 이러한 경우에는 게임을 해본 적이 없기 때문에 경험적 실험을 통해 확률을 계산할 수 없을 것입니다. 이때는 해당 게임 및 플레이어의 정보를 토대로 사전 확률을 설정한 다음 관련되는 다양한 데이터들을 토대로 확률을 보정하는, 베이지안 추론이 유용할 것입니다. 사실 우리는 이미 베이즈 정리에 대해 알고 있습니다. 베이즈 정리의 고등 수학 과정에서 배운 조건부 확률(P(A|B))에서 나왔으며 따라서 그 증명 또한 어렵지 않습니다. 이제야 위의 "안전띠를 매는 것이 더 위험한 것인가?" 질문에 대한 답을 해보겠습니다. 우리는 아무런 정보가 없는 상황에서 이유 불충분의 원리에 따라 운전 시 안전띠를 착용한 사람과 착용하지 않은 사람의 비율을 50:50으로 설정했습니다. 이후 데이터를 보아 사실 운전자의 95%는 안전띠를 착용했으며, 5%만이 안전띠를 착용하지 않았음을 알았습니다. 따라서 안전띠를 착용한 사람 중 사망한 비율과 안전띠를 착용하지 않은 사람 중 사망한 비율을 다시 계산해보니 전혀 다른 결과를 얻을 수 있었습니다. 이 과정이 바로 베이지안 추론, 베이즈 정리입니다. 확률을 구하면서 안전띠를 착용하지 않은 운전자 중 사망한 비율은 조건부 확률로, 다음의 식으로 표현할 수 있습니다. P(사망한 운전자|안전띠를 착용하지 않은 운전자)

이제 암환자 예측 시스템을 보겠습니다. 표를 보면서 짐작했듯 70%의 정확도(TP/전체)는 사실 일반 환자를 일반 환자로 정확히 예측했기 때문에 높아진 수치입니다. 이는 암환자와 일반 환자의 비율이 50:50으로 두는 이유 불충분의 원리와는 달리, 실제로는 일반 환자의 비율이 암환자에 비해 극명히 높기 때문에, 시스템이 환자를 암 환자로 예측했더라도 실제 암환자일 비율은 정밀도(TP/(TP+FP))를 계산해보면 2% 채 되지 않습니다.

이제 확률의 허점이라는 말에 대해 어느 정도 이해할 수 있을 것입니다. 아래는 베이즈 공식과 그 증명 과정입니다.

P(A | B) = P(B | A) P(A) / P(B)

Bayes theorem과 증명 과정

이미 고등 수학 과정에서 조건부 확률의 공식을 배웠으므로, 귀납적 추리로도 베이즈 공식이 성립함은 익히 알 수 있을 것입니다. 오른쪽의 해석이 중요한데, P(A|B)를 단순히 "B 사건이 일어났을 때 A 사건이 일어날 확률"로 해석하기보다 베이지안의 시점에서 "사전 확률인 P(A), 즉 사건 A가 일어날 확률에 P(B|A) 사건 A가 일어났을 때의 사건 B의 확률을 곱한 다음 P(B), 사건 B가 일어날 확률로 조정해주면 사후 확률(사건 B가 발생한 이후 갱신된 사건 A의 확률)인 P(A|B)를 얻는다"라고 해석하는 것이 더 이해에 도움 될 것입니다. 사전 확률과 사후 확률에 대해 이해한다면 이제부터 확률을 보는 시점은 이전과 조금 달라질 것입니다.

이제 우리는 경험적 확률(사전 확률)서 시작해 확률을 바라보는 두 관점인 빈도론과 베이지안에 대해 알아봤으며 추가로 베이즈 정리의 공식을 증명해봤습니다. 하지만 이번에 배우는 알고리즘은 단순히 베이즈 알고리즘이 아닌 나이브 베이즈 알고리즘인데, 그렇다면 나이즈는 어떤 말일까요? 교재의 예시를 빌려와, 치킨 집에서 사건 A를 시간대, B를 맥주 주문으로 두고 아래의 표를 보겠습니다.

시간	맥주 주문
오전	X
오전	X
점심	O
점심	X
점심	X
저녁	O
저녁	O
저녁	O
저녁	X
저녁	X

이제 손님이 왔을 때, 저녁에 온 손님이 맥주를 주문할 확률을 구해보겠습니다. 베이즈 공식에 따르면 P(주문|저녁) = P(저녁|주문) * P(주문) / P(저녁)으로 (3/4 * 4/10) / (5/10), 0.6의 확률을 구할 수 있습니다. 이처럼 데이터 레이블이 두 개인 경우에는 사실 베이즈 공식을 사용하지 않더라도 굉장히 쉽게 확률을 구할 수 있습니다. 이번에는 데이터를 조금 더 추가해보겠습니다. 손님의 성별을 추가한 아래의 표에서 저녁에 온 남성 손님이 맥주를 주문할 확률을 구해보겠습니다. 저녁과 남성, 두 레이블이 동시에 발생하므로 결합확률의 특징으로 이해해야 합니다. 결합 확률은 위의 증명에서도 보였듯이, 두 가지 이상의 사건이 동시에 발생하는 확률로 사건 A와 사건 B가 있을 때 두 사건 A, B가 동시에 발생하는 확률 P(A, B)는 P(A|B) P(B), P(A∩B)로 계산합니다.

시간	성별	맥주 주문
오전	남	X
오전	여	X
점심	남	O
점심	여	X
점심	여	X
저녁	남	O
저녁	남	O
저녁	남	O
저녁	남	X
저녁	여	X

P(주문|저녁, 남성) = P(저녁, 남성|주문) * P(주문) / P(저녁, 남성) = (3/4 * 4/10) / (4/10) = 3/4, 0.75의 확률을 구할 수 있습니다. 데이터 레이블이 셋 이상 있으니 슬슬 계산량이 많아집니다. 현실의 문제에서는 이 보다 훨씬 많은 데이터 레이블로 확률을 구해야 하기 때문에, 나이브 베이즈 알고리즘에서는 모든 사건을 독립적인 사건으로 간주합니다. 모든 사건을 독립적으로 보게 되면, 결합 확률의 공식에서 P(A, B)를 더 이상 P(A|B) P(B)로 구할 필요 없이 P(A) P(B)로 구할 수 있습니다. 다시 돌아와 P(주문|저녁, 남성)을 나이브 베이즈 알고리즘에서 구하면 P(주문|저녁, 남성) = (P(저녁|주문) * P(남성|주문) * P(주문)) / (P(저녁) * P(성인))으로 구할 수 있습니다. 조금 더 간단히, P(저녁) * P(성인)은 정규화 상수로, 전체 확률을 조정해주는 확률값입니다. 나이브 베이즈 알고리즘에서는 공통분모인 정규화 상수를 제거해 계산량을 더 줄입니다. 따라서 나이브 베이즈 알고리즘으로 구한 저녁에 온 남성 손님이 맥주를 주문할 확률은 0.75가 아닌 3/4 * 10/4, 0.3이 됩니다. 마찬가지 방법으로 저녁에 온 남성 손님이 맥주를 주문하지 않을 확률을 구하면 0.066이 나오며, 따라서 저녁에 남성 손님이 올 경우 맥주를 주문할 것으로 분류할 수 있습니다. 이제 나이브 베이즈 알고리즘에서 특징이 여러 개인 경우의 공식은 다음과 같이 표현할 수 있겠습니다.

특징이 여러 개인 경우의 나이브 베이즈 공식

특징이 여러 개인 경우에도 나이브 베이즈 공식은 단순히 하나의 식으로 표현할 수 있습니다. 위의 치킨집 예시를 다시 빌려와 우리는 계산량을 줄이고자 공통분모인 정규화 상수를 제거한 채 계산했습니다. 결과적으로 저녁에 오는 남성 손님은 맥주를 주문할 확률은 0.3, 주문하지 않은 확률은 0.066으로, 저녁에 오는 남성 손님의 특징은 맥주를 주문하는 레이블에 분류될 것입니다. 이때 유의할 것은 저녁이라는 특징과 남성의 특징 서로는 독립적이라는 점입니다. 이제 베이즈 이론과 나이브 베이즈 알고리즘이 어느 정도 이해되었으리라 생각합니다. 서두에서 말했듯이 나이브 베이즈 알고리즘은 스팸 메일 분류에 굉장히 뛰어난 성능을 보입니다. 스팸 메일 분류는 뒤의 실습에서 다시 살펴보기로 하고, 이제는 데이터들의 특징이 이산적이지 않은 경우의 나이브 베이즈 알고리즘을 살펴보겠습니다. 우리가 위에서 살펴본 모든 예시들은 데이터들이 이산적이라는 특징을 가지고 있습니다. 맥주 주문은 O, X로 나뉘며 성별 또한 남성과 여성 두 분류, 시간대는 오전, 점심, 저녁 세 분류로 나누었습니다. 만약 데이터의 특징들이 연속적일 경우에는 어떤 방법을 사용해야 할까요? 이때는 가우시안 나이브 베이즈 분류(Gaussian Naive Bayes)를 사용하는 것이 좋습니다. 가우시안 나이브 베이즈는 특징들의 값들이 정규 분포(가우시안 분포)되어 있다는 가정 하에 조건부 확률을 계산합니다. 정규 분포되어 있다는 가정은 표본 평균과 표본 분산을 가진다는 것을 의미하며 나이브 베이즈 공식과 정규 분포의 표현식을 결합한 형태로 표현합니다. 지금 당장 아래의 수식으로 표현할 수 있지만 당장은 이 수식을 너무 자세히 알 필요는 없을 것 같습니다. 지금 중요한 점은 이산적이지 않은 연속적인 특징들에 대해서는 가우시안 나이브 베이즈 분류를 사용하는 것이 효율적이라는 것입니다. 다음 포스트 실습에서 직접 해볼 것이지만 예시로 붓꽃의 꽃받침 길이에 따른 분류는, 길이라는 연속적인 특징들을 가우시안 나이브 베이즈 분류기로 분류하는 것입니다.

가우시안 나이브 베이즈 공식

반면 위의 예시들처럼 이산적인 데이터의 경우에는 사이킷런에서 제공하는 두 가지의 나이브 베이즈 분류 모델을 상황에 맞게 적절히 사용하면 됩니다. 다음은 다항 분포 나이브 베이즈(Multinomial Naive Bayes)와 베르누이 나이브 베이즈(Bernoulli Naive Bayes)에 대한 설명과 두 차이점, 사용 예시입니다.

먼저 다항 분포 나이브 베이즈는 데이터의 특징들의 출현 횟수를 표현할 때 사용합니다. 예를 들어 동전을 2번 던졌을 때 앞면이 2번, 뒷면이 0번 나왔다면 데이터는 (앞면, 뒷면) = (2,0)과 같이 나타낼 것입니다. 인덱스는 앞면과 뒷면을 의미하며, 인덱스에 해당하는 값은 앞면과 뒷면의 출현 횟수를 표시합니다. 반면 베르누이 나이브 베이즈는 데이터의 특징들을 0과 1로 표현할 때 사용합니다. 위의 예시에서 앞면이 2번 나왔음에도 앞면 출현 횟수인 2를 표시하는 것이 아니라, 앞면이 한 번이라도 나왔으니 1, 뒷면은 한 번도 나오지 않았으니 0으로 표시해 베르누이 나이브 베이즈에서 동전 던지기 데이터는 (앞면, 뒷면) = (1,0)과 같이 표현될 것입니다. 실습에서는 다음의 총 세 가지 데이터셋을 분류해볼 것이며 붓꽃(iris) 데이터셋 분류는 가우시안 나이브 베이즈 분류 모델로, 영화 리뷰 긍정/부정 분류는 다항 분포 나이브 베이즈 분류 모델로, 스팸 메일 분류는 베르누이 나이브 베이즈 분류 모델을 사용할 것입니다.

실습에 앞서, 다른 모델에서처럼 나이브 베이즈 분류 모델에서도 overfitting, underfitting 등의 문제점을 방지하기 위해 모델 학습에 보정해줘야 하는 부분이 있습니다. 먼저 스무딩입니다. 스무딩은 이산적인 데이터들의 경우 빈도수가 0일 때 확률이 0이 되는 문제점을 극복하기 위해 나온 보정 방법으로, 학습 데이터에 없던 데이터가 출현해도 빈도수에 1을 더해서 확률이 0이 되는 현상을 방지합니다. 스팸 메일 분류 예시를 들자면 현재까지 우리가 만든 나이브 베이즈 분류 모델에서 우리는 메일에 'free', 'coupon' 두 특징만으로 학습하고자 했는데, 새로운 단어인 'sale'이 등장한다면 학습 데이터에 없던 단어이기 때문에 확률을 0으로 만들어 버려 스팸 분류를 제대로 하지 못하는 문제점이 발생합니다. 따라서 이러한 특징들에 대해서는 새로운 데이터를 봤을 때, 0이 아니라 빈도수를 1 늘려 확률을 계산하게끔 하는 기법입니다. 파이썬을 사용하신 분들이라면 collections 라이브러리의 defaultdict(int)를 떠올리면 이해에 도움이 될 것 같습니다. 다음으로 언더플로우 현상은 Vanishing gradient를 떠올리면 이해가 쉽습니다. Vanishing gradient는 뉴럴 네트워크에서 Backpropagation으로 학습하는 도중 활성화 함수를 sigmoid로 설정해 0과 1 사이의 값이 지속적으로 곱해지는 이유로 Gradient 항이 사실상 사라져 학습망이 깊어질수록 이전의 노드들이 결과에 미치는 영향이 급격히 줄어드는 상황을 말합니다. 언더플로우 현상 또한 확률은 항상 1보다 작기 때문에, 많은 특징들에 대해 모든 확률들을 곱하다 보면(나이브 베이즈 분류에서는 모든 사건을 독립적으로 간주하기 때문에, 모든 특징들의 확률을 곱하는 상황이 자주 등장합니다.) 0에 가까운 너무 낮은 숫자가 나와 비교 및 분류가 힘들어지는 현상입니다. 따라서 이런 경우에는 로그를 취한 다음 연산을 진행하는 등의 방법으로 언더플로우 현상을 방지할 수 있습니다.

이번 포스트에서 알아본 나이브 베이즈 알고리즘은 모든 데이터의 특징들을 독립적인 간주하는 나이브 가정에도 불구하고, 높은 정확도를 보이며 특히 앞에서 말했듯이 문서 및 메일 분류에 굉장히 강한 모습을 보입니다. 또한 데이터의 특징들을 독립적으로 간주하기 때문에 계산량이 월등히 적어지며 다른 모델들과 비교했을 때 계산 속도가 상당히 빠릅니다. 하지만 그러한 가정으로 인하여 현실 세계의 다른 분류에서는 사용이 어려운 경우도 많으며, 이러한 점을 조심하여 사용해야만 좋은 정확도를 얻을 수 있습니다. 다음 포스트에서는 가우시안 나이브 베이즈 분류 모델을 사용하여 꽃받침 길이에 따른 붓꽃 데이터를 분류하는 실습을 진행해보겠습니다.

Decision Tree 실습 - 지니 계수 및 서울 지역 다중 분류 (2)

어른이프로그래머 — Wed, 19 Jan 2022 21:00:07 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다

이번 포스트에서는 서울 지역의 위치 정보(위도, 경도)로 임의의 지역을 한강을 기준으로 하는 네 지역(강북, 강남, 강동, 강서)로 분류하는 Decision Tree 모델을 생성하고 학습해보겠습니다.

모든 머신러닝 문제는 문제 정의 및 데이터 수집에서 출발합니다. 바로 위에서 말했듯이 우리는 이번 실습에서 서울 지역의 위치 정보(위도, 경도)를 데이터로 서울을 한강을 기준으로 하는 네 지역(강북, 강남, 강동, 강서)로 분류하고, 임의의 지역의 위치 정보를 테스트 데이터로 삼아 분류해보겠습니다. 서울의 위치 정보는 구(district)와 동(dong)으로 나누었으며 district_dict_list는 모델 학습에, dong_dict_list는 테스트에 사용합니다. 리스트들을 데이터 프레임으로 만들어 저장한 다음, 두 데이터 레이블의 분포를 확인합니다.

레이블의 분포가 각각 5개로 동일한 것을 알 수 있습니다.

이제 데이터를 시각화해보겠습니다. 상위 5개의 데이터의 확인해보고, 파이썬의 데이터 시각화 라이브러리 matplotlib.plyplot을 활용해 데이터 분포를 2차원 그래프에 그려보겠습니다. 이전 포스트에서는 상위 데이들을 확인해보고 학습에 필요한 특징인지를 판단 후 제거, 수정하는 데이터 전처리 과정을 거쳤는데, Decision Tree는 각 특징을 독립적으로 사용하기 때문에 이번 모델에서는 별도의 데이터 전처리 과정이 필요하지 않습니다.

fig_reg = 회귀선 제거, scatter_kws = 좌표 상 점의 크기, https://seaborn.pydata.org/generated/seaborn.lmplot.html

이제 데이터를 학습 데이터(train_df, X_train, y_train)와 테스트 데이터(test_df, X_test, y_test)로 나눕니다. 단, 학습과 테스트에는 구(district)와 동(dong)의 실제 지명은 중요하지 않으므로, 삭제한 다음 나눕니다.

이제 Decision Tree 모델을 생성해보겠습니다. preprocessing.LabelEncoder()로 생성된 le를 fit_transform()하면 중복된 레이블들이 하나로 통합된 One-Hot Encoding된 레이블들로 인코딩됩니다. 이제 인코딩된 레이블과 학습 데이터를 DecisionTreeClassifier에 넣어 모델을 생성해보겠습니다. 사실 Decision Tree의 모델은 사이킷런에 이미 다 구현되어 있으며 tree.DecisionTreeClassifier().fit(학습 데이터와 인코딩 된 레이블)을 통해 모델을 생성할 수 있습니다. DecisionTreeClassifier()에는 다양한 매개변수들이 존재하는데, 이 매개변수들의 쓰임새와 사용 방법은 아래에서 알아보겠습니다. 이제 학습된 모델을 시각화해보겠습니다. 2차원 그래프에 deicision boundary를 그리고, 다른 색상으로 표현하여 구간을 구분해보겠습니다.

구간을 나눠 모델을 시각해보니, 학습 데이터에만 아주 잘 맞게끔 학습된 과적합 상태임을 알 수 있습니다.

학습된 모델을 시각화해보니, 데이터별로 색상에 맞게 decision boundary가 잘 형성된 상태임이 보입니다. 하지만 과연 좋은 모델이라고 할 수 있을까요? 빨간색으로 분류된 강북 지역의 경우, decision boundary가 둘로 나뉘어 있습니다. 이 점이 말하는 바는 즉 모델이 학습 데이터에만 너무 딱 맞게끔 학습하다보니, 과적화된 모델이 생성되었다는 의미입니다. 예를 들어 가장 높은 latitude를 갖는 강북 지점에서 longitude를 살짝만 낮추면, 사실 강북에 가깝다고 보는 것이 맞지만 이 모델에서는 강동으로 분류할 것 입니다. 다른 말로는 학습에는 없는 임의의 데이터에 대해서는 정확도가 낮을 것 입니다. 이전 Decision Tree 포스트에서 설명했듯 Decision Tree는 과적합되기 매우 쉬운 모델입니다. 모든 특징을 독립적으로 사용하기 때문에 하나의 데이터 포인트의 영향이 모델에 미치는 영향이 큽니다. 이는 이전 SVM 모델에서 gamma값이 커지게 되면 decision boundary가 작아지며 데이터에 맞춰 구부러지는 것과 같습니다. 이제 DecisionTreeClassifier()의 매개변수들이 필요한 차례입니다. tree.DecisionTreeClassifier()의 매개변수들을 잘 이용하면 과적합을 방지할 수 있는데, 이번에는 4가지의 매개변수를 이용하여 모델의 과적합을 해소해보겠습니다. 쓰이는 매개변수들은 다음과 같습니다.

모델 과적합을 방지하고자 DecisionTreeClassifier()에 사용되는 매개변수

max_depth, 트리의 최대 한도 깊이를 제한하는 매개변수입니다. 트리의 깊이가 깊다는 의미는 특징들을 세세하게 분류하고 있다는 의미입니다. 스무고개에서 세 네번만에 정답을 맞출 수도 있지만, 스무번까지 질문을 하면 정답의 폭이 굉장히 좁아집니다. 정답의 폭이 굉장히 좁다는 것은 다르게는 과적합되어 있다는 의미로 해석할 수 있습니다. 보다 일반적인 decision boundary를 위해, 트리의 최대 한도 깊이를 줄이는 것 또한 좋은 방법입니다. max_depth와 마찬가지로 min_samples_split와 min_sample_leaf를 설정하며, random_state는 사실 모델의 과적합과는 별개로 난수 seed를 직접 설정하여 같은 값에 대해 동일한 학습 결과를 만드는 매개변수입니다. 이제 이 매개변수들을 활용해 과적합을 방지한 모델을 학습해보겠습니다.

매개변수를 활용해 새로 학습한 모델. 조금 더 좋은 decision boundary로 분류되어 있습니다.

학습된 모델을 시각화해보니 실제 임의의 데이터들을 넣어도 괜찮을법한 좋은 모델이 된 것으로 보입니다. 이제 학습 트리를 시각화해보겠습니다. Decision Tree 시각화에 graphviz를 사용할 것이며 사용된 매개변수에 대한 설명은 아래 사진에서 확인할 수 있습니다.

out_file: 파일로 변환의 여부. feature_names: 사용되는 특징들의 이름. filled: 그림에 색상을 넣는지의 여부. rounded: 반올림 여부. special_characters: 특수문자 사용 여부

gini: 불순도 척도, 낮을 수록 순도가 높음. samples: 노드 안에 있는 데이터들의 개수. values: 레이블 별 데이터의 개수. class: 레이블

마지막으로 생성한 모델을 테스트해서 정확도를 측정하고, 실제 값과 예측 값을 비교해보겠습니다. 정확도가 1.0인 것을 보니 모든 예측이 맞았음을 알 수 있습니다. 실제로 Decision Tree는 각각의 특징들을 독립적으로 사용하기 때문에 데이터의 크기가 너무 크지만 않다면, 매우 높은 정확도를 보입니다.

Decision Tree 실습 - 지니 계수 및 서울 지역 다중 분류 (1)

어른이프로그래머 — Wed, 19 Jan 2022 16:00:56 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다

이번 포스트에서는 Decision Tree를 활용해 서울 지역 위치 정보를 데이터로 서울 지역을 강동, 강서, 강남, 강북 네 군집으로 다중 분류해보겠습니다. 이전 Deicision Tree에서 우리는 ID3 알고리즘은 정보 이득(information gain)과 엔트로피(entrophy)를 이용하는 알고리즘임을 알아봤습니다. 반면 사이킷런의 Decision Tree는 CART(classification and regression tree) 타입으로, CART는 트리의 노드마다 특징을 이진 분류(Binary classification)하는 특징이 있어 일반적으로 지니 계수를 사용합니다. 지니 계수는 데이터의 통계적 분산 정도를 표현한 값으로, 다시 말해 데이터 군집의 불순도를 측정하는 지표입니다. 지니 계수가 높을수록 군집 내 데이터들의 속성들이 많이 일치한다는 뜻으로, 순도가 높다고 표현하며 반대로 지니 계수가 낮을수록 순도가 낮습니다. 따라서 CART 알고리즘은 지니 계수가 높은 방향으로 Decision Tree의 노드를 구성합니다. 사진을 보고 보스베이비와 성인 남자를 구분하는 예시를 들어보겠습니다. 다음의 표는 보스베이비와 성인 남자를 구분하기 위한 데이터입니다.

이름	정장을 입었는가?	검은색 머리인가?	레이블
보스베이비	예	아니오	보스베이비
이상인	아니오	예	성인 남성
보스베이비	예	아니오	보스베이비
보스베이비	예	아니오	보스베이비
권수현	예	예	성인 남성
배승준	예	예	성인 남성

검은색 머리인지를 먼저 물어본다면, 보스베이비와 성인 남성을 한 번에 분류할 수 있습니다. 반면, 정장을 입었는지를 먼저 물어본다면, 다시 한번 검은색 머리인지를 물어봐야만 두 군집을 정확히 분류할 수 있습니다. 따라서 이번에는 검은색 머리인지를 먼저 물어보는 것이 더 효율적이며, 이처럼 데이터 분류에는 엔트로피를 최소로 하는, 다른 말로는 높은 지니 계수를 갖도록 영향력이 큰 특징을 상위 노드로, 영향력이 작은 특징을 하위 노드로 선택하는 것이 중요합니다. 그렇다면 이제 엔트로피와 정보이득, 지니 계수를 실제로 계산해보겠습니다.

질문 하나만으로 보스베이비를 구분할 수 있습니다!

Entrophy, Information gain

이전 포스트에서 엔트로피와 정보 이득에 대해 자세히 설명하였기 때문에, 짧게 알아보겠습니다. 공식은 다음과 같습니다.

정보 이득과 엔트로피를 구하는 과정

엔트로피를 통해 정보 이득을 구하니, 검은색 머리를 상위 노드 특징으로 하는 것이 효율적임을 알았습니다.

지니 계수(Gini coefficient)

지니 계수를 구하는 과정은 더욱 간단합니다. 지니 계수는 순도와 비례하며, 순도가 높다는 뜻은 한 군집에 모여있는 데이터들의 속성이 많이 일치한다는 뜻임을 생각하며 다음의 과정을 보겠습니다. 먼저 지니 계수를 통해 의사결정 트리의 노드를 결정하는 순서는 다음의 두 단계가 끝입니다.

1. 특징으로 분리된 두 노드의 지니 계수를 구함 (P^2 + Q^2)

2. 특징에 대한 지니 계수를 구함

지니 계수로 계산한 효율적인 상위 노드 또한 검은 머리 특징입니다.

지니 계수는 계산과 이해가 쉽다는 장점이 있습니다. 사이킷런을 이용하면 엔트로피나 지니 계수의 수식을 이해하지 않고서도 Decision Tree를 만들 수 있으나, 최적화를 위해서는 수학적인 이해도 꼭 필요합니다. 의사결정 트리는 이해도 쉽고 사용하는 것도 쉽지만 오버피팅되기 쉬운 모델입니다. 웬만해선 모든 특징을 반영하게 되며 따라서 지니 계수를 이용하는 CART 알고리즘을 사용할지, 엔트로피와 정보 이득을 사용하는 ID3 알고리즘을 사용할지를 잘 선택해야 하며 트리의 깊이는 어느 정도로할지 등 다양한 상황을 고려하여 최적의 의사결정 트리 모델을 생성하는 것이 중요합니다. 또한 의사결정 트리는 다중 분류(Multiclass classification)에도 탁월한 성능을 보이는데, 다음 포스트에서는 서울 지역 위치 정보를 데이터로 서울 지역을 강동, 강서, 강남, 강북 네 군집으로 다중 분류하는 모델을 생성해보겠습니다.

머신러닝 모델의 성능을 알아보자

어른이프로그래머 — Sat, 8 Jan 2022 19:00:27 +0900

이 포스트는 허민석 님의 저서 "나의 첫 머신러닝/딥러닝"의 내용을 정리하였습니다.

저번 포스트에서 우리는 아래와 같이 사이킷런의 classifiaction_report와 accuracy_score를 사용하여 SVM 모델의 정확도를 측정해봤습니다. 정확도(accuracy) 0.95는 한눈에 들어오지만 classification_report에 나오는 precision, recall, f1-score 지표들은 한눈에 들어오지 않아 이해에 어려울 수 있습니다. 이번 포스트에서는 precision, recall, f1-score 등 다양한 머신러닝 모델의 평가 방법을 알아보고, 최종적으로는 아래의 표를 해석해보겠습니다.

시작에 앞서, 이해를 위해 선행되는 5가지에 대해 알아보겠습니다.

1. 혼동 행렬(confusion matrix)

혼동 행렬은 지도 학습으로 훈련된 분류 알고리즘의 성능을 시각적으로 나타낸 표입니다. 행은 예측값을, 열은 실제값을 (혹은 그 반대) 나타내며 예를 들어 손으로 쓴 알파벳을 보여줬을 때 알파벳을 알아맞히는 머신러닝 모델의 혼동 행렬을 보겠습니다. 아래 표의 행은 예측값을, 열은 실제값을 의미합니다.

실제 \ 예측	A	B	C	D
A	9	1	0	0
B	1	15	3	1
C	5	0	24	1
D	0	4	1	15

위의 혼동 행렬을 분석해보면, A를 10번 보여줬을 때, 9번은 A로 정확히 예측했으나 1번은 B로 잘못 예측했습니다. B를 20번 보여줬을 때는 15번을 B로 정확히 예측했으며 1번은 A, 3번은 C, 1번은 D로 잘못 예측했습니다. 동일한 방법으로 C, D에 대해서도 분석할 수 있으며, 혼동 행렬을 통해 모델이 B를 C로, C를 A로, D를 B로 잘못 예측하는 빈도가 다소 잦다는 정보를 얻고서 모델의 성능을 높이는 방법을 찾을 수 있습니다.

2. TP (True Positive) - 맞는 실제값을 올바르게 예측한 것

TP는 혼동행렬에서 실제값 A를 A로 정확히 예측한 경우를 말합니다. 위의 혼동 행렬에서 빨간색으로 표시된 대각선이 부분이 TP입니다.

TP는 정답인 예측을 말하며, 이제부터 이해를 위해 실제값을 파란색, 예측값을 빨간색으로 표시하겠습니다.

실제 \ 예측	A	B	C	D
A	9	1	0	0
B	1	15	3	1
C	5	0	24	1
D	0	4	1	15

3. TN (True Negative) - 틀린 실제값을 올바르게 예측한 것

TN은 틀린 것을 틀렸다고 올바르게 예측한 것으로, A클래스에 대한 TN은 실제값 A가 아닌 것을 A가 아니라고 올바르게 예측한 경우를 말합니다. A 클래스에 대한 TN은 A가 아닌 클래스들에 대해 A가 아니라고 예측한 값들을 의미하며, 아래 표에서 색깔로 표시된 칸들에 해당합니다. TP와 달리 클래스 별로 TN이 따로 존재합니다.

실제 \ 예측	A	B	C	D
A	9	1	0	0
B	1	15	3	1
C	5	0	24	1
D	0	4	1	15

4. FP (False Positive) - 틀린 실제값을 맞다고 잘못 예측한 것

FP는 틀린 것을 맞다고 잘못 예측한 것으로, A 클래스에 대한 FP는 실제값 A가 아닌 것을 A가 맞다고 잘못 예측한 경우입니다. 다시 말해 A클래스의 FP는 A에 대해 A가 아닌 B, C, D를 A로 잘못 예측한 값들입니다.

실제 \ 예측	A	B	C	D
A	9	1	0	0
B	1	15	3	1
C	5	0	24	1
D	0	4	1	15

5. FN (False Negative) - 맞는 실제값을 틀렸다고 잘못 예측한 것

FN은 맞는 것을 틀렸다고 잘못 예측한 것으로, A 클래스에 대한 FN은 A라는 실제값을 A가 아니라고 예측한 경우입니다. 아래는 A 클래스의 FN을 표현했으며, TP를 제외한 나머지 값들이 클래스 별 FN에 해당합니다.

실제 \ 예측	A	B	C	D
A	9	1	0	0
B	1	15	3	1
C	5	0	24	1
D	0	4	1	15

TP, TN, FP, FN은 많이 헷갈릴 수 있습니다. 따라서 한 클래스를 예로 들며 한 문장으로 정리하며 이해하면, 혼동을 줄일 수 있습니다. 예를 들어 A 클래스에 대해 TP, TN, FP, FN은 순서대로 "A에 대해 A라고 예측", "A가 아닌 것에 대해 A가 아니라고 예측", "A가 아닌 것에 대해 A라고 예측", "A에 대해 A가 아니라고 예측"이라는 한 문장으로 정리할 수 있습니다. 혼동 행렬과 TP, TN, FP, FN에 대해 완벽히 이해되었다면, 이제 모델의 성능을 평가하는 지표에 대해 하나씩 알아보겠습니다.

1. 정확도 (accuracy)

정확도는 보편적으로 사용되는 모델 성능을 평가하는 지표로, 모델이 입력된 데이터에 대해 얼마나 정확히 예측하는지를 나타냅니다. 위의 혼동 행렬에서 보면 A를 A라고 정확히 예측, B를 B라고 정확히 예측하는지 등에 해당하며, 이는 TP로 따라서 정확도는 TP를 전체 셀로 나눈 값입니다.

실제 \ 예측	A	B	C	D
A	9	1	0	0
B	1	15	3	1
C	5	0	24	1
D	0	4	1	15

정확도: (9 + 15 + 24 + 15) / 80 = 0.78

2. 정밀도 (precision)

정밀도는 모델의 예측값이 얼마나 정확하게 예측되었는지를 나타내는 지표입니다. 교재의 암환자 예측 모델의 예를 들어 이해해보겠습니다. 아래의 표에서 행으로 나열된 암환자, 일반 환자는 예측값, 열으로 나열된 암환자, 일반 환자는 실제값입니다.

실제 \ 예측	암환자	일반환자
암환자	9	1
일반환자	30	60

암 예측 모델 A의 혼동행렬

실제 \ 예측	암환자	일반환자
암환자	1	9
일반환자	20	70

암 예측 모델 B의 혼동 행렬

예측 모델 A, B 중 어떤 모델이 더 좋은 모델로 볼 수 있을까요? 위에서 알아본 정확도(accuracy)를 지표로 두 모델을 비교해보면, A 모델의 정확도는 (9 + 60) / 100 = 0.69, B 모델의 정확도는 (1 + 70) / 100 = 0.71로 B 모델이 더 좋은 모델으로 판단할 수 있습니다. 하지만 데이터의 특성상, 우리는 단순히 정확도에 중점을 두지 않고 암이라고 예측했을 때, 예측이 더 정확한 모델을 선호할 것입니다. 암이 아님에도 모델이 암으로 예측했다면, 당장 불필요한 치료들을 받아야 하는 위험이 있습니다. 이처럼 정밀도는 예측값이 얼마나 실제값에 정확한지를 나타냅니다. 아래는 정밀도를 구하는 공식이며, 공식에서 TP는 "암환자를 암환자로 정확히 예측한 경우", FP는 "일반 환자를 암환자로 잘못 예측한 경우"에 해당합니다. 실제로 계산한 모델 A의 암환자 정밀도는 9 / (9+30) * 100 = 23%, 모델 B의 암환자 정밀도는 1 / (1+20) * 100 = 4.7%로, 정밀도 측면에서 A가 B에 비해 더 좋은 모델로 볼 수 있습니다.

정밀도(precision) = TP / (TP + FP)

3. 재현율 (recall)

재현율은 실제값 중 모델이 정확히 예측한 값의 비율을 나타내는 지표입니다. 암환자 예측 모델에서 암환자 재현율은 실제 암환자들이 모델에서 암환자로 예측되는 비율입니다. 정밀도와 헷갈릴 수 있는데, 정밀도는 예측값의 시점에서 실제값을, 재현율은 실제값의 시점에서 예측값을 판단한다고 생각하면 이해에 도움이 될 수 있습니다. 따라서 재현율과 정밀도는 서로 Trade-off 되는 성격을 지니며, 아래의 재현율을 구하는 공식에서 TP는 "암환자를 암환자로 정확히 예측한 경우", FN은 "암환자를 일반 환자로 잘못 예측한 경우"에 해당합니다.

실제 \ 예측	암환자	일반환자
암환자	9	1
일반환자	30	60

실제 \ 예측	암환자	일반환자
암환자	1	9
일반환자	20	70

재현율(recall) = TP / (TP + FN)

실제로 계산해보면 모델 A의 암환자 재현율은 9 / (9 + 1) * 100 = 90%, 모델 B의 암환자 재현율은 1 / (1 + 9) * 100 = 10%로, 재현율을 측면에서 A가 B에 비해 더 좋은 모델로 볼 수 있습니다.

4. F1 score

정밀도와 재현율 모두 중요한 수치로 상황에 따라 무엇을 쓸지 고민될 수 있습니다. 데이터에 따라 정밀도를 사용하는 것이 합리적으로 보일 때 재현율을 사용했다면, 위에서 말했듯 둘은 Trade off 되는 특성이 있으므로 자칫 잘못 사용하면 원하는 모델을 선택하지 못할 수 있습니다. 이런 이유로 나온 F1 score는 정밀도와 재현율을 조화 평균 내어 하나의 수치로 나타낸 지표입니다. A, B의 조화 평균의 공식은 2AB / (A+B)이며 아래 그래프의 교차점에 해당합니다.

A와 B의 조화평균: 2AB / (A+B)

따라서 재현율과 정밀도의 조화 평균인 F1 score의 공식은 아래와 같습니다. F1 score는 정밀도와 재현율의 특징을 모두 포함하므로 정확도와 함께 성능 평가에 많이 사용됩니다. 그렇다면 정확도와 F1 score는 각각 어떤 경우에 자주 사용될까요?

F1 score = 2 * precision * recall / (precision + recall)

먼저 정확도는 데이터 레이블의 분포가 균일할 때 주로 사용합니다. 레이블의 분포가 균일하다면 모든 레이블에 대해 비슷한 성능을 보여주는 것이 보장되므로, 이 때는 정확도를 주로 사용합니다. 하지만 아래의 표에서처럼 레이블이 불균일하게 분포되어 있을 때는 정확도는 왜곡된 성능 평가를 보여줍니다. 이러한 경우에는 F1 score를 사용하여 더 나은 모델을 판단합니다. 아래의 예시를 보겠습니다.

모델 1 실제 \ 예측	A	B	C	D
A	995	5	0	0
B	8	0	1	1
C	10	0	0	1
D	0	1	9	0

위의 표의 모델 1은 A 레이블에 대해서는 잘 맞추지만 B, C, D 레이블에 대해서는 하나도 맞추지 못하고 있습니다. 또한 A 레이블에 해당하는 데이터의 비율이 압도적으로 많아, 좋은 모델로 볼 수 없음에도 정확도는 (995 + 0 + 0 + 0) / 1030 * 100 = 96.6%로 매우 높은 수치를 보입니다. 또한 아래 표의 모델 2에서도 비록 예측 수준은 높아졌지만, 여전히 레이블이 데이터 상에서 불균일하게 분포되어 있는 모습을 보입니다. 그렇지만 한 눈에 봐도 모델 1에 비해서는 좋은 모델으로 평가되어야 하지만, 모델 1과 모델 2를 정확도 측면에서만 평가하자면 모델 1의 정확도는 96.6%인 반면, 모델 2의 정확도는 70.5%로 모델 1이 더 좋은 모델로 잘못 판단할 수 있습니다.

모델 2 실제 \ 예측	A	B	C	D
A	700	100	100	100
B	0	9	1	0
C	0	0	9	1
D	0	1	0	9

이제 모델 1과 모델 2를 F1 score를 계산해 비교해보겠습니다. 먼저 A, B, C, D의 클래스 별 재현율과 정밀도를 계산하여 표에 추가합니다.

모델 1 실제 \ 예측	A	B	C	D	재현율(recall)
A	995	5	0	0	0.99
B	8	0	2	2	0
C	10	0	0	1	0
D	0	1	9	0	0
정밀도(precision)	0.98	0	0	0

모델 2 실제 \ 예측	A	B	C	D	재현율(recall)
A	700	100	100	100	0.7
B	0	9	1	0	0.9
C	0	0	9	1	0.9
D	0	1	0	9	0.9
정밀도(precision)	1	0.08	0.08	0.08

먼저 모델 1의 평균 정밀도는 (0.98 + 0 + 0 + 0) / 4 = 0.245, 평균 재현율은 (0.99 + 0 + 0 + 0) / 4 = 0.2475로, F1 score를 구하면 2 * 0.245 + 0.2475 / (0.245 + 0.2475) = 0.246입니다. 반면 모델 2의 평균 정밀도는 (1 + 0.08 + 0.08 + 0.08) / 4 = 0.31, 평균 재현율은 (0.7 + 0.9 + 0.9 + 0.9) / 4 = 0.85로, F1 score는 2 * 0.31 * 0.85 / (0.31 + 0.85) = 0.454로 모델 1에 비해 큽니다. 따라서 레이블이 정확도의 측면이 아닌 F1 score로 두 모델을 비교했을 때, 원하는 "모델 2가 모델 1에 비해 더 좋은 모델입니다"라는 결론을 얻을 수 있습니다.

이제 이전 포스트의 2020-21 시즌 NBA 농구선수들의 포지션 예측 SVM 모델을 사이킷런의 classification_report를 사용하여 평가한 결과표를 해석해보겠습니다.

먼저 표에서 우리는 레이블 별 precision(정밀도), recall(재현율)의 결괏값, 이를 조화 평균 낸 f1-score를 확인할 수 있습니다. support는 레이블의 실제 샘플의 수를 알려줍니다. 이전 포스트에서 실제값과 SVM 모델의 예측값을 비교한 아래의 데이터 프레임을 보면,

실제 레이블을 담은 grount_truth에는 C(센터) 레이블이 7개, SG(슈팅 가드) 레이블이 13개의 샘플이 있음을 알 수 있습니다.

정확도 accuracy는 0.95를 확인하고 보니, 처음 보는 macro avg와 weighted avg가 있습니다. 순서대로 macro avg는 샘플 레이블 수의 불균형을 무시한 채 클래스 별 동일한 가중치를 두고서 평균을 낸 지표입니다. recall의 macro avg를 확인하면 샘플 레이블 수 support가 C와 SG가 서로 다름에도, 두 클래스에 동일한 가중치를 두어 두 값을 단순 평균 낸 0.96(recall macro avg = (1.00 + 0.92) / 2)이 나옵니다. 반면 weighted avg는 샘플 레이블 수의 불균형을 고려하여 표본의 수를 가중치로 두어 평균 낸 값입니다. 동일하게 recall의 weighted avg를 확인하면, 샘플 레이블의 수 7, 13을 각각의 precision에 곱한 다음 더하여 전체 레이블 수 20으로 나눠줍니다.(recall weighted avg = (1.00 * 7 + 0.92 * 13) / 20) 결과적으로 macro avg는 샘플 레이블의 수를 무시한 채 모든 클래스 별 동일한 가중치 1을 두고 계산하기 때문에 소수 샘플 클래스의 성능이 낮을 때 그 영향력이 커 전체 평균값이 낮아지는 모습을 보이지만, weighted avg는 샘플 레이블 수를 가중치로 두어 계산하기 때문에 소수 샘플 클래스의 영향력이 작아 전체 값에 미미한 영향을 미치는 모습을 보입니다.

SVM(Support Vector Machine) 실습 - 농구 선수 포지션 예측

어른이프로그래머 — Sat, 8 Jan 2022 00:00:20 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다.

이번 포스트는 SVM(Support Vector Machine) 모델로 kNN 알고리즘에서처럼 2020-21 시즌 NBA 농구 선수의 포지션을 예측해보겠습니다. 데이터 크롤링과 EDA 과정은 이전 포스트에서 다뤘으므로, 모델을 생성하는 작업부터 시작하겠습니다. 먼저 필요한 라이브러리들을 임포트한 다음, 2020-21 NBA 농구 선수들의 데이터를 읽어 들여 판다스 데이터 프레임의 형태로 생성합니다. kNN EDA 과정에서 찾은 분별력이 떨어지는 특징들을 데이터 프레임에서 제거한 다음 전체 데이터를 학습 데이터와 테스트 데이터로 분리했습니다.

이번 SVM 실습에서는 RBF 커널을 사용하며 먼저 두 parameter(C, gamma)의 최적값을 찾아야 합니다. C와 gamma에 대해 다시 짚고 넘어가겠습니다. 비용(C)은 얼마나 많은 데이터가 다른 클래스(오류)에 놓이는 것을 허용하는지를 조정하는 변수로 비용이 낮을수록 margin을 최대한 높이고 train error를 증가하는 방향으로 decision boundary를 설정하며, 반대로 비용이 높을수록 margin을 줄이고 train error를 감소하는 방향으로 decision boundary를 설정합니다. 비용을 낮추면 margin이 높아져 다소 범용적인 decision bounary를 갖는다는 장점이 있지만 과소적합을 유의해야 하며, 반대로 비용을 높이면 margin이 낮아져 학습 데이터에 대해 높은 정확도를 보이지만 과대적합의 위험이 있습니다. gamma는 kernel의 표준 편차를 조절하는 변수로, gamma가 작을수록 데이터 포인트가 decision boundary에 미치는 영향이 커져 decision boundary가 완만한 기울기를 보이며 반대로 gamma가 클수록 데이터 포인트의 영향이 작아져 decision boundary가 작아지며 구부러집니다. 비용과 마찬가지로 gamma가 작을수록 과소적합의, gamma가 클수록 과대적합의 문제를 유의해야 합니다. 우리는 Grid Search 방법으로 k-fold 교차검증을 통해 최적의 C와 gamma를 구할 것입니다. GridSearhCV()를 보면, estimator로 SVM의 classifier인 SVC()가 사용되었으며 튜닝할 파라미터들(kernel, gamma, C)을 딕셔너리 형태로 만들어 GridSearchCV()에 넣습니다. 이때 k-fold 교차검증의 값을 10(cv=10)으로 설정합니다. GridSearchCV()는 사이킷런에 구현되어 있는 최적의 파라미터를 구하는 함수로, 함수 인자들에 대한 자세한 설명은 다음의 공식 문서에서 확인할 수 있습니다. 생성된 객체 clf에서 fit() 메소드를 실행하면, 교차 검증 성능이 가장 좋은 최적의 parameter를 찾아주고 활용하여 train 데이터에 대한 새로운 모델을 자동으로 생성합니다. 시각화에 편하고자 이번엔 3점 슛과 블로킹, 두 특징만 사용하여 최적의 parameter와 교차 검증 점수를 확인해보니, C : 1, gamma : 0.1, accuracy : 0.875라는 결과를 얻었습니다.

최적의 C와 gamma를 구했으니, decision boundary를 만들 수 있습니다. 이전에, 최적의 C와 gamma의 1/100과 100배에 해당하는 값들에 대해서도 모두 확인해보기 위해 값들을 C_candidates와 gamma_candidates에 저장한 모든 조합에 대해 학습된 모델을 classifiers에 저장하여 시각화해보겠습니다. 시각화를 위해 편의성을 생각하여 센터(C)를 1, 슈팅가드(SG)를 2로 표현하였으며 matplotlib로 시각화한 차트는 아래와 같습니다.

GridSearchCV()의 k-fold 교차 검증 방식으로 최적의 C, gamma를 구했습니다.

C와 gamma 조합으로 만든 차트를 시각화하여 표현했습니다. 9개의 차트 중 가장 가운데에 있는 차트가 최적화된 C와 gamma로 생성된 차트입니다.

위의 9개의 차트 중, 가장 가운데에 있는 차트가 바로 GridSearchCV()를 통해 얻은 최적의 C와 gamma로 학습된 모델입니다. 파란색 부분과 빨간색 부분 사이의 흰색 부분에 있는 decision boundary를 기준으로 보면, 두 데이터의 군집이 균등하게 분류되어 있는 것을 확인할 수 있습니다. 이제 최적의 parameter만으로 생성한 모델 clf를 사용하여 테스트해보겠습니다. 사이킷런의 classification_report와 accuracy_score를 활용하면 모델의 accuracy 뿐만 아니라 정밀도(precision), 재현율(recall), f1-score까지 모두 확인할 수 있습니다. 정밀도, 재현율, f1-score 등의 모델 성능 평가는 다음 포스트에서 다루며 그때 다시 지금의 표를 분석해보겠습니다. accuracy는 0.95로 매우 높은 수치이며, 실제 데이터 프레임을 생성하여 실제값과 SVM 모델의 예측값을 비교하면 한 선수를 제외하고선 모두 정확한 예측을 했음을 알 수 있습니다. 물론 이 수치는 런타임을 다시 실행시마다 테스트 데이터와 훈련 데이터가 랜덤 하게 분류되므로 다를 수 있으니, 코드 실행 시 결괏값이 조금은 다를 수도 있습니다. 하지만 주목할 점은 최적의 parameter를 찾는 과정에서 모델 생성 과정까지 어렵지 않았음에도, 매우 높은 정확도를 보이는 점에서 SVM은 이전 포스트에서 첫 줄에 설명했듯이 "SVM은 kNN, Decision Tree와 마찬가지로 주로 classification을 위해 사용되는 알고리즘으로, 이해하기 어렵지 않은 알고리즘에 비해 성능이 매우 우수하여 지도학습 머신러닝 알고리즘으로 자주 사용됩니다."는 말이 실습을 통해 확실히 이해될 것입니다.

SVM(Support Vector Machine)

어른이프로그래머 — Fri, 7 Jan 2022 04:00:03 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다.

이번 포스트에서는 SVM, 서포트 벡터 머신 알고리즘에 대해 알아보겠습니다. SVM은 kNN, Decision Tree와 마찬가지로 주로 classificaion을 위해 사용되는 알고리즘으로, 이해하기 어렵지 않은 알고리즘에 비해 성능이 매우 우수하여 지도학습 머신러닝 알고리즘으로 자주 사용됩니다. 서포트 벡터 머신은 적은 데이터에 대해서 다른 알고리즘에 비해 높은 정확도를 내며 예측 속도가 빠르고, 뒤에서 알아볼 커널 트릭을 통해 다양한 feature를 갖는 데이터를 분류하기 쉽다는 장점이 있습니다. 그렇다면 SVM 알고리즘은 무엇이고 어떤 동작 원리로 실행되는지 알아보겠습니다.

이해를 돕고자 교재의 서울의 어느 지역이 강북인지, 강남인지를 구분하는 예시를 들어 설명하겠습니다. 우리는 현재 서울에서 용산, 이태원, 한남, 금호, 동작, 반포, 신사, 압구정을 여행했습니다. 아래의 그래프는 X, Y축을 동쪽과 북쪽으로 설정한 다음 강북의 용산, 이태원, 한남, 금호를 O, 강남의 동작, 반포, 신사, 압구정을 X로 표현한 그래프입니다. 만약 우리가 강북과 강남을 구분 지을 수 있는 한강의 위치를 2차원 공간의 선으로 표현할 수 있다면, 새로 여행할 성수동이 강북인지, 강남인지 구분할 수 있을 것입니다. 이때 데이터를 구분하는 선, 여기서는 한강을 곧 SVM의 decision boundary(결정 경계)라고 합니다. 단순히 강북과 강남이 구분되기만 하면 되니, 선으로 표현할 수 있는 한강의 후보는 다양합니다. 아래 그림에서 보라색으로 표시된 한강의 위치 후보1의 선과 위치 후보2의 선 둘 모두 강북과 강남을 구분할 수 있으니, 두 후보 선은 SVM 알고리즘의 decision boundary라고 말할 수 있습니다. 하지만 kNN에서 최적의 k를 찾는 것이 중요한 문제였듯이, SVM에서도 최적의 decision boundary를 찾는 것이 중요합니다. 그렇다면 후보 1과 후보 2 중 더 좋은 decision boundary는 어떤 것 일까요? 후보 1은 decision boundary와 강북, 강남의 데이터 중 가장 가까운 데이터 간의 거리가 후보 2에 비해 넓습니다. 후보 2의 decision boundary는 지금의 데이터에서는 가장 잘 학습된 경계선이지만, 용산에서 조금 내려간 이촌을 자칫 강남 지역으로 잘못 예측하는 등 테스트 및 새로운 데이터에 대해서는 정확도가 낮을 수 있습니다. 따라서 후보 1의 decision boundary가 더 좋다고 볼 수 있습니다.

서울의 지역들을 북쪽(N), 동쪽(E)에 따라 설정한 지도입니다.

한강 후보1 (왼쪽)과 후보2 (오른쪽)

이제 우리는 "SVM은 최적의 decision boundary를 찾으면 새로운 데이터에 대해서도 쉽게 예측할 수 있겠다"는 결론을 낼 수 있습니다. 그렇다면 앞으로 최적의 decision boundary은 어떻게 찾는지, 1차원 공간의 혹은 3차원 그 이상의 다차원 공간의 데이터에 대해서는 어떻게 처리하는지에 대해 알아보겠습니다. 그보다 먼저 SVM에서 2차원 공간의 벡터에 대해 짚고 넘어가겠습니다. 벡터는 크기와 방향을 갖는 선으로, 비록 위의 그래프에서 한남동을 하나의 점으로 표현했지만, 실제로는 서울 최서남단의 (0,0) 지점에서 시작해 (5,5) 지점으로 향하는 벡터입니다. 따라서 이해를 위해 용산을 O, 반포를 X 점으로 표현했지만, 실제로는 (0,0) -> (1,4)의 벡터, (0,0) -> (3,1)의 벡터라고 이해하는 것이 정확합니다. 위에서 후보 1은 decision boundary에서 가장 가까운 한남, 압구정 사이 간격이 넓은 반면 후보 2는 용산, 압구정 사이의 간격이 매우 좁다고 했는데, 이처럼 decision boundary의 최전방 데이터 포인트인 한남과 압구정, 용산과 압구정을 Support Vector라고 하며 Support Vector와 decision boundary 사이의 거리를 margin이라고 합니다. SVM에서는 margin을 최대로 하는 decision boundary를 찾는 것이 목표이며, margin이 클수록 새로운 데이터에 대해서 안정적으로 분류할 가능성이 높습니다.

이제 vector로 표현된 데이터들의 Support Vector를 찾아 margin을 최대로 하는 decision boundary를 설정하는 것이 끝일까요? 사실, 실제 데이터에는 outlier(이상치)들이 존재합니다. 강남과 강북을 구분 짓는 것은 사실 한강 위치 하나의 속성만으로 결정지어도 큰 문제가 없지만, 이전 포스트에서 kNN 알고리즘 실습에서처럼 3점 슛을 많이 득점한 센터 포지션의 농구 선수도, 리바운드를 많이한 슈팅 가드 포지션의 농구 선수도 존재합니다. 그러면 이러한 outlier들에 대해서도 하나 하나 모두 학습하면 되지 않을까요? 이 문제에 대해서는 예전 포스트에서 Cost와 Overfitting, Underfitting에 대해 다룬 적이 있었습니다. 간단히 말하자면, 아래의 오른쪽 그림2과 같이 군집을 벗어난 outlier들에 대해 모두 학습할 경우, Overfitting(과대적합)으로 인해 테스트 및 새로운 데이터에 대해서는 오류를 낼 가능성이 더욱 높아집니다. 오히려 왼쪽 그림1는 outlier를 제외하고보면 margin이 그림 2에 비해 큽니다. 결국 궁극적인 목표는 테스트와 새로운 데이터에 대해 높은 정확도를 보이는 모델을 생성하는 것이기 때문에, 모델 설계 시 학습 데이터에 대해서만 에러가 적게끔 설정하는 것은 좋은 방법이 아닙니다. 그림1에서 X를 O라고 분류하는, 학습 모델의 오류를 허용하기 위해 decision boundary와 margin의 간격을 어느 정도로 할지를 결정하는 cost(비용, C)를 사용합니다. cost는 얼마나 많은 데이터가 다른 클래스에 놓이는 것을(오류) 허용하는지를 결정하는 변수입니다. cost가 낮을수록, margin을 최대로 하고 학습 에러율을 증가하는 방향으로 decision boundary를 설정하는 것이 합리적입니다(soft margin). 반면 cost가 높을수록, margin을 낮추고 학습 에러율을 감소하는 방향으로 decision boundary를 설정하는 것이 바람직합니다(hard margin). 따라서 적절한 cost를 찾아 과소적합과 과대적합을 일어나지 않도록 하며 최적의 decision boundary를 설정하는 것이 중요합니다.

위, 아래의 서포트 벡터 사이의 마진이 넓은 왼쪽의 decision boundary에 비해, 오른쪽은 좁습니다.

결국 SVM에서 가장 중요한 것은 decision boundary를 찾는 것입니다. 위의 예시에서 2차원 공간에서 decision boundary는 선으로 표현되었습니다. 그렇다면 항상 decision boundary는 1차원 선의 개념일까요? 사실 decision boundary는 (벡터 공간 차원 - 1)차원으로 정해집니다. 2차원 좌표계 공간에서 decision boundary는 1차원 선으로 존재하는 반면, 3차원 공간의 데이터에서 decision boundary는 2차원의 면으로 존재합니다. 이러한 이유로 decision boundary는 때로 hyperplane으로 불리기도 하며 아래의 수식으로 표현할 수 있습니다.

Decision boundary = (Vector Dimension - 1)D

그렇다면 1차원 데이터의 decision boundary는 0차원의 점으로 표현해야 합니다. 하지만 아래 그림에서처럼 직선 상의 O와 X를 구분 짓는 점 형태의 decision boundary를 찾으라고 한다면, 누구도 적절한 정답을 낼 수 없을 것입니다. 어느 지점에 놓아도 학습 모델의 오류가 너무 높아 과소적합이 발생할 것이며 새로운 데이터에 대해서 에러율이 높을 것입니다.

이러한 문제로 인해 SVM에서는 주어진 저차원 벡터 공간의 데이터 벡트들을 고차원 벡터 공간으로 매핑하여 옮긴 다음 decision boundary를 찾는 작업을 진행합니다. 예를 들어, 1차원 선 상의 데이터(x)들을 2차원 데이터로 매핑하면 y축이 생기게 됩니다. y = x^2라는 함수를 통해 1차원 데이터들을 매핑한다면 데이터는 (-2, 4) 등의 2차원 벡터로 표현할 수 있으며, 아래의 그림에서처럼 데이터들을 2차원 좌표계에 그려 적절한한 decision boundary를 찾을 수 있습니다.

1차원의 데이터를 2차원에 매핑하여 decision boundary를 찾을 수 있습니다.

물론 한 차원 상위의 2차원 공간에 매핑될 때도 데이터는 벡터의 형태로 매핑되며, 저차원 데이터를 고차원 데이터로 매핑하고자 사용한 y = x^2을 Mapping function(매핑 함수)이라고 합니다. 하지만 실제로 데이터를 고차원의 데이터로 매핑하고자 한다면 데이터의 양이 너무 많아 계산량이 많아지므로 속도가 느려져 사용하는 것에 제한적입니다. 따라서 실제로 데이터를 고차원의 데이터 형태로 매핑하지는 않으며 동일한 효과로 빠른 속도로 decision boundary를 찾는 방법을 고안했으며, 이 방법이 바로 kernel trick(커널 트릭)입니다.

kerenl의 parameter로 위에서 언급한 cost와 gamma를 조절하여 decision boundary의 margin을 조절할 수 있습니다. gamma는 일전에 언급했던 overfitting을 피하고자 Regularization의 cost function에 (lambda)*(∑w^2)를 더해주는 것처럼, kernel에서의 gamma는 데이터 포인트의 영향이 미치는 범위로, decision boundary의 곡률을 조정하는 parameter입니다. gamma가 적을 경우에는 하나 하나의 데이터 포인트가 영향을 끼치는 범위가 넓어지지만, gamma가 높을 경우에는 데이터 포인트가 영향을 끼치는 범위가 좁아집니다. 아래 그림을 보면 gamma = 0.01일 때는 그 범위가 넓어져 파란색 범위와 빨간색 범위가 넓은 범위로 나타나지만, gamma = 100이되면 그 데이터 포인트 바로 주위에만 영향을 끼치게 되어 파란색 범위와 빨간색 범위가 데이터 포인트에 한정적입니다. 따라서 gamma가 커질수록 decision boundary가 학습 데이터에 맞게끔 구부러지는 모습을 보이며, gamma가 작아질수록 decision boudnary가 일반적으로 직선의 모습을 띄게 됩니다. 이는 cost와 마찬가지로 overfitting과 underfitting의 문제를 불러올 수 있으며 따라서 cost와 gamma를 조정하며 overfitting과 underfitting에 대처하여 최적의 decision boundary를 선택하는 것이 중요합니다. 아래의 표는 최적의 cost와 gamma parameter를 찾는 Grid Search의 예시입니다.

출처: 허민석 님의 유튜브, [머신러닝] SVM(서포트 벡터 머신)

cost \ gamma	1	10	100
1	0.7	0.8	0.7
10	0.8	0.8	0.9
100	0.6	0.8	0.8

마지막으로 SVM 알고리즘의 장단점을 알아보겠습니다. 먼저, kernel trick을 사용하여 features가 많은 데이터를 분류하는 데에도 강합니다. N-features의 데이터는 N차원 공간의 데이터 포인트 벡터로 표현되고, N+1 차원의 공간에서 hyperplane을 찾아 데이터 분류가 가능하기 때문입니다. 또한 overfitting과 underfitting을 parameter(cost, gamma)를 조절하여 대처할 수 있으며 적은 학습 데이터로 학습 시에도 높은 정확도를 보입니다. 하지만 그만큼 데이터 전처리 과정이 상당히 중요하며 특성이 많아질 수록 데이터와 decision boundary를 시각화하여 표현하는 것이 어렵습니다.

이번 포스트에서는 SVM 알고리즘에 대해 알아보았습니다. 다음 포스트에서는 SVM 알고리즘을 실제로 실습해보며 kNN 알고리즘에서와 같이 2020-21 시즌 농구 선수의 포지션을 SVM 알고리즘을 활용하여 예측해보겠습니다.

kNN(k-Nearest Neighbors) 알고리즘 - 농구선수 포지션 예측(2)

어른이프로그래머 — Mon, 3 Jan 2022 04:00:38 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다.

이전 포스트에서는 2020-21 시즌 NBA 농구 선수의 실제 데이터를 담은 사이트에서 크롤링하여 판다스의 데이터 프레임의 형식으로 가공한 다음, csv 파일을 생성해봤습니다. 이번에는 데이터 시각화 및 분석 이후 kNN 모델을 생성한 다음 예측 및 평가를 진행해보겠습니다. 실습 환경은 Google Colab에서 진행하였으며, 실습 코드 및 데이터는 위 링크의 Github에서 받아볼 수 있습니다.

그렇다면 이제 코드를 보겠습니다. 필요한 라이브러리들을 임포트 한 다음, 먼저 만들어 둔 csv 파일을 읽어 판다스 데이터 프레임 형태로 생성합니다. kNN은 scikit-learn에 이미 구현되어 있으므로 단순히 sklearn 라이브러리를 임포트 해서 쓰면 됩니다. 먼저 데이터 구성을 살펴보겠습니다. 실제 사이트에서는 28개의 속성이 있지만, 우리는 이미 학습에 필요할 것으로 예상되는 속성들만 크롤링해왔기 때문에 당장은 더 이상 데이터를 가공하지 않아도 될 것으로 보입니다. 학습 레이블의 수를 확인한 다음, matplotlib를 이용해 속성들을 2차원에 표현해보겠습니다.

필요한 라이브러리들을 임포트한 다음, 깃허브에 있는 csv 파일을 읽어들여 판다스 데이터 프레임 형태로 만듭니다.

수집된 데이터의 상위 5개 샘플과 학습 레이블(포지션)의 분포를 확인합니다.

아래 사진처럼 2차원 좌표에 속성들을 묶어 표현해봤습니다. O는 C(센터), X는 SG(슈팅 가드)이며, 데이터 시각화의 목적은 학습에 불필요한 속성을 제거하는 것에 있습니다. 스틸 횟수와 2점슛, 어시스트 횟수와 2점 슛을 그린 아래 두 사진의 그래프를 보면, 센터 포지션과 슈팅 가드 포지션이 비슷한 수준으로 분포되어 있어 두 포지션을 구별하는 변별력이 떨어지는 것으로 보이는 반면, 블로킹과 3점 슛, 리바운드와 3점 슛의 분포를 그린 그래프에서는 두 포지션이 나름의 구별되는 군집을 이루고 있습니다. 실제 농구에서 2점 슛은 센터 포지션과 슈팅 가드 포지션 모두 득점을 많이 하지만, 3점 슛은 슈팅 가드의 주요 역할 중 하나로, 페인트존 내에서 플레이를 주로 하는 센터에 비해 더 많습니다. 반면 리바운드는 센터 포지션이 훨씬 많습니다. 이렇게 우리는 데이터를 시각화하여 필요한 속성이 무엇인지, 불필요한 속성이 무엇인지 구별해낼 수 있었습니다. 사실 속성별 필요/불필요 구분은 직접 그래프를 그려보며 확인해봐도 되지만, 미리 가설을 세운 다음 가설이 맞는지 검증해보는 것도 좋은 방법입니다. 예를 들면 "센터 포지션은 페인트존 내에서 주로 활동하므로 리바운드 횟수가 슈팅 가드에 비해 많을 것이다"는 가설을 세운 다음 두 속성을 그려본 다음, 두 속성은 학습에 필요한 속성인 것을 확인하는 것과 같습니다.

포지션 별 스틸과 2점슛의 분포

포지션 별 어시스트와 2점슛의 분포

포지션 별 블로킹과 3점슛의 분포

포지션 별 리바운드와 3점슛의 분포

그렇다면 분별력이 떨어져 학습에 불필요한 속성인 2점슛과 어시스트, 스틸을 데이터 프레임에서 삭제한 다음, 다시 데이터 프레임을 확인해보면, 이제 우리는 3점 슛, 리바운드, 블로킹의 속성으로 모델을 학습할 것임을 알 수 있습니다. 그다음 학습 데이터와 테스트 데이터를 8:2의 비율로 분리하겠습니다. 데이터를 분리하는 작업도 이미 sklearn 내 train_test_split()의 함수로 구현되어 있습니다. 테스트 데이터 사이즈를 결정짓는 test_size를 0.2로 설정한 다음 실행하면, train에는 전체 데이터의 80%, test에는 전체 데이터의 20%로 분리되어 저장되어 있음을 알 수 있습니다.

2점슛, 어시스트, 스틸 속성을 데이터 프레임에서 삭제한 다음 학습 데이터와 테스트 데이터를 분리합니다.

이제 kNN 알고리즘을 적용하여 모델을 생성하기 위해, 가장 중요한 작업인 최적의 K를 찾는 작업을 진행하겠습니다. 최적의 K를 찾는 방법으로 가장 많이 사용되는 것은 검증 데이터를 사용해 가장 예측율이 높은 K를 찾는 것입니다. 위에서 분리한 테스트 데이터(test)와 sklearn의 cross_val_score를 사용하여 kNN 모델의 k-fold 교차 검증을 진행할 것입니다. k-fold 교차 검증에 대해 잠시 알아보면, 머신러닝의 모델을 테스트 하기 이전, 검증 단계에서 모델의 성능을 짐작해볼 수 있습니다. 실제 모델을 생성 시에는 오랜 시간과 큰 비용이 소모되므로, 매번 함수 인자 값을 변경하며 모델 성능을 직접 테스트하는 것은 굉장히 비효율적입니다. 일반적으로 모델 검증에는 검증 데이터를 활용하는데, 예를 들어 위에서처럼 전체 데이터를 20%의 테스트 데이터와 80%의 학습 데이터로 나눈 이후, 학습 데이터에서 다시 90%를 실제 학습 데이터, 10%를 검증 데이터로 활용합니다. 이처럼 검증 데이터는 전체 데이터에 비해 굉장히 작은 비율이기 때문에, 전체 데이터가 크지 않다면 검증 데이터를 한 번 사용하여 모델 성능을 평가 시에는 지엽적이거나 한쪽에 편증된 데이터가 사용될 수 있다는 측면에서 검증 정확도를 신뢰하기 어렵습니다. 이때 사용할 수 있는 방법이 k-fold 교차 검증으로, 학습 데이터의 일정 부분을 검증 데이터로 활용하되 n번의 검증 과정으로 모든 학습 데이터를 한 번씩 검증 데이터로 사용할 수 있게끔 하는 방법입니다. k = 10이라고 한다면 k-fold 교차 검증에서는 학습 데이터를 비반복으로 10%씩 분리하여 검증 데이터로 활용하여 검증 결과를 낸 다음, 이들을 평균 낸 값을 사용합니다. 이렇게 되면 학습 데이터는 전체 데이터의 80%에 해당하는 만큼, 충분한 검증이 이루어졌다고 볼 수 있으며 한쪽으로 편증된 데이터들 또한 평균값으로 회귀되기 때문에 전반적으로 신뢰할 수 있는 검증 결과를 얻을 수 있습니다. 다시 돌아와 최적의 k를 찾기 위해 k의 범위를 3부터 학습 데이터의 절반까지로 지정한 다음 k=10의 k-fold 교차 검증을 수행하여 검증 결과를 저장한 다음, k 값에 따른 정확도를 그래프로 그려보겠습니다.

k의 범위를 정한 다음 최적의 k를 찾는 k-fold 교차 검증을 수행합니다.

가장 높은 검증 정확도를 보이는 k를 찾습니다.

그래프를 그려 확인해보니 k = 5일 때 검증 정확도가 가장 높은 것을 알 수 있습니다. 이제 최적의 k를 찾은 다음, 모델을 학습하고 미리 분리해둔 테스트 데이터로 모델을 검증하는 일만 남았습니다. 미리 짚고 넘어가자면 학습 데이터와 테스트 데이터는 무작위로 분리되기 때문에 실행마다 최적의 k 값이 달라질 수 있습니다.

모델을 학습하고 테스트하여 예측 정확도를 출력합니다.

sklearn에 구현되어 있는 kNeighborsClassifier()의 n_neighbors를 미리 찾은 최적의 k값을 넣은 다음 3P, BLK, TRB 속성과 Pos 레이블로 모델을 학습하여 테스트한 다음 정확도를 출력하니 0.85(85%)의 정확도를 보입니다. 테스트 데이터 선수의 3P, BLK, TRB 값을 토대로 포지션을 예측한 결과와 실제 포지션을 비교해본 결과가 100개 중 85개 수준으로 일치했다는 것은 모델 생성에 힘들지 않았음에도 유의미하고 괜찮은 정확도를 보였다고 볼 수 있습니다. 실제로 예측값과 실제값을 비교한 데이터 프레임을 확인해보면 20명 중 3명의 포지션 예측만 틀렸음을 알 수 있습니다. 모든 센터 포지션 선수들이 3점슛에 약하거나 모든 슈팅가드 포지션 선수들이 리바운드가 적은 것은 아닐 것이므로, 실제로 kNN 알고리즘 모델은 훨씬 더 좋은 평가를 받을 수 있을 것입니다.

이번 포스트에서는 데이터를 시각화하여 불필요한 속성을 제거하여 kNN 알고리즘 모델을 생성하고 학습하는 과정에서, k-fold 교차 검증까지 알아보았습니다. 사실 kNN 알고리즘은 기존 데이터와의 거리를 계산하여 예측하기 때문에, 연산 과정이 많아 예측 속도가 느리지만 별도의 모델 학습이 필요없습니다. 따라서 게으른 학습(lazy learning)으로도 불리며, 실시간 데이터를 사용할 때 유용하게 사용됩니다. 이처럼 kNN 알고리즘의 장단점을 확실히 알고서 모델을 적절히 사용한다면 쉬운 과정으로도 높은 예측율을 얻을 수 있습니다.

kNN(k-Nearest Neighbors) 알고리즘 - 농구선수 포지션 예측(1)

어른이프로그래머 — Sun, 2 Jan 2022 07:30:03 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다. 실습 코드와 자료는 링크의 Github에서 볼 수 있습니다.

이번에는 2020-21 시즌 NBA 농구 선수들의 데이터를 사용하여 특정 농구 선수의 포지션을 kNN 알고리즘으로 예측해보겠습니다. 데이터는 NBA 농구 선수들의 데이터에서 추출하였으며 우리는 특정 선수의 포지션을 예측하고 레이블과 비교하여 정확도를 측정해보겠습니다. 원래 실습은 2017 NBA 농구선수의 데이터를 사용하지만 이번 포스트는 2022년에 작성되었기 때문에 2020-21 시즌의 데이터로 실습하며, 파이썬을 활용한 데이터 크롤링부터 데이터 가공, 시각화의 과정을 모두 담고자 했습니다.

위 링크의 사이트에 접속하면, 다음의 표를 볼 수 있습니다.

baseket-ball reference

우리의 일차적인 목표는 웹 페이지의 정보들을 가져와 판다스의 데이터 프레임의 형태로 가공한 다음, csv 파일로 생성하는 것입니다.

웹 페이지의 정보들을 가져오는 작업이 바로 크롤링으로, 인공지능뿐만 아니라 데이터와 관련된 모든 분야에서 크롤링은 매우 중요한 작업입니다. 파이썬에서는 이미 크롤링을 위한 다양한 라이브러리들이 준비되어 있는데, 이번엔 BeautifulSoup를 사용하여 크롤링을 하겠습니다. 참고로 파이썬의 크롤링 라이브러리는 대표적으로 BeautifulSoup, Selenium, Scrapy 등이 있으며 각각의 장단점이 있습니다. 예를 들어 지금처럼 정적인 페이지에서 단순히 데이터만 크롤링하기에는 빠르고 단순한 BeautifulSoup가 효과적이지만, 동적인 페이지 혹은 웹 페이지를 실제로 띄운 다음 페이지를 제어하는 것은 Selenium으로 할 수 있습니다. 따라서 보통 크롤링 시에는 BeautifulSoup와 Selenium을 적절한 상황에 조합하여 사용하는 경우가 많지만 이번에는 단순히 정적인 페이지에서의 텍스트 데이터만 가져오는 작업이기 때문에, BeautifulSoup만을 사용하여 크롤링했습니다. 다음의 실습 코드와 csv 파일은 링크의 깃허브에서 받아볼 수 있습니다.

필요한 라이브러리를 임포트한 다음, 웹 페이지의 url을 변수에 넣어 저장해놓습니다. BeautifulSoup 등의 외부 라이브러리는 따로 설치가 필요합니다. 이제 웹 페이지 링크에서 BeautifulSoup의 object를 생성하는데, lxml은 파이썬에서 사용되는 내부적으로 트리 구조를 가지는 마크업 언어인 XML을 해석하는 프로그램(parser)입니다. 다음의 그림을 보면 이해가 쉬울 것입니다. mac os 기준 웹 페이지에서 option + command + u를 누르면 다음의 창을 볼 수 있을 것입니다.

mac : option + command + u

웹 페이지의 HTML 소스를 볼 수 있습니다. 이제 왼쪽 위의 나침반 모양의 버튼을 클릭한 다음 표 전체 부분이 파란색 박스로 되는 위치에 놓고 클릭하면, 표의 소스를 볼 수 있습니다.

파란색 박스로 색칠되어 있는 부분이 표에 해당하는 소스입니다.

아래의 사진처럼 펼쳐보며 아래 소스 위에 마우스를 올리며 웹 페이지를 보면 노란색 박스 부분으로 색칠되어 우리는 어느 소스가 표의 어느 부분에 해당하는지 알 수 있습니다. 물론 HTML에 대한 기초적 지식이 있다면 좋지만, 소스를 자세히 보면 보라색 글씨의 <thead>, <tr>, <th></th>를 볼 수 있습니다. 모두 table 태그로, HTML에서 표를 구성하는 요소들입니다. <thead>로 시작했다면 </thead>로 닫아줘야 하며, 마찬가지로 <tr>로 시작했다면 </tr>로 닫아줘야 합니다. 이러한 구성이 위에서 말한 트리 구조를 가진의 XML 형식입니다. 먼저 BeautifulSoup의 find_all 함수를 사용하여 표의 제목인 Rk, Player, Pos, Age 등의 정보를 쉽게 추출할 수 있습니다.

아래 코드를 보면 th, tr의 table 태그를 볼 수 있습니다. 우리는 이번 크롤링에서 HTML에 대한 자세한 지식까지 필요로 하지는 않지만, 기초 지식이 다소 필요하다는 부분이 이러한 면입니다. 코드를 그대로 해석해보면 "행을 만드는 table row 태그 중 첫 번째(표의 제목 부분이 저장되어 있습니다.)에서 table head 태그를 찾아, 해당 태그의 텍스트를 리스트로 만든다"로 해석할 수 있습니다. 바로 위의 사진을 보며 이해하면, <tr> 하위의 <th>에서 형광색 부분의 Rk, Player, Pos 등의 텍스트를 추출하며, 이렇게 만든 headers 리스트를 출력해보면 정상적으로 데이터를 추출했음을 알 수 있습니다. 이제 우리는 크롤링하여 추출한 데이터를 보며 Player(선수 이름), Pos(포지션), 3P(3점 슛), 2P(2점 슛), TRB(리바운드), AST(어시스트), STL(스틸), BLK(블로킹)의 데이터만을 사용할 것을 판단할 수 있습니다.

이제 각 행의 데이터를 추출해보겠습니다. 이번에는 <thead> 아래의 <tbody>를 살펴보면, <tr class="full_table data-row="0">을 볼 수 있습니다. 사실 해당 웹 페이지를 처음 열면 아래 사진에서처럼 Rk 5, 6, 7등이 한 선수임에도 불구하고 팀을 옮기며 기록이 따로 적혀 있습니다. 노란색으로 그어진 Hide Partial Rows를 클릭하면 되지만, 우리는 이러한 버튼 클릭 여부 하나만을 위해 Selenium을 사용하고 싶지는 않습니다. 그렇다면 페이지 소스를 조금 자세히 들여다보겠습니다.

Rk 5, 6, 7은 모두 한 선수입니다

class name으로 구분되어 있습니다.

소스를 자세히 들여다보면, class=""부분에서 차이가 있는 것을 알 수 있습니다. 마우스를 갖다 대며 확인해보면 "full_table"은 Hide Partial Rows를 눌렀을 시 나타나는 행의 클래스만을 표현하며, "italic_text partial table"은 한 선수의 중복된 기록까지 담은 클래스임을 눈치챌 수 있습니다. 그렇다면 우리의 목표는 100명의 서로 다른 선수들의 데이터를 추출하는 것임으로 full_table이라는 class name 속성을 이용하면, 원하는 데이터만 추출할 수 있습니다. 또한 마찬가지로, 위에서 Player, Pos, 3P, 2P, TRB 등의 속성들만 추출하고자 했는데 이 또한 아래 그림처럼 data-stat이라는 속성을 지정해주면, 우리는 "웹 페이지의 표에서 원하는 데이터만 따로 추출하여 파이썬의 리스트로 저장"하는 작업을 완료할 수 있습니다. 코드와 그림을 동시에 보며 이해하면 보다 쉬울 것입니다.

이제 리스트에 저장된 데이터들을 pandas의 데이터 프레임 형식으로 만든 다음 csv 파일로 저장하겠습니다. 그보다 먼저 이번 실습에서는 kNN 알고리즘의 효율성을 보여주고자 농구 모든 포지션이 아닌 서로의 역할이 꽤 차이나는 센터(C)와 슈팅가드(SG) 포지션 각각 50명씩, 총 100명의 데이터에 대해서만 레이블을 갖도록 하겠습니다. 이를 위해 판다스의 데이터 프레임으로 만든 다음, Pos열의 C와 SG만 따로 뽑아내어 상위 50명의 데이터 프레임을 생성한 다음, 두 데이터 프레임을 다시 합치는 형식의 작업을 거칠 것입니다. 이는 특히 어렵지는 않기 때문에 코드와 결과를 보며 간략히 말하겠습니다.

미리 생성해둔 col_name을 제목으로 df를 만들었으며 df['Pos'] == 'C', df['Pos'] == 'SG'로 두 포지션에 해당하는 선수들의 데이터만 50명씩 따로 뽑았으며, 두 데이터 프레임을 하나의 useful_df 데이터 프레임으로 합친 다음 csv 파일로 저장했습니다. 이제 다음 포스트에서는 크롤링으로 만든 csv 파일을 활용하여 농구 선수 포지션 예측하는 모델을 만드는 작업을 하겠습니다.

Decision Tree + ID3 알고리즘

어른이프로그래머 — Fri, 24 Dec 2021 03:05:46 +0900

이 포스트는 허민석 님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다.

kNN, 최근접 이웃법 알고리즘에 이어 이번 포스트에서는 Decision Tree(결정 트리, 의사결정 트리)와 ID3(Iterative Dichotomiser 3) 알고리즘에 대해 알아보겠습니다.

전 포스트에서 kNN 알고리즘을 설명하며 유유상종이라는 사자성어를 예로 들어 설명했는데, 이번에는 Decision Tree를 쉽게 이해하기 위해 스무고개를 예로 들어보겠습니다. 우리는 스무고개를 할 때 예 / 아니오에 해당하는 질문을 통해 후보군을 좁혀 나갑니다. 아래의 그림처럼 정답이 "보스 베이비"라고 할 때 먼저 첫 번째 질문으로 "사람인가요?"를 했다면, "아니오"라는 답변을 통해 후보군을 사람이 아닌 분류로 좁혀나갈 수 있습니다. 다음 질문으로 "애니메이션에 나오는 캐릭터인가요?"에 대해서는 "예", 그다음 질문으로 "캐릭터가 성인인가요?"에 "아니오"라는 답변을 받았다면, 정답이 될 수 있는 후보를 굉장히 많이 좁힐 수 있습니다. 마지막으로 "캐릭터가 정장을 입고 있나요?"라는 질문을 한다면, "예"라는 대답과 함께 우리는 정답이 보스 베이비임을 맞출 수 있습니다. 이렇듯 스무고개와 동일한 방식으로 어떤 특징(Feature)이나 속성(Attribute)을 통해 나무 구조로 나타내며 데이터를 분류하는 방식이 Decision Tree(결정 트리) 알고리즘입니다.

Boss Baby!

이제 허민석 님의 유튜브 영상에 나오는 "겨울에 찍은 가족사진 찾기"를 Decision Tree를 통해 찾아보겠습니다. 먼저 우리는

1. 컴퓨터에게 무엇을 해야 하는지를 알려줘야 합니다. 이 과정에는 define problem(겨울에 찍은 가족사진 찾기)과 collect training data(train data로 8개의 사진 모으기)이 포함됩니다. 위의 설명대로 겨울에 찍은 가족사진을 찾는 문제 상황을 정의하고, 훈련 데이터로 사용될 데이터들을 모읍니다. 현재 8장의 훈련 데이터 사진이 있으며, 이 중 겨울에 찍은 가족사진을 찾는 것이 컴퓨터에게 요구됩니다. 왼쪽 위에서부터 1, 2, 3, 4, 왼쪽 아래에서부터 5, 6, 7, 8이라고 하겠습니다.

collect training data, 출처 : 허민석 님의 머신러닝 유튜브

이제 우리는 2. Decision Tree를 생성합니다. 이때 우리는 먼저 extract data(속성을 정한 다음 사진별 데이터 추출) 다음 build a tree(결정 트리 생성) 작업을 합니다. 데이터의 속성이 데이터 추출 및 분류에 굉장히 중요한 점으로, 이번에는 만화 캐릭터인지(cartoon caracter?), 겨울인지(winter?), 사진에 나오는 인물이 1명 이상인지(more than 1?)의 속성으로 데이터를 추출하겠습니다. 이제 우리는 표로 정리하여 데이터를 한눈에 볼 수 있으며 속성들을 토대로 결정 트리를 생성할 수 있습니다.

img	cartoon caracter?	winter?	more than 1?
1	No	Yes	No
2	Yes	No	Yes
3	Yes	No	Yes
4	No	Yes	No
5	No	No	Yes
6	No	Yes	Yes
7	Yes	No	Yes
8	No	Yes	No

이제 Decision Tree를 만듭니다. 사실 Decision Tree를 만들 때는 어떤 속성을 먼저 사용하는지에 따라 효율성이 달라지는데, 이 내용은 조금 있다 ID3 알고리즘을 알아볼 때 수학적으로 분석해 볼 것입니다. 지금은 attribute의 순서대로 Decision Tree를 그려보면 아래의 그림과 같습니다.

Decision Tree, winter family photo를 정확히 예측하고 있습니다. 출처: 허민석 님의 머신러닝 유튜브

이제 Decision Tree를 토대로 3. deploy machine(머신이 작동하며 학습하는 작업)과 4. 테스트 데이터들에 대한 테스트를 거치게 됩니다. 여기까지가 Decision Tree 알고리즘 작동 방식에 대한 설명이며, 처음 말했던 것처럼 스무고개를 생각하면 이해가 보다 쉬울 것입니다.

이제 보다 효율적인 Decision Tree를 위해서는 어떻게 해야 할까요? 먼저 불순도(impurity)와 엔트로피(entrophy)에 대해 이해하고 넘어가겠습니다. 우선 불순도는 한 범주 내 다른 범주의 개체들이 얼마나 포함되어 있는지에 대한 지표입니다. 반대되는 개념으로는 순도(purity)가 있으며, 아래의 그림을 보면 항아리 1과 3에는 파란색 공과 빨간색 공들만 들어 있으나, 항아리 2에는 파란색 공들과 빨간색 공들이 섞여 있는 모습을 볼 수 있습니다. 항아리 1과 3은 불순도 0%, 순도 100%이며 항아리 2는 불순도가 높고 순도가 낮은 상태라고 말할 수 있습니다.

항아리 1과 3은 한 색깔의 공들만 있는 반면, 항아리 2에는 두 색의 공들이 섞여 있습니다. 이 경우 불순도가 높은 상태라고 판단됩니다.

불순도를 수치화한 지표에는 엔트로피가 대표적입니다. 엔트로피는 특정 정보에 대한 불확실성을 의미하며, 한 단어로 복잡함을 의미합니다. 방이 어지러운 상태면 방의 엔트로피가 높은 상태이고, 잘 정리 정돈되어 있는 상태면 엔트로피가 낮은 상태라고 말할 수 있습니다. 불순도를 엔트로피로 수치화하여 최적의 Decision Tree를 생성하는 알고리즘이 이제부터 알아볼 ID3 알고리즘이며, ID3는 Iterative Dichotomiser 3의 약자로, 이분하다는 뜻의 프랑스어인 Dichotomiser을 토대로 해석해보면, "반복적으로 이분하는 알고리즘"이라는 의미이며 결국 불순도가 낮은 방향으로, 다시 말해 엔트로피가 낮은 방향으로 Decision Tree를 구성하는 것이 효율적임을 의미합니다. 위의 "겨울에 찍은 가족사진 찾기" 예시를 보며 설명하겠습니다.

처음 8장의 사진에서, 분류에 어떤 속성을 사용하느냐에 따라 분류되는 사진의 수가 달라지는 것을 확인할 수 있습니다. 예를 들어 위의 왼쪽 사진에서처럼 "Cartoon Character?" 속성이 분류 기준으로 사용된다면 Yes / No 분류기를 거쳐 남는 사진은 4개입니다. 반면 중간과 오른쪽 사진에서처럼 "Winter?"과 "More than 1?" 속성이 분류 기준으로 사용된다면 분류기를 거쳐 남는 사진은 5개가 됩니다. 물론 "최종적으로 남는 데이터는 어차피 하나이므로 큰 차이가 없지 않나요?" 하는 의문점이 들 수 있지만, 실제 모델을 만들어 학습 시에는 데이터의 양이 방대하므로 분류기를 거쳐가며 남는 데이터의 개수가 가장 작아지는 속성을 사용하는 것이, 다른 말로 엔트로피가 가장 작아지는 속성을 사용하는 것이 효율적인 알고리즘이라고 할 수 있습니다. 또한 ID3에는 information gain(정보 획득)의 개념을 알아두어야 하는데, information gain은 base entrophy에서 new entrophy을 뺀 것을 의미합니다. 예를 들어 위 사진의 왼쪽에서 분류 이전 사진의 개수(base entrophy)는 8개이며, 속성 "Cartoon Character?"로 분류한 뒤 남은 사진의 개수(new entrophy)는 4개로, 정보 획득은(had 8 pictures - now just 4 left, 8-4) 4입니다. 결과적으로 entrophy는 적은 방향으로, information gain은 큰 방향으로 속성을 선택하는 것이 중요하다고 할 수 있습니다. 이해를 돕기 위해 사진의 개수로 엔트로피를 설명했지만, 실제 엔트로피는 공식에 의해 수치적으로 계산되며, 엔트로피를 통해 information gain을 계산한 다음 최적의 속성을 선택하여 알고리즘을 구성하게 됩니다. 이제부터 처음 상태의 엔트로피와 첫 번째 단계를 거친 다음의 엔트로피 계산을 통해 information gain을 얻은 다음, 어떤 속성이 information gain이 가장 높은지(다른 말로 가장 효율적인 첫 번째 분류 속성을 찾는 과정입니다) 알아보겠습니다.

먼저 처음 상태의 엔트로피(base entrophy)를 계산해보겠습니다. 공식에서 p는 확률을 의미하며 p(+)는 분류기에 통과된, p(-)는 분류기에서 걸러진 사진으로 이해하는 것이 좋습니다. 엔트로피를 구하는 공식은 다음과 같습니다.

Entrophy([+, -]) = -p(+) log(p(+)) -p(-) log(p(-)), Binary Logarithm

base entrophy

base entrophy는 위의 과정을 통해 0.543을 구할 수 있습니다. 이제 각 속성별 new entrophy를 구해 최종 information gain을 얻는 과정을 살펴보겠습니다. 각 속성별 new entrophy는 자세한 계산과정은 생략한 채, p(+)와 p(-)에 집중하여 보는 것이 좋습니다.

information gain = base entrophy - new entrophy

new entrophy를 구하는 과정에서 엔트로피 앞부분에 해당 속성이 선택될 확률(1번에서, E(winter family photo, cartoon)을 구하는 과정에서 E([0+, 4-]) 앞의 p(4/8)를 의미합니다)을 곱하는 부분에 유의하며 이해하면, 쉽게 이해할 수 있을 것입니다. 물론 우리는 직관적으로 "Cartoon Character?" 속성을 먼저 선택하는 것이 유리하다고 판단할 수 있지만, 컴퓨터는 엔트로피 계산 과정을 통해 information gain을 구하는 과정을 거쳐 information gain이 가장 높은 속성인 "Cartoon Character?"를 선택합니다.

이번 포스트에서는 Decision Tree와 ID3 알고리즘을 엔트로피 개념으로 접근해 수학적으로 알아보았습니다. 다음 포스트에서는 SVM(Support Vector Machine)에 대해 알아보겠습니다.

kNN(k-Nearest Neighbors) 알고리즘

어른이프로그래머 — Thu, 23 Dec 2021 04:30:14 +0900

이 포스트는 허민석님의 유튜브 머신러닝 내용을 정리한 글입니다. 실습 코드는 도서 나의 첫 머신러닝/딥러닝에서 발췌해왔습니다.

앞으로의 포스트에서는 kNN, Decision Tree, SVM, Naive Bayes 등의 ML supervised learning 알고리즘을 알아볼 테며, 이번에는 kNN 알고리즘에 대해 알아보겠습니다.

kNN(k-Nearest Neighbors), 최근접 이웃법 알고리즘은 ML의 supervised learning 중 한 알고리즘으로, supervised learning(지도 학습)은 classification(분류)과 regression(회귀)로 나뉘며 이때 kNN 알고리즘은 주로 classification, 분류를 위해 사용되는 알고리즘입니다. 참고로 kNN 알고리즘의 군집화, labeling 되는 특징 때문에 unsupervised learning의 clustering(군집화)과 헷갈릴 수 있는데, 이미 관측되고 학습된 데이터들이 존재한다는 점에서 차이점이 있습니다.

kNN 알고리즘을 설명할 때 흔히들 "유유상종"이라는 표현을 많이 인용합니다. 유유상종은

"본시 같은 류의 새가 무리 지어 사는 법입니다."

라는 의미의 속담이며 이를 토대로 이해하면 kNN 알고리즘은 k개의 근접한 새들이 포함된 새의 무리를 찾는 알고리즘입니다.

예를 들어 영화 스파이더맨: 노 웨이 홈이 액션 영화에 포함되는지, 로맨스 영화에 포함되는지 알아보고자 합니다. 우리는 이미 많은 액션 영화와 로맨스 영화를 보고서 해당 영화들의 스킨십 횟수와 싸우는 횟수를 데이터화 했다고 하겠습니다. 이를 토대로 그린 아래의 그래프에서 X축은 skinship count, Y축은 fight count, 로맨스 영화는 x, 액션 영화는 o, 스파이더맨은 *입니다.

skinship, fight count로 분류한 액션 영화, 로맨스 영화와 스파이더맨

먼저, 그림의 1과 2를 보겠습니다. 우리는 직관적으로 1은 Action movie, 2는 Romance movie의 범주에 들어갈 것임을 예측할 수 있으며 실제 학습에서도 동일한 예측이 나올 것입니다. 하지만 * 모양의 스파이더 맨을 보면, 어떤 이들은 skinship count만 보면 Romance movie로 분류해야 한다고 보는 반면 다른 이들은 fight count에 따라 Action movie로 분류해야 한다고 볼 수도 있습니다. 이렇듯 새로운 데이터에 대해 분류하고자 할 때는 약속된 분류 기준이 필요하며, 우리는 kNN 알고리즘을 사용하여 해결할 수 있습니다.

먼저 최근접점 k를 정해야 합니다. 이때 정하는 k는 "분류할 새로운 데이터(*)로 부터 원을 그렸을 때 포함되는 데이터의 수"로 이해하는 것이 좋습니다. k는 1 이상의 수로, 동률을 방지하고자 보편적으로 홀수를 사용합니다. 실제 k = 1에서부터 k 값을 늘려가며 데이터 *를 기준으로 하는 원을 그려보겠습니다.

k = 1, Action moive로 분류됩니다.

k = 1일 때입니다. *를 중심으로 하고 근접점이 하나가 포함되도록 원을 그렸을 때, 스파이더 맨은 액션 영화로 분류될 것입니다.

k = 2, 1:1 동률인 상황으로 문제가 발생합니다.

k = 2일 때, 원안에 포함되는 데이터가 각각 하나씩 나와 문제가 발생합니다. 물론 거리상 가까운 데이터(직관적으로는 액션 영화 데이터가 로맨스 영화 데이터에 비해 더 가까워 보입니다)의 분류를 따르거나 랜덤 값을 주어 선택하는 방법도 있지만, 보편적으로는 지향하지 않기 때문에 미리 언급했던 것처럼 홀수를 선택하는 것이 좋습니다.

k = 3, 2:1로 Action movie로 분류됩니다.

최종적으로 정한 k의 값을 3으로 했을 때 원 안에 포함되는 데이터는 액션 영화 2, 로맨스 영화 1로, 스파이더맨은 액션 영화로 분류될 것입니다. 이때 처음 드는 의문점이 몇 가지 있을 것입니다. 먼저 "k의 값이 1일 때와 3일 때, 결국 스파이더 맨은 액션 영화로 분류될 것인데 k를 늘려가며 모두 확인해봐야 하는 이유가 있나?" 하는 의문이 들 수도 있습니다. 이는 over fitting(과적합)과 관련이 있으며, over fitting에 대해 궁금하시다면 이전에 over fitting에 대해서 설명한 포스트를 참고하시는 것을 추천드립니다. 다시 돌아와, 극단적인 예시를 들어 k = 1일 때의 문제를 보겠습니다.

k = 1로 정했을 때의 over fitting

우리는 그래프를 봤을 때 스파이더 맨에 근접한 로맨스 영화들이 있지만, 그래도 액션 영화의 범주에 가깝다고 판단할 수 있습니다. 하지만 k = 1로 정한 다음 학습했을 때, 컴퓨터는 최근접한 로맨스 영화의 데이터를 토대로 스파이더 맨을 로맨스 영화로 예측할 것입니다. 이는 원하는 결과가 아닙니다. 심지어 k = 3으로 했을 때도 로맨스 영화로 예측할 것입니다. 이때 적당한 k값은 5라고 할 수 있습니다.

k = 5일 때, 괜찮은 예측을 할 수 있습니다.

그렇다면 k값이 클수록 좋은 것일까요? 그렇다고 할 수는 없습니다. k값이 과도하게 크다면, under fitting(과소 적합)의 문제가 발생합니다. 위의 그림에서 학습 데이터들은 액션 영화 6개, 로맨스 영화 7개로 13개입니다. 이때 극단적으로 k = 13(13이 큰 수는 아니지만, 현재 예시에서는 데이터 세트 전체에 해당하는 수입니다)으로 설정한 다음 학습한다면, 학습 데이터 간의 거리가 무시된 채 데이터 수가 많은 로맨스 영화로 예측될 것입니다. 이렇듯 분류기가 학습 데이터들의 특징을 반영하지 못한 채 학습하는 것은 지양해야 합니다. 그렇다면 k는 얼마로 두고서 학습을 진행하는 것이 좋을까요? 물론 데이터들의 수, 데이터 고유의 특징 등에 따라 다르지만 검증 데이터만을 넣어 분류 정확도를 측정한 한 모델에서는 아래의 그래프에서처럼 k는 75 근처에서 괜찮은 정확도를 보입니다. 또한 그래프에서 k가 25 미만 일 때는 over fitting의 문제로 정확도가 현저히 낮으며, 75를 지나면서도 under fitting의 문제로 정확도가 낮아지는 추이를 보이고 있다는 점입니다.

k에 따른 검증 정확도 그래프

다시 돌아와서 kNN 알고리즘에서 새로운 데이터를 중심으로 원을 그리는 것이 이해에 편하다고 했지만, 정확히는 수학적으로 새로운 데이터로부터의 거리를 토대로 계산됩니다. 이때의 거리는 Euclidean distance(유클리드 거리)로, 이차원에서 피타고라스 정리를 이용해 두 점 사이의 거리를 구할 수 있습니다. 아래 그림을 보겠습니다.

Euclidean distance로 계산한 데이터 간의 거리

그림에서처럼 스파이더 맨 데이터(*)의 좌표가 (6,6)라고 할 때, 스파이더 맨과 다른 모든 데이터 간의 거리를 계산한 다음 최근접한 데이터들이 순서대로 k가 됩니다. 그림에서는 (5,7) 좌표의 액션 영화와의 거리가 √2로 최근접 데이터이며 다음으로는 (7,3) 좌표의 로맨스 영화(√10), 다음으로는 (3,4) 좌표의 액션 영화(√13)입니다. 이렇듯 실제 컴퓨터 연산에서는 거리를 기반으로 계산되어 최근접 k개만큼의 데이터 비를 토대로 예측 및 분류합니다. 따라서 kNN 알고리즘은 거리 기반 분류 분석 모델 알고리즘이며 굉장히 쉽고 직관적으로 이해할 수 있기 때문에 많이 사용됩니다.

사실 kNN 알고리즘은 게으른 학습으로도 불리는데, 현재 데이터 분포를 토대로 학습하기 때문에 단순하고 효율적이며 훈련 단계가 빠르고 유클리드 거리 기반으로 수치 데이터 분류 작업에 높은 성능을 보인다는 장점이 있지만, 따로 모델을 생성하지 않기 때문에 새로운 데이터와 분류되는 군집 사이의 연관성을 명확히 알기 어려우며 k를 적절히 선택하지 못했을 때는 원치 않은 예측값이 나오며 그다음 예측에도 영향을 미칠 수 있다는 단점이 있습니다. 또한 명목 데이터 및 누락 데이터들에 대한 추가 처리 작업이 요구되며 데이터가 많아지면 분류 단계에서 시간이 오래 걸릴 수 있습니다. 이렇듯 여느 알고리즘에서처럼 장점과 단점을 모두 가지고 있지만 kNN 알고리즘은 현재에도 이미지 처리, 얼굴 인식, 추천 시스템, 글자 인식 등 다양한 분야에서 종종 쓰이며 유용한 알고리즘입니다.

Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation / Attention

어른이프로그래머 — Tue, 24 Nov 2020 04:20:59 +0900

Reference
Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
참고 영상: 곽근봉님의 논문 리뷰 영상, 허민석님의 seq2seq + Attention model
참고 블로그: Jamie Kang's weblog on computing, gihub.io.

본 논문 리뷰는 작성자의 이해를 돕고자 작성자의 지식 범위 내에서 작성되었으며, 따라서 어려운 내용에 대한 상세한 설명이 다소 부족할 수 있습니다. 리뷰에 사용된 모든 사진은 논문에서 발췌해왔습니다.

· Abstract & Conclusion

전체적인 논문의 이해를 위해 서두의 Abstract와 마지막의 Conclusion을 묶었습니다.

논문은 새로운 NMT(Neural Machine Translation) 방법인 RNN Encoder-Decoder(앞으로는 seq2seq로 부름) 모델을 제안합니다.

RNN으로 만든 Encoder-Decoder구조와 새로운 Hidden Unit을 제안하며, 동시에 이전의 SMT(Statiscal Machine Translation)과 비교하여 새로운 가능성을 제안합니다.

논문은 또한 seq2seq 모델이 기존의 기계 번역 시스템에 쉽게 적용할 수 있는 점, 의미와 문법적인 내용을 담은 범용적인 Phrase Representation으로 활용할 수 있는 점에서 seq2seq 모델이 SMT 성능을 높일 수 있으며 더 나아가 SMT를 완전히 대체할 수 있는 가능성에 대해 말하고 있습니다.

따라서 이번 포스트에서는 seq2seq모델의 구조에 대해 알아보며 논문 내용에 더하여 Attention mechanism에 대해서도 알아보겠습니다.

· new Hidden state

Hidden state를 이해하기 위해서는 먼저 RNN에 대해 알고 있어야 합니다(논문 2.3절, Hidden Unit that Adaptively Remembers and Forgets). 이번 포스트에서는 RNN에 대해서는 따로 설명하지는 않지만, 필요하다면 이전 포스트 12-1.RNN / SimpleRNN, 12-2. RNN-LSTM레이어를 훑어보고 오시는 것을 추천드립니다.

저는 RNN의 구조를 한마디로 Hidden state를 통해 Input이 output으로 나오는 구조라고 설명하고 싶습니다. RNN의 핵심은 Hidden state에 있는데, 이번 논문에서는 새로운 형태의 Hidden state를 제안하고 있습니다. 아래는 새로운 Hidden state의 구조입니다.

new Hidden state

그림에서는 두 형태의 h와 h̃이 나오는데, h를 이전의 Hidden state, h̃를 현재의 Hidden state을 의미합니다. 새로운 Gate인 r은 Reset Gate로 이전의 hidden state인 h를 얼마나 유지하고 반영할 것인지를 정하며 z는 Update Gate로 현재의 hidden state인 h̃을 얼마나 반영할 것인지를 정합니다. 위의 그림에서 이해하면 Reset Gate가 열려있을 수록, 즉 0에 가까울 수록 hidden state는 이전의 hidden state의 정보를 무시하고 새로운 input으로 업데이트합니다. r과 z에 대한 식은 아래 그림을 보며 설명하겠습니다. 먼저 Reset Gate입니다.

reset gate

수식은 j번째 hidden state의 Reset Gate를 계산하 는 방식을 나타내는데, 이해를 위해 설명을 하자면, σ는 logistic sigmoid function, 활성화 함수를, [.]j는 j-th element of vector, 벡터의 j번째 요소를 의미합니다. Wr와 Ur는 weight을, x와 h⟨t−1⟩은 input과 이전 hidden state를 의미합니다. 이를 바탕으로 수식을 말로 풀어보면 Reset Gate는 input(x)에 weight(Wr)를 곱한 값과 이전 hidden state(h⟨t−1⟩)에 weight(Ur)를 곱한 값을 더해 활성화 함수인 sigmoid function에 넣어 구합니다. 이 때 주목할 점은 input에 곱하는 weight(Wr)와 hidden state에 곱하는 weight(Ur)이 다른 weight이라는 점입니다.

update gate

z는 r과 동일한 방식으로 계산하며, 새로 제안된 Hidden state를 구하는 수식은 아래로 표현됩니다.

new Hidden state, where h̃

h̃

새로운 hidden state의 수식을 예를 들어 설명하면 Update gate인 z의 값이 0.2일때, j번째 요소의 t번째 hidden state는 이전 state의 정보를 20% 넘겨주고 새로운 state의 정보를 80% 받는다고 해석할 수 있습니다. 참고로 위의 수식에서 ⊙는 element-wise product(Hadmard product), φ는 활성화 함수 tanh입니다. 이러한 방식으로 나온 hidden state들에 weight(V)를 곱해 Encoder의 output인 C(context vector)를 구할 수 있는데, 이는 RNN Encoder에서 다시 알아보겠습니다.

· Encoder-Decoder

Encoder-Decoder

위는 이번 논문의 핵심인 Encoder-Decoder 구조를 도식화한 그림입니다(논문 2.2절, RNN Encoder-Decoder). 먼저 Encoder에서는 input sequence X의 임베딩 벡터를 읽으면서 Hidden state를 update합니다. 예시를 들어 설명하면, "i love you"를 단어 단위로 고정된 크기의 임베딩 벡터로 만들어 입력 X로 넣습니다. 첫 번째 입력 X는 "i", 두 번째 입력 X는 "love", 세 번째 입력 X는 "you"가 임베딩된 벡터로 들어갈 것입니다. Encoder은 입력들을 받아 Hidden state를 update하며, input sequence의 마지막을 알리는 symbol인 EOS(End-Of-Sequence)를 받으면 hidden state는 전체 input sequence를 담은 벡터 c를 만듭니다. 총 N개의 input에 대해, 벡터 c를 만드는 식은 다음과 같습니다. c = tanh(V $h_{⟨ t ⟩}$ ), V = weight, $h_{⟨ t ⟩}$ = h for N input sequence.

다음은 Decoder입니다. Decoder은 Encoder와는 반대로 주어진 Hidden state인 $h_{⟨ t ⟩}$

여기서 f는 non-linear activation function으로, 대표적으로 sigmoid와 tanh가 있습니다. linear activation function과 non-linear activation function에 대해서는 다음의 글에서 자세히 알 수 있습니다.

이제 모델이 Encoder-Decoder를 학습하는 과정이 남았습니다. 모델은 Encoder와 Decoder를 동시에 학습하며, 자세히는 input sequence data(x $h_{⟨ t ⟩}$

$h_{⟨ t ⟩}$

y⟨t⟩

Encoder-Decoder 학습

$h_{⟨ t ⟩}$

· RNN Encoder-Decoder on SMT

$h_{⟨ t ⟩}$

SMT

대부분의 SMT 모델은 선형로그 모델이며, log p(f|e)를 구하는 식은 아래와 같습니다. 식에서 w는 weight을, f(f,e)는 feature을 의미하며, log Z(e)는 normalization 상수입니다. 이 때 weight은 BLEU Score를 maximize하도록 최적화합니다. BLEU Score은 모델의 성능을 측정할 때 사용하는 지표로, 뒤에서 다시 알아보겠습니다. Abstract에서 말한 바와 같이 이번 논문에서 제안한 seq2seq모델을 f(f,e)에 적용해 SMT의 성능을 높일 수 있습니다. 자세히는 phrase-based SMT에서 scoring phrase pair table 부분에 seq2seq모델을 적용해 성능을 높일 수 있습니다. SMT에 대해서 상세한 지식이 부족하기 때문에, 지금은 "논문에서 제안한 seq2seq모델로 SMT의 성능을 향상시킬 수 있다"라고 이해하고 넘어가겠습니다.

log p(fe)

· Experiments

논문에서는 seq2seq 모델의 성능을 알아보기 위해 English-to-French translation task를 진행했습니다. task는 영어 구문을 불어 구문으로 번역하는 확률을 모델이 학습하도록 한 후, 이 모델을 baseline 시스템에 적용해 phrase pair table에 점수를 측정하도록 설계했습니다. 학습 환경과 파라미터들은 논문에서 확인할 수 있으며, BLEU Score를 사용하여 Score를 측정한 모델은 다음과 같습니다.

Baseline : SMT moses
RNN : Baseline + RNN Encoder-Decoder(seq2seq)
CSLM + RNN : seq2seq + CSLM(Continuous Space Language Models) 적용
CSLM + RNN + WP : CSLM + RNN에 Word Penalty(자주 나오지 않는, Dictionary 내 Unknown 단어에 대해 penalty) 적용

측정 score인 BLEU(Bilingual evaluation understudy) Score는 실제 사람이 한 번역과 기계 번역의 유사성을 계산하는 방식으로 구한 지표입니다. 아래는 score 측정 결과표입니다.

BLEU Score

scoring 결과 SMT 모델만으로 학습했을 때 보다 RNN Encoder-Decoder를 적용했을 때 성능이 향상했으며, CSLM과 함께 적용했을 때 최적의 성능이 나온 것을 확인할 수 있습니다. 추가로 WP를 적용했을 때는 dev score은 비슷했으나, test score은 다소 떨어졌음을 볼 수 있습니다. 논문에서는 BLEU Score 뿐만 아니라 아래 그림과 같이 seq2seq모델을 적용했을 때의 다양한 phrase들에 대한 translation도 보여줍니다.

English-To-French translation

또한 아래 그림에서 알 수 있듯이 논문에서 제안하는 seq2seq 모델이 phrase들을 의미적(semantically), 문법적(syntactically)으로 잘 표현하는 것을 알 수 있습니다. Abstract에서 말했던 "논문이 제안하는 새로운 모델이 의미와 문법적인 내용을 담은 범용적인 Phrase Representation으로 활용할 수 있는 점"이 바로 이 점을 두고 한 말입니다.

이로써 seq2seq(RNN Encoder-Decoder) 모델을 소개한 논문 Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation에 대한 리뷰는 끝입니다. 딥러닝을 처음 공부하며 느꼈던 점 중 하나는, '책, 구글, 유튜브를 보고 딥러닝 모델을 생성하고 학습하는 방법을 알겠는데, 단순히 라이브러리를 임포트해서 만들어진 모델을 사용하는 것일 뿐, 그 모델이 어떻게 동작하고 모델을 구성하는 수식은 무엇일까?'에 대한 질문이였습니다. AI를 공부한 이후 태고적인 질문으로, '컴퓨터가 사람처럼 사고하고 행동하는 것이 대중적으로 알려진 AI라면, AI 시스템을 만든 사람은 어떻게하면 사람처럼 행동할 수 있도록 만들었을까?'는 질문과 딥러닝을 공부하다 느낀 '모델을 학습할 때, 모델은 어떤 방식으로 학습의 오류를 알고 weight을 변경하지?'는 질문이였습니다. 그러다 이번에 seq2seq 모델 구현을 위해 논문을 찾아보다, 새로운 시야를 얻을 수 있었습니다. 저처럼 ML/DL을 처음 공부하는 분이라면 책과 구글링, 유튜브를 보며 모델을 구현해보고 학습해보는 과정을 클론 코딩하는 해보며 공부하는 분들이 많을 것이라 생각합니다. 그러다보면 다양한 모델들을 알게되고, 모르는 것은 구글링해보며(예를 들어, model.compile(activation:'sigmoid', ..)을 보면 구글에 sigmoid activation function만 검색해도 한글, 영문으로 된 좋은 글들을 많이 볼 수 있습니다.) 지식을 쌓아나갔지만, 정작 sigmoid functiob에 대한 수식에 대해서는 관심이 없으며 sigmoid function의 그래프와 값 범위 등에만 관심이 있을 수도 있습니다. 저도 맨 처음, 책 하나를 사서 이러한 방식으로 공부하다보니 언젠가 '이제 몇가지 모델들에 대해서도 알겠는데... 모델들의 동작방식에 대해서도 알겠는데... 그래서 이 모델들은 어떻게 이렇게 동작할 수 있는거지?'는 생각이 들었습니다. 이런 분들이 있으시다면, 논문을 읽어보는 것을 추천드립니다. 처음 논문을 읽는 것에 대한 두려움으로 논문 읽기가 꺼려진다면, 구글링이나 유튜브에서 논문 리뷰 영상을 먼저 보고 필요한 부분만 발췌해가며 이해하는 것도 매우 좋은 방법이라 생각합니다.

12-2. RNN - LSTM(Long Short Term Memory) 레이어

어른이프로그래머 — Tue, 25 Aug 2020 01:20:42 +0900

이 포스트는 허민석님의 유튜브 [딥러닝]LSTM 쉽게 이해하기와 Christopher olah's blog, Understanding LSTM Networks를 참고하여 작성했습니다. 누구나 이해할 수 있는 수준으로 설명하고자 하였으며 LAB의 코드는 TF2.0에 맞추어 재작성되었습니다.

LSTM은 SimpleRNN의 치명적인 단점을 해결하고자 1997년 Sepp Hochreiter와 Jurgen Schmidhuber에 의해 제안된 레이어입니다. 그렇다면 먼저 SimpleRNN의 문제점이 무엇인지, LSTM은 그 문제점을 어떻게 해결했는지에 대해 알아보겠습니다.

SipleRNN의 치명적인 단점, 장기 의존성(Long-Term Dependency) 문제

먼저 SimpleRNN의 치명적인 단점, 장기 의존성 문제에 대해 알아보겠습니다. 장기 의존성 문제란 입력과 출력 사이의 거리가 멀어질수록 연관 관계가 적어지는 문제입니다. RNN에서는 하나의 weight을 반복적으로 사용하는데, 미분을 사용하여 오차를 구할 때 이 weight을 계속 곱하면 값이 엄청나게 커지는 exploding gradient나 엄청나게 작아지는 vanishing gradient 현상이 발생합니다. 먼저 그림으로 보겠습니다.

그림1. SimpleRNN 네트워크 구조(many to many)

그림2. vanishing gradient, exploding gradient

위의 네트워크 구조는 "다음에 나올 단어를 예측하는 모델(word predictor, many to many)"을 구현한 SimpleRNN 구조입니다. gradient descent를 이용해 weight을 업데이트해주며, BPTT(BackPropagation Through Time) 알고리즘으로 오차 E3를 구할 수 있습니다. 그림에서는 chain rule을 이용하여 ∂E3/∂W를 구하는 과정을 수식으로 표현하였는데, ∂H3/∂H2 * ∂H2/∂H1에 주목해 보겠습니다. 이는 H1이 H3에 미치는 영향, 즉 입력 데이터 X1이 X3에 미치는 영향으로 해석할 수도 있습니다. 이때 *로 나눠진 두 부분을 풀어서 보면 ∂H3/∂H2, ∂H2/∂H1로 둘은 하나의 미분 값 weight(Whh)을 가집니다. 즉 하나의 weight을 두 번 곱하는 것으로 생각할 수 있습니다. 이번에는 아래의 그림 2를 보겠습니다. 그림 2는 그림 1과 달리 입력 데이터가 X1, X2... X100, X101로 많습니다. 이렇게 되면 ∂E101/∂W을 구할 때 아래의 수식에서처럼 ∂H2/∂H1 * ∂H3/∂H2 *... * ∂H100/∂H99로 X1이 X101에 미치는 영향을 구할 수 있습니다. 하지만 위의 방법으로 계산 시, 하나의 weight을 100번 곱하는 것으로 해석할 수 있는데, 이때 문제점이 발생합니다. 만약 미분 값이 1보다 작다면, 1보다 작은 값을 100번 곱하는 것이기 때문에 0에 가까운 매우 작은 값이 될 것입니다. 따라서 W=W-∂E/∂W에서 ∂E/∂W가 0에 가깝기 때문에 weight 값이 거의 변하지 않아 학습이 길어지고 비효율적이게 됩니다. 이것을 vanishing gradient 현상이라고 합니다. 반대로 미분 값이 1보다 크다면, 1보다 큰 값을 100번 곱하는 것이기 때문에 매우 큰 값이 될 것이며 이때의 weight은 매우 큰 값을 가질 것입니다. 이것을 exploding gradient 현상이라고 합니다.

그림 3-1. vanishing gradient

그림 3-2. exploding gradient 현상 시의 그래프

이제 위에서 소개한 "다음에 나올 단어를 예측하는 모델"의 예시를 보겠습니다.

이는 장기 의존성 문제를 이해하기에 가장 직관적인 예시입니다. 빨간색 빈칸에 들어가는 알맞은 단어를 예측하는 문제입니다. 위의 문장에서 sky를 유추하기 위한 핵심 단어는 clouds입니다. clouds는 비교적 가까이 있기 때문에 sky라는 단어를 유츄하기까지에는 큰 어려움이 없습니다. 하지만 아래 문장은 French를 유추하기 위해서는 France를 찾아야 하는데, 두 단어 사이의 거리는 매우 길기 때문에 French를 유추하기까지는 길고 비효율적인 학습과정을 필요로 할 것입니다. 그렇다면 이러한 장기 의존성 문제를 어떻게 해결했을까요? 아래를 보겠습니다.

LSTM 레이어

장기 의존성 문제를 해결하기 위해 1997년 Sepp Hochreiter와 Jurgen Schmidhuber은 LSTM 레이어를 제안하였습니다. 그렇다면 LSTM 레이어가 SimpleRNN과 어떻게 다른지 살펴보겠습니다.

그림 4. SimpleRNN(위)과 LSTM(아래)

먼저 SimpleRNN에서 필요한 것은 무엇일까요? 바로 특정 정보를 기억하고 잊는 장치가 필요했습니다. John은 남자, Jane은 여자라고 했을 때 위의 문장에서 he라는 단어를 유추하기 위해서는 John이라는 단어를 기억하고 있어야 합니다. 하지만 뒤의 she라는 단어를 유추하기 위해서는 기억하고 있던 John이라는 단어는 잊고, Jane이라는 단어를 다시 기억해야 합니다. 이렇게 네트워크는 데이터를 기억하고 잊는 정보를 공유해야 하는데, LSTM에서는 이 정보를 셀 상태(cell state)라고 합니다. 정확히 cell state는 그림 4의 LSTM(아래) 레이어에 표시되어 있는 윗 선에 해당하며, 밑에서 배우겠지만 LSTM은 gate라는 구조에 의해 cell state에 무엇인가를 더하거나 없앨 수 있습니다. 먼저 첫 번째 forget gate layer의 경우를 먼저 보겠습니다.

그림 5. LSTM forget gate layer, 출처: https://colah.github.io/posts/2015-08-Understanding-LSTMs/

이 과정에서는 Sigmoid를 통해 0과 1의 숫자를 내보내는데, 이 값은 곧 정보를 얼마나 기억할 것인지를 의미합니다. 값이 0이라면 아무것도 기억하지 않는다, 잊는다는 의미이며 값이 1이라면 모든 정보를 기억한다는 의미로 해석할 수 있습니다. 타임스탭 t에서의 LSTM forget layer의 출력은 다음과 같이 나타낼 수 있습니다. 위의 문장을 예로 들면 forget gate layer에서 일어나는 일을 그림 5-2로 표현할 수 있습니다. Jane이라는 입력이 성별을 구분 짓는 데에 유의미한 새로운 정보이기 때문에, John이라는 단어를 20% 정도만 기억하는 것을 알 수 있습니다.

그림 5-1. 타임스탭 t에서의 forget layer의 출력

그림 5-2. forget gate layer를 통과한 정보

다음은 정보들 중 어떤 정보를 cell state에 저장할 것인지를 저장하는 input gate layer입니다. John이라는 정보를 20%만 기억하는 것 외에도, Jane이라는 정보를 cell state에 저장하는 것 또한 매우 중요한 작업입니다. 과정을 순서대로 보면 입력된 정보를 이전의 정보와 합쳐 sigmoid를 통과함으로써 새로운 정보를 어느정도 내보낼 것인지를 결정합니다. 동시에 tan layer를 거쳐 새로운 Ct를 만들고, 이렇게 두 단계에서 나온 정보를 합쳐서 cell state에 더할 준비를 합니다. 결과적으로 새로운 정보로부터 만들어진 Ct와 이전 정보가 담긴 Ct-1을 결합해 LSTM의 cell state를 업데이트합니다. 과정을 그림으로 나타내면 아래와 같습니다.

그림 6. Input gate layer의 과정, 새로운 정보를 처리하고(위) ,이전의 정보와 합쳐 cell state를 업데이트합니다.(아래)

그림 6-1. 업데이트 된 cell state Ct는 "Jane"을 기억하게 됩니다.

마지막으로 출력을 내보내는 output gate layer입니다. output gate에서는 정보를 출력하고 cell state를 다음 cell에 전달해야합니다. 이 과정은 cell state의 정보가 tanh 통해 들어오는 동시에 다음 cell state로 전달되고, 현재의 정보와 이전의 정보가 sigmoid를 통해서 들어와 서로 곱하여 그 값을 output으로 출력하고 동시에 다음 hidden state로 넘어가게 됩니다.

그림 7. output gate layer의 과정 및 수식

그림 7-1. "she"를 유추할 수 있고 다음 cell state에 "Jane"을 넘겨줍니다.

LSTM은 이러한 과정을 통해 이전의 정보가 유의미할때까지 기억하고, 필요 없다면 잊어버리며 현재의 정보와 합쳐 정확한 출력을 내게 됩니다. 사실 수식을 보며 LSTM을 이해하는 것은 처음 LSTM을 접하는 입장에서는 굉장히 어려울 것입니다. 다만 John is my friend.. Jane is his wife... 의 예시로 LSTM을 처음 이해하면, 다소 어렵지 않게 다가갈 수 있고 이후 순서대로 수식을 풀어나가 보면 위의 그림을 모두 이해할 수 있을 것입니다. 물론 LSTM은 앞으로도 매우 유용하게 쓰이기 때문에, 다음 포스트에서는 LSTM 레이어를 이용하여 문제를 해결해 나가는 과정을 코드와 함께 살펴보겠습니다.

12-1. RNN / SimpleRNN

어른이프로그래머 — Wed, 19 Aug 2020 02:10:02 +0900

이 포스트는 허민석님의 유튜브 [딥러닝]RNN 기초 강의와 시작하세요! 텐서플로2.0프로그래밍을 참고하여 작성했습니다.
누구나 이해할 수 있는 수준으로 설명하고자 하였으며 LAB의 코드는 TF2.0에 맞추어 재작성되었습니다.

CNN에 이어 이번에는 순환 신경망(RNN, Recurrent Neural Network)과 RNN의 가장 기초인 SimpleRNN에 대해 알아보겠습니다. 먼저 RNN은 음악, 자연어, 주식 시장 등 시간의 흐름에 따라 변화하는 시퀀스(순서가 있는) 데이터를 입력받아 처리할 때 사용됩니다. 하나의 예로 여러 단어들이 주어졌을 때, 이 단어들을 조합해서 만든 문장의 품사를 맞추는 프로그램을 생각해보겠습니다. 예시를 들어 i, google, at, work의 네 단어가 주어졌을 때, 'i work at google(나는 구글에서 일한다)'와 'i google at work(나는 직장에서 구글링을 한다)'의 두 문장을 만들 수 있습니다. 이는 google과 work 단어 둘 다 명사의 뜻과 동사의 뜻이 있으며, 서로 동사-명사, 명사-동사로 쓰여도 전혀 어색하지 않기 때문입니다. 따라서 두 문장에서 google과 work가 명사인지 동사인지는 앞 뒤 단어의 품사 혹은 문장 성분이 중요합니다. 아래 그림을 보겠습니다. I work at google에서 work는 I라는 대명사 뒤에 나왔으므로 동사로 사용되었습니다. 반면 google은 at 뒤에 나와 구글이라는 장소를 의미하는 명사로 사용되었습니다.

i뒤에 나온 work, at뒤에 나온 google이 나온 것으로 보아 work는 동사, google은 명사로 사용되었음을 알 수 있습니다.

이번에는 반대로 google이 동사로, work가 명사로 사용되었습니다.

work와 google의 품사를 구분하는 것은 주어진 단어 앞의 단어인 i와 at입니다. 따라서 이전 단어의 품사 정보를 기억하는 새로운 형식의 네트워크 구조가 필요해짐에 따라 나온 것이 바로 RNN입니다. 이 때 기존 네트워크와 달리 이전의 정보를 기억하는 공간을 hidden state라고 하며, 입출력의 형태에 따라 아래와 같이 다양한 문제에 대해 다양한 구조의 네트워크를 만들 수 있습니다. 아래에서 각 네트워크의 예시로는 다음과 같습니다. 이미지를 입력했을 때 이미지에 대한 설명을 하는 이미지 설명 생성(Image captioning, one to many), 문장의 긍/부정을 판단하는 문장 감성 분석기(Sentiment classification, many to one), 한영/영한 번역 등의 언어 자동번역기(Machine Translation, many to many), 문장에서 다음에 나올 단어를 예측하는 모델(Word predictor, many to many).

다음 포스트에서 LSTM을 설명할 때 마지막의 문장에서 다음에 나올 단어를 예측하는 모델을 예로 들어 설명할 것이므로, 지금은 많은 문제들을 RNN으로 해결할 수 있다는 것에 대해서만 알고 넘어가겠습니다. 이제 RNN에서 가장 기초적인 구조인 SimpleRNN를 예로 입력이 hidden state에서 계산되어 출력되는 과정에 대해 알아보겠습니다.

출처: 허민석님의 유튜브 [딥러닝] RNN 기초: https://www.youtube.com/watch?v=PahF2hZM6cs

선을 따라 h_t에서의 출력을 살펴보면, 이전 네트워크들과는 달리 h_t-1의 출력을 어느 정도 반영할지 정하는 weight인 Whh과 곱한 값을 h_t의 입력에 weight을 곱한 값과 더하는 것을 볼 수 있습니다. 이를 아래처럼 수식으로도 표현할 수 있는데, 많이 복잡해 보이지만 기존의 네트워크에서 "출력을 정하는 데에 있어 이전의 정보를 얼마만큼 기억할 것인지를 고려"하는 수식이 추가되었을 뿐입니다.

활성화 함수 tanh를 통과하지 않은 h_t에서의 출력

이후 모델은 softmax를 통해 one-hot encoding된 값을 통해 차례대로 대명사, 동사, 전치사, 명사라는 답을 예측합니다. 사실 이 문장에서 i와 at는 대명사와 전치사임을 모델도 이미 알고 있기 때문에 이 단어들이 work와 google에 미치는 영향(각 단계에서의 Whh값)이 어느 정도 유의미해야만 정확한 예측을 할 수 있었을 것입니다. 이후에는 모델의 예측값(아래 그림에서의 pred)을 실제값(target)과 비교하며 w_xh, bias, w_hh를 최적화하여 둘의 차이를 줄여나가도록 학습을 합니다. 이때 주의할 점으로는 RNN은 셀 하나를 가지고 재사용하는 방식이기 때문에 w_xh와 bias, w_hh는 모든 네트워크에서 하나의 동일한 값입니다.

one-hot encoding된 예측값 pred를 실제값 target과 비교하며 weight과 bias를 업데이트합니다.

이번에는 문장의 긍정/부정을 판단하는 감성 분석의 알고리즘을 보겠습니다. 역시 단어들의 앞 뒤 관계를 파악해(문맥이라는 표현이 정확하겠습니다) 긍정/부정을 판단하였으며, 주목할 점은 분류할 항목이 긍정/부정의 2개이기 때문에 binary classification을 사용하며 학습 시에는 역전파(BackPropagation Throuht Time, BPTT) 방법을 사용했습니다.

이제 SimpleRNN에 대해 알아보겠습니다. 사실 RNN에서는 LSTM이나 GRU 등이 더 자주 사용되긴 하지만, SimpleRNN은 RNN의 가장 기초적인 레이어로서 RNN을 쉽게 이해하는데 도움이 될 것 입니다. SimpleRNN의 구조는 위의 문장 품사 맞추는 프로그램의 네트워크 구조처럼 단순한 네트워크들이 이어져있는 모양입니다. 이제 다음의 childult-programmer github에서 예제 문제와 코드를 보겠습니다. 문제는 다음과 같습니다.

그렇다면 TF2.0버전에 맞추어 Keras에서 SimpleRNN을 구현한 코드는 다음과 같습니다. 실제 keras.layers.SimpleRNN에는 아래의 많은 인자들을 필요로 하지만, 지금 필요로 하는 인자는 반복 횟수와 입력 벡터의 크기를 담은 인자 input_shape와 반환 시 시퀀스 형식으로(one to many, many to many, LSTM 등에서는 True로 사용됩니다) 반환할 것인지를 표현하는 인자 return_sequences만이 필요합니다. 블록 형태로 표현하면 왼쪽이 return_sequences=False일 때, 오른쪽이 return_sequences=True일 때의 모양입니다. 바로 밑에는 출력을 위해 Dense레이어를 연결한 모습을 볼 수 있습니다.

return_sequences= False/True, 출처: https://tykimos.github.io/2017/04/09/RNN_Getting_Started/

나머지 코드들은 링크의 Github에서 확인할 수 있습니다. 사실 SimpleRNN은 다음 포스트에서 알아볼 LSTM, GRU 레이어들에 비해 복잡한 현실 문제를 푸는데에는 한계점이 많습니다. 따라서 다음 포스트에서는 그 한계점은 무엇이고 LSTM, GRU 레이어들은 무엇인지에 대해 알아보겠습니다.

시작하세요! 텐서플로 2.0 프로그래밍 리뷰

어른이프로그래머 — Fri, 17 Jul 2020 03:25:07 +0900

본 포스트는 페이스북 생활코딩 페이지 책프협 골라 받는 서평 이벤트로 도서를 받아 작성했습니다.

시작하세요! 텐서플로 2.0 프로그래밍, 김환희 지음

처음 AI와 딥러닝을 공부할 때, 무엇부터 공부해야 하는지, 어떤 순서로 공부해야 하는지에 대해 많이들 궁금해하실 것이라 생각합니다. 저는 Andrew ng 교수님의 machine learning과 김성훈 교수님의 모두를 위한 딥러닝 강의로 딥러닝에 입문하였습니다. 다만 급변하는 AI 시장의 흐름에서 2019년 9월에 텐서플로 버전이 2.0으로 업그레이드됨에 따라 Keras를 중심으로 하는 고수준 API의 통합이 있었고, 따라서 이제는 Keras를 이용해 모델을 만들고 학습하는 방법을 아는 것이 중요해졌습니다. 하지만 텐서플로 1.X 버전에서 딥러닝을 배우고 코드를 짜던 분들이라면 Keras에서 모델을 만들고 학습하는 것에 익숙지 않을 것입니다. 이처럼 · 텐서플로 버전이 업그레이드됨에 따라 Keras를 배우고 싶으신 분 · 처음 입문하고 앞으로의 트렌드에 맞춰 딥러닝을 배우고 싶으신 분 · 이미 딥러닝의 이론을 공부하고 코드로 실습하고 싶으신 분들에게 추천하고 싶은 책을 소개해드리려 합니다. "시작하세요! 텐서플로 2.0 프로그래밍"은 Keras로 다양한 문제를 풀어봄으로써 신규 혹은 기존의 사용자들이 텐서플로 2.0 버전에 익숙해질 수 있는 데에 큰 도움을 주는 책이라고 생각합니다. 책은 텐서플로 2.0 버전의 주요 변화를 시작으로 텐서플로 설치, 파이썬의 기본 문법들을 설명하고 뒤이어 회귀와 분류, 신경망과 모델에 대해 실습 코드와 함께 설명하고 있습니다. 책을 받아 처음 읽었을 때 인상 깊었던 점은 Keras로 모델을 구성하여 학습하는 코드에서 함수의 인수들에 대한 설명까지 자세히 파고든 점입니다. 보통의 프로그래머분들이라면 '구글링으로 Keras 문법을 찾아보고 사용하면 되지 않을까?'라고 생각하고 물론 수준 있는 프로그래머분들은 구글링으로도 충분히 Keras를 사용할 수 있을 것입니다. 하지만 저처럼 파이썬의 문법들은 잘 알고, 딥러닝의 이론도 어느 정도 알고 있긴 하지만 텐서플로를 처음 접한다면 model = tf.keras.Sequential([tf.keras.layers.LSTM(units=30, return_sequences=True, input_shape=[100,2])])과 같은 코드를 처음 보는 볼 때 units, return_sequences 등의 인수들은 무엇을 뜻하는지, 이를 어떤 식으로 구글링 해야 할지 등에 대해 힘들 것입니다. 하지만 이 책에서는 코드 한 줄 한 줄을 이론과 그림을 붙여 설명해 정말 자세히 배운다는 느낌을 받을 수 있었습니다. 실제 책의 한 코드 설명을 예를 들어 보겠습니다.

예제 6.1 Conv2D 레이어 생성코드 (p.146)
conv1 = tf.keras.layers.Conv2D(kernel_size=(3,3), strides = (2,2), padding='valid', filters=16)
=> Conv2D 레이어를 생성할 때의 주요 인수는 kernel_size, strides, padding, filters의 네 가지입니다. kernel_size는 필터 행렬의 크기입니다. 이것은 수용 영역이라고도 부릅니다. 앞의 숫자는 높이, 뒤의 숫자는 너비이고 하나만 쓸 경우 높이와 너비를 동일한 값으로 사용한다는 뜻입니다. strides는 필터가 계산 과정에서 한 스텝마다 이동하는 크기입니다. 기본값은 (1,1)이고 ... 그림 6.10처럼 동일한 조건에서 strides가 달라지면... (중략)

위의 Conv2D 레이어 생성코드 설명을 보면 Conv2D 레이어의 인수들을 이론과 그림을 예로 하나씩 설명해줍니다. 설명을 보면 인수 strides의 기본값에 대해서도 설명하고 있습니다. 구글링을 통해 다양한 코드를 접한 분들이라면 어떤 코드에서는 A인수가 사용되지 않았으나 어떤 코드에서는 A인수가 사용된 적을 보셨을 것입니다. 그 때면 인수가 사용되지 않았을 때 디폴트 값은 무엇인지에 대한 설명을 다시 찾아보아야며 실제로 인수들의 디폴트 값은 케라스 공식문서에서도 안 나와있는 경우가 있어 찾기가 힘듭니다. 그런데 이 책에서는 텐서플로 2.0을 처음 접하는 사람들이 겪을 힘든 점들까지 고려해 코드를 정말 자세히 설명했다는 것을 느낄 수 있었습니다. 하지만 책은 실습 코드에만 치중하지 않았습니다. 실제 책을 읽어보았을 때 그림이 굉장히 많은 것을 볼 수 있는데, 저는 이 점이 굉장히 좋았습니다. 보통 코드를 실행하면 손실과 정확도를 출력하는 정도에 그칩니다. 따라서 학습이 진행될 때 그림이 어떻게 학습되는지 등은 사용자가 직접 확인하기에는 쉽지 않습니다. 하지만 책에서는 그림으로 학습 과정을 설명하고, 코드 뿐만 아니라 이론도 그림을 통해 이해를 돕고 있습니다. 텐서플로 2.0버전에서 keras로 코드를 작성하고 싶으신 분들이라면 꼭 권장하고 싶은 책입니다. 목차와 순서에 맞게 읽지 않고 필요에 맞는 페이지에서 원하는 내용만 골라 읽다보니 책 한권을 모두 읽게 되었습니다. 이 책을 읽으며 굉장히 집중하고 몰입 할 수 있을 정도로 중요한 내용들이 조밀하게 작성된 느낌을 받을 수 있었습니다. 텐서플로 2.0버전으로 업그레이드 된지는 아직 1년이 채 되지 않았으나 언제 바뀔지 모르는 인공지능 시장에서 트렌드에 맞춰 미래지향적으로 실력을 기르는 것, 하지만 단순히 클론코딩만이 아닌 인공지능의 기초 이론과 수학적 지식을 아는 것, 이 둘이 합쳐졌을 때 비로소 인공지능 전문가로 불릴 수 있을 것입니다. "시작하세요! 텐서플로 2.0 프로그래밍"은 트렌드를 맞춰 실력을 기르는 것에 분명히 일조하는 책이라고 할 수 있습니다. 다만 수학적 지식이 부족하거나 딥러닝의 기본 이론 지식이 부족하다면, 이 책으로 이론을 접하는 것보다는 위에서 말한 두 강의를 먼저 듣는 것을 추천합니다. 마지막으로 "책의 표지에는 등대와 등불이 있습니다. 어둠 속에서는 작고 미약한 빛이라도 큰 도움이 됩니다. 텐서플로와 딥러닝을 처음 접하는 분들에게 이 책이 미약하지만 의지할 수 있는 빛이 됐으면 하는 작은 소망으로 표지를 정했습니다. 부디 이 책을 읽고 하나라도 얻어가는 것이 있으시다면 저에게는 가장 뿌듯한 일이 될 것입니다."라는 책의 서문 내용과 같이 책은 단순히 텐서플로 2.0버전의 코드들을 소개한다는 느낌만이 아닌 텐서플로 버전이 업그레이드되며 충족되지 못하고 가려웠던 부분들을 긁어준다는 느낌을 강하게 줍니다.

11-3. Fashion MNIST를 Keras를 이용한 ConvNet으로 풀어보자

어른이프로그래머 — Mon, 13 Jul 2020 15:35:29 +0900

이 포스트는 모두를 위한 딥러닝 - Tensor Flow를 정리한 내용을 담았습니다.
누구나 이해할 수 있는 수준으로 설명하고자 하였으며 LAB의 코드는 TF2.0에 맞추어 재작성되었습니다.

이번 포스트는 모두를 위한 딥러닝 LAB 11-2의 "MNIST 99% with CNN"를 응용해 "Fashion MNIST with CNN, TF2.X"로 재해석하여 작성했습니다. 포스트의 코드는 책 "시작하세요! 텐서플로 2.0 프로그래밍"을 참고하여 작성했습니다.

Fashion MNIST

MNIST는 손으로 쓴 숫자 글씨를 모아놓은 데이터셋으로, 프로그래밍 언어를 처음 배울 때 "Hello World"를 출력하는 것과 같이 기계학습 분야를 대표하는 고전적인 문제입니다. Fashion MNIST는 MNIST에 영향을 받아 옷과 신발, 가방의 이미지들을 모아놓은 데이터셋입니다. Fashion MNIST의 이미지 크기는 28x28픽셀이며 60000개의 학습셋과 10000개의 테스트셋을 가집니다.

Fashion MNIST

Label	Category
0	티셔츠/상의
1	바지
2	스웨터
3	드레스
4	코트
5	샌들
6	셔츠
7	운동화
8	가방
9	부츠

이제 Fasion MNIST를 TF2버전으로 Keras와 CNN 구조를 이용해 풀어보겠습니다. 먼저 아래는 코드 전문입니다.

"""
@IDE: Pycharm
@Environment: TF 2.1.0, python 3.7.7

@citation: 시작하세요! 텐서플로 2.0 프로그래밍
@author: Hwanhee kim

@Rewrite: childult-programmer
@Github: https://github.com/childult-programmer
"""

import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Conv2D, MaxPool2D
from tensorflow.keras.layers import Flatten, Dense, Dropout

# Fashion MNIST 데이터세트
# Label     Category
# 0         티셔츠/상의
# 1         바지
# 2         스웨터
# 3         드레스
# 4         코트
# 5         샌들
# 6         셔츠
# 7         운동화
# 8         가방
# 9         부츠

# Fashion MNIST 데이터셋 로딩
fashion_mnist = tf.keras.datasets.fashion_mnist
(train_X, train_Y), (test_X, test_Y) = fashion_mnist.load_data()

# # 첫번째 이미지 출력
# plt.imshow(train_X[0], cmap='gray')
# plt.colorbar()
# plt.show()
#
# print(train_Y[0])

# 정규화
train_X = train_X / 255.0
test_X = test_X / 255.0

# reshape 이전
# print(train_X.shape, test_X.shape)          # (60000, 28, 28), (10000, 28, 28)

# reshape 이후
# 채널(컬러 이미지는 RGB의 3채널, 흑백 이미지는 1채널)을 갖도록 reshape
train_X = train_X.reshape(-1, 28, 28, 1)
test_X = test_X.reshape(-1, 28, 28, 1)
# print(train_X.shape, test_X.shape)          # (60000, 28, 28, 1) (10000, 28, 28, 1)

# # 그래프를 그려 Fashion MNIST 데이터 확인
# # 전체 그래프의 크기를 width=10, height=10으로 지정
# plt.figure(figsize=(10, 10))
# for c in range(16):
#     # 4X4 그리드에서 c+1번째 칸에 그래프를 그립니다. 1~16
#     plt.subplot(4, 4, c+1)
#     plt.imshow(train_X[c].reshape(28, 28), cmap='gray')
#
# plt.show()

# Fashion MNIST 분류를 위한 CNN 모델 정의
model = Sequential([
    # 특징 추출기 (Feature Extractor)
    Conv2D(input_shape=(28, 28, 1), kernel_size=(3, 3), filters=32),
    MaxPool2D(strides=(2, 2)),
    Conv2D(kernel_size=(3, 3), filters=64),
    MaxPool2D(strides=(2, 2)),
    Conv2D(kernel_size=(3, 3), filters=128),
    # 다차원 이미지 => 1차원
    Flatten(),
    # 분류기 (Classifier)
    Dense(units=128, activation='relu'),
    Dropout(rate=0.3),
    Dense(units=10, activation='softmax')
])

# 모델 학습 과정 설정
model.compile(optimizer=tf.keras.optimizers.Adam(),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 모델 학습
history = model.fit(train_X, train_Y, epochs=15, validation_split=0.25)

plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], 'b-', label='loss')
plt.plot(history.history['val_loss'], 'r--', label='val_loss')
plt.xlabel('Epoch')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['acc'], 'g-', label='acc')
plt.plot(history.history['val_acc'], 'k--', label='val_acc')
plt.xlabel('Epoch')
plt.ylim(0.7, 1)
plt.legend()

plt.show()

# 모델 평가
print(model.evaluate(test_X, test_Y, verbose=0))

Keras에는이미 Fashion MNIST 데이터셋이 탑재되어 있습니다. tf.keras.datasets.fashion_mnist로 Fashion MNIST 데이터셋을 training set과 test set 튜플로 나누었습니다. load_data()는 train_X와 test_X에는 이미지 데이터를, train_Y와 test_Y에는 범주 라벨의 형태를 취한 2개의 튜플을 반환합니다. line 36 - 40의 주석을 해제한 후 실행하면 데이터셋의 첫 번째 이미지를 확인하면 데이터의 이미지가 0에서 255까지의 값을 가지는 28x28 픽셀 크기의 2차원 이미지임을 확인할 수 있습니다.

Fashion MNIST 첫 번째 이미지

이후 우리는 최댓값과 최솟값을 알고 있기 때문에 이미지 픽셀값을 255로 나눠 0.0과 1.0 사이의 값으로 정규화합니다. 또한 Conv2D 레이어로 연산할 것이기 때문에, 이미지가 채널을 가진 형태로 만들기 위해 reshape해줍니다. 참고로 코드에 주석이 많이 씌어져 있는데, 이미지를 출력해 확인하거나 데이터의 형태를 확인하기 위해 작성한 코드이기 때문에 실제로 작성하실 때는 주석 부분을 지우고 작성하셔도 됩니다. 이제 CNN 모델을 정의하고 학습하는 과정을 살펴보겠습니다.

line 66 - 79에서는 Fashion MNIST 분류를 위해 CNN 모델을 정의하고 있습니다. 모델은 Convolution 레이어와 Pooling 레이어를 사용하여 이미지의 특징을 추출하고 Dropout 레이어와 Dense(Fully Connected) 레이어를 사용해 과적합을 방지하고 이미지를 분류하도록 구성했습니다. 아래는 CNN 모델의 구조를 그림으로 나타냈습니다.

CNN 구조

Conv2D 레이어를 보겠습니다. 맨 처음의 Conv2D 레이어에는 이미지의 input_shape를 지정해주어야합니다. 입력이미지의 높이, 너비, 채널 수에 따라 (28, 28, 1)로 정의한 뒤 kernel_size와 filter의 개수를 정해주었습니다. 필터의 수는 32부터 시작해 64, 128로 3개의 Conv2D 레이어에 뒤로 갈수록 2배씩 늘렸습니다. Conv2D 레이어 위에 MaxPool2D 레이어를 쌓은 모습을 볼 수 있습니다. max pooling 레이어는 이미지의 특정 데이터를 강조하고 싶을 때나 특히 과적합을 방지하고자 할때 많이 사용되는데, 과적합을 방지하는 것에 대해 잠시 살펴보고 넘어가겠습니다. 처음 Conv2D레이어에서 우리는 28x28크기의 이미지를 3x3크기의 필터 32개로 Feature Map을 만들었습니다. stride는 따로 정하지 않았기 때문에 디폴트 값인 1로 놓고 각 Conv2D 레이어에 있는 feature의 수를 계산하면 ((28 - 3)/1 + 1) * ((28 - 3)/1 + 1) = 26 * 26 = 676개 입니다. 이런 layer를 32층 쌓았으니 총 feature의 개수는 676 * 32 = 21632개가 됩니다. 이렇게 feature가 많아지면 과적합(overfitting)의 우려가 있으므로, 우리는 이를 max pooling을 사용해 이미지의 크기를 줄임으로써 feature의 개수를 줄여 방지할 수 있습니다. 코드를 보면 MaxPool2D 레이어의 pool_size와 strides를 (2, 2)로 정했습니다. 이후 Conv2D와 MaxPool 레이어를 반복해서 쌓으며 이미지의 특징을 추출한 뒤, 이미지를 1차원으로 바꿔(Flatten()) Label로 분류하는 모델을 쌓고 있습니다. 이 때 Dropout 레이어를 넣어 과적합을 방지하고자 했으며 마지막 Dense 레이어를 보면 Label 개수에 맞춰 unit을 10으로 정하고 활성화함수를 softmax로 설정한 것을 알 수 있습니다. line 82 - 87에서는 CNN 모델의 학습 과정을 설정하고 실제로 모델을 학습하는 모습을 볼 수 있는데, 여기서 sparse_categorical_crossentropy라는 다소 생소한 손실 함수를 사용했습니다. sparse_categorical_crossentropy는 categorical_crossentropy와 같은 다중 분류 손실 함수지만, 샘플 값을 입력하는 부분에서 One-hot encoding을 하지 않고 정수 값을 넘겨줄 수 있다는 점에서 차이가 있습니다. 또한 모델 학습에서 validation_split을 0.25로 지정했는데, validation_split은 train_X와 train_Y에서 일정 비율을 분리해 검증 데이터로 사용하며, 검증 데이터는 각 Epoch마다 검증 데이터의 정확도를 출력해 훈련이 잘 이루어지고 있는지를 알고싶을때 사용됩니다. 이 검증 데이터는 훈련에는 반영되지 않고 단지 훈련 과정을 지켜보기 위한 용도로만 사용됩니다.

마지막으로 loss와 accuracy 그래프를 출력하고 모델을 평가하는 코드입니다. matplotlib 라이브러리를 이용해 그래프를 그리고 model.evaluate()로 모델을 평가하고 있습니다. 그래프를 그리는 코드에서 loss는 매 에포크 마다의 훈련 손실값, val_loss는 매 에포크 마다의 검증 손실값, acc는 매 에포크 마다의 훈련 정확도, val_acc는 매 에포크 마다의 검증 정확도를 나타냅니다. 위에서 validation_split으로 분류한 검증 데이터가 val_loss와 val_acc의 데이터가 됩니다. 그래프를 그렸을 때 만약 loss는 감소하는데 val_loss는 증가한다는 것은 과적합이 일어났다는 것을 뜻합니다. verbose는 학습 중 출력되는 문구를 설정하는데, verbose=0은 아무것도 출력하지 않으며 verbose=1은 훈련의 진행도를 보여주는 진행 막대를, verbose=2는 미니 배치마다 손실 정보를 출력합니다.

출처: 딥러닝을 이용한 자연어 처리 입문

이제 코드를 실행하여 출력화면을 보겠습니다. 먼저 아래의 그래프를 보면 loss는 Epoch에 따라 급격히 줄어드는 반면 val_loss는 줄어들다 늘어났다를 반복하며 0.35와 0.4 사이에 머물고 있습니다. 언뜻보면 과적합이 일어난 상태라고 해석할 수도 있지만, MaxPooling 레이어와 Dropout 레이어를 사용하지 않았을 때에 비하면 훨씬 개선된 수준이라는 것을 알 수 있습니다. loss, accuracy의 최종 결과를 보면 [0.3989..., 0.8932]로, Conv2D와 Dense 레이어만 사용해 해결했을 때에 비해 좋아졌다는 것을 알 수 있습니다. Conv2D와 Dense 레이어만 사용해 문제를 해결한 코드는 따로 작성하진 않지만, 실제로 두 코드를 실행해 결과를 확인해보면 정확도가 0.8577에서 0.8932로 4%가량 높아졌음을 알 수 있습니다. 손실에서는 큰 차이를 보입니다.

case 1. 코드 실행 그래프

case 2. Conv2D, Dense 레이어만 사용해 이미지를 분류했을 때

case 1. 코드 실행 출력 화면

case 2. Conv2D, Dense 레이어만 사용해 이미지를 분류했을 때

CNN 퍼포먼스 향상

CNN 모델을 사용해 Fashion MNIST를 분류하는 문제에서 손실을 줄이고 정확도를 높이는 등 더 좋은 퍼포먼스를 내는데에는 여러 방법들이 있지만, 그 중 대표적인 두 방법을 알아보겠습니다. 첫 번째는 더 많은 레이어 쌓기 입니다. 당연하게끔 더 많은 레이어를 쌓으면 이미지의 특징을 더 많이 추출할 수 있을 것으로 기대할 수 있습니다. Fashion MNIST를 CNN을 사용해 분류하는 유명한 모델중 하나인 VGG-19는 Convolution과 Pooling 레이어를 겹쳐 총 19개의 레이어를 겹쳐 만들었습니다. 이렇게 되면 이미지 분류에 대한 정확도는 높아지는데, 다만 굉장한 양의 연산을 필요로 하기 때문에 실행에 많은 메모리와 시간을 필요로합니다. 따라서 네트워크를 축소화하여 Convolution 레이어를 2개 겹치고 Pooling 레이어를 하나 겹치는 패턴을 두번 반복하는 VGG-7 Net으로 실행해 정확도를 측정해보면 92%의 매우 높은 정확도를 보임을 알 수 있습니다. 두 번째 방법은 이미지 보강입니다. 이미지 보강은 훈련 데이터에 없는 이미지를 새롭게 만들어 내어 훈련 데이터를 보강하는 작업인데, 예를 들어 위의 Fashion MNIST 첫 번째 이미지를 보면 운동화의 코가 왼쪽을 향하고 있습니다. 이 때 만약 Fashion MNIST에 운동화의 코가 오른쪽을 향하는 이미지가 들어왔다면 신경망은 새로운 이미지에 대해 좋은 결과를 내지 못할 것 입니다. 이를 위해 이미지를 가로로 뒤집거나(horizonal flip) 운동화의 코가 오른쪽으로 향하도록 회전시키거나(rotate), 기울이거나(shear) 확대하는(zoom) 등으로 다양한 이미지를 만들어 내어 데이터의 표현력을 조금 더 좋게 만들 수 있습니다. keras에는 이미지 보강을 위해 ImageDataGenerator가 내장되어 있습니다. Fashion MNIST의 첫 번째 이미지에 대해서만 코드로 확인해보겠습니다.

# Image Augmentation 데이터 표시
image_generator = ImageDataGenerator(
    rotation_range=10,
    zoom_range=0.10,
    shear_range=0.5,
    width_shift_range=0.10,
    height_shift_range=0.10,
    horizontal_flip=True,
    vertical_flip=False)

augment_size = 100

x_augmented = image_generator.flow(np.tile(train_X[0].reshape(28 * 28), 100).reshape(-1, 28, 28, 1),
                                   np.zeros(augment_size), batch_size=augment_size, shuffle=False).next()[0]

# 새롭게 생성된 이미지 표시
plt.figure(figsize=(10, 10))
for c in range(100):
    plt.subplot(10, 10, c + 1)
    plt.axis('off')
    plt.imshow(x_augmented[c].reshape(28, 28), cmap='gray')

plt.show()

운동화 이미지가 여러 가지 형태로 조금씩 바뀐 것을 확인할 수 있습니다.각 이미지는 비슷하면서도 자세히 보면 조금씩 다릅니다. 이미지 보강 코드에 대해서는 다음번에 자세히 알아보도록 하겠습니다.