[AI SCHOOL 5기] 머신 러닝 실습 - Pipeline

Feature Transformer #

Import Libraries #

python
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline

ColumnTransformer #

python
numeric_features = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'TAX', 'PTRATIO', 'B', 'LSTAT']
numeric_transformer = StandardScaler()

categorical_features = ['CHAS', 'RAD']
categorical_transformer = OneHotEncoder(categories='auto')

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)])

OneHotEncoder()handle_unknown 설정

  • error: 숫자로 변환된 분류형 범주에 새로운 문자열 데이터가 들어올 경우 에러를 발생시킴
  • ignore: 카테고리에 해당되는 번호가 없으면 자동으로 0으로 바꿈

Preprocessing-Only #

python
preprocessor_pipe = Pipeline(steps=[('preprocessor', preprocessor)])
  • steps: 전처리 도구를 순서대로 적용 (모델도 입력 가능)

Model Fitting #

python
preprocessor_pipe.fit(x_train)

x_train_transformed = preprocessor_pipe.transform(x_train)
x_test_transformed = preprocessor_pipe.transform(x_test)
  • Numeric Variables에 대한 11개의 열,
    Categorical Variables에 대한 2개의 열,
    카테고리 별 One-Hot Encoding이 적용된 9개의 열을 함께 표시
  • Pipeline을 통해 전처리를 진행할 경우 데이터를 원래대로 되돌리는 inverse_trasnform 불가능

Preprocessing + Training #

python
from sklearn.ensemble import GradientBoostingClassifier

model = Pipeline(steps=[('preprocessor', preprocessor),
                        ('classifier', GradientBoostingClassifier(n_estimators=200, random_state=0))])
  • Preprocessing과 Training을 같이 묶을 경우 다른 모델을 끼워넣기 어려움
  • 위 단점 떄문에 전처리만을 사용하는 것을 권장

Preprocessing + Training + HPO #

python
model = Pipeline(steps=[('preprocessor', preprocessor),
                        ('classifier', GradientBoostingClassifier())])

param_grid = {
    'classifier__loss': ['deviance', 'exponential'],
    'classifier__learning_rate': [0.01, 0.001],
    'classifier__n_estimators': [200, 400],
    'classifier__min_samples_split': [2, 4],
    'classifier__max_depth': [2, 4],
    'classifier__random_state': [0]
}

grid_search = GridSearchCV(model, param_grid,
                           refit=True, cv=3, n_jobs=1, verbose=1, scoring= 'accuracy')

[AI SCHOOL 5기] 머신 러닝 실습 - Model Stacking

Model Stacking #

  • 서로 다른 모델들을 모으고 Ensemble 기법을 사용해 개선된 모델을 만드는 것
  • 기존 모델들로부터 예측 결과를 도출하는 1st Stage
    이를 기반으로 추가적인 판단을 진행하는 2nd Stage로 나뉨

1st Stage #

  1. train_X를 가지고 1번 모델을 Training
  2. Training을 거친 1번 모델에 train_X를 넣었을 때 결과(예측값)을 저장
  3. 다른 모델에도 동일한 작업을 했을 때 나온 1열의 예측값들을 묶어 S_train을 생성 (기존 Ensemble은 S_train을 행별로 투표해서 분류함)

2nd Stage #

  1. 새로운 모델 생성 (1st Stage에서 사용한 것과 다른 모델 사용 가능)
  2. S_train_X, train_Y를 가지고 새로운 모델을 Training

Test Model #

  1. test_X를 1st Stage 모델에 넣고 결과로 나온 예측값들의 묶음 S_test를 생성 (2nd Stage 모델의 학습 데이터는 원본 데이터와 다르기 때문에 test_X를 바로 넣으면 안됨)
  2. S_train_X, train_Y를 2nd Stage 모델에 넣었을 때 결과를 가지고 Accuracy 계산

Functional API #

Import Library #

python
from vecstack import stacking

1st Level Models #

python
models = [
    ExtraTreesClassifier(random_state = 0, n_jobs = -1, n_estimators = 100, max_depth = 3),
    RandomForestClassifier(random_state = 0, n_jobs = -1, n_estimators = 100, max_depth = 3),
    XGBClassifier(seed = 0, n_jobs = -1, learning_rate = 0.1, n_estimators = 100, max_depth = 3)]

Stacking #

python
S_train, S_test = stacking(models,
                           X_train, y_train, X_test,
                           regression = False,
                           metric = accuracy_score,
                           n_folds = 4, stratified = True, shuffle = True,
                           random_state = 0, verbose = 2)
  • S_train과 S_test를 같이 생성 (y_test는 2차 모델 성능 평가에서만 사용)
  • metric: Focus를 맞출 대상

2nd Level Model #

python
model = XGBClassifier(seed = 0, n_jobs = -1, learning_rate = 0.1, n_estimators = 100, max_depth = 3, eval_metric='mlogloss')

model = model.fit(S_train, y_train)

y_pred = model.predict(S_test)
  • accuracy_score(y_test, y_pred)를 확인하여 모델의 성능 평가

Scikit-learn API #

Import Library #

python
from vecstack import StackingTransformer

1st Level Estimators #

python
estimators = [
    ('ExtraTrees', ExtraTreesClassifier(random_state = 0, n_jobs = -1, n_estimators = 100, max_depth = 3)),
    ('RandomForest', RandomForestClassifier(random_state = 0, n_jobs = -1, n_estimators = 100, max_depth = 3)),
    ('XGB', XGBClassifier(seed = 0, n_jobs = -1, learning_rate = 0.1, n_estimators = 100, max_depth = 3, eval_metric='mlogloss'))]
  • stacking과 다르게 모델 이름과 모델 객체를 같이 튜플로 묶음

StackingTransformer #

python
stack = StackingTransformer(estimators,
                            regression = False,
                            metric = accuracy_score,
                            n_folds = 4, stratified = True, shuffle = True,
                            random_state = 0, verbose = 2)
  • stacking과 다르게 x data와 y data를 입력하지 않고 객체 자체를 모델처럼 사용

Model Fitting #

python
stack = stack.fit(X_train, y_train)

S_train = stack.transform(X_train)
S_test = stack.transform(X_test)
  • stacking은 새로운 데이터를 넣을 때 어려움이 있지만,
    StackingTransformer는 전처리 도구처럼 사용 가능

2nd Level Estimator #

python
model = XGBClassifier(seed = 0, n_jobs = -1, learning_rate = 0.1,n_estimators = 100, max_depth = 3, eval_metric='mlogloss')
model = model.fit(S_train, y_train)

y_pred = model.predict(S_test)

[AI SCHOOL 5기] 머신 러닝 실습 - PCA

Principal Component Analysis #

  • 차원 축소를 통해 최소 차원의 정보로 원래 차원의 정보를 모사하는 알고리즘
  • 데이터의 열의 수가 많아 학습 속도가 느려질 때 열의 수를 줄이기 위해 사용
  • Dimension Reduction: 고차원 벡터에서 일부 차원의 값을 모두 0으로 만들어 차원을 줄임
  • 원래의 고차원 벡터의 특성을 최대한 살리기 위해 가장 분산이 높은 방향으로 회전 변환 진행
  • 전체 데이터를 기반으로 분산이 가장 큰 축을 찾아 PC 1으로 만들고,
    PC 1에 직교하는 축 중에서 분산이 가장 큰 축을 PC 2로 만드는 과정 반복
  • 정보의 누락이 있기 때문에 경우에 따라 모델의 성능 하락 발생
  • Feature Selection: 기존에 존재하는 열 중에 n개를 선택
  • Feature Extraction: 기존에 있는 열들을 바탕으로 새로운 열들을 만들어냄 (차원 축소)

Learning Process #

Import Libraries #

python
from sklearn import decomposition
from sklearn import datasets

Load Model #

python
iris = datasets.load_iris()
x = iris.data
y = iris.target

Create Model #

python
model = decomposition.PCA(n_components=1) 
  • component의 개수에 상관없이 PC 1은 언제나 동일

Model Fitting #

python
model.fit(x)
x1 = model.transform(x)

Plot Model #

Histogram (components=1) #

python
import seaborn as sns

sns.distplot(x1[y==0], color="b", bins=20, kde=False)
sns.distplot(x1[y==1], color="g", bins=20, kde=False)
sns.distplot(x1[y==2], color="r", bins=20, kde=False)

plt.xlim(-6, 6)

plt.show()

histogram

[AI SCHOOL 5기] 머신 러닝 실습 - K-Means

1. K-Means Algorithm #

  • K는 전체 데이터를 몇 개의 그룹으로 묶어낼 것인지 결정하는 상수
  • 어떤 K 값이 적절한 것인지 파악하는 것이 중요
  • 각각의 데이터마다 중심값까지의 거리를 계속 물어보기 때문에 계산량이 많음
  • 클러스터링 성능을 향상시키기 위해 GPU Accelerated t-SNE for CUDA 활용

Clustering Process #

  1. K개의 임의의 중심값을 선택
  2. 각 데이터마다 중심값까지의 거리를 계산하여 가까운 중심값의 클러스터에 할당
  3. 각 클러스터에 속한 데이터들의 평균값으로 각 중심값을 이동
  4. 데이터에 대한 클러스터 할당이 변하지 않을 때까지 2와 3을 반복

2. Learning Process #

Model Fitting #

python
from sklearn import cluster

kmeans = cluster.KMeans(n_clusters=2, random_state=0).fit(X) 
  • kmeans.labels_: 클러스터 번호
  • kmeans.cluster_centers_: 학습이 끝난 중심값

Model Predict #

python
kmeans.predict([[0, 0], [8, 4]]))
  • 각각의 번호가 어떤 클러스터에 속하는지 예측

3. K-Means for Iris Data #

Import Libraries #

python
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

from sklearn import cluster
from sklearn import datasets
from sklearn import metrics
  • Axes3D: 3D 공간에서 시각화하는 함수

Model Fitting #

python
estimators = [('k=8', cluster.KMeans(n_clusters=8)),
              ('k=3', cluster.KMeans(n_clusters=3)),
              ('k=3(r)', cluster.KMeans(n_clusters=3, n_init=1, init='random'))]

Plot Model #

python
fignum = 1
titles = ['8 clusters', '3 clusters', '3 clusters, bad initialization']

for name, est in estimators:
    fig = plt.figure(fignum, figsize=(7, 7))
    ax = Axes3D(fig, elev=48, azim=134)
    est.fit(X)
    labels = est.labels_

    ax.scatter(X[:, 3], X[:, 0], X[:, 2], c=labels.astype(np.float), edgecolor='w', s=100)

    ...
    
    fignum = fignum + 1

plt.show()
  • plt.figure(fignum): plot을 여러 개 생성 (subplot()은 하나의 plot을 분리)
  • Axes3D(elev, azim): elevation (축의 고도), azimuth (방위각)
  • astype: 색깔 칠해주는 옵션
  • edgecolor: 테두리
kmeans-1kmeans-2kmeans-3
  • 1번 모델은 8개의 클러스터로 나눈 모델 (불필요하게 세분화시킴)
  • 3번 모델은 초기 중앙값을 랜덤으로 잡아서 특정 클러스터에 데이터가 몰림

Ground Truth (원본) #

python
fig = plt.figure(figsize=(7, 7))
ax = Axes3D(fig,  elev=48, azim=134)

for name, label in [('Setosa', 0), ('Versicolour', 1), ('Virginica', 2)]:
    ax.text3D(X[y == label, 3].mean(), X[y == label, 0].mean(), X[y == label, 2].mean()+2, 
              name, horizontalalignment='center')

ax.scatter(X[:, 3], X[:, 0], X[:, 2], c=y, edgecolor='w', s=100)

...

plt.show()

4. 최적의 클러스터 개수 #

최적의 클러스터 기준 #

  1. 같은 클러스터에 있는 데이터끼리 뭉쳐 있음
  2. 서로 다른 클러스터에 있는 데이터끼리 멀리 떨어져 있음

Elbow 기법 #

  • SSE(Sum of Squared Errors)의 값이 점점 줄어들다가 어느 순간
    줄어드는 비율이 급격하게 작아지는 부분이 발생
  • 결과물인 그래프 모양을 보면 팔꿈치에 해당하는 부분이 최적의 클러스터 개수가 됨
python
def elbow(X):
    total_distance = []
    for i in range(1, 11):
        model = cluster.KMeans(n_clusters=i, random_state=0)
        model.fit(X)

        total_distance.append(model.inertia_) 

    plt.plot(range(1, 11), total_distance, marker='o')
    plt.xlabel('# of clusters')
    plt.ylabel('Total distance (SSE)')
    plt.show()

elbow(X)
  • model.inertia_: 샘플에 대해 가장 가까운 클러스터와의 거리 제곱의 합
  • inertia 값은 클러스터 수가 늘어날수록 감소
  • 같은 클러스터에 있는 데이터끼리 뭉쳐있는 정도만 확인 가능

elbow

[AI SCHOOL 5기] 머신 러닝 실습 - Kernelized SVM

Support Vector Machine #

  • 패턴 인식을 위한 지도 학습 모델
  • 데이터를 분류하는 Margin을 최대화하는 결정 경계(Decision Boundary)를 찾는 기법
  • 결정 경계와 가장 가까운 데이터를 가로지르는 선을 기준으로 Plus & Minus Plane 설정
  • Support Vector: 결정 경계와 가장 가까운 데이터의 좌표
  • Margin: b11(plus-plane)과 b12(minus-plane) 사이의 거리, 2/w
  • 기존의 Hard Margin SVM은 소수의 Noise로 인해 결정 경계를 찾지 못할 수 있음
  • Plus & Minus Plane에 약간의 여유 변수를 두어 에러를 무시하는 Soft Margin SVM로 발전

arg min #

$$arg\ min\lbrace\frac{1}{2}{||w||}^2+C\Sigma^n_{i=1}\xi_i\rbrace$$ $$\text{단, }y_i({w}\cdot{x_i}-b)\ge{1-\xi_i},\quad{\xi_i\ge{0}},\quad{\text{for all }1\le{i}\le{n}}$$

[AI SCHOOL 5기] 머신 러닝 실습 - KNN

K-Nearest Neightbor Algorithm #

  • 기존의 가까운 이웃 데이터를 살펴 새로운 데이터를 분류하는 알고리즘
  • K=3일 경우, 가장 가까운 나머지 3개 중 2개가 Red면 Red로 판단
  • K 값이 작아질수록 아주 작은 영향에로 판단이 바뀌는 Overfitting 발생
  • K 값이 커질수록 멀리보고 결정이 느려져 Overfitting 감소

Learning Process #

Load Data #

python
iris = datasets.load_iris() # 붓꽃 데이터 (150행, 4열)

Select Feature #

python
x = iris.data[:, :2] # [꽃받침 길이, 꽃받침 넓이]
y = iris.target

Create Model #

python
model = neighbors.KNeighborsClassifier(6)

Model Fitting #

python
model.fit(x, y)

Model Predict #

python
model.predict([[9, 2.5], [3.5, 11]]) # 각각의 분류 표시

Plot Model #

Data Points #

python
plt.figure(figsize=(10,5))
plt.scatter(x[:, 0], x[:, 1])
plt.title("Data points")
plt.show()

knn

[AI SCHOOL 5기] 머신 러닝 실습 - Gradient Boosting

XG Boost #

  • Extreme Gradient Boosting
  • 대용량 분산 처리를 위한 Gradient Boosting 라이브러리
  • Decision Tree(의사결정나무)Boosting 기법을 적용한 알고리즘
  • AdaBoost는 학습 성능은 좋으나, 모델의 학습 시간이 오래 걸리는 단점
  • 병렬 처리 기법을 적용하여 Gradient Boost보다 학습 속도를 끌어올림
  • Hyper-Parameter가 너무 많기 때문에 권장 세팅 사용 @ http://j.mp/2PukeTS

Decision Tree #

  • 이해하기 쉽고 해석도 용이함
  • 입력 데이터의 작은 변동에도 Tree의 구성이 크게 달라짐
  • 과적합이 쉽게 발생 (중간에 멈추지 않으면 Leaf 노드에 하나의 데이터만 남게 됨)
  • 의사결정나무의 문제를 해결하기 위해 Boosting 기법 활용
  • ex) 테니스를 쳤던 과거 데이터를 보고 날씨 정보를 이용해 의사결정

AdaBoost #

  • Adaptive Boosting
  • 데이터를 바탕으로 여러 weak learner 들을 반복적으로 생성
  • 앞선 learner가 잘못 예측한 데이터에 가중치를 부여하고 학습
  • 최종적으로 만들어진 strong learner를 이용하여 실제 예측 진행
  • 에러를 최소화하는 weight를 매기기 위해 경사 하강법 사용
  • ex) Regression: 평균/가중평균, Classification: 투표

XG Boost References #


Ensemble #

  • 주어진 데이터를 이용하여 여러 개의 서로 다른 예측 모형을 생성한 후,
    예측 모형의 예측 결과를 종합하여 하나의 최종 예측결과를 도출해내는 방법
  • 다양한 모델이 문제 공간의 다른 측면을 보면서 각기 다른 방식으로 오점이 있다고 가정
    (모델 별로 약점을 보완)

Boosting #

  • weak learner들을 strong learner로 변환시키는 알고리즘
    (약한 학습기를 여러개 사용해서 하나의 강건한 학습기를 만들어내는 것)
  • 의사결정나무 모델을 합리적인 수준(60~70% 성능)에서 여러 종류 생성
  • ex) AdaBoost

Gradient Boosting #

  • 경사 하강법을 사용해서 AdaBoost보다 성능을 개선한 Boosting 기법
  • AdaBoost는 높은 가중치를 가진 지점이 존재하게 되면 성능이 크게 떨어지는 단점
    (높은 가중치를 가진 지점과 가까운 다른 데이터들이 잘못 분류될 가능성이 높음)
  • Gradient Boosting 기법은 이전 모델에 종속적이기 때문에 병렬 처리가 불가능

Bagging #

  • Bootstrap Aggregating
  • 가중치를 매기지 않고 각각의 모델이 서로 독립적
  • x 데이터 열들의 서로 다른 조합으로 독립적인 모델을 여러 종류 생성
  • ex) Random Forest

Random Forest #

  • 각 모델은 서로 다른 샘플 데이터셋을 활용 (Bootstrap Sampling & Bagging)
  • 각 데이터셋은 복원추출을 통해 원래 데이터셋 만큼의 크기로 샘플링 (누락 & 중복 발생)
  • 위 서로 다른 샘플로 각 모델 생성 시, 각 노드 지점마다 x열 n개 중 랜덤하게 m개 중 분기 선택
  • Classification에서는 root n을 m으로 사용
  • Regression에서는 n/3을 m으로 사용
  • @ https://j.mp/3rZ05bN & https://j.mp/3GJ7QqH

Learning Process #

Import Libraries #

python
import numpy as np
import matplotlib.pyplot as plt

from sklearn import ensemble
from sklearn import datasets
from sklearn.utils import shuffle
from sklearn.metrics import mean_squared_error

Load Data #

python
boston = datasets.load_boston()

X, y = shuffle(boston.data, boston.target, random_state=13)
X = X.astype(np.float32)
offset = int(X.shape[0] * 0.9)

X_train, y_train = X[:offset], y[:offset]
X_test, y_test = X[offset:], y[offset:]
  • load 부분에서 다른 데이터도 사용 가능
  • boston.data: x data
  • boston.target: y data
  • int(X.shape[0] * 0.9): 전체 행 중 90 퍼센트 의미
  • boston.feature_names: 데이터셋에서 열 이름
  • boston.DESCR: 데이터에 대한 상세 설명

Model Fitting #

python
params = {'n_estimators': 500, 'max_depth': 4, 'min_samples_split': 2,
          'learning_rate': 0.01, 'loss': 'ls'}
clf = ensemble.GradientBoostingRegressor(**params)

clf.fit(X_train, y_train)
mse = mean_squared_error(y_test, clf.predict(X_test))
print("MSE: %.4f" % mse)

Plot Deviance #

python
test_score = np.zeros((params['n_estimators'],), dtype=np.float64)

for i, y_pred in enumerate(clf.staged_predict(X_test)):
    test_score[i] = clf.loss_(y_test, y_pred)

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.title('Deviance')
plt.plot(np.arange(params['n_estimators']) + 1, clf.train_score_, 'b-',
         label='Training Set Deviance')
plt.plot(np.arange(params['n_estimators']) + 1, test_score, 'r-',
         label='Test Set Deviance')
plt.legend(loc='upper right')
plt.xlabel('Boosting Iterations')
plt.ylabel('Deviance')
  • Deviance: 편차값, 에러
  • n_estimators: 의사결정나무 모델을 몇 개 만들었는지
  • Test Data에 대한 에러 라인이 튕겨올라가는 지점이 Overfitting

deviance

[AI SCHOOL 5기] 머신 러닝 실습 - 로지스틱 회귀

Logistic Regression #

  • 이진 분류(0 또는 1) 문제를 해결하기 위한 모델
  • 다항 로지스틱 회귀(k-class), 서수 로지스틱 회귀(k-class & ordinal)도 존재
  • Sigmoid Function을 이용하여 입력값이 양성 클래스에 속할 확률을 계산
  • 로지스틱 회귀를 MSE 식에 넣으면 지수 함정의 특징 때문에 함정이 많은 그래프가 나옴
  • 분류를 위한 Cost Function인 Cross-Entropy 활용
  • 성능 지표로는 Cross-Entropy 외에 Accuracy 등을 같이 사용
  • ex) 스팸 메일 분류, 질병 양성/음성 분류 등

양성/음성 분류 모델 #

  • 선형 모델은 새로운 데이터가 들어오면 양성/음성 판단 기준이 크게 바뀜
  • 모델을 지수 함수인 Sigmoid Function으로 변경

Sigmoid Function #

  • θ 값에 따라 기울기나 x축의 위치가 바뀌는 지수 함수
  • y축을 이동하는 선형 함수와 다르게 x축을 이동
  • y가 0.5가 되는 지점을 기준으로 대칭되는 형태
  • y값은 조건부 확률로 해석 (X가 있을 때 양성 클래스일 확률값)

Cross-Entropy Function #

  • 예측값의 분포와 실제값의 분포를 비교하여 그 차이를 Cost로 결정
  • 인공신경망에 각 행을 열단위로 쪼개 입력으로 넣었을 때 마지막에 카테고리 개수만큼의 수를 반환
  • Softmax Function을 통과시키면 개수는 그대로지만 합쳤을 때 1이되는 숫자로 변경
  • 인공신경망 결과로 뱉어낸 카테고리별 확률을 정답과 비교해 Cross-Entropy 계산
  • One-Hot Encoding이 적용된 정답을 One-Hot Label이라 부름
  • 정답 확률이 높고 오답 확률이 낮은 모델이 나은 모델
  • Cross-Entropy는 하나의 분포를 다른 분포로 옮겨내는 거리라고도 불림

Softmax Algorithm #

$$S(y_i)=\frac{e^{y_i}}{\Sigma_j{e^{y_i}}}$$

[AI SCHOOL 5기] 머신 러닝

인공지능 #

  • Intelligent Agents를 만드는 것
  • 주변 환경들을 인식하고 원하는 행동을 취하여 목표를 성취하는 것

Artificial Narrow Intelligence #

  • 제한된 기능만 수행할 수 있는 인공지능
  • weak AI

Artificial General Intelligence #

  • 사람만큼 다양한 분야에서 기능을 수행할 수 있는 인공지능
  • strong AI

Artificial Super Intelligence #

  • 모든 분야에서 사람보다 뛰어난 인공지능

모델 #

  • 데이터를 가장 잘 설명할 수 있는 함수 (y = ax + b)
  • 모델에서 θ는 Parameter(가중치, Weight) 의미
  • 모델에서 h(x)는 Hypotheses(가설) 의미
  • 모델에서 b는 Bias(편향, 보정치) 의미

머신러닝 #

  • 어떠한 과제를 해결하는 과정에서 특정한 평가 기준을 바탕으로 학습의 경험을 쌓는 프로그램

머신러닝 분류 #

51p

[AI SCHOOL 5기] 머신 러닝 실습 - 선형 회귀

Linear Regression #

  • 종속 변수 y와 독립 변수 x 사이의 선형 상관 관계를 모델링하는 회귀분석 기법
  • 정답이 있는 데이터의 추세를 잘 설명하는 선형 함수를 찾아 x에 대한 y를 예측
  • Linear Combination (선형 결합): 더하기와 곱하기로만 이루어진 식
  • 단순 회귀분석: 1개의 독립변수(x)가 1개의 종속변수(y)에 영향을 미칠 때
  • 다중 회귀분석: 2개 이상의 독립변수(x)가 1개의 종속변수(y)에 영향을 미칠 때
  • 선형 회귀는 가장 적합한 θ들의 집합을 찾는 것이 목표

Cost Function #

  • 예측 값과 실제 값의 차이를 기반으로 모델의 성능(정확도)을 판단하기 위한 함수
  • Objective (MIN or MAX) 함수 안에 Cost Function이 존재
  • 선형 회귀에서는 Mean Squre(d) Error Function (평균 제곱 오차 함수) 활용
  • MSE(Cost)가 최소가 되는 θ(a & b)를 찾아야하며,
    이를 위한 최적화 기법으로 Gradient Descent Algorithm (경사하강법) 활용

Mean Squre Error Function #

  • 회귀 분석을 위한 Cost Function
  • y축 방향의 차이를 에러로 판단하는데 전체 에러를 단순하게 합칠 경우
    양 에러와 음 에러가 상쇄되어 올바른 판단을 할 수 없음
  • 부호를 제거하기 위해 모든 에러에 제곱을 취하고 그 평균을 구한 것이 MSE
  • MSE(Cost)가 0에 가까울수록 에러가 적다고 판단
  • 값에 제곱을 취하기 때문에 이상치가 있으면 영향을 많이 받아 이상치를 찾아내기 쉬움
  • 제곱 대신에 절댓값을 사용하는 MAE Function은 이상치에 영향을 덜 받음

Gradient Descent Algorithm #

  • Cost Function의 값을 최소로 만드는 θ를 찾아나가는 방법
  • Cost Function의 Gradient(기울기)에 상수를 곱한 값을 빼서 θ를 조정
  • 어느 방향으로 θ를 움직이면 Cost가 작아지는지 현재 위치에서 함수를 미분하여 판단
  • 변수(θ)를 움직이면서 전체 Cost 값이 변하지 않거나 매우 느리게 변할 때까지 접근
  • MSE를 미분했을 때 0이 나오는 지점을 찾아도 되지만, 빅데이터에서 x 데이터 역행렬이 오래걸림
  • 그래프 중간에 함정처럼 페인 부분을 Local Minima라 부름 (목표점은 Global Minima)
  • 가던 방향에서 조금 더 가는 발전된 Gradient Descent 기법을 통해 함정을 빠져나감
  • Local Minima도 Global Minima와 비슷하게 떨어지기 때문에 에러가 적음

$$\text{repeat until convergence}\ { \theta_j:=\theta_j-{\alpha}\frac{\delta}{\delta\theta_j}J(\theta_0,\theta_1)\quad(\text{for}j=0\text{and}j=1) }$$