def train(model, data, target, optimizer, max_iterations, loss_func_args): start_time = time.time() number_of_terms = [coeff_vec.shape[0] for coeff_vec in model(data)[3]] board = Tensorboard(number_of_terms) # Training print( '| Iteration | Progress | Time remaining | Cost | MSE | Reg | LL |' ) for iteration in torch.arange(0, max_iterations + 1): # Calculating prediction and library and scaling prediction, time_deriv_list, sparse_theta_list, coeff_vector_list, theta = model( data) coeff_vector_scaled_list = scaling(coeff_vector_list, sparse_theta_list, time_deriv_list) # Calculating loss loss_mse = mse_loss(prediction, target) loss_reg = reg_loss(time_deriv_list, sparse_theta_list, coeff_vector_list) loss = torch.sum(loss_mse) + torch.sum(loss_reg) # Writing if iteration % 100 == 0: # Write progress to command line progress(iteration, start_time, max_iterations, loss.item(), torch.sum(loss_mse).item(), torch.sum(loss_reg).item(), torch.sum(loss_reg).item()) lstsq_solution = torch.inverse( theta.T @ theta) @ theta.T @ time_deriv_list[0] # Calculate error for theta theta_true = loss_func_args['library'] dt_true = loss_func_args['time_deriv'] mae_library = torch.mean(torch.abs(theta - theta_true), dim=0) mae_dt = torch.mean(torch.abs(dt_true - time_deriv_list[0]), dim=0) # Write to tensorboard board.write(iteration, loss, loss_mse, loss_reg, loss_reg, coeff_vector_list, coeff_vector_scaled_list, lstsq_solution=lstsq_solution.squeeze(), mae_library=mae_library, mae_time_deriv=mae_dt) # Optimizer step optimizer.zero_grad() loss.backward() optimizer.step() board.close()
def train(model, data, target, optimizer, max_iterations, loss_func_args): '''Trains the deepmod model with MSE, regression and l1 cost function. Updates model in-place.''' start_time = time.time() number_of_terms = [coeff_vec.shape[0] for coeff_vec in model(data)[3]] board = Tensorboard(number_of_terms) # Training print( '| Iteration | Progress | Time remaining | Cost | MSE | Reg | LL |' ) for iteration in torch.arange(0, max_iterations + 1): # Calculating prediction and library and scaling prediction, time_deriv_list, sparse_theta_list, coeff_vector_list, theta = model( data) coeff_vector_scaled_list = scaling(coeff_vector_list, sparse_theta_list, time_deriv_list) # Calculating loss loss_mse = mse_loss(prediction, target) loss_reg = reg_loss(time_deriv_list, sparse_theta_list, coeff_vector_list) loss_l1 = l1_loss(coeff_vector_scaled_list, loss_func_args['l1']) loss = torch.sum(1 + 2 * torch.log(2 * pi * loss_mse) + loss_reg / loss_mse) # Writing if iteration % 100 == 0: # Write progress to command line progress(iteration, start_time, max_iterations, loss.item(), torch.sum(loss_mse).item(), torch.sum(loss_reg).item(), torch.sum(loss_reg).item()) # Calculate error for theta theta_true = loss_func_args['library'] dt_true = loss_func_args['time_deriv'] mae_library = torch.mean(torch.abs(theta - theta_true), dim=0) mae_dt = torch.mean(torch.abs(dt_true - time_deriv_list[0]), dim=0) # Write to tensorboard board.write(iteration, loss, loss_mse, loss_reg, loss_l1, coeff_vector_list, coeff_vector_scaled_list, mae_library=mae_library, mae_time_deriv=mae_dt) # Optimizer step optimizer.zero_grad() loss.backward() optimizer.step() board.close()
def train(model, data, target, optimizer, max_iterations, loss_func_args, log_dir=None): start_time = time.time() number_of_terms = [coeff_vec.shape[0] for coeff_vec in model(data)[3]] board = Tensorboard(number_of_terms, log_dir) # Training print( '| Iteration | Progress | Time remaining | Cost | MSE | Reg | LL |' ) for iteration in torch.arange(0, max_iterations + 1): # Calculating prediction and library and scaling prediction, time_deriv_list, sparse_theta_list, coeff_vector_list, theta = model( data) coeff_vector_scaled_list = scaling(coeff_vector_list, sparse_theta_list, time_deriv_list) # Calculating loss loss_mse = mse_loss(prediction, target) loss_reg = reg_loss(time_deriv_list, sparse_theta_list, coeff_vector_list) loss_ll = torch.log(2 * pi * loss_mse) loss_ll_fit = torch.log(2 * pi * loss_mse) + loss_reg / loss_mse loss = torch.sum(loss_ll) + torch.sum(loss_ll_fit) # Writing if iteration % 100 == 0: # Write progress to command line progress(iteration, start_time, max_iterations, loss.item(), torch.sum(loss_mse).item(), torch.sum(loss_reg).item(), torch.sum(loss_ll).item()) # Calculate error for theta # Write to tensorboard board.write(iteration, loss, loss_mse, loss_reg, loss_ll, coeff_vector_list, coeff_vector_scaled_list) # Optimizer step optimizer.zero_grad() loss.backward() optimizer.step() board.close()
def train_dynamic_logprob_scaled_double(model, data, target, optimizer, max_iterations, loss_func_args={'sparsity_update_period': 200, 'start_sparsity_update': 5000}): '''Trains the deepmod model with MSE, regression and l1 cost function. Updates model in-place.''' start_time = time.time() number_of_terms = [coeff_vec.shape[0] for coeff_vec in model(data)[3]] board = Tensorboard(number_of_terms) #sigma = loss_func_args['noise'] # noise parameter # Training print('| Iteration | Progress | Time remaining | Cost | MSE | Reg | LL |') for iteration in torch.arange(0, max_iterations + 1): # Calculating prediction and library and scaling prediction, time_deriv_list, sparse_theta_list, coeff_vector_list, theta = model(data) coeff_vector_scaled_list = scaling(coeff_vector_list, sparse_theta_list, time_deriv_list) # Calculating loss loss_mse = mse_loss(prediction, target) loss_reg = reg_loss(time_deriv_list, sparse_theta_list, coeff_vector_list) loss_ll_fit = torch.log(2 * pi * loss_reg) #optimal sigma loss_ll = torch.log(2 * pi * loss_mse) #optimal sigma loss = torch.sum(loss_ll_fit) + torch.sum(loss_ll) # Writing if iteration % 100 == 0: progress(iteration, start_time, max_iterations, loss.item(), torch.sum(loss_mse).item(), torch.sum(loss_reg).item(), torch.sum(loss_ll).item()) # Before writing to tensorboard, we need to fill the missing values with 0 coeff_vectors_padded = [torch.zeros(mask.size()).masked_scatter_(mask, coeff_vector.squeeze()) for mask, coeff_vector in zip(model.constraints.sparsity_mask, coeff_vector_list)] scaled_coeff_vectors_padded = [torch.zeros(mask.size()).masked_scatter_(mask, coeff_vector.squeeze()) for mask, coeff_vector in zip(model.constraints.sparsity_mask, coeff_vector_scaled_list)] board.write(iteration, loss, loss_mse, loss_reg, loss_ll, coeff_vectors_padded, scaled_coeff_vectors_padded) # Optimizer step optimizer.zero_grad() loss.backward() optimizer.step() # Updating sparsity pattern if (iteration >= loss_func_args['start_sparsity_update']) and (iteration % loss_func_args['sparsity_update_period'] == 0): with torch.no_grad(): model.constraints.sparsity_mask = model.calculate_sparsity_mask(theta, time_deriv_list) board.close()