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()
def save_results(self):
output_fname = 'results/uniform_buy_and_hold_dollars_over_time.txt'
util.save_results(output_fname, self.dollars_history)
def save_results(self):
output_fname = 'results/new/rmr.txt'
util.save_results(output_fname, self.dollars_history)
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
def save_results(self):
output_fname = 'results/new/const_rebalancing_dollars_over_time.txt'
util.save_results(output_fname, self.dollars_history)
