NAIAHD

개념정리에 대해서 8월 29일 추가 하겠습니다.

분류데 대해서 소계해 드리겠습니다. 

•지도학습

•classification

•분류는 미리 정의된, 가능성 있는 여러 클래스 레이블 (class label) 중 하나를 예측하는 것입니다.

예:

•붓꽃을 세 품종 중 하나로 분류

•강아지인지 고양이인지 분류

•스팸인지 아닌지 분류

•양성인지 음성인지 분류

출처 : Introduction to Machine Learning with Python

인공지능:

사람 처럼 해동하도록 만들어진 장치 (또는 소프트웨어)

머신러닝 :

명시적인 프로그래밍 없이 컴퓨터가 학습하는 능력을 갖추게 하는 연구 분야.

Arthur Samuel, 1959

빅데이터 :

엄청  나게 많은 양의 데이터를 다루는 것

딥러닝 :

머신러닝에 포함된것이다.

수많은 기법중의 하나이다.

뉴런 층을 사용해서 

지도학습 Supervised Learning :

"답" 이 있고 이 답을 맞추는 게 학습의 목적

분류 classification :

여러가지 옵션에서 고르는 것 

회귀 regression :

연속적인 수에서 고르고 몇가지 옵션에서 고르지는 않다.

비지도 학습 Unsupervised Learning

"답" 이 없고 이 답을 맞추는 게 학습의 목적 

묶으는 기준이 프로그램이 한다.

k최근접 이웃 알고리즘

k- Nearest Neighbors Algorithm : KNN

가장 가까운 이웃 데이터 K개를 찾음

참조 :

처음 배우는 인공지능

핸즈온 머신러닝 2판

다중회귀분석(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)

install.packages("nycflights13")
library(nycflights13)
data(package = "nycflights13")
4개의 data set이 있다.
Data sets in package ĄŽnycflights13ĄŻ:

airlines                            Airline names.
airports                            Airport metadata
flights                             Flights data
planes                              Plane metadata.
weather                             Hourly weather data

install.packages("nycflights13")
library(nycflights13)
data(package = "nycflights13")

flights
#행의 개수

dim(flights)
str(flights)
nrow(flights)
flights #tibble 이여서 몇개만 보여주고 마지막에 개수 보여준다.
summary(flights)#행의 개수 안보임

fly1 <- flights
summary(fly1)
fly1 <- as.data.frame(fly1)
summary(fly1)#행의 개수  class를 보기 

#flights 데이터셋에서 열이 이름(변수명)
colnames(flights)
names(flights)

#1월 1일 데이터는 모두 몇개 입니까 ?
library(dplyr)
flights %>% filter(month == '1' & day == '1' ) %>% nrow

flights

#도착 지연 시 이 2시간 이하인 항공편은 모두 몇 회입니까 ?
flights %>% filter(arr_delay < 120) %>% nrow

#출발시간과 도착시간이 모두 1시간 이상 지연된 항공편은 모두 몇 회입니까?
flights %>% filter(dep_delay >= 60 & arr_delay >= 60) %>% nrow

#filter(dep_delay >= 60 & arr_delay >= 60)->flight,origin,dest,arr_delay,dep_delay,distance,air_time조회해서 데이터셋 만들기 
flights_new <- flights %>% filter(dep_delay >= 60 & arr_delay >= 60) %>% select(flight,origin,dest,arr_delay,dep_delay,distance,air_time ,arr_time)
flights_new

#도착지연은 오름차순 출발지연은 내림차누
flights_new %>% arrange(arr_delay,desc(dep_delay))#앞에것 하고 동급 있을때 내림차순으로 한다.

#gain speed구하기 
flights_new %>% mutate( gain = arr_delay- dep_delay, speed = distance/air_time )

flights %>% nrow#336776
flights <- na.omit(flights)#na없에기 
flights %>% nrow#327346
flights %>% summarize(delay= mean(dep_delay), delay_sd = sd(dep_delay))

#flights에서 12개월가 월별 평균출발시간(dep_time)을 구하세요
flights
flights %>% group_by(month) %>% summarise(dep_mean = mean(dep_time))
#'mean(dep_time)' 이름을 지정하지 않았다.


flights %>% distinct(month)
str(flights)
summary(flights)
summary(airquality)
library(ggplot2)
summary(mpg)

크롤링이란   (Crawling)  ->데이터 전처리 
크롤링(Crawling)이란? 
- 스크레이핑(Scraping)이라고도 하며 웹 페이지를 그대로 가져와서 거기서 데이터를 추출해내는 행위이다. 
크롤링(Crawling)은 불법일까? 
- 크롤링하여 얻은 데이터를 개인 하드에 소장하는 것까지는 합법이다.   
하지만 배포하면 그 순갂부터 합법과 불법이 갈린다. 
- 합법적인 크롤링은 사이트 운영자의 의사에 반하지 않는 것이다. 
- 불법적인 크롤링은 사이트 운영자의 의사에 반하거나 실정법을 어기는 것이다. 
- 크롤링은 웹페이지의 소스가 포함되어 있다. 이런 소스들은 웹프로그래밍 저작물이며       
이를 불법 복제하는 것은 위법이다. 
크롤링(Crawling)을 위한 기본 개념을 알아보자. 
- 서버 : 외부에서 요청하면 규칙대로 정보를 제공하는 역할을 한다. 
- 브라우저 : 서버가 주는 것들을 사용자에게 보여준다. 
 크롤링(Crawling)을 위한 기본 개념을 알아보자. 
- 웹 서버는 text(html, css, js 등)와 image를 브라우저를 통해 사용자에게     보여준다
준비물 

1. 구글크롬 2. Selector Gadget 3. 엑셀 

 
• 방법 
 
1. 구글크롬을 설치한다. 

2. https://selectorgadget.com/에서 들어가서 북마크에 설치한다.

3. 다음에 들어간다. 
4. 검색 키워드로 서치한다. 
5. 원하는 컨테츠를 선택한다.(ex. 뉴스, 블로그, 카페) 
6. 2페이지에 갔다가 다시 1페이지로 돌아온다. 

install.packages("rvest")
library(rvest)
install.packages("stringr")
library(stringr)

title = c()#빈상태에서 접여여기
body = c()

#주소가 자동으로 바꾸게 넣어줘야 한다.
url_base ="https://search.daum.net/search?w=news&q=%EA%B5%AD%ED%9A%8C&DA=PGD&spacing=0&p="
url_crawl = paste(url_base);#paste는 문자 열 둘개를 붙이는 함수 
# url_crawl = paste(url_base, i )#url주소와 i를 붙여라 
print(url_crawl,1)
hdoc = read_html(url_crawl)
hdoc

for(i in 1:10){#i가 1부터 진행
  #url_crawl = paste(url_base, i , sep ="");#paste는 문자 열 둘개를 붙이는 함수 
  url_crawl = paste(url_base, i , sep ="");
 # url_crawl = paste(url_base, i )#url주소와 i를 붙여라 
  print(url_crawl)
  #t_css = ".f_link_b"#소제목으로 되여있다.F12로 하면 볼수 있다. .은 class를 표현하는 것이다.
  #b_css = ".desc"#
  #ie에서 F12로 하면 볼수 있다. .은 class를 표현하는 것이다
  #구글 selectorGadget에서 볼수 있다.
  
  hdoc = read_html(url_crawl)#그 경로에 있는 것을 읽어온다.가져오는 것
  
  
  #t_node = html_nodes(hdoc, t_css)#사진  ,text중 다르다.판단하는 함수가 
  #b_node = html_nodes(hdoc, b_css)
  t_node = html_nodes(hdoc, ".f_link_b")
  b_node = html_nodes(hdoc, ".desc")
  
  title_part = html_text(t_node)#글자를 가져오는 함수 달려가서 가져와야 한다.
  body_part = html_text(b_node)
  
  title = c(title,title_part)
  # title = c() vector형태로 되여있다.
  body = c(body,body_part)
}
news = cbind(title,body)
news
write.csv(news,"crawltest.csv")

텍스트마이닝 
빈도분석 • 감성분석 • 한국어처리  KoNLP 
rjAVA는 한글에서 필요하는것 
RjAVA있어야 한

library(KoNLP)
library(wordcloud2)

useSejongDic()

text = readLines("textMining\\ahn.txt")
text

nouns <- extractNoun(text)#명사만 뽑아내는 것
nouns
#F1extract Nouns from Korean sentence uses Hannanum analyzer
#F2함수 내용  HannanumObj한글 페키지 
#"그렇습니다. 미래는 지금 우리 앞에 있습니다. " ->"미래" "우리" "앞"

nouns <- unlist(nouns)#LIST아니게 바꾼다.->1차원형태로 VECTOR형태로
nouns

nouns <- nouns[nchar(nouns)>=2]#nouns안에 있는 글자의 개수가 2보다 큰것 
nouns#nouns 2글자 이상인것만 한글자 지웠다.

#빈도를 새는것 
wordFreq <- table(nouns)
wordFreq <- sort(wordFreq, decreasing = T)#숫자가 많이 나온것을 정렬
wordFreq <- head(wordFreq, 20)
wordFreq

wordFreq <- table(nouns) %>% sort(decreasing = T) %>% head(20)
wordFreq
wordcloud2(wordFreq,fontFamily = '맑은 고딕')

useSejongDic()
nouns <- readLines("textMining\\leesungman.txt",encoding = "UTF-8") %>% extractNoun() %>% unlist()
nouns <- readLines("textMining\\leesungman.txt") %>% extractNoun() %>% unlist()
nouns <- nouns[nchar(nouns)>= 2]
nouns
wordFreq <- table(nouns) %>% sort(decreasing = T) %>% head(20)
wordcloud2(wordFreq,fontFamily = '맑은 고딕')
#jeonduhwan.txt
#kimdaejung.txt
#leesungman.txt 'textMining\leesungman.txt'에서 불완전한 마지막 행이 발견되었습니다
#roh.txt parkjunghee1.txt,leesungman.txt->그냥하면 된다.

#가장 많이 사용된 단어 알아보기 
txt = readLines("news.txt")
head(txt)

library(stringr)
extractNoun("대한민국의 영토는 한반도와 그 부속서로 한다.")
nouns <- extractNoun(txt)

wordcount <- table(unlist(nouns))
df_word <- as.data.frame(wordcount,stringsAsFactors = F)

df_word <- rename(df_word, word= Var1, freq = Freq)
df_word <- filter(df_word,nchar(word)>=2)

top20 <- df_word %>% arrange(desc(freq)) %>% head(20) 
top20

#useNIAdic
txt <- str_replace_all(txt,"//w","") #정규표현식 

빈도가 많이 쓰여진다. 
감성 분석 
웹 사이트와 소셜미디어에 나타난 소비자의 감성을 붂석하여 유용한 정보로  재가공하는 기술을 의미한다. 
문장에서 사용된 단어의 긍정과 부정의 빈도에 따라 문장의 긍정, 부정을 평가한다. 
사람이 작성한 텍스트 앆에는 그 글의 주요 대상이 되는 주제(Topic)와  주제에 대한 글쓴이의 의견(Opinion)이 있다. 
감성 붂석은 주제에 대한 글쓴이의 의견을 파악하는 것으로 Opinion Mining이라고도 한다

list.of.packages <- c("","","","")
new.packages <- list.of.packages()

install.packages("twitteR")
install.packages("ROAuth")
install.packages("plyr")
install.packages("stringr")
library(twitteR)
library(ROAuth)
library(plyr)
library(stringr)

#키
API_key <- ""
API_secret <- ""
access_token <- ""
access_secret <- ""

#object로 할수 있다. save(df_midterm,file="df_midterm.rda")->1일 날 것
#load("df_midterm.rda")

setup_twitter_oauth(counsumer_key = API_key, consumer_secret = API_secret,access_token = access_token,access_secret = access_secret)


#전 세계에서 
install.packages("ggmap")
library(ggmap)
library(ggplot2)

html.airports <- read_html("https://en.wikipedia.org/wiki/List_of_busiest_airports_by_passenger_traffic")
html.airports
df <- html_table(html_nodes(html.airports, "table")[[1]],fill= T) #[[]]list중에서 첫번째것 
#html_table 표 가지로 가는 것 
#html_nodes 노드 가지로 가는 것 

head(df)
head(df$Airport)
colnames(df)
colnames(df)[6] <- "total" #있으면 보여주고 없으면 만들어준다.
df$total
df$total <- gsub(',','',df$total)#정규표현식 할떄 나오는 것 g는 global하는 것 
#전부다 대체 하는 것이다. ,를 찾아서 ''으로 대체 한다.
df$total <- as.numeric(df$total)#character->숫자로 바꾸는 것 
df$total

Github에 있는 twitteR 패키지를 설치하기 위해 devtools 패키지를 설치한다.
rjson, bit64, httr은 의존성으로 함께 설치가 필요하다.
ROAuth 패키지는 트위터의 권한을 얻기 위해 설치가 필요하다.

* 패키지 설치 후 library() 로 로드한다. twitter 패키지는 install_github() 함수를 사 용하며
username은 자싞의 Desktop 사용자 이름으로 정의한다.

* 앞서 설명했던 API_key, API_secret, access_token, access_secret 을 복사 붙여넣기  한다.

* 저장했던 4개의 객체를 옵션으로 넣고 함수를 실행한다.

* searchTwitter() 함수를 이용하여 @apple 를 검색한 자료를 가져온다. since, until로 검색 기갂을 설정하고, lang로 언어를 설정할 수 있다.

* 500개를 설정했지만 실제 자료는 300개가 출력됐다. 해당 키워드에 일치되는 결과가 300개이기 때문

유투브에서 보기
3blue1brown
cs230
cs231n

knitr::kable(anscombe)
anscombe.1 <- data.frame(x = anscombe[["x1"]], y = anscombe[["y1"]], Set = "Anscombe Set 1")
anscombe.2 <- data.frame(x = anscombe[["x2"]], y = anscombe[["y2"]], Set = "Anscombe Set 2")
anscombe.3 <- data.frame(x = anscombe[["x3"]], y = anscombe[["y3"]], Set = "Anscombe Set 3")
anscombe.4 <- data.frame(x = anscombe[["x4"]], y = anscombe[["y4"]], Set = "Anscombe Set 4")
anscombe.data <- rbind(anscombe.1, anscombe.2, anscombe.3, anscombe.4)
aggregate(cbind(x, y) ~ Set, anscombe.data, mean)
aggregate(cbind(x, y) ~ Set, anscombe.data, sd)
model1 <- lm(y ~ x, subset(anscombe.data, Set == "Anscombe Set 1"))

model2 <- lm(y ~ x, subset(anscombe.data, Set == "Anscombe Set 2"))

model3 <- lm(y ~ x, subset(anscombe.data, Set == "Anscombe Set 3"))

model4 <- lm(y ~ x, subset(anscombe.data, Set == "Anscombe Set 4"))
library(plyr)

correlation <- function(data) {
  
  x <- data.frame(r = cor(data$x, data$y))
  
  return(x)
  
}

ddply(.data = anscombe.data, .variables = "Set", .fun = correlation)

summary(model1)

summary(model2)

summary(model3)

summary(model4)

library(ggplot2)
gg <- ggplot(anscombe.data, aes(x = x, y = y))

gg <- gg + geom_point(color = "black")

gg <- gg + facet_wrap(~Set, ncol = 2)

gg <- gg + geom_smooth(formula = y ~ x, method = "lm", se = FALSE, data = anscombe.data)

gg

#package있는지 없는지
install.packages("datasauRus")
library(datasauRus)
if(requireNamespace("dplyr")){
  suppressPackageStartupMessages(library(dplyr))
  datasaurus_dozen %>% 
    group_by(dataset) %>% 
    summarize(
      mean_x    = mean(x),
      mean_y    = mean(y),
      std_dev_x = sd(x),
      std_dev_y = sd(y),
      corr_x_y  = cor(x, y)
    )
}
if(requireNamespace("ggplot2")){
  library(ggplot2)
  ggplot(datasaurus_dozen, aes(x=x, y=y, colour=dataset))+
    geom_point()+
    theme_void()+
    theme(legend.position = "none")+
    facet_wrap(~dataset, ncol=3)
}
#reshap2가 없을때 
if(!require(reshape2)){
  install.packages("reshape2")
  require(reshape2)
}

비지도학습-군집분석
1.군집분석이란?
2.k-means
3.적정 k의 값
k는 숫자이다.
분류 vs 군집화
분류: 범주의 수 및 각 개체의 범주 정보를 사전에 알 수 있으면, 입력 변수 값으로부터 범저 정보를 유추하여 새로운 개체에 대해 가장 
적합한 범주로 할당하는 문제(지도 학습)
군집화(clustering) 군집의 수 ,속성 등이 사전에 알려져 있지 않으면 최적의 구분을 찾아가는 문제(비지도 학습)
k는 숫자이다.
#회귀문제

if(!require(caret)){
  install.packages("caret")
  require(caret)
}

data("iris")
View(iris)

set.seed(123)
inTrain <- createDataPartition(y = iris$Species, p = 0.7, list = F)
training <- iris[inTrain,]
testing <- iris[-inTrain,]
training
#표준화
training.data <- scale(training[-5])#데이터 형태 맞춘다.
training.data
summary(training.data)

iris.kmeans <- kmeans(training.data[,-5],center = 3, iter.max = 10000)
iris.kmeans$centers

의사결정 나무
의사결정나무 정형데이터 나무 시리즈
다양한 도형을 분류하는 의사 결정 나무 
검정색 찾을 때 까지 얼마나 가야 만 찾을 수 있는지 

if(!require(NbClust)){
  install.packages("NbClust")
  require(NbClust)
}
#값이 정해진 것이 아니다.맘데로 정할 수 있다.
nc <- NbClust(training.data, min.nc = 2, max.nc = 15, method = "kmeans")

barplot(table(nc$Best.n[1,]),xlab ="Number of Clusters",ylab ="Number of chosen",main="Number of Clusters chosen")

training.data <- as.data.frame(training.data)#레ㅌ프트 생성한다.
modFit <- train(x = training.data[,-5],y = training$cluster, method="rpart")
#의상결정으로 분류하는 것  rpart
#rpart 반복적으로 20번씩 계속 해주는 것 
#분집을 나누고 의사결정 모데을 만들어서 예측해서 
#정답하고 결과가 얼마나 차이나는 가 
testing.data <- as.data.frame(scale(testing[,-5]))
testingclusterPred <- predict(modFit, testing.data)
table(testingclusterPred,testing$Species)

entropy 순도를 높여가는 양식
다른 변수인 소득을 기준으로 정렬하고 다시 같은 작업을 반복
entropy낮은 기준에서 나눈다.
순도를 높이기 위해 계속 나눈다.

계층적 방법
dendrogram 계층적분석 방법이다. ggplot에서 

knn분석

ribbon
#ribbon
huron <- data.frame(year = 1875 : 1972 , level = as.vector(LakeHuron))
huron
ggplot(data = huron, aes(x= year))+geom_area(aes(y = level))
p <- ggplot(data = huron, aes(x = year))
p <- p+geom_area(aes(y = level))
p + coord_cartesian(ylim = c(570,590))#limit줘서 해줘야 한다.


p <- ggplot(data = huron, aes(x= year))
p <- p+geom_area(aes(y = level))
p +coord_cartesian(ylim = c(min(huron$level)-2,max(huron$level)+2))

 
p <- ggplot(huron,aes(x= year))+geom_ribbon(aes(ymin= min(level)-2,ymax = level+2))

p <- ggplot(huron, aes(x= year)) +geom_ribbon(aes(ymin = min(level)-2, ymax = level+2))

p <- ggplot(huron,aes(x = year,fill="skyblue"))+geom_ribbon(aes(ymin = min(level)-2, ymax = level+2,fill="skyblue"),color="skyblue")

p <- ggplot(huron, aes(x=year,fill="skyblue"))
p + geom_ribbon(aes(ymin=level-2, ymax=level+2 ,fill="skyblue"), colour="blue")

knn ->거리를 계싼하는 것
knn(k-Nearest Neighbor)새로운 돌아온 데이터와 그룹의 데이터와 가장 가까우니 새로운것과 재일 가까운 것은 그룹이다.->분류 알고리즘

k 인접 이웃 분류
overfitting 완전 최적화 데이터 under fit이 안되도록 학습할때 잘 안될 수 있다.
일반화 유지 그래서 적절한 것을 구해야 한다.
유클리드 거리 Euclidean distance L2거리 직선거리  
맨하탄 거리 직선이 아닐때 L1거리