# 학습 데이터 개수를 300개로 제한 -> overfitting 만들기 위해서
X_train = X_train[:300]
Y_train = Y_train[:300]
X_test = X_test[:300] # 실험 시간 줄이기 위해서
Y_test = Y_test[:300]
epochs = 200 # 1 에포크: 모든 학습 데이터가 1번씩 학습된 경우
mini_batch_size = 100 # 1번 forward에 보낼 데이터 샘플 개수
train_size = X_train.shape[0]
iter_per_epoch = int(max(train_size / mini_batch_size, 1))
# 학습하면서 학습/테스트 데이터의 정확도를 각 에포크마다 기록
train_accuracies = []
test_accuracies = []
optimizer = Sgd(learning_rate=0.01) # optimizer
for epoch in range(epochs):
for i in range(iter_per_epoch):
x_batch = X_train[(i * mini_batch_size):((i + 1) * mini_batch_size)]
y_batch = Y_train[(i * mini_batch_size):((i + 1) * mini_batch_size)]
gradients = neural_net.gradient(x_batch, y_batch)
optimizer.update(neural_net.params, gradients)
train_acc = neural_net.accuracy(X_train, Y_train)
train_accuracies.append(train_acc)
test_acc = neural_net.accuracy(X_test, Y_test)
test_accuracies.append(test_acc)
print(f'epoch #{epoch}: train={train_acc}, test={test_acc}')
x = np.arange(epochs)
# 각 실험 조건 별로 테스트할 신경망을 생성
neural_nets = dict()
train_losses = dict()
for key, type in weight_init_types.items():
neural_nets[key] = MultiLayerNet(input_size=784,
hidden_size_list=[100, 100, 100, 100],
output_size=10,
weight_init_std=type)
train_losses[key] = [] # 빈 리스트 생성 - 실험(학습)하면서 손실값들을 저장
# MNIST train/test 데이터 로드
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label=True)
iterations = 2_000 # 학습 회수
batch_size = 128 # 1번 학습에 사용할 샘플 개수(미니 배치)
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)
from ch05.ex10_twolayer import TwoLayerNetwork
from ch06.ex02_sgd import Sgd
from ch06.ex04_adagrad import AdaGrad
from ch06.ex05_adam import Adam
from ch06.ex06_RMSProp import RMSProp
from ch06.ex07_nesterov import Nesterov
from ch06.ex03_momentum import Momentum
from dataset.mnist import load_mnist
if __name__ == '__main__':
# MNIST(손글씨 이미지) 데이터 로드
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label=True)
# 최적화 알고리즘을 구현한 클래스의 인스턴스들을 dict에 저장
optimizers = dict()
optimizers['sgd'] = Sgd()
optimizers['momentum'] = Momentum()
optimizers['adagrad'] = AdaGrad()
optimizers['adam'] = Adam()
optimizers['rmsprop'] = RMSProp()
optimizers['nesterov'] = Nesterov()
# 은닉층 1개, 출력층 1개로 이루어진 신경망을 optimizer 개수만큼 생성
# 각 신경망에서 손실들을 저장할 dict를 생성
neural_nets = dict()
train_losses = dict()
for key in optimizers:
neural_nets[key] = TwoLayerNetwork(input_size=784,
hidden_size=32,
output_size=10)
train_losses[key] = [] # loss들의 이력(history)를 저장
weight_init_types = {'std 0.01': 0.01, 'Xavier': 'sigmoid', 'He': 'relu'}
neural_nets = dict()
train_loses = dict()
for key, value in weight_init_types.items():
neural_nets[key] = MultiLayerNet(input_size=784,
hidden_size_list=[100, 100, 100, 100],
output_size=10,
weight_init_std=value)
train_loses[key] = [] # 실험하면서 손실값 저장
# 2. MNIST train, test 데이터 로드
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label=True)
iterators = 2_000
batch_size = 128 # 1번 학습에 사용할 샘플 갯수(미니배치)
optimizer = Sgd(learning_rate=0.01) # 파라미터 최적화를 할 알고리즘
# 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) 업데이트
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label=True)
# 학습 시간을 줄이기 위해서 학습 데이터의 개수를 줄임.
X_train = X_train[:1000] # 데이터 1000개만 사용
Y_train = Y_train[:1000]
train_size = X_train.shape[0]
batch_size = 128
learning_rate = 0.01
iterations = 200
train_accuracies = [] # 배치 정규화를 사용하지 않는 신경망의 정확도를 기록
bn_train_accuracies = [] # 배치 정규화를 사용하는 신경망의 정확도를 기록
# 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)
from ch05.ex10_twolayer import TwoLayerNetwork
from ch06.ex02_sgd import Sgd
from ch06.ex04_adagrad import AdaGrad
from ch06.ex05_adam import Adam
from ch06.ex06_rmsprop import RMSProp
from ch06.ex07_nesterov import Nesterov
from ch06.ex3_momentum import Momentum
from dataset.mnist import load_mnist
if __name__ == '__main__':
# MNIST(손글씨 이미지) 데이터 로드
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label=True)
# 최적화 알고리즘을 구현한 클래스의 인스턴스들을 dict에 저장
optimizers = dict()
optimizers['SGD'] = Sgd()
optimizers['Momentum'] = Momentum()
optimizers['AdaGrad'] = AdaGrad()
optimizers['Adam'] = Adam()
optimizers['RMSProp'] = RMSProp()
optimizers['Nesterov'] = Nesterov()
# 은닉층 1개, 출력층 1개로 이루어진 신경망을 optimizers 개수만큼 생성
# 각 신경망에서 손실들을 저장할 dict를 생성
neural_nets = dict()
train_losses = dict()
for key in optimizers:
neural_nets[key] = TwoLayerNetwork(input_size=784,
hidden_size=32,
output_size=10)
train_losses[key] = [] # loss들의 이력(history)를 저장하게 됨.
use_batchnorm=True)
neural_net = MultiLayerNetExtend(input_size=784,
hidden_size_list=[100, 100, 100, 100, 100],
output_size=10,
weight_init_std=0.1,
use_batchnorm=False)
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label=True)
# 학습 시간을 줄이기 위해서 학습 데이터의 개수 줄이기
X_train = X_train[:1000]
Y_train = Y_train[:1000]
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:
# 미니 배치를 20번 학습시키면서, 두 신경망에서 정확도(accuracy)를 기록
# -> 그래프
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label=True)
# 학습 시간을 줄이기 위해 학습 데이터의 개수를 줄임.
X_train = X_train[:1000]
Y_train = Y_train[:1000]
train_size = X_train.shape[0]
batch_size = 128
learning_rate = 0.1
iterations = 20
train_accuracies = [] # 배치 정규화를 사용하지 않는 신경망의 정확도를 기록
bn_train_accuracies = [] # 배치 정규화를 사용하는 신경망의 정확도를 기록
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)
from ch06.ex05_ADAM import Adam
from ch06.ex06_rmsprop import RMSProp
from ch06.ex07_nesterov import Nesterov
from dataset.mnist import load_mnist
if __name__ == '__main__':
#MNIST(손글씨 이미지) 데이터 로드
(X_train, Y_train), (X_test, Y_test) = load_mnist(one_hot_label= True)
# train_size = X_train.shape[0] # 60000만개를 모두 트레인 시킬 것은 아니라 넣어주지 않음
# X_train.shape = (60000, 784)
#최적화 알고리즘을 구현한 클래스의 인스턴스들을 dict에 저장
optimizers = dict()
optimizers['SGD'] = Sgd() # key값으로 알고리즘 이름을 준다 ex. ['SGD'] = 그리고 다른 파일에서 만든 알고리즘을 import 해준다
optimizers['Momentum'] = Momentum()
optimizers['Adagrad'] = AdaGrad()
optimizers['ADAM'] = Adam()
optimizers['RMS'] = RMSProp()
optimizers['Nesterov'] = Nesterov()
# 은직층 1개, 출력층 1개로 이루어진 신경망을 optimizer 개수만큼 생성
# 각 신경망에서 손실들을 저장할 dict를 생성
train_losses = dict()
neural_nets = dict()
for key in optimizers:
neural_nets[key] = TwolayerNetwork(input_size = 784,
hidden_size = 32,
output_size= 10)