def main(): if len(sys.argv) < 4: print_usage() dataset = sys.argv[1] base_dir = sys.argv[2] out_file = sys.argv[3] phase = sys.argv[4] names = util.load_names(dataset, phase) lbls = util.load_labels(dataset, phase) centers = [] for idx, strin in enumerate(lbls): # load label data joints = np.asarray(np.reshape(strin.split(), (21, 3)), dtype=np.float32) # convert label data from world coordinates to pixel locations joints, skel_camcoords = util.world2pixel(joints, dataset) # calculate centers c = util.get_center_fpad(joints) c = np.asarray(c, dtype=np.float32) centers.append(c.reshape((1, 3))) if idx % 500 == 0: print('{}/{}'.format(idx + 1, len(names))) util.save_results(centers, out_file)
def run_analysis(self) -> None: matplotlib_setup(use_tex=False) results_list = list(self.results.values()) figures = self.analysis_func( self._list_of_dict_to_dict_of_list(results_list), self.config) save_results(path=os.path.join('plots', self.config_name), figures=figures, exist_ok=True)
def main(): if len(sys.argv) < 3: print_usage() dataset = sys.argv[1] out_file = sys.argv[2] data_dir_dict = { 'nyu': config.nyu_data_dir, 'icvl': config.icvl_data_dir, 'msra': config.msra_data_dir, 'hands17': config.hands_data_dir } base_dir = data_dir_dict[dataset] #sys.argv[3] batch_size = 64 if len(sys.argv) == 4: batch_size = int(sys.argv[3]) # generate deploy prototxt make_baseline_net( os.path.join('/home/boonyew/Documents/PoseRen', 'models/'), dataset) make_pose_ren_net( os.path.join('/home/boonyew/Documents/PoseRen', 'models/'), dataset) hand_model = ModelPoseREN(dataset) names = util.load_names(dataset) centers = util.load_centers(dataset) if dataset == 'msra': # the last index of frames belong to the same subject msra_id_split_range = np.array( [8499, 16991, 25403, 33891, 42391, 50888, 59385, 67883, 76375]) - 1 results = [] for test_id in range(9): hand_model.reset_model(dataset, test_id) sidx = msra_id_split_range[test_id - 1] + 1 if test_id else 0 eidx = msra_id_split_range[test_id] sub_names = names[sidx:eidx + 1] sub_centers = centers[sidx:eidx + 1] print('evaluating for subject {} ...'.format(test_id)) sub_results = hand_model.detect_files(base_dir, sub_names, sub_centers, max_batch=batch_size) if test_id == 0: results = sub_results else: results = np.concatenate((results, sub_results), axis=0) util.save_results(results, out_file) else: results = hand_model.detect_files(base_dir, names, centers, max_batch=batch_size) util.save_results(results, out_file)
def main(): if len(sys.argv) < 5: print_usage() dataset = sys.argv[1] model = sys.argv[2] out_file = sys.argv[3] base_dir = sys.argv[4] hand_model = HandModel(dataset, model) names = util.load_names(dataset) centers = util.load_centers(dataset) results = hand_model.detect_files(base_dir, names, centers) util.save_results(results, out_file)
def main(): args = parse_args() dataset_model = args.dataset_model dataset_image = args.dataset_image if dataset_image is None: dataset_image = dataset_model hand_model = HandModel(dataset_model, args.model_prefix, lambda img: util.get_center(img, lower=args.lower, upper=args.upper), param=(args.fx, args.fy, args.ux, args.uy)) with open(args.in_file) as f: names = [line.strip() for line in f] results = hand_model.detect_files(args.base_dir, names, dataset=dataset_image, is_flip=args.is_flip) util.save_results(results, args.out_file)
def main(): if len(sys.argv) < 3: print_usage() dataset = sys.argv[1] out_file = sys.argv[2] data_dir_dict = {'nyu': config.nyu_data_dir, 'icvl': config.icvl_data_dir + 'test/Depth/', 'msra': config.msra_data_dir} base_dir = data_dir_dict[dataset] #sys.argv[3] batch_size = 64 if len(sys.argv) == 4: batch_size = int(sys.argv[3]) # generate deploy prototxt make_baseline_net(os.path.join(ROOT_DIR, '../models'), dataset) make_pose_ren_net(os.path.join(ROOT_DIR, '../models'), dataset) hand_model = ModelPoseREN(dataset) names = util.load_names(dataset) centers = util.load_centers(dataset) # print("centers = {}".format(np.shape(centers))) # c = centers[0] # print("centers[0] = {}".format(list(c))) if dataset == 'msra': # the last index of frames belong to the same subject msra_id_split_range = np.array([8499, 16991, 25403, 33891, 42391, 50888, 59385, 67883, 76375]) - 1 results = [] for test_id in xrange(9): hand_model.reset_model(dataset, test_id) sidx = msra_id_split_range[test_id-1] + 1 if test_id else 0 eidx = msra_id_split_range[test_id] sub_names = names[sidx:eidx+1] sub_centers= centers[sidx:eidx + 1] print('evaluating for subject {} ...'.format(test_id)) sub_results = hand_model.detect_files(base_dir, sub_names, sub_centers, max_batch=batch_size) if test_id == 0: results = sub_results else: results = np.concatenate((results, sub_results), axis=0) util.save_results(results, out_file) else: results = hand_model.detect_files(base_dir, names, centers, max_batch=batch_size) print(results[0]) img = cv2.imread("/media/reborn/Others/Study/Reborn/Github/Pose-REN/test/image_0000.png", 2).astype("float32") img_show = show_results(img, results[0], dataset) cv2.imwrite('result.jpg', img_show) util.save_results(results, out_file)
def main(): # Load data print('Loading data') data_k = util.load_fast_mri_data('../data/file1000308.h5', 17) # Subsample k-space data print('Loading sampling mask') sampling_func = SamplingFunction('../common/mask_x3.h5') down_data_k = sampling_func.subsample(data_k) # Estimate phase and sensitivity maps calib = down_data_k[:, 310:329, 177:195] [est_phase, sens_maps] = lpr.util.est_phase_sens_maps(down_data_k, calib) # Generate perturbation print('Generating perturbation') perturb = perturbations.CheckerboardPerturbation( perturb_mag, (perturb_r_pos, perturb_c_pos), (data_k.shape[1], data_k.shape[2]), [8, 8], [32, 32]) # Add perturbation print('Adding perturbation') down_perturbed_data_k = lpr.add_perturbation(down_data_k, perturb, sampling_func.subsample, est_phase, sens_maps) # Run reconstruction print('Running reconstruction') recon = unet_recon(down_data_k, R=3) perturb_recon = unet_recon(down_perturbed_data_k, R=3) # Calculate LPR print('Calculating LPR') resp = lpr.calculate_lpr(recon, perturb_recon, perturb) # Save results as images print('Saving results') util.save_results(recon, perturb, resp, out_dir, crop=False)
def main(): if len(sys.argv) < 4: print_usage() dataset = sys.argv[1] base_dir = sys.argv[2] out_file = sys.argv[3] names = util.load_names(dataset) centers = [] for idx, name in enumerate(names): if dataset == 'nyu': # use synthetic image to compute center name = name.replace('depth', 'synthdepth') img = util.load_image(dataset, os.path.join(base_dir, name)) if dataset == 'icvl': center = util.get_center(img, upper=500, lower=0) elif dataset == 'nyu': center = util.get_center(img, upper=1300, lower=500) elif dataset == 'msra': center = util.get_center(img, upper=1000, lower=10) centers.append(center.reshape((1, 3))) if idx % 500 == 0: print('{}/{}'.format(idx + 1, len(names))) util.save_results(centers, out_file)
def main(): agent = Agent(args.game, args.deep_learning_mode, display=args.display, load_model=args.load_model, record=args.record, test=args.test_run) if args.record: util.record( agent, './data/recordings/{}/{}/'.format(args.game, args.deep_learning_mode)) return games_to_play = args.evaluation_games for epoch in range(args.training_epochs): try: print('Training Epoch: ', epoch + 1) print('************************') running_score = 0 frames_survived = 0 avg_loss = agent.training(args.training_steps) for i in range(games_to_play): print('Evaluation Game: ', i) agent_scores = agent.simulate_intelligent(evaluating=True) running_score += agent_scores[0] frames_survived += agent_scores[1] except: print('There was an exception!') print('############ Traceback ##############') print_exc() print('#####################################', end='\n\n') print('Quitting...') break finally: running_score /= games_to_play frames_survived /= games_to_play # Save the Average Score and Frames survived over 10 agents for this interval util.save_results( './data/{1}/{0}_avgscore_{1}.npy'.format( agent.name, args.deep_learning_mode), running_score) util.save_results( './data/{1}/{0}_avgframes_surv_{1}.npy'.format( agent.name, args.deep_learning_mode), frames_survived) # Save the average model loss over each training epoch # There are interval / 3 training epochs per interval util.save_results( './data/{1}/{0}_loss_{1}.npy'.format(agent.name, args.deep_learning_mode), avg_loss)
def save_results(self): output_fname = 'results/uniform_buy_and_hold_dollars_over_time.txt' util.save_results(output_fname, self.dollars_history)
if __name__ == "__main__": TRAIN_DATA = sys.argv[1] TEST_DATA = sys.argv[2] RESULTS_DIR = sys.argv[3] PREDS_DIR = sys.argv[4] PLOTS_DIR = sys.argv[5] MODEL = sys.argv[6] if MODEL == "rank": RANK = int(sys.argv[7]) else: RANK = 1 train_data = scipy.io.loadmat(TRAIN_DATA)['out'] test_data = scipy.io.loadmat(TEST_DATA)['out'] maes, rmses, pearsons, all_pearson, all_preds, B = icm_gp_experiment(train_data, test_data, MODEL, RANK) if MODEL == "rank": preds_name = '_'.join([MODEL, str(RANK) + '.tsv']) plot_name = '_'.join([MODEL, str(RANK), 'matrix.png']) else: preds_name = MODEL + '.tsv' plot_name = '_'.join([MODEL, 'matrix.png']) np.savetxt(os.path.join(PREDS_DIR, preds_name), all_preds) print_results(maes, rmses, pearsons, all_pearson) save_results(maes, rmses, pearsons, all_pearson, RESULTS_DIR) plot_coreg_matrix(B, os.path.join(PLOTS_DIR, plot_name))
def save_results(self): output_fname = 'results/new/const_rebalancing_dollars_over_time.txt' util.save_results(output_fname, self.dollars_history)
return result def basic(): model = sklearn.ensemble.RandomForestClassifier(criterion='gini', n_estimators=1100, max_depth=5, min_samples_split=4, min_samples_leaf=5, max_features='auto', oob_score=True, random_state=42, n_jobs=-1, verbose=0) #model = sklearn.tree.DecisionTreeClassifier(max_depth=8) model.fit(X, y) yy = model.predict(X_sub) yy = denormalize(yy) return yy if __name__ == '__main__': result = basic() #result = ensemble() save_results(result.astype(int), 'C:/kaggle_test/titanic/', 'basic.csv', root) score = score_basic('C:/kaggle_test/titanic/basic.csv') print(score)
X_train, corpus, corpusLst = newsgroup_featurize(trainraw, alphanum_only=True) Y_train = newsgroup_label_to_id(trainlab) print('Features calculated.') training_data = [x for x in zip(corpusLst, Y_train)] #print("Training: ", training_data) #print("Corpus List: ", corpusLst) X_dev, _, _ = newsgroup_featurize(testraw[:1000], alphanum_only = True) Y_dev = newsgroup_label_to_id(devlab[:1000]) X_test, _, _corpusLstTest = newsgroup_featurize(testraw, alphanum_only = True) classes = list(set(Y_train)) model = MaximumEntropyModel(corpus, classes) model.train(training_data) Y_pred = model.predict(X_dev) print("Y DEV: ", Y_dev[0:10]) print("Y PRED: ", Y_pred[0:10]) # print(Y_pred, Y_dev) count = 0 for i in range(len(Y_dev)): if Y_pred[i] == Y_dev[i]: count += 1 acc = count/len(Y_dev) print(acc) Y_test = model.predict(X_test) Y_test = newsgroup_id_to_label(Y_test) save_results(Y_test, 'maxent_newsgroup_test_predictions.csv')
exist_ok=True) # Split data sss = StratifiedShuffleSplit(n_splits=3, test_size=0.1, random_state=args.seed) scoring = { 'acc': make_scorer(accuracy_score), 'roc_auc': make_scorer(roc_auc_score, needs_proba=True), 'mcc': make_scorer(matthews_corrcoef), 'bal': make_scorer(balanced_accuracy_score), 'recall': make_scorer(recall_score) } max_iters = 10000 save_results(args.savefile, 'w', 'model', None, True) with warnings.catch_warnings(): warnings.simplefilter('ignore', ConvergenceWarning) warnings.simplefilter('ignore', RuntimeWarning) environ[ "PYTHONWARNINGS"] = "ignore" # Also affect subprocesses (n_jobs > 1) # Linear SVM print("\rLinear SVM ", end='') parameters = {'C': [0.01, 0.1, 1, 10, 100]} # svc = svm.LinearSVC(class_weight=args.class_weight, random_state=seed) svc = svm.SVC(kernel='linear', class_weight=args.class_weight, random_state=args.seed, probability=True,
def blend_mode(tuples): valuess = np.array(list(map(lambda tup: tup[1], tuples))) clipped = clip(valuess) X, counts = scipy.stats.mode(clipped, axis=0) print(counts) return X[0, :] if __name__ == '__main__': is_scored = True import os root = 'C:/kaggle_test/2d/blend/' files = os.listdir(root) files = list(filter(lambda f: not os.path.isdir(root + f), files)) tuples = [] for f in files: if is_scored: score = float('0.' + f.replace('.csv', '')) else: score = 0.5 df = pd.read_csv(root + f) values = df[df.columns[1]].to_numpy() tuples.append((1.0 - score, values)) results = 10000 * np.round(blend(tuples) / 10000).astype(int) save_results(results, root, 'blend.csv')
def main(): parser = argparse.ArgumentParser() parser.add_argument('--filename', required=True, help='Name/path of file') parser.add_argument('--savefile', type=str, default='./output.txt', help='Path to file where will be save results') parser.add_argument('--class_weight', action='store_true', default=None, help='Use balance weight') parser.add_argument('--seed', default=1234, help='Number of seed') parser.add_argument('--pretrain_epochs', type=int, default=100, help="Number of epochs to pretrain model AE") parser.add_argument('--dims_layers_ae', type=int, nargs='+', default=[500, 100, 10], help="Dimensional of layers in AE") parser.add_argument('--batch_size', type=int, default=50) parser.add_argument('--lr', type=float, default=0.001, help="Learning rate") parser.add_argument('--use_dropout', action='store_true', help="Use dropout") parser.add_argument('--no-cuda', action='store_true', help='disables CUDA training') parser.add_argument('--earlyStopping', type=int, default=None, help='Number of epochs to early stopping') parser.add_argument('--use_scheduler', action='store_true') args = parser.parse_args() print(args) np.random.seed(args.seed) torch.manual_seed(args.seed) use_cuda = not args.no_cuda and torch.cuda.is_available() device = torch.device("cuda" if use_cuda else "cpu") print(f'Device: {device.type}') loaded = np.load(args.filename) data = loaded['data'] labels = loaded['label'] del loaded name_target = PurePosixPath(args.savefile).stem save_dir = f'{PurePosixPath(args.savefile).parent}/tensorboard/{name_target}' Path(save_dir).mkdir(parents=True, exist_ok=True) args.dims_layers_ae = [data.shape[1]] + args.dims_layers_ae model_ae = AutoEncoder(args.dims_layers_ae, args.use_dropout).to(device) criterion_ae = nn.MSELoss() optimizer = torch.optim.Adam(model_ae.parameters(), lr=args.lr, weight_decay=1e-5) scheduler = None if args.use_scheduler: scheduler = torch.optim.lr_scheduler.LambdaLR( optimizer, lr_lambda=lambda ep: 0.95) min_val_loss = np.Inf epochs_no_improve = 0 fit_time_ae = 0 writer = SummaryWriter(save_dir) model_path = f'{PurePosixPath(args.savefile).parent}/models_AE/{name_target}.pth' Path(PurePosixPath(model_path).parent).mkdir(parents=True, exist_ok=True) epoch_tqdm = tqdm(range(args.pretrain_epochs), desc="Epoch loss") for epoch in epoch_tqdm: loss_train, fit_t = train_step(model_ae, criterion_ae, optimizer, scheduler, data, labels, device, writer, epoch, args.batch_size) fit_time_ae += fit_t if loss_train < min_val_loss: torch.save(model_ae.state_dict(), model_path) epochs_no_improve = 0 min_val_loss = loss_train else: epochs_no_improve += 1 epoch_tqdm.set_description( f"Epoch loss: {loss_train:.5f} (minimal loss: {min_val_loss:.5f}, stop: {epochs_no_improve}|{args.earlyStopping})" ) if args.earlyStopping is not None and epoch > args.earlyStopping and epochs_no_improve == args.earlyStopping: print('\033[1;31mEarly stopping in AE model\033[0m') break print('===================================================') print(f'Transforming data to lower dimensional') if device.type == "cpu": model_ae.load_state_dict( torch.load(model_path, map_location=lambda storage, loc: storage)) else: model_ae.load_state_dict(torch.load(model_path)) model_ae.eval() low_data = np.empty((data.shape[0], args.dims_layers_ae[-1])) n_batch, rest = divmod(data.shape[0], args.batch_size) n_batch = n_batch + 1 if rest else n_batch score_time_ae = 0 with torch.no_grad(): test_tqdm = tqdm(range(n_batch), desc="Transform data", leave=False) for i in test_tqdm: start_time = time.time() batch = torch.from_numpy( data[i * args.batch_size:(i + 1) * args.batch_size, :]).float().to(device) # ===================forward===================== z, _ = model_ae(batch) low_data[i * args.batch_size:(i + 1) * args.batch_size, :] = z.detach().cpu().numpy() end_time = time.time() score_time_ae += end_time - start_time print('Data shape after transformation: {}'.format(low_data.shape)) print('===================================================') if args.class_weight: args.class_weight = 'balanced' else: args.class_weight = None # Split data sss = StratifiedShuffleSplit(n_splits=3, test_size=0.1, random_state=args.seed) scoring = { 'acc': make_scorer(accuracy_score), 'roc_auc': make_scorer(roc_auc_score, needs_proba=True), 'mcc': make_scorer(matthews_corrcoef), 'bal': make_scorer(balanced_accuracy_score), 'recall': make_scorer(recall_score) } max_iters = 10000 save_results(args.savefile, 'w', 'model', None, True, fit_time_ae=fit_time_ae, score_time_ae=score_time_ae) with warnings.catch_warnings(): warnings.simplefilter('ignore', ConvergenceWarning) warnings.simplefilter('ignore', RuntimeWarning) environ["PYTHONWARNINGS"] = "ignore" # Linear SVM print("\rLinear SVM ", end='') parameters = {'C': [0.01, 0.1, 1, 10, 100]} # svc = svm.LinearSVC(class_weight=args.class_weight, random_state=seed) svc = svm.SVC(kernel='linear', class_weight=args.class_weight, random_state=args.seed, probability=True, max_iter=max_iters) clf = GridSearchCV(svc, parameters, cv=sss, n_jobs=-1, scoring=scoring, refit='roc_auc', return_train_score=True) try: clf.fit(low_data, labels) except Exception as e: if hasattr(e, 'message'): print(e.message) else: print(e) save_results(args.savefile, 'a', 'Linear SVM', clf, False, fit_time_ae=fit_time_ae, score_time_ae=score_time_ae) # RBF SVM print("\rRBF SVM ", end='') parameters = { 'kernel': ['rbf'], 'C': [0.01, 0.1, 1, 10, 100], 'gamma': ['scale', 'auto', 1e-2, 1e-3, 1e-4] } svc = svm.SVC(gamma="scale", class_weight=args.class_weight, random_state=args.seed, probability=True, max_iter=max_iters) clf = GridSearchCV(svc, parameters, cv=sss, n_jobs=-1, scoring=scoring, refit='roc_auc', return_train_score=True) try: clf.fit(low_data, labels) except Exception as e: if hasattr(e, 'message'): print(e.message) else: print(e) save_results(args.savefile, 'a', 'RBF SVM', clf, False, fit_time_ae=fit_time_ae, score_time_ae=score_time_ae) # LogisticRegression print("\rLogisticRegression ", end='') lreg = LogisticRegression(random_state=args.seed, solver='lbfgs', multi_class='ovr', class_weight=args.class_weight, n_jobs=-1, max_iter=max_iters) parameters = {'C': [0.01, 0.1, 1, 10, 100]} clf = GridSearchCV(lreg, parameters, cv=sss, n_jobs=-1, scoring=scoring, refit='roc_auc', return_train_score=True) try: clf.fit(low_data, labels) except Exception as e: if hasattr(e, 'message'): print(e.message) else: print(e) save_results(args.savefile, 'a', 'LogisticRegression', clf, False, fit_time_ae=fit_time_ae, score_time_ae=score_time_ae) print()
def save_results(self): output_fname = 'results/new/rmr.txt' util.save_results(output_fname, self.dollars_history)
train_labels_filename = '~/assignment-1-fixed-kushandjay/data/newsgroups/train/train_labels.csv' dev_data_filename = '~/assignment-1-fixed-kushandjay/data/newsgroups/dev/dev_data.csv' dev_labels_filename ='~/assignment-1-fixed-kushandjay/data/newsgroups/dev/dev_labels.csv' test_data_filename = '~/assignment-1-fixed-kushandjay/data/newsgroups/test/test_data.csv' m = dy.ParameterCollection() # get raw data and labels for train, dev, and test set trainraw, trainlab, devraw, devlab, testraw, testlab, classes = newsgroup_data_loader(train_data_filename, train_labels_filename,dev_data_filename,\ dev_labels_filename, test_data_filename) X_train, corpus, corpusLst = newsgroup_featurize(trainraw, alphanum_only=True) Y_train = newsgroup_label_to_id(trainlab) training_data = [x for x in zip(corpusLst, Y_train)] # X_dev, devCorpus, devCorpusLst = newsgroup_featurize(devraw, alphanum_only=True) # Y_dev = newsgroup_label_to_id(devlab) # dev_input_data = [x for x in zip(devCorpusLst, Y_dev)] X_test, _, _ = newsgroup_featurize(testraw, alphanum_only = True) numClasses = len(set(Y_train)) model = MultilayerPerceptronModel(m, corpus, numClasses, len(X_train)) print('Training now.') model.train(training_data) Y_test_predicted = model.predict(X_test) Y_test_predicted = newsgroup_id_to_label(Y_test_predicted) save_results(Y_test_predicted, 'mlp_newsgroup_test_predictions.csv')
train_x = train_data[emo_id, :, :-1] train_y = train_data[emo_id, :, -1:] test_x = test_data[emo_id, :, :-1] test_y = test_data[emo_id, :, -1:] k = GPy.kern.RBF(train_data[emo_id].shape[1] - 1) m = GPy.models.GPRegression(train_x, train_y, kernel=k) m.optimize_restarts(verbose=True, robust=True) preds = m.predict(test_x)[0] maes[emo] = MAE(preds, test_y) rmses[emo] = math.sqrt(MSE(preds, test_y)) pearsons[emo] = pearsonr(preds, test_y)[0] all_labels = np.concatenate((all_labels, test_y.flatten())) all_preds = np.concatenate((all_preds, preds.flatten())) all_pearson = pearsonr(all_preds, all_labels)[0] return maes, rmses, pearsons, all_pearson, all_preds if __name__ == "__main__": TRAIN_DATA = sys.argv[1] TEST_DATA = sys.argv[2] RESULTS_DIR = sys.argv[3] PREDS_DIR = sys.argv[4] train_data = scipy.io.loadmat(TRAIN_DATA)['out'] test_data = scipy.io.loadmat(TEST_DATA)['out'] maes, rmses, pearsons, all_pearson, all_preds = single_gp_experiment( train_data, test_data) np.savetxt(os.path.join(PREDS_DIR, 'single_gp.tsv'), all_preds) save_results(maes, rmses, pearsons, all_pearson, RESULTS_DIR) print_results(maes, rmses, pearsons, all_pearson)
print("=" * 50) print("Forest {} generation time: {}s".format( i + 1, "{0:.3f}".format(end - start))) results = forest.predict_df(test) total_results.append(results) if verbose > 1: confusion_matrix = ConfusionMatrix(results) confusion_matrix.show(verbose=(verbose > 2)) final_confusion_matrix = ConfusionMatrix(pd.concat(total_results)) total_end = time.time() print("=" * 50) print(f"Results for {data_path.replace('.csv', '')}:") print( f"Params: k_folds: {k_folds_number}; ntree: {trees_number}; m: {attributes_in_division}; seed: {seed}" ) final_confusion_matrix.show(verbose=(verbose > 0)) execution_time = total_end - total_start print(f"Total processing time: {execution_time:0.3f}s") save_results(final_confusion_matrix, data_path, k_folds_number, trees_number, attributes_in_division, execution_time, seed, parallelize) if parallelize: pool.close()
centers = util.load_centers(dataset, phase).astype(float) fx, fy, ux, uy = util.get_param(dataset) out_file = root_dir + 'labels/fpad_' + phase + '_label_nm.txt' lbls = np.asarray([s.split() for s in lbls], dtype=np.float32) for lid, lbl in enumerate(lbls): joints = np.asarray(np.reshape(lbl, (21, 3)), dtype=np.float32) joints, skel_camcoords = util.world2pixel(joints, dataset) lbls[lid] = np.reshape(joints, (63)) lbls = np.reshape(lbls, (-1, 63)) x = util.normalize_pose(dataset, lbls, centers, 150, fx, fy) util.save_results(x, out_file) ################################################################################ ############################ Test Normalized joints: norm to 2D pixel to 3D World back to 2D pixel and plot ################################# ### Test label normalization by projecting the normalized joints onto some depth image samples ### this segment is only for validation ############################################################################################################################################# lbls = util.load_labels(dataset, phase) ### load test/train data names = util.load_names(dataset, phase) centers = util.load_centers(dataset, phase).astype(float) fx, fy, ux, uy = util.get_param(dataset) lbls = [s.split() for s in lbls] lbls = np.reshape(np.asarray(lbls, dtype=np.float32), (-1, 63)) lbls = util.transform_pose(dataset, lbls, centers, 150, fx, fy) # norm to 2D pixel