import numpy as np
data_origin = [[30, 100], [20, 50], [35, np.nan],
               [25, 80], [30, 70], [40, 60]]
data_origin

import numpy as np
data_origin = [[30, np.nan], [20, 50], [35, np.nan],
               [25, 80], [30, np.nan], [40, 60]]
data_origin

# 보간법 1 : 평균값으로 결측값을 대체
from sklearn.preprocessing import Imputer
imp_mean = Imputer(missing_values='NaN', strategy='mean')
imp_mean.fit(data_origin)

data_mean_imp = imp_mean.transform(data_origin)
print(data_mean_imp)

# 보간법 2 : 중간값으로 결측값을 대체
imp_median = Imputer(missing_values='NaN', strategy='median')
imp_median.fit(data_origin)

data_median_imp = imp_median.transform(data_origin)
print(data_median_imp)

# 보간법 3 : 새로운 데이터에 보간법 적용
new = [[20, np.nan],
       [30, np.nan],
       [np.nan, 70],
       [np.nan, np.nan]]

new_mean_imp = imp_mean.transform(new)
print(new_mean_imp)

# 불완전한 당뇨질환 데이터를 불러온다
from sklearn import datasets
dataset   = datasets.load_diabetes()
X_full, y = dataset.data, dataset.target

# 25% 의 결측치를 OverWriting 한다
m, n      = X_full.shape
m_missing = int(m * 0.25)
print("전체 데이터 Index : {:,}\n결측 데이터 Index : {:,}".format(m, m_missing))

# 결측값이 제거된 DataSet의 R^2 추정치를 계산한다
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score
regressor        = RandomForestRegressor(random_state = 42, 
                                         max_depth = 10, 
                                         n_estimators = 100)
score_rm_missing = cross_val_score(
    regressor, X_rm_missing, y_rm_missing).mean()
print('결측값이 제거된 DataSet 의 R^2 : {0:.2f}'.format(score_rm_missing))

# Imputation with mean value
imp_mean   = Imputer(missing_values='NaN', strategy='mean')
X_mean_imp = imp_mean.fit_transform(X_missing)
# Estimate R^2 on the data set with missing samples removed
regressor      = RandomForestRegressor(random_state=42, max_depth=10, n_estimators=100)
score_mean_imp = cross_val_score(regressor, X_mean_imp, y).mean()
print('Score with the data set with missing values replaced by mean: {0:.2f}'.format(score_mean_imp))

# Estimate R^2 on the full data set
regressor  = RandomForestRegressor(random_state = 42, 
                                   max_depth = 10, 
                                   n_estimators = 500)
score_full = cross_val_score(regressor, X_full, y).mean()
print('Score with the full data set: {0:.2f}'.format(score_full))

# 손으로 작성한 DataSet을 불러온다
from sklearn.datasets import load_digits
dataset = load_digits()
X, y    = dataset.data, dataset.target
print(X.shape)

# 64차원 원본 데이터의 정확도를 측정한다
from sklearn.svm import SVC
from sklearn.model_selection import cross_val_score
classifier = SVC(gamma=0.005)
score      = cross_val_score(classifier, X, y).mean()
print('Score with the original data set: {0:.2f}'.format(score))

# Feature selection with random forest
from sklearn.ensemble import RandomForestClassifier
random_forest = RandomForestClassifier(n_estimators=100, criterion='gini', n_jobs=-1)
random_forest.fit(X, y)

# Sort features based on their importancies
feature_sorted = np.argsort(random_forest.feature_importances_)

# Select different number of top features
K = [10, 15, 25, 35, 45]
for k in K:
    top_K_features   = feature_sorted[-k:]
    X_k_selected     = X[:, top_K_features]
    # Estimate accuracy on the data set with k selected features
    classifier       = SVC(gamma=0.005)
    score_k_features = cross_val_score(classifier, X_k_selected, y).mean()
    print('Score with the data set of top {0} features: {1:.2f}'.format(k, score_k_features))

from sklearn.decomposition import PCA

N = [10, 15, 25, 35, 45]
for n in N:
    pca = PCA(n_components=n)
    X_n_kept = pca.fit_transform(X)
    # Estimate accuracy on the data set with top n components
    classifier = SVC(gamma=0.005)
    score_n_components = cross_val_score(classifier, X_n_kept, y).mean()
    print('Score with the data set of top {0} components: {1:.2f}'.format(n, score_n_components))

from sklearn.preprocessing import Binarizer

X = [[4], [1], [3], [0]]
binarizer = Binarizer(threshold=2.9)
X_new = binarizer.fit_transform(X)
print(X_new)

from sklearn.preprocessing import PolynomialFeatures

X     = [[2, 4], [1, 3], [3, 2], [0, 3]]
poly  = PolynomialFeatures(degree=2)
X_new = poly.fit_transform(X)
print(X_new)

# 정규화 작업후 객체를 저장
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)

import pickle
file_name = "./data/scaler.p"
pickle.dump(scaler, open(file_name, "wb" ))
X_scaled_train = scaler.transform(X_train)
print('정규화 작업이 완료된 객체를 {}로 저장'.format(file_name))

# 작업이 완료된 객체로 모델을 학습
from sklearn.svm import SVR
regressor = SVR(C=20)
regressor.fit(X_scaled_train, y_train)
file_name = "./data/regressor.p"
pickle.dump(regressor, open(file_name, "wb"))
print("학습이 완료된 객체를 {}로 저장".format(file_name))

# Monitor
from sklearn.metrics import r2_score
print('Health check on the model, R^2: {0:.3f}'.format(r2_score(y_new, predictions)))