728x90
반응형

순환신경망(RNN)

📍 순환신경망(Recurrent Neural Network, RNN)
 - RNN은 텍스트 처리를 위해 고안된 모델(계층)
 - 바로 이전의 데이터(텍스트)를 재사용하는 신경망 계층임 - 이전에 진행한 훈련기억을 가지고 다시 훈련하는 방식

📍 순환신경망 종류
 - 심플 순환신경망(Simple RNN)
 - 장기기억 순환신경망(LSTM)
 - 게이트웨이 반복 순환신경망(GRU)

📍 Simple RNN 단점
 - 긴 문장(시퀀스)을 학습하기 어려움
 - 시퀀스가 길 수록 초반의 정보는 점진적으로 희석(소멸)
 - 즉, 멀리 떨어져 있는 단어의 정보를 인식하는데 어려움이 있음
 - 이러한 단점을 보환한 모델이 LSTM과 GRU

📍 LSTM(Long Shot-Term Memory, 장기기억)
 - 단기기억을 오래 기억할 수 있도록 고안된 모델
 - 많은 이전 정보를 기억해야 하기 때문에 훈련 속도가 느리며, 시스템 저장 공간이 많이 필요함

📍 GRU(Gated Recurrent Unit, 게이트 반복 단위)
 - LSTM의 느린 속도를 개선하기 위해 고안된 모델
 - 성능은 LSTM과 유사함

📍 Simle RNN, LSTM, GRU 모두 RMSprop 옵티마이저를 일반적으로 사용
  • 사용 라이브러리
    import tensorflow as tf
    from tensorflow import keras
    
    ''' 영화 감상평에 대한 긍정/부정 데이터셋 '''
    from tensorflow.keras.datasets import imdb
    
    from sklearn.model_selection import train_test_split
    
    ''' 텍스트 길이 정규화 라이브러리 '''
    from tensorflow.keras.preprocessing.sequence import pad_sequences
  • 사용할 데이터 :  IMDB
    ''' 데이터 불러들이기
     - IMDB 데이터 사용, 말뭉치 500개 사용
    '''
    (train_input, train_target), (test_input, test_target) = imdb.load_data(num_words=500)
    
    print(train_input.shape, train_target.shape)
    print(test_input.shape, test_target.shape)​


  • 훈련 : 검증 데이터로 분류하기 (8 : 2)
    ''' train : val = 8 : 2로 분류하기 '''
    
    train_input, val_input, train_target, val_target = train_test_split(train_input, train_target, test_size=0.2, random_state=42)
    print(train_input.shape, train_target.shape)
    print(val_input.shape, val_target.shape)
    print(test_input.shape, test_target.shape)​


  • 텍스트 정규화하기
    - 훈련, 검증, 테스트 데이터 내의 각 문장의 길이를 100으로 통일(정규화) 시키기
    - 왜 100인가? 단어 갯수의 분포를 이용해서 훈련에 사용할 독립변수 각 값들의 길이 기준 정의했을 때, 전체적으로 왼쪽편에 집중되어 있으며, x축 125 정도에 많은 빈도를 나타내고 있음. 따라서, 독립변수 각 값들의 길이를 100으로 통일(정규화)
    - 앞쪽을 제거, 채우기
    - pad_sequences() : 텍스트의 길이를 maxlen 갯수로 통일시키기
    - maxlen보다 작으면 0으로 채우고, 크면 제거한다.

    train_seq = pad_sequences(train_input, maxlen=100)
    
    val_seq = pad_sequences(val_input, maxlen=100)
    
    test_seq = pad_sequences(test_input, maxlen=100)
    
    print(train_seq.shape, train_target.shape)
    print(val_seq.shape, val_target.shape)
    print(test_seq.shape, test_target.shape)

장기기억 순환신경망(LSTM)

  • LSTM 모델 생성하기
    model = keras.Sequential()
    model​
  • 계층 생성 및 모델에 추가하기 
    - 임베딩 계층 추가 : 말뭉치 500, 출력크기 16, 입력크기 100
    - LSTM 계층 추가 : 출력크기 8
    - 출력 계층 추가
    model.add(keras.layers.Embedding(500, 16, input_length=100))
    model.add(keras.layers.LSTM(8))
    model.add(keras.layers.Dense(1, activation="sigmoid"))
    
    model.summary()​


  • 모델 설정하기
    - 학습율 : 0.0001
    - 옵티마이저 : RMSprop
    - RMSprop : 먼 거리는 조금 반영, 가까운 거리는 많이 반영하는 개념을 적용
    rmsprop = keras.optimizers.RMSprop(learning_rate=0.0001)
    model.compile(optimizer=rmsprop,
                 loss="binary_crossentropy",
                 metrics=["accuracy"])​
  • 콜백함수 정의하기
    - 자동 저장 위치 및 파일명 : ./model/best_LSTM_model.h5

    - 자동저장 및 자동 종료 콜백함수 정의하기
    checkpoint_cb = keras.callbacks.ModelCheckpoint("./model/best_LSTM_model.h5")
    
    early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
                                                     restore_best_weights=True)
    checkpoint_cb, early_stopping_cb
  • 모델 훈련시키기
    - 100번 반복, 배치사이즈 64, 검증 동시 진행
    model.fit(train_seq, train_target,
              epochs=100,
              batch_size=64,
              validation_data=(val_seq, val_target),
              callbacks=[checkpoint_cb, early_stopping_cb])

  • 훈련, 검증, 테스트 성능검증하기
    model.evaluate(train_seq, train_target)
    model.evaluate(val_seq, val_target)
    model.evaluate(test_seq, test_target)


  • LSTM 모델의 드롭아웃 속성(계층아님) 적용하기
    - LSTM 모델(계층)에 드롭아웃 속성 적용, 30% 훈련에서 제외
    - 나머지 모두 위와 동일하게 처리하여 훈련, 검증, 테스트 데이터에 대한 성능검증 진행
    ''' 모델 생성 '''
    model = keras.Sequential()
    
    ''' 계층 생성 '''
    model.add(keras.layers.Embedding(500, 16, input_length=100))
    model.add(keras.layers.LSTM(8, dropout=0.3))
    model.add(keras.layers.Dense(1, activation="sigmoid"))
    
    ''' 모델 설정 '''
    rmsprop = keras.optimizers.RMSprop(learning_rate=0.0001)
    model.compile(optimizer=rmsprop,
                 loss="binary_crossentropy",
                 metrics=["accuracy"])
    
    ''' 콜백함수 정의 '''
    checkpoint_cb = keras.callbacks.ModelCheckpoint("./model/best_LSTM_model.h5")
    early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
                                                     restore_best_weights=True)
    
    ''' 모델 훈련 '''
    model.fit(train_seq, train_target,
              epochs=100,
              batch_size=64,
              validation_data=(val_seq, val_target),
              callbacks=[checkpoint_cb, early_stopping_cb])​
  • 드롭아웃 속성 적용 시 훈련, 검증, 테스트 성능검증하기
    model.evaluate(train_seq, train_target)
    model.evaluate(val_seq, val_target)
    model.evaluate(test_seq, test_target)​


  • LSTM 2개 연결하기
    - LSTM 2개를 연결할 때는 연속해서 LSTM 계층을 추가해야함
    - 첫번째 LSTM 계층의 속성에는 return_sequences=True 속성을 추가해 준다.
    - 두번째 LSTM은 첫번째 LSTM의 훈련결과를 이어받아서 계속 훈련을 이어나간다.
    ''' 모델 생성 '''
    model = keras.Sequential()
    
    ''' 계층 생성 '''
    model.add(keras.layers.Embedding(500, 16, input_length=100))
    model.add(keras.layers.LSTM(8, dropout=0.3, return_sequences=True))
    model.add(keras.layers.LSTM(8, dropout=0.2))
    model.add(keras.layers.Dense(1, activation="sigmoid"))
    
    ''' 모델 설정 '''
    rmsprop = keras.optimizers.RMSprop(learning_rate=0.0001)
    model.compile(optimizer=rmsprop,
                 loss="binary_crossentropy",
                 metrics=["accuracy"])
    
    ''' 콜백함수 정의 '''
    checkpoint_cb = keras.callbacks.ModelCheckpoint("./model/best_LSTM_model.h5")
    early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
                                                     restore_best_weights=True)
    
    ''' 모델 훈련 '''
    model.fit(train_seq, train_target,
              epochs=100,
              batch_size=64,
              validation_data=(val_seq, val_target),
              callbacks=[checkpoint_cb, early_stopping_cb])

  • LSTM 2개 연결 시 훈련, 검증, 테스트 성능검증하기

게이트웨이 반복 순환신경망(GRU)

  • GRU 모델
''' 모델 생성 '''
model = keras.Sequential()

''' 계층 생성 '''
model.add(keras.layers.Embedding(500, 16, input_length=100))
model.add(keras.layers.GRU(8))
model.add(keras.layers.Dense(1, activation="sigmoid"))

''' 모델 설정 '''
rmsprop = keras.optimizers.RMSprop(learning_rate=0.0001)
model.compile(optimizer=rmsprop,
             loss="binary_crossentropy",
             metrics=["accuracy"])

''' 콜백함수 정의 '''
checkpoint_cb = keras.callbacks.ModelCheckpoint("./model/best_LSTM_model.h5")
early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
                                                 restore_best_weights=True)

''' 모델 훈련 '''
history = model.fit(train_seq, train_target,
          epochs=100,
          batch_size=64,
          validation_data=(val_seq, val_target),
          callbacks=[checkpoint_cb, early_stopping_cb])

 

  • 훈련, 검증, 테스트 성능검증하기
model.evaluate(train_seq, train_target)
model.evaluate(val_seq, val_target)
model.evaluate(test_seq, test_target)

 
728x90
반응형
728x90
반응형

DL 시작 전 가상환경 새로 생성하기

1. conda 업데이트
          > conda update -n base conda

2. pip 업데이트
          > python -m pip install --upgrade pip

3. 가상환경 생성하기
          > conda create -n gj_env_ python=3.9
4. 가상환경으로 들어가기(활성화시키기)

          > conda activate gj_env_dl
5. 외부 에디터에서 가상환경 연결(kernel) 하기 위하여 jupyter 설치하기
          > pip install jupyter notebook
6. 커널 생성하기 (base root 가상환경에서 진행)
          > python -m ipykernel install --user --name gj_env_dl --display-name gj_env_dl_kernel
7. 커널 생성 목록 확인하기
          > jupyter kernelspec list
8. 기본 패키지 설치하기( gj_env_dl에서 진행)
          > pip install ipython jupyter matplotlib pandas xlrd seaborn scikit-learn
          > pip install openpyxl
          > pip install folium (지도 시각화)
          > pip install plotly (시각화)
          > pip install xgboost (머신러닝 앙상블 분류모델)
          > pip install nltk (자연어처리)
          > pip install wordcloud
          > pip install JPype1
          > pip install konlpy (/anaconda3/envs/gj_env_dl/Lib/site-packages/konlpy/jvm.py에서 별(*) 표시 삭제)
9. 딥러닝 - 텐서플로우 설치하기( 텐서플로우  설치 후 numpy 설치하면 충돌 난다. 텐서플로우의 numpy가 따로 있다.)
          > pip install tensorflow==2.8.2
10. 딥러닝 - 모델 시각화 라이브러리
          > conda install -c conda-forge pydot graphviz

 

Tensorflow 정상적으로 설치되었는지 확인

> python
>>> from tensorflow import keras
>>> from tensorflow.keras.layers import Dense
>>> dns = keras.Sequential()

>>> dns.add(Dense(units=1, input_shape(1,)))
>>> dns.compile(optimizer="sgd", loss="mse")
>>> dns.summary()

 

인공신경망 훈련 모델 맛보기

🏓라이브러리 불러오기

import tensorflow as tf
from tensorflow import keras

import matplotlib.pyplot as plt
import numpy as np

from sklearn.model_selection import train_test_split

 

🏓랜덤 고정값 설정

''' 실행 결과를 동일하게 하기 위한 처리(완전 동일하지 않을 수도 있음) '''
tf.keras.utils.set_random_seed(42)

''' 연산 고정 '''
tf.config.experimental.enable_op_determinism()

 

데이터 수집

'''
- keras에서 제공해주는 이미지 데이터셋 사용
- MNIST 패션 이미지
- 이미지 데이터는 픽셀 데이터로 이루어져 있다.
'''
# 튜플(독립변수 종속변수) 안에 튜플(훈련데이터, 테스트데이터) 안에 array
(train_input, train_target), (test_train, test_target) = keras.datasets.fashion_mnist.load_data()
print(train_input.shape, train_target.shape)
print(test_train.shape, test_target.shape)

''' 이미지 1개에 대한 데이터 추출
    - 각 데이터는 픽셀값(색상값)
    - 픽셀값(색상값)은 0 ~ 255 (총 256개의 값드로 구성되어 있음)
'''
train_input[0]

 

훈련데이터 10개만 이용해서 데이터를 이미지로 시각화하기

''' 서브플롯 사용 : 이미지 10개를 하나로 시각화 '''
fig, axs = plt.subplots(1, 10, figsize=(10, 10))

''' 훈련데이터 10개에 대한 처리 '''
for i in range(10) : 
    ''' 픽셀데이터를 이미지로 시각화 : imshow() '''
    axs[i].imshow(train_input[i], cmap="gray_r")

    ''' x, y 좌표계 숨기기 '''
    axs[i].axis("off")
plt.show()

''' 종속변수 10개 추출해서 매핑된 값 확인해보기 '''
train_target[:10]

''' 종속변수의 범주값 확인하기 '''
np.unique(train_target, return_counts=True)

 

데이터 스케일링

  • 사용되는 데이터의 특성상 0부터 255까지의 값을 가지고 있음
  • 값의 범위 폭이 크기 때문에 일반화(데이터 스케일링)하여 사용
  • 데이터 스케일링을 수행하는 방법으로 라이브러리를 사용해도 되며, 값의 최댓값을 이용해서 산술 연산을 이용해 데이터 스케일링해도 된다.
  • 데이터 스케일링 수행하기
train_scaled_255 = train_input / 255.0
train_scaled_255[0]

test_scaled_255 = test_input / 255.0
test_scaled_255[0]

train_scaled_255.shape, test_scaled_255.shape

  • 모델 훈련에 사용하기 위해서는 2차원으로 변환 필요
train_scaled_2d = train_scaled_255.reshape(-1, 28*28)
train_scaled_2d.shape

 

훈련 : 검증 데이터로 분리 (8:2)

train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled_2d,
                                                                      train_target,
                                                                      test_size=0.2,
                                                                      random_state=42)
print(train_scaled.shape, train_target.shape)
print(val_scaled.shape, val_target.shape)

 

인공신경망 모델 훈련시키기 위한 단계

🏓 딥러닝은 계층 구조의 모델로 구성됨

🏓 2. 인공신경망 계층(layer) 생성하기

  • Dense
    → 딥러닝에서 가장 기본적인 계층
    → 모델에 넣어서 훈련을 수행하게 된다.

  • 딥러닝에서 사용하는 용어
    → 특성 : 뉴런이라고도 칭한다.
    → 크기 : 갯수를 의미한다.

  • 딥러닝에서 사용되는 숫자들의 범위
    →  일반적으로 딥러닝에서는 숫자의 범위를 16 ~ 512 또는 32 ~ 512로 사용한다.
    →  높이와 너비를 나타내는 숫자가 있는 경우에는 3x3 또는 5x5를 주로 사용한다.

  • 모델에는 여러개의 계층(layer)이 사용될 수 있다.
    • 첫번째 계층
      → 입력 계층(Input layer)이라고 칭한다.
      → 입력 계층에는 input_shape()가 정의된다.
      → input_shape()에는 독립변수의 열갯수를 정의한다
      → 모델에서 한개의 계층만 사용되는 경우에는 입력 계층이 곧, 출력 계층의 역할까지 수행한다.
                  >> 이 경우에는 출력 크기는 종속변수의 범주 갯수를 정의한다.
                        
    • 중간 계층
      → 은닉 계층(Hidden layer)이라고 칭한다.
      → 은닉 계층은 여러개 사용된다.
      → 은닉 계층의 출력 크기(갯수)는 일정하지 않다.
      → 출력 크기(갯수)는 사람이 정한다.
      출력 크기(갯수)는 다음 은닉계층이 입력 크기(갯수)로 받아서 훈련을 이어가는 방식이다.

    • 마지막 계층
      → 출력 계층(Output layer)이라고 칭한다.
      → 출력 계층에 사용되는 출력 크기는 종속변수의 범주 갯수를 정의한다.
  • units : 특정 계층에서의 출력의 크기(갯수), 결과갯수
    →  딥러닝 모델에는 계층이 여러개 사용될 수 있으며, 마지막 계층에는 units의 갯수는 종속변수 범주의 갯수를 사용한다.
    →  중간에 사용되는 계층을 은닉계층(hidden layer)이라고 칭하며, 중간에 사용되는 계층 간에는 출력 크기를 넘겨받아서 사용된다.
    →  중간 계층의 출력 크기에 따라서 성능에 영향을 미칠 수도 있기 때문에 하이퍼파라미터 튜닝을 진행하는 경우도 있다.
    →  하이퍼파라미터 튜닝은 값을 바꾸면서 여러번 시도하는 방식을 따른다.
        
  • kernel_initializer : 가중치를 초기화하는 방법을 지정
    →  가중치 : 손실을 최소화하기 위해서 모델이 훈련을 반복하는 과정에서 스스로 조정하는 값을 의미함
    →  가중치 초기화 방법 : uniform, normal 방법이 있음
         * uniform : 균일 분포 방법
         * normal : 가우시안 분포(정규 분포) 방법
  • activation : 활성화 함수라고 칭한다.
    →  훈련 시 입력된 특성(뉴런)의 크기를 어떤 형태의 크기로 변환할지를 결정하는 방법 정의
    →  출력계층(Output Layer)에는 해당 종속변수의 특성에 따라 결정됨
             >> 선형형태인 회귀분석의 경우 linear 사용
             >> 범주형태의 분류분석인 경우 Sigmoid, Softmax, ReLU, Tanh, Leaky ReLU 등 사용
                               > 이진분류 : Sigmoid, ReLU, Tanh, Leaky ReLU
                               > 다중분류 : Softmax
    →  입력계층 또는 은닉계층에는 Sigmoid, Softmax, ReLU, Tanh, Leaky ReLU 등이 사용됨

dense = keras.layers.Dense(units=10,
                           kernel_initializer="uniform",
                          activation="softmax",
                          input_shape=(784, )
                          )
dense

🏓 1. 인공신경망 모델 생성하기

model = keras.Sequential(dense)
model

🏓 3 . 모델 설정 단계

  • loss
    → 손실을 줄이기 위해 사용되는 함수 정의
    → 손실함수에는 categorical_crossentropy, binary_crossentropy, sparse_categorical_crossentropy 가 있음
    • categorical_crossentropy : 다중분류 손실함수
      종속변수의 데이터 값이 원-핫인코딩된 형태로 되어있는 경우 사용
      예시 데이터 : [[0, 1, 0], [0, 0, 1], [0, 1, 0], ...]
    • sparse_categorical_crossentropy : 다중분류 손실함수
      종속변수의 데이터 값이 숫자값으로 3개 이상으로 되어있는 경우 사용
      예시 데이터 : [0, 1, 2, 3, 4, ... ]
    • binary_crossentropy : 이진분류 손실함수
      종속변수의 데이터 값이 숫자값으로 2개 정의되어 있는 경우
      예시 데이터 : [0, 1, 1, 0, 0, 1, ... ]
model.compile(
    ### 손실함수 : 종속변수의 형태에 따라 결정 됨
    loss="sparse_categorical_crossentropy",
    ### 훈련 시 출력할 값 : 정확도 출력
    metrics="accuracy"
)

 

 

💡categorical_crossentropy와 관련한 원-핫 인코딩 예제

import numpy as np
from tensorflow.keras.utils import to_categorical

### 임의 데이터 생성
# - randint() : 랜덤하게 정수값을 생성하는 함수
#   --> 첫번째 인자 : 범주의 범위(0~2까지로 3개의 범주를 의미함)
#   --> 두번째 인자 : 몇 개의 랜덤한 범주값을 만들지에 대한 값(10개 생성)
labels = np.random.randint(3, size=(10,))
labels

### 원-핫 인코딩(One-Hot Encoding) 하기
# - to_categorical() : 각각의 값을 범주의 갯수만큼의 리스트로 데이터 생성
#                   : 리스트 내 데이터에서 1이 있는 곳의 인덱스 위치값은 실제 labels의 값과 동일
# - num_classes : unique한 범주의 갯수 정의
one_hot_labels = to_categorical(labels, num_classes=3)
labels, one_hot_labels.shape, one_hot_labels

🏓 4. 모델 훈련시키기

''' epochs : 훈련 반복 횟수(손실함수의 손실률을 계속 줄여나가면서 반복함) ''' 
# model.fit(train_scaled, train_target, epochs=100)
# 정확도가 거의 유사하다면 손실률이 작은 것을 선택한다.
# 91번 loss: 0.4116 - accuracy: 0.8772 와 98번 loss: 0.4140 - accuracy: 0.8774를 비교했을 때 91번 선택
model.fit(train_scaled, train_target, epochs=91)

🏓 5. 모델 성능 검증하기

score = model.evaluate(val_scaled, val_target)
score

 

인공신경망 모델 훈련 순서

  1. 모델 생성 (또는 계층 생성)
  2. 계층 생성 (또는 모델 생성)
  3. 모델 설정 (compile)
  4. 모델 훈련 시키기(fit)
  5. 성능평가(검증, evaluate)

성능 개선 방법

  • 데이터 증가 시키기
  • 하이퍼파라미터 튜닝(일반적으로 딥러닝에서는 디폴트 값을 사용해도 됨)
    성능이 현저히 낮은 경우에는 튜닝 필요
  • 계층을 추가 또는 제거

모델에서 사용한 계층 확인하기

''' 
 - Output Shape() : 출력 크기 (10개 출력) 
 - Param : 계층이 훈련 중에 사용한 총 특성의 갯수
     -> Dense() 계층 계산공식 = (입력크기 + 1) * 출력크기
                             = (784 + 1) * 10 = 7850
'''
model.summary()
# dense계층에서 훈련시킴

은닉계층(Hidden Layer) 추가하기

model.add(
    keras.layers.Dense(
        10,
        kernel_initializer="uniform",
        activation="relu",
        input_shape=(784, )
    )
)
# 훈련
model.fit(train_scaled, train_target, epochs=50)
# 검증
model.evaluate(val_scaled, val_target)
model.summary()

 

첫 dense에서 나온 출력 값 10이 그대로 dense_2로 이 입력값으로 들어감.

dense_2의 Param이 110인 이유?

(10+ 1) * 10 = 110

 

728x90
반응형
728x90
반응형

모델 저장 및 불러오기

훈련모델 저장 및 불러오는 2가지 방법

  • joblib 방식
  • pickle 방식

모델 저장하기 전에 와인데이터로 rf모델 생성함

 joblib 방식

import joblib
''' 
훈련모델 저장하기 
 - 파일 확장자는 자유롭게
'''

joblib.dump(rf, "./model/rf_model_joblib.md")

''' 모델 파일 불러들이기 '''
joblib_model = joblib.load("./model/rf_model_joblib.md")
joblib_model

joblib_model.predict(test_input)

 

pickle 방식

import pickle

''' 
훈련모델 저장하기 
 - wb : w는 쓰기, b는 바이너리 => 바이너리 형태로 쓰기
'''

with open("./model/rf_model_pickle.md", "wb") as fw :
    pickle.dump(rf, fw)
''' 
모델 파일 불러오기
 - rb : r는 읽기, b는 바이너리 => 바이너리 형태의 파일 내용 읽기
'''
with open ("./model/rf_model_pickle.md", "rb") as f :
    load_pickle_model = pickle.load(f)

load_pickle_model

load_pickle_model.predict(test_input)

728x90
반응형
728x90
반응형

군집모델

군집(Clustering)분석

  • 비지도 학습
  • 군집분석은 분류를 위한 분석
  • 패턴이 유사한 데이터들끼리 묶는 작업
  • 묶음 단위를 군집(Cluster)이라고 칭한다.
  • 대표 모델 : KMeans(K평균)

KMeans(K평균) 군집 모델

  • 모델 스스로 패턴이 유사한 특성(컬럼)들을 묶으면서 중심 평균을 구하는 방식
  • 점진적으로 패턴이 유사한 특성들끼리 묶어나가는 방식
  • 특성들이 묶이면서 중심에 대한 평균이 이동됨
  • 가장 대표적인 군집모델

🖍️ 특징

  • 군집할 갯수를 미리 정의해야 함
  • 군집할 갯수는 종속변수의 범주의 갯수와 동일함(이미 종속변수를 알고 있는 경우도 있고, 아닌 경우도 있음)
  • 군집의 갯수를 이미 알고 있는 경우에는 직접 갯수 정의, 모르는 경우에는 하이퍼파라미터 튜닝을 통해 적절한 갯수 선정 

🖍️ 작동방식

  1. 데이터들을 이용해서 무작위로 K개의 클러스터 중심을 정함
  2. 각 샘플에서 가장 가까운 클러스터 중심을 찾아서 해당 클러스터의 샘플로 지정
  3. 특정 클러스터에 속한 "샘플들의 평균값"으로 클러스터 중심을 변경
  4. 클러스터 중심에 변화가 없을 때까지 2번 ~ 3번을 반복 수행하게 되는 모델임

사용할 라이브러리

import pandas as pd
import numpy as np

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import accuracy_score, confusion_matrix

''' KMeans 군집 모델 '''
from sklearn.cluster import KMeans

 

사용할 데이터 셋 - 와인데이터

'''
 - 데이터 불러오기 : 변수명 data
 - 독립변수와 종속변수로 나누기 : 변수명은 X, y
'''
data = pd.read_csv("./data/08_wine.csv")
X = data.iloc[:,:-1]
y = data["class"]
X.shape, y.shape

 

데이터 스케일링 - 정규화

'''
 - 정규화 클래스 변수 : scaler
 - 독립변수 정규화 변수명 : X_scaled
'''

scaler = StandardScaler()
scaler.fit(X)
X_scaled = scaler.transform(X)

X_scaled.shape

 

훈련 : 테스트 분리하기 (8:2)

'''
 - 변수명 : X_train, X_test, y_train, y_test
'''
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, random_state=42, test_size=0.2)

print(X_train.shape, y_train.shape)
print(X_test.shape, y_test.shape)

 

하이퍼파라미터 튜닝을 위한 매개변수 정의하기

'''
 - n_clusters : 군집갯수
 - n_init : 초기 중심점 설정 횟수
 - max_iter : 최대 반복 횟수
 - tol : 중심정의 이동이 설정 값보다 작으면 종료
'''

param_grid = {
    "n_init" : [10, 30, 50],
    "max_iter" : [10, 30, 50],
    "tol" : [0.0001, 0.001, 0.01, 0.1]
    # "n_clusters" : [2, 3, 4, 5]
}

 

 

튜닝 및 훈련모델 생성

  • 튜닝에 사용할 훈련모델 생성
kmeans = KMeans(n_clusters=2, random_state=42)
  • GridSearchCV 생성하여 베스트 모델 찾기
grid_search = GridSearchCV(kmeans, param_grid, cv=5, scoring="accuracy")
grid_search

  • 튜닝 시작하기
grid_search.fit(X_train, y_train)

  • 최적의 매개변수를 가지는 모델 추출하기
best_model = grid_search.best_estimaitor_
best_model

 

훈련 및 검증(테스트) 모델 평가하기

'''
 - 훈련 및 테스트 예측
 - 훈련 및 테스트 정확도 확인
 - 오차행렬(혼동행렬) 추출
'''

train_pred = best_model.predict(X_train)
test_pred = best_model.predict(X_test)

train_acc = accuracy_score(y_train, train_pred)
test_acc = accuracy_score(y_test, test_pred)

''' 오차행렬도(혼동행렬) '''
cm = confusion_matrix(y_test, test_pred)

print(f"훈련 정확도 : {train_acc} / 테스트 정확도 : {test_acc}")
print(f"오차행렬(혼동행렬) : {cm}")

결과

와인 데이터는 군집분석으로 적절하지 않다

지도학습 기반의 분류모델이 적절하다.

지도학습을 하려면 정답을 알아야 한다.

정답을 알지 못한다면 라벨링을 해야 한다.(종속변수를 만들어야 한다)

 

시각화 하기

  • 시각화 라이브러리
import matplotlib.pyplot as plt
import seaborn as sns

plt.rc("font", family="Malgun Gothic")
plt.rcParams["axes.unicode_minus"] = False
  • 시각화에 사용할 데이터 생성하기
data = {
    "alcohol" : X_train[:, 0],
    "sugar" : X_train[:, 1],
    "pH" : X_train[:, 2],
    "class" : y_train,
    "cluster" : train_pred
}   
train_data = pd.DataFrame(data=data)
train_data

  • 시각화하기
sns.pairplot(train_data, hue="cluster")
plt.show()

 

class가 0과 1 밖에 없기 때문에 위와 같은 일직선 모양의 그래프가 나타남

섞여있으면 군집이 안된 것 (예를 들어, alcohol과 pH)

파란색(0)이 1에 있으면 틀린 것 > 분류를 잘못함

주황색(1)이 0에 있으면 틀린 것 > 분류를 잘못함

 

Iris(붓꽃) 데이터셋을 이용한 군집(Clustering)분석

  • 사용 라이브러리
from sklearn.cluster import KMeans

''' 
 군집분석 평가 방법 : 실루엣 score로 평가함
 - 값의 범위 : -1 ~ 1 사이의 값
 - -1에 가까울 경우 : 군집 분류가 잘 안된 경우
 - 0에 가까울 경우 : 이도 저도 아닌 상태()
 - 1에 가까울 경우 : 군집이 잘 된 경우
'''

from sklearn.metrics import silhouette_score

''' Iris(붓꽃) 데이터셋 라이브러리 '''
from sklearn.datasets import load_iris

import seaborn as sns
  • Iris 데이터 읽어들이기
iris = load_iris()
iris
  • 특성 설명

- sepal length : 꽃받침 길이
- sepal width : 꽃받침 너비
- petal length : 꽃잎 길이
- petal width : 꽃잎 너비

 

  • 종속변수 특성 설명
    - 0, 1, 2의 값 (붓꽃의 품종)
    - 0 : 세토사(setosa)
    - 1 : 버시컬러(verstcolor)
    - 2 : 버지니카(virginica)

  • 분석 주제
    - 4가지 독립변수 특성을 이용하여 붓꽃의 품종 종류별로 군집(클러스터) 분류하기

독립변수와 종속변수 데이터 추출하기

'''
독립변수명 : X
종속변수명 : y
'''

X = iris.data
y = iris.target
X.shape, y.shape

 

군집 모델 생성 / 훈련 및 예측

'''
 - 군집분류에서는 별도로 훈련과 검증데이터로 분류하기 않고, 전체 데이터를 사용하여 군집합니다.
'''
'''
 * 군집모델 생성하기
  - 군집 갯수 지정
  - n_init : 초기 중심점 설정 횟수는 10으로 설정
  - 랜덤 규칙 : 42번 
'''
kmeans_model = KMeans(n_clusters=3, n_init=10, random_state=42)
kmeans_model

''' 
 - 모델 훈련 및 군집하기(예측)
 - 군집분석에서는 훈련과 동시에 예측이 수행 됨
'''
kmeans_labels = kmeans_model.fit_predict(X)
print(kmeans_labels)
print(y)

 

군집결과 시각화하기

  • 주성분분석(PCA)을 통해 시각화하기
  • 주성분분석(PCA)
    →  훈련에 사용된 특성들 중에 특징을 가장 잘 나타낼 수 있는 특성을 추출하는 방식
    → 특성을 추출하여 특성을 축소시키는 방식으로 "차원축소"라고 칭한다.
    → 주요 성분의 특성만을 사용하기 때문에 빠른 성능을 나타냄
  • 주성분분석(차원축소) 라이브러리
from sklearn.decomposition import PCA

 

  • 주성분분석(PCA) 클래스 생성하기
'''
 - n_components : 주성분 몇개로 차원을 축소할지 정의
'''
pca = PCA(n_components=2)
pca

 

  • 주성분 찾기
pca.fit(X)
X_pca = pca.transform(X)
X_pca.shape

 

  • 시각화 하기
plt.title("K평균 군집화 결과")
plt.scatter(X_pca[:, 0], X_pca[:,1], c=kmeans_labels)
plt.show()

 

 

1개(초록)는 분류가 잘 되었고, 나머지 2개(보라, 노랑)는 섞여있다.

3개의 범주 중 1개는 정확히 분류 되었고 나머지는 섞여있다. 이 둘은 50% 의 확률로 분류되지 않을 수도 있다. 그렇기 때문에 이  분류모델을 사용하기엔 부족한 부분이 있다고 판단한다

 

그러나 보라 노랑이 섞여는 있지만 어느정도 분류된 것 처럼 보이기 때문에 사용할 수 도 있다.

 

 

 

 

  • 군집분석 평가하기 : 실루엣 평가
s_score = silhouette_score(X, kmeans_labels)
s_score

 

728x90
반응형
728x90
반응형

분류모델_선정하기

사용할 라이브러리 정의

''' 데이터 처리 '''
import pandas as pd

''' 데이터 분류 '''
from sklearn.model_selection import train_test_split

''' 하이퍼파라미터 튜닝 '''
from sklearn.model_selection import GridSearchCV

''' 사용할 분류모델들 '''
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import HistGradientBoostingClassifier
from xgboost import XGBClassifier

''' 데이터 스케일링 : 정규화 '''
from sklearn.preprocessing import StandardScaler

''' 평가 '''
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score

''' 오차행렬(혼동행렬) '''
from sklearn.metrics import confusion_matrix
from sklearn.metrics import ConfusionMatrixDisplay

 

데이터 셋

data = pd.read_csv("./data/08_wine.csv")
data.info()
data.describe()

 

데이터프레임에서 독립변수와 종속변수로 데이터 분리하기

''' 
 사용할 변수
 - 독립변수 : X
 - 종속변수 : y
'''

# X = data[["alcohol", "sugar", "pH"]]
X = data.iloc[:,:-1]
y = data["class"]
X, y

 

 

정규화

'''
사용할 변수
 - 독립변수 정규화 : X_scaled
'''
ss = StandardScaler()
ss.fit(X)
X_scaled = ss.transform(X)
X_scaled

훈련:검증:테스트 = 6:2:2로 분리하기

'''
사용할 변수
 - X_train, y_train
 - X_val, y_val
 - X_test, y_test
'''

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.4, random_state=42)
X_val, X_test, y_val, y_test = train_test_split(X_test, y_test, random_state=42, test_size=0.5)

print(f"{X_train.shape} / {y_train.shape}")
print(f"{X_val.shape} / {y_val.shape}")
print(f"{X_test.shape} / {y_test.shape}")

 

훈련에 사용할 모든 모델 생성하기

rf_model = RandomForestClassifier()
et_model = ExtraTreesClassifier()
gd_model = GradientBoostingClassifier()
hg_model = HistGradientBoostingClassifier()
xgb_model = XGBClassifier()

''' 리스트 타입의 변수에 모델 객체 담기 '''
models = [rf_model, et_model, gd_model, hg_model, xgb_model]
models

''' 모델 이름을 리스트 변수에 담기 '''
model_name = [rf_model.__class__.__name__,
              et_model.__class__.__name__,
             gd_model.__class__.__name__,
             hg_model.__class__.__name__,
              xgb_model.__class__.__name__]
model_name

 

GridSearchCV를 위한 하이퍼파라미터 매개변수 정의

  •  n_estimators()
        - 트리의 갯수를 의미함
        - 트리의 갯수를 늘리게 되면 모델의 복잡성이 증가됨
        - 과적합을 방지하고 더 좋은 성능을 낼 수 있음
        - 설정값 : 제한은 없으나, 50, 100 ~ 1000 사이의 값을 주로 사용
        - rf, xt, gb, xgb에서 사용가능
        - hg에서는 max_iter() 함수를 사용함

  • max_depth()
        - 각 트리의 최대 깊이를 의미함(root 노드는 제외)
        - 트리의 최대 깊이가 길어질 수록 모델의 복잡성이 증가함
        - 설정값 : 제한 없음, 주로 None ~ 50 사이의 값이 주로 사용됨
        - 모든 모델 사용가능

  •  min_samples_split()
        - 노드를 분할하기 위한 최소한의 갯수를 의미함
        - 설정값: 제한없음, 2 ~ 10 사이의 값이 주로 사용됨
        - rf, xt, gb 모델만 사용가능

  •  min_samples_leaf()
        - 리프 노드 (결정노드)의 최소한의 샘플 수를 의미함
        - 설정값 : 제한없음, 1 ~ 10 사이의 값이 주로 사용됨
        - rf, xt, gb, hg 모델 사용가능
        - xgb 모델은 min_child_weight() 함수 사용

 

모든 모델에 대해서 GridSearchCV 수행 후 정확도 평가하기

''' RF, GB에서 특성중요도 추출 라이브러리 '''
from sklearn.feature_selection import SelectFromModel
''' HGB에 대한 특성중요도 추출 라이브러리 '''
from sklearn.inspection import permutation_importance

''' 최종 결과는 DataFrame에 저장하여 출력 '''
df = pd.DataFrame()

for model, modelName in zip(models, model_name):
    print(f"------------------{modelName} 시작------------------")
    ''' ------------------하이퍼파라미터 매개변수 정의하기------------------ '''
    if modelName == "HistGradientBoostingClassifier" :
        param_grid = {
            "max_iter" : [50, 100],
            "max_depth" : [None, 10],
            "min_samples_leaf" : [1, 2, 4]
        }

    elif modelName == "XGBClassifier" : 
         param_grid = {
             "n_estimators" : [50, 100],
             "max_depth" : [None, 10],
             "min_child_weight" : [1, 2, 4]
        }
     
    else :
         param_grid = {
             "n_estimators" : [50, 100],
             "max_depth" : [None, 10],
             "min_samples_split" : [2, 5],
             "min_samples_leaf" : [1, 2, 4]
        }

    ''' GridSearchCV 수행하기 '''    
    grid_search = GridSearchCV(model, param_grid, cv=5, scoring="accuracy")
    # print(grid_search)
    
    grid_search.fit(X_train, y_train)

    ''' 최적의 모델 받아오기 '''
    model = grid_search.best_estimator_
    #print(model)

    ''' ------------------훈련 및 검증정확도 확인하기------------------ '''
    ''' 정확도를 확인하기 위하여 예측하기 '''
    train_pred = model.predict(X_train)
    val_pred = model.predict(X_val) 

    ''' 정확도 확인하기 '''
    train_acc = accuracy_score(y_train, train_pred)
    val_acc = accuracy_score(y_val, val_pred)

    ''' ------------------최종 테스트 평가하기------------------ '''
    ''' 테스트 데이터로 예측하기 '''
    test_pred = model.predict(X_test)

    ''' 정확도 확인하기 '''
    test_acc = accuracy_score(y_test, test_pred)
    ''' 정밀도 확인하기 '''
    test_pre = precision_score(y_test, test_pred)
    ''' 재현율 확인하기 '''
    test_rec = recall_score(y_test, test_pred)
    ''' F1 확인하기 '''
    test_f1 = f1_score(y_test, test_pred)

    ''' 오차행렬도(혼동행렬) '''
    cm = confusion_matrix(y_test, test_pred)

    ''' 데이터 프레임에 담기 '''
    df_temp = pd.DataFrame({
        "모델명" : [modelName],
        "훈련정확도" : [train_acc],
        "검증정확도" : [val_acc],
        "테스트정확도" : [test_acc],
        "(훈련-검증)" : [train_acc - val_acc],
        "정밀도" : [test_pre],
        "재현율" : [test_rec],
        "F1-score" : [test_f1]
    })

    ''' 하나의 데이터프레임에 추가하기 '''
    df = pd.concat([df, df_temp], ignore_index=True)

    print(df)

    ''' ------------------특성 중요도------------------ '''
    ''' 독립변수의 특성이름 추출하기 '''
    columnNames = X.columns

    ''' 특성중요도를 담을 리스트 변수'''
    feature_importances = []

    ''' 특성중요도는 모델 훈련에 따른 중요도, 따라서 훈련데이터 사용 '''
    ''' 추출된 특성중요도의 리스트 값의 순서는 특성의 실제 순서와 동일함 '''
    if modelName == "HistGradientBoostingClassifier" :
        feature_importances = permutation_importance(model, X_train, y_train, n_repeats=10, random_state=42)
        feature_importances = feature_importances.importances_mean
    else :
        feature_importances = model.feature_importances_
  
    ''' 추출된 특성중요도 값과 실제 특성명과 매핑하여 딕셔너리에 담기 '''
    feature_importances_dict = {k : v for k, v in zip(columnNames, feature_importances)}

    print(f"특성중요도 : ", feature_importances_dict)
    print()

728x90
반응형
728x90
반응형

https://mzero.tistory.com/115 에 이어서

 

[인공지능][ML] Machine Learning - 분류모델 / 앙상블모델 / 배깅 / 부스팅 / 랜덤포레스트

분류 앙상블 모델 🍇 앙상블 모델 tree구조(결정트리)를 기반으로 만들어진 모델 여러개의 트리 모델을 이용해서 훈련하는 모델을 앙상블 모델이라고 칭한다. 🍇 앙상블 모델 분류 회귀와 분류

 

 

 

 

 

mzero.tistory.com

Randomforest(랜덤포레스트)

🍇 훈련하기

1. StandardScaler 사용

''' 훈련모델 생성하기 '''
from sklearn.ensemble import RandomForestClassifier

''' 모델(클래스) 생성하기
 - cpu의 코어는 모두 사용, 랜덤값은 42번을 사용하여 생성하기
 - 모델 변수의 이름은 rf 사용
'''
rf = RandomForestClassifier(n_jobs=-1, random_state=42)

''' 모델 훈련 시키기 '''
rf.fit(train_std_scaler, train_target)

''' 훈련 및 검증(테스트) 정확도(score) 확인하기 '''
train_score = rf.score(train_std_scaler, train_target)
test_score = rf.score(test_std_scaler, test_target)
print(f"훈련 = {train_score} / 검증 = {test_score}")

 

2. RobustScaler 사용

''' 모델(클래스) 생성하기
 - cpu의 코어는 모두 사용, 랜덤값은 42번을 사용하여 생성하기
 - 모델 변수의 이름은 rf 사용
'''
rf = RandomForestClassifier(random_state=42, n_jobs=-1)

''' 모델 훈련 시키기 '''
rf.fit(train_rbs_scaler, train_target)

''' 훈련 및 검증(테스트) 정확도(score) 확인하기 '''
train_score = rf.score(train_rbs_scaler, train_target)
test_score = rf.score(test_rbs_scaler, test_target)
print(f"훈련 = {train_score} / 검증 = {test_score}")

 

3. MinMaxScaler 사용

''' 모델(클래스) 생성하기
 - cpu의 코어는 모두 사용, 랜덤값은 42번을 사용하여 생성하기
 - 모델 변수의 이름은 rf 사용
'''
rf = RandomForestClassifier(random_state=42, n_jobs=-1)

''' 모델 훈련 시키기 '''
rf.fit(train_mm_scaler, train_target)

''' 훈련 및 검증(테스트) 정확도(score) 확인하기 '''
train_score = rf.score(train_mm_scaler, train_target)
test_score = rf.score(test_mm_scaler, test_target)
print(f"훈련 = {train_score} / 검증 = {test_score}")

 

해석
 - 가장 일반화된 모델을 나타내는 스케일링 방법으로는 StandardScaler 정규화 방법을 사용했을 때 이다.
 - 3개 모두 0.1 이상의 과대적합 양상을 보인다.
 - 따라서, 하이퍼파라미터 튜닝 및 다른 분류모델에 의한 훈련이 필요할 것으로 보인다.
 

🍇 예측하기

''' 모델(클래스) 생성하기 '''
rf = RandomForestClassifier(n_jobs=-1, random_state=42)

''' 모델 훈련 시키기 '''
rf.fit(train_std_scaler, train_target)

''' 예측하기 '''
y_pred = rf.predict(test_std_scaler)
y_pred

 

🍇 성능평가하기

  • 분류 모델 평가 방법
    - 정확도, 정밀도, 재현율, F1-score 값을 이용해서 평가함
    - 예측에 오류가 있는지 확인 : 오차행렬도(혼동행렬도)를 통해 확인

  • 평가 기준
    - 정확도를 이용하여 과적합 여부 확인(이미 위에서 실행함)
    - 재현율이 높고, F1-score 값이 높은 값을 가지는 모델을 선정하게 됨
    - 정확도, 정밀도, 재현율, F1-score의 모든 값은 0~1 사이의 값을 가지며, 값이 높을 수록 좋다.
    - 재현율을 가장 중요시 여긴다.


  • 성능 평가에 시각화 자료 사용
''' 시각화 라이브러리 정의하기 '''
import matplotlib.pyplot as plt
import seaborn as sns

''' 한글처리 '''
plt.rc("font", family = "Malgun Gothic")
''' 마이너스 기호 처리 '''
plt.rcParams["axes.unicode_minus"] = True

import numpy as np
''' 오차행렬 계산 라이브러리 '''
from sklearn.metrics import confusion_matrix
''' 오차행렬도 시각화 라이브러리 '''
from sklearn.metrics import ConfusionMatrixDisplay

 

  • 오차행렬도 그리기
''' 오차행렬의 기준 특성은 종속변수 기준 '''
''' 훈련에서 사용한 종속변수의 범주 확인하기 '''
rf.classes_

''' 오차행렬 평가 매트릭스 추출하기 '''
cm = confusion_matrix(test_target, y_pred, labels=rf.classes_)

''' 오차행렬도 시각화 하기 '''
disp = ConfusionMatrixDisplay(confusion_matrix=cm,
                       display_labels=rf.classes_)

disp.plot()

TN (0, 0) 실제 0인 값을 0으로 예측 > 참
FP (0, 1) 실제 0인 값을 1로 예측 > 긍정적 오류
FN (1, 0) 실제 1인 값을 0으로 예측 > 부정적 오류 : 해당 값이 많을 수록 사용할 수 없는 모델이 된다.
TP (1, 1) 실제 1인 값을 1로 예측 > 참

<오차행렬(혼동행렬)>
- 어떠한 유형의 오류가 발생하고 있는지를 나타내는 값
- 이를 시각화한 것을 오차행렬도 또는 혼동행렬도라고 칭함
- 정확도(score)의 값과 오차행렬도의 시각화 결과로 최종 모델을 선정한다.

<해석 방법>
- 긍정(Positive)적 오류인지, 부정(Negative)적 오류인지로 해석함

* FP(False Positive)
     : 예측결과가 맞지는 않음(False)
     : 긍정적(Positive)로 해석함 : 위험하지 않은 오류

* FN(False Negative)
     : 예측결과가 맞지는 않음(False)
     : 부정적(Negative) 오류로 해석함 
     : 위험한 오류로 해석
     : FN의 값이 크다면, 정확도(score)의 값이 높더라도 예측 모델로 사용하는데 고려해야함

* TP(True Positive)
     : 예측결과가 맞는 경우(True)
     : 1을 1로 잘 예측한 경우

* TN(True Negative)
     : 예측결과가 맞는 경우(True)
     : 0을 0으로 잘 예측한 경우
<평가에 사용되는 값 : 정확도, 정밀도, 재현율, F1_score>

* 정확도
    - 예측결과가 실제값과 얼마나 정확한가를 나타내는 값
    - Accuracy = (TP + TN) / (TP + TN + FP + FN)

* 정밀도(Precision)
    - 모델이 1로 예측한 데이터 중에 실제로 1로 잘 예측한 겂
    - Precision = TP / (TP + FP)

* 재현율(Recall)
    - 실제로 1인 데이터를 1로 잘 예측한 값
    - Recall = TP / (TP + FN)
    - 위험한 오류가 포함되어 있음

* F1-score
    - 정밀도와 재현율을 조합하여 하나의 통계치로 반환한 값
    - 정밀도와 재현율의 평균이라고 생각해소 됨
    - F1 Score = 2 * {(정밀도 * 재현율) / (정밀도 + 재현율)}

<최종 모델 선정 방법>
 - 과소 및 과대 적합이 일어나지 않아야 함
 - 재현율과 F1-score가 모두 높으면 우수한 모델로 평가할 수 있음
 - 재현율이 현저히 낮은 경우에는 모델 선정에서 고려, 또는 제외

 

  • 분류모델 평가 라이브러리
''' 정확도 : 훈련 및 검증 정확도에서 사용한 score()함수와 동일함 '''
from sklearn.metrics import accuracy_score
''' 정밀도 '''
from sklearn.metrics import precision_score
''' 재현율 '''
from sklearn.metrics import recall_score
''' F1-score '''
from sklearn.metrics import f1_score

 

1. 정확도

acc = accuracy_score(test_target, y_pred)
acc

 

2. 정밀도

pre = precision_score(test_target, y_pred)
pre

 

3. 재현율

rec = recall_score(test_target, y_pred)
rec

 

4. F1-score

rec = recall_score(test_target, y_pred)
rec

해석
- 정확도는 0.89로 높은편
- 정밀도, 재현율, F1_score의 값이 0.92 이상으로 매우 높은 값을 나타내고 있음
- 따라서, 랜덤포레스트 모델을 이용해서 해당 데이터에 대한 예측을 하는데 사용가능
- 즉, 예측 모델로 사용가능
728x90
반응형

+ Recent posts