def visulize(): from utils import visualize_graph from tensorboardX import SummaryWriter model = GConv(3, 5, 3) writer = SummaryWriter() visualize_graph(model, writer, input_size=(1, 12, 32, 32)) writer.close()
def main(show_age_clusterization, show_contacts_tree,
show_total_statistics, show_all_contacts,
use_profile_spreading, verbose):
with open('config.json', 'r') as config_json:
config = config_json.read()
settings = json.loads(config)
if verbose:
logger.setLevel(logging.INFO)
tree = ContactsTree(settings['depth'], settings['age_params'])
sender = tree.generate_tree()
settings.update(dict(use_profile_spreading=use_profile_spreading))
simulator = SimulationManager(sender=sender, settings=settings)
simulator.start_simulation()
nodes = sender.traverse()
if show_total_statistics:
stats = simulator.statistics()
click.echo('\nAverage request number: {}'.format(simulator.average_request_number()))
click.echo('\nAggregated data...')
for answer, votes in stats.iteritems():
click.echo(
'Answer "{answer}" got {votes}% of votes'.format(
answer=answer,
votes=votes
)
)
if show_contacts_tree:
figure(1)
visualize_graph(nodes)
if show_age_clusterization:
figure(2)
hist(
generate_age_ranges(1000, settings['age_params']['avg_age'], settings['age_params']['age_dev']),
bins=50
)
pylab.show()
if show_all_contacts:
json_nodes = json.dumps(nodes, default=serializer, indent=4)
click.echo('\nContacts tree:\n{}'.format(json_nodes))
download=True, transform=train_transform)
test_dataset = datasets.MNIST(root=args.dataset_dir, train=False,
download=True,transform=test_transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size,
num_workers=args.workers, pin_memory=True, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=args.batch_size,
num_workers=args.workers, pin_memory=True, shuffle=True)
# Load model
model = get_network_fn(args.model)
print(model)
# Try to visulize the model
try:
visualize_graph(model, writer, input_size=(1, 1, 28, 28))
except:
print('\nNetwork Visualization Failed! But the training procedure continue.')
# optimizer = optim.Adadelta(model.parameters(), lr=args.lr, rho=0.9, eps=1e-06, weight_decay=3e-05)
# optimizer = optim.Adam(model.parameters(), lr=args.lr, weight_decay=3e-05)
optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum, weight_decay=3e-05)
scheduler = StepLR(optimizer, step_size=10, gamma=0.5)
criterion = nn.CrossEntropyLoss()
device = torch.device("cuda" if use_cuda else "cpu")
model = model.to(device)
criterion = criterion.to(device)
# Calculate the total parameters of the model
print('Model size: {:0.2f} million float parameters'.format(get_parameters_size(model)/1e6))
num_workers=args.workers,
pin_memory=True,
shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=args.batch_size,
num_workers=args.workers,
pin_memory=True,
shuffle=True)
# Load model
model = resnet18(M=args.M, method=args.method, stages=stages).to(device)
print(model)
# Try to visulize the model
try:
visualize_graph(model, writer, input_size=(1, 3, 32, 32))
except:
print(
'\nNetwork Visualization Failed! But the training procedure continue.')
# Calculate the total parameters of the model
print('Model size: {:0.2f} million float parameters'.format(
get_parameters_size(model) / 1e6))
MFilter_params = [
param for name, param in model.named_parameters()
if name[-8:] == 'MFilters'
]
Other_params = [
param for name, param in model.named_parameters()
if name[-8:] != 'MFilters'
def create_policy_and_execute(strategy, g, base_availability_models, base_model_variances, true_schedules, node_requests, mu, params, visualize, visualize_path):
## plan, execution loop
num_requests = len(node_requests)
requests_left_to_deliver = copy.deepcopy(node_requests)
availability_observations = {}
total_profit = 0.0
total_maintenance_profit = 0.0
delivery_history = []
nodes_delivered = []
img_history = []
path_history = [params['start_node_id']]
action_history = []
curr_time = params['start_time']
curr_node = params['start_node_id']
# path_length = path_length # FIXME
path_visits = 0
maintenance_reward_collected_current_plan = 0.0
failure_penalty_current_plan = 0.0
plan_times = []
# # replan
# if (strategy == 'no_temp') or (strategy == 'no_replan'):
# replan = False
# else:
# replan = True
# # multiple visits planned
# if (strategy == 'observe_sampling_mult_visits') or ('observe_mult_visits'):
# multiple_visits = True
# else:
# multiple_visits = False
# if visualize:
# visualize_graph(g, base_availability_models, true_schedules, availability_observations, curr_time_index, curr_node, node_requests, delivery_history, curr_time, mu)
# img_history.append(img)
replan = True
end_reached = False
while not(end_reached):
if replan:
if curr_time >= (params['start_time'] + params['budget']):
end_reached = True
break
runtime_start = timer()
mcts = MCTS(g, base_availability_models, availability_observations, requests_left_to_deliver, curr_node, curr_time, params['budget']-curr_time, params['max_iterations'], params['planning_horizon'], params['maintenance_reward'], params['deliver_reward'], params['mu'], params['discovery_factor'], params['distribution_node'], params['maintenance_node'], params['ensemble_method'])
mcts.create_policy()
plan_time = timer() - runtime_start
plan_times.append(plan_time)
print ("MCTS plan time: " + str(plan_time))
path_visits = 1
curr_state = mcts.root_node_id
maintenance_reward_collected_current_plan = 0.0
failure_penalty_current_plan = 0.0
replan = False
else:
# follow policy
next_step = mcts.choose_best_action(curr_state, params['min_expansions'], maintenance_reward_collected_current_plan, failure_penalty_current_plan)
# print (next_step)
# did not explore or not enough visits
if next_step == None:
replan = True
print ('Replanning')
continue
else:
action = next_step[0]
visits = next_step[2]
distances = next_step[3]
# print ('Curr node: ' + curr_node)
# print ('Time: ' + str(curr_time))
# print ('Action: ' + action)
# print ()
if action == 'move':
curr_state = visits[0]
visit = mcts.nodes[curr_state].pose_id
dist = distances[0]
action_history.append('move_' + visit + '_' + str(curr_time))
curr_time += dist
curr_node = visit
path_visits += 1
path_history.append(visit)
elif action == 'maintenance':
curr_state = visits[0]
visit = mcts.nodes[curr_state].pose_id
dist = distances[0]
action_history.append('maintenance_' + visit + '_' + str(curr_time))
curr_time += dist
curr_node = visit
path_visits += 1
path_history.append(visit)
total_maintenance_profit += params['maintenance_reward']
maintenance_reward_collected_current_plan += params['maintenance_reward']
elif action == 'observe':
visit = mcts.nodes[visits[0]].pose_id
curr_time_index = int(curr_time/params['time_interval'])
available = true_schedules[visit][curr_time_index]
availability_observations[visit] = [available, curr_time]
if bool(available):
curr_state = visits[0]
dist = distances[0]
else:
curr_state = visits[1]
dist = distances[1]
visit = mcts.nodes[visits[1]].pose_id
action_history.append('observe_' + visit + '_' + str(curr_time))
curr_time += dist
curr_node = visit
path_visits += 1
path_history.append(visit)
elif action == 'deliver':
visit = mcts.nodes[visits[0]].pose_id
deliver_time = curr_time + distances[0]
if deliver_time > (params['start_time'] + params['budget']):
end_reached = True
break
deliver_time_index = int(deliver_time/params['time_interval'])
available = true_schedules[visit][deliver_time_index]
availability_observations[visit] = [available, deliver_time]
if bool(available):
curr_state = visits[0]
dist = distances[0]
requests_left_to_deliver.remove(visit)
total_profit += params['deliver_reward']
delivery_history.append([visit, deliver_time])
nodes_delivered.append(visit)
else:
curr_state = visits[1]
dist = distances[1]
visit = mcts.nodes[visits[1]].pose_id
failure_penalty_current_plan -= params['deliver_reward']
action_history.append('deliver_' + visit + '_' + str(curr_time))
curr_time += dist
curr_node = visit
path_visits += 1
path_history.append(visit)
if curr_time >= (params['start_time'] + params['budget']):
end_reached = True
break
if visualize:
curr_time_index = int(curr_time/params['time_interval'])
img = visualize_graph(g, base_availability_models, true_schedules, availability_observations, curr_time_index, curr_node, node_requests, nodes_delivered, curr_time, params['mu'], strategy, params['use_gp'])
img_history.append(img)
# if breakout:
# break
ratio_divisor = num_requests*params['deliver_reward'] + ((params['budget']-params['start_time']-num_requests)/params['time_interval'])*params['maintenance_reward']
competitive_ratio = (float(total_profit) + total_maintenance_profit)/ratio_divisor
maintenance_ratio_divisor = ((params['budget']-params['start_time'])/params['time_interval'])*params['maintenance_reward']
maintenance_competitive_ratio = total_maintenance_profit/maintenance_ratio_divisor
print ()
print(strategy + " cr: " + str(competitive_ratio))
ave_plan_time = sum(plan_times)/len(plan_times)
if visualize:
imageio.mimsave(visualize_path, img_history, duration=2)
print (action_history)
return total_profit, competitive_ratio, maintenance_competitive_ratio, path_history, ave_plan_time
def plan_and_execute(strategy, g, base_availability_models, base_model_variances, true_schedules, node_requests, mu, params, visualize, visualize_path):
## plan, execution loop
num_requests = len(node_requests)
requests_left_to_deliver = copy.deepcopy(node_requests)
availability_observations = {}
total_profit = 0.0
total_maintenance_profit = 0.0
delivery_history = []
nodes_delivered = []
img_history = []
path_history = [params['start_node_id']]
action_history = []
curr_time = params['start_time']
curr_node = params['start_node_id']
path_length = 1
path_visits = 0
plan_times = []
# replan
if (strategy == 'no_temp') or (strategy == 'no_replan'):
replan = False
else:
replan = True
# multiple visits planned
if (strategy == 'observe_sampling_mult_visits') or ('observe_mult_visits'):
multiple_visits = True
else:
multiple_visits = False
# if visualize:
# visualize_graph(g, base_availability_models, true_schedules, availability_observations, curr_time_index, curr_node, node_requests, delivery_history, curr_time, mu)
# img_history.append(img)
while (path_visits < path_length):
runtime_start = timer()
path = plan_path(strategy, g, base_availability_models, base_model_variances, availability_observations, requests_left_to_deliver, curr_time, curr_node, mu, params)
path_length = len(path)
plan_time = timer() - runtime_start
plan_times.append(plan_time)
print ("Plan time: " + str(plan_time))
## Execute
if path_length > 1:
path_visits = 1
for next_step in path:
visit = next_step[0]
action = next_step[1]
dist = next_step[2]
path_history.append(visit)
action_history.append(action + '_' + visit + '_' + str(curr_time))
# if curr_node == visit:
# dist = 1
# else:
# # dist = g.get_distance(curr_node, visit)
# dist = g[curr_node][visit]['weight']
curr_time += dist
curr_node = visit
path_visits += 1
if (visit == params['maintenance_node']) and (action == 'maintenance'):
total_maintenance_profit += params['maintenance_reward']
breakout = False
curr_time_index = int(curr_time/params['time_interval'])
if curr_time_index > (params['num_intervals'] - 1):
print("Curr time index exceeds num intervals: " + str(curr_time_index))
curr_time_index = params['num_intervals']-1
path_visits = 0
path_length = 0
break
# assert(curr_time_index <= (params['num_intervals'] - 1))
if visit in requests_left_to_deliver:
if action == 'deliver':
available = true_schedules[visit][curr_time_index]
if bool(available):
requests_left_to_deliver.remove(visit)
total_profit += params['deliver_reward']
delivery_history.append([visit, curr_time])
nodes_delivered.append(visit)
availability_observations[visit] = [1, curr_time]
if multiple_visits:
if replan:
path_visits = 0
path_length = 1
breakout = True
else:
# observation
availability_observations[visit] = [0, curr_time]
# put package back
if (curr_time + dist/2) <= (params['start_time'] + params['budget']):
curr_time += dist/2
else:
curr_time = params['start_time'] + params['budget']
curr_node = params['start_node_id']
path_visits += 1
path_history.append(curr_node)
if replan:
path_visits = 0
path_length = 1
breakout = True
# Break out after every observation
if action == 'observe':
available = true_schedules[visit][curr_time_index]
availability_observations[visit] = [available, curr_time]
if replan:
path_visits = 0
path_length = 1
breakout = True
if visualize:
img = visualize_graph(g, base_availability_models, true_schedules, availability_observations, curr_time_index, curr_node, node_requests, nodes_delivered, curr_time, mu, strategy, params['use_gp'])
img_history.append(img)
if breakout:
break
else:
path_visits = 0
path_length = 0
ratio_divisor = num_requests*params['deliver_reward'] + ((params['budget']-params['start_time']-num_requests)/params['time_interval'])*params['maintenance_reward']
competitive_ratio = (float(total_profit) + total_maintenance_profit)/ratio_divisor
maintenance_ratio_divisor = ((params['budget']-params['start_time'])/params['time_interval'])*params['maintenance_reward']
maintenance_competitive_ratio = total_maintenance_profit/maintenance_ratio_divisor
print ()
print(strategy + " cr: " + str(competitive_ratio))
ave_plan_time = sum(plan_times)/len(plan_times)
if visualize:
imageio.mimsave(visualize_path, img_history, duration=2)
print (action_history)
return total_profit, competitive_ratio, maintenance_competitive_ratio, path_history, ave_plan_time
def _train(self, train_loader, test_loader, output_dir, train_output_dir, test_output_dir, model_output_dir):
args = self.args
disc = self.disc
disc2 = self.disc2
gen = self.gen
train_losses = {}
test_losses = {}
if args.optimizer == 'sgd':
optimizer_g = optim.SGD(gen.parameters(), lr=args.lr/args.gen_lr_factor, momentum=0.9)
optimizer_d = optim.SGD(disc.parameters(), lr=args.lr, momentum=0.9)
optimizer_d2 = optim.SGD(disc2.parameters(), lr=args.lr, momentum=0.9)
elif args.optimizer == 'adam':
optimizer_g = optim.Adam(gen.parameters(), lr=args.lr/args.gen_lr_factor, betas=(0.5, 0.999))
optimizer_d = optim.Adam(disc.parameters(), lr=args.lr, betas=(0.5, 0.999))
optimizer_d2 = optim.Adam(disc2.parameters(), lr=args.lr, betas=(0.5, 0.999))
for epoch in range(args.epochs_cls):
self.disc.train()
train_loss = self._train_cls(self.args, epoch+1, disc, train_loader, optimizer_d)
train_losses[epoch] = train_loss
# Frequency to output and visualize results
if (epoch+1) % args.visualize_freq == 0 or epoch == 0:
test_loss = self._test_2(args, epoch+1, disc, test_loader, test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc.state_dict(), model_output_dir + 'disc_cls.pth')
print("Saved model")
with open(output_dir +'/train_losses.txt', 'w') as f:
json.dump(train_losses, f)
with open(output_dir +'/test_losses.txt', 'w') as f:
json.dump(test_losses, f)
# self._build_statistics(args, train_loader, disc)
for epoch in range(args.epochs_cls, args.epochs_cls+args.epochs):
self.disc.train()
self.gen.train()
if args.joint:
# Training discriminator and generator with same batch
train_loss = self._train_joint(self.args, epoch+1, disc, gen, train_loader, optimizer_d, optimizer_g, train_output_dir)
else:
# Training discriminator for one epoch, then generator for one epoch
train_loss = self._train_alt(self.args, epoch+1, disc, gen, train_loader, optimizer_d, optimizer_g, train_output_dir)
train_losses[epoch] = train_loss
disc.eval()
gen.eval()
# Frequency to output and visualize results
if (epoch+1) % args.visualize_freq == 0 or epoch == args.epochs_cls:
test_loss = self._test(args, epoch+1, disc, gen, test_loader, test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc.state_dict(), model_output_dir + 'disc.pth')
torch.save(gen.state_dict(), model_output_dir + 'gen.pth')
print("Saved model")
with open(output_dir +'/train_losses.txt', 'w') as f:
json.dump(train_losses, f)
with open(output_dir +'/test_losses.txt', 'w') as f:
json.dump(test_losses, f)
visualize_graph(train_losses, epoch+1, output_dir)
# Validate how well training on generated feature maps work on real images
if args.phase_2:
disc.eval()
gen.eval()
for epoch in range(args.epochs_cls+args.epochs, args.epochs_cls+args.epochs+args.epochs_2):
disc2.train()
train_loss = self._train_2(args, epoch+1, disc, disc2, gen, train_loader, optimizer_d2, train_output_dir)
train_losses[epoch] = train_loss
disc2.eval()
if (epoch+1) % args.visualize_freq == 0 or epoch == args.epochs_cls+args.epochs:
test_loss = self._test_2(args, epoch+1, disc2, test_loader, test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc2.state_dict(), model_output_dir + 'disc2.pth')
print("Saved model")
with open(output_dir +'/train_losses.txt', 'w') as f:
json.dump(train_losses, f)
with open(output_dir +'/test_losses.txt', 'w') as f:
json.dump(test_losses, f)
def _train(self, train_loader, test_loader, output_dir, train_output_dir,
test_output_dir, model_output_dir):
args = self.args
disc = self.disc
disc2 = self.disc2
gen = self.gen
train_losses = {}
test_losses = {}
optimizer_g = optim.Adam(gen.parameters(),
lr=args.lr,
betas=(0.5, 0.999))
optimizer_d = optim.Adam(disc.parameters(),
lr=args.lr,
betas=(0.5, 0.999))
optimizer_d2 = optim.Adam(disc2.parameters(),
lr=args.lr,
betas=(0.5, 0.999))
for epoch in range(args.epochs):
self.disc.train()
self.gen.train()
if args.joint:
train_loss = self._train_joint(self.args, epoch + 1, disc, gen,
train_loader, optimizer_d,
optimizer_g, train_output_dir)
else:
train_loss = self._train_alt(self.args, epoch + 1, disc, gen,
train_loader, optimizer_d,
optimizer_g, train_output_dir)
train_losses[epoch] = train_loss
disc.eval()
gen.eval()
if (epoch + 1) % args.visualize_freq == 0 or epoch == 0:
test_loss = self._test(args, epoch + 1, disc, gen, test_loader,
test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc.state_dict(), model_output_dir + 'disc.pth')
torch.save(gen.state_dict(), model_output_dir + 'gen.pth')
print("Saved model")
with open(output_dir + '/train_losses.txt', 'w') as f:
json.dump(train_losses, f)
with open(output_dir + '/test_losses.txt', 'w') as f:
json.dump(test_losses, f)
visualize_graph(train_losses, epoch + 1, output_dir)
if args.phase_2:
for epoch in range(args.epochs, args.epochs * 2):
disc.train()
gen.train()
train_loss = self._train_2(args, epoch + 1, disc, disc2, gen,
train_loader, optimizer_d2,
train_output_dir)
train_losses[epoch] = train_loss
disc.eval()
gen.eval()
if (epoch +
1) % args.visualize_freq == 0 or epoch == args.epochs:
test_loss = self._test_2(args, epoch + 1, disc2,
test_loader, test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc2.state_dict(),
model_output_dir + 'disc2.pth')
print("Saved model")
with open(output_dir + '/train_losses.txt', 'w') as f:
json.dump(train_losses, f)
with open(output_dir + '/test_losses.txt', 'w') as f:
json.dump(test_losses, f)
def _train(self, train_loader, test_loader, output_dir, train_output_dir,
test_output_dir, model_output_dir):
args = self.args
disc = self.disc
disc2 = self.disc2
gen = self.gen
train_losses = {}
test_losses = {}
if args.optimizer == 'sgd':
optimizer_g = optim.SGD(gen.parameters(),
lr=args.lr / args.gen_lr_factor,
momentum=0.9)
optimizer_d = optim.SGD(disc.parameters(),
lr=args.lr,
momentum=0.9)
optimizer_d2 = optim.SGD(disc2.parameters(),
lr=args.lr,
momentum=0.9)
elif args.optimizer == 'adam':
optimizer_g = optim.Adam(gen.parameters(),
lr=args.lr / args.gen_lr_factor,
betas=(0.5, 0.999))
optimizer_d = optim.Adam(disc.parameters(),
lr=args.lr,
betas=(0.5, 0.999))
optimizer_d2 = optim.Adam(disc2.parameters(),
lr=args.lr,
betas=(0.5, 0.999))
if args.stored_features:
# Features from custom discriminator model
with open('data/resnet_features.pkl', 'rb') as f:
self._features = pickle.load(f)
with open('data/resnet_targets.pkl', 'rb') as f:
self._targets = pickle.load(f)
print("Loaded stored feature statistics")
elif args.stored_features_pretrained:
# Features from pretrained resnet model
with open('data/pretrained_resnet_features.pkl', 'rb') as f:
self._features = pickle.load(f)
with open('data/pretrained_resnet_targets.pkl', 'rb') as f:
self._targets = pickle.load(f)
print("Loaded stored pretrained feature statistics")
else:
for epoch in range(args.epochs_cls):
disc.train()
train_loss = self._train_cls(self.args, epoch + 1, disc,
train_loader, optimizer_d)
train_losses[epoch] = train_loss
# Frequency to output and visualize results
if (epoch + 1) % args.visualize_freq == 0 or epoch == 0:
test_loss = self._test_2(args, epoch + 1, disc,
test_loader, test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc.state_dict(),
model_output_dir + 'disc_cls.pth')
print("Saved model")
with open(output_dir + '/train_losses.txt', 'w') as f:
json.dump(train_losses, f)
with open(output_dir + '/test_losses.txt', 'w') as f:
json.dump(test_losses, f)
self._build_statistics_index(args, train_loader, disc)
if args.resume:
disc.load_state_dict(torch.load(model_output_dir + 'disc.pth'))
gen.load_state_dict(torch.load(model_output_dir + 'gen.pth'))
print("Loaded previous disc and gen")
else:
for epoch in range(args.epochs_cls, args.epochs_cls + args.epochs):
disc.train()
gen.train()
if args.joint:
# Training discriminator and generator with same batch
train_loss = self._train_joint(self.args, epoch + 1, disc,
gen, train_loader,
optimizer_d, optimizer_g,
train_output_dir)
else:
# Training discriminator for one epoch, then generator for one epoch
train_loss = self._train_alt(self.args, epoch + 1, disc,
gen, train_loader,
optimizer_d, optimizer_g,
train_output_dir)
train_losses[epoch] = train_loss
disc.eval()
gen.eval()
# Frequency to output and visualize results
if (epoch + 1
) % args.visualize_freq == 0 or epoch == args.epochs_cls:
test_loss = self._test(args, epoch + 1, disc, gen,
test_loader, test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc.state_dict(),
model_output_dir + 'disc.pth')
torch.save(gen.state_dict(), model_output_dir + 'gen.pth')
print("Saved model")
with open(output_dir + '/train_losses.txt', 'w') as f:
json.dump(train_losses, f)
with open(output_dir + '/test_losses.txt', 'w') as f:
json.dump(test_losses, f)
visualize_graph(train_losses,
epoch + 1,
output_dir,
recon=args.recon,
mse=args.mse)
# Validate how well training on generated feature maps work on real images
if args.phase_2:
disc.eval()
gen.eval()
for epoch in range(args.epochs_cls + args.epochs,
args.epochs_cls + args.epochs + args.epochs_2):
disc2.train()
train_loss = self._train_2(args, epoch + 1, disc2, gen,
train_loader, optimizer_d2,
train_output_dir)
train_losses[epoch] = train_loss
disc2.eval()
if (
epoch + 1
) % args.visualize_freq == 0 or epoch == args.epochs_cls + args.epochs or (
epoch +
1) == args.epochs_cls + args.epochs + args.epochs_2:
test_loss = self._test_2(args, epoch + 1, disc2,
test_loader, test_output_dir)
test_losses[epoch] = test_loss
torch.save(disc2.state_dict(),
model_output_dir + 'disc2.pth')
print("Saved model")
with open(output_dir + '/train_losses.txt', 'a+') as f:
json.dump(train_losses, f)
with open(output_dir + '/test_losses.txt', 'a+') as f:
json.dump(test_losses, f)