[Python] 신경망 모델 훈련

# 케라스 API를 사용해서 모델 훈련에 필요한 도구 알아보기
# 데이터 준비
from sklearn.model_selection import train_test_split
from tensorflow import keras

(train_input, train_target), (test_input, test_target) = \
    keras.datasets.fashion_mnist.load_data()
train_scaled = train_input / 255.0
train_scaled, val_scaled, train_target, val_target = train_test_split(
    train_scaled, train_target, test_size = 0.2, random_state = 42)

• train_test_split : 데이터를 훈련용(train)과 검증용(validation)으로 분리하는 함수
• tensorflow.keras : 케라스 API를 사용하기 위해 텐서플로에서 가져옴
• fashion_mnist.load_data() : Fashion MNIST 데이터셋을 불러옴
  • 훈련 데이터(train_input, train_target)와 테스트 데이터(test_input, test_target)를 가져옴
• train_scaled = train_input / 255.0 : 픽셀 값을 0 ~ 1 범위로 정규화
• train_scaled, val_scaled, train_target, val_target = train_test_split(
      train_scaled, train_target, test_size = 0.2, random_state = 42)
  
  • 훈련 데이터를 훈련(train)과 검증(val) 데이터로 분할
  • test_size = 0.2 : 전체 훈련 데이터의 20%를 검증 데이터로 사용
  • random_state = 42 : 랜덤 시드를 고정해 항상 동일한 방식으로 데이터를 분할

# 딥러닝 모델을 만드는 함수 정의
def model_fn(a_layer = None):
    model = keras.Sequential()
    model.add(keras.layers.Flatten(input_shape = (28, 28)))
    model.add(keras.layers.Dense(100, activation = 'relu'))
    
    if a_layer:
        model.add(a_layer)

    model.add(keras.layers.Dense(10, activation = 'softmax'))
    return model

• model_fn() : 딥러닝 모델 생성 함수
• keras.Sequential() : 순차적(Sequential) 모델을 생성
• model.add(keras.layers.Flatten(input_shape = (28, 28)))
  • 입력 데이터의 차원을 펼침(2차원 배열 >> 1차차원 벡터)
  • input_shape = (28, 28) : 입력 이미지는 28 x 28 크기의 2D 배열
  • >> 1D 벡터(28 x 28 = 784 차원)로 변환해서 Dense 레이어에 입력
• model.add(keras.layers.Dense(100, activation = 'relu'))
  • 100개의 뉴런을 갖고, 활성화 함수로 relu를 사용
  • ReLU : 음수를 0으로 만들고, 양수는 그대로 출력하는 활성화 함수 >> 비선형성을 추가해서 학습 능력 증가
• if a_layer:
       model.add(a_layer)
  • 함수의 인자로 a_layer를 받을 경우 해당 레이어 추가
• model.add(keras.layers.Dense(10, activation = 'softmax'))
  • 10개의 뉴런 > 10개의 클래스(0 ~ 9)에 대한 확률 출력
  • softmax 활성화 함수 : 출력값을 확률로 변환(총합이 1이 되도록 정규화)
  • 가장 높은 확률을 가진 뉴런이 예측한 클래스

(1) 층을 추가하지 않고 model_fn() 호출

model = model_fn()
model.summary()

 

(2) 모델 설정 및 훈련, 훈련 결과를 변수에 담기

model.compile(loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
history = model.fit(train_scaled, train_target, epochs = 5, verbose = 0)

• model.compile() : 모델을 훈련할 수 있도록 설정
• loss = 'sparse_categorical_crossentropy' :
  • 손실 함수 설정
  • 다중 클래스 분류 문제에서 정수형 라벨을 사용할 때 적합
• metrics = ['accuracy'] :
  • 모델 성능 평가 지표로 정확도(accuracy)를 사용
• history = model.fit(train_scaled, train_target, epochs=5, verbose=0)
  
  • model.fit() : 훈련 데이터로 모델 학습
  • train_scaled : 입력 데이터
  • train_target : 정답 데이터
  • epochs = 5 : 전체 데이터를 5번 반복
  • verbose = 0 : 훈련 중 출력되는 메세지 숨김
    (1이면 학습 진행 상황 출력, 2이면 epoch 별로 요약 출력)

# 변수 history 딕셔너리 확인
print(history.history.keys())

 

(3) 손실와 정확도 그래프

# 손실 그래프
import matplotlib.pyplot as plt
plt.plot(history.history['loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

손실 그래프

# 정확도 그래프
plt.plot(history.history['accuracy'])
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.show()

정확도 그래프

>>> 에포크마다 손실은 감소하고 정확도가 향상됨

 

 

(3-1) 에포크(반복) 수를 늘려 모델을 훈련시키고 손실, 정확도 그래프 그리기

model = model_fn()
model.compile(loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
history = model.fit(train_scaled, train_target, epochs = 20, verbose = 0)

# 손실 그래프
plt.plot(history.history['loss'])
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

손실 그래프

# 정확도 그래프
plt.plot(history.history['accuracy'])
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.show()

정확도 그래프

반복을 많이 할 수록 손실이 잘 감소됨

---

검증 손실

과(대)적합, 과소적합을 파악하기 위해 훈련 세트, 테스트 세트에 대한 점수 검증하기

# 에포크마다 검증 손실을 계산하기 위해 케라스 모델에 검증 데이터 전달
model = model_fn()
model.compile(loss = 'sparse_categorical_crossentropy', metrics = ['accuracy'])
history = model.fit(train_scaled, train_target, epochs = 20, verbose = 0,
                    validation_data = (val_scaled, val_target))

• validation_data : 검증 데이터를 훈련 과정에서 함께 평가하도록 설정하는 옵션
• (val_scaled, val_target)을 전달해서 에포크마다 검증 손실과 검증 정확도를 계산

history 딕셔너리에 검증 세트도 추가됨

 

 

훈련 손실과 검증 손실을 그래프로 비교하기

plt.plot(history.history['loss']) # 훈련 손실
plt.plot(history.history['val_loss']) # 검증 손실
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(['train', 'val'])
plt.show()

>> 훈련 손실을 꾸준히 감소하기 때문에 과대적합 모델이 만들어짐

>> 검증 손실이 증가하는 시점을 뒤로 늦추면 검증 세트의 손실이 줄어들고, 정확도도 늘어날 것

 

옵티마이저 하이퍼 파라미터를 조정해서 과대적합을 완화시키기

# Adam 옵티마이저 적용
model = model_fn()
model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy',
              metrics = ['accuracy'])
history = model.fit(train_scaled, train_target, epochs = 20, verbose = 0,
                    validation_data = (val_scaled, val_target))

> 과대적합이 조금 줄어듬

---

드롭아웃(Dropout)

- 뉴런을 랜덤하게 비활성화해서 학습을 진행하는 기법

> 과대적합 방지에 효과적, 특정 뉴런들이 학습 중에 너무 강하게 연관되는 것을 방지,

신경망이 보다 일반화된 패턴을 학습할 수 있도록 도와줌

# 케라스 드롭아웃 클래스 : keras.layers.Dropout
model = model_fn(keras.layers.Dropout(0.3)) # 30%를 드롭아웃으로 지정
model.summary()

은닉층에 추가된 드롭아웃층은 훈련되는 모델 파라미터가 없음 >> 입력과 출력의 크기가 같음

 

model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy',
              metrics = ['accuracy'])
history = model.fit(train_scaled, train_target, epochs = 20, verbose = 0,
                    validation_data = (val_scaled, val_target))

과대적합이 확실히 줄어든 모습, 10번 반복부터 검증 손실이 상승하지 않고 비슷하게 유지됨

 

# 과대적합 되지 않은 모델을 얻기 위해서 에포크 횟수를 10으로 하고 다시 훈련
model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy',
              metrics = ['accuracy'])
history = model.fit(train_scaled, train_target, epochs = 10, verbose = 0,
                    validation_data = (val_scaled, val_target))

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

---

모델 저장과 복원

# 케라스 모델의 훈련 파라미터를 저장하는 메서드 : save_weights()
# HDF5(Hierarchical Data Format) 포맷으로 저장
model.save_weights('model-weights.weights.h5')

# 모델의 구조와 모델 파라미터를 함께 저장하는 메서드 : save()
model.save('model-whole.keras')

 

저장된 파일을 가지고 두 가지 실험

 

1. 저장한 모델 파라미터를 읽어서 사용하는 방법

# 새로운 모델을 만들고 이전에 저장했던 모델 파라미터 적용
model = model_fn(keras.layers.Dropout(0.3))
model.load_weights('model-weights.weights.h5')

가장 큰 값의 인덱스를 골라 타깃 레이블과 비교하여 정확도 계산하기

# 검증 정확도 확인
# predict() : 케라스 예측을 수행하는 메서드
# 머신러닝의 predict()와 다르게 10개 클래스에 대한 확률을 반환함
import numpy as np
val_labels = np.argmax(model.predict(val_scaled), axis = 1)
print('검증 정확도 :', np.mean(val_labels == val_target))

• val_labels = np.argmax(model.predict(val_scaled), axis=-1) : 배열의 마지막 차원을 가지고 최대값 선택
• print(np.mean(val_labels == val_target)) : 각 위치(인덱스)의 값과 타겟 값이 같으면 '1', 다르면 '0' --> 이것으로 평균 정확도 계산

 

 

(2) 모델 전체 파일을 읽어서 검증 세트 정확도 출력

model = keras.models.load_model('model-whole.keras')
loss, acc = model.evaluate(val_scaled, val_target)
print(f'검증 데이터 손실: {loss:.4f}')
print(f'검증 데이터 정확도: {acc:.4f}')

 

>> 같은 모델을 저장하고 파일을 다시 불러서 확인한 결과 : 동일한 정확도를 얻음

---

콜백

- 훈련 과정에서 중간에 어떤 작업을 수행할 수 있게 해주는 객체

# 케라스에서 keras.callbacks 패키지아래에 정의됨
model = model_fn(keras.layers.Dropout(0.3))
model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy',
              metrics = ['accuracy'])

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-model.keras', save_best_only = True)
# save_best_only = True : 가장 높은 점수를 만드는 모델 저장

model.fit(train_scaled, train_target, epochs = 20, verbose = 0,
          validation_data = (val_scaled, val_target), callbacks = [checkpoint_cb])

• ModelCheckpoint() : 모델을 특정 조건일 때 저장하는 콜백
• save_best_only = True
  • 검증 데이터 기준 가장 좋은 모델만 저장
• callback = [checkpoint_cb] : 훈련 중 가장 좋은 모델을 자동 저장

모델이 훈련한 다음 best-model.keras에 최상의 점수를 낸 모델이 저장됨

 

베스트 모델을 읽어서 예측하기

model = keras.models.load_model('best-model.keras')
loss, acc = model.evaluate(val_scaled, val_target)
print(f'검증 데이터 손실: {loss:.4f}')
print(f'검증 데이터 정확도: {acc:.4f}')

---

조기종료(Early Stopping)

- 검증 점수가 상승하기 시작하면 과대적합이 더 커지므로 더 이상 훈련을 계속할 필요가 없음

>> 과대적합이 시작되기 전에 훈련을 미리 중지하는 것

model = model_fn(keras.layers.Dropout(0.3))
model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy',
              metrics = ['accuracy'])

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-model.keras', save_best_only = True)
# save_best_only = True : 가장 높은 점수를 만드는 모델 저장

early_stopping_cb = keras.callbacks.EarlyStopping(patience = 2, restore_best_weights = True)
# rstore_best_weights = True : 최상의 가중치 값으로 다시 복원

model.fit(train_scaled, train_target, epochs = 20, verbose = 0,
          validation_data = (val_scaled, val_target), 
          callbacks = [checkpoint_cb, early_stopping_cb])

• partience = 2 : 검증 성능이 개선되지 않아도 기다리는 횟수

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

조기종료 기법을 사용하면 에포크 횟수를 늘려도 괜찮음

ModelCheckpoint 콜백을 함께 사용해서 최상의 모델을 자동으로 저장함

---

합성곱 신경망(CNN, Convolutional Neural Network)

- 이미지 처리에 특화된 딥러닝 모델, 픽셀 간의 공간적 관계를 유지하면서 특징을 추출함

• 기본 구성요소
  • 입력층 : 이미지 데이터
  • 합성곱 층 : 필터를 사용해서 트징을 추출(엣지, 모서리, 색상, 질감 등 패턴 학습)
  • 활성화 함수 : 비선형성을 추가해서 복잡한 패턴 학습이 가능
  • 풀링 층 : 이미지 크기를 줄여 연산량을 감소, 중요한 특징만 유지
  • 완전 연결층 : 추출된 특징을 기반으로 최종 분류(softmax 함수를 사용해서 확률 값 출력)
  • 출력층 : 최종 예측 결과

# 합성곱 : 입력 데이터 전체에 가중치를 적용하는 것이 아닌 일부에만 가중치를 곱한다.
# 10개의 입력을 가진 합성곱의 뉴런은 8개의 출력을 만든다,(가중치가 3개일 경우)
# 필터 - 뉴런이 입력위를 이동하면서 출력을 만들기 때문에 뉴런을 필터라 함.

 

케라스의 합성곱 층

# 케라스의 합성곱은 keras.layers 패키지에 Conv2D 클래스로 제공함
from tensorflow import keras
keras.layers.Conv2D(10, kernel_size = (3,3), activation = 'relu')
# 10 : 필터의 개수, kernel_size : 커널의 크기, activation : 활성화 함수

 

패딩 : 입력과 특성맵의 크기를 동일하게 만들기 위해 입력 주문에 0으로 채우는 것

> 패딩 없이 합성곱을 하면 위쪽 모서리의 3은 커널 가중치 계산을 한번만 참여하는 반면

다른 원소들은 2번 이상 커널 계산에 참여.

>> 각 모서리의 중요한 정보가 특성맵에 전달되지 않을 가능성이 높음

# 케라스에서 패딩을 지정하는 방법 : pedding 속성
keras.layers.Conv2D(10, kernel_size = (3,3), activation = 'relu', padding = 'same')

# 스트라이드
# 합성곱(필터)의 이동 크기 지정
keras.layers.Conv2D(10, kernel_size = (3,3), activation = 'relu', padding = 'same', strides = 1)

# 풀링 : 합성곱 층에서 만든 특성맵의 가로, 세로 크기를 줄이는 역할
# 특성맵의 개수는 줄어들지 않음.
# 풀링에는 가중치가 없고 필터를 적용한 영역에서 가장 큰 값(최대풀링)을 고르거나,
# 평균(평균풀링)을 계산.
# 풀링은 합성곱층과 구분하기 위해 풀링층이라 부른다.

# 케라스에서 풀링 구현. strides나 padding 매개변수 제공
keras.layers.MaxPooling2D(2)    # 최대풀링. 매개변수(2) : 풀링의 크기 지정
# 평균 풀링 클래스 : AveragePooling2D

 

합성곱 신경망을 이용한 이미지 분류

# MNIST 데이터 호출
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()
# 흑백이미지의 경우 채널 차원이 없는 2차원 배열이지만, Conv2D층을 사용하기 위해 마지막에 채널 차원을 추가해야 한다.
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)

• train_input.reshape(-1, 28, 28, 1) : Conv2D층을 사용하기 위해 2D 이미지를 4D 텐서로 바꿔줌

합성곱 신경망 만들기

# Sequential 클래스에 합성곱층 Conv2D 추가
model = keras.Sequential()
model.add(keras.layers.Conv2D(32, kernel_size = 3, activation = 'relu', padding = 'same',
                              input_shape = (28, 28, 1)))

>> 합성곱 층은 32개의 필터 사용, 커널의 크기(3, 3), relu 활성화 함수, 세임패딩 사용

# 풀링층 추가하기
model.add(keras.layers.MaxPooling2D(2))

패션 MNIST 입력 이미지(28, 28), 세임패딩을 적용해서 합성곱 층의 출력은 입력층과 동일한 크기

(2,2)풀링을 적용 >> 특성맵의 절반으로 줄어서 (14, 14, 32)가 됨

 

두번째 합성곱 층, 풀링 층 추가하기

# 필터의 갯수를 64개로 늘림.
model.add(keras.layers.Conv2D(64, kernel_size = 3, activation = 'relu', padding = 'same'))
model.add(keras.layers.MaxPooling2D(2))

세임패딩 사용 > 14 x 14의 크기, 필터는 64 >>> (14, 14, 64)

풀링 층을 통과한 최종 맵은 (7, 7, 64)의 결과(특성맵)가 나옴.

 

2차원 특성맵을 일렬로 펼치기

# Flatten, Dense, Dense, 출력층으로 구성
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'))

• Flatten : 2D 또는 3D 형태의 데이터를 1D로 평탄화
  
  • 합성곱층(Conv2D)과 풀링층(maxPooling2D)에서 나온 3D 텐서를 1D 벡터로 변환해서 완전 연결층(Densc Layer)로 전달
• model.add(keras.layers.Dense(100, activation='relu'))
  
  • 100개의 뉴런을 가지는 완전 연결층
  • Relu 활성화 함수 사용
• model.add(keras.layers.Dropout(0.4))
  
  • 훈련 중 40%의 뉴런을 무작위로 끄는 기법 적용
• model.add(keras.layers.Dense(10, activation='softmax'))
  
  • 출력층 | 10개의 뉴런을 가지는 완전 연결층
  • 확률을 출력하는 softmax 활성화 함수 사용

 

층의 구성을 그림으로 표현해주는 geras.utils 패키지 내에 plot_module() 함수로 그리기

# 1. pip install pydot
# 2. Graphiz 설치 : https://graphviz.org/download/ -> graphviz-10.0.1 (64-bit) EXE installer [sha256]
# 3. conda install graphviz
# 4. pip install plot_model

• pip install pydot
• Graphiz 설치 : https://graphviz.org/download/ -> graphviz-10.0.1 (64-bit) EXE installer [sha256]
• conda install graphviz
• pip install plot_model

# layer 그리기
keras.utils.plot_model(model, show_shapes = True)
# show_shapes = True : 입출력 크기 표시

 

모델 컴파일 및 훈련

model.compile(optimizer = 'adam', loss = 'sparse_categorical_crossentropy',
              metrics = ['accuracy'])

checkpoint_cb = keras.callbacks.ModelCheckpoint('best-cnn-model.keras', save_best_only = True)

early_stopping_cb = keras.callbacks.EarlyStopping(patience = 2, restore_best_weights = True)

history = model.fit(train_scaled, train_target, epochs = 20, validation_data = (val_scaled, val_target),
                    callbacks = [checkpoint_cb, early_stopping_cb])

import matplotlib.pyplot as plt
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend(['train', 'val'])
plt.show()

검증 세트에 대한 손실이 점차 감소하다가 정체되기 시작하고, 훈련 세트에 대한 손실은 낮아짐

>> 4번째 에포크를 최적의 반복 횟수로 생각할 수 있음

loss, acc = model.evaluate(val_scaled, val_target)
print(f'검증 데이터 손실: {loss:.4f}')
print(f'검증 데이터 정확도: {acc:.4f}')

 

검증 데이터에서 샘플 이미지 확인

plt.imshow(val_scaled[0].reshape(28, 28), cmap = 'gray_r')
plt.show()

# predict() 함수를 이용해 샘플 데이터 예측
# predict() 함수는 10개 클래스에 대한 예측확률 결과로 출력
preds = model.predict(val_scaled[0:1])
print(preds)

plt.bar(range(1,11), preds[0])
plt.xlabel('class')
plt.ylabel('prob.')
plt.show()

 

# 레이블을 리스트로 저장
classes = ['티셔츠', '바지', '스웨터', '드레스', '코트', '샌달', '셔츠', '스니커즈', '가방', '앨글부츠']
print(classes[np.argmax(preds)])

샘플을 가방으로 예측

 

테스트 세트의 성능 확인

test_scaled = test_input.reshape(-1, 28, 28, 1) / 255.0
loss, acc = model.evaluate(test_scaled, test_target)
print(f'테스트 데이터 손실: {loss:.4f}')
print(f'테스트 데이터 정확도: {acc:.4f}')

>>> 아이템 분류시 90%의 성능을 기대할 수 있음.

---

합성곱 신경망의 시각화

 

1. 앞에서 만든 체크포인트 파일 읽기

from tensorflow import keras
model = keras.models.load_model('best-cnn-model.keras')
model.layers

# 첫번째 합성곱 층의 shape 출력
conv = model.layers[0]
print(conv.weights[0].shape, conv.weights[1].shape)

# 첫번째 layer의 가중치 평균, 표준편차
conv_weights = conv.weights[0].numpy()
print('가중치 평균:', conv_weights.mean())
print('가중치 표준편차:', conv_weights.std())

import matplotlib.pyplot as plt
plt.hist(conv_weights.reshape(-1, 1))
plt.xlabel('weight')
plt.ylabel('count')
plt.show()

# 각 필터의 가중치 이미지를 출력
fix, axs = plt.subplots(2, 16, figsize = (15,2))

for i in range(2):
    for j in range(16):
        # vmin, vmax는 출력할 값의 범위를 한정.
        axs[i, j].imshow(conv_weights[:, :, 0, i * 16 + j], vmin = -0.5, vmax = 0.5)
        axs[i, j].axis('off')
        
plt.show()

---

신경망 모델 훈련과 최적화 과정 마무리

• 1. 검증 손실과 과대적합
  •  검증 손실 : 모델 훈련 중 검증 데이터에서 손실이 커지면 과대적합이 발생
• 2. 옵티마이저 하이퍼파라미터 조정 후 과대적합 완화
  • Adam 옵티마이저와 같은 알고리즘을 사용하면 학습률을 자동으로 조정하면서 더 빠르고 효율적인 학습을 할 수 있음
• 3. 드롭아웃 : 훈련 중 일부 뉴런을 무작위로 비활성화하여 모델이 특정 뉴런에 의존하지 않게 함
• 4. 모델 저장과 복원 : model.save()를 사용해 모델을 저장하고, keras.models.load_model()을 사용하여 나중에 불러와서 예측을 수행할 수 있다.
• 5. 콜백 : 훈련 중 모델의 성능을 모니터링하고, 특정 조건에 맞춰 자동으로 특정 작업을 수행하는 기능
  • ModelCheckpoint: 모델의 성능이 개선될 때마다 모델을 저장하는 콜백
  • EarlyStopping: 검증 성능이 더 이상 개선되지 않으면 훈련을 중단하는 콜백. 이를 통해 불필요한 훈련을 피하고 과대적합을 방지할 수 있다
• 6. 베스트 모델을 읽어 예측
  • ModelCheckpoint 콜백을 사용하여 훈련 중 가장 성능이 좋은 모델을 저장한 후, 이 모델을 불러와 예측을 수행할 수 있다
  • 모델을 불러올 때 restore_best_weights=True를 설정하면, 훈련 중 가장 성능이 좋았던 가중치를 복원할 수 있다
• 7. 조기 종료 : 검증 성능이 더 이상 개선되지 않으면 훈련을 일찍 종료하는 기법
  • patience를 설정하여 몇 번의 에포크까지 개선이 없으면 훈련을 멈추도록 할 수 있다
• 8. 합성곱 신경망 : 합성곱층(Conv2D), 풀링층(MaxPooling2D), 완전 연결층(Dense)을 포함하여 이미지에서 중요한 특징을 추출하고, 이를 바탕으로 분류를 수행
• 9. 케라스의 합성곱 층(Conv2D) : 각 필터는 이미지에서 특정 패턴을 감지하며, 학습을 통해 필터의 가중치가 조정
• 10. 합성곱 신경망을 이용한 이미지 분류 : 모델은 이미지를 작은 지역으로 분할하여 각 지역에서 중요한 정보를 학습하고, 이를 통해 전체 이미지를 분류한다

---

• keras.Sequential() : 신경망을 층들이 순차적으로 쌓인 구조로 정의할 수 있는 클래스
• add() : Sequential 모델에 층을 추가하는 메서드 > 층을 추가할 때마다 모델에 순차적으로 레이어가 쌓임
  • 모델에 다양한 층(예: Conv2D, MaxPooling2D, Dense, Dropout 등)을 추가
• Conv2D : 합성곱 층을 정의하는 클래스
  • 하이퍼파라미터
    • filters : 필터 개수, 출력 공간의 차원 수
    • kernel_size : 커널(필터)크기
    • activation : 활성화 함수 선택
    • padding : 패딩 방식(same은 출력과 입력의 크기가 동일하게 유지되도록 패딩을 추가함)
• MaxPolling2D : 최대 풀링 연산을 수행하는 층 > 특성맵의 크기를 줄이고, 연산량을 감소시키고, 중요한 정보를 유지하는데 사용
  • pool_size : 풀링 영역의 크기(기본적으로 (2, 2)로 설정하면 2x2 영역을 기준으로 풀링을 수행)
• Dense : 완전 연결층을 추가하는 클래스
  • units : 이 층의 출력 공간 차원 수(100은 100개의 뉴런을 가진 층을 의미)
  • activation: 활성화 함수(relu는 ReLU 활성화 함수, softmax는 다중 클래스 분류에서 사용되는 활성화 함수)
• Dropout() : 훈련 중 일부 뉴런을 무작위로 제거해 과적합을 방지하는 방법
  • (비율) : 0.4는 훈련 시 40%의 뉴런을 무작위로 제거
• compile() : 모델을 훈련하기 전에 사용하는 메서드로, 손실 함수와 옵티마이저, 평가 메트릭스를 설정
• ModelCheckpoint : 훈련 중 가장 성능이 좋은 모델을 저장하는 콜백
  • save_best_only=True로 설정하면 가장 좋은 성능을 낸 모델만 저장
• EarlyStopping : 검증 손실이 개선되지 않으면 훈련을 중단하는 콜백
  • restore_best_weights=True를 설정하면 훈련을 중단하기 전 가장 좋은 가중치를 복원