게으른 우루루

SVM에 더 자세한 정보는 이전 포스팅을 참조하세요

[1]Kernelized Support Vector Machines

# library import

from sklearn.svm import SVC

from sklearn.model_selection import train_test_split

from sklearn.datasets import load_iris

# data load

iris = load_iris()

# data partition

x_train, x_test, y_train, y_test = \

  train_test_split(iris.data, iris.target,

                   test_size=0.3, random_state=0)

print('train set size:{}, test set size:{}'.format(x_train.shape, x_test.shape))

# train set size:(105, 4), test set size:(45, 4)

# grid search

best_score = 0

values = [0.001, 0.01, 0.1, 1, 10, 100]

for g in values:

    for c in values:

        svc = SVC(gamma=g, C=c).fit(x_train, y_train)

        score = svc.score(x_test, y_test)

        if score > best_score:

            best_score = score

            best_param = {'C':c, 'gamma':g}

print('best score ==> {:.3f}'.format(best_score))

print('best parameter ==> {}'.format(best_parameter))

# best score ==> 0.978

# best parameter ==> {'C': 100, 'gamma': 0.001}

# library load

from sklearn.datasets import load_iris

from sklearn.linear_model import LogisticRegression

from sklearn.model_selection import LeaveOneOut, cross_val_score, KFold

# dataset

iris = load_iris()

# create object

logreg = LogisticRegression() # model

loo = LeaveOneOut() # LeaveOneOut model

# test validation

# LOOCV

scores_loo = cross_val_score(logreg, iris.data, iris.target, cv=loo) 

# K-fold(5)

kfold = KFold(n_splits=5, random_state=0, shuffle=True)

scores_fold = cross_val_score(logreg, iris.data, iris.target, cv=kfold) # model, train, target, cross validation

# cv result

print('iris.data.shape \n{}'.format(iris.data.shape))

print('cv number of partition \n{}'.format(len(scores_loo)))

print('mean score_loocv \n{:.3f}'.format(scores_loo.mean()))

print('mean score_kfold \n{:.3f}'.format(scores_fold.mean()))

cv result

# iris데이터를 이용하여 shuffle-split cross-validation

# load library

from sklearn.model_selection import ShuffleSplit

# create object

shuffle_split = ShuffleSplit(test_size=0.5, train_size=0.5, n_splits=10) # ShuffleSplit 객체 생성

# cv test

scores = cross_val_score(logreg, iris.data, iris.target, cv=shuffle_split)

# cv test result

print('cv test score \n{}'.format(scores))

cv test score

그룹별 교차 검증의 자세한 정보는 아래 링크 참조

http://scikit-learn.org/stable/modules/cross_validation.html

# load library

from sklearn.model_selection import GroupKFold

from sklearn.datasets import make_blobs

# datasets

x, y = make_blobs(n_samples=12, random_state=0)

plt.scatter(x[:, 0], x[:, 1], c=y)

plt.xlabel('feature 0')

plt.ylabel('feature 1')

plt.show()

make_blobs로 만든 인위적 데이터

# create object

gkfold = GroupKFold(n_splits=3) # GroupKFold

groups = [0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3] # group class

# cv test

scores = cross_val_score(logreg, x, y, groups, cv=gkfold)

# cv test result

print('cv test score \n{}'.format(scores))

cv test score

LogisticRegression 이전 포스팅 참조하기: [1]Logistic Regression[1], [2]Logistic Regression[2]

# library import

from sklearn.model_selection import cross_val_score

from sklearn.datasets import load_iris

from sklearn.linear_model import LogisticRegression

# dataset

iris = load_iris()

logreg = LogisticRegression()

scores = cross_val_score(logreg, iris.data, iris.target, cv=5) # model, train, target, cross validation

print('cross-val-score \n{}'.format(scores))

print('cross-val-score.mean \n{:.3f}'.format(scores.mean()))

5겹 교차검증 결과와 평균

# load library

import matplotlib.pyplot as plt

import matplotlib

from sklearn.datasets import load_iris

from sklearn.linear_model import LogisticRegression

from sklearn.model_selection import cross_val_score

import numpy as np

# data load

iris = load_iris()

print('iris label \n{}'.format(iris.target))

print('''iris label's bin \n{}'''.format(np.bincount(iris.target)))

iris label과 bin

# library import

import mglearn

# matplotlob 설정

matplotlib.rc('font', family='AppleGothic') # 한글출력

plt.rcParams['axes.unicode_minus']=False # 축 -

mglearn.plots.plot_stratified_cross_validation()

plt.show()

클래스 레이블 순서대로 정렬된 데이터에서 기본 교차 검증과 계층별 교차 검증 비교

# library import

from sklearn.model_selection import KFold

kfold = KFold(n_splits=5) # KFold 객체 생성

logreg = LogisticRegression() # 모델 객체 생성

for n in [3, 5]:

    kfold = KFold(n_splits=n)

    scores = cross_val_score(logreg, iris.data, iris.target, cv=kfold)

    print('n_splits={}, cross validation score: {}'.format(n, scores))

n_splits에 따른 교차 검증 테스트 점수

for n in [3, 5]:

    kfold = KFold(n_splits=n, shuffle=True, random_state=0)

    scores = cross_val_score(logreg, iris.data, iris.target, cv=kfold)

    print('n_splits={}, cross validation score: {}'.format(n, scores))

shuffle과 random_stat매개변수를 조정한 교차 검증 테스트 점수

# library import

import mglearn

import matplotlib.pyplot as plt

mglearn.plots.plot_cross_validation()

plt.show()

5-겹 교차 검증에서의 데이터 분할

### library import

from mglearn.datasets import load_citibike

import matplotlib

import matplotlib.pyplot as plt

import pandas as pd

import numpy as np

### matplotlib 설정

matplotlib.rc('font', family='AppleGothic')

plt.rcParams['axes.unicode_minus'] = False

### datasets

citibike = load_citibike()

print('citibike.head() \n{}'.format(citibike.head()))

citibike.head()

print('citibike.index.min() \n{}'.format(citibike.index.min()))

print('citibike.index.max() \n{}'.format(citibike.index.max()))

xticks = pd.date_range(start=citibike.index.min(), end=citibike.index.max(), freq='D')

print('xticks \n{}'.format(xticks))

# 그래프의 축을 만들기 위해 freq='D'로 설정하여 일별데이터로 수정

citibike의 index전처리

# strftime('%w'): datatime에서 일요일 ~ 토요일을 인덱스 0~6까지 부여

# strftime(' %m-%d'): datatime에서 '월', '일' 뽑아내기

print('''xticks.strftime(%w) \n{}'''.format(xticks.strftime('%w'))) 

print('''xticks.strftime( '%m-%d') \n{}'''.format(xticks.strftime(' %m-%d'))) 

x축 데이터를 위한 전처리

week = ['sun', 'mon', 'tue', 'wed', 'thr', 'fri', 'sat']

# xticks.strftime('%w')의 결과는 str형태이기 때문에 int()를 이용하여 숫자로 변환

xticks_name = [week[int(w)] + d for w, d in zip(xticks.strftime('%w'), xticks.strftime(' %m-%d'))] # list 축약

print('xticks_name \n{}'.format(xticks_name))

x축 데이터를 위한 xticks_name

plt.xticks(xticks, xticks_name,rotation=90, ha='left') # ha: horizon align; 수평정렬 

plt.plot(citibike, lw=1, c='darkblue') # lw = linewidth, c = colors

plt.xlabel('date')

plt.ylabel('count')

plt.show()

한 시티바이크 대여소에서 한달간 자전거가 대여된 횟수

y = citibike.values # target

x = citibike.index.astype('int64').values.reshape(-1, 1) // 10**9 # datetime ==> int64 ==> 값만 가지고오기 ==> 1열의 데이터로 ==> scale조정

### library import

from sklearn.ensemble import RandomForestRegressor

### train 갯수

n_train = 8 * 23

### data 분할

x_train, x_test, y_train, y_test = \

  x[:n_train], x[n_train:], y[:n_train], y[n_train:]

### 모델 적용  

rfr = RandomForestRegressor(n_estimators=100, random_state=0)

rfr.fit(x_train, y_train)

y_pred = rfr.predict(x_test)

y_pred_train = rfr.predict(x_train)

### 유효성 평가

print('R-Square \n{:.3f}'.format(rfr.score(x_test, y_test))) # -0.035

### visualization

plt.xticks(range(0, len(x), 8), xticks_name, rotation=90, ha='left') # ha = holizon align 

plt.plot(range(n_train), y_train, label='train')

plt.plot(range(n_train, len(y_test) + n_train), y_test, ls=':', label='test') # plt.plot(x, y, linestyles, label)

plt.plot(range(n_train), y_pred_train, ls='--', label='train test') # ls = linestyles

plt.plot(range(n_train, len(y_test) + n_train), y_pred, ls='--', label='test pred') 

plt.legend(loc=2)

plt.xlabel('date')

plt.ylabel('count')

plt.show()

POSIX 시간만 사용하여 만든 랜덤 포레스트의 예측

RandomForest는 이전 포스팅 참조: [1]Random Forest -- intro, [2]Random Forest

# n_train = 8 * 23

# model = RandomForestRegressor(n_estimators=100, random_state=0)

def eval_feature(features, target, model):

    # data 분할

    x_train, x_test, y_train, y_test = \

      features[:n_train], features[n_train:], target[:n_train], target[n_train:]

    # model 적용

    model.fit(x_train, y_train)

    y_pred = model.predict(x_test)

    y_pred_train = model.predict(x_train)

    # 유효성 평가

    print('R-Square \n{:.3f}'.format(model.score(x_test, y_test)))

    # visualization

    plt.xticks(range(0, len(x), 8), xticks_name, rotation=90, ha='left')

    plt.plot(range(n_train), y_train, label='train')

    plt.plot(range(n_train, len(y_test) + n_train), y_test, ls=':', label='test')

    plt.plot(range(n_train), y_pred_train, ls='--', label='train test')

    plt.plot(range(n_train, len(y_test) + n_train), y_pred, ls='--', label='test pred')

    plt.legend(loc=2)

    plt.xlabel('date')

    plt.ylabel('count')

    plt.show()

# x = citibike.index.astype('int64').values.reshape(-1, 1) // 10**9

x_hours = citibike.index.hour.values.reshape(-1, 1) # 시간만 출력

eval_feature(x_hours, y, model) # 사용자 정의 함수

시간만 사용하여 만든 랜덤 포레스트의 예측// R-square = 0.600

# print(citibike.index.dayofweek) : 일요일부터 토요일까지를 0~6까지로 인덱싱 

### 시간데이터에 요일 정보를 추가

x_hours_week = np.hstack([citibike.index.dayofweek.values.reshape(-1, 1),

                          citibike.index.hour.values.reshape(-1 ,1)])

eval_feature(x_hours_week, y, model)

시간과 요일 특성을 사용해 만든 랜덤 포레스트의 예측//R-square = 0.842

# library import

from sklearn.linear_model import LinearRegression, Ridge

eval_feature(x_hours_week, y, LinearRegression())

시간과 요일 특성을 사용하여 만든 선형 회귀의 예측, R-square=0.132

# library import

from sklearn.preprocessing import OneHotEncoder

# encoder load

encoder = OneHotEncoder()

encoder.fit(x_hours_week)

x_hours_week_encoder = encoder.transform(x_hours_week).toarray() # ndarray로 전환

eval_feature(x_hours_week_encoder, y, Ridge())

시간과 요일의 원-핫 인코딩을 사용해 만든 선형 회귀의 예측, R-Square = 0.619

# library import

from sklearn.preprocessing import PolynomialFeatures

poly_transformer = PolynomialFeatures(degree=2, interaction_only=True, include_bias=False) # include_bias=왼쪽에 절편항 추가

poly_transformer.fit(x_hours_week_encoder) # 인코더 학습

x_hours_week_encoder_poly = poly_transformer.transform(x_hours_week_encoder) #  인코더를 데이터에 적용

ridge = Ridge()

eval_feature(x_hours_week_encoder_poly, y, ridge)

시간과 요일의 곱을 특성으로 사용해서 만든 선형 회귀의 예측, R-Square = 0.845

hour = ['{:02d}:00'.format(i) for i in range(0, 24, 3)]

day = ['mon', 'tue', 'wed', 'thr', 'fri','sat', 'sun']

features = day + hour

### get_featrues_names 메소드를 통해 PolynomialFeatures로 추출한 상호작용 특성에 이름을 달아주고 계수가 0이 아닌 특성만 선형

features_poly = poly_transformer.get_feature_names(features)

features_nonzero = np.array(features_poly)[ridge.coef_ != 0]

coef_nonzero = ridge.coef_[ridge.coef_ != 0]

x_axis_data = np.arange(len(coef_nonzero))

plt.scatter(x_axis_data, coef_nonzero)

plt.xticks(x_axis_data, features_nonzero, rotation=90)

plt.xlabel('feature name')

plt.ylabel('coefficient size')

plt.show()

시간과 요일의 곱을 사용한 선형 모델의 계수

decision tree : [1]Decision Tree

Lasso : Lasso

### library import

from sklearn.datasets import load_breast_cancer

from sklearn.feature_selection import SelectPercentile

from sklearn.model_selection import train_test_split

import numpy as np

import matplotlib

import matplotlib.pyplot as plt

### matplotlib 한글출력, 축- 설정

matplotlib.rc('font', family='AppleGothic')

plt.rcParams['axes.unicode_minus'] = False

### dataload

cancer = load_breast_cancer()

### preprocessing

rng = np.random.RandomState(seed=0) # random seed

noise = rng.normal(size=(cancer.data.shape[0], 50)) # normal분포에서 cancer.data.shape[0]x50의 데이터추출

cancer_data_noise = np.hstack([cancer.data, noise]) # data 병합

print('cancer_data_noise.shape \n{}'.format(cancer_data_noise.shape)) # (569, 80)

### data 분할

x_train, x_test, y_train, y_test = \

  train_test_split(cancer_data_noise, cancer.target,

                   test_size=0.5, random_state=0)

### preprocessing 메소드 호출 및 적용

select = SelectPercentile(percentile=50).fit(x_train, y_train) # percentile: 50%만 선택

x_train_select = select.transform(x_train) # 적용

x_test_selected = select.transform(x_test)

print('x_train.shape \n{}'.format(x_train.shape))

print('x_train_select.shape \n{}'.format(x_train_select.shape))

합친 데이터와 선택된 데이터의 형태

idx = select.get_support()^[각주:1]

print('idx \n{}'.format(idx))

논리값으로 만들어진 idx

plt.matshow(idx.reshape(1, -1), cmap='gray_r')

plt.yticks([]) # 축눈금없애기

plt.xlabel('feature number')

plt.show()

SelectPercentile이 선택한 특성

Logistic Regression 링크 참조

[1]Logistic Regression[1], [2]Logistic Regression[2]

### library import

from sklearn.linear_model import LogisticRegression

### model 호출

lr = LogisticRegression()

### 전체특성을 사용했을 때 정확도

lr.fit(x_train, y_train)

print('전체 특성을 사용한 점수: \n{:.3f}'.format(lr.score(x_test, y_test))) # 0.937

### 일부특성을 사용했을 때 정확도

lr.fit(x_train_select, y_train)

print('선택된 특성을 사용한 점수 \n{:.3f}'.format(lr.score(x_test_selected, y_test))) # 0.951

tree model

[1]Decision Tree -- intro, [2]Decision Tree, [3]Decision Tree Regressor

random forest

[1]Random Forest -- intro, [2]Random Forest

gradient Boosting Model

[1]Gradient Boosting Model

neural network

[1]Neural Network(Deep Learning)

linear model

[1]Linear Regression -- intro, [2]LinearRegression, [3]Ridge, [4]Lasso

# library import

import numpy as np

import matplotlib.pyplot as plt

import matplotlib

# matplotlib 한글/ 축- 설정

matplotlib.rc('font', family='AppleGothic')

plt.rcParams['axes.unicode_minus']

# datasets

rnd = np.random.RandomState(seed=0) # random seed

x_org = rnd.normal(size=(1000,3)) # 정규분포

w = rnd.normal(size=3) # 정규분포

x = rnd.poisson(lam=np.exp(x_org)) # poisson distribution, lam = lambda

y = np.dot(x_org, w) # x_org(1000,3) , w(3,)이므로 (1000,)형태의 데이터가 만들어짐

print('x[:10, 0] \n{}'.format(x[:10, 0]))

print('특성 종류 \n{}'.format(np.unique(x[:, 0])))

print('특성 빈도 \n{}'.format(np.bincount(x[:,0])))

x의 개략적인 구조 확인

# visualization

_, axes = plt.subplots(1, 3)

for i, ax in enumerate(axes.ravel()):

    bins = np.bincount(x[:, i])

    ax.bar(range(len(bins)), bins, color='grey')

    ax.hlines(y=263, xmin=-1, xmax=len(bins)+1, alpha=0.4, linestyles=':', colors='red')

    ax.hlines(y=129, xmin=-1, xmax=len(bins)+1, alpha=0.4, linestyles=':', colors='red')

    ax.set_xlabel('x의 {}번째 특성'.format(i+1))

    ax.set_ylabel('frequency')

plt.show()

x의 특성별 histogram

# library import: Ridge는 위의 링크 참조

from sklearn.linear_model import Ridge

from sklearn.model_selection import train_test_split

# data 분할

x_train, x_test, y_train, y_test =\

  train_test_split(x, y,

                   random_state=0, test_size=0.3)

# model 유효성 평가

for alpha in [0.001, 1, 1000]:

    ridge = Ridge(alpha=alpha).fit(x_train, y_train)

    print('\nalpha={}, {}의 정확도 {:.3f}'.format(alpha, ridge.__class__.__name__,ridge.score(x_test, y_test)))

alpha값에 따란 Ridge의 정확도

### 정확도가 51.3%로 좋지 못하지만, 규제를 풀수록(alpha가 커질수록) 정확도가 낮아지는 것을 확인

### log scaling

x_train_log = np.log(x_train + 1) # 0이 있으면 Inf가 나오기 때문에 1을 더함

x_test_log = np.log(x_test + 1)

###  visualization

_, bins = np.histogram(x_train_log, bins=10)

_, axes = plt.subplots(1, 3)

for i, ax in enumerate(axes.ravel()):

    ax.hist(x_train_log[:, i], bins=bins, color='darkblue')

    ax.hlines(y=200, xmin=-1, xmax=len(bins)+1, alpha=0.4, linestyles=':', colors='red')

    ax.hlines(y=100, xmin=-1, xmax=len(bins)+1, alpha=0.4, linestyles=':', colors= 'red')

    ax.set_xlabel('logx의 {}번째 특성'.format(i+1))

    ax.set_ylabel('frequency')

plt.show()

로그 변환 후 x 특성 값의 histogram

Ridge 참조

• Ridge

Random Forest 참조

• Random Forest -- intro

• Random Forest

### load library

from sklearn.datasets import load_boston

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import MinMaxScaler, OneHotEncoder, PolynomialFeatures

from sklearn.linear_model import Ridge

from sklearn.ensemble import RandomForestRegressor

### data load

boston = load_boston() 

# print(boston.keys())

x_train, x_test, y_train, y_test = \

  train_test_split(boston.data, boston.target,

                   test_size=0.3, random_state=0)

### scale 조정

scaler_mms = MinMaxScaler().fit(x_train) # scaler 호출

x_train_scaled = scaler_mms.transform(x_train) # scaler를 x_train에 적용

x_test_scaled = scaler_mms.transform(x_test) # scaler를 x_test를 적용

### model

randfor = RandomForestRegressor(n_estimators=100, random_state=0, n_jobs=-1) # n_jobs = 코어의 수(-1 : all)

ridge = Ridge()

models = [randfor, ridge]

### model 적용 및 성능 테스트

for degree in range(1, 6):

    poly = PolynomialFeatures(degree=degree, include_bias=False).fit(x_train_scaled)# include_bias = True: x_train_scaled 맨 왼쪽에 상수항 추가. 

    x_train_poly = poly.transform(x_train_scaled)

    x_test_poly = poly.transform(x_test_scaled)

    print('degree={}'.format(degree))

    print('x_train.shape={}'.format(x_train.shape))

    print('x_train_poly.shape={}\n'.format(x_train_poly.shape))

    print('원래 특성과 polynomial 한 특성의 수 \n==> origin:{}, poly:{}\n'.format(

        boston.data.shape[1], len(poly.get_feature_names())))

    for model in models:

        conf = model.fit(x_train_scaled, y_train)

        print('교차항이 없을 때 {} 점수: {:.3f}'.format(

            model.__class__.__name__, model.score(x_test_scaled, y_test))) # __class__.__name__ : class이름 호출

        conf = model.fit(x_train_poly, y_train)

        print('degree={}, 교차항이 있을 때 {} 점수{:.3f}\n'.format(

            degree, model.__class__.__name__, model.score(x_test_poly, y_test)))

    ptrint('----------------------------------------------')

모델 성능 테스트 평가의 일부분

### import library

import matplotlib.pyplot as plt

import matplotlib

from sklearn.preprocessing import OneHotEncoder

from mglearn.datasets import make_wave

import numpy as np

### matplotlib 설정

matplotlib.rc('font', family='AppleGothic')

plt.rcParams['axes.unicode_minus'] = False

### datasets

x , y = make_wave(n_samples=100)

# print(x)

# print(y)

### binding

bins = np.linspace(-3, 3, num=11)

# print(bins)

which_bins = np.digitize[각주:1](x, bins=bins) # bins: 구간

# print(x[:5])

# print(which_bins)

encoder = OneHotEncoder(sparse=False).fit(which_bins) # OneHotEncoder 메소드 호출 후 적용

x_binned = encoder.transform(which_bins)

print('x_binned[:5] \n{}'.format(x_binned[:5]))

wave데이터의 x에서 one-hot-encoding을 적용한 데이터의 일부

### import library

from sklearn.linear_model import LinearRegression

### model 호출 후 OHE(One Hot Encoding)된 데이터 적용

lreg = LinearRegression().fit(x_binned, y)

### 축 생성

line = np.linspace(-3, 3, num=1000, endpoint=False).reshape(-1, 1)

### np.digitize(line, bins=bins) : line의 각 데이터 포인트가 bins의 어디 구간인지 표현 ==> 1~10 까지 숫자

### encoder.transform(np.digitize(line, bins=bins)) : 1 ~ 10까지를 OHE로 표현 ex) 1 => [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]  // 3 => [0, 0, 1, 0, 0, 0, 0, 0 ,0 ,0]

line_binned = encoder.transform(np.digitize(line, bins=bins))

### predict

lreg_pred = lreg.predict(line_binned) 

### 각 구간에서는 같은 특성(ex)[0, 1, 0, 0, 0 ,0 ,0 ,0 ,0 ,0])을 가지기 때문에 각 구간에서는 일정한 값으로 예측됨

### 구간에서 기울기 값 추가

x_combined = np.hstack([x, x_binned]) # 원래 특성x와 구간별로 OHE된 리스트를 결합

print('x_combined.shape \n{}'.format(x_combined.shape))

line_combined = np.hstack([line, line_binned])

### model 호출 후 결합한 데이터를 적용

lreg_comb = LinearRegression().fit(x_combined, y)

### predict

pred_lreg_comb = lreg_comb.predict(line_combined)

### visualization

plt.scatter(x[:, 0], y, marker='o', c='k') # c = color

plt.plot(line, lreg_pred, label='binding linear Reg', ls='--', lw=3) # ls = linestyles,  lw= linewidths

plt.plot(line, pred_lreg_comb, label='plus original feature')

plt.vlines(bins, ymin=-3, ymax=3, lw=1, alpha=0.2, linestyles=':') # lw = linewidths

plt.ylabel('output regression')

plt.xlabel('input feature')

plt.legend(loc=2) # loc = 1, 2, 3, 4 : 오른쪽 위, 왼쪽 위, 왼쪽 아래, 오른쪽 아래

plt.show()

### data 축 추가

x_product = np.hstack([x_binned, x * x_binned])

line_proudct = np.hstack([line_binned, line*line_binned])

print(x_product.shape) # (100, 20)

### x_binned는 데이터 포인트가 속한 구간의 one-hot-encoding이므로 x를 곱하면 해당 구간이외에는 모두 0

### 모델 호출 후 결합한 데이터 적용

linear_reg = LinearRegression().fit(x_product, y)

pred_linear_reg = linear_reg.predict(line_proudct)

### visualization

plt.plot(line, pred_linear_reg, label='original feature를 곱한 linear regression')

for bin in bins:

    plt.plot([bin, bin], [-3, 3], ls=':', c='k', lw=1, alpha=0.4)

plt.scatter(x[:, 0], y, marker='o', c='k')

plt.ylabel('output regression')

plt.xlabel('input feature')

plt.legend(loc=2)

plt.show()

### 구간 나누기는 연속형 특성을 확장하는 방법 중 하나

### 특성 x가 주어지면 x**2, x**3, x**4 ... 등을 시도 가능하여 여러차원으로 까지 늘릴 수 있음

### preprocessing의 PolynomialFeatures에 구현되어 있음

from sklearn.preprocessing import PolynomialFeatures

### degree: x**10까지, include_bias=True: 절편을 그리기 위해 값이 1인 특성을 왼쪽에 추가

poly = PolynomialFeatures(degree=10, include_bias=False) 

poly.fit(x)

x_poly = poly.transform(x)

# 10차원을 사용했으므로 10개의 특성이 만들어짐

print('x_poly.shape \n{}'.format(x_poly.shape))

print('x[:5] \n{}'.format(x[:5]))

print('x_poly[:5] \n{}'.format(x_poly[:5]))

print('poly.get_feature_names() \n{}'.format(poly.get_feature_names()))

만들어진 특성의 모양

SVR 은 아래 링크 참조

Kernelized Support Vector Machines

### viusalization

### 다항식을 결합한 특성을 적용

poly_reg = LinearRegression().fit(x_poly, y)

line_poly = poly.transform(line)

pred_poly_reg = poly_reg.predict(line_poly)

plt.plot(line, pred_poly_reg, label='polynomial linear regression')

plt.scatter(x[:, 0], y, marker='o', c='k')

plt.xlabel('input feature')

plt.ylabel('output regression')

plt.vlines(bins, ymin=-3, ymax=3, linestyles=':', colors='grey', alpha=0.4) # linestyles = ':'  ==> dash

from sklearn.svm import SVR

for gamma in [1, 10]:

    svr = SVR(gamma=gamma).fit(x, y)

    plt.plot(line, svr.predict(line), label='SVR gamma={}'.format(gamma))

plt.legend(loc=(-0.001, 1.01))

plt.show()

# library import

from sklearn.linear_model import LinearRegression

from sklearn.tree import DecisionTreeRegressor

from mglearn.datasets import make_wave

import numpy as np

import matplotlib.pyplot as plt

import matplotlib

# matplotlib 설정

matplotlib.rc('font', family='AppleGothic') # 한글

plt.rcParams['axes.unicode_minus'] = False # 축 -

# dataset

x, y = make_wave(n_samples=100)

line = np.linspace(-3, 3, num=1000, endpoint=False).reshape(-1, 1)

# model fit

# decision tree

decision_tree_reg = DecisionTreeRegressor(min_samples_split=3).fit(x, y) # min_samples_split^[각주:1]

plt.plot(line, decision_tree_reg.predict(line), label='decision tree')

# linear regression

linear_reg = LinearRegression().fit(x, y)

plt.plot(line, linear_reg.predict(line), ls='--', label='linear regression') # ls = linestyle, 

plt.scatter(x[:, 0], y, marker='o', c='k') # c=color

plt.ylabel('output regression')

plt.xlabel('input feature')

plt.legend(loc=2)

plt.show()

### step1. 구간을 먼저 정하고 ==> 같은 간격으로 10개의 구간을 정의

bins = np.linspace(-3, 3, num=11) # num: 쪼갤 갯수

print('구간: \n{}'.format(bins))

print('구간의 수 \n{}'.format(len(bins)-1))

-3, 3 사이의 구간과 구간의 수

### step2. 각 데이터 포인트가 어느 구간에 속하는지 기록

which_bin = np.digitize(x, bins=bins) # 데이터, 구간

print('데이터 포인트 처음 5개 \n{}'.format(x[:5]))

print('데이터 포인트의 소속구간 처음 5개 \n{}'.format(which_bin[:5]))

각 구간에 맵핑한 x 데이터의 일부

# library import

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder(sparse=False) # sparse matrix: 희소행렬, True면 1이 있는 값의 위치와 값을 나타냄

encoder.fit(which_bin)

x_binned = encoder.transform(which_bin)

print('x_binned[:5] \n{}'.format(x_binned[:5]))

one-hot-encoder된 구간에 맵핑된 x 데이터의 일부

### 구간을 10개로 정의했기 때문에 변환된 데이터셋 x_binned는 10개의 특성으로 구간

print('x_binned.shape \n{}'.format(x_binned.shape)) # (100, 10)

### one-hot-encoding된 데이터로 선형 회귀 모델과 결정트리의 모델을 새로 만들면

line_binned = encoder.transform(np.digitize(line, bins=bins))

plt.scatter(x[:, 0], y, marker='o', c='k') # c = color

lr_reg = LinearRegression().fit(x_binned, y)

plt.plot(line, lr_reg.predict(line_binned), label='binding linear regression', lw=5) # lw = linewidth

tree_reg = DecisionTreeRegressor(min_samples_split=3).fit(x_binned, y)

plt.plot(line, tree_reg.predict(line_binned), ls='--', label='binding decision tree', c='red') # ls = linestyle, c = color

plt.vlines(bins, ymin=-3, ymax=3, lw=1, alpha=0.2) # lw = linewidth

plt.legend(loc=2)

plt.ylabel('output regression')

plt.xlabel('input feature')

plt.show()

# library import

import pandas as pd

# DataFrame 생성

df = pd.DataFrame({'숫자 특성': [0, 1, 2, 1],

                        'factor형 특성': ['핸드폰', '밀스', '핸드폰', '상자']})

# DataFrame 출력

print('df \n{}'.format(df))

# one-hot-encoding 적용

df_dummy = pd.get_dummies(df)

print('df_dummy \n{}'.format(df_dummy))

### get_dummies를 사용하면 문자열 특성만 인코딩되며 숫자 특성은 바뀌지 않음

### series를 str형태로 변형후 get_dummies 적용

### get_dummies를 적용할 때 columns를 직접 입력

### 방법 1

df1 = df.copy() #  DataFrame 복사

df1['숫자 특성'] = df1['숫자 특성'].astype(str) # 타입변형

df1_dummies = pd.get_dummies(df1)

print('df1_dummies \n{}'.format(df1_dummies))

### 방법 2

df2_dummies = pd.get_dummies(df, columns=['숫자 특성', 'factor형 특성']) # get_dummies 적용시 columns 지정

print('df2_dummies \n{}'.format(df2_dummies))

# library import

import pandas as pd

# data load

adult.csv

adult = pd.read_csv('adult.csv', index_col=False) 

# 원하는 열만 추출

adult = adult[['age', 'workclass', 'education', 'gender', 'hours-per-week', 'occupation', 'income']]

print('adult.head() \n{}'.format(adult.head()))

print('columns names \n{}'.format(adult.columns)) # 열 출력

print('age의 갯수 \n{}'.format(adult.age.value_counts())) # dataframe.열.메소드

print('workclass의 갯수 \n{}'.format(adult.workclass.value_counts())) # ? 값 있음을 확인

print('education의 갯수 \n{}'.format(adult.education.value_counts())) 

print('gender의 갯수 \n{}'.format(adult.gender.value_counts()))

print('hours-per-week의 갯수 \n{}'.format(adult['hours-per-week'].value_counts())) # 열이름이 특수문자나 띄어쓰기 있으면 ['열이름']으로 접근

print('occupation의 갯수 \n{}'.format(adult.occupation.value_counts())) # ? 값 있음을 확인

print('income의 갯수 \n{}'.format(adult.income.value_counts()))

adult_dummies = pd.get_dummies(adult)

print('원본 특성:\n', list(adult.columns), '\n')

print('get_dummies 후의 특성 :\n', list(adult_dummies.columns))

원본 특성과 get_dummies후의 특성, 'age', 'hours-per-week'를 제외하고 전부 나뉘어진 것을 볼 수 있음

### 숫자형인 age, hours-per-week는 그대로지만 factor형 특성은 값마다 새로운 특성이 만들어짐

### pandas의 values속성을 이용해 numpy 배열로 바꿀수 있음

### target을 income으로 잡을 것이므로 income을 데이터에서 분리해야함

### numpy에서 np.arange(11)[0:10]은 인덱스가 10인 항목을 포함하지 않음

### 그러나 pandas에서 범위 끝은 그 열을 포함함

features = adult_dummies.loc[:, 'age':'occupation_ Transport-moving']

import numpy as np

x = features.values # feature를 numpy배열로 변환

y = adult_dummies['income_ >50K'].values # 타겟데이터를 numpy 배열로 변환

print('x.shape: {}. y.shape: {}'.format(x.shape, y.shape)) # x.shape: (31143, 44), y.shape:(31143,)

from sklearn.linear_model import LogisticRegression

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = \

  train_test_split(x, y,

                   test_size=0.3, random_state=0)

logreg = LogisticRegression().fit(x_train, y_train)

print('테스트 점수 \n{:.3f}'.format(logreg.score(x_test, y_test))) # 0.813

### adult 데이터셋에서는 factor형 변수가 문자열로 인코딩 되어있음

### 철자 오류가 날 수 있지만 다른 한 편으로는 변수가 factor형이란 것을 확실하게 알 수가 있음

### 하지만 저장 공간을 절약하거나 데이터 취합 방식에 따라 범주형 변수가 숫자로 인코딩 된 경우가 많음

### 예를들어 adult 데이터셋에 있는 인구조사 데이터가 설문지를 이용해 모은 것이라고 가정하면 workclass에 대합 대답은 0, 1 ,2 등이 됨 ==> 이 열은 0~8까지의 숫자로 채워지

### 게 되고 누군가 이 데이터셋을 보면 이 변수를 연속형으로 다뤄야할지 factor형으로 다뤄야할지 단번에 알아채기가 어려움. 그러나 숫자가 workclass를 나타낸다고 알게  되면

### 이  값은 이산적이므로 연속형 변수로 다루면 안된다는 것이 명확해짐

# load library

from sklearn.datasets import fetch_lfw_people

import numpy as np

import matplotlib

import matplotlib.pyplot as plt

from sklearn.decomposition import PCA, NMF

from sklearn.preprocessing import MinMaxScaler

from sklearn.cluster import DBSCAN

# matplotlib 설정 

matplotlib.rc('font', family='AppleGothic')

plt.rcParams['axes.unicode_minus'] = False

people = fetch_lfw_people(min_faces_per_person=20, resize=0.7, color=False) # min_faces_per_person = 겹치지 않는 최소 얼굴 수, 

image_size = people.images[0].shape

# outlier 있는지 확인 

_, bins = np.histogram(people.target, bins=100)

plt.hist(people.target, bins=bins)

plt.xticks(range(len(people.target_names)), people.target_names, rotation=90, ha='center')

plt.hlines(50, xmin=0, xmax=bins[-1], linestyles='--')# 수평선

plt.show()

# 특성이 50개

idx = np.zeros(people.target.shape, dtype=np.bool)

for tg in np.unique(people.target):

    idx[np.where(people.target == tg)[0][:50]] = 1

# 데이터 분할

x_people = people.data[idx]

y_people = people.target[idx]

# 전처리

scaler_mms = MinMaxScaler()

x_people_scaled = scaler_mms.fit_transform(x_people)

# pca는 whiten 옵션을 True를 주면 전처리효과가 발생

# 훈련데이터를 PCA주성분 100개로 변환

pca = PCA(n_components=100, random_state=0, whiten=True).fit(x_people)

x_pca = pca.transform(x_people)

# 훈련데이터를 NMF 성분 100개로 변환

nmf = NMF(n_components=100, random_state=0).fit(x_people_scaled)

x_nmf = nmf.transform(x_people_scaled)

# DBSCAN에서 알맞은 min_sample값과 eps구하기

for min_sample in [3, 5, 7, 9]:

    for eps in [0.2, 0.4, 0.9, 1, 3, 5, 7, 9, 11, 13, 15, 17]:

        dbscan = DBSCAN(n_jobs=-1, min_samples=min_sample, eps=eps)

        labels_pca = dbscan.fit_predict(x_pca) # pca를 이용한 성분을 이용한 dbscan을 예측

        labels_nmf = dbscan.fit_predict(x_nmf) # nmf를 이용한 성분을 이용한 dbscan으로 예측

        print('︎=== min_sample:{}, eps:{} ==='.format(min_sample, eps))

        print('')

        print('pca ==> cluster 수: {}'.format(len(np.unique(labels_pca))))

        print('pca ==> cluster 크기: {}\n'.format(np.bincount(labels_pca+1)))

        print('nmf ==> cluster 수: {}'.format(len(np.unique(labels_nmf))))

        print('nmf ==> cluster 크기: {}'.format(np.bincount(labels_nmf+1)))

        print('---------------------------------------')

### pca : min_sample=3, eps=7일 때 가장 많은 클러스터가 생김

### nmf : min_sample=3, eps=0.9일 때 가장 많은 클러스터가 생김

# 가장 많은 클러스터가 생긴 eps와 n_sample 츨력

dbscan = DBSCAN(min_samples=3, eps=7, n_jobs=-1) # n_jobs = 코어의 갯수

labels_pca = dbscan.fit_predict(x_pca)

dbscan = DBSCAN(min_samples=3, eps=0.9, n_jobs=-1)

labels_nmf = dbscan.fit_predict(x_nmf)

# pca 주성분, DBSCAN 을 이용한 시각화

for cluster in range(labels_pca.max() + 1):

    idx = labels_pca == cluster 

    n_images = np.sum(idx) # idx중 true인 것의 갯수

    fig, axes = plt.subplots(1,n_images, figsize=(n_images*1.5, 4), # figsize=(a,b) axb 그림사이즈

                            subplot_kw={'xticks':(), 'yticks':()})

    for image, label, ax in zip(x_people[idx], y_people[idx], axes.ravel()):

        ax.imshow(image.reshape(image_size))

        ax.set_title(people.target_names[label].split()[-1])

plt.gray()

plt.show()

# PCA 주성분 분석

pca = PCA(n_components=100, whiten=True, random_state=0) 

pca.fit_transform(x_people_scaled) # 모델 fitting

x_pca = pca.transform(x_people_scaled) # 적용한 모델을 원래 데이터에 적용

# NMF 분석

nmf = NMF(n_components=100, random_state=0)

nmf.fit_transform(x_people_scaled) # 모델 fitting

x_nmf = nmf.transform(x_people_scaled) # 적용한 모델을 원래 데이터에 적용

# DBSCAN Agglomerative Algorithm

dbscan = DBSCAN() 

labels_pca = dbscan.fit_predict(x_pca) # pca를 군집화

labels_nmf = dbscan.fit_predict(x_nmf) # nmf를 군집화

print('\n레이블 종류: \npca: {}\nnmf: {}'.format(np.unique(labels_pca), np.unique(labels_nmf))) # [-1], 

### PCA, NMF 모두 레이블이 -1뿐임 ==> DBSCAN에 의해 noise point로 처리

### solution:

### 1. eps값을 크게 ==> 데이터 point의 이웃의수 증가

### 2. min_samples 값을 작게 ==> cluster에 모을 point 수를 감소

### 알맞은 eps값 확인 (-1, 0)

for eps in [0.5, 0.7, 0.9, 1, 5, 9, 15, 17]: # eps 목록

    dbscan = DBSCAN(min_samples=3, eps=eps)

    labels_pca = dbscan.fit_predict(x_pca)

    labels_nmf = dbscan.fit_predict(x_nmf)

    print('pca ==> n_samples: {}, eps: {:.3f} - {}'.format(3, eps, np.unique(labels_pca)))

    print('nmf ==> n_samples: {}, eps: {:.3f} - {}\n'.format(3, eps, np.unique(labels_nmf)))

# DBSCAN -- pca

dbscan = DBSCAN(min_samples=3, eps=15)

labels_pca = dbscan.fit_predict(x_pca)

# DBSCAN -- NMF

dbscan = DBSCAN(min_samples=3, eps=1)

labels_nmf = dbscan.fit_predict(x_nmf)

print('레이블 종류: \npca: {}\nnmf: {}'.format(np.unique(labels_pca), np.unique(labels_nmf))) # (-1, 0)

pca_count = np.bincount(labels_pca + 1) # bincount는 음수는 표현할 수없으니 1을 더함

nmf_count = np.bincount(labels_nmf + 1)

print('클러스터별 포인트 수:\npca: {}\nnmf: {}'.format(pca_count, nmf_count))

### visualization

noise_pca = x_people[labels_pca == -1] # noise 값만 추출

noise_nmf = x_people[labels_nmf == -1]

fig, axes = plt.subplots(3, 9,

                        subplot_kw={'xticks':(), 'yticks':()},

                        gridspec_kw={'hspace':0.5})

for image, ax in zip(noise_pca, axes.ravel()):

    ax.imshow(image.reshape(people_image))

plt.gray()

plt.show()

fig, axes = plt.subplots(3, 9,

                        subplot_kw={'xticks':(), 'yticks':()},

                        gridspec_kw={'hspace':0.5})

for image, ax in zip(noise_nmf, axes.ravel()):

    ax.imshow(image.reshape(people_image))

plt.gray()

plt.show()