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