def Evaluate_Result(homedir='.',
tProb_=None,
lag_time=1,
microstate_mapping_=None,
MacroAssignments_=None,
name=None):
MacroMSM = MarkovStateModel(lag_time=lag_time)
MacroMSM.fit(MacroAssignments_)
Macro_tProb_ = MacroMSM.tProb_
Macro_tCount_ = MacroMSM.tCount_
#plot_matrix(labels=None, tProb_=tProb_, name=name)
#Calculate metastablilty
print "Calculating Metastablilty and Modularity..."
metastability = Macro_tProb_.diagonal().sum()
metastability /= len(Macro_tProb_)
print "Metastability:", metastability
#Calculate modularity
micro_tProb_ = tProb_
degree = micro_tProb_.sum(axis=1) #row sum of tProb_ matrix
total_degree = degree.sum()
modularity = 0.0
len_mapping = len(microstate_mapping_)
for i in xrange(len_mapping):
state_i = microstate_mapping_[i]
for j in xrange(len_mapping):
state_j = microstate_mapping_[j]
if state_i == state_j:
modularity += micro_tProb_[
i, j] - degree[i] * degree[j] / total_degree
modularity /= total_degree
print "Modularity:", modularity
Macro_tCountDir = homedir + "/" + name + "Macro_tCounts.mtx"
Macro_tProbDir = homedir + "/" + name + "Macro_tProb.mtx"
Metastability_Modularity_Dir = homedir + "/" + name + "Metastability_Modularity.txt"
np.savetxt(Metastability_Modularity_Dir, [metastability, modularity],
fmt="%lf")
scipy.io.mmwrite(Macro_tCountDir,
scipy.sparse.csr_matrix(Macro_tCount_),
field='integer')
scipy.io.mmwrite(Macro_tProbDir, scipy.sparse.csr_matrix(Macro_tProb_))
#Plot tProb matrix
plot_matrix(tProb_=Macro_tProb_, name=name)
def execute_line(self, bql_string, pretty=True, timing=False, plots=None):
if timing:
start_time = time.time()
out = self.parser.parse_line(bql_string)
if out is None:
print "Could not parse command. Try typing 'help' for a list of all commands."
return
elif not out:
return
method_name, args_dict = out
result = self.call_bayesdb_engine(method_name, args_dict)
result = self.callback(method_name, args_dict, result)
if timing:
end_time = time.time()
print 'Elapsed time: %.2f seconds.' % (end_time - start_time)
if plots is None:
plots = 'DISPLAY' in os.environ.keys()
if bql_string.lower().strip().startswith('estimate'):
## Special logic to display matrices.
if not (result['filename'] or plots):
print "No GUI available to display graphics: please enter the filename where the graphics should be saved, with the extension indicating the filetype (e.g. .png or .pdf). Enter a blank filename to instead view the matrix as text."
filename = raw_input()
if len(filename) > 0:
result['filename'] = filename
utils.plot_matrix(result['matrix'], result['column_names'], title=result['title'], filename=result['filename'])
else:
pp = self.pretty_print(result)
print pp
return pp
else:
utils.plot_matrix(result['matrix'], result['column_names'], title=result['message'], filename=result['filename'])
elif pretty:
if type(result) == dict and 'message' in result.keys():
print result['message']
pp = self.pretty_print(result)
print pp
return pp
else:
if type(result) == dict and 'message' in result.keys():
print result['message']
return result
def evaluate_performance(self,
path_scores_parameters=None,
path_scores_cm=None):
test_set_desc = np.asarray([
self.desc_relevant_config_videos[i].flatten()
for i in self.test_video_idx
])
test_set_vas = np.asarray(
[self.vas_sequences[i] for i in self.test_video_idx])
num_test_videos = test_set_desc.shape[0]
sum_error = 0
confusion_matrix = np.zeros(shape=(11, 11))
real__vas = []
predicted__vas = []
if path_scores_parameters is not None:
out_df_scores = pd.DataFrame(
columns=['sequence_num', 'real_vas', 'vas_predicted', 'error'])
for num_video in np.arange(num_test_videos):
real_vas = test_set_vas[num_video]
real__vas.append(real_vas)
vas_predicted = self.__predict(test_set_desc[num_video].reshape(
1, -1))
predicted__vas.append(vas_predicted)
error = abs(real_vas - vas_predicted)
sum_error += error
if path_scores_parameters is not None:
data = np.hstack((np.array([
self.test_video_idx[num_video], real_vas, vas_predicted,
error
]).reshape(1, -1)))
out_df_scores = out_df_scores.append(pd.Series(
data.reshape(-1), index=out_df_scores.columns),
ignore_index=True)
confusion_matrix[real_vas][vas_predicted] += 1
if path_scores_parameters is not None:
out_df_scores.to_csv(path_scores_parameters,
index=False,
header=True)
if path_scores_cm is not None:
plot_matrix(cm=confusion_matrix,
labels=np.arange(0, 11),
normalize=True,
fname=path_scores_cm)
mean_error = round(sum_error / num_test_videos, 3)
return mean_error, confusion_matrix
def _show(self, data, output, train=True):
self.writer.add_image(
'a-input',
make_grid(data[0].cpu(), nrow=data.shape[1], normalize=True))
self.writer.add_image(
'b-output_rec',
make_grid(output["rec"][0].cpu(),
nrow=output["rec"].shape[1],
normalize=True))
self.writer.add_image(
'c-output_pred',
make_grid(output["pred"][0].cpu(),
nrow=output["pred"].shape[1],
normalize=True))
if output["selector"] is not None:
S_plot = plot_matrix(output["selector"])
self.writer.add_image('ba-S',
make_grid(S_plot, nrow=1, normalize=False))
if output["obs_rec_pred"] is not None:
g_plot = plot_representation(
output["obs_rec_pred"][:, :output["rec"].shape[1]].cpu())
g_plot_pred = plot_representation(
output["obs_rec_pred"][:, output["rec"].shape[1]:].cpu())
self.writer.add_image(
'd-g_repr_rec',
make_grid(to_tensor(g_plot), nrow=1, normalize=False))
self.writer.add_image(
'e-g_repr_pred',
make_grid(to_tensor(g_plot_pred), nrow=1, normalize=False))
if output["A"] is not None:
A_plot = plot_matrix(output["A"])
self.writer.add_image('f-A',
make_grid(A_plot, nrow=1, normalize=False))
if output["B"] is not None:
B_plot = plot_matrix(output["B"])
self.writer.add_image('g-B',
make_grid(B_plot, nrow=1, normalize=False))
if output["u"] is not None:
u_plot = plot_representation(
output["u"][:, :output["u"].shape[1]].cpu())
self.writer.add_image(
'e-gu', make_grid(to_tensor(u_plot), nrow=1, normalize=False))
def reconstruct_correspondence_matrix(data, cost_func, alphas, betas):
best_matrix = None
reconstruction_errors = np.zeros((len(alphas), len(betas)))
min_reconstruction_error = np.inf
best_alpha, best_beta = np.nan, np.nan
for alpha_idx in range(len(alphas)):
for beta_idx in range(len(betas)):
reconstructed_correspondence_matrix = (
cmr.CorrespondenceMatrixReconstructor(
C=1.0, max_iters=10000, stopping_eps=10**(-4)).fit(
cost_matrix=np.nan_to_num(cost_func(
alpha=alphas[alpha_idx],
beta=betas[beta_idx],
time=data.cost_matrix_time,
distance=data.cost_matrix_distance),
nan=np.inf),
living_people=np.nansum(data.correspondence_matrix,
axis=1),
working_people=np.nansum(data.correspondence_matrix,
axis=0)).predict())
reconstruction_error = np.linalg.norm(
reconstructed_correspondence_matrix -
np.nan_to_num(data.correspondence_matrix, nan=0.0))
reconstruction_errors[alpha_idx, beta_idx] = reconstruction_error
if reconstruction_error < min_reconstruction_error:
min_reconstruction_error = reconstruction_error
best_alpha, best_beta = alphas[alpha_idx], betas[beta_idx]
best_matrix = reconstructed_correspondence_matrix
print('alpha =', alphas[alpha_idx], 'beta =', betas[beta_idx],
'reconstruction error =', reconstruction_error)
print('\nOptimization has finished.\n')
print('reconstruction_errors =\n', reconstruction_errors, '\n')
print('min_reconstruction_error =', min_reconstruction_error)
utils.plot_matrix(matrix=reconstruction_errors,
plot_name='reconstruction_errors_' + cost_func.__name__,
annot=False,
linewidths=0,
xticklabels=np.round(betas, 2),
yticklabels=np.round(alphas, 2),
xlabel='beta',
ylabel='alpha')
return best_matrix, best_alpha, best_beta
def main():
data = get_traffic_data()
plot_traffic_data(data)
print('Data have been found. Running optimization...\n')
cost_func = cost_function.compute_cost3
reconstructed_correspondence_matrix, best_alpha, best_beta = (
reconstruct_correspondence_matrix(data=data,
cost_func=cost_func,
alphas=0.001 * np.arange(1, 501, 1),
betas=0.001 * np.arange(1, 4, 1)))
utils.plot_matrix(matrix=reconstructed_correspondence_matrix,
plot_name='reconstructed_correspondence_matrix_' +
cost_func.__name__,
annot=True,
linewidths=0.5)
print('best_alpha =', best_alpha, 'best_beta =', best_beta)
print('\nDone.')
def _show(self, data, output, train=True):
g_plot = plot_representation(output[2][:,:output[0].shape[1]].cpu())
g_plot_pred = plot_representation(output[2][:,output[0].shape[1]:].cpu())
A_plot = plot_matrix(output[4])
if output[5] is not None:
B_plot = plot_matrix(output[5])
self.writer.add_image('B', make_grid(B_plot, nrow=1, normalize=False))
if output[6] is not None:
u_plot = plot_representation(output[6][:, :output[6].shape[1]].cpu())
self.writer.add_image('u', make_grid(to_tensor(u_plot), nrow=1, normalize=False))
# if output[10] is not None: # TODO: Ara el torno a posar
# # print(output[10][0].max(), output[-1][0].min())
# shape = output[10][0].shape
# self.writer.add_image('objects', make_grid(output[10][0].permute(1, 2, 0, 3, 4).reshape(*shape[1:-2], -1, shape[-1]).cpu(), nrow=output[0].shape[1], normalize=True))
self.writer.add_image('A', make_grid(A_plot, nrow=1, normalize=False))
self.writer.add_image('g_repr', make_grid(to_tensor(g_plot), nrow=1, normalize=False))
self.writer.add_image('g_repr_pred', make_grid(to_tensor(g_plot_pred), nrow=1, normalize=False))
self.writer.add_image('input', make_grid(data[0].cpu(), nrow=data.shape[1], normalize=True))
self.writer.add_image('output_0rec', make_grid(output[0][0].cpu(), nrow=output[0].shape[1], normalize=True))
self.writer.add_image('output_1pred', make_grid(output[1][0].cpu(), nrow=output[1].shape[1], normalize=True))
def Evaluate_Result(homedir='.', tProb_=None, lag_time=1, microstate_mapping_=None, MacroAssignments_=None, name=None):
MacroMSM = MarkovStateModel(lag_time=lag_time)
MacroMSM.fit(MacroAssignments_)
Macro_tProb_ = MacroMSM.tProb_
Macro_tCount_ = MacroMSM.tCount_
#plot_matrix(labels=None, tProb_=tProb_, name=name)
#Calculate metastablilty
print "Calculating Metastablilty and Modularity..."
metastability = Macro_tProb_.diagonal().sum()
metastability /= len(Macro_tProb_)
print "Metastability:", metastability
#Calculate modularity
micro_tProb_ = tProb_
degree = micro_tProb_.sum(axis=1) #row sum of tProb_ matrix
total_degree = degree.sum()
modularity = 0.0
len_mapping = len(microstate_mapping_)
for i in xrange(len_mapping):
state_i = microstate_mapping_[i]
for j in xrange(len_mapping):
state_j = microstate_mapping_[j]
if state_i == state_j:
modularity += micro_tProb_[i, j] - degree[i]*degree[j]/total_degree
modularity /= total_degree
print "Modularity:", modularity
Macro_tCountDir = homedir + "/" + name + "Macro_tCounts.mtx"
Macro_tProbDir = homedir + "/" + name + "Macro_tProb.mtx"
Metastability_Modularity_Dir = homedir + "/" + name + "Metastability_Modularity.txt"
np.savetxt(Metastability_Modularity_Dir, [metastability, modularity], fmt="%lf")
scipy.io.mmwrite(Macro_tCountDir, scipy.sparse.csr_matrix(Macro_tCount_), field='integer')
scipy.io.mmwrite(Macro_tProbDir, scipy.sparse.csr_matrix(Macro_tProb_))
#Plot tProb matrix
plot_matrix(tProb_=Macro_tProb_, name=name)
def evaluate_performance_on_scaled_pain(self, path_scores_cm=None):
test_set_desc = np.asarray([
self.desc_relevant_config_videos[i].flatten()
for i in self.test_video_idx
])
test_set_vas = np.asarray(
[self.vas_sequences[i] for i in self.test_video_idx])
num_test_videos = test_set_desc.shape[0]
confusion_matrix = np.zeros(shape=(3, 3))
dict_pain_level = {
0: 0,
1: 1,
2: 1,
3: 1,
4: 2,
5: 2,
6: 2,
7: 2,
8: 2,
9: 2,
10: 2
}
labels_cm = ["no pain", "weak pain", "severe pain"]
for num_video in np.arange(num_test_videos):
real_vas = test_set_vas[num_video]
real_level_idx = dict_pain_level[real_vas]
vas_predicted = self.__predict(test_set_desc[num_video].reshape(
1, -1))
predicted_level_idx = dict_pain_level[vas_predicted]
confusion_matrix[real_level_idx][predicted_level_idx] += 1
if path_scores_cm is not None:
plot_matrix(cm=confusion_matrix,
labels=labels_cm,
normalize=True,
fname=path_scores_cm)
return confusion_matrix
def plot_traffic_data(data):
utils.plot_matrix(matrix=data.correspondence_matrix,
plot_name='correspondence_matrix',
annot=True,
linewidths=0.5)
utils.plot_matrix(matrix=data.cost_matrix_time,
plot_name='cost_matrix_time',
annot=True,
linewidths=0.5)
utils.plot_matrix(matrix=data.cost_matrix_distance,
plot_name='cost_matrix_distance',
annot=True,
linewidths=0.5)
def _do_gen_matrix(self,
col_function_name,
X_L_list,
X_D_list,
M_c,
T,
tablename='',
filename=None,
col=None,
confidence=None,
limit=None,
submatrix=False):
if col_function_name == 'mutual information':
col_function = getattr(self, '_mutual_information')
elif col_function_name == 'dependence probability':
col_function = getattr(self, '_dependence_probability')
elif col_function_name == 'correlation':
col_function = getattr(self, '_correlation')
elif col_function_name == 'view_similarity':
col_function = getattr(self, '_view_similarity')
else:
raise Exception('Invalid column function')
num_cols = len(X_L_list[0]['column_partition']['assignments'])
column_names = [
M_c['idx_to_name'][str(idx)] for idx in range(num_cols)
]
column_names = numpy.array(column_names)
# extract unordered z_matrix
num_latent_states = len(X_L_list)
z_matrix = numpy.zeros((num_cols, num_cols))
for i in range(num_cols):
for j in range(num_cols):
z_matrix[i][j] = col_function(i, j, X_L_list, X_D_list, M_c, T)
if col:
z_column = list(z_matrix[M_c['name_to_idx'][col]])
data_tuples = zip(z_column, range(num_cols))
data_tuples.sort(reverse=True)
if confidence:
data_tuples = filter(lambda tup: tup[0] >= float(confidence),
data_tuples)
if limit and limit != float("inf"):
data_tuples = data_tuples[:int(limit)]
data = [tuple([d[0] for d in data_tuples])]
columns = [d[1] for d in data_tuples]
column_names = [
M_c['idx_to_name'][str(idx)] for idx in range(num_cols)
]
column_names = numpy.array(column_names)
column_names_reordered = column_names[columns]
if submatrix:
z_matrix = z_matrix[columns, :][:, columns]
z_matrix_reordered = z_matrix
else:
return {'data': data, 'columns': column_names_reordered}
else:
# hierachically cluster z_matrix
import hcluster
Y = hcluster.pdist(z_matrix)
Z = hcluster.linkage(Y)
pylab.figure()
hcluster.dendrogram(Z)
intify = lambda x: int(x.get_text())
reorder_indices = map(intify, pylab.gca().get_xticklabels())
pylab.close()
# REORDER!
z_matrix_reordered = z_matrix[:,
reorder_indices][reorder_indices, :]
column_names_reordered = column_names[reorder_indices]
title = 'Pairwise column %s for %s' % (col_function_name, tablename)
if filename:
utils.plot_matrix(z_matrix_reordered, column_names_reordered,
title, filename)
return dict(matrix=z_matrix_reordered,
column_names=column_names_reordered,
title=title,
filename=filename,
message="Created " + title)
X_scaler = StandardScaler() X_scaled = X_scaler.fit_transform(X) X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.25) etc_3 = ExtraTreesClassifier(max_features=0.42, n_estimators=ESTIMATORS, n_jobs=-1) """Classification Report & Confusion Matrix""" etc_3.fit(X_train, y_train) y_pred_etc_3 = etc_3.predict(X_test) print "[Classification Report]" print classification_report(y_test, y_pred_etc_3) print "[Train dataset] Score: %.5f" % etc_3.score(X_train, y_train) print "[Test dataset] Score: %.5f" % etc_3.score(X_test, y_test) plot_matrix(etc_3, X_test, y_test, filename) """Plot ROC Curve""" y_score = etc_3.predict_proba(X_test) y_test_bin = np.array(label_binarize(y_test, classes=np.unique(y))) n_classes = y_test_bin.shape[1] plot_roc_curve(n_classes, y_test_bin, y_score, filename) """Plot Decision Area""" clf = ExtraTreesClassifier(n_estimators=ESTIMATORS, max_features=0.42, n_jobs=-1) plot_decision_area(clf, X_scaled[:, 2:4], y, title="Extra Trees Classifier", filename=filename) """Plot Learning Curve""" X_lc = X_scaled[:10000] y_lc = y[:10000] plot_learning_curve(clf, "Extra Trees Classifier", X_lc, y_lc, filename=filename)
"""Testing A Simple Prediction"""
#print("Feature vector: %s" % X_test[:1])
print("Label: %s" % str(y_test[0]))
print("Predicted: %s" % str(net0.predict(X_test[:1])))
"""Metrics"""
# layer_info = PrintLayerInfo()
# net0.verbose = 3
# net0.initialize()
#print layer_info(net0)
print "[Classification Report]: "
print classification_report(y_test, predicted)
print "[Train dataset] Score: ", net0.score(X_train, y_train)
print "[Test dataset] Score: ", net0.score(X_test, y_test)
plot_matrix(net0, X_test, y_test, filename)
valid_accuracies = np.array([i["valid_accuracy"] for i in net0.train_history_])
plot_accuracy(valid_accuracies, filename)
train_loss = [row['train_loss'] for row in net0.train_history_]
valid_loss = [row['valid_loss'] for row in net0.train_history_]
plot_loss(valid_loss, train_loss, filename)
y_score = net0.predict_proba(X_test) #[:, 1]
y_test_bin = np.array(label_binarize(y_test, classes=np.unique(y)))
n_classes = y_test_bin.shape[1]
plot_roc_curve(n_classes, y_test_bin, y_score, filename=filename)
def visualise_feature_matrix(self):
utils.plot_matrix(self.feature_matrix)
net0 = NeuralNetConstructor(93)
net0.fit(X_train, y_train)
predicted = net0.predict(X_test)
"""Testing A Simple Prediction"""
#print("Feature vector: %s" % X_test[:1])
print("Label: %s" % str(y_test[0]))
print("Predicted: %s" % str(net0.predict(X_test[:1])))
"""Metrics"""
# layer_info = PrintLayerInfo()
# net0.verbose = 3
# net0.initialize()
#print layer_info(net0)
print "[Classification Report]: "
print classification_report(y_test, predicted)
print "[Train dataset] Score: ", net0.score(X_train, y_train)
print "[Test dataset] Score: ", net0.score(X_test, y_test)
plot_matrix(net0, X_test, y_test, filename)
valid_accuracies = np.array([i["valid_accuracy"] for i in net0.train_history_])
plot_accuracy(valid_accuracies, filename)
train_loss = [row['train_loss'] for row in net0.train_history_]
valid_loss = [row['valid_loss'] for row in net0.train_history_]
plot_loss(valid_loss, train_loss, filename)
y_score = net0.predict_proba(X_test) #[:, 1]
y_test_bin = np.array(label_binarize(y_test, classes=np.unique(y)))
n_classes = y_test_bin.shape[1]
plot_roc_curve(n_classes, y_test_bin, y_score, filename=filename)
X_scaled = X_scaler.fit_transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=.25)
etc_3 = ExtraTreesClassifier(max_features=0.42,
n_estimators=ESTIMATORS,
n_jobs=-1)
"""Classification Report & Confusion Matrix"""
etc_3.fit(X_train, y_train)
y_pred_etc_3 = etc_3.predict(X_test)
print "[Classification Report]"
print classification_report(y_test, y_pred_etc_3)
print "[Train dataset] Score: %.5f" % etc_3.score(X_train, y_train)
print "[Test dataset] Score: %.5f" % etc_3.score(X_test, y_test)
plot_matrix(etc_3, X_test, y_test, filename)
"""Plot ROC Curve"""
y_score = etc_3.predict_proba(X_test)
y_test_bin = np.array(label_binarize(y_test, classes=np.unique(y)))
n_classes = y_test_bin.shape[1]
plot_roc_curve(n_classes, y_test_bin, y_score, filename)
"""Plot Decision Area"""
clf = ExtraTreesClassifier(n_estimators=ESTIMATORS,
max_features=0.42,
n_jobs=-1)
plot_decision_area(clf,
X_scaled[:, 2:4],
y,
title="Extra Trees Classifier",
filename=filename)
"""Plot Learning Curve"""
def _show(self, data, output, train=True):
rec = output["rec_ori"]
if output["pred_roll"] is not None:
data_plot = data[0, -output["pred_roll"].shape[1]:]
rec_plot = output["rec_ori"][0, -output["pred_roll"].shape[1]:]
pred_plot = output["pred_roll"][0]
vid_plot = torch.cat([data_plot, rec_plot, pred_plot], dim=0)
nrow = output["pred_roll"].shape[1]
else:
vid_plot = torch.cat([data[0, -output["rec_ori"].shape[1]:], output["rec_ori"][0, :]], dim=0)
nrow = output["rec_ori"].shape[1]
self.writer.add_image('a-Videos--Input-Rec-Pred', make_grid(vid_plot.cpu(), nrow=nrow, normalize=True))
# self.writer.add_image('a-input', make_grid(data[0].cpu(), nrow=data.shape[1], normalize=True))
# self.writer.add_image('b-output_rec', make_grid(output["rec"][0, -output["pred"].shape[1]:].cpu(), nrow=output["pred"].shape[1], normalize=True))
# # self.writer.add_image('b-output_rec_ori', make_grid(output["rec_ori"][0, -output["pred"].shape[1]:].cpu(), nrow=output["pred"].shape[1], normalize=True))
# self.writer.add_image('c-output_pred', make_grid(output["pred"][0].cpu(), nrow=output["pred"].shape[1], normalize=True))
# if output["selector"] is not None:
# S_plot = plot_matrix(output["selector"])
# self.writer.add_image('ba-S', make_grid(S_plot, nrow=1, normalize=False))
if output["obs_rec_pred"] is not None:
if output["pred"] is not None:
g_plot = plot_representation (output["obs_rec_pred"][:,rec.shape[1]-output["pred"].shape[1]:rec.shape[1]].cpu())
g_plot_pred = plot_representation (output["obs_rec_pred"][:,rec.shape[1]:].cpu())
self.writer.add_image('e-g_repr_pred', make_grid(to_tensor(g_plot_pred), nrow=1, normalize=False))
else: g_plot = plot_representation (output["obs_rec_pred"].cpu())
self.writer.add_image('d-g_repr_rec', make_grid(to_tensor(g_plot), nrow=1, normalize=False))
if output["obs_rec_pred_rev"] is not None:
g_plot = plot_representation (output["obs_rec_pred_rev"].cpu())
self.writer.add_image('ea-g_repr_pred_rev', make_grid(to_tensor(g_plot), nrow=1, normalize=False))
if output["dyn_features"] is not None:
# g_plot = plot_representation (output["dyn_features"]["rec_ori"].cpu())
# self.writer.add_image('states_rec_ori', make_grid(to_tensor(g_plot), nrow=1, normalize=False))
g_plot = plot_representation (output["dyn_features"]["rec_ori"].cpu()) #[:,-output["pred"].shape[1]:].cpu())
self.writer.add_image('states_rec', make_grid(to_tensor(g_plot), nrow=1, normalize=False))
if output["pred"] is not None:
g_plot = plot_representation (output["dyn_features"]["pred"].cpu())
self.writer.add_image('states_pred', make_grid(to_tensor(g_plot), nrow=1, normalize=False))
if output["pred_roll"] is not None:
g_plot = plot_representation (output["dyn_features"]["pred_roll"].cpu())
self.writer.add_image('states_pred_roll', make_grid(to_tensor(g_plot), nrow=1, normalize=False))
if output["A"] is not None:
A_plot = plot_matrix(output["A"])
self.writer.add_image('f-A', make_grid(A_plot, nrow=1, normalize=False))
# if output["Ainv"] is not None:
# A_plot = plot_matrix(output["Ainv"])
# self.writer.add_image('fa-A-inv', make_grid(A_plot, nrow=1, normalize=False))
# AA_plot = plot_matrix(torch.mm(output["A"],output["Ainv"]))
# self.writer.add_image('fb-AA', make_grid(AA_plot, nrow=1, normalize=False))
# else:
# AA_plot = plot_matrix(torch.mm(output["A"],torch.pinverse(output["A"])))
# self.writer.add_image('fb-AA', make_grid(AA_plot, nrow=1, normalize=False))
# if output["selectors_rec"] is not None:
# sels_rec = output["selectors_rec"]
# if output["selectors_pred"] is not None:
# sels_pred = output["selectors_pred"]
# sel_rec_plot = plot_representation(sels_rec[:,-sels_pred.shape[1]:].cpu())
# else:
# sel_rec_plot = plot_representation(sels_rec.cpu())
# self.writer.add_image('b-sel_repr_rec', make_grid(to_tensor(sel_rec_plot), nrow=1, normalize=False))
# if output["selectors_pred"] is not None:
# sels_pred = output["selectors_pred"]
# sel_pred_plot = plot_representation(sels_pred.cpu())
# self.writer.add_image('b-sel_repr_pred', make_grid(to_tensor(sel_pred_plot), nrow=1, normalize=False))
if output["B"] is not None:
B_plot = plot_matrix(output["B"])
self.writer.add_image('g-B', make_grid(B_plot, nrow=1, normalize=False))
if output["u"] is not None:
u_plot = plot_representation(output["u"][:, :output["u"].shape[1]].cpu())
self.writer.add_image('eb-gu', make_grid(to_tensor(u_plot), nrow=1, normalize=False))
# if output[10] is not None: # TODO: Ara el torno a posar
# # print(output[10][0].max(), output[-1][0].min())
# shape = output[10][0].shape
# self.writer.add_image('objects', make_grid(output[10][0].permute(1, 2, 0, 3, 4).reshape(*shape[1:-2], -1, shape[-1]).cpu(), nrow=output[0].shape[1], normalize=True))
# output["rec"] = torch.clamp(torch.sum(out_rec.reshape(bs, self.n_objects, -1, *out_rec.size()[1:]), dim=1), min=0, max=1)
# output["pred"] = torch.clamp(torch.sum(out_pred.reshape(bs, self.n_objects, -1, *out_rec.size()[1:]), dim=1), min=0, max=1)
# output["obs_rec_pred"] = returned_g.reshape(-1, returned_g.size()[-1:])
# output["gauss_post"] = returned_post
# output["A"] = A
# output["B"] = B
# output["u"] = u.reshape(bs * self.n_objects, -1, u.shape[-1])
# output["bern_logit"] = u_logit.reshape(bs, self.n_objects, -1, u_logit.shape[-1]) # Input distribution