def testZeroOut(self, test_inputs, test_targets, criterion, net_gru_mse, net_gru_dtw, net_gru_dilate):
## Testing for first input/target loss
criterion_softdtw = SoftDTW(gamma=self.gamma, normalize=True)
zero_inputs = test_inputs.detach().cpu().numpy()[0, :, self.idx_tgt_col]
zero_targets = test_targets.detach().cpu().numpy()[0, :, :]
zero_mse_pred = net_gru_mse(test_inputs).to(self.device).detach().cpu().numpy()[0, :,
:]
zero_dtw_pred = net_gru_dtw(test_inputs).to(self.device).detach().cpu().numpy()[0, :,
:]
zero_dilate_pred = net_gru_dilate(test_inputs).to(self.device).detach().cpu().numpy()[0, :,
:]
print(f"zero input:{zero_inputs}")
print(f"zero targets:{zero_targets}")
print(f"zero mse:{zero_mse_pred}")
print(f"zero dtw:{zero_dtw_pred}")
print(f"zero dilate:{zero_dilate_pred}")
print(f"mse net mse: {criterion(test_targets, net_gru_mse(test_inputs))}, "
f"dtw: {criterion_softdtw(test_targets, net_gru_mse(test_inputs))}, "
f"dilate: {dilate_loss(net_gru_mse(test_inputs), test_targets, alpha=self.alpha, gamma=self.gamma, device=self.device)} ")
print(f"dtw net mse: {criterion(test_targets, net_gru_dtw(test_inputs))}, "
f"dtw: {criterion_softdtw(test_targets, net_gru_dtw(test_inputs))}, "
f"dilate: {dilate_loss(net_gru_dtw(test_inputs), test_targets, alpha=self.alpha, gamma=self.gamma, device=self.device)}, ")
print(f"dilate net mse: {criterion(test_targets, net_gru_dilate(test_inputs))}, "
f"dtw: {criterion_softdtw(test_targets, net_gru_dilate(test_inputs))}, "
f"dilate: {dilate_loss(net_gru_dilate(test_inputs), test_targets, alpha=self.alpha, gamma=self.gamma, device=self.device)}, ")
def train_model(self,
net,
batch_size,
loss_type,
learning_rate,
epochs=1000,
gamma=0.001,
print_every=50,
eval_every=50,
verbose=1,
Lambda=1,
alpha=0.5):
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)
criterion = torch.nn.MSELoss()
criterion_softdtw = SoftDTW(gamma=gamma, normalize=True)
for epoch in range(epochs):
for i, data in enumerate(self.trainloader, 0):
inputs, target = data
inputs = torch.tensor(inputs,
dtype=torch.float32).to(self.device)
target = torch.tensor(target,
dtype=torch.float32).to(self.device)
# batch_size, N_output = target.shape[0:2]
# forward + backward + optimize
outputs = net(inputs)
loss_mse, loss_shape, loss_temporal = torch.tensor(
0), torch.tensor(0), torch.tensor(0)
## TODO next run with dtw implementation
if (loss_type == 'dtw'):
loss_dtw = criterion_softdtw(outputs, target)
loss = torch.mean(loss_dtw)
if (loss_type == 'mse'):
loss_mse = criterion(target, outputs)
loss = loss_mse
if (loss_type == 'dilate'):
loss, loss_shape, loss_temporal = dilate_loss(
outputs, target, alpha, gamma, self.device)
# print(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if (verbose):
if (epoch % print_every == 0):
print('epoch ', epoch, ' loss ', loss.item(),
' loss shape ', loss_shape.item(), ' loss temporal ',
loss_temporal.item())
self.eval_model(net,
self.testloader,
batch_size,
gamma,
verbose=1)
def train_model(net,
batch_size,
loss_type,
learning_rate,
epochs=1000,
gamma=0.001,
print_every=50,
eval_every=50,
verbose=1,
Lambda=1,
alpha=0.5,
target_mean=0,
target_std=0):
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)
criterion = torch.nn.MSELoss()
criterion_softdtw = SoftDTW(gamma=gamma, normalize=True)
for epoch in range(epochs):
for i, data in enumerate(trainloader, 0):
## TODO modified for CustomDS
try:
inputs, target, _ = data
except:
try:
inputs, target = data
except:
pass
inputs = torch.tensor(inputs, dtype=torch.float32).to(device)
target = torch.tensor(target, dtype=torch.float32).to(device)
# batch_size, N_output = target.shape[0:2]
# forward + backward + optimize
# print(f"input size: {inputs.size()}")
# print(f"input size -1: {inputs.size(-1)}")
# print(net)
outputs = net(inputs)
loss_mse, loss_shape, loss_temporal = torch.tensor(
0), torch.tensor(0), torch.tensor(0)
## TODO next run with dtw implementation
if (loss_type == 'dtw'):
loss_dtw = criterion_softdtw(outputs, target)
loss = torch.mean(loss_dtw)
if (loss_type == 'mse'):
loss_mse = criterion(target, outputs)
loss = loss_mse
if (loss_type == 'dilate'):
loss, loss_shape, loss_temporal = dilate_loss(
outputs, target, alpha, gamma, device)
# print(loss)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if epoch > 300:
for z in range(len(outputs.to(device).detach().cpu().numpy())):
preds_arr = outputs.to(device).detach().cpu().numpy()[
z, :, :] * target_std + target_mean
input_arr = inputs.detach().cpu().numpy()[
z, :, idx_tgt_col] * target_std + target_mean
target_arr = target.detach().cpu().numpy()[
z, :, :] * target_std + target_mean
plt.plot(range(0, len(input_arr)),
input_arr,
label='input',
linewidth=1)
plt.plot(range(
len(input_arr) - 1,
len(input_arr) + len(target_arr)),
np.concatenate([
input_arr[len(input_arr) - 1:len(input_arr)],
target_arr.ravel()
]),
label='target',
linewidth=1)
plt.plot(range(
len(input_arr) - 1,
len(input_arr) + len(target_arr)),
np.concatenate([
input_arr[len(input_arr) - 1:len(input_arr)],
preds_arr.ravel()
]),
label='prediction',
linewidth=1)
plt.title(
f"f{loss_type}: {loss.item()}, loss shape: {loss_shape.item()}, loss temporal: {loss_temporal.item()}"
)
plt.show()
if (verbose):
if (epoch % print_every == 0):
print('epoch ', epoch, ' loss ', loss.item(), ' loss shape ',
loss_shape.item(), ' loss temporal ',
loss_temporal.item())
eval_model(net, testloader, gamma, verbose=1)
test_inputs, test_targets = next(gen_test)
test_inputs = torch.tensor(test_inputs, dtype=torch.float32).to(device)
test_targets = torch.tensor(test_targets, dtype=torch.float32).to(device)
criterion = torch.nn.MSELoss()
nets = [net_gru_mse, net_gru_dtw, net_gru_dilate]
nets_name = ["net_gru_mse", "net_gru_dtw", "net_gru_dilate"]
######################################################################################################################
############################################## RAN ABOVE ON CONSOLE ##################################################
######################################################################################################################
## Testing for first input/target loss
criterion_softdtw = SoftDTW(gamma=gamma, normalize=True)
zero_inputs = test_inputs.detach().cpu().numpy()[
0, :, idx_tgt_col] * target_log_std + target_log_mean
zero_targets = test_targets.detach().cpu().numpy()[
0, :, :] * target_log_std + target_log_mean
zero_mse_pred = net_gru_mse(test_inputs).to(device).detach().cpu().numpy()[
0, :, :] * target_log_std + target_log_mean
zero_dtw_pred = net_gru_dtw(test_inputs).to(device).detach().cpu().numpy()[
0, :, :] * target_log_std + target_log_mean
zero_dilate_pred = net_gru_dilate(test_inputs).to(
device).detach().cpu().numpy()[0, :, :] * target_log_std + target_log_mean
print(f"zero input:{zero_inputs}")
print(f"zero targets:{zero_targets}")
print(f"zero mse:{zero_mse_pred}")