AICE Associate - 딥러닝

 

딥러닝 모델 만들기

# import
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout

# 모델 생성 (뼈대)
model = Sequential()

# 모델 구조
#히든레이어를 만드는데 노드는 128개이고 input_shapre는 x.shape결과로
#첫번째 줄만 input이 있어서 작성해주고 두번째 add부터는 안써도됨, 
#활성화함수는 relu

model.add(Dense(128, input_shape=(X_train.shape[1],), activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dropout(0.3))   #dropout 노드간 연결 삭제 (30%)

# output layer의 unit 수는 타겟 변수의 범주 개수와 동일하다.
# activation 회귀/분류에 따라 sigmoid, softmax 사용
# 2진분류인 경우 sigmoid, 그 외는 softmax 사용
model.add(Dense(1, activation='sigmoid'))

 

딥러닝 모델 컴파일

분류) loss=’categorical_crossentropy’ , metrics=[‘accuracy'] (y값 one_hot_encoding한경우)

        loss=’sparse_categorical__crossentropy’, metrics=[‘accuracy']  (‘y값 one_hot_encoding 안함)

        loss = 'binary_crossentropy' (이중분류)

(예측-회귀) loss= ‘mean_squared_error’, metrics=[‘mse’]

model.compile(optimizer='adam', loss='mean_squared_error')

 

#얼리스탑: 모델 과적합방지를 위해 학습이 더 이상 개선되지 않으면 학습 종료

#moniter – 학습되지는 확인하는 기준
#mode – 모델 최적화기준(최대/최소)
#patience – 모델 성능이 개선되니 않을 때 지켜보는 횟수

from tensorflow.keras.callbacks import EarlyStopping

es = EarlyStopping(monitor='val_loss', mode='min')

# early_stop = EarlyStopping(monitor='val_loss, verbose=1, patience=5)

 

# 모델체크포인트: 모델을 학습 시 일정한 간격으로 모델의 가중치를 저장하며 최적 모델을 선택

#filepath: 모델저장경로
#monitor: 모니터링하는 지표
#mode: 모델 최적화의 기준(최대화/최소화)
#verbose: 정보 표시정도(0,1,2)
#save_best_only = True: 가장 좋은 성능의 모델만 저장


from tensorflow.keras.callbacks import ModelCheckpoint

mc = ModelCheckpoint('my_checkpoibnt.ckpt',
		monitor='val_loss',
		mode='min',
		save_best_only=True)
        
# check_point = ModelCheckpoint('best_model.h5',verbose=1, monitor='val_loss', save_best_only=True)

 

# 모델 학습

# validate_data: 검증용 데이터, 종속변수와 타겟변수 쌍으로 입력해야함
#epochs : 학습반복횟구
#batch_size: 학습 시 한번에 처리하는 데이터 사이즈
#callbacks: EarlyStopping, ModelCheckpoint와 같은 학습 과정에서 호출되는 함수

# 간단버젼 -> model.fit(X_train, y_train)

history = model.fit(X_train, y_train,
		validation_data = (X_test, y_test),
		epochs=30,
		batch_size=128,
		callbacks=[es, mc])

 

#모델평가 관련 라이브러리

# import
from sklearn.metrics import * # 모든 함수 로드

# 분류 모델 평가 지표
from sklearn.metrics import accuracy_score             # 정확도
from sklearn.metrics import precision_score            # 정밀도
from sklearn.metrics import recall_score               # 재현율
from sklearn.metrics import f1_score                   # f1 score
from sklearn.metrics import confusion_matrix          # 혼동행렬
from sklearn.metrics import accuracy_score            # 모든 지표 한번에

# 회귀 모델 평가 지표
from sklearn.metrics import r2_score               # R2 결정계수
from sklearn.metrics import mean_squared_error     # MSE
from sklearn.metrics import mean_absolute_error    # MAE

 

모델평가

 회귀

pred = model.predict(X_test)

r2_score = r2_score(y_test, pred)
mse = mean_squred_error(y_test, pred, squared=False)
mae = mean_absolute_error((y_test, pred)

 

분류

loss, accuracy = model.evaluate(X_test, y_test)

print(f"Test Loss: {loss:.4f}")
print(f"Test Accuracy: {accuracy:.4f}")

 

그래프그리기 

#학습 mse와 검증mse를 그래프로 그리기
#import
from sklearn.metrics import mean_squared_error     # MSE

plt.plot(history.history['loss'])
plt.plot(history.history['val_lass'])

plt.title('Model MSE')          #그래프 타이틀
plt.legend(['mse','val_mse'])   #그래프 범례
plt.xlabel('Epochs')    
plt.ylabel('MSE')

plt.show()

 

분류모델 그래프 그리기

plt.plot(history.history['loss'], 'r')
plt.plot(history.history['accuracy'], 'b')
plt.plot(history.history['val_loss'], 'y')
plt.plot(history.history['val_accuracy'], 'k')

plt.title('Loss and Accuracy')

plt.xlabel('Epochs')

plt.ylabel('Loss')

plt.legend(['Loss', 'Accuracy', 'val_loss', 'val_accuracy'])

plt.show()

 

 

Confusion Matrix 시각화하기

TN FP

FN TP

from sklearn.metrics import confusion_matrix          # 혼동행렬


# 오차행렬
# TN  FP
# FN  TP

y_pred = model.predict(X_test) # 모델 예측값 저장
cf_matrix = confusion_matrix(y_test, y_pred)

print(cf_matrix) # 혼동 행렬

# 히트맵으로 시각화

sns.heatmap(cf_matrix,    # 혼동 행렬
		annot=True, # 주석
		fmt='d')         # 주석 포맷

plt.show()

 

 

 

이중분류인 경우 딥러닝

model = Sequential()
model.add(Dense(128,  input_dim=X.shape[1], activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
model.add(Dense(16, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.summary()

#아래는 원핫인코딩 한 버전, 안했다면 loss='sparse_binary_crossentrop'
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping
es = EarlyStopping(monitor='val_loss', patience=20)

mc = ModelCheckpoint('best_model.h5', verbose=1,
                              monitor='val_loss', save_best_only=True)

history = model.fit(X_train, y_train, epochs=200, verbose=1, batch_size=10, 
                    validation_data=(X_test, y_test),
                    callbacks=[es,mc]) 
                    
model.evaluate(X_test, y_test)

 

 

 

다중분류인 경우 딥러닝 참고 - 원핫인코딩 안한 버젼

import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Activation, Dropout, BatchNormalization
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras.utils import to_categorical

tf.random.set_seed(1)

# 38개 input layer
# unit 5개 hidden layer
# dropout
# unit 4개 hidden layer
# dropout
# 2개 output layser : 다중분류

model = Sequential()
model.add(Dense(5, activation='relu', input_shape=(38,)))
model.add(Dropout(0.3))
model.add(Dense(4, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(2, activation='softmax'))

#모델 컴파일 – 다중 분류 모델
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
              
#모델학습
history = model.fit(X_train, y_train,
          validation_data=(X_test, y_test),
          epochs=20,
          batch_size=16)

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# val_loss 모니터링해서 성능이 5번 지나도록 좋아지지 않으면 조기 종료
early_stop = EarlyStopping(monitor='val_loss', verbose=1, patience=5)

# val_loss 가장 낮은 값을 가질때마다 모델저장
check_point = ModelCheckpoint('best_model.h5', verbose=1,
                              monitor='val_loss', save_best_only=True)

#모델학습
history = model.fit(x=X_train, y=y_train,
          epochs=50 , batch_size=20,
          validation_data=(X_test, y_test), verbose=1,
          callbacks=[early_stop, check_point])

#성능 시각화
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Acc')
plt.legend(['acc', 'val_acc'])
plt.show()

#성능평가
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import classification_report

pred = model.predict(X_test)
y_pred = np.argmax(pred, axis=1)

# 정확도 
accuracy_score(y_test, y_pred)

# accuracy, recall, precision 성능 한번에 보기
print(classification_report(y_test, y_pred))