def train_model(net,
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()
huber_loss = torch.nn.SmoothL1Loss()
for epoch in range(epochs):
for i, data in enumerate(trainloader, 0):
inputs, target, _ = data
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
outputs = net(inputs)
loss_mse, loss_shape, loss_temporal = torch.tensor(
0), torch.tensor(0), torch.tensor(0)
if (loss_type == 'mse'):
loss_mse = criterion(target, outputs)
loss = loss_mse
if (loss_type == 'dilate_shape'):
loss, loss_shape, loss_temporal = dilate_loss(
target, outputs, alpha, gamma, device)
loss = loss_shape
if (loss_type == 'dilate'):
loss, loss_shape, loss_temporal = dilate_loss(
target, outputs, alpha, gamma, device)
if (loss_type == 'huber'):
loss = huber_loss(target, outputs)
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())
eval_model(net, testloader, gamma, verbose=1)
def train_model(net,trainloader,testloader,loss_type,nsamples,learning_rate, device, epochs=1000, gamma = 0.001,
print_every=50,eval_every=50, verbose=1, Lambda=1, alpha=0.5, regul_entropy=False, lambda_entropy=1):
optimizer = torch.optim.Adam(net.parameters(),lr=learning_rate)
scheduler = ReduceLROnPlateau(optimizer, mode='min', patience=3,factor=0.1,verbose=True)
criterion = torch.nn.MSELoss()
epoch_list = []
mse_list,dtw_list,tdi_list,dilate_list,best_mse_list,best_dtw_list,best_tdi_list,best_dilate_list,card_shape_list,card_time_list=[],[],[],[],[],[],[],[],[],[]
best_mse = float('inf')
for epoch in range(epochs):
net.train()
t0 = time.time()
for i, data in enumerate(trainloader, 0):
inputs, target = data
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]
outputs, z_mu, z_logvar = net(inputs, target) # outputs [batch, seq_len, nfeatures]
loss_recons, loss_KL = 0,0
if (loss_type=='mse'):
loss_mse = criterion(target,outputs)
loss_recons = loss_mse
if (loss_type=='dilate'):
loss_dilate, loss_shape, loss_temporal = dilate_loss(target,outputs,alpha, gamma, device)
loss_recons = loss_dilate
loss_KL = loss_kullback_leibler(z_mu, z_logvar) # Kullback-Leibler
loss = loss_recons + loss_KL
if (regul_entropy):
nsamples_entropy = 10
loss_entropy = torch.tensor([0],dtype=torch.float32).to(device)
#for b in range(0,batch_size):
b = 0
for k in range(nsamples_entropy):
output_k = net.sample(inputs[b:b+1, :,:], target[b:b+1, :,:]) # output_k [1, seq_len, nfeatures]
loss_entropy += criterion(output_k,target[b:b+1, :,:])
loss_entropy = loss_entropy /(batch_size * nsamples_entropy)
loss = loss + lambda_entropy * loss_entropy
optimizer.zero_grad()
loss.backward()
optimizer.step()
if(verbose):
if (epoch % print_every == 0):
print('ep ', epoch, ' loss ',loss.item(), ' rec ',loss_recons.item(),' KL=',loss_KL.item(),' time ',time.time()-t0)
if (epoch % eval_every == 0):
mse,dilate = eval_model(net,testloader,nsamples,device,gamma,'vae')
scheduler.step(dilate)
mse_list.append(mse)
dilate_list.append(dilate)
epoch_list.append(epoch)
return 0
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 diversity_loss(predictions, target, quality, diversity_kernel, alpha,
gamma, ldtw, device):
# predictions [batch_size, nsamples, seq_len, nfeatures]
# target [batch_size, seq_len, nfeatures]
criterion = torch.nn.MSELoss()
nsamples = predictions.shape[1]
S = torch.zeros((nsamples, nsamples)).to(device) # similarity matrix
for i in range(0, nsamples):
for j in range(0, nsamples):
if i <= j:
if diversity_kernel == 'dtw':
dtw = dtw_loss(predictions[:, i, :, :],
predictions[:, j, :, :], gamma, device)
S[i, j] = dtw
if diversity_kernel == 'tdi':
dilate, shape, tdi = dilate_loss(predictions[:, i, :, :],
predictions[:, j, :, :],
alpha, gamma, device)
S[i, j] = tdi
if diversity_kernel == 'mse':
S[i, j] = criterion(predictions[:, i, :, :],
predictions[:, j, :, :])
S[j, i] = S[i, j] # matrix symmetrization
# Kernel computation:
S_mean = torch.mean(S)
if diversity_kernel == 'dtw':
Lambda = 1 / torch.abs(S_mean)
K = torch.exp(-Lambda * S)
if diversity_kernel == 'tdi':
Lambda = 1 / torch.abs(S_mean)
K = torch.exp(10 * Lambda * S)
if diversity_kernel == 'mse':
Lambda = S_mean
K = torch.exp(-Lambda * S)
I = torch.eye((nsamples)).to(device)
M = I - torch.inverse(K + I)
dpp_loss = -torch.trace(M)
return dpp_loss
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)
def train_model(net,
trainloader,
validationloader,
loss_type,
learning_rate,
epochs=1000,
gamma=0.001,
print_every=50,
eval_every=50,
verbose=1,
Lambda=1,
alpha=0.5,
scalerY=[],
modelSaver=[],
save=True,
device=[]):
#Using Adam optimizer
optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)
criterion = torch.nn.MSELoss()
criterion2 = torch.nn.L1Loss()
train_loss_hist = [] # save training loss at every epoch
val_mse_hist = [
] # save validation *mse* at every epoch such that epoch%print_every == 0
val_mae_hist = [
] # save validation *mae* at every epoch such that epoch%print_every == 0
val_dtw_hist = [
] # save validation *dtw* at every epoch such that epoch%print_every == 0, for DILATE Loss
val_tdi_hist = [
] # save validation *tdi* at every epoch such that epoch%print_every == 0, for DILATE Loss
#scale: constant multiplier of the output normalizer scalerY.
# An output value X(in the original range) is scaled as X*scale(to the zero-max normalized range)
scale = torch.from_numpy(scalerY.scale_).to(device).float()
train_loss_epoch = [
] #temporary storage for losses over batches in a single epoch
best_loss = 10000000000000 #track the best VALIDATION loss for early stopping
for epoch in range(epochs):
net.train()
train_loss_epoch = []
# You can schedule the learning rate by modifying here,
# E.g. At 10th and 25th epoch, divide the learning rate by 10 as:
# if(epoch==10 or epoch==25):
# for param_group in optimizer.param_groups:
# learning_rate = learning_rate*0.1
# param_group['lr'] = learning_rate
for i, data in enumerate(trainloader, 0):
#Get a batch of data from the trainloader
inputs_Encoder, inputs_Decoder, inputs_Encoder_global, inputs_Decoder_global, target = data
inputs_Encoder = torch.tensor(inputs_Encoder,
dtype=torch.float32).to(device)
inputs_Decoder = torch.tensor(inputs_Decoder,
dtype=torch.float32).to(device)
inputs_Encoder_global = torch.tensor(
inputs_Encoder_global, dtype=torch.float32).to(device)
inputs_Decoder_global = torch.tensor(
inputs_Decoder_global, dtype=torch.float32).to(device)
target = torch.tensor(target, dtype=torch.float32).to(device)
batch_size, N_output = target.shape[0:2]
# Forward
outputs = net(inputs_Encoder, inputs_Decoder,
inputs_Encoder_global, inputs_Decoder_global)
loss_mse, loss_shape, loss_temporal = torch.tensor(
0), torch.tensor(0), torch.tensor(0)
# Loss
if (loss_type == 'mse'):
loss_mse = criterion(target[:, :, 0] * scale, outputs[:, :, 0])
loss = loss_mse
if (loss_type == 'dilate'):
loss, loss_shape, loss_temporal = dilate_loss(
target * scale, outputs, alpha, gamma, device)
if (loss_type == 'mae'):
loss_mae = criterion2(target[:, :, 0] * scale, outputs[:, :,
0])
loss = loss_mae
# Backward + Optimize
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_loss_epoch.append(loss.item())
train_loss_hist.append(np.mean(train_loss_epoch))
if (verbose):
if (epoch % print_every == 0):
#Evaluate on validation
net.eval()
val_mse, val_mae, val_dtw, val_tdi = eval_model(
net,
validationloader,
device,
gamma=gamma,
verbose=1,
scalerY=scalerY)
print('Epoch: ', epoch, '| Train loss: ',
np.mean(train_loss_epoch), '| Val mae loss: ',
val_mae * scalerY.scale_)
print(
'|--------------------------------------------------------|'
)
val_mse_hist.append(val_mse)
val_mae_hist.append(val_mae)
val_dtw_hist.append(val_dtw)
val_tdi_hist.append(val_tdi)
if (val_mae < best_loss):
#save model with respect to validation mae
best_loss = val_mae
if (save):
modelSaver.saveNetwork(network)
modelSaver.best_epoch = epoch
modelSaver.best_net = network
return train_loss_hist, val_mse_hist, val_mae_hist, val_dtw_hist, val_tdi_hist
