def execute(): """Fix Hardcoded Tray icons.""" action = App.get("action") apps = App.get_supported_apps() done = [] total_time = 0 counter = 0 total_counter = len(apps) for app in apps: app_name = app.name delta = app.do_action(action) total_time += delta if app.success: counter += 1 if app_name not in done: progress(counter, total_counter, delta, app_name) done.append(app_name) else: total_counter -= 1 if apps: print(_("Took {:.2f}s to finish the tasks").format(total_time)) elif action == Action.APPLY: print(_("No apps to fix!")) elif action == Action.CLEAR_CACHE: print(_("No cache found.")) else: print(_("No apps to revert!"))
def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations): for self.iteration in range(number_of_training_iterations): # Pass the training set through our neural network output_from_layer_1, output_from_layer_2 = self.think( training_set_inputs) # Calculate the error for layer 2 (The difference between the desired output # and the predicted output). layer2_error = training_set_outputs - output_from_layer_2 layer2_delta = layer2_error * self.__sigmoid_derivative( output_from_layer_2) # Calculate the error for layer 1 (By looking at the weights in layer 1, # we can determine by how much layer 1 contributed to the error in layer 2). layer1_error = layer2_delta.dot(self.layer2.synaptic_weights.T) layer1_delta = layer1_error * self.__sigmoid_derivative( output_from_layer_1) # Calculate how much to adjust the weights byFalse layer1_adjustment = training_set_inputs.T.dot(layer1_delta) layer2_adjustment = output_from_layer_1.T.dot(layer2_delta) # Adjust the weights. self.layer1.synaptic_weights += layer1_adjustment self.layer2.synaptic_weights += layer2_adjustment outputs = self.iteration % 5000 == 0 and self.iteration != 0 if outputs is True: # output weights and a guess at current iteration self.print_weights(self.iteration) hidden_state, output = self.think(self.arrGuess) print("\u001b[33m" + str(output) + "\u001b[0m\n") # Display weight information for all layers, and make an estimate at this stage if (outputs and debug and display) is True: # add current guess to graph plt.plot(self.iteration, output, '-o') plt.show() plt.pause(0.001) utils.progress(self.iteration, number_of_training_iterations, status="I'm thinking...")
def train_branched(local_rank, world_size, device, start_epoch, max_epochs, tasks, trainloader, model, loss, optimizer, scheduler, exp_dir): writer = SummaryWriter(log_dir=exp_dir) if local_rank == 0 else None iter_per_epoch = len( trainloader.dataset) // (trainloader.batch_size * max(1, world_size)) total_iter = iter_per_epoch * max_epochs model.train() for epoch in range(start_epoch, max_epochs + 1): if world_size > 1: trainloader.sampler.set_epoch(epoch) for batch_idx, samples in enumerate(trainloader): inputs = samples['image'].to(device, non_blocking=True) target = { task: samples[task].to(device, non_blocking=True) for task in tasks } optimizer.zero_grad() output = model(inputs) tot_loss = loss(output, target) tot_loss.backward() optimizer.step() if (batch_idx + 1) % 100 == 0 and local_rank == 0: current_loss = tot_loss.item() n_iter = (epoch - 1) * iter_per_epoch + batch_idx + 1 print('Train Iterations: {}, Loss: {}'.format( utils.progress(n_iter, total_iter), current_loss)) writer.add_scalar('loss_current', current_loss, n_iter) writer.add_scalar('learning_rate', optimizer.param_groups[0]['lr'], n_iter) scheduler.step() if local_rank == 0: # save model state = { 'state_dict': model.state_dict(), 'tasks': tasks, 'branch_config': model.branch_config, 'epoch': epoch, 'optimizer': optimizer.state_dict(), 'scheduler': scheduler.state_dict() } torch.save(state, Path(exp_dir) / 'checkpoint.pth')
def train_search(device, start_epoch, max_epochs, tasks, trainloader_weight, trainloader_arch, model, loss, optimizer_weight, optimizer_arch, exp_dir): writer = SummaryWriter(log_dir=exp_dir) iter_per_epoch = len( trainloader_weight.dataset) // trainloader_weight.batch_size total_iter = iter_per_epoch * max_epochs delay_epochs = max_epochs // 20 model.train() for epoch in range(start_epoch, max_epochs + 1): model.warmup_flag = (epoch <= delay_epochs) # set the gumbel temperature according to a linear schedule model.gumbel_temp = min( 5.0 - (epoch - delay_epochs - 1) / (max_epochs - delay_epochs - 1) * (5.0 - 0.1), 5.0) arch_loss = 0 arch_counter = 0 if epoch > delay_epochs: print('modifying architecture...') # we reset the arch optimizer state optimizer_arch.state = defaultdict(dict) # we use current batch statistics in search period model.freeze_encoder_bn_running_stats() for samples_search in trainloader_arch: inputs_search = samples_search['image'].to(device, non_blocking=True) target_search = { task: samples_search[task].to(device, non_blocking=True) for task in tasks } optimizer_arch.zero_grad() for task in tasks: # many images don't have human parts annotations, skip those uniq = torch.unique(target_search[task]) if len(uniq) == 1 and uniq[0] == 255: continue output = model(inputs_search, task=task) tot_loss = loss(output, target_search, task=task) tot_loss.backward() arch_loss += tot_loss.item() arch_counter += 1 optimizer_arch.step() # we reset the main optimizer state because arch has changed optimizer_weight.state = defaultdict(dict) # we should reset bn running stats model.unfreeze_encoder_bn_running_stats() model.reset_encoder_bn_running_stats() for batch_idx, samples in enumerate(trainloader_weight): inputs = samples['image'].to(device, non_blocking=True) target = { task: samples[task].to(device, non_blocking=True) for task in tasks } current_loss = 0 counter = 0 for task in tasks: # many images don't have human parts annotations, skip those uniq = torch.unique(target[task]) if len(uniq) == 1 and uniq[0] == 255: continue optimizer_weight.zero_grad() output = model(inputs, task=task) tot_loss = loss(output, target, task=task, omit_resource=True) tot_loss.backward() optimizer_weight.step() current_loss += tot_loss.item() counter += 1 if (batch_idx + 1) % 100 == 0: n_iter = (epoch - 1) * iter_per_epoch + batch_idx + 1 print('Train Iterations: {}, Loss: {:.4f}'.format( utils.progress(n_iter, total_iter), current_loss / counter)) writer.add_scalar('loss_current', current_loss / counter, n_iter) writer.add_scalar('arch_loss', arch_loss / max(1, arch_counter), n_iter) writer.add_scalar('gumbel_temp', model.gumbel_temp, n_iter) for name, param in model.named_arch_parameters(): writer.add_image(name, torch.nn.functional.softmax(param.data, dim=-1), n_iter, dataformats='HW') # save model state = { 'state_dict': model.state_dict(), 'tasks': tasks, 'epoch': epoch, 'optimizer_weight': optimizer_weight.state_dict(), 'optimizer_arch': optimizer_arch.state_dict(), } torch.save(state, Path(exp_dir) / 'checkpoint.pth') branch_config = model.get_branch_config() utils.write_json({'config': branch_config}, Path(exp_dir) / 'branch_config.json')