목차
1. 신경망모델에 계층(layer) 추가하는 방법
2. 성능 향상 방법
3. 옵티마이저(Optimizer)
- SGD(확률적 경사하강법), Adagrad, RMSProp, Adam
- 학습률
- 모멘텀
fashion_mnist 데이터로 독립변수와 종속변수 읽어들이기
라이브러리
import tensorflow as tf
from tensorflow import keras
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
"""실행 결과를 동일하게 하기 위한 처리(완전 동일하지 않을 수도 있음)"""
tf.keras.utils.set_random_seed(42)
"""연산 고정"""
tf.config.experimental.enable_op_determinism()
데이터 수집
(train_input, train_target), (test_input, test_target) = keras.datasets.fashion_mnist.load_data()
print(train_input.shape , train_target.shape)
print(test_input.shape , test_target.shape)
출력 : (60000, 28, 28) (60000,)
(10000, 28, 28) (10000,)
정규화
정규화
train_scaled_255 = train_input / 255.0
test_scaled_255 = test_input / 255.0
train_scaled_255.shape, test_scaled_255.shape
출력 : ((60000, 28, 28), (10000, 28, 28))
데이터 전처리(2차원 데이터로 변환하기)
train_scaled_2d = train_scaled_255.reshape(-1, 28*28)
test_scaled_2d = test_scaled_255.reshape(-1, 28*28)
print(train_scaled_2d.shape, test_scaled_2d.shape)
출력 : (60000, 784) (10000, 784)
훈련:검증(8:2)로 분류하기
훈련 및 검증 데이터로 분류하기 (8:2)
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled_2d, train_target,
test_size=0.2,
random_state=42)
print(train_scaled.shape, train_target.shape)
print(val_scaled.shape, val_target.shape)
print(test_scaled_2d.shape, test_target.shape)
출력 : (48000, 784) (48000,)
(12000, 784) (12000,)
(10000, 784) (10000,)
계층 추가하기
신경망모델에 계층(layer) 추가하는 방법(3가지)
1. 층을 먼저 만들고, 신경망 모델 생성 시 추가하기
2. 신경망모델 생성 시 계층(layer)을 함께 추가
3. 신경망 모델을 먼저 생성 후, 계층 추가하기
[1번 방법] 층을 먼저 만들고, 신경망 모델 생성 시 추가하기
입력계층(Input Layer) 생성하기
dense1 = keras.layers.Dense(
### 출력 개수(units은 생략가능)
100,
activation="sigmoid",
### 입력 개수
input_shape=(784, ))
dense1
출력 : <keras.layers.core.dense.Dense at 0x27234b85df0>
출력계층(Output Layer) 생성하기
### 다중분류는 softmax 활성화 함수 사용해야함.
### 10개를 출력해야함 // 100개->10개로 확률로 손실 적은 것으로 출력시켜줌.
dense2 = keras.layers.Dense(10, activation="softmax")
dense2
출력 : <keras.layers.core.dense.Dense at 0x27234b85a90>
신경망 모델 생성하기
### 껍데기 모델에 계층 추가함, 보통 파이썬에서 여러 개 넣을때 리스트 형태로 넣으면 됨
model = keras.Sequential([dense1, dense2])
model
출력 : <keras.engine.sequential.Sequential at 0x27234b85d60>
모델 계층 확인하기
model.summary()
출력 :
[2번 방법] 신경망모델 생성 시 계층(layer)을 함께 추가
모델 생성 및 계층 추가하기
model = keras.Sequential(
[keras.layers.Dense(
100,
activation="sigmoid",
input_shape=(784, ),
### name : 계층 이름 설정
name="Input-Layer"),
keras.layers.Dense(10, activation="softmax", name="Output-Layer")
],
name = "Model-2")
model
출력 : <keras.engine.sequential.Sequential at 0x27234b8c970>
모델 계층 확인하기
⭐나중에 꼭 캡처해놓기⭐
model.summary()
출력 :
[3번 방법] 신경망 모델을 먼저 생성 후, 계층 추가하기
신경망 모델 생성하기
⚡신경망 모델 생성하기
- 일반적으로 사용되는 방식(빈 껍데기 만들고 계층 추가하기)
- 위의 1, 2 방법으로 수행 후, 계층을 추가할 필요성이 있을 경우에도 사용됨 ( add 사용 )
model = keras.Sequential()
model
출력 : <keras.engine.sequential.Sequential at 0x27234b8c340>
계층 생성 및 모델에 추가하기
model.add(
keras.layers.Dense(100, activation="sigmoid", input_shape=(784, ), name="Input-Layer")
)
model.add(
keras.layers.Dense(10, activation="softmax", name = "Output-Layer")
)
model
출력 : <keras.engine.sequential.Sequential at 0x27234b8c340>
모델 계층 확인하기
⭐나중에 꼭 캡처해놓기⭐
model.summary()
출력 :
모델 설정하기(compile)
"""손실함수는 다중분류 사용"""
model.compile(
loss = "sparse_categorical_crossentropy",
metrics = "accuracy"
)
출력 :
모델 훈련하기(fit)
"""반복횟수 10번 → 100번(하이퍼파라메터 튜닝) 추가"""
model.fit(train_scaled, train_target, epochs=100)
출력 :
성능 평가하기(검증)
"""손실율과 정확도 출력하기"""
score = model.evaluate(val_scaled, val_target)
print(f"손실율 : {score[0]}, 정확도 : {score[1]}")
출력 : 손실율 : 0.5846814513206482, 정확도 : 0.8820833563804626
해석🪄 : 정확도를 보았을때 0.9정도가 정확도가 높다라 한다.
과대,과소,정상 중 정상인 편 검증 정확도 보다 훈련 정확도가 높으므로
성능 향상시키기
<성능 향상 방법>
1. 데이터 증가 시키기
2. 하이퍼파라메터 튜닝
→ 반복횟수 증가
→ 계층 추가 또는 제거(일반적으로 추가)
→ 이외 하이퍼파라메터들...
3. 옵티마이저
[1번 방법] 반복횟수 증가
훈련 반복횟수 증가시키기(50회 → 100회)
"""반복횟수 10번 → 100번(하이퍼파라메터 튜닝) 추가"""
model.fit(train_scaled, train_target, epochs=100)
출력 :
성능 평가하기(검증)
"""손실율과 정확도 출력하기"""
score = model.evaluate(val_scaled, val_target)
print(f"손실율 : {score[0]}, 정확도 : {score[1]}")
출력 : 손실율 : 0.5846814513206482, 정확도 : 0.8820833563804626
[2번 방법] 성능향상 - 은닉 계층(Hidden Layer) 추가
모델 생성
model = keras.Sequential()
model
출력 : <keras.engine.sequential.Sequential at 0x2724e7f4670>
입력 계층 추가하기
- 전처리 계층으로 추가
⭐Flatten()⭐
: 차원축소 전처리 계층 (1차원으로 축소)
: 훈련에 영향을 미치지는 않음 ⭐⭐
: 일반적으로 입력계층 다음에 추가하거나, 입력계층으로 사용되기도 함
: 이미지 데이터 처리시에 주로 사용됨
model.add(
keras.layers.Flatten(input_shape=(28, 28))
)
중간계층 = 은닉계층(hidden layer) 생성하기
- Dense()로 만들어지는 계층은 모델 성능에 영향을 미침 ⭐⭐
model.add(
keras.layers.Dense(100, activation = "relu")
)
출력 계층(output layer) 생성하기
- Dense()로 만들어지는 계층은 모델 성능에 영향을 미침 ⭐⭐
model.add(
keras.layers.Dense(10, activation="softmax")
)
모델에 추가된 계층 모두 확인하기
model.summary()
모델 설정하기(compile)
model.compile(
loss = "sparse_categorical_crossentropy",
metrics = "accuracy"
)
※ flatten 계층은 1차원이므로 훈련이 안됨.
왜? 훈련모델은 2차원데이터로 되어있으므로
그래서 깨끗한 데이터 다시 가져와야함(2차원으로 변환 하지 않기!)
차원축소하지 않은 정규화된 데이터로 다시 생성
⚡ 깨끗한 데이터 다시 가져와야함
- 훈련모델은 2차원데이터로 되어있는데 flatten 계층은 1차원이므로 훈련이 안됨
- 따라서 2차원 변환하지 않은 데이터 가져오기
(train_input, train_target), (test_input, test_target) = keras.datasets.fashion_mnist.load_data()
print(train_input.shape , train_target.shape)
print(test_input.shape , test_target.shape)
출력 : (60000, 28, 28) (60000,)
(10000, 28, 28) (10000,)
train_scaled_255 = train_input / 255.0
test_scaled_255 = test_input / 255.0
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled_255, train_target,
test_size=0.2,
random_state=42)
print(train_scaled.shape, train_target.shape)
print(val_scaled.shape, val_target.shape)
print(test_scaled_255.shape, test_target.shape)
출력 :
(48000, 28, 28) (48000,)
(12000, 28, 28) (12000,)
(10000, 28, 28) (10000,)
모델 훈련시키기
model.fit(train_scaled, train_target, epochs=100)
출력 :
성능평가 - 검증하기
score = model.evaluate(val_scaled, val_target)
score
출력 :
375/375 [==============================] - 0s 535us/step - loss: 1.1827 - accuracy: 0.8741
[1.1827137470245361, 0.8740833401679993]
옵티마이저
<성능 향상 방법>
1. 데이터 증가 시키기
2. 하이퍼파라메터 튜닝
→ 반복횟수 증가
→ 계층 추가 또는 제거(일반적으로 추가)
→ 이외 하이퍼파라메터들...
3. 옵티마이저
<옵티마이저(Optimizer)>
- 옵티마이저 설정 위치 : compile() 시에 설정함
- 손실을 줄여나가기 위한 방법을 설정함
- 손실을 줄여나가는 방법을 보통 "경사하강법" 이라고 칭합니다.
- "경사하강법"을 이용한 여러가지 방법들 중 하나를 선택하는 것이 옵티마이저 선택입니다.
- 옵티마이저 종류 : SGD(확률적 경사하강법), Adagrad, RMSProp, Adam 이 있음
* SGD(확률적경사하강법)
- 현재 위치에서 기울어진 방향을 찾을 때
→ 지그재그 모양으로 탐색해 나가는 방법
* Adagrad
- 학습율을 적절하게 설정하기 위해 학습율 감소라는 기술을 사용
- 학습 진행 중에 학습율을 줄여가는 방법을 사용
- 처음에는 학습율(보폭)을 크게 학습하다가, 점점 작게 학습한다는 의미
* RMSProp
- Adagrad의 단점을 보완한 방법
- Adagrad는 학습량을 점점 작게 학습하기 때문에 학습량이 0이 되어 갱신되지 않는(학습되지 않는) 시점이 발생할 수 있는 단점이 있음
- 이러한 단점을 보완하여 과거의 기울기 값을 반영하는 방식 사용
- 먼 과거의 기울기(경사) 값은 조금 반영하고, 최근 기울기(경사)를 많이 반영
- Optimizer의 기본값(default)로 사용됨
* Adam
- 공이 굴러가듯이 모멘텀(momentum → 관성)과 Adagrad를 융합한 방법
- 자주 사용되는 기법으로, 좋은 결과를 얻을 수 있는 방법으로 유명함
** 모멘텀 : 관성과 가속도를 적용하여 이동하던 방향으로 좀 더 유연하게 작동함
- 메모리 사용이 많은 단점이 있음(과거 데이터를 저장해 놓음)
- 가장 많이 사용하는 방법
옵티마이저 - compile
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer="sgd",
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
옵티마이저 - fit
model.fit(train_scaled, train_target, epochs=10)
옵티마이저 - evaluate
score = model.evaluate(val_scaled, val_target)
score
출력 :
375/375 [==============================] - 0s 574us/step - loss: 1.0868 - accuracy: 0.8797
[1.086826205253601, 0.8796666860580444]
옵티마이저 - 학습률
<옵티마이저에 학습률 적용하기>
* 학습률을 적용하는 방법
- 사용되는 4개의 옵티마이저를 객체로 생성하여 learning_rate(학습률) 값을 설정할 수 있음
- 학습률 : 보폭 이라고 생각하시면 됩니다.
- 학습률이 작을 수록 보폭이 작다고 보시면 됩니다.
- 가장 손실이 작은 위치를 찾아서 움직이게 됩니다.
- 이때 가장 손실이 작은 위치는 모델이 스스로 찾아서 움직이게 됩니다.(사람 관여하지 않음)
- 학습률의 기본값은 = 0.01을 사용 (사용값의 범위 0.1 ~ 0.0001 정도)
* 과적합을 해소하기 위한 튜닝방법으로 사용됨
- 과대적합이 일어난 경우 : 학습률을 크게
- 과소적합이 일어난 경우 : 학습률을 작게
- 과대/과소를 떠나서, 직접 값의 범위를 적용하여 튜닝을 수행한 후 가장 일반화 시점의 학습률 값을 찾는 것이 중요함
옵티마이저에 학습률 적용하기
"""옵티마이저 객체 생성"""
sgd = keras.optimizers.SGD(learning_rate=0.1)
"""모델 설정(compile)"""
model.compile(
optimizer=sgd,
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
model.fit(train_scaled, train_target, epochs=50)
출력 :
score = model.evaluate(val_scaled, val_target)
score
출력 :
375/375 [==============================] - 0s 558us/step - loss: 1.0818 - accuracy: 0.8837
[1.0817798376083374, 0.8836666941642761]
옵티마이저 - 모멘텀
< 모멘텀(Momentum) >
- 과거의 방향(기울기)를 적용하여 → 관성을 적용시키는 방법
- 기본적으로 0.9 이상의 값을 적용시킴
- 보통 nesterov=True 속성과 함께 사용됨
→ nesterov=True : 모멘텀 방향보다 조금 더 앞서서 경사를 계산하는 방식(미리 체크)
- momentum 속성을 사용할 수 있는 옵티마이저 : SGD, RMSProp
모멘텀(Momentum) 직접 적용하기
### 모멘텀 정의
sgd = keras.optimizers.SGD(
momentum=0.9, nesterov=True, learning_rate=0.1)
### 모멘텀 적용(compile)
model.compile(
optimizer=sgd,
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
### 모델 훈련
model.fit(train_scaled, train_target, epochs=50)
### 성능 검증
score = model.evaluate(val_scaled, val_target)
score
출력 :
375/375 [==============================] - 0s 579us/step - loss: 0.6494 - accuracy: 0.8347
[0.6494151949882507, 0.8347499966621399]
옵티마이저 적용 실습
Adagrad
adagrad = keras.optimizers.Adagrad()
model.compile(
optimizer=adagrad,
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
""" 또는 """
model.compile(
optimizer="adagrad",
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
RMSProp
rmsprop = keras.optimizers.RMSprop()
model.compile(
optimizer=rmsprop,
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
""" 또는 """
model.compile(
optimizer="rmsprop",
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
Adam
adam = keras.optimizers.Adam()
model.compile(
optimizer=adam,
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
""" 또는 """
model.compile(
optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
신경망 모델 실습
1. 신경망 모델 생성
2. 계층 추가하기
- 1차원 전처리계층 추가
- 은닉계층 추가, 활성화함수 relu 사용, 출력크기 100개
- 최종 출력계층 추가
3. 모델 설정하기
- 옵티마이저에는 adam 사용, 학습률 0.01 사용
4. 훈련시키기
- 훈련횟수 : 50회
5. 성능평가하기
### 데이터셋 불러오기
(train_input, train_target), (test_input, test_target) = keras.datasets.fashion_mnist.load_data()
print(train_input.shape , train_target.shape)
print(test_input.shape , test_target.shape)
### 정규화
train_scaled_255 = train_input / 255.0
test_scaled_255 = test_input / 255.0
### 훈련 : 검증하기
train_scaled, val_scaled, train_target, val_target = train_test_split(train_scaled_255, train_target,
test_size=0.2,
random_state=42)
print(train_scaled.shape, train_target.shape)
print(val_scaled.shape, val_target.shape)
print(test_scaled_255.shape, test_target.shape)
### 신경망 모델 생성
model = keras.Sequential()
model
### 계층 추가하기
model.add(
keras.layers.Flatten(
input_shape=(28,28)
)
)
model.add(
keras.layers.Dense(
100, activation = "relu"
)
)
model.add(
keras.layers.Dense(
10, activation= "softmax"
)
)
### 계층 확인하기
model.summary()
### 모델 설정하기
adam = keras.optimizers.Adam(learning_rate=0.01)
model.compile(
optimizer=adam,
loss = "sparse_categorical_crossentropy",
metrics= "accuracy"
)
### 훈련시키기
model.fit(train_scaled, train_target, epochs=50)
### 성능평가하기
score = model.evaluate(val_scaled, val_target)
score
신경망 모델 실습 - 함수화
<실습>
- 옵티마이저에 적용할 학습기법(sgd, adagrad, rmsprop, adam) 중에
- 가장 좋은 성능을 나타내는 옵티마이저 학습기법 확인하기
- 훈련횟수 : 50회
- 학습률은 기본값 사용
- 은닉계층 relu 사용
- 성능 평가결과가 가장 높을 때의 학습기법과 손실율, 정확도를 출력해주세요~
옵티마이저 학습방법 및 반복횟수를 받아서 처리할 함수 정의
def getBestEval(opt, epoch):
"""모델 생성"""
model= keras.Sequential()
"""레이어 계층 생성 및 모델에 추가하기"""
model.add(keras.layers.Flatten(input_shape = (28, 28)))
model.add(keras.layers.Dense(100, activation="relu"))
model.add(keras.layers.Dense(10, activation="softmax"))
"""모델 설정하기"""
model.compile(optimizer = opt,
loss = "sparse_categorical_crossentropy",
metrics= "accuracy")
"""모델 훈련시키기"""
model.fit(train_scaled, train_target, epochs=epoch)
"""모델 성능 평가"""
score = model.evaluate(val_scaled, val_target)
"""성능 결과 반환하기"""
return score
함수 호출하기
""" 옵티마이저를 리스트로 정의하기 """
optimizers = ["sgd", "adagrad", "rmsprop", "adam"]
"""최고 정확도를 담을 변수 정의"""
best_acc = 0.0
"""최고 정확도일 때의 학습방법을 담을 변수 정의"""
best_acc_opt = ""
"""최저 손실율을 담을 변수 정의"""
best_loss = 1.0
"""최저 손실율일 때의 학습방법을 담을 변수 정의"""
best_loss_opt = ""
"""옵티마이저의 학습방법을 반복하여 성능 확인하기"""
for opt in optimizers:
print(f"-------------------------{opt}---------------------------")
"""함수 호출"""
epoch = 50
rs_score = getBestEval(opt, epoch)
"""가장 높은 정확도와 이때 학습방법 저장하기"""
if best_acc < rs_score[1]:
best_acc = rs_score[1]
best_acc_opt = opt
"""가장 낮은 손실율와 이때 학습방법 저장하기"""
if best_loss > rs_score[0]:
best_loss = rs_score[0]
best_loss_opt = opt
print()
print("전체 실행 종료 >>>>>>>>>>")
print(f"최고정확도 옵티마이저 : {best_acc_opt} / 최고정확도 : {best_acc} ")
print(f"최저손실율 옵티마이저 : {best_loss_opt} / 최저손실율 : {best_loss} ")
'인공지능 > 딥러닝' 카테고리의 다른 글
| [딥러닝DL] DNN 회귀데이터 사용 (1) | 2024.01.05 |
|---|---|
| [딥러닝DL] 심층신경망 훈련 및 성능향상2 - 성능규제(Dropout), 모델 저장 및 불러오기, 콜백함수(ModelCheckpoint, EarlyStopping) (1) | 2024.01.05 |
| [딥러닝DL] 심층신경망(DNN) 훈련 및 성능향상 - verbose, epoch, history, 시각화 (2) | 2024.01.03 |
| [딥러닝] 인공신경망 훈련모델 맛보기 (1) | 2023.12.29 |
| [딥러닝]딥러닝 환경설정하기 + 가상환경 생성 (0) | 2023.12.29 |
