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

import tensorflow as tf
from keras.backend.tensorflow_backend import set_session
# tf.compat.v1.disable_eager_execution()

# config = tf.compat.v1.ConfigProto()
# config.gpu_options.per_process_gpu_memory_fraction = 0.1
# set_session(tf.compat.v1.Session(config=config))


config = tf.compat.v1.ConfigProto()
config.gpu_options.per_process_gpu_memory_fraction = 0.1
tf.compat.v1.keras.backend.set_session(tf.compat.v1.Session(config=config))

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

'''
위스콘신 유방암 데이터
이 데이터는 악성(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()

# 연속형 피처 선택 알고리즘
'''
SBS(Sequential Backward Selection) : 계산상 효율을 위해 초기 피처 부분 공간의 차원을 축소시킬 때
분류기 성능이 무너지는 것을 최소화하는 것을 목표로 한다.
'''
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']

from sklearn.cross_validation import train_test_split
X, y = df_wine.iloc[:, 1:].values, df_wine.iloc[:, 0].values

from sklearn.base import clone
from itertools import combinations
import numpy as np
from sklearn.cross_validation import train_test_split
from sklearn.metrics import accuracy_score
class SBS():
    def __init__(self, estimator, k_features, scoring=accuracy_score,
                 test_size=0.25, random_state=1):
        self.scoring = scoring
        self.estimator = clone(estimator)
        self.k_features = k_features
        self.test_size = test_size
        self.random_state = random_state

    def fit(self, X, y):
        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=self.test_size,
                                                            random_state=self.random_state)
        dim = X_train.shape[1]
        #print('dim:\n', dim)
        self.indices_ = tuple(range(dim))
        #print('self.indices:\n', self.indices_)
        self.subsets_ = [self.indices_]
        #print('self.subsets:\n', self.subsets_)
        score = self._calc_score(X_train, y_train, X_test, y_test, self.indices_)
        #print('score:\n', score)
        self.scores_ = [score]

        while dim > self.k_features:
            scores = []
            subsets = []

            for p in combinations(self.indices_, r=dim-1):
                score = self._calc_score(X_train, y_train, X_test, y_test, p)
                scores.append(score)
                subsets.append(p)
                best = np.argmax(scores)
                self.indices_ = subsets[best]
                self.subsets_.append(self.indices_)
                dim -= 1

                self.scores_.append(scores[best])
                #print('self.scores_:\n', self.scores_)
            self.k_score_ = self.scores_[-1]

            return self

    def transform(self, X):
        return X[:, self.indices_]

    def _calc_score(self, X_train, y_train, X_test, y_test, indices):
        self.estimator.fit(X_train[:, indices], y_train)
        y_pred = self.estimator.predict(X_test[:, indices])
        score = self.scoring(y_test, y_pred)
        return score

from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
knn = KNeighborsClassifier(n_neighbors=2)
sbs = SBS(knn, k_features=1)
sbs.fit(X_train_std, y_train)
#print('sbs.subsets_:\n', sbs.subsets_)
k_feat = [len(k) for k in sbs.subsets_]
plt.plot(k_feat, sbs.scores_, marker='o')
plt.ylim([0.7, 1.1])
plt.ylabel('Accuracy')
plt.xlabel('Number of features')
plt.grid()
plt.show()

k5 = list(sbs.subsets_[8])
#print('k5:\n', k5)
print('df_wine.columns[1:][k5]:\n', df_wine.columns[1:][k5])

knn.fit(X_train_std, y_train)
print('Training accuracy:', knn.score(X_train_std, y_train))
print('Test accuracy:', knn.score(X_test_std, y_test))

knn.fit(X_train_std[:, k5], y_train)
print('Training accuracy:', knn.score(X_train_std[:, k5], y_train))
print('Test accuracy:', knn.score(X_test_std[:, k5], y_test))

#### 랜덤 포레스트를 활용한 피처 중요도의 평가
'''
랜덤 포레스트를 사용하면 데이터가 선형적으로 분리 가능한지 여부와 상관없이
포레스트 내의 모든 의사결정나무로부터 계산된 평균 불순도 감소분으로 피처의 중요도를 측정할 수 있다.
나무 기반의 모델은 표준화나 정규화가 필요하지 않다는 것을 기억하자.
'''
from sklearn.ensemble import RandomForestClassifier
feat_labels = df_wine.columns[1:]
forest = RandomForestClassifier(n_estimators=10000, random_state=0, n_jobs=-1)
forest.fit(X_train, y_train)
importances = forest.feature_importances_
indices = np.argsort(importances)[::-1]
for f in range(X_train.shape[1]):
    print("%2d) %-*s %f" % (f+1, 30, feat_labels[f], importances[indices[f]]))

plt.title('Feature Importances')
plt.bar(range(X_train.shape[1]), importances[indices], color='lightblue', align='center')
plt.xticks(range(X_train.shape[1]), feat_labels, rotation=90)
plt.xlim([-1, X_train.shape[1]])
plt.tight_layout()
plt.show()

X_selected = forest.transform(X_train, threshold=0.15)
print('X_selected.shape:\n', X_selected.shape)

https://hunkim.github.io/ml/

모두를 위한 머신러닝과 딥러닝의 강의

알파고와 이세돌의 경기를 보면서 이제 머신 러닝이 인간이 잘 한다고 여겨진 직관과 의사 결정능력에서도 충분한 데이타가 있으면 어느정도 또는 우리보다 더 잘할수도 있다는 생각을 많이 하게 되었습니다. Andrew Ng 교수님이 말씀하신것 처럼 이런 시대에 머신 러닝을 잘 이해하고 잘 다룰수 있다면 그야말로 "Super Power"를 가지게 되는 것이 아닌가 생각합니다.

더 많은 분들이 머신 러닝과 딥러닝에 대해 더 이해하고 본인들의 문제를 이 멋진 도구를 이용해서 풀수 있게 하기위해 비디오 강의를 준비하였습니다. 더 나아가 이론에만 그치지 않고 최근 구글이 공개한 머신러닝을 위한 오픈소스인 TensorFlow를 이용해서 이론을 구현해 볼수 있도록 하였습니다.

수학이나 컴퓨터 공학적인 지식이 없이도 쉽게 볼수 있도록 만들려고 노력하였습니다.

 시즌 RL - Deep Reinforcement Learning

비디오 리스트 (일주일에 한강좌씩 천천이 업데이트 예정입니다.)

• Lecture 1: 수업의 개요 비디오  강의 슬라이드 
• Lecture 2: OpenAI GYM 게임해보기 비디오  강의 슬라이드 
• Lab 2: OpenAI GYM 게임해보기 실습 비디오  실습슬라이드 
• Lecture 3: Dummy Q-learning (table) 비디오  강의 슬라이드 
• Lab 3: Dummy Q-learning (table) 비디오  실습슬라이드 
• Lecture 4: Q-learning exploit&exploration and discounted reward 비디오  강의 슬라이드 
• Lab 4: Q-learning exploit&exploration and discounted reward 비디오  실습슬라이드 
• Lecture 5: Q-learning in non-deterministic world 비디오  강의 슬라이드 
• Lab 5: Q-learning in non-deterministic world 비디오  실습슬라이드 
• Lab 5-1: Q-learning web Demo 비디오 
• Lecture 6: Q-Network 비디오  강의 슬라이드 
• Lab 6-1: Q Network for Frozen Lake 비디오  실습슬라이드 
• Lab 6-2: Q Network for Cart Pole 비디오  실습슬라이드 
• Lecture 7: DQN 비디오  강의 슬라이드 
• Lab 7-1: DQN 1 (NIPS 2013) 비디오  실습슬라이드 
• Lab 7-2: DQN 2 (Nature 2015) 비디오  실습슬라이드 
• Lab 7-3: DQN Cart Pole Demo 비디오 
• Lab 7-4: DQN Simple Pacman Demo (여러분은 최고 몇점까지 갈수 있나요?) 비디오 

시즌 NLP - Deep NLP

(시즌 RL이 끝나는 2017년 4~5월경에 업데이트 예정입니다.)

• Lec 0: 수업의 개요 비디오  슬라이드 
• Bot lab1-1: API.ai의 개념 비디오 
• Bot lab1-2: API.ai 사용해보기 비디오 

시즌 1 - 딥러닝의 기본 (TF 1.0 lab 업데이트중) 비디오 리스트

• 수업에 사용하는 코드 https://github.com/hunkim/DeepLearningZeroToAll
• 수업의 개요 비디오  슬라이드 
• 머신러닝의 개념과 용어 비디오  (TensorFlow의 기본 Lab 비디오 ) 강의 슬라이드  Lab 슬라이드 
• Linear Regression 의 개념 비디오  (TensorFlow 로 구현 Lab 비디오 ) 슬라이드 
• Linear Regression cost함수 최소화 비디오  (TensorFlow 로 구현 Lab 비디오 ) 슬라이드 
• 여러개의 입력(feature)의 Linear Regression 비디오  (TensorFlow 로 구현 Lab 비디오 ) 슬라이드 
• Logistic (Regression) Classification 슬라이드 
• Hypothesis 함수 소개 비디오 
• Cost 함수 소개 비디오 
• TensorFlow에서의 구현 비디오 
• Softmax Regression (Multinomial Logistic Regression) 슬라이드 
• Multinomial 개념 소개 비디오 
• Cost 함수 소개 비디오 
• TensorFlow에서의 구현 비디오 
• ML의 실용과 몇가지 팁 슬라이드 
• 학습 rate, Overfitting, 그리고 일반화 (Regularization) 비디오 
• Training/Testing 데이타 셋 비디오 
• TensorFlow에서의 구현 (학습 rate, training/test 셋으로 성능평가) 비디오 
• 딥러닝의 기본 개념과, 문제, 그리고 해결 슬라이드 
• 딥러닝의 기본 개념: 시작과 XOR 문제 비디오 
• 딥러닝의 기본 개념2: Back-propagation 과 2006/2007 '딥'의 출현 비디오 
• 실습비디오 없음
• Neural Network 1: XOR 문제와 학습방법, Backpropagation (1986 breakthrough) 강의 슬라이드  실습 슬라이드 
• XOR 문제 딥러닝으로 풀기 비디오 
• 특별편: 10분안에 미분 정리하기 비디오 
• 딥넷트웍 학습 시키기 (backpropagation) 비디오 
• 실습1: XOR을 위한 텐스플로우 딥넷트웍 비디오 
• 실습2: Tensor Board로 딥네트웍 들여다보기 비디오 
• Neural Network 2: ReLU and 초기값 정하기 (2006/2007 breakthrough) 강의 슬라이드  실습 슬라이드 
• XSigmoid 보다 ReLU가 더 좋아 비디오 
• Weight 초기화 잘해보자 비디오 
• Dropout 과 앙상블 비디오 
• 레고처럼 넷트웍 모듈을 마음껏 쌓아 보자 비디오 
• 실습: 딥러닝으로 MNIST 98%이상 해보기 비디오 
• Convolutional Neural Networks 강의 슬라이드  실습 슬라이드 
• ConvNet의 Conv 레이어 만들기 비디오 
• ConvNet Max pooling 과 Full Network 비디오 
• ConvNet의 활용예 비디오 
• 실습: ConvNet을 TensorFlow로 구현하자 (MNIST 99%) 비디오 
• Recurrent Neural Network 강의 슬라이드  실습 슬라이드 
  • NN의 꽃 RNN 이야기 비디오 
  • 실습: TensorFlow에서 RNN 구현하기 비디오 
• [보너스] Deep Deep Network AWS 에서 GPU와 돌려보기 (powered by AWS) 실습 슬라이드  비디오 
• [보너스2] AWS에서 저렴하게 Spot Instance를 터미네이션 걱정없이 사용하기 (powered by AWS) 실습 슬라이드  비디오 
• [보너스3] Google Cloud ML을 이용해 TensorFlow 실행하기 실습 슬라이드  비디오 (한글)  비디오 (영어) 

Acknowledgement

이 비디오는 저도 인터넷등을 통해 공부하면서 만든것이며 아래 자료를 많이 사용하였습니다.

• Andrew Ng’s and other ML tutorials
• https://class.coursera.org/ml-003/lecture
• http://www.holehouse.org/mlclass/ (note)
• Deep Learning Tutorial
• Andrej Karpathy's Youtube channel
• 동국대 홍정모 교수님의 C++로 배우는 딥러닝
• Lecture Videos
• CS231n: Convolutional Neural Networks for Visual Recognition
• CS224d: Deep Learning for Natural Language Processing
• Tensorflow
• https://www.tensorflow.org
• TensorFlow Tutorials (Simple Examples)
• Another TensorFlow Tutorials
• TensorFlow Examples
• Deep learning @Udacity

의견주기

비디오나 강의에 대한 의견이 있으시면 아래로 이메일을 보내 주시면 됩니다. 홍콩과기대 김성훈

이번에는 선형대수학(Linear algebra)에 대해서 공부를 합니다.

이름은 거창하지만 실제로는 더하기, 곱하기 이런 기본 산수 수준인데 단지 다른 것은 알고리즘을 사용하기 위해서 필요한 행렬과 벡터 위주로 다루고 있습니다.

행렬이나 벡터도 이름만 거창하지 실제로는 여러번 산수해야하는 것을 한번에 산수하면 되도록 해주는 도구라고 생각하면 될 것 같습니다. 알아두면 매우 유용한 면이 많아 보이는 내용입니다.

예를 들어서, 1+1, 1+2, 1+3을 한다고 생각해보겠습니다.

단순한 더하기를 3번 수행해야 하는데, 행렬이나 벡터를 이용하면 더하기 1번에 3개의 결과를 얻어낼수 있는 효과가 있을 뿐이지 더하기는 동일합니다.

행렬(Matrix)

사각형 모양안에 숫자들을 나열해 놓은 형태로 아래 그림과 같이 표기가 됩니다.

이 숫자들은 행(rows)과 열(columns)로 구분이 가능합니다. 그래서 전체를 하나로 표기할 수도 있고 내부에 숫자들을 각각 표기할 수도 있게 됩니다. 

Matrix를 표기할 때 4 x 2와 같이 표기를 합니다. 그냥 4개의 행과 2개의 열로 이루어진 Matrix이며 4 by 2라고 읽습니다.

아래 그림에서는 R로 Matrix의 이름을 표현했고 4x2의 숫자를 갖는 매트릭스를 보여주고 있습니다. 그리고 그 오른쪽에는 2x3의 다른 Matrix를 표현하고 있는 것입니다.

Matrix는 여러 숫자들을 가지고 있고 각자의 자리가 있기 때문에 개별적으로 요소들도 표기가 가능합니다.

아래 그림의 A라는 Matrix는 4x2의 크기를 갖고 있으며 총 8개의 숫자를 표현하고 있습니다.

A11은 1번째 행의 1번째 열의 자리에 있는 숫자를 표현합니다. 그래서 A11의 값은 1402가 됩니다.

A32는 3번째 행의 2번째 열의 자리에 있는 숫자를 표현하는 것이니 값이 1437이 되겠지요

그런데 A43은 4번째 행의 3번째 열의 자리를 찾는데 3번째 열이 없기 때문에 error가 됩니다. 존재하지 않는 값을 찾고 있기에 오류이지요

벡터(Vector)

Vector는 행렬과 비슷하게 생겼지만 다른 점은 열(column)이 1개만 존재하는 형태라는 것입니다. 그래서 항상 한줄로만 표기가 됩니다. 즉, n x 1의 matrix 이면서 vector가 되는 것입니다.

아래 그림에서는 Vector를 y로 표기하였습니다.

마찬가지로 각 숫자들은 지정 좌석이 있기 때문에 y1은 1번째 자리의 460의 값을 표현할 수 있게 됩니다.

1번째 자리수는 0번부터 시작할 수도 있고 1번부터 시작할 수도 있습니다.

이것은 사용하는 program에 따라 다를 수 있습니다. 일반적인 java와 c 같은 프로그램에서는 배열을 보통 0부터 표현을 하기도 하며 (0-indexed), 이 강좌에서는 1부터 표현하는 것으로 교수님께서 설명을 하고 계십니다. (1-indexed)

4개의 숫자이므로 0-indexed에서는 y0, y1, y2, y3으로 표현이 되고, 1-indexed에서는 y1, y2, y3, y4로 표현이 되는 차이만 있을뿐입니다.

Matrix Addition(행렬 더하기)

Matrix와 Vector의 정의를 알았으니 이제 더하는 방법을 알아봅니다.

두개의 Matrix를 더하는 것은 같은 자리의 숫자를 더해서 새로운 Matrix를 만들어 내는 것입니다.

아래 그림에서 3x2 Matrix+ 3x2 Matrix를 하면 같은 사이즈를 가지는 3x2 Matrix가 생성된다는 것을 보여주고 있습니다.

같은 자리의 수인 1 + 4 = 5,  0 + 0.5 = 0.5,  2 + 2 = 4와 같이 더하기가 되는 것을 알 수 있습니다.

그 밑에 있는 3x2 Matrix + 2x2 Matrix는 왜 error가 될까요? 숫자들의 자리가 맞지 않으니 더할 수 있는 값이 없어서 입니다. 그러므로 같은 크기의 Matrix끼리만 연산이 된다는 결과가 나타납니다.

Scalar Multiplication ( Matrix 곱하기 상수)

Scalar는 상수를 의미합니다. 이 상수를 Matrix에 곱하는 것이 가능합니다. 같은 크기의 Matrix가 아니지만 각각의 숫자들에 동일하게 적용시켜주면 됩니다.

아래 그림에서 Matrix에 3을 곱해주면 각 자리에 위치한 모든 숫자들에 3을 곱해서 기존 Matrix의 크기와 같은 Matrix가 생성이 되는 모습입니다. 앞에서 곱해주나 뒤에서 곱해주나 같은 결과가 나옵니다. 산수와 같죠?

그 밑에 쪽에 나누기도 동일하게 적용을 해주면 연산이 가능합니다.

지금까지 알아본 더하기와 곱하기를 혼합해서 연산을 하면 아래 그림과 같이 됩니다.

곱하기와 나누기를 먼저 계산하고 그 결과를 더하기와 빼기를 수행합니다. 이것도 산수와 똑같습니다.

Matrix X Vector (Matrix 곱하기 Vector)

Matrix와 Vector를 곱하면 어떻게 될까요

각각 크기를 가지고 있으므로 곱하기가 되는 대상에 주의를 해야 합니다.

아래 그림은 기본적인 곱하기에 대한 특성을 보여주고 있습니다. A Matrix의 크기가 m x n이라고 할 경우에 x Vector의 크기는 n x 1이 되어야 한다 입니다. 같은 사이즈의 n이 되어야 곱하기를 할 수 있다는 뜻이됩니다. 이렇게 곱하기를 한 결과는 m의 크기를 갖는 Vector가 됩니다. 그럼 어떻게 곱하기가 되는지 예제를 보면 쉽습니다.

A Matrix는 3x4의 크기를 가지고 있습니다. 4개의 columns를 가지고 있고 곱하고자 하는 x Vector는 4x1의 크기를 가지고 4개의 rows를 가집니다. 곱하기를 하는 방법은 A Matrix의 가로줄과 x라는 이름의 Vector의 세로줄을 곱해주고 이 값들을 모두 더해줍니다 . 

A11 * x1 + A12 * x2 + A13 * x3 + A14 * x4와 같이 연산이 되어 결국 값은

1*1 + 2*3 + 1*2 + 5*1   = 1 + 6 + 2 + 5   = 14 값이 되는 것입니다.

결과 값을 차례대로 Vector 형식으로 적어주면 m개의 크기를 갖는 결과 Vector가 생성이 됩니다.

이와 같이 연산이 되기에 Matrix의 가로 크기와 Vector의 세로 크기가 같아야 하겠습니다. 그리고 그 결과는 Matrix 의 세로 크기와 같은 크기를 갖는 Vector로 만들어집니다.

복잡한 식도 심플하게 변형 (kind of trick)

Matrix의 연산에 특성을 이용하면 복잡한 계산식을 심플하게 표현할 수 있게 됩니다. 이것은 parameters이 많아질수록 더욱 효과적으로 표현이 가능해지는 장점을 가지고 있습니다. 우리가 앞으로 다뤄야 하는 dataset이 아주 많은 데이터 parameters들을 가지고 있기 때문에 이를 활용하는 것에 익숙해져야 하기 때문입니다.

이전에 본적이 있는 일차방정식으로 표현이 된 h 함수입니다. 두개의 parameters를 가지고 있고 곱하기와 더하기로 표현이 되고 있습니다. 이것을 Matrix로 표현을 하면 아래쪽에 있는 그림과 같이 표현이 가능합니다.

세타zero로 표현했던 -40의 값은 상수이기 때문에 1을 곱해줘도 같은 값을 가질 수 있습니다. 세타one으로 표현했던 0.25의 값은 x와 곱해지는 인수임을 유의해서 아래 그림을 보면 됩니다.

h 함수는 집의 사이즈에 따른 집의 가격을 나타내는 공식이였습니다. x는 집의 사이즈 데이터가 되고 h는 그 사이즈에 해당하는 집의 가격을 나타냈었습니다. 이 공식에 의하면 집의 사이즈에 0.25를 곱하고 -40을 더하면 집에 가격이 된다고 합니다. 이것을 Matrix로 아래와 같이 변환해서 계산을 해보면 일차방정식과 동일한 결과가 된다는 것을 알 수 있습니다.

h 함수는 다음과 같이 표현이 가능하게 되고

h = -40 * 1 + 0.25 * x

그리고 이것은 다음과 같은 행렬의 곱으로 표현이 가능합니다.

h = [-40, 0.25] * [1, x]

이러한 원리로 분리해서 만들어낸 것입니다. (2번째 Vector를 세로로 써야 맞는데...)

아래 그림에서는 곱하는 순서만 바뀌었을 뿐이지 같은 방식의 곱하기를 나타내고 있습니다.

결국 이렇게 Matrix를 이용하면 어떻게 되는가 하면, h 함수가 다음과 같이 심플해지게 됩니다.

h = Xa (X : Matrix, a : Vector) 

상수들이 Vector가 되면서 곱하기로만 표현이 됩니다. 여기서 주의할 것은 X Matrix의 columns의 수와 a Vector의 rows 수가 같아야 연산이 된다는 것입니다.

Matrix x Matrix (Matrix 곱하기)

Matrix 끼리의 곱셈입니다. column만 늘어나는 것이고 연산은 동일합니다.

아래 그림은 m x n Matrix와 n x o Matrix를 곱하면 m x o Matrix가 결과가 된다는 것을 이야기 합니다.

아래 그림은 예를들어서 설명을 하고 있습니다.

앞에 Matrix의 가로줄과 뒤에 Matrix의 세로줄의 수들을 곱하고 그결과를 더해서 나온 값이 결과 Matrix가 됩니다.

즉, 1번째 row와 1번째 column이 연산되어, 결과 Matrix의 1번째 row와 1번째 column의 자리에 위치하는 값이 되는 것입니다.

다수의 공식도 심플하게 변형 (kind of trick)

다시 h 함수로 돌아가보겠습니다.

아까전에는 parameters를 심플하게 표현했었는데 이번에는 여러개의 h 함수를 표현해보려 합니다.

머신러닝에서 우리의 목표는 cost가 가장 적은(0에 가까운) h 함수의 찾아내는 것이였습니다.

그러기 위해서 parameters를 동시에 업데이트 해가면서 cost를 산출하고 목표를 향해 갔었습니다.

parameters가 변경되면 다른 h 함수가 되기 때문에 여러번의 연산을 하게 될 것입니다.

이것을 아래 그림과 같이 parameter를 이제 Vector가 아닌 Matrix로 표현을 하면 여러번의 연산도 한번에 심플하게 할수 있다는 것을 알수 있습니다.

Properties of Matrix (특성)

Matrix의 곱셈은 순서가 바뀌면 다른 결과가 나오므로 일반적으로는 곱하는 순서가 중요합니다.

즉, 교환법칙이 성립하지 않는다고 합니다.(not commutative)

아래 그림의 예제를 보시면 다른 결과가 나오는 것을 보실수 있습니다.

Matrix x scalar 값은 교환법칙이 성립이 되었었는데, Matrix x Matrix는 그렇치 않으니 주의를 해야겠습니다.

곱셈에서 결합법칙이 성립이 됩니다. (Associative)

산수할때 괄호안에 있는 계산이 우선순위가 되는 것과 동일합니다.

Identity Matrix라고 하는 것인데 산수에서 8 * 1 = 8이 되는 것과 동일한 결과를 나타내주는 숫자 1과 같은 역활을 하는 Matrix를 의미합니다. 이 Matrix는 대각선으로 1의 값을 갖는 형태로 표현이 됩니다. 아래 그림을 보면 Matrix의 크기별로 형태를 볼 수 있습니다. 이 Identity Matrix는 I라고 표기하며 A * I = I * A = A의 결과가 됩니다.

특이한 점은 일반적으로 Matrix 의 곱셈은 교환법칙이 성립되지 않치만 Identity Matrix 는 교환법칙이 성립된다는 점입니다.

Inverse Matrix는 어떤 Matrix 와 반대 성향을 가지고 있는 Matrix 로서 이 두개의 Matrix 의 곱셈은 Identity Matrix 로 나타나는 것입니다. 아래 그림에서 A Matrix 에 대해서 A-1 라는 Inverse Matrix 가 존재하며 이 둘을 곱하면 I Matrix가 되는 것을 보여주고 있습니다. 하지만 모든 Matrix가 Inverse 형태를 갖는 것은 아니라고 합니다. 모든 요소가 0으로 구성되는 Matrix는 Inverse를 가지지 않습니다. 

Inverse Matrix는 Identity Matrix를 만들기 위한 역산으로 계산이 되어 만들어집니다. 아래 그림의 상단에 표기된 분수처럼 계산이 되어 생성이 되는데 실제 구현할때는 이를 계산해주는 함수들이 있으니 개념만 알고 넘어가면 됩니다.

Matrix Transpose는 어느 Matrix의 크기를 변형하는 방법입니다.

아래 그림에서 A Matrix 는 2x3의 크기를 가지고 있습니다. AT라고 표시되어 있는 오른쪽에 Matrix 는 A Matrix 의 transpose라고 하고 이 Matrix 값들은 대칭이 되는 형태로 표현이 됩니다.

A Matrix의 값들을 오른쪽 아래방향으로 대각선을 그어서 이 대각선을 기준으로 거울에 비치듯이 뒤집으면 됩니다.

각각의 값들은 변하지 않고 자리만 변경되는 것입니다. 그래서 m x n Matrix의 transpose는 n x m의 크기로 변형이 됩니다.

이것은 Matrix곱하기를 할 때 유용하게 사용할 수 있습니다. 일반적인 곱셈을 할 때 크기가 동일해야 했습니다. 즉, A Matrix의 rows의 숫자들 갯수와 B Matrix의 columns의 숫자들의 갯수가 동일해야 연산이 가능했었습니다. 이 크기를 맞춰주기 위해서 형태를 transpose하고 연산을 수행하는데 이용되는 것입니다.

이것이 Linear algebra의 전부는 아니지만 우리가 머신러닝을 배우면서 사용하게 될 내용들에 대해서 배웠습니다. 이제 우리는 많은 데이터들을 한번에 처리할 수 있는 준비가 된 셈입니다.

지난번에 Cost 함수에 대해서 알아보았습니다.

이번에는 Cost 함수를 minimizing 하기 위한 알고리즘에 대해서 알아보겠습니다.

이 알고리즘의 이름은 Gradient descent algorithm이라고 합니다. 변역해서 이야기 하면 경사면을 하강하는 알고리즘이 되는데 실제로도 그렇습니다.

우리는 기본이 되는 linear regression에서 하나씩 살펴보고 있지만 실제로 이 알고리즘은 여러 다양한 분야에서 범용적으로 사용이 되는 알고리즘입니다. 중요하다는 뜻이 되겠습니다.

Cost 함수를 minimizing하기 위한 방법중에 하나인 이 Gradient descent algorithm은 이미 알고 계시듯이 우리가 목표로 하는 직선을 찾기 위한 방법이되고 이를 머신이 학습한다고 표현합니다.

현재까지 배운것을 아래와 같이 요약정리 할 수 있습니다.

Cost 함수인 J함수는 두개의 parameters를 가지고 있으며 우리가 원하는 목표는 이 Cost가 minimization되는 파라미터로 구성된 함수를 찾는 것입니다. 이 함수를 찾을때까지 우리는 두개의 파라미터를 변경해 가면서 J함수를 줄여가도록 할 것입니다.

J함수를 3차원으로 그려보면 아래와 같이 나타나는 경우도 있을 것입니다.

봉우리가 2개이상이 있는 그래서 골짜기 같은 것도 보여지는 함수인가 봅니다.

여기서 왼쪽 봉우리 쯤에서 시작을 한다고 생각을 해보면 경사면을 따라서 하강을 한다고 했으니 아래와 같은 경로로 내려와서 최저점에 도달하게 될 것입니다.

만약, 조금 다른 위치에서 시작한다고 가정을 해보면 위와는 다른 경로로 최저점에 도달한다는 것을 볼 수 있습니다.

결국 최저점이 다른 2개의 지점으로 생기게 되는군요. 이러면 안될거 같은데 뭔가 이상합니다. 이러한 최저점을 local optimum 혹은 local minimum 이라고 합니다. 우리가 원하는 목표는 global optimum 이겠지요?

위의 함수를 수학적으로 표현을 해보면 아래와 같습니다.

여기서 등호 비슷한 := 이 표현은 프로그램의 할당(Assignment)와 같습니다. 즉, 기호 오른쪽의 값(value)을 왼쪽의 항목에 할당(준다)한다는 의미로 오른쪽의 값과 동일한 값을 왼쪽 항목이 가지게 됩니다. 그냥 값을 오른쪽에서 왼쪽으로 전달해주는 겁니다.

그리고 빨간색으로 표기된 알파는 learning rate라고 합니다. 이것은 경사면을 따라 내려올때 한 걸음에 해당하는 step을 나타내는 기호입니다. 이 값이 크면 한걸음의 보폭이 커질 것이고, 작아지면 총총걸음이 되는 것과 같습니다.

그다음에 알파 뒤에 있는 구분은 고등학교때 배운 미분(편미분)인데 이것은 뒤에서 설명을 하게 됩니다. 그냥 J함수를 미분을 하는가 보다 생각하면 됩니다.

여기서는 경사면을 따라서 한걸음 내려오는 행위를 수학적으로 생각하면 두개의 파라미터인 세타zero와 세타one의 값이 변경되면서 Cost가 한단계 줄어드는 것과 같습니다. 그런데 Cost 함수(J)는 두개의 파라미터를 가지고 있기 때문에 두개의 파라미터 값이 동시에 변경되고 Cost가 산출이 되어야 합니다. 이것을 Simultaneous update라고 합니다. 

만약에 아래 그림의 오른쪽으로 나타낼 수 있는것처럼 세타zero가 값이 먼저 바뀌고 Cost를 구하게 된 이후에 세타one의 값이 바뀐다고 하면 어떻게 될까요? Cost 함수가 하나의 파라미터 값만 바뀌고 움직이고 또 다른 하나의 파라미터 값이 바뀌고 또 움직이고 마치 짝다리 걸음을 하는 것 같은 이상한 모양새가 될 것 같습니다. 이렇게 되면 안된다라는 의미가 됩니다. 이는 구현시에 참고해야 할 내용이 됩니다.

자 이제 다시 Gradient descent algorithm을 봅니다.

아래 수식을 잠깐 보면 한점에 도달할때까지 이 식을 반복된다고 합니다. 그리고 마이너스 알파(learning rate)과 J를 미분하는 식(derivative:편미분), 그리고 파라메터인 세타zero와 세타one이 동시에 업데이트가 되어야 한다고 되어있습니다. 간단히 나타내기 위해서 세타one만 조금더 살펴봅니다.

만약에 세타one 파라미터의 값이 최저점보다 크다(오른쪽에 위치)라고 생각해보면 아래 그림의 위쪽 그래프와 같이 됩니다. 이때 J함수를 미분을 하면 빨간선과 같은 기울기가 됩니다. 미분은 기울기 맞죠?

경사도를 따라 내려가는 알고리즘이니까 기울기를 따라 왼쪽으로 이동하게 됩니다. 이때 알파 뒷부분의 공식은 positive number, 플러스 수가 되는데 앞에 마이너스가 붙어 있으니까 theta값이 줄어듭니다.

이번에는 세타one 파라미터의 값이 최저점보다 작다(왼쪽에 위치)라고 생각해봅니다. 아래 그림의 아래쪽 그래프가 보이시죠. 미분한 기울기는 반대 방향의 마이너스로 생기게 됩니다. 역시 경사면을 따라서 내려오면 오른쪽으로 이동하게 되겠네요. 이때 알파 뒷부분의 공식은 negative number가 됩니다. 앞에 마이너스가 있으니 플러스 값이 되어 더해지겠네요. 그래서 오른쪽으로 이동하게 됩니다.

결국 어느 점에서 시작하더라도 최저점을 향해서 잘 찾아 움직이는 것 같습니다. 이것이 미분으로 생긴 공식이 하는 역활입니다.

이번에는 알파에 대해서 알아보겠습니다.

경사면을 내려오는 step이라고 했었는데 너무 작으면 아래 그림의 위쪽 그래프와 같이 총총걸음으로 하염없이 오래 내려옵니다. 반대로 너무 크면 아래쪽 그래프와 같이 최저점을 찾지 못하고 양쪽을 오락가락 하다가 스탭이 꼬여서 거꾸로 올라가 버리는 경우도 발생한다고 합니다. 우리가 원하는 것은 한점으로 이동하는 것(converge)인데 반대로 분산되는 것(diverge)처럼 됩니다.

만약 아래 그림과 같은 함수가 있을때 세타one에서 시작을 한다고 생각을 해보면 (파라미터가 하나이고 세타one의 위치가 곧 local optima 위치가 동일합니다) 어떤일이 발생할까요? 한번 생각해보시겠습니까? 원 강의에서 나오는 문제입니다^^

이번에는 알파에 대해서 좀더 알아보겠습니다.

알파는 learning rate이고 step인데 만약에 이 알파 값이 고정되었다면 어떻게 될까요

알파 값은 뒤에 미분으로 나타나는 식과의 곱하기입니다. 미분 값, 즉 경사도가 가파를 수록 크고 경사도가 작아질 수록 작아지게 될 것입니다. 곱하기를 하니 알파 값이 고정이라도 움직임이 점차 내려오면서 같이 작아질 것 같습니다. 아래 그래프의 표시처럼 말입니다. 별도로 알파 값을 조절하지 않아도 이 식에서 자연스럽게 적절한 값으로 조절이 되니 신통방통합니다. 멋진 알고리즘인 것 같습니다

이제 거의 다왔습니다. 배운것을 정리를 하면서 중요한 점 하나만 보면 끝이납니다.

Linear regression에서 h 함수를 만들었고, J함수를 봤습니다. 이 J 함수를 우리가 원하는 minimizing 하기 위한 알고리즘이 지금 공부하는 Gradient descent algorithm이 되겠습니다. 

이 알고리즘의 미분식에 대해서 조금 더 보면,

두개의 파라미터로 구성이 되어 있고 이것을 각각의 파라미터로 편미분을 하면 아래와 같이 두개의 식이 만들어집니다. 일단 h 함수를 대입해서 일차방정식을 넣고 이것을 처음 세타zero로 편미분을 한 것이 아래 위쪽 식이 되고 다음 세타one으로 편미분을 하면 맨밑에 식이 됩니다. 

편미분을 하게 되면 제곱은 곱하기로 내려오고 2 * 1/2m이 되어 결국 1/m이 된 것입니다. 그리고 세타zero는 원래 상수 였기때문에 x 변수가(input data) 사라지는 것이고 세타one으로 미분한 것은 x 변수가 살아있는 것이 두 식의 차이점입니다.

어찌되었든간에, 결국 두개의 파라미터 세타zero와 세타one은 동시에 업데이트 되어 경사면을 내려오게 만든다는 것이고 위에서 본것처럼 아래와 같은 굴곡있는 함수의 경우 다른 점(local optima)로 내려가는 이상한 현상이 생길 수 있다는 것입니다.

그래서 우리는 아래와 같이 하나의 최저점을 가지고 있는 활 같은 모양(bow shaped function)을 선호하며 위의 굴곡있는 함수가 만약 있다면 아래와 같은 이쁘게 구부러진 모양의 함수로 만들어야 한다는 것이 핵심입니다. 그래야 우리가 원하는 global optimum를 찾을 수 있고 이것을 잘 찾는 알고리즘이 좋은 알고리즘이 됩니다. 잘 찾았다면 결과도 아주 잘 예측할 수 있는 것이기도 하게 되겠습니다.

이제 등고선으로 표현을 해보면 아래와 같습니다. 한번 본적이 있었져?

오른쪽 동고선에 빨간점에서 시작을 합니다. 조금씩 움직이면서 이때의 파라미터로 구성이 되는 h 함수를 그리면 왼쪽의 직선처럼 되는데 실제 데이터와 조금 다르기 때문에 Cost가 아직 큽니다.

이렇게 계속 동시에 파라미터가 변경이 되면서 등고선의 중앙(global optimum)에 다다르게 되면 이때의 파라미터가 구성하는 h 함수 일차방정식인 직선을 그려보면 아래와 같이 되고 이것은 실제 결과 값과 거의 비슷하므로 우리가 찾는 것이 됩니다. 잘 찾았다는 것은 잘 학습을 했다는 것이 되겠습니다.

이와 같이 반복적으로 움직이고 판단하고 다시 움직이는 알고리즘들을 batch라고 불른다고 합니다. 뭔가 조금 어색해 보이지만 그렇게 많이 쓴다고 하니 용어만 알아두면 되겠습니다. 그럼 batch가 아닌것도 있을까? 네 있다고 합니다. 나중에 다루는 것 같습니다만 위의 편미분을 한번에 수학적으로 풀수 있다면 여러 step을 반복하지 않아도 될 것인데 이러한 것은 일부 작은 dataset에서만 가능하다고 합니다.

우리가 하려고 하는 큰 스케일의 dataset에서는 지금 배운 Gradient descent algorithm이 보다 범용적으로 사용이 가능한 좋은 알고리즘이 되겠습니다.

여러분은 Gradient descent algorithm에 대해서 모든 것을 배우셨습니다.^^

긴 글 읽으시느냐고 수고하셨습니다

우리는 Supervised 방식을 공부하고 있기 때문에 결과 값을 비교할 수 있습니다.

왜냐하면 실제 정확한 결과 값을 알고 있기 때문입니다.

이 결과 값을 비교할 수 있는 표현이 Cost입니다. 그리고 Cost를 수학적인 함수로 표현하는 것도 배우게 될 것입니다.

이전 내용에서 이어서

h 함수를 일차방정식으로 표현할 수 있었습니다. ( h = Ax + B)

여기서 A와 B를 Parameters라고 합니다. 이 파라미터가 결정이 되면 우리는 원하는 결과 값을 찾을 수 있게 됩니다.

그럼 이 파라미터 값은 어떻게 찾을 수 있을까요?

바로 minimize를 해서 찾을 수 있습니다. 

우리는 이미 결과 값을 알고 있기 때문에 실제 결과 값과 알고리즘이 수행하여 예측한 결과 값을 비교해서 그 차이를 구할 수 있는데, 이 차이가 가장 작은 즉, 실제 값과 가장 가까운 결과가 나올 수 있는 파라미터를 구하면 될 것입니다.

그러한 파라미터로 구성된 직선이 우리가 찾고자 하는 기준이 됩니다.

Dataset에서 첫번째 데이터를 보면 집의 사이즈가 2104피트인 집이 실제 가격이 460,000달러였습니다.

x가 2104 값일때 실제 결과인 h가 460,000 값이 되어야 하는 것이지요

그런데 알고리즘을 수행하여 머신이 학습한 결과 값이 400,000달러라고 가정을 해보면 실졔 값과의 차이가 60,000달러 만큼 발생하는 것을 알 수 있습니다. 이 60,000달러가 Cost로 표현이 됩니다.

Cost는 예측된 결과 값(h) - 실제 결과 값(y)으로 정의를 할 수 있는데 이 값이 마이너스(-)의 값을 가질 수 있으므로 제곱을 해줍니다. 수식으로 표현하면 Cost = (h - y)^2이 되고 아래 그림의 오른쪽 위에 표현식과 비슷하게 됩니다

첫번째 데이터에 대한 것만 보고 표현한 것이니 이것을 모든 Dataset으로 확장해서 표현을 하면 1번째 데이터부터 m번째 데이터까지의 합으로 나타낼 수 있습니다. 또 이 값을 2m으로 나누어주면 평균 값이 됩니다.

이것을 수식으로 아래 그림과 같이 표현 할 수 있습니다. 그리고 이것이 Cost 함수가 됩니다.

우리는 이 cost가 가장 적은 것을 찾아야 하는것이 목표입니다.

목표를 달성하기만 하면 우리는 정확한 값을 에측할 수 있게 되기 때문입니다

Cost 함수를 제이(J)로 표현하였고 이 J함수가 minimize 된 값을 찾는 것이 우리의 목표라고 아래 왼쪽 그림에서 표현이 되어 있습니다.

지금까지 Cost에 대해서 알아보았는데 이제부터는 이 Cost함수가 어떤 의미와 특징을 가지고 있는지 알아봅니다.

Cost함수를 좀더 간단하게 표현하기 위해서 세타zero를 0이라로 가정하여 없앴습니다. ( y = Ax 가 됩니다)

h = Ax를 그래프로 그리면 아래 왼쪽의 그림과 같이 표현이 됩니다.

여기서 또 A = 1 이라고 가정을 하면 h = x가 되니 (1,1), (2,2)의 값을 갖는 직선이 되겠지요. 

실제 결과인 y와 h의 값이 동일하다면 이때 cost 함수를 아래와 같이 풀어보면 값이 0이 됩니다.

다시말하면, A=1이고 B=0일때 Cost=0이 되는 것입니다.

이렇게 하나씩 그래프로 찍어서 보면 아래 오른쪽 그림과 같이 Cost 함수는 이차방정식의 그래프로 나타나는 것을 알 수 있습니다. 이때 minimize 된 값을 찾는 것이 목표이기 때문에 그래프에서 가장 아래쪽인 j=0이 되는 cost가 0이 되는 세타one (혹은 A)를 찾아내는 것이 목표이자 머선이 학습으로 수행하여 찾아야할 파라미터 값이 됩니다. ( A=1 )

이 J 함수를 3차원으로 나타내면 아래 그림과 같이 된다고 합니다. 이쁩니다.

위 3차원 그래프를 등고선의 형태로 표현하면 아래와 같이 된다고 합니다.

만약 왼쪽의 직선과 같은 h를 발견했다면 실제 데이터(점들)과 많이 다르기 때문에 비용함수인 J가 중앙에서 멀리 있는 것(등고선의 바깥쪽에)을 볼 수 있습니다.

그러나 이것은 우리의 목표와 맞지 않으므로 답이 아니지요

아래 그림과 같은 직선으로 표현되는 h를 발견했다면 실졔 데이터와 비슷하기 때문에 비용함수인 J가 중앙에 있는 것을 보실 수 있습니다. 우리가 찾는 minimize라는 의미는 등고선으로 표현 했을때 정중앙에 위치하는 즉, Cost가 0에 가까운 것을 찾는 다는 뜻입니다. 또 Cost가 0에 가깝다는 의미는 실제 데이터의 결과값과의 차이가 거의 나지 않는 다는 똣이고 이는 예측 가능한 정확도가 높다는 것이 됩니다.

이런 과정으로 머신이 학습을 하여 결과를 찾는 것입니다.

많은 수식과 그래프로 표현이 되었지만 요약하자면 알고리즘(머신)이 수행되면서 예측한 값과 실제 값을 비교해서 Cost를 분석하고 이 Cost가 가장 적은 기준을 찾아내는 것입니다.

이제 한걸음 들어가게 됩니다.

앞에서 공부했던 Supervised Learning에서 regression 에 대한 예시를 가지고 이것을 수학적인 표현식으로는 어떻게 표현이 되는지를 보겠습니다.

집의 사이즈에 따라서 집의 매매가격의 변화하는 데이터를 그래프로 표현하면 아래와 같습니다.

사이즈가 커지면 가격이 높아지니 선을 하나 그어볼 수 있을 것입니다.

이 직선은 사이즈와 가격에 대한 변화를 아주 잘 나타내는 그래프이자 수학적으로는 일차방정식으로 표현이 됩니다.

데이터셋의 실제 데이터들을 하나씩 열어보면 아래와 같이 사이즈와 가격으로 구성이 된 정보들을 볼 수 있습니다.

저기 지역에서는 사이즈가 2104 피트인 집이 460,000달러인가 봅니다.

DataSet의 크기, 즉 데이터의 수량을 m으로 표현을 하고

집의 사이즈를 x로 표현을 하고

집의 가격을 y로 표현하기로 했습니다.

그래서 첫번째 데이터인 x1이 2104를 표현하게 되고, y1는 460달러를 표현하게 되었습니다.

쉽게 우리가 가장 잘 아는 일차방정식과 동일합니다. ( y = Ax + B )

이 직선이 무엇이였죠? 사이즈에 따른 집의 가격들이였습니다. 이 직선을 알면 우리는 무엇을 할 수 있게 되는걸까요? 사이즈만 알면 집값을 예측할 수 있게 될 것입니다. 

그러면 우리가 알고자 하는 것은 저 직선을 만드는 것일까요? 네 맞습니다. 그런데 이것을 우리가 찾는게 아니라 알고리즘(머신)이 학습해서 찾아줄 것입니다.

개념을 도식화해서 보면 아래 왼쪽의 그림과 같이 dataset이 알고리즘을 통해서 수행이 되는데 h라고 표현이 되어 있는 Hypothesis(가설)을 세우기만 하면 x라는 입력값에서 y라는 우리가 원하는 집값을 예측하는 결과 값이 도출되게 될 것입니다.

여기서 h가 그 직선의 함수가 되고

h = Ax + B인데 아래 교수님은 조금 유식하게 세타(θ)로 표현하셨습니다. 오른쪽 녹색 보이시죠?

세타 zero가 B가 되고 세타 one이 A와 동일합니다.

이번 예제에서는 직선 형태의 regression이라 이를 Linear regression이라고 호칭합니다.

그리고 x라는 입력값(feature)이 하나이기 때문에 one variable 혹은 Univariable이라고 합니다.

이를 합치면 Univariate linear regression 이라고 하고 우리가 배운 것을 표현하는 멋진 용어가 됩니다.

머신이 학습을 하는 방식은 Supervised Learning과 Unsupervised Learning의 2가지로 구분이 됩니다.

이는 기초 데이터인 Dataset의 성격과 원하는 결과 값의 성격에 따라 다르게 사용이 됩니다.

Supervised Learning

변역하면 지도식 학습 방법입니다.

선생님이 학생을 교육하듯이 이미 답을 알고 있는 상태에서 학습을 하는 경우입니다.

DataSet이 이미 결과 값을 포함하고 있어 머신이 학습을 수행하여 나온 결과 값이 얼마정도의 오차를 가지고 있는지 알수 있는 경우에 사용될 수 있습니다.

예를들어, 집의 사이즈에 따른 집의 가격을 분석한다면 우리는 이미 평수에 따른 가격이 어떻게 구성이 되는지를 알고 있습니다. 실제로 집이 거래된 가격도 정확하게 알 수 있습니다. 이 집의 사이즈 데이터를 머신이 학습하고 수행한 결과 값은 집의 매매가로 나타나게 될 것이고 이를 실제 값과 비교해서 Cost(오차값)를 비교할 수 있습니다.

집은 사이즈가 커질 수록 매매가가 높아지기 때문에 연속적인 값으로 나타나게 됩니다. 이렇게 연속적인 결과 값으로 나오는 것을 Regression이라고 합니다. 

또는 집의 구조에 따라서 아파트인지 빌라인지 단독주택인지 구분이 되는데 이러한 값을 나타내는 것은 Classification이라고 합니다.

아래 그림은 강의에서 사용한 종양 크기에 대한 암환자 정보를 구분하는 내용입니다. 일정한 사이즈 이하인지 이상인지에 따라 악성종양인지 여부를 구분합니다. 이처럼 구분하여 나타내지는 값에 대한 분석을 Classification으로 처리하면 되는것입니다

어떠한 데이터들을 구분을 한다는 것은 어떤 기준이 필요하게 됩니다.

아래와 같은 데이터들은 선형의 기준선으로 인해 분류가 될 수 있습니다.

이렇게 잘 구분할 수 있는 선을 찾고 하는 것이 supervised에서 머신이 학습을 하여 찾아내는 결과가 됩니다.

두가지의 학습 방식은 다른 성향의 결과 값을 예측하고자 할 때 사용이 되므로 이 차이를 잘 이해해야 합니다.

머신러닝을 이용하여 무엇인가를 예측하고자 할때 적절하게 사용해야 하기 때문입니다.

Unsupervised Learning

자율학습이라고 표현되는 학습 방법입니다.

이것이 supervised와 다른 점은 우리가 답을 알고 있지 않는 상태에서 학습을 하는 경우라는 것입니다.

DataSet에 어떤 정보들이 있는지 우리는 알지 못하고 어떤 데이터로 구성이 되어 있는지도 알지 못할때 사용됩니다. 우리가 원하는 결과들은 비슷한 의미를 가진 데이터들이나 비슷한 주제로 구성된 데이터들을 분류하여 보고자 할 때 사용됩니다. 이를 clustering 혹은 grouping 이라고 표현됩니다.

예를들어, 우리의 물건을 구매한 고객 데이터를 분석한다고 생각해보면 됩니다. 연령대 별로 혹은 소비자의 소득수준으로 구분되어 판매량을 분석할 수 있을 것이고 전체 시장에서 우리 물건에 대한 시장 점유율과 같은 결과로 나타날 수도 있을 것입니다.

또는 비슷한 뉴스나 피드들을 grouping하여 사용자에게 보여주는 서비스도 가능할 것입니다. 같은 주제에 대한 다양한 정보들을 한눈에 볼 수 있어 편리할 겁니다.

또, 음성인식에서도 유용하게 활용이 될 수 있습니다.

사용자가 클럽같이 시끄러운 곳에서 오더를 할때 머신은 주위 사람들의 소리와 음악소리 같은 잡음들은 다 무시하고 사용자가 말하는 음성만 정확하게 인식이 되도록 할 수 있습니다.

아래와 같이 강의에서 분리된 음성을 직접 들려주시면서 이런 알고리즘을 실제 구현하면 저렇게 한줄로 표현이 될 수 있다고 이야기 하고 있습니다. 우리가 처음에 막연하게 생각 했던 것보다 쉬울 것 같지 않습니까?^^

Machine Learning

머신 러닝의 기본 방식은 크게 3가지로 구성이 됩니다.

분석하고자 하는 데이터를 기초로 머신이 학습 또는 task를 수행하게 되고 그 수행결과 값이 실제 값과 같은지를 판단하는 과정으로 진행이 됩니다.

여기에서 사용되는 기초 데이터를 Dataset 이라고 하며 데이터는 수량이 많고 다양할 수록 좋은 데이터가 될 것입니다. 이러한 데이터를 수집하는 단계가 있을 것입니다.

그리고 머신이 학습을 수행하는 단계에서 앞으로 공부하게 될 Algorithm 들이 적용이 될 것입니다.

이렇게 수행한 결과 값이 우리가 원하는 값이 되어야 하며, 실제 우리가 원하는 값과 비교를 하여 그 결과가 적절한 것인지 아닌지 여부를 측정하게 됩니다. 만약 원하는 값이 아니라면 수행을 계속 진행하거나 알고리즘의 수정이 필요합니다. 이렇게 수행한 결과 값과 우리가 실제로 기대하는 결과 값의 차이를 Cost로 표현하고 수학적인 함수로 표현이 될 것입니다.

History

머신 러닝에서 하나의 분야인 딥러닝은 인간의 뇌신경계를 연구하면서 발견된 내용들을 토대로 하고 있습니다.

사람의 뇌 구성을 그대로 알고리즘으로 구현했다고 봐도 될 것 같습니다.

뇌 구성은 알아도 뇌가 어떻게 동작해서 생각하고 결정을 하는지까지는 아직 알수 없을 것인데 이러한 신기한 것이 머신에서도 가능한 것이 아닌가 싶습니다. 구성만 되면 원하는 결과가 사람이 수행한 결과보다도 높은 정확도로 나타나고 있으니까 말입니다. 이미 사람보다 똑똑한 머신들이 태어났다고 봐야 할 것입니다.

약 50년전부터 인공지능에 대한 연구가 시작되어 지금까지 많은 전문가들이 발전시켜온 분야라고 하는데 우리는 강의를 통해서 한 두달만에 이런 지식을 배울 수 있다니 그저 놀랍니다.

이미 많은 분야에서 적용이 되어 서비스가 되고 있는데 대표적인 것이 검색엔진, 추천서비스, 음성인식, 얼굴인식, 자율운행 자동차등 입니다. 이러한 변화들을 보면 기존의 플레폼 성격적인 서비스(우리가 이런 서비스를 만들었으니 이렇게 사용해주세요 하는 서비스들)는 지나가고 앞으로는 사용자 개개인의 성향에 맞추어 주는 서비스(사용자마다 성향에 따라 다른 결과를 보여주는 서비스들)들이 발전될 것 같습니다.

상세한 히스토리는 김성훈 교수님의 강좌에서 '딥러닝의 기본개념' 내용을 보시면 재미있게 역사적인 스토리들을 알 수 있습니다. 교수님 좋은 강좌 항상 감사합니다. 시즌2도 기대하고 있겠습니다.^^

https://hunkim.github.io/ml/

http://daeson.tistory.com/entry/%EB%A8%B8%EC%8B%A0-%EB%9F%AC%EB%8B%9D%EC%97%90-%EB%8C%80%ED%95%98%EC%97%AC

머신러닝 분야에 세계적인 권위를 가지고 계신 Andrew Ng 교수님의 무료강좌를 공부하면서 정리를 해보려고 합니다.

https://www.coursera.org/learn/machine-learning/lecture/RKFpn/welcome

초기 몇개의 강의는 한글로 된 transcirpt이 지원이 되고 있습니다. 조금 지나면 모든 강의를 한글 스크릡트로 볼수 있게 될 것 같습니다.

아래는 소개글인데 너무 멋지고 별도로 요약정리할 필요도 없을 것 같아서 그냥 퍼왔습니다.

한번씩 읽어만 봐도 왜 우리가 머신러닝을 배워야 하는지 자연스럽게 이해할 수 있게 됩니다.

앞으로는 모든 분야에서 사용하지 않으면 안되는 기술이 될 것 같습니다.

기계학습 무료 온라인 강의에 오신 것을 환영합니다. 기계학습은 최근 기술 중에서 가장 흥미있는 분야중 하나인데요. 이 강의에서 여러분은 실전 연습을 통하여 현재 사용되고 있는 알고리즘을 직접 배치해보는 것을 배우게 될 것입니다. 여러분들은 자기도 모르게 학습알고리즘을 하루에도 수 십번 사용 하고 있습니다. 매일 여러분들은 인터넷 검색을 할 때 구글이나 Bing같은 곳에서 웹 검색 엔진들을 사용할텐데요, 검색엔진들이 검색을 잘 하기 위해서 학습 알고리즘이 사용됩니다. 또 이 알고리즘을 사용하여 구글이나 마이크로소프트에서 웹페이지들을 랭크 하게 됩니다. 여러분들이 페이스북이나 애플의 사진 어플리케이션을 사용 할 때 여러분과 친구들의 사진들을 인식하게 되는데 이것 또한 기계학습입니다. 이메일을 사용 할 때 이메일 스팸필터가 수많은 양의 스팸메일로부터 스팸메일을 걸러 주게 될 텐데요. 이것 또한 학습알고리즘을 사용한 것입니다. 아직 멀었지만, 여러분이나 저와 같은 지능을 가진 기계를 만들기위해서 수많은 인공지능 연구자들의 최선의 목표는 학습 알고리즘을 인간의 뇌를 흉내내서 만들어 인간의 뇌와 비슷하게 학습하게 만드는 것입니다. 이 부분에 대해서는 나중에 더 말씀 드리도록 하겠습니다. 이번 강의에서는 최신의 기계학습 알고리즘에 대하여 배워 보겠습니다. 하지만 단지 어떤 알고리즘이 사용되는지 설명하고 그 알고리즘이 어떻게 유도되는지 수학적으로는 알 필요 없으니 걱정하지마세요. 그럼 우리는 이제 이러한 알고리즘들을 사용하여 예제들을 풀어보고 어떻게 작동되는지 확인하는데 많은 시간을 보내게 될 것입니다. 그럼 왜 기계학습이 오늘날에 사용되고 있는 것 일까요? 기계학습은 인공지능분야에서 발전하여 파생되어 나갔습니다. 우리는 기계가 지능을 가지길 원했고 몇몇 간단한 일들을 스스로 해내길 원했습니다. 가령 A에서 B로갈 때 어디로 가는 게 더 빨리 갈 수 있느냐 하는 것들 말입니다. 하지만 웹검색, 사진태그, 스팸메일필터 말고도 인공지능 프로그램들이 할 수 있는 우리가 모르는 더 많은 부분들이 있습니다 우리가 여기서 알 수 있는 한 가지는 기계가 스스로 학습한다는 사실입니다. 그래서 기계학습은 컴퓨터의 새로운 능력을 불어넣어 향상 시켜주기 때문에 오늘날 기초과학과 산업의 여러 분야에서 사용되고 있습니다. 제가 기계학습분야에서 있는 동안 헬리콥터조종사, 생물학자, 컴퓨터시스템 종사자들 (이곳 스탠포드 학생들)과 얘기하며 그리고 최근에 학습알고리즘을 그들의 시스템에 적용하고 싶어 하는 실리콘밸리회사들로부터 2,3주에 한번 이메일을 받고 있습니다. 이 같은 현상은 기계학습이 필요한 분야가 점차 확산 되고 있다는 뜻이기도 합니다. 자동화로보틱스, 생물학계산, 실리콘밸리의 수많은 일 등.. 이것들은 기계학습의 강력한 이점을 이용하고자 합니다. 여기 기계학습의 간단한 예가 있습니다. 데이터베이스 수집입니다. 기계학습이 발전하게 된 이유 중 하나는 웹과 모든 것이 자동화가 되었기 때문인데요. 이것은 전보다 우리가 가지고 있는 데이터가 훨씬 많아 졌기 때문입니다. 예를 들어, 실리콘밸리의 수 많은 회사들이 웹에서 클릭된 데이터를 수집하려고 합니다. 이것을 클릭스트림데이터라고 하는데 기계학습 알고리즘을 사용하여 이 데이터들을 수집하고 사용자가 어떠한 서버가 더욱 쾌적한지 알아내고 유저에게 더 나은 서비스를 제공할 수 있게 됩니다. 이것은 현재 실리콘밸리에서 여러 핵심분야 중 하나입니다. 의료 기록. 자동화가 되면서 우리는 전자 의료기록부를 가지게 되었습니다. 의료 기록들의 분석을 통하여 병이 낫게 하는데 도움이 되게 되었습니다. 또, 생물학 계산 자동화를 통하여 생물학자들은 엄청난 양의 유전자를 분석할 수 있게 되었고 기계학습알고리즘이 인간 게놈을 이해하는데 도움을 주게 되었습니다. 공학분야 역시 마찬가지로 점점 더 커져가는 데이터를 처리해야하는 상황이 왔습니다. 그래서 현재 그 방대한 데이터들을 학습알고리즘을 사용하여 분석하고 있습니다. 다음으로 수동적으로 프로그래밍을 할 수 없을 때 사용하는 자동화 학습 프로그래밍분야입니다. 예를들면, 저는 자동화 헬리콥터를 수년간 연구 했습니다. 처음에 저는 헬리콥터가 비행하게 만드는 컴퓨터 프로그래밍 법을 몰랐습니다. 연구 끝에 알아낸 한가지 방법은 컴퓨터가 스스로 학습하여 헬리콥터가 날게 하는 방법이었습니다.

이것은 또한 미국에서 해외로 우편물을 발송할 때 비용이 많이 들지 않게 하는 방법으로도 쓰이고 있습니다. 편지봉투에 이렇게 써놓으면 학습알고리즘이 손글씨를 분석하여 자동으로 분류를 하게 됩니다. 이같은 기술을 통하여 불과 몇센트 만으로 수천마일의 거리로 우편을 보낼 수 있게 합니다. 그리고 자연언어처리기법이나 컴퓨터비전분야를 본 적이 있으실 겁니다. 이것 들은 언어를 이해하고 그림들을 식별하는 인공지능 분야입니다. 수많은 자연언어 처리기법과 컴퓨터비전 분야는 오늘날 기계학습에 적용 되고 있습니다. 또한 스스로 프로그래밍을 할 수 있는 학습알고리즘은 널리 이용되고 있습니다. 여러분들은 자주 아마존이나 넷플릭스 또는 아이튠즈 지니어스를 이용 보셨을 겁니다. 그곳에서 영화나 제품, 음악들을 추천하는 서비스를 하고 있습니다. 이것도 학습알고리즘을 이용한 것입니다. 만약 사용자가 수십만이라고 생각해 보세요, 수십만의 사용자를 다루는데 매번 다른 프로그래밍을 할 수는 없을 것입니다. 이것들을 할 수 있는 방법은 오직 기계가 스스로 추천을 할 수 있게끔 만드는 것입니다. 여러분의 취향을 고려해서요. 마지막으로 학습알고리즘은 오늘날 인간이 학습하는 것과 인간의 두뇌를 이해하기 위하여 사용 되고도 있습니다. 앞으로 연구자들이 어떠한 과정으로 인공지능의 꿈을 어떻게 이뤄나가고 있는지 얘기 할 것입니다. 몇 달 전에 한 학생이 상위 12개의 IT기술들이 나온 기사를 보여줬습니다. 그 기술들은 IT기술 분야의 전문가들이 부인 할 수 없는 유망한 기술들 이었습니다. 약간 예전의 기사임에도, 그 상위 12개의 기술들 중 가장 전망 있는 IT기술은 바로 기계학습분야 였습니다. 이곳 스탠포드에서도, 매년 수많은 채용인들이 기계학습분야를 전공한 학생들을 채용하기 위한 수요가 매년 증가 하고 있습니다. 그래서 저는 이 기술의 수요가 매우 급격하게 증가하고 있으며 기계학습을 배우는 것은 매우 가치 있는 시간이 될 것이라 생각합니다. 다음 강의에서 우리는 기계학습이 무엇인가에 대하여 좀 더 보편적인 정의를 알려 드리겠습니다. 그리고 기계학습 문제의 종류들과 알고리즘에 대하여 얘기 해보겠습니다. 여러분은 주요 기계학습기술들을 선택 하고 여러 알고리즘 중 하나를 어떻게 선택해야하는지, 언제 그 알고리즘을 적절하게 사용 할 것인지에 대하여 배워봅시다.