def prediction_tractogram(hyperparams, model, dataset, batch_size_override,
prediction_method):
loss = loss_factory(hyperparams,
model,
dataset,
loss_type=prediction_method)
batch_scheduler = batch_scheduler_factory(
hyperparams,
dataset,
train_mode=False,
batch_size_override=batch_size_override,
use_data_augment=False)
_ = loss.losses # Hack to generate update dict in loss :(
predictions = loss.samples
predict, timestep_losses, inputs, targets, masks = log_variables(
batch_scheduler, model, predictions, loss.loss_per_time_step,
dataset.symb_inputs * 1, dataset.symb_targets * 1,
dataset.symb_mask * 1)
if hyperparams['model'] == 'ffnn_regression':
# Regrouping data into streamlines will only work if the original streamlines were NOT shuffled, resampled or augmented
timesteps_prediction = ArraySequence()
timesteps_loss = ArraySequence()
timesteps_inputs = ArraySequence()
timesteps_targets = ArraySequence()
idx = 0
for length in dataset.streamlines._lengths:
start = idx
idx = end = idx + length
timesteps_prediction.extend(predict[start:end])
timesteps_loss.extend(timestep_losses[start:end])
timesteps_inputs.extend(inputs[start:end])
timesteps_targets.extend(targets[start:end])
else:
timesteps_prediction = ArraySequence(
[p[:int(m.sum())] for p, m in zip(chain(*predict), chain(*masks))])
timesteps_loss = ArraySequence([
l[:int(m.sum())]
for l, m in zip(chain(*timestep_losses), chain(*masks))
])
timesteps_inputs = ArraySequence(
[i[:int(m.sum())] for i, m in zip(chain(*inputs), chain(*masks))])
# Use np.squeeze in case gru_multistep is used to remove the empty k=1 dimension
timesteps_targets = ArraySequence([
np.squeeze(t[:int(m.sum())])
for t, m in zip(chain(*targets), chain(*masks))
])
# Debug : Print norm stats
# print("Dataset: {}; # of streamlines: {}".format(dataset.name, len(dataset)))
# all_predictions = np.array(list(chain(*timesteps_prediction)))
# prediction_norms = np.linalg.norm(all_predictions, axis=1)
# print("Prediction norm --- Mean:{}; Max:{}; Min:{}".format(np.mean(prediction_norms), np.max(prediction_norms), np.min(prediction_norms)))
# all_targets = np.array(list(chain(*timesteps_targets)))
# target_norms = np.linalg.norm(all_targets, axis=1)
# print("Target norm --- Mean:{}; Max:{}; Min:{}".format(np.mean(target_norms), np.max(target_norms), np.min(target_norms)))
# Color is based on timestep loss
cmap = cm.get_cmap('bwr')
values = np.concatenate(timesteps_loss)
vmin = np.percentile(values, 5)
vmax = np.percentile(values, 95)
scalar_map = cm.ScalarMappable(norm=mplcolors.Normalize(vmin=vmin,
vmax=vmax),
cmap=cmap)
streamlines = []
colors = []
for i, t, p, l in zip(timesteps_inputs, timesteps_targets,
timesteps_prediction, timesteps_loss):
pts = np.r_[i[:, :3], [i[-1, :3] + t[-1]]]
streamline = np.zeros(((len(pts) - 1) * 3 + 1, 3))
streamline[::3] = pts
streamline[1:-1:3] = pts[:-1] + p
streamline[2:-1:3] = pts[:-1]
streamlines.append(streamline)
# Color input streamlines in a uniform color, then color predictions based on L2 error
color = np.zeros_like(streamline)
# Base color of streamlines is minimum value (best score)
color[:] = scalar_map.to_rgba(vmin, bytes=True)[:3]
color[1:-1:3, :] = scalar_map.to_rgba(l, bytes=True)[:, :3]
colors.append(color)
tractogram = nib.streamlines.Tractogram(streamlines,
data_per_point={"colors": colors})
return tractogram
def evaluation_tractogram(hyperparams, model, dataset, batch_size_override, metric):
loss = loss_factory(hyperparams, model, dataset, loss_type=None)
batch_scheduler = batch_scheduler_factory(hyperparams, dataset, train_mode=False, batch_size_override=batch_size_override, use_data_augment=False)
_ = loss.losses # Hack to generate update dict in loss :(
if hyperparams['model'] == 'ffnn_regression':
timestep_losses, inputs, targets = log_variables(batch_scheduler,
model,
loss.loss_per_time_step,
dataset.symb_inputs * 1,
dataset.symb_targets * 1)
# Regrouping data into streamlines will only work if the original streamlines were NOT shuffled, resampled or augmented
timesteps_loss = ArraySequence()
seq_loss = []
timesteps_inputs = ArraySequence()
timesteps_targets = ArraySequence()
idx = 0
for length in dataset.streamlines._lengths:
start = idx
idx = end = idx+length
timesteps_loss.extend(timestep_losses[start:end])
seq_loss.extend(np.mean(timestep_losses[start:end]))
timesteps_inputs.extend(inputs[start:end])
timesteps_targets.extend(targets[start:end])
else:
timestep_losses, seq_losses, inputs, targets, masks = log_variables(batch_scheduler,
model,
loss.loss_per_time_step,
loss.loss_per_seq,
dataset.symb_inputs * 1,
dataset.symb_targets * 1,
dataset.symb_mask * 1)
timesteps_loss = ArraySequence([l[:int(m.sum())] for l, m in zip(chain(*timestep_losses), chain(*masks))])
seq_loss = np.array(list(chain(*seq_losses)))
timesteps_inputs = ArraySequence([i[:int(m.sum())] for i, m in zip(chain(*inputs), chain(*masks))])
# Use np.squeeze in case gru_multistep is used to remove the empty k=1 dimension
timesteps_targets = ArraySequence([np.squeeze(t[:int(m.sum())]) for t, m in zip(chain(*targets), chain(*masks))])
if metric == 'sequence':
# Color is based on sequence loss
values = seq_loss
elif metric == 'timestep' or metric == 'cumul_avg':
# Color is based on timestep loss
values = np.concatenate(timesteps_loss)
else:
raise ValueError("Unrecognized metric: {}".format(metric))
cmap = cm.get_cmap('bwr')
vmin = np.percentile(values, 5)
vmax = np.percentile(values, 95)
scalar_map = cm.ScalarMappable(norm=mplcolors.Normalize(vmin=vmin, vmax=vmax), cmap=cmap)
streamlines = []
colors = []
for i, t, l, seq_l in zip(timesteps_inputs, timesteps_targets, timesteps_loss, seq_loss):
pts = np.r_[i[:, :3], [i[-1, :3] + t[-1]]]
color = np.zeros_like(pts)
if metric == 'sequence':
# Streamline color is based on sequence loss
color[:, :] = scalar_map.to_rgba(seq_l, bytes=True)[:3]
elif metric == 'timestep':
# Streamline color is based on timestep loss
# Identify first point with green
color[0, :] = [0, 255, 0]
color[1:, :] = scalar_map.to_rgba(l, bytes=True)[:, :3]
elif metric == 'cumul_avg':
# Streamline color is based on timestep loss
# Compute cumulative average
cumul_avg = np.cumsum(l) / np.arange(1, len(l) + 1)
# Identify first point with green
color[0, :] = [0, 255, 0]
color[1:, :] = scalar_map.to_rgba(cumul_avg, bytes=True)[:, :3]
else:
raise ValueError("Unrecognized metric: {}".format(metric))
streamlines.append(pts)
colors.append(color)
tractogram = nib.streamlines.Tractogram(streamlines, data_per_point={"colors": colors})
return tractogram
def evaluation_tractogram(hyperparams, model, dataset, batch_size_override,
metric):
loss = loss_factory(hyperparams, model, dataset, loss_type=None)
batch_scheduler = batch_scheduler_factory(
hyperparams,
dataset,
train_mode=False,
batch_size_override=batch_size_override,
use_data_augment=False)
_ = loss.losses # Hack to generate update dict in loss :(
if hyperparams['model'] == 'ffnn_regression':
timestep_losses, inputs, targets = log_variables(
batch_scheduler, model, loss.loss_per_time_step,
dataset.symb_inputs * 1, dataset.symb_targets * 1)
# Regrouping data into streamlines will only work if the original streamlines were NOT shuffled, resampled or augmented
timesteps_loss = ArraySequence()
seq_loss = []
timesteps_inputs = ArraySequence()
timesteps_targets = ArraySequence()
idx = 0
for length in dataset.streamlines._lengths:
start = idx
idx = end = idx + length
timesteps_loss.extend(timestep_losses[start:end])
seq_loss.extend(np.mean(timestep_losses[start:end]))
timesteps_inputs.extend(inputs[start:end])
timesteps_targets.extend(targets[start:end])
else:
timestep_losses, seq_losses, inputs, targets, masks = log_variables(
batch_scheduler, model, loss.loss_per_time_step, loss.loss_per_seq,
dataset.symb_inputs * 1, dataset.symb_targets * 1,
dataset.symb_mask * 1)
timesteps_loss = ArraySequence([
l[:int(m.sum())]
for l, m in zip(chain(*timestep_losses), chain(*masks))
])
seq_loss = np.array(list(chain(*seq_losses)))
timesteps_inputs = ArraySequence(
[i[:int(m.sum())] for i, m in zip(chain(*inputs), chain(*masks))])
# Use np.squeeze in case gru_multistep is used to remove the empty k=1 dimension
timesteps_targets = ArraySequence([
np.squeeze(t[:int(m.sum())])
for t, m in zip(chain(*targets), chain(*masks))
])
if metric == 'sequence':
# Color is based on sequence loss
values = seq_loss
elif metric == 'timestep' or metric == 'cumul_avg':
# Color is based on timestep loss
values = np.concatenate(timesteps_loss)
else:
raise ValueError("Unrecognized metric: {}".format(metric))
cmap = cm.get_cmap('bwr')
vmin = np.percentile(values, 5)
vmax = np.percentile(values, 95)
scalar_map = cm.ScalarMappable(norm=mplcolors.Normalize(vmin=vmin,
vmax=vmax),
cmap=cmap)
streamlines = []
colors = []
for i, t, l, seq_l in zip(timesteps_inputs, timesteps_targets,
timesteps_loss, seq_loss):
pts = np.r_[i[:, :3], [i[-1, :3] + t[-1]]]
color = np.zeros_like(pts)
if metric == 'sequence':
# Streamline color is based on sequence loss
color[:, :] = scalar_map.to_rgba(seq_l, bytes=True)[:3]
elif metric == 'timestep':
# Streamline color is based on timestep loss
# Identify first point with green
color[0, :] = [0, 255, 0]
color[1:, :] = scalar_map.to_rgba(l, bytes=True)[:, :3]
elif metric == 'cumul_avg':
# Streamline color is based on timestep loss
# Compute cumulative average
cumul_avg = np.cumsum(l) / np.arange(1, len(l) + 1)
# Identify first point with green
color[0, :] = [0, 255, 0]
color[1:, :] = scalar_map.to_rgba(cumul_avg, bytes=True)[:, :3]
else:
raise ValueError("Unrecognized metric: {}".format(metric))
streamlines.append(pts)
colors.append(color)
tractogram = nib.streamlines.Tractogram(streamlines,
data_per_point={"colors": colors})
return tractogram
def prediction_tractogram(hyperparams, model, dataset, batch_size_override, prediction_method):
loss = loss_factory(hyperparams, model, dataset, loss_type=prediction_method)
batch_scheduler = batch_scheduler_factory(hyperparams, dataset, train_mode=False, batch_size_override=batch_size_override, use_data_augment=False)
_ = loss.losses # Hack to generate update dict in loss :(
predictions = loss.samples
predict, timestep_losses, inputs, targets, masks = log_variables(batch_scheduler,
model,
predictions,
loss.loss_per_time_step,
dataset.symb_inputs * 1,
dataset.symb_targets * 1,
dataset.symb_mask * 1)
if hyperparams['model'] == 'ffnn_regression':
# Regrouping data into streamlines will only work if the original streamlines were NOT shuffled, resampled or augmented
timesteps_prediction = ArraySequence()
timesteps_loss = ArraySequence()
timesteps_inputs = ArraySequence()
timesteps_targets = ArraySequence()
idx = 0
for length in dataset.streamlines._lengths:
start = idx
idx = end = idx+length
timesteps_prediction.extend(predict[start:end])
timesteps_loss.extend(timestep_losses[start:end])
timesteps_inputs.extend(inputs[start:end])
timesteps_targets.extend(targets[start:end])
else:
timesteps_prediction = ArraySequence([p[:int(m.sum())] for p, m in zip(chain(*predict), chain(*masks))])
timesteps_loss = ArraySequence([l[:int(m.sum())] for l, m in zip(chain(*timestep_losses), chain(*masks))])
timesteps_inputs = ArraySequence([i[:int(m.sum())] for i, m in zip(chain(*inputs), chain(*masks))])
# Use np.squeeze in case gru_multistep is used to remove the empty k=1 dimension
timesteps_targets = ArraySequence([np.squeeze(t[:int(m.sum())]) for t, m in zip(chain(*targets), chain(*masks))])
# Debug : Print norm stats
# print("Dataset: {}; # of streamlines: {}".format(dataset.name, len(dataset)))
# all_predictions = np.array(list(chain(*timesteps_prediction)))
# prediction_norms = np.linalg.norm(all_predictions, axis=1)
# print("Prediction norm --- Mean:{}; Max:{}; Min:{}".format(np.mean(prediction_norms), np.max(prediction_norms), np.min(prediction_norms)))
# all_targets = np.array(list(chain(*timesteps_targets)))
# target_norms = np.linalg.norm(all_targets, axis=1)
# print("Target norm --- Mean:{}; Max:{}; Min:{}".format(np.mean(target_norms), np.max(target_norms), np.min(target_norms)))
# Color is based on timestep loss
cmap = cm.get_cmap('bwr')
values = np.concatenate(timesteps_loss)
vmin = np.percentile(values, 5)
vmax = np.percentile(values, 95)
scalar_map = cm.ScalarMappable(norm=mplcolors.Normalize(vmin=vmin, vmax=vmax), cmap=cmap)
streamlines = []
colors = []
for i, t, p, l in zip(timesteps_inputs, timesteps_targets, timesteps_prediction, timesteps_loss):
pts = np.r_[i[:, :3], [i[-1, :3] + t[-1]]]
streamline = np.zeros(((len(pts) - 1) * 3 + 1, 3))
streamline[::3] = pts
streamline[1:-1:3] = pts[:-1] + p
streamline[2:-1:3] = pts[:-1]
streamlines.append(streamline)
# Color input streamlines in a uniform color, then color predictions based on L2 error
color = np.zeros_like(streamline)
# Base color of streamlines is minimum value (best score)
color[:] = scalar_map.to_rgba(vmin, bytes=True)[:3]
color[1:-1:3, :] = scalar_map.to_rgba(l, bytes=True)[:, :3]
colors.append(color)
tractogram = nib.streamlines.Tractogram(streamlines, data_per_point={"colors": colors})
return tractogram
