[인공지능][DL] Deep Learning 실습 - 신경망계층 추가방법 및 성능향상방법

실습 - 1

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"
)

''' 4. 훈련시키기 '''
model.fit(train_scaled, train_target, epochs=50)

''' 5. 성능 평가하기 '''
score = model.evaluate(val_scaled, val_target)

print(f"손실율 : {score[0]} / 정확도 : {score[1]}")

 

훈련 횟수가 증가할 수록 정확도가 감소되었기 때문에 훈련율을 0.01로 조정

조정 후 정확도 확인

 

실습 - 2

<실습>
- 옵티마이저에 적용할 학습기법(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}")