def main(): parser = argparse.ArgumentParser(description='Chainer example: Titanic') parser.add_argument('--unit', '-u', type=int, default=1000, help='Number of units') args = parser.parse_args() print('# unit: {}'.format(args.unit)) 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 = L.Classifier(nets.MLP(args.unit, 2, False, 0.5)) test_df = get_test_titanic() x_test = test_df[:, 1:] # 標準化 sc = StandardScaler() x_test = sc.fit_transform(x_test) chainer.serializers.load_npz("train_chainer.model", model) label_prediction = predict(model, x_test) ids = test_df[:, 0].reshape(x_test.shape[0], 1) result = np.hstack((ids, label_prediction.reshape(x_test.shape[0], 1))) np.savetxt("predict_chainer.csv", result, delimiter=",", header="PassengerId,Survived", fmt='%.0f')
def load_mlp(opt, device): basename = "mlp" model_fname = basename + ".model" location = { 'cuda:' + str(opt.gpu): 'cuda:' + str(opt.gpu) } if opt.gpu != -1 else 'cpu' model_dict = torch.load(model_fname, map_location=location) model = nets.MLP(opt.idim, opt.nclasses).to(device) model.load_state_dict(model_dict) return model
def build_model(opt): location = opt.gpu if torch.cuda.is_available( ) and opt.gpu != -1 else 'cpu' device = torch.device(location) model = nets.MLP(opt.idim, opt.nclasses).to(device) task_permutation = np.random.permutation(784) # task_permutation = np.array(range(784)) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(params=filter(lambda p: p.requires_grad, model.parameters()), lr=opt.lr) return device, model, task_permutation, criterion, optimizer
elif args.dataset == 'cifar10' or args.dataset == 'cifar100': # return (- torch.distributions.Normal(x.view(-1, img_dim ** 2), 1.).log_prob(rce)).sum() + beta * kld return F.mse_loss(rce, x, reduction='sum') + beta * kld if args.flow == 'Planar': flows = SimpleFlowModel( [Planar((args.latent_size, )) for k in range(args.K)]) elif args.flow == 'Radial': flows = SimpleFlowModel( [Radial((args.latent_size, )) for k in range(args.K)]) elif args.flow == 'RealNVP': b = torch.Tensor([1 if i % 2 == 0 else 0 for i in range(args.latent_size)]) flows = [] for i in range(args.K): s = nets.MLP([args.latent_size, 8, args.latent_size]) t = nets.MLP([args.latent_size, 8, args.latent_size]) if i % 2 == 0: flows += [MaskedAffineFlow(b, s, t)] else: flows += [MaskedAffineFlow(1 - b, s, t), BatchNorm()] flows = SimpleFlowModel( flows[:-1]) # Remove last Batch Norm layer to allow arbitrary output model = FlowVAE(flows).to(device) optimizer = optim.Adam(model.parameters(), lr=0.001) # train_losses = [] train_loader, test_loader = flow_vae_datasets(args.dataset) def train(model, epoch, beta):
if opt.net == 'rnn_atten': model = nets.RNNAtteion(voc_size=len(TXT.vocab.itos), edim=opt.edim, hdim=opt.hdim, dropout=opt.dropout, padding_idx=TXT.vocab.stoi[PAD], nclasses=nclasses).to(device) if opt.net == 'rnn_atten_lm': model = nets.RNNAtteionLM(voc_size=len(TXT.vocab.itos), edim=opt.edim, hdim=opt.hdim, dropout=opt.dropout, padding_idx=TXT.vocab.stoi[PAD], nclasses=nclasses).to(device) if opt.net == 'mlp': model = nets.MLP(opt.idim, nclasses).to(device) if opt.net == 'rammlp': model = nets.RAMMLP(idim=opt.idim, nclasses=nclasses, capacity=opt.capacity, criterion=nn.CrossEntropyLoss(), bsz_sampling=opt.bsz_sampling).to(device) if opt.net == 'mbpamlp': model = nets.MbPAMLP(idim=opt.idim, nclasses=nclasses, capacity=opt.capacity, criterion=nn.CrossEntropyLoss(), add_per=opt.add_per, device=device).to(device)
def main(): parser = argparse.ArgumentParser(description='Chainer example: Titanic') 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=10, help='Number of sweeps over the dataset to train') parser.add_argument('--frequency', '-f', type=int, default=-1, help='Frequency of taking a snapshot') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') 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() 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 = L.Classifier(nets.MLP(args.unit, 2)) if args.gpu >= 0: chainer.cuda.get_device(args.gpu).use() # Make a specified GPU current model.to_gpu() # Copy the model to the GPU # Setup an optimizer optimizer = chainer.optimizers.Adam() optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(0.01)) # Load the MNIST dataset #train, test = chainer.datasets.get_mnist() train, test = get_titanic() 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, 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 for each specified epoch frequency = args.epoch if args.frequency == -1 else max(1, args.frequency) trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch')) # Write a log of evaluation statistics for each epoch trainer.extend(extensions.LogReport()) # 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')) # 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()) if args.resume: # Resume from a snapshot chainer.serializers.load_npz(args.resume, trainer) # Run the training trainer.run() chainer.serializers.save_npz("train_chainer.model", model)