def main(args):
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
chainer.cuda.cupy.random.seed(0)
t = np.array([0], dtype=np.int32)
tmp = cuda.to_gpu(t)
# setup result directory
start_time = datetime.now().strftime('%Y%m%d_%H_%M_%S')
if args.test:
start_time = "test_" + start_time
result_dest = args.result_dir + '/' + start_time
result_abs_dest = os.path.abspath(result_dest)
if not args.extract_parameter:
os.makedirs(result_dest)
with open(os.path.join(result_abs_dest, "settings.json"), "w") as fo:
fo.write(json.dumps(vars(args), sort_keys=True, indent=4))
# data setup
data_processor = DataProcessor(args)
data_processor.prepare_dataset()
vocab_q = data_processor.vocab_q
vocab_d = data_processor.vocab_d
if args.create_vocabulary:
print('dump')
with open(args.vocab_path+"en_{}_vocab_for_index.txt".format(args.doc_lang),"wb") as f_q,\
open(args.vocab_path+"{}_vocab_for_index.txt".format(args.doc_lang),'wb') as f_d:
cPickle.dump(dict(vocab_q), f_q)
cPickle.dump(dict(vocab_d), f_d)
print('done')
# model setup
if args.deep:
nn = Network_deep(args, len(vocab_q), len(vocab_d))
else:
nn = Network(args, len(vocab_q), len(vocab_d))
if args.load_embedding:
nn.load_embeddings(args, vocab_q, "query")
nn.load_embeddings(args, vocab_d, "document")
model = L.Classifier(nn, lossfun=F.hinge)
model.compute_accuracy = False
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
# optimizer setup
if args.optimizer == "adagrad":
optimizer = O.AdaGrad(lr=0.05)
else:
optimizer = O.Adam()
optimizer.setup(model)
# converter setup
if args.encode_type == "lstm":
converter = converter_for_lstm
else:
converter = concat_examples
# iterator, updater and trainer setup
train_iter = chainer.iterators.SerialIterator(data_processor.train_data, args.batchsize)
dev_iter = chainer.iterators.SerialIterator(data_processor.dev_data, args.batchsize, repeat=False, shuffle=False)
test_iter = chainer.iterators.SerialIterator(data_processor.test_data, args.batchsize, repeat=False, shuffle=False)
updater = training.StandardUpdater(train_iter, optimizer, converter=converter, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=result_dest)
model_path = '/'.join(args.model_path.split('/')[0:-1])+'/'
model_epoch = args.model_path.split('/')[-1].split('_')[-1]
print('model path = ' + model_path + 'model_epoch_{}'.format(model_epoch))
if args.load_snapshot:
print("loading snapshot...")
serializers.load_npz(model_path +'model_epoch_{}'.format(model_epoch), trainer)
# serializers.load_npz(model_path +'model_epoch_{}'.format(model_epoch), model, path='updater/model:main/')
print('done')
exit()
if args.extract_parameter:
print('extract parameter...')
serializers.load_npz(model_path +'model_epoch_{}'.format(model_epoch), trainer)
if args.deep:
p1 = model.predictor.l1
p2 = model.predictor.l2
p3 = model.predictor.l3
p4 = model.predictor.l4
serializers.save_npz(model_path+"l1.npz", p1)
serializers.save_npz(model_path+"l2.npz", p2)
serializers.save_npz(model_path+"l3.npz", p3)
serializers.save_npz(model_path+"l4.npz", p4)
p5 = model.predictor.conv_q
serializers.save_npz(model_path+"conv_q.npz", p5)
print('done')
exit()
if args.load_parameter:
print("loading parameter...")
if args.deep:
p1 = model.predictor.l1
p2 = model.predictor.l2
p3 = model.predictor.l3
p4 = model.predictor.l4
serializers.load_npz(model_path+ "l1.npz", p1)
serializers.load_npz(model_path+ "l2.npz", p2)
serializers.load_npz(model_path+ "l3.npz", p3)
serializers.load_npz(model_path+ "l4.npz", p4)
p5 = model.predictor.conv_q
serializers.load_npz(model_path+ "conv_q.npz", p5)
print('done')
# Evaluation setup
iters = {"dev": dev_iter, "test": test_iter}
trainer.extend(RankingEvaluator(iters, model, args, result_abs_dest, data_processor.n_test_qd_pairs, converter=converter, device=args.gpu))
# # Log reporter setup
trainer.extend(extensions.LogReport(log_name='log'))
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss_dev', 'validation/main/loss_test']))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.snapshot(filename='model_epoch_{.updater.epoch}'),
trigger=chainer.training.triggers.MinValueTrigger('validation/main/loss_dev'))
trainer.run()
def main():
#added alex_mini and alex_mini_fp16
archs = {
'alex': alex.Alex,
'alex_fp16': alex.AlexFp16,
'googlenet': googlenet.GoogLeNet,
'googlenetbn': googlenetbn.GoogLeNetBN,
'googlenetbn_fp16': googlenetbn.GoogLeNetBNFp16,
'nin': nin.NIN,
'resnet50': resnet50.ResNet50,
'alex_mini': alex_mini.AlexMini,
'alex_mini_fp16': alex_mini.AlexMiniFp16,
'alex_mini2': alex_mini2.AlexMini2,
'alex_mini2_fp16': alex_mini2.AlexMini2Fp16
}
parser = argparse.ArgumentParser(
description='Learning convnet from ILSVRC2012 dataset')
parser.add_argument('train', help='Path to training image-label list file')
parser.add_argument('val', help='Path to validation image-label list file')
parser.add_argument('--arch',
'-a',
choices=archs.keys(),
default='nin',
help='Convnet architecture')
parser.add_argument('--batchsize',
'-B',
type=int,
default=32,
help='Learning minibatch size')
parser.add_argument('--epoch',
'-E',
type=int,
default=10,
help='Number of epochs to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU')
parser.add_argument('--initmodel',
help='Initialize the model from given file')
parser.add_argument('--loaderjob',
'-j',
type=int,
help='Number of parallel data loading processes')
parser.add_argument('--mean',
'-m',
default='mean.npy',
help='Mean file (computed by compute_mean.py)')
parser.add_argument('--resume',
'-r',
default='',
help='Initialize the trainer from given file')
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--root',
'-R',
default='.',
help='Root directory path of image files')
parser.add_argument('--val_batchsize',
'-b',
type=int,
default=250,
help='Validation minibatch size')
parser.add_argument('--test', action='store_true')
parser.set_defaults(test=False)
args = parser.parse_args()
# Initialize the model to train
model = archs[args.arch]()
if args.initmodel:
print('Load model from', args.initmodel)
chainer.serializers.load_npz(args.initmodel, model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use() # Make the GPU current
model.to_gpu()
# Load the datasets and mean file
mean = np.load(args.mean)
train = PreprocessedDataset(args.train, args.root, mean, model.insize)
val = PreprocessedDataset(args.val, args.root, mean, model.insize, False)
# These iterators load the images with subprocesses running in parallel to
# the training/validation.
train_iter = chainer.iterators.MultiprocessIterator(
train, args.batchsize, n_processes=args.loaderjob)
val_iter = chainer.iterators.MultiprocessIterator(
val, args.val_batchsize, repeat=False, n_processes=args.loaderjob)
# Set up an optimizer
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.out)
val_interval = (10 if args.test else 1000), 'iteration'
log_interval = (10 if args.test else 1000), 'iteration'
trainer.extend(extensions.Evaluator(val_iter, model, device=args.gpu),
trigger=val_interval)
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=val_interval)
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=val_interval)
# Be careful to pass the interval directly to LogReport
# (it determines when to emit log rather than when to read observations)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
# Save two plot images to the result dir
if extensions.PlotReport.available():
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',
file_name='loss.png'))
trainer.extend(
extensions.PlotReport(
['main/accuracy', 'validation/main/accuracy'],
'epoch',
file_name='accuracy.png'))
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'lr'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
def main(gpu=-1, batch_size=1, iterations=100000,
lr=1e-10, out='result', resume=''):
# prepare datasets
def transform(in_data):
img, label = in_data
vgg_subtract_bgr = np.array(
[103.939, 116.779, 123.68], np.float32)[:, None, None]
img -= vgg_subtract_bgr
img = pad(img, max_size=(512, 512), bg_value=0)
label = pad(label, max_size=(512, 512), bg_value=-1)
return img, label
train_data = VOCSemanticSegmentationDataset(mode='train')
test_data = VOCSemanticSegmentationDataset(mode='val')
extend(train_data, transform)
extend(test_data, transform)
# set up FCN32s
n_class = 21
model = FCN32s(n_class=n_class)
if gpu != -1:
model.to_gpu(gpu)
chainer.cuda.get_device(gpu).use()
# prepare an optimizer
optimizer = chainer.optimizers.MomentumSGD(lr=lr, momentum=0.99)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005))
# prepare iterators
train_iter = chainer.iterators.SerialIterator(
train_data, batch_size=batch_size)
test_iter = chainer.iterators.SerialIterator(
test_data, batch_size=1, repeat=False, shuffle=False)
updater = training.StandardUpdater(train_iter, optimizer, device=gpu)
trainer = training.Trainer(updater, (iterations, 'iteration'), out=out)
val_interval = 3000, 'iteration'
log_interval = 100, 'iteration'
trainer.extend(
TestModeEvaluator(test_iter, model, device=gpu), trigger=val_interval)
# reporter related
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.PrintReport(
['iteration', 'main/time',
'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy',
'main/accuracy_cls', 'validation/main/accuracy_cls',
'main/iu', 'validation/main/iu',
'main/fwavacc', 'validation/main/fwavacc']),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
# visualize training
trainer.extend(
extensions.PlotReport(
['main/loss', 'validation/main/loss'],
trigger=log_interval, file_name='loss.png')
)
trainer.extend(
extensions.PlotReport(
['main/accuracy', 'validation/main/accuracy'],
trigger=log_interval, file_name='accuracy.png')
)
trainer.extend(
extensions.PlotReport(
['main/accuracy_cls', 'validation/main/accuracy_cls'],
trigger=log_interval, file_name='accuracy_cls.png')
)
trainer.extend(
extensions.PlotReport(
['main/iu', 'validation/main/iu'],
trigger=log_interval, file_name='iu.png')
)
trainer.extend(
extensions.PlotReport(
['main/fwavacc', 'validation/main/fwavacc'],
trigger=log_interval, file_name='fwavacc.png')
)
trainer.extend(
SemanticSegmentationVisReport(
range(10), # visualize outputs for the first 10 data of test_data
test_data,
model,
n_class=n_class,
predict_func=model.extract # use FCN32s.extract to get a score map
),
trigger=val_interval, invoke_before_training=True)
trainer.extend(extensions.dump_graph('main/loss'))
if resume:
chainer.serializers.load_npz(osp.expanduser(resume), trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu', '-g', default=-1, type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--unit', '-u', default=300, type=int,
help='number of units')
parser.add_argument('--window', '-w', default=3, type=int,
help='window size')
parser.add_argument('--batchsize', '-b', type=int, default=10000,
help='learning minibatch size')
parser.add_argument('--epoch', '-e', default=30, type=int,
help='number of epochs to learn')
parser.add_argument('--model', '-m', choices=['skipgram', 'cbow'],
default='cbow',
help='model type ("skipgram", "cbow")')
parser.add_argument('--negative-size', default=5, type=int,
help='number of negative samples')
parser.add_argument('--out-type', '-o', choices=['hsm', 'ns', 'original'],
default='hsm',
help='output model type ("hsm": hierarchical softmax, '
'"ns": negative sampling, "original": '
'no approximation)')
parser.add_argument('--out', default='result',
help='Directory to output the result')
parser.add_argument('--test', dest='test', action='store_true')
parser.set_defaults(test=False)
args = parser.parse_args()
if args.gpu >= 0:
chainer.backends.cuda.get_device_from_id(args.gpu).use()
cuda.check_cuda_available()
print('GPU: {}'.format(args.gpu))
print('# unit: {}'.format(args.unit))
print('Window: {}'.format(args.window))
print('Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('Training model: {}'.format(args.model))
print('Output type: {}'.format(args.out_type))
print('')
if args.gpu >= 0:
cuda.get_device_from_id(args.gpu).use()
# Load the dataset
train, val, _ = chainer.datasets.get_ptb_words()
vocab = chainer.datasets.get_ptb_words_vocabulary()
train, val, _, vocab, original_index, ori_con_data = w2v_mi.get_pair(train, val, _, vocab)
counts = collections.Counter(train)
counts.update(collections.Counter(val))
n_vocab = max(train) + 1
if args.test:
train = train[:100]
val = val[:100]
index2word = {wid: word for word, wid in six.iteritems(vocab)}
print('n_vocab: %d' % n_vocab)
print('data length: %d' % len(train))
if args.out_type == 'hsm':
HSM = L.BinaryHierarchicalSoftmax
tree = HSM.create_huffman_tree(counts)
loss_func = HSM(args.unit, tree)
loss_func.W.data[...] = 0
elif args.out_type == 'ns':
cs = [counts[w] for w in range(len(counts))]
loss_func = L.NegativeSampling(args.unit, cs, args.negative_size)
loss_func.W.data[...] = 0
elif args.out_type == 'original':
loss_func = SoftmaxCrossEntropyLoss(args.unit, n_vocab)
else:
raise Exception('Unknown output type: {}'.format(args.out_type))
# Choose the model
if args.model == 'skipgram':
model = SkipGram(n_vocab, args.unit, loss_func)
elif args.model == 'cbow':
model = ContinuousBoW(n_vocab, args.unit, loss_func, ori_con_data)
else:
raise Exception('Unknown model type: {}'.format(args.model))
if args.gpu >= 0:
model.to_gpu()
# Set up an optimizer
optimizer = O.Adam()
optimizer.setup(model)
# Set up an iterator
train_iter = WindowIterator(train, args.window, args.batchsize, original_index)
val_iter = WindowIterator(val, args.window, args.batchsize, original_index, repeat=False)
# Set up an updater
updater = training.StandardUpdater(
train_iter, optimizer, converter=convert, device=args.gpu)
# Set up a trainer
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(extensions.Evaluator(
val_iter, model, converter=convert, device=args.gpu))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss']))
trainer.extend(extensions.ProgressBar())
trainer.run()
# Save the word2vec model
with open('word2vec.model', 'w') as f:
f.write('%d %d\n' % (len(index2word)-1, args.unit))
w = cuda.to_cpu(model.embed.W.data)
for i, wi in enumerate(w):
if i == len(index2word)-1:
print(i)
continue
v = ' '.join(map(str, wi))
f.write('%s %s\n' % (index2word[i], v))
def main():
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--resume',
'-r',
default='',
help='Resume the optimization from snapshot')
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
default=20,
type=int,
help='number of epochs to learn')
parser.add_argument('--dimz',
'-z',
default=20,
type=int,
help='dimention of encoded vector')
parser.add_argument('--batchsize',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--test',
action='store_true',
help='Use tiny datasets for quick tests')
parser.add_argument('--out',
'-o',
type=str,
default='./result/',
help='dir to save snapshots.')
parser.add_argument('--interval',
'-i',
type=int,
default=5,
help='interval of save images.')
parser.add_argument
args = parser.parse_args()
batchsize = args.batchsize
n_epoch = args.epoch
n_latent = args.dimz
print('GPU: {}'.format(args.gpu))
print('# dim z: {}'.format(args.dimz))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Prepare dataset
print('load MNIST dataset')
model = net.VAE(4096, n_latent, 500)
if args.gpu >= 0:
cuda.get_device(args.gpu).use()
model.to_gpu()
xp = np if args.gpu < 0 else cuda.cupy
# Setup optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
X = []
for i in range(1, 500):
fName = "./glasses/screened-glasses/%s.jpg" % (i)
n = np.ndarray.flatten(np.array(Image.open(fName).convert('L'),
'f')) / 255
X.append(n)
for i in range(1, 500):
fName = "./glasses/screened-solo/%s.JPG" % (i)
n = np.ndarray.flatten(np.array(Image.open(fName).convert('L'),
'f')) / 255
X.append(n)
X = np.array(X)
train_iter = chainer.iterators.SerialIterator(X, args.batchsize)
# test_iter = chainer.iterators.SerialIterator(
# test, args.batchsize, repeat=False, shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (1000, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
# trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
if not os.path.exists(os.path.join(args.out, 'cg.dot')):
print('dump computational graph of `main/loss`')
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
trainer.extend(
extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}'),
trigger=(args.interval, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# if you want to output different log files epoch by epoch,
# use below statement.
#trainer.extend(extensions.LogReport(log_name='log_'+'{epoch}'))
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss']))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
# # if you want to show the result images epoch by epoch,
# # use the extension below.
# @training.make_extension(trigger=(args.interval, 'epoch'))
# def save_images(trainer):
# out_dir = os.path.join(
# trainer.out, 'epoch_{}'.format(str(trainer.updater.epoch)))
# if not os.path.exists(out_dir):
# os.mkdir(out_dir)
# train_ind = [1, 3, 5, 10, 2, 0, 13, 15, 17]
# x = chainer.Variable(np.asarray(train[train_ind]), volatile='on')
# x1 = model.decode(model.encode(x)[0])
# save_image(x.data, filename=os.path.join(out_dir, 'train'))
# save_image(x1.data, filename=os.path.join(
# out_dir, 'train_reconstructed'))
# test_ind = [3, 2, 1, 18, 4, 8, 11, 17, 61]
# x = chainer.Variable(np.asarray(test[test_ind]), volatile='on')
# x1 = model(x)
# x1 = model.decode(model.encode(x)[0])
# save_image(x.data, filename=os.path.join(out_dir, 'test'))
# save_image(x1.data, filename=os.path.join(
# out_dir, 'test_reconstructed'))
# # draw images from randomly sampled z
# z = chainer.Variable(np.random.normal(
# 0, 1, (9, n_latent)).astype(np.float32))
# x = model.decode(z)
# save_image(x.data, filename=os.path.join(out_dir, 'sampled'))
# trainer.extend(save_images)
if args.resume:
# Resume from a snapshot
chainer.serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
def generate_graph(model_type, output_dir):
# Set up a neural network to train
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
model = L.Classifier(models[model_type](10))
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist(ndim=3)
train_iter = chainer.iterators.SerialIterator(train, 128)
test_iter = chainer.iterators.SerialIterator(test,
128,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=-1)
trainer = training.Trainer(updater, (2, 'epoch'), out=output_dir)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=-1))
# Take a snapshot for each specified epoch
trainer.extend(extensions.snapshot(filename=model_type),
trigger=(2, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
snapshot_path = os.path.join(output_dir, model_type)
if os.path.exists(snapshot_path):
# Resume from a snapshot
chainer.serializers.load_npz(snapshot_path, trainer)
else:
# Run the training
trainer.run()
example_input = numpy.expand_dims(
train[0][0], axis=0) # example input (anything ok, (batch_size, 784))
x = chainer.Variable(example_input)
y = model.predictor(x)
graph = ChainerConverter().convert(
[x], [y]) # convert graph to intermediate representation
return model, test, graph
def main():
parser = argparse.ArgumentParser(description='ChainerMN example: MNIST')
parser.add_argument('--batchsize', '-b', type=int, default=100,
help='Number of images in each mini-batch')
parser.add_argument('--communicator', type=str,
default='hierarchical', help='Type of communicator')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', action='store_true',
help='Use GPU')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--unit', '-u', type=int, default=1000,
help='Number of units')
args = parser.parse_args()
# Prepare ChainerMN communicator.
if args.gpu:
if args.communicator == 'naive':
print("Error: 'naive' communicator does not support GPU.\n")
exit(-1)
print('Using {} communicator'.format(args.communicator))
comm = chainermn.create_communicator(args.communicator)
device = comm.intra_rank
else:
if args.communicator != 'naive':
print('Warning: using naive communicator '
'because only naive supports CPU-only execution')
comm = chainermn.create_communicator('naive')
device = -1
if comm.mpi_comm.rank == 0:
print('GPU: {}'.format(device))
print('# unit: {}'.format(args.unit))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
model = L.Classifier(MLP(args.unit, 10))
if device >= 0:
chainer.cuda.get_device(device).use()
model.to_gpu()
# Create a multi node optimizer from a standard Chainer optimizer.
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.Adam(), comm)
optimizer.setup(model)
# Split and distribute the dataset. Only worker 0 loads the whole dataset.
# Datasets of worker 0 are evenly split and distributed to all workers.
if comm.rank == 0:
train, test = chainer.datasets.get_mnist()
else:
train, test = None, None
train = chainermn.scatter_dataset(train, comm)
test = chainermn.scatter_dataset(test, comm)
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
repeat=False, shuffle=False)
updater = training.StandardUpdater(train_iter, optimizer, device=device)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Create a multi node evaluator from a standard Chainer evaluator.
evaluator = extensions.Evaluator(test_iter, model, device=device)
evaluator = chainermn.create_multi_node_evaluator(evaluator, comm)
trainer.extend(evaluator)
# Some display and output extensions are necessary only for one worker.
# (Otherwise, there would just be repeated outputs.)
if comm.rank == 0:
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
trainer.extend(extensions.ProgressBar())
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-g', '--gpu', type=int, default=0)
args = parser.parse_args()
args.max_iteration = 10000
args.interval_eval = 1000
args.interval_print = 10
args.git_hash = instance_occlsegm_lib.utils.git_hash(__file__)
args.hostname = socket.gethostname()
now = datetime.datetime.now()
args.timestamp = now.isoformat()
args.out = osp.join(here, 'logs', now.strftime('%Y%m%d_%H%M%S'))
try:
os.makedirs(args.out)
except OSError:
pass
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
data = synthetic2d.datasets.InstanceImageDataset(load_pred=False)
class_names = data.class_names
data_train = chainer.datasets.TransformDataset(data, Transform(train=True))
iter_train = chainer.iterators.SerialIterator(data_train, batch_size=1)
iter_test = chainer.iterators.SerialIterator(data, batch_size=1)
model = synthetic2d.models.FCN8sAtOnce(n_class=len(class_names))
vgg16 = fcn.models.VGG16()
chainer.serializers.load_npz(vgg16.download(), vgg16)
model.init_from_vgg16(vgg16)
model = chainercv.links.PixelwiseSoftmaxClassifier(predictor=model)
if args.gpu >= 0:
model.to_gpu()
optimizer = chainer.optimizers.Adam(alpha=1e-5)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005))
model.predictor.upscore2.disable_update()
model.predictor.upscore_pool4.disable_update()
model.predictor.upscore8.disable_update()
updater = training.StandardUpdater(iter_train, optimizer, device=args.gpu)
trainer = training.Trainer(updater,
stop_trigger=(args.max_iteration, 'iteration'),
out=args.out)
trainer.extend(synthetic2d.extensions.ParamsReport(args.__dict__))
trainer.extend(extensions.snapshot_object(
target=model.predictor, filename='model_{.updater.iteration:08}.npz'),
trigger=(args.interval_eval, 'iteration'))
trainer.extend(
extensions.LogReport(trigger=(args.interval_print, 'iteration')))
trainer.extend(
extensions.PrintReport(
['epoch', 'iteration', 'elapsed_time', 'main/loss']))
assert extensions.PlotReport.available()
trainer.extend(
extensions.PlotReport(y_keys=['main/loss'],
x_key='iteration',
file_name='loss.png',
trigger=(args.interval_print, 'iteration')))
trainer.extend(synthetic2d.extensions.SemanticSegmentationVisReport(
iter_test,
transform=Transform(train=False),
class_names=class_names,
device=args.gpu,
shape=(15, 5)),
trigger=(args.interval_print, 'iteration'))
trainer.extend(extensions.ProgressBar(update_interval=5))
trainer.run()
def main():
args = parser()
# 時間読み込み
now = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
# 保存ディレクトリ先
save_dir = Path('result') / now
log_dir = save_dir / 'log'
model_dir = save_dir / 'model'
snap_dir = save_dir / 'snap'
matrix_dir = save_dir / 'matrix'
# 保存ディレクトリ先作成
save_dir.mkdir(exist_ok=True, parents=True)
log_dir.mkdir(exist_ok=True, parents=True)
model_dir.mkdir(exist_ok=True, parents=True)
snap_dir.mkdir(exist_ok=True, parents=True)
matrix_dir.mkdir(exist_ok=True, parents=True)
# Dataset読み込み
root = args.dataset
dir_list = os.listdir(root)
dir_list.sort()
if 'mean.npy' in dir_list:
dir_list.remove('mean.npy')
# datasetに画像ファイルとラベルを読み込む
print('dataset loading ...')
datasets = DirectoryParsingLabelDataset(root)
print('finish!')
# クラス数
class_num = len(set(datasets.labels))
print('class number : {}'.format(class_num))
# fold数
k_fold = args.kfold
print('k_fold : {}'.format(k_fold))
X = np.array([image_paths for image_paths in datasets.img_paths])
y = np.array([label for label in datasets.labels])
kfold = StratifiedKFold(n_splits=k_fold, shuffle=True, random_state=402).split(X, y)
for k, (train_idx, val_idx) in enumerate(kfold):
print("============= {} fold training =============".format(k + 1))
X_train, y_train = X[train_idx], y[train_idx]
X_val, y_val = X[val_idx], y[val_idx]
# 画像とラベルをセットにしたデータセットを作る
train = LabeledImageDataset([(x, y) for x, y in zip(X_train, y_train)])
validation = LabeledImageDataset([(x, y) for x, y in zip(X_val, y_val)])
train, validation, mean = get_dataset(train, validation, root, datasets, use_mean=True)
# model setup
#model = L.Classifier(archs[args.arch](output=class_num))
model = ABNClassifier(archs[args.arch](output=class_num))
lr = args.lr
optimizer = chainer.optimizers.MomentumSGD(lr)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0001))
# using GPU
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# setup iterators
train_iter = chainer.iterators.MultithreadIterator(train, args.batchsize, n_threads=8)
validation_iter = chainer.iterators.MultithreadIterator(validation, args.batchsize,
repeat=False, shuffle=False, n_threads=8)
# setup updater and trainer
updater = training.StandardUpdater(
train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(
updater, (args.epoch, 'epoch'), out=save_dir)
# set extensions
log_trigger = (1, 'epoch')
target = 'lr'
trainer.extend(CosineShift(target, args.epoch, 1),
trigger=(1, "epoch"))
trainer.extend(extensions.Evaluator(validation_iter, model, device=args.gpu),
trigger=log_trigger)
snap_name = '{}-{}_fold_model.npz'.format(k_fold, k+1)
trainer.extend(extensions.snapshot_object(model, str(snap_name)),
trigger=chainer.training.triggers.MaxValueTrigger(
key='validation/main/accuracy', trigger=(1, 'epoch')))
log_name = '{}-{}_fold_log.json'.format(k_fold, k+1)
trainer.extend(extensions.LogReport(
log_name=str(log_name), trigger=log_trigger))
trainer.extend(extensions.observe_lr(), trigger=log_trigger)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration',
'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy',
'elapsed_time', 'lr'
]), trigger=(1, 'epoch'))
trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch',file_name='loss{}.png'.format(k+1)))
trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'],
'epoch', file_name='accuracy{}.png'.format(k+1)))
trainer.extend(extensions.ProgressBar(update_interval=10))
#if args.resume:
#chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
snap_file = save_dir / snap_name
shutil.move(str(snap_file), str(snap_dir))
log_file = save_dir / log_name
shutil.move(str(log_file), str(log_dir))
# model save
save_model = model_dir / "{}_{}-{}_fold.npz".format(now, k_fold, k + 1)
chainer.serializers.save_npz(str(save_model), model)
print("============= {} fold Evaluation =============".format(k + 1))
# 画像フォルダ
dnames = glob.glob('{}/*'.format(root))
labels_list = []
for d in dnames:
p_dir = Path(d)
labels_list.append(p_dir.name)
if 'mean.npy' in labels_list:
labels_list.remove('mean.npy')
confusion_matrix_cocoa(validation, args.gpu, 8,
model, matrix_dir, k, labels_list)
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
print 'using GPU \n'
start_time = time.time() #start time measurement
# train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
# validation_iter = chainer.iterators.SerialIterator(validation, args.batchsize, repeat=False)
train_iter = chainer.iterators.MultiprocessIterator(
train, args.batchsize, n_processes=args.loaderjob)
validation_iter = chainer.iterators.MultiprocessIterator(
validation, args.batchsize, repeat=False, n_processes=args.loaderjob)
updater = training.StandardUpdater(train_iter,
optimizer,
device=args.gpu,
converter=myConverter)
trainer = training.Trainer(updater, (args.epoch, 'epoch'))
trainer.extend(
extensions.Evaluator(validation_iter,
model,
device=args.gpu,
converter=myConverter))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport(
['epoch', 'main/accuracy', 'validation/main/accuracy']))
#trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss','main/accuracy', 'validation/main/accuracy']))
trainer.extend(extensions.ProgressBar())
trainer.run()
def main():
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
choices_dataset = ['real', 'synthetic']
parser.add_argument('dataset', choices=choices_dataset, help='dataset')
parser.add_argument('-g', '--gpu', type=int, default=0, help='gpu id')
choices_model = ['fcn8s', 'fcn32s']
parser.add_argument('-m',
'--model',
choices=choices_model,
default=choices_model[0],
help='model file')
parser.add_argument('--freeze',
choices=['conv5', 'fc6', 'fc7'],
help='end layer to freeze feature extractor')
args = parser.parse_args()
args.max_iteration = int(100e3)
args.interval_eval = int(1e3)
args.interval_print = 10
args.git_hash = instance_occlsegm_lib.utils.git_hash(__file__)
args.hostname = socket.gethostname()
now = datetime.datetime.now()
args.timestamp = now.isoformat()
args.out = osp.join(here, 'logs', now.strftime('%Y%m%d_%H%M%S'))
try:
os.makedirs(args.out)
except OSError:
pass
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
if args.dataset == 'real':
data_train = instance_occlsegm_lib.datasets.apc.\
ARC2017SemanticSegmentationDataset(split='train')
class_names = data_train.class_names
data_train = chainer.datasets.TransformDataset(data_train,
Transform(train=True))
elif args.dataset == 'synthetic':
data_train = synthetic2d.datasets.ARC2017SyntheticDataset(
do_aug=True, aug_level='object')
class_names = data_train.class_names
data_train = chainer.datasets.TransformDataset(data_train,
Transform(train=True))
else:
raise ValueError
iter_train = chainer.iterators.MultiprocessIterator(data_train,
batch_size=1,
shared_mem=10**7)
data_test = instance_occlsegm_lib.datasets.apc.\
ARC2017SemanticSegmentationDataset(split='test')
data_test = chainer.datasets.TransformDataset(data_test,
Transform(train=False))
iter_test = chainer.iterators.SerialIterator(data_test,
batch_size=1,
repeat=False,
shuffle=False)
if args.model == 'fcn8s':
model = synthetic2d.models.FCN8sAtOnce(n_class=len(class_names))
elif args.model == 'fcn32s':
model = synthetic2d.models.FCN32s(n_class=len(class_names))
else:
raise ValueError
vgg16 = fcn.models.VGG16()
chainer.serializers.load_npz(vgg16.pretrained_model, vgg16)
model.init_from_vgg16(vgg16)
model = chainercv.links.PixelwiseSoftmaxClassifier(predictor=model)
if args.gpu >= 0:
model.to_gpu()
optimizer = chainer.optimizers.Adam(alpha=1e-5)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005))
if args.model == 'FCN8sAtOnce':
model.predictor.upscore2.disable_update()
model.predictor.upscore_pool4.disable_update()
model.predictor.upscore8.disable_update()
elif args.model == 'FCN32s':
model.predictor.upscore.disable_update()
if args.freeze in ['conv5', 'fc6', 'fc7']:
model.predictor.conv5_1.disable_update()
model.predictor.conv5_2.disable_update()
model.predictor.conv5_3.disable_update()
if args.freeze in ['fc6', 'fc7']:
model.predictor.fc6.disable_update()
if args.freeze in ['fc7']:
model.predictor.fc7.disable_update()
updater = training.StandardUpdater(iter_train, optimizer, device=args.gpu)
trainer = training.Trainer(updater,
stop_trigger=(args.max_iteration, 'iteration'),
out=args.out)
trainer.extend(SemanticSegmentationEvaluator(iter_test,
model.predictor,
label_names=class_names),
trigger=(args.interval_eval, 'iteration'))
# logging
trainer.extend(synthetic2d.extensions.ParamsReport(args.__dict__))
trainer.extend(
extensions.LogReport(trigger=(args.interval_print, 'iteration')))
trainer.extend(
extensions.PrintReport([
'epoch', 'iteration', 'elapsed_time', 'main/loss',
'validation/main/miou'
]))
trainer.extend(extensions.ProgressBar(update_interval=5))
# plotting
assert extensions.PlotReport.available()
trainer.extend(
extensions.PlotReport(y_keys=['main/loss'],
x_key='iteration',
file_name='loss.png',
trigger=(args.interval_print, 'iteration')))
trainer.extend(
extensions.PlotReport(y_keys=['validation/main/miou'],
x_key='iteration',
file_name='miou.png',
trigger=(args.interval_print, 'iteration')))
# snapshotting
trainer.extend(extensions.snapshot_object(target=model.predictor,
filename='model_best.npz'),
trigger=training.triggers.MaxValueTrigger(
key='validation/main/miou',
trigger=(args.interval_eval, 'iteration')))
# visualizing
data_test_raw = instance_occlsegm_lib.datasets.apc.\
ARC2017SemanticSegmentationDataset(split='test')
iter_test_raw = chainer.iterators.SerialIterator(data_test_raw,
batch_size=1,
repeat=False,
shuffle=False)
trainer.extend(synthetic2d.extensions.SemanticSegmentationVisReport(
iter_test_raw,
transform=Transform(train=False),
class_names=class_names,
device=args.gpu,
shape=(6, 2)),
trigger=(args.interval_eval, 'iteration'))
trainer.run()
def main():
parser = argparse.ArgumentParser(
description='Chainer example: convolutional seq2seq')
parser.add_argument('--batchsize',
'-b',
type=int,
default=32,
help='Number of images in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--unit',
'-u',
type=int,
default=512,
help='Number of units')
parser.add_argument('--layer',
'-l',
type=int,
default=6,
help='Number of layers')
parser.add_argument('--input',
'-i',
type=str,
default='./',
help='Input directory')
parser.add_argument('--source',
'-s',
type=str,
default='europarl-v7.fr-en.en',
help='Filename of train data for source language')
parser.add_argument('--target',
'-t',
type=str,
default='europarl-v7.fr-en.fr',
help='Filename of train data for target language')
parser.add_argument('--source-valid',
'-svalid',
type=str,
default='dev/newstest2013.en',
help='Filename of validation data for source language')
parser.add_argument('--target-valid',
'-tvalid',
type=str,
default='dev/newstest2013.fr',
help='Filename of validation data for target language')
parser.add_argument('--out',
'-o',
default='result',
help='Directory to output the result')
parser.add_argument('--source-vocab',
type=int,
default=40000,
help='Vocabulary size of source language')
parser.add_argument('--target-vocab',
type=int,
default=40000,
help='Vocabulary size of target language')
parser.add_argument('--no-bleu', '-no-bleu', action='store_true')
args = parser.parse_args()
print(json.dumps(args.__dict__, indent=4))
# Check file
en_path = os.path.join(args.input, args.source)
source_vocab = ['<eos>', '<unk>'] + \
europal.count_words(en_path, args.source_vocab)
source_data = europal.make_dataset(en_path, source_vocab)
fr_path = os.path.join(args.input, args.target)
target_vocab = ['<eos>', '<unk>'] + \
europal.count_words(fr_path, args.target_vocab)
target_data = europal.make_dataset(fr_path, target_vocab)
assert len(source_data) == len(target_data)
print('Original training data size: %d' % len(source_data))
train_data = [(s, t) for s, t in six.moves.zip(source_data, target_data)
if 0 < len(s) < 50 and 0 < len(t) < 50]
print('Filtered training data size: %d' % len(train_data))
en_path = os.path.join(args.input, args.source_valid)
source_data = europal.make_dataset(en_path, source_vocab)
fr_path = os.path.join(args.input, args.target_valid)
target_data = europal.make_dataset(fr_path, target_vocab)
assert len(source_data) == len(target_data)
test_data = [(s, t) for s, t in six.moves.zip(source_data, target_data)
if 0 < len(s) and 0 < len(t)]
source_ids = {word: index for index, word in enumerate(source_vocab)}
target_ids = {word: index for index, word in enumerate(target_vocab)}
target_words = {i: w for w, i in target_ids.items()}
source_words = {i: w for w, i in source_ids.items()}
# Define Model
model = net.Seq2seq(args.layer, min(len(source_ids), len(source_words)),
min(len(target_ids), len(target_words)), args.unit)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu(args.gpu)
# Setup Optimizer
optimizer = chainer.optimizers.Adam(alpha=args.unit**(-0.5),
beta1=0.9,
beta2=0.98,
eps=1e-9)
optimizer.setup(model)
# Setup Trainer
train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_data,
args.batchsize,
repeat=False,
shuffle=False)
iter_per_epoch = len(train_data) // args.batchsize
print('Number of iter/epoch =', iter_per_epoch)
updater = training.StandardUpdater(train_iter,
optimizer,
converter=seq2seq_pad_concat_convert,
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# TODO lengthen this interval
# If you want to change a logging interval, change this number
log_trigger = (min(100, iter_per_epoch // 2), 'iteration')
def floor_step(trigger):
floored = trigger[0] - trigger[0] % log_trigger[0]
if floored <= 0:
floored = trigger[0]
return (floored, trigger[1])
# Validation every half epoch
eval_trigger = floor_step((iter_per_epoch // 2, 'iteration'))
record_trigger = training.triggers.MinValueTrigger('val/main/perp',
eval_trigger)
evaluator = extensions.Evaluator(test_iter,
model,
converter=seq2seq_pad_concat_convert,
device=args.gpu)
evaluator.default_name = 'val'
trainer.extend(evaluator, trigger=eval_trigger)
# Use Vaswan's magical rule of learning rate (Eq. 3 in the paper)
trainer.extend(VaswaniRule('alpha', d=args.unit, warmup_steps=4000),
trigger=(1, 'iteration'))
trainer.extend(extensions.observe_lr(observation_key='alpha'),
trigger=(1, 'iteration'))
# Only if a model gets best validation score,
# save the model
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}.npz'),
trigger=record_trigger)
def translate_one(source, target):
words = europal.split_sentence(source)
print('# source : ' + ' '.join(words))
x = model.xp.array([source_ids.get(w, 1) for w in words], 'i')
ys = model.translate([x])[0]
words = [target_words[y] for y in ys]
print('# result : ' + ' '.join(words))
print('# expect : ' + target)
@chainer.training.make_extension(trigger=(200, 'iteration'))
def translate(trainer):
translate_one('Who are we ?', 'Qui sommes-nous?')
translate_one(
'And it often costs over a hundred dollars ' +
'to obtain the required identity card .',
'Or, il en coûte souvent plus de cent dollars ' +
'pour obtenir la carte d\'identité requise.')
source, target = test_data[numpy.random.choice(len(test_data))]
source = ' '.join([source_words[i] for i in source])
target = ' '.join([target_words[i] for i in target])
translate_one(source, target)
# Gereneration Test
trainer.extend(translate, trigger=(min(200, iter_per_epoch), 'iteration'))
# Calculate BLEU every half epoch
if not args.no_bleu:
trainer.extend(CalculateBleu(model,
test_data,
'val/main/bleu',
device=args.gpu,
batch=args.batchsize // 4),
trigger=floor_step((iter_per_epoch // 2, 'iteration')))
# Log
trainer.extend(extensions.LogReport(trigger=log_trigger),
trigger=log_trigger)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'val/main/loss', 'main/perp',
'val/main/perp', 'main/acc', 'val/main/acc', 'val/main/bleu', 'alpha',
'elapsed_time'
]),
trigger=log_trigger)
print('start training')
trainer.run()
def main():
# %% Load datasets
train, valid, test, train_moles, valid_moles, test_moles = load_dataset(
CTYPE)
train_gp = train.groupby('molecule_name')
valid_gp = valid.groupby('molecule_name')
test_gp = test.groupby('molecule_name')
# %%
structures = pd.read_csv(DATA_PATH / 'structures.csv')
giba_features = pd.read_csv(
DATA_PATH / 'unified-features' / 'giba_features.csv', index_col=0)
structures = pd.merge(structures, giba_features.drop(
['atom_name', 'x', 'y', 'z'], axis=1), on=['molecule_name', 'atom_index'])
norm_col = [col for col in structures.columns if col not in [
'molecule_name', 'atom_index', 'atom', 'x', 'y', 'z']]
structures[norm_col] = (
structures[norm_col] - structures[norm_col].mean()) / structures[norm_col].std()
structures = structures.fillna(0)
structures_groups = structures.groupby('molecule_name')
# %%
if CTYPE != 'all':
train_couple = pd.read_csv(DATA_PATH / 'typewise-dataset' / 'kuma_dataset'
/ 'kuma_dataset' / 'train' / '{}_full.csv'.format(CTYPE), index_col=0)
else:
train_couple = pd.read_csv(DATA_PATH / 'typewise-dataset'
/ 'kuma_dataset' / 'kuma_dataset' / 'train_all.csv', index_col=0)
train_couple = reduce_mem_usage(train_couple)
train_couple = train_couple.drop(
['id', 'scalar_coupling_constant', 'type'], axis=1)
if CTYPE != 'all':
test_couple = pd.read_csv(DATA_PATH / 'typewise-dataset' / 'kuma_dataset'
/ 'kuma_dataset' / 'test' / '{}_full.csv'.format(CTYPE), index_col=0)
else:
test_couple = pd.read_csv(DATA_PATH / 'typewise-dataset'
/ 'kuma_dataset' / 'kuma_dataset' / 'test_all.csv', index_col=0)
test_couple = reduce_mem_usage(test_couple)
test_couple = test_couple.drop(['id', 'type'], axis=1)
couples = pd.concat([train_couple, test_couple])
del train_couple, test_couple
couples_norm_col = [col for col in couples.columns if col not in [
'atom_index_0', 'atom_index_1', 'molecule_name', 'type']]
for col in couples_norm_col:
if couples[col].dtype == np.dtype('O'):
couples = pd.get_dummies(couples, columns=[col])
else:
couples[col] = (couples[col] - couples[col].mean()
) / couples[col].std()
couples = couples.fillna(0)
couples = couples.replace(np.inf, 0)
couples = couples.replace(-np.inf, 0)
couples_groups = couples.groupby('molecule_name')
# %% Make graphs
feature_col = [col for col in structures.columns if col not in [
'molecule_name', 'atom_index', 'atom']]
list_atoms = list(set(structures['atom']))
print('list of atoms')
print(list_atoms)
train_graphs = list()
train_targets = list()
train_couples = list()
print('preprocess training molecules ...')
for mole in tqdm(train_moles):
train_graphs.append(Graph(structures_groups.get_group(
mole), list_atoms, feature_col, mole))
train_targets.append(train_gp.get_group(mole))
train_couples.append(couples_groups.get_group(mole))
valid_graphs = list()
valid_targets = list()
valid_couples = list()
print('preprocess validation molecules ...')
for mole in tqdm(valid_moles):
valid_graphs.append(Graph(structures_groups.get_group(
mole), list_atoms, feature_col, mole))
valid_targets.append(valid_gp.get_group(mole))
valid_couples.append(couples_groups.get_group(mole))
test_graphs = list()
test_targets = list()
test_couples = list()
print('preprocess test molecules ...')
for mole in tqdm(test_moles):
test_graphs.append(Graph(structures_groups.get_group(
mole), list_atoms, feature_col, mole))
test_targets.append(test_gp.get_group(mole))
test_couples.append(couples_groups.get_group(mole))
# %% Make datasets
train_dataset = DictDataset(
graphs=train_graphs, targets=train_targets, couples=train_couples)
valid_dataset = DictDataset(
graphs=valid_graphs, targets=valid_targets, couples=valid_couples)
test_dataset = DictDataset(
graphs=test_graphs, targets=test_targets, couples=test_couples)
# %% Build Model
model = WeaveNet(n_sub_layer=3)
model.to_gpu(device=0)
# %% Sampler
train_sampler = SameSizeSampler(structures_groups, train_moles, BATCH_SIZE)
valid_sampler = SameSizeSampler(structures_groups, valid_moles, BATCH_SIZE,
use_remainder=True)
test_sampler = SameSizeSampler(structures_groups, test_moles, BATCH_SIZE,
use_remainder=True)
# %% Iterator, Optimizer
train_iter = chainer.iterators.SerialIterator(
train_dataset, BATCH_SIZE, order_sampler=train_sampler)
valid_iter = chainer.iterators.SerialIterator(
valid_dataset, BATCH_SIZE, repeat=False, order_sampler=valid_sampler)
test_iter = chainer.iterators.SerialIterator(
test_dataset, BATCH_SIZE, repeat=False, order_sampler=test_sampler)
optimizer = optimizers.Adam(alpha=1e-3)
optimizer.setup(model)
# %% Updater
if opt.multi_gpu:
updater = training.updaters.ParallelUpdater(
train_iter,
optimizer,
# The device of the name 'main' is used as a "master", while others are
# used as slaves. Names other than 'main' are arbitrary.
devices={'main': 0, 'sub1': 1, 'sub2': 2, 'sub3': 3},
)
else:
updater = training.StandardUpdater(train_iter, optimizer,
converter=coupling_converter, device=0)
# early_stopping
stop_trigger = triggers.EarlyStoppingTrigger(patients=EARLY_STOPPING_ROUNDS,
monitor='valid/main/ALL_LogMAE',
max_trigger=(EPOCH, 'epoch'))
trainer = training.Trainer(updater, stop_trigger, out=RESULT_PATH)
# %% Evaluator
trainer.extend(
TypeWiseEvaluator(iterator=valid_iter, target=model, converter=coupling_converter,
name='valid', device=0, is_validate=True))
trainer.extend(
TypeWiseEvaluator(iterator=test_iter, target=model, converter=coupling_converter,
name='test', device=0, is_submit=True))
# %% Other extensions
trainer.extend(training.extensions.ExponentialShift('alpha', 0.99999))
trainer.extend(stop_train_mode(trigger=(1, 'epoch')))
trainer.extend(
training.extensions.observe_value(
'alpha', lambda tr: tr.updater.get_optimizer('main').alpha))
trainer.extend(training.extensions.LogReport(
log_name=f'weavenet_log_{CTYPE}'))
trainer.extend(training.extensions.PrintReport(
['epoch', 'elapsed_time', 'main/loss', 'valid/main/ALL_LogMAE', 'alpha']))
# trainer.extend(extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}'))
trainer.extend(SaveRestore(filename=f'weavenet_best_epoch_{CTYPE}'),
trigger=triggers.MinValueTrigger('valid/main/ALL_LogMAE'))
# %% Train
chainer.config.train = True
trainer.run()
# %% Final Evaluation
chainer.config.train = False
y_total = []
t_total = []
test_iter.reset()
for batch in test_iter:
in_arrays = coupling_converter(batch, 0)
with chainer.no_backprop_mode(), chainer.using_config('train', False):
y = model.predict(**in_arrays)
y_data = cuda.to_cpu(y.data)
y_total.append(y_data)
t_total.extend([d['targets'] for d in batch])
df_truth = pd.concat(t_total, axis=0)
y_pred = np.sum(np.concatenate(y_total), axis=1)
submit = pd.DataFrame()
submit['id'] = df_truth['id']
submit['scalar_coupling_constant'] = y_pred
submit.drop_duplicates(subset='id', inplace=True)
submit.sort_values('id', inplace=True)
submit.to_csv(f'weavenet_{CTYPE}.csv', index=False)
def main():
archs = {
'googlenet': googlenet_sigmoid.GoogLeNet,
'resnet50': resnet50_2_sigmoid.ResNet50
}
archs_softmax = {
'googlenet': googlenet.GoogLeNet,
'resnet50': resnet50_2.ResNet50
}
parser = argparse.ArgumentParser(
description='Learning convnet from ILSVRC2012 dataset')
parser.add_argument('train', help='Path to training image-label list file')
parser.add_argument('val', help='Path to validation image-label list file')
parser.add_argument('--arch',
'-a',
choices=archs.keys(),
default='googlenet',
help='Convnet architecture')
parser.add_argument('--batchsize',
'-B',
type=int,
default=32,
help='Learning minibatch size')
parser.add_argument('--epoch',
'-E',
type=int,
default=10,
help='Number of epochs to train')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU')
parser.add_argument('--initmodel',
help='Initialize the model from given file')
parser.add_argument('--loaderjob',
'-j',
type=int,
help='Number of parallel data loading processes')
parser.add_argument('--mean',
'-m',
default='mean.npy',
help='Mean file (computed by compute_mean.py)')
parser.add_argument('--resume',
'-r',
default='',
help='Initialize the trainer from given file')
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--root',
'-R',
default='.',
help='Root directory path of image files')
parser.add_argument('--optimizer', default='adam', help='optimizer')
parser.add_argument('--weight_decay',
type=float,
default=0.0001,
help='weight decay')
parser.add_argument('--lr_shift',
type=float,
default=0.5,
help='lr exponential shift. 0 mean not to shift')
parser.add_argument('--val_batchsize',
'-b',
type=int,
default=250,
help='Validation minibatch size')
parser.add_argument('--test', action='store_true')
parser.set_defaults(test=False)
args = parser.parse_args()
model_cls = archs[args.arch]
model_softmax_cls = archs_softmax[args.arch]
# Load the datasets and mean file
insize = model_cls.insize
mean = np.load(args.mean)
train = PreprocessedDataset(args.train, args.root, mean, insize)
val = PreprocessedDataset(args.val, args.root, mean, insize, False)
# Initialize the model to train
model = model_cls(output_size=len(train.get_example(0)[1]))
if args.initmodel:
print('Load model from', args.initmodel)
try:
chainer.serializers.load_npz(args.initmodel, model)
except ValueError as e:
print('not match model. try default ModelClass. "{}"'.format(e))
src_model = model_softmax_cls()
chainer.serializers.load_npz(args.initmodel, src_model)
copy_model(src_model, model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use() # Make the GPU current
model.to_gpu()
# These iterators load the images with subprocesses running in parallel to
# the training/validation.
train_iter = chainer.iterators.MultiprocessIterator(
train, args.batchsize, n_processes=args.loaderjob)
val_iter = chainer.iterators.MultiprocessIterator(
val, args.val_batchsize, repeat=False, n_processes=args.loaderjob)
# Set up an optimizer
# optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
if args.optimizer == 'adam':
optimizer = chainer.optimizers.Adam()
else:
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(args.weight_decay))
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.out)
val_interval = (1 if args.test else 100000), 'iteration'
log_interval = (1 if args.test else 1000), 'iteration'
test_interval = 1, 'epoch'
trainer.extend(extensions.Evaluator(val_iter, model, device=args.gpu),
trigger=test_interval)
trainer.extend(extensions.dump_graph('main/loss'))
#trainer.extend(extensions.snapshot(), trigger=val_interval)
#trainer.extend(extensions.snapshot_object(
# model, 'model_iter_{.updater.iteration}'), trigger=val_interval)
trainer.extend(
extensions.snapshot(filename='snapshot_epoch-{.updater.epoch}'))
trainer.extend(
extensions.snapshot_object(model,
filename='model_epoch-{.updater.epoch}'))
# Be careful to pass the interval directly to LogReport
# (it determines when to emit log rather than when to read observations)
trainer.extend(extensions.LogReport(trigger=test_interval))
trainer.extend(extensions.observe_lr(), trigger=test_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'lr'
]),
trigger=test_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.lr_shift > 0:
# Reduce the learning rate by half every 25 epochs.
if args.optimizer == 'adam':
trainer.extend(extensions.ExponentialShift('alpha', args.lr_shift),
trigger=(25, 'epoch'))
else:
trainer.extend(extensions.ExponentialShift('lr', args.lr_shift),
trigger=(25, 'epoch'))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
# Introduce argparse for clarity and organization.
# Starting to use higher capacity models, thus set up for GPU.
parser = argparse.ArgumentParser(description='Chainer-Tutorial: MLP')
parser.add_argument('--batch_size',
'-b',
type=int,
default=128,
help='Number of samples in each mini-batch')
parser.add_argument('--epoch',
'-e',
type=int,
default=100,
help='Number of times to train on data set')
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID: -1 indicates CPU')
args = parser.parse_args()
# Load mnist data
# http://docs.chainer.org/en/latest/reference/datasets.html
train, test = chainer.datasets.get_mnist()
# Define iterators.
train_iter = chainer.iterators.SerialIterator(train, args.batch_size)
test_iter = chainer.iterators.SerialIterator(test,
args.batch_size,
repeat=False,
shuffle=False)
# Initialize model: Loss function defaults to softmax_cross_entropy.
# 784 is dimension of the inputs, 625 is n_units in hidden layer
# and 10 is the output dimension.
model = L.Classifier(MLP(625, 10))
# Set up GPU usage if necessary. args.gpu is a condition as well as an
# identification when passed to get_device().
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
model.to_gpu()
# Define optimizer (SGD, Adam, RMSProp, etc)
# http://docs.chainer.org/en/latest/reference/optimizers.html
optimizer = chainer.optimizers.SGD()
optimizer.setup(model)
# Set up trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'))
# Evaluate the model at end of each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Helper functions (extensions) to monitor progress on stdout.
report_params = [
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(report_params))
trainer.extend(extensions.ProgressBar())
# Run trainer
trainer.run()
def main():
'''
main function, start point
'''
# 引数関連
parser = argparse.ArgumentParser()
parser.add_argument('--batchsize', '-b', type=int, default=128,
help='Number of images in each mini-batch')
parser.add_argument('--learnrate', '-l', type=float, default=0.01,
help='Learning rate for SGD')
parser.add_argument('--epoch', '-e', type=int, default=100,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=0,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--iter_parallel', action='store_true', default=False,
help='filter(kernel) sizes')
parser.add_argument('--opt' , '-o', type=str, choices=('adam', 'sgd') ,default='sgd')
args = parser.parse_args()
# parameter出力
print("-=Learning Parameter=-")
print("# Max Epochs: {}".format(args.epoch))
print("# Batch Size: {}".format(args.batchsize))
print("# Learning Rate: {}".format(args.learnrate))
print("# Optimizer Method: {}".format(args.opt))
print('# Train Dataet: General 100')
if args.iter_parallel:
print("# Data Iters that loads in Parallel")
print("\n")
# 保存ディレクトリ
# save didrectory
outdir = path.join(
ROOT_PATH, 'results/FINet3_opt_{}'.format(args.opt))
if not path.exists(outdir):
os.makedirs(outdir)
with open(path.join(outdir, 'arg_param.txt'), 'w') as f:
for k, v in args.__dict__.items():
f.write('{}:{}\n'.format(k, v))
print('# loading dataet(General100_train, General100_test) ...')
train = SequenceDatasetOnMem(dataset='train')
test = SequenceDatasetOnMem(dataset='test')
# prepare model
model = N.GenEvaluator(N.FINet3())
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# setup optimizer
if args.opt == 'adam':
optimizer = chainer.optimizers.Adam()
elif args.opt == 'sgd':
optimizer = chainer.optimizers.MomentumSGD(lr=args.learnrate, momentum=0.9)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
# setup iter
if args.iter_parallel:
train_iter = chainer.iterators.MultiprocessIterator(
train, args.batchsize, n_processes=6)
test_iter = chainer.iterators.MultiprocessIterator(
test, args.batchsize, repeat=False, shuffle=False, n_processes=6)
else:
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(
test, args.batchsize, repeat=False, shuffle=False)
# setup trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=outdir)
# # eval test data
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# dump loss graph
trainer.extend(extensions.dump_graph('main/loss'))
# lr shift
if args.opt == 'sgd':
trainer.extend(extensions.ExponentialShift("lr", 0.1), trigger=(100, 'epoch'))
elif args.opt == 'adam':
trainer.extend(extensions.ExponentialShift("alpha", 0.1), trigger=(50, 'epoch'))
# save snapshot
trainer.extend(extensions.snapshot(), trigger=(10, 'epoch'))
trainer.extend(extensions.snapshot_object(
model, 'model_snapshot_{.updater.epoch}'), trigger=(10, 'epoch'))
# log report
trainer.extend(extensions.LogReport())
trainer.extend(extensions.observe_lr(), trigger=(1, 'epoch'))
# plot loss graph
trainer.extend(
extensions.PlotReport(['main/loss', 'validation/main/loss'],
'epoch', file_name='loss.png'))
# plot acc graph
trainer.extend(
extensions.PlotReport(
['main/PSNR', 'validation/main/PSNR'],
'epoch', file_name='PSNR.png'))
# print info
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss', 'main/PSNR', 'validation/main/PSNR', 'lr', 'elapsed_time']))
# print progbar
trainer.extend(extensions.ProgressBar())
trainer.run()
array = {
'input_array': input_array,
'dists': dists,
'pairs_index': pairs_index
}
if with_target:
array['targets'] = to_device(device, np.concatenate(list_targets))
return array
print('Creating updater and trainer')
updater = training.StandardUpdater(train_iter,
optimizer,
converter=coupling_converter,
device=DEVICE)
trainer = training.Trainer(updater, (200, 'epoch'), out="result")
#############
## EVALUATOR
#############
from chainer.training.extensions import Evaluator
from chainer import cuda
class TypeWiseEvaluator(Evaluator):
def __init__(self,
iterator,
target,
def main():
# Check if GPU is available
# (ImageNet example does not support CPU execution)
if not chainer.cuda.available:
raise RuntimeError('ImageNet requires GPU support.')
archs = {
'alex': alex.Alex,
'googlenet': googlenet.GoogLeNet,
'googlenetbn': googlenetbn.GoogLeNetBN,
'nin': nin.NIN,
'resnet50': resnet50.ResNet50,
}
parser = argparse.ArgumentParser(
description='Learning convnet from ILSVRC2012 dataset')
parser.add_argument('train', help='Path to training image-label list file')
parser.add_argument('val', help='Path to validation image-label list file')
parser.add_argument('--arch',
'-a',
choices=archs.keys(),
default='nin',
help='Convnet architecture')
parser.add_argument('--batchsize',
'-B',
type=int,
default=32,
help='Learning minibatch size')
parser.add_argument('--epoch',
'-E',
type=int,
default=10,
help='Number of epochs to train')
parser.add_argument('--initmodel',
help='Initialize the model from given file')
parser.add_argument('--loaderjob',
'-j',
type=int,
help='Number of parallel data loading processes')
parser.add_argument('--mean',
'-m',
default='mean.npy',
help='Mean file (computed by compute_mean.py)')
parser.add_argument('--resume',
'-r',
default='',
help='Initialize the trainer from given file')
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--root',
'-R',
default='.',
help='Root directory path of image files')
parser.add_argument('--val_batchsize',
'-b',
type=int,
default=250,
help='Validation minibatch size')
parser.add_argument('--test', action='store_true')
parser.add_argument('--communicator', default='pure_nccl')
parser.set_defaults(test=False)
args = parser.parse_args()
# Start method of multiprocessing module need to be changed if we
# are using InfiniBand and MultiprocessIterator. This is because
# processes often crash when calling fork if they are using
# Infiniband. (c.f.,
# https://www.open-mpi.org/faq/?category=tuning#fork-warning )
# Also, just setting the start method does not seem to be
# sufficient to actually launch the forkserver processes, so also
# start a dummy process.
# See also our document:
# https://chainermn.readthedocs.io/en/stable/tutorial/tips_faqs.html#using-multiprocessiterator
# This must be done *before* ``chainermn.create_communicator``!!!
multiprocessing.set_start_method('forkserver')
p = multiprocessing.Process()
p.start()
p.join()
# Prepare ChainerMN communicator.
comm = chainermn.create_communicator(args.communicator)
device = comm.intra_rank
if comm.rank == 0:
print('==========================================')
print('Num process (COMM_WORLD): {}'.format(comm.size))
print('Using {} communicator'.format(args.communicator))
print('Using {} arch'.format(args.arch))
print('Num Minibatch-size: {}'.format(args.batchsize))
print('Num epoch: {}'.format(args.epoch))
print('==========================================')
model = archs[args.arch]()
if args.initmodel:
print('Load model from', args.initmodel)
chainer.serializers.load_npz(args.initmodel, model)
chainer.cuda.get_device_from_id(device).use() # Make the GPU current
model.to_gpu()
# Split and distribute the dataset. Only worker 0 loads the whole dataset.
# Datasets of worker 0 are evenly split and distributed to all workers.
mean = np.load(args.mean)
if comm.rank == 0:
train = PreprocessedDataset(args.train, args.root, mean, model.insize)
val = PreprocessedDataset(args.val, args.root, mean, model.insize,
False)
else:
train = None
val = None
train = chainermn.scatter_dataset(train, comm, shuffle=True)
val = chainermn.scatter_dataset(val, comm)
# A workaround for processes crash should be done before making
# communicator above, when using fork (e.g. MultiProcessIterator)
# along with Infiniband.
train_iter = chainer.iterators.MultiprocessIterator(
train, args.batchsize, n_processes=args.loaderjob)
val_iter = chainer.iterators.MultiprocessIterator(
val, args.val_batchsize, repeat=False, n_processes=args.loaderjob)
# Create a multi node optimizer from a standard Chainer optimizer.
optimizer = chainermn.create_multi_node_optimizer(
chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9), comm)
optimizer.setup(model)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=device)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.out)
val_interval = (10, 'iteration') if args.test else (1, 'epoch')
log_interval = (10, 'iteration') if args.test else (1, 'epoch')
# Create a multi node evaluator from an evaluator.
evaluator = TestModeEvaluator(val_iter, model, device=device)
evaluator = chainermn.create_multi_node_evaluator(evaluator, comm)
trainer.extend(evaluator, trigger=val_interval)
# Some display and output extensions are necessary only for one worker.
# (Otherwise, there would just be repeated outputs.)
if comm.rank == 0:
trainer.extend(extensions.DumpGraph('main/loss'))
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'lr'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--model',
choices=('ssd300', 'ssd512', 'ssd300plus', 'dssd300',
'essd300', 'essd300plus', 'refinedet320'),
default='ssd300')
parser.add_argument('--batchsize', type=int, default=32)
parser.add_argument('--gpu', type=int, default=0)
parser.add_argument('--out', default='result')
parser.add_argument('--resume')
args = parser.parse_args()
if args.model == 'ssd300':
model = SSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'ssd512':
model = SSD512(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'ssd300plus':
model = SSD300Plus(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'dssd300':
model = DSSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'essd300':
model = ESSD300(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'essd300plus':
model = ESSD300Plus(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
elif args.model == 'refinedet320':
model = RefineDet320(n_fg_class=len(voc_bbox_label_names),
pretrained_model='imagenet')
model.use_preset('evaluate')
if isinstance(model, RefineDet320):
train_chain = RefineDetTrainChain(model)
else:
train_chain = MultiboxTrainChain(model)
if args.gpu >= 0:
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
train = TransformDataset(
ConcatenatedDataset(VOCBboxDataset(year='2007', split='trainval'),
VOCBboxDataset(year='2012', split='trainval')),
Transform(model.coder, model.insize, model.mean))
train_iter = chainer.iterators.MultiprocessIterator(train,
args.batchsize,
shared_mem=4000000)
test = VOCBboxDataset(year='2007',
split='test',
use_difficult=True,
return_difficult=True)
test_iter = chainer.iterators.SerialIterator(test,
args.batchsize,
repeat=False,
shuffle=False)
# initial lr is set to 1e-3 by ExponentialShift
optimizer = chainer.optimizers.MomentumSGD()
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
if isinstance(model, RefineDet320):
trainer = training.Trainer(updater, (240000, 'iteration'), args.out)
trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3),
trigger=triggers.ManualScheduleTrigger([160000, 200000],
'iteration'))
else:
trainer = training.Trainer(updater, (120000, 'iteration'), args.out)
trainer.extend(extensions.ExponentialShift('lr', 0.1, init=1e-3),
trigger=triggers.ManualScheduleTrigger([80000, 100000],
'iteration'))
trainer.extend(DetectionVOCEvaluator(test_iter,
model,
use_07_metric=True,
label_names=voc_bbox_label_names),
trigger=(10000, 'iteration'))
log_interval = 10, 'iteration'
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
if args.model == 'refinedet320':
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'lr', 'main/loss', 'main/arm_loss/loc',
'main/arm_loss/conf', 'main/odm_loss/loc', 'main/odm_loss/conf',
'validation/main/map'
]),
trigger=log_interval)
else:
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'lr', 'main/loss', 'main/loss/conf',
'main/loss/loc', 'validation/main/map'
]),
trigger=log_interval)
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.snapshot(), trigger=(10000, 'iteration'))
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=(120000, 'iteration'))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser(description='Chainer example: VAE')
parser.add_argument('--gpu', default=0, type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--output_dir', '-o', default='result_mvae/',
help='Directory to output the result')
parser.add_argument('--epochs', '-e', default=100, type=int,
help='Number of epochs')
parser.add_argument('--dimz', '-z', default=8, type=int,
help='Dimention of encoded vector')
parser.add_argument('--batchsize', '-batch', type=int, default=32,
help='Learning minibatch size')
parser.add_argument('--beta', '-b', default=1,
help='Beta coefficient for the KL loss')
parser.add_argument('--gamma_obj', '-gO', default=1,
help='Gamma coefficient for the OBJECT classification loss')
parser.add_argument('--gamma_rel', '-gR', default=1,
help='Gamma coefficient for the RELATIONAL classification loss')
parser.add_argument('--alpha', '-a', default=1,
help='Alpha coefficient for the reconstruction loss')
parser.add_argument('--freq', '-f', default=1000,
help='Frequency at which snapshots of the model are saved.')
parser.add_argument('--augment_counter', type=int, default=0,
help='Number ot times to augment the train data')
parser.add_argument('--objects_n', default=2, type=int,
help='# of objects to be used')
args = parser.parse_args()
if not osp.isdir(osp.join(args.output_dir)):
os.makedirs(args.output_dir)
if not osp.isdir(osp.join(args.output_dir, 'models')):
os.makedirs(osp.join(args.output_dir, 'models'))
print('\n###############################################')
print('# GPU: \t\t\t{}'.format(args.gpu))
print('# dim z: \t\t{}'.format(args.dimz))
print('# Minibatch-size: \t{}'.format(args.batchsize))
print('# Epochs: \t\t{}'.format(args.epochs))
print('# Beta: \t\t{}'.format(args.beta))
print('# Gamma OBJ: \t\t{}'.format(args.gamma_obj))
print('# Gamma REL: \t\t{}'.format(args.gamma_rel))
print('# Frequency: \t\t{}'.format(args.freq))
print('# Out Folder: \t\t{}'.format(args.output_dir))
print('###############################################\n')
stats = {'train_loss': [], 'train_rec_loss': [], 'train_kl': [],
'train_label_obj_acc': [], 'train_label_obj_loss': [],
'train_label_rel_acc': [], 'train_label_rel_loss': [],
'valid_loss': [], 'valid_rec_loss': [], 'valid_kl': [],
'valid_label_obj_acc': [], 'valid_label_obj_loss': [],
'valid_label_rel_acc': [], 'valid_label_rel_loss': []}
models_folder = os.path.join(args.output_dir, "models")
# BASE_DIR = "yordan_experiments"
# folder_names = [osp.join(BASE_DIR, 'off-on'),
# osp.join(BASE_DIR, 'nonfacing-facing'),
# osp.join(BASE_DIR, 'out-in')]
BASE_DIR = "yordan_experiments_2"
folder_names = [osp.join(BASE_DIR, 'off-on'),
osp.join(BASE_DIR, 'nonfacing-facing'),
osp.join(BASE_DIR, 'out-in')]
# folder_names = ['yordan_experiments/off-on']
generator = data_generator.DataGenerator(folder_names=folder_names,\
data_split=0.8,
include_eef=True)
train, train_labels, train_concat, train_vectors, test, test_labels, test_concat, test_vectors,\
unseen, unseen_labels, unseen_concat, unseen_vectors,\
groups_obj, groups_rel = generator.generate_dataset(args=args)
data_dimensions = train.shape
print('\n###############################################')
print("DATA_LOADED")
print("# Training Images: \t\t{0}".format(train.shape))
print("# Testing Images: \t\t{0}".format(test.shape))
print("# Unseen Images: \t\t{0}".format(unseen.shape))
print("# Training Rel Labels: \t\t{0}".format(train_labels.shape))
print("# Testing Rel Labels: \t\t{0}".format(test_labels.shape))
print("# Unseen Rel Labels: \t\t{0}".format(unseen_labels.shape))
print("# Training Rel Vectors: \t\t{0}".format(train_vectors.shape))
print("# Testing Rel Vectors: \t\t{0}".format(test_vectors.shape))
print('###############################################\n')
if len(train_concat[1]) > 0:
print("# Relation Label Stats:")
for group_idx, group in groups_rel.items():
print("# Group: \t\t{0} : {1}".format(group_idx, group))
for label_idx, label in enumerate(group + ["unlabelled"]):
print("#{0} Train: \t\t{1}".format(label,len(filter(lambda x:label == x[group_idx], train_labels))))
print("#{0} Test: \t\t{1}".format(label,len(filter(lambda x:label == x[group_idx], test_labels))))
print('###############################################\n')
if len(train_concat[3]) > 0:
print("# Object Label Stats:")
train_object_vectors = np.array([train_concat[i][3][j] for i in range(len(train_concat)) for j in range(args.objects_n)])
test_object_vectors = np.array([test_concat[i][3][j] for i in range(len(test_concat)) for j in range(args.objects_n)])
train_object_vector_masks = np.array([train_concat[i][4][j] for i in range(len(train_concat)) for j in range(args.objects_n)])
test_object_vector_masks = np.array([test_concat[i][4][j] for i in range(len(test_concat)) for j in range(args.objects_n)])
for group_idx, group in groups_obj.items():
print("# Group: \t\t{0} : {1}".format(group_idx, group))
for label_idx, label in enumerate(group):
print("#{0} Train: \t\t{1}".format(label,len(filter(lambda (x, y):label_idx == x[group_idx] and y[group_idx] != 0, zip(train_object_vectors, train_object_vector_masks)))))
print("#{0} Test: \t\t{1}".format(label,len(filter(lambda (x, y):label_idx == x[group_idx] and y[group_idx] != 0, zip(test_object_vectors, test_object_vector_masks)))))
for label_idx, label in enumerate(["unlabelled"]):
print("#{0} Train: \t\t{1}".format(label,len(filter(lambda (x, y):label_idx == x[group_idx] and y[group_idx] == 0, zip(train_object_vectors, train_object_vector_masks)))))
print("#{0} Test: \t\t{1}".format(label,len(filter(lambda (x, y):label_idx == x[group_idx] and y[group_idx] == 0, zip(test_object_vectors, test_object_vector_masks)))))
print('###############################################\n')
train_iter = chainer.iterators.SerialIterator(train_concat, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_concat, args.batchsize,
repeat=False, shuffle=False)
model = net.Robot_Regressor(alpha=args.alpha, beta = args.beta)
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu()
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
# optimizer = chainer.optimizers.RMSprop()
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(0.0005))
# optimizer.add_hook(chainer.optimizer_hooks.GradientClipping(0.00001))
updater = training.StandardUpdater(train_iter, optimizer,
loss_func=model.lf_regress,
device=args.gpu)
trainer = training.Trainer(updater, (args.epochs, 'epoch'), out=args.output_dir)
trainer.extend(extensions.Evaluator(test_iter, model, eval_func=model.lf_regress, device=args.gpu), name="val", trigger=(1, 'epoch'))
trainer.extend(extensions.LogReport(trigger=(1, 'epoch')))
trainer.extend(extensions.PrintReport([
'epoch', \
'main/mse_l', 'val/main/mse_l', \
'main/kl', 'val/main/kl']))
trainer.extend(extensions.PlotReport(['main/mse_l', \
'val/main/mse_l'], \
x_key='epoch', file_name='mse_loss.png', marker=None))
trainer.extend(extensions.PlotReport(['main/kl', \
'val/main/kl'], \
x_key='epoch', file_name='kl.png', marker=None))
# trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.extend(extensions.FailOnNonNumber())
trainer.extend(extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}.trainer'), trigger=(args.epochs, 'epoch'))
trainer.extend(extensions.snapshot_object(model, filename='snapshot_epoch_{.updater.epoch}.model'), trigger=(10, 'epoch'))
trainer.extend(extensions.snapshot_object(model, 'final.model'), trigger=(args.epochs, 'epoch'))
trainer.extend(extensions.ExponentialShift('alpha', 0.5, init=1e-3, target=1e-8), trigger=(args.epochs/2, 'epoch')) # For Adam
trainer.run()
h25 = F.relu(self.l2(h24))
h26 = F.relu(self.l2(h25))
return self.l3(h26)
model = L.Classifier(
MLP(44, 1), lossfun=F.sigmoid_cross_entropy, accfun=F.binary_accuracy)
# Setup an optimizer
optimizer = chainer.optimizers.SGD()
optimizer.setup(model)
gpu_id = -1 # Change to -1 to use CPU
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=gpu_id)
trainer = training.Trainer(updater, (50, 'epoch'), out='result')
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=gpu_id))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=(20, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Save two plot images to the result dir
def main():
parser = argparse.ArgumentParser(description='World Models ' + ID)
parser.add_argument('--data_dir',
'-d',
default="data/wm",
help='The base data/output directory')
parser.add_argument(
'--game', default='CarRacing-v0',
help='Game to use') # https://gym.openai.com/envs/CarRacing-v0/
parser.add_argument('--experiment_name',
default='experiment_1',
help='To isolate its files from others')
parser.add_argument(
'--load_batch_size',
default=10,
type=int,
help='Load game frames in batches so as not to run out of memory')
parser.add_argument(
'--model',
'-m',
default='',
help=
'Initialize the model from given file, or "default" for one in data folder'
)
parser.add_argument('--no_resume',
action='store_true',
help='Don'
't auto resume from the latest snapshot')
parser.add_argument(
'--resume_from',
'-r',
default='',
help='Resume the optimization from a specific snapshot')
parser.add_argument('--test',
action='store_true',
help='Generate samples only')
parser.add_argument('--gpu',
'-g',
default=0,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
default=1,
type=int,
help='number of epochs to learn')
parser.add_argument(
'--snapshot_interval',
'-s',
default=100,
type=int,
help='100 = snapshot every 100itr*batch_size imgs processed')
parser.add_argument('--z_dim',
'-z',
default=32,
type=int,
help='dimension of encoded vector')
parser.add_argument('--batch_size',
'-b',
type=int,
default=100,
help='learning minibatch size')
parser.add_argument('--no_progress_bar',
'-p',
action='store_true',
help='Display progress bar during training')
parser.add_argument('--kl_tolerance', type=float, default=0.5, help='')
args = parser.parse_args()
log(ID, "args =\n " + str(vars(args)).replace(",", ",\n "))
output_dir = os.path.join(args.data_dir, args.game, args.experiment_name,
ID)
random_rollouts_dir = os.path.join(args.data_dir, args.game,
args.experiment_name, 'random_rollouts')
mkdir(output_dir)
max_iter = 0
auto_resume_file = None
files = os.listdir(output_dir)
for file in files:
if re.match(r'^snapshot_iter_', file):
iter = int(re.search(r'\d+', file).group())
if (iter > max_iter):
max_iter = iter
if max_iter > 0:
auto_resume_file = os.path.join(output_dir,
"snapshot_iter_{}".format(max_iter))
model = CVAE(args.z_dim)
if args.model:
if args.model == 'default':
args.model = os.path.join(output_dir, ID + ".model")
log(ID, "Loading saved model from: " + args.model)
chainer.serializers.load_npz(args.model, model)
optimizer = chainer.optimizers.Adam(alpha=0.0001)
optimizer.setup(model)
log(ID, "Loading training data")
train = VisionDataset(dir=random_rollouts_dir,
load_batch_size=args.load_batch_size,
shuffle=True,
verbose=True)
train_iter = chainer.iterators.SerialIterator(train,
args.batch_size,
shuffle=False)
updater = training.StandardUpdater(train_iter,
optimizer,
device=args.gpu,
loss_func=model.get_loss_func(
args.kl_tolerance))
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=output_dir)
trainer.extend(extensions.snapshot(),
trigger=(args.snapshot_interval, 'iteration'))
trainer.extend(
extensions.LogReport(trigger=(100 if args.gpu >= 0 else 10,
'iteration')))
trainer.extend(
extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'main/kl_loss', 'main/rec_loss',
'elapsed_time'
]))
if not args.no_progress_bar:
trainer.extend(
extensions.ProgressBar(
update_interval=100 if args.gpu >= 0 else 10))
sample_idx = np.random.choice(range(train.get_current_batch_size()),
64,
replace=False)
sample_frames = chainer.Variable(np.asarray(train[sample_idx]))
np.random.seed(31337)
sample_z = chainer.Variable(
np.random.normal(0, 1, (64, args.z_dim)).astype(np.float32))
save_images_collage(sample_frames.data,
os.path.join(output_dir, 'train.png'))
sampler = Sampler(model, args, output_dir, sample_frames, sample_z)
trainer.extend(sampler, trigger=(args.snapshot_interval, 'iteration'))
if args.resume_from:
log(ID, "Resuming trainer manually from snapshot: " + args.resume_from)
chainer.serializers.load_npz(args.resume_from, trainer)
elif not args.no_resume and auto_resume_file is not None:
log(ID,
"Auto resuming trainer from last snapshot: " + auto_resume_file)
chainer.serializers.load_npz(auto_resume_file, trainer)
if not args.test:
log(ID, "Starting training")
trainer.run()
log(ID, "Done training")
log(ID, "Saving model")
chainer.serializers.save_npz(os.path.join(output_dir, ID + ".model"),
model)
if args.test:
log(ID, "Saving test samples")
sampler(trainer)
if not args.test:
log(ID, "Saving latent z's for all training data")
train = VisionDataset(dir=random_rollouts_dir,
load_batch_size=args.load_batch_size,
shuffle=False,
verbose=True)
total_batches = train.get_total_batches()
for batch in range(total_batches):
gc.collect()
train.load_batch(batch)
batch_frames, batch_rollouts, batch_rollouts_counts = train.get_current_batch(
)
mu = None
ln_var = None
splits = batch_frames.shape[0] // args.batch_size
if batch_frames.shape[0] % args.batch_size != 0:
splits += 1
for i in range(splits):
start_idx = i * args.batch_size
end_idx = (i + 1) * args.batch_size
sample_frames = batch_frames[start_idx:end_idx]
if args.gpu >= 0:
sample_frames = chainer.Variable(cp.asarray(sample_frames))
else:
sample_frames = chainer.Variable(sample_frames)
this_mu, this_ln_var = model.encode(sample_frames)
this_mu = this_mu.data
this_ln_var = this_ln_var.data
if args.gpu >= 0:
this_mu = cp.asnumpy(this_mu)
this_ln_var = cp.asnumpy(this_ln_var)
if mu is None:
mu = this_mu
ln_var = this_ln_var
else:
mu = np.concatenate((mu, this_mu), axis=0)
ln_var = np.concatenate((ln_var, this_ln_var), axis=0)
running_count = 0
for rollout in batch_rollouts:
rollout_dir = os.path.join(random_rollouts_dir, rollout)
rollout_count = batch_rollouts_counts[rollout]
start_idx = running_count
end_idx = running_count + rollout_count
this_mu = mu[start_idx:end_idx]
this_ln_var = ln_var[start_idx:end_idx]
np.savez_compressed(os.path.join(rollout_dir, "mu+ln_var.npz"),
mu=this_mu,
ln_var=this_ln_var)
running_count = running_count + rollout_count
log(ID, "> Processed z's for rollouts " + str(batch_rollouts))
# Free up memory:
batch_frames = None
mu = None
ln_var = None
log(ID, "Done")
def main():
"""
Main Function
"""
# 再現性確保
common.set_random_state(0)
# --------------------------------------------------
# データ取得
# --------------------------------------------------
dataset = "mnist"
X_train, X_test, Y_train, Y_test = common.read_data(data=dataset,
one_hot=False)
n_in = X_train.shape[1]
if dataset == "mnist":
n_out = 10
X_train = X_train.astype(np.float32)
Y_train = Y_train.astype(np.int)
X_test = X_test.astype(np.float32)
Y_test = Y_test.astype(np.int)
train_data = [(X_train[i], Y_train[i]) for i in range(len(X_train))]
# --------------------------------------------------
# モデル構築
# --------------------------------------------------
n_hidden_list = common.n_hidden_list
class MLP(ChainList):
"""
Multi Layer Perceptron
"""
def __init__(self, n_in, n_hidden_list, n_out):
"""
引数
n_in:入力層ユニット数、n_hidden_list:隠れ層ユニット数のリスト、n_out:出力層ユニット数
戻り値なし
"""
super(MLP, self).__init__()
with self.init_scope():
# 入力層=隠れ層、隠れ層-隠れ層
for n_hidden in n_hidden_list:
self.add_link(L.Linear(None, n_hidden,
initialW=HeNormal()))
# 隠れ層-出力層
self.add_link(L.Linear(None, n_out, initialW=HeNormal()))
def __call__(self, x):
"""
引数
モデル入力
戻り値
モデル出力(出力は全結合層)
"""
link_list = list(self.children())
# 入力層=隠れ層
x = link_list[0](x)
x = F.relu(x)
# 隠れ層-隠れ層
for i, link in enumerate(link_list[1:-1]):
x = link(x)
x = F.relu(x)
x = F.dropout(x, 0.5)
# 隠れ層-出力層
x = link_list[-1](x)
return x
model = L.Classifier(MLP(n_in, n_hidden_list, n_out))
# --------------------------------------------------
# 学習
# --------------------------------------------------
train_iter = iterators.SerialIterator(train_data,
batch_size=common.batch_size,
shuffle=True)
optimizer = optimizers.Adam()
optimizer.setup(model)
updater = training.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(updater, (common.epochs, 'epoch'),
out='chainer_result')
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.PrintReport(
['epoch', 'main/loss', 'main/accuracy', 'elapsed_time']))
with chainer.using_config('train', True):
trainer.run()
# --------------------------------------------------
# 検証
# --------------------------------------------------
with chainer.using_config('train', False):
model(Variable(X_train), Variable(Y_train))
loss_train = model.loss.data
acc_train = model.accuracy.data
model(Variable(X_test), Variable(Y_test))
loss_test = model.loss.data
acc_test = model.accuracy.data
# --------------------------------------------------
# 結果のグラフ化
# --------------------------------------------------
common.plot_result(loss_train, loss_test, acc_train, acc_test)
print(acc_test)
def main():
parser = argparse.ArgumentParser(description='ModelNet40 classification')
# parser.add_argument('--conv-layers', '-c', type=int, default=4)
parser.add_argument('--method', '-m', type=str, default='point_cls')
parser.add_argument('--batchsize', '-b', type=int, default=32)
parser.add_argument('--dropout_ratio', type=float, default=0.3)
parser.add_argument('--num_point', type=int, default=1024)
parser.add_argument('--gpu', '-g', type=int, default=-1)
parser.add_argument('--out', '-o', type=str, default='result')
parser.add_argument('--epoch', '-e', type=int, default=250)
# parser.add_argument('--unit-num', '-u', type=int, default=16)
parser.add_argument('--seed', '-s', type=int, default=777)
parser.add_argument('--protocol', type=int, default=2)
parser.add_argument('--model_filename', type=str, default='model.npz')
parser.add_argument('--resume', type=str, default='')
parser.add_argument('--trans', type=strtobool, default='true')
parser.add_argument('--use_bn', type=strtobool, default='true')
parser.add_argument('--normalize', type=strtobool, default='false')
parser.add_argument('--residual', type=strtobool, default='false')
parser.add_argument('--pose_estimate',
'-p',
type=strtobool,
default='false')
args = parser.parse_args()
seed = args.seed
method = args.method
num_point = args.num_point
out_dir = args.out
num_class = 40
num_pose = 6
debug = False
if method == 'point_pose':
from pose_dataset import get_train_dataset, get_test_dataset
else:
from ply_dataset import get_train_dataset, get_test_dataset
try:
os.makedirs(out_dir, exist_ok=True)
import chainerex.utils as cl
fp = os.path.join(out_dir, 'args.json')
cl.save_json(fp, vars(args))
print('save args to', fp)
except ImportError:
pass
# Dataset preparation
train = get_train_dataset(num_point=num_point)
val = get_test_dataset(num_point=num_point)
if method == 'kdnet_cls' or method == 'kdcontextnet_cls':
from chainer_pointnet.utils.kdtree import TransformKDTreeCls
max_level = calc_max_level(num_point)
print('kdnet_cls max_level {}'.format(max_level))
return_split_dims = (method == 'kdnet_cls')
train = TransformDataset(
train,
TransformKDTreeCls(max_level=max_level,
return_split_dims=return_split_dims))
val = TransformDataset(
val,
TransformKDTreeCls(max_level=max_level,
return_split_dims=return_split_dims))
if method == 'kdnet_cls':
# Debug print
points, split_dims, t = train[0]
print('converted to kdnet dataset train', points.shape,
split_dims.shape, t)
points, split_dims, t = val[0]
print('converted to kdnet dataset val', points.shape,
split_dims.shape, t)
if method == 'kdcontextnet_cls':
# Debug print
points, t = train[0]
print('converted to kdcontextnet dataset train', points.shape, t)
points, t = val[0]
print('converted to kdcontextnet dataset val', points.shape, t)
if debug:
# use few train dataset
train = SubDataset(train, 0, 50)
# Network
# n_unit = args.unit_num
# conv_layers = args.conv_layers
trans = args.trans
use_bn = args.use_bn
normalize = args.normalize
residual = args.residual
dropout_ratio = args.dropout_ratio
from chainer.dataset.convert import concat_examples
converter = concat_examples
if method == 'point_cls':
print(
'Train PointNetCls model... trans={} use_bn={} dropout={}'.format(
trans, use_bn, dropout_ratio))
model = PointNetCls(out_dim=num_class,
in_dim=3,
middle_dim=64,
dropout_ratio=dropout_ratio,
trans=trans,
trans_lam1=0.001,
trans_lam2=0.001,
use_bn=use_bn,
residual=residual)
elif method == 'point_pose':
print(
'Train PointNetCls model... trans={} use_bn={} dropout={}'.format(
trans, use_bn, dropout_ratio))
model = PointNetPose(out_dim=num_pose,
in_dim=3,
middle_dim=64,
dropout_ratio=dropout_ratio,
trans=trans,
trans_lam1=0.001,
trans_lam2=0.001,
use_bn=use_bn,
residual=residual)
elif method == 'point2_cls_ssg':
print('Train PointNet2ClsSSG model... use_bn={} dropout={}'.format(
use_bn, dropout_ratio))
model = PointNet2ClsSSG(out_dim=num_class,
in_dim=3,
dropout_ratio=dropout_ratio,
use_bn=use_bn,
residual=residual)
elif method == 'point2_cls_msg':
print('Train PointNet2ClsMSG model... use_bn={} dropout={}'.format(
use_bn, dropout_ratio))
model = PointNet2ClsMSG(out_dim=num_class,
in_dim=3,
dropout_ratio=dropout_ratio,
use_bn=use_bn,
residual=residual)
elif method == 'kdnet_cls':
print('Train KDNetCls model... use_bn={} dropout={}'.format(
use_bn, dropout_ratio))
model = KDNetCls(
out_dim=num_class,
in_dim=3,
dropout_ratio=dropout_ratio,
use_bn=use_bn,
max_level=max_level,
)
def kdnet_converter(batch, device=None, padding=None):
# concat_examples to CPU at first.
result = concat_examples(batch, device=None, padding=padding)
out_list = []
for elem in result:
if elem.dtype != object:
# Send to GPU for int/float dtype array.
out_list.append(to_device(device, elem))
else:
# Do NOT send to GPU for dtype=object array.
out_list.append(elem)
return tuple(out_list)
converter = kdnet_converter
elif method == 'kdcontextnet_cls':
print('Train KDContextNetCls model... use_bn={} dropout={}'
'normalize={} residual={}'.format(use_bn, dropout_ratio,
normalize, residual))
model = KDContextNetCls(
out_dim=num_class,
in_dim=3,
dropout_ratio=dropout_ratio,
use_bn=use_bn,
# Below is for non-default customization
levels=[3, 6, 9],
feature_learning_mlp_list=[[32, 32, 128], [64, 64, 256],
[128, 128, 512]],
feature_aggregation_mlp_list=[[128], [256], [512]],
normalize=normalize,
residual=residual)
else:
raise ValueError('[ERROR] Invalid method {}'.format(method))
train_iter = iterators.SerialIterator(train, args.batchsize)
val_iter = iterators.SerialIterator(val,
args.batchsize,
repeat=False,
shuffle=False)
device = args.gpu
# classifier = Classifier(model, device=device)
classifier = model
load_model = False
if load_model:
serializers.load_npz(os.path.join(out_dir, args.model_filename),
classifier)
if device >= 0:
print('using gpu {}'.format(device))
chainer.cuda.get_device_from_id(device).use()
classifier.to_gpu() # Copy the model to the GPU
optimizer = optimizers.Adam()
optimizer.setup(classifier)
updater = training.StandardUpdater(train_iter,
optimizer,
converter=converter,
device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=out_dir)
from chainerex.training.extensions import schedule_optimizer_value
from chainer.training.extensions import observe_value
# trainer.extend(observe_lr)
observation_key = 'lr'
trainer.extend(
observe_value(
observation_key,
lambda trainer: trainer.updater.get_optimizer('main').alpha))
trainer.extend(
schedule_optimizer_value(
[10, 20, 100, 150, 200, 230],
[0.003, 0.001, 0.0003, 0.0001, 0.00003, 0.00001]))
trainer.extend(
E.Evaluator(val_iter, classifier, converter=converter,
device=args.gpu))
trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(E.LogReport())
trainer.extend(
E.PrintReport([
'epoch',
'main/loss',
'main/cls_loss',
'main/trans_loss1',
'main/trans_loss2',
'main/accuracy',
'validation/main/loss',
# 'validation/main/cls_loss',
# 'validation/main/trans_loss1', 'validation/main/trans_loss2',
'validation/main/accuracy',
'lr',
'elapsed_time'
]))
trainer.extend(E.ProgressBar(update_interval=10))
if args.resume:
serializers.load_npz(args.resume, trainer)
trainer.run()
# --- save classifier ---
# protocol = args.protocol
# classifier.save_pickle(
# os.path.join(out_dir, args.model_filename), protocol=protocol)
serializers.save_npz(os.path.join(out_dir, args.model_filename),
classifier)
def main():
# Parse the arguments.
args = parse_arguments()
if args.label:
labels = args.label
class_num = len(labels) if isinstance(labels, list) else 1
else:
raise ValueError('No target label was specified.')
# Dataset preparation. Postprocessing is required for the regression task.
def postprocess_label(label_list):
return numpy.asarray(label_list, dtype=numpy.float32)
# Apply a preprocessor to the dataset.
print('Preprocessing dataset...')
preprocessor = preprocess_method_dict[args.method]()
parser = CSVFileParser(preprocessor,
postprocess_label=postprocess_label,
labels=labels,
smiles_col='SMILES')
dataset = parser.parse(args.datafile)['dataset']
# Scale the label values, if necessary.
if args.scale == 'standardize':
scaler = StandardScaler()
labels = scaler.fit_transform(dataset.get_datasets()[-1])
dataset = NumpyTupleDataset(*(dataset.get_datasets()[:-1] +
(labels, )))
else:
scaler = None
# Split the dataset into training and validation.
train_data_size = int(len(dataset) * args.train_data_ratio)
train, _ = split_dataset_random(dataset, train_data_size, args.seed)
# Set up the predictor.
predictor = set_up_predictor(args.method, args.unit_num, args.conv_layers,
class_num)
# Set up the iterator.
train_iter = SerialIterator(train, args.batchsize)
# Set up the regressor.
metrics_fun = {
'mean_abs_error': MeanAbsError(scaler=scaler),
'root_mean_sqr_error': RootMeanSqrError(scaler=scaler)
}
regressor = Regressor(predictor,
lossfun=F.mean_squared_error,
metrics_fun=metrics_fun,
device=args.gpu)
# Set up the optimizer.
optimizer = optimizers.Adam()
optimizer.setup(regressor)
# Set up the updater.
updater = training.StandardUpdater(train_iter,
optimizer,
device=args.gpu,
converter=concat_mols)
# Set up the trainer.
print('Training...')
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
trainer.extend(E.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(E.LogReport())
trainer.extend(
E.PrintReport([
'epoch', 'main/loss', 'main/mean_abs_error',
'main/root_mean_sqr_error', 'elapsed_time'
]))
trainer.extend(E.ProgressBar())
trainer.run()
# Save the regressor's parameters.
model_path = os.path.join(args.out, args.model_filename)
print('Saving the trained model to {}...'.format(model_path))
regressor.save_pickle(model_path, protocol=args.protocol)
# Save the standard scaler's parameters.
if scaler is not None:
with open(os.path.join(args.out, 'scaler.pkl'), mode='wb') as f:
pickle.dump(scaler, f, protocol=args.protocol)
def train(_db, client_id, mlp, file_images_name, file_labels_name, l1_w_list,
l2_w_list):
print('train')
# Create a model
model = L.Classifier(mlp)
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
model.links()
try:
print('start download file')
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('t2.technion.ac.il',
username='******',
password='******')
cmd_images = 'cat ' + file_images_name
images_stdin, images_stdout, images_stderr = ssh.exec_command(
cmd_images)
read_image = str(images_stdout.read(), 'utf-8')
read_image = re.split('\[', read_image)
cmd_labels = 'cat ' + file_labels_name
labels_stdin, labels_stdout, labels_stderr = ssh.exec_command(
cmd_labels)
read_labels = str(labels_stdout.read(), 'utf-8')
ssh.close()
print('finish download file')
except:
_db.GlobalParameters.update_one({'id': 1},
{'$inc': {
'image_file_index': -1
}})
return
label_array = np.fromstring(read_labels, dtype=np.int32, sep=',')
images_array = [None] * 1200
for i in range(0, 1200):
images_array[i] = np.fromstring(read_image[i + 1],
dtype=np.float32,
sep=' ')
train_tuple = tuple_dataset.TupleDataset(images_array, label_array)
# train_, test = chainer.datasets.get_mnist()
# TODO: check with roman the mini batch size in the client side.
train_iter = chainer.iterators.SerialIterator(train_tuple,
1) # 1 = mini patch
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=-1)
trainer = training.Trainer(updater, (1, 'epoch'), out='result')
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.ProgressBar())
# Run the training
start_time = time.time()
trainer.run()
end_time = time.time()
# compute the deltas and send them
total_time = end_time - start_time
delta_layer1 = np.zeros((300, 784), dtype='float32')
delta_layer2 = np.zeros((10, 300), dtype='float32')
for i in range(10):
for j in range(300):
delta_layer2[i][j] = mlp.l2.W.data[i][j] - l2_w_list[i][j]
for i in range(300):
for j in range(784):
delta_layer1[i][j] = mlp.l1.W.data[i][j] - l1_w_list[i][j]
try:
while _db.GlobalParameters.find_one({'id': 1})['list_busy'] == 1:
continue
_db.GlobalParameters.update({'id': 1}, {'$set': {'list_busy': 1}})
network = _db.Network.find_one({'id': 1})
l1_list = network['l1_list']
l2_list = network['l2_list']
for i in range(300):
for j in range(784):
l1_list[i][j] += (delta_layer1[i][j] * 0.1
) # 0.1 is the learning rate.
for i in range(10):
for j in range(300):
l2_list[i][j] += (delta_layer2[i][j] * 0.1
) # 0.1 is the learning rate.
_db.Network.update({'id': 1},
{'$set': {
'l1_list': l1_list,
'l2_list': l2_list
}})
_db.GlobalParameters.update({'id': 1}, {'$set': {'list_busy': 0}})
except:
_db.GlobalParameters.update_one({'id': 1},
{'$inc': {
'image_file_index': -1
}})
_db.GlobalParameters.update({'id': 1}, {'$set': {'list_busy': 0}})
return
data = {
'id': client_id,
'mode': 'train',
'work_time': total_time,
}
print("total_time: " + str(total_time))
requests.post(url + 'deepLearning"', json.dumps(data))
train, test = chainer.datasets.get_mnist(ndim=3)
# ニューラルネットワークの登録
model = L.Classifier(MyChain(), lossfun=F.softmax_cross_entropy)
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# イテレータの定義
train_iter = chainer.iterators.SerialIterator(train, batchsize) # 学習用
test_iter = chainer.iterators.SerialIterator(test,
batchsize,
repeat=False,
shuffle=False) # 評価用
# アップデータの登録
updater = training.StandardUpdater(train_iter, optimizer)
# トレーナーの登録
trainer = training.Trainer(updater, (epoch, 'epoch'))
# 学習状況の表示や保存
trainer.extend(extensions.Evaluator(test_iter, model)) # エポック数の表示
#trainer.extend(extensions.dump_graph('main/loss'))#ニューラルネットワークの構造
#trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch',file_name='loss.png'))#誤差のグラフ
#trainer.extend(extensions.PlotReport(['main/accuracy', 'validation/main/accuracy'],'epoch', file_name='accuracy.png'))#精度のグラフ
trainer.extend(extensions.LogReport()) #ログ
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
])) #計算状態の表示
def main():
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument('--batchsize', '-b', type=int, default=100,
help='Number of images in each mini-batch')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result/4',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
parser.add_argument('--unit', '-u', type=int, default=50,
help='Number of units')
args = parser.parse_args()
print('GPU: {}'.format(args.gpu))
print('# unit: {}'.format(args.unit))
print('# Minibatch-size: {}'.format(args.batchsize))
print('# epoch: {}'.format(args.epoch))
print('')
# Set up a neural network to train
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
model = mlp.MLP(args.unit, 10)
classifier_model = L.Classifier(model)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current
classifier_model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(classifier_model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist()
train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test, args.batchsize, repeat=False, shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, classifier_model, device=args.gpu))
# Dump a computational graph from 'loss' variable at the first iteration
# The "main" refers to the target link of the "main" optimizer.
trainer.extend(extensions.dump_graph('main/loss'))
# Take a snapshot at each epoch
#trainer.extend(extensions.snapshot(), trigger=(args.epoch, 'epoch'))
trainer.extend(extensions.snapshot(), trigger=(1, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))
if extensions.PlotReport.available():
# Plot graph for loss for each epoch
trainer.extend(extensions.PlotReport(
['main/loss', 'validation/main/loss'],
x_key='epoch', file_name='loss.png'))
trainer.extend(extensions.PlotReport(
['main/accuracy', 'validation/main/accuracy'],
x_key='epoch',
file_name='accuracy.png'))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
if args.resume:
# Resume from a snapshot
serializers.load_npz(args.resume, trainer)
# Run the training
trainer.run()
serializers.save_npz('{}/mlp.model'.format(args.out), model)
train, args.batchsize)
test_iter = chainer.iterators.SerialIterator(
test, args.batchsize,
repeat=False, shuffle=False)
optimizer = chainer.optimizers.MomentumSGD(lr=args.lr)
optimizer.setup(train_chain)
for param in train_chain.params():
if param.name == 'b':
param.update_rule.add_hook(GradientScaling(2))
else:
param.update_rule.add_hook(WeightDecay(0.0005))
updater = training.StandardUpdater(
train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(
updater, (args.iteration, "iteration"), args.out)
val_interval = args.val_iter, "iteration"
trainer.extend(
DetectionVOCEvaluator(
test_iter, model, use_07_metric=True,
label_names=label_names),
trigger=val_interval)
log_interval = args.log_iter, "iteration"
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport(
['epoch', 'iteration', 'lr',
def main():
parser = argparse.ArgumentParser(description='Chainer example: MNIST')
parser.add_argument("--model", default="fc", choices=["fc", "conv"])
parser.add_argument('--gpu',
'-g',
type=int,
default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument(
'--out',
'-o',
default='output_chainer',
help='Directory to output the graph descriptor and sample test data')
parser.add_argument("--backend",
default="webgpu,webgl,webassembly,fallback")
args = parser.parse_args()
output_dir = os.path.join(args.out, f"./chainer_model")
os.makedirs(output_dir, exist_ok=True)
# Set up a neural network to train
# Classifier reports softmax cross entropy loss and accuracy at every
# iteration, which will be used by the PrintReport extension below.
model = L.Classifier(models[args.model](10))
if args.gpu >= 0:
# Make a specified GPU current
chainer.cuda.get_device_from_id(args.gpu).use()
model.to_gpu() # Copy the model to the GPU
# Setup an optimizer
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
# Load the MNIST dataset
train, test = chainer.datasets.get_mnist(ndim=3)
train_iter = chainer.iterators.SerialIterator(train, 128)
test_iter = chainer.iterators.SerialIterator(test,
128,
repeat=False,
shuffle=False)
# Set up a trainer
updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
trainer = training.Trainer(updater, (2, 'epoch'), out=output_dir)
# Evaluate the model with the test dataset for each epoch
trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))
# Take a snapshot for each specified epoch
trainer.extend(extensions.snapshot(filename=args.model),
trigger=(2, 'epoch'))
# Write a log of evaluation statistics for each epoch
trainer.extend(extensions.LogReport())
# Print selected entries of the log to stdout
# Here "main" refers to the target link of the "main" optimizer again, and
# "validation" refers to the default name of the Evaluator extension.
# Entries other than 'epoch' are reported by the Classifier link, called by
# either the updater or the evaluator.
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
# Print a progress bar to stdout
trainer.extend(extensions.ProgressBar())
snapshot_path = os.path.join(output_dir, args.model)
if os.path.exists(snapshot_path):
# Resume from a snapshot
chainer.serializers.load_npz(snapshot_path, trainer)
else:
# Run the training
trainer.run()
# conversion
print('Transpiling model to WebDNN graph descriptor')
if args.gpu >= 0:
model.to_cpu()
example_input = numpy.expand_dims(
train[0][0], axis=0) # example input (anything ok, (batch_size, 784))
x = chainer.Variable(example_input)
y = model.predictor(x)
graph = ChainerConverter().convert(
[x], [y]) # convert graph to intermediate representation
for backend in args.backend.split(","):
exec_info = generate_descriptor(backend, graph)
exec_info.save(args.out)
print('Exporting test samples (for demo purpose)')
test_samples_json = []
for i in range(10):
image, label = test[i]
test_samples_json.append({
'x': image.flatten().tolist(),
'y': int(label)
})
with open(os.path.join(args.out, 'test_samples.json'), 'w') as f:
json.dump(test_samples_json, f)
