def denoise_on_test(model,
data,
shapes,
length,
path,
result_path,
names=None):
'''
:param model: PyTorch Neural Network model
:param data: Loaded numpy data
:param shapes: Shapes to convert back cyclic data
:param length: The length to convert back cyclic data
:param path: Model's weights path
:param result_path: Experiment path to save denoised input
:param names: If None each entry save with name 'i.npy', in other way name for each entry can be provided
:return: None
'''
# load_best_model
model = load_model_state(model, path)
result = [to_np(model(to_var(d, is_on_cuda(model))[None])) for d in data]
output = postprocessing(result, shapes, length)
result_path = Path(result_path)
if names is not None:
for i, n in enumerate(names):
s = (result_path / n)
s.mkdir(exist_ok=True)
np.save(s, np.squeeze(output[i]).T)
else:
for i, o in enumerate(output):
name = str(i) + '.npy'
np.save(result_path / name, np.squeeze(o).T)
def val():
generator.eval()
t = sample_on_sphere(latent_dim, 144, state=0).astype('float32')
with torch.no_grad():
y = to_np(generator(to_var(t, device=generator)))[:, 0]
return {'generated__image': bytescale(stitch(y, bytescale))}
def get_trio(self, batch_of_images):
"""
Returns the prediction for the given ``inputs``.
Notes
-----
Note that both input and output are **not** of type `torch.Tensor` - the conversion
to torch.Tensor is made inside this function.
"""
self.model_core.eval()
with torch.no_grad():
batch_of_images = to_var(batch_of_images, self.model_core)
u_out = self.u_net(batch_of_images)
u_curve = self.to_curve(u_out)
z, reconstructed = self.autoencoder(u_curve)
return to_np(
self.logits2pred(u_out)), to_np(z), to_np(reconstructed)
def crf_train_step(x, spacings, target, architecture: CRFWrapper, criterion, optimizer, lr, with_crf: bool):
architecture.train()
x, target = sequence_to_var(x, target, device=architecture)
output = architecture(x, spacings) if with_crf else architecture.network(x)
loss = criterion(output, target)
optimizer_step(optimizer, loss, lr=lr)
return to_np(loss)
def z_to_curve(self, z, input):
self.model_core.eval()
with torch.no_grad():
input_shape = input.shape
batch_size = input_shape[0]
z = to_var(z, self.model_core)
x = self.autoencoder.decoder_lin(z)
x = x.reshape(batch_size, 128, 32)
x = self.autoencoder.decoder_conv(x)
reproduced_curve = nn.functional.interpolate(x, input_shape[2:])
return to_np(reproduced_curve)
def train_step(image_groups, *, generator, discriminator, gen_optimizer,
disc_optimizer, latent_dim, r1_weight, **optimizer_kwargs):
def latent(reference):
return to_var(sample_on_sphere(latent_dim,
len(reference))).to(reference)
assert len(image_groups)
discriminator.train()
generator.eval()
losses = defaultdict(list)
for i, images in enumerate(image_groups):
real = to_var(images, device=discriminator)
fake = generator(latent(real))
real_logits = discriminator(real)
fake_logits = discriminator(fake)
dis_fake = functional.softplus(fake_logits).mean()
dis_real = functional.softplus(-real_logits).mean()
loss = dis_fake + dis_real
if i == 0 and r1_weight > 0:
r1 = r1_loss(images, discriminator)
loss = loss + r1_weight * r1
losses['dis_r1'].append(to_np(r1))
optimizer_step(disc_optimizer, loss, **optimizer_kwargs)
losses['dis_fake'].append(to_np(dis_fake))
losses['dis_real'].append(to_np(dis_real))
# it's ok, `real` is already defined
generator.train()
discriminator.eval()
fake = generator(latent(real))
fake_logits = discriminator(fake)
loss = functional.softplus(-fake_logits).mean()
optimizer_step(gen_optimizer, loss, **optimizer_kwargs)
return {**dmap(np.mean, losses), 'gen': to_np(loss).item()}
def evaluate(model, data, targets):
'''
:param model: PyTorch Neural Network model
:param data: Loaded numpy data to evaluate model
:param targets: Numpy categorical target
:return: Accuracy score of the model
'''
model.eval()
preds = [
to_np(model(to_var(d, is_on_cuda(model))[None])).argmax(1)
for d in data
]
return accuracy_score(targets, preds)
def do_inf_step(self, batch_of_images):
"""
Returns the prediction for the given ``inputs``.
Notes
-----
Note that both input and output are **not** of type `torch.Tensor` - the conversion
to torch.Tensor is made inside this function.
"""
self.model_core.eval()
with torch.no_grad():
batch_of_images = to_var(batch_of_images, self.model_core)
u_out = self.u_net(batch_of_images)
return to_np(self.logits2pred(u_out))
def val_loss(model, val_data, val_labels, criterion):
'''
:param model: PyTorch Neural Network model
:param val_data: Loaded numpy data
:param val_labels: Loaded numpy target
:param criterion: Loss function
:return: Mean value of Loss function
'''
losses = [
to_np(
criterion(model(to_var(val_data[i])[None]),
to_var(val_labels[i])[None]))
for i in range(len(val_data))
]
return np.mean(losses)
def train_step(*inputs,
architecture,
criterion,
optimizer,
n_targets=1,
loss_key=None,
alpha_l2sp=None,
reference_architecture=None,
**optimizer_params):
architecture.train()
if n_targets >= 0:
n_inputs = len(inputs) - n_targets
else:
n_inputs = -n_targets
assert 0 <= n_inputs <= len(inputs)
inputs = sequence_to_var(*inputs, device=architecture)
inputs, targets = inputs[:n_inputs], inputs[n_inputs:]
if alpha_l2sp is not None:
if reference_architecture is None:
raise ValueError(
'`reference_architecture` should be provided for L2-SP regularization.'
)
w_diff = torch.tensor(0., requires_grad=True, dtype=torch.float32)
w_diff.to(get_device(architecture))
for p1, p2 in zip(architecture.parameters(),
reference_architecture.parameters()):
w_diff = w_diff + torch.sum((p1 - p2)**2)
loss = criterion(architecture(*inputs), *targets) + alpha_l2sp * w_diff
else:
loss = criterion(architecture(*inputs), *targets)
if loss_key is not None:
optimizer_step(optimizer, loss[loss_key], **optimizer_params)
return dmap(to_np, loss)
optimizer_step(optimizer, loss, **optimizer_params)
return to_np(loss)
def train_step(inputs, targets, model, optimizer):
model.train()
# move the tensors to the same device as `model`
inputs, targets = sequence_to_var(inputs, targets, device=model)
prediction = model(inputs)
# the model has 2 `heads`
assert prediction.shape[1] == 2, prediction.shape
curves, limits = prediction[:, 0], prediction[:, 1]
limits_mask = ~torch.isnan(targets)
loss = functional.binary_cross_entropy_with_logits(
limits, limits_mask.to(dtype=limits.dtype))
if limits_mask.any():
# penalize only the predictions where the target is defined
loss = loss + functional.mse_loss(curves[limits_mask],
targets[limits_mask])
optimizer_step(optimizer, loss)
return to_np(loss) # convert back to numpy
def q_update(states, actions, rewards, done, *, gamma, agent, target_agent=None, optimizer, max_grad_norm=None,
norm_type='inf', **optimizer_params):
check_shape_along_axis(actions, rewards, axis=1)
n_steps = actions.shape[1]
assert n_steps > 0
assert states.shape[1] == n_steps + 1
agent.train()
if target_agent is None:
target_agent = agent
else:
target_agent.eval()
# first and last state
start, stop = states[:, 0], states[:, -1]
# discounted rewards
rewards = discount_rewards(np.moveaxis(rewards, 1, 0), gamma)
actions = actions[:, [0]]
gamma = gamma ** n_steps
start, stop, actions, rewards, done = to_var(start, stop, actions, rewards, done, device=agent)
predicted = agent(start).gather(1, actions).squeeze(1)
with torch.no_grad():
values = target_agent(stop).detach().max(1).values
expected = (1 - done.to(values)) * values * gamma + rewards
loss = functional.mse_loss(predicted, expected)
set_params(optimizer, **optimizer_params)
optimizer.zero_grad()
loss.backward()
if max_grad_norm is not None:
torch.nn.utils.clip_grad_norm_(agent.parameters(), max_grad_norm, norm_type)
optimizer.step()
return to_np(loss)
def get_q_values(state, agent):
return to_np(agent(to_var(state[None], device=agent)))[0]
def predict(x):
model.eval()
x = to_var(x, args.device)
prediction = model(x[..., 0])
prediction[:, 1] = torch.sigmoid(prediction[:, 1])
return to_np(prediction)[..., None]
