def main(): running_reward = 10 for i_episode in flor.it(count(1)): state, ep_reward = env.reset(), 0 if flor.SkipBlock.step_into(probed=False): for t in range(1, 10000): # Don't infinite loop while learning action = select_action(state) state, reward, done, _ = env.step(action) if args.render: env.render() policy.rewards.append(reward) ep_reward += reward if done: break running_reward = 0.05 * ep_reward + (1 - 0.05) * running_reward finish_episode() running_reward, state, ep_reward = flor.SkipBlock.end( running_reward, state, ep_reward) if i_episode % args.log_interval == 0: print('Episode {}\tLast reward: {:.2f}\tAverage reward: {:.2f}'. format(i_episode, ep_reward, running_reward)) if running_reward > env.spec.reward_threshold: print("Solved! Running reward is now {} and " "the last episode runs to {} time steps!".format( running_reward, t)) break
def train(model, optimizer, criterion=nn.BCELoss(), train_loader=train_iter, valid_loader=valid_iter, test_loader=test_iter, num_epochs=5, eval_every=(len(train_iter) // 2), file_path='training_process', best_valid_loss=float('Inf')): running_loss = 0.0 valid_running_loss = 0.0 global_step = 0 train_loss_list = [] valid_loss_list = [] global_steps_list = [] model.train() for epoch in flor.it(range(num_epochs)): if flor.SkipBlock.step_into('batchwise-loop'): for (((words, words_len), labels), _) in train_loader: labels = labels.to(device) words = words.to(device) words_len = words_len.to(device) output = model(words, words_len) loss = criterion(output, labels) optimizer.zero_grad() loss.backward() optimizer.step() running_loss += loss.item() global_step += 1 if ((global_step % eval_every) == 0): model.eval() with torch.no_grad(): for (((words, words_len), labels), _) in valid_loader: labels = labels.to(device) words = words.to(device) words_len = words_len.to(device) output = model(words, words_len) loss = criterion(output, labels) valid_running_loss += loss.item() average_train_loss = (running_loss / eval_every) average_valid_loss = (valid_running_loss / len(valid_loader)) train_loss_list.append(average_train_loss) valid_loss_list.append(average_valid_loss) global_steps_list.append(global_step) running_loss = 0.0 valid_running_loss = 0.0 model.train() print('Epoch [{}/{}], Step [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}'.format((epoch + 1), num_epochs, global_step, (num_epochs * len(train_loader)), average_train_loss, average_valid_loss)) flor.log('avg_train_loss,avg_val_loss', (average_train_loss, average_valid_loss)) flor.SkipBlock.end(model) y_pred = [] model.eval() with torch.no_grad(): for ((words, words_len), _) in test_loader: words = words.to(device) words_len = words_len.to(device) output = model(words, words_len) output = (output > 0.5).int() y_pred.extend(output.tolist()) print('Finished Training!') return y_pred
def train( model, optimizer, criterion=nn.BCELoss(), train_loader=train_iter, valid_loader=valid_iter, test_loader=test_iter, num_epochs=5, eval_every=len(train_iter) // 2, file_path="training_process", best_valid_loss=float("Inf"), ): running_loss = 0.0 valid_running_loss = 0.0 global_step = 0 train_loss_list = [] valid_loss_list = [] global_steps_list = [] # training loop best_accuracy = float("inf") model.train() for epoch in flor.it(range(num_epochs)): if flor.SkipBlock.step_into("batchwise-loop"): for ((words, words_len), labels), _ in train_loader: labels = labels.to(device) words = words.to(device) words_len = words_len.detach().cpu() output = model(words, words_len) loss = criterion(output, labels) optimizer.zero_grad() loss.backward() optimizer.step() # update running values running_loss += loss.item() global_step += 1 # evaluation step if global_step % eval_every == 0: model.eval() with torch.no_grad(): # validation loop for ((words, words_len), labels), _ in valid_loader: labels = labels.to(device) words = words.to(device) words_len = words_len.detach().cpu() output = model(words, words_len) loss = criterion(output, labels) valid_running_loss += float(loss.item()) # evaluation average_train_loss = running_loss / eval_every average_valid_loss = valid_running_loss / len(valid_loader) if average_valid_loss < best_accuracy: best_accuracy = average_valid_loss torch.save(model.state_dict(), "best-model.pt") train_loss_list.append(average_train_loss) valid_loss_list.append(average_valid_loss) global_steps_list.append(global_step) # resetting running values running_loss = 0.0 valid_running_loss = 0.0 model.train() # print progress print( "Epoch [{}/{}], Step [{}/{}], Train Loss: {:.4f}, Valid Loss: {:.4f}" .format( epoch + 1, num_epochs, global_step, num_epochs * len(train_loader), average_train_loss, average_valid_loss, )) flor.log("avg_train_loss,avg_val_loss", (average_train_loss, average_valid_loss)) # type: ignore flor.SkipBlock.end(model, optimizer) flor.log("eval", None) # type:ignore # model.load_state_dict(torch.load("best-model.pt")) # predict test y_pred = [] model.eval() with torch.no_grad(): for ((words, words_len)), _ in test_loader: # labels = labels.to(device) words = words.to(device) words_len = words_len.detach().cpu() output = model(words, words_len) output = (output > 0.5).int() y_pred.extend(output.tolist()) print("Finished Training!") return y_pred
print(netD) criterion = nn.BCELoss() fixed_noise = torch.randn(opt.batchSize, nz, 1, 1, device=device) real_label = 1 fake_label = 0 # Setup optimizer optimizerD = optim.Adam(netD.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) optimizerG = optim.Adam(netG.parameters(), lr=opt.lr, betas=(opt.beta1, 0.999)) if opt.dry_run: opt.niter = 1 for epoch in flor.it(range(opt.niter)): if flor.SkipBlock.step_into("training_loop", probed=False): for i, data in enumerate(dataloader, 0): ############################ # (1) Update D network: maximize log(D(x)) + log(1 - D(G(z))) ########################### # train with real netD.zero_grad() real_cpu = data[0].to(device) batch_size = real_cpu.size(0) label = torch.full((batch_size, ), real_label, dtype=real_cpu.dtype, device=device) output = netD(real_cpu)
logvar).item() if i == 0: n = min(data.size(0), 8) comparison = torch.cat([ data[:n], recon_batch.view(args.batch_size, 1, 28, 28)[:n] ]) save_image(comparison.cpu(), 'results/reconstruction_' + str(epoch) + '.png', nrow=n) test_loss = flor.SkipBlock.end(test_loss) test_loss /= len(test_loader.dataset) print('====> Test set loss: {:.4f}'.format(test_loss)) if __name__ == "__main__": if not os.path.exists('results'): os.mkdir('results') for epoch in flor.it(range(1, args.epochs + 1)): train(epoch) test(epoch) with torch.no_grad(): sample = torch.randn(64, 20).to(device) sample = model.decode(sample).cpu() save_image(sample.view(64, 1, 28, 28), 'results/sample_' + str(epoch) + '.png') flor.flush()
total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = 100 * correct / total print( "Accuracy of the network on the 10000 test images: %d %%" % flor.pin("acc", accuracy) ) net = Net() if torch.cuda.is_available(): net = net.cuda() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) for epoch in flor.it(range(2)): running_loss = 0.0 if flor.SkipBlock.step_into("training_loop", probed=False): for i, data in enumerate(trainloader, 0): inputs, labels = data if torch.cuda.is_available(): inputs = inputs.cuda() labels = labels.cuda() optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics running_loss += loss.item()
with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total)) net = Net() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) for epoch in flor.it(range(3)): print(f'epoch: {epoch}') running_loss = 0.0 if flor.SkipBlock.step_into('training_loop', probed=True): for i, data in enumerate(trainloader, 0): inputs, labels = data optimizer.zero_grad() outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % 2000 == 1999: # print every 2000 mini-batches print('[%d, %5d] loss: %.3f' %
def eval(net): correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total)) net = Net() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9) for epoch in flor.it(range(80)): print(f'epoch: {epoch}') running_loss = 0.0 if flor.SkipBlock.step_into('training_loop', probed=True): print('foo') time.sleep(0.002) flor.SkipBlock.end(net, optimizer) eval(net) print('Finished Training')