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)