def infer_initial_states_sctrnn(params, old_model, testing_data, num_timesteps=0, epochs=None, start_is='mean', error_computation='standard', single_recognition=False, hyp_prior=None, external_signal_variance=-1, x_start=None, use_init_state_loss=True): # each trajectory is handled as a separate "class", infer initial states per class num_classes = testing_data.shape[0] # full number of timesteps num_timesteps_orig = int(testing_data.shape[1] / params.num_io) # timesteps to use for inference if num_timesteps == 0: num_timesteps = num_timesteps_orig gpu_id = 0 # -1 for CPU # Determine whether CPU or GPU should be used xp = np if gpu_id >= 0 and cuda.available: print("Use GPU!") cuda.get_device_from_id(gpu_id).use() xp = cuda.cupy else: print("Use CPU!") gpu_id = -1 c = [] num_samples_per_class = 1 for i in range(num_classes): for j in range(num_samples_per_class): c.append(i) c_train = xp.array(c) save_location = "." if os.path.exists("/media/AnjaDataDrive"): save_location = "/media/AnjaDataDrive" save_location += "/results" now = datetime.datetime.now() expStr = str(now.year).zfill(4) + "-" + str( now.month).zfill(2) + "-" + str(now.day).zfill(2) + "_" + str( now.hour).zfill(2) + "-" + str(now.minute).zfill(2) + "_" + str( now.microsecond).zfill(7) + "_inference" save_dir = os.path.join(save_location, expStr) print(save_dir) pathlib.Path(save_dir).mkdir(parents=True, exist_ok=True) save_interval = 100 # interval for testing the production capability of the network and saving initial state information save_model_interval = 100 # interval for storing the learned model # Should better already be done outside this method # try: # x_train = range2norm(x_train_orig, params.norm_offset, params.norm_range, minmax = params.minmax) # x_train = xp.float32(x_train) # # N = len(x_train) # except: # print("No normalization applicable...") # x_train = testing_data # CUT PART OF THE TRAINING SIGNAL (COMPLETION TASK) testing_data_cut = testing_data[:, 0:params.num_io * num_timesteps] plot_results(xp.copy(testing_data_cut[0::num_samples_per_class]), num_timesteps, os.path.join(save_dir, 'target_trajectories.png'), params.num_io, twoDim=True) info = "same trajectories (original #timesteps: " + str( num_timesteps_orig) + "), used #timesteps: " + str(num_timesteps) # copy network model and prepare it for backpropagation inference params.learn_weights = False params.learn_bias = False params.epochs = epochs max_epochs = 500 if params.epochs: epoch_array_size = params.epochs else: epoch_array_size = max_epochs model = SCTRNN(params.num_io, params.num_c, params.tau_c, num_classes, init_state_init=params.init_state_init, init_state_learning=params.learn_init_states, weights_learning=params.learn_weights, bias_learning=params.learn_bias, tau_learning=params.learn_tau, pretrained_model=old_model) #model.hyp_prior = params.hyp_prior #model.external_signal_variance = params.external_signal_variance if not hyp_prior is None: model.hyp_prior = hyp_prior params.hyp_prior = hyp_prior if external_signal_variance is None or external_signal_variance >= 0: model.external_signal_variance = external_signal_variance params.external_signal_variance = external_signal_variance params.lr = 0.01 with open(os.path.join(save_dir, "info.txt"), 'w') as f: f.write(params.get_parameter_string()) f.write("\n") f.write(info) f.write("\n") f.close() if start_is is 'mean': model.set_initial_states_mean() elif start_is is 'zero': model.set_initial_states_zero() else: model.initial_states.W.array = start_is #model.apply_estimated_variance = True model.set_init_state_learning(c_train) if gpu_id >= 0: model.to_gpu(gpu_id) testing_data = cuda.to_gpu(testing_data) x_start = cuda.to_gpu(x_start) save_network(save_dir, params=params, model=model, model_filename="network-initial") # Optimizer optimizer = optimizers.Adam(params.lr) optimizer.setup(model) #optimizer.add_hook(chainer.optimizer.WeightDecay(0)) history_init_state_var = np.zeros((epoch_array_size + 1, )) history_init_state_var[0] = np.mean( np.var(model.initial_states.W.array, axis=0)) history_generation_error_proactive = np.empty((num_classes, ), dtype=object) history_generation_error_reactive = np.empty((num_classes, ), dtype=object) history_training_error = np.zeros((epoch_array_size + 1, )) history_training_variance_estimation = np.zeros( (epoch_array_size + 1, num_classes)) history_initial_states = [] likelihood_per_epoch = [] print("actual variance of init_states_0: " + str(history_init_state_var[0])) # Evaluate the performance of the untrained network test_batch_size = np.min( [model.initial_states.W.array.shape[0], testing_data.shape[0]]) res, resv, resm = model.generate(model.initial_states.W.array, num_timesteps_orig, add_variance_to_output=0, x_start=x_start) results = res #cuda.to_cpu(res) for i in range(num_classes): generation_error = chainer.functions.mean_squared_error( results[i, :], testing_data[i, :]).array.tolist() history_generation_error_proactive[i] = [generation_error] with open(os.path.join(save_dir, "evaluation.txt"), 'a') as f: f.write("before learning: pattern generation error (proactive): " + str(history_generation_error_proactive[i]) + "\n") plot_results(xp.copy(results), num_timesteps_orig, os.path.join(save_dir, "proactive_before-learning"), params.num_io, twoDim=True) res, resv, resm, pe, wpe, respost = model.generate( model.initial_states.W.array, num_timesteps_orig, external_input=xp.asarray(testing_data[0::num_samples_per_class, :]), add_variance_to_output=0, x_start=x_start) results = res #cuda.to_cpu(res) for i in range(num_classes): generation_error = chainer.functions.mean_squared_error( results[i, :], testing_data[i, :]).array.tolist() history_generation_error_reactive[i] = [generation_error] with open(os.path.join(save_dir, "evaluation.txt"), 'a') as f: f.write("before learning: pattern generation error (reactive): " + str(history_generation_error_reactive[i]) + "\n") plot_results(xp.copy(results), num_timesteps_orig, os.path.join(save_dir, "reactive_before-learning"), params.num_io, twoDim=True) # arrays for tracking likelihood and determining stop condition all_mean_diffs = [] all_std_diffs = [] m1s = [] s1s = [] # tmp_epoch_marker = 0 # conv_eval_interval = 1000 # the length of the interval to consider for determining convergence for epoch in range(1, epoch_array_size + 1): epochStart = time.time() outv = np.zeros((num_timesteps, )) # permutate samples in each epoch so that they are randomly ordered perm = np.random.permutation(testing_data_cut.shape[0]) # here, one batch equals the full training set x_batch = xp.asarray(testing_data_cut[perm]) x_batch = x_batch + 0.01 * xp.random.randn( x_batch.shape[0], x_batch.shape[1]).astype('float32') model.set_init_state_learning(c_train[perm]) mean_init_states = chainer.Variable(xp.zeros((), dtype=xp.float32)) mean_init_states = chainer.functions.average(model.initial_states.W, axis=0) #keepdims=True #mean_init_states = xp.mean(c0.array,axis=0) # using this instead causes no difference in resulting gradient of c0 # initialize error acc_loss = chainer.Variable(xp.zeros( (), dtype=xp.float32)) # for weight backprop acc_init_loss = chainer.Variable(xp.zeros( (), dtype=xp.float32)) # for init states backprop err = xp.zeros(()) # for evaluation only # clear gradients from previous batch model.cleargrads() # clear output and variance estimations from previous batch model.reset_current_output() t = 0 # iterate through time x_t = x_batch[:, params.num_io * t:params.num_io * (t + 1)] # next time step to be predicted (for evaluation) x_t1 = x_batch[:, params.num_io * (t + 1):params.num_io * (t + 2)] # x_t = xp.reshape(x_batch[0][t,:], (1, params.num_io)) # x_t1 = xp.reshape(x_batch[0][t+1,:], (1, params.num_io)) # for i in range(1, params.batch_size): # x_t = np.concatenate((x_t, xp.reshape(x_batch[i][t,:], (1,params.num_io))),axis=0) # x_t1 = np.concatenate((x_t1, xp.reshape(x_batch[i][t+1,:], (1,params.num_io))),axis=0) # execute first forward step u_h, y, v = model( x_t, None ) # initial states of u_h are set automatically according to model.classes # noisy output estimation #y_out = y.array + xp.sqrt(v.array) * xp.random.randn() # compute prediction error, averaged over batch if error_computation == 'standard': # compare network prediction to ground truth loss_i = chainer.functions.gaussian_nll(chainer.Variable(x_t1), y, exponential.log(v)) elif error_computation == 'integrated': # compare network prediction to posterior of perception loss_i = chainer.functions.gaussian_nll(model.current_x, y, exponential.log(v)) acc_loss += loss_i acc_loss += loss_i # compute error for evaluation purposes err += chainer.functions.mean_squared_error( chainer.Variable(x_t), y).array.reshape(()) * params.batch_size outv[t] = xp.mean(v.array) # rollout trajectory for t in range(1, num_timesteps - 1): # current time step x_t = x_batch[:, params.num_io * t:params.num_io * (t + 1)] # next time step to be predicted (for evaluation) x_t1 = x_batch[:, params.num_io * (t + 1):params.num_io * (t + 2)] u_h, y, v = model(x_t, u_h) # noisy output estimation #y_out = y.array + xp.sqrt(v.array) * xp.random.randn() # compute error for backprop for weights if error_computation == 'standard': loss_i = chainer.functions.gaussian_nll( chainer.Variable(x_t1), y, exponential.log(v)) elif error_computation == 'integrated': integrated_x = params.training_external_contrib * chainer.Variable( x_t1) + (1 - params.training_external_contrib) * ( y + chainer.functions.sqrt(v) * xp.random.randn()) loss_i = chainer.functions.gaussian_nll( integrated_x, y, exponential.log(v)) acc_loss += loss_i # compute error for evaluation purposes err += chainer.functions.mean_squared_error( chainer.Variable(x_t), y).array.reshape(()) * params.batch_size outv[t] = xp.mean(v.array) # for each training sequence of this batch: compute loss for maintaining desired initial state variance if not single_recognition and use_init_state_loss: for s in range(len(c_train)): if gpu_id >= 0: acc_init_loss += chainer.functions.gaussian_nll( model.initial_states()[model.classes][s], mean_init_states, xp.ones(mean_init_states.shape) * exponential.log( cuda.to_gpu(params.init_state_var, device=gpu_id))) else: acc_init_loss += chainer.functions.gaussian_nll( model.initial_states()[model.classes][s], mean_init_states, exponential.log(params.init_state_var)) # compute gradients # (gradients from L_out and L_init are summed up) # gradient of initial states equals: # 1/params.init_state_var * (c0[cl]-mean_init_states).array acc_init_loss.backward() else: epochBatchProcessed = time.time() acc_loss.backward() print("update") optimizer.update() print("Done epoch " + str(epoch)) error = err / params.batch_size / num_timesteps mean_estimated_var = xp.mean(outv) history_training_error[epoch] = error history_training_variance_estimation[epoch, :] = mean_estimated_var print("train MSE = " + str(error) + "\nmean estimated var: " + str(mean_estimated_var)) print("init_states = [" + str(model.initial_states.W.array[0][0]) + "," + str(model.initial_states.W.array[0][1]) + "...], var: " + str(np.mean(np.var(model.initial_states.W.array, axis=0))) + ", accs: " + str(acc_loss) + " + " + str(acc_init_loss)) likelihood_per_epoch.append( np.float64(acc_loss.array + acc_init_loss.array)) history_init_state_var[epoch] = np.mean( np.var(model.initial_states.W.array, axis=0)) with open(os.path.join(save_dir, "evaluation.txt"), 'a') as f: f.write("epoch: " + str(epoch) + "\n") f.write("train MSE = " + str(error) + "\nmean estimated var: " + str(mean_estimated_var)) f.write("initial state var: " + str(history_init_state_var[epoch]) + ", precision loss: " + str(acc_loss) + ", variance loss: " + str(acc_init_loss) + "\ninit states:\n") for i in range(num_classes): f.write("\t[" + str(model.initial_states.W[i][0]) + "," + str(model.initial_states.W[i][1]) + "...]\n") f.close() if epoch % save_interval == 1 or epoch == params.epochs: # evaluate proactive generation res, resv, resm, u_h_history = model.generate( model.initial_states.W.array, num_timesteps_orig, add_variance_to_output=0, additional_output='activations', x_start=x_start) results = res #cuda.to_cpu(res) plot_results(xp.copy(results), num_timesteps_orig, os.path.join( save_dir, "proactive_epoch-" + str(epoch).zfill(len(str(epochs)))), params.num_io, twoDim=True) for i in range(num_classes): generation_error = chainer.functions.mean_squared_error( results[i, :], testing_data[i, :]).array.tolist() history_generation_error_proactive[i].append(generation_error) with open(os.path.join(save_dir, "evaluation.txt"), 'a') as f: f.write("pattern generation error (proactive): " + str(generation_error) + "\n") f.close() # evaluate reactive generation res, resv, resm, pe, wpe, u_h_history, respost = model.generate( model.initial_states.W.array, num_timesteps_orig, external_input=xp.asarray( testing_data[0::num_samples_per_class, :]), additional_output='activations', x_start=x_start) results = res #cuda.to_cpu(res) plot_results(xp.copy(results), num_timesteps_orig, os.path.join( save_dir, "reactive_epoch-" + str(epoch).zfill(len(str(epochs)))), params.num_io, twoDim=True) for i in range(test_batch_size): generation_error = chainer.functions.mean_squared_error( results[i, :], testing_data[i, :]).array.tolist() history_generation_error_reactive[i].append(generation_error) with open(os.path.join(save_dir, "evaluation.txt"), 'a') as f: f.write("pattern generation error (reactive): " + str(generation_error) + "\n") f.close() if epoch % save_model_interval == 1 or epoch == params.epochs: save_network(save_dir, params, model, model_filename="network-epoch-" + str(epoch).zfill(len(str(epochs)))) np.save(os.path.join(save_dir, "history_init_state_var"), np.array(history_init_state_var)) np.save( os.path.join(save_dir, "history_generation_error_proactive"), np.array(history_generation_error_proactive)) np.save( os.path.join(save_dir, "history_generation_error_reactive"), np.array(history_generation_error_reactive)) np.save(os.path.join(save_dir, "history_training_error"), np.array(history_training_error)) np.save( os.path.join(save_dir, "history_training_variance_estimation"), np.array(history_training_variance_estimation)) fig = plt.figure() ax = fig.add_subplot(111) ax.plot(np.arange(0, len(history_init_state_var)), history_init_state_var) plt.title("init state variance") fig.savefig(os.path.join(save_dir, "init-state-var")) plt.close() fig = plt.figure() ax = fig.add_subplot(121) for i in range(num_classes): ax.plot( np.arange(0, len(history_generation_error_proactive[i])) * save_interval, history_generation_error_proactive[i]) ax = fig.add_subplot(122) for i in range(num_classes): ax.plot( np.arange(0, len(history_generation_error_reactive[i])) * save_interval, history_generation_error_reactive[i], label=str(i)) plt.title("generation error (proactive / reactive)") plt.legend() fig.savefig(os.path.join(save_dir, "generation-error")) plt.close() plt.figure() plt.plot(np.arange(len(all_std_diffs)), all_std_diffs, 'bo', label='std diff') plt.plot(np.arange(len(all_mean_diffs)), all_mean_diffs, 'ro', label='mean diff') plt.legend() plt.savefig(os.path.join(save_dir, 'convergence-condition.png')) plt.close() history_initial_states.append(model.initial_states.W.array.copy()) # if no epoch number is decided, stop when error is below a threshold if not epochs: if error < 0.01: break save_network(save_dir, params, model, model_filename="network-final") return model.initial_states, history_initial_states, results, resm, save_dir
if __name__ == '__main__': #ハイパーパラメータ num_epochs = 10 #エポック数 batch_size = 500 #バッチ数 learing_rate = 0.001 #学習率 #データ読み込み train, test = load_Mnist() x_train, c_train = train x_test, c_test = test num_train = len(x_train) num_test = len(x_test) #モデル、オプティマイザ(chainer関数の使用) model = ConvNet() optimizer = optimizers.Adam(learing_rate) optimizer.setup(model) if args.gpu >= 0: cuda.get_device(args.gpu).use() model.to_gpu() #訓練ループ loss_log = [] for epoch in range(num_epochs): for i in range(0, num_train, batch_size): x_batch = xp.asarray(x_train[i:i + batch_size]) # 1->バッチサイズまでのループ c_batch = xp.asarray(c_train[i:i + batch_size]) y_batch = model(x_batch) #損失関数の計算
model.to_gpu() def forward(x_data, y_data, train=True): x, t = chainer.Variable(x_data), chainer.Variable(y_data) h = F.max_pooling_2d(F.relu(model.conv1(x)), 2) h = F.max_pooling_2d(F.relu(model.conv2(h)), 2) h = F.dropout(F.relu(model.l1(h)), train=train) y = model.l2(h) if train: return F.softmax_cross_entropy(y, t) else: return F.accuracy(y, t) optimizer = optimizers.Adam() optimizer.setup(model) fp1 = open("accuracy.txt", "w") fp2 = open("loss.txt", "w") fp1.write("epoch\ttest_accuracy\n") fp2.write("epoch\ttrain_loss\n") # 訓練ループ start_time = time.clock() for epoch in range(1, n_epoch + 1): print "epoch: %d" % epoch perm = np.random.permutation(N) sum_loss = 0
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() scaler.fit(dataset.get_datasets()[-1]) 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, label_scaler=scaler) # Set up the iterator. train_iter = SerialIterator(train, args.batchsize) # Set up the regressor. device = args.gpu metrics_fun = {'mae': F.mean_absolute_error, 'rmse': rmse} regressor = Regressor(predictor, lossfun=F.mean_squared_error, metrics_fun=metrics_fun, device=device) # Set up the optimizer. optimizer = optimizers.Adam() optimizer.setup(regressor) # Set up the updater. updater = training.StandardUpdater(train_iter, optimizer, device=device, 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/mae', 'main/rmse', '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)
def main(): t0 = time.time() train_num = int(n_data*0.95) test_num = n_data - train_num channel = 1 axis_x = div axis_y = div axis_z = div output_pos = 3 output_ori = 4 if orientation == "quaternion" else 3 class_num = 2 x = np.zeros((n_data, channel, axis_z, axis_y, axis_x), dtype='float32') if orientation == "quaternion": import network_1 as network y = np.zeros((n_data,7), dtype='float32') elif orientation == 'euler': import network_euler as network y = np.zeros((n_data,6), dtype='float32') elif orientation == 'rotation_matrix': import network_matrix as network y = np.zeros((n_data,12), dtype='float32') if output == 'classification': import network_matrix_class as network #y = np.append(y, np.zeros((n_data,class_num), dtype='float32'), axis=1) label = np.zeros((n_data), dtype='int32') print("load dataset") infh = h5py.File('./datasets/hv7_52000.hdf5', 'r') infh.keys() if output == 'classification': infh2 = h5py.File('./datasets/paper_hv6_58000.hdf5', 'r') infh2.keys() for n in tqdm(range(0,n_data)): ## load dataset from hdf if(output == 'regression' or n < n_data/2): voxel_data = infh["data_"+str(n+1)]['voxel'].value tf_data = infh["data_"+str(n+1)]['pose'].value if output == 'classification': label[n] = np.array(0, dtype='int32') else: voxel_data = infh2["data_"+str(n+1)]['voxel'].value tf_data = infh2["data_"+str(n+1)]['pose'].value if output == 'classification': label[n] = np.array(1, dtype='int32') ## transform or normalize orientation x[n,channel-1] = voxel_data.reshape(axis_x, axis_y, axis_z) if orientation == "euler": tf_data[3:6] = tf_data[3:6]/3.14 y[n] = tf_data[0:6] elif orientation == "rotation_matrix": y[n][0:3] = tf_data[0:3] tf_data = euler_matrix(tf_data[3], tf_data[4], tf_data[5], 'sxyz') y[n][3:12] = tf_data[0:3,0:3].reshape(9) print(x.shape) print("y.shape: {}".format(y.shape)) #### visualize voxel data ## point_x = [] ## point_y = [] ## point_z = [] ## fig = plt.figure() ## ax = fig.add_subplot(111, projection='3d') ## ax.set_xlabel("x") ## ax.set_ylabel("y") ## ax.set_zlabel("z") ## ## for m in range(channel): ## for i in range(axis_z): ## for j in range(axis_y): ## for k in range(axis_x): ## if(voxel_data[(div*div*i) + (div*j) + (k)] == 1): ## x[n, m, i, j, k] = 1 ## point_x.append(k) ## point_y.append(j) ## point_z.append(i) ## ## ax.scatter(point_x, point_y, point_z) ## plt.show() ##for a in range(4): ##p = Process(target=make_voxel, args=(infh,)) ##p.start() ##p.join() print("finish loading datasets") t1 = time.time() elapsed_time1 = t1-t0 print("データ読み込み時間:{}".format(elapsed_time1)) nn = network.CNN() if gpu >= 0: nn.to_gpu(0) ##print(x[0:train_num]) if output == 'classification': p = list(zip(x, y, label)) random.shuffle(p) x, y, label = zip(*p) train = TupleDataset(x[:train_num], y[:train_num], label[:train_num]) val = TupleDataset(x[train_num:],y[train_num:], label[train_num:]) else: p = list(zip(x, y)) random.shuffle(p) x, y = zip(*p) train = TupleDataset(x[:train_num], y[:train_num]) val = TupleDataset(x[train_num:],y[train_num:]) train_iter = iterators.SerialIterator(train, batchsize) val_iter = iterators.SerialIterator(val, batchsize, False, False) optimizer = optimizers.Adam() optimizer.setup(nn) updater = training.updaters.StandardUpdater(train_iter, optimizer, device=gpu) trainer = training.Trainer(updater, (max_epoch, 'epoch')) trainer.extend(extensions.LogReport()) trainer.extend(extensions.Evaluator(val_iter, nn, device=gpu)) trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss'])) trainer.extend(extensions.PlotReport(['main/loss', 'validation/main/loss'], x_key='epoch', file_name='loss.png')) trainer.extend(extensions.dump_graph('main/loss')) ##trigger = training.triggers.MaxValueTrigger('validation/main/loss', trigger=(1, 'epoch')) ##trainer.extend(extensions.snapshot_object(nn, filename='result/new_best.model'), trigger=trigger) trainer.run() if args.gpu >= 0: nn.to_cpu() t2 = time.time() elapsed_time2 = t2-t1 print("データ読み込み時間:{}".format(elapsed_time1)) print("学習時間:{}".format(elapsed_time2)) serializers.save_npz('result/new.model', nn)
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=100, type=int, help='number of units') parser.add_argument('--window', '-w', default=5, type=int, help='window size') parser.add_argument('--batchsize', '-b', type=int, default=1000, help='learning minibatch size') parser.add_argument('--epoch', '-e', default=20, type=int, help='number of epochs to learn') parser.add_argument('--model', '-m', choices=['skipgram', 'cbow'], default='skipgram', 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.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() counts = collections.Counter(train) counts.update(collections.Counter(val)) n_vocab = max(train) + 1 if args.test: train = train[:100] val = val[:100] vocab = chainer.datasets.get_ptb_words_vocabulary() 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) 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) val_iter = WindowIterator(val, args.window, args.batchsize, repeat=False) # Set up an updater updater = training.updaters.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), args.unit)) w = cuda.to_cpu(model.embed.W.data) for i, wi in enumerate(w): v = ' '.join(map(str, wi)) f.write('%s %s\n' % (index2word[i], v))
def train(args): np.random.seed(args.seed) train_l, train_ul, test = load_dataset(args.data_dir, valid=args.validation, dataset_seed=args.dataset_seed) print("N_train_labeled:{}, N_train_unlabeled:{}".format( train_l.N, train_ul.N)) enc = CNN(n_outputs=args.n_categories, dropout_rate=args.dropout_rate, top_bn=args.top_bn) if args.gpu > -1: chainer.cuda.get_device(args.gpu).use() enc.to_gpu() if args.net != '': serializers.load_npz(args.net, enc) optimizer = optimizers.Adam(alpha=args.lr, beta1=args.mom1) optimizer.setup(enc) if args.opt != '': serializers.load_npz(args.opt, optimizer) alpha_plan = [args.lr] * args.num_epochs beta1_plan = [args.mom1] * args.num_epochs for i in range(args.epoch_decay_start, args.num_epochs): alpha_plan[i] = float(args.num_epochs - i) / ( args.num_epochs - args.epoch_decay_start) * args.lr beta1_plan[i] = args.mom2 accs_test = np.zeros(args.num_epochs) cl_losses = np.zeros(args.num_epochs) ul_losses = np.zeros(args.num_epochs) mkdir_p(args.log_dir) for epoch in range(args.num_epochs): with chainer.using_config('train', True): optimizer.alpha = alpha_plan[epoch] optimizer.beta1 = beta1_plan[epoch] sum_loss_l = 0 sum_loss_ul = 0 for it in range(args.num_iter_per_epoch): start = time.time() x1, t = train_l.get(args.batchsize, gpu=args.gpu, aug_trans=args.aug_trans, aug_flip=args.aug_flip) loss_l = loss_labeled(enc, Variable(x1), Variable(t)) x_u1, _ = train_ul.get(args.batchsize_ul, gpu=args.gpu, aug_trans=args.aug_trans, aug_flip=args.aug_flip) loss_ul = loss_unlabeled(enc, Variable(x_u1), args) beta = args.beta loss_total = loss_l + beta * loss_ul enc.cleargrads() loss_total.backward() optimizer.update() sum_loss_l += loss_l.data sum_loss_ul += loss_ul.data end = time.time() print( "Epoch: {} Iter: {} time_batch: {} beta: {} loss_l: {} loss_ul: {}" .format(epoch, it, end - start, beta, loss_l.data, loss_ul.data)) cl_losses[epoch] = sum_loss_l / args.num_iter_per_epoch ul_losses[epoch] = sum_loss_ul / args.num_iter_per_epoch if (epoch + 1) % args.eval_freq == 0: with chainer.using_config('train', False): acc_test_sum = 0 test_x, test_t = test.get() N_test = test_x.shape[0] for i in range(0, N_test, args.batchsize_eval): x = test_x[i:i + args.batchsize_eval] t = test_t[i:i + args.batchsize_eval] if args.gpu > -1: x, t = cuda.to_gpu(x, device=args.gpu), cuda.to_gpu( t, device=args.gpu) _, acc = loss_test(enc, Variable(x), Variable(t)) acc_test_sum += acc * x.shape[0] accs_test[epoch] = acc_test_sum / N_test print( "Epoch:{}, classification loss:{}, unlabeled loss:{}, time:{}" .format(epoch, cl_losses[epoch], ul_losses[epoch], end - start)) print("test acc:{}".format(accs_test[epoch])) sys.stdout.flush() if (epoch + 1) % args.snapshot_freq == 0: # Save stats and model np.savetxt(os.path.join(args.log_dir, 'log.txt'), np.concatenate([ np.array([['acc', 'cl_loss', 'ul_loss']]), np.transpose([accs_test, cl_losses, ul_losses]) ], 0), fmt='%s') serializers.save_npz( os.path.join(args.log_dir, 'trained_model_ep{}'.format(epoch)), enc) serializers.save_npz( os.path.join(args.log_dir, 'optimizer_ep{}'.format(epoch)), optimizer) # Save final stats and model np.savetxt(os.path.join(args.log_dir, 'log.txt'), np.concatenate([ np.array([['acc', 'cl_loss', 'ul_loss']]), np.transpose([accs_test, cl_losses, ul_losses]) ], 0), fmt='%s') serializers.save_npz(os.path.join(args.log_dir, 'trained_model_final'), enc) serializers.save_npz(os.path.join(args.log_dir, 'optimizer_final'), optimizer)
def main(): # Supported preprocessing/network list method_list = ['nfp', 'ggnn', 'schnet', 'weavenet', 'rsgcn'] label_names = D.get_tox21_label_names() iterator_type = ['serial', 'balanced'] parser = argparse.ArgumentParser( description='Multitask Learning with Tox21.') parser.add_argument('--method', '-m', type=str, choices=method_list, default='nfp', help='graph convolution model to use ' 'as a predictor.') parser.add_argument('--label', '-l', type=str, choices=label_names, default='', help='target label for logistic ' 'regression. Use all labels if this option ' 'is not specified.') parser.add_argument('--iterator-type', type=str, choices=iterator_type, default='serial', help='iterator type. If `balanced` ' 'is specified, data is sampled to take same number of' 'positive/negative labels during training.') parser.add_argument('--eval-mode', type=int, default=1, help='Evaluation mode.' '0: only binary_accuracy is calculated.' '1: binary_accuracy and ROC-AUC score is calculated') parser.add_argument('--conv-layers', '-c', type=int, default=4, help='number of convolution layers') parser.add_argument('--batchsize', '-b', type=int, default=32, help='batch size') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID to use. Negative value indicates ' 'not to use GPU and to run the code in CPU.') parser.add_argument('--out', '-o', type=str, default='result', help='path to output directory') parser.add_argument('--epoch', '-e', type=int, default=10, help='number of epochs') parser.add_argument('--unit-num', '-u', type=int, default=16, help='number of units in one layer of the model') parser.add_argument('--resume', '-r', type=str, default='', help='path to a trainer snapshot') parser.add_argument('--frequency', '-f', type=int, default=-1, help='Frequency of taking a snapshot') parser.add_argument('--protocol', type=int, default=2, help='protocol version for pickle') parser.add_argument('--model-filename', type=str, default='classifier.pkl', help='file name for pickled model') parser.add_argument('--num-data', type=int, default=-1, help='Number of data to be parsed from parser.' '-1 indicates to parse all data.') args = parser.parse_args() method = args.method if args.label: labels = args.label class_num = len(labels) if isinstance(labels, list) else 1 else: labels = None class_num = len(label_names) # Dataset preparation train, val, _ = data.load_dataset(method, labels, num_data=args.num_data) # Network predictor_ = predictor.build_predictor(method, args.unit_num, args.conv_layers, class_num) iterator_type = args.iterator_type if iterator_type == 'serial': train_iter = I.SerialIterator(train, args.batchsize) elif iterator_type == 'balanced': if class_num > 1: raise ValueError('BalancedSerialIterator can be used with only one' 'label classification, please specify label to' 'be predicted by --label option.') train_iter = BalancedSerialIterator(train, args.batchsize, train.features[:, -1], ignore_labels=-1) train_iter.show_label_stats() else: raise ValueError('Invalid iterator type {}'.format(iterator_type)) val_iter = I.SerialIterator(val, args.batchsize, repeat=False, shuffle=False) classifier = Classifier(predictor_, lossfun=F.sigmoid_cross_entropy, metrics_fun=F.binary_accuracy, device=args.gpu) optimizer = O.Adam() optimizer.setup(classifier) updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=concat_mols) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend( E.Evaluator(val_iter, classifier, device=args.gpu, converter=concat_mols)) trainer.extend(E.LogReport()) eval_mode = args.eval_mode if eval_mode == 0: trainer.extend( E.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', 'validation/main/loss', 'validation/main/accuracy', 'elapsed_time' ])) elif eval_mode == 1: train_eval_iter = I.SerialIterator(train, args.batchsize, repeat=False, shuffle=False) trainer.extend( ROCAUCEvaluator(train_eval_iter, classifier, eval_func=predictor_, device=args.gpu, converter=concat_mols, name='train', pos_labels=1, ignore_labels=-1, raise_value_error=False)) # extension name='validation' is already used by `Evaluator`, # instead extension name `val` is used. trainer.extend( ROCAUCEvaluator(val_iter, classifier, eval_func=predictor_, device=args.gpu, converter=concat_mols, name='val', pos_labels=1, ignore_labels=-1)) trainer.extend( E.PrintReport([ 'epoch', 'main/loss', 'main/accuracy', 'train/main/roc_auc', 'validation/main/loss', 'validation/main/accuracy', 'val/main/roc_auc', 'elapsed_time' ])) else: raise ValueError('Invalid accfun_mode {}'.format(eval_mode)) trainer.extend(E.ProgressBar(update_interval=10)) frequency = args.epoch if args.frequency == -1 else max(1, args.frequency) trainer.extend(E.snapshot(), trigger=(frequency, 'epoch')) if args.resume: chainer.serializers.load_npz(args.resume, trainer) trainer.run() config = { 'method': args.method, 'conv_layers': args.conv_layers, 'unit_num': args.unit_num, 'labels': args.label } with open(os.path.join(args.out, 'config.json'), 'w') as o: o.write(json.dumps(config)) classifier.save_pickle(os.path.join(args.out, args.model_filename), protocol=args.protocol)
def main(): ########################### #### create dictionary #### ########################### if os.path.exists('./data/corpus/dictionary.dict'): if args.lang == 'ja': corpus = JaConvCorpus(file_path=None, batch_size=batchsize) else: corpus = ConvCorpus(file_path=None, batch_size=batchsize) corpus.load(load_dir='./data/corpus/') else: if args.lang == 'ja': corpus = JaConvCorpus(file_path=data_file, batch_size=batchsize) else: corpus = ConvCorpus(file_path=data_file, batch_size=batchsize) corpus.save(save_dir='./data/corpus/') print('Vocabulary Size (number of words) :', len(corpus.dic.token2id)) ###################### #### create model #### ###################### model = Seq2Seq(len(corpus.dic.token2id), feature_num=feature_num, hidden_num=hidden_num, batch_size=batchsize, gpu_flg=args.gpu) if args.gpu >= 0: model.to_gpu() optimizer = optimizers.Adam(alpha=0.001) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.GradientClipping(5)) # optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001)) ########################## #### create ID corpus #### ########################## input_mat = [] output_mat = [] max_input_ren = max_output_ren = 0 for input_text, output_text in zip(corpus.posts, corpus.cmnts): # convert to list input_text.reverse() # encode words in a reverse order input_text.insert(0, corpus.dic.token2id["<eos>"]) output_text.append(corpus.dic.token2id["<eos>"]) # update max sentence length max_input_ren = max(max_input_ren, len(input_text)) max_output_ren = max(max_output_ren, len(output_text)) input_mat.append(input_text) output_mat.append(output_text) # padding for li in input_mat: insert_num = max_input_ren - len(li) for _ in range(insert_num): li.insert(0, corpus.dic.token2id['<pad>']) for li in output_mat: insert_num = max_output_ren - len(li) for _ in range(insert_num): li.append(corpus.dic.token2id['<pad>']) # create batch matrix input_mat = np.array(input_mat, dtype=np.int32).T output_mat = np.array(output_mat, dtype=np.int32).T # separate corpus into Train and Test perm = np.random.permutation(len(corpus.posts)) test_input_mat = input_mat[:, perm[0:0 + testsize]] test_output_mat = output_mat[:, perm[0:0 + testsize]] train_input_mat = input_mat[:, perm[testsize:]] train_output_mat = output_mat[:, perm[testsize:]] list_of_references = [] for text_ndarray in test_output_mat.T: reference = text_ndarray.tolist() references = [[w_id for w_id in reference if w_id is not -1]] list_of_references.append(references) ############################# #### train seq2seq model #### ############################# accum_loss = 0 train_loss_data = [] test_loss_data = [] bleu_score_data = [] wer_score_data = [] for num, epoch in enumerate(range(n_epoch)): total_loss = test_loss = 0 batch_num = 0 perm = np.random.permutation(len(corpus.posts) - testsize) # for training for i in range(0, len(corpus.posts) - testsize, batchsize): # select batch data input_batch = train_input_mat[:, perm[i:i + batchsize]] output_batch = train_output_mat[:, perm[i:i + batchsize]] # Encode a sentence model.initialize() # initialize cell model.encode(input_batch, train=True) # encode (output: hidden Variable) # Decode from encoded context end_batch = xp.array( [corpus.dic.token2id["<start>"] for _ in range(batchsize)]) first_words = output_batch[0] loss, predict_mat = model.decode(end_batch, first_words, train=True) next_ids = first_words accum_loss += loss for w_ids in output_batch[1:]: loss, predict_mat = model.decode(next_ids, w_ids, train=True) next_ids = w_ids accum_loss += loss # learn model model.cleargrads() # initialize all grad to zero accum_loss.backward() # back propagation optimizer.update() total_loss += float(accum_loss.data) batch_num += 1 print('Epoch: ', num, 'Batch_num', batch_num, 'batch loss: {:.2f}'.format(float(accum_loss.data))) accum_loss = 0 # for testing list_of_hypotheses = [] for i in range(0, testsize, batchsize): # select test batch data input_batch = test_input_mat[:, i:i + batchsize] output_batch = test_output_mat[:, i:i + batchsize] # Encode a sentence model.initialize() # initialize cell model.encode(input_batch, train=True) # encode (output: hidden Variable) # Decode from encoded context end_batch = xp.array( [corpus.dic.token2id["<start>"] for _ in range(batchsize)]) first_words = output_batch[0] loss, predict_mat = model.decode(end_batch, first_words, train=True) next_ids = xp.argmax(predict_mat.data, axis=1) test_loss += loss if args.gpu >= 0: hypotheses = [cuda.to_cpu(next_ids)] else: hypotheses = [next_ids] for w_ids in output_batch[1:]: loss, predict_mat = model.decode(next_ids, w_ids, train=True) next_ids = xp.argmax(predict_mat.data, axis=1) test_loss += loss if args.gpu >= 0: hypotheses.append(cuda.to_cpu(next_ids)) else: hypotheses.append(next_ids) # collect hypotheses for calculating BLEU score hypotheses = np.array(hypotheses).T for hypothesis in hypotheses: text_list = hypothesis.tolist() list_of_hypotheses.append( [w_id for w_id in text_list if w_id is not -1]) # calculate BLEU score from test (develop) data bleu_score = nltk.translate.bleu_score.corpus_bleu(list_of_references, list_of_hypotheses, weights=(0.25, 0.25, 0.25, 0.25)) bleu_score_data.append(bleu_score) print('Epoch: ', num, 'BLEU SCORE: ', bleu_score) # calculate WER score from test (develop) data wer_score = 0 for index, references in enumerate(list_of_references): wer_score += wer(references[0], list_of_hypotheses[index]) wer_score /= len(list_of_references) wer_score_data.append(wer_score) print('Epoch: ', num, 'WER SCORE: ', wer_score) # save model and optimizer if (epoch + 1) % 10 == 0: print('-----', epoch + 1, ' times -----') print('save the model and optimizer') serializers.save_hdf5('data/' + str(epoch) + '.model', model) serializers.save_hdf5('data/' + str(epoch) + '.state', optimizer) # display the on-going status print('Epoch: ', num, 'Train loss: {:.2f}'.format(total_loss), 'Test loss: {:.2f}'.format(float(test_loss.data))) train_loss_data.append(float(total_loss / batch_num)) test_loss_data.append(float(test_loss.data)) # evaluate a test loss check_loss = test_loss_data[-10:] # check out the last 10 loss data end_flg = [ j for j in range(len(check_loss) - 1) if check_loss[j] < check_loss[j + 1] ] if len(end_flg) > 8: print('Probably it is over-fitting. So stop to learn...') break # save loss data with open('./data/loss_train_data.pkl', 'wb') as f: pickle.dump(train_loss_data, f) with open('./data/loss_test_data.pkl', 'wb') as f: pickle.dump(test_loss_data, f) with open('./data/bleu_score_data.pkl', 'wb') as f: pickle.dump(bleu_score_data, f) with open('./data/wer_score_data.pkl', 'wb') as f: pickle.dump(wer_score_data, f)
def create(self): if self.dtype == numpy.float16: kwargs = {'eps': 1e-6} else: kwargs = {} return optimizers.Adam(0.05, **kwargs)
def _test_abc(self, use_lstm, discrete=True, steps=1000000, require_success=True, gpu=-1): def make_env(process_idx, test): size = 2 return ABC(size=size, discrete=discrete, episodic=True, partially_observable=self.use_lstm, deterministic=test) sample_env = make_env(0, False) action_space = sample_env.action_space obs_space = sample_env.observation_space def phi(x): return x n_hidden_channels = 20 n_hidden_layers = 1 nonlinearity = F.leaky_relu if use_lstm: if discrete: model = chainerrl.links.Sequence( L.LSTM(obs_space.low.size, n_hidden_channels, forget_bias_init=1), policies.FCSoftmaxPolicy( n_hidden_channels, action_space.n, n_hidden_channels=n_hidden_channels, n_hidden_layers=n_hidden_layers, nonlinearity=nonlinearity), ) else: model = chainerrl.links.Sequence( L.LSTM(obs_space.low.size, n_hidden_channels, forget_bias_init=1), policies.FCGaussianPolicy( n_hidden_channels, action_space.low.size, n_hidden_channels=n_hidden_channels, n_hidden_layers=n_hidden_layers, bound_mean=True, min_action=action_space.low, max_action=action_space.high, nonlinearity=nonlinearity, ) ) else: if discrete: model = policies.FCSoftmaxPolicy( obs_space.low.size, action_space.n, n_hidden_channels=n_hidden_channels, n_hidden_layers=n_hidden_layers, nonlinearity=nonlinearity) else: model = policies.FCGaussianPolicy( obs_space.low.size, action_space.low.size, n_hidden_channels=n_hidden_channels, n_hidden_layers=n_hidden_layers, bound_mean=True, min_action=action_space.low, max_action=action_space.high, nonlinearity=nonlinearity, ) if gpu >= 0: chainer.cuda.get_device(gpu).use() model.to_gpu() opt = optimizers.Adam() opt.setup(model) beta = 1e-2 agent = chainerrl.agents.REINFORCE( model, opt, beta=beta, phi=phi, batchsize=self.batchsize, backward_separately=self.backward_separately, act_deterministically=True, ) chainerrl.experiments.train_agent_with_evaluation( agent=agent, env=make_env(0, False), eval_env=make_env(0, True), outdir=self.outdir, steps=steps, max_episode_len=2, eval_interval=500, eval_n_runs=5, successful_score=1) # Test env = make_env(0, True) n_test_runs = 5 for _ in range(n_test_runs): total_r = 0 obs = env.reset() done = False reward = 0.0 while not done: action = agent.act(obs) print('state:', obs, 'action:', action) obs, reward, done, _ = env.step(action) total_r += reward if require_success: self.assertAlmostEqual(total_r, 1) agent.stop_episode()
start_epoch = 0 if args.model != -1: # 保存したモデルがある場合 serializers.load_hdf5('epoch_' + str(args.model) + '.model', model) start_epoch = args.model if args.gpus >= 0: # GPU使用の設定 cuda.get_device_from_id(args.gpus).use() model.to_gpu(args.gpus) xp = cuda.cupy if args.optimize == 'sgd': # 学習率のアルゴリズム optm = optimizers.SGD() elif args.optimize == 'adagrad': optm = optimizers.AdaGrad() elif args.optimize == 'adam': optm = optimizers.Adam() elif args.optimize == 'adadelta': optm = optimizers.AdaDelta() elif args.optimize == 'rmsprop': optm = optimizers.RMSprop() optm.setup(model) optm.add_hook(chainer.optimizer.WeightDecay(0.0001)) optm.add_hook(chainer.optimizer.GradientClipping(5)) start_time = time.time() cur_time = start_time print('Training start...') for epoch in range(start_epoch, args.epoch): train_batch_loss = [] dev_batch_loss = []
def main(): parser = argparse.ArgumentParser() parser.add_argument('--outdir', type=str, default='results', help='Directory path to save output files.' ' If it does not exist, it will be created.') parser.add_argument('--env', type=str, default='Hopper-v2', help='OpenAI Gym MuJoCo env to perform algorithm on.') parser.add_argument('--num-envs', type=int, default=1, help='Number of envs run in parallel.') parser.add_argument('--seed', type=int, default=0, help='Random seed [0, 2 ** 32)') parser.add_argument('--gpu', type=int, default=0, help='GPU to use, set to -1 if no GPU.') parser.add_argument('--load', type=str, default='', help='Directory to load agent from.') parser.add_argument('--steps', type=int, default=10**6, help='Total number of timesteps to train the agent.') parser.add_argument('--eval-n-runs', type=int, default=10, help='Number of episodes run for each evaluation.') parser.add_argument('--eval-interval', type=int, default=5000, help='Interval in timesteps between evaluations.') parser.add_argument('--replay-start-size', type=int, default=10000, help='Minimum replay buffer size before ' + 'performing gradient updates.') parser.add_argument('--batch-size', type=int, default=256, help='Minibatch size') parser.add_argument('--render', action='store_true', help='Render env states in a GUI window.') parser.add_argument('--demo', action='store_true', help='Just run evaluation, not training.') parser.add_argument('--monitor', action='store_true', help='Wrap env with gym.wrappers.Monitor.') parser.add_argument('--log-interval', type=int, default=1000, help='Interval in timesteps between outputting log' ' messages during training') parser.add_argument('--logger-level', type=int, default=logging.INFO, help='Level of the root logger.') parser.add_argument('--policy-output-scale', type=float, default=1., help='Weight initialization scale of polity output.') parser.add_argument('--debug', action='store_true', help='Debug mode.') args = parser.parse_args() logging.basicConfig(level=args.logger_level) if args.debug: chainer.set_debug(True) args.outdir = experiments.prepare_output_dir(args, args.outdir, argv=sys.argv) print('Output files are saved in {}'.format(args.outdir)) # Set a random seed used in ChainerRL misc.set_random_seed(args.seed, gpus=(args.gpu, )) # Set different random seeds for different subprocesses. # If seed=0 and processes=4, subprocess seeds are [0, 1, 2, 3]. # If seed=1 and processes=4, subprocess seeds are [4, 5, 6, 7]. process_seeds = np.arange(args.num_envs) + args.seed * args.num_envs assert process_seeds.max() < 2**32 def make_env(process_idx, test): env = gym.make(args.env) # Unwrap TimiLimit wrapper assert isinstance(env, gym.wrappers.TimeLimit) env = env.env # Use different random seeds for train and test envs process_seed = int(process_seeds[process_idx]) env_seed = 2**32 - 1 - process_seed if test else process_seed env.seed(env_seed) # Cast observations to float32 because our model uses float32 env = chainerrl.wrappers.CastObservationToFloat32(env) # Normalize action space to [-1, 1]^n env = chainerrl.wrappers.NormalizeActionSpace(env) if args.monitor: env = gym.wrappers.Monitor(env, args.outdir) if args.render: env = chainerrl.wrappers.Render(env) return env def make_batch_env(test): return chainerrl.envs.MultiprocessVectorEnv([ functools.partial(make_env, idx, test) for idx, env in enumerate(range(args.num_envs)) ]) sample_env = make_env(process_idx=0, test=False) timestep_limit = sample_env.spec.tags.get( 'wrapper_config.TimeLimit.max_episode_steps') obs_space = sample_env.observation_space action_space = sample_env.action_space print('Observation space:', obs_space) print('Action space:', action_space) action_size = action_space.low.size winit = chainer.initializers.GlorotUniform() winit_policy_output = chainer.initializers.GlorotUniform( args.policy_output_scale) def squashed_diagonal_gaussian_head(x): assert x.shape[-1] == action_size * 2 mean, log_scale = F.split_axis(x, 2, axis=1) log_scale = F.clip(log_scale, -20, 2) var = F.exp(log_scale * 2) return chainerrl.distribution.SquashedGaussianDistribution(mean, var=var) policy = chainer.Sequential( L.Linear(None, 256, initialW=winit), F.relu, L.Linear(None, 256, initialW=winit), F.relu, L.Linear(None, action_size * 2, initialW=winit_policy_output), squashed_diagonal_gaussian_head, ) policy_optimizer = optimizers.Adam(3e-4).setup(policy) def make_q_func_with_optimizer(): q_func = chainer.Sequential( concat_obs_and_action, L.Linear(None, 256, initialW=winit), F.relu, L.Linear(None, 256, initialW=winit), F.relu, L.Linear(None, 1, initialW=winit), ) q_func_optimizer = optimizers.Adam(3e-4).setup(q_func) return q_func, q_func_optimizer q_func1, q_func1_optimizer = make_q_func_with_optimizer() q_func2, q_func2_optimizer = make_q_func_with_optimizer() # Draw the computational graph and save it in the output directory. fake_obs = chainer.Variable(policy.xp.zeros_like(obs_space.low, dtype=np.float32)[None], name='observation') fake_action = chainer.Variable(policy.xp.zeros_like( action_space.low, dtype=np.float32)[None], name='action') chainerrl.misc.draw_computational_graph([policy(fake_obs)], os.path.join( args.outdir, 'policy')) chainerrl.misc.draw_computational_graph([q_func1(fake_obs, fake_action)], os.path.join( args.outdir, 'q_func1')) chainerrl.misc.draw_computational_graph([q_func2(fake_obs, fake_action)], os.path.join( args.outdir, 'q_func2')) rbuf = replay_buffer.ReplayBuffer(10**6) def burnin_action_func(): """Select random actions until model is updated one or more times.""" return np.random.uniform(action_space.low, action_space.high).astype(np.float32) # Hyperparameters in http://arxiv.org/abs/1802.09477 agent = chainerrl.agents.SoftActorCritic( policy, q_func1, q_func2, policy_optimizer, q_func1_optimizer, q_func2_optimizer, rbuf, gamma=0.99, replay_start_size=args.replay_start_size, gpu=args.gpu, minibatch_size=args.batch_size, burnin_action_func=burnin_action_func, entropy_target=-action_size, temperature_optimizer=chainer.optimizers.Adam(3e-4), ) if len(args.load) > 0: agent.load(args.load) if args.demo: eval_stats = experiments.eval_performance( env=make_batch_env(test=True), agent=agent, n_steps=None, n_episodes=args.eval_n_runs, max_episode_len=timestep_limit, ) print('n_runs: {} mean: {} median: {} stdev {}'.format( args.eval_n_runs, eval_stats['mean'], eval_stats['median'], eval_stats['stdev'])) else: experiments.train_agent_batch_with_evaluation( agent=agent, env=make_batch_env(test=False), eval_env=make_batch_env(test=True), outdir=args.outdir, steps=args.steps, eval_n_steps=None, eval_n_episodes=args.eval_n_runs, eval_interval=args.eval_interval, log_interval=args.log_interval, max_episode_len=timestep_limit, )
def main(): import logging logging.basicConfig(level=logging.DEBUG) parser = argparse.ArgumentParser() parser.add_argument('--outdir', type=str, default='results', help='Directory path to save output files.' ' If it does not exist, it will be created.') parser.add_argument('--env', type=str, default='Pendulum-v0') parser.add_argument('--seed', type=int, default=0, help='Random seed [0, 2 ** 32)') parser.add_argument('--gpu', type=int, default=0) parser.add_argument('--final-exploration-steps', type=int, default=10**4) parser.add_argument('--start-epsilon', type=float, default=1.0) parser.add_argument('--end-epsilon', type=float, default=0.1) parser.add_argument('--noisy-net-sigma', type=float, default=None) parser.add_argument('--demo', action='store_true', default=False) parser.add_argument('--load', type=str, default=None) parser.add_argument('--steps', type=int, default=10**5) parser.add_argument('--prioritized-replay', action='store_true') parser.add_argument('--episodic-replay', action='store_true') parser.add_argument('--replay-start-size', type=int, default=1000) parser.add_argument('--target-update-interval', type=int, default=10**2) parser.add_argument('--target-update-method', type=str, default='hard') parser.add_argument('--soft-update-tau', type=float, default=1e-2) parser.add_argument('--update-interval', type=int, default=1) parser.add_argument('--eval-n-runs', type=int, default=100) parser.add_argument('--eval-interval', type=int, default=10**4) parser.add_argument('--n-hidden-channels', type=int, default=100) parser.add_argument('--n-hidden-layers', type=int, default=2) parser.add_argument('--gamma', type=float, default=0.99) parser.add_argument('--minibatch-size', type=int, default=None) parser.add_argument('--render-train', action='store_true') parser.add_argument('--render-eval', action='store_true') parser.add_argument('--monitor', action='store_true') parser.add_argument('--reward-scale-factor', type=float, default=1e-3) args = parser.parse_args() # Set a random seed used in ChainerRL misc.set_random_seed(args.seed, gpus=(args.gpu, )) args.outdir = experiments.prepare_output_dir(args, args.outdir, argv=sys.argv) print('Output files are saved in {}'.format(args.outdir)) def clip_action_filter(a): return np.clip(a, action_space.low, action_space.high) def make_env(test): env = gym.make(args.env) # Use different random seeds for train and test envs env_seed = 2**32 - 1 - args.seed if test else args.seed env.seed(env_seed) # Cast observations to float32 because our model uses float32 env = chainerrl.wrappers.CastObservationToFloat32(env) if args.monitor: env = gym.wrappers.Monitor(env, args.outdir) if isinstance(env.action_space, spaces.Box): misc.env_modifiers.make_action_filtered(env, clip_action_filter) if not test: # Scale rewards (and thus returns) to a reasonable range so that # training is easier env = chainerrl.wrappers.ScaleReward(env, args.reward_scale_factor) if ((args.render_eval and test) or (args.render_train and not test)): env = chainerrl.wrappers.Render(env) return env env = make_env(test=False) timestep_limit = env.spec.tags.get( 'wrapper_config.TimeLimit.max_episode_steps') obs_space = env.observation_space obs_size = obs_space.low.size action_space = env.action_space if isinstance(action_space, spaces.Box): action_size = action_space.low.size # Use NAF to apply DQN to continuous action spaces q_func = q_functions.FCQuadraticStateQFunction( obs_size, action_size, n_hidden_channels=args.n_hidden_channels, n_hidden_layers=args.n_hidden_layers, action_space=action_space) # Use the Ornstein-Uhlenbeck process for exploration ou_sigma = (action_space.high - action_space.low) * 0.2 explorer = explorers.AdditiveOU(sigma=ou_sigma) else: n_actions = action_space.n q_func = q_functions.FCStateQFunctionWithDiscreteAction( obs_size, n_actions, n_hidden_channels=args.n_hidden_channels, n_hidden_layers=args.n_hidden_layers) # Use epsilon-greedy for exploration explorer = explorers.LinearDecayEpsilonGreedy( args.start_epsilon, args.end_epsilon, args.final_exploration_steps, action_space.sample) if args.noisy_net_sigma is not None: links.to_factorized_noisy(q_func) # Turn off explorer explorer = explorers.Greedy() # Draw the computational graph and save it in the output directory. chainerrl.misc.draw_computational_graph( [q_func(np.zeros_like(obs_space.low, dtype=np.float32)[None])], os.path.join(args.outdir, 'model')) opt = optimizers.Adam() opt.setup(q_func) rbuf_capacity = 5 * 10**5 if args.episodic_replay: if args.minibatch_size is None: args.minibatch_size = 4 if args.prioritized_replay: betasteps = (args.steps - args.replay_start_size) \ // args.update_interval rbuf = replay_buffer.PrioritizedEpisodicReplayBuffer( rbuf_capacity, betasteps=betasteps) else: rbuf = replay_buffer.EpisodicReplayBuffer(rbuf_capacity) else: if args.minibatch_size is None: args.minibatch_size = 32 if args.prioritized_replay: betasteps = (args.steps - args.replay_start_size) \ // args.update_interval rbuf = replay_buffer.PrioritizedReplayBuffer(rbuf_capacity, betasteps=betasteps) else: rbuf = replay_buffer.ReplayBuffer(rbuf_capacity) agent = DQN(q_func, opt, rbuf, gpu=args.gpu, gamma=args.gamma, explorer=explorer, replay_start_size=args.replay_start_size, target_update_interval=args.target_update_interval, update_interval=args.update_interval, minibatch_size=args.minibatch_size, target_update_method=args.target_update_method, soft_update_tau=args.soft_update_tau, episodic_update=args.episodic_replay, episodic_update_len=16) if args.load: agent.load(args.load) eval_env = make_env(test=True) if args.demo: eval_stats = experiments.eval_performance( env=eval_env, agent=agent, n_steps=None, n_episodes=args.eval_n_runs, max_episode_len=timestep_limit) print('n_runs: {} mean: {} median: {} stdev {}'.format( args.eval_n_runs, eval_stats['mean'], eval_stats['median'], eval_stats['stdev'])) else: experiments.train_agent_with_evaluation( agent=agent, env=env, steps=args.steps, eval_n_steps=None, eval_n_episodes=args.eval_n_runs, eval_interval=args.eval_interval, outdir=args.outdir, eval_env=eval_env, train_max_episode_len=timestep_limit)
def main(): # Parse the arguments. args = parse_arguments() augment = False if args.augment == 'False' else True multi_gpu = False if args.multi_gpu == 'False' else True 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): label_arr = np.asarray(label_list, dtype=np.int32) return label_arr # Apply a preprocessor to the dataset. logging.info('Preprocess train dataset and test dataset...') preprocessor = preprocess_method_dict[args.method]() parser = CSVFileParserForPair(preprocessor, postprocess_label=postprocess_label, labels=labels, smiles_cols=['smiles_1', 'smiles_2']) train = parser.parse(args.train_datafile)['dataset'] test = parser.parse(args.test_datafile)['dataset'] if augment: logging.info('Utilizing data augmentation in train set') train = augment_dataset(train) num_train = train.get_datasets()[0].shape[0] num_test = test.get_datasets()[0].shape[0] logging.info('Train/test split: {}/{}'.format(num_train, num_test)) if len(args.net_hidden_dims): net_hidden_dims = tuple([ int(net_hidden_dim) for net_hidden_dim in args.net_hidden_dims.split(',') ]) else: net_hidden_dims = () fp_attention = True if args.fp_attention else False update_attention = True if args.update_attention else False weight_tying = False if args.weight_tying == 'False' else True attention_tying = False if args.attention_tying == 'False' else True fp_batch_normalization = True if args.fp_bn == 'True' else False layer_aggregator = None if args.layer_aggregator == '' else args.layer_aggregator context = False if args.context == 'False' else True output_activation = functions.relu if args.output_activation == 'relu' else None predictor = set_up_predictor( method=args.method, fp_hidden_dim=args.fp_hidden_dim, fp_out_dim=args.fp_out_dim, conv_layers=args.conv_layers, concat_hidden=args.concat_hidden, layer_aggregator=layer_aggregator, fp_dropout_rate=args.fp_dropout_rate, fp_batch_normalization=fp_batch_normalization, net_hidden_dims=net_hidden_dims, class_num=class_num, sim_method=args.sim_method, fp_attention=fp_attention, weight_typing=weight_tying, attention_tying=attention_tying, update_attention=update_attention, fp_max_degree=args.fp_max_degree, context=context, context_layers=args.context_layers, context_dropout=args.context_dropout, message_function=args.message_function, readout_function=args.readout_function, num_timesteps=args.num_timesteps, num_output_hidden_layers=args.num_output_hidden_layers, output_hidden_dim=args.output_hidden_dim, output_activation=output_activation, symmetric=args.symmetric) train_iter = SerialIterator(train, args.batchsize) test_iter = SerialIterator(test, args.batchsize, repeat=False, shuffle=False) metrics_fun = {'accuracy': F.binary_accuracy} classifier = Classifier(predictor, lossfun=loss_func, metrics_fun=metrics_fun, device=args.gpu) # Set up the optimizer. optimizer = optimizers.Adam(alpha=args.learning_rate, weight_decay_rate=args.weight_decay_rate) # optimizer = optimizers.Adam() # optimizer = optimizers.SGD(lr=args.learning_rate) optimizer.setup(classifier) # add regularization if args.max_norm > 0: optimizer.add_hook( chainer.optimizer.GradientClipping(threshold=args.max_norm)) if args.l2_rate > 0: optimizer.add_hook(chainer.optimizer.WeightDecay(rate=args.l2_rate)) if args.l1_rate > 0: optimizer.add_hook(chainer.optimizer.Lasso(rate=args.l1_rate)) # Set up the updater. if multi_gpu: logging.info('Using multiple GPUs') updater = training.ParallelUpdater(train_iter, optimizer, devices={ 'main': 0, 'second': 1 }, converter=concat_mols) else: logging.info('Using single GPU') updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu, converter=concat_mols) # Set up the trainer. logging.info('Training...') # add stop_trigger parameter early_stop = triggers.EarlyStoppingTrigger(monitor='validation/main/loss', patients=10, max_trigger=(500, 'epoch')) out = 'output' + '/' + args.out trainer = training.Trainer(updater, stop_trigger=early_stop, out=out) # trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out) trainer.extend( E.Evaluator(test_iter, classifier, device=args.gpu, converter=concat_mols)) train_eval_iter = SerialIterator(train, args.batchsize, repeat=False, shuffle=False) trainer.extend( AccuracyEvaluator(train_eval_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='train_acc', pos_labels=1, ignore_labels=-1, raise_value_error=False)) # extension name='validation' is already used by `Evaluator`, # instead extension name `val` is used. trainer.extend( AccuracyEvaluator(test_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='val_acc', pos_labels=1, ignore_labels=-1)) trainer.extend( ROCAUCEvaluator(train_eval_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='train_roc', pos_labels=1, ignore_labels=-1, raise_value_error=False)) # extension name='validation' is already used by `Evaluator`, # instead extension name `val` is used. trainer.extend( ROCAUCEvaluator(test_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='val_roc', pos_labels=1, ignore_labels=-1)) trainer.extend( PRCAUCEvaluator(train_eval_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='train_prc', pos_labels=1, ignore_labels=-1, raise_value_error=False)) # extension name='validation' is already used by `Evaluator`, # instead extension name `val` is used. trainer.extend( PRCAUCEvaluator(test_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='val_prc', pos_labels=1, ignore_labels=-1)) trainer.extend( F1Evaluator(train_eval_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='train_f', pos_labels=1, ignore_labels=-1, raise_value_error=False)) # extension name='validation' is already used by `Evaluator`, # instead extension name `val` is used. trainer.extend( F1Evaluator(test_iter, classifier, eval_func=predictor, device=args.gpu, converter=concat_mols, name='val_f', pos_labels=1, ignore_labels=-1)) # apply shift strategy to learning rate every 10 epochs # trainer.extend(E.ExponentialShift('alpha', args.exp_shift_rate), trigger=(10, 'epoch')) if args.exp_shift_strategy == 1: trainer.extend(E.ExponentialShift('alpha', args.exp_shift_rate), trigger=triggers.ManualScheduleTrigger( [10, 20, 30, 40, 50, 60], 'epoch')) elif args.exp_shift_strategy == 2: trainer.extend(E.ExponentialShift('alpha', args.exp_shift_rate), trigger=triggers.ManualScheduleTrigger( [5, 10, 15, 20, 25, 30], 'epoch')) elif args.exp_shift_strategy == 3: trainer.extend(E.ExponentialShift('alpha', args.exp_shift_rate), trigger=triggers.ManualScheduleTrigger( [5, 10, 15, 20, 25, 30, 40, 50, 60, 70], 'epoch')) else: raise ValueError('No such strategy to adapt learning rate') # # observation of learning rate trainer.extend(E.observe_lr(), trigger=(1, 'iteration')) entries = [ 'epoch', 'main/loss', 'train_acc/main/accuracy', 'train_roc/main/roc_auc', 'train_prc/main/prc_auc', # 'train_p/main/precision', 'train_r/main/recall', 'train_f/main/f1', 'validation/main/loss', 'val_acc/main/accuracy', 'val_roc/main/roc_auc', 'val_prc/main/prc_auc', # 'val_p/main/precision', 'val_r/main/recall', 'val_f/main/f1', 'lr', 'elapsed_time' ] trainer.extend(E.PrintReport(entries=entries)) # change from 10 to 2 on Mar. 1 2019 trainer.extend(E.snapshot(), trigger=(2, 'epoch')) trainer.extend(E.LogReport()) trainer.extend(E.ProgressBar()) trainer.extend( E.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png')) trainer.extend( E.PlotReport(['train_acc/main/accuracy', 'val_acc/main/accuracy'], 'epoch', file_name='accuracy.png')) if args.resume: resume_path = os.path.join(out, args.resume) logging.info( 'Resume training according to snapshot in {}'.format(resume_path)) chainer.serializers.load_npz(resume_path, trainer) trainer.run() # Save the regressor's parameters. model_path = os.path.join(out, args.model_filename) logging.info('Saving the trained model to {}...'.format(model_path)) classifier.save_pickle(model_path, protocol=args.protocol)
print(list_length) all_valid_instance_list = Get_name_list(mode='Valid') valid_list_length = len(all_valid_instance_list) print(valid_list_length) # initialize DRS networks drs = DRS(w) if (gpu_id == 0): drs.to_gpu(gpu_id) index = 0 loss_train_list = [] loss_valid_list = [] optimizer = optimizers.Adam(alpha=0.0001,beta1=0.9,beta2=0.999) optimizer.setup(drs) iterations = 30000 num_sample = 40 # (if =1, NaN appears) # Start trainig for i in range(iterations): train_list = [] for j in range(num_batch_instance): if (index == list_length): random.shuffle(all_instance_list) # shuffle index = 0 train_list.append(all_instance_list[index]) index += 1
n_iter = n_data // batchsize print(n_iter, 'iterations,', n_epoch, 'epochs') model = FastStyleNet() vgg = VGG() serializers.load_npz('vgg16.model', vgg) if args.initmodel: print('load model from', args.initmodel) serializers.load_npz(args.initmodel, model) if args.gpu >= 0: cuda.get_device(args.gpu).use() model.to_gpu() vgg.to_gpu() xp = np if args.gpu < 0 else cuda.cupy O = optimizers.Adam(alpha=args.lr) O.setup(model) if args.resume: print('load optimizer state from', args.resume) serializers.load_npz(args.resume, O) style = vgg.preprocess(np.asarray(Image.open(args.style_image).convert('RGB').resize((image_size,image_size)), dtype=np.float32)) style = xp.asarray(style, dtype=xp.float32) style_b = xp.zeros((batchsize,) + style.shape, dtype=xp.float32) for i in range(batchsize): style_b[i] = style feature_s = vgg(Variable(style_b)) gram_s = [gram_matrix(y) for y in feature_s] for epoch in range(n_epoch): print('epoch', epoch)
def main(): parser = argparse.ArgumentParser(description='Chainer example: DQN') parser.add_argument('--env', type=str, default='CartPole-v0', help='Name of the OpenAI Gym environment') parser.add_argument('--batch-size', '-b', type=int, default=64, help='Number of transitions in each mini-batch') parser.add_argument('--episodes', '-e', type=int, default=1000, help='Number of episodes to run') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--out', '-o', default='dqn_result', help='Directory to output the result') parser.add_argument('--unit', '-u', type=int, default=100, help='Number of units') parser.add_argument('--target-type', type=str, default='dqn', help='Target type', choices=['dqn', 'double_dqn']) parser.add_argument('--reward-scale', type=float, default=1e-2, help='Reward scale factor') parser.add_argument('--replay-start-size', type=int, default=500, help=('Number of iterations after which replay is ' 'started')) parser.add_argument('--iterations-to-decay-epsilon', type=int, default=5000, help='Number of steps used to linearly decay epsilon') parser.add_argument('--min-epsilon', type=float, default=0.01, help='Minimum value of epsilon') parser.add_argument('--target-update-freq', type=int, default=100, help='Frequency of target network update') parser.add_argument('--record', action='store_true', default=True, help='Record performance') parser.add_argument('--no-record', action='store_false', dest='record') args = parser.parse_args() # Initialize an environment env = gym.make(args.env) assert isinstance(env.observation_space, gym.spaces.Box) assert isinstance(env.action_space, gym.spaces.Discrete) obs_size = env.observation_space.low.size n_actions = env.action_space.n if args.record: env = gym.wrappers.Monitor(env, args.out, force=True) reward_threshold = env.spec.reward_threshold if reward_threshold is not None: print('{} defines "solving" as getting average reward of {} over 100 ' 'consecutive trials.'.format(args.env, reward_threshold)) else: print('{} is an unsolved environment, which means it does not have a ' 'specified reward threshold at which it\'s considered ' 'solved.'.format(args.env)) # Initialize variables D = collections.deque(maxlen=10**6) # Replay buffer Rs = collections.deque(maxlen=100) # History of returns iteration = 0 # Initialize a model and its optimizer Q = QFunction(obs_size, n_actions, n_units=args.unit) if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() Q.to_gpu(args.gpu) target_Q = copy.deepcopy(Q) opt = optimizers.Adam(eps=1e-2) opt.setup(Q) for episode in range(args.episodes): obs = env.reset() done = False R = 0.0 # Return (sum of rewards obtained in an episode) timestep = 0 while not done and timestep < env.spec.timestep_limit: # Epsilon is linearly decayed epsilon = 1.0 if len(D) < args.replay_start_size else \ max(args.min_epsilon, np.interp( iteration, [0, args.iterations_to_decay_epsilon], [1.0, args.min_epsilon])) # Select an action epsilon-greedily if np.random.rand() < epsilon: action = env.action_space.sample() else: action = get_greedy_action(Q, obs) # Execute an action new_obs, reward, done, _ = env.step(action) R += reward # Store a transition D.append((obs, action, reward * args.reward_scale, done, new_obs)) obs = new_obs # Sample a random minibatch of transitions and replay if len(D) >= args.replay_start_size: sample_indices = random.sample(range(len(D)), args.batch_size) samples = [D[i] for i in sample_indices] update(Q, target_Q, opt, samples, target_type=args.target_type) # Update the target network if iteration % args.target_update_freq == 0: target_Q = copy.deepcopy(Q) iteration += 1 timestep += 1 Rs.append(R) average_R = np.mean(Rs) print('episode: {} iteration: {} R: {} average_R: {}'.format( episode, iteration, R, average_R)) if reward_threshold is not None and average_R >= reward_threshold: print('Solved {} by getting average reward of ' '{} >= {} over 100 consecutive episodes.'.format( args.env, average_R, reward_threshold)) break
def set_optimizer(model, alpha, beta): optimizer = optimizers.Adam(alpha = alpha, beta1 = beta) optimizer.setup(model) return optimizer
def train_dcgan_labeled(gen, dis, epoch0=0): o_gen = optimizers.Adam(alpha=0.0002, beta1=0.5) o_dis = optimizers.Adam(alpha=0.0002, beta1=0.5) o_gen.setup(gen) o_dis.setup(dis) o_gen.add_hook(chainer.optimizer.WeightDecay(0.00001)) o_dis.add_hook(chainer.optimizer.WeightDecay(0.00001)) zvis = (xp.random.uniform(-1, 1, (100, nz), dtype=np.float32)) for epoch in xrange(epoch0, n_epoch): perm = np.random.permutation(n_train) sum_l_dis = np.float32(0) sum_l_gen = np.float32(0) for i in xrange(0, n_train, batchsize): # discriminator # 0: from s_dataset # 1: from s_dataset encode decode # 2: from s_dataset encode decode #print "load image start ", i sx = np.zeros((batchsize, 3, 96, 96), dtype=np.float32) tx = np.zeros((batchsize, 3, 96, 96), dtype=np.float32) for j in range(batchsize): try: s_rnd = np.random.randint(len(s_dataset)) t_rnd = np.random.randint(len(t_dataset)) s_rnd2 = np.random.randint(2) t_rnd2 = np.random.randint(2) s_img = np.asarray( Image.open(StringIO( s_dataset[s_rnd])).convert('RGB')).astype( np.float32).transpose(2, 0, 1) t_img = np.asarray( Image.open(StringIO( s_dataset[t_rnd])).convert('RGB')).astype( np.float32).transpose(2, 0, 1) if s_rnd2 == 0: sx[j, :, :, :] = (s_img[:, :, ::-1] - 128.0) / 128.0 else: sx[j, :, :, :] = (s_img[:, :, :] - 128.0) / 128.0 if t_rnd2 == 0: tx[j, :, :, :] = (t_img[:, :, ::-1] - 128.0) / 128.0 else: tx[j, :, :, :] = (t_img[:, :, :] - 128.0) / 128.0 except: print 'read image error occured', fs[t_rnd] #print "load image done" # train generator sx = Variable(cuda.to_gpu(sx)) tx = Variable(cuda.to_gpu(tx)) sx2, sz = gen(sx) tx2, tz = gen(tx) sx3, sz2 = gen(sx2) L_tid = F.mean_squared_error(tx, tx2) L_const = F.mean_squared_error(sz, sz2) L_tv = (((sx2[:, 1:] - sx2)**2 + (sx2[:, :, 1:] - sx2)**2) + ((tx2[:, 1:] - tx2)**2 + (tx2[:, :, 1:] - tx2)**2)**0.5) / float(batchsize) # train discriminator yl_sx2 = dis(sx2) yl_tx2 = dis(tx2) yl_tx = dis(tx) L_dis = F.softmax_cross_entropy( yl_sx2, Variable(xp.zeros(batchsize, dtype=np.int32))) L_dis += F.softmax_cross_entropy( yl_tx2, Variable(xp.ones(batchsize, dtype=np.int32))) L_dis += F.softmax_cross_entropy( yl_tx, Variable(xp.ones(batchsize, dtype=np.int32) * 2)) L_gang = ( F.softmax_cross_entropy( sx2, Variable(xp.ones(batchsize, dtype=np.int32) * 2)) + F.softmax_cross_entropy( tx2, Variable(xp.ones(batchsize, dtype=np.int32) * 2))) L_gen = L_gang + alpha * L_const + beta * L_tid + gamma * L_tv #print "forward done" o_gen.zero_grads() L_gen.backward() o_gen.update() o_dis.zero_grads() L_dis.backward() o_dis.update() sum_l_gen += L_gen.data.get() sum_l_dis += L_dis.data.get() #print "backward done" if i % image_save_interval == 0: pylab.rcParams['figure.figsize'] = (16.0, 16.0) pylab.clf() vissize = 100 z = zvis z[50:, :] = (xp.random.uniform(-1, 1, (50, nz), dtype=np.float32)) z = Variable(z) x = gen(z, test=True) x = x.data.get() for i_ in range(100): tmp = ((np.vectorize(clip_img)(x[i_, :, :, :]) + 1) / 2).transpose(1, 2, 0) pylab.subplot(10, 10, i_ + 1) pylab.imshow(tmp) pylab.axis('off') pylab.savefig('%s/vis_%d_%d.png' % (out_image_dir, epoch, i)) serializers.save_hdf5( "%s/dcgan_model_dis_%d.h5" % (out_model_dir, epoch), dis) serializers.save_hdf5( "%s/dcgan_model_gen_%d.h5" % (out_model_dir, epoch), gen) serializers.save_hdf5( "%s/dcgan_state_dis_%d.h5" % (out_model_dir, epoch), o_dis) serializers.save_hdf5( "%s/dcgan_state_gen_%d.h5" % (out_model_dir, epoch), o_gen) print 'epoch end', epoch, sum_l_gen / n_train, sum_l_dis / n_train
def main(): ########################### #### create dictionary #### ########################### if os.path.exists('./data/corpus/dictionary.dict'): corpus = JaConvCorpus(file_path=None, batch_size=batchsize, size_filter=True) corpus.load(load_dir='./data/corpus/') else: corpus = JaConvCorpus(file_path=data_file, batch_size=batchsize, size_filter=True) corpus.save(save_dir='./data/corpus/') print('Vocabulary Size (number of words) :', len(corpus.dic.token2id)) ################################## #### create model (copy data) #### ################################## rough_model = './data/199_rough.model' model = Seq2Seq(len(corpus.dic.token2id), feature_num=feature_num, hidden_num=hidden_num, batch_size=batchsize, gpu_flg=args.gpu) serializers.load_hdf5(rough_model, model) if args.gpu >= 0: model.to_gpu() ########################## #### create ID corpus #### ########################## input_mat = [] output_mat = [] max_input_ren = max_output_ren = 0 for input_text, output_text in zip(corpus.fine_posts, corpus.fine_cmnts): # convert to list input_text.reverse() # encode words in a reverse order input_text.insert(0, corpus.dic.token2id["<eos>"]) output_text.append(corpus.dic.token2id["<eos>"]) # update max sentence length max_input_ren = max(max_input_ren, len(input_text)) max_output_ren = max(max_output_ren, len(output_text)) input_mat.append(input_text) output_mat.append(output_text) # padding for li in input_mat: insert_num = max_input_ren - len(li) for _ in range(insert_num): li.insert(0, corpus.dic.token2id['<pad>']) for li in output_mat: insert_num = max_output_ren - len(li) for _ in range(insert_num): li.append(corpus.dic.token2id['<pad>']) # create batch matrix input_mat = np.array(input_mat, dtype=np.int32).T output_mat = np.array(output_mat, dtype=np.int32).T # separate corpus into Train and Test train_input_mat = input_mat train_output_mat = output_mat ############################# #### train seq2seq model #### ############################# accum_loss = 0 train_loss_data = [] for num, epoch in enumerate(range(n_epoch)): total_loss = 0 batch_num = 0 perm = np.random.permutation(len(corpus.fine_posts) - testsize) # initialize optimizer optimizer = optimizers.Adam(alpha=0.001) optimizer.setup(model) # optimizer.add_hook(chainer.optimizer.GradientClipping(5)) optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001)) # for training for i in range(0, len(corpus.fine_posts) - testsize, batchsize): # select batch data input_batch = train_input_mat[:, perm[i:i + batchsize]] output_batch = train_output_mat[:, perm[i:i + batchsize]] # Encode a sentence model.initialize() # initialize cell model.encode(input_batch, train=True) # encode (output: hidden Variable) # Decode from encoded context end_batch = xp.array( [corpus.dic.token2id["<start>"] for _ in range(batchsize)]) first_words = output_batch[0] loss, predict_mat = model.decode(end_batch, first_words, train=True) next_ids = first_words accum_loss += loss for w_ids in output_batch[1:]: loss, predict_mat = model.decode(next_ids, w_ids, train=True) next_ids = w_ids accum_loss += loss # learn model model.cleargrads() # initialize all grad to zero accum_loss.backward() # back propagation optimizer.update() total_loss += float(accum_loss.data) print('Epoch: ', num, 'Batch_num', batch_num, 'batch loss: {:.2f}'.format(float(accum_loss.data))) accum_loss = 0 # save model and optimizer if (epoch + 1) % 5 == 0: print('-----', epoch + 1, ' times -----') print('save the model and optimizer') serializers.save_hdf5('data/' + str(epoch) + '_fine.model', model) serializers.save_hdf5('data/' + str(epoch) + '_fine.state', optimizer) # save loss data with open('./data/fine_loss_train_data.pkl', 'wb') as f: pickle.dump(train_loss_data, f)
n_vocab = bow.shape[1] # Number of dimensions in a single word vector n_units = 256 # number of topics n_topics = 20 batchsize = 128 counts = corpus.keys_counts[:n_vocab] # Get the string representation for every compact key words = corpus.word_list(vocab)[:n_vocab] model = LDA(n_docs, n_topics, n_units, n_vocab) if os.path.exists('lda.hdf5'): print("Reloading from saved") serializers.load_hdf5("lda.hdf5", model) model.to_gpu() optimizer = O.Adam() optimizer.setup(model) j = 0 fraction = batchsize * 1.0 / bow.shape[0] for epoch in range(50000000): if epoch % 100 == 0: p = cuda.to_cpu(model.proportions.W.data).copy() f = cuda.to_cpu(model.factors.W.data).copy() w = cuda.to_cpu(model.embedding.W.data).copy() d = prepare_topics(p, f, w, words) print_top_words_per_topic(d) for (ids, batch) in utils.chunks(batchsize, np.arange(bow.shape[0]), bow): t0 = time.time() model.cleargrads() rec, ld = model.forward(ids, batch)
def train_dcgan_labeled(gen, dis, epoch0=0): o_gen = optimizers.Adam(alpha=0.0002, beta1=0.5) o_dis = optimizers.Adam(alpha=0.0002, beta1=0.5) o_gen.setup(gen) o_dis.setup(dis) o_gen.add_hook(chainer.optimizer.WeightDecay(0.00001)) o_dis.add_hook(chainer.optimizer.WeightDecay(0.00001)) zvis = (xp.random.uniform(-1, 1, (100, nz), dtype=np.float32)) for epoch in range(epoch0, n_epoch): perm = np.random.permutation(n_train) sum_l_dis = np.float32(0) sum_l_gen = np.float32(0) for i in range(0, n_train, batchsize): # discriminator # 0: from dataset # 1: from noise #print "load image start ", i x2 = np.zeros((batchsize, 3, 96, 96), dtype=np.float32) for j in range(batchsize): try: rnd = np.random.randint(len(dataset)) rnd2 = np.random.randint(2) img = np.asarray( Image.open(StringIO( dataset[rnd])).convert('RGB')).astype( np.float32).transpose(2, 0, 1) if rnd2 == 0: x2[j, :, :, :] = (img[:, :, ::-1] - 128.0) / 128.0 else: x2[j, :, :, :] = (img[:, :, :] - 128.0) / 128.0 except: print('read image error occured', fs[rnd]) #print "load image done" # train generator z = Variable( xp.random.uniform(-1, 1, (batchsize, nz), dtype=np.float32)) x = gen(z) yl = dis(x) L_gen = F.softmax_cross_entropy( yl, Variable(xp.zeros(batchsize, dtype=np.int32))) L_dis = F.softmax_cross_entropy( yl, Variable(xp.ones(batchsize, dtype=np.int32))) # train discriminator x2 = Variable(cuda.to_gpu(x2)) yl2 = dis(x2) L_dis += F.softmax_cross_entropy( yl2, Variable(xp.zeros(batchsize, dtype=np.int32))) #print "forward done" o_gen.zero_grads() L_gen.backward() o_gen.update() o_dis.zero_grads() L_dis.backward() o_dis.update() sum_l_gen += L_gen.data.get() sum_l_dis += L_dis.data.get() #print "backward done" if i % image_save_interval == 0: pylab.rcParams['figure.figsize'] = (16.0, 16.0) pylab.clf() vissize = 100 z = zvis z[50:, :] = (xp.random.uniform(-1, 1, (50, nz), dtype=np.float32)) z = Variable(z) x = gen(z, test=True) x = x.data.get() for i_ in range(100): tmp = ((np.vectorize(clip_img)(x[i_, :, :, :]) + 1) / 2).transpose(1, 2, 0) pylab.subplot(10, 10, i_ + 1) pylab.imshow(tmp) pylab.axis('off') pylab.savefig('%s/vis_%d_%d.png' % (out_image_dir, epoch, i)) serializers.save_hdf5( "%s/dcgan_model_dis_%d.h5" % (out_model_dir, epoch), dis) serializers.save_hdf5( "%s/dcgan_model_gen_%d.h5" % (out_model_dir, epoch), gen) serializers.save_hdf5( "%s/dcgan_state_dis_%d.h5" % (out_model_dir, epoch), o_dis) serializers.save_hdf5( "%s/dcgan_state_gen_%d.h5" % (out_model_dir, epoch), o_gen) print('epoch end', epoch, sum_l_gen / n_train, sum_l_dis / n_train)
def __init__(self, NN, lr, w_decay): self.model = NN self.optimizer = optimizers.Adam(alpha=lr) self.optimizer.setup(self.model) self.optimizer.add_hook(chainer.optimizer.WeightDecay(rate=w_decay))
h1 = F.dropout(F.relu(self.l1(x)), ratio=self.dr) h2 = F.dropout(F.relu(self.l2(h1)), ratio=self.dr) return self.l3(h2) model = Network() gpu_id = -1 # cpuを使うときは-1に設定 if gpu_id >= 0: model.to_cpu(gpu_id) from chainer import optimizers # 最適化手段の選択 optimizer = optimizers.Adam(alpha=0.001, beta1=0.9, beta2=0.999, \ eps=1e-08, eta=1.0, weight_decay_rate=0, amsgrad=False) optimizer.setup(model) from chainer.dataset import concat_examples from chainer.backends.cuda import to_cpu max_epoch = 10 train_losses = [] train_accuracies = [] test_losses = [] test_accuracies = [] train_loss_list = [] train_acc_list = [] test_loss_list = []
def train(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--dir', type=str, default='./train_images/') parser.add_argument('--gen', type=str, default=None) parser.add_argument('--dis', type=str, default=None) parser.add_argument('--optg', type=str, default=None) parser.add_argument('--optd', type=str, default=None) parser.add_argument('--epoch', '-e', type=int, default=3) parser.add_argument('--lr', '-l', type=float, default=0.001) parser.add_argument('--beta1', type=float, default=0) parser.add_argument('--beta2', type=float, default=0.99) parser.add_argument('--batch', '-b', type=int, default=16) parser.add_argument('--depth', '-d', type=int, default=0) parser.add_argument('--alpha', type=float, default=0) parser.add_argument('--delta', type=float, default=0.00005) parser.add_argument('--out', '-o', type=str, default='img/') parser.add_argument('--num', '-n', type=int, default=10) parser.add_argument('--communicator', type=str, default='hierarchical', help='Type of communicator') args = parser.parse_args() train = dataset.ImageDataset(directory=args.dir, depth=args.depth) train_iter = iterators.MultiprocessIterator(train, batch_size=args.batch, repeat=True, shuffle=True, n_processes=14) if args.gpu >= 0: comm = chainermn.create_communicator(args.communicator) device = comm.intra_rank cuda.get_device_from_id(device).use() gen.to_gpu() dis.to_gpu() else: comm = chainermn.create_communicator('naive') device = -1 gen = network.Generator(depth=args.depth) if args.gen is not None: print('loading generator model from ' + args.gen) serializers.load_npz(args.gen, gen) dis = network.Discriminator(depth=args.depth) if args.dis is not None: print('loading discriminator model from ' + args.dis) serializers.load_npz(args.dis, dis) if args.gpu >= 0: device = comm.intra_rank cuda.get_device_from_id(device).use() gen.to_gpu() dis.to_gpu() opt_g = optimizers.Adam(alpha=args.lr, beta1=args.beta1, beta2=args.beta2) opt_g = chainermn.create_multi_node_optimizer(opt_g, comm, double_buffering=False) opt_g.setup(gen) if args.optg is not None: print('loading generator optimizer from ' + args.optg) serializers.load_npz(args.optg, opt_g) opt_d = optimizers.Adam(alpha=args.lr, beta1=args.beta1, beta2=args.beta2) opt_d = chainermn.create_multi_node_optimizer(opt_d, comm, double_buffering=False) opt_d.setup(dis) if args.optd is not None: print('loading discriminator optimizer from ' + args.optd) serializers.load_npz(args.optd, opt_d) updater = WganGpUpdater(alpha=args.alpha, delta=args.delta, models=(gen, dis), iterator={'main': train_iter}, optimizer={'gen': opt_g, 'dis': opt_d}, device=device) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out='results') if comm.rank == 0: out_dir = args.out+'depth'+str(args.depth) if os.path.isdir(out_dir): shutil.rmtree(out_dir) os.makedirs(out_dir) for i in range(args.num): img = train.get_example(i) filename = os.path.join(out_dir, 'real_{}.png'.format(i)) utils.save_image(img, filename) def output_image(gen, depth, out, num): @chainer.training.make_extension() def make_image(trainer): z = gen.z(num) x = gen(z, alpha=trainer.updater.alpha) x = chainer.cuda.to_cpu(x.data) for i in range(args.num): img = x[i].copy() filename = os.path.join(out, '{}_{}.png'.format(trainer.updater.epoch, i)) utils.save_image(img, filename) return make_image if comm.rank == 0: trainer.extend(extensions.LogReport(trigger=(1, 'epoch'))) trainer.extend(extensions.PrintReport(['epoch', 'gen_loss', 'loss_d', 'loss_l', 'loss_dr', 'dis_loss', 'alpha'])) trainer.extend(extensions.snapshot_object(gen, 'gen'), trigger=(10, 'epoch')) trainer.extend(extensions.snapshot_object(dis, 'dis'), trigger=(10, 'epoch')) trainer.extend(extensions.snapshot_object(opt_g, 'opt_g'), trigger=(10, 'epoch')) trainer.extend(extensions.snapshot_object(opt_d, 'opt_d'), trigger=(10, 'epoch')) trainer.extend(output_image(gen, args.depth, out_dir, args.num), trigger=(1, 'epoch')) trainer.extend(extensions.ProgressBar(update_interval=1)) trainer.run() if comm.rank == 0: modelname = './results/gen'+str(args.depth) print( 'saving generator model to ' + modelname ) serializers.save_npz(modelname, gen) modelname = './results/dis'+str(args.depth) print( 'saving discriminator model to ' + modelname ) serializers.save_npz(modelname, dis) optname = './results/opt_g' print( 'saving generator optimizer to ' + optname ) serializers.save_npz(optname, opt_g) optname = './results/opt_d' print( 'saving generator optimizer to ' + optname ) serializers.save_npz(optname, opt_d)
def main(): #引数の格納 args = set_args() #modelの設定 model = Network2.MyNet() #GPUの設定 if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # optimizerのセットアップ #optimizer = chainer.optimizers.MomentumSGD(lr=args.learnrate).setup(model) optimizer = optimizers.Adam(alpha=1e-4, beta1=0.9, beta2=0.999, eps=1e-08) optimizer.setup(model) #optimizer.add_hook(chainer.optimizer.WeightDecay(0.0005)) layer_names = [ 'conv1_1', 'conv1_2', 'conv2_1', 'conv2_2', 'conv3_1', 'conv3_2', 'conv3_3', 'conv3_4', 'conv4_1', 'conv4_2', 'conv4_3_CPM', 'conv4_4_CPM' ] optimizer.add_hook(GradientScaling(layer_names, 1 / 4)) layer_names = [ 'conv1_1', 'conv1_2', 'conv2_1', 'conv2_2', 'conv3_1', 'conv3_2', 'conv3_3', 'conv3_4', 'conv4_1', 'conv4_2' ] for layer_name in layer_names: optimizer.target[layer_name].enable_update() #datasetの読み込み #CocoDataLoaderは既存ファイルの使用 coco_train = COCO( os.path.join(constants['data_add'], 'annotations/person_keypoints_train2017.json')) coco_val = COCO( os.path.join(constants['data_add'], 'annotations/person_keypoints_val2017.json')) train = CocoDataLoader(coco_train, model.insize, mode='train') val = CocoDataLoader(coco_val, model.insize, mode='val', n_samples=100) #iteratorのセットアップ train_iter = chainer.iterators.SerialIterator(train, args.batchsize, shuffle=True) val_iter = chainer.iterators.SerialIterator(val, args.batchsize, repeat=False, shuffle=False) # UpdatorとTrainerのセットアップ updater = Net_Updater(train_iter, model, optimizer, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.out) #trainerのExtend trainer.extend(extensions.Evaluator(val_iter, model, device=args.gpu)) 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()) 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')) #学習開始 trainer.run() #学習結果の保存 model.to_cpu() serializers.save_npz('trained_model', model)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', '-g', type=int, default=-1) parser.add_argument('--model', '-m', type=str, default=None) parser.add_argument('--opt', type=str, default=None) parser.add_argument('--epoch', '-e', type=int, default=20) parser.add_argument('--lr', '-l', type=float, default=0.001) parser.add_argument('--batch', '-b', type=int, default=32) parser.add_argument('--noplot', dest='plot', action='store_false') args = parser.parse_args() # Set up a neural network to train. train_x, test_x = get_cifar10(withlabel=False, ndim=3) train = LoadDataset(train_x) test = LoadDataset(test_x) train_iter = iterators.SerialIterator(train, batch_size=args.batch, shuffle=True) test_iter = iterators.SerialIterator(test, batch_size=args.batch, repeat=False, shuffle=False) # Define model model = network.CAE(3, 3) # Load weight if args.model != None: print("loading model from " + args.model) serializers.load_npz(args.model, model) if args.gpu >= 0: cuda.get_device_from_id(0).use() model.to_gpu() # Define optimizer opt = optimizers.Adam(alpha=args.lr) opt.setup(model) if args.opt != None: print("loading opt from " + args.opt) serializers.load_npz(args.opt, opt) # Set up a trainer updater = training.StandardUpdater(train_iter, opt, device=args.gpu) trainer = training.Trainer(updater, (args.epoch, 'epoch'), out='results') trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu)) trainer.extend(extensions.LogReport(trigger=(10, 'iteration'))) if args.plot and extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], 'epoch', file_name='loss.png')) trainer.extend( extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss'])) trainer.extend(extensions.ProgressBar(update_interval=1)) # Train trainer.run() # Save results modelname = "./results/model" print("saving model to " + modelname) serializers.save_npz(modelname, model) optname = "./results/opt" print("saving opt to " + optname) serializers.save_npz(optname, opt)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--out', type=str, default='result', help='Output directory') parser.add_argument('--mscoco-root', type=str, default='data', help='MSOCO dataset root directory') parser.add_argument('--max-iters', type=int, default=50000, help='Maximum number of iterations to train') parser.add_argument('--batch-size', type=int, default=128, help='Minibatch size') parser.add_argument('--dropout-ratio', type=float, default=0.5, help='Language model dropout ratio') parser.add_argument('--val-keep-quantity', type=int, default=100, help='Keep every N-th validation image') parser.add_argument('--val-iter', type=int, default=100, help='Run validation every N-th iteration') parser.add_argument('--log-iter', type=int, default=1, help='Log every N-th iteration') parser.add_argument('--snapshot-iter', type=int, default=1000, help='Model snapshot every N-th iteration') parser.add_argument('--rnn', type=str, default='nsteplstm', choices=['nsteplstm', 'lstm'], help='Language model layer type') parser.add_argument('--gpu', type=int, default=0, help='GPU ID (negative value indicates CPU)') parser.add_argument('--max-caption-length', type=int, default=30, help='Maxium caption length when using LSTM layer') args = parser.parse_args() # Load the MSCOCO dataset. Assumes that the dataset has been downloaded # already using e.g. the `download.py` script train, val = datasets.get_mscoco(args.mscoco_root) # Validation samples are used to address overfitting and see how well your # model generalizes to yet unseen data. However, since the number of these # samples in MSCOCO is quite large (~200k) and thus require time to # evaluate, you may choose to use only a fraction of the available samples val = val[::args.val_keep_quantity] # Number of unique words that are found in the dataset vocab_size = len(train.vocab) # Instantiate the model to be trained either with LSTM layers or with # NStepLSTM layers model = ImageCaptionModel(vocab_size, dropout_ratio=args.dropout_ratio, rnn=args.rnn) if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() model.to_gpu() def transform(in_data): # Called for each sample and applies necessary preprocessing to the # image such as resizing and normalizing img, caption = in_data img = model.prepare(img) return img, caption # We need to preprocess the images since their sizes may vary (and the # model requires that they have the exact same fixed size) train = TransformDataset(train, transform) val = TransformDataset(val, transform) train_iter = iterators.MultiprocessIterator(train, args.batch_size, shared_mem=700000) val_iter = chainer.iterators.MultiprocessIterator(val, args.batch_size, repeat=False, shuffle=False, shared_mem=700000) optimizer = optimizers.Adam() optimizer.setup(model) def converter(batch, device): # The converted receives a batch of input samples any may modify it if # necessary. In our case, we need to align the captions depending on if # we are using LSTM layers of NStepLSTM layers in the model. if args.rnn == 'lstm': max_caption_length = args.max_caption_length elif args.rnn == 'nsteplstm': max_caption_length = None else: raise ValueError('Invalid RNN type.') return datasets.converter(batch, device, max_caption_length=max_caption_length) updater = training.updater.StandardUpdater(train_iter, optimizer=optimizer, device=args.gpu, converter=converter) trainer = training.Trainer(updater, out=args.out, stop_trigger=(args.max_iters, 'iteration')) trainer.extend(extensions.Evaluator(val_iter, target=model, converter=converter, device=args.gpu), trigger=(args.val_iter, 'iteration')) trainer.extend( extensions.LogReport(['main/loss', 'validation/main/loss'], trigger=(args.log_iter, 'iteration'))) trainer.extend( extensions.PlotReport(['main/loss', 'validation/main/loss'], trigger=(args.log_iter, 'iteration'))) trainer.extend(extensions.PrintReport([ 'elapsed_time', 'epoch', 'iteration', 'main/loss', 'validation/main/loss' ]), trigger=(args.log_iter, 'iteration')) # Save model snapshots so that later on, we can load them and generate new # captions for any image. This can be done in the `predict.py` script trainer.extend(extensions.snapshot_object(model, 'model_{.updater.iteration}'), trigger=(args.snapshot_iter, 'iteration')) trainer.extend(extensions.ProgressBar()) trainer.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument('--epoch', '-e', type=int, default=10, help='Number of examples in epoch') parser.add_argument('--batchsize', '-b', type=int, default=1, help='Number of examples in each mini-batch') 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('--model', '-m', default='', help='Load model') parser.add_argument('--path0', '-p0', default='./DATA/*/*.png', help='path for images used subject') parser.add_argument('--path1', '-p1', default='./DATA/*/*.JPEG', help='path for images used back') parser.add_argument('--test', '-t', action='store_true', help='evaluation only') parser.add_argument('--image', action='store_true', help='put image for test') args = parser.parse_args() train_dataset = DataSet(420, args.path0, args.path1) test_dataset = DataSet(50, args.path0, args.path1) model = Loss_Link(VGG()) if args.gpu >= 0: cuda.get_device_from_id(args.gpu).use() model.to_gpu() optimizer = optimizers.Adam() optimizer.setup(model) model.predictor.base.disable_update() if args.model: serializers.load_npz(args.model, model) train_iter = iterators.SerialIterator( train_dataset, batch_size=args.batchsize, shuffle=True) test_iter = iterators.SerialIterator( test_dataset, batch_size=args.batchsize, repeat=False) if args.test: eva = training.extensions.Evaluator( test_iter, model, device=args.gpu)() for key in eva: print(key + ":" + str(eva[key])) elif args.image: if not os.path.exists(args.out): os.mkdir(args.out) IMG_PATHS = [args.path0, args.path1] data = [] base_n = len(glob.glob(IMG_PATHS[1])) img_n = len(glob.glob(IMG_PATHS[0])) for i, IMG_PATH in enumerate(IMG_PATHS): data.append([]) for path in glob.glob(IMG_PATH): img_ = cv2.imread(path) if i == 0: img = cv2.resize(img_, (256, 256)) else: img = cv2.resize(img_, (512, 512)) data[i].append(img) offset_x = random.randint(0, 255) offset_y = random.randint(0, 255) base = copy.deepcopy(data[1][random.randint(0, base_n - 1)]) base[offset_x:offset_x + 256, offset_y:offset_y + 256, :] = copy.deepcopy(data[0][random.randint(0, img_n - 1)]) cv2.imwrite(args.out + "/input_image.png", cv2.resize(base, (224, 224))) mask = np.zeros((512, 512)) mask[offset_x:offset_x + 256, offset_y:offset_y + 256] =\ np.ones((256, 256)) cv2.imwrite(args.out + "/ideal_image.png", cv2.resize(np.array(mask * 255). astype("uint8"), (224, 224))) pred = model.predictor(xp.array([cv2.resize(base, (224, 224)). transpose(2, 0, 1) / 255]). astype('float32')).array[0] > 0.7 cv2.imwrite(args.out + "/output_image.png", np.array(pred * 255).reshape(224, 224).astype("uint8")) else: updater = training.StandardUpdater(train_iter, optimizer) trainer = training.Trainer( updater, (args.epoch, 'epoch'), out=args.out) trainer.extend(training.extensions.Evaluator( test_iter, model, device=args.gpu), trigger=(1, 'epoch')) trainer.extend(training.extensions.LogReport( trigger=(1, 'epoch'))) trainer.extend(training.extensions.PrintReport( entries=['iteration', 'main/loss', 'main/accuracy', 'elapsed_time']), trigger=(1, 'epoch')) trainer.extend(training.extensions.snapshot(), trigger=((1, 'epoch'))) if args.resume: serializers.load_npz(args.resume, trainer, strict=False) trainer.run() serializers.save_npz('model.npz', model)