import sklearn
print(sklearn.__version__)

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

import pandas as pd

# 붓꽃 데이터 세트를 로딩
iris = load_iris()

# iris.data는 Iris 데이터 세트에서 피처만으로 된 데이터를 numpy로 가지고 있음
iris_data = iris.data

# iris.target은 붓꽃 데이터 세트에서 레이블(결정 값) 데이터를 numpy로 가지고 있음
iris_label = iris.target

print("iris target 값 : {}".format(iris_label))
print("iris target 명 : {}".format(iris.target_names))

# 붓꽃 데이터 세트를 자세히 보기 위해 DataFrame으로 변환
iris_df = pd.DataFrame(data = iris_data, columns = iris.feature_names)
iris_df["label"] = iris_label
iris_df.head(3)

X_train, X_test, y_train, y_test = train_test_split(iris_data, iris_label, test_size = 0.2, random_state = 11)

# DiecisionTreeClassifier 객체 생성
dt_clf = DecisionTreeClassifier(random_state = 11)

# 학습 수행
dt_clf.fit(X_train, y_train)

# 학습이 완료된 DecisionTreeClassifier 객체에서 테스트 데이터 세트로 예측 수행.
pred = dt_clf.predict(X_test)

pred

from sklearn.metrics import accuracy_score
print("예측 정확도 : {0:.4f}".format(accuracy_score(y_test, pred)))

from sklearn.datasets import load_iris

iris_data = load_iris()
print(type(iris_data))

keys = iris_data.keys()
print("붓꽃 데이터 세트의 키들 : {}".format(keys))

print("feature_names의 type : {}".format(type(iris_data.feature_names)))
print(" feature_names의 shape : {}".format(len(iris_data.feature_names)))
print(iris_data.feature_names)

print("-" * 90)

print("target_names의 type : {}".format(type(iris_data.target_names)))
print(" target_names의 shpae : {}".format(len(iris_data.target_names)))
print(iris_data.target_names)

print("-" * 90)

print("data의 type : {}".format(type(iris_data.data)))
print( "data의 shpae : {}".format(iris_data.data.shape))
print(iris_data.data)

print("-" * 90)

print("target의 type : {}".format(type(iris_data.target)))
print(" target의 shape : {}".format(iris_data.target.shape))
print(iris_data.target)

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

iris = load_iris()
dt_clf = DecisionTreeClassifier()
train_data = iris.data
train_label = iris.target

# 학습 수행
dt_clf.fit(train_data, train_label)

# 학습 데이터 셋으로 예측 수행
pred = dt_clf.predict(train_data)
print("예측 정확도 : {}".format(accuracy_score(train_label, pred)))

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split


dt_clf = DecisionTreeClassifier()
iris_data = load_iris()

X_train, X_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, 
                                                    test_size = 0.3, random_state = 121)

dt_clf.fit(X_train, y_train)
pred = dt_clf.predict(X_test)
print("예측 정확도 : {:.4f}".format(accuracy_score(y_test, pred)))

import pandas as pd

iris_df = pd.DataFrame(iris_data.data, columns = iris_data.feature_names)
iris_df["target"] = iris_data.target
iris_df.head()

ftr_df = iris_df.iloc[:, :-1]
tgt_df = iris_df.iloc[:, -1]

X_train, X_test, y_train, y_test = train_test_split(ftr_df, tgt_df, 
                                                    test_size = 0.3, random_state = 121)

print(type(X_train), type(X_test), type(y_train), type(y_test))

dt_clf = DecisionTreeClassifier()
dt_clf.fit(X_train, y_train)
pred = dt_clf.predict(X_test)
print("예측 정확도 : {0:.4f}".format(accuracy_score(y_test, pred)))

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
from sklearn.model_selection import KFold
from sklearn.datasets import load_iris
import numpy as np

iris = load_iris()
features = iris.data
label = iris.target
dt_clf = DecisionTreeClassifier(random_state = 156)

# 5개의 폴드 세트로 분리하는 KFold 객체와 폴드 세트별 정확도를 담을 리스트 객체 생성
kfold = KFold(n_splits = 5)
cv_accuracy = []
print("붓꽃 데이터 세트 크기 : {}".format(features.shape[0]))

n_iter = 0

# KFold 객체의 split() 호출하면 폴드 별 학습용, 검증용 테스트의 로우 인덱스를 array로 반환
for train_index, test_index in kfold.split(features) : 
    # kfold.split()으로 반환된 인덱스를 이용하여 학습용, 검증용 테스트 데이터 추출
    X_train, X_test = features[train_index], features[test_index]
    y_train, y_test = label[train_index], label[test_index]
    
    # 학습 및 예측
    dt_clf.fit(X_train, y_train)
    pred = dt_clf.predict(X_test)
    n_iter += 1
    
    # 반복 시 마다 정확도 측정
    accuracy = np.round(accuracy_score(y_test, pred), 4)
    train_size = X_train.shape[0]
    test_size = X_test.shape[0]
    print("{} 교차 검증 정확도 : {}, 학습 데이터 크기 : {}, 검증 데이터 크기 : {}"
         .format(n_iter, accuracy, train_size, test_size))
    print("{} 검증 세트 인덱스 : {}".format(n_iter, test_index))
    
    cv_accuracy.append(accuracy)
    
    print("")
    
# 개별 iteration별 정확도를 합하여 평균 정확도 계산
print("평균 검증 정확도 : {}".format(np.mean(cv_accuracy)))

import pandas as pd

iris = load_iris()

iris_df = pd.DataFrame(iris.data, columns = iris.feature_names)
iris_df["label"] = iris.target
iris_df["label"].value_counts()

kfold = KFold(n_splits = 3)
# kfold.split(X)는 폴드 세트를 3번 반복할 때 마다 달라지는 학습/테스트용 데이터 로우 인덱스 번호 반환

n_iter = 0
for train_index, test_index in kfold.split(iris_df) :
    n_iter += 1
    label_train = iris_df["label"].iloc[train_index]
    label_test = iris_df["label"].iloc[test_index]
    print("## 교차 검증 : {}".format(n_iter))
    print("")
    print("학습 레이블 데이터 분포 : \n{}".format(label_train.value_counts()))
    print("검증 레이블 데이터 분포 : \n{}".format(label_test.value_counts()))
    print("-" * 30)

from sklearn.model_selection import StratifiedKFold

skf = StratifiedKFold(n_splits = 3)
n_iter = 0

for train_index, test_index in skf.split(iris_df, iris_df["label"]) :
    n_iter += 1
    label_train = iris_df["label"].iloc[train_index]
    label_test = iris_df["label"].iloc[test_index]
    print("## 교차 검증 : {}".format(n_iter))
    print("")
    print("학습 레이블 데이터 분포 : \n{}".format(label_train.value_counts()))
    print("검증 레이블 데이터 분포 : \n{}".format(label_test.value_counts()))
    print("-" * 30)

dt_clf = DecisionTreeClassifier(random_state=156)

skfold = StratifiedKFold(n_splits=3)
n_iter=0
cv_accuracy=[]

# StratifiedKFold의 split( ) 호출시 반드시 레이블 데이터 셋도 추가 입력 필요  
for train_index, test_index  in skfold.split(features, label):
    # split( )으로 반환된 인덱스를 이용하여 학습용, 검증용 테스트 데이터 추출
    X_train, X_test = features[train_index], features[test_index]
    y_train, y_test = label[train_index], label[test_index]
    
    #학습 및 예측 
    dt_clf.fit(X_train , y_train)    
    pred = dt_clf.predict(X_test)

    # 반복 시 마다 정확도 측정 
    n_iter += 1
    accuracy = np.round(accuracy_score(y_test,pred), 4)
    train_size = X_train.shape[0]
    test_size = X_test.shape[0]
    
    print('\n#{0} 교차 검증 정확도 :{1}, 학습 데이터 크기: {2}, 검증 데이터 크기: {3}'
          .format(n_iter, accuracy, train_size, test_size))
    print('#{0} 검증 세트 인덱스:{1}'.format(n_iter,test_index))
    cv_accuracy.append(accuracy)
    
# 교차 검증별 정확도 및 평균 정확도 계산 
print('\n## 교차 검증별 정확도:', np.round(cv_accuracy, 4))
print('## 평균 검증 정확도:', np.mean(cv_accuracy)) 

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score, cross_validate
from sklearn.datasets import load_iris
import numpy as np

iris_data = load_iris()
dt_clf = DecisionTreeClassifier(random_state = 156)

data = iris_data.data
label = iris_data.target

# 성능 지표는 "정확도", 교차 검증 세트는 3개
scores = cross_val_score(dt_clf, data, label, scoring = "accuracy", cv = 3)
print("교차 검증별 정확도 : {}".format(np.round(scores, 4)))
print("평균 검증 정확도 : {}".format(np.mean(scores), 4))

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score

# 데이터를 로닝하고 학습데이터와 테스트 데이터 분리
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target,
                                                   test_size = 0.2, random_state = 121)

dtree = DecisionTreeClassifier()

# parameter들을 dictionary 형태로 설정
parameters = {"max_depth" : [1, 2, 3], "min_samples_split" : [2, 3]}

import pandas as pd

# param_grid의 하이퍼 파라미터들을 3개의 train, test set fold 로 나누어서 테스트 수행 설정.  
### refit=True 가 default 임. True이면 가장 좋은 파라미터 설정으로 재 학습 시킴.  
grid_dtree = GridSearchCV(dtree, param_grid=parameters, cv=3, refit=True, return_train_score=True)

# 붓꽃 Train 데이터로 param_grid의 하이퍼 파라미터들을 순차적으로 학습/평가 .
grid_dtree.fit(X_train, y_train)

# GridSearchCV 결과는 cv_results_ 라는 딕셔너리로 저장됨. 이를 DataFrame으로 변환
scores_df = pd.DataFrame(grid_dtree.cv_results_)
scores_df[['params', 'mean_test_score', 'rank_test_score', 
           'split0_test_score', 'split1_test_score', 'split2_test_score']]

print('GridSearchCV 최적 파라미터:', grid_dtree.best_params_)
print('GridSearchCV 최고 정확도: {0:.4f}'.format(grid_dtree.best_score_))

# refit=True로 설정된 GridSearchCV 객체가 fit()을 수행 시 학습이 완료된 Estimator를 내포하고 있으므로 predict()를 통해 예측도 가능. 
pred = grid_dtree.predict(X_test)
print('테스트 데이터 세트 정확도: {0:.4f}'.format(accuracy_score(y_test,pred)))

# GridSearchCV의 refit으로 이미 학습이 된 estimator 반환
estimator = grid_dtree.best_estimator_

# GridSearchCV의 best_estimator_는 이미 최적 하이퍼 파라미터로 학습이 됨
pred = estimator.predict(X_test)
print('테스트 데이터 세트 정확도: {0:.4f}'.format(accuracy_score(y_test,pred)))

from sklearn.preprocessing import LabelEncoder

items = ["TV", "냉장고", "전자렌지", "컴퓨터", "선풍기", "선풍기", "믹서", "믹서"]

# LabelEncoder를 객체로 생성한 후, fit()과 transform()으로 label 인코딩 수행.
encoder = LabelEncoder()
encoder.fit(items)
labels = encoder.transform(items)
print("인코딩 변환값 : {}".format(labels))

print("인코딩 클래스 : {}".format(encoder.classes_))

print("디코딩 원본값 : {}".format(encoder.inverse_transform([4, 5, 2, 0, 1, 1, 3, 3])))

from sklearn.preprocessing import OneHotEncoder
import numpy as np

items = ["TV", "냉장고", "전자렌지", "컴퓨터", "선풍기", "선풍기", "믹서", "믹서"]

# 먼저 숫자값으로 변환을 위해 label encoding
encoder = LabelEncoder()
encoder.fit(items)
labels = encoder.transform(items)

# 2차원 데이터로 변환
labels = labels.reshape(-1, 1)

# 원-핫 인코딩 적용|
oh_encoder = OneHotEncoder()
oh_encoder.fit(labels)
oh_labels = oh_encoder.transform(labels)

print("원-핫 인코딩 데이터 : \n{}".format(oh_labels.toarray()))
print("")
print("원-핫 인코딩 데이터 차원 : \n{}".format(oh_labels.shape))

import pandas as pd

df = pd.DataFrame({ "items" : ["TV", "냉장고", "전자렌지", "컴퓨터", "선풍기", "선풍기", "믹서", "믹서"] })
df

pd.get_dummies(df)

from sklearn.datasets import load_iris
import pandas as pd
# 붓꽃 데이터 셋을 로딩하여 DataFrame으로 변환해보자

iris = load_iris()
iris_data = iris.data
iris_df = pd.DataFrame(data = iris_data, columns = iris.feature_names)

iris_df

print("feature들의 평균 값 : \n\n{}".format(iris_df.mean(axis = 0)))
print("-" * 30)
print("feature들의 분산 값 : \n\n{}".format(iris_df.var(axis = 0)))

from sklearn.preprocessing import StandardScaler

# StandScaler 객체 생성
scaler = StandardScaler()

# StandardScaler로 데이터 셋 변환, fit()과 transform()호출
scaler.fit(iris_df)
iris_scaled = scaler.transform(iris_df)

# transform시 scale 변환된 데이터 셋이 numpy ndarray로 반환되므로 DataFrame으로 변환
iris_df_scaled = pd.DataFrame(data = iris_scaled, columns = iris.feature_names)
print("feature들의 평균 값 : \n\n{}".format(iris_df_scaled.mean(axis=0)))
print("-" * 30)
print("feature들의 분산 값 : \n\n{}".format(iris_df_scaled.var(axis=0)))

from sklearn.preprocessing import MinMaxScaler

# MinMaxScaler 객체 생성
scaler = MinMaxScaler()
scaler.fit(iris_df)
iris_scaled = scaler.transform(iris_df)

# transform시 scale변환된 데이터 셋이 numpy ndarray이므로 DataFrame으로 변환
iris_df_scaled = pd.DataFrame(data = iris_scaled, columns = iris.feature_names)
print("feature들의 최소값 : \n\n{}".format(iris_df_scaled.min(axis=0)))
print("-" * 30)
print("feature들의 최대값 : \n\n{}".format(iris_df_scaled.max(axis=0)))