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')
