Ai - Analysis : 유방암 데이터

Minhyeok Kim·2022년 10월 11일

google colab 을 이용하여 Ai 기초 다지기2

유방암 데이터를 가져와서 기본적인 분석데이터 출력하기.

# 유방암 데이터 집합 읽어 들이기

# 라이브러리 임포트
from sklearn.datasets import load_breast_cancer

# 데이터 내려받기
cancer = load_breast_cancer()

# 데이터에 대한 설명 읽기
print(cancer.DESCR)

# 한글 셋팅!!!!!!!!
!sudo apt-get install -y fonts-nanum
!sudo fc-cache -fv
!rm ~/.cache/matplotlib -rf

import matplotlib.pyplot as plt

plt.rc('font', family='NanumBarunGothic') 

# 한글 셋팅을 마무리 했으면 런타임을 다시시작 해야함!!

# 데이터프레임으로 변환하기

columns = [
      '반지름_평균', '텍스처_평균', '둘레길이_평균', '면적_평균',
     '평활도_평균', '콤팩트도_평균', '오목면_평균', '오목점_평균', '대칭성_평균',
     '프랙탈도_평균', '반지름_표준편차', '텍스처_표준편차', '둘레길이_표준편차', '면적_표준편차',
     '평활도_표준편차', '콤팩트도_표준편차', '오목면_표준편차', '오목점_표준편차',
     '대칭성_표준편차', '프랙탈도_표준편차', '반지름_최대', '텍스처_최대', '둘레길이_최대',
     '면적_최대', '평활도_최대', '콤팩트도_최대', '오목면_최대','오목점_최대',
     '대칭성_최대','프랙탈도_최대'
    ]

# 읽어 들인 데이터를 데이터프레임으로 변환
df = pd.DataFrame(cancer.data, columns=columns)

# 정답 데이터를 꺼냄
y = pd.Series(cancer.target)

# 입력데이터를 화면에 출력하기
# 입력 데이터의 20번째 줄부터 24번째 줄까지 화면에 출력
display(df[20:25])

# 정답 데이터의 20번째 줄부터 24번째 줄까지 화면에 출력 
# y 값(label) 유방암이 양성(1)인지 악성(0)인지 판단한 결과값
print(y[20:25])

# 이제 사진 데이터만 넣으면 모델을 거쳐서 y 결과값을 얻어낼 수 있음

# 입력 데이터의 행과 열의 수를 확인
print(df.shape)
print()

# 정답 데이터의 1(양성)과 0(악성)의 건수 확인
print(y.value_counts())

# 산점도를 그리기 위한 준비
# 입력데이터를 대응하는 정답 데이터의 값에 따라 분할한다.

# 정답데이터 = 0(악성)인 데이터 골라내기
df0 = df[y==0]

# 정답 데이터 =1(양성)인 데이터 골라내기
df1 = df[y==1]

display(df0.head())
display(df1.head())

# 산점도 그리기
# 그래프의 크기 설정
plt.figure(figsize=(6,6))

# 목적변수 값이 1인 데이터의 산점도 그리기
plt.scatter(df0['반지름_평균'], df0['텍스처_평균'], marker = 'x', c = 'b', label = '악성')
plt.scatter(df1['반지름_평균'], df1['텍스처_평균'], marker = 's', c = 'k', label = '양성')

# 그리드 표시
plt.grid()

# 레이블 표시
plt.xlabel('반지름_평균')
plt.ylabel('텍스처_평균')

# 범례 그리기
plt.legend()

# 화면에 전체 그래프를 출력
plt.show()

# 입력 데이터를 두개의 필드로 줄이기
input_columns = ['반지름_평균', '텍스처_평균']

x = df[input_columns]
display(x.head())

# 학습 데이터와 검증데이터 분할하기

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, train_size = 0.7, test_size = 0.3, random_state = random_seed)

# 분할된 데이터를 확인하기 (요소 수)

print(x_train.shape)
print(x_test.shape)
print(y_train.shape)
print(y_test.shape)

# 데이터 분할 결과 확인하기(데이터 내용)

display(x_train.head())
display(x_test.head())
display(y_train.head())
display(y_test.head())

# 알고리즘 선택하기
# 확률을 구할때 0 부터 1사이에 그래프를 그리는데에는 LogisticRegression 이 좋다.
from sklearn.linear_model import LogisticRegression
algorithm = LogisticRegression(random_state = random_seed)

# 학습
# 여기 알고리즘은 위에서 가져온 LogisticRegression 이다.
algorithm.fit(x_train, y_train)
print(algorithm.get_params())

# 예측
# predict 함수를 호출한다.
y_pred = algorithm.predict(x_test)
print(y_pred)

# 정답 데이터와 예측 결과 비교하기

# 정답 데이터를 앞에서부터 10건 추려냄
# y_test는 데이터프레임이므로 value 속성에 담긴 넘파이 배열로 변환한다.
y_test10 = y_test[:10].values
print(y_test10)

# 예측 결과를 앞에서부터 10건 추려냄
y_pred10 = y_pred[:10]
print(y_pred10)

# 정답을 맞힌 건수 세기
# 정답 데이터 == 예측 결과
w1 = (y_test10 == y_pred10)
print(w1)

# 정답을 맞힌 개수
w2 = w1.sum()
print(w2)

# 정확도 계산하기

# 정답을 맞힌 건수를 계산 / if(y_test 값이 y_pred 값과 같다면~)
w = (y_test.values == y_pred)
correct = w.sum()

# 검증 데이터 전체 건수
N = len(w)

# 정확도 = (정답수) / (검증 데이터 전체 건수)
score = correct / N

# 결과를 출력
print(f'정확도 : {score:.04f}')
######################
# 위 코드를 score 함수를 이용하여 줄여서 표현하면,
score2 = algorithm.score(x_test, y_test)
print(f'정확도 : {score:0.4f}')
# 그냥 표현하면,
print(score2)

# 튜닝 : 모델의 정확도 개선하기
# 원래 있던 30개 필드를 모두 포함해 학습 데이터와 검증 데이터를 다시 만든다.
x2_train, x2_test, y_train, y_test = train_test_split(df, y, train_size = 0.7, test_size = 0.3, random_state = random_seed)

# 로지스틱 회귀 모델도 다시 만든다.
algorithm2 = LogisticRegression(random_state = random_seed)

# 새로 만든 학습 데이터로 학습을 진행한다.
algorithm2.fit(x2_train, y_train)

# 검증 데이터로 정확도를 확인한다.
score2 = algorithm2.score(x2_test, y_test)
print(f'정확도 : {score2:.04f}')

# 모델의 내부변수(절편, 계수)값 구하기

# x1, x2의 계수
w1 = algorithm.coef_[0][0]
w2 = algorithm.coef_[0][1]

# 절편
w0 = algorithm.intercept_[0]

# 값 확인하기
print(f'w0 = {w0:.4f}  w1 = {w1:.4f}  w2 = {w2:.4f}')

# 결정경계를 계산하는 함수

# 결정경계 계산 함수
# 0 = w0 + w1 * x + w2 * y를 y에 대해 풀면
# y = -(w0 + w1 * x)/ w2가 된다

def boundary(algorithm, x):
    w1 = algorithm.coef_[0][0]
    w2 = algorithm.coef_[0][1]
    w0 = algorithm.intercept_[0]
    y = -(w0 + w1 * x)/w2
    return y

# 결정경계의 경곗값 계산하기

# 결정경계의 x축 양끝 좌표값
x_range = np.array((df['반지름_평균'].min(), df['반지름_평균'].max()))

# 결정경계의 y축 양끝 좌표값
y_range = boundary(algorithm, x_range)

# y의 최솟값과 최댓값은 산포도의 점으로 결정한다
y_lim = (df['텍스처_평균'].min(), df['텍스처_평균'].max())

# 결과 확인
print('x축 양끝 좌표: ', x_range)
print('y축 양끝 좌표: ', y_range)
print('그래프의 y구간: ', y_lim)

# 산포도와 결정경계 그리기

# 그래프 크기 정의
plt.figure(figsize=(6,6))

# 목적변수의 값이 0인 데이터의 산포도
plt.scatter(df0['반지름_평균'], df0['텍스처_평균'], marker='x', c='b', label='악성')

# 목적변수의 값이 1인 데이터의 산포도
plt.scatter(df1['반지름_평균'], df1['텍스처_평균'], marker='s', c='k', label='양성')

# 결정경계
plt.plot(x_range, y_range, c='r', label='결정경계')

# 범위 지정
plt.ylim(y_lim)

# 레이블 추가
plt.xlabel('반지름_평균')
plt.ylabel('텍스처_평균')

# 범례 표시
plt.legend()

# 그리드 표시
plt.grid()

# 그래프 화면 출력
plt.show()

import numpy as np

from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import numpy as np


np.random.seed(41)

iris = load_iris()
knn = KNeighborsClassifier(n_neighbors = 5)

X_train, X_test, Y_train, Y_test = train_test_split(iris['data'], iris['target'], test_size = 0.25, stratify = iris['target'])

Y_train

knn.fit(X_train, Y_train)

y_pred = knn.predict(X_test)

print("prediction accuracy:{:.2f}".format(np.mean(y_pred == Y_test)))

머신러닝 진행과정

머신러닝은 아래의 순서대로 진행된다.

데이터 읽기 -> 데이터 확인 -> 데이터 전처리 -> 데이터 분할 -> 알고리즘 선택 -> 데이터 학습 -> 예측 -> 평가 -> 튜닝

데이터 읽기

유방암 정보를 sklearn.datasets 에서 가져와 읽는다.

데이터 확인 & 전처리

유방암 정보를 알고리즘 모델에서 사용하기 위해 확인하고 사전작업을 진행한다.
사용될 정보들을 네이밍 해주고, 어떤게 악성이고, 어떤게 양성인지 구분하는 작업 등등

데이터 분할

데이터셋을 학습데이터와 검증데이터로 분할한다.

보통 과적합을 방지하기 위해서 전체데이터를 학습데이터, 검증데이터, 테스트 데이터로 나누는데, 비율을 5 : 3 : 2 로 한다고 한다.

Training data : 모형 f 를 추정하는데 사용
Validation data : 모형 f 가 적합한지 검증에 사용
Test data : 최종적으로 모형 f 의 성능 평가에 사용

알고리즘 선택

위에 내용에서는 미리 알고리즘을 선택해서 진행하였지만, 보통 아래와 같이 여러 알고리즘을 import 시켜서 테스트해보고 가장 적합한 알고리즘 모델을 선택한다.

# 여러가지 알고리즘을 담은 리스트 생성하기
# 여러 알고리즘 비교하는데, 결과가 같게 random_state 값은 동일하게 둔다

# 선형 회귀
from sklearn.linear_model import LogisticRegression
algorithm1 = LogisticRegression(random_state = random_seed)

# 서포트 벡터 머신(커널)
from sklearn.svm import SVC
algorithm2 = SVC(kernel = 'rbf', random_state = random_seed)

# 결정 트리
from sklearn.tree import DecisionTreeClassifier
algorithm3 = DecisionTreeClassifier(random_state = random_seed)

# 랜덤 포레스트
from sklearn.ensemble import RandomForestClassifier
algorithm4 = RandomForestClassifier(random_state = random_seed)

# XGBoost
from xgboost import XGBClassifier
algorithm5 = XGBClassifier(random_state = random_seed)

# 알고리즘을 담은 리스트 생성
algorithms = [algorithm1, algorithm2, algorithm3, algorithm4,
              algorithm5]

# 정확도 비교하기

for algorithm in algorithms:
  # 학습을 수행
  algorithm.fit(x_train, y_train);

  # 정확도 측정
  score = algorithm.score(x_test, y_test);

  # 알고리즘 이름
  name = algorithm.__class__.__name__

  # 정확도, 알고리즘 이름 출력
  print(f'score : {score:.4f}  {name}')