1. 신경망 모델 생성 2. 계층 추가하기 - 1차원 전처리 계층 추가 - 은닉계층 추가, 활성화함수 relu 사용, 출력크기 100개 - 최종 출력계층 추가 3. 모델설정하기 - 옵티마이저는 adam 사용, 학습률 0.1 사용 4. 훈련시키기 - 훈련횟수 : 50 5. 성능 평가하기
''' 1. 신경망 모델 생성 '''
model = keras.Sequential()
''' 2. 계층 추가하기
- 1차원 전처리 계층 추가
- 은닉계층 추가, 활성화함수 relu 사용, 출력크기 100개
- 최종 출력계층 추가
'''
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")
)
''' 3. 모델설정하기
- 옵티마이저는 adam 사용, 학습률 0.1 사용
'''
adam = keras.optimizers.Adam(
learning_rate=0.1
)
model.compile(
optimizer="adam",
loss="sparse_categorical_crossentropy",
metrics="accuracy"
)
<실습> - 옵티마이저에 적용할 학습기법(sgd, adagrad, rmsprop, adam) 중에 가장 좋은 성능을 나타내는 옵티마이저 학습기법 확인하기 - 훈련횟수 : 50회 - 학습률은 기본값 사용 - 은닉계층 relu 사용 - 성능 평가결과를 이용해서 손실율이 가장 낮을 때의 학습방법, 정확도가 가장 높을 때의 학습방법을 각각 출력하기
작성한 코드
''' 1. 신경망 모델 생성 '''
model = keras.Sequential()
''' 2. 계층 추가하기 '''
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"))
opt = ["sgd", "adagrad", "rmsprop", "adam"]
best_loss_optimizer = None
best_accuracy_optimizer = None
best_loss = float('inf') # 초기값을 무한대로 설정
best_accuracy = 0.0
for i in opt:
if i == "sgd":
optimizer = keras.optimizers.SGD()
elif i == "adagrad":
optimizer = keras.optimizers.Adagrad()
elif i == "rmsprop":
optimizer = keras.optimizers.RMSprop()
else:
optimizer = keras.optimizers.Adam()
print(f"-------------------옵티마이저 {i} 시작-------------------")
model.compile(
optimizer=optimizer,
loss="sparse_categorical_crossentropy",
metrics=["accuracy"]
)
model.fit(train_scaled, train_target, epochs=50)
loss, accuracy = model.evaluate(val_scaled, val_target)
print(f"손실율 : {loss} / 정확도 : {accuracy}")
print(f"-------------------옵티마이저 {i} 종료-------------------")
# 가장 좋은 성능인지 확인
if loss < best_loss:
best_loss = loss
best_loss_optimizer = i
if accuracy > best_accuracy:
best_accuracy = accuracy
best_accuracy_optimizer = i
print("손실율이 가장 낮을 때의 학습방법:", best_loss_optimizer)
print("정확도가 가장 높을 때의 학습방법:", best_accuracy_optimizer)
강사님 코드
### 옵티마이저 학습방법 및 반복횟수를 받아서 처리할 함수 정의
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=10
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_opt} / best_acc : {best_acc}")
print(f"best_loss_opt : {best_loss_opt} / best_loss : {best_loss}")
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
데이터 수집 및 정규화
📍 fashion_mnist 데이터를 이용해서 훈련 및 테스트에 대한 독립변수와 종속변수 읽어 들이기 → 변수는 항상 사용하는 변수명으로 설정 📍 정규화하기 📍 훈련의 독립 및 종속변수를 이용해서 훈련 : 검증 = 8 : 2로 분류하기
'''
255로 나누는 이유는 이미지 데이터가 보통 0에서 255 사이의 픽셀 값으로 구성되어 있기 때문이다.
각 픽셀의 값이 0일 때는 최소값, 255일 때는 최대값이므로,
이 값을 0에서 1 사이의 범위로 매핑하기 위해 255로 나누어준다.
이렇게 하면 모든 픽셀 값이 0에서 1 사이의 실수 값으로 정규화된다.
'''
train_scaled_255 = train_input / 255.0
train_scaled_255[0]
test_scaled_255 = test_input / 255.0
test_scaled_255[0]
train_scaled_255.shape, test_scaled_255.shape
''' 입력계층(Input layer) 생성하기 '''
dense1 = keras.layers.Dense(100, activation="sigmoid", input_shape=(784,))
''' 출력계층(Output layer) 생성하기 '''
dense2 = keras.layers.Dense(10, activation="softmax")
''' 신경망 모델 생성하기 '''
### 여러개를 넣어야 할 때 리스트[] 사용
model = keras.Sequential([dense1, dense2])
model
''' 입력계층(Input layer) 생성하기 '''
dense1 = keras.layers.Dense(100, activation="sigmoid", input_shape=(784,))
''' 출력계층(Output layer) 생성하기 '''
dense2 = keras.layers.Dense(10, activation="softmax")
''' 신경망 모델 생성하기 '''
### 여러개를 넣어야 할 때 리스트[] 사용
model = keras.Sequential([dense1, dense2])
model
''' 모델 계층 확인하기 '''
model.summary()
- Output Shape로 100개를 출력해냄 - 다음 계층(dense_1)이 100개를 입력 계층으로 받음 - 그리고 다시 시그모이드 함수를 이용해 10개로 출력해냄 - dense_1에서 훈련에 관여하고 있는 계층 78500개 - param이 0 이면 훈련에 영향을 미치고 있는 계층이 없다.
2. 신경망모델 생성 시 계층(layer)을 함께 추가
''' 모델 생성 및 계층 추가하기 '''
model = keras.Sequential([
keras.layers.Dense(100, activation="sigmoid",
input_shape=(784,), name = "Input-layer"),
keras.layers.Dense(10, activation="softmax", name = "Output-layer")],
name = "Model-2"
)
model.summary()
3. 신경망 모델을 먼저 생성 후, 계층 추가하기
''' 신경망 모델 생성하기
- 일반적으로 사용되는 방식
- 위의 1, 2 방법으로 수행 후, 계층을 추가할 필요성이 있을 경우에도 사용됨'''
model = keras.Sequential()
''' 계층 생성 및 모델에 추가하기 '''
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.summary()
모델 설정하기(compile)
''' 손실함수는 다중분류 사용 '''
model.compile(
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
옵티마이저(Optimizer) →옵티마이저 설정 위치 : compile() 시에 설정함 →손실을 줄여나가기 위한 방법을 설정함 →손실을 줄여나가는 방법을 보통 "경사하강법"이라고 칭한다. →"경사하강법"을 이용한 여러 가지 방법들 중 하나를 선택하는 것이 옵티마이저 선택이다. →옵티마이저 종류 : SGD(확률적 경사하강법), Adagrad, RMSProp, Adam이 있음
📍 SDG(확률적 경사하강법) - 현재 위치에서 기울어진 방향을 찾을 때 지그재그 모양으로 탐색해 나가는 방법 📍 Adagrad - 학습률(보폭)을 적절하게 설정하기 위해 학습율 감소라는 기술을 사용 - 학습 진행 중에 학습률을 줄여가는 방법을 사용 - 처음에는 학습율을 크게 학습하다가, 점점 작게 학습한다는 의미 - 기울기가 유연함
📍 RMSProp - Adagrad의 단점을 보완한 방법 - Adagrad는 학습량을 점점 작게 학습하기 때문에 학습량이 0이 되어 갱신(학습)되지 않는 시점이 발생할 수 있는 단점이 있음 - 이러한 단점을 보완하여 과거의 기울기 값을 반영하는 방식 사용 - 먼 과거의 기울기(경사) 값은 조금 반영하고, 최근 기울기(경사)를 많이 반영 - Optimizer의 기본값(default)으로 사용됨
📍 Adam - 공이 굴러가듯이 모멘텀(momentum→관성)과 Adagrad를 융합한 방법 ** 모멘텀 : 관성과 가속도를 적용하여 이동하던 방향으로 좀 더 유연하게 작동함 - 자주 사용되는 기법으로, 좋은 결과를 얻을 수 있는 방법으로 유명함 - 메모리 사용이 많은 단점이 있음(과거 데이터를 저장해 놓음)
어떤 걸 써야 하는지 정해져 있지 않음 가장 좋은 건 모멘텀을 적용한 adam sgd는 가장 초기에 나왔기 때문에 많이 사용하기 않음. 기본값인RMSProp을 사용하고 adam사용. 하이퍼파라미터 튜닝을 한다면 모두 다 사용해 보는 것을 추천
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer="sgd",
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
학습률을 적용하는 방법 - 사용되는 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"
)
모멘텀(Momentum) - 기존의 방향(기울기)을 적용하여 관성을 적용시키는 방법 - 기본적으로 0.9 이상의 값을 적용시킴 - 보통 nesterov=True 속성과 함께 사용됨 →nesterov=True : 모멘텀 방향보다 조금 더 앞서서 경사를 계산하는 방식(미리 체크) - momentum 속성을 사용할 수 있는 옵티마이저 : SGD, RMSProp
''' 옵티마이저 객체 생성 '''
sgd = keras.optimizers.SGD(
momentum=0.9,
nesterov=True,
learning_rate=0.1
)
''' 모델 설정(compile) '''
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer="sgd",
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
''' adagrad '''
adagrad = keras.optimizers.Adagrad()
''' 모델 설정(compile) '''
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer=adagrad,
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
''' 또는 '''
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer="adagrad",
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
RMSprod
''' RMSProd '''
rmsprop = keras.optimizers.RMSprop()
''' 모델 설정(compile) '''
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer=rmsprop,
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
''' 또는 '''
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer="rmsprop",
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
Adam
''' Adam '''
adam = keras.optimizers.Adam()
''' 모델 설정(compile) '''
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer=adam,
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
''' 또는 '''
model.compile(
### 옵티마이저 정의 : 손실을 줄여나가는 방법
optimizer="adam",
### 손실함수 : 종속변수의 형태에 따라 결정 됨
loss="sparse_categorical_crossentropy",
### 훈련 시 출력할 값 : 정확도 출력
metrics="accuracy"
)
