[AI 스터디] Section 8 : CNN & LeNet5

CNN (Convolutional Neural Network) 소개

이미지 학습 과정

1. Pixel 정보 인식

• pixel : 0 ~ 255 사이의 정수값으로 빛의 강도를 나타냄 (black : 0)
• 컬러이미지 : 흑백 이미지 3장으로 RGB로 겹쳐서 색을 표현하게 됨

< NN (neural network)를 거치면서 이미지의 특성이 학습됨>

 

2. Edge/Simple Shape 특성 학습
  ⇒ 은닉층을 거침 : 단순한 특성(사선, 수직선 등의 테두리 등을 학습)

 

3. Complex Shape 특성 학습
  ⇒ 은닉층 단계가 깊어짐 : 단순한 특성을 조합한 복잡한 쉐입이 학습됨

 

4. 얼굴인식에 필요한 특성 학습

  ⇒ 최종 : 전체 인식에 필요한 특성을 학습

 

5. 얼굴을 보고 누구인지 분류 가능

 

CNN 이전의 이미지 처리 : 2차원 이미지를 1차원 벡터 conversion

1. reshape(60000, 784) : 60000장의 사진을 reshape
2. 문제점
   • 이미지의 공간적, 지역적 특성 상실
   • fully connected이므로 계산량 급증
     ⇒ 100만 픽셀의 경우, 1000 x 1000 사진
     ⇒ 컬러면, 3 x 1000 x 1000
     ⇒ 총 계산 : 300만 차원 x Layer 수 x 각 Layer의 Neuron 수
   • 해결 : 이미지를 처리하기 위한 특별한 구조의 NN이 필요 ⇒ CNN

 

CNN의 특별한 레이어

 

Convolutional Layer (합성곱층)

01. 특징

• Image 정보의 공간적 지역 특성 (Locality) 보존
  ⇒ 커널 사이즈 만큼의 patch의 인접 픽셀들에 대한 상관관계를 비선형 필터를 적용해 Locality 추출
  ⇒ 여러개의 필터 적용시, 다양한 locality 추출 가능
       ( 필터 각각에 특징을 직접 부여하는게 아니라 역전파에 의해 자동으로 최적화됨)
• Filter (Kernel) 을 이용한 이미지 특성 추출
• Parameter Sharing
  : 이미지의 모든패치가 동일한 커널을 적용하여 다음 레이어의 output 출력한다.
  ⇒ 장점 : 파라미터의 개수가 획기적으로 감소 (학습되는것은 커널밖에 없기 때문)

02. Kernel : 스스로 학습하는 파라미터로, Neural Network의 경사하강법과 오차역전파로 학습된다

03. Convolution (합성곱)

  (1) 방법

• 첫번째 image patch 생성
  → kernel 사이즈에 맞게 input 이미지를 이미지 패치로 만든 것
  → 결과 : 5 = 1x1 + 0x2 + 0x3 + 1x4 (파랑색 )
• 한 픽셀 옮겨서, 2번째 이미지 패치 생성
• 끝까지 도달시, 한픽셀 내려가서 다시 진행
• 끝까지 진행

 (2)  Padding

     : 합성곱 진행시, 인풋사이즈가 줄어들게 되는데 이를 막기 위한 방법

• default = no padding
  ⇒ 이유 : 이미지의 대부분은 가운데가 중요한 것
• padding을 사용하는 경우 (= padding = ”same”) : 중요한 데이터가 귀퉁이에 있어 정보손실을 막아야하는 경우
• 방법 : 4x4 인풋의 가장자리에 0 픽셀을 넣어 5x5로 만든 후, 합성곱을 진행

 (3) Striding

  : 이미지 패치를 생성할 때, 움직이는 정도 (= 필터를 인풋에서 움직이는 간격의 정도)

• 특징 : stride가 클수록 계산이 줄고, 속도가 빨라지나, 정보가 많이 손실되어 정확도가 떨어짐
• 사용하는 경우 : 정확도 보단, 속도를 중요시 하고 싶은 경우 / 이미지가 너무 큰 경우
• 일반적으로는 1로 많이 함

(4) 컬러 이미지에서의 합성곱

• R, G, B 3개의 채널로 구성된 사진의 채널 각각에 필터를 적용
• 3개의 합성곱 결과를 더하여 하나의 matrix로 만듭
• 비선형 필터를 적용하는 단계로, relu(matrix + b)를 거쳐, output을 생성한다.

 

Pooling Layer (풀링층)

01. 특징

 - Image data 의 정보 손실 없는 압축 (정보 손실을 최소화!) : 사이즈 축소됨

   ➔ 계산량 및 메모리 사용량 축소, 파라미터의 수 감소 (과적합 방지 → 일반화 능력에 도움됨)

 - 뉴런의 가중치가 없음

 - positional Invariance : 특정 픽셀의 정확한 포지션에 민감도가 적음

   ➔ 여러개의 풀링을 거치면, 넓은 영역에 걸쳐서 같은 효과가 발생함

   ➔  이유 : 풀링을 거치면서 원래 이미지의 여러 개 픽셀의 특성을 1픽셀에 담게 되기 때문

 

02. 역할 : image subsampling

  ➔ 이미지 사이즈를 줄여도, 정보 손실이 얼마 되지 않음을 이용한 것

 

03. 종류

 - Average Pooling : 평균값을 내, 그 값을 사용하는 것 

 - Max Pooling : 최대값을 가져온 것

  ➔ ex) 2x2 max pooling with stride 2 : 2x2 픽셀을 이미지에 적용해, 4개의 픽셀 중 최대값 1개씩 뽑음

 

04. Flattening

 (1) 필요한 이유 : 마지막엔 꼭 fully connected layer/Dense 레이어를 거쳐야하는데, 이들은 입력을 1차원으로만 받기 때문에

 (2) 과정

• 이미지를 Flattening 을 통해 1차원으로 만듬
• fully connected 레이어로 연결된 히든레이어를 지남
• softmax 함수를 지나, 이 사진이 어떤 사진일 확률을 출력
• 분류됨

 

대표적인 CNN 모델

AlexNet	- 2012 년 ILSVRC 대회 우승 - LeNet의 확장판
GoogleLeNet(Inception Net)	- 2014 년 ILSVRC 대회 우승
ResNet	- 2015 년 ILSVRC 대회 우승 - 152개의 층 : ResNet 부터 딥해지기 시작 - skip connection을 통해 원래의 정보를 잊지 않고, 학습을 이어나갈 수 있음
MobileNet	- 1000가지 클래스를 분류할 수 있는 가벼운 모델 - mobile device 용 pre-trained model ⇒ 전이학습 모델 ⇒ 파인튜닝해서 사용 가능
VGG-16	- Keras 내장 사전 학습 모델 - (2014 년, 16 layers)

실습 - Deeper CNN을 이용한 CIFAR-10 분류

모델

GPU가 연결되었는지 확인 + 텐서플로우 버전

# GPU 연결 확인
from tensorflow.python.client import device_lib
device_lib.list_local_devices()

# 텐서플로우 버전
import tensorflow as tf
tf.__version__

데이터 불러오기

import numpy as np
from tensorflow.keras.datasets import cifar10

# train, test split
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
# (50000, 32, 32, 3)
# (10000, 32, 32, 3)
# (50000, 1)
# (10000, 1)

# 클래스별 이름
cifa10_classes = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']

# 클래스별 사진 시각화
fig, axes = plt.subplots(2, 8, figsize=(15, 4))
axes = axes.ravel()
for i in range(16):
    idx = np.random.randint(0, len(y_train))
    axes[i].imshow(X_train[idx, :])
    axes[i].set_xticks([])
    axes[i].set_yticks([])
    axes[i].set_title(cifa10_classes[y_train[idx, 0]])

# data normalization
X_train_scaled = X_train / 255.
X_test_scaled  = X_test / 255.

# one-hot encoding of class labels
# categorical cross entryopy를 적용하기 위함
y_train_onehot = utils.to_categorical(y_train)
y_test_onehot  = utils.to_categorical(y_test)
print(y_train_onehot.shape)
print(y_test_onehot.shape)

# tf.data 를 이용한 shuffling and batch 구성
# gpu에 효율적으로 데이터를 올리기 위해 사용 (안해도 나중에 변환과정을 거쳐짐
# 이거 하기 전은 numpy 데이터 (GPU에서는 못돌아가는 데이터 타입)
# 그냥 출력하면 뭐가 나오지 않음
train_ds = tf.data.Dataset.from_tensor_slices((X_train_scaled, y_train_onehot)).shuffle(10000).batch(64)
test_ds  = tf.data.Dataset.from_tensor_slices((X_test_scaled, y_test_onehot)).batch(64)

모델 구성

from tensorflow.keras import utils
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Activation, Dropout
from tensorflow.keras.optimizers import Adam
import matplotlib.pyplot as plt

# model build
model = Sequential()

model.add(Conv2D(16, (3, 3), padding='same', input_shape=(32, 32, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D((2,2))) # strides 지정이 생략됨 => pool 사이즈와 동일하게
model.add(Dropout(0.2)) # 20 % 뉴런 deactivate

# 앞 보다 필터 사이즈 늘려감-> 계속 늘려감 -> 사진 사이지는 maxpooling 되며 작아지지만, 개수는 늘어나도록
model.add(Conv2D(32, (3, 3), padding='same')) 
model.add(Activation('relu'))
model.add(MaxPooling2D((2, 2)))
model.add(Dropout(0.2))

model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(MaxPooling2D((2,2)))
model.add(Dropout(0.2))

model.add(Flatten()) # Dense 레이어와 연결하기 위해
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax')) # 아웃풋 레이어와 바로 열결 / 다중분류여서 softmax

# 모델 요약
model.summary()

모델 학습

# model compile : 다중분류여서 categorical_crossentropy
# Adam을 함수로 부르게 되면 파라미터로 학습률등을 지정 가능
model.compile(loss='categorical_crossentropy', optimizer=Adam(learning_rate=0.001), metrics=['accuracy'])

# 모델 학습
model.fit(train_ds, epochs=5, validation_data=test_ds, verbose=1, shuffle=True)

모델 예측

# [0.9354581832885742, 0.6686000227928162]
model.evaluate(test_ds, verbose=0)

# 확률 분포를 반환하므로 argmax를 이용해, 가장 확률이 높은 인덱스값 반환하도록
# => y_test와 비교할 수 있음
y_pred = model.predict(X_test_scaled).argmax(axis=-1)

# y_test를 flatten : (10000,1) => (10000,)
y_true = y_test.ravel()

평가 지표

cm = confusion_matrix(y_true, y_pred)

array([[734,  25,  51,  21,   5,   6,  10,   8,  93,  47],
       [ 13, 830,   3,   6,   4,   2,   8,   2,  23, 109],
       [ 99,   5, 536,  81,  74,  68,  77,  25,  27,   8],
       [ 41,  14,  79, 478,  46, 162,  94,  29,  27,  30],
       [ 38,   5, 137,  71, 509,  42,  93,  82,  16,   7],
       [ 24,   7,  80, 215,  30, 527,  30,  56,  17,  14],
       [ 10,   7,  50,  64,  34,  14, 797,   3,   9,  12],
       [ 17,   1,  41,  48,  59,  79,  12, 707,   9,  27],
       [ 72,  46,  14,  14,   3,   6,   5,   5, 807,  28],
       [ 32, 118,   6,  14,   7,   3,   7,  15,  37, 761]], dtype=int64)

잘 나왔는지 확인 시각화 : 뭘로 예측했는지 확인 가능

fig, axes = plt.subplots(2, 8, figsize=(15, 4))
axes = axes.ravel()

# 16개의 무작위 이미지를 선택하여 표시
for i in range(16):
    idx = np.random.randint(0, len(y_test))  # 무작위 인덱스 생성
    axes[i].imshow(X_test[idx, :])      # 이미지 표시
    axes[i].set_xticks([])                    # x축 눈금 제거
    axes[i].set_yticks([])                    # y축 눈금 제거
    # 실제 라벨과 예측된 라벨로 제목 설정
    axes[i].set_title("true={} \\npredicted={}".
                      format(cifa10_classes[y_true[idx]], cifa10_classes[y_pred[idx]]))

plt.tight_layout() # 서브플롯들이 겹치지 않도록 레이아웃 조정
plt.show() 

Heat Map

plt.figure(figsize=(10,8))

sns.heatmap(cm, annot=True)

plt.xticks(np.arange(10), cifa10_classes, rotation=45, fontsize=12)
plt.yticks(np.arange(10), cifa10_classes, rotation=45, fontsize=12)
plt.xlabel("true class")
plt.ylabel("predicted class")
plt.title('Confusion Matrix')
print('Test Accuracy :', accuracy_score(y_true, y_pred))

 

---

LesNet 5

01. 소개

 - 1998년 Yan LeCunn이 제안한 최초의 CNN 모델

 

02. 구조

- 2, 4, 7, 8, 9 : 5개의 층을 가짐 (학습되는 파라미터가 있는 층) 

1. input image : 32x32의 흑백 이미지
2. convolution filter : 5x5의 6장의 필터 ⇒ 결과 : 28x28x6
3. pooling : average pooling (2x2 / stride 2) ⇒ 결과 : 14x14x6
4. convolution filter : 5x5의 16장의 필터 ⇒ 결과 : 10x10x16
5. pooling : average pooling (2x2 / stride 2) ⇒ 결과 : 5x5x16 (5x5 사이즈의 사진 16)
6. flattening : 400x1 벡(1655=400)
7. Dense layer : 120개의 뉴런 ⇒ 결과 : fully connected 레이어 생성
8. Dense layer : 84개의 뉴런
9. output layer : 10개의 뉴런 ⇒ 결과 : 10개 중 하나로 분류하는 모델

03. 실습 : MNIST 데이터셋을 이용한 모델 구축

데이터 불러오기 및 정제

from tensorflow.keras.datasets import mnist

# 자동으로 파이썬의 튜플 형태로 데이터가 나눠
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# 클래스 별 그림
plt.figure(figsize=(5,5))
for i in range(9):
    plt.subplot(3, 3, i+1)
    plt.imshow(X_train[i], cmap='gray', interpolation='none') # default : color
    plt.title("Class {}".format(y_train[i]))
    plt.xticks([])
    plt.yticks([])
plt.tight_layout()
plt.show()

# simple scailing : 최대값으로 나눠 0 ~ 1 사이로 pixel 값을 scale
X_train_scaled = X_train / 255.
X_test_scaled = X_test / 255.
X_train_scaled.shape, X_test_scaled.shape # ((60000, 28, 28), (10000, 28, 28))

# Conv2D layer 의 입력 사양에 맞추어 3 dimension 으로 차원 증가 : 흑백이므로 1 (컬러면 3)
X_train_scaled = np.expand_dims(X_train_scaled, axis=3)
X_test_scaled = np.expand_dims(X_test_scaled, axis=3)
X_train_scaled.shape, X_test_scaled.shape # ((60000, 28, 28, 1), (10000, 28, 28, 1))

# 레이블을 one hot encoding 해줌 -> categorical cross entryopy를 적용하기 위함
# (60000, 10) (10000, 10)
y_train_onehot = tf.keras.utils.to_categorical(y_train)
y_test_onehot = tf.keras.utils.to_categorical(y_test)

# tf.data 를 이용한 shuffling and batch 구성
# gpu에 효율적으로 데이터를 올리기 위해 사용 (안해도 나중에 변환과정을 거쳐짐
# 이거 하기 전은 numpy 데이터 (GPU에서는 못돌아가는 데이터 타입)
# 그냥 출력하면 뭐가 나오지 않음
train_ds = tf.data.Dataset.from_tensor_slices((X_train_scaled, y_train_onehot)).shuffle(10000).batch(128) # 튜플 형태로 입력피처, 레이블 데이터를 넣음 
test_ds  = tf.data.Dataset.from_tensor_slices((X_test_scaled, y_test_onehot)).batch(128) # shuffle 필요 없음 -> test에 굳이,,,,!

# 출력 방법 : for문 사용
for x, y in train_ds :
	print(X)

LeNet 구성

model = tf.keras.Sequential()

model.add(Conv2D(6, kernel_size=5, padding="same", input_shape=(28, 28, 1))) # 패딩 적용
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))

model.add(Conv2D(16, kernel_size=5, padding="valid"))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))

model.add(Flatten())
model.add(Dense(120))
model.add(Activation ('relu'))

model.add(Dense(84))
model.add(Activation ('relu'))

model.add(Dense(10))
model.add(Activation ('softmax')) # 다중분류이므로 softmax

model.summary()
Model: "sequential_3"
_________________________________________________________________
 Layer (type)                      Output Shape              Param #   
=================================================================
 conv2d_4 (Conv2D)                (None, 28, 28, 6)         156                                                                 
 activation_4 (Activation)        (None, 28, 28, 6)         0                                                                        
 max_pooling2d_2 (MaxPooling 2D)  (None, 14, 14, 6)         0                                                                                                                                       
 conv2d_5 (Conv2D)                (None, 10, 10, 16)        2416                                                                      
 activation_5 (Activation)        (None, 10, 10, 16)        0                                                                          
 max_pooling2d_3 (MaxPooling 2D)  (None, 5, 5, 16)          0                                                                                                                                       
 flatten_1 (Flatten)              (None, 400)               0                                                                          
 dense_2 (Dense)                  (None, 120)               48120                                                                     
 activation_6 (Activation)        (None, 120)               0                                                                         
 dense_3 (Dense)                  (None, 84)                10164                                                                     
 activation_7 (Activation)        (None, 84)                0                                                                         
 dense_4 (Dense)                  (None, 10)                850                                                                       
 activation_8 (Activation)        (None, 10)                0                                                                         
=================================================================
Total params: 61,706
Trainable params: 61,706
Non-trainable params: 0

# 모델 컴파일
model.compile(loss="categorical_crossentropy", optimizer='adam', metrics=['accuracy'])

모델 훈련 및 예측

# 위에서 train_ds를 구성하며 배치사이즈 등을 맞춰놓았기 때문에 필요없음
history = model.fit(train_ds, epochs=5, validation_data=test_ds)
                    
score = model.evaluate(test_ds, verbose=0)
print("Test loss ", score[0]) # Test loss  0.037596870213747025
print("Test Accuracy ", score[1]) # Test Accuracy  0.9873999953269958

y_pred = model.predict(X_test_scaled).argmax(axis=1)

# 모델 훈련 결과 시각화 : 과적합이 일어났는지 확인하기 위함
plt.figure(figsize=(12,4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.legend(['train', 'test'])

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'test']

예측 결과 확인 및 시각화

from sklearn.metrics import confusion_matrix, accuracy_score

# Test Accuracy : 0.985
print('Test Accuracy :', accuracy_score(y_test, y_pred))

# 혼동행렬 그냥 출력
print(confusion_matrix(y_test, y_pred))

# 혼동행렬 시각화
plt.figure(figsize=(7,6))
sns.heatmap(confusion_matrix(y_test, y_pred), annot=True, fmt='d')
plt.xticks(np.arange(10), list(range(10)), rotation=45, fontsize=12)
plt.yticks(np.arange(10), list(range(10)), rotation=45, fontsize=12)
plt.xlabel("predicted class")
plt.ylabel("true class")
plt.title('Confusion Matrix')

 

04. 실습 : Fashion MNIST 데이터셋을 이용한 모델 구축

데이터 불러오기 및 정제

(train_images, train_labels), (test_images, test_labels) = tf.keras.datasets.fashion_mnist.load_data()

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 
               'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

# 데이터 예시 시각화
plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
    plt.xticks([])
    plt.yticks([])

X_train = train_images / 255.0
X_test  = test_images / 255.0

# Conv2D layer 의 입력 사양에 맞추어 3 dimension 으로 차원 증가
X_train_scaled = np.expand_dims(X_train_scaled, axis=3)
X_test_scaled = np.expand_dims(X_test_scaled, axis=3)
X_train_scaled.shape, X_test_scaled.shape # ((60000, 28, 28, 1), (10000, 28, 28, 1))

# 레이블을 one hot encoding : (60000, 10) (10000, 10)
y_train_onehot = tf.keras.utils.to_categorical(y_train)
y_test_onehot = tf.keras.utils.to_categorical(y_test)

# tf.data 를 이용한 shuffling and batch 구성
train_ds = tf.data.Dataset.from_tensor_slices((X_train_scaled, y_train_onehot)).shuffle(10000).batch(128) # 튜플 형태로 입력피처, 레이블 데이터를 넣음 
test_ds  = tf.data.Dataset.from_tensor_slices((X_test_scaled, y_test_onehot)).batch(128) # shuffle 필요 없음 -> test에 굳이,,,,!

모델 구성

# LeNet model 구성
# kernel 사이즈를 줄이고 convolution 층 한번 더 늘림
model = tf.keras.Sequential()

model.add(Conv2D(6, kernel_size=3, padding="same", input_shape=(28, 28, 1))) # 패딩 적용
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))

model.add(Conv2D(16, kernel_size=3, padding="valid"))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))

model.add(Conv2D(32, kernel_size=3, padding="valid"))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))

model.add(Flatten())
model.add(Dense(120))
model.add(Activation ('relu'))

model.add(Dense(84))
model.add(Activation ('relu'))

model.add(Dense(10))
model.add(Activation ('softmax')) # 다중분류이므로 softmax

model.summary()
Model: "sequential_1"
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┓
┃ Layer (type)                         ┃ Output Shape                ┃         Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━┩
│ conv2d (Conv2D)                      │ (None, 28, 28, 6)           │              60 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ activation (Activation)              │ (None, 28, 28, 6)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d (MaxPooling2D)         │ (None, 14, 14, 6)           │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_1 (Conv2D)                    │ (None, 12, 12, 16)          │             880 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ activation_1 (Activation)            │ (None, 12, 12, 16)          │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_1 (MaxPooling2D)       │ (None, 6, 6, 16)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ conv2d_2 (Conv2D)                    │ (None, 4, 4, 32)            │           4,640 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ activation_2 (Activation)            │ (None, 4, 4, 32)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ max_pooling2d_2 (MaxPooling2D)       │ (None, 2, 2, 32)            │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ flatten (Flatten)                    │ (None, 128)                 │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense (Dense)                        │ (None, 120)                 │          15,480 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ activation_3 (Activation)            │ (None, 120)                 │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_1 (Dense)                      │ (None, 84)                  │          10,164 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ activation_4 (Activation)            │ (None, 84)                  │               0 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ dense_2 (Dense)                      │ (None, 10)                  │             850 │
├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤
│ activation_5 (Activation)            │ (None, 10)                  │               0 │
└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘
 Total params: 32,074 (125.29 KB)
 Trainable params: 32,074 (125.29 KB)
 Non-trainable params: 0 (0.00 B)
 
# model compile 
model.compile(loss="categorical_crossentropy", optimizer='adam', metrics=['accuracy'])

모델 훈련 및 예측 및 결과

# 모델 학습
history = model.fit(train_ds, epochs=5, validation_data=test_ds)
                    
score = model.evaluate(test_ds, verbose=0)
print("Test loss ", score[0]) # Test loss 
print("Test Accuracy ", score[1]) # Test Accuracy

y_pred = model.predict(X_test_scaled).argmax(axis=1)

# 모델 훈련 결과 시각화
plt.figure(figsize=(12,4))
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.legend(['train', 'test'])

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'test']

혼동행렬 시각화

# confusion matrix 시각화
cm = confusion_matrix(y_test, y_pred)
ax = sns.heatmap(cm, annot=True, fmt='d')
plt.figure(figsize=(7,6))
ax.set_xticklabels(class_names,  rotation=45, fontsize=12)
ax.set_yticklabels(class_names,  rotation=45, fontsize=12)
ax.set_xlabel("predicted class")
ax.set_ylabel("true class")