def main():
# 获取MNIST数据
(train_x, train_label), (test_x, test_label) = load_mnist(flatten=False)
# 构造深层CNN
network = DeepConvNet()
# 生成一个训练器
trainer = Trainer(network,
train_x,
train_label,
test_x,
test_label,
epochs=20,
mini_batch_size=100,
optimizer='Adam',
optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000,
verbose=True)
trainer.train() # 训练上面构造好的神经网络
network.save_params() # 训练完成后持久化参数
print("Saved Network Parameters!")
# 获取训练过程中训练集和测试集的准确率
train_acc_list = trainer.train_acc_list
test_acc_list = trainer.test_acc_list
draw(train_acc_list, test_acc_list) # 绘制准确率变化图
def __train(lr, weight_decay, epocs = 50):
network = MultiLayerNet(input_size = 784, hidden_size_list = [100, 100, 100, 100, 100, 100], output_size = 10, weight_decay_lambda= weight_decay)
trainer = Trainer(network, x_train, t_train, x_val, t_val, epochs = epocs, mini_batch_size=100, optimizer="sgd", optimizer_param={"lr":lr}, verbose=False)
trainer.train()
return trainer.test_acc_list, trainer.train_acc_list
def main():
(train_x, train_label), (test_x, test_label) = load_mnist()
# 为了再现过拟合，减少学习数据
train_x = train_x[: 300]
train_label = train_label[: 300]
# 设定是否使用Dropuout，以及比例 ========================
use_dropout = False
# use_dropout = True
dropout_ratio = 0.2
network = MultiLayerNetExtend(
input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10, use_dropout=use_dropout, dropout_ratio=dropout_ratio)
trainer = Trainer(network, train_x, train_label, test_x, test_label,
epochs=301, mini_batch_size=100, optimizer='sgd',
optimizer_param={'lr': 0.01}, verbose=True)
trainer.train()
train_acc_list = trainer.train_acc_list
test_acc_list = trainer.test_acc_list
draw(train_acc_list, test_acc_list)
def __train(lr, weight_decay, epocs=50):
network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10, weight_decay_lambda=weight_decay)
trainer = Trainer(network, x_train, t_train, x_val, t_val,
epochs=epocs, mini_batch_size=100,
optimizer='sgd', optimizer_param={'lr': lr}, verbose=False)
trainer.train()
return trainer.test_acc_list, trainer.train_acc_list
def train(train_x, train_label, val_x, val_label, lr, weight_decay, epochs=50):
# 按照给定的超参数进行训练一个神经网络，并返回在验证集和训练集上的准确率
network = MultiLayerNet(input_size=784,
hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10, weight_decay_lambda=weight_decay)
trainer = Trainer(network, train_x, train_label, val_x, val_label,
epochs=epochs, mini_batch_size=100, optimizer='SGD',
optimizer_param={'lr': lr}, verbose=True)
trainer.train()
return trainer.test_acc_list, trainer.train_acc_list
def main():
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False, one_hot_label=True)
network = DeepConvNet()
trainer = Trainer(network, x_train, t_train, x_test, t_test,
epochs=20, mini_batch_size=100,
optimizer='Adam', optimizer_param={'lr':0.001},
evaluate_sample_num_per_epoch=1000)
trainer.train()
network.save_params('deep_convnet_params.pkl')
print("Saved Network Parameters!")
def __train(lr, weight_decay, epocs = 50):
#네트워크 생성
network = MultiLayerNet(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size= 10, weight_decay_lambda=weight_decay)
#훈련 초기화
trainer = Trainer(network,x_train,t_train,x_test,t_test,epocs,mini_batch_size=100,
optimizer='adam', optimizer_param={'lr':lr},verbose=False)
#훈련 시작
trainer.train()
return trainer.test_acc_list, trainer.train_acc_list
def __train(epocs=50):
network = MultiLayerNet(input_size=784,
hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10,
weight_decay_lambda=1.865405500969014e-05)
trainer = Trainer(network,
x_train,
t_train,
x_test,
t_test,
epochs=epocs,
mini_batch_size=100,
optimizer='AdaGrad',
optimizer_param={'lr': 0.002737364082615975})
trainer.train()
return trainer.test_acc_list, trainer.train_acc_list
def main():
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
# 処理に時間のかかる場合はデータを削除
#x_train, t_train = x_train[:5000], t_train[:5000]
#x_test, t_test = x_test[:1000], t_test[:1000]
max_epochs = 20
network = SimpleConvNet(input_dim=(1, 28, 28),
conv_param={
'filter_num': 30,
'filter_size': 5,
'pad': 0,
'stride': 1
},
hidden_size=100,
output_size=10,
weight_init_std=0.01)
trainer = Trainer(network,
x_train,
t_train,
x_test,
t_test,
epochs=max_epochs,
mini_batch_size=100,
optimizer='Adam',
optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000)
trainer.train()
# パラメータの保存
network.save_params("params.pkl")
print("Saved Network Parameters!")
# グラフの描画
markers = {'train': 'o', 'test': 's'}
x = np.arange(max_epochs)
plt.plot(x, trainer.train_acc_list, marker='o', label='train', markevery=2)
plt.plot(x, trainer.train_acc_list, marker='s', label='test', markevery=2)
plt.xlabel = ("epochs")
plt.ylabel = ("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()
def __train(lr, weight_decay, epoches=50):
net = MultiLayerNet(input_size=784,
hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10,
weight_decay_lambda=weight_decay)
trainer = Trainer(net,
x_train,
t_train,
x_valuation,
t_valuation,
epoches=epoches,
mini_batch_size=100,
optimizer='SGD',
optimizer_param={'lr': lr},
verbose=False)
trainer.train()
return trainer.train_acc_list, trainer.test_acc_list
def __train(lr, weight_decay_lambda, epoch_num=120):
network = MultiLayerNetExtend(input_size=784,
hidden_size_list=[100] * 5,
output_size=10,
activation='ReLu',
weight_init_std='ReLu',
weight_decay_lambda=weight_decay_lambda,
use_BatchNormalization=False,
use_weight_decay=True)
# 注意下面传入的不是测试集而是验证集
trainer = Trainer(network=network,
x_train=x_train,
t_train=t_train,
x_test=x_val,
t_test=t_val,
epochs=epoch_num,
mini_batch_num=100,
optimizer='SGD',
optimizer_params={'lr': lr})
trainer.train()
return trainer.train_acc_list, trainer.test_acc_list # 返回一次实验测试集和验证集的精度
def main():
# 获取MNIST数据
(train_x, train_label), (test_x, test_label) = load_mnist(flatten=False)
# 构造CNN
network = SimpleConvNet(input_dim=(1, 28, 28),
conv_param={
'filter_num': 30,
'filter_size': 5,
'pad': 0,
'stride': 1
},
hidden_size=100,
output_size=10,
weight_init_std=0.01)
# 生成一个训练器
trainer = Trainer(network,
train_x,
train_label,
test_x,
test_label,
epochs=20,
mini_batch_size=100,
optimizer='Adam',
optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000,
verbose=True)
trainer.train() # 训练上面构造好的神经网络
network.save_params() # 训练完成后持久化参数
print("Saved Network Parameters!")
# 获取训练过程中训练集和测试集的准确率
train_acc_list = trainer.train_acc_list
test_acc_list = trainer.test_acc_list
draw(train_acc_list, test_acc_list) # 绘制准确率变化图
def train():
start = time.time()
(x_train, t_train), (x_test, t_test) = load_katakana_arg(flatten=False)
print('x_train', x_train.shape, 't_train', t_train.shape)
print('x_test', x_test.shape, 't_test', t_test.shape)
network = CNNNet()
trainer = Trainer(network, x_train, t_train, x_test, t_test,
epochs=50, mini_batch_size=256,
optimizer='Adam', optimizer_param={'lr': 0.001})
train_acc_list, train_loss_list, test_acc_list, test_loss_list = trainer.train()
elapsed_time = time.time() - start
print("=============== Elapse Time ===============")
print("elapsed_time:{0}".format(elapsed_time) + "[sec]")
network = MultiLayerNetExtend(input_size=784,
hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10,
use_dropout=use_dropout,
dropout_ration=dropout_ration)
trainer = Trainer(network,
x_train,
t_train,
x_test,
t_test,
epochs=301,
mini_batch_size=100,
optimizer='sgd',
optimizer_param={'lr': 0.01},
verbose=True)
trainer.train() # 开始训练
# 获取精度结果
train_acc_list = trainer.train_acc_list
test_acc_list = trainer.test_acc_list
# 绘制图表
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, marker='o', label='train', markevery=10)
plt.plot(x, test_acc_list, marker='s', label='test', markevery=10)
plt.xlabel('epochs')
plt.ylabel('accuracy')
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True)
# 오버피팅을 재현하기 위해 학습 데이터 수를 줄임
x_train = x_train[:300]
t_train = t_train[:300]
# 드롭아웃 사용 유무와 비울 설정 ========================
use_dropout = True # 드롭아웃을 쓰지 않을 때는 False
dropout_ratio = 0.2
# ====================================================
network = MultiLayerNetExtend(input_size=784, hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10, use_dropout=use_dropout, dropout_ration=dropout_ratio)
trainer = Trainer(network, x_train, t_train, x_test, t_test,
epochs=301, mini_batch_size=100,
optimizer='sgd', optimizer_param={'lr': 0.01}, verbose=True)
trainer.train()
train_acc_list, test_acc_list = trainer.train_acc_list, trainer.test_acc_list
# 그래프 그리기==========
markers = {'train': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, marker='o', label='train', markevery=10)
plt.plot(x, test_acc_list, marker='s', label='test', markevery=10)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc='lower right')
plt.show()
'qat_scheme': KMQATScheme.LossAwareCompensation},
conv_param_5={'filter_num': 256, 'filter_size': 3, 'pad': 1, 'stride': 1,
'enable_fp_qat': True, 'enable_bp_gradient_quantization': True,
'qat_scheme': KMQATScheme.LossAwareCompensation},
affine1_param={'enable_fp_qat': False, 'enable_bp_gradient_quantization': False},
affine2_param={'enable_fp_qat': False, 'enable_bp_gradient_quantization': False},
affine3_param={'enable_fp_qat': False, 'enable_bp_gradient_quantization': False},
hidden_size_1=4096, hidden_size_2=4096, output_size=10,
enable_compensation_L2_regularization=True, compensation_L2_regularization_lambda=0.1,
mini_batch_size=batch_size)
# ======================================= Network Configuration =======================================
trainer = Trainer(network, x_train, t_train, x_test, t_test,
epochs=max_epochs, mini_batch_size=batch_size,
optimizer=optimizer, optimizer_param={'lr': learning_rate},
evaluate_sample_num_per_epoch=evaluate_sample_num, log_per_epoch=log_per_epoch, verbose=True)
trainer.train(log_time=method_time_inspection)
# Draw figure
markers = {'train loss': '^', 'train acc': 'o', 'test acc': 's'}
x = np.arange(len(trainer.train_loss_list))
plt.plot(x, trainer.train_loss_list, marker='^', label='train loss', markevery=2)
plt.plot(x, trainer.train_acc_list, marker='o', label='train acc', markevery=2)
plt.plot(x, trainer.test_acc_list, marker='s', label='test acc', markevery=2)
plt.xlabel("Training Progress")
plt.ylabel("Accuracy & Loss")
plt.ylim(0, 2.5)
plt.legend(loc='best')
plt.show()
hidden_size_list=[100, 100, 100, 100, 100, 100],
output_size=10,
use_dropout=use_dropout,
dropout_ration=dropout_ratio)
trainer = Trainer(network,
x_train,
t_train,
x_test,
t_test,
epochs=301,
mini_batch_size=100,
optimizer='sgd',
optimizer_param={'lr': 0.01},
verbose=True) #verbose는 중간중간 출력값을 나타내고 싶을 때
trainer.train() #훈련 시작!
train_acc_list, test_acc_list = trainer.train_acc_list, trainer.test_acc_list
#그래프 그리기=======================
markers = {'trainer': 'o', 'test': 's'}
x = np.arange(len(train_acc_list))
plt.plot(x, train_acc_list, marker='o', label='train', markevery=10)
plt.plot(x, test_acc_list, marker='s', label='test', markevery=10)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.0)
plt.legend(loc="lower left")
plt.show()
print("-" * 80 + "\n")
trainer1 = Trainer(device,
model,
dataset,
optimizer,
[CrossEntropy(), AlphaLoss()],
name=args.name,
topk=topk,
checkpointFreq=args.checkpoint_freq)
trainer1.temperature = args.starting_temp
trainer1.callbacks.append(AlphaCallback(args.alpha))
if scheduler is not None:
trainer1.callbacks.append(SchedulerCB(scheduler))
trainer1.train(args.epochs)
torch.save(model.state_dict(), args.name + ".model")
else: # arg.resume is not None
model.load_state_dict(torch.load(args.resume))
print("-" * 80)
print("Binarize and fine tune\n")
print("")
FROZEN_ALPHA = (model.Lblock.alpha.data > 0.2).float().to(device)
with open("logs/{}.log".format(args.name), "a") as f:
f.write("*******\nFine tuning after binarization\n*******\n")
model.Lblock.alpha.data = FROZEN_ALPHA
model.Lblock.alpha.requires_grad = False
# coding: utf-8
import os
import sys
sys.path.append(os.pardir) # 부모 디렉터리의 파일을 가져올 수 있도록 설정
from dataset.mnist import load_mnist
from deep_convnet import DeepConvNet
from common.trainer import Trainer
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
network = DeepConvNet()
trainer = Trainer(network,
x_train,
t_train,
x_test,
t_test,
epochs=20,
mini_batch_size=100,
optimizer='Adam',
optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=1000)
trainer.train()
# 매개변수 보관
network.save_params("deep_convnet_params.pkl")
print("Saved Network Parameters!")
def cnn_constructor():
"""
Referenced by https://github.com/oreilly-japan/deep-learning-from-scratch
common modules referenced there too.
"""
global network, classes, imsize
(x_train, t_train), (x_test,
t_test), classes = dataset(image_dir="images",
test_percentage=10,
validation_percentage=10,
imsize=imsize)
x_train = chenneling(x_train)
x_test = chenneling(x_test)
train_num = x_train.shape[0]
test_num = x_test.shape[0]
x_train, t_train = shuffle_dataset(x_train, t_train)
x_test, t_test = shuffle_dataset(x_test, t_test)
net_param = "cnn_params" + str(imsize) + ".pkl"
if not os.path.exists("params/"):
os.makedirs("params/")
# make convolution eural network
# x_train.shape[1:] returns channel, height, width
network = ConvNet(input_dim=(x_train.shape[1:]),
conv_param={
'filter_num': 20,
'filter_size': 3,
'pad': 0,
'stride': 1
},
hidden_size=32,
output_size=classes,
weight_init_std=0.001)
trainer = Trainer(network,
x_train,
t_train,
x_test,
t_test,
epochs=1,
mini_batch_size=FLAGS.batch_size,
optimizer='Adam',
optimizer_param={'lr': 0.001},
evaluate_sample_num_per_epoch=train_num)
params_loaded = False
if not os.path.exists("params/"):
os.makedirs("params/")
if (os.path.exists("params/" + net_param)):
network.load_params("params/" + net_param)
params_loaded = True
print("\n* Loaded Network Parameters! - " + net_param)
if ((FLAGS.train_epochs > 0) or (params_loaded == False)):
if (FLAGS.train_epochs <= 0):
FLAGS.train_epochs = 10
# Training
for ep in range(FLAGS.train_epochs):
trainer.train()
# Save parameters
network.save_params("params/" + net_param)
# plot graphs
# Grpah 1: Accuracy
markers = {'train': 'o', 'test': 's', 'loss': 'd'}
x1 = np.arange(len(trainer.train_acc_list))
plt.clf()
plt.plot(x1,
trainer.train_acc_list,
marker='o',
label='train',
markevery=1)
plt.plot(x1,
trainer.test_acc_list,
marker='s',
label='test',
markevery=1)
plt.xlabel("epochs")
plt.ylabel("accuracy")
plt.ylim(0, 1.1)
plt.legend(loc='lower right')
plt.title("Accuracy")
now = datetime.now()
filename = "params/" + now.strftime(
'%Y%m%d_%H%M%S%f') + "_" + "ep" + ".png"
plt.savefig(filename)
#plt.show()
# Graph 2: Loss
x2 = np.arange(len(trainer.train_loss_list))
plt.clf()
plt.plot(x2,
trainer.train_loss_list,
marker='o',
label='loss',
markevery=1)
plt.xlabel("iter")
plt.ylabel("loss")
plt.legend(loc='lower right')
plt.title("Cross entropy loss")
now = datetime.now()
filename = "params/" + now.strftime(
'%Y%m%d_%H%M%S%f') + "_" + "ep" + ".png"
plt.savefig(filename)
#plt.show()
print("\n* Saved Network Parameters! - " + net_param)
