(─━┘_└━─)/ 머리만1톤(Head1Ton)

우리는 한번쯤 스무고개라는 놀이를 해본 경험이 있을 겁니다. 상대방이 가지고 있는 답을 20번 이내의 질문으로 알아 맞추는 것이죠. 스무고개는 정답을 맞추는 사람이 질문을 잘 던져야 답을 제대로 빨리 찾아낼 수 있습니다.

스무고개와 비슷한 원리로, 의사결정트리 분류기(decison tree classifier)는 일련의 질문에 근거하여 주어진 데이터를 분류해주는 알고리즘입니다. 아래의 그림을 보시죠.

이 그림은 휴일에 무엇을 할지 결정하기 위한 의사결정트리의 한 예입니다. 흰색 둥근 사각형으로 되어 있는 부분이 의사결정을 위한 질문이고, 회색으로 채워진 사각형은 의사결정이 된 부분입니다.

이와 비슷한 원리로 꽃잎길이와 꽃잎너비와 같이 수치로 되어 있는 데이터에 대해서도 의사결정트리를 이용해 분류가 가능하겠지요. 예를 들면 아래 그림과 같이 3-depth 질문으로 분류가 가능한 질문을 만들 수가 있을 것입니다.

위 그림을 해설하면 이렇습니다.

첫 번째 질문인 꽃잎너비가 0.75 이하인 녀석들만 분류를 해봤더니 setosa로 모두 분류되었고, 그렇지 않은 녀석들 중에 꽃잎길이가 4.9 이하인 녀석들만 모아보니 versicolor와 verginica의 비율이 10:4로, 꽃잎길이가 4.9 초과하는 녀석들만 모아보니 versicolor와 verginica의 비율이 2:10으로 나오더라 입니다. 마찬가지로 각기 분류된 녀석들 각각에서 꽃잎너비가 1.6이하인지, 꽃잎길이가 5.0 이하인지로 질문을 던져서 각각 분류해보니 최종적으로 맨 아래의 회색 사각형처럼 분류되더라..가 결론입니다.

만약 이 질문의 깊이가 더 깊어지면 보다 더 정확한 값들로 분류가 되겠지만, 이전 포스팅에서 말한 오버피팅이 되버리는 문제가 발생할 수 있으므로 적절한 선에서 질문을 잘라줘야 합니다.

그렇다면 이런 일련의 질문들을 어떻게 만들 수 있을까요...?

의사결정트리 학습은 트레이닝 데이터를 이용해 데이터를 최적으로 분류해주는 질문들을 학습하는 머신러닝입니다.

의사결정트리 학습에 대한 개념은 이것이 다입니다. 이제 의사결정트리에서 질문들을 만들어내기 위한 메커니즘에 대해 가볍게 살펴봅니다. 말은 가볍게라고 썼지만 결코 가볍지 않습니다.

​

의사결정트리 학습에서 각 노드에서 분기하기 위한 최적의 질문은 정보이득(Information Gain)이라는 값이 최대가 되도록 만들어주는 것이 핵심입니다. 어느 특정 노드에서 m개의 자식 노드로 분기되는 경우 정보이득은 아래의 식으로 정의합니다.

여기서, f는 분기를 시키기 위한 트레이닝 데이터의 특성값(예를 들어, 꽃잎 길이 또는 꽃잎 너비)이며 Dp는 부모노드에 존재하는 데이터 세트, Dj는 j번째 자식노드에 존재하는 데이터 세트입니다. I(Dp)는 Dp의 데이터 불순도(impurity), I(Dj)는 Dj의 데이터 불순도를 의미합니다. 그리고 Np와 Nj는 Dp의 데이터 개수와 Dj의 데이터의 개수입니다.

여기서 데이터 불순도란 데이터가 제대로 분류되지 않고 섞여 있는 정도를 말하는데, 이에 대해서는 아래에서 좀 더 자세히 다루도록 하겠습니다.

아무튼 정보이득 IG는 자식노드의 데이터 불순도가 작으면 작을수록 커지게 됩니다.

계산을 단순화하기 위해 보통 의사결정트리에서 분기되는 자식 노드의 개수는 2개로 하는데, 이를 이진 의사결정트리(Binary decision tree)라고 부릅니다. 특정 노드에서 분기되는 2개의 자식노드를 각각 L과 R첨자를 나타내서 표현하여 위 식을 단순화하면 아래와 같은 식이 됩니다.

아까 위에서 데이터 불순도를 언급했는데, 이진 의사결정트리에서 데이터 불순도를 측정하는 방법은 아래와 같이 3가지가 있습니다.

1. 지니 인덱스(Gini Index)
2. 엔트로피(entropy)
3. 분류오류(classification error)

위 그림과 같이 80개의 데이터가 40개씩 두 종류의 데이터로 분류되어 있고, 이를 (40, 40)과 같이 표현해 봅니다. 의사결정트리 A는 (40, 40)을 (30, 10), (10, 30)으로 분리하는 것이고, 의사결정트리 B는 (40, 40)을 (20, 40), (20, 0)으로 분리하는 것입니다.

여기서 데이터 불순도 계산 방법으로 분류오류를 적용하고, 최종적으로 A, B의 정보이득을 각각 계산해보도록 하겠습니다.

​

Dp의 데이터 불순도를 계산하려면 p(i\t)를 계산해야 하겠죠. p(i\t)는 노드 t에 존재하는 데이터 중, i부류에 속하는 데이터 비율이라고 했습니다. 위의 예에서 2가지 부류만 있으므로 편의상 제1부류, 제2부류라 하겠습니다. (40, 40)은 80개의 데이터 중 40개는 제1부류에, 나머지 40개는 제2부류에 속하는 멤버이므로 p(1\t), p(2\t)는 모두 0.5로 같습니다. 따라서 위에서 서술한 분류오류에 의한 데이터 불순도 역시 제1부류, 제2부류 모두 0.5로 같습니다.

마찬가지 방법으로 DL, DR의 데이터 불순도를 계산할 수 있겠지요. 계산식을 적어보면 다음과 같습니다.

​

의사결정트리 A의 경우 불순도 I(Dp), I(DL), I(DR) 및 정보이득 IG 계산

​

​

​

따라서 정보이득 계산식에 의한 정보이득 값은 다음과 같습니다.

​의사결정트리 B의 경우 불순도 I(Dp), I(DL), I(DR) 및 정보이득 IG 계산 

따라서 정보이득계산 식에 의한 정보이득 값은 다음과 같습니다.

이제 정보이득을 계산하는 원리는 대충 이해했겠지요.

비슷한 방법으로 데이터 불순도를 계산하는 방법으로 지니 인덱스, 엔트로피를 적용하였을 경우 A, B에서 정보이득은 다음과 같이 계산됩니다.

지니 인덱스로 계산한 경우

• A에서 정보이득 : 0.125
• B에서 정보이득 : 약 0.16

• A에서 정보이득 : 0.19
• B에서 정보이득 : 0.31

여태까지 다루었던 scikit-learn의 퍼셉트론, 로지스틱 회귀, SVM은 경사하강법 알고리즘을 적용한 것입니다.

만약 머신러닝을 수행할 데이터가 대용량이라면 확률적 경사하강법(Stochastic Gradient Descent) 알고리즘을 적용한 버전이 여러모로 효율적일 수 있습니다.

scikit-learn의 SGDClassifier 클래스는 확률적 경사하강법 알고리즘을 적용한 퍼셉트론, 로지스틱 회귀, SVM을 활용할 수 있도록 해줍니다.

확률적 경사하강법을 적용한 퍼셉트론, 로지스틱 회귀, SVM을 이용하려면 아래와 같은 코드를 적용하면 됩니다.

이전 포스팅의 skl_svm.py에서 아래의 모듈을 추가합니다.

scikit-learn의 Perceptron(), LogisticRegression(), SVC() 대신 SGDClassifier()의 loss 인자값을 달리해서 확률적 경사하강법 알고리즘을 적용한 것으로 대체할 수 있습니다.

수정한 코드를 반영하여 skl_sgd.py로 저장합니다. 

skl_sgd.py 

확률적 경사하강법을 적용한 퍼셉트론, 로지스틱 회귀, SVM의 실행 결과는 다음과 같습니다.

확률적 경사하강법 적용 퍼셉트론 실행 결과

확률적 경사하강법 적용 로지스틱 회귀 실행 결과

확률적 경사하강법 SVM 실행 결과 

결과를 보면 퍼셉트론을 제외하고 로지스틱 회귀나 SVM은 영역 구분 자체가 완전히 달라졌음을 알 수 있습니다. 참고로 확률적 경사하강법을 적용한 코드는 실행할 때마다 그 결과값이 다르게 나옵니다. 

로지스틱 회귀와 함께 분류를 위한 강력한 머신러닝 알고리즘으로 널리 사용되는 것이 바로 SVM(Support Vector Machine)입니다.

SVM은 퍼셉트론의 개념을 확장하여 적용한 알고리즘인데, 퍼셉트론이 분류 오류를 최소화하는 알고리즘인 반면 SVM은 margin을 최대가 되도록 하는 알고리즘입니다.

여기서 말하는 margin은 분류를 위한 경계선과 이 경계선에 가장 가까운 트레이닝 데이터 사이의 거리를 말합니다. 이 경계선에 가장 가까운 트레이닝 데이터들을 support vector라고 부릅니다. 아래의 그림을 보시죠~

위의 왼쪽 그림을 보면 빨간색 원으로 표시된 집단과 초록색 더하기 기호로 표시된 집단을 분류하는 경계선은 다양하게 존재할 수 있습니다. SVM은 두 집단을 분류하는 경계선 중 support vector와의 거리가 가장 멀리 떨어져 있는 경계선을 찾아내는 알고리즘입니다.

​

이 알고리즘은 경계선에 가장 가까이 있는 support vector를 지나는 선과 거리가 최대가 되는 경계선을 구함으로써 그 목적을 달성하게 됩니다. 여기서 말한 선은 엄밀히 말하면 다차원 공간의 초평면(hyperplane)인데, 초평면의 개념을 설명하기도 복잡하고, 실제 초평면을 머릿속으로 상상하기도 힘들므로, 그냥 선으로 생각하고 사용해도 큰 무리가 없으므로 초평면을 선으로 생각하도록 하겠습니다.

SVM이 퍼셉트론의 개념으로부터 출발하고 확장된 것이므로 입력되는 트레이닝 데이터, 입력값과 곱해지는 가중치와 관련된 수식들이 등장하게 되는데, 중간단계의 복잡한 수식을 모두 스킵하면 결국 아래 수식의 최소 값을 구하는 것이 SVM의 핵심 원리가 됩니다.

여기서 j는 트레이닝 데이터의 특성값의 개수가 그 범위가 되며, i는 트레이닝 데이터의 개수가 그 범위가 됩니다. C는 로지스틱 회귀에서 설명했던 정규화와 관련된 상수와 비슷한 개념이며 ξ는 여유 변수(slack variables)라고 부르는데, 이 변수는 분류 오류가 생기는 데이터에 적절한 패널티를 부여함으로써 비선형적으로 분리되는 모델을 완화시켜 최적화된 수렴값을 가지도록 하기 위한 선형 제약(linear contraints) 값입니다.

말이 좀 어렵지만 여기서 우리가 눈여겨 볼 부분이 C입니다. C값을 변화시키면 알고리즘이 결정하는 경계선이 달라집니다. 아래의 그림을 보면서 살포시 이해를 해봅니다.

위 그림과 같이 빨간색 원으로 이루어진 집단과 초록색 더하기 기호로 이루어진 집단이 분포하고 있을 때, C 값이 크면 왼쪽 그림처럼, C 값이 작으면 오른쪽 그림처럼 경계선이 결정됩니다. 왼쪽 그림에서 경계선은 오버피팅되었다고 볼 수 있고 오른쪽 그림에서 경계선은 최적화 되었다고 볼 수 있습니다. 

대충 눈치를 챘겠지만 scikit-learn의 SVM을 적용할 때도 위에서 설명한 C값이 등장하게 됩니다.

이전 포스팅에서 구현했던 skl_logistic.py에서..

아래와 같이 SVM을 활용하기 위한 모듈을 추가합니다.

그리고 if __name__ == '__main__': 에서 로지스틱 회귀 알고리즘을 호출하는 부분을 아래의 내용으로 바꿉니다.

마지막으로 plot_decision_regions() 함수 호출부분에서 title 인자를 적절한 값으로 수정합니다.

수정된 코드를 skl_svm.py로 저장합니다.

skl_svm.py 

추가된 코드에서 C 값으로 1.0이 할당되어 있습니다. 이 C값을 조정함으로써 언더피팅과 오버피팅을 조절하게 됩니다.  

이제 코드를 수행해보면 아래와 같은 결과가 나옵니다.

로지스틱 회귀가 구분한 경계선과 비교해보면 경계선과 support vector와의 거리가 동일하게 그려져 있음을 알 수 있습니다. 결과의 품질은 로지스틱 회귀와 동일하게 나오네요. 

로지스틱 회귀(logistic regression)는 선형 또는 바이너리 분류 문제를 위한 단순하면서도 보다 강력한 분류 알고리즘입니다. 로지스틱 회귀에서 등장하는 회귀(regression)는 통계에서 말하는 회귀와는 별로 관계가 없는, 머신러닝의 분류와 관련된 알고리즘 이름으로 생각하면 됩니다.

로지스틱 회귀는 선형 분리 모델에서 훌륭하게 동작하며, 실제로 가장 많이 사용되는 분류 알고리즘 중 하나입니다. 머리가 좀 아프더라도 로지스틱 회귀를 살포시 이해하도록 해봅니다.

로지스틱 회귀를 이해하기 위한 첫 단계는 다음과 같은 약간의 확률과 관련된 지식이 필요합니다.

영어로 odds는 어떤 일이 일어날 승산을 말합니다. 특정 사건의 승산률 odds ratio는 다음과 같이 정의됩니다.

여기서 p는 어떤 특정 사건이 발생할 확률입니다. 즉 odds ratio는 어떤 특정 사건이 일어날 확률과 그 사건이 일어나지 않을 확률의 비로 정의됩니다.

다시 우리의 머신러닝 주제로 돌아갑니다. 우리가 머신러닝을 수행해서 얻은 학습 결과를 이용해 어떤 값에 대한 예측값이 실제 결과값과 동일하게 나올 확률을 p라고 하면 이 머신러닝의 odds ratio 역시 위와 같이 정의됩니다.

이제, odds ratio의 로그값을 함수값으로 가지는 함수를 정의해 봅니다.

p는 0과 1사이의 수이고,  f(p)의 범위는 실수 전체가 됩니다. 우리가 이전 포스팅에서 다루었던 순입력 함수의 리턴값을 다시 한번 상기해 봅니다.  순입력 함수의 리턴값을 z로 표기하면 아래와 같습니다.

z는 w의 값에 따라 실수 전체에 대해 매핑되는 값이며, z의 값에 따라 입력된 트레이닝 데이터 X가 어떤 집단에 속하는지 아닌지 결정하게 되는 값입니다. 따라서 위에서 정의한 f(p)의 값을 z로 매핑할 수 있습니다.

여기서, p를 z에 관한 식으로 나타내면 아래와 같은 식이 됩니다. (고등학교때 배웠던 지수와 로그의 관계식을 알면 됩니다!)

이 확률 p를 z에 관한 함수로 표현하여 다음과 같이 나타냅니다.

이 함수를 그래프로 그려보면 다음과 같은 s자 형태의 곡선으로 나타납니다. 이런 이유로 이 함수를 sigmoid 함수라고 부릅니다.  

로지스틱 회귀에서는 순입력 함수의 리턴값에 대해 가중치 업데이트 여부를 결정하는 활성 함수로 이 sigmoid 함수를 이용합니다.

즉 로지스틱 회귀는 순입력 함수의 리턴값을 sigmoid 함수에 대입하여 그 결과값을 가지고 가중치 업데이트를 할지 말지를 결정하는 것이 핵심입니다. sigmoid 함수의 리턴값은 곧 입력한 트레이닝 데이터가 특정 클래스에 속할 확률이 되므로, 로지스틱 회귀는 입력되는 트레이닝 데이터의 특정 클래스에 포함될 예측 확률에 따라 머신러닝을 수행하는 알고리즘임을 알 수 있습니다.

우리는 실생활에서 예측되는 부류(class) 그 자체 뿐만 아니라 그 부류에 속할 확률이 유용할 때가 많습니다. 일기예보에서 내일 비가 올 확률을 예측하는 것이라던지, 환자의 증상을 보고 그 환자가 특정 질병에 걸렸을 확률을 계산하는 것 등이 그 예입니다. 로지스틱 회귀는 실제로 의학 분야에서 광범위하게 활용되고 있기도 합니다.

​

로지스틱 회귀에서 활용되는 비용함수 J(w)와 가중치 업데이트 식은 퍼셉트론의 그것과 동일한 원리이며, 이에 대한 구체적인 내용은 본 포스팅의 목적에 어울리지 않게 너무 어려워서 패스하도록 합니다.

그러면 아이리스 데이터를 가지고 scikit-learn을 이용하여 로지스틱 회귀 알고리즘으로 머신러닝을 수행하는 코드를 봅니다.

이전 포스팅에서 설명한 skl_perceptron.py 코드에서 아래의 내용을 반영합니다.

필요 모듈 임포트하는 부분에서 아래 코드를 추가합니다.

if __name__ == '__main__': 에서 아래 코드를 찾습니다.

이 부분을 아래의 코드로 수정합니다.

​

마지막으로 plot_decision_regions() 함수 호출부분에서 title 인자를 적절하게 변경합니다.

​

이렇게 작성된 코드를 skl_logistic.py로 저장합니다.

​

skl_logistic.py

​

​ 

결국 scikit-learn의 퍼셉트론 코드와 로지스틱 회귀 코드는 알고리즘을 선택하고 적용하는 부분만 다릅니다.

그런데 LogisticRegression()을 보면 C=1000.0 이라는 생소한 부분이 보입니다. 이 값을 이해하려면 머신러닝에 있어 공통적으로 나타나는 문제인 오버피팅과 이를 해결하기 위한 정규화라는 개념을 알아야 합니다.

오버피팅(Overfitting)이란 말 그대로 너무 잘 맞아 떨어진다는 뜻이며, 이는 머신러닝을 위해 입력된 값에만 너무 잘 맞아 떨어지도록 계산을 해서 입력에 사용된 트레이닝 데이터 이외의 데이터들에 대해서는 잘 맞아 떨어지지 않는 경우가 발생하게 되어 미지의 데이터에 대해 그 결과를 예측하기 위한 머신러닝의 결과로는 바람직하지 않습니다.

아래의 그림을 보면 오버피팅을 이해할 수 있습니다. 물론 이 그림은 'Python Machine Learning'에서 가져온 것입니다.

위 그림에서 2번째 그림처럼 최적의 조건을 찾기 위해 사용되는 것이 정규화(regularization)라는 기법인데, 정규화를 통해 데이터 모델의 복잡성을 튜닝하여 언더피팅과 오버피팅의 트레이드 오프(trade-off)를 찾아내는 것입니다. 로지스틱 회귀에서 사용되는 정규화 기법은 가장 일반적으로 사용되는 L2 정규화인데, 위의 코드에서 생소했던 C=1000.0 부분이 L2 정규화와 관련된 인자로 이해하시면 됩니다.

L2 정규화는 로지스틱 회귀의 비용함수 J(w)를 아래와 같은 식으로 변형하여 동작합니다.

여기서 λ를 정규화 파라미터라고 부르며, C값은 λ의 역수로 정의합니다.

따라서 C값을 감소시키면 λ가 커지게 되며, 이는 정규화를 강하게 한다는 의미입니다. 아무튼 생소했던 C값이 무엇인지 대충은 알았으므로 이쯤에서 넘어 가도록 하겠습니다.

코드를 수행하면 다음과 같은 결과가 나옵니다.

결과를 보면 scikit-learn 퍼셉트론에 비해 로지스틱 회귀가 아이리스 데이터에 대해 더 정확도 높게 분류하고 있고, 머신러닝에 의해 분리된 영역이 퍼셉트론의 결과와 다르다는 것을 알 수 있습니다.

이것으로 로지스틱 회귀에 대한 내용은 마무리하겠습니다. 

[10편] 'scikit-learn을 이용해 퍼셉트론 머신러닝 수행하기'에서 scikit-learn의 퍼셉트론으로 아이리스 데이터의 70%를 가지고 머신러닝을 수행하고, 나머지 30%의 데이터로 머신러닝 결과를 테스트해보는 코드를 제시했습니다.

이번에는 70%의 데이터를 가지고 머신러닝을 수행한 결과가 실제 어떻게 데이터들을 분류하고 있는지 그래프로 나타내보고, 퍼셉트론 알고리즘의 유효성에 대해 고찰해보고자 합니다.

먼저, 아래의 코드를 작성하고 mylib 폴더에 plotdregion.py로 저장합니다.

plotdregion.py

이 코드는 plot_decision_region 함수의 인자 classifier로 주어진 퍼셉트론 분류기를 이용해 머신러닝을 수행한 결과가 트레이닝 데이터가 분포하고 있는 좌표계에서 어떻게 영역을 구분하는지 보여주기 위함입니다.

원리는 이렇습니다.

아이리스 트레이닝 데이터 X는 (꽃잎길이, 꽃잎너비) 2개의 값으로 되어 있으므로 x축의 값으로 꽃잎길이, y축의 값으로 꽃잎너비로 되어 있는 좌표계에 데이터를 표시할 수 있습니다.

그리고 좌표계를 바둑판으로 생각해보면, 좌표계에서 격자의 교차점도 아이리스 데이터 (꽃잎길이, 꽃잎너비)의 어떤 값이라고 생각할 수 있겠지요. 따라서 이 교차점의 좌표를 인자 classifier로 주어진 퍼셉트론 분류기로 머신러닝을 수행하여 나온 결과도 iris-setosa, iris-versicolor, iris-virginica를 의미하는 0, 1, 2 중 어느 한개의 값이 될 것이고, 0으로 되어 있는 영역은 빨간색, 1로 되어 있는 부분은 파란색, 2로 되어 있는 부분은 초록색으로 표시를 하여 머신러닝의 결과를 영역으로 표시하게 됩니다.

그럼 코드의 주요부분을 설명하겠습니다.

>>> markers = ('s', 'x', 'o', '^', 'v')

>>> colors = ('r', 'b', 'lightgreen', 'gray', 'cyan')

>>> cmap = ListedColormap(colors[:len(np.unique(y))])

markers는 matplotlib에서 정의한 점 표시 모양 5개를 튜플로 정의한 것이고, colors는 색상 5개를 튜플로 정의한 것입니다. ListedColormap은 인자로 주어진 색상을 그래프상에 표시하기 위한 객체입니다. numpy.unique(y)는 y에 있는 고유한 값을 작은 값 순으로 나열합니다. 예를 들어 [1, 0, 0, 2, 2, 0, 0, 1, 2]에는 고유한 값이 0, 1, 2밖에 없으므로 numpy.unique([1, 0, 0, 2, 2, 0, 0, 1, 2])는 [0, 1, 2]가 됩니다. 

따라서 cmap = ListedColormap(colors[:3])이 되어 cmap에는 colors[0], colors[1], colors[2]가 매핑된 ListedColormap 객체가 됩니다. 이는 곧 빨간색, 파란색, 밝은 초록색이 매핑되는 겁니다.

>>> x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1

>>> x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1

>>> xx, yy = np.meshgrid(np.arange(x1_min, x1_max, resolution),

                                np.arange(x2_min, x2_max, resolution)) 

x1_min, x1_max는 트레이닝 데이터 X의 첫 번째값인 꽃잎길이의 최소값-1, 최대값+1 입니다.

마찬가지로 x2_min, x2_max는 트레이닝 데이터 X의 두 번째값인 꽃잎너비의 최소값-1, 최대값+1 입니다. 

numpy.meshgrid()는 격자의 교차점 좌표를 편리하게 다룰 수 있도록 값을 리턴하는 함수입니다. 이해를 돕기 위해 아래의 코드를 봅니다.

>>> x = [0, 1, 2, 3, 4, 5]

>>> y = [0, 1, 2, 3, 4, 5]

>>> xx, yy = np.meshgrid(x, y)

>>> plt.plot(xx, yy, marker='.', color='k', linestyle='none')

이 코드는 x 범위 0~5까지 정수, y 범위 0~5까지 정수를 좌표로 하는 격자의 교차점의 위치를 찍어주는 코드입니다. 실행을 해보면 다음과 같은 결과가 나옵니다.

따라서 원래 코드에서 xx와 yy는 아이리스 트레이닝 데이터의 꽃잎길이, 꽃잎너비가 분포하는 좌표 격자 교차점을 resolution 간격으로 편리하게 만들어줄 수 있는 값을 가지고 있습니다.

>>> Z = classifier.predict(np.array([xx.ravel(), yy.ravel()]).T)

>>> Z = Z.reshape(xx.shape) 

xx, yy를 ravel()을 이용해 1차원 배열로 한줄로 쭉 만든 후 전치행렬로 변환하여 퍼셉트론 분류기의 predict()의 인자로 입력하여 계산된 예측값을 Z로 둡니다. Z를 reshape()을 이용해 원래 배열 모양으로 복원합니다.

>>> plt.contourf(xx, yy, Z, alpha=0.5, cmap=cmap)

Z를 xx, yy가 축인 그래프상에 cmap을 이용해 등고선을 그립니다.

이후 부분은 아이리스 트레이닝 데이터를 matplotlib의 산점도 그리기를 이용해 그래프상에 찍어주는 겁니다. 특히 테스트 데이터는 강조하는 원으로 다시 표시 해주었습니다. matplotlib의 산점도 그리기 포스팅을 참고하면 됩니다.

☞ matplotlib으로 산점도 그리기 바로가기

이제 이전 포스팅의 skl_perceptron0.py의 if __name__ == '__main__':코드 맨 마지막에 아래의 코드를 추가해서 skl_perceptron.py로 저장합니다.

​ 

여기서 numpy.vstack(x, y)는 x배열과 y배열을 수직으로 쌓는 것이고, numpy.hstack(x, y)는 x배열과 y배열을 수평으로 쌓는 것입니다.

skl_perceptron.py 

코드를 실행해보면 다음과 같은 결과를 볼 수 있습니다.

scikit-learn의 퍼셉트론 알고리즘의 아이리스 트레이닝 데이터를 이용해 머신러닝한 결과는 iris-setosa를 빨간색 영역으로, iris-versicolor를 파란색 영역으로, iris-virginica를 초록색 영역과 같이 분류합니다.

그런데 실제 데이터 분포를 보면 알 수 있듯이 x로 표시된 iris-versicolor가 빨간색 영역과 초록색 영역에서도 보이고, 초록색 원으로 표시된 것도 파란색 영역에서 찾을 수 있습니다. 따라서 퍼셉트론으로 아이리스 3가지 품종을 완벽하게 분류하지 못했다는 것을 알 수 있습니다. 테두리가 검정색인 원으로 표시한 것이 테스트 데이터입니다. 테스트 데이터 중 4개가 엉뚱한 영역에 있음을 알 수 있습니다. 

퍼셉트론은 이와 같이 선형분리가 완벽하게 되지 않는 데이터로는 머신러닝을 제대로 수행할 수 없습니다.

이미 말했듯이 퍼셉트론이나 이를 발전시킨 아달라인은 머신러닝을 위한 트레이닝 데이터가 완전히 선형 분리가 되어 있지 않으면 제대로 된 머신러닝을 수행할 수 없습니다. 하지만 우리가 접하는 대부분의 데이터들은 선형 분리가 불가능한 것들이며, 이런 이유로 머신러닝을 위한 방법으로써 퍼셉트론은 실제로 잘 활용되지는 않습니다.

그렇지만 퍼셉트론은 분류(classification)를 위한 다양한 알고리즘의 개발과 발전에 기초 개념을 제공했다는 것만으로도 매우 가치가 있는 것이죠~

다양한 분류 알고리즘 중, 해결하고자 하는 문제에 최적인 알고리즘을 선택하는 일은 경험이 필요합니다. 이 분류 알고리즘으로 트라이 해보고, 저 분류 알고리즘으로 한번 트라이 해보고, 이런 식으로 다양한 분류 알고리즘을 적용하여 가장 최적인 결과가 나오는 것을 선택하는 것이죠. 이 후, 이와 유사한 작업을 할 경우에는 최적인 알고리즘을 채택해서 적용하게 되는 것입니다. 따라서 우리가 획득하고 트레이닝 시킬 데이터의 종류에 따라 최적인 분류 알고리즘을 찾는 것이 중요합니다.

분류를 위한 머신러닝을 수행할 때 일반적으로 아래의 단계를 따릅니다.

1. 트레이닝 데이터에서 트레이닝을 수행할 적절한 특성(feature)값(실제 머신러닝을 위해 입력되는 값) 선택하기
2. 성능 메트릭(performance metric) 선택하기
3. 분류기(classifier)를 선택하고 알고리즘 최적화하기
4. 머신러닝 성능 측정하기
5. 알고리즘 튜닝하기

위에서 설명한 각 단계의 자세한 내용은 차근차근 진행하도록 하도록 하고, 이번 포스팅에서는 우리가 이미 직접 파이썬으로 구현해보았던 퍼셉트론을 scikit-learn API를 이용해 수행해보는 것입니다.

scikit-learn은 파이썬으로 구현한 머신러닝을 위한 확장 라이브러리입니다. scikit-learn은 아래와 같이 머신러닝을 위한 다양한 API를 제공합니다.

• Classification
• Regression
• Clustering
• Dimensional reduction
• Model selection
• Preprocessing

이와 관련한 많은 내용을 알고 싶다면 scikit-learn 공식 사이트를 방문해서 살펴보도록 하세요~

☞ scikit-learn 공식 사이트 바로 가기

여러분의 컴퓨터에 scikit-learn이 아직 설치되어 있지 않았다면 윈도우 명령 프롬프트를 실행하고 다음과 같이 pip를 이용해 scikit-learn을 설치합니다.

pip install scikit-learn

자 그러면 아래의 코드를 작성하고 skl_perceptron0.py로 저장합니다.

skl_perceptron0.py 

>>> from sklearn import datasets

>>> from sklearn.cross_validation import train_test_split

>>> from sklearn.preprocessing import StandardScaler

>>> from sklearn.linear_model import Perceptron

>>>from sklearn.metrics import accuracy_score

scikit-learn의 필요한 모듈을 임포트합니다.

이후에 등장하는 코드는 이전 포스팅에서 퍼셉트론이나 아달라인을 잘 이해했다면, scikit-learn에서 제공하는 API를 이용하는 것 이외에는 거의 동일한 프로세스로 머신러닝을 수행하게 됩니다.

>>> iris = datasets.load_iris()

scikit-learn에는 이전 포스팅에서 학습 데이터로 다루었던 아이리스에 대한 데이터를 자체적으로 가지고 있습니다. 이 데이터는 datasets 모듈의 load_iris() 함수를 통해 읽어올 수 있는데, scikit-learn에서 정의한 특이한 클래스 형태로 저장되어 있습니다.

>>> X = iris.data[:, [2, 3]]

>>> y = iris.target   

X에 아이리스 데이터에서 꽃잎길이와 꽃잎너비 데이터를 대입합니다. 그리고 y에는 품종 데이터를 담습니다. y를 화면에 출력해보면 알겠지만 y에 저장된 아이리스 품종데이터는 0, 1, 2의 값으로만 구성되어 있습니다. 이는 iris-setosa, iris-versicolor, iris-verginica에 해당하는 값입니다. 즉, scikit-learn에서 품종 데이터를 이미 숫자로 바꾸어 저장해둔 것입니다.

>>> X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,

                                                              random_state=0)

train_test_split()은 원래 트레이닝 데이터와 결과값인 X와 y를 무작위로 섞은 후 test_size로 주어진 비율만큼 각각 나눕니다. 예를 들어 test_size = 0.3으로 되어 있으면 X와 y를 무작위로 섞은 후에 70%는 X_train과 y_train으로, 나머지 30%는 X_test, y_test로 둡니다. random_state의 값은 난수 발생을 위한 seed의 인자값입니다.

아이리스 데이터를 70%는 트레이닝 데이터로, 나머지 30%는 테스트 데이터로 나누는 이유는 70%의 데이터로 머신러닝을 수행하여 학습이 마무리되면, 나머지 30%의 데이터에 대한 예측값과 실제 결과값을 비교함으로써 머신러닝이 얼마나 잘되었는지 확인하기 위함입니다.

>>> sc = StandardScaler()

scikit-learn의 preprocessing 모듈이 제공하는 StandardScaler()는 표준화를 적용하기 위한 클래스입니다. 표준화에 대해서는 이미 이전 포스팅에서 자세히 다루었습니다.

>>> sc.fit(X_train)

X_train의 평균과 표준편차를 구합니다.

>>> X_train_std = sc.transform(X_train)

>>> X_test_std = sc.transform(X_test)

X_train과 X_test를 표준화한 데이터를 각각 X_train_std, y_test_std에 대입합니다.

>>> ml = Perceptron(eta0=0.01, n_iter=40, random_state=0)

>>> ml.fit(X_train_std, y_train)

scikit-learn의 linear_model에는 머신러닝을 위한 다양한 선형모델 알고리즘들을 제공합니다. 여기에는 Perceptron 클래스도 포함되어 있습니다. learning rate을 0.01로 두고 퍼셉트론 객체를 생성합니다. X_train과 y_train을 이용해 머신러닝을 수행합니다.

>>> y_pred = ml.predict(X_test_std)

퍼셉트론으로 머신러닝을 수행한 후 X_test_std를 이용해서 이에 대한 예측값을 계산하고 y_pred로 둡니다.

>>> print('총 테스트 개수:%d, 오류개수:%d' %(len(y_test), (y_test != y_pred).sum()))

테스트 값에 대한 실제 결과값인 y_test와 머신러닝을 수행한 퍼셉트론에 의해 예측된  값인 y_pred를 비교하여 다른 값을 가진 개수를 출력합니다.

>>> print('정확도: %.2f' %accuracy_score(y_test, y_pred))

scikit-learn의 metrics 모듈에서 제공하는 accuracy_score()는 인자에 y_test, y_pred를 순서대로 입력하면 y_test와 y_pred를 비교하고 값이 같은 비율, 즉 정확도를 계산해줍니다.

이 코드를 수행하면 아래와 같은 결과가 나옵니다.

총 테스트 개수: 45, 오류개수: 4

정확도: 0.91

다음 포스팅에서 실제 아이리스 트레이닝 데이터가 어떻게 분포하는지 산점도로 그래프를 그려보고, 퍼셉트론 머신러닝에 의해 학습된 분류가 어떻게 이 데이터들을 구분하는지 그 영역을 그래프로 그려서 확인하고 그 유효성에 대해 살펴보도록 하겠습니다. 

우리가 실제로 다루는 데이터는 매우 큰 용량의 데이터가 대부분이며 , 이런 대규모 데이터에 대한 머신러닝을 이전 포스팅에서 설명한 배치 경사하강법을 이용한 아달라인을 그대로 활용하는 것은 성능면에서 문제가 있습니다.

이런 문제점을 극복하기 위한 방법으로 확률적 경사하강법(Stochastic Gradient Descent)을 적용한 아달라인이 있습니다.

이전 포스팅의 내용 중 아달라인의 가중치 업데이트 수식을 다시 상기해 봅니다.

이 수식의 계산을 위해, 

모든 트레이닝 데이터의 실제 결과값과 예측값의 차를 더한 값을 구해야 합니다.

그런데, 확률적 경사하강법에서는 아래와 같이 i번째 트레이닝 데이터에 대해서만 계산한 값을 이용합니다.

예를 들어 이해를 해봅니다.

100만개의 트레이닝 데이터가 있다고 가정합니다. 이를 배치 경사하강법으로 계산하려면 100만 x 100만 = 1조 번의 연산이 필요합니다. 이는 가중치를 업데이트 하는 식에서 y^(i)를 계산하기 위해 100만번의 덧셈을 해야하고, wj를 최종적으로 업데이트하기 위해 전체적으로 또 100만번의 덧셈을 수행해야 하기 때문입니다.

그런데, 확률적 경사하강법을 적용하게 되면 100만개의 모든 데이터를 활용하여 머신러닝을 수행하더라도 100만번의 연산만 필요합니다. 

확률적 경사하강법을 이용하면 배치 경사하강법의 근사치로 계산되지만 가중치를 업데이트하는 시간이 빠르기 때문에 실제로는 비용함수의 수렴값에 더 빨리 도달하게 됩니다.

그리고, 확률적 경사하강법에서 비용함수의 값을 계산할 때 값이 순환되는 것을 피하기 위해 학습을 반복할 때마다 트레이닝 데이터의 순서를 랜덤하게 섞어서 수행하는 것이 좋습니다.

또한 크라우드 소싱(crowd sourcing)으로 머신러닝을 적용하는 웹에서도 확률적 경사하강법을 활용할 수 있습니다. 어떤 사람이 웹을 통해 데이터를 제공하고, 이 데이터에 대한 예측 결과를 그 사람에게 제시하여 피드백을 받아 재학습을 시키는 것이 바로 그 예입니다. 이에 대해서는 이후 포스팅에서 다루어 보도록 하겠습니다.

그러면 실제 코드를 보면서 이해해봅니다. 아래 코드를 작성하고 mylib 폴더에 adalinesgd.py로 저장합니다.

adalinesgd.py 

이전 포스팅에서 소개한 표준화를 적용한 배치 아달라인의 AdalineGD 클래스와 여기서 구현한 AdalineSGD 클래스의 다른 부분만 설명합니다.

주요 변경 부분은 AdalineSGD 클래스의 fit() 함수의 로직과 _suffle() 함수가 추가된 것입니다.

>>> from numpy.random import seed

난수 발생기 초기화를 위해 numpy.random 모듈의 seed 함수를 임포트합니다.

>>> if random_state:

       seed(random_state)

random_state의 값이 있으면 이 값으로 난수 발생기를 초기화합니다.

>>> if self.shuffle:

       X, y = self._shuffle(X, y)

self.shuffle이 True로 설정되어 있으면, self._shuffle() 함수를 이용해 트레이닝 데이터 X와 y를 랜덤하게 섞습니다.

>>> cost = []
       for xi, target in zip(X, y):
          output = self.net_input(xi)
          error = target - output                
          self.w_[1:] += self.eta * xi.dot(error)
          self.w_[0] += self.eta * error                
          cost.append(0.5 * error**2)

       avg_cost = sum(cost)/len(y)

       self.cost_.append(avg_cost)

이 부분이 가중치를 업데이트하는 아래 식을 구현한 것입니다.

모든 트레이닝 데이터에 대해 비용함수의 값을 더해주고 for구문이 완료되면 평균값을 구하여 최종적인 비용함수 값으로 취합니다. 

>>> def _shuffle(self, X, y):

       r = np.random.permutation(len(y))

       return X[r], y[r]

numpy.random.permutation은 주어진 인자 미만의 정수(0을 포함)로 순열을 만드는 함수입니다. 따라서 r의 값은 0~len(y) 미만까지 정수를 랜덤하게 섞은 결과이므로, X[r], y[r]은 X와 y를 랜덤하게 섞은 numpy 배열이 됩니다.

나머지 부분은 이전 포스팅의 코드와 동일합니다.

자, 그러면 아래의 파일을 작성하고 std_adalinesgd_iris.py로 저장합니다. 보면 알겠지만, AdalineSGD를 임포트한 것과 AdalineSGD 클래스에서 random_state=1 로 설정한 것 빼고는 이전 포스팅의 std_adaline_iris.py와 로직이 동일합니다. 

std_adalinesgd_iris.py 

이 코드를 실행하면 아래와 같은 결과가 나옵니다. 

위 그래프를 보면, 비용함수의 값이 빠르게 줄어드는 것을 볼 수 있습니다. 이유는 한번의 반복문에서 가중치를 업데이트하는 빈도수가 더 많이 일어나기 때문이지요. 학습 반복회수가 늘어나면 결국 배치 경사하강법을 적용한 아달라인과 비슷해짐을 알 수 있습니다.

이로써 단순 인공신경망인 퍼셉트론과 아달라인에 대해 간략하게 살펴보았습니다.

물론 수식들이 나오고 내용도 이해하기 난해하지만 이제 어려운 부분들은 모두 끝났습니다. 앞으로 다루게 될 내용들은 이 개념들의 확장들이고, Scikit-Learn과 같은 라이브러리들은 사용자 친화적인 API들이므로 알고리즘 내부를 알 필요없이 다양한 머신러닝을 적용할 수 있습니다.

그렇더라도 퍼셉트론과 아달라인의 개념을 이해하게 되면 scikit-learn에서 제공하는 API의 활용도 더 편리하게 사용할 수 있고, 나아가 텐서플로우(TensorFlow)와 같은 오픈소스로 공개된 러닝 시스템에서도 여태까지 배운 개념이 적용되기도 합니다.

다음에는 머신러닝과 관련된 사용자 친화적인 scikit-learn API를 이용하여 머신러닝을 수행하는 다양한 알고리즘과 관련된 내용을 소개하도록 하겠습니다. 

이번 포스팅에서는 퍼셉트론을 구현한 코드를 조금 수정하여 아달라인 코드를 파이썬으로 구현해 봅니다. 아래의 코드를 작성하고 mylib 폴더에 adaline.py로 저장합니다.

adaline.py 

기본인자의 디폴트 값, thresholds를 0.0으로 고정한 부분을 제외하면 퍼셉트론을 구현한 Perceptron 클래스와 아달라인을 구현한 AdalineGD 클래스에서 다른 부분은 아래의 fit() 내에서 구현한 부분 밖에 없습니다.

>>> for i in range(self.n_iter):

          output = self.net_input(X)

          errors = (y - output)

          self.w_[1:] += self.eta * X.T.dot(errors)

          self.w_[0] += self.eta * errors.sum()

          cost = (errors**2).sum() / 2

          self.cost_.append(cost)

이 부분이 아달라인에서 가중치를 업데이트 하는 아래 식을 구현한 것입니다.

adline.py에서 리스트로 정의된 self.cost_ 는 비용함수 J(w)가 어떤 값으로 수렴하는지 확인하기 위해 매 반복마다 계산되는 비용함수값을 저장하기 위한 변수입니다.

X.T는 행렬 X의 전치행렬을 의미합니다.

행렬 X와 행렬 Y의 행렬 곱셈이 가능하려면 X의 행의 숫자와 Y의 열의 숫자가 같아야 하는데, X.T로 X의 행과 열을 바꾸어야 가중치가 저장된 errors와 곱셈이 가능하기 때문입니다.

이것이 다입니다. 퍼셉트론의 코드를 다 이해하고, 아달라인의 가중치 업데이트 식을 알고 있다면 아달라인 코드는 이해하기가 쉽습니다.

이제 퍼셉트론에서 다루었던 아이리스 품종 데이터를 이용해서 아달라인으로 머신러닝을 수행하는 아래의 코드를 작성하여 adaline_iris.py로 저장합니다.

adaline_iris.py

if __name__ == '__main__': 에 있는 코드는 퍼셉트론에서와 마찬가지로 아이리스 품종 데이터 100개를 읽어와서 하나는 learning rate을 0.01로 두고 아달라인을 수행하여 얻은 비용함수 J(w)의 값 변화와 또 하나는 learning rate을 0.0001로 두고 아달라인을 수행하여 얻은 비용함수 J(w)의 값 변화를 matplotlib을 이용해 화면에 그려주는 코드입니다.

matplotlib에 대한 내용은 예전에 따로 시리즈로 포스팅했으니 아래 링크를 참조하기 바랍니다.

☞ Matplotlib을 이용한 데이터 시각화 프로그래밍 시리즈 바로가기

코드를 수행하면 다음과 같은 그래프가 화면에 나타납니다.

왼쪽 그래프를 보면 알수 있듯이 learning rate을 0.01로 수행한 아달라인의 비용함수 J(w) 값은 계속 커집니다. 즉 이 경우에는 J(w) 값이 수렴하지 않고 발산해버립니다.

반면, learning rate의 값을 0.0001로 수행한 아달라인의 비용함수 J(w)값은 계속 작아져서 어느 특정한 값에 수렴하게 된다는 것을 알 수 있습니다.

따라서 learning rate을 매우 작게 해야 아달라인의 J(w) 값이 작아지고 우리가 원하는 머신러닝의 결과를 얻을 수 있습니다.

이렇게 되는 이유는 아래의 그림으로 설명이 가능합니다.

이전 포스팅에서 아달라인에서 스텝 크기 △w는 아래와 같이 정의된다고 하였습니다.

여기서 η가 learning rate 입니다.

아달라인이 제대로 수행되려면 위 그림의 왼쪽 그림과 같이 초기 가중치로부터 곡선을 따라 아래로 차근차근 내려가야 하는데, 이렇게 되려면 △w의 값이 작아져야 합니다. 만약 △w의 값이 크게 되면 위 그림의 오른쪽 그림과 같이 초기 가중치가 위치한 부분에서 곡선의 최소값을 건너뛴 위치에서 다시 스텝을 계산하게 되고 이런 식으로 스텝의 크기가 갈수록 커져버려서 비용함수 J(w)의 값은 발산하게 됩니다.

learning rate의 값이 매우 작으면 J(w)의 값은 수렴하지만, 의미 있는 값으로 수렴하는 것을 확인하려면 매우 많은 반복 회수가 필요합니다.

다음에는 정규분포에서 사용되는 표준화(standardization)를 이용해 이런 단점을 극복하는 아달라인 알고리즘을 적용해보도록 합니다. 

이번에는 아래의 링크에서 얻을 수 있는 150개의 아이리스 데이터를 단순 인공신경망인 단층 퍼셉트론으로 머신러닝을 수행해 보도록 하겠습니다.

https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data

위의 링크를 클릭해보면 아래와 같은 csv 형태로 저장된 150개의 데이터를 볼 수 있습니다.

5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa

...

7.0,3.2,4.7,1.4,Iris-versicolor
6.4,3.2,4.5,1.5,Iris-versicolor
...

6.2,3.4,5.4,2.3,Iris-virginica
5.9,3.0,5.1,1.8,Iris-virginica 

이 데이터는 4개의 특성값과 이 특성값에 따른 품종으로 되어 있는데, 첫번째부터 차례대로 꽃받침길이, 꽃받침너비, 꽃잎길이, 꽃잎너비, 아이리스 품종을 나타냅니다. 데이터는 각각 iris-setosa에 대한 데이터가 50개, iris-versicolor에 대한 데이터가 50개, iris-virginica에 대한 데이터가 50개로 구성되어 있습니다.

참고로 아이리스(iris)는 우리말로 붓꽃이라 부르며 꽃받침길이와 너비, 꽃잎길이와 너비로 품종을 구분하나 봅니다.

이제 위의 데이터를 아래의 표와 같이 보기 편하게 정리를 해봅니다.

우리가 해볼 것은 이전 포스팅에서 소개한 퍼셉트론 알고리즘을 이용해 꽃받침길이/너비, 꽃잎길이/너비를 이용해 아이리스 품종을 구분할 수 있도록 머신러닝을 수행하는 것입니다.

아시다시피 퍼셉트론은 바이너리 결과를 가지므로 3개의 품종을 동시에 구분할 수 있는 머신러닝을 수행할 수는 없습니다. 따라서 1~100까지의 데이터에서 꽃받침길이와 꽃잎길이 데이터만을 이용해 Iris-Setosa와 Iris-Versicolor의 2개 품종을 구분할 수 있도록 학습시키도록 합니다.

아래의 코드를 작성하고 perceptron_iris.py로 저장합니다. 참고로 코드의 맨 윗줄 %matplotlib inline은 Jupyter 환경에서 코딩하는 경우, maplotlib 결과를 임베드시켜 보여주는 코드이므로  Jupyter 환경이 아닌 경우, 삭제하면 됩니다.

​ 

perceptron_iris.py 

​

>>> import pandas as pd

>>> import matplotlib

>>> import matplotlib.pyplot as plt

>>> from matplotlib import style

>>> from mylib.perceptron import Perceptron

필요한 모듈을 임포트 합니다.

​

>>> krfont = {'family':'NanumGothic', 'weight':'bold', 'size':10}
>>> matplotlib.rc('font', **krfont)

>>> matplotlib.rcParams['axes.unicode_minus'] = False

이 부분은 matplotlib에서 한글을 표현하기 위한 것으로 윈도우 환경에서 구동하는 경우 제거해도 됩니다.

이전 포스팅의 perceptron_and.py와 비교하여 if __name__ == '__main__' 에서 변경된 부분입니다.

>>> df = pd.read_csv('iris.data', header=None)

csv 형식으로 저장된 'iris.data'를 pandas의 read_csv() 함수를 이용해서 읽고, pandas의 DataFrame 객체로 변환합니다. 아이리스 데이터 링크에 걸려 있는 파일을 로컬로 다운로드 받아서 수행하는 경우 위 코드와 같이 하면 되지만 'iris.data' 부분에 아이리스 데이터를 다운로드 받을 수 있는 URL을 그대로 적어도 무방합니다.

참고로 pandas는 데이터 처리와 관련된 다양한 라이브러리를 제공하는 파이썬 확장 모듈입니다. pandas에 대한 내용은 너무 방대하므로 여기서는 다루지 않습니다.

>>> y = df.iloc[0:100, 4].values

>>> y = np.where(y=='Iris-setosa', -1, 1)

아이리스 데이터를 저장한 DataFrame에서 0~99라인까지 5번째 컬럼의 데이터 값을 numpy 배열로 리턴받아 y에 대입합니다. 따라서 아이리스 데이터 파일에서 100개의 데이터를 추출하여 5번째 컬럼의 데이터 값을 numpy 배열로 리턴한 것이죠. 앞에서 보인 표를 보면 5번째 컬럼은 아이리스 품종을 나타내는 문자열 값입니다.(x0은 아이리스 데이터에 있는 값이 아님을 유의하세요~) 

y에 저장된 품종을 나타내는 문자열이 'Iris-setosa'인 경우 -1, 그렇지 않은 경우 1로 바꾼 numpy 배열을 y에 다시 대입합니다. 앞에서 언급했듯이 아이리스 데이터는 1~50까지가 Iris-setosa이며, 51~100까지가 Iris-versicolor 입니다. 따라서 y의 0~49번 인덱스에 해당하는 값은 -1로 50~99번 인덱스에 해당하는 값은 1로 되어 있는 numpy 배열이 됩니다.

>>> X = df.iloc[0:100, [0, 2]].values

아이리스 데이터를 저장한 DataFrame에서 0~99라인까지 1번째, 3번째 컬럼의 데이터 값을 numpy 배열로 리턴받아 이를 X에 대입합니다. 아이리스 데이터의 1번째 값은 꽃받침길이이며, 3번째 값은 꽃잎길이입니다. 즉 이 코드는 꽃받침길이, 꽃잎길이에 따른 아이리스 품종을 머신러닝으로 학습하는 내용이 될 것입니다.

>>> plt.scatter(X[:50, 0], X[:50, 1], color='r', marker='o', label='setosa')

>>> plt.scatter(X[50:100, 0], X[50:100, 1], color='b', marker='x', label='versicolor')

>>> plt.xlabel('꽃잎 길이(cm)')

>>> plt.ylabel('꽃받침 길이(cm)')

>>> plt.legend(loc=4)

>>> plt.show()

이 코드는 X에 저장된 아이리스 데이터의 꽃받침길이, 꽃잎길이에 대한 데이터의 상관관계를 파악하기 위해 Matplotlib의 산점도를 이용해 화면에 그려보는 코드입니다. Matplotlib의 산점도 그리기는 아래의 제 블로그 포스팅을 참고하세요.

☞ 데이터 시각화 프로그래밍 - 산점도 그리기 바로가기

>>> ppn = Perceptron(eta=0.1)

>>> ppn.fit(X, y)

>>> print(ppn.errors_)

이 부분은 이전 코드와 변동 없습니다.

코드 설명을 보면 알 수 있듯이, 이전 포스팅에서 AND 연산을 학습한 것과 비교하면 학습하려는 데이터 세트를 구성하는 방법을 제외하고는 거의 동일하다는 것을 알 수 있습니다.

프로그램을 실행하면 다음과 같은 결과가 화면에 나올 것입니다.

[ 0.2   1.4   0.94]
[ 0.    0.8   1.32]
[-0.2  0.2  1.7]
[-0.2   0.32  2.12]
[-0.4  -0.7   1.84]
[-0.4  -0.7   1.84]
[-0.4  -0.7   1.84]
[-0.4  -0.7   1.84]
[-0.4  -0.7   1.84]
[-0.4  -0.7   1.84]
[1, 3, 3, 2, 1, 0, 0, 0, 0, 0]

위 실행결과를 보면 알 수 있듯이 6번째 학습후에 가중치의 값이 최종적으로 결정된다는 것을 알 수 있습니다.

50개의 Iris-setosa 데이터, 50개의 Iris-versicolor 데이터로 수행한 머신러닝의 결과는 다음과 같이 요약할 수 있습니다.

*** 머신러닝 결과 *** 

-0.4 + (-0.7) x (꽃받침길이) + 1.84 x (꽃잎길이) 의 값이 0보다 작거나 같으면 Iris-setosa, 이 값이 0보다 크면 Iris-versicolor로 분류함

여태까지 언급한 퍼셉트론은 입력값과 가중치, 그리고 하나의 노드(또는 뉴런)와 출력값을 가지는 단층 퍼셉트론이며 퍼셉트론에 대한 내용은 이정도에서 마무리 하도록 합니다.  

참고로 단층 퍼셉트론은 선형 분리가 가능한 데이터에 대해서만 유효하며,  비선형적으로 분리되는 데이터에 대해서는 가중치 값을 계산하지 못하는 경우가 대부분입니다. 예를 들어 단층 퍼셉트론으로 AND 연산에 대한 학습은 가능하였지만 XOR 연산에 대한 학습은 불가능하다고 증명되었습니다. 단층 퍼셉트론의 많은 약점을 보완하기 위해 다층 퍼셉트론 개념이 나왔는데 이에 대해서는 시간이 되는대로 차후에 살펴보도록 합니다. 

이제 [2편]에서 설명했던 퍼셉트론 알고리즘을 파이썬으로 구현해 봅니다.

먼저, 논리곱 AND 연산에 대해 퍼셉트론 알고리즘으로 머신러닝을 수행하는 예를 보면서 이해를 해보도록 합니다.

참을 1, 거짓을 0으로 정의할 때, 논리곱 AND 연산은 다음과 같이 정의됩니다.

0 AND 0 = 0

0 AND 1 = 0

1 AND 0 = 0

1 AND 1 = 1

퍼셉트론 알고리즘을 이용해 AND 연산을 학습시키는 것이 우리의 목표입니다.

AND 연산을 위해 필요한 트레이닝 데이터는 위에서 보인 4가지이며, 트레이닝 데이터의 특성값은 0과 1 2개입니다. 이를 이전 포스팅에서 정의한 표를 이용해 나타내보면 다음과 같습니다.

퍼셉트론 알고리즘에서 보통 0 또는 매우 작은 값을 가중치의 초기값으로 둔다고 했는데, 우리의 알고리즘에서는 초기 가중치의 값을 모두 0으로 둡니다.

learning rate η는 0.1로, 임계값은 0으로 정의하고, 순입력 함수 결과값이 임계값 0보다 크면 1, 그렇지 않으면 -1로 정의해봅니다.

자, 이전 포스팅에서 소개된 알고리즘 원리에 따라 퍼셉트론 학습을 수행해봅니다.

1. 트레이닝 데이터1에 대해 순입력 함수 리턴값을 계산합니다.

w0 x x0 + w1 x x1 + w2 x x2 = 0.0 x1 + 0.0 x 0 + 0.0 x 0 = 0

2. 순입력 함수의 리턴값과 임계값 0을 비교하면 0보다 크지 않으므로 활성 함수 리턴값은 -1이 됩니다. 이는 실제 결과값에 대한 활성 함수 리턴값과 일치하므로 가중치 업데이트 없이 다음 트레이닝 데이터 2로 넘어갑니다.

3. 트레이닝 데이터2~3까지는 예측된 값의 활성 함수 리턴값과 실제 결과값의 활성 함수 리턴값이 일치하므로 가중치 업데이트 없이 트레이닝 데이터4로 넘어갑니다.

4. 트레이닝 데이터4에 대해 1과 같이 계산한 퍼셉트론 예측값의 활성 함수 리턴값은 -1로 나왔지만 실제 결과값의 활성 함수 리턴값은 1이므로 예측값과 결과값이 다릅니다. 따라서 아래의 식에 의해 가중치를 다시 계산합니다.

w0 = w0 + 0.1(1-(-1))1 = 0 + 0.2 = 0.2

w1 = w1 + 0.1(1-(-1))1 = 0 + 0.2 = 0.2

w2 = w2 + 0.1(1-(-1))1 = 0 + 0.2 = 0.2

5. 트레이닝 데이터4에서 가중치가 업데이트 되었으므로 새롭게 업데이트 된 가중치를 가지고 트레이닝 데이터1부터 1의 과정을 다시 수행합니다.

이런 식으로 트레이닝 데이터1~4에 대한 예측값의 활성 함수 리턴값과 실제 결과값의 활성 함수 리턴값이 같아지도록 가중치를 계속 업데이트해보면

w0 = -0.4, w1 = 0.4, w2 = 0.2 일 때, 모든 트레이닝 데이터에 대한 예측값과 결과값의 활성 함수 리턴값이 같아집니다.

이와 같은 퍼셉트론 알고리즘은 다음과 같은 파이썬 코드로 구현됩니다. 참고로 퍼셉트론 알고리즘을 구현한 아래의 코드는 Sebastian Raschka의 'Python Machine Learning'책에 있는 코드입니다. 아래의 코드를 작성하고 perceptron.py로 저장합니다.

​ 

perceptron.py 

나의 경우 mylib이라는 이름의 폴더를 만들고 여기에 perceptron.py를 저장해두었습니다. 여러분들의 작업 폴더가 c:/mywork 이라면 하위 폴더로 c:/mywork/mylib을 만들고 mylib에 여러분들이 작성한 라이브러리들을 저장해두면 관리하기가 쉽습니다.

아래의 코드를 작성하고, perceptron_and.py라는 이름으로 작업 폴더에 저장합니다.

perceptron_and.py

다음 포스팅에서는 perceptron.py와 perceptron_and.py 코드에 대해 가볍게 설명하고 머신러닝을 위한 훌륭한 샘플 데이터인 아이리스(iris; 우리말로 붓꽃)의 품종 분류에 대한 트레이닝 데이터를 이용해 머신러닝을 수행하는 것에 대해 살펴보겠습니다. 

 [출처] [2편] 퍼셉트론(Perceptron) - 인공신경망의 기초개념|작성자 옥수별

퍼셉트론(Perceptron)​

​인공지능(AI)은 우리 사람의 뇌를 흉내내는 인공신경망과 다양한 머신러닝 알고리즘을 통해 구현됩니다. 이전 포스팅에서 잠시 언급했던 딥러닝 알고리즘이 현재 가장 널리 사용되는 인공지능을 위한 알고리즘이죠. 이런 딥러닝도 수십년전에 개념이 정립되었던 초기 인공신경망으로부터 발전된 것이라 볼 수 있습니다.

여기서 소개할 퍼셉트론과 퍼셉트론을 좀 더 발전시킨 아달라인은 이해하기가 다소 까다로울수 있지만 앞으로 계속 등장할 머신러닝의 다양한 내용을 위한 기초 개념이 되므로 이해하고 넘어가는 것이 좋습니다.

우리 사람의 뇌는 신경계를 구성하는 주된 세포인 뉴런(neuron)을 약 1000억개 정도 가지고 있으며, 뉴런들은 시냅스라는 구조를 통해 전기, 화학적 신호를 주고 받음으로써 다양한 정보를 받아들이고, 그 정보를 저장하는 기능을 수행합니다.

아래 그림은 하나의 뉴런에서 신호를 입력 받고 그에 대한 결과 신호를 출력하는 개념을 도식화 한 것입니다.

​우리 사람의 뇌속에는 위 그림과 같은 뉴런이 1000억개 가까이 서로가 다층적으로 복잡하게 연결되어 있는 것이죠. 이런 뇌 구조로 뇌활동이 일어나는 것이며, 인간이 수행하는 모든 일(생각하고, 배우고, 창조하고, 기억하고, 느끼고,, 아파하고,, 등등 모든 것)에 관여하고 있습니다.

​

1943년 신경과학자인 Warren S. McCulloch과 논리학자인 Walter Pitts는 하나의 사람 뇌 신경세포를 하나의 이진(Binary)출력을 가지는 단순 논리 게이트로 설명했습니다.

위 그림에서 여러 개의 입력 신호가 가지돌기(Dendrite)에 도착하면 신경세포 내에서 이들을 하나의 신호로 통합하고, 통합된 신호 값이 어떤 임계값을 초과하면 하나의 단일 신호가 생성되며, 이 신호가 축삭돌기(Axon)를 통해 다른 신경세포로 전달하는 것으로 이해했습니다. 이렇게 단순화 된 원리로 동작하는 뇌 세포를 McCulloch-Pitts뉴런(MCP 뉴런)이라 부릅니다.

​ 

1957년 코넬 항공 연구소에 근무하던 Frank Rosenblatt은 MCP 뉴런 모델을 기초로 퍼셉트론(Perceptron) 학습 규칙이라는 개념을 고안하게 되는데, Rosenblatt은 하나의 MCP 뉴런이 출력신호를 발생할지 안할지 결정하기 위해, MCP 뉴런으로 들어오는 각 입력값에 곱해지는 가중치 값을 자동적으로 학습하는 알고리즘을 제안했습니다.

​이 알고리즘은 머신러닝의 지도학습이나 뷴류(classification)의 맥락에서 볼 때, 하나의 샘플이 어떤 클래스에 속해 있는지 예측하는데 사용될 수 있습니다.

아래 그림은 Rosenblatt이 제안한 퍼셉트론 알고리즘 개념을 도식화 한 것입니다.

여기서 x0~xn은 퍼셉트론 알고리즘으로 입력되는 값이며, w0~wn은 각각 x0~xn에 곱해지는 가중치입니다. 입력값은 보통 분류를 위한 데이터의 특성(feature)을 나타내는 값으로 이루어져 있으며, 이 특성값 x0~xn에 가중치 w0~wn을 곱한 값을 모두 더하여 하나의 값으로 만듭니다. 이 값을 만드는 함수를 순입력 함수(net input 함수)라고 부릅니다. 순입력 함수의 결과값을 특정 임계값과 비교를 하고, 순입력 함수 결과값이 이 임계값보다 크면 1, 그렇지 않으면 -1로 출력하는 함수를 정의합니다. 이 함수를 활성 함수(Activation function)라고 부릅니다.

퍼셉트론은 다수의 트레이닝 데이터를 이용하여 일종의 지도 학습을 수행하는 알고리즘입니다. 트레이닝 데이터에는 데이터의 특성값에 대응되는 실제 결과값을 가지고 있어야 합니다. 입력되는 특성값 x0~xn에 대한 실제 결과값을 y라고 한다면 이 y를 활성 함수에 의해 -1 또는 1로 변환합니다. 이렇게 변환한 값과 퍼셉트론 알고리즘에 의해 예측된 값이 다르면 이 두 개의 값이 같아질 때까지 특정식에 의해 가중치 w0~wn을 업데이트 합니다.

위 그림을 보다 단순하게 도식화하면 다음 그림과 같이 입력층, 중간층, 출력층과 같이 나타낼 수 있습니다.

​

여기서 중간층을 노드 또는 뉴런이라 부르며, 입력층은 다른 노드의 출력값이 입력값으로 입력되는 것이고, 출력층은 이 노드의 출력값이 다른 노드로 전달되는 층이라고 생각하면 됩니다.

이와 같이 중간층이 하나의 노드로 구성되어 중간층과 출력층의 구분이 없는 구조를 단순 또는 단층 퍼셉트론이라 부르며, 중간층을 구성하는 노드가 여러 개이고, 이러한 중간층이 다수로 구성되어 있는 구조를 다층 퍼셉트론이라 부릅니다. 

아래는 다층 퍼셉트론을 응용한 인공신경망 구조의 한 예시입니다.

​

이러한 다층 인공신경망을 학습하는 알고리즘을 딥 러닝(Deep Learning)이라고 말합니다.

이것이 퍼셉트론의 핵심입니다. 그러면 좀 더 자세하게 살펴보도록 하겠습니다. 

MCP 뉴런과 Rosenblatt의 퍼셉트론 모델은 사람 뇌의 단일 뉴런이 작동하는 방법을 흉내내기 위해 환원 접근법(redcutionist approach)을 이용합니다. 이는 초기 가중치를 임의의 값으로 정의하고 예측값의 활성 함수 리턴값과 실제 결과값의 활성 함수 리턴값이 동일하게 나올 때까지 가중치의 값을 계속 수정하는 방법입니다.

Rosenblatt의 초기 퍼셉트론 알고리즘을 요약하면 다음과 같습니다.

1. 입력되는 특성값에 곱해지는 가중치 w 값들을 모두 0 또는 작은 값으로 무작위 할당함
2. 임계값을 정의함(보통 0으로 정의합니다.)
3. 트레이닝 데이터 샘플 x를 순입력 함수를 이용해 가중치와 각각 곱한 후 그 총합을 구함
4. 활성 함수를 이용해 트레이닝 데이터 샘플에 대한 예측값을 -1 또는 1로 결과가 나오게 함
5. 트레이닝 데이터 샘플의 실제 결과값에 대한 활성 함수 리턴값과 4에서 나온 예측값을 비교함
6. 예측값과 결과값이 다르면 모든 가중치 w를 업데이트하고 3의 과정부터 다시 시작함
7. 예측값과 결과값이 동일하게 나오면 패스

자, 아래와 같이 n개의 특성값을 가진 m개의 트레이닝 데이터가 있다고 가정합니다.

이 트레이닝 데이터로 퍼셉트론 알고리즘을 이용해 머신러닝을 수행하려고 합니다. Rosenblatt의 퍼셉트론 알고리즘에서 x0는 실제 트레이닝 데이터의 특성값과는 무관하며 x0의 초기값으로 보통 1로 둡니다. 퍼셉트론 알고리즘에서 x0를 바이어스(bias)라 부릅니다. 따라서 실제 트레이닝 데이터의 특성값은 x1부터 시작한다고 보면 됩니다.

이제 우리가 1로 정한 x0의 값과 n개의 트레이닝 데이터의 각 특성값 x1~xn과 이 특성값에 곱할 가중치 w1~wn의 값을 0과 1사이의 임의의 값으로 랜덤하게 할당한 후 위 표를 아래와 같이 다시 구성해 봅니다.

​

트레이닝 데이터1~m까지 각 특성값에 대해 퍼셉트론 알고리즘을 구동합니다. 퍼셉트론 알고리즘에서 가중치를 업데이트 하는 식은 다음과 같이 정의됩니다.

여기서 wj 는 트레이닝 데이터의 j번째 특성값 xj와 곱하는 가중치이며, y는 트레이닝 데이터의 실제 결과값에 대한 활성 함수 리턴값, y^은 예측값에 대한 활성 함수 리턴값입니다. (y - y^) 앞에 곱한 그리스 문자 η는 학습률(learning rate)이라 하며, Rosenblatt의 퍼셉트론에서는 learning rate을 매우 작은 값으로 할당합니다.

퍼셉트론 알고리즘은 다음과 같은 방식으로 구동합니다.

1. ​w0~wn의 값을 0.0, 임계값 0.0, 에타값은 0.1로 둡니다.
2. 트레이닝 데이터1의 특성값들에 대한 예측값의 활성 함수 리턴값을 계산합니다.
3. 2에서 계산된 값이 이 실제 결과값의 활성 함수 리턴값과 같으면 가중치 업데이트 없이 다음 트레이닝 데이터에 대해 2번 과정으로 넘어갑니다.
4. 예측값의 활성 함수 리턴값이 실제 결과값의 활성 함수 리턴값과 다르면 위 식에 의해 w0~wn의 가중치를 업데이트 합니다. 
5. 트레이닝 데이터2~m에 대해서 2~4를 반복합니다.

위와 같은 절차로 트레이닝 데이터1~m까지 모든 예측값이 실제 결과값과 동일해질 때까지 반복합니다. 트레이닝 데이터1~m까지 예측값에 대한 활성 함수 리턴값이 실제 결과값의 활성 함수 리턴값과 동일하면 퍼셉트론 학습은 종료됩니다.

퍼셉트론에 대한 개략적인 개념을 소개했으니, 다음 포스팅에서는 퍼셉트론 알고리즘을 파이썬으로 구현해보고, 실제 몇 개의 데이터 세트를 이용해 머신러닝을 수행해보도록 하겠습니다. 

 [출처] [1편] 인공지능과 머신러닝|작성자 옥수별

2016년 3월, 구글의 자회사 딥마인드가 만든 알파고가 세계적인 바둑기사 이세돌을 4승1패로 이긴 이후, 우리나라뿐만 아니라 전세계적으로 인공지능(AI, Artificial Intelligence)에 대한 관심이 증폭되었습니다.

사실, 인공지능이라는 개념은 1956년 소수의 수학자와 과학자들이 모인 다트머스 회의에서 처음으로 탄생했습니다. 하지만 여러가지 이유로 인해 인공지능은 한동안 관심사에서 멀어지게 되고 등한시되었습니다.

그러다가 IBM의 인공지능 딥블루가 1997년 체스경기에서 인간 챔피언을 이겨버렸고, 이후 컴퓨팅 기술의 발전과 HW의 고사양화, 빅데이터 시대를 맞이하면서 인공지능은 진화하게 됩니다. 다시말하면, 1990년대 중반까지 인공지능이 선험적인 경험과 지식을 활용하는 형태였다면, 2000년대 이후에는 기계 스스로 대량의 데이터를 통해 스스로 지식을 찾아내는 방식으로 진화하게 된 것입니다.

기계 스스로 대량의 데이터로부터 지식이나 패턴을 찾아내어 학습하는 것을 우리는 '머신러닝(Machine Learning)'이라 부르고, 우리말로는 '기계학습'이라 부릅니다. 그리고 머신러닝 연구의 한부분인 인공신경망 분야에 '딥러닝(Deep Learning)'이라는 새로운 방식으로 인해 대전환점을 맞이하게 됩니다.

2017년 IT 키워드중 하나가 바로 인공지능이며, 인공지능의 기반이 되는 머신러닝이 이제 대세가 되는 시대가 된것 같습니다.

이에 따라 이번 포스팅 시리즈는 파이썬을 이용하여 머신러닝을 구현하는데 필요한 내용을 정리하고 학습하도록 하겠습니다. 포스팅에서 다룰 내용은 대부분이 각종 사이트에서 발췌하여 제가 응용한 것들이며, 참고 서적으로는 Sebastian Raschka가 지은 'Python Machine Learning'이라는 책입니다.

또 다시 파이썬 예찬론을 펼치게 되는데요, 파이썬은 언어자체의 문법이 깔끔하고 영어와 유사하며 온갖 용도로 사용되는 가장 인기있는 언어중 하나입니다. 특히, 데이터의 처리와 분석에 관련된 다양한 라이브러리들이 있어 데이터 과학자들 사이에 입지가 튼튼하며, 인공지능을 구현하는데 인기도 면에서 2위를 달리는 프로그래밍 언어입니다. 이쯤에서 파이썬 예찬론은 그만하겠습니다.

파이썬에 대해 완전 초보이신 분들은 제가 정말 쉽게 쉽게 쓴, '초보자를 위한 파이썬200제(정보문화사)'로 학습하시면 도움이 될 것 같습니다~^^

아무튼 이번 포스팅에서는, 머신러닝에 대한 대략적인 기초 지식을 살펴보고, 본격적인 내용에 대해 포스팅하도록 하겠습니다. 아마 OpenCV 강좌처럼 장대한(?) 여정이 될 것 같군요~

머신러닝은 주어진 데이터를 바탕으로 새로운 질문에 대해 예측하는 것이 최종 목적이며, 이러한 머신러닝을 학습방법에 따라 구분하면 다음과 같은 것들이 있습니다. 이들에 대한 자세한 내용은 강좌를 진행하면서 서술하겠습니다.

• 지도학습(Supervised Learning)
• 컴퓨터에 학습을 시킬 때 사람이 개입하여 정답을 달아주는 방식으로 학습을 진행합니다. 예를 들어 손으로 쓴 숫자를 인식하기 위해 컴퓨터에 학습을 시킬 때 최초 일정량의 데이터에 대해서 사람이 이 녀석인 1이야, 저 녀석은 8이야 하는 식으로 각 숫자에 대해 라벨을 달아주어 컴퓨터에 학습을 시킵니다. 제 블로그의 OpenCV 강좌 중 머신러닝 기초2 - KNN을 이용하여 손글씨 인식하기가 지도학습을 이용한 머신러닝의 한 예입니다.
• 지도학습에는 다음과 같은 것들이 있습니다.
• 분류(Classification)
• 회귀(Regression)
• 비지도학습(Unsupervised Learning)
• 사람의 개입없이 컴퓨터 스스로가 라벨링 되어 있지 않은 데이터에 대해 학습을 하는 방식입니다. 이 세상에 존재하는 대부분의 데이터는 라벨이 붙어 있지 않습니다. 따라서 비지도학습은 머신러닝이 나아갈 방향입니다.
• 비지도학습에는 다음과 같은 것들이 있습니다.
• 군집화(Clustering)
• 분포추정(Underlying Probability Density Estimation)
• 강화학습(Reinforcement Learning)
• 강화학습은 기계 혹은 컴퓨터로 하여금 현태 상태에서 어떤 행동을 취하는 것이 최적의 것인가를 학습하는 것입니다. 하나의 행동을 취할때 마다 외부에서 보상(Reward)이 주어지며, 이 보상이 최대화하는 방향으로 학습이 진행됩니다. 외부에서 주어지는 보상은 행동을 취한 후 바로 주어질 수도 있고, 조금 있다가 줄 수도 있습니다.  

머신러닝을 구현하기 위한 알고리즘에는 다음과 같은 것들이 있으며, 자세한 내용은 강좌를 진행하면서 서술하겠습니다.

• 경사하강법(Gradient Descent)
• 회귀기법
• 선형 회귀(Linear Regression)
• 로지스틱 회귀(Logistic Regression)
• 확률기반
• 나이브 베이즈 분류기(Naive Bayes Classifier; NBC)
• 은닉 마르코프 모델(Hidden Markov Model; HMM)
• 기하기반
• k-Means Clustering(kMC)
• k-Nearest Neighbors(kNN)
• Support Vector Machine(SVM)
• 인공신경망
• Perceptron
• Multi Layer Perceptron(MLP)
• Deep Neural Network

이번 머신러닝 포스팅 시리즈에 소개되는 대부분의 내용은 Sebastian Raschka의 Python Machine Learning이라는 책을 참고하였으며, 다양한 인터넷 사이트의 내용들을 참고하였습니다.

포스팅에서 다루는 파이썬 버전은 3.5.x 이므로 2.7.x 버전 사용자는 참고하시기 바랍니다. 그리고 앞으로 게시될 머신러닝 포스팅 시리즈에 등장하는 많은 수의 소스코드는 기본적으로 Python Machine Learning에 있는 소스코드를 토대로 작성되었으며, 필요시 제가 수정한 부분도 있다는 사실을 미리 알려둡니다.

먼저, 윈도우 명령 프롬프트를 구동하고 아래와 같이 필요한 패키지부터 설치합니다.

pip install numpy

pip install scipy

pip install matplotlib

pip install scikit-learn

pip install pandas​

이제 준비는 끝났으므로 다음 포스팅부터 본격적으로 공부를 시작해보도록 하겠습니다. 

>>>t = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]

>>>x = np.array(t)

>>>type(x)

>>>x.shape

(3, 4)

>>>x.ravel()

array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

>>>x.ravel().shape

(12,)

>>>x.shape = (6, 2)

>>>x

array([[1, 2],

[3, 4],

[5, 6],

[7, 8],

[9, 10],

[11, 12]])

>>>x.transpose()

array([[1, 3, 5, 7, 9, 11],

[2, 4, 6, 8, 10, 12]])

>>>x.resize((2, 6))

>>>x

array([[1, 2, 3, 4, 5, 6],

[7, 8, 9, 10, 11, 12]

# 파이프라인을 가진 스트리밍 워크플로우

'''
위스콘신 유방암 데이터
이 데이터는 악성(malignant)과 양성(benign)의 암세포로 구성된 569개 샘플을 포함.
~2 열까지는 각 샘플의 ID숫자와 이들의 진단 결과값을 저장
3 ~ 32 열은 30개의 실제 값으로 이루어진 피처
'''

import pandas as pd
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/wdbc.data', header=None)

from sklearn.preprocessing import LabelEncoder
X = df.loc[:, 2:].values
y = df.loc[:, 1].values
print('df: ', df)
print('X: ', X)
print('y: ', y)
le = LabelEncoder()
y = le.fit_transform(y)
print('y-transform: ', y)

print(le.transform(['M', 'B']))

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
print('X_train: ', X_train)
print('y_train: ', y_train)
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
pipe_lr = Pipeline([('scl', StandardScaler()),
                    ('pca', PCA(n_components=2)),
                    ('clf', LogisticRegression(random_state=1))])
pipe_lr.fit(X_train, y_train)
print('Test Accuracy: %.3f' % pipe_lr.score(X_test, y_test))


# k-fold 교차검증을 사용하여 모델 성능 평가
# - 일반화 성능을 만족시키는 최적의 하이퍼파라미터 값을 찾기 위한 모델 튜닝에 사용
import numpy as np
from sklearn.cross_validation import StratifiedKFold
kfold = StratifiedKFold(y=y_train, n_folds=10, random_state=1)
#print('kfold: ', kfold)
scores = []
for k, (train, test) in enumerate(kfold):
#    print('train: ', train, 'test: ', test)
    pipe_lr.fit(X_train[train], y_train[train])
    score = pipe_lr.score(X_train[test], y_train[test])
    scores.append(score)
    print('Fold: %s, Class dist.: %s, Acc: %.3f' % (k+1, np.bincount(y_train[train]), score))
print('CV accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))


from sklearn.cross_validation import cross_val_score
scores = cross_val_score(estimator=pipe_lr, X=X_train, y=y_train, cv=10, n_jobs=1)
print('CV accuracy scores: %s' % scores)
print('CV accuracy: %.3f +/- %.3f' % (np.mean(scores), np.std(scores)))

# 검증 곡선을 사용해서 높은 바이어스나 높은 분산에 대한 이슈를 어떻게 해소할 수 있는지 확인.
import matplotlib.pyplot as plt
from sklearn.learning_curve import learning_curve
pipe_lr = Pipeline([
    ('scl', StandardScaler()),
    ('clf', LogisticRegression(penalty='l2', random_state=0))
])
train_sizes, train_scores, test_scores = learning_curve(estimator=pipe_lr,
                                                        X=X_train,
                                                        y=y_train,
                                                        train_sizes=np.linspace(0.1, 1.0, 10),
                                                        cv=10,
                                                        n_jobs=1)
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)

plt.plot(train_sizes, train_mean, color='blue', marker='o', markersize=5, label='training accuracy')
plt.fill_between(train_sizes, train_mean + train_std, train_mean - train_std, alpha=0.15, color='blue')
plt.plot(train_sizes, test_mean, color='green', linestyle='--', marker='s', markersize=5, label='validation accuracy')
plt.fill_between(train_sizes, test_mean + test_std, test_mean - test_std, alpha=0.15, color='green')
plt.grid()
plt.xlabel('Number of training samples')
plt.ylabel('Accuracy')
plt.legend(loc='lower right')
plt.ylim([0.8, 1.0])
plt.show()

# 검증곡선으로 오버피팅과 언더피팅 다루기
'''
검증곡선은 학습곡선과 관련되어 있지만 훈련 정확도와 테스트 정확도를 샘플 크기의 함수로 플롯하는 대신,
로지스틱 회귀의 역정규화 파라피터 C와 같은 모델 파라미터 값들을 다양하게 한다.
'''
from sklearn.learning_curve import validation_curve
param_range = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
train_scores, test_scores = validation_curve(
    estimator=pipe_lr,
    X=X_train,
    y=y_train,
    param_name='clf__C',
    param_range=param_range,
    cv=10
)
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)
plt.plot(param_range, train_mean, color='blue', marker='o', markersize=5, label='training accuracy')
plt.fill_between(param_range, train_mean + train_std, train_mean - train_std, alpha=0.15, color='blue')
plt.plot(param_range, test_mean, color='green', linestyle='--', marker='s', markersize=5, label='validation accuracy')
plt.fill_between(param_range, test_mean + test_std, test_mean - test_std, alpha=0.15, color='green')
plt.grid()
plt.xscale('log')
plt.legend(loc='lower right')
plt.xlabel('Parameter C')
plt.ylabel('Accuracy')
plt.ylim([0.8, 1.0])
plt.show()

'''
차원축소를 위한 피처 선택의 방법 중 피처 추출이 있다.
원래보다 낮은 차원의 새로운 피처 부분공간으로 변환시킴으로써 데이터의 정보를 요약할 수 있도록 도와주는
세 가지 기초 기법에 대해 학습한다.
* 비지도적 데이터 압축을 위한 주성분 분석(PCA)
* 최대화 분류 분리를 위한 지도적 차원축소 기법으로써의 선형 분리 분석(LDA)
* 커널(kernel) 주성분 분석을 활용한 비선형 차원축소
'''
# 주성분 분석을 활요한 비지도적 차원축소

# 전체 분산과 설명 분산
import pandas as pd
df_wine = pd.read_csv('wine.data', header=None)

from sklearn.cross_validation import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
# 표준화
sc = StandardScaler()
X_train_std = sc.fit_transform(X_train)
X_test_std = sc.fit_transform(X_test)

# 공분산 행렬 만들기
# 아이겐페어(eigenpairs)는 Numpy의 linalg.eig 함수 사용
import numpy as np
cov_mat = np.cov(X_train_std.T) # 공분산행렬 계산 (같은 피처를 행으로 만들어서)
eigen_vals, eigen_vecs = np.linalg.eig(cov_mat)
print('\nEigenvalues \n%s' % eigen_vals)
print('\nEigenvectors \n%s' % eigen_vecs)

# 아이겐밸류의 분산 비율을 구한다.
tot = sum(eigen_vals)
var_exp = [(i / tot) for i in sorted(eigen_vals, reverse=True)] # 내림차순 정렬
cum_var_exp = np.cumsum(var_exp) # 설명 분산의 누적 합 계산
import matplotlib.pyplot as plt
plt.bar(range(1,14), var_exp, alpha=0.5, align='center', label='individual explained variance')
plt.step(range(1,14), cum_var_exp, where='mid', label='cumulative explained variance')
plt.ylabel('Explained variance ratio')
plt.xlabel('Principal components')
plt.legend(loc='best')
plt.show()

# 피처 변환
eigen_pairs = [(np.abs(eigen_vals[i]), eigen_vecs[:, i]) for i in range(len(eigen_vals))]
eigen_pairs.sort(reverse=True) # 내림차순 정렬
print('eigen_pairs:\n', eigen_pairs)
w = np.hstack((eigen_pairs[0][1][:, np.newaxis], eigen_pairs[1][1][:, np.newaxis]))
print('Matrix W:\n', w)

# 투영행렬을 사용해서 샘플 x(1x13차원의 행 벡터)를 PCA 부분공간 x`로 변환할 수 있다.
print('X_train_std[0]:\n', X_train_std[0].dot(w))
# 124 x 13차원의 훈련데이터를 행렬의 내적곱 계산을 사용해서 두 개의 주성분으로 변환
X_train_pca = X_train_std.dot(w)

colors = ['r', 'b', 'g']
markers = ['s', 'x', 'o']
for l, c, m in zip(np.unique(y_train), colors, markers):
    plt.scatter(X_train_pca[y_train==l, 0], X_train_pca[y_train==l, 1], c=c, label=l, marker=m)
plt.xlabel('PC 1')
plt.ylabel('PC 2')
plt.legend(loc='upper left')
plt.show()


## 사이킷런에서 주성분 분석
from matplotlib.colors import ListedColormap

def plot_decision_regions(X, y, classifier, resolution=0.02):
    markers = ('s', 'x', 'o', '^', 'v')
    colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
    cmap = ListedColormap(colors[:len(np.unique(y))])

    x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))

    Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
    Z = Z.reshape(xx1.shape)
    plt.contourf(xx1, xx2, Z, alpha=0.4, cmap=cmap)
    plt.xlim(xx1.min(), xx1.max())
    plt.ylim(xx2.min(), xx2.max())

    for idx, cl in enumerate(np.unique(y)):
        plt.scatter(x=X[y==cl, 0], y=X[y==cl, 1], alpha=0.8, c=cmap(idx), marker=markers[idx], label=cl)

from sklearn.linear_model import LogisticRegression
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
lr = LogisticRegression()
X_train_pca = pca.fit_transform(X_train_std)
X_test_pca = pca.transform(X_test_std)
lr.fit(X_train_pca, y_train)
plot_decision_regions(X_train_pca, y_train, classifier=lr)
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.legend(loc='lower left')
plt.show()

plot_decision_regions(X_test_pca, y_test, classifier=lr)
plt.xlabel('PC 1')
plt.ylabel('PC 2')
plt.legend(loc='lower left')
plt.show()

pca = PCA(n_components=None)
X_train_pca = pca.fit_transform(X_train_std)
print('pca.explained_variance_ratio_:\n', pca.explained_variance_ratio_)

# 세 개의 평균 벡터 결과 도출
np.set_printoptions(precision=4)
mean_vecs = []

for label in range(1,4):
    mean_vecs.append(np.mean(X_train_std[y_train==label], axis=0))
    print('MV %s: %s\n' %(label, mean_vecs[label-1]))

d = 13 # number of features
S_W = np.zeros((d, d))
for label, mv in zip(range(1,4), mean_vecs):
    class_scatter = np.zeros((d, d))
    for row in X[y==label]:
        row, mv = row.reshape(d, 1), mv.reshape(d, 1)
        class_scatter += (row-mv).dot((row-mv).T)
    S_W += class_scatter
print('Within-class scatter matrix: %sx%s' % (S_W.shape[0], S_W.shape[1]))

print('Class label distribution: %s' % np.bincount(y_train)[1:])

d = 13
S_W = np.zeros((d, d))
for label, mv in zip(range(1,4), mean_vecs):
    class_scatter = np.cov(X_train_std[y_train==label].T)
    S_W += class_scatter
print('Scaled within-class scatter matrix: %sx%s' % (S_W.shape[0], S_W.shape[1]))

mean_overall = np.mean(X_train_std, axis=0)
d = 13
S_B = np.zeros((d,d))
for i, mean_vec in enumerate(mean_vecs):
    n = X[y==i+1, :].shape[0]
    mean_vec = mean_vec.reshape(d, 1)
    mean_overall = mean_overall.reshape(d, 1)
    S_B += n * (mean_vec - mean_overall).dot((mean_vec - mean_overall).T)
print('Between-class scatter matrix: %sx%s' % (S_B.shape[0], S_B.shape[1]))

import pandas as pd
from io import StringIO

csv_data = '''A,B,C,D
1.0,2.0,3.0,4.0
5.0,6.0,,8.0
0.0,11.0,12.0,
'''
df = pd.read_csv(StringIO(csv_data))
print('df:\n ', df)
print('df.isnull().sum():\n ', df.isnull().sum())

# 결측값을 가진 샘플이나 피처 제거
print('df.dropna():\n ', df.dropna()) # 결측값을 가진 행을 제거하는 방법
print('df.dropna(axis=1):\n ', df.dropna(axis=1)) # 결측값을 가진 열을 제거하는 방법
print("df.dropna(how='all'):\n", df.dropna(how='all')) # 모든 열이 결측값을 가진 행만 제거
print('df.dropna(thresh=4):\n', df.dropna(thresh=4)) # 최소 4개의 결측치가 아닌 값을 가지지 못하는 행 제거
print("df.dropna(subset=['C']:\n", df.dropna(subset=['C'])) # C열에서 결측치가 있는 행을 제거

# 결측값의 보정
# 전체 피처열의 평균값으로 결측값을 간단히 대체하는 평균보정법
from sklearn.preprocessing import Imputer
imr = Imputer(missing_values='NaN', strategy='mean', axis=0)
imr = imr.fit(df)
imputed_data = imr.transform(df.values)
print('imputed_data:\n', imputed_data)


import pandas as pd
df = pd.DataFrame([
    ['green', 'M', 10.1, 'class1'],
    ['red', 'L', 13.5, 'class2'],
    ['blue', 'XL', 15.3, 'class1']
])
df.columns = ['color', 'size', 'price', 'classlabel']
print('df:\n', df)

# 순위형 피처 매핑
# ex) XL = L + 1 = M + 2
size_mapping = {'XL': 3, 'L': 2, 'M': 1}
df['size'] = df['size'].map(size_mapping)
print('df:\n', df)

# 역매핑
inv_size_mapping = {v: k for k, v in size_mapping.items()}
print('inv_size_mapping:\n', inv_size_mapping)


# 분류 레이블 인코딩
import numpy as np
class_mapping = {label:idx for idx, label in enumerate(np.unique(df['classlabel']))}
print('class_mapping:\n', class_mapping)

df['classlabel'] = df['classlabel'].map(class_mapping)
print('df:\n', df)
# 역매핑
inv_class_mapping = {v: k for k, v in class_mapping.items()}
df['classlabel'] = df['classlabel'].map(inv_class_mapping)
print('df:\n', df)

from sklearn.preprocessing import LabelEncoder
class_le = LabelEncoder()
y = class_le.fit_transform(df['classlabel'].values)
print('y:\n', y)

print('class_le.inverse_transform(y):\n', class_le.inverse_transform(y))


# 명목형 피처에 원핫 인코딩 수행
X = df[['color', 'size', 'price']].values
color_le = LabelEncoder()
X[:, 0] = color_le.fit_transform(X[:, 0])
print('X:\n', X)


# one hot encoding
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(categorical_features=[0])
print('ohe.fit_transform(X).toarray():\n', ohe.fit_transform(X).toarray())

print('df:\n', df)
print("pd.get_dummies(df[['price', 'color', 'size']]):\n", pd.get_dummies(df[['price', 'color', 'size']]))


# 데이터를 훈련용과 테스트용으로 분할하기
df_wine = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', header=None)
df_wine.columns = ['Class label', 'Alcohol',
                   'Malic acid', 'Ash',
                   'Alcalinity of ash', 'Magnesium',
                   'Total phenols', 'Flavanoids',
                   'Nonflavanoid phenols', 'Proanthocyanins',
                   'Color intensity', 'Hue',
                   'OD280/OD315 of diluted wines', 'Proline']
print('Class labels', np.unique(df_wine['Class label']))
print('df_wine.head():\n', df_wine.head())

# 테스트용과 훈련용으로 임의 분할하기 위한 편리한 방법 한 가지는 사이킷런 cross_validation 서브 모듈의 train_test_split 함수
from sklearn.cross_validation import train_test_split
X, y = df_wine.iloc[:, 1].values, df_wine.iloc[:, 0].values
print('X:\n', df_wine.iloc[:, 1].values)    # Alcohol
print('y:\n', df_wine.iloc[:, 0].values)    # Class label
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
print('X_train:\n', X_train)
print('X_test:\n', X_test)

# 최소-최대 스케일링 프로시저
from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
X_train = np.array(X_train).reshape((len(X_train), 1))
X_test = np.array(X_test).reshape((len(X_test), 1))
X_train_norm = mms.fit_transform(X_train)
X_test_norm = mms.transform(X_test)
print('X_train_norm:\n', X_train_norm)
print('X_test_norm:\n', X_test_norm)

# 표준화 프로시저
from sklearn.preprocessing import StandardScaler
stdsc = StandardScaler()
X_train_std = stdsc.fit_transform(X_train)
X_test_std = stdsc.transform(X_test)
print('X_train:\n', X_train)
print('X_train_std:\n', X_train_std)


############ 오버피팅을 줄일 수 있는 일반적인 방법

from sklearn.linear_model import LogisticRegression
LogisticRegression(penalty='l1')
print("LogistincRegression(penality='l1'):\n", LogisticRegression(penalty='l1'))
lr = LogisticRegression(penalty='l1', C=0.1)
lr.fit(X_train_std, y_train)
print('Training accuracy:', lr.score(X_train_std, y_train))
print('Test accuracy:', lr.score(X_test_std, y_test))
lr.intercept_
print('lr.intercept_: ', lr.intercept_)
lr.coef_
print('lr.coef_: ', lr.coef_)


# 여러가지 정규화 강도를 위한 다양한 피처들의 가중계수인 정규화의 경로를 플롯
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.subplot(111)
colors = ['blue', 'green', 'red', 'cyan',
          'magenta', 'yellow', 'black',
          'pink', 'lightgreen', 'lightblue',
          'gray', 'indigo', 'orange']
weights, params = [], []
for c in np.arange(-4, 6):
    lr = LogisticRegression(penalty='l1', C=10**np.float32(c), random_state=0)
    lr.fit(X_train_std, y_train)
    weights.append(lr.coef_[1])
    params.append(10**np.float32(c))

weights = np.array(weights)
for column, color in zip(range(weights.shape[1]), colors):
    plt.plot(params, weights[:, column], label=df_wine.columns[column+1], color=color)

plt.axhline(0, color='black', linestyle='--', linewidth=3)
plt.xlim([10**(-5), 10**5])
plt.ylabel('weight coefficient')
plt.xlabel('C')
plt.xscale('log')
plt.legend(loc='upper left')
ax.legend(loc='upper center', bbox_to_anchor=(1.38, 1.03), ncol=1, fancybox=True)
plt.show()