def printTrainTestPred(model, cnt, trainIn, trainLabel, testIn, testLabel, meta):
print('Printing train/test predictions:')
predTrain = data.denormalize(model.predict(trainIn[:cnt]), meta)
labelTrain = data.denormalize(trainLabel[:cnt], meta)
trainData = []
trainCols = []
for i in xrange(trainLabel.shape[1]):
trainData.append(list(predTrain[:,i]))
trainCols.append('train pred label{}'.format(i))
trainData.append(list(labelTrain[:,i]))
trainCols.append('train true label{}'.format(i))
traindf = pd.DataFrame(np.array(trainData).T, columns=trainCols)
print traindf
predTest = data.denormalize(model.predict(testIn[:cnt]), meta)
labelTest = data.denormalize(testLabel[:cnt], meta)
testData = []
testCols = []
for i in xrange(testLabel.shape[1]):
testData.append(list(predTest[:,i]))
testCols.append('test pred label{}'.format(i))
testData.append(list(labelTest[:,i]))
testCols.append('test true label{}'.format(i))
testdf = pd.DataFrame(np.array(testData).T, columns=testCols)
print testdf
def validate_on_single_img(model, img_path, upscale_factor):
img = load_img(img_path, upscale_factor)
w, h = img.size
size = h // upscale_factor, w // upscale_factor
x = data.get_input_tranforms(size=size)(img).unsqueeze(0)
downscaled = data.denormalize(x[0, 0].detach().numpy())
out_img = model(x).clamp(0)
out_img = out_img.detach().numpy()
out_img = data.denormalize(out_img)
out_img = PIL.Image.fromarray(out_img[0, 0], 'L')
fig, axs = plt.subplots(1, 3)
axs[0].imshow(img, cmap='gray', vmin=0, vmax=255)
axs[1].imshow(downscaled, cmap='gray', vmin=0, vmax=255)
axs[2].imshow(out_img, cmap='gray', vmin=0, vmax=255)
plt.show()
def evaluate_timeseries_with_label(timeseries, labels, window_size):
filter_length = 128
nb_filter = 64
nb_series = 1
nb_samples = timeseries.shape[0]
print('\n\nTimeseries ({} samples by {} series):\n'.format(
nb_samples, nb_series))
model = make_timeseries_regressor(window_size=window_size,
filter_length=filter_length,
nb_input_series=nb_series,
nb_outputs=nb_series,
nb_filter=nb_filter)
print(
'\n\nModel with input size {}, output size {}, {} conv filters of length {}'
.format(model.input_shape, model.output_shape, nb_filter,
filter_length))
model.summary()
X = np.atleast_3d(timeseries)
y = np.atleast_3d(labels)
print('\nShape: {}: y:{}'.format(X.shape, y.shape))
test_size = int(0.1 * len(timeseries))
train_size = int(0.9 * len(timeseries))
#X_train, X_test, y_train, y_test = X[:-test_size], X[-test_size:], y[:-test_size], y[-test_size:]
idx = np.random.choice(len(timeseries), len(timeseries), replace=False)
train_idx = idx[:train_size]
test_idx = idx[train_size:]
global eval_data_scale, eval_label_scale
eval_data_scale = data_scale[test_idx, :]
eval_label_scale = label_scale[test_idx, :]
X_train, X_test, y_train, y_test = X[train_idx, :], X[test_idx, :], y[
train_idx, :], y[test_idx, :]
#train
model.fit(X_train,
y_train,
epochs=30,
batch_size=8,
validation_data=(X_test, y_test))
model.save_weights('try5_keras4.hd5')
pred = model.predict(X_test)
X_test = denormalize(X_test, eval_data_scale, axis=1)
y_test = denormalize(y_test, eval_label_scale, axis=1)
pred = denormalize(pred, eval_label_scale, axis=1)
save_plot(X_test, y_test, pred, 'try5_keras4.out', style='keras')
def plot_image(epoch, generator, dataloader, dim=(1, 3), figsize=(15, 5)):
for i, imgs in tqdm(enumerate(dataloader)):
imgs_hr = Variable(imgs["hr"].type(Tensor))
imgs_lr = Variable(imgs["lr"].type(Tensor))
gen_hr = generator(imgs_lr)
#denormalize input
imgs_lr = denormalize(imgs_lr)
# Scaling output
gen_hr = gen_hr.clamp(0, 1)
for j in range(imgs_lr.shape[0]):
batches_done = i * len(dataloader) + j
psnr_val = psnr_fn(gen_hr[[j]], imgs_hr[[j]]).mean().item()
ssim_val = ssim_fn(gen_hr[[j]], imgs_hr[[j]]).mean().item()
file_name = os.path.join(
args.output_path, 'generated_image_' + str(batches_done) +
"_" + str(epoch) + "_PSNR : " + str(round(psnr_val, 2)) +
" SSIM : " + str(round(ssim_val, 2)) + '.png')
lr_image = F.interpolate(imgs_lr[[j]],
(imgs_hr.shape[2], imgs_hr.shape[3]),
mode='nearest')[0]
hr_image = imgs_hr[j]
gen_image = gen_hr[j]
concat_image = torch.cat((lr_image, gen_image, hr_image), 2)
save_image(concat_image, file_name)
def predict(net, data_iter):
X = []
y = []
p = []
predict_loss, n = 0.0, 0.0
i = 0
for batch in data_iter:
data, label, batch_size = _get_batch(batch, ctx)
losses = []
outputs = [net(X) for X in data]
losses = [loss(yhat, y) for yhat, y in zip(outputs, label)]
predict_loss += sum([l.sum().asscalar() for l in losses])
n += batch_size
data = [
denormalize(D,
eval_data_scale[i * batch_size:(i + 1) *
batch_size, :],
axis=2) for D in data
]
label = [
denormalize(D,
eval_label_scale[i * batch_size:(i + 1) *
batch_size, :],
axis=2) for D in label
]
outputs = [
denormalize(D,
eval_label_scale[i * batch_size:(i + 1) *
batch_size, :],
axis=2) for D in outputs
]
outputs = [
D.reshape((batch_size, 1, sequence_length)) for D in outputs
]
X.append(data[0][0].asnumpy())
y.append(label[0][0].asnumpy())
p.append(outputs[0][0].asnumpy())
i += 1
print("Cumulative_Loss: %.3f, Predict_Loss: %.3f " %
(predict_loss, predict_loss / n))
return X, y, p
def model_predict(net, data_iter, batch_size, num_channel=1):
i = 0
X = []
y = []
p = []
cumulative_loss = 0
for i, (data, label) in enumerate(data_iter):
data = data.as_in_context(ctx)
label = label.as_in_context(ctx)
if data.shape[0] < batch_size:
continue
output = net(data) # (n,w)
output = output.reshape((batch_size, sequence_length, 1))
loss = square_loss(output, label)
cumulative_loss += nd.mean(loss).asscalar()
print("iter %d, loss: %e" % (i, cumulative_loss))
denormalize(data,
eval_data_scale[i * batch_size:(i + 1) * batch_size, :])
denormalize(label,
eval_label_scale[i * batch_size:(i + 1) * batch_size, :])
denormalize(output,
eval_label_scale[i * batch_size:(i + 1) * batch_size, :])
X.append(np.squeeze(data[0].asnumpy()))
y.append(np.squeeze(label[0].asnumpy()))
p.append(output[0].asnumpy())
if i == 0:
print(data.shape, label.shape, output.shape)
i += 1
print("predict_loss: %e," % (cumulative_loss))
return X, y, p
def plot_image(generators, dataloader, model_names):
for i, imgs in tqdm(enumerate(dataloader)):
imgs_hr = Variable(imgs["hr"].type(Tensor))
imgs_lr = Variable(imgs["lr"].type(Tensor))
for j in range(imgs_lr.shape[0]):
batches_done = i * len(dataloader) + j
file_name = os.path.join(
args.output_path,
'generated_image_11_' + str(batches_done) + '.png')
csv_file_name = os.path.join(
args.output_path,
'generated_image_11_' + str(batches_done) + '.csv')
imgs_lr_1 = imgs_lr.clone()
lr_image = F.interpolate(denormalize(imgs_lr_1)[[j]],
(imgs_hr.shape[2], imgs_hr.shape[3]),
mode='nearest')[0]
if args.debug:
print("LR Shape", lr_image.shape)
final_image = lr_image.unsqueeze(0)
list_psnr = []
list_ssim = []
for generator in generators:
gen_hr = generator(imgs_lr)
gen_hr = gen_hr.clamp(0, 1)
psnr_val = psnr_fn(gen_hr[[j]], imgs_hr[[j]]).mean().item()
ssim_val = ssim_fn(gen_hr[[j]], imgs_hr[[j]]).mean().item()
final_image = torch.cat((final_image, gen_hr[[j]]), 0)
list_psnr.append(psnr_val)
list_ssim.append(ssim_val)
final_image = torch.cat((final_image, imgs_hr[[j]]), 0)
if args.debug:
print("Final Shape", final_image.shape)
grid_image = torchvision.utils.make_grid(final_image, nrow=2)
if args.debug:
print("Grid Shape", grid_image.shape)
save_image(grid_image, file_name)
for i in range(len(model_names)):
write_to_csv_file(csv_file_name, [
args.dataset_name, model_names[i], list_psnr[i],
list_ssim[i]
])
def discreteClassify(model, input, labels, meta):
partitioner = PermutationPartitioner(len(input), len(input) / RP['num_partitions'])
iterations = RP['num_partitions']**2
metrics = {
'acc': np.zeros((iterations)),
'log_loss': np.zeros((iterations)),
# 'auc': np.zeros((iterations)),
# 'auc_micro': np.zeros((iterations))
}
# first denormalize labels, so we do it only once
labels = data.denormalize(labels, meta)
for iteration in range(iterations):
# print('\titer:\t{}/{}'.format(iteration, iterations))
part = partitioner.get()
partIn = input[part]
partLabels = labels[part]
partPred = model.predict(partIn, batch_size = RP['batch'])
binarizedPred = np.zeros((len(partPred), len(partPred[0])))
"""
for row in range(len(partLabels)):
for idx, val in enumerate(partLabels[row]):
if val == 1:
sys.stdout.write('{}, '.format(idx))
for val in partPred[row]:
sys.stdout.write('{}, '.format(val))
sys.stdout.write('\n')
sys.stdout.flush()
"""
for i in range(len(partPred)):
maxValue = 0
maxIndex = 0
for index in range(len(partPred[i])):
value = partPred[i][index]
if value > maxValue:
maxValue = value
maxIndex = index
binarizedPred[i][maxIndex] = 1
metrics['acc'][iteration] = sk.metrics.accuracy_score(partLabels,
binarizedPred)
metrics['log_loss'][iteration] = sk.metrics.log_loss(partLabels,
binarizedPred)
'''
keepVec = []
for col in range(len(partLabels[0])):
wasOne = 0
for row in range(len(partLabels)):
if partLabels[row][col] == 1:
wasOne = 1
break
if wasOne:
keepVec.append(col)
cutLabels = np.zeros((len(partLabels), len(keepVec)))
cutPreds = np.zeros((len(partLabels), len(keepVec)))
for idx, keep in enumerate(keepVec):
for row in range(len(partLabels)):
cutLabels[row][idx] = partLabels[row][keep]
cutPreds[row][idx] = binarizedPred[row][keep]
metrics['auc'][iteration] = sk.metrics.roc_auc_score(cutLabels,
cutPreds, average = 'macro')
metrics['auc_micro'][iteration] = sk.metrics.roc_auc_score(cutLabels,
cutPreds, average = 'micro')
'''
metricsOverall = {
'acc_avg': np.nanmean(metrics['acc']),
'acc_std': np.nanstd(metrics['acc']),
'log_loss_avg': np.nanmean(metrics['log_loss']),
'log_loss_std': np.nanstd(metrics['log_loss']),
# 'auc_avg': np.nanmean(metrics['auc']),
# 'auc_std': np.nanstd(metrics['auc']),
# 'auc_micro_avg': np.nanmean(metrics['auc_micro']),
# 'auc_micro_std': np.nanstd(metrics['auc_micro'])
'auc_avg': None,
'auc_std': None,
'auc_micro_avg': None,
'auc_micro_std': None,
}
print('Overall metrics:')
print('\tACC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['acc_avg'],metricsOverall['acc_std']))
print('\tLogLos:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['log_loss_avg'],metricsOverall['log_loss_std']))
# print('\tAUC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['auc_avg'],metricsOverall['auc_std']))
# print('\tAUC Micro:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['auc_micro_avg'],metricsOverall['auc_micro_std']))
return metricsOverall
def predict(model, input, labels, meta):
if RP['edge_prediction']:
partitioner = PermutationPartitioner(len(input[0]), len(input[0]) / RP['num_partitions'])
else:
partitioner = PermutationPartitioner(len(input), len(input) / RP['num_partitions'])
iterations = RP['num_partitions']**2
metrics = {
'r2': np.zeros((labels.shape[1], iterations)),
'mse': np.zeros((labels.shape[1], iterations)),
'mae': np.zeros((labels.shape[1], iterations)),
}
# first denormalize labels, so we do it only once
labels = data.denormalize(labels, meta)
for iteration in range(iterations):
print('\titer:\t{}/{}'.format(iteration+1, iterations))
part = partitioner.get()
if RP['edge_prediction']:
partIn = [input[0][part],input[1][part]]
else:
partIn = input[part]
partLabelsT = labels[part].T
partPredT = model.predict(partIn, batch_size = RP['batch']).T
for i in range(labels.shape[1]):
metrics['r2'][i][iteration] = computeR2(partPredT[i], partLabelsT[i])
metrics['mse'][i][iteration] = computeMSE(partPredT[i], partLabelsT[i])
metrics['mae'][i][iteration] = computeMAE(partPredT[i], partLabelsT[i])
del partIn
del partLabelsT
del partPredT
metricsPerLabel = {
'r2_avg': np.nanmean(metrics['r2'], axis = 1),
'r2_std': np.nanstd(metrics['r2'], axis = 1),
'mse_avg': np.nanmean(metrics['mse'], axis = 1),
'mse_std': np.nanstd(metrics['mse'], axis = 1),
'mae_avg': np.nanmean(metrics['mae'], axis = 1),
'mae_std': np.nanstd(metrics['mae'], axis = 1),
}
metricsOverall = {
'r2_avg': np.nanmean(metrics['r2']),
'r2_std': np.nanstd(metrics['r2']),
'mse_avg': np.nanmean(metrics['mse']),
'mse_std': np.nanstd(metrics['mse']),
'mae_avg': np.nanmean(metrics['mae']),
'mae_std': np.nanstd(metrics['mae']),
}
for i,labelName in enumerate(RD['labels']):
print('{}/{} - {}:'.format(i+1, len(RD['labels']),labelName))
print('\tR2:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsPerLabel['r2_avg'][i],metricsPerLabel['r2_std'][i]))
print('\tMSE:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsPerLabel['mse_avg'][i],metricsPerLabel['mse_std'][i]))
print('\tMAE:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsPerLabel['mae_avg'][i],metricsPerLabel['mae_std'][i]))
print('Overall metrics:')
print('\tR2:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['r2_avg'],metricsOverall['r2_std']))
print('\tMSE:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['mse_avg'],metricsOverall['mse_std']))
print('\tMAE:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['mae_avg'],metricsOverall['mae_std']))
return metricsOverall
def regularize_state_Soft(states, rel_attrs, stat):
"""
:param states: B x N x state_dim
:param rel_attrs: B x N x N x relation_dim
:param stat: [xxx]
:return new states: B x N x state_dim
"""
states_denorm = denormalize([states], [stat[1]], var=True)[0]
states_denorm_acc = denormalize([states.clone()], [stat[1]], var=True)[0]
rel_attrs = rel_attrs[0]
rel_attrs_np = rel_attrs.detach().cpu().numpy()
def get_rel_id(x):
return np.where(x > 0)[0][0]
B, N, state_dim = states.size()
count = Variable(
torch.FloatTensor(np.zeros((1, N, 1, 8))).to(states.device))
for i in range(N):
for j in range(N):
if i == j:
assert get_rel_id(
rel_attrs_np[i, j]) % 9 == 0 # rel_attrs[i, j, 0] == 1
count[:, i, :, :] += 1
continue
assert torch.sum(rel_attrs[i, j]) <= 1
if torch.sum(rel_attrs[i, j]) == 0:
continue
if get_rel_id(
rel_attrs_np[i, j]) % 9 == 1: # rel_attrs[i, j, 1] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 2 # rel_attrs[j, i, 2] == 1
x0 = 1
y0 = 3
x1 = 0
y1 = 2
idx = 1
elif get_rel_id(
rel_attrs_np[i, j]) % 9 == 2: # rel_attrs[i, j, 2] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 1 # rel_attrs[j, i, 1] == 1
x0 = 3
y0 = 1
x1 = 2
y1 = 0
idx = 2
elif get_rel_id(
rel_attrs_np[i, j]) % 9 == 3: # rel_attrs[i, j, 3] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 4 # rel_attrs[j, i, 4] == 1
x0 = 0
y0 = 1
x1 = 2
y1 = 3
idx = 3
elif get_rel_id(
rel_attrs_np[i, j]) % 9 == 4: # rel_attrs[i, j, 4] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 3 # rel_attrs[j, i, 3] == 1
x0 = 1
y0 = 0
x1 = 3
y1 = 2
idx = 4
elif get_rel_id(
rel_attrs_np[i, j]) % 9 == 5: # rel_attrs[i, j, 5] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 8 # rel_attrs[j, i, 8] == 1
x = 0
y = 3
idx = 5
elif get_rel_id(
rel_attrs_np[i, j]) % 9 == 8: # rel_attrs[i, j, 8] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 5 # rel_attrs[j, i, 5] == 1
x = 3
y = 0
idx = 8
elif get_rel_id(
rel_attrs_np[i, j]) % 9 == 6: # rel_attrs[i, j, 6] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 7 # rel_attrs[j, i, 7] == 1
x = 1
y = 2
idx = 6
elif get_rel_id(
rel_attrs_np[i, j]) % 9 == 7: # rel_attrs[i, j, 7] == 1:
assert get_rel_id(
rel_attrs_np[j, i]) % 9 == 6 # rel_attrs[j, i, 6] == 1
x = 2
y = 1
idx = 7
else:
AssertionError("Unknown rel_attr %f" % rel_attrs[i, j])
if idx < 5:
# if connect by two points
x0 *= 2
y0 *= 2
x1 *= 2
y1 *= 2
count[:, i, :, x0:x0 + 2] += 1
count[:, i, :, x1:x1 + 2] += 1
states_denorm_acc[:, i, x0:x0 + 2] += states_denorm[:, j,
y0:y0 + 2]
states_denorm_acc[:, i, x0 + 8:x0 +
10] += states_denorm[:, j, y0 + 8:y0 + 10]
states_denorm_acc[:, i, x1:x1 + 2] += states_denorm[:, j,
y1:y1 + 2]
states_denorm_acc[:, i, x1 + 8:x1 +
10] += states_denorm[:, j, y1 + 8:y1 + 10]
else:
# if connected by a corner
x *= 2
y *= 2
count[:, i, :, x:x + 2] += 1
states_denorm_acc[:, i, x:x + 2] += states_denorm[:, j,
y:y + 2]
states_denorm_acc[:, i,
x + 8:x + 10] += states_denorm[:, j,
y + 8:y + 10]
states_denorm = states_denorm_acc.view(B, N, 2, state_dim // 2) / count
states_denorm = states_denorm.view(B, N, state_dim)
return normalize([states_denorm], [stat[1]], var=True)[0]
def classify(model, input, labels, meta):
if RP['edge_prediction']:
partitioner = PermutationPartitioner(len(input[0]), len(input[0]) / RP['num_partitions'])
else:
partitioner = PermutationPartitioner(len(input), len(input) / RP['num_partitions'])
iterations = RP['num_partitions']**2
metrics = {
'acc': np.zeros((labels.shape[1], iterations)),
'log_loss': np.zeros((labels.shape[1], iterations)),
'auc': np.zeros((labels.shape[1], iterations)),
'confusion': np.zeros((labels.shape[1], iterations, 2, 2)),
}
# first denormalize labels, so we do it only once
labels = data.denormalize(labels, meta)
for iteration in range(iterations):
print('\titer:\t{}/{}'.format(iteration, iterations))
part = partitioner.get()
if RP['edge_prediction']:
partIn = [input[0][part],input[1][part]]
else:
partIn = input[part]
partLabelsT = labels[part].T
partPredT = model.predict(partIn, batch_size = RP['batch']).T
for i in range(labels.shape[1]):
confusion = computeConfusion(partPredT[i], partLabelsT[i])
metrics['confusion'][i][iteration] = confusion
metrics['acc'][i][iteration] = (confusion[0][0]+confusion[1][1]) / confusion.sum()
metrics['log_loss'][i][iteration] = utility.logloss(partPredT[i],partLabelsT[i],RP['classify_label_neg'],RP['classify_label_pos'])
metrics['auc'][i][iteration] = computeAUC(partPredT[i], partLabelsT[i])
del partIn
del partLabelsT
del partPredT
metricsPerLabel = {
'acc_avg': np.nanmean(metrics['acc'], axis = 1),
'acc_std': np.nanstd(metrics['acc'], axis = 1),
'log_loss_avg': np.nanmean(metrics['log_loss'], axis = 1),
'log_loss_std': np.nanstd(metrics['log_loss'], axis = 1),
'auc_avg': np.nanmean(metrics['auc'], axis = 1),
'auc_std': np.nanstd(metrics['auc'], axis = 1)
}
metricsOverall = {
'acc_avg': np.nanmean(metrics['acc']),
'acc_std': np.nanstd(metrics['acc']),
'log_loss_avg': np.nanmean(metrics['log_loss']),
'log_loss_std': np.nanstd(metrics['log_loss']),
'auc_avg': np.nanmean(metrics['auc']),
'auc_std': np.nanstd(metrics['auc'])
}
for i,labelName in enumerate(RD['labels']):
print('{}/{} - {}:'.format(i+1, len(RD['labels']),labelName))
print('\tACC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsPerLabel['acc_avg'][i],metricsPerLabel['acc_std'][i]))
print('\tLogLos:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsPerLabel['log_loss_avg'][i],metricsPerLabel['log_loss_std'][i]))
print('\tAUC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsPerLabel['auc_avg'][i],metricsPerLabel['auc_std'][i]))
print('Overall metrics:')
print('\tACC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['acc_avg'],metricsOverall['acc_std']))
print('\tLogLos:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['log_loss_avg'],metricsOverall['log_loss_std']))
print('\tAUC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['auc_avg'],metricsOverall['auc_std']))
return metricsOverall
# rollout and calculate distance to goal
if args.env == 'Rope':
state_cur_v = to_var(state_cur, use_gpu)[None, :, :]
for j in range(step, args.roll_step):
action_cur = control_v[j:j+1]
action_cur_normalized = normalize([action_cur], [stat[2]], var=True)[0]
state_cur_normalized = normalize([state_cur_v], [stat[1]], var=True)[0]
# print(attr_normalized.size(), state_cur_normalized.size(), action_cur_normalized.size())
with torch.set_grad_enabled(True):
pred = model([attr_normalized, state_cur_normalized, Rr_batch, Rs_batch, Ra_batch],
args.pstep, action=action_cur_normalized)
stat_vel = stat[1][args.position_dim:, :]
pred = denormalize([pred], [stat_vel], var=True)[0]
assert pred.requires_grad
state_cur_v[:, :, :args.position_dim] = state_cur_v[:, :, :args.position_dim] + pred * args.dt
state_cur_v[:, :, args.position_dim:] = pred
loss = criterionMSE(
state_cur_v[:, :args.n_particle, :args.position_dim],
state_goal_v[:, :args.n_particle, :args.position_dim])
elif args.env == 'Box':
# print('actions', actions)
# print('latents', latents)
actions_cur = actions.clone()
latents_cur = latents.clone()
for j in range(step, args.roll_step):
def get_pred(TMP, WDIR, WSPD):
return data.denormalize(
get_prediction([data.normalize_in([TMP, WDIR, WSPD])]))[0][0]
def get_pred(TMP, WDIR, WSPD):
return data.denormalize(get_prediction([data.normalize_in([TMP, WDIR, WSPD])]))[0][0]
def eval(idx_rollout, video=True):
print(f'\n=== Forward Simulation on Example {roll_idx} ===')
seq_data = load_data(prepared_names, os.path.join(data_dir, str(idx_rollout) + '.rollout.h5'))
attrs, states, actions, rel_attrs = [to_var(d.copy(), use_gpu=use_gpu) for d in seq_data]
seq_data = denormalize(seq_data, stat)
attrs_gt, states_gt, action_gt = seq_data[:3]
param_file = os.path.join(data_dir, str(idx_rollout // args.group_size) + '.param')
param = torch.load(param_file)
engine.init(param)
'''
fit data
'''
fit_data = get_more_trajectories(roll_idx)
fit_data = [to_var(d, use_gpu=use_gpu) for d in fit_data]
bs = args.fit_num
''' T x N x D (denormalized)'''
states_pred = states_gt.copy()
states_pred[1:] = 0
''' T x N x D (normalized)'''
s_pred = states.clone()
'''
reconstruct loss
'''
attrs_flat = get_flat(fit_data[0])
states_flat = get_flat(fit_data[1])
actions_flat = get_flat(fit_data[2])
rel_attrs_flat = get_flat(fit_data[3])
g = model.to_g(attrs_flat, states_flat, rel_attrs_flat, args.pstep)
g = g.view(torch.Size([bs, args.time_step]) + g.size()[1:])
G_tilde = g[:, :-1]
H_tilde = g[:, 1:]
U_tilde = fit_data[2][:, :-1]
G_tilde = get_flat(G_tilde, keep_dim=True)
H_tilde = get_flat(H_tilde, keep_dim=True)
U_tilde = get_flat(U_tilde, keep_dim=True)
_t = time.time()
A, B, fit_err = model.system_identify(
G=G_tilde, H=H_tilde, U=U_tilde, rel_attrs=fit_data[3][:1, 0], I_factor=args.I_factor)
_t = time.time() - _t
'''
predict
'''
g = model.to_g(attrs, states, rel_attrs, args.pstep)
pred_g = None
for step in range(0, args.time_step - 1):
# prepare input data
if step == 0:
current_s = states[step:step + 1]
current_g = g[step:step + 1]
states_pred[step] = states_gt[step]
else:
'''current state'''
if args.eval_type == 'valid':
current_s = states[step:step + 1]
elif args.eval_type == 'rollout':
current_s = s_pred[step:step + 1]
'''current g'''
if args.eval_type in {'valid', 'rollout'}:
current_g = model.to_g(attrs[step:step + 1], current_s, rel_attrs[step:step + 1], args.pstep)
elif args.eval_type == 'koopman':
current_g = pred_g
'''next g'''
pred_g = model.step(g=current_g, u=actions[step:step + 1], rel_attrs=rel_attrs[step:step + 1])
'''decode s'''
pred_s = model.to_s(attrs=attrs[step:step + 1], gcodes=pred_g,
rel_attrs=rel_attrs[step:step + 1], pstep=args.pstep)
pred_s_np_denorm = denormalize([to_np(pred_s)], [stat[1]])[0]
states_pred[step + 1:step + 2] = pred_s_np_denorm
d = args.state_dim // 2
states_pred[step + 1:step + 2, :, :d] = states_pred[step:step + 1, :, :d] + \
args.dt * states_pred[step + 1:step + 2, :, d:]
s_pred_next = normalize([states_pred[step + 1:step + 2]], [stat[1]])[0]
s_pred[step + 1:step + 2] = to_var(s_pred_next, use_gpu=use_gpu)
if video:
engine.render(states_pred, seq_data[2], param, act_scale=args.act_scale, video=True, image=True,
path=os.path.join(args.evalf, str(idx_rollout) + '.pred'),
states_gt=states_gt)
X = []
y = []
p = []
cumulative_loss = 0
for data, label in data_iter:
data = data.as_in_context(ctx, )
label = label.as_in_context(ctx, )
if data.shape[0] < batch_size:
continue
output = net(data) # (n,w)
loss = square_loss(output, label[:, :, 0])
cumulative_loss += nd.mean(loss).asscalar()
print("iter %d, loss: %e" % (i, cumulative_loss))
X.append(np.squeeze(data[0].asnumpy()))
y.append(np.squeeze(label[0].asnumpy()))
p.append(output[0].asnumpy())
if i == 0:
print(data.shape, label.shape, output.shape)
i += 1
print("predict_loss: %e," % (cumulative_loss))
return X, y, p
X, y, predicted = model_predict(net, eval_iter, batch_size)
# X: (n, w, c)
X = [denormalize(a, data_scale, axis=1) for a in X]
y = [denormalize(a, label_scale, axis=1) for a in y]
predicted = [denormalize(a, label_scale, axis=1) for a in predicted]
save_plot(X, y, predicted, 'try4_ivi.out')
def mpc_qp(g_cur,
g_goal,
time_cur,
T,
rel_attrs,
A_t,
B_t,
Q,
R,
node_attrs=None,
actions=None,
gt_info=None):
"""
Model Predictive Control + Quadratic Programming
:param rel_attrs: N x N x relation_dim
:param node_attrs: N x attributes_dim
:return action sequence u: T - 1 x N x action_dim
"""
n_obj = engine.num_obj
constraints = []
if not args.baseline:
D = args.g_dim
else:
D = g_goal.shape[-1]
if args.fit_type == 'structured':
dim_a = args.action_dim
g = cp.Variable((T * n_obj, D))
u = cp.Variable(((T - 1) * n_obj, args.action_dim))
augG = cp.Variable(((T - 1) * n_obj, D * args.relation_dim))
augU = cp.Variable(
((T - 1) * n_obj, args.action_dim * args.relation_dim))
for t in range(T - 1):
st_idx = t * n_obj
ed_idx = (t + 1) * n_obj
for r in range(args.relation_dim):
constraints.append(
augG[st_idx:ed_idx, r * D:(r + 1) *
D] == rel_attrs[:, :, r] @ g[st_idx:ed_idx])
for r in range(args.relation_dim):
constraints.append(
augU[st_idx:ed_idx, r * dim_a:(r + 1) *
dim_a] == rel_attrs[:, :, r] @ u[st_idx:ed_idx])
cost = 0
for idx in range(n_obj):
# constrain the initial g
constraints.append(g[idx] == g_cur[idx])
for t in range(1, T):
cur_idx = t * n_obj + idx
prv_idx = (t - 1) * n_obj + idx
zero_normed = -stat[2][:, 0] / stat[2][:, 1]
act_scale_max_normed = (args.act_scale -
stat[2][:, 0]) / stat[2][:, 1]
act_scale_min_normed = (-args.act_scale -
stat[2][:, 0]) / stat[2][:, 1]
constraints.append(u[prv_idx] >= act_scale_min_normed)
constraints.append(u[prv_idx] <= act_scale_max_normed)
if args.env == 'Rope':
if idx == 0:
# first mass: action_y = 0 (no action_y now)
pass
else:
# other mass: action_x = action_y = 0
constraints.append(u[prv_idx][:] == zero_normed)
elif args.env in ['Soft', 'Swim']:
if node_attrs[idx, 0] < 1e-6:
# if there is no actuation
constraints.append(u[prv_idx][:] == zero_normed)
else:
pass
constraints.append(g[cur_idx] == A_t @ augG[prv_idx] +
B_t @ augU[prv_idx])
# penalize large actions
cost += quad_form(u[prv_idx] - zero_normed, R)
cost += quad_form(g[(T - 1) * n_obj + idx] - g_goal[idx], Q)
elif args.fit_type == 'unstructured':
zero_normed = -stat[2][:, 0] / stat[2][:, 1]
g = cp.Variable((T, n_obj * args.g_dim))
u = cp.Variable((T - 1, n_obj * args.action_dim))
cost = 0
constraints.append(g[0] == g_cur.ravel())
for t in range(1, T):
act_scale_normed = (args.act_scale - stat[2][:, 0]) / stat[2][:, 1]
act_scale_normed = np.repeat(act_scale_normed, n_obj, 0)
constraints.append(u[t - 1] >= -act_scale_normed)
constraints.append(u[t - 1] <= act_scale_normed)
if args.env == 'Rope':
# set action on balls to zeros expect the first one
for idx in range(1, n_obj):
constraints.append(u[t - 1][idx] == zero_normed)
elif args.env in ['Soft', 'Swim']:
for idx in range(0, n_obj):
if node_attrs[idx, 0] < 1e-6:
constraints.append(
u[t - 1][idx * args.action_dim:(idx + 1) *
args.action_dim] == zero_normed)
constraints.append(g[t] == A_t @ g[t - 1] + B_t @ u[t - 1])
for i in range(n_obj):
cost += quad_form(
u[t - 1][i * args.action_dim:(i + 1) * args.action_dim] -
zero_normed, R)
for i in range(n_obj):
cost += quad_form(
g[T - 1][i * args.g_dim:(i + 1) * args.g_dim] - g_goal[i], Q)
elif args.fit_type == 'diagonal':
zero_normed = -stat[2][:, 0] / stat[2][:, 1]
g = cp.Variable((T, n_obj * args.g_dim))
u = cp.Variable((T - 1, n_obj * args.action_dim))
cost = 0
constraints.append(g[0] == g_cur.ravel())
for t in range(1, T):
act_scale_normed = (args.act_scale - stat[2][:, 0]) / stat[2][:, 1]
act_scale_normed = np.repeat(act_scale_normed, n_obj, 0)
constraints.append(u[t - 1] >= -act_scale_normed)
constraints.append(u[t - 1] <= act_scale_normed)
if args.env == 'Rope':
# set action on balls to zeros expect the first one
for idx in range(1, n_obj):
constraints.append(u[t - 1][idx] == zero_normed)
elif args.env in ['Soft', 'Swim']:
for idx in range(0, n_obj):
if node_attrs[idx, 0] < 1e-6:
constraints.append(
u[t - 1][idx * args.action_dim:(idx + 1) *
args.action_dim] == zero_normed)
for i in range(n_obj):
t1 = A_t @ g[t - 1][i * args.g_dim:(i + 1) * args.g_dim]
t2 = B_t @ u[t - 1][i * args.action_dim:(i + 1) *
args.action_dim]
if args.env == 'Rope':
t2 = t2[:, 0]
constraints.append(g[t][i * args.g_dim:(i + 1) *
args.g_dim] == t1 + t2)
cost += quad_form(
u[t - 1][i * args.action_dim:(i + 1) * args.action_dim] -
zero_normed, R)
for i in range(n_obj):
cost += quad_form(
g[T - 1][i * args.g_dim:(i + 1) * args.g_dim] - g_goal[i], Q)
objective = cp.Minimize(cost)
prob = cp.Problem(objective, constraints)
result = prob.solve()
u_val = u.value
g_val = g.value
u = u_val.reshape(T - 1, n_obj, args.action_dim)
u = denormalize([u], [stat[2]])[0]
g = g_val.reshape(T, n_obj, D)
return u
def shoot_mpc_qp(roll_idx):
print(f'\n=== Model Based Control on Example {roll_idx} ===')
'''
load data
'''
seq_data = load_data(prepared_names,
os.path.join(data_dir,
str(roll_idx) + '.rollout.h5'))
attrs, states, actions, rel_attrs = [
to_var(d.copy(), use_gpu=use_gpu) for d in seq_data
]
seq_data = denormalize(seq_data, stat)
attrs_gt, states_gt, actions_gt = seq_data[:3]
'''
setup engine
'''
param_file = os.path.join(data_dir,
str(roll_idx // args.group_size) + '.param')
param = torch.load(param_file)
engine.init(param)
n_obj = engine.num_obj
'''
fit koopman
'''
print('===> system identification!')
fit_data = get_more_trajectories(roll_idx)
fit_data = [to_var(d, use_gpu=use_gpu) for d in fit_data]
bs = args.fit_num
attrs_flat = get_flat(fit_data[0])
states_flat = get_flat(fit_data[1])
actions_flat = get_flat(fit_data[2])
rel_attrs_flat = get_flat(fit_data[3])
g = model.to_g(attrs_flat, states_flat, rel_attrs_flat, args.pstep)
g = g.view(torch.Size([bs, args.time_step]) + g.size()[1:])
G_tilde = g[:, :-1]
H_tilde = g[:, 1:]
U_left = fit_data[2][:, :-1]
G_tilde = get_flat(G_tilde, keep_dim=True)
H_tilde = get_flat(H_tilde, keep_dim=True)
U_left = get_flat(U_left, keep_dim=True)
A, B, fit_err = model.system_identify(G=G_tilde,
H=H_tilde,
U=U_left,
rel_attrs=fit_data[3][:1, 0],
I_factor=args.I_factor)
'''
shooting
'''
print('===> model based control start!')
# current can not set engine to a middle state
assert args.roll_start == 0
start_step = args.roll_start
g_start_v = model.to_g(attrs=attrs[start_step:start_step + 1],
states=states[start_step:start_step + 1],
rel_attrs=rel_attrs[start_step:start_step + 1],
pstep=args.pstep)
g_start = to_np(g_start_v[0])
if args.env == 'Rope':
goal_step = args.roll_step + args.roll_start
elif args.env == 'Soft':
goal_step = args.roll_step + args.roll_start
elif args.env == 'Swim':
goal_step = args.roll_step + args.roll_start
g_goal_v = model.to_g(attrs=attrs[goal_step:goal_step + 1],
states=states[goal_step:goal_step + 1],
rel_attrs=rel_attrs[goal_step:goal_step + 1],
pstep=args.pstep)
g_goal = to_np(g_goal_v[0])
states_start = states_gt[start_step]
states_goal = states_gt[goal_step]
states_roll = np.zeros((args.roll_step + 1, n_obj, args.state_dim))
states_roll[0] = states_start
control = np.zeros((args.roll_step + 1, n_obj, args.action_dim))
# control_v = to_var(control, use_gpu, requires_grad=True)
bar = ProgressBar()
for step in bar(range(args.roll_step)):
states_input = normalize([states_roll[step:step + 1]], [stat[1]])[0]
states_input_v = to_var(states_input, use_gpu=use_gpu)
g_cur_v = model.to_g(attrs=attrs[:1],
states=states_input_v,
rel_attrs=rel_attrs[:1],
pstep=args.pstep)
g_cur = to_np(g_cur_v[0])
'''
setup parameters
'''
T = args.roll_step - step + 1
A_v, B_v = model.A, model.B
A_t = to_np(A_v[0]).T
B_t = to_np(B_v[0]).T
if not args.baseline:
Q = np.eye(args.g_dim)
else:
Q = np.eye(g_goal.shape[-1])
if args.env == 'Rope':
R_factor = 0.01
elif args.env == 'Soft':
R_factor = 0.001
elif args.env == 'Swim':
R_factor = 0.0001
else:
assert False
R = np.eye(args.action_dim) * R_factor
'''
generate action
'''
rel_attrs_np = to_np(rel_attrs)[0]
assert args.optim_type == 'qp'
if step % args.feedback == 0:
node_attrs = attrs_gt[0] if args.env in ['Soft', 'Swim'] else None
u = mpc_qp(g_cur,
g_goal,
step,
T,
rel_attrs_np,
A_t,
B_t,
Q,
R,
node_attrs=node_attrs,
actions=to_np(actions[step:]),
gt_info=[
param, states_gt[goal_step:goal_step + 1],
attrs[step:step + T], rel_attrs[step:step + T]
])
else:
u = u[1:]
pass
'''
execute action
'''
engine.set_action(u[0]) # execute the first action
control[step] = engine.get_action()
engine.step()
states_roll[step + 1] = engine.get_state()
'''
render
'''
engine.render(states_roll,
control,
param,
act_scale=args.act_scale,
video=True,
image=True,
path=os.path.join(args.shootf,
str(roll_idx) + '.shoot'),
states_gt=np.tile(states_gt[goal_step:goal_step + 1],
(args.roll_step + 1, 1, 1)),
count_down=True,
gt_border=True)
states_result = states_roll[args.roll_step]
states_goal_normalized = normalize([states_goal], [stat[1]])[0]
states_result_normalized = normalize([states_result], [stat[1]])[0]
return norm(states_goal - states_result), (states_goal, states_result,
states_goal_normalized,
states_result_normalized)
def predict(model, input, labels, meta):
if RP['edge_prediction']:
partitioner = PermutationPartitioner(
len(input[0]),
len(input[0]) / RP['num_partitions'])
else:
partitioner = PermutationPartitioner(len(input),
len(input) / RP['num_partitions'])
iterations = RP['num_partitions']**2
metrics = {
'r2': np.zeros((labels.shape[1], iterations)),
'mse': np.zeros((labels.shape[1], iterations)),
'mae': np.zeros((labels.shape[1], iterations)),
}
# first denormalize labels, so we do it only once
labels = data.denormalize(labels, meta)
for iteration in range(iterations):
print('\titer:\t{}/{}'.format(iteration + 1, iterations))
part = partitioner.get()
if RP['edge_prediction']:
partIn = [input[0][part], input[1][part]]
else:
partIn = input[part]
partLabelsT = labels[part].T
partPredT = model.predict(partIn, batch_size=RP['batch']).T
for i in range(labels.shape[1]):
metrics['r2'][i][iteration] = computeR2(partPredT[i],
partLabelsT[i])
metrics['mse'][i][iteration] = computeMSE(partPredT[i],
partLabelsT[i])
metrics['mae'][i][iteration] = computeMAE(partPredT[i],
partLabelsT[i])
del partIn
del partLabelsT
del partPredT
metricsPerLabel = {
'r2_avg': np.nanmean(metrics['r2'], axis=1),
'r2_std': np.nanstd(metrics['r2'], axis=1),
'mse_avg': np.nanmean(metrics['mse'], axis=1),
'mse_std': np.nanstd(metrics['mse'], axis=1),
'mae_avg': np.nanmean(metrics['mae'], axis=1),
'mae_std': np.nanstd(metrics['mae'], axis=1),
}
metricsOverall = {
'r2_avg': np.nanmean(metrics['r2']),
'r2_std': np.nanstd(metrics['r2']),
'mse_avg': np.nanmean(metrics['mse']),
'mse_std': np.nanstd(metrics['mse']),
'mae_avg': np.nanmean(metrics['mae']),
'mae_std': np.nanstd(metrics['mae']),
}
for i, labelName in enumerate(RD['labels']):
print('{}/{} - {}:'.format(i + 1, len(RD['labels']), labelName))
print('\tR2:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsPerLabel['r2_avg'][i], metricsPerLabel['r2_std'][i]))
print('\tMSE:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsPerLabel['mse_avg'][i], metricsPerLabel['mse_std'][i]))
print('\tMAE:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsPerLabel['mae_avg'][i], metricsPerLabel['mae_std'][i]))
print('Overall metrics:')
print('\tR2:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['r2_avg'],
metricsOverall['r2_std']))
print('\tMSE:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['mse_avg'],
metricsOverall['mse_std']))
print('\tMAE:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['mae_avg'],
metricsOverall['mae_std']))
return metricsOverall
def discreteClassify(model, input, labels, meta):
partitioner = PermutationPartitioner(len(input),
len(input) / RP['num_partitions'])
iterations = RP['num_partitions']**2
metrics = {
'acc': np.zeros((iterations)),
'log_loss': np.zeros((iterations)),
# 'auc': np.zeros((iterations)),
# 'auc_micro': np.zeros((iterations))
}
# first denormalize labels, so we do it only once
labels = data.denormalize(labels, meta)
for iteration in range(iterations):
# print('\titer:\t{}/{}'.format(iteration, iterations))
part = partitioner.get()
partIn = input[part]
partLabels = labels[part]
partPred = model.predict(partIn, batch_size=RP['batch'])
binarizedPred = np.zeros((len(partPred), len(partPred[0])))
"""
for row in range(len(partLabels)):
for idx, val in enumerate(partLabels[row]):
if val == 1:
sys.stdout.write('{}, '.format(idx))
for val in partPred[row]:
sys.stdout.write('{}, '.format(val))
sys.stdout.write('\n')
sys.stdout.flush()
"""
for i in range(len(partPred)):
maxValue = 0
maxIndex = 0
for index in range(len(partPred[i])):
value = partPred[i][index]
if value > maxValue:
maxValue = value
maxIndex = index
binarizedPred[i][maxIndex] = 1
metrics['acc'][iteration] = sk.metrics.accuracy_score(
partLabels, binarizedPred)
metrics['log_loss'][iteration] = sk.metrics.log_loss(
partLabels, binarizedPred)
'''
keepVec = []
for col in range(len(partLabels[0])):
wasOne = 0
for row in range(len(partLabels)):
if partLabels[row][col] == 1:
wasOne = 1
break
if wasOne:
keepVec.append(col)
cutLabels = np.zeros((len(partLabels), len(keepVec)))
cutPreds = np.zeros((len(partLabels), len(keepVec)))
for idx, keep in enumerate(keepVec):
for row in range(len(partLabels)):
cutLabels[row][idx] = partLabels[row][keep]
cutPreds[row][idx] = binarizedPred[row][keep]
metrics['auc'][iteration] = sk.metrics.roc_auc_score(cutLabels,
cutPreds, average = 'macro')
metrics['auc_micro'][iteration] = sk.metrics.roc_auc_score(cutLabels,
cutPreds, average = 'micro')
'''
metricsOverall = {
'acc_avg': np.nanmean(metrics['acc']),
'acc_std': np.nanstd(metrics['acc']),
'log_loss_avg': np.nanmean(metrics['log_loss']),
'log_loss_std': np.nanstd(metrics['log_loss']),
# 'auc_avg': np.nanmean(metrics['auc']),
# 'auc_std': np.nanstd(metrics['auc']),
# 'auc_micro_avg': np.nanmean(metrics['auc_micro']),
# 'auc_micro_std': np.nanstd(metrics['auc_micro'])
'auc_avg': None,
'auc_std': None,
'auc_micro_avg': None,
'auc_micro_std': None,
}
print('Overall metrics:')
print('\tACC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['acc_avg'],
metricsOverall['acc_std']))
print('\tLogLos:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsOverall['log_loss_avg'], metricsOverall['log_loss_std']))
# print('\tAUC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['auc_avg'],metricsOverall['auc_std']))
# print('\tAUC Micro:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['auc_micro_avg'],metricsOverall['auc_micro_std']))
return metricsOverall
def classify(model, input, labels, meta):
if RP['edge_prediction']:
partitioner = PermutationPartitioner(
len(input[0]),
len(input[0]) / RP['num_partitions'])
else:
partitioner = PermutationPartitioner(len(input),
len(input) / RP['num_partitions'])
iterations = RP['num_partitions']**2
metrics = {
'acc': np.zeros((labels.shape[1], iterations)),
'log_loss': np.zeros((labels.shape[1], iterations)),
'auc': np.zeros((labels.shape[1], iterations)),
'confusion': np.zeros((labels.shape[1], iterations, 2, 2)),
}
# first denormalize labels, so we do it only once
labels = data.denormalize(labels, meta)
for iteration in range(iterations):
print('\titer:\t{}/{}'.format(iteration, iterations))
part = partitioner.get()
if RP['edge_prediction']:
partIn = [input[0][part], input[1][part]]
else:
partIn = input[part]
partLabelsT = labels[part].T
partPredT = model.predict(partIn, batch_size=RP['batch']).T
for i in range(labels.shape[1]):
confusion = computeConfusion(partPredT[i], partLabelsT[i])
metrics['confusion'][i][iteration] = confusion
metrics['acc'][i][iteration] = (confusion[0][0] +
confusion[1][1]) / confusion.sum()
metrics['log_loss'][i][iteration] = utility.logloss(
partPredT[i], partLabelsT[i], RP['classify_label_neg'],
RP['classify_label_pos'])
metrics['auc'][i][iteration] = computeAUC(partPredT[i],
partLabelsT[i])
del partIn
del partLabelsT
del partPredT
metricsPerLabel = {
'acc_avg': np.nanmean(metrics['acc'], axis=1),
'acc_std': np.nanstd(metrics['acc'], axis=1),
'log_loss_avg': np.nanmean(metrics['log_loss'], axis=1),
'log_loss_std': np.nanstd(metrics['log_loss'], axis=1),
'auc_avg': np.nanmean(metrics['auc'], axis=1),
'auc_std': np.nanstd(metrics['auc'], axis=1)
}
metricsOverall = {
'acc_avg': np.nanmean(metrics['acc']),
'acc_std': np.nanstd(metrics['acc']),
'log_loss_avg': np.nanmean(metrics['log_loss']),
'log_loss_std': np.nanstd(metrics['log_loss']),
'auc_avg': np.nanmean(metrics['auc']),
'auc_std': np.nanstd(metrics['auc'])
}
for i, labelName in enumerate(RD['labels']):
print('{}/{} - {}:'.format(i + 1, len(RD['labels']), labelName))
print('\tACC:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsPerLabel['acc_avg'][i], metricsPerLabel['acc_std'][i]))
print('\tLogLos:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsPerLabel['log_loss_avg'][i],
metricsPerLabel['log_loss_std'][i]))
print('\tAUC:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsPerLabel['auc_avg'][i], metricsPerLabel['auc_std'][i]))
print('Overall metrics:')
print('\tACC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['acc_avg'],
metricsOverall['acc_std']))
print('\tLogLos:\t{0:.3f}\t+/-\t{1:.3f}'.format(
metricsOverall['log_loss_avg'], metricsOverall['log_loss_std']))
print('\tAUC:\t{0:.3f}\t+/-\t{1:.3f}'.format(metricsOverall['auc_avg'],
metricsOverall['auc_std']))
return metricsOverall
attr, state, Rr, Rs, Ra, n_particles,
node_r_idx, node_s_idx, pstep,
instance_idx, phases_dict, args.verbose_model)
# print('Time forward', time.time() - st_time)
# print(vels)
if args.debug:
data_nxt_path = os.path.join(args.dataf, 'valid', str(infos[idx]), str(step + 1) + '.h5')
data_nxt = normalize(load_data(data_names, data_nxt_path), stat)
label = Variable(torch.FloatTensor(data_nxt[1][:n_particles]).cuda())
# print(label)
loss = np.sqrt(criterionMSE(vels, label).item())
print(loss)
vels = denormalize([vels.data.cpu().numpy()], [stat[1]])[0]
if args.env == 'RiceGrip' or args.env == 'FluidShake':
vels = np.concatenate([vels, v_nxt_gt[step, n_particles:]], 0)
data[0] = data[0] + vels * args.dt
if args.env == 'RiceGrip':
# shifting the history
# positions, restPositions
data[1][:, args.position_dim:] = data[1][:, :-args.position_dim]
data[1][:, :args.position_dim] = vels
if args.debug:
data[0] = p_gt[step + 1].copy()
data[1][:, :args.position_dim] = v_nxt_gt[step]
