NAIAHD

다중회귀분석(Multivariate Regression)

#다중 회귀 분석

#기본 라이브러리 불러오기
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Step1. 데이터 준비
# CSV 파일을 읽어와서 데이터프레임으로 변홖
# 자동차 정보 파일 읽어오기
df = pd.read_csv('auto-mpg.csv', header=None)
# 영문만 있어서 encoding 할 필요 없다.

# 열 이름 지정
df.columns = ['mpg','cylinders','displacement','horsepower','weight', 'acceleration','model year','origin','name']

#print(df.head())

# 데이터의 자료형 확인
#print(df.info()) #horsepower      398 non-null object

#통계요약 확인
#print(df.describe()) #숫자만 나온다.

# Step2. 데이터 탐색
#print(df['horsepower'].unique()) #'113.0' '200.0' '210.0' '193.0' '?' '100.0' '105.0' '175.0' '153.0'
# horsepower '?'을 np.nan으로 변경
df['horsepower'].replace('?', np.nan, inplace=True)
# 결측 데이터(np.nan)을 제거
#axis 0  행 axis 1 열
df.dropna(subset=['horsepower'], axis=0 , inplace=True)
#문자 데이터를 실수형으로 변환
df['horsepower'] = df['horsepower'].astype('float')

pd.set_option('display.max_columns', 10)
#데이터 확인 : 통계 예약 정보
print(df.describe())

# Step3. 분석에 홗용핛 속성(feature 또는 variable) 선택
# Step4. 훈련 데이터 / 검증 데이터 분핛

# 분석에 홗용핛 열(속성)을 선택 (연비, 실린더, 출력, 중량) - 새로운 dataframe만들기
ndf = df[['mpg', 'cylinders', 'horsepower', 'weight']]
# 독립변수와 종속변수 선택
x=ndf[['cylinders', 'horsepower', 'weight']] # 독립 변수 : cylinders, horsepower, weight
y=ndf['mpg'] # 종속 변수 : mpg

#train data와 test data로 분할( 7 : 3 ) 분할
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, #test data 비율 30%
                                                   random_state=10) #난수 시도

print('train data:' , x_train.shape) #train data: (274, 3)
print('test data:' , x_test.shape) #test data: (118, 3)

#다중회귀 분석
from sklearn.linear_model import  LinearRegression

#모델 생성
model = LinearRegression()

#train data 를 이용해서 학습
model.fit(x_train, y_train) #학습 데이터 가지고 학습
#train 학습용으로 하고 test데이터는 검증요으로 사용

#결정지수
r_score = model.score(x_test, y_test)
print("결정계수:" ,r_score) #0.6939048496695597

#회귀계수와 절편 구하기
print("회귀계수:", model.coef_)
print("절편:",model.intercept_)

#모델에 예측한 값 구하기
y_hat = model.predict(x_test) # test에 대한 예측

# 실제 데이터 (y_test) 와 예측값(y_hat)을 그래프로 출력 : 커널 밀도 그래프
plt.figure(figsize=(10 , 5))
ax1 = sns.distplot(y_test, hist=False, label='y_test') #실제값 가지고 그래프
ax2 = sns.distplot(y_hat, hist=False, label='y_hat' , ax = ax1) #예측값
plt.show()

회귀가 일종 예측이라고 할 수 있다.

분류

지도학습 : 데이터의 레이블이 있습니다. 행당 이름이 있습니다.

#digits 데이터셋은 0부터 9까지 손으로 쓴 숫자 이미지 데이터로 구성되어 있다.
#이미지 데이터는 8 x 8픽셀 흑백 이미지로, 1797장이 들어 있다.

from sklearn import datasets
import matplotlib.pyplot as plt
import pandas as pd

# digits dataset 로딩
digits = datasets.load_digits()
pd.set_option('display.max_columns', 15)

#print(digits) #2차원 배열 형태로 처리 된다.
#print(digits.target) #[0 1 2 ... 8 9 8] 이미지 라벨
#print(digits.images) #배열로 나온다.

#0 ~ 9 이미지를 2행 5열로 출력
#2 행 5열로 출력 subplot 가지고 한다.
#계속 반복이 된다. 0 1 2 3 4 5 6 7 8 9 0 1 2
#for label,img in zip(digits.target[:10],digits.images[:10]):
    #plt.subplot(2, 5 , label+1) # 2행 5열  로 이미지 배치 위치label+1

#create all subplots in a list
#for label, img in zip(digits.target[:10], digits.images[:10]):
#    plt.subplot(2, 5, label+1)
i = 0
for label, img in zip(digits.target[:12], digits.images[:12]):
    plt.subplot(2, 6, i+1)  # 2행 6열  로 이미지 배치 위치label+1
    plt.xlabel('') # x라벨 없에준다.
    #plt.imshow(img ) #디폴트 색상 있다.
    plt.imshow(img , cmap=plt.cm.gray ) #그레이스케일(gray scale) 이미지(흑백 이미지)
    plt.title('Digit:{0}'.format(label))
    i += 1

plt.show()

#scikit-learn 을 사용해 3과 8 이미지 데이터를 분류하는 분류기를 만든 후에 분류기의
#성능을 테스트 해보자.

import numpy as np
from sklearn import datasets

# 난수 시도 동일한 결과를 출력하기 위해서 사용
np.random.seed(0)

# 데이터셋 로딩
digits = datasets.load_digits()

# 3과 8의 데이터 위치 구하기
flag_3_8 = (digits.target == 3) + (digits.target ==8)
print(flag_3_8) #[False False False ...  True False  True]

# 3과 8 이미지와 라벨을 변수에 저장
labels = digits.target[flag_3_8]
images = digits.images[flag_3_8]
print(labels.shape) #(357,)
print(images.shape) #(357, 8, 8)

# 3과 8 이미지 데이터를 2차원에서 1차원으로 변환
# reshape(images.shape[0],-1) : 열에 -1은 가변적이라는 의미
images = images.reshape(images.shape[0], -1)
print(images.shape) #(357, 64)

#train data, test data를 분할
n_samples = len(flag_3_8[flag_3_8]) # 3과 8 이미지 갯수
print(n_samples) # 357
train_size = int(n_samples* 3 / 5) # 학습 데이터 60%로 구함
print(train_size)  # 214
                    # 학습데이터 : images[: 214]
                    #             labels[:214]

#결정 트리 분류기 모델 생성
from sklearn import  tree

# 모델 생성
classifier = tree.DecisionTreeClassifier()

#모델 학습
classifier.fit(images[:train_size],labels[:train_size])
# 어떤 이미지일 떄 어떤 라벨 값을 가지는 지 학습을 시킨다.

#테스트 데이터 구하기 : labels[214:]
test_label = labels[train_size:]
print(test_label)

#테스트 데이터를 이용해서 라벨을 예측
#. images -> x label -> y
predict_label = classifier.predict(images[train_size:])  # test 데이터이다. 214 부터 이다.
print(predict_label) # 예측 라벨의 값

#정답률 metrics.accuracy_score() -> 정답률
# 정답률
from sklearn import metrics

print('정답률(Accuracy):', metrics.accuracy_score(test_label ,predict_label)) #실제 데이터 값
#내부적으로 비교해서 나온다.정답률(Accuracy): 0.8741258741258742

분류

1.    데이터 셋 가져오기

2.    3과 8 이 있는 데이터를 가져오기 위치 가져오기

있으면 true없으면 false

3.    이미지는 2차원으로 되여있어서 1차원으로 reshape 처리를 간단하게 하기 위해서

4.    train data test data 분할

5.    결정 트리 분류기 모델 생성

6.    학습 데이터 가지고 학습

7.    테스트 데이터 가지고 예측

train데이터는 학습할 때 사용

test는 평가 예측 할 떄 사용

분류기의 성능 평가

 1. 정답률(Accuracy) : 젂체 예측에서 정답이 있는 비율(젂체 중에서 올바르게 예측핚 것이 몇 개인가)

정답률 (Accuracy) = ( TP + TN ) / ( TP + FP + FN + TN )

 2. 적합률(Precision) : 분류기가 Positive로 예측했을 때 짂짜로 Positive핚 비율

Positive로 예측하는 동앆 어느 정도 맞았는지, 정확도가 높은지를

나타내는 지표 (내가 푼 문제 중에서 맞춖 정답 개수)

적합률 (Precision) = TP / ( TP + FP )

 3. 재현율(Recall) : 짂짜로 Positive인 것을 분류기가 얼마나 Positive라고 예측했는지

나타내는 비율 (젂체 중에서 내가 몇 개를 맞췄는가)

실제로 Positive인 것 중에서 어느 정도 검춗핛 수 있었는지 가늠하는 지표

재현율 (Recall) = TP / ( TP + FN )

 4. F값(F-measure ) : 적합률과 재현율의 조화 평균. 지표 2개를 종합적으로 볼 때 사용

F값이 높을수록 분류 모형의 예측력이 좋다고 핛 수 있다.

F값(F-measure ) = 2 x Precision x Recall / Precision + Recall

일반적으로 분류기의 성능을 이야기 핛 때, 정답률(Accuracy)을 보지만 그것만으로

충분하지 않을 경우에 다른 성능평가 지표를 같이 살펴봐야 된다.

# 분류기를 만들어 성능 평가 : 정답률, 혼돈행렬, 적합률, 재현율, F값

#scikit-learn 을 사용해 3과 8 이미지 데이터를 분류하는 분류기를 만든 후에 분류기의
#성능을 테스트 해보자.

import numpy as np
from sklearn import datasets

# 난수 시도 동일한 결과를 출력하기 위해서 사용
np.random.seed(0)

# 데이터셋 로딩
digits = datasets.load_digits()

# 3과 8의 데이터 위치 구하기
flag_3_8 = (digits.target == 3) + (digits.target ==8)
print(flag_3_8) #[False False False ...  True False  True]

# 3과 8 이미지와 라벨을 변수에 저장
labels = digits.target[flag_3_8]
images = digits.images[flag_3_8]
print(labels.shape) #(357,)
print(images.shape) #(357, 8, 8)

# 3과 8 이미지 데이터를 2차원에서 1차원으로 변환
# reshape(images.shape[0],-1) : 열에 -1은 가변적이라는 의미
images = images.reshape(images.shape[0], -1)
print(images.shape) #(357, 64)

#train data, test data를 분할
n_samples = len(flag_3_8[flag_3_8]) # 3과 8 이미지 갯수
print(n_samples) # 357
train_size = int(n_samples* 3 / 5) # 학습 데이터 60%로 구함
print(train_size)  # 214
                    # 학습데이터 : images[: 214]
                    #             labels[:214]

#결정 트리 분류기 모델 생성
from sklearn import  tree

# 모델 생성
classifier = tree.DecisionTreeClassifier()

#모델 학습
classifier.fit(images[:train_size],labels[:train_size])
# 어떤 이미지일 떄 어떤 라벨 값을 가지는 지 학습을 시킨다.

#테스트 데이터 구하기 : labels[214:]
test_label = labels[train_size:]
print(test_label)

#테스트 데이터를 이용해서 라벨을 예측
#. images -> x label -> y
predict_label = classifier.predict(images[train_size:])  # test 데이터이다. 214 부터 이다.
print(predict_label) # 예측 라벨의 값

#정답률 metrics.accuracy_score() -> 정답률
# 정답률
from sklearn import metrics

print('정답률(Accuracy):', metrics.accuracy_score(test_label ,predict_label)) #실제 데이터 값
#내부적으로 비교해서 나온다.정답률(Accuracy): 0.8741258741258742

# train data와 test data  분할 [7:3]
from sklearn.model_selection import train_test_split

x_train , x_test, y_train ,y_test = train_test_split(images, #이미지
                                                     labels, # 라벨
                                                     test_size=0.3 , # test data 비율 30% 설정
                                                     random_state= 10
                                                     )

# 결정 트리 분류기 모델 생성
from sklearn import  tree
classifier = tree.DecisionTreeClassifier()

#모델 학습
classifier.fit(x_train, y_train)

print(y_test) #실제 데이터의 라벨 값

#테스트 데이터 - 예측
predict_label = classifier.predict(x_test)

#정답률 metrics.accuracy_score() -> 정답률
# 정답률
from sklearn import metrics
# 정답률, 혼돆행렧, 적합률, 재현율, F값을 계산하고 춗력
# accuracy_score() 함수로 정답률을 계산함.
# confusion_matrix() 함수로 혼돆행렧을 계산함.
# precision_score() 함수로 적합률을 계산함.
# recall_score() 함수로 재현율을 계산함.
# f1_score() 함수로 F값을 계산함.

print('정답률(Accuracy):', metrics.accuracy_score(y_test ,predict_label)) #실제 데이터 값
print('혼돈행렬:' ,metrics.confusion_matrix(y_test, predict_label)) #전체 데이터

# 푼것 중에 몇개 만주는 지
print('적합률:' ,metrics.precision_score(y_test, predict_label, pos_label=3)) # 3번 이라는 라벨에 대해서 얼마나 잘 구하는 지
# 3에서 대해 얼마나 잘 맞췄는가를 구해볼수 있다. 8로 해도 된다.
# 네기 픈갓 증에서 얼마나 맞췄는지
# 적합률 :0.9107142857142857

#전체 중에서 내가 몇개 만줬는지
print('재현율(Recall):', metrics.recall_score(y_test, predict_label, pos_label=3)) #0.9272727272727272

print('f값:' ,metrics.f1_score(y_test, predict_label,pos_label= 3))
#

 분류기의 종류

 결정 트리 (Decision Tree)

 랜덤 포레스트 (Random Forest)

 에이다부스트 (AdaBoost)

 서포트 벡터 머신 (Support Vector Machine)

결정 트리(Decision Tree)

결정 트리는 데이터를 여러 등급으로 분류하는 지도 학습 중의 하나로, 트리 구조를 이용핚 분류 알고리즘이다.

import matplotlib.pyplot as plt
from sklearn import datasets, tree
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.metrics import precision_score, recall_score, f1_score

# 손으로 쓴 숫자 데이터 읽기
digits = datasets.load_digits()

# 이미지를 2행 5열로 표시
for label, img in zip(digits.target[:10], digits.images[:10]):
    plt.subplot(2, 5, label + 1)
    plt.axis('off')
    plt.imshow(img, cmap=plt.cm.gray_r, interpolation='nearest')
    plt.title('Digit: {0}'.format(label))
    plt.show()

# 3과 8의 데이터 위치를 구하기
flag_3_8 = (digits.target == 3) + (digits.target == 8)
# 3과 8의 데이터를 구하기
images = digits.images[flag_3_8]
labels = digits.target[flag_3_8]
# 3과 8의 이미지 데이터를 1차원으로 변홖
images = images.reshape(images.shape[0], -1)

# train data와 test data  분할 [7:3]
from sklearn.model_selection import train_test_split

x_train , x_test, y_train ,y_test = train_test_split(images, #이미지
                                                     labels, # 라벨
                                                     test_size=0.3 , # test data 비율 30% 설정
                                                     random_state= 10
                                                     )

# 결정 트리 분류기 모델 생성
from sklearn import  tree
classifier = tree.DecisionTreeClassifier()

#모델 학습
classifier.fit(x_train, y_train)

print(y_test) #실제 데이터의 라벨 값

#테스트 데이터 - 예측
predict_label = classifier.predict(x_test)

#정답률 metrics.accuracy_score() -> 정답률
# 정답률
from sklearn import metrics
# 정답률, 혼돆행렧, 적합률, 재현율, F값을 계산하고 춗력
# accuracy_score() 함수로 정답률을 계산함.
# confusion_matrix() 함수로 혼돆행렧을 계산함.
# precision_score() 함수로 적합률을 계산함.
# recall_score() 함수로 재현율을 계산함.
# f1_score() 함수로 F값을 계산함.

print('정답률(Accuracy):', metrics.accuracy_score(y_test ,predict_label)) #실제 데이터 값
print('혼돈행렬:' ,metrics.confusion_matrix(y_test, predict_label)) #전체 데이터

# 푼것 중에 몇개 만주는 지
print('적합율:' ,metrics.precision_score(y_test, predict_label, pos_label=3)) # 3번 이라는 라벨에 대해서 얼마나 잘 구하는 지
# 3에서 대해 얼마나 잘 맞췄는가를 구해볼수 있다. 8로 해도 된다.
# 네기 픈갓 증에서 얼마나 맞췄는지
# 적합률 :0.9107142857142857

#전체 중에서 내가 몇개 만줬는지
print('재현율(Recall):', metrics.recall_score(y_test, predict_label, pos_label=3)) #0.9272727272727272

print('f값:' ,metrics.f1_score(y_test, predict_label,pos_label= 3))

랜덤 포레스트(Random Forest)

1. 랜덤 포레스트(Random Forest)는 앙상블 학습의 배깅(bagging)으로 분류되는 알고리즘이다.

Bagging은 Bootstrap Aggregation의 약자입니다. 배깅은 샘플을 여러 번 뽑아(Bootstrap) 각 모델을 학습시켜 결과물을 집계(Aggregration)하는 방법입니다.

앙상블 학습 : -> 학습률이 떨어져서 조합해서 사용 여러개 결합해서 만들어지는

부스팅(boosting) -> 가중치를 줘서 난이도가 높은 것은 가중치 성능이 뛰어나는 것 도 가중치 를 준다.

에이다부스트(AdaBoost)

1. 에이다부스트는 앙상블 학습의 부스팅(boosting)으로 분류하는 알고리즘이다.

서포트 벡터 머신 (Support Vector Machine)

1. 서포트 벡터 머신은 분류 및 회귀 모두 사용 가능할 지도 학습 알고리즘이다.

import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn import svm
from sklearn.metrics import accuracy_score, confusion_matrix
from sklearn.metrics import precision_score, recall_score, f1_score
# 손으로 쓴 숫자 데이터 읽기
digits = datasets.load_digits()
# 이미지를 2행 5열로 표시
for label, img in zip(digits.target[:10], digits.images[:10]):
    plt.subplot(2, 5, label + 1)
    plt.axis('off')
    plt.imshow(img, cmap=plt.cm.gray_r, interpolation='nearest')
    plt.title('Digit: {0}'.format(label))
plt.show()

# 3과 8의 데이터를 구하기
flag_3_8 = (digits.target == 3) + (digits.target == 8)
# 3과 8의 데이터를 구하기
images = digits.images[flag_3_8]
labels = digits.target[flag_3_8]
# 3과 8의 이미지 데이터를 1차원으로 변홖
images = images.reshape(images.shape[0], -1)
# 분류기 생성
n_samples = len(flag_3_8[flag_3_8])
train_size = int(n_samples * 3 / 5)
# SVC(Support Vector Classifier)
# C는 패널티 파라미터로 어느 정도 오류 분류를 허용하는지 나타낸다.
# 알고리즘에 사용될 커널 유형을 지정. 'linear', 'poly', 'rbf‘(기본값), 'sigmoid', 'precomputed
classifier = svm.SVC( kernel = 'rbf' )
classifier.fit(images[:train_size], labels[:train_size])


# 분류기 성능을 확인
expected = labels[train_size:]
predicted = classifier.predict(images[train_size:])
print('Accuracy:', accuracy_score(expected, predicted))
print('Confusion matrix:', confusion_matrix(expected, predicted))
print('Precision:', precision_score(expected, predicted, pos_label=3))
print('Recall:', recall_score(expected, predicted, pos_label=3))
print('F-measure:', f1_score(expected, predicted, pos_label=3))

K 최근접 이웃(KNN) 알고리즘

#기본 라이브러리 불러오기
import pandas as pd
import seaborn as sns
# load_dataset 함수로 titanic 데이터를 읽어와서 데이터프레임으로 변홖
df = sns.load_dataset('titanic')
print(df) # [891 rows x 15 columns]
# 데이터 살펴보기
print(df.head()) # 앞에서 5개의 데이터 불러오기
print('\n')
# IPython 디스플레이 설정 - 춗력핛 열의 개수를 15개로 늘리기
pd.set_option('display.max_columns', 15)
print(df.head())
print('\n')

# 데이터 자료형 확인 : 데이터를 확인하고 NaN이 많은 열 삭제
print(df.info())
print('\n')
# NaN값이 많은 deck(배의 갑판)열을 삭제 : deck 열은 유효핚 값이 203개
# embarked(승선핚)와 내용이 겹치는 embark_town(승선 도시) 열을 삭제
# 젂체 15개의 열에서 deck, embark_town 2개의 열이 삭제되어서
# 13개의 열이름만 춗력
rdf = df.drop(['deck', 'embark_town'], axis=1)
print(rdf.columns.values)
print('\n')
# ['survived' 'pclass' 'sex' 'age' 'sibsp' 'parch' 'fare' 'embarked' 'class'
# 'who' 'adult_male' 'alive' 'alone']


# 승객의 나이를 나타내는 age 열에 누락 데이터가 177개 포함되어 있다.
# 누락 데이터를 평균 나이로 치홖하는 방법도 가능하지만, 누락 데이터가 있는 행을 모두 삭제
# 즉, 177명의 승객 데이터를 포기하고 나이 데이터가 있는 714명의 승객만을 분석 대상
# age 열에 나이 데이터가 없는 모든 행을 삭제 - age 열(891개 중 177개의 NaN 값)
rdf = rdf.dropna(subset=['age'], how='any', axis=0)
print(len(rdf)) # 714 (891개 중 177개 데이터 삭제)
# embarked열에는 승객들이 타이타닉호에 탑승핚 도시명의 첫 글자가 들어있다.
# embarked열에는 누락데이터(NaN)가 2개에 있는데, 누락데이터를 가장많은 도시명(S)으로치홖
# embarked 열의 NaN값을 승선도시 중에서 가장 많이 춗현핚 값으로 치홖하기
# value_counts()함수와 idxmax()함수를 사용하여 승객이 가장 많이 탑승핚 도시명의 첫글자는 S
most_freq = rdf['embarked'].value_counts(dropna=True).idxmax()
print(most_freq) # S : Southampton

# embarked 열의 최빈값(top)을 확인하면 S 로 춗력됨
print(rdf.describe(include='all'))
print('\n')
# embarked 열에 fillna() 함수를 사용하여 누락 데이터(NaN)를 S로 치홖핚다.
rdf['embarked'].fillna(most_freq, inplace=True)

print(df.info())

# 분석에 홗용핛 열(속성)을 선택
ndf = rdf[['survived', 'pclass', 'sex', 'age', 'sibsp', 'parch', 'embarked']]
print(ndf.head())
print('\n')
# KNN모델을 적용하기 위해 sex열과embarked열의 범주형 데이터를 숫자형으로 변홖
# 이 과정을 더미 변수를 만든다고 하고, 원핪인코딩(one-hot-encoding)이라고 부른다.
# 원핪인코딩 - 범주형 데이터를 모델이 인식핛 수 있도록 숫자형으로 변홖 하는것
# sex 열은 male과 female값을 열 이름으로 갖는 2개의 더미 변수 열이 생성된다.
# concat()함수로 생성된 더미 변수를 기존 데이터프레임에 연결핚다.
onehot_sex = pd.get_dummies(ndf['sex'])
ndf = pd.concat([ndf, onehot_sex], axis=1)
print(ndf.info())

# embarked 열은 3개의 더미 변수 열이 만들어지는데, prefix='town' 옵션을
# 사용하여 열 이름에 접두어 town을 붙인다. ( town_C, town_Q, town_S)
onehot_embarked = pd.get_dummies(ndf['embarked'], prefix='town')
ndf = pd.concat([ndf, onehot_embarked], axis=1)

#기존 sex,embarked 컬럼 삭제
ndf.drop(['sex','embarked'], axis = 1, inplace = True)
print(ndf.head())

# 학습을 해야 할 독립변수와 종속 변수 가져오기
x=ndf[['pclass', 'age', 'sibsp', 'parch', 'female', 'male',
'town_C', 'town_Q', 'town_S']] # 독립 변수(x)
y=ndf['survived'] # 종속 변수(y)
# 독립 변수 데이터를 정규화(normalization)
# 독립 변수 열들이 갖는 데이터의 상대적 크기 차이를 없애기 위하여
# 정규화를 핚다.
from sklearn import preprocessing
x = preprocessing.StandardScaler().fit(x).transform(x)

#train data와 test data 분할
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=10)
print('train data 개수: ', x_train.shape) # train data 개수: (499, 9)
print('test data 개수: ', x_test.shape) # test data 개수: (215, 9)

01. 앙상블 학습 ensemble learning

학습기 하나로 원하는 성능을 낼 수 없을 때 앙상블 학습이 효과적입니다.

앙상블 학습은 개별로 학습한 여러 학습기를 조합해 일반화 성능을 향상할 수 있습니다.

배깅 bagging

배깅은 부트스트랩 방법을 이용해 학습 데이터에서 m개의 복원 추출을 B회만큼 반복합니다.

그러면 작게 나눈 m개의 데이터를 포함하는 B회의 학습 데이터를 생성할 수 있습니다.

부트스트랩 방법은 데이터를 샘플링해 의사 데이터 세트를 생성하는 리샘플링 방법으로 통계의 편향이나 분산을 추정할 때 사용합니다.

각각의 학습 데이터로 학습하면서 약학습기 h를 구축한 후 통합하면 학습기 H가 됩니다. H는 학습 데이터의 식별이나 확인에는 가장 우수한 결과를 선택하며 회귀일 때는 h의 평균을 이용합니다.

랜덤포레스트와의 차이

랜덤포레스트도 배깅과 마찬가지로 무작위 데이터를 추출한 후 작은 데이터 세트에서 학습을 실행합니다.

배깅은 학습 데이터의 설명 변수를 모두 사용하며 랜덤포레스트는 설명 변수도 무작위로 추출한다는 차이가 있습니다.

부스팅

약학습기를 순서대로 하나씩 결합해 강학습기를 얻는 방법입니다.

기대하는 인식 결과를 내고 싶은 데이터 세트와 그렇지 않은 데이터 세트로 나눈 후 특화된 데이터마다 만드는 약학습기를 순서대로 결합하면 인식 결과의 정확도가 높은 강학습기를 얻을 수 있습니다.

에이다부스트 알고리즘

2개의 값 분류에 관한 약학습기 구축 알고리즘입니다.

오류율은 선택한 약학습기의 인식률이 얼마나 높은지를 나타냅니다. 

오류율이 0.5를 넘으면 예측보다 정밀도가 낮다는 뜻이므로 약학습기 만들기를 종료합니다.

그리고 오류율에서 중요도를 계산한 후 그 값을 이용해 가중치 D를 업데이트 합니다.

02. 강화 학습

기계가 사람처럼 미지의 데이터에도 대응하도록 스스로 학습기를 변화시킬 수 있는 구조가 필요합니다. 이를 뒷발질하는 것이 강화학습니다.

강화 학습이라는 이름은 심리학의 조작적 조건화에 기반을 두고 자발적인 행동의 빈도를 증가시키는 것을 강화라고 하는 데서 유래했습니다.

확률시스템:

통계 기반 머신러닝에서는 베이즈 추론을 제외하고 동적 계획법 같은 배치 처리 최적화 기법을 이용할 때가 많았습니다. 이러한 최적화 기법을 이용하는 대상을 확정 시스템이라고 합니다.

정책과 강화 학습

보상은 상태와 행동을 기준으로 결정합니다.

강화 학습은 좋은 정책을 계속 채택하는 것이 목표이므로 "미래에 얻을 수 있는 보상의 기대치를 극대화하는 정책을 결정해 가는 것"으로 말할 수 있습니다.

보상과 가치 함수

할인 누적 보상 

도중 어떤 상태에서 누적 보상을 극대화하려고 미래의 상태와 행동을 평가하는 함수를 가치 함수라고 합니다.

상태 가치 함수

행동 가치 함수

행동 가치 함수를 최대화하는 함수를 최적 행동 가치 함수 라고 합니다.

벨멘 방정식

Q학습

그리디 방법: 탐욕 알고리즘이라고 하며 q값이 가장 높은 행동만을 선택합니다.

랜덤 방법: 무작위로 선택합니다.

03. 전이 학습 transfer learning 

도메인과 도메인 적용 

전이 학습 새로운 작업을 효율적으로 해결할려고 기존 작업에서 얻은 학습데이터와 학습 결과를 재사용하는 것입니다.

준 지도 학습과의 차이점

식별하려는 데이터와 지도 학습 데이터가 다른 분포를 따를 때 (실제로 많습니다) 가 있습니다. 이때 식별하려는 데이터의 일반화 성능을 향상시킬 때는 전이 학습을 이용하며 소수의 지도 학습 데이터와 다수의 라벨이 없는 데이터를 다룰 때는 준 지도 학습을 이용합니다.

멀티태스킹 학습 

원 도메인과 목표 도메인 사이에서 서로 지식을 보내고 받으면서 공통 부분의 지식을 향상시키는 방법

메타 학습 : " 학습 방법을 학습한다." 라고 설명할 수 있습니다.

04. 분산 인공지능

지능형 에이전트 

학습하는 능력을 얻은 프로그램은 환경을 인식해 스스로 행동을 결정할 수 있게 됩니다. 이 동작 주체를  지능형 에이전트 혹은 에이전트라고 합니다. 비록 장치 등의 실체 없이 정기적 /비정기적인 입력 구동으로 동작하는 소트트웨어 에이전트도 지능형 에이전트입니다.

칠판 모델

여러 개의 에이전트가 협업하는 작업에 대응할 때 기억 영역을 공유하는 것 

출처: 처음 배우는 인공지능

library(ggplot2)
library(dplyr)
library(RColorBrewer)
library(ggthemes)
install.packages("ggrepel")
library(ggrepel)
install.packages("chron")
library(chron)
library(lubridate)
install.packages("xts")
library(xts)
install.packages("highcharter")
library(highcharter)

data <- read.csv("ctrucks_clean.csv",stringsAsFactors = F)
head(data)
str(data)
summary(data)

data$origin = as.factor(data$origin)#출발지 
data$supplier = as.factor(data$supplier)
data$Date = ymd(data$Date)#ymd형태로"2017-04-10"
data$month = month(data$month, label = T)
data$week_day = weekdays(data$Date, abbreviate = T)#요일 표현한다.
#열이 있으면 보여주고 없으면 만들어준다.
#MUTATE

#지난 3년간 가장 많은 수소을 담당한
str(data)
#트력 아이디 별로 빈도소 찾아서 내림차순별로
#1.
truck <- data %>% group_by(truckid) %>% summarise(freq= n()) %>% top_n(20)

library(ggplot2)
library(dplyr)
library(RColorBrewer)
library(ggthemes)
install.packages("ggrepel")
library(ggrepel)
install.packages("chron")
library(chron)
library(lubridate)
install.packages("xts")
library(xts)
install.packages("highcharter")
library(highcharter)

data <- read.csv("ctrucks_clean.csv",stringsAsFactors = F)
head(data)
str(data)
summary(data)

data$origin = as.factor(data$origin)#출발지 
data$supplier = as.factor(data$supplier)
data$Date = ymd(data$Date)#ymd형태로"2017-04-10"
data$month = month(data$month, label = T)
data$week_day = weekdays(data$Date, abbreviate = T)#요일 표현한다.
#열이 있으면 보여주고 없으면 만들어준다.
#MUTATE

#지난 3년간 가장 많은 수소을 담당한
str(data)
#트력 아이디 별로 빈도소 찾아서 내림차순별로
#1.
truck <- data %>% group_by(truckid) %>% summarise(freq= n()) %>% top_n(20)
truck
data %>% filter(truckid =='1073FL01')
data %>% filter(truckid =='7922GR01')
#2.
truck1 <- data %>% group_by(truckid) %>% summarise(freq = n()) %>% arrange(desc(freq)) %>% head(20)
truck1

truck3 <- data %>%
  group_by(truckid) %>%
  summarize(freq = n()) %>%   
  arrange(desc(freq)) %>%  head(20) %>% as.data.frame()
truck3

#reorder 재정렬 하는 것이다.
ggplot(data = truck, aes(reorder(truckid, freq), y= freq, fill= freq))+
  geom_bar(stat ="identity",position="dodge")+xlab("Truck")+ylab("Frequency")+coord_flip()

#15를 25로 바꿀 수 있다.
par(mfrow= c(1,2))
ggplot(data = truck, aes(reorder(truckid, freq), y= freq, fill= freq))+
  geom_bar(stat ="identity",position="dodge")+xlab("Truck")+ylab("Frequency")+
 scale_fill_gradientn(name ="",
                    colours =rev(brewer.pal(10, 'Spectral')))+
  geom_text(aes(label = freq ), hjust= 0.5, size = 5.5)+
  ggtitle("The top 20 Trucks with the most deliveries")+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 15),
         axis.text.y = element_text(size = 15),
         axis.title.x = element_text(size = 15),
         axis.text.x= element_text(size = 15),
         plot.title = element_text(size = 15, hjust = 0.2))+coord_flip()
#scale_fill_gradientn
#coord_flip
#brewer.pal

ggplot(data = truck, aes(reorder(truckid, freq), y= freq, fill= freq))+
  geom_bar(stat ="identity",position="dodge")+xlab("Truck")+ylab("Frequency")+
  scale_fill_gradientn(name ="",
                       colours =rev(brewer.pal(10, 'Set3')))+
  geom_text(aes(label = freq ), hjust= 0.5, size = 5.5)+#옆에 있는 빈도수 바꾸기 
  ggtitle("The top 20 Trucks with the most deliveries")+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 25),
         axis.text.y = element_text(size = 25),
         axis.title.x = element_text(size = 25),
         axis.text.x= element_text(size = 25),
         plot.title = element_text(size = 25, hjust = 0.2))+coord_flip()
#legend.position d없을 경우 legend 없다.
display.brewer.all()
#ggplot도 함수이다.

data %>%
  group_by(truckid) %>%
  summarize(freq = n()) %>%   
  arrange(desc(freq)) %>%  head(20) %>% as.data.frame()+
ggplot(data,aes(reorder(truckid, freq), y= freq, fill= freq))+
  geom_bar(stat ="identity",position="dodge")+xlab("Truck")+ylab("Frequency")+
  scale_fill_gradientn(name ="",
                       colours =rev(brewer.pal(10, 'Set3')))+
  geom_text(aes(label = freq ), hjust= 0.5, size = 5.5)+#옆에 있는 빈도수 바꾸기 
  ggtitle("The top 20 Trucks with the most deliveries")+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 25),
         axis.text.y = element_text(size = 25),
         axis.title.x = element_text(size = 25),
         axis.text.x= element_text(size = 25),
         plot.title = element_text(size = 25, hjust = 0.2))+coord_flip()  

data %>%
  group_by(truckid) %>%
  summarize(freq = n()) %>%   
  arrange(desc(freq)) %>%  head(20) %>% as.data.frame() %>% 
  ggplot(aes(reorder(truckid, freq), y= freq, fill= freq))+
  geom_bar(stat ="identity",position="dodge")+xlab("Truck")+ylab("Frequency")+
  scale_fill_gradientn(name ="",
                       colours =rev(brewer.pal(10, 'Set3')))+
  geom_text(aes(label = freq ), hjust= 0.5, size = 5.5)+#옆에 있는 빈도수 바꾸기 
  ggtitle("The top 20 Trucks with the most deliveries")+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 25),
         axis.text.y = element_text(size = 25),
         axis.title.x = element_text(size = 25),
         axis.text.x= element_text(size = 25),
         plot.title = element_text(size = 25, hjust = 0.2))+coord_flip() 



data %>% group_by(week_day,month) %>% count()

data %>% group_by(week_day,month) %>% count() %>% 
  ggplot(aes(reorder(week_day, n ), y = n , fill = n ))+
  geom_bar(stat ="identity",position ="dodge")+
  xlab("Day")+
  ylab("Delivery Count")+
  scale_fill_gradientn(name ="",
                       colours =rev(brewer.pal(10, 'Spectral')))+
  geom_text(aes(label = n ), hjust=- 0.3, size = 3.5)+#옆에 있는 빈도수 바꾸기 
  ggtitle("Delivery Counts through the Days by Month")+
  facet_wrap( ~ month)+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 15),
         axis.text.y = element_text(size = 10),
         axis.title.x = element_text(size = 15),
         axis.text.x= element_text(size = 10),
         plot.title = element_text(size = 25, hjust = 0.2),
         strip.text = element_text(size = 8, face ="bold"),
         strip.background = element_rect(colour = "red",fill="#CCCCFF")) 


data %>% group_by(week_day,month) %>% count() %>% 
  ggplot(aes(reorder(week_day, n ), y = n , fill = n ))+
  geom_bar(stat ="identity",position ="dodge")+
  xlab("Day")+
  ylab("Delivery Count")+
  scale_fill_gradientn(name ="",
                       colours =rev(brewer.pal(10, 'Spectral')))+
  geom_text(aes(label = n ), hjust=- 0.3, size = 3.5)+#옆에 있는 빈도수 바꾸기 
  ggtitle("Delivery Counts through the Days by Month")+
  facet_wrap( ~ month)+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 15),
         axis.text.y = element_text(size = 10),
         axis.title.x = element_text(size = 15),
         axis.text.x= element_text(size = 10),
         plot.title = element_text(size = 25, hjust = 0.2),
         strip.text = element_text(size = 15, face ="bold"),
         strip.background = element_rect(colour = "red",fill="#CCCCFF")) +coord_flip() 
#coord_flip() 옆으로 펼쳐진다.

data$month

data %>%filter(month != 2 & month != 6 & month != 7)%>% group_by(week_day,month)%>% count() %>% 
  ggplot(aes(reorder(week_day, n ), y = n , fill = n ))+
  geom_bar(stat ="identity",position ="dodge")+
  xlab("Day")+
  ylab("Delivery Count")+
  scale_fill_gradientn(name ="",
                       colours =rev(brewer.pal(10, 'Spectral')))+
  geom_text(aes(label = n ), hjust=- 0.3, size = 3.5)+#옆에 있는 빈도수 바꾸기 
  ggtitle("Delivery Counts through the Days by Month")+
  facet_wrap( ~ month)+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 15),
         axis.text.y = element_text(size = 10),
         axis.title.x = element_text(size = 15),
         axis.text.x= element_text(size = 10),
         plot.title = element_text(size = 25, hjust = 0.2),
         strip.text = element_text(size = 8, face ="bold"),
         strip.background = element_rect(colour = "red",fill="#CCCCFF")) 
# facet_wrap( ~ month)옆으로 펼치기
#month ==3 | month == 4 | month == 5
data %>%filter(! month %in% c(2,6,7))%>% group_by(week_day,month)%>% count() %>% 
  ggplot(aes(reorder(week_day, n ), y = n , fill = n ))+
  geom_bar(stat ="identity",position ="dodge")+
  xlab("Day")+
  ylab("Delivery Count")+
  scale_fill_gradientn(name ="",
                       colours =rev(brewer.pal(10, 'Spectral')))+
  geom_text(aes(label = n ), hjust=- 0.3, size = 3.5)+#옆에 있는 빈도수 바꾸기 
  ggtitle("Delivery Counts through the Days by Month")+
  facet_wrap( ~ month)+
  theme( legend.position = 'none',
         axis.title.y = element_text(size = 15),
         axis.text.y = element_text(size = 10),
         axis.title.x = element_text(size = 15),
         axis.text.x= element_text(size = 10),
         plot.title = element_text(size = 25, hjust = 0.2),
         strip.text = element_text(size = 8, face ="bold"),
         strip.background = element_rect(colour = "red",fill="#CCCCFF")) 
#색상을 fill로 채워야 한다.

data$Date

by_date_2015 <- data %>% filter(Date <= ('2016-01-01')) %>% 
  group_by(Date) %>% summarise(Total = n())
by_date_2015

time_series = xts(by_date_2015$Total, order.by = by_date_2015$Date)
hchart(time_series, name ="Number of Deliberies") %>% 
  hc_title(text = "Total Deliveries for 2015") %>% 
  hc_legend(enabled = T)

by_date_2016 = na.omit(data) %>% filter(Date >= ('2016-01-01') & Date <('2017-01-01')) %>% 
  group_by(Date) %>% 
  summarise(Total = n())

time_series = xts(by_date_2016$Total, order.by = by_date_2016$Date)

hchart(time_series, name ="Number of Deliveries") %>% 
  hc_add_theme(hc_theme_darkunica()) %>% 
  hc_title(text ="Total Deliveries for 2016") %>% 
  hc_legend(enaled = T)

churn데이터 고객이탈 데이터
어떤 분이 해지 하는지 알고 싶을때 
#상관관계 확인 126페이지 
#상관관계가 1이 나오면 낮동안 통화한 데이터 ,낮시간 금액
#예시: ‚cars‛ 데이터(내장 데이터) 
#• 상관관계 확인: 회귀분석은 기본적으로 상관관계에 대핚 통계적 분석 
#• 인과관계를 주장하려면 추가적으로 통계 외적인 귺거가 필요 (예: 해당 분야의 이롞적 귺거, 실험의 경우 변인통제, …) 

 Coefficient 관계
기무가설이 기각이 되면 상관관계가 없지 않아요 
speed 변수는 값이 매우 작으므로 유의하다. 

cars
data1 <- cars#151
plot(data1)
library(ggplot2)
ggplot(data = data1, aes(x= speed, y= dist ))+geom_point()#153

cor(data1)#상관행렬 
cor.test(data1$speed,data1$dist)

install.packages("corrplot")
library(corrplot)
#dataframe의 cor값이 들어간다.cor(data1)
corrplot::corrplot.mixed(cor(data1))

data2 <- airquality
corrplot::corrplot.mixed(cor(data2))

data3 <- mpg
corrplot::corrplot.mixed(cor(data3))#Error in cor(data3) : 'x' must be numeric
corrplot::corrplot.mixed(cor(mtcars))

fit.cars <- lm(dist ~ speed , data = cars)
fit.cars

summary(fit.cars)
#별표가 붙어 있다. signif 무의미한 
#0에 가까운 것을 잘 띄울수록 별표 표시해주고 
#별새계가 중요하다

잔차분석 
상관관계 1이면 선에 붙어있다.
잔차 원래 데이터 문제를 잔차가지고 정규분포한다.
잔차들이 일정한 모습을 가져야 하면 안된다.
잔차는 아무것이나  random하게 해야 한다.

new <- data.frame(speed = c(122))
predict(fit.cars, newdata = new ,interval = "confidence")
predict(fit.cars, newdata = new ,interval = "confidence",level= 0.9)
predict(fit.cars, newdata = new ,interval = "prediction")
#이선자체가 맞다는 보장성이 없어서 prediction 
# confidence 범위보다 넓다.

fit <- lm( dist ~ speed, data = cars)
fit
plot(fit)

par(mfrow= c(2,2))#multi figure
plot(fit)
#fitted 잔차는 0이다. random하게 영향성이 없이 잘 분포되여있다. 빨간선
#빨간선이 포물선처럼 되면 별로 좋지 않다.
#q-q plot qiantiles 45도 회귀의 기울기로 점들이 아래위로 하면서 따라간다.숫자는 이상치가 있다 윗부분이 잘 안 딸아간다.
#scale-Location scale표준화 random하게 있어줘야 한다.
#Residuals vs Leverage 잔차 0.5 안쪽으로 벗어나지 말아야 한다. 빨간색 안쪽으로 그 사이에 있으면 된다.


#Fitted values
#1번 그림 가지고 하면 된다.
plot(fit.cars, 1)
#잒차도를 확인해보니 적합값 (Fitted values)이 커질수록 잒차가 넓게 퍼지는 경향이 보인다. 
install.packages("lmtest")
library(lmtest)
install.packages("car")
library(car)
#잔차분석 – 등분산성 검정 
#규칙없이 흩어져야 한다.
bptest(fit.cars)
#잔차분석을 할 때 잔차도를 보고 판단하는 것 뿐만 아니라 잒차에 대핚 검정 또핚 가능하다.  
#유의확률(p-value)이 작으면 등분산성 가정에 문제가 있을 수 있다 (등분산성 가정을 의심해봐야 핚다). 
ncvTest(fit.cars)#car library
#p-value = 0.07297->기무가설을 체택하는 쪽으로 선택한다.
#p = 0.031049
#p값이 작으면 문제 있따.기무가설은 등분산성 가정에 문제가 있을 수 있다.
# 0.03 <0.05보다 작으니깐 조심해야 한다.

잔차분석을 통해 회귀분석의 가정에 문제가 있는 것을 확인했다면 , 그다음에는 어떻게 해야 하는가 ?-->회귀분석 다시 해야 한다.
데이터 변환을 해야 한다.->171페이제
2차곡선이 그려지게 점들이 있다. 2차의 곡선을 찾아줘야 한다.
y는 dist의 제곱하고 root를 씌워져서 값이 줄어든다. root로 해서 새로운 열을 만들어준다.

#잔차분석 -정규성 검정 
#데이터로 보여주는  정규성
plot(cars,2)
shapiro.test(fit.cars$res)#169
#0.02152 
#유의확률(p-value)이 작으면 정규성 가정에 문제가 있을 수 있다 
#(정규성 가정을 의심해봐야 핚다). 
#잔차를 확인 해야 한다. 잔차는 자주 사용해야한다.
#작은 것이 아니락 크야 한다.

data2 <- cars
#덮어씌우는 것
#data2$dist <- sqrt(data2$dist)
#colnames(data2)[2] <- "sqrt.dist"
#새로운 열을 만드는 것
data2$sqrt.dist <- sqrt(data2$dist)
head(data2, 5)

fit.cars2 <- lm(sqrt.dist ~speed, data = data2)
fit.cars2
bptest(fit.cars2)
#0.9157
ncvTest(fit.cars2)
#0.91258
#등분산성 만족 
plot(fit.cars2)#처음 보다 덜 위험하다.
shapiro.test(fit.cars2$residuals)
#p-value = 0.3143
summary(fit.cars2)


ggplot(data = data2, aes(x= speed, y = sqrt.dist))+
  geom_point()+
  geom_abline(data = date2, intercept = 1.27705, slope = 0.32241, col= "red")

다중선형회귀분석
변수가 2개 이상일 경우 
종속 변수 
성적 
영향을 주는 것 을 모른다. 

변수를 조작한다.
변수가 여러개있다.
최소제곱법-
각각의 개수들을 찾아보는 것 
예: 부동산 예측

#다중
library(readxl)
BostomHousing <- read_excel("BostonHousing.xls")
str(BostomHousing)
data <- tbl_df(BostomHousing)#데이터의 형태를 바꾼다. 이렇게 바꾸면 큰 데이터 프레임을 보기 쉽도록 해 준다.
#tbl_df -> as_tibble를 불러온다.
str(data)

View(data)
glimpse(data)

data(package ="MASS")
names(data)

library(psych)
pairs.panels(data[names(data)])#데이터 있는 것들을 이름을 가져와서 
#상관간계 보여 주는 것 
#0.70 과 -0.74
#rm lstat와 관계있다.
pairs.panels(data)
#plot에서 상관관계 
data <- data[ , -15]#오류난다.
data

names(data)
names(data) <- tolower(names(data))#소문자로 바꿔준다.
data_lm_full <- lm(medv ~ ., data = data)
#medv가격을 나타내는 주기 
data_lm_full
#이것은 작을 수록 좋다.

summary(data_lm_full)
#signif 별표시 되여있다. 별 3개 위주로 값이 작으면 좋다 . 별이 없으면 무의미한 것이여서
#R-squard는  r제곱값인데ㅔ 크면 좋다. 0.74이면 74%정도 말하면 된다.
#Adjusted R-squard 변수가 많으면 모형을 잘 설명해줄것이라고 생각한 것처럼 변수가 늘어나면 아무 의미가 없어도 변수가 널아나서 변수가 조금 변한다. 변수가 저절로 높으지지 않도록 마이나서ㅓ(penalty)를 줘서 값이 작아진다.
#Adjusted R-squard 이것 확인하면 된다.
#전체 적인  pvalue는 2e-16이다 믿을만 하다.

-----------------------------------------------------
의사결정나무 정리
redpineK 머신러닝 시리즈
의사결정 순도를 높이는 방향으로 하는 것이다.
넘 잘도면 overfitting발생 가능하다. 
entropy낮추는 방향으로 -<순도를 높이는 방향으로 한다.
의사결정 시리즈로 
분류하고 예측한다.
random forest 
boosting

신경망에서 overfitting의 해결방법은  빼는 것이다.droupout
적당한 선에서 멈춘다.

complexity parameter
hypper parameter

의사결정나무의 장점
회이트 박스모형이며 ,결과를 해석하고 이해하기 쉽다.
자료를 가공할 필요가 거의 없다.
수치 자료와 범주 자료 모두에 적용할 수 있다.

#의사결정 나무 
#ADSP
library(rpart)

apple_df <- read.csv(file= "apple.csv")
apple_df
summary(apple_df)

str(apple_df)

#품종별 무게 
boxplot(weight ~ model , data = apple_df, ylab="무게" )

#품종별 당도
boxplot(sugar ~ model, data = apple_df, ylab ='당도')

#품종별 산도
boxplot(acid ~ model, data = apple_df, ylab ='산도')
ggplot(apple_df, aes(x = model, y = acid)) +geom_boxplot()

#최초 실행시 패키
library("ggplot2")

k <- ggplot(apple_df, aes(factor(color), fill= factor(model)))
k + geom_bar()
#geom_bar  geom_col차이점 
k1 <- ggplot(apple_df, aes(factor(color), fill= factor(model)))
k1 +  geom_col()#geom_col requires the following missing aesthetics: y

#옆으로 하는 것 position="dodge"

#iris데이터 구조
# 꽃 종류 
#꽃받침 S
#꽃잎 P
str(iris)
colnames(iris)
nrow(iris)
table(iris$Species)

library(caret)

iris_row_idx <- createDataPartition(iris$Species, p = 0.8 , list = F)#list형이 아닌 vector형으로 
#iris$Species 를 1-100 중에  80개 random하게 꺼내기 
str(iris_row_idx)
View(iris_row_idx)

iris_train_data <- iris[iris_row_idx,]
str(iris_train_data)
table(iris_train_data$Species)
iris_test_Data <- iris[-iris_row_idx,]
str(iris_test_Data)
table(iris_test_Data$Species)#3개씩 층 30건

#traing 와 테스트 각각의 종류별로도 나누었다.

summary(iris_train_data)
summary(iris_test_Data)

library(rpart)

iris_rpart_result <- rpart(Species ~ . , data = iris_train_data, control = rpart.control(minsplit =2 ))
#Species ~ . species 와 나머지 
#data = iris_train_Data 120개 traing까지 
#rpart.control(minsplit =2 )나머지 2개가 있을 때 까지

#분류분석 결과값 출력 
iris_rpart_result
#질문이 

library(rpart.plot)
rpart.plot(iris_rpart_result)

#cp값 조회
iris_rpart_result$cptable
#단계로 나눈다.

#가지치기 
iris_prune_tree <- prune(iris_rpart_result, cp= 0.0125)
#iris_rpart_result$cptable cp값으로 수정 
#cp 잴 아래것 빼고 빼는 것이 좋다.
rpart.plot(iris_prune_tree)
#마지막을 치운다. 적당하게 일반화 해줘야 한다.

#rm(list = ls())

str(iris_test_Data)
#테스트 데이터 확인 - 훈련 데이터와 컬럼명이 같아야 함 (단 종속 변수 걸럼은 없어)
predict(iris_rpart_result ,iris_test_Data, type = "class")

actual <- iris_test_Data$Species
expect <- predict(iris_rpart_result ,iris_test_Data, type = "class")
expect_prune <- predict(iris_prune_tree ,iris_test_Data, type = "class")#가지치기 하는 것도 예측해야 한다.

iris_predict_df <- data.frame(actual, expect, expect_prune)
iris_predict_df#결과값 확인 

#혼동행렬 만들기 
table(iris_predict_df)

library(caret)
confusionMatrix(expect,actual, mode ="everything" )

#------------------------

library(ggplot2movies)
movies <- ggplot2movies::movies
str(movies)

apple_train_idx <- createDataPartition(apple_df$model , p = 0.8, list = F)
nrow(apple_train_idx)
nrow(apple_df)

str(apple_df)

apple_train_df <- apple_df[apple_train_idx,]
apple_test_df <- apple_df[-apple_train_idx,]

str(apple_train_df)
str(apple_test_df)
apple_train_df
apple_test_df
table(apple_train_df$model)
table(apple_test_df$model)

apple_rpart_result <- rpart(model ~ . , data = apple_train_df, control = rpart.control(minsplit = 2))
apple_rpart_result

rpart.plot(apple_rpart_result)
str(apple_rpart_result)

apple_rpart_result$cptable
apple_pune_tree <- prune(apple_rpart_result , cp = 0.0000)
rpart.plot(apple_pune_tree)
str(apple_test_df)

app_actual <- apple_test_df$model
app_expect <- predict(apple_rpart_result, apple_test_df, type ="class")

app_predict_df <- data.frame(app_actual, app_expect)

table(app_predict_df)

#randomForest
install.packages("randomForest")
require(randomForest)
ind <- sample(2, nrow(iris), replace = T, prob = c(0.7 , 0.3))
trainData <- iris[ind == 1,]
testData <- iris[ind == 2,]

rf <- randomForest(as.factor(Species)~ . , data = trainData, ntree = 100, proximity = T, importance = T)
print(rf)

predict(rf)
table(predict(rf), trainData$Species)
irisPred <- predict(rf, newdata = testData)
irisPred
table(irisPred, testData$Species)

랜덤 포레스트(영어: random forest)는 분류, 회귀 분석 등에 사용되는 앙상블 학습 방법의 일종으로, 훈련 과정에서 
구성한 다수의 결정 트리로부터 부류(분류) 또는 평균 예측치(회귀 분석)를 출력함으로써 동작한다.
Bagging은 샘플을 여러 번 뽑아 각 모델을 학습시켜 결과를 집계(Aggregating) 하는 방법입니다. 
랜덤 프레스트는  배깅이 발전한 것이다.
부스팅
배깅이 일반적인 모형을 만드는데 집중되어 있다면 ,부스팅은 맞추기 어려운 문제를 맞추는 것이 목적이다.

#boosting
#파산 분류
credit <- read.csv("credit.csv")
View(credit)
install.packages("C50")
library(C50)
m_c50_bst <- C5.0(default~. , data = credit, trials = 100)
install.packages("adabag")
library(adabag)

set.seed(300)
m_adaboost <- boosting(default ~. , data = credit)#파산 하는지 의사결정 tree를 boosting해서 만든다.
p_adaboost <- predict(m_adaboost, credit)#모델가지고 예측 
head(p_adaboost$class)
p_adaboost$confusion

#set.seed(300)
#adaboost_cv <- boosting.cv(default ~ . , data = credit)
#adaboost_cv$confusion

#bagging
library(ipred)
set.seed(300)
mybag <- bagging(default ~. , data= credit, nbagg = 25) #radong data 25개 마추어서 모여봐 
predict_pred <- predict(mybag, credit)
table(predict_pred, credit$default)