JINHEE's lab

#Linear line의 생성
line_x = np.linspace(np.min(X_test['s6']), max(X_test['s6']), 10)                      
line_y = sim_lr.predict(line_x.reshape(-1,1))            

print(line_x)
print(line_y)

#Test data를 표현
plt.scatter(X_test['s6'], y_test, s=10, c='black')
plt.plot(line_x, line_y, c='red')
plt.legend(['Test data sample','Regression line'])

이번 예제에서는 혈당을 나타내는 feature인 's6' 하나를 가지고 당뇨 예측을 해본다.

알고리듬 임포트

from sklearn.linear_model import LinearRegression
sim_lr = LinearRegression()

데이터 쪼개기

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
                                      data, label, test_size = 0.2, random_state=2023)

혈당 수치만 가져와서 sklearn에 맞는 array형태로 바꾸기

X_train['s6'].values.reshape((-1,1)), y_train

학습

sim_lr.fit(X_train['s6'].values.reshape((-1,1)), y_train)

예측

y_pred = sim_lr.predict(X_test['s6'].values.reshape((-1,1)))

from sklearn.metrics import r2_score
print('단순 선형 회귀, R2: {:.2f}'.format(r2_score(y_test, y_pred)))
print('단순 선형 회귀 계수(w) : {:.2f}, 절편(b): {:.2f}'.format(sim_lr.coef_[0],sim_lr.intercept_))  

    출력>
    단순 선형 회귀, R2: 0.16
    단순 선형 회귀 계수(w) : 586.70, 절편(b): 152.60

시각화

#Linear line의 생성
line_x = np.linspace(np.min(X_test['s6']), max(X_test['s6']), 10)                     
line_y = sim_lr.predict(line_x.reshape(-1,1))                                        

print(line_x)
print(line_y)

#Test data를 표현
plt.scatter(X_test['s6'], y_test, s=10, c='black')
plt.plot(line_x, line_y, c='red')
plt.legend(['Test data sample','Regression line'])

점과 선의 괴리감이 커서 좋은 모델은 아닌 걸 알 수 있다 : 예측율이 떨어질 듯

필요한 모듈 임포트

import numpy as np
import pandas as pd
import sklearn 
import matplotlib.pyplot as plt

당뇨병 데이터 임포트

from sklearn.datasets import load_diabetes
diabetes = load_diabetes()

print(diabetes.DESCR)  # 데이터 확인

값 변수 지정

data = diabetes.data
label = diabetes.target
columns = diabetes.feature_names

데이터 프레임 만들기

data = pd.DataFrame(data, columns = columns)
data.head()

Accuracy (정확도) 모든 데이터에 대해 클래스 라벨을 얼마나 잘맞혔는지 계산

                               Accuracy  = 1 - (못맞춘 정도) 

[데이터 정리]

이번 예제에서는 전복 데이터셋 파일을 가지고 진행한다. 데이터 파일은 두개로  abalone.txt는 전복 데이터를abalone_attributes는 features 데이터를 가지고 있다. 전복의 성별을 구별하는 것을 목표로 모델을 만들고 accuracy를 평가해보자.

파일 임포트

import os
from os.path import join

abalone_path = join('.','abalone.txt')   # 현재 위치, 파일이름
column_path = join('.','abalone_attributes.txt')

abalone_columns = list()
for l in open(column_path):
  abalone_columns.append(l.strip())

데이터 프레임 형태로 바꿔주기

data = pd.read_csv(abalone_path, header=None, names=abalone_columns)     # pd 데이터 프레임 형태로 가져오기
data.head()

        출력>

미성숙한 전복 데이터 제거, 성별을 숫자형태로 encoding하고 성별 feature을 삭제해버린다.

data = data[data['Sex'] != 'I']
label = data['Sex'].map(lambda x: 0 if x =='M' else 1)   #lamda식으로 x의 값 기본 0, x가 M이면 넘어가고 아니면 1로 줘라
del data['Sex']

데이터 쪼개기

X_train, X_test, y_train, y_test = train_test_split(data,label,test_size=0.2, random_state = 2023)

[알고리즘 학습=>모델]

rf = RandomForestClassifier(max_depth=5)
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)

[정확도 평가]

정확도를 체크하는 모듈들 임포트

from sklearn.metrics import accuracy_score, precision_score, recall_score, roc_auc_score

print('Accuracy: {:.2f}'.format(accuracy_score(y_test, y_pred)))        # 값으로 원본데이터와 예측치 넣어준다
print('Precision: {:.2f}'.format(precision_score(y_test, y_pred)))  
print('Recall: {:.2f}'.format(recall_score(y_test, y_pred)))  
print('AUC: {:.2f}'.format(roc_auc_score(y_test, y_pred)))  

    출력>
    Accuracy: 0.53
    Precision: 0.53
    Recall: 0.23
    AUC: 0.52

[최적의 depth 구하기]

best_model_depth = 0
best_model_accuracy = 0

for i in [2,3,4,5,6,7,8,9,10]:
  rf = RandomForestClassifier(max_depth=i)
  rf.fit(X_train, y_train)
  y_pred = rf.predict(X_test)

  acc = accuracy_score(y_test, y_pred)

  print('Accuracy: i={} {:.2f}'.format(i, acc * 100))   # 값을 보고 가장 결과값이 높게 나오는 depth 알 수 있다, 같은 조건이면 더 단순한 i가 낮은 값을 선택

  if best_model_accuracy < acc:
    best_model_depth = i
    best_model_accuracy = acc

print('-------------------------------')
print('best_model_depth={0}, best_model_accracy={1}'.format(
    best_model_depth, best_model_accuracy))
    
    
    출력>
    Accuracy: i=2 53.09
    Accuracy: i=3 51.68
    Accuracy: i=4 52.20
    Accuracy: i=5 53.44
    Accuracy: i=6 54.14
    Accuracy: i=7 53.62
    Accuracy: i=8 53.09
    Accuracy: i=9 54.85
    Accuracy: i=10 54.32
    -------------------------------
    best_model_depth=9, best_model_accracy=0.5485008818342152

1.Decision Tree

임포트

from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(max_depth=3)         # depth로 어디까지 노드 내려갈 수 있는지

알고리즘 훈련 및 정확도 테스트 ( 이 예제는 데이터빨로 정확도가 over-fit 되어있다. 100% 정확도는 오히려 좋지 않다.)

dt.fit(X_train, y_train)
y_pred = dt.predict(X_test)
print('tree 정확도: {:.2f}%'.format(accuracy_score(y_test, y_pred)*100))

    출력>
    tree 정확도: 100.00%

트리 구조를 그려주는 모듈 임포트

from sklearn.tree import export_graphviz                  # 트리의 구조 출력
export_graphviz(dt, out_file='tree.dot')            # (model, out_file)을 써준다. model은 방금 우리가 학습시킨 모델 dt.fit을 넣고 파일을 'tree.dot'으로 저장한다.

파일 저장

from subprocess import call                         # dot 파일을 그림으로 그려 저장
call(['dot','-Tpng','tree.dot','-o', 'decistion-tree.png','-Gdpi=600'])   # 파일저장: 포멧: dot, 선이 선명하게 나오는 png파일로 열기: Tpng(투명한 png), 그려줄 파일명 : tree.dot,저장할 이름 : decistion-tree.png, 그래픽해상도: '-Gdpi=600', 그리고 이제 잘 안먹히면 '-o'를 파일명 뒤에 붙여주면 된다.

그림으로 나타내주기

from IPython.display import Image                                
Image(filename = 'decistion-tree.png')

2. Random Forest

from sklearn.ensemble import RandomForestClassifier           

rf = RandomForestClassifier()
rf.fit(X_train, y_train)
y_pred = rf.predict(X_test)
print('랜덤 포레스트 정확도: {:.2f}'.format(accuracy_score(y_test, y_pred) * 100))

    출력>
    랜덤 포레스트 정확도: 100.00

 Support Vector Machine?

주어진 데이터를 바탕으로 두 카테고리 사이의 가격(Margin)을 최대한 넓게 차이하는 방법을 찾아내는 방법. 그 마진 사이에 겹쳐있는 데이터들은 서포트 백터라고 부른다.

임포트,  SMC는 svm을 이용해서 classification한다는 의미

from sklearn.svm import SVC

알고리즘에 데이터 넣고 훈련시켜 모델 만들기

for i in [0.1,0.2,0.3,0.4,0.5,0.6,0.7, 0.8,0.9,1]:
  svc = SVC(C=i)                                         # C는 Margin 사이에 들어온 데이터(노이즈)를 얼마나 무시할지로 값이 커질수록 무시하는 노이즈도 많아진다 , 이번에 for문을 통해 값을 몇으로 줘야 모델의 정확도가 높아질지 뽑아냈다.
  svc.fit(X_train, y_train)                              # 알고리즘에 데이터줘서 훈련완료 => 모델
  y_pred = svc.predict(X_test)                           # 예측 완료
  print('서포트 벡터 머신, i={} 정확도: {:.2f}'.format(i, accuracy_score(y_test, y_pred)*100
  
  출력>
    서포트 벡터 머신, i=0.1 정확도: 90.00
    서포트 벡터 머신, i=0.2 정확도: 100.00
    서포트 벡터 머신, i=0.3 정확도: 100.00
    서포트 벡터 머신, i=0.4 정확도: 100.00
    서포트 벡터 머신, i=0.5 정확도: 100.00
    서포트 벡터 머신, i=0.6 정확도: 100.00
    서포트 벡터 머신, i=0.7 정확도: 100.00
    서포트 벡터 머신, i=0.8 정확도: 100.00
    서포트 벡터 머신, i=0.9 정확도: 100.00
    서포트 벡터 머신, i=1 정확도: 100.00

from sklearn.linear_model import LogisticRegression 
lr = LogisticRegression()

lr.fit(X_train, y_train)

모델이 잘 학습되었나 확인

lr.predict(X_test)
y_pred = lr.predict(X_test)    


# 결과 확인 (예측값과 실제값이 얼마나 일치하는지를 확인하여 모델의 정확도를 확인 가능 )
from sklearn.metrics import accuracy_score      # accurency (정확도) 스코어 모듈 부르기

print('로지스틱 회귀 정확도: {:.2f}'.format(accuracy_score(y_test, y_pred) * 100))   # 1.0이면 100프로인데 예쁘게 보기 위에 뒤에 100곱해준다
print('로지스틱 회귀, 계수(w) : {0}\n절편(b): {1}'.format(                         # 우리가 4개의 regression 값을 사용하기 때문에 4개의 속성(각각의 특성)이 3가지 클래스마다 나오는 것이라 기울기가 총 12개 값이..
                                    lr.coef_, lr.intercept_))                        # 절편(b=bias)은 각각의 시작점을 나타낸다 , 클래스(라벨)이 세가지니까 세가지 값이 나온다.

계수와 절편?

y = wx + b에서 y는 예측치 x는 그래프 가로 w는 기울기(계수) b는 기본 시작값