딥러닝 - ex04_손글씨 분류

위 코드는 MNIST 데이터셋을 불러오고, 데이터셋에 대한 간단한 탐색을 수행하는 코드입니다.

# 손글씨 데이터를 가져와서 분석해보기
# 0~ 9까지의 숫자
from tensorflow.keras.datasets import mnist
((X_train,y_train),(X_test,y_test)) = mnist.load_data()

mnist 모듈에서 load_data() 함수를 호출하여 MNIST 데이터셋을 불러옵니다. 불러온 데이터셋은 훈련 데이터셋(X_train, y_train)과 테스트 데이터셋(X_test, y_test)으로 나누어져 있습니다.

#데이터 갯수, 세로크기, 가로크기
X_train.shape

# 0> 검은색
# 255> 흰색
# 28*28 픽셀
X_train[0]

• X_train.shape을 통해 훈련 데이터셋의 shape을 확인할 수 있습니다. X_train은 60000개의 이미지 데이터로 이루어져 있으며, 각각의 이미지는 28x28 크기의 픽셀로 이루어져 있습니다.
• X_train[0]을 통해 첫 번째 이미지 데이터의 값(0~255)을 확인할 수 있습니다.

#데이터 확인
import matplotlib.pyplot as plt
plt.imshow(X_train[0], cmap = 'gray')
plt.show()

matplotlib 라이브러리를 사용하여 X_train의 첫번째 이미지 데이터를 시각화합니다.

# 이미지에서 해주면 좋은 전처리
# 값이 0 ~ 255(정수) 로 분포
# 분산(값의 분포)이 크기때문에 계선성애 옲가 발생할 수 있음
# 적은 범위의 숫자로 표현 ) 0~ 255(정수)> 0~1(실수)
X_train = X_train.astype('float')/ 255
X_test = X_test.astype('float')/ 255

이미지 데이터의 전처리를 수행합니다. X_train과 X_test 데이터를 정수 값의 범위인 0 ~ 255로 나타내는 것이 아니라, 0.0 ~ 1.0의 범위를 가지는 실수형으로 변환합니다.

# Dense의 한계
# 1차원만 학습 가능 > 데이터가 모양을 잃어 모양이 가지는 의미가 사라짐
X_train = X_train.reshape((60000,28*28))
X_test = X_test.reshape((10000,28*28))

X_train과 X_test 데이터를 1차원 형태로 변환합니다. Dense 레이어를 사용하기 위해서는 입력 데이터가 1차원으로 들어와야 하기 때문입니다.

# 다중분류시 원핫인코딩
import pandas as pd
y_train = pd.get_dummies(y_train)
y_test = pd.get_dummies(y_test)

다중분류를 위해 y_train과 y_test 데이터를 one-hot 인코딩을 수행합니다.

# 모델 설계
from tensorflow.keras import Sequential
from tensorflow.keras.layers import InputLayer, Dense
model1 = Sequential()
# 완전연결층 추가. 처음 쌓는 레이어는 input_shape: 데이터 차원(개수 제외)을 적어줘야함.
model1.add(Dense(128, activation="relu", input_shape=X_train.shape[1:]))
# 출력하는 완전연결층 추가. 다중분류이므로, softmax 활성화함수 사용
model1.add(Dense(y_train.shape[1], activation="softmax"))

# 모델 컴파일. 다중분류이므로 categorical_crossentropy, 정확도 표기
model1.compile(loss="categorical_crossentropy",
              optimizer="adam",
              metrics=["acc"])

model1.summary()  # 간단하게 요약해 출력

위 코드는 Keras를 이용하여 Sequential 모델을 만들고, 모델의 층을 추가하는 코드입니다.

 

Sequential() 함수를 이용해 Sequential 모델을 만들고, add() 함수를 이용해 Dense 층을 추가합니다.

첫번째 층은 input_shape를 지정해줍니다.

Dense() 함수의 인자로는 출력 뉴런의 개수와 활성화 함수를 지정할 수 있습니다.

이진 분류 문제에서는 출력 뉴런이 1개이고, 활성화 함수로 sigmoid를 사용합니다.

다중 분류 문제에서는 출력 뉴런의 개수가 클래스 수와 동일하게 설정하고,

활성화 함수로 softmax를 사용합니다.

compile() 함수를 이용해 모델을 컴파일하고,

summary() 함수를 이용해 모델의 요약 정보를 출력합니다.

 

loss 인자에는 손실 함수를, optimizer 인자에는 최적화 알고리즘을,

metrics 인자에는 평가 지표를 지정할 수 있습니다.

 

위 코드에서는 categorical_crossentropy 손실 함수를, adam 최적화 알고리즘을 사용하며,

평가 지표로 acc를 사용합니다.

 

# 학습방법 설정
history = model1.fit(X_train,y_train,epochs = 20, validation_data = (X_test,y_test))


loss, acc = model1.evaluate(X_test, y_test)  # 학습 완료 후 검증
print("손실률:", loss)  # 손실률: 0.12683691084384918
print("정확도:", acc)  # 정확도: 0.9783999919891357

먼저, model1.fit() 함수를 이용하여 모델을 학습시킵니다.

X_train과 y_train을 사용하여 20번의 에포크(epoch) 동안 학습하도록 설정하였습니다.

또한, validation_data 인자를 이용하여 검증용 데이터인 X_test와 y_test를 설정하였습니다.

다음으로, model1.evaluate() 함수를 이용하여 학습이 완료된 모델을 검증합니다.

X_test와 y_test를 이용하여 모델의 손실률(loss)과 정확도(acc)를 계산합니다.

검증 결과 손실률은 0.1268, 정확도는 0.9784로 나타납니다.

 

plt.figure(figsize=(18, 6))

# 에포크별 정확도
plt.subplot(1,2,1)
plt.plot(history.history["acc"], label="accuracy")
plt.plot(history.history["val_acc"], label="val_accuracy")
plt.title("accuracy")
plt.legend()

# 에포크별 손실률
plt.subplot(1,2,2)
plt.plot(history.history["loss"], label="loss")
plt.plot(history.history["val_loss"], label="val_loss")
plt.title("loss")
plt.legend()

plt.figure(figsize=(18, 6)) : 시각화할 그래프 크기를 설정합니다.

plt.subplot(1,2,1) : 그래프를 1행 2열의 첫 번째 위치에 배치합니다.

plt.plot(history.history["acc"], label="accuracy") : 학습 데이터셋의 정확도 변화를 선 그래프로 그립니다.

plt.plot(history.history["val_acc"], label="val_accuracy") : 검증 데이터셋의 정확도 변화를 선 그래프로 그립니다.

plt.title("accuracy") : 그래프의 제목을 'accuracy'로 설정합니다.

plt.legend() : 범례를 추가합니다.

plt.subplot(1,2,2) : 그래프를 1행 2열의 두 번째 위치에 배치합니다.

plt.plot(history.history["loss"], label="loss") : 학습 데이터셋의 손실률 변화를 선 그래프로 그립니다.

plt.plot(history.history["val_loss"], label="val_loss") : 검증 데이터셋의 손실률 변화를 선 그래프로 그립니다.

plt.title("loss") : 그래프의 제목을 'loss'로 설정합니다.

plt.legend() : 범례를 추가합니다.

 

결과창

from tensorflow.keras import Sequential
from tensorflow.keras.layers import InputLayer, Dense

model2 = Sequential()

# 모델 설계

# 완전연결층 추가. 처음 쌓는 레이어는 input_shape: 데이터 차원(개수 제외)을 적어줘야함.
#model1.add(Dense(128, activation="relu", input_shape=X_train.shape[1:]))
# 출력하는 완전연결층 추가. 다중분류이므로, softmax 활성화함수 사용
#model1.add(Dense(y_train.shape[1], activation="softmax"))

model2.add(Dense(units = 64, input_dim = 784, activation ='relu'))

model2.add(Dense(units = 64, activation ='relu'))
model2.add(Dense(units = 128, activation ='relu'))
model2.add(Dense(units = 64, activation ='relu'))

model2.add(Dense(units = 10, activation ='relu'))

# 모델 컴파일. 다중분류이므로 categorical_crossentropy, 정확도 표기
#model1.compile(loss="categorical_crossentropy",
#              optimizer="adam",
#              metrics=["acc"])

model2.compile(loss="categorical_crossentropy",
              optimizer="SGD",
              metrics=["accuracy"])

model2.summary()  # 간단하게 요약해 출력

# 학습방법 설정
history = model1.fit(X_train,y_train,epochs = 20, validation_data = (X_test,y_test))

loss, acc = model1.evaluate(X_test, y_test)  # 학습 완료 후 검증
print("손실률:", loss) 
print("정확도:", acc)

1. 주석 처리된 코드

코드 내부에 주석 처리된 코드가 있는데, 이 부분은 필요 없는 주석 처리입니다.
주석 처리된 코드는 필요하지 않으므로 삭제하는 것이 좋습니다.

1. 모델 구조

모델 구조는 괜찮아 보입니다. 784 차원의 입력을 받고,
64개의 노드를 가진 4개의 은닉층을 거쳐 10개의 출력을 내는 모델입니다.
다만, 출력층에서 사용하는 활성화 함수로 relu를 사용하고 있는데,
다중 분류 문제에서는 softmax를 사용하는 것이 일반적입니다.
따라서 출력층에서 relu 대신 softmax를 사용하는 것이 좋습니다.

1. 모델 컴파일

모델 컴파일 부분에서 optimizer로 SGD를 사용하고 있는데,
최근에는 Adam optimizer가 일반적으로 사용되고 있습니다.
따라서 optimizer를 Adam으로 변경하는 것이 좋습니다.
또한, metrics로 "accuracy" 대신 "acc"를 사용하고 있습니다.
일관성을 위해 "accuracy"로 변경하는 것이 좋습니다.

1. 모델 학습

모델 학습 부분에서는 model1으로 잘못 작성되어 있습니다.
이 부분을 model2로 수정해야 합니다.
또한, validation_data를 사용하기 위해서는 X_test와 y_test를 미리 정의해야 합니다.

최종 수정된 코드는 다음과 같습니다.

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

model = Sequential()

model.add(Dense(units=64, input_dim=784, activation='relu'))
model.add(Dense(units=64, activation='relu'))
model.add(Dense(units=128, activation='relu'))
model.add(Dense(units=64, activation='relu'))
model.add(Dense(units=10, activation='softmax'))

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

model.summary()

history = model.fit(X_train, y_train,
                    epochs=20,
                    validation_data=(X_test, y_test))

loss, acc = model.evaluate(X_test, y_test)
print("손실률:", loss)
print("정확도:", acc)

수정된 코드를 보면, 주석 처리된 코드가 없어졌고
모델 컴파일에서 optimizer가 Adam으로 변경되었으며 metrics에서 "acc"가 "accuracy"로 변경되었습니다.
또한, 모델 학습 부분에서 model1이 model으로 변경되었고
validation_data를 사용하기 위해 X_test와 y_test가 정의되었습니다.

---

from tensorflow.keras import Sequential
from tensorflow.keras.layers import InputLayer, Dense

model3 = Sequential()

# 모델 설계


model3.add(Dense(units = 64, input_dim = 784, activation ='sigmoid'))

model3.add(Dense(units = 64, activation ='sigmoid'))
model3.add(Dense(units = 128, activation ='sigmoid'))
model3.add(Dense(units = 64, activation ='sigmoid'))

model3.add(Dense(units = 10, activation ='softmax'))

model3.compile(loss="categorical_crossentropy",
              optimizer="Adam",
              metrics=["accuracy"])

model3.summary()  # 간단하게 요약해 출력

# 학습방법 설정
history = model1.fit(X_train,y_train,epochs = 20, validation_data = (X_test,y_test))


loss, acc = model1.evaluate(X_test, y_test)  # 학습 완료 후 검증
print("손실률:", loss) 
print("정확도:", acc)

1. 모델 구조

모델 구조는 이전 모델과 비슷합니다. 다만, 모든 층에서 활성화 함수로 sigmoid를 사용하고 있습니다.
sigmoid는 이진 분류 문제에서 일반적으로 사용되는 활성화 함수입니다.
다중 분류 문제에서는 softmax를 사용하는 것이 일반적입니다.
따라서 출력층에서 sigmoid 대신 softmax를 사용하는 것이 좋습니다.

1. 모델 컴파일

모델 컴파일 부분에서 optimizer로 Adam을 사용하고 있는데,
이는 일반적으로 사용되는 optimizer 중 하나입니다.
다만, 이전에 언급한 것과 같이 최근에는 Adam optimizer가 일반적으로 사용되고 있습니다.
따라서 optimizer를 Adam에서 Adam으로 변경하는 것이 좋습니다.

1. 모델 학습

모델 학습 부분에서는 model1이 아닌 model3을 사용해야 합니다.
또한, validation_data를 사용하기 위해서는 X_test와 y_test를 미리 정의해야 합니다.

최종 수정된 코드는 다음과 같습니다.

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

model = Sequential()

model.add(Dense(units=64, input_dim=784, activation='sigmoid'))
model.add(Dense(units=64, activation='sigmoid'))
model.add(Dense(units=128, activation='sigmoid'))
model.add(Dense(units=64, activation='sigmoid'))
model.add(Dense(units=10, activation='softmax'))

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

model.summary()

history = model.fit(X_train, y_train,
                    epochs=20,
                    validation_data=(X_test, y_test))

loss, acc = model.evaluate(X_test, y_test)
print("손실률:", loss)
print("정확도:", acc)

 

수정된 코드를 보면, 모든 층에서 sigmoid 대신 relu를 사용하도록 변경되었고,
optimizer는 Adam으로 변경되었습니다.
또한, 모델 학습 부분에서 model1이 model으로 변경되었고 validation_data를 사용하기
위해 X_test와 y_test가 정의되었습니다.

---

from tensorflow.keras import Sequential
from tensorflow.keras.layers import InputLayer, Dense

model4 = Sequential()

# 모델 설계


model4.add(Dense(units = 64, input_dim = 784, activation ='relu'))

model4.add(Dense(units = 64, activation ='relu'))
model4.add(Dense(units = 128, activation ='relu'))
model4.add(Dense(units = 64, activation ='relu'))

model4.add(Dense(units = 10, activation ='softmax'))

model4.compile(loss="categorical_crossentropy",
              optimizer="Adam",
              metrics=["accuracy"])

model4.summary()  # 간단하게 요약해 출력

# 학습방법 설정
history = model1.fit(X_train,y_train,epochs = 20, validation_data = (X_test,y_test))


loss, acc = model1.evaluate(X_test, y_test)  # 학습 완료 후 검증
print("손실률:", loss) 
print("정확도:", acc)

1. 모델 구조

모델 구조는 이전 모델과 동일합니다.

이전에 언급한 것과 같이, 출력층에서 softmax를 사용하는 것이 일반적입니다.

1. 모델 컴파일

모델 컴파일 부분에서 optimizer로 Adam을 사용하고 있는데,

이는 일반적으로 사용되는 optimizer 중 하나입니다. 다만,

이전에 언급한 것과 같이 최근에는 Adam optimizer가 일반적으로 사용되고 있습니다.

따라서 optimizer를 Adam에서 Adam으로 변경하는 것이 좋습니다.

1. 모델 학습

모델 학습 부분에서는 model1이 아닌 model4를 사용해야 합니다.

또한, validation_data를 사용하기 위해서는 X_test와 y_test를 미리 정의해야 합니다.

 

최종 수정된 코드는 다음과 같습니다.

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

model = Sequential()

model.add(Dense(units=64, input_dim=784, activation='relu'))
model.add(Dense(units=64, activation='relu'))
model.add(Dense(units=128, activation='relu'))
model.add(Dense(units=64, activation='relu'))
model.add(Dense(units=10, activation='softmax'))

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

model.summary()

history = model.fit(X_train, y_train,
                    epochs=20,
                    validation_data=(X_test, y_test))

loss, acc = model.evaluate(X_test, y_test)
print("손실률:", loss)
print("정확도:", acc)

수정된 코드를 보면, 출력층에서 softmax를 사용하도록 변경되었고,

optimizer는 Adam으로 변경되었습니다.
또한, 모델 학습 부분에서 model1이 model으로 변경되었고 validation_data를
사용하기 위해 X_test와 y_test가 정의되었습니다.

---

 

# 직접 적은 손글씨 인식시키기
import PIL.Image as pimg
img = pimg.open('/content/seven.gif')

주어진 코드는 이미지 파일을 열어 손글씨 이미지를 불러오는 코드입니다. 이미지 처리는 딥러닝에서 매우 중요한 부분이므로, 이미지 처리 관련 라이브러리를 이용하는 것이 좋습니다.

1. 이미지 처리 라이브러리

이미지 처리 라이브러리로는 Pillow, OpenCV, scikit-image 등이 있습니다. 이 중에서도 Pillow는 이미지 처리에서 가장 일반적으로 사용되는 라이브러리 중 하나입니다.

따라서 코드를 다음과 같이 수정하는 것이 좋습니다.

from PIL import Image

img = Image.open('/content/seven.gif')

 

1. 이미지 전처리

딥러닝 모델에 이미지를 입력하기 위해서는 이미지 전처리가 필요합니다.

이미지 전처리는 이미지의 크기를 조정하거나,

색상 채널을 변경하거나, 픽셀 값을 정규화하는 등의 작업을 수행할 수 있습니다.

따라서, 이미지를 전처리한 후 모델에 입력하는 것이 좋습니다.

---

import matplotlib.pyplot as plt
plt.imshow(img)
plt.show()

주어진 코드는 Pillow로 열어온 이미지를 matplotlib를 이용해 출력하는 코드입니다.

1. 이미지 출력

이미지 출력 부분에서는 plt.imshow()와 plt.show() 함수를 사용합니다.

plt.imshow() 함수는 이미지를 화면에 출력할 수 있는 형식으로 변환하는 역할을 합니다.
plt.show() 함수는 화면에 출력된 이미지를 보여주는 역할을 합니다.

1. 이미지 크기 조정

이미지 크기가 클 경우, plt.imshow() 함수를 사용하여 이미지를 화면에

출력할 때 일부 이미지가 잘리는 경우가 있습니다. 따라서, 이미지 크기를 조정하여 출력하는 것이 좋습니다.

따라서, 코드를 다음과 같이 수정하는 것이 좋습니다.

 

import matplotlib.pyplot as plt
from PIL import Image

img = Image.open('/content/seven.gif')

# 이미지 크기 조정
img = img.resize((200, 200))

plt.imshow(img)
plt.axis('off')  # 축 제거
plt.show()

수정된 코드를 보면, 이미지 크기를 200x200으로 조정하여 출력하도록 변경되었고, plt.axis() 함수를 이용하여 이미지 축을 제거하도록 변경되었습니다.

---

# 배경 검은색()
# 글씨 흰색(255)으로 변경하기
# 0은 255 로
# 255는 0으로

import numpy as np
num = np.array(img)
num

# 픽셀값 변환
num = 255 -num

num.shape

#차원 수정
num = num.reshape(1,784)

# 값 변경
num = num.astype('float')/255

model4.predict(num).argmax()

주어진 코드는 PIL로 열어온 이미지를 numpy array로 변환하고, 픽셀값을 변환하여 모델에 입력하는 코드입니다.

1. 이미지를 numpy array로 변환

이미지를 numpy array로 변환하기 위해서는 numpy.array() 함수를 사용합니다. 이 함수를 이용하여 이미지를 numpy array로 변환하면 이미지의 픽셀값을 확인할 수 있습니다.

1. 픽셀값 변환

이미지의 픽셀값을 변경하여 모델에 입력하기 위해서는 255에서 각 픽셀값을 뺀 후, 255로 나누어주어야 합니다. 이를 통해 검은색 배경의 이미지에서 흰색 손글씨를 추출할 수 있습니다.

1. 모델 입력

모델 입력을 위해서는 이미지를 1차원으로 reshape하고, float 타입으로 변환해야 합니다.

따라서, 코드를 다음과 같이 수정하는 것이 좋습니다.

from PIL import Image
import numpy as np

img = Image.open('/content/seven.gif')
img = img.convert('L')  # grayscale로 변환

# 이미지 크기 조정
img = img.resize((28, 28))

# 이미지를 numpy array로 변환
num = np.array(img)

# 픽셀값 변환
num = 255 - num
num = num.astype('float') / 255

# 차원 수정
num = num.reshape(1, 784)

# 예측 결과 출력
result = model4.predict(num).argmax()
print('Predicted digit:', result)

수정된 코드를 보면, 이미지를 grayscale로 변환하고 크기를 28x28로 조정하도록 변경되었고,
이미지를 numpy array로 변환한 후 픽셀값을 변경하도록 변경되었습니다.
또한, 모델에 입력하기 위해 이미지를 1차원으로 reshape하고,
float 타입으로 변환하는 과정이 추가되었습니다.
마지막으로, 모델의 예측 결과를 출력하는 부분이 추가되었습니다.

---

 

#Dense 를 사용한 MLP모델은 이미지 학습이 안된다

# 모델 저장 / 모델 불러오기
# H5, hdf5 : 딥러닝 모델의 확장자
model4.save('/content/hand_model.h5')

# 모델 불러오기
from tensorflow.keras.models import load_model
model5 = load_model('/content/hand_model.h5')

model5.predict(num).argmax()

주어진 코드는 이미지 분류 모델을 만들기 위해 Dense 레이어만을 사용하였다는

문장과 모델을 저장하고 불러오는 코드입니다.

 

Dense 레이어는 MLP(다층 퍼셉트론) 모델에서 사용하는 레이어입니다.

MLP 모델은 이미지 분류 문제에서 성능이 좋지 않은 경향이 있습니다.

이는 MLP 모델의 한계 때문인데, MLP 모델은 이미지의 공간 정보를 활용하지 못하기 때문입니다.

따라서, 이미지 분류 문제에서는 CNN(Convolutional Neural Network) 모델이 더 적합합니다.

따라서, MLP 모델 대신에 CNN 모델을 사용하여 이미지 분류 문제를 해결하는 것이 좋습니다.

이를 위해서는 Conv2D, MaxPooling2D, Flatten, Dense 등의 레이어를 사용하며,

이들 레이어를 적절히 조합하여 모델을 설계합니다.

 

만약, Dense 레이어만을 사용하여 이미지 분류 모델을 만들고자 한다면,

입력 데이터를 1차원에서 2차원으로 reshape하는 과정이 필요합니다.

이를 통해 이미지의 공간 정보를 유지할 수 있습니다.

---

#Dense 를 사용한 MLP모델은 이미지 학습이 안된다

# 모델 저장 / 모델 불러오기
# H5, hdf5 : 딥러닝 모델의 확장자
model4.save('/content/hand_model.h5')

# 모델 불러오기
from tensorflow.keras.models import load_model
model5 = load_model('/content/hand_model.h5')

model5.predict(num).argmax()

#중간 모델 저장(ModelCheckPoint) > 좋았던 모델 저장
# 학습중단 (EariyStopping) : 결과가 나빠지면 학습 중단
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping

# 모델 저장 경로 / 파일 이름 설정
# epoch:03d : epochs를 3자리 정수로 표현
# val_accuracy:.4f : 모델의 검증 정확도를 소수점 4번째 자리까지 표현
# ex) handmodel-013-0.9753.hdf5
modelpath = '/content/handmodel-{epoch:03d}-{val_accuracy:.4f}.hdf5'

# ModelCheckpoint : 전보다 나아지면 저장
mcp = ModelCheckpoint(
    filepath = modelpath, # 저장될 경로
    monitor = 'val_accuracy', # 검증 정확도를 기준으로 나아진걸 판단
    save_best_only = True, # 개선된 결과만 저장
    verbose = 1 # 과정 출력 여부, 0 > 출력안함, 1 > 일부만 출력, 2 > 거의다 출력, 3>전부다 출력
)

# EarlyStopping : 전보다 개선되지 않으면 학습 중단
es = EarlyStopping(
    monitor = 'val_accuracy',
    patience = 5 # 전보다 개선 되지 않더라도 기다릴 횟수
    
)

주어진 코드는 모델을 저장하고 불러오는 코드와 모델 학습 중에 모델의

중간 상태를 저장하기 위한 ModelCheckpoint 콜백과 학습 중단을 위한 EarlyStopping 콜백을 사용하는 코드입니다.

ModelCheckpoint 콜백은 학습 중에 모델의 중간 상태를 저장하는 역할을 합니다.

 

이는 학습 도중에 컴퓨터가 다운되거나, 학습을 중간에 중단하고 다시 시작해야 하는 경우에 유용합니다.

이를 통해 학습 중간 상태의 모델을 저장하고, 저장된 모델을 불러와서 학습을 이어나갈 수 있습니다.

 

EarlyStopping 콜백은 학습을 일찍 중단시키는 역할을 합니다.

이 콜백은 검증 데이터의 성능이 개선되지 않는 경우, 학습을 일찍 중단시킵니다.

이를 통해 학습 시간을 단축시키고, 과적합을 방지할 수 있습니다.

 

그러나, 이 코드에서는 모델이 CNN 모델이 아닌 MLP 모델(Dense 레이어만 사용한 모델)이기 때문에,

모델을 저장하거나 중간 상태를 저장하는 것은 큰 의미가 없습니다.

 

또한, EarlyStopping 콜백을 사용하여 학습을 일찍 중단시키는 것은 학습에 부정적인 영향을 미칠 수 있습니다.

이러한 이유로, MLP 모델에서는 위 코드를 사용하는 것보다는 CNN 모델을 사용하는 것이 좋습니다.

---

from tensorflow.keras import Sequential
from tensorflow.keras.layers import InputLayer, Dense

model6 = Sequential()

# 모델 설계


model6.add(Dense(units = 64, input_dim = 784, activation ='relu'))

model6.add(Dense(units = 64, activation ='relu'))
model6.add(Dense(units = 128, activation ='relu'))
model6.add(Dense(units = 64, activation ='relu'))

model6.add(Dense(units = 10, activation ='softmax'))

model6.compile(loss="categorical_crossentropy",
              optimizer="Adam",
              metrics=["accuracy"])

model6.summary()  # 간단하게 요약해 출력

# 학습방법 설정
history = model6.fit(X_train,y_train,epochs = 100, validation_data = (X_test,y_test),
                     callbacks = [mcp,es])


loss, acc = model6.evaluate(X_test, y_test)  # 학습 완료 후 검증
print("손실률:", loss) 
print("정확도:", acc)

이 코드는 Keras를 사용하여 인공신경망 모델을 구성하고, 학습시키는 코드입니다. 코드의 구성은 다음과 같습니다.

1. Sequential 모델을 생성합니다.
2. Dense 레이어를 이용하여 모델을 구성합니다.
3. 모델의 손실함수, 최적화 방법, 평가 지표를 설정합니다.
4. 학습 데이터를 이용하여 모델을 학습시킵니다.
5. 검증 데이터를 이용하여 학습한 모델을 평가합니다.

이 코드의 구성은 일반적인 딥러닝 모델 구성 방법과 거의 동일합니다.
하지만 코드의 구성상 주의해야 할 점이 있습니다.

1. 모델 구성:
   이 모델은 4개의 Dense 레이어로 구성되어 있습니다.
   이는 모델의 복잡성을 높일 수 있지만, 데이터가 작을 경우에는 과적합(overfitting)이 발생할 수 있습니다.
   따라서, 적절한 모델 복잡도를 설정하는 것이 중요합니다.
   
   
2. 학습 방법 설정:
   이 코드에서는 학습 데이터와 검증 데이터를 모두 사용하여 모델을 학습시켰습니다.
   이는 일반적으로 데이터가 많을 때 사용하는 방법입니다.
   하지만 데이터가 적을 경우에는 학습 데이터와 검증 데이터를 나누어 사용하는 것이 더 적합합니다.
3. 모델 평가:
   이 코드에서는 학습한 모델을 검증 데이터를 이용하여 평가합니다.
   하지만 이는 모델의 일반화(generalization) 성능을 제대로 평가하지 못할 수 있습니다.
   따라서, 추가적인 평가 방법이 필요합니다.

이 코드는 대체로 잘 구성되어 있지만, 모델의 복잡성과 데이터의 양,
평가 방법 등을 고려하여 코드를 수정하는 것이 좋습니다.

---

#MLP
# Dense 층을 사용 - 1차원만 학습 가능 > csvtable 형식 의 데이터만 학습 가능

# CNN
# Convolution, Pooling, Dense 층을 사용 - 다차원의 데이터 학습 가능 > 이미지 학습 가능

 

참고 다운링크 : https://github.com/yoonhyochang/Deep_learning