[AI 스터디] Section 3 : 전통적 머신러닝 - 지도학습 모델 part 1

머신러닝 end-to-end process

1. 문제 정의 : 뭘 해야 겠다! -> 분류, 회귀 등 어떤 것인지

2. 데이터 준비

  < 전통적인 프로그래밍에서의 데이터 준비 >

  a. 유저의 요구사항, 비즈니스 룰, 프로그램 스팩, 설계서 정리

  b. 전통적인 프로그래밍에서 프로그램에 어떤 규칙을 넣을지 조사

 

 < 머신러닝 프로젝트에서의 데이터 준비 >

  ⇒ 위와 같은 전통적인 프로그래밍에서의 단계 필요 없음

  a. 전달받은 비즈니스 요구사항 확인

  b. 데이터를 가지고 있는지, 어떻게 준비할 것인지, 어디서 모을것인지 연구

  c. 확보한 데이터 정제 (80%의 시간을 주로 여기에 사용)

 

3. 모델 선택 : 데이터와 문제 정의에 맞는 여러 모델 중 하나 선택

4. 모델 작성 : 선택한 모델을 작성

5. 모델 평가 : 작성한 모델 평가

6. 모델 개선 : 평가 결과가 기대치에 미치는지 확인

  a. 기대치에 미침 ⇒ 결과 보고

  b. 기대치에 미치지 못함 ⇒ 모델 선택 단계부터 다시 사이클 시작

 

모델 작성 순서

: 프로그램 안에서 프로그램이 작성되는 순서 (티피컬함, 틀이 박혀있음)

1. 필요한 라이브러리 임포트
   • 대표적인 라이브러리 : sklearn, numpy, pandas, matplotlib 등
2. 데이터 로드
   • 사전에 준비된 csv 파일 사용
   • Sklearn에 내장된 데이터 로딩해 사용
3. 데이터 내용 파악
   • 목적 : 직관을 얻기 위해 & 내가 사용하려는 모델의 input 사양과 데이터가 동일한지 확인하기 위해
   • Shape : input 사양 확인
   • Pandas의 describe(), 기술 통계 : 데이터 내용 파악
   • Matplotlib 등 : 시각화를 통한 데이터 파악
4. Train, test set 분할
   • 방법 : sklearn.train_test_split 함수 / numpy 슬라이싱 등
   • Train set : 모델 훈련에 사용하는 데이터 셋
   • Test set : 훈련된 모델을 테스트하는데 사용하는 데이터 셋
5. Feature Scaling (= 데이터 정규화)
   • : 전체 데이터들이 큰 숫자, 작은 숫자 들이 피처별로 섞여 있는 것을 전부 비슷한 크기로 맞춰주는 작업
6. Model object creation⇒ 모델 안에 어려운 알고리즘이 내장되어 있어 함수처럼 모델을 불러서 사용할 것
   • : 모델 오브젝트 (모델 인스턴스) 하나 생성
7. Model train
   • : sklearn의 fit()이라는 메소드로 훈련 진행
8. Model 평가
   • : 평가 지표 출력 및 시각화
9. Best model 선택
   • : 훌륭한 모델, 가장 데이터에 적합한 모델 선택하는 과정의 반복 진행

 

선형 회귀 모델 설명

단변수 선형회귀 (Univariate Linear Regression)

: 한 개의 변수로 결과 예측

1. 하나만 가지고 하는 이유는 ?
   • 시각화를 하기 위해 (변수가 여러개 되면 시각화 불가)
   • ⇒ 변수가 아무리 많아져도, 변수 하나가 증명되면 똑같이 공식 적용 가능
   • ⇒ 그렇기 때문에 변수 하나만으로 원리를 파악후, 확장해나가면 됨
2. 방법
   • $y=wx+b$
     • X, y (입력데이터, 레이블)가 주어짐 + w, b는 미지수
     • W, b 를 추정해야함
   • Linear regression 과정 : 데이터 포인트들을 시각화하여 그 포인트들을 가장 잘 표현하는 선을 찾아내기

                ⇒ 무수한 라인을 그을 수 있는데 이 중에서 최선의 라인을 찾아야하는 것

 

3. 비용함수 (cost Function)

 : 최선의 라인이 무엇인지 측정하는 방법

• 목적 : 가설(= 모델)의 아웃풋이 얼마나 틀렸는지 측정하는 것  (=오차최소화하는 선 찾기)
• Example
  • X1일때, 모델 예측 = 모델 식에 x1을 넣어 나온 값, 실제 데이터 = y1
  • 오차 = 실제 데이터 y1 - 모델에 x1을 넣어 나온 예측한 값  = $y-\\hat{y}$
• 공식
  • $$ Minimize \sum_{i=1}^n{(true-prediction)^2} $$
  • 제곱을 하는 이유는 ? : +, - 로 오차가 나오게 되므로 이를 없애기 위해
  • 다른 방법은 ? : 절댓값으로 만들기 ⇒ 제곱보다 안 쓰는 이유는 ? : 미분이 잘 안되기 때문

• MSE (Mean squared Error) (평균 제곱 오차)
  • $$ MSE = \frac{1}{n} \sum_{i=1}^n(\hat{Y_i} - Y_i) $$
  • 데이터를 전부 예측한 값, 실제값의 차이 모두를 제곱하여 평균낸것
  • MSE를 최소화하는 w, b를 찾기 ⇒ w, b가 동시에 최소화가 되는 지점이 MSE를 최소화하는 지점임

4. 선형 회귀의 정확도 측정 : R2 score (결정 계수)

• 라이브러리 함수 : sklearn.metrics.r2_score
• 0 (부정확함) ≤ R2 ≤ 1 (정확함)  ⇒ 분모와 분자가 같기 때문에 0
• $$1-\frac{SSE}{SST}$$
• $$= 1 - \frac{예측값에 대한 분산의 합}{분산의 합}$$
• (SST : 평균으로 부터 얼마나 떨어져 있는지 ⇒ 분산)

 

다변수 선형회귀 (Multivariate Linear Regression)

: 변수가 여러개 (X1, X2, X3 … )

 

1. 차원

  ⇒ 면 주위에 데이터 포인트들이 공간에 처져 있는데 그 사이에 MSE가 최소가 되는 면을 찾아내는 것

  ⇒ 3차원 이상이 되므로 선이 아닌 면으로 표현

 

실습 - 선형 회귀 모델 : 당뇨병 진행률 예측

단변수 선형회귀

dia = datasets.load_diabetes() # 데이터 불러오기오기
print(dia.DESCR) # 어떤 데이터가 어떻게 구성되어있는지 출력

dia.feature_names # 피처 이름들 출력
dia.data.shape # shape 확인 : (442, 10)
dia.target.shape # 타겟 shape 확인 : (442,) 442개의 각 레코드에 대한 정답이 매핑됨

# 데이터 프레임으로 바꾸어 확인
df = pd.DataFrame(dia.data, columns=dia.feature_names) # 데이터 프레임으로 확인
df.head() # 5개의 행, 전체 열 간단히 확인 가능

데이터 생성

# 시각화를 위해 단변수 선형회귀를 해야하는데, 그러려면 피처를 하나만 고름
# bmi로 실습
dia_X = df["bmi"].values
dia_X.shape # (442,) : 벡터 형태임 => 사이킷런의 데이터는 2차원 배열 형태로 만들어줘야함 => reshape
# reshape : 2차원 배열 형태로 생성
dia_X = df["bmi"].values.reshape(-1,1) #reshape(442,1) (o)

# 훈련셋, 검증셋 분활 : 슬라이싱 이용
dia_X_train = dia_X[:-20] # 뒤에서 20번째 까지, 
dia_X_test = dia_X[-20:] # 뒤에서 부터 20번째
dia_X_train.shape, dia_X_test.shape # (422,1),(20,1)

dia_y_train = dia.target[:-20] # (422,)
dia_y_test = dia.target[20:] #(20,)

Sklearn model 이용

regr = linear_model.LinearRegression() # 괄호 필수!, 아니면 인스턴스 생성이 안되는것

regr.fit(dia_X_train, dia_y_train) # 모델 학습
regr.coef_ # 기울기
regr.intercept_ # 절편

y_pred = regr.predict(dia_X_test) # 검증 셋에 대한 예측값

# 예측값, 정답값 사이의 시각화로 예측이 잘되었는지 확인
plt.scatter(dia_X_test, dia_y_test, label = "True Value")
plt.plot(dia_X_test, y_pred, color='r', label = "Predict")
plt.xlabel("bmi")
plt.ylabel("Progress")
plt.legend()

# R2 계산
r2_score(dia_y_test, y_pred) # 0.4725... : 높진 않음
# MSE
mean_squared_error(dia_y_test, y_pred)

다변수 선형회귀 : bmi, bp 두가지 변수 이용

# bmi, bp 두 피처만 가져오기
dia_X = df[["bmi", "bp"]].values # reshape 필요없음 2개의 피처이므로 이미 행렬임
dia_X.shape #(442,2)

# 훈련셋, 검증셋 분활 : 슬라이싱 이용 -> 위와 동일
dia_X_train = dia_X[:-20] # 뒤에서 20번째 까지, 
dia_X_test = dia_X[-20:] # 뒤에서 부터 20번째
dia_X_train.shape, dia_X_test.shape # (422,2),(20,2)

dia_y_train = dia.target[:-20] # (422,)
dia_y_test = dia.target[20:] #(20,)

# 모델 훈련 및 예측
regr = linear_model.LinearRegression() # 괄호 필수!, 아니면 인스턴스 생성이 안되는것

regr.fit(dia_X_train, dia_y_train) # 모델 학습
regr.coef_ # 기울기
regr.intercept_ # 절편

y_pred = regr.predict(dia_X_test) # 검증 셋에 대한 예측값

# R2 계산
r2_score(dia_y_test, y_pred) # 0.465... : 더 안좋아짐
# MSE
mean_squared_error(dia_y_test, y_pred)

다변수 선형회귀 : 전체 피처를 이용

# bmi, bp 두 피처만 가져오기
dia_X = df.values
dia_X.shape # (442,10) : reshape 필요없음

# 훈련셋, 검증셋 분활 : 슬라이싱 이용 -> 위와 동일
dia_X_train = dia_X[:-20] # 뒤에서 20번째 까지, 
dia_X_test = dia_X[-20:] # 뒤에서 부터 20번째
dia_X_train.shape, dia_X_test.shape # (422,10),(20,10)

dia_y_train = dia.target[:-20] # (422,)
dia_y_test = dia.target[20:] #(20,)

# 모델 훈련 및 예측
regr = linear_model.LinearRegression() # 괄호 필수!, 아니면 인스턴스 생성이 안되는것

regr.fit(dia_X_train, dia_y_train) # 모델 학습
regr.coef_ # 기울기
regr.intercept_ # 절편

y_pred = regr.predict(dia_X_test) # 검증 셋에 대한 예측값

# R2 계산
r2_score(dia_y_test, y_pred) # 0.58.... : 그냥 아까보단 좋아짐
# MSE
mean_squared_error(dia_y_test, y_pred)

KNN 알고리즘 설명

KNN (K-Nearest Neighbors, K 최근접 이웃)

1. 작동 방법
   • k값을 선택
   • 예측하고자하는 데이터포인트와 모든 데이터간의 거리 계산
   • 트레이닝셋에서 예측할 포인트와 가까이있는 K개의 데이터포인트 선택
   • 분류, 회귀에 따라 값 예측
     • 분류 : 단순히 가장 가까운 이웃들의 레이블 중 가장 많은 레이블로 분류
     • 회귀 : 이웃 값들의 평균
2. 특징
   • 장점 : 심플 / 이해하기 쉬운 모델
   • 단점
     • 데이터가 커질 수록 느려짐
     • ⇒ 이유 : 다차원으로 갈 수록 모든 거리를 다 계산하고 분류하는 양이 느려지기 때문에
     • 이상치와 결측치의 영향이 크다 (= 엉뚱하게 분류될 확률이 크다)
   • K 값이 매우 중요하게 작용됨
3. 거리 계산 방법 : 피타고라스 정리에 의한 유클리드 거리 계산

$$ d(p,q) =d(q,p)\\ = \sqrt{(q_1-p_1)^2 + (q_2-p_2)^2 + ... +(q_n-p_n)^2 }\\= \sqrt{\sum_{i=1}^n (q_i - p_i)^2} $$

 

실습 - KNN : 붓꽃 데이터 분류

붓꽃 데이터 소개

1. Dataset : sklearn의 iris dataset
2. 피처 : 꽃받침 길이, 꽃받침 너비, 꽃잎 길이, 꽃잎 너비
3. 행 : 150
4. 타겟 : 꽃의 종류 (Setosa, verslcolor, virginica 3종류)

모델 코드

neighbors.KNeighborsClassifier(n_neighbors, weights=weights)

1. N_neighbors : 이웃 개수
2. Weights : 거리 계산을 어떤 방식으로 할 것인가
   • Uniform : 모든 이웃의 가중치를 동일하게 취급 → 거리는 상관하지 않는것
   • Distance : 이웃의 거리에 반비례하게 가중치 조정 → 먼 것은 가중치 적음

데이터 셋

from sklearn.datasets import load_iris

iris = load_iris() # 딕셔너리 형태로 키에 각 데이터들이 있음
# 주의 : 타겟 데이터가 0 1 2 순으로 섞이지 않고 되어있음 -> 섞어야함
# 안섞으면 검증은 2번만 하고 훈련은 0 1로만 훈련됨

iris.data.shape #(150,4)
iris.feature_names # 피처 이름
iris.target_names # 타겟 종류

X = iris.data[:,:2] # sepal length, sepal width 두개만 사용
y = iris.target

X.shape, y.shape #(150,2) (150,)

# train, test 셋으로 분류
from sklearn.model_selection import train_test_split
# test set : 20% / random state : 0
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size =0.2, random_state = 0)

X_train.shape, X_test.shape, y_train.shape, y_test.shape
# (120,2) (30,2) (120,) (30,)
# 사이킷런의 데이터셋은 잘 정제되어 있기 때문에 에러날 일이 없는데
# 에러가 난다면 거의 무조건 shape가 잘못 되어있어서이므로 shape를 잘 확인하자

KNN object 생성 및 훈련

from sklearn.neighbors import KNeighborsClassifier

clf = KNeighborsClassifier(n_neighbors=15, weights='uniforn')
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

예측의 정확도 평가

from sklearn.metrics import accuracy_score

accuracy_score(y_test, y_pred) #0.666666

시각화

# 분류된것을 색으로 표시하여 2차원 공간에서 3개를 확인할 수 있음
import matplotlib.pyplot as plt
X_train[y_train==0] # 타겟이 0인것만 골라줌

# 방법 1
plt.scatter(X_train[y_train==0,0], X_train[y_train==0,1])
plt.scatter(X_train[y_train==1,0], X_train[y_train==1,1])
plt.scatter(X_train[y_train==2,0], X_train[y_train==2,1])

# 방법 2
for i in range(3):
	plt.scatter(X_train[y_train==i,0], X_train[y_train==i,1])
	
plt.legend()

# 하나 선택해서 이게 올바르게 예측이 되는건지 확인하는 시각화
# 20번째 데이터를 골라서 해당 위치에 x 표시로 그려줌
# 20번째 데이터 주위에 어떤 레이블의 데이터가 많은지 확인 가능 => 2번
plt.plot(X_test[20,0], X_test[20,1], cr='r', marker='x', markersize = 20)

clf.predict(X_test[20:21]) # 예측한 값이 출력됨 => 2번

Confusion Matrix (혼동행렬)

from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)

import seaborn as sns
plt.figure(figsize=(5,4))
ax = sns.headmap(cm, annot=True, fmt='d')
ax.set_title("confusion matrix)
ax.set_ylable("True")
ax.set_xlable("Predicted")
# 어떤 종으로 몇개를 맞췄는지, 어떤 종으로 몇개를 틀렸는지 등을 확인 가능

결정나무 (Decision Tree) 알고리즘 설명

이 모델이 중요한 이유

: 이 모델 기반으로 좋은 모델들이 많이 만들어지고 있기 때문

결정나무 형식 및 특징

1. 형식 : 이진트리 형식
   • Tree 인 이유 : 나무를 뽑아 뿌리를 위쪽으로 해놓은 형태
2. 구성
   • 맨 위쪽 : root
   • 맨 아래쪽(분류값) : leaf node
   • 질문들(test) : node
   • Test 결과 : branch
3. 장점
   • 화이트 박스 모델 : 왜 이 모델이 이렇게 예측했는지 확인할 수 있음
   • → 보통 다른 모델의 경우에는 왜 그렇게 나왔는 지 설명하기 힘들다.
   • 데이터 프리프로세싱할 필요 없음
4. 단점
   • 과적합 되기 쉬움 (: 예측은 잘되나 검증, 실제 데이터셋에서 잘 맞지 않음)
   • 훈련 데이터의 작은 변화에도 매우 민감함

결정나무 방법

: 엔트로피가 높은 상태 → 낮은 상태가 되도록 데이터를 특정 조건을 찾아 나무 모양으로 구분해 나감

1. 어떤 조건 및 범위에 대한 답으로 yes, no를 정해감
2. 조건 및 범위를 줄여가며 데이터를 분류

질문 기준

• If else로 만들 수 있지만 복잡하기 때문에 코딩 하지 않음
• 최적의 조건들이 배치되도록 적절히 학습하여 스스로 배치

좋은 결정나무 모델

: 가장 최적의 조건들이 배치가 된 것

알고리즘의 종류

→ 변종이 많음

1. ID3
   • 가장 기본적인 알고리즘
   • 정보이득 이용해 트리 구성
   • 사이킷런에 내장됨
2. CART
   • ID3와 거의 비슷한 알고리즘
   • 지니불순도를 이용한 트리 구성
   • 사이킷런에 내장됨
3. C4.5, C5.0
   • ID3를 개선한 알고리즘
4. CHAID, MARS

알고리즘 기준

[ 엔트로피 (Entropy)]

1. 의미 : 주어진 데이터 집합의 혼잡도, 얼마나 분류되지 않고 섞여있는지 ⇒ 우리가 가지고 있지 않은 정보의 양
2. 특징
   • 엔트로피가 높다 : 데이터 집합에 서로 다른 종류의 레코드들이 섞여있음 (= 분류가 안됨)
   • 엔트로피가 낮다 : 같은 종류의 레코드들이 섞여있음
   • 범위 : 0 (가장 혼합도가 낮은 상태) ~ 1 (가장 혼합도가 높은 상태)
   • 혼잡도, 정보의 양은 비례함 : 깔끔하게 분류되어있으면 배울게 없음
3. 공식 : $$ Entropy = -\sum_{i=1}^{m} p_ilog_2^{(p_i)}\\ p_i = \frac{freq(c_i, s)}{|s|} $$

  (S: 주어진 데이터들의 집합, C: 레코드(클래스) 값들의 집합, freq(Ci,S): S에서 Ci에 속하는 레코드의 수, |S|: 주어진 데이터들의 집합의 데이터 개수)

 

   4. 정보 이득(information gain) : 우리가 시스템의 통계를 알게되어 감소하는 엔트로피

$$Information Gain = Entropy(Parent) – (weight) * Entropy(Child)$$

실습 - Decision Tree 모델 작성 및 시각화 : 붓꽃 데이터 분류

데이터 불러오기 및 스플릿

# 데이터 불러오기
from sklearn.datasets import load_iris
iris = load_iris()

# train_test_split
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3)

decision tree 모델 : max_depth = 2

from sklearn import tree

clf = tree.DecisionTreeClassifier(max_depth=2, criterion='entropy') # 기본은 gini 
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)

accuracy_score(y_test, y_pred) #0.9555555555555556

# 이진 트리 시각화 -> 화이트박스 모델
import matplotlib.pyplot as plt

fig = plt.figure(figsize=(25,20))
# _(언더스코어)를 하나 주는 이유 : 반환값을 받게 되는데, 변수로 이걸 받지 않으면 지저분하게 찍히게되므로
# 반환값을 서프레스 하고자 함
# plot_tree 라는 메소드가 제공됨
_ = tree.plot_tree(clf, _names=iris.feature_names, ss_names=iris.target_names, filled=True)

 

max_depth를 설정하지 않았을 때

# 모델 설정
# NONE 으로 설정시, 제한을 두지 않는 것
clf = tree.DecisionTreeClassifier(max_depth=None)
clf.fit(X_train, y_train)

y_pred = clf.predict(X_test)
accuracy_score(y_test, y_pred) # 0.9333333333333333

# 시각화
fig = plt.figure(figsize=(25,20))
_ = tree.plot_tree(clf, 
                   feature_names=iris.feature_names,  
                   class_names=iris.target_names,
                   filled=True)