chapter_9_3

LSTM 신경망 훈련하기

  • RNN은 실무에서 안씀!!!!!!!!!!!
  • 나온 배경
    • 문장이 길면, 학습 능력이 떨어짐
    • Long Short-Term Memory
  • 단기 기억을 오래 기억하기 위해 고안됨.

데이터 불러오기

1
2
3
4
5
6
7
8
from tensorflow.keras.datasets import imdb
from sklearn.model_selection import train_test_split

(train_input, train_target), (test_input, test_target) = imdb.load_data(
num_words=500)

train_input, val_input, train_target, val_target = train_test_split(
train_input, train_target, test_size=0.2, random_state=42)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17465344/17464789 [==============================] - 0s 0us/step
17473536/17464789 [==============================] - 0s 0us/step

padding

1
2
3
4
from tensorflow.keras.preprocessing.sequence import pad_sequences

train_seq = pad_sequences(train_input, maxlen=100)
val_seq = pad_sequences(val_input, maxlen=100)

모형 만들기

1
2
3
4
5
6
7
from tensorflow import keras
model = keras.Sequential()
model.add(keras.layers.Embedding(500, 16, input_length = 100))
model.add(keras.layers.LSTM(8)) # SimpleRNN
model.add(keras.layers.Dense(1, activation='sigmoid'))

model.summary()
Model: "sequential"
_________________________________________________________________
 Layer (type)                /images/chapter_9_3/output Shape              Param #   
=================================================================
 embedding (Embedding)       (None, 100, 16)           8000      
                                                                 
 lstm (LSTM)                 (None, 8)                 800       
                                                                 
 dense (Dense)               (None, 1)                 9         
                                                                 
=================================================================
Total params: 8,809
Trainable params: 8,809
Non-trainable params: 0
_________________________________________________________________
1
2
3
4
5
6
7
8
9
10
11
12
13
rmsprop = keras.optimizers.RMSprop(learning_rate=1e-4)
model.compile(optimizer=rmsprop, loss='binary_crossentropy',
metrics=['accuracy'])

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-lstm-model.h5',
save_best_only=True)
early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
restore_best_weights=True)

# epochs = 100
history = model.fit(train_seq, train_target, epochs=10, batch_size=64,
validation_data=(val_seq, val_target),
callbacks=[checkpoint_cb, early_stopping_cb])
Epoch 1/10
313/313 [==============================] - 13s 36ms/step - loss: 0.6922 - accuracy: 0.5400 - val_loss: 0.6909 - val_accuracy: 0.5952
Epoch 2/10
313/313 [==============================] - 12s 39ms/step - loss: 0.6886 - accuracy: 0.6219 - val_loss: 0.6855 - val_accuracy: 0.6436
Epoch 3/10
313/313 [==============================] - 10s 33ms/step - loss: 0.6778 - accuracy: 0.6671 - val_loss: 0.6655 - val_accuracy: 0.6896
Epoch 4/10
313/313 [==============================] - 11s 35ms/step - loss: 0.6173 - accuracy: 0.7113 - val_loss: 0.5780 - val_accuracy: 0.7118
Epoch 5/10
313/313 [==============================] - 11s 34ms/step - loss: 0.5591 - accuracy: 0.7294 - val_loss: 0.5511 - val_accuracy: 0.7362
Epoch 6/10
313/313 [==============================] - 13s 43ms/step - loss: 0.5346 - accuracy: 0.7499 - val_loss: 0.5300 - val_accuracy: 0.7488
Epoch 7/10
313/313 [==============================] - 10s 33ms/step - loss: 0.5143 - accuracy: 0.7640 - val_loss: 0.5139 - val_accuracy: 0.7618
Epoch 8/10
313/313 [==============================] - 10s 33ms/step - loss: 0.4964 - accuracy: 0.7748 - val_loss: 0.4970 - val_accuracy: 0.7722
Epoch 9/10
313/313 [==============================] - 10s 33ms/step - loss: 0.4816 - accuracy: 0.7828 - val_loss: 0.4844 - val_accuracy: 0.7806
Epoch 10/10
313/313 [==============================] - 11s 35ms/step - loss: 0.4691 - accuracy: 0.7908 - val_loss: 0.4739 - val_accuracy: 0.7808

손실 곡선 추가

1
2
3
4
5
6
7
8
import matplotlib.pyplot as plt

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'val'])
plt.show()

png

순환층에 드롭아웃 적용하기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
model2 = keras.Sequential()

model2.add(keras.layers.Embedding(500, 16, input_length=100))
# 드롭아웃 추가
model2.add(keras.layers.LSTM(8, dropout=0.3))
model2.add(keras.layers.Dense(1, activation='sigmoid'))

rmsprop = keras.optimizers.RMSprop(learning_rate=1e-4)
model2.compile(optimizer=rmsprop, loss='binary_crossentropy',
metrics=['accuracy'])

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-dropout-model.h5',
save_best_only=True)
early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
restore_best_weights=True)

# epcohs = 100
history = model2.fit(train_seq, train_target, epochs=10, batch_size=64,
validation_data=(val_seq, val_target),
callbacks=[checkpoint_cb, early_stopping_cb])

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'val'])
plt.show()
Epoch 1/10
313/313 [==============================] - 14s 37ms/step - loss: 0.6929 - accuracy: 0.5109 - val_loss: 0.6926 - val_accuracy: 0.5336
Epoch 2/10
313/313 [==============================] - 11s 34ms/step - loss: 0.6915 - accuracy: 0.5725 - val_loss: 0.6908 - val_accuracy: 0.5904
Epoch 3/10
313/313 [==============================] - 11s 34ms/step - loss: 0.6887 - accuracy: 0.6108 - val_loss: 0.6868 - val_accuracy: 0.6312
Epoch 4/10
313/313 [==============================] - 13s 40ms/step - loss: 0.6818 - accuracy: 0.6508 - val_loss: 0.6774 - val_accuracy: 0.6510
Epoch 5/10
313/313 [==============================] - 11s 35ms/step - loss: 0.6623 - accuracy: 0.6740 - val_loss: 0.6441 - val_accuracy: 0.6678
Epoch 6/10
313/313 [==============================] - 11s 35ms/step - loss: 0.6024 - accuracy: 0.7145 - val_loss: 0.5710 - val_accuracy: 0.7374
Epoch 7/10
313/313 [==============================] - 12s 38ms/step - loss: 0.5601 - accuracy: 0.7370 - val_loss: 0.5479 - val_accuracy: 0.7512
Epoch 8/10
313/313 [==============================] - 11s 35ms/step - loss: 0.5387 - accuracy: 0.7502 - val_loss: 0.5285 - val_accuracy: 0.7600
Epoch 9/10
313/313 [==============================] - 11s 34ms/step - loss: 0.5189 - accuracy: 0.7624 - val_loss: 0.5089 - val_accuracy: 0.7714
Epoch 10/10
313/313 [==============================] - 11s 35ms/step - loss: 0.5008 - accuracy: 0.7746 - val_loss: 0.4928 - val_accuracy: 0.7758

png

  • Reference : 혼자 공부하는 머신러닝 + 딥러닝

chapter_9_2

순환 신경망으로 IMDB 리뷰 분류

  • 혹시, 자연어 처리, 감정분석 관심 있으면 강사님께 개인적으로 연락!

  • 주제 : 긍정리뷰 부정리뷰 분류

  • 501p

    • 텍스트 자체가 신경망에 전달하지 않는다! (문자열 –> 수식에 적용 X)

    • 문자열을 수식으로 정하는 규칙이 매우 가변적임. (토근화, Tokenizing)

    • He follows the cat. He loves the cat.
      10 11 12 13 10 14 12 13

    • 고양이를 따라간다. He follows the cat.
      10 11 12 13 14 15

  • RNN, LSTM 알고리즘

    • 영어권 사람들이 만들었어요.
    • 자연어처리와 관련된 많은 알고리즘
      • 영어권 사람들이 만듬
  • 한글 != 영어

    • 성과 내려면 제품(=돈) (네이버)
1
2
from tensorflow.keras.datasets import imdb
(train_input, train_target), (test_input, test_target) = imdb.load_data(num_words = 500)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/imdb.npz
17465344/17464789 [==============================] - 0s 0us/step
17473536/17464789 [==============================] - 0s 0us/step
  • 데이터 크기 확인 (1차원 배열)
  • 텍스트의 길이가 다 다르기 때문에 1차원 배열로 정리 가능
1
print(train_input.shape, test_input.shape)
(25000,) (25000,)
  • 문장의 길이가 다 다르다!
1
2
3
print(len(train_input[0]))
print(len(train_input[1]))
print(len(train_input[2]))
218
189
141
  • Raw 데이터 전처리 -> 토큰화 작업이 끝난 상황 (문자열 –> 숫자로 바뀜)
1
print(train_input[0])
[1, 14, 22, 16, 43, 2, 2, 2, 2, 65, 458, 2, 66, 2, 4, 173, 36, 256, 5, 25, 100, 43, 2, 112, 50, 2, 2, 9, 35, 480, 284, 5, 150, 4, 172, 112, 167, 2, 336, 385, 39, 4, 172, 2, 2, 17, 2, 38, 13, 447, 4, 192, 50, 16, 6, 147, 2, 19, 14, 22, 4, 2, 2, 469, 4, 22, 71, 87, 12, 16, 43, 2, 38, 76, 15, 13, 2, 4, 22, 17, 2, 17, 12, 16, 2, 18, 2, 5, 62, 386, 12, 8, 316, 8, 106, 5, 4, 2, 2, 16, 480, 66, 2, 33, 4, 130, 12, 16, 38, 2, 5, 25, 124, 51, 36, 135, 48, 25, 2, 33, 6, 22, 12, 215, 28, 77, 52, 5, 14, 407, 16, 82, 2, 8, 4, 107, 117, 2, 15, 256, 4, 2, 7, 2, 5, 2, 36, 71, 43, 2, 476, 26, 400, 317, 46, 7, 4, 2, 2, 13, 104, 88, 4, 381, 15, 297, 98, 32, 2, 56, 26, 141, 6, 194, 2, 18, 4, 226, 22, 21, 134, 476, 26, 480, 5, 144, 30, 2, 18, 51, 36, 28, 224, 92, 25, 104, 4, 226, 65, 16, 38, 2, 88, 12, 16, 283, 5, 16, 2, 113, 103, 32, 15, 16, 2, 19, 178, 32]
  • Target 데이터 출력
    • 0은 부정리뷰
    • 1은 긍정리뷰
1
print(train_target[:20])
[1 0 0 1 0 0 1 0 1 0 1 0 0 0 0 0 1 1 0 1]

데이터셋 분리

1
2
3
4
5
6
from sklearn.model_selection import train_test_split 
train_input, val_input, train_target, val_target = train_test_split(
train_input, train_target, test_size = 0.2, random_state=42
)

train_input.shape, val_input.shape, train_target.shape, val_target.shape
((20000,), (5000,), (20000,), (5000,))

데이터 시각화

  • 각 리뷰의 평균단어의 갯수
1
2
3
4
5
import numpy as np
#temp_list = [len(x) for x in train_input]
# print(temp_list)
lengths = np.array([len(x) for x in train_input])
print(np.mean(lengths), np.median(lengths))
239.00925 178.0
1
2
3
4
5
import matplotlib.pyplot as plt 
plt.hist(lengths)
plt.xlabel('length')
plt.ylabel('frequency')
plt.show()

png

  • 짧은 단어 100개만 사용
  • 모든 길이를 100에 맞춘다.
    • “패딩”
  • 데이터의 갯수는 20000, 전체 길이는 100으로 맞춤
1
2
3
4
from tensorflow.keras.preprocessing.sequence import pad_sequences 
train_seq = pad_sequences(train_input, maxlen = 100)

print(train_seq.shape)
(20000, 100)
1
print(train_seq[5])
[  0   0   0   0   1   2 195  19  49   2   2 190   4   2 352   2 183  10
  10  13  82  79   4   2  36  71 269   8   2  25  19  49   7   4   2   2
   2   2   2  10  10  48  25  40   2  11   2   2  40   2   2   5   4   2
   2  95  14 238  56 129   2  10  10  21   2  94 364 352   2   2  11 190
  24 484   2   7  94 205 405  10  10  87   2  34  49   2   7   2   2   2
   2   2 290   2  46  48  64  18   4   2]
1
2
print(train_input[0][-10:])
print(train_seq[0])
[6, 2, 46, 7, 14, 20, 10, 10, 470, 158]
[ 10   4  20   9   2 364 352   5  45   6   2   2  33 269   8   2 142   2
   5   2  17  73  17 204   5   2  19  55   2   2  92  66 104  14  20  93
  76   2 151  33   4  58  12 188   2 151  12 215  69 224 142  73 237   6
   2   7   2   2 188   2 103  14  31  10  10 451   7   2   5   2  80  91
   2  30   2  34  14  20 151  50  26 131  49   2  84  46  50  37  80  79
   6   2  46   7  14  20  10  10 470 158]
1
val_seq = pad_sequences(val_input, maxlen = 100)

순환 신경망 만들기

1
2
3
4
from tensorflow import keras
model = keras.Sequential()
model.add(keras.layers.SimpleRNN(8, input_shape=(100, 500)))
model.add(keras.layers.Dense(1, activation='sigmoid'))
  • 원핫 인코딩 적용
    • 매칭이 성공하면 1을 출력
1
2
train_oh = keras.utils.to_categorical(train_seq)
print(train_oh.shape)
(20000, 100, 500)
1
print(train_oh[0][0][:12])
[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 1. 0.]
1
print(np.sum(train_oh[0][0]))
1.0
  • 1이 출력되었으므로 성공
  • 이제 검증데이터에 적용한다.
1
val_oh = keras.utils.to_categorical(val_seq)
1
model.summary()
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 simple_rnn (SimpleRNN)      (None, 8)                 4072      
                                                                 
 dense (Dense)               (None, 1)                 9         
                                                                 
=================================================================
Total params: 4,081
Trainable params: 4,081
Non-trainable params: 0
_________________________________________________________________
1
2
3
4
5
6
7
8
9
10
11
12
13
14
"""
rmsprop = keras.optimizers.RMSprop(learning_rate=1e-4)
model.compile(optimizer=rmsprop, loss='binary_crossentropy',
metrics=['accuracy'])

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-simplernn-model.h5',
save_best_only=True)
early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
restore_best_weights=True)

history = model.fit(train_oh, train_target, epochs=100, batch_size=64,
validation_data=(val_oh, val_target),
callbacks=[checkpoint_cb, early_stopping_cb])
"""
"\nrmsprop = keras.optimizers.RMSprop(learning_rate=1e-4)\nmodel.compile(optimizer=rmsprop, loss='binary_crossentropy', \n              metrics=['accuracy'])\n\ncheckpoint_cb = keras.callbacks.ModelCheckpoint('best-simplernn-model.h5', \n                                                save_best_only=True)\nearly_stopping_cb = keras.callbacks.EarlyStopping(patience=3,\n                                                  restore_best_weights=True)\n\nhistory = model.fit(train_oh, train_target, epochs=100, batch_size=64,\n                    validation_data=(val_oh, val_target),\n                    callbacks=[checkpoint_cb, early_stopping_cb])\n"
  • 514p
    • 문제점 발생: 토큰 1개를 500차원으로 늘림.. –> 데이터 크기가 500배 커짐
1
2
3
4
5
6
7
from tensorflow import keras
model2 = keras.Sequential()
model2.add(keras.layers.Embedding(500, 16, input_length = 100))
model2.add(keras.layers.SimpleRNN(8))
model2.add(keras.layers.Dense(1, activation='sigmoid'))

model2.summary()
Model: "sequential_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 embedding (Embedding)       (None, 100, 16)           8000      
                                                                 
 simple_rnn_1 (SimpleRNN)    (None, 8)                 200       
                                                                 
 dense_1 (Dense)             (None, 1)                 9         
                                                                 
=================================================================
Total params: 8,209
Trainable params: 8,209
Non-trainable params: 0
_________________________________________________________________
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'''
rmsprop = keras.optimizers.RMSprop(learning_rate=1e-4)
model2.compile(optimizer=rmsprop, loss='binary_crossentropy',
metrics=['accuracy'])

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-embedding-model.h5',
save_best_only=True)
early_stopping_cb = keras.callbacks.EarlyStopping(patience=3,
restore_best_weights=True)

history = model2.fit(train_seq, train_target, epochs=100, batch_size=64,
validation_data=(val_seq, val_target),
callbacks=[checkpoint_cb, early_stopping_cb])
'''
"\nrmsprop = keras.optimizers.RMSprop(learning_rate=1e-4)\nmodel2.compile(optimizer=rmsprop, loss='binary_crossentropy', \n               metrics=['accuracy'])\n\ncheckpoint_cb = keras.callbacks.ModelCheckpoint('best-embedding-model.h5', \n                                                save_best_only=True)\nearly_stopping_cb = keras.callbacks.EarlyStopping(patience=3,\n                                                  restore_best_weights=True)\n\nhistory = model2.fit(train_seq, train_target, epochs=100, batch_size=64,\n                     validation_data=(val_seq, val_target),\n                     callbacks=[checkpoint_cb, early_stopping_cb])\n "
  • Reference : 혼자 공부하는 머신러닝 + 딥러닝

chapter_9_1

순차 데이터와 순환 신경망

통계

  • 초급 레벨 : 기초통계 (t.test, 분산분석, 회귀분석 등)
  • 중급 레벨 : 시계열 분석 / 베이지안 / 비모수검정
  • 시계열 데이터 : 주식/ 날씨 / 매장 매출
    • R로 공부할 것

텍스트

  • 텍스트 마이닝 (데이터 분석가)
    • 대표 적으로 감정분석 (긍정 / 부정 분류)
    • 문자열 : 인코딩하는 방법론이 존재
  • 자연어 처리 (개발자에 해당)
    • 챗봇
    • 자동 번역
  • 기본 딥러닝 알고리즘 / RNN & LSTM
    • 현실에서 쓸까? 안쓴다!
  • 자료
  • 분야 선정
    • 영상인식, 이미지 분류, 음성, 자연어

순환 신경망

  • 이미지는 픽셀값이 어느정도 고정이 되어 있음

    • 28x28로 정의 / 모든 데이터는 28x28 맞출 수 있음
  • 텍스트

    • 값이 고정이 불가함
  • 494p

  • I am a boy(1, 4, 3)

  • I am a handsome boy(1, 4, 1, 2)

  • Reference : 혼자 공부하는 머신러닝 + 딥러닝

Scikitlearn_pipeline_tutorial

데이터 누수 방지 위한 모델링 기법 : 파이프라인 구축

  • 수능 시험 = 최종 테스트 데이터
  • 모의고사 또는 과거 기출문제 = 검증데이터
  • 교과서 문제지 = 훈련 데이터
  • 머신러닝 엔지니어 : MLOps (선행되어야 하는 코드 조건, Pipeline 형태로 구축)
    • 머신러닝 코드 자동화 가능! 운영 가능!
    • 개발업계의 최상위 연봉자!

데이터 불러오기

1
2
3
4
import pandas as pd
import numpy as np
data = pd.read_csv('https://raw.githubusercontent.com/MicrosoftDocs/ml-basics/master/data/daily-bike-share.csv')
data.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 731 entries, 0 to 730
Data columns (total 14 columns):
 #   Column      Non-Null Count  Dtype  
---  ------      --------------  -----  
 0   instant     731 non-null    int64  
 1   dteday      731 non-null    object 
 2   season      731 non-null    int64  
 3   yr          731 non-null    int64  
 4   mnth        731 non-null    int64  
 5   holiday     731 non-null    int64  
 6   weekday     731 non-null    int64  
 7   workingday  731 non-null    int64  
 8   weathersit  731 non-null    int64  
 9   temp        731 non-null    float64
 10  atemp       731 non-null    float64
 11  hum         731 non-null    float64
 12  windspeed   731 non-null    float64
 13  rentals     731 non-null    int64  
dtypes: float64(4), int64(9), object(1)
memory usage: 80.1+ KB

데이터 추출

1
2
3
4
cols = ['season', 'mnth', 'holiday', 'weekday', 'workingday', 'weathersit', 'temp', 'atemp', 'hum', 'windspeed', 'rentals']
data = data[cols]
data.info()
# data['mnth'].value_counts()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 731 entries, 0 to 730
Data columns (total 11 columns):
 #   Column      Non-Null Count  Dtype  
---  ------      --------------  -----  
 0   season      731 non-null    int64  
 1   mnth        731 non-null    int64  
 2   holiday     731 non-null    int64  
 3   weekday     731 non-null    int64  
 4   workingday  731 non-null    int64  
 5   weathersit  731 non-null    int64  
 6   temp        731 non-null    float64
 7   atemp       731 non-null    float64
 8   hum         731 non-null    float64
 9   windspeed   731 non-null    float64
 10  rentals     731 non-null    int64  
dtypes: float64(4), int64(7)
memory usage: 62.9 KB
  • Data Preprocessing
    • 결측치 수동으로 채우거나
    • 불필요한 변수를 제거하거나
    • 이상치를 제거하거나
    • 파생변수를 만들거나 등

기본 : 데이터 불러오기 -> 데이터 전처리 -> 피처공학(원핫-인코딩) -> 데이터셋 분리 -> 모델링 코드 -> 모델평가

파이프라인 : 데이터 불러오기 -> 데이터 전처리 -> 데이터셋 분리 -> 파이프라인 구축(피처공학, 모델링 코드) -> 모델 평가

데이터 셋 분리

1
2
3
4
5
from sklearn.model_selection import train_test_split
X = data.drop('rentals',axis=1)
y = data['rentals']

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
  • Feature Engineering
    • 기존 : 개별적으로 코드 작성
    • 현재 : Pipeline 코드로 추가할 것

Pipeline 구축

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
from sklearn.preprocessing import StandardScaler, OrdinalEncoder, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline

# 데이터 타입 3가지
# 수치형 데이터, 문자열 데이터
# 문자열 데이터 : 범주형(명목형, 서열형 데이터로 구분됨)
numeric_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='mean'))
,('scaler', StandardScaler())
])

ordinal_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant'))
,('ordEncoder', OrdinalEncoder())
])

onehot_transformer = Pipeline(steps=[
('imputer', SimpleImputer(strategy='constant'))
,('oheEncoder', OneHotEncoder())
])

# 수치형 데이터 및 Categorical 데이터 컬럼 분리

numeric_features = ['temp', 'atemp', 'hum', 'windspeed']
ordinal_features = ['holiday', 'weekday', 'workingday', 'weathersit']
onehot_features = ['season', 'mnth']

# numeric_features = data.select_dtypes(include=['int64', 'float64']).columns
# categorical_features = data.select_dtypes(include=['object']).drop(['Loan_Status'], axis=1).columns

preprocessor = ColumnTransformer(
transformers=[
('numeric', numeric_transformer, numeric_features)
, ('ord_categorical', ordinal_transformer, ordinal_features)
, ('ohe_categorical', onehot_transformer, onehot_features)
])

모델 적용

  • 전처리가 끝났으니 모델을 적용한다.
1
2
3
4
5
6
7
8
9
from sklearn.ensemble import RandomForestRegressor

pipeline = Pipeline(steps = [
('preprocessor', preprocessor)
,('regressor', RandomForestRegressor())
])

rf_model = pipeline.fit(X_train, y_train)
print(rf_model)
Pipeline(steps=[('preprocessor',
                 ColumnTransformer(transformers=[('numeric',
                                                  Pipeline(steps=[('imputer',
                                                                   SimpleImputer()),
                                                                  ('scaler',
                                                                   StandardScaler())]),
                                                  ['temp', 'atemp', 'hum',
                                                   'windspeed']),
                                                 ('ord_categorical',
                                                  Pipeline(steps=[('imputer',
                                                                   SimpleImputer(strategy='constant')),
                                                                  ('ordEncoder',
                                                                   OrdinalEncoder())]),
                                                  ['holiday', 'weekday',
                                                   'workingday',
                                                   'weathersit']),
                                                 ('ohe_categorical',
                                                  Pipeline(steps=[('imputer',
                                                                   SimpleImputer(strategy='constant')),
                                                                  ('oheEncoder',
                                                                   OneHotEncoder())]),
                                                  ['season', 'mnth'])])),
                ('regressor', RandomForestRegressor())])
  • 파이프라인끼리 연결시켜서 길게 늘이는 원리
    • 데이터가 라인을 따라 흐르게 된다. 자동화

모델 평가

1
2
3
from sklearn.metrics import r2_score
predictions = rf_model.predict(X_test)
print (r2_score(y_test, predictions))
0.7728368422640097

다중 모형 개발

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from sklearn.ensemble import RandomForestRegressor
from sklearn.tree import DecisionTreeRegressor

regressors = [
RandomForestRegressor()
,DecisionTreeRegressor()
]

# regressors = [pipe_rf, pipe_dt]
for regressor in regressors:
pipeline = Pipeline(steps = [
('preprocessor', preprocessor)
,('regressor',regressor)
])
model = pipeline.fit(X_train, y_train)
predictions = model.predict(X_test)
print(regressor)
print(f'Model r2 score:{r2_score(predictions, y_test)}')
RandomForestRegressor()
Model r2 score:0.74544998600902
DecisionTreeRegressor()
Model r2 score:0.6365934810580942

chapter_8_1

합성곱 신경망

  • 코드보다는 용어 정리가 중요하다

  • 더 나은 정확도를 위한 발전 과정

    • 로지스틱 회귀 (일반 ML 모형) : 81%
    • 인공신경망 (딥러닝 초기 모형) : 87%
    • 합성곱 (Convolution, CNN)
  • 합성곱 (CNN)

    • 이미지의 특성을 뽑아내는 과정
    • 합성곱에서는 뉴런이 입력층 위를 이동하면서 출력을 만든다. = 도장을 연상하라
    • 합성곱 층의 뉴런에 있는 가중치 개수는 하이퍼 파라미터이다.
      • 발전사 : alexnet -> resnet -> efficientnet
      • 채널, 이미지의 너비, 크기 (파라미터 튜닝)
      • Vision Transformer
    • 비디오
      • 객체인식(Object Detection)
      • Yolo 논문
  • RNN / LSTM (자연어 처리)

    • 구글 2017년 Transformer (논문)
  • 필터 (filter)

    • 합성곱에서의 뉴런
      • 뉴런 개수를 이야기할 때 필터라 칭한다.
      • 합성곱에서는 완전 연결 신경망과 달리 뉴런을 필터라 부른다.
    • 혹은 커널(kernel)이라 부른다.
      • 입력에 곱해지는 가중치를의미할 때 커널이라 부른다.

합성곱의 장점

  • 기존 : 1차원 배열에서만 연산이 가능
  • 2차원 배열에도 연산을 할 수 있도록 구현
    • 입력이 2차원 배열이 되므로 필터도 2차원이다.
    • 선형대수를 공부해야 하나요??
1
2
3
4
from tensorflow import keras
keras.layers.Conv2D(10, # 필터(즉, 도장)의 개수
kernel_size=(3,3), # 필터에 사용할 커널의 크기
activation = 'relu') # 활성화 함수 지정
<keras.layers.convolutional.Conv2D at 0x7f6c99df5c90>

패딩 (padding)

  • 입력 배열의 주위를 가상의 원소로 채우는 것.
  • 실제 입력값이 아니기 때문에 패딩은 0으로 채운다.
  • 실제 값은 0으로 채워져 있기에 계산에 영향을 미치지 않는다.
    • 세임 패딩 (same padding) : 입력 주위에 0으로 패딩 하는 것
    • 밸리드 패딩 (valid padding) : 패딩 없이 순수한 입력 배열에서만 합성곱하여 특성 맵을 마드는 것

패딩의 목적

  • 배열의 크기를 조정하더라도 이미지 원 특성이 손실되는 것을 방지하는 것

스트라이드 (stride)

  • 기존에 합성곱 연산은 좌우, 위아래로 한 칸씩 이동했다.
    • 두 칸씩 건너뛸 수도 있다.
    • 이런 이동의 크기를 ‘스트라이드’라고 한다.
  • 두 칸씩 이동하면 특성 맵의 크기가 더 작아진다.
    • 커널 도장을 찍는 횟수가 줄어들기 때문.
  • 디폴트는 1칸 이동이다.
1
2
3
4
5
keras.layers.Conv2D(10,                         # 필터(즉, 도장)의 개수
kernel_size=(3,3), # 필터에 사용할 커널의 크기
activation='relu', # 활성화 함수 지정
padding = 'same', # 세임 패딩
strides = 1) # 1칸씩 이동
<keras.layers.convolutional.Conv2D at 0x7f6c992ba8d0>

풀링 (pooling)

  • 값을 추출
  • 100 x 100 이미지 –> (수치로) 주요 이미지의 특성만 뽑은 후, 원 이미지와 같게 만듬 (50 x 50)
  • 합성곱 층에서 만든 특성 맵의 가로세로 크기를 줄이는 역할을 수행한다.
    • 특성맵의 크기를 줄이지는 않는다.
  • 합성곱처럼 입력 위를 지나가면서 도장을 찍는다.
    • 하지만, 풀링에는 가중치가 없다.
  • 최대 풀링 (max pooling)
    • 도장을 찍은 영역에서 가장 큰 값을 고른다.
  • 평균 풀링 (average pooling)
    • 도장을 찍은 영역에서 평균값을 계산한다.
  • 특성 맵이 여러 개라면 동일한 작업을 반복한다.
    • 즉, 10개의 특성 맵이 있다면 풀링을 거친 특성맵도 10개가 된다.
  • 풀링 영역은 풀링의 크기만큼 이동한다.
    • 즉, 겹치지 않고 이동한다.
    • 풀링의 크기가 (2,2)이면 가로세로 두 칸씩 이동한다.
    • 풀링은 가중치가 없고 풀링 크기와 스트라이드가 같다.
1
2
3
keras.layers.MaxPooling2D(2,                 # 풀링의 크기. 대부분은 2로 둔다.
strides=2, # 2칸씩 이동. 풀링의 크기와 같게 설정된다.
padding='valid') # 풀링은 패딩을 하지 않으므로 'valid'로 지정.
<keras.layers.pooling.MaxPooling2D at 0x7f6c99253e90>
  • 기억할 점
    • 풀링은 가로세로 방향으로만 진행한다.
    • 특성 맵의 개수는 변하지 않고 그대로이다.

합성곱 신경망의 전체 구조

  • p437
  • 1단계 : 이미지 데이터 입력
  • 2단계 : 합성곱 층
    • (1) kernel_size + padding
    • (2) 활성화 함수 적용
    • (3) 각각의 특성맵을 산출
  • 3단계 : 풀링층
    • (1) Max Pooling : 최댓값 추출
    • (2) 최종 특성맵
  • 위 과정을 계속 반복하는 것이 CNN 알고리즘
  • 4단계 : 밀집층 (Fully Connected Layer)
    • Chapter 7장
    • 3차원 배열을 1차원으로 펼친다. (Flatten 클래스)
    • 출력층의 입력이 된다.
  • 5단계 : 분류 예측값을 산출 (Softmax 활성화 함수)
    • 지정한 활성화 함수를 거쳐 최종 예측 확률이 된다.

주요 키워드 : 사전학습(Pretrained) / 전이학습 (Transfer Learning) / 파인 튜닝(Fine Tuning)

  • 다른 사람이 작성한 학습 코드를 사용한다.

  • 파인 튜닝 : 미세 조정하는 것이다.

    • 캐글 경진대회에서 주로 사용.
  • Reference : 혼자 공부하는 머신러닝 + 딥러닝

chapter_8_1_2

08-2. 합성곱 신경망을 이용한 이미지 분류

패션 MNIST 데이터 불러오기

  • 데이터 스케일을 0 ~ 255 사이 0 ~ 1 로 표준화
  • 훈련 데이터 / 검증 데이터 분류
  • 완전 연결 신경망 (Fully Connected Layer)

–> 2차원 배열 -> 1차원 배열 (최종 분류값 도출)
–> 완전 연결 신경망과 달리, 합성곱에서는 2차원 이미지를 그대로 사용한다.

1
2
3
4
5
6
7
8
9
10
from tensorflow import keras
from sklearn.model_selection import train_test_split

(train_input, train_target), (test_input, test_target) = \
keras.datasets.fashion_mnist.load_data()

train_scaled = train_input.reshape(-1, 28, 28, 1) / 255.0

train_scaled, val_scaled, train_target, val_target = train_test_split(
train_scaled, train_target, test_size=0.2, random_state=42)
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
32768/29515 [=================================] - 0s 0us/step
40960/29515 [=========================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
26427392/26421880 [==============================] - 0s 0us/step
26435584/26421880 [==============================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
16384/5148 [===============================================================================================] - 0s 0us/step
Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
4423680/4422102 [==============================] - 0s 0us/step
4431872/4422102 [==============================] - 0s 0us/step

합성곱 신경망 만들기

  • 446p
  • 437p 그림을 코드로 구현하는 내용
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
model = keras.Sequential()
# 합성곱 층
model.add(keras.layers.Conv2D(32, kernel_size=3, activation = 'relu', # Conv2D() 는 합성곱 층을 만든다.
padding = 'same', input_shape = (28, 28, 1))) # 합성곱의 필터 32이므로 특성 맵의 깊이는 32

# 풀링층
model.add(keras.layers.MaxPooling2D(2)) # (2,2) 풀링을 적용하여 합성곱 층의 특성 맵의 크기가 절반이 된다.

# 합성곱 층
model.add(keras.layers.Conv2D(64, kernel_size=(3,3), activation = 'relu', # 합성곱의 필터 64이므로 특성 맵의 깊이는 64
padding = 'same'))

# 풀링층
model.add(keras.layers.MaxPooling2D(2)) # (2,2) 풀링을 적용하여 합성곱 층의 특성 맵의 크기가 절반이 된다.

# 완전연결층 (밀집층 = Fully Connected Layer)
# Chapter 7장 내용
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(100, activation='relu')) # 은닉층
model.add(keras.layers.Dropout(0.4)) # 드롭아웃 -> 과대 적합 방지
model.add(keras.layers.Dense(10, activation='softmax')) # 출력측

model.summary()
Model: "sequential"
_________________________________________________________________
 Layer (type)                /images/chapter_8_1_2/output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 28, 28, 32)        320       
                                                                 
 max_pooling2d (MaxPooling2D  (None, 14, 14, 32)       0         
 )                                                               
                                                                 
 conv2d_1 (Conv2D)           (None, 14, 14, 64)        18496     
                                                                 
 max_pooling2d_1 (MaxPooling  (None, 7, 7, 64)         0         
 2D)                                                             
                                                                 
 flatten (Flatten)           (None, 3136)              0         
                                                                 
 dense (Dense)               (None, 100)               313700    
                                                                 
 dropout (Dropout)           (None, 100)               0         
                                                                 
 dense_1 (Dense)             (None, 10)                1010      
                                                                 
=================================================================
Total params: 333,526
Trainable params: 333,526
Non-trainable params: 0
_________________________________________________________________
  • 필터의 개수에 따라 특성 맵의 크기는
    • 첫 번째 합성곱 층을 통과하면서 특성 맵의 크기가 32가 된다.
    • 두 번째 합성곱에서 특성 맵의 크기가 64로 늘어난다.
  • 반면 특성 맵의 가로세로 크기는
    • 첫 번째 풀링 층에서 절반으로 줄어든다.
    • 두 번째 풀링층에서 다시 절반으로 더 줄어든다.
  • Flatten 클래스에서 (7,7,64) 크기의 특성 맵을 1차원 배열로 펼친다.
    • (7,7,64) -> (3136,)

모델 파라미터 개수 계산

  • 첫 번째 합성곱 층

    • 32개 필터, 커널 크기(3,3), 깊이1, 필터마다 하나의 절편 -> 3x3x1x32 + 32 = 320개
  • 두 번째 합성곱 층

    • 64개 필터, 커널 크기(3,3), 깊이32, 필터마다 하나의 절편 -> 3x3x32x64 + 64 = 18,496개
  • Flatten 즉, 은닉층

    • (3136,) 개의 1차원 배열, 100개의 뉴런 -> 3136x100 + 100 = 313,700개
  • 텐서플로 : https://www.tensorflow.org/hub

  • 필요한 것을 찾아서 가져다 사용할 수 있다.

  • 층의 구성을 그림으로 표현해 본다.

  • keras.uitls 패키지의 plot_model() 함수 사용

1
keras.utils.plot_model(model)

png

  • 박스 안에서

    • 왼쪽 : 층의 이름
    • 오른쪽 : 클래스
  • inputLayer 클래스

    • 케라스가 자동으로 추가해주는 입력층의 역할.
    • Conv2D 클래스의 input_shape 매개변수를 사용.
  • 층의 구성을 그림으로 표현해 본다.

  • keras.uitls 패키지의 plot_model() 함수 사용

  • show_shapes 매개변수를 True로 설정하면 그림에 입력과 출력의 크기를 표시한다.

1
keras.utils.plot_model(model, show_shapes = True)

png

  • 지금까지 한 것은 모델 정의
  • 모델 컴파일 후, 훈련
    • 7장 내용
    • Adam 옵티마이저를 사용
    • 조기 종료 기법을 구현 : ModelCheckpoint 콜백과 EarlyStopping 콜백을 함께 사용한다.
1
2
3
4
5
6
7
8
9
10
11
12
13
import tensorflow as tf
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy',
metrics='accuracy')

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-cnn-model.h5',
save_best_only=True)
early_stopping_cb = keras.callbacks.EarlyStopping(patience=2,
restore_best_weights=True)

with tf.device('/device:GPU:0'): # GPU 잡는 법
history = model.fit(train_scaled, train_target, epochs=10,
validation_data=(val_scaled, val_target),
callbacks=[checkpoint_cb, early_stopping_cb])
Epoch 1/10
1500/1500 [==============================] - 59s 39ms/step - loss: 0.4968 - accuracy: 0.8231 - val_loss: 0.3245 - val_accuracy: 0.8799
Epoch 2/10
1500/1500 [==============================] - 55s 37ms/step - loss: 0.3304 - accuracy: 0.8809 - val_loss: 0.2726 - val_accuracy: 0.8967
Epoch 3/10
1500/1500 [==============================] - 55s 37ms/step - loss: 0.2833 - accuracy: 0.8987 - val_loss: 0.2461 - val_accuracy: 0.9072
Epoch 4/10
1500/1500 [==============================] - 55s 37ms/step - loss: 0.2534 - accuracy: 0.9069 - val_loss: 0.2360 - val_accuracy: 0.9119
Epoch 5/10
1500/1500 [==============================] - 55s 37ms/step - loss: 0.2311 - accuracy: 0.9165 - val_loss: 0.2258 - val_accuracy: 0.9170
Epoch 6/10
1500/1500 [==============================] - 55s 37ms/step - loss: 0.2104 - accuracy: 0.9224 - val_loss: 0.2346 - val_accuracy: 0.9157
Epoch 7/10
1500/1500 [==============================] - 55s 37ms/step - loss: 0.1916 - accuracy: 0.9275 - val_loss: 0.2132 - val_accuracy: 0.9234
Epoch 8/10
1500/1500 [==============================] - 55s 37ms/step - loss: 0.1757 - accuracy: 0.9343 - val_loss: 0.2152 - val_accuracy: 0.9220
Epoch 9/10
1500/1500 [==============================] - 56s 37ms/step - loss: 0.1619 - accuracy: 0.9393 - val_loss: 0.2172 - val_accuracy: 0.9247
  • 훈련 세트의 정확도가 이전에 비해 증가했다.
  • 손실 그래프를 그린다.
    • 조기 종료가 잘 이루어졌는지 확인하자.
1
2
3
4
5
6
7
import matplotlib.pyplot as plt
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epoch')
plt.xlabel('loss')
plt.legend(['train', 'val'])
plt.show()

png

  • 그래프를 기반으로 9번째 에포크를 최적으로 생각할 수 잇다.
  • 세트에 대한 성능을 평가해본다.
1
model.evaluate(val_scaled, val_target)
375/375 [==============================] - 5s 14ms/step - loss: 0.2132 - accuracy: 0.9234





[0.21322399377822876, 0.9234166741371155]
  • 좌측 파일 선택 -> best-cnn-model.h5 다운로드

08-3. 합성곱 신경망 시각화

  • 교재 465p
  • 사전 학습 = 이전에 만든 모델이 어떤 가중치를 학습했는지 확인하기 위해 체크포인트 파일을 읽는다.
  • model.layers
    • 케라스 모델에 추가한 층을 출력한다.
1
2
3
4
5
6
7
from tensorflow import keras

# 사전학습 진행
model2 = keras.models.load_model("best-cnn-model.h5")

#keras.utils.plot_model(model2, show_shapes = True)
model.layers
[<keras.layers.convolutional.Conv2D at 0x7fe1487e19d0>,
 <keras.layers.pooling.MaxPooling2D at 0x7fe1d0495b50>,
 <keras.layers.convolutional.Conv2D at 0x7fe148c92590>,
 <keras.layers.pooling.MaxPooling2D at 0x7fe1487fa9d0>,
 <keras.layers.core.flatten.Flatten at 0x7fe1446bad10>,
 <keras.layers.core.dense.Dense at 0x7fe1446ba210>,
 <keras.layers.core.dropout.Dropout at 0x7fe14465cf50>,
 <keras.layers.core.dense.Dense at 0x7fe14465dcd0>]
  • 합성곱 층의 가중치를 확인 가능
  • 우선 첫 번째 합성곱 층의 가중치를 조사한다.
1
2
conv = model.layers[0]
print(conv.weights[0].shape, conv.weights[1].shape) # 가중치, 절편
(3, 3, 1, 32) (32,)
1
2
conv_weights = conv.weights[0].numpy()
print(conv_weights.mean(), conv_weights.std()) # 가중치 배열의 평균, 표쥰편차
-0.038952995 0.26509935
  • 이 가중치가 어떤 분표를 가졌는지 보기 쉽게 히스토그램으로 그린다.
1
2
3
4
plt.hist(conv_weights.reshape(-1, 1))
plt.xlabel('weight')
plt.ylabel('count')
plt.show()

png

  • 이 가중치가 어떤 의미인지 시각화 해보자.
  • 468p
  • 32개의 커널을 16개씩 2줄로 출력한다.
1
2
3
4
5
6
7
8
ig, axs = plt.subplots(2, 16, figsize=(15,2))

for i in range(2):
for j in range(16):
axs[i, j].imshow(conv_weights[:,:,0,i*16 + j], vmin=-0.5, vmax=0.5) # vmin, vmax는 맷플롯립의 컬러맵으로 표현할 범위를 지정
axs[i, j].axis('off')

plt.show()

png

  • 색이 밝은지 어두운지를 통해 가중치를 판단할 수 있다.

이번에는 훈련하지 않은 빈 합성곱 신경망을 만든다.

  • 먼저 Conv2D 층을 하나 추가한다.
1
2
3
4
no_training_model = keras.Sequential()

no_training_model.add(keras.layers.Conv2D(32, kernel_size=3, activation='relu',
padding='same', input_shape=(28,28,1)))
  • 첫 번째 Conv2D층의 가중치를 no_training_conv 변수에 저장한다.
1
2
3
no_training_conv = no_training_model.layers[0]

print(no_training_conv.weights[0].shape)
(3, 3, 1, 32)
  • 가중치의 평균과 표준편차를 확인한다.
1
2
no_training_weights = no_training_conv.weights[0].numpy()
print(no_training_weights.mean(), no_training_weights.std())
0.011464282 0.08503365
  • 이 가중치 배열을 히스토그램으로 표현한다.
1
2
3
4
plt.hist(no_training_weights.reshape(-1, 1))
plt.xlabel('weight')
plt.ylabel('count')
plt.show()

png

  • 그래프가 이전과 확실히 다르다.
  • 이 가중치 값을 맷플롯립의 imshow() 함수를 사용해 이전처럼 그림으로 출력한다.
1
2
3
4
5
6
7
8
ig, axs = plt.subplots(2, 16, figsize=(15,2))

for i in range(2):
for j in range(16):
axs[i, j].imshow(no_training_weights[:,:,0,i*16 + j], vmin=-0.5, vmax=0.5) # vmin, vmax는 맷플롯립의 컬러맵으로 표현할 범위를 지정
axs[i, j].axis('off')

plt.show()

png

  • 전체적으로 가중치가 밋밋하게 초기화되었다.
  • 이 그림을 훈련이 끝난 이전 가중치와 비교해보자.
  • 합성곱 신경망이 패현MNIST 데이터셋의 부류 정확도를 높이기 위해 유용한 패턴을 학습했다는 사실을 눈치챌 수 있다.

함수형 API

  • 474p
  • 특성 맵 시각화
    • 케라스로 패현 MNIST 데이터셋을 읽은 후 훈련 세트에 있는 첫 번째 샘플을 그려본다.
1
2
3
4
5
print(model.input)
conv_acti = keras.Model(model.input, model.layers[0]./images/chapter_8_1_2/output)
(train_input, train_target), (test_input, test_target) = keras.datasets.fashion_mnist.load_data()
plt.imshow(train_input[0], cmap='gray_r')
plt.show()
KerasTensor(type_spec=TensorSpec(shape=(None, 28, 28, 1), dtype=tf.float32, name='conv2d_input'), name='conv2d_input', description="created by layer 'conv2d_input'")

png

  • 앵클 부트다.
  • 이 샘플을 conv_acti 모델에 주입하여 Conv2D 층이 만드는 특성 맵을 출력한다.
  • 08-2장에서 했던 것처럼 전처리를 진행한다.
  • feature_maps의 크기를 확인한다.
1
2
3
inputs = train_input[0:1].reshape(-1, 28, 28, 1)/255.0
feature_maps = conv_acti.predict(inputs)
print(feature_maps.shape)
(1, 28, 28, 32)
  • same 패딩과 32개의 필터를 사용한 합성곱 층의 출력이므로 (28,28,32)이다.
  • 샘플을 하나 입력했기에 1이다.
  • 앞에서와 같이 맷플롯립의 imshow함수로 특성 맵을 그린다.
    • 32개의 특성 맵을 4개의 행으로 나누어 그린다.
1
2
3
4
5
6
7
8
fig, axs = plt.subplots(4, 8, figsize=(15,8))

for i in range(4):
for j in range(8):
axs[i, j].imshow(feature_maps[0,:,:,i*8 + j])
axs[i, j].axis('off')

plt.show()

png

  • 두 번째 합성곱 층이 많든 특성 맵도 같은 방식으로 확인할 수 있다.
  • 먼저 model 객체의 입력과 두 번째 합성곱 층인 model.layers[2]의 출력을 연결한 conv2_acti 모델을 만든다.
  • 그 다음 첫 샘플을 conv2_acti 모델의 predict() 메서드에 전달한다.
  • 첫 번째 풀링 층에서 가로세로 크기가 줄반으로 줄고, 두 번째 합성곱 층의 필터 개수는 64개이므로 (14,14,64) 가 된다.
  • 64개의 특성 맵을 8개씩 나누어 imshow()함수로 그린다.
1
2
3
4
5
6
7
8
9
10
11
12
conv2_acti = keras.Model(model.input, model.layers[2]./images/chapter_8_1_2/output)
feature_maps = conv2_acti.predict(train_input[0:1].reshape(-1, 28, 28, 1)/255.0)
print(feature_maps.shape)

fig, axs = plt.subplots(8, 8, figsize=(12,12))

for i in range(8):
for j in range(8):
axs[i, j].imshow(feature_maps[0,:,:,i*8 + j])
axs[i, j].axis('off')

plt.show()
(1, 14, 14, 64)

png

  • 이번 특성 맵은 시각적으로 이해하기 어렵다.

  • 두 번째 합성곱 층의 필터 크기는 (3,3,32)인데 (14,14,32)인 특성 맵에서 어떤 부위를 감지하는지 직관적으로 이해하기 어렵다.

    • 478p 그림 참고
  • 이런 현상은 합성곱 층을 많이 쌓을수록 심해진다.

  • Reference : 혼자 공부하는 머신러닝 + 딥러닝