optimizer = Sgd(learning_rate=0.01) # 파라미터 최적화 알고리즘
# optimizer를 변경하면 테스트
optimizer = Adam()
np.random.seed(109)
for i in range(iterations): # 2,000번 반복하면서
# 미니 배치 샘플 랜덤 추출
mask = np.random.choice(X_train.shape[0], batch_size)
X_batch = X_train[mask]
Y_batch = Y_train[mask]
for key, net in neural_nets.items(): # 테스트 신경망 종류마다 반복
# gradient 계산
gradients = net.gradient(X_batch, Y_batch)
# 파라미터(W, b) 업데이트
optimizer.update(net.params, gradients)
# 손실(loss) 계산 -> 리스트 추가
loss = net.loss(X_batch, Y_batch)
train_losses[key].append(loss)
# 손실 일부 출력
if i % 100 == 0:
print(f'===== iteration #{i} =====')
for key, loss_list in train_losses.items():
print(key, ':', loss_list[-1])
# x축-반복 회수, y축-손실 그래프
x = np.arange(iterations)
for key, loss_list in train_losses.items():
plt.plot(x, loss_list, label=key)
plt.title('Weight Init Compare')
plt.xlabel('Iterations')
# optimizer = Adam() # 파라미터 최적화를 할 알고리즘
# optimizer 변경해가면서 테스트
# 3. 2,000번 반복하면서
np.random.seed(109)
for i in range(iterators):
# 미니 배치 샘플 랜덤 추출
batch_mask = np.random.choice(X_train.shape[0], batch_size)
X_batch = X_train[batch_mask]
Y_batch = Y_train[batch_mask]
# 테스트 할 신경망 종류마다 반복
for key, value in neural_nets.items():
# gradient 계산
gradient = value.gradient(X_batch, Y_batch)
# 파라미터(W, b) 업데이트
optimizer.update(value.params, gradient)
# 손실(Loss) 계산 -> 리스트 추가
loss = value.loss(X_batch, Y_batch)
train_loses[key].append(loss)
# 손실 100번마다 한번씩 츨력
if i % 100 == 0:
print(f'\n===== {i}번째 training =====')
for key, value in train_loses.items():
print(key, ':', value[-1])
# 4. x축:반복횟수 / y축:손실 그래프
x = np.arange(iterators)
markers = {'std 0.01': 'o', 'Xavier': 's', 'He': 'D'}
for key, value in train_loses.items():
plt.plot(x, value, label=key,
marker=markers[key]) # value넣을 때 sooth curve 찾아보기
iterator = 200
batch_size = 128
learning_rate = 0.01
neural_optimizer = Sgd()
bn_neural_optimizer = Sgd()
neural_acc_list = []
bn_neural_acc_list = []
for i in range(iterator):
mask = np.random.choice(X_train.shape[0], batch_size)
X_batch = X_train[mask]
Y_batch = Y_train[mask]
for network in (neural_net, bn_neural_net):
gradient = network.gradient(X_batch, Y_batch)
if network == neural_net:
neural_optimizer.update(network.params, gradient)
neural_acc = neural_net.accuracy(X_batch, Y_batch)
neural_acc_list.append(neural_acc)
else:
bn_neural_optimizer.update(network.params, gradient)
bn_neural_acc = bn_neural_net.accuracy(X_batch, Y_batch)
bn_neural_acc_list.append(bn_neural_acc)
print(f'===== {i}번째 training =====')
print('Without BatchNorm', neural_acc_list[-1])
print('BatchNorm', bn_neural_acc_list[-1])
# gradients = neural_net.gradient(X_batch, Y_batch)
# neural_optimizer.update(neural_net.params, gradients)
# neural_acc = neural_net.accuracy(X_batch, Y_batch)
# neural_acc_list.append(neural_acc)
#
# optimizer = Sgd(learning_rate)
# 파라미터 최적화 알고리즘이 SGD가 아닌 경우에는 신경망 개수만큼 optimizer를 생성.
optimizer = Sgd(learning_rate)
bn_optimizer = Sgd(learning_rate)
# 학습하면서 정확도의 변화를 기록
for i in range(iterations):
# 미니 배치를 랜덤하게 선택(0~999 숫자들 중 128개를 랜덤하게 선택)
mask = np.random.choice(train_size, batch_size)
x_batch = X_train[mask]
y_batch = Y_train[mask]
# 배치 정규화를 사용하지 않는 신경망에서 gradient를 계산.
gradients = neural_net.gradient(x_batch, y_batch)
# 파라미터 업데이트(갱신) - W(가중치), b(편향)을 업데이트
optimizer.update(neural_net.params, gradients)
# 업데이트된 파라미터들을 사용해서 배치 데이터의 정확도 계산
acc = neural_net.accuracy(x_batch, y_batch)
# 정확도를 기록
train_accuracies.append(acc)
# 배치 정규화를 사용하는 신경망에서 같은 작업을 수행.
bn_gradients = bn_neural_net.gradient(x_batch, y_batch) # gradient 계산
bn_optimizer.update(bn_neural_net.params, bn_gradients) # W, b 업데이트
bn_acc = bn_neural_net.accuracy(x_batch, y_batch) # 정확도 계산
bn_train_accuracies.append(bn_acc) # 정확도 기록
print(f'iteration #{i}: without={acc}, with={bn_acc}')
# 정확도 비교 그래프
x = np.arange(iterations)
optimizer = Sgd(learning_rate)
bn_optimizer = Sgd(learning_rate)
# 학습하면서 정확도의 변화를 기록
np.random.seed(110)
for i in range(iterations):
# 미니 배치를 랜덤하게 선택(0~999 숫자들 중 128개를 랜덤하게 선택)
mask = np.random.choice(train_size, batch_size)
x_batch = X_train[mask]
y_batch = Y_train[mask]
# 각 신경망에서 gradient를 계산
gradients = neural_net.gradient(x_batch, y_batch)
# 파라미터 업데이터(갱신) - W(가중치), b(편향)을 업데이트
optimizer.update(neural_net.params, gradients)
# 업데이트된 파라미터들을 사용해서 배치 데이터의 정확도 계산
acc = neural_net.accuracy(x_batch, y_batch)
# 정확도를 기록
train_accuracies.append(acc)
# 배치 정규화를 사용하는 신경망에서 같은 작업을 수행
bn_gradients = bn_neural_net.gradient(x_batch, y_batch)
bn_optimizer.update(bn_neural_net.params, bn_gradients) # W(가중치), b(편향)을 업데이트
bn_acc = bn_neural_net.accuracy(x_batch, y_batch) # 정확도 계산
bn_train_accuracies.append(bn_acc) # 정확도 기록
print(f'iteration #{i}: without= {acc}, with={bn_acc}')
# 정확도 비교 그래프
x = np.arange(iterations)