[혼공머신] Logistic Regression (로지스틱 회귀)

로지스틱 회귀

럭키백의 확률

K-최근접 이웃 알고리즘은 주변 이웃을 찾아주니까 이웃의 클래스 비율을 확률이라고 출력하면 될수 있다고 생각합니다.

• 보면 샘플 X 주위에 가장 가까운 이웃 샘플 10개를 표시했습니다. 삼각형이 5개, 사각형이 3개, 원 2개가 있습니다.
• 이웃한 샘플의 클래스를 확률로 삼는다면 샘플 X가 사각형이 확률은 30%, 삼각형일 확률은 50%, 원인 확률은 20%입니다.
• Scikit-learn의 K-최근접 이웃 분류기도 이와 동일한 방식으로 Class 확률을 계산하여 제공합니다. 한번 데이터를 불러와서 해보겠습니다.

---

데이터 준비

import pandas as pd
fish = pd.read_csv('https://bit.ly/fish_csv_data')
fish.head()

# Species(7개의 생선에 대한 종류)-Target, 나머지는 특성 데이터(input_data-fish_input)
print(pd.unique(fish['Species']))

['Bream' 'Roach' 'Whitefish' 'Parkki' 'Perch' 'Pike' 'Smelt']

• 이 데이터프레임에서 Species 열을 타깃으로 만들고 나머지 5개 열은 입력 데이터로 사용하겠습니다.

fish_input = fish[['Weight','Length','Diagonal','Height','Width']].to_numpy()
print(fish_input[:5])

[[242. 25.4 30. 11.52 4.02 ]
 [290. 26.3 31.2 12.48 4.3056]
 [340. 26.5 31.1 12.3778 4.6961]
 [363. 29. 33.5 12.73 4.4555]
 [430. 29. 34. 12.444 5.134 ]]

• 타겟 데이터도 만들어 보겠습니다.

# Species(7개의 생선에 대한 종류)-Target
fish_target = fish['Species'].to_numpy()

• 앞에서 배웠듯이 머신러닝에서는 기본으로 데이터 세트 2개가 필요합니다.

from sklearn.model_selection import train_test_split
train_input, test_input, train_target, test_target = train_test_split(fish_input, fish_target, random_state=42)

• 그다음 Scikit-learn의 StandardScaler 클래스를 사용해 Training_set와 Test_set를 표준화 처리하겠습니다.
• 알아야 할점은, Training_set의 통계값으로 Test_set를 변환해야 합니다.

from sklearn.preprocessing import StandardScaler
ss = StandardScaler()
ss.fit(train_input)
train_scaled = ss.transform(train_input)
test_scaled = ss.transform(test_input)

---

K-최근접 이웃의 다중분류

Scikit-learn의 KNeighborsClassifier 클래스 객체를 만들고 Training_set로 모델을 훈련한 다음 Training_set와 Test_set의 점수를 확인해 보겠습니다. 최근접 이웃 개수는 k는 3으로 지정하고 사용해보겠습니다.

from sklearn.neighbors import KNeighborsClassifier
kn = KNeighborsClassifier(n_neighbors=3)
kn.fit(train_scaled, train_target)
print(kn.score(train_scaled, train_target))
print(kn.score(test_scaled, test_target))

0.8907563025210085
0.85

• 여기서 잠깐 짚고 넘어가야 할 부분이 있습니다. 타깃 데이터를 만들 때 fish['Species']를 사용해서 만들었기 때문에, Training & Test set의 7개의 생선 종류가 들어가 있습니다. 이렇게 타깃 데이터의 2개 이상의 클래스가 포함된 문제를 다중 분류(Multi-class Classification)라고 부릅니다.
• 한번 Classes들의 개수를 출력해 보겠습니다.

# 속성 확인, _는 모델이 데이터로부터 학습한 속성이라는것을 나타냄
print(kn.classes_)

['Bream' 'Parkki' 'Perch' 'Pike' 'Roach' 'Smelt' 'Whitefish']

• Bream이 첫번째 Class, Parkki는 두번째 Class가 되는 식입니다.
• predict() Method는 Target값으로도 예측을 출력합니다. 한번 예측해 보겠습니다.

print(kn.predict(test_scaled[:5]))

['Perch' 'Smelt' 'Pike' 'Perch' 'Perch']

• 이 5개의 샘플에 대한 예측은 어떤 확률로 만들어졌을까요?
• Scikit-learn의 분류모델을 predict_, proba() method로 class별 확률값을 반환합니다.
• 한번, Test_set에 있는 처음 5개의 샘플에 대한 확률을 출력해 보겠습니다.
• Numpy의 round() 함수는 기본으로 소수점 첫째 자리에서 반올림을 하는데, decimals 매개변수로 유지할 소수점 아래 자릿수를 지정할 수 있습니다.

# 확률 출력시 predict_proba method 사용
# 5개의 sample, 7개의 생선
import numpy as np
proba = kn.predict_proba(test_scaled[:5])
print(np.round(proba, decimals=4))

[[0.     0.     1.     0.     0.     0.     0.    ]
 [0.     0.     0.     0.     0.     1.     0.    ]
 [0.     0.     0.     1.     0.     0.     0.    ]
 [0.     0.     0.6667 0.     0.3333 0.     0.    ]
 [0.     0.     0.6667 0.     0.3333 0.     0.    ]]

• predict_proba() Method의 출력 순서는 앞에 보았던 classes_ 속성과 같습니다.
• 즉, 첫번째 열이 'Bream'에 대한 확률, 두번째는 'Parkki'에 대한 확률입니다.

• 이 모델이 계산한 확률이 가장 가까운 이웃이 맞는지 확인해 보겠습니다. 한번 4번째 샘플의 최근접 이웃의 Class를 확인해 보겠습니다.

distances, indexes = kn.kneighbors(test_scaled[3:4])
print(train_target[indexes])

[['Roach' 'Perch' 'Perch']]

• 이 샘플의 이웃은 다섯번째 Class인 'Roach'가 1개이고, 'Perch'가 2개입니다.
• 따라서 다섯 번째 클래스에 대한 확률은 1/3, 즉 0.333이고 세번째 클래스에 대한 확률은 2/3 = 0.6667입니다.
• 앞서 출력한 네 번째 샘플의 클래스 확률과 같습니다.
• 이런 번거로운 계산은 Scikit-learn이 수행해주므로, predict_proba() Method를 호출하면 그만입니다.
• 근데, K-최근접 이웃 알고리즘을 사용하면 나오는 확률은 0/3, 1/3, 2/3, 3/3이 전부입니다. 뭔가 이상하긴 하네요..

---

Logistic Regression (로지스틱 회귀)

로지스틱 회귀(Logistic Regression)는 회귀이지만, 분류모델 입니다. 이 알고리즘은 선형 회구와 동일하게 선형 방정식을 학습합니다.

Logistic Regression 선형방정식 예시

• 여기서 a,b,c,d,e는 가중치 혹은 계수입니다. 특성은 늘어났지만, 다중 회귀(Multiple Regression)를 위한 선형 방정식과 같습니다.
• z에는 어떠한 값도 들어갈 수 있습니다. 다만, 확률을 나타내려면 0~1 (0~100%)사이 값이 되어야 한다.
• 근데, 만약에 z가 큰 음수가 될때는 0이되고, 큰 양수가 될때 1이 되도록 봐꾸는 방법이 있을까요?

여기서 Sigmoid 함수 or Logistic 함수를 사용하면 가능합니다.

• Sigmoid 함수 에서는 위의 선형 방정식을 이용해서 z의 음수를 사용한 후, 자연 상수 e를 거듭제곱 하고 1을 더한 값의 역수를 취합니다.
• z가 무한하게 큰 음수일 경우는 0에 가까워지고, z가 무한하게 큰 양수일 경우에는 1에 가까워 집니다. z가 0이면 값은 0.5가 나옵니다.
• Sigmoid 함수는 절대로 0~1 사이를 벗어날 수 없기 때문입니다. 그래서 0~1 사이 값을 0~100%로 볼수 있습니다.
• 한번 Numpy 라이브러리를 사용해서 그래프를 그려보겠습니다. 여기서 -5가 5사이에 0.1 간격으로 배열 z를 만들고, 다음 z 위치마다 Sigmoid 함수를 계산합니다.

import numpy as np
import matplotlib.pyplot as plt
z = np.arange(-5, 5, 0.1)
phi = 1 / (1+ np.exp(-z))
plt.plot(z, phi)
plt.xlabel('z')
plt.ylabel('phi')
plt.show()

• 이 그래프를 보면 Sigmoid 함수의 출력은 0~1 사이로 변하는것을 알 수 있습니다.
• 그러면 Logistic 회귀 모델을 훈련해 보겠습니다. Scikit-learn에서는 로지스틱 회귀 모델인 Logistic Regression Class를 사용해 보겠습니다.
• 한번 테스트로 Sigmoid 함수의 출력이 0.5보다 크면 양성, 작으면 음성으로 판단할 수 있게 출력해 보겠습니다.

# 불리언 인덱싱, Logistic 회귀로 이진 분류 수행
char_arr = np.array(['A','B','C','D','E'])
print(char_arr[[True, False, True, False, False]])

['A' 'C']

• 잘 나오는것을 확인하였고, 이 방식을 사용해서 도미(Bream)와 빙어(Smelt)의 행을 비교 연산자를 사용해서 골라내겠습니다.

bream_smelt_indexes = (train_target == 'Bream') | (train_target == 'Smelt')
train_bream_smelt = train_scaled[bream_smelt_indexes]
target_bream_smelt = train_target[bream_smelt_indexes]

• 비교연산자를 사용하면 도미 & 빙어 행을 모두 Ture로 봐꿀 수 있습니다.
• 어떻게 골라내냐면, train_target == 'Bream' &  train_target == 'Smelt' 이렇게 사용해서 배열에 Bream, Smelt 인것은 True, 나머지는 False로 반환합니다.
• bream_smelt_indexes 배열은 코드를 보시면 알수 있지만, 도미와 빙어일 경우 'True' 나머지는 'False' 값을 반환합니다.
• 따라서, train_scaled, train_target 배열에 불리언 인덱싱을 적용하면 골라낼 수 있습니다.
• 이제 이 데이터로 Logistic 회귀 모델을 훈련해 보겠습니다. LogisticRegression(로지스틱 회귀) 클래스는 선형모델이므로 sklearn.linear_model 패키지 안에 있습니다.

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression()
lr.fit(train_bream_smelt, target_bream_smelt)

• 훈련한 모델을 사용해서 train_bream_smelt에 있는 처음 5개 샘플을 예측해 보겠습니다.

print(lr.predict(train_bream_smelt[:5]))

['Bream' 'Smelt' 'Bream' 'Bream' 'Bream']

• 두번째 Sample을 제외하고 모두 도미(Bream)로 예측 했습니다.
• KNeighborsClassifier와 마찬가지로 예측 확률은 predict_proba() Method에서 제공합니다.
• train_bream_smelt에서 처음 5개의 Sample의 예측 확률을 출력해 보겠습니다.

# 왼쪽이 음성, 오른쪽이 양성 데이터, 순서는 'Bream' 'Smelt' 'Bream' 'Bream' 'Bream'
print(lr.predict_proba(train_bream_smelt[:5]))

[[0.99759855 0.00240145]
 [0.02735183 0.97264817]
 [0.99486072 0.00513928]
 [0.98584202 0.01415798]
 [0.99767269 0.00232731]]

각 Sample마다 2개의 확률이 출력되었습니다. 왼쪽은 음성(0), 오른쪽은 양성(1) 클래스에 대한 확률입니다.

• 그러면 Bream, Smelt 중에 어떤것이 양성 클래스 일까요?
• K-최근접 이웃 분류기에선, Scikit-learn은 Target값을 알파벳순으로 정렬하여 사용합니다. classes_ 속성을 사용하면 확인 가능합니다.

print(lr.classes_)

['Bream' 'Smelt']

• 빙어(Smelt)가 양성 클래스 라고 나옵니다. predict_proba() Method가 반환한 배열값을 보면 두번째 Sample에서만 양성인 빙어의 확률이 높습니다. 나머지는 모두 도미(Bream)이겠군요.
• 그러면, Logistic Regression으로 이진 분류를 했으니까, 선형회귀에서 했던것 처럼 로지스틱 회귀가 학습한 계수를 확인해 보겠습니다.

# z = -0.404 x 무게 - 0.576 x 길이 - 0.663 x 대각선 - 0.013 x 높이 - 0.732 x 두께 - 2.161
print(lr.coef_, lr.intercept_)

[[-0.4037798 -0.57620209 -0.66280298 -1.01290277 -0.73168947]] [-2.16155132]

• Logistic 회귀 모델이 학습한 방정식은 다음과 같습니다.

방정식을 보면, Logistic 회귀는 선형회귀랑 비슷합니다. 그러면 LogisticRegression 모델로 z값 계산이 가능할까요?

• LogisticRegression Class는 decision_function() Method로 z값을 출력할 수 있습니다.
• train_bream_smelt의 처음 5개의 sample z값을 출력해 보겠습니다.

decisions = lr.decision_function(train_bream_smelt[:5])
print(decisions)

[-6.02927744 3.57123907 -5.26568906 -4.24321775 -6.0607117 ]

• 이 z값을 Sigmoid 함수에 넣으면 확률을 얻을 수 있습니다.
• Python의 scipy(사이파이) 라이브러리에도 Sigmoid 함수가 있습니다. expit() 이라는 Method 입니다.
• np.exp() 함수를 사용해 분수 계산을 하는 것보다 안전합니다. decision 배열의 값을 확률로 변환해 보겠습니다.

# 계산시, z값은 양성 class에 대한 z값만 계산. 선형함수는 하나. 양성 class에 대한 z값만 계산
from scipy.special import expit
print(expit(decisions))

[0.00240145 0.97264817 0.00513928 0.01415798 0.00232731]

• 출력된 값들을 보면 predict_proba() method 출력의 두 번째 열(0.97264817)의 값과 동일합니다.
• 즉, decision_function() Method는 양성 Class에 대한 z 값을 반환합니다.

---

Logistic Regression(로지스틱 회귀-다중 분류)

Logistic Regression은 기본적으로 릿지 회귀와 같이 계수의 제곱을 규제합니다. 이런 규제를 L2 규제라고도 부릅니다.

• 릿지 회귀에서는 alpha 매개변수로 규제의 양을 조절합니다. alpha가 커지면 규제가 커집니다.
• Logistic Regression에서 규제를 제어하는 매개변수는 c 입니다.
• 하지만, c는 alpha와 반대로 작을수록 규제가 커집니다. c의 기본값은 1이지만, 규제 완화를 위해서 20으로 늘려서 계산해 보겠습니다.

lr = LogisticRegression(C=20, max_iter=1000)
lr.fit(train_scaled, train_target)

print(lr.score(train_scaled, train_target))
print(lr.score(test_scaled, test_target))

0.9327731092436975
0.925

• 이번에는 Training_set와 Test_set에 대한 점수가 높고, 과대적합(Overfitting)이나 과소적합(Underfitting)으로 치우친것 같지 않습니다.
• 다음으로, Test_set의 처음 5개 Sample에 대한 예측값을 출력해 보겠습니다.

print(lr.predict(test_scaled[:5]))

['Perch' 'Smelt' 'Pike' 'Roach' 'Perch']

• 테스트 세트의 처음 5개 sample에 대한 예측 확률을 출력해 보겠습니다. 소숫점 네번째 자리에서 반올림 하겠습니다.

proba = lr.predict_proba(test_scaled[:5])
print(np.round(proba, decimals=3))

[[0.    0.014 0.841 0.    0.136 0.007 0.003]
 [0.    0.003 0.044 0.    0.007 0.946 0.   ]
 [0.    0.    0.034 0.935 0.015 0.016 0.   ]
 [0.011 0.034 0.306 0.007 0.567 0.    0.076]
 [0.    0.    0.904 0.002 0.089 0.002 0.001]]

• 5개 샘플에 대한 예측이므로 5개의 헹이 출력되었습니다.
• 위에부터 행으로 'Perch', 'Smelt', 'Pike', 'Roach', 'Perch' 순입니다.

print(lr.classes_)

['Bream' 'Parkki' 'Perch' 'Pike' 'Roach' 'Smelt' 'Whitefish']

• print로 classes_ 객체를 출력해보면 클래스의 정보를 확인할수 있습니다.
• 열로는 'Bream', 'Parkki', 'Perch', 'Pike', 'Roach', 'Smelt', 'Whitefish' 순서입니다.

보면, 첫번째 sample은 'Perch'로 가장 높은 확률로 예측을 하였고, 3번째 sample은 'Pike'로 높은 확률로 예측하였습니다.

• 그러면 다중 분류인 경우 선형 방정식은 어떤 모습일까요? coef_ 와 intercept_의 크기를 출력해 보겠습니다.

print(lr.coef_.shape, lr.intercept_.shape)

(7, 5) (7,)

• 이 데이터는 5개의 특성(sample)을 사용하므로 coef_배열의 열은 5개, 행은 7개 입니다, intercept_도 7개가 있습니다.
• 즉, 이말은 이진 분류에서 보았던 z를 7개나 계산한다는 말입니다.
• 다중 분류는 클래스마다 z값을 1개씩 계산합니다. 이중 가장 높은 z 값을 출력하는 클래스가 예측 클래스가 됩니다.
• 그러면 여기서 확률은 어떻게 계산할까요? 이진분류는 Sigmoid 함수를 사용해 z를 0~1사이 확률값으로 변환합니다.
• 다중분류는 그냥 이진분류처럼 똑같이 Sigmoid 함수를 사용해 확률값으로 변환하지만. z값의 개수만큼 확률로 변환합니다.

---

Softmax 함수

Softmax 함수는 z값을 지수함수에 적용하여 계산합니다. 계산방식을 풀어보겠습니다.

• z값 개수의 이름을 z1, z2, ... z7까지 붙이겠습니다. (z값은 7개)
• 그리고 z1~z7까지 값을 사용해 지수함수를 모두 더합니다. 다 더한 값은 e_sum이라고 하겠습니다.
• 그리고 각각의 값을 e_sum으로 나누어 주면 됩니다.

• 이제 이진 분류에서 decision_function() Method로 z1~z7 까지의 값을 구한 다름 Softmax 함수를 사용해 확률로 봐꾸어 보겠습니다.
• Test_set의 처음 5개 샘플에 대한 z1~z7까지의 값을 구해보겠습니다.

# z값 출력, 선형함수 7개(다중분류) - 7개의 출력. 5개의 sample에 대하여 7개의 결정함수(z)값 출력
decision = lr.decision_function(test_scaled[:5])
print(np.round(decision, decimals=2))

[[ -6.5    1.03   5.16  -2.73   3.34   0.33  -0.63]
 [-10.86   1.93   4.77  -2.4    2.98   7.84  -4.26]
 [ -4.34  -6.23   3.17   6.49   2.36   2.42  -3.87]
 [ -0.68   0.45   2.65  -1.19   3.26  -5.75   1.26]
 [ -6.4   -1.99   5.82  -0.11   3.5   -0.11  -0.71]]

• 또한 scipy도 Softmax 함수를 제공합니다. spicy.special 아래에 softmax()함수를 import해 사용하겠습니다.

from scipy.special import softmax
proba = softmax(decision, axis=1)
print(np.round(proba, decimals=3))

[[0.    0.014 0.841 0.    0.136 0.007 0.003]
 [0.    0.003 0.044 0.    0.007 0.946 0.   ]
 [0.    0.    0.034 0.935 0.015 0.016 0.   ]
 [0.011 0.034 0.306 0.007 0.567 0.    0.076]
 [0.    0.    0.904 0.002 0.089 0.002 0.001]]

• 앞서 구한 decision 배열을 softmax() 함수에 전달했습니다.
• softmax()의 axis 매개변수는 softmax를 계산할 축을 지정합니다. 여기서는 axis=1로 지정하여 각 행, 즉 각 sample에 대해 softmax를 계산합니다.
• 만약, axis 매개변수를 지정하지 않으면? 베열 전체에 대해 softmax를 계산합니다.
• 또한, proba 배열과 비교해도 결과가 일치합니다. 그러면 맞게 훈련한 것이 맞습니다.

---

Keywords

• 로지스틱 회귀는 선형 방정식을 사용한 분류 알고리즘입니다. 선형 회귀와 달리 시그모이드 함수나 소프트맥스 힘수를 사용하여 클래스 확률을 출력할 수 있습니다.
• 다중 분류는 타깃 클래스가 2개 이상인 분류 문제입니다. 로지스틱 회귀는 디중 분류를 위해 소프트맥스 함수를 사용하여 클래스를 예측합니다.
• 시그모이드 함수는 선형 방정식의 출력을 O과 1 사이의 값으로 압축하며 이진 분류를 위해 사용합니다.
• 소프트맥스 함수는 디중 분류에서 여러 선형 방정식의 출력 결괴를 정규화하여 합이 1이 되도록 만듭니다.

핵심 패키지와 함수

scikit-learn

• Logistic Regression은 선형 분류 알고리즘인 로지스퇴 회귀를 위한 클래스입니다.
• solver 매개변수에서 시용할 알고리즘을 선택할 수 있습니다. 기본값은 ‘lbfgs’입니다. 사이킷 런 0.17 버전에 추가된 ‘sag’는 확률적 평균 경사 하강법 알고리즘으로 특성과 샘플 수가 많을 때 성능은 빠르고 좋습니다. 사이킷런 0.19 버전에는 ‘sag’의 개선 버전인 ‘saga’가 추가되었습니다.
• penalty 매개변수에서 L2 규제(릿지 방식)와 L1 규제(라쏘방식)를선택할수 있습니다. 기본값은 L2 규제를 의미하는 ‘12’입니다.
• c 매개변수에서 규제의 강도를 제어합니다. 기본값은 1.0이며 값이 작을수록 규제가 강해집 니다.
• predict_proba() 메서드는 예측 확률을 반환합니다. 이진 분류의 경우에는 샘플마다 음성 클래스와 양성 클래스에 대한 확률을 반환합니다. 다중 분류의 경우에는 샘플마다 모든 클래스에 대한 획률을 반환합니다.
• decision function()은 모델이 학습한 선형방정식의 출력을 반환합니다. 이진 분류의 경우 양성 클래스의 획률이 반환 됩니다. 이 값이 0보다 크면 양성 클래스, 작거나 같으면 음성 클래스로 예측합니다. 다중분류의 경우 각클래스마다 선형 방정식을 계산합니다. 가장 큰 값의 클래스가 예측 클래스가 됩니다.