def main(argv=None): data_file = FLAGS.data_dir + FLAGS.dataset_name + '.npz' data = np.load(data_file) read_index = FLAGS.read_index train_data, train_labels, test_data, test_labels = data['train_X'], data[ 'train_Y'], data['test_X'], data['test_Y'] train_X, train_Y, test_X, test_Y = train_data[read_index], train_labels[ read_index], test_data[read_index], test_labels[read_index] if FLAGS.dataset_name != 'mnist': train_X, test_X = train_X / 255, test_X / 255 val_X, val_Y = data['val_X'] / 255, data['val_Y'] else: mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True) val_X, val_Y = mnist.validation.images, mnist.validation.labels Train_size = len(train_X) total_batch = Train_size / FLAGS.batch_size model.build(total_batch) with tf.Session() as sess: tf.global_variables_initializer().run() print('== Get feature weight by using AFS ==') A = run_train(sess, train_X, train_Y, val_X, val_Y) print('== The Evaluation of AFS ==') ac_score_list = run_test(A, train_X, train_Y, test_X, test_Y, total_batch) show_result(ac_score_list, FLAGS.dataset_name)
def test_in_dir(test, dir, fd_result, fd_check): output_m = test_minishell(test) file_output_m, files_m = get_created_files(test) output_b = test_bash(test) file_output_b, files_b = get_created_files(test) ret1 = check_text_differences(test, output_m, output_b) ret2 = check_text_differences(None, file_output_m, file_output_b) ret3 = check_created_files(files_m, files_b) show_result(dir, fd_result, fd_check, ret1, ret2, ret3, test, output_m, output_b, files_b, files_m, file_output_m, file_output_b)
def main(): train_url = "e:/data/comment_sentiment/train_set.csv" test_url = "e:/data/comment_sentiment/test_set.csv" train_x, train_y = utils.load_data(train_url) test_x, test_y = utils.load_data(test_url) bayes = Bayes() bayes.train_model(train_x, train_y) pre_y = bayes.predict(test_x) utils.show_result(test_y, np.array([pre_y]).T, "bayes_comment")
def main(): train_url = "train_set.csv" test_url = "test_set.csv" x, y = utils.load_data(train_url) test_x, test_y = utils.load_data(test_url) gda = GDA() gda.train_model(x, y) pre_y = gda.predict(test_x) utils.show_result(test_y, pre_y, "gda_comment")
def main(): train_url = "e:/data/comment_sentiment/train_set.csv" test_url = "e:/data/comment_sentiment/test_set.csv" x, y = utils.load_data(train_url) test_x, test_y = utils.load_data(test_url) lr = LogisticRegression() lr.train_model(x, y) pre_y = lr.predict(test_x) utils.show_result(test_y, pre_y, "logistic_comment")
def main(params): np.random.seed(7) if params['data'] == 'linear': inputs, labels = utils.generate_linear(n=100) elif params['data'] == 'xor': inputs, labels = utils.generate_xor_easy() else: raise KeyError("Please select a correct input data") model = MyModel(in_features=2, out_features=1, hid_dim=[8, 16], activation=params['no_activation']) # Start training e = 0 loss_recorder = [] while (1): e += 1 outputs = model.forward(inputs) if params['loss_fn'] == 'ce': model.backward(inputs, outputs, labels, nesterov=params['nesterov'], loss='ce') loss = model.ce(outputs, labels) elif params['loss_fn'] == 'mse': model.backward(inputs, outputs, labels, nesterov=params['nesterov'], loss='mse') loss = model.mse(outputs, labels) else: raise ValueError(f"No such loss function: {params['loss_fn']}") model.update(lr=params['lr'], gamma=params['momentum']) loss_recorder.append(loss) if e % params['show_period'] == 0: preds = model.pred(outputs) print( f"[{e:^7d}]Accuracy now is " f"{model.cal_acc(preds, labels):.2%}" f", Loss now is {loss:.2f}", ) if loss < 0.01 or model.cal_acc(preds, labels) == 1: print("Model has almost fitted the data") print(f"Model prediction:\n {outputs}") utils.show_result(inputs, labels, preds) utils.show_loss_rec(loss_recorder, range(1, e + 1)) break
def train(model, optimizer, dataloader, loss_fn, metric_fn, param, current_epoch): model.train() summary = [] for i, data in enumerate(dataloader): img_batch = data['img'] depth_batch = data['depth'] # move to GPU if available img_batch, depth_batch = img_batch.cuda(), depth_batch.cuda() # compute model output output_batch = model(img_batch) # clear previous gradients, compute loss optimizer.zero_grad() loss = loss_fn(output_batch, depth_batch, param['mode'], img=img_batch) loss.backward() # performs updates using calculated gradients optimizer.step() if i % 10 == 0: print('Train: epoch %d iter %d loss: %.3f' % (current_epoch, i, loss)) writer.add_scalar('training loss', loss, current_epoch * len(dataloader) + i) output_batch, depth_batch = output_batch.cpu().detach().numpy(), depth_batch.cpu().detach().numpy() pred_batch = net.depth_inference(output_batch, param['mode']) metrics = metric_fn(pred_batch, depth_batch) # for metric, value in metrics.items(): # print('Training epoch %d iter %d metric %s: %.3f' % (epoch, i, metric, value)) # writer.add_scalar(metric, value, epoch * len(dataloader) + i) metrics['loss'] = loss.item() summary.append(metrics) if i % 100 == 0: if param['mode'] in ['sord_ent_weighted', 'sord_weighted_minent']: aux_map = net.local_entropy(depth_batch, kernel=16, mask=True) elif param['mode'] == 'sord_min_local_ent': aux_map = net.local_entropy(pred_batch, kernel=16) elif param['mode'] == 'sord_align_grad': aux_map = net.edge(pred_batch) else: aux_map = None error_map = net.depth_error_map(pred_batch, depth_batch) show_result_fig = utils.show_result(data, pred_batch, aux_map, error_map, param['batch_size'], shuffle=True) writer.add_figure('Train Input_RGB Input_Depth Output_Depth_map', show_result_fig, current_epoch * len(dataloader) + i) metrics_train = {metric: np.mean([x[metric] for x in summary]) for metric in summary[0]} print('\n------ After training %d epochs, train set metrics mean: ------ \n%s\n' % (current_epoch, metrics_train))
def evaluate(model, dataloader, loss_fn, metric_fn, param, current_epoch, writer): model.eval() summary = [] for i, data in enumerate(dataloader): img_batch = data['img'] depth_batch = data['depth'] # move to GPU if available img_batch_cropped = net.equally_spaced_crop(img_batch, param['eval_n_crop']) depth_batch_cropped = net.equally_spaced_crop(depth_batch, param['eval_n_crop']) img_batch_cropped, depth_batch_cropped = img_batch_cropped.cuda(), depth_batch_cropped.cuda() with torch.no_grad(): # compute model output output_batch_cropped = model(img_batch_cropped) # compute loss (No need to compute loss for evaluation, save time) # loss = loss_fn(output_batch_cropped, depth_batch_cropped, param['mode'], img=img_batch_cropped) output_batch_cropped, depth_batch = output_batch_cropped.cpu().numpy(), depth_batch.cpu().numpy() pred_batch_cropped = net.depth_inference(output_batch_cropped, param['mode']) pred_batch = net.pred_overlap(pred_batch_cropped, depth_batch.shape, param['eval_n_crop']) metrics = metric_fn(pred_batch, depth_batch) # metrics['loss'] = loss.item() summary.append(metrics) if i % 10 == 0: print('------') for metric, value in metrics.items(): print('Val: epoch %d iter %d metric %s: %.3f' % (current_epoch, i, metric, value)) if param['mode'] in ['sord_ent_weighted', 'sord_weighted_minent']: aux_map = net.local_entropy(depth_batch, kernel=16, mask=True) elif param['mode'] == 'sord_min_local_ent': aux_map = net.local_entropy(pred_batch, kernel=16) elif param['mode'] == 'sord_align_grad': aux_map = net.edge(pred_batch) else: aux_map = None error_map = net.depth_error_map(pred_batch, depth_batch) show_result_fig = utils.show_result(data, pred_batch, aux_map, error_map, param['batch_size'], shuffle=False) writer.add_figure('Val Input_RGB Input_Depth Output_Depth_map', show_result_fig, current_epoch * len(dataloader) + i) # for metric, value in metrics.items(): # writer.add_scalar(metric, value, i) metrics_mean = {metric: np.mean([x[metric] for x in summary]) for metric in summary[0]} return metrics_mean
accuracy_t = compute_acc(test_output, tes_label) if accuracy_t > accuracy_max: accuracy_max = accuracy_t preds = test_output.data.max(1)[1] print(classification_report(tes_label.cpu().detach().numpy(), preds.cpu().detach().numpy(), digits=6), file=file_name) torch.save(netG.state_dict(), './netG_max.pth') torch.save(netD.state_dict(), './netD_max.pth') print( '[%d/%d][%d/%d] Loss_D: %.4f Loss_G: %.4f D(x): %.4f D(G(z)): %.4f / %.4f Acc: %.4f AccT: %.4f MAX: %.4f' % (epoch + 1, opt.niter, i + 1, len(dataloader), errD, errG, D_x, D_G_z1, D_G_z2, accuracy, accuracy_t, accuracy_max), file=file_name) ########################### # results visualization & model preservation ########################### if (epoch + 1) % 50 == 0: show_result(real_cpu.cpu().detach().numpy(), (epoch + 1), path='%s/real_samples.png' % opt.outf) fake = netG(eval_noise) show_result(fake.cpu().detach().numpy(), (epoch + 1), path='%s/fake_samples_epoch_%03d.png' % (opt.outf, epoch + 1)) torch.save(netG.state_dict(), '%s/netG_epoch_%d.pth' % (opt.outf, epoch + 1)) torch.save(netD.state_dict(), '%s/netD_epoch_%d.pth' % (opt.outf, epoch + 1))
def train_adan(self): stop = False pre_epoch = 0 count = 0 self.build_adan() # Trainable variables T_vars = tf.trainable_variables() self.D_vars = [ var for var in T_vars if var.name.startswith('discriminator') ] self.C_vars = [ var for var in T_vars if var.name.startswith('classifier') ] self.G_vars = [ var for var in T_vars if var.name.startswith('generator') ] self.E_vars = [var for var in T_vars if var.name.startswith('encoder')] self.R_vars = [var for var in T_vars if var.name.startswith('decoder')] # Optimizer with tf.control_dependencies( tf.get_collection_ref(tf.GraphKeys.UPDATE_OPS)): D_optimizer = tf.train.AdamOptimizer(self.lr_D, beta1=0.5, epsilon=1e-5).minimize( self.D_loss, var_list=self.D_vars) C_optimizer = tf.train.AdamOptimizer(self.lr_C, beta1=0.5, epsilon=1e-5).minimize( self.C_loss, var_list=self.C_vars) G_optimizer = tf.train.AdamOptimizer(self.lr_G, beta1=0.5, epsilon=1e-5).minimize( self.G_loss, var_list=self.G_vars) E_optimizer = tf.train.AdamOptimizer(self.lr_E, beta1=0.5, epsilon=1e-5).minimize( self.E_loss, var_list=self.E_vars) R_optimizer = tf.train.AdamOptimizer(self.lr_R, beta1=0.5, epsilon=1e-5).minimize( self.R_loss, var_list=self.R_vars) tf.global_variables_initializer().run() train_op = tf.group(C_optimizer, R_optimizer, E_optimizer, G_optimizer) train_hist = { 'D_losses': [], 'C_losses': [], 'G_losses': [], 'R_losses': [] } acc_hist = {'f_acc': [], 'r_acc': [], 'f_std': [], 'r_std': []} with tqdm(total=self.epoch) as pbar: for e in range(self.epoch): if stop != True: pbar.update(1) index = np.arange(len(self.x_train)) np.random.shuffle(index) x_train = self.x_train[index] y_train_ohe = self.y_train_ohe[index] for iter in range(x_train.shape[0] // self.batch): x_ = x_train[iter * self.batch:(1 + iter) * self.batch] y_ = y_train_ohe[iter * self.batch:(1 + iter) * self.batch] z_ = np.random.normal(0, 1, (self.batch, self.zdim)) # Training the discriminator and then freezing its weights for d in range(self.d_times): self.sess.run(D_optimizer, { self.x: x_, self.y: y_, self.z: z_ }) loss_d = self.sess.run(self.D_loss, { self.x: x_, self.y: y_, self.z: z_ }) self.sess.run(train_op, { self.x: x_, self.y: y_, self.z: z_ }) loss_c, loss_r, loss_e, loss_g = self.sess.run( [ self.C_loss, self.R_loss, self.E_loss, self.G_loss ], { self.x: x_, self.y: y_, self.z: z_ }) train_hist['D_losses'].append(loss_d) train_hist['C_losses'].append(loss_c) train_hist['G_losses'].append(loss_g) train_hist['R_losses'].append(loss_r) z_trn = np.random.normal( 0, 1, (self.x_train.shape[0], self.zdim)) prob_f = self.sess.run(self.prob_fake, { self.z: z_trn, self.y: self.y_train_ohe }) prob_f_mean = np.mean(prob_f) prob_trn = self.sess.run(self.prob_real, { self.x: self.x_train, self.y: self.y_train_ohe }) prob_trn_mean = np.mean(prob_trn) acc_hist['f_acc'].append(prob_f_mean) acc_hist['r_acc'].append(prob_trn_mean) acc_hist['f_std'].append(np.std(prob_f)) acc_hist['r_std'].append(np.std(prob_trn)) prob_r = self.sess.run(self.prob_real, {self.x: self.x_train}) prob_mean = np.mean(prob_r) # Early stop if e > 200 and np.abs(prob_mean - 0.5) <= 0.01 and np.abs( prob_trn_mean - 0.5) <= 0.01 and np.abs(prob_f_mean - 0.5) <= 0.01: if np.abs(e - pre_epoch) <= 2 and count == 3: stop = True show_result(train_hist, e, self.num) show_result2(acc_hist, e, self.num) model_name = './model_adan/model' + str( e) + '.ckpt' self.saver.save(self.sess, model_name) elif np.abs(e - pre_epoch) <= 2: pre_epoch = e count = count + 1 else: pre_epoch = e if e == self.epoch - 1: show_result(train_hist, e, self.num) show_result2(acc_hist, e, self.num) model_name = './model_adan/model_loso' + str( self.num) + '_final.ckpt' self.saver.save(self.sess, model_name)
print("Starting Conv_MLP training") history, test_predictions, test_real, MSE = model.train_series( serie[0:n], serie_test[0:test_size], epochs=epochs, bsize=bsize, p_filepath=preds_filepath, l_filepath=l_filepath, w_filepath=w_filepath, h=h, callbacks=callbacks) """ Pure LSTM """ if model_choice == "LSTM": print("Initializing LSTM object") model = noHW_LSTM(inp_window=in_window, out_window=out_window) print("Starting LSTM training") history, test_predictions, test_real, MSE = model.fit_NN( serie[0:n], serie_test[0:test_size], epochs=epochs, bsize=bsize, p_filepath=preds_filepath, l_filepath=l_filepath, w_filepath=w_filepath, h=h, callbacks=callbacks) show_result(test_real, test_predictions, full=False)
def train_wadan(self): self.build_wadan() # Trainable variables T_vars = tf.trainable_variables() self.D_vars = [ var for var in T_vars if var.name.startswith('discriminator') ] self.C_vars = [ var for var in T_vars if var.name.startswith('classifier') ] self.G_vars = [ var for var in T_vars if var.name.startswith('generator') ] self.E_vars = [var for var in T_vars if var.name.startswith('encoder')] self.R_vars = [var for var in T_vars if var.name.startswith('decoder')] # Optimizer with tf.control_dependencies( tf.get_collection_ref(tf.GraphKeys.UPDATE_OPS)): D_optimizer = tf.train.AdamOptimizer(self.lr_D, beta1=0.5, epsilon=1e-5).minimize( self.D_loss, var_list=self.D_vars) C_optimizer = tf.train.AdamOptimizer(self.lr_C, beta1=0.5, epsilon=1e-5).minimize( self.C_loss, var_list=self.C_vars) G_optimizer = tf.train.AdamOptimizer(self.lr_G, beta1=0.5, epsilon=1e-5).minimize( self.G_loss, var_list=self.G_vars) E_optimizer = tf.train.AdamOptimizer(self.lr_E, beta1=0.5, epsilon=1e-5).minimize( self.E_loss, var_list=self.E_vars) R_optimizer = tf.train.AdamOptimizer(self.lr_R, beta1=0.5, epsilon=1e-5).minimize( self.R_loss, var_list=self.R_vars) tf.global_variables_initializer().run() train_op = tf.group(R_optimizer, E_optimizer) train_hist = { 'D_losses': [], 'C_losses': [], 'G_losses': [], 'R_losses': [] } with tqdm(total=self.epoch) as pbar: for e in range(self.epoch): # start = time.clock() pbar.update(1) index = np.arange(len(self.x_train)) np.random.shuffle(index) x_train = self.x_train[index] y_train_ohe = self.y_train_ohe[index] for iter in range(x_train.shape[0] // self.batch): # start = time.clock() x_ = x_train[iter * self.batch:(1 + iter) * self.batch] y_ = y_train_ohe[iter * self.batch:(1 + iter) * self.batch] z_ = np.random.normal(0, 1, (self.batch, self.zdim)) self.sess.run(C_optimizer, { self.x: x_, self.y: y_, self.z: z_ }) loss_c = self.sess.run(self.C_loss, { self.x: x_, self.y: y_, self.z: z_ }) for d in range(self.d_times): self.sess.run(D_optimizer, { self.x: x_, self.y: y_, self.z: z_ }) loss_d = self.sess.run(self.D_loss, { self.x: x_, self.y: y_, self.z: z_ }) for e_t in range(self.e_times): self.sess.run(train_op, { self.x: x_, self.y: y_, self.z: z_ }) loss_r = self.sess.run(self.R_loss, { self.x: x_, self.y: y_, self.z: z_ }) self.sess.run(G_optimizer, { self.x: x_, self.y: y_, self.z: z_ }) loss_g = self.sess.run(self.G_loss, { self.x: x_, self.y: y_, self.z: z_ }) # elapse = (time.clock()-start) # print('Time used:', elapse) train_hist['D_losses'].append(loss_d) train_hist['C_losses'].append(loss_c) train_hist['G_losses'].append(loss_g) train_hist['R_losses'].append(loss_r) if e == self.epoch - 1: show_result(train_hist, e, self.num) model_name = './model_wadan/model_loso' + str( self.num) + '_final.ckpt' self.saver.save(self.sess, model_name)
X_train, Y_train = generate_linear(n=100) X_test, Y_test = generate_linear(n=100) elif args.dataset == 'xor': X_train, Y_train = generate_XOR_easy() X_test, Y_test = generate_XOR_easy() else: raise RuntimeError('Dataset Not Found') net = Net() if args.criterion == 'mse': criterion = nn.MSE() elif args.criterion == 'crossentropy': criterion = nn.CrossEntropy() else: raise RuntimeError('Criterion Not Found') if args.optimizer == 'sgd': optimizer = optim.SGD(net.parameters(), lr=args.lr, momentum=args.momentum) elif args.optimizer == 'adagrad': optimizer = optim.Adagrad(net.parameters(), lr=args.lr) else: raise RuntimeError('Optimizer Not Found') model = Model(net, criterion, optimizer) train_history = model.train(X_train, Y_train, epochs=args.epochs) test_history = model.test(X_test, Y_test) show_history(train_history) show_result(X_test, Y_test, test_history['predict'])
history, test_predictions, test_real, MSE = model.train_series( serie_train, serie_test, epochs=epochs, bsize=bsize, p_filepath=preds_filepath, l_filepath=l_filepath, w_filepath=w_filepath, h=h, callbacks=callbacks) print("=============Ending Conv_MLP without HW============") """ Pure LSTM """ if model_choice == "LSTM": print("Initializing LSTM object") model = noHW_LSTM(inp_window=in_window, out_window=out_window) print("Starting LSTM training") history, test_predictions, test_real, MSE = model.fit_NN( serie_train, serie_test, epochs=5, bsize=32, p_filepath=preds_filepath, l_filepath=l_filepath, w_filepath=w_filepath, h=h, callbacks=callbacks) show_result(test_real, test_predictions)
if 'cls' in result_name: cls_scores.append(caffe_result[result_name]) else: bbox_preds.append(caffe_result[result_name]) get_bboxes_caffe = Get_Bboxes_Caffe( anchor_generator['strides'], anchor_generator['ratios'], octave_base_scale=anchor_generator['octave_base_scale'], scales_per_octave=anchor_generator['scales_per_octave']) # get bboxes from model bbox_list = get_bboxes_caffe.get_bboxes(cls_scores, bbox_preds, img_meta, test_cfg, rescale=True) bbox_results = [ bbox2result(det_bboxes, det_labels, 1) for det_bboxes, det_labels in bbox_list ] out_file = os.path.join(args.show_dir, img_meta['ori_filename']) show_result(raw_img, bbox_results[0], show=True, out_file=out_file, score_thr=0.3) # import ipdb; ipdb.set_trace()
A = utils.create_affinity_matrix(X_norm) Q = utils.create_constraint_matrix(z) D = np.diag(np.sum(A, axis=1)) vol = np.sum(A) D_norm = np.linalg.inv(np.sqrt(D)) L_norm = np.eye(*A.shape) - D_norm.dot(A.dot(D_norm)) Q_norm = D_norm.dot(Q.dot(D_norm)) # alpha < K-th eigenval of Q_norm alpha = 0.6 * sp.linalg.svdvals(Q_norm)[K] Q1 = Q_norm - alpha * np.eye(*Q_norm.shape) val, vec = sp.linalg.eig(L_norm, Q1) vec = vec[:,val >= 0] vec_norm = (vec / np.linalg.norm(vec, axis=0)) * np.sqrt(vol) costs = np.multiply(vec_norm.T.dot(L_norm), vec_norm.T).sum(axis=1) ids = np.where(costs > 1e-10)[0] min_idx = np.argsort(costs[ids])[0:K] min_v = vec_norm[:,ids[min_idx]] u = D_norm.dot(min_v) model = KMeans(n_clusters=K).fit(u) labels = model.labels_ utils.show_result(X_norm, labels)
for j in range(3): if game_state.board_state[i,j] == 1: utils.show_piece(screen, gs.black_piece, (i,j)) elif game_state.board_state[i,j] == -1: utils.show_piece(screen, gs.white_piece, (i,j)) index1, index2 = 0, 0 # 绘制的是第几个形状 for i in range(9): if game_state.player1.collected_flag[i,0] == 1: shape = game_state.player1.collected_shape_dict[i] index1 += 1 used_flag = game_state.player1.collected_flag[i, 1] utils.show_collected_shape(screen, player = 1, shape = shape, \ index = index1, used_flag=used_flag) # if game_state.player1.collected_flag[i,1] == 1: # utils.show_used_symbol() if game_state.player2.collected_flag[i,0] == 1: shape = game_state.player2.collected_shape_dict[i] index2 += 1 used_flag = game_state.player2.collected_flag[i, 1] utils.show_collected_shape(screen, player = 2, shape = shape, \ index = index2, used_flag=used_flag) if game_state.convert_shape_selected != -1: area_index = game_state.shape_area_selected_index # print('area_index: ', area_index) utils.show_selected_shape(screen, player_id, area_index) utils.show_result(screen, result, player_id) pygame.display.update()
def main(rank): #Seed - Added for TPU purposes torch.manual_seed(1) #Create log folder root = 'result_fg/' model = 'coco_model_' result_folder_name = 'images_' + FLAGS['log_dir'] model_folder_name = 'models_' + FLAGS['log_dir'] if not os.path.isdir(root): os.mkdir(root) if not os.path.isdir(root + result_folder_name): os.mkdir(root + result_folder_name) if not os.path.isdir(root + model_folder_name): os.mkdir(root + model_folder_name) #Save the script copyfile(os.path.basename(__file__), root + result_folder_name + '/' + os.path.basename(__file__)) #Define transformation for dataset images - e.g scaling transform = transforms.Compose( [ transforms.Scale((FLAGS['img_size'],FLAGS['img_size'])), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ] ) #Load dataset category_names = FLAGS['category_names'].split(',') #Serial Executor - This is needed to spread inside TPU for memory purposes SERIAL_EXEC = xmp.MpSerialExecutor() #Define Dataset dataset = SERIAL_EXEC.run( lambda: CocoData( root = FLAGS['train_imgs_path'], annFile = FLAGS['train_annotation_path'], category_names = category_names, transform=transform, final_img_size=FLAGS['img_size'] ) ) #Discard images contain very small instances dataset.discard_small(min_area=0.03, max_area=1) #Define data sampler - Added for TPU purposes train_sampler = DistributedSampler( dataset, num_replicas=xm.xrt_world_size(), rank=xm.get_ordinal(), shuffle=True ) #Define data loader train_loader = DataLoader( #Modified for TPU purposes dataset, batch_size=FLAGS['batch_size'], sampler=train_sampler, num_workers=FLAGS['num_workers'] # shuffle=True ) #Define device - Added for TPU purposes device = xm.xla_device(devkind='TPU') #For evaluation define fixed masks and noises data_iter = iter(train_loader) sample_batched = data_iter.next() x_fixed = sample_batched['image'][0:FLAGS['num_test_img']] x_fixed = Variable(x_fixed.to(device)) y_fixed = sample_batched['single_fg_mask'][0:FLAGS['num_test_img']] y_fixed = Variable(y_fixed.to(device)) z_fixed = torch.randn((FLAGS['num_test_img'],FLAGS['noise_size'])) z_fixed = Variable(z_fixed.to(device)) #Define networks generator = Generator_FG( z_dim=FLAGS['noise_size'], label_channel=len(category_names), num_res_blocks=FLAGS['num_res_blocks'] ) discriminator_glob = Discriminator( channels=3+len(category_names) ) discriminator_instance = Discriminator( channels=3+len(category_names), input_size=FLAGS['local_patch_size'] ) WRAPPED_GENERATOR = xmp.MpModelWrapper(generator) #Added for TPU purposes WRAPPED_DISCRIMINATOR_GLOB = xmp.MpModelWrapper(discriminator) #Added for TPU purposes WRAPPED_DISCRIMINATOR_INSTANCE = xmp.MpModelWrapper(discriminator) #Added for TPU purposes G_fg = WRAPPED_GENERATOR.to(device) #Modified for TPU purposes D_glob = WRAPPED_DISCRIMINATOR.to(device) #Modified for TPU purposes D_instance = WRAPPED_DISCRIMINATOR.to(device) #Modified for TPU purposes #Load parameters from pre-trained models if FLAGS['pre_trained_model_path'] != None and FLAGS['pre_trained_model_epoch'] != None: try: G_fg.load_state_dict(xser.load(FLAGS['pre_trained_model_path'] + 'G_fg_epoch_' + FLAGS['pre_trained_model_epoch'])) D_glob.load_state_dict(xser.load(FLAGS['pre_trained_model_path'] + 'D_glob_epoch_' + FLAGS['pre_trained_model_epoch'])) D_instance.load_state_dict(xser.load(FLAGS['pre_trained_model_path'] + 'D_local_epoch_' + FLAGS['pre_trained_model_epoch'])) xm.master_print('Parameters are loaded!') except: xm.master_print('Error: Pre-trained parameters are not loaded!') pass #Define interpolation operation up_instance = nn.Upsample( size=(FLAGS['local_patch_size'],FLAGS['local_patch_size']), mode='bilinear' ) #Define pooling operation for the case that image size and local patch size are mismatched pooling_instance = nn.Sequential() if FLAGS['local_patch_size']!=FLAGS['img_size']: pooling_instance.add_module( '0', nn.AvgPool2d(int(FLAGS['img_size']/FLAGS['local_patch_size'])) ) #Define training loss function - binary cross entropy BCE_loss = nn.BCELoss() #Define feature matching loss criterionVGG = VGGLoss() criterionVGG = criterionVGG.to(device) #Modified for TPU Purposes #Define optimizer G_local_optimizer = optim.Adam( G_fg.parameters(), lr=FLAGS['lr'], betas=(0.0, 0.9) ) D_local_optimizer = optim.Adam( list(filter(lambda p: p.requires_grad, D_glob.parameters())) + list(filter(lambda p: p.requires_grad, D_instance.parameters())), lr=FLAGS['lr'], betas=(0.0,0.9) ) #Deine learning rate scheduler scheduler_G = lr_scheduler.StepLR( G_local_optimizer, step_size=FLAGS['optim_step_size'], gamma=FLAGS['optim_gamma'] ) scheduler_D = lr_scheduler.StepLR( D_local_optimizer, step_size=FLAGS['optim_step_size'], gamma=FLAGS['optim_gamma'] ) #----------------------------TRAIN----------------------------------------- xm.master_print('training start!') tracker = xm.RateTracker() #Added for TPU reasons start_time = time.time() for epoch in range(FLAGS['train_epoch']): epoch_start_time = time.time() para_loader = pl.ParallelLoader(train_loader, [device]) #Added for TPU purposes loader = para_loader.per_device_loader(device) #Added for TPU purposes D_local_losses = [] G_local_losses = [] y_real_ = torch.ones(FLAGS['batch_size']) y_fake_ = torch.zeros(FLAGS['batch_size']) y_real_ = Variable(y_real_.to(device)) #Modified for TPU purposes y_fake_ = Variable(y_fake_.to(device)) #Modified for TPU purposes data_iter = iter(loader) num_iter = 0 while num_iter < len(loader): #Modified for TPU purposes j=0 while j < FLAGS['critic_iter'] and num_iter < len(loader): j += 1 sample_batched = data_iter.next() num_iter += 1 x_ = sample_batched['image'] x_ = Variable(x_.to(device)) #Modified for TPU purposes y_ = sample_batched['single_fg_mask'] y_ = Variable(y_.to(device)) #Modified for TPU purposes fg_mask = sample_batched['seg_mask'] fg_mask = Variable(fg_mask.to(device)) #Modified for TPU purposes y_instances = sample_batched['mask_instance'] bbox = sample_batched['bbox'] mini_batch = x_.size()[0] if mini_batch != FLAGS['batch_size']: break #Update discriminators - D #Real examples D_glob.zero_grad() D_instance.zero_grad() y_reduced = torch.sum(y_,1).clamp(0,1).view(y_.size(0),1,FLAGS['img_size'],FLAGS['img_size']) x_d = torch.cat([x_,fg_mask],1) x_instances = torch.zeros((FLAGS['batch_size'],3,FLAGS['local_patch_size'],FLAGS['local_patch_size'])) x_instances = Variable(x_instances.to(device)) y_instances = Variable(y_instances.to(device)) y_instances = pooling_instance(y_instances) G_instances = torch.zeros((FLAGS['batch_size'],3,FLAGS['local_patch_size'],FLAGS['local_patch_size'])) G_instances = Variable(G_instances.to(device)) #Obtain instances for t in range(x_d.size()[0]): x_instance = x_[t,0:3,bbox[0][t]:bbox[1][t],bbox[2][t]:bbox[3][t]] x_instance = x_instance.contiguous().view(1,x_instance.size()[0],x_instance.size()[1],x_instance.size()[2]) x_instances[t] = up_instance(x_instance) D_result_instance = D_instance(torch.cat([x_instances,y_instances],1)).squeeze() D_result = D_glob(x_d).squeeze() D_real_loss = BCE_loss(D_result, y_real_) + BCE_loss(D_result_instance, y_real_) D_real_loss.backward() #Fake examples z_ = torch.randn((mini_batch,FLAGS['noise_size'])) z_ = Variable(z_.to(device)) #Generate fake images G_fg_result = G_fg(z_,y_, torch.mul(x_,(1-y_reduced))) G_result_d = torch.cat([G_fg_result,fg_mask],1) #Obtain fake instances for t in range(x_d.size()[0]): G_instance = G_result_d[t,0:3,bbox[0][t]:bbox[1][t],bbox[2][t]:bbox[3][t]] G_instance = G_instance.contiguous().view(1,G_instance.size()[0],G_instance.size()[1],G_instance.size()[2]) G_instances[t] = up_instance(G_instance) D_result_instance = D_instance(torch.cat([G_instances,y_instances],1).detach()).squeeze() D_result = D_glob(G_result_d.detach()).squeeze() D_fake_loss = BCE_loss(D_result, y_fake_) + BCE_loss(D_result_instance, y_fake_) D_fake_loss.backward() xm.optimizer_step(D_local_optimizer) #Modified for TPU purposes D_train_loss = D_real_loss + D_fake_loss D_local_losses.append(D_train_loss.data[0]) if mini_batch != FLAGS['batch_size']: break #Update generator G G_fg.zero_grad() D_result = D_glob(G_result_d).squeeze() D_result_instance = D_instance(torch.cat([G_instances,y_instances],1)).squeeze() G_train_loss = (1-FLAGS['trade_off_G'])*BCE_loss(D_result, y_real_) + FLAGS['trade_off_G']*BCE_loss(D_result_instance, y_real_) #Feature matching loss between generated image and corresponding ground truth FM_loss = criterionVGG(G_fg_result, x_) #Reconstruction loss Recon_loss = mse_loss(torch.mul(x_,(1-y_reduced) ), torch.mul(G_fg_result,(1-y_reduced)) ) total_loss = G_train_loss + FLAGS['lambda_FM']*FM_loss + FLAGS['lambda_recon']*Recon_loss total_loss.backward() xm.optimizer_step(G_local_optimizer) G_local_losses.append(G_train_loss.data[0]) xm.master_print('loss_d: %.3f, loss_g: %.3f' % (D_train_loss.data[0],G_train_loss.data[0])) if (num_iter % 100) == 0: xm.master_print('%d - %d complete!' % ((epoch+1), num_iter)) xm.master_print(result_folder_name) #Modified location of the scheduler step to avoid warning scheduler_G.step() scheduler_D.step() epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time xm.master_print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), FLAGS['train_epoch'], per_epoch_ptime, torch.mean(torch.FloatTensor(D_local_losses)), torch.mean(torch.FloatTensor(G_local_losses)))) #Save images G_fg.eval() if epoch == 0: show_result( (epoch+1), x_fixed, save=True, path=root + result_folder_name+ '/' + model + str(epoch + 1 ) + '_gt.png' ) for t in range(y_fixed.size()[1]): show_result( (epoch+1), y_fixed[:,t:t+1,:,:], save=True, path=root + result_folder_name+ '/' + model + str(epoch + 1 ) +'_'+ str(t) +'_masked.png' ) show_result( (epoch+1), G_fg( z_fixed, y_fixed, torch.mul( x_fixed, (1-torch.sum(y_fixed,1).view(y_fixed.size(0),1,FLAGS['img_size'],FLAGS['img_size'])) ) ), save=True, path=root + result_folder_name+ '/' + model + str(epoch + 1 ) + '_fg.png' ) G_fg.train() #Save model params if FLAGS['save_models'] and (epoch>11 and epoch % 10 == 0 ): xser.save( G_fg.state_dict(), root + model_folder_name + '/' + model + 'G_fg_epoch_'+str(epoch)+'.pth' master_only=True ) xser.save( D_glob.state_dict(), root + model_folder_name + '/' + model + 'D_glob_epoch_'+str(epoch)+'.pth' master_only=True ) xser.save( D_instance.state_dict(), root + model_folder_name + '/' + model + 'D_local_epoch_'+str(epoch)+'.pth' master_only=True ) end_time = time.time() total_ptime = end_time - start_time xm.master_print("Training finish!... save training results") xm.master_print('Training time: ' + str(total_ptime))
import numpy as np import utils if __name__ == '__main__': X_norm, _ = utils.create_data() A = utils.create_affinity_matrix(X_norm) D = np.diag(np.sum(A, axis=1)) L = D - A eigvals, eigvecs = np.linalg.eig(L) n_dim = eigvecs.shape[0] p = np.zeros(n_dim) p[eigvecs[:, 1] > 0] = 1.0 utils.show_result(X_norm, p)
if (num_iter % 100) == 0: print('%d - %d complete!' % ((epoch+1), num_iter)) print(result_folder_name) epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time epoch_biassed = epoch + epoch_bias print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_local_losses)), torch.mean(torch.FloatTensor(G_local_losses)))) fixed_p1 = root + result_folder_name+ '/' + model + str(epoch_biassed + 1 ) + '.png' fixed_p3 = root + result_folder_name+ '/' + model + str(epoch_biassed + 1 ) + '_gt.png' #Evaluate if epoch == 0: show_result((epoch_biassed+1),x_fixed ,save=True, path=fixed_p3) for t in range(y_fixed.size()[1]): fixed_p2 = root + result_folder_name+ '/' + model + str(epoch_biassed + 1 + t ) + '_gt_y.png' show_result((epoch_biassed+1), y_fixed[:,t:t+1,:,:] ,save=True, path=fixed_p2) show_result((epoch_biassed+1),G_local(z_fixed, y_fixed) ,save=True, path=fixed_p1) #Save model params if save_models and (epoch_biassed>21 and epoch_biassed % 10 == 0 ): torch.save(G_local.state_dict(), root +model_folder_name+ '/' + model + 'G_glob_epoch_'+str(epoch_biassed)+'.pth') torch.save(D_local.state_dict(), root + model_folder_name +'/'+ model + 'D_glob_epoch_'+str(epoch_biassed)+'.pth') torch.save(G_local.state_dict(), root +model_folder_name+ '/' + model + 'G_glob_epoch_'+str(epoch_biassed)+'.pth') torch.save(D_local.state_dict(), root + model_folder_name +'/'+ model + 'D_glob_epoch_'+str(epoch_biassed)+'.pth') end_time = time.time()
fixed_p = root + 'Results/' + model + str(epoch + 1) f0 = open('i0.txt', 'a') f1 = open('i1.txt', 'a') f2 = open('i2.txt', 'a') f3 = open('i3.txt', 'a') f4 = open('i4.txt', 'a') f5 = open('i5.txt', 'a') f6 = open('i6.txt', 'a') f7 = open('i7.txt', 'a') f8 = open('i8.txt', 'a') f9 = open('i9.txt', 'a') print('Generating Results') print('0s') r0 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y0s, save=True, path=fixed_p + '0.png') print('1s') r1 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y1s, save=True, path=fixed_p + '1.png') print('2s') r2 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y2s, save=True, path=fixed_p + '2.png') print('3s') r3 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y3s, save=True, path=fixed_p + '3.png') print('4s') r4 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y4s, save=True, path=fixed_p + '4.png') print('5s') r5 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y5s, save=True, path=fixed_p + '5.png') print('6s') r6 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y6s, save=True, path=fixed_p + '6.png') print('7s') r7 = utils.show_result(sess, (epoch + 1), G_z, flatG_z, z, isTrain, fixed_z_, ygen=ygen, label=y7s, save=True, path=fixed_p + '7.png') print('8s')
pr=1, compute_mtf=False) #%% Call NN print("Initializing Conv_MLP object") model = Conv_MLP(img_size=img_size, N_Channel=2, test_size=test_size) #if compute_mtf=False -> set N_Channel=2 print("Starting Conv_MLP training") history, y_pred, y_true, MSE = model.train_HW(HW, epochs=5, bsize=32, p_filepath=preds_filepath, callbacks=False) print("Finished training") print(MSE) print("Showing results") show_result(y_pred, y_true, title="Conv-MLP with HW", full=False) print("=============TESTING RAW TS============") print("Initializing Conv_MLP object") model = Conv_MLP(img_size=img_size, N_Channel=3, raw=True, test_size=test_size) #if compute_mtf=False -> set N_Channel=2 print("Starting Conv_MLP training") history, y_pred, y_true, MSE = model.train_series(serie[0:n], serie_test[0:test_size], epochs=5, bsize=32, p_filepath=preds_filepath, callbacks=False) print("Finished training") print(MSE) print("Showing results")
G_train_loss = BCE_loss(D_result, y_real_) G_train_loss.backward() G_optimizer.step() G_losses.append(G_train_loss.item()) epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_losses)), torch.mean(torch.FloatTensor(G_losses)))) fixed_p = root + 'Fixed_results/' + model + str(epoch + 1) + '.png' show_result(G, (epoch + 1), save=True, path=fixed_p) train_hist['D_losses'].append(torch.mean(torch.FloatTensor(D_losses))) train_hist['G_losses'].append(torch.mean(torch.FloatTensor(G_losses))) train_hist['per_epoch_ptimes'].append(per_epoch_ptime) end_time = time.time() total_ptime = end_time - start_time train_hist['total_ptime'].append(total_ptime) print("Avg one epoch ptime: %.2f, total %d epochs ptime: %.2f" % (torch.mean(torch.FloatTensor( train_hist['per_epoch_ptimes'])), train_epoch, total_ptime)) print("Training finish!... save training results") torch.save(G.state_dict(), root + model + 'generator_param.pkl') torch.save(D.state_dict(), root + model + 'discriminator_param.pkl') with open(root + model + 'train_hist.pkl', 'wb') as f:
def train(epoch=10, batch_size=10, dataset_path=None, one_hot=False): if one_hot: loss_func = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=LR) else: loss_func = nn.BCELoss() optimizer = optim.RMSprop(net.parameters(), lr=LR, alpha=0.9) if dataset_path is not None and DEVICE != "kaggle": if sys.platform.startswith('win'): TRAIN_PATH = dataset_path + '\\train' VALID_PATH = dataset_path + '\\test' elif sys.platform.startswith('linux'): TRAIN_PATH = dataset_path + '/train' VALID_PATH = dataset_path + '/test' elif DEVICE == "kaggle": TRAIN_PATH = '../input/dogs-vs-cats/train/train' VALID_PATH = '../input/dogs-vs-cats/test/test' DATASET_PATH = '../input/dogs-vs-cats' # print(TRAIN_PATH) else: raise ValueError("Dataset can not be None") cat_dog_dataset = dataloader.CatVsDogDataset(TRAIN_PATH, mode="train", one_hot=one_hot) train_loader = Data(cat_dog_dataset, batch_size=batch_size, shuffle=True, num_workers=0) # train_loader = Data(cat_dog_dataset, batch_size=batch_size, shuffle=True) cat_dog_dataset_test = dataloader.CatVsDogDataset(TRAIN_PATH, mode="test", one_hot=one_hot) test_loader = Data(cat_dog_dataset_test, batch_size=batch_size, shuffle=True, num_workers=0) # test_loader = Data(cat_dog_dataset_test, batch_size=batch_size, shuffle=True) cat_dog_dataset_valid = dataloader.CatVsDogValid(VALID_PATH) valid_loader = Data(cat_dog_dataset_valid, batch_size=batch_size, shuffle=True, num_workers=0) start_time = time.time() print("Net: VGG%s, Total epoch: %d, Batch_size: %d, LR: %f, Device: %s"%(NET, epoch, batch_size, LR, DEVICE)) time.sleep(0.1) for epoch in range(epoch): print("\nEpoch: %d"%(epoch + 1)) time.sleep(0.1) train_loss_sum, train_acc_sum, n = 0.0, 0.0, 0 for batch, (x, y) in enumerate(tqdm(train_loader)): y_hat = net(x) # if batch_size > 1, use sum() to calculate per batch loss if one_hot: loss = loss_func(y_hat, y).sum() else: loss = loss_func(y_hat, y) # print("\t\tBatch #{0}/{1}".format(batch+1, len(train_loader)) + "Loss = %.6f"%float(loss)) if optimizer is not None: optimizer.zero_grad() elif params is not None and params[0].grad is not None: for param in params: param.grad.data.zero_() loss.backward() if optimizer is None: optimizer = optim.SGD(net.parameters(), lr=globals(LR)) optimizer.step() else: optimizer.step() # convert tensor data type to float data type # train_loss_sum += loss.item() # train_acc_sum += (y_hat == y).sum().item() if one_hot: train_loss_sum += loss_func(y_hat, y).sum().item() train_acc_sum += (y_hat.argmax(dim=1) == y).sum().item() else: train_loss_sum += loss.item() train_acc_sum += (torch.round(y_hat) == y).float().mean().item() # print(train_loss_sum) # print(train_acc_sum) # train_loss_sum += float(loss_func(y_hat, y)) print('Epoch: {epoch}, Loss:{loss}, Accuracy:{accuracy}, Average_loss:{average_loss}, Average_accuracy:{average_accuracy}%'.\ format(epoch=epoch+1, loss=float('%.6f' % train_loss_sum), accuracy=float('%.6f' % train_acc_sum), \ average_loss=float('%.6f' %(train_loss_sum/(batch+1))), \ average_accuracy=float('%.6f' % (train_acc_sum/(batch+1)*100)))) if (epoch+1) % RECORD_EPOCH == 0: test_acc = evaluate_accuracy(test_loader, net) print('Epoch: {epoch}, Valid accuracy: {valid:.6f}%'.format(epoch=epoch+1, valid=test_acc*100)) end_time = time.time() h, m, s = second2clock(end_time - start_time) print("Total trainning time: " + "%d hours %02d mins %.2f seconds" % (h, m, s)) start_time = time.time() test_acc = evaluate_accuracy(test_loader, net) end_time = time.time() h, m, s = second2clock(end_time - start_time) print("Test accuracy: {:.6f}".format(test_acc*100) + "%, Eval time: " + "%d hours %02d mins %.2f seconds" % (h, m, s)) test_img, test_label = iter(test_loader).__next__() show_result(net, test_img[0:SHOW_PIC_NUM], test_label[0:SHOW_PIC_NUM], rgb=RGB) if SHOW_VALID_PIC: valid_img = iter(valid_loader).__next__() show_valid(net, valid_img[0:SHOW_PIC_NUM], rgb=RGB) if CSV: valid_loader = Data(cat_dog_dataset_valid, batch_size=1, shuffle=False, num_workers=0) creat_csv(net, valid_loader)
test_size=test_size) #if compute_mtf=False -> set N_Channel=2 print("Starting Conv_MLP training") history, y_pred, y_true, MSE = model.train_series( serie[0:n], serie_test[0:test_size], epochs=epochs, bsize=bsize, p_filepath=preds_filepath, l_filepath=l_filepath, w_filepath=w_filepath, h=h, callbacks=callbacks) """ Pure LSTM """ if model_choice == "LSTM": print("Initializing LSTM object") model = noHW_LSTM(inp_window=in_window, out_window=out_window) print("Starting LSTM training") history, y_pred, y_true, MSE = model.fit_NN(serie[0:n], serie_test[0:test_size], epochs=epochs, bsize=bsize, p_filepath=preds_filepath, l_filepath=l_filepath, w_filepath=w_filepath, h=h, callbacks=callbacks) show_result(y_true, y_pred, full=False)
def train(epochs, batch_size, lr, loss_fn, data_dir): param_cuda = torch.cuda.is_available() #check training starting time start_time = time.time() G, D, G_opt, D_opt = initialize(mean=0.0, std=0.02, lr=lr) #train_hist dict will store the losses of every epoch train_hist = {} train_hist['D_model_mean_losses'] = [] train_hist['G_model_mean_losses'] = [] train_hist['per_epoch_ptimes'] = [] train_hist['total_ptime'] = [] #folder for saving the images if not os.path.isdir('GAN_results'): os.mkdir('GAN_results') for epoch in range(epochs): # Run one epoch logging.info("Epoch {}/{}".format(epoch + 1, epochs)) epoch_start_time = time.time() #One epoch of trainning over all the dataset train_hist = epoch_train(G=G, D=D, G_opt=G_opt, D_opt=D_opt, batch_size=batch_size, lr=lr, loss_fn=loss_fn, data_dir=data_dir, train_hist=train_hist) epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time #print progress information for every epoch: print("iteration number "+str(epoch)) print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), epochs, per_epoch_ptime, torch.mean(torch.FloatTensor(train_hist['D_model_mean_losses'])), torch.mean(torch.FloatTensor(train_hist['G_model_mean_losses'])))) #Save weights utils.save_checkpoint({'epoch': epoch + 1, 'D_model_state_dict': D.state_dict(), 'G_model_state_dict': G.state_dict(), 'D_optim_dict': D_opt.state_dict(), 'G_optim_dict': G_opt.state_dict()}, is_best=False, checkpoint = 'GAN_results/') #Generate and save pictures for every epoch: p = 'GAN_results/result_epoch_' + str(epoch + 1) + '.png' utils.show_result(param_cuda, G, (epoch+1), p, save=True) #add epoch time to the training history train_hist['per_epoch_ptimes'].append(per_epoch_ptime) end_time = time.time() total_ptime = end_time - start_time train_hist['total_ptime'].append(total_ptime) print("Avg per epoch ptime: %.2f, total %d epochs ptime: %.2f" % (torch.mean(torch.FloatTensor(train_hist['per_epoch_ptimes'])), epochs, total_ptime)) print("Training finish!... save learned parameters") #plot training history utils.show_train_hist(train_hist, save=True, path= 'GAN_results/_train_hist.png')
seed=None), bias_initializer=Constant(value=0.1))) # 最终输出15个2维坐标 model.summary() model.compile(optimizer='sgd', loss='mean_squared_error') return model model = bulid_model() early_stopping = EarlyStopping( monitor='val_loss', patience=20, # patience: 没有进步的训练轮数,在这之后训练就会被停止。 restore_best_weights=True ) #从具有监测数量的最佳值的时期恢复模型权重。如果为 False,则使用在训练的最后一步获得的模型权重。 model.fit(X_train, y_train, epochs=50, batch_size=256, validation_split=0.1, callbacks=[early_stopping]) ID = '' # 保存模型 model.save(ID + 'model.h5') # 预测 pred_y = model.predict(X_test, verbose=1) export(pred_y, ID + '2017211444.csv') # use complete student id as the export filename show_result(X_test[0].reshape(96, 96), pred_y[0]) #画图
def main(): parser = argparse.ArgumentParser() parser.add_argument('--log_dir', type=str, default='log', help='Name of the log folder') parser.add_argument('--save_models', type=bool, default=True, help='Set True if you want to save trained models') parser.add_argument('--pre_trained_model_path', type=str, default=None, help='Pre-trained model path') parser.add_argument('--pre_trained_model_epoch', type=str, default=None, help='Pre-trained model epoch e.g 200') parser.add_argument('--train_imgs_path', type=str, default='/mnt/sdb/data/COCO/train2017', help='Path to training images') parser.add_argument( '--train_annotation_path', type=str, default='/mnt/sdb/data/COCO/annotations/instances_train2017.json', help='Path to annotation file, .json file') parser.add_argument('--category_names', type=str, default='giraffe,elephant,zebra,sheep,cow,bear', help='List of categories in MS-COCO dataset') parser.add_argument('--num_test_img', type=int, default=4, help='Number of images saved during training') parser.add_argument('--img_size', type=int, default=256, help='Generated image size') parser.add_argument( '--local_patch_size', type=int, default=256, help='Image size of instance images after interpolation') parser.add_argument('--batch_size', type=int, default=4, help='Mini-batch size') parser.add_argument('--train_epoch', type=int, default=400, help='Maximum training epoch') parser.add_argument('--lr', type=float, default=0.0002, help='Initial learning rate') parser.add_argument('--optim_step_size', type=int, default=80, help='Learning rate decay step size') parser.add_argument('--optim_gamma', type=float, default=0.5, help='Learning rate decay ratio') parser.add_argument( '--critic_iter', type=int, default=5, help='Number of discriminator update against each generator update') parser.add_argument('--noise_size', type=int, default=256, help='Noise vector size') parser.add_argument('--lambda_FM', type=float, default=1, help='Trade-off param for feature matching loss') parser.add_argument('--lambda_branch', type=float, default=100, help='Trade-off param for reconstruction loss') parser.add_argument( '--num_res_blocks', type=int, default=2, help='Number of residual block in generator shared part') parser.add_argument('--num_res_blocks_fg', type=int, default=2, help='Number of residual block in non-bg branch') parser.add_argument('--num_res_blocks_bg', type=int, default=0, help='Number of residual block in generator bg branch') opt = parser.parse_args() print(opt) #Create log folder root = 'result_bg/' model = 'coco_model_' result_folder_name = 'images_' + opt.log_dir model_folder_name = 'models_' + opt.log_dir if not os.path.isdir(root): os.mkdir(root) if not os.path.isdir(root + result_folder_name): os.mkdir(root + result_folder_name) if not os.path.isdir(root + model_folder_name): os.mkdir(root + model_folder_name) #Save the script copyfile(os.path.basename(__file__), root + result_folder_name + '/' + os.path.basename(__file__)) #Define transformation for dataset images - e.g scaling transform = transforms.Compose([ transforms.Scale((opt.img_size, opt.img_size)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) #Load dataset category_names = opt.category_names.split(',') dataset = CocoData(root=opt.train_imgs_path, annFile=opt.train_annotation_path, category_names=category_names, transform=transform, final_img_size=opt.img_size) #Discard images contain very small instances dataset.discard_small(min_area=0.0, max_area=1) #dataset.discard_bad_examples('bad_examples_list.txt') #Define data loader train_loader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True) #For evaluation define fixed masks and noises data_iter = iter(train_loader) sample_batched = data_iter.next() y_fixed = sample_batched['seg_mask'][0:opt.num_test_img] y_fixed = Variable(y_fixed.cuda()) z_fixed = torch.randn((opt.num_test_img, opt.noise_size)) z_fixed = Variable(z_fixed.cuda()) #Define networks G_bg = Generator_BG(z_dim=opt.noise_size, label_channel=len(category_names), num_res_blocks=opt.num_res_blocks, num_res_blocks_fg=opt.num_res_blocks_fg, num_res_blocks_bg=opt.num_res_blocks_bg) D_glob = Discriminator(channels=3 + len(category_names), input_size=opt.img_size) G_bg.cuda() D_glob.cuda() #Load parameters from pre-trained models if opt.pre_trained_model_path != None and opt.pre_trained_model_epoch != None: try: G_bg.load_state_dict( torch.load(opt.pre_trained_model_path + 'G_bg_epoch_' + opt.pre_trained_model_epoch)) D_glob.load_state_dict( torch.load(opt.pre_trained_model_path + 'D_glob_epoch_' + opt.pre_trained_model_epoch)) print('Parameters are loaded!') except: print('Error: Pre-trained parameters are not loaded!') pass #Define training loss function - binary cross entropy BCE_loss = nn.BCELoss() #Define feature matching loss criterionVGG = VGGLoss() criterionVGG = criterionVGG.cuda() #Define optimizer G_local_optimizer = optim.Adam(G_bg.parameters(), lr=opt.lr, betas=(0.0, 0.9)) D_local_optimizer = optim.Adam(filter(lambda p: p.requires_grad, D_glob.parameters()), lr=opt.lr, betas=(0.0, 0.9)) #Deine learning rate scheduler scheduler_G = lr_scheduler.StepLR(G_local_optimizer, step_size=opt.optim_step_size, gamma=opt.optim_gamma) scheduler_D = lr_scheduler.StepLR(D_local_optimizer, step_size=opt.optim_step_size, gamma=opt.optim_gamma) #----------------------------TRAIN--------------------------------------- print('training start!') start_time = time.time() for epoch in range(opt.train_epoch): scheduler_G.step() scheduler_D.step() D_local_losses = [] G_local_losses = [] y_real_ = torch.ones(opt.batch_size) y_fake_ = torch.zeros(opt.batch_size) y_real_, y_fake_ = Variable(y_real_.cuda()), Variable(y_fake_.cuda()) epoch_start_time = time.time() data_iter = iter(train_loader) num_iter = 0 while num_iter < len(train_loader): j = 0 while j < opt.critic_iter and num_iter < len(train_loader): j += 1 sample_batched = data_iter.next() num_iter += 1 x_ = sample_batched['image'] y_ = sample_batched['seg_mask'] y_reduced = torch.sum(y_, 1).view(y_.size(0), 1, y_.size(2), y_.size(3)) y_reduced = torch.clamp(y_reduced, 0, 1) y_reduced = Variable(y_reduced.cuda()) #Update discriminators - D #Real examples D_glob.zero_grad() mini_batch = x_.size()[0] if mini_batch != opt.batch_size: y_real_ = torch.ones(mini_batch) y_fake_ = torch.zeros(mini_batch) y_real_, y_fake_ = Variable(y_real_.cuda()), Variable( y_fake_.cuda()) x_, y_ = Variable(x_.cuda()), Variable(y_.cuda()) x_d = torch.cat([x_, y_], 1) D_result = D_glob(x_d).squeeze() D_real_loss = BCE_loss(D_result, y_real_) D_real_loss.backward() #Fake examples z_ = torch.randn((mini_batch, opt.noise_size)) z_ = Variable(z_.cuda()) #Generate fake images G_result, G_result_bg = G_bg(z_, y_) G_result_d = torch.cat([G_result, y_], 1) D_result = D_glob(G_result_d.detach()).squeeze() D_fake_loss = BCE_loss(D_result, y_fake_) D_fake_loss.backward() D_local_optimizer.step() D_train_loss = D_real_loss + D_fake_loss D_local_losses.append(D_train_loss.item()) #Update generator G G_bg.zero_grad() D_result = D_glob(G_result_d).squeeze() G_train_loss = BCE_loss(D_result, y_real_) #Feature matching loss between generated image and corresponding ground truth FM_loss = criterionVGG(G_result, x_) #Branch-similar loss branch_sim_loss = mse_loss(torch.mul(G_result, (1 - y_reduced)), torch.mul(G_result_bg, (1 - y_reduced))) total_loss = G_train_loss + opt.lambda_FM * FM_loss + opt.lambda_branch * branch_sim_loss total_loss.backward() G_local_optimizer.step() G_local_losses.append(G_train_loss.item()) print('loss_d: %.3f, loss_g: %.3f' % (D_train_loss.item(), G_train_loss.item())) if (num_iter % 100) == 0: print('%d - %d complete!' % ((epoch + 1), num_iter)) print(result_folder_name) epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), opt.train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_local_losses)), torch.mean(torch.FloatTensor(G_local_losses)))) #Save images G_bg.eval() G_result, G_result_bg = G_bg(z_fixed, y_fixed) G_bg.train() if epoch % 10 == 0: for t in range(y_fixed.size()[1]): show_result((epoch + 1), y_fixed[:, t:t + 1, :, :], save=True, path=root + result_folder_name + '/' + model + str(epoch + 1) + '_masked.png') show_result((epoch + 1), G_result, save=True, path=root + result_folder_name + '/' + model + str(epoch + 1) + '.png') show_result((epoch + 1), G_result_bg, save=True, path=root + result_folder_name + '/' + model + str(epoch + 1) + '_bg.png') #Save model params if opt.save_models and (epoch > 21 and epoch % 10 == 0): torch.save( G_bg.state_dict(), root + model_folder_name + '/' + model + 'G_bg_epoch_' + str(epoch) + '.pth') torch.save( D_glob.state_dict(), root + model_folder_name + '/' + model + 'D_glob_epoch_' + str(epoch) + '.pth') end_time = time.time() total_ptime = end_time - start_time print("Training finish!... save training results") print('Training time: ' + str(total_ptime))
#%% Constants inpt_window = 100 outp_window = 1 n = 30000 dt = 0.1 #%% Create Data tsc1 = TSC_function(savevals=True) tsc2 = TSC_function(savevals=True) serie_train = tsc1.get_next_N_vals(n, function_example_ma, dt, sigma=2.5) serie_test = tsc2.get_next_N_vals(n, function_example_ma, dt, sigma=2.5) #You can replace this below with wherever you want the predictions csv file to be preds_filepath = "predictions_test" print("Initializing LSTM object") model = noHW_LSTM(inp_window=inpt_window, out_window=outp_window) print("Starting LSTM training") history, y_pred, y_true, MSE = model.fit_NN(serie_train[0:n], serie_test[0:n], epochs=2, bsize=64, p_filepath=preds_filepath, callbacks=False) show_result(y_true, y_pred, full=False, title="LSTM without HW")
def main(): parser = argparse.ArgumentParser() parser.add_argument('--log_dir', type=str, default='log', help='Name of the log folder') parser.add_argument('--save_models', type=bool, default=True, help='Set True if you want to save trained models') parser.add_argument('--pre_trained_model_path', type=str, default=None, help='Pre-trained model path') parser.add_argument('--pre_trained_model_epoch', type=str, default=None, help='Pre-trained model epoch e.g 200') parser.add_argument('--train_imgs_path', type=str, default='C:/Users/motur/coco/images/train2017', help='Path to training images') parser.add_argument( '--train_annotation_path', type=str, default='C:/Users/motur/coco/annotations/instances_train2017.json', help='Path to annotation file, .json file') parser.add_argument('--category_names', type=str, default='giraffe,elephant,zebra,sheep,cow,bear', help='List of categories in MS-COCO dataset') parser.add_argument('--num_test_img', type=int, default=16, help='Number of images saved during training') parser.add_argument('--img_size', type=int, default=128, help='Generated image size') parser.add_argument( '--local_patch_size', type=int, default=128, help='Image size of instance images after interpolation') parser.add_argument('--batch_size', type=int, default=16, help='Mini-batch size') parser.add_argument('--train_epoch', type=int, default=400, help='Maximum training epoch') parser.add_argument('--lr', type=float, default=0.0002, help='Initial learning rate') parser.add_argument('--optim_step_size', type=int, default=80, help='Learning rate decay step size') parser.add_argument('--optim_gamma', type=float, default=0.5, help='Learning rate decay ratio') parser.add_argument( '--critic_iter', type=int, default=5, help='Number of discriminator update against each generator update') parser.add_argument('--noise_size', type=int, default=128, help='Noise vector size') parser.add_argument('--lambda_FM', type=float, default=1, help='Trade-off param for feature matching loss') parser.add_argument('--lambda_recon', type=float, default=0.00001, help='Trade-off param for reconstruction loss') parser.add_argument('--num_res_blocks', type=int, default=5, help='Number of residual block in generator network') parser.add_argument( '--trade_off_G', type=float, default=0.1, help= 'Trade-off parameter which controls gradient flow to generator from D_local and D_glob' ) opt = parser.parse_args() print(opt) #Create log folder root = 'result_fg/' model = 'coco_model_' result_folder_name = 'images_' + opt.log_dir model_folder_name = 'models_' + opt.log_dir if not os.path.isdir(root): os.mkdir(root) if not os.path.isdir(root + result_folder_name): os.mkdir(root + result_folder_name) if not os.path.isdir(root + model_folder_name): os.mkdir(root + model_folder_name) #Save the script copyfile(os.path.basename(__file__), root + result_folder_name + '/' + os.path.basename(__file__)) #Define transformation for dataset images - e.g scaling transform = transforms.Compose([ transforms.Scale((opt.img_size, opt.img_size)), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)), ]) #Load dataset category_names = opt.category_names.split(',') dataset = CocoData(root=opt.train_imgs_path, annFile=opt.train_annotation_path, category_names=category_names, transform=transform, final_img_size=opt.img_size) #Discard images contain very small instances dataset.discard_small(min_area=0.03, max_area=1) #Define data loader train_loader = DataLoader(dataset, batch_size=opt.batch_size, shuffle=True) #For evaluation define fixed masks and noises data_iter = iter(train_loader) sample_batched = data_iter.next() x_fixed = sample_batched['image'][0:opt.num_test_img] x_fixed = Variable(x_fixed.cuda()) y_fixed = sample_batched['single_fg_mask'][0:opt.num_test_img] y_fixed = Variable(y_fixed.cuda()) z_fixed = torch.randn((opt.num_test_img, opt.noise_size)) z_fixed = Variable(z_fixed.cuda()) #Define networks G_fg = Generator_FG(z_dim=opt.noise_size, label_channel=len(category_names), num_res_blocks=opt.num_res_blocks) D_glob = Discriminator(channels=3 + len(category_names)) D_instance = Discriminator(channels=3 + len(category_names), input_size=opt.local_patch_size) G_fg.cuda() D_glob.cuda() D_instance.cuda() #Load parameters from pre-trained models if opt.pre_trained_model_path != None and opt.pre_trained_model_epoch != None: try: G_fg.load_state_dict( torch.load(opt.pre_trained_model_path + 'G_fg_epoch_' + opt.pre_trained_model_epoch)) D_glob.load_state_dict( torch.load(opt.pre_trained_model_path + 'D_glob_epoch_' + opt.pre_trained_model_epoch)) D_instance.load_state_dict( torch.load(opt.pre_trained_model_path + 'D_local_epoch_' + opt.pre_trained_model_epoch)) print('Parameters are loaded!') except: print('Error: Pre-trained parameters are not loaded!') pass #Define interpolation operation up_instance = nn.Upsample(size=(opt.local_patch_size, opt.local_patch_size), mode='bilinear') #Define pooling operation for the case that image size and local patch size are mismatched pooling_instance = nn.Sequential() if opt.local_patch_size != opt.img_size: pooling_instance.add_module( '0', nn.AvgPool2d(int(opt.img_size / opt.local_patch_size))) #Define training loss function - binary cross entropy BCE_loss = nn.BCELoss() #Define feature matching loss criterionVGG = VGGLoss() criterionVGG = criterionVGG.cuda() #Define optimizer G_local_optimizer = optim.Adam(G_fg.parameters(), lr=opt.lr, betas=(0.0, 0.9)) D_local_optimizer = optim.Adam( list(filter(lambda p: p.requires_grad, D_glob.parameters())) + list(filter(lambda p: p.requires_grad, D_instance.parameters())), lr=opt.lr, betas=(0.0, 0.9)) #Deine learning rate scheduler scheduler_G = lr_scheduler.StepLR(G_local_optimizer, step_size=opt.optim_step_size, gamma=opt.optim_gamma) scheduler_D = lr_scheduler.StepLR(D_local_optimizer, step_size=opt.optim_step_size, gamma=opt.optim_gamma) #----------------------------TRAIN----------------------------------------- print('training start!') start_time = time.time() for epoch in range(opt.train_epoch): epoch_start_time = time.time() scheduler_G.step() scheduler_D.step() D_local_losses = [] G_local_losses = [] y_real_ = torch.ones(opt.batch_size) y_fake_ = torch.zeros(opt.batch_size) y_real_, y_fake_ = Variable(y_real_.cuda()), Variable(y_fake_.cuda()) data_iter = iter(train_loader) num_iter = 0 while num_iter < len(train_loader): j = 0 while j < opt.critic_iter and num_iter < len(train_loader): j += 1 sample_batched = data_iter.next() num_iter += 1 x_ = sample_batched['image'] y_ = sample_batched['single_fg_mask'] fg_mask = sample_batched['seg_mask'] y_instances = sample_batched['mask_instance'] bbox = sample_batched['bbox'] mini_batch = x_.size()[0] if mini_batch != opt.batch_size: break #Update discriminators - D #Real examples D_glob.zero_grad() D_instance.zero_grad() x_, y_ = Variable(x_.cuda()), Variable(y_.cuda()) fg_mask = Variable(fg_mask.cuda()) y_reduced = torch.sum(y_, 1).clamp(0, 1).view(y_.size(0), 1, opt.img_size, opt.img_size) x_d = torch.cat([x_, fg_mask], 1) x_instances = torch.zeros( (opt.batch_size, 3, opt.local_patch_size, opt.local_patch_size)) x_instances = Variable(x_instances.cuda()) y_instances = Variable(y_instances.cuda()) y_instances = pooling_instance(y_instances) G_instances = torch.zeros( (opt.batch_size, 3, opt.local_patch_size, opt.local_patch_size)) G_instances = Variable(G_instances.cuda()) #Obtain instances for t in range(x_d.size()[0]): x_instance = x_[t, 0:3, bbox[0][t]:bbox[1][t], bbox[2][t]:bbox[3][t]] x_instance = x_instance.contiguous().view( 1, x_instance.size()[0], x_instance.size()[1], x_instance.size()[2]) x_instances[t] = up_instance(x_instance) D_result_instance = D_instance( torch.cat([x_instances, y_instances], 1)).squeeze() D_result = D_glob(x_d).squeeze() D_real_loss = BCE_loss(D_result, y_real_) + BCE_loss( D_result_instance, y_real_) D_real_loss.backward() #Fake examples z_ = torch.randn((mini_batch, opt.noise_size)) z_ = Variable(z_.cuda()) #Generate fake images G_fg_result = G_fg(z_, y_, torch.mul(x_, (1 - y_reduced))) G_result_d = torch.cat([G_fg_result, fg_mask], 1) #Obtain fake instances for t in range(x_d.size()[0]): G_instance = G_result_d[t, 0:3, bbox[0][t]:bbox[1][t], bbox[2][t]:bbox[3][t]] G_instance = G_instance.contiguous().view( 1, G_instance.size()[0], G_instance.size()[1], G_instance.size()[2]) G_instances[t] = up_instance(G_instance) D_result_instance = D_instance( torch.cat([G_instances, y_instances], 1).detach()).squeeze() D_result = D_glob(G_result_d.detach()).squeeze() D_fake_loss = BCE_loss(D_result, y_fake_) + BCE_loss( D_result_instance, y_fake_) D_fake_loss.backward() D_local_optimizer.step() D_train_loss = D_real_loss + D_fake_loss D_local_losses.append(D_train_loss.data[0]) if mini_batch != opt.batch_size: break #Update generator G G_fg.zero_grad() D_result = D_glob(G_result_d).squeeze() D_result_instance = D_instance( torch.cat([G_instances, y_instances], 1)).squeeze() G_train_loss = (1 - opt.trade_off_G) * BCE_loss( D_result, y_real_) + opt.trade_off_G * BCE_loss( D_result_instance, y_real_) #Feature matching loss between generated image and corresponding ground truth FM_loss = criterionVGG(G_fg_result, x_) #Reconstruction loss Recon_loss = mse_loss(torch.mul(x_, (1 - y_reduced)), torch.mul(G_fg_result, (1 - y_reduced))) total_loss = G_train_loss + opt.lambda_FM * FM_loss + opt.lambda_recon * Recon_loss total_loss.backward() G_local_optimizer.step() G_local_losses.append(G_train_loss.data[0]) print('loss_d: %.3f, loss_g: %.3f' % (D_train_loss.data[0], G_train_loss.data[0])) if (num_iter % 100) == 0: print('%d - %d complete!' % ((epoch + 1), num_iter)) print(result_folder_name) epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time print('[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), opt.train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(D_local_losses)), torch.mean(torch.FloatTensor(G_local_losses)))) #Save images G_fg.eval() if epoch == 0: show_result((epoch + 1), x_fixed, save=True, path=root + result_folder_name + '/' + model + str(epoch + 1) + '_gt.png') for t in range(y_fixed.size()[1]): show_result((epoch + 1), y_fixed[:, t:t + 1, :, :], save=True, path=root + result_folder_name + '/' + model + str(epoch + 1) + '_' + str(t) + '_masked.png') show_result((epoch + 1), G_fg( z_fixed, y_fixed, torch.mul(x_fixed, (1 - torch.sum(y_fixed, 1).view( y_fixed.size(0), 1, opt.img_size, opt.img_size)))), save=True, path=root + result_folder_name + '/' + model + str(epoch + 1) + '_fg.png') G_fg.train() #Save model params if opt.save_models and (epoch > 11 and epoch % 10 == 0): torch.save( G_fg.state_dict(), root + model_folder_name + '/' + model + 'G_fg_epoch_' + str(epoch) + '.pth') torch.save( D_glob.state_dict(), root + model_folder_name + '/' + model + 'D_glob_epoch_' + str(epoch) + '.pth') torch.save( D_instance.state_dict(), root + model_folder_name + '/' + model + 'D_local_epoch_' + str(epoch) + '.pth') end_time = time.time() total_ptime = end_time - start_time print("Training finish!... save training results") print('Training time: ' + str(total_ptime))
def train_and_evaluate(param_cuda, dataset, G_model, D_model, G_optimizer, D_optimizer, loss_fn, train_loader, train_epoch, model_dir, restore_file=None): '''Train the model and evaluate every epoch''' # reload weights from restore_file if specified if restore_file is not None: restore_path = os.path.join(model_dir, restore_file + '.pth.tar') logging.info("Restoring parameters from {}".format(restore_path)) utils.load_checkpoint(restore_path, D_model, G_model, D_optimizer, G_optimizer) # check training starting time start_time = time.time() # here we are going to save the losses of every epoch train_hist = {} train_hist['D_model_mean_losses'] = [] train_hist['G_model_mean_losses'] = [] train_hist['per_epoch_ptimes'] = [] train_hist['total_ptime'] = [] # folder for saving the images if not os.path.isdir(dataset + '_results'): os.mkdir(dataset + '_results') for epoch in range(train_epoch): # Run one epoch logging.info("Epoch {}/{}".format(epoch + 1, train_epoch)) epoch_start_time = time.time() # compute number of batches in one epoch (one full pass over the training set) train_hist = train(G_model, D_model, G_optimizer, D_optimizer, loss_fn, train_loader, param_cuda, train_hist) epoch_end_time = time.time() per_epoch_ptime = epoch_end_time - epoch_start_time #prints in every epoch: print("iteration number " + str(epoch)) print( '[%d/%d] - ptime: %.2f, loss_d: %.3f, loss_g: %.3f' % ((epoch + 1), train_epoch, per_epoch_ptime, torch.mean(torch.FloatTensor(train_hist['D_model_mean_losses'])), torch.mean(torch.FloatTensor(train_hist['G_model_mean_losses'])))) # Save weights utils.save_checkpoint( { 'epoch': epoch + 1, 'D_model_state_dict': D_model.state_dict(), 'G_model_state_dict': G_model.state_dict(), 'D_optim_dict': D_optimizer.state_dict(), 'G_optim_dict': G_optimizer.state_dict() }, is_best=False, checkpoint=dataset + '_results/') #save test pictures after every epoch: p = dataset + '_results/result_epoch_' + str(epoch + 1) + '.png' utils.show_result(param_cuda, G_model, (epoch + 1), p, save=True) # add epoch time to the training history train_hist['per_epoch_ptimes'].append(per_epoch_ptime) end_time = time.time() total_ptime = end_time - start_time train_hist['total_ptime'].append(total_ptime) print("Avg per epoch ptime: %.2f, total %d epochs ptime: %.2f" % (torch.mean(torch.FloatTensor( train_hist['per_epoch_ptimes'])), train_epoch, total_ptime)) print("Training finish!... save learned parameters") # plot training history utils.show_train_hist(train_hist, save=True, path=dataset + '_results/_train_hist.png')
- Conv_LSTM without HW - Conv_MLP with HW - Conv_MLP without HW - pure LSTM """ p_filepath = "predictions_lorenz" w_filepath = "weights_lorenz" print("======================Conv_LSTM with HW====================") data = pd.read_csv(os.path.join(p_filepath, "Conv-LSTM_20200109-0009.csv")) preds = data['Predictions'] real = data['True value'] MSE_test = ((real - preds)**2).mean() print("MSE Test loss: ", MSE_test) show_result(real, preds, full=False, title="Conv_LSTM with HW") #Model path: #model = load_model(os.path.join(w_filepath,"Conv_LSTM-weights-improvement-10-0.0016-bigger.hdf5")) print("======================Conv_LSTM without HW====================") data = pd.read_csv(os.path.join(p_filepath, "Conv-LSTM_raw_20200106-2051.csv")) preds = data['Predictions'] real = data['True value'] MSE_test = ((real - preds)**2).mean() print("MSE Test loss: ", MSE_test) show_result(real, preds, full=False, title="Conv_LSTM without HW") #Model path: #model = load_model(os.path.join(w_filepath,"Conv_LSTM_raw_weights-18.4356.hdf5")) print("======================Conv_MLP with HW====================") data = pd.read_csv(os.path.join(p_filepath, "Conv_MLP-20200108-2118.csv"))
in_window = 100 test_size = 10000 tsc = TSC_lorenz(savevals=True) serie = tsc.get_next_N_vals(n) serie_test = tsc.get_next_N_vals(n) # ==============CONSTANTS END============= print("=============TESTING HW============") #%%create holt winter object print("Initializing Holt Winter") HW=Holt_Winters_NN(serie,serie_test,1,h=6,windowsize=img_size,stride=1,alpha=0.25,beta=0,gamma=0.35) print("Initializing Conv_LSTM object") Conv_LSTM_HW = Conv_LSTM(img_size, seq_len, in_window=in_window, out_window=out_window, conv_layers=0, lstm_layers=2, dropout=0.4, pre_loaded=False, bidirectional=True, channels=2, test_size=test_size) print("Starting Conv_LSTM training") model_hw, y_true, y_pred = Conv_LSTM_HW.train_HW(HW, epochs=5, bsize=64, p_filepath=preds_filepath, callbacks=False) print("Finished training") print("Showing results") show_result(y_pred, y_true, title="Conv-LSTM With HW", full=False) print("=============TESTING RAW TS============") #%% #create NN model print("Initializing Conv_LSTM object") Conv_LSTM_HW = Conv_LSTM(img_size, seq_len, in_window=in_window, out_window=out_window, conv_layers=0, lstm_layers=2, dropout=0.4, pre_loaded=False, bidirectional=True, channels=3, test_size=test_size) print("Starting Conv_LSTM training") model_hw, y_true, y_pred = Conv_LSTM_HW.train_series(serie,serie_test, epochs=5, bsize=64, p_filepath=preds_filepath, callbacks=False) print("Finished training") print("Showing results") show_result(y_pred, y_true, title="Conv-LSTM Without HW")