def train(epoch): agent.train() rnet.train() matches, rewards, policies = [], [], [] for batch_idx, (inputs, targets) in tqdm.tqdm(enumerate(trainloader), total=len(trainloader)): inputs, targets = Variable(inputs), Variable(targets).cuda(async=True) if not args.parallel: inputs = inputs.cuda() probs, value = agent(inputs) #---------------------------------------------------------------------# policy_map = probs.data.clone() policy_map[policy_map<0.5] = 0.0 policy_map[policy_map>=0.5] = 1.0 policy_map = Variable(policy_map) probs = probs*args.alpha + (1-probs)*(1-args.alpha) distr = Bernoulli(probs) policy = distr.sample() v_inputs = Variable(inputs.data, volatile=True) preds_map = rnet.forward(v_inputs, policy_map) preds_sample = rnet.forward(inputs, policy) reward_map, _ = get_reward(preds_map, targets, policy_map.data) reward_sample, match = get_reward(preds_sample, targets, policy.data) advantage = reward_sample - reward_map # advantage = advantage.expand_as(policy) loss = -distr.log_prob(policy).sum(1, keepdim=True) * Variable(advantage) loss = loss.sum() #---------------------------------------------------------------------# loss += F.cross_entropy(preds_sample, targets) optimizer.zero_grad() loss.backward() optimizer.step() matches.append(match.cpu()) rewards.append(reward_sample.cpu()) policies.append(policy.data.cpu()) accuracy, reward, sparsity, variance, policy_set = utils.performance_stats(policies, rewards, matches) log_str = 'E: %d | A: %.3f | R: %.2E | S: %.3f | V: %.3f | #: %d'%(epoch, accuracy, reward, sparsity, variance, len(policy_set)) print log_str log_value('train_accuracy', accuracy, epoch) log_value('train_reward', reward, epoch) log_value('train_sparsity', sparsity, epoch) log_value('train_variance', variance, epoch) log_value('train_unique_policies', len(policy_set), epoch)
def test(epoch): agent.eval() matches, rewards, policies = [], [], [] for batch_idx, (inputs, targets) in tqdm.tqdm(enumerate(testloader), total=len(testloader)): # inputs, targets = Variable(inputs, volatile=True), Variable(targets).cuda(async=True) inputs, targets = Variable(inputs, volatile=True), Variable(targets) if not args.parallel: # inputs = inputs.cuda() inputs = inputs probs, _ = agent(inputs) policy = probs.data.clone() policy[policy < 0.5] = 0.0 policy[policy >= 0.5] = 1.0 policy = Variable(policy) if args.cl_step < num_blocks: policy[:, :-args.cl_step] = 1 preds = rnet.forward(inputs, policy) reward, match = get_reward(preds, targets, policy.data) matches.append(match) rewards.append(reward) policies.append(policy.data) accuracy, reward, sparsity, variance, policy_set = utils.performance_stats( policies, rewards, matches) log_str = 'TS - A: %.3f | R: %.2E | S: %.3f | V: %.3f | #: %d' % ( accuracy, reward, sparsity, variance, len(policy_set)) print log_str log_value('test_accuracy', accuracy, epoch) log_value('test_reward', reward, epoch) log_value('test_sparsity', sparsity, epoch) log_value('test_variance', variance, epoch) log_value('test_unique_policies', len(policy_set), epoch) # save the model agent_state_dict = agent.module.state_dict( ) if args.parallel else agent.state_dict() state = { 'agent': agent_state_dict, 'epoch': epoch, 'reward': reward, 'acc': accuracy } torch.save( state, args.cv_dir + '/ckpt_E_%d_A_%.3f_R_%.2E_S_%.2f_#_%d.t7' % (epoch, accuracy, reward, sparsity, len(policy_set)))
def test(P=None, mode='auto'): dices, policies = [], [] # make file path = 'nii_image' utils.mkdir(path) for batch_idx, (input, target) in tqdm.tqdm(enumerate(testloader), total=len(testloader)): input, target = input.cuda(), target.cuda() if mode == 'auto': probs, _ = agent(input) policy = probs.clone() policy[policy < 0.5] = 0.0 policy[policy >= 0.5] = 1.0 else: assert P is not None, f"P can not be None when mode is {mode}." policy = P seg_map = torch.sigmoid( seg_model.forward_single(input, policy.data.squeeze(0))) seg_map = F.interpolate(seg_map, size=(target.size(1), target.size(2), target.size(3)), mode="trilinear", align_corners=True) dice = compute_dice(seg_map, target) # save image seg_map_numpy = seg_map.cpu().detach().numpy() seg_map_numpy_s = np.squeeze(seg_map_numpy) sitk_img = sitk.GetImageFromArray(seg_map_numpy_s) sitk.WriteImage(sitk_img, path + '/' + mode + str(batch_idx) + '.nii', True) dices.append(dice) policies.append(policy.data) dice, _, sparsity, variance, policy_set, policy_list = utils.performance_stats( policies, dices, dices) log_str = u''' Dice: %.6f Block Usage: %.3f \u00B1 %.3f Unique Policies: %d ''' % (dice, sparsity, variance, len(policy_set)) print(log_str) print('policy_set', policy_set) print('policy_list', policy_list) print('dices', list(map(lambda x: x.item(), dices))) return dice #
def test(budget_constraint): total_ops = [] matches, policies = [], [] inference_time = [] for batch_idx, (inputs, targets) in tqdm.tqdm(enumerate(testloader), total=len(testloader)): targets = targets.cuda(async=True) inputs = inputs.cuda() with torch.no_grad(): time_st = time.time() budget = torch.ones(targets.shape).cuda() * budget_constraint probs, _ = agent(inputs, budget) policy = probs.clone() policy[policy < 0.5] = 0.0 policy[policy >= 0.5] = 1.0 preds = rnet.forward_single(inputs, policy.data.squeeze(0)) inference_time.append((time.time() - time_st) * 1000.0) _, pred_idx = preds.max(1) match = (pred_idx == targets).data.float() matches.append(match) policies.append(policy.data) ops = count_flops(agent) + count_flops(rnet) total_ops.append(ops) accuracy, _, sparsity, variance, policy_set = utils.performance_stats( policies, matches, matches) ops_mean, ops_std = np.mean(total_ops), np.std(total_ops) inference_time_mean, inference_time_std = np.mean(inference_time), np.std( inference_time) log_str = u''' Accuracy: %.3f Block Usage: %.3f \u00B1 %.3f FLOPs/img: %.2E \u00B1 %.2E Unique Policies: %d Average Inference time: %.3f \u00B1 %.3f ''' % (accuracy, sparsity, variance, ops_mean, ops_std, len(policy_set), inference_time_mean, inference_time_std) print("======================== budget constraint: " + str(budget_constraint) + " =========================") print(log_str) print("%.3f/%.3f/%.3f/%.2E/%.2E/%.3f/%.3f/%d" % (accuracy, sparsity, variance, ops_mean, ops_std, inference_time_mean, inference_time_std, len(policy_set))) with open(args.output, 'a') as f: f.write("%.2f,%.3f,%.3f,%.3f,%.2E,%.2E,%.3f,%.3f,%.3f,%.3f,%d\n" % (budget_constraint, accuracy, sparsity, variance, ops_mean, ops_std, ops_mean, ops_std, inference_time_mean, inference_time_std, len(policy_set)))
def test(epoch): agent.eval() rnet.eval() matches, rewards, policies = [], [], [] for batch_idx, (inputs, locations, targets) in enumerate(testloader): inputs, targets = Variable( inputs, volatile=True), Variable(targets).cuda(async=True) locations = Variable(locations, volatile=True) inputs = inputs.cuda() locations = locations.cuda() probs = agent(inputs, locations) policy = probs.data.clone() policy[policy < 0.5] = 0.0 policy[policy >= 0.5] = 1.0 policy = Variable(policy) preds = rnet.forward(inputs, policy) reward, match = get_reward(preds, targets, policy.data) matches.append(match) rewards.append(reward) policies.append(policy.data) accuracy, reward, sparsity, variance, policy_set = utils.performance_stats( policies, rewards, matches) log_str = 'TS - A: %.3f | R: %.2E | S: %.3f | V: %.3f | #: %d' % ( accuracy, reward, sparsity, variance, len(policy_set)) print log_str # save the model agent_state_dict = agent.module.state_dict( ) if args.parallel else agent.state_dict() rnet_state_dict = rnet.module.state_dict( ) if args.parallel else rnet.state_dict() state = { 'agent': agent_state_dict, 'resnet': rnet_state_dict, 'epoch': epoch, 'reward': reward, 'acc': accuracy } torch.save( state, args.cv_dir + '/ckpt_E_%d_A_%.3f_R_%.2E_S_%.2f_#_%d.t7' % (epoch, accuracy, reward, sparsity, len(policy_set)))
def test(epoch): vmodel.eval() accuracies = [] log.info("test Epoch is %d" %(epoch)) for idx, data in enumerate(testloader): data = [d.to(vdevice) for d in data] # _, [attr_pred, obj_pred, _] = vmodel(data,(attr_emb,obj_emb)) _, [attr_pred, obj_pred, _] = vmodel(data) # shape of attr_pred is [bs,3]:: 3 is open,closed nd orcl attr_id match_stats = utils.performance_stats(attr_pred, obj_pred, data) accuracies.append(match_stats) accuracies = zip(*accuracies) accuracies = map(torch.mean, map(torch.cat, accuracies)) attr_acc, obj_acc, closed_acc, open_acc, objoracle_acc = accuracies print( '(test) E: %d | A: %.3f | O: %.3f | Cl: %.3f | Op: %.4f | OrO: %.4f'%(epoch, attr_acc, obj_acc, closed_acc, open_acc, objoracle_acc))
def test(limit): total_ops = [] matches, policies = [], [] for batch_idx, (inputs, targets) in tqdm.tqdm(enumerate(testloader), total=len(testloader)): inputs, targets = Variable( inputs, volatile=True).cuda(), Variable(targets).cuda() probs, _ = agent(inputs) _, order = torch.sort(probs, 1) policy = probs.clone() policy[order < limit] = 0.0 policy[order >= limit] = 1.0 preds = rnet.forward(inputs, policy) _, pred_idx = preds.max(1) match = (pred_idx == targets).data.float() matches.append(match) policies.append(policy.data) ops = count_flops(agent) + count_flops(rnet) total_ops.append(ops) accuracy, _, sparsity, variance, policy_set = utils.performance_stats( policies, matches, matches) ops_mean, ops_std = np.mean(total_ops), np.std(total_ops) log_str = u''' Accuracy: %.3f Block Usage: %.3f \u00B1 %.3f FLOPs/img: %.2E \u00B1 %.2E Unique Policies: %d ''' % (accuracy, sparsity, variance, ops_mean, ops_std, len(policy_set)) log_value('test_acc', accuracy, limit) print(log_str)
def train(epoch): agent.train() rnet.train() matches, rewards, rewards_baseline, policies = [], [], [], [] for batch_idx, (inputs, targets) in tqdm.tqdm(enumerate(trainloader), total=len(trainloader)): inputs, targets = Variable(inputs), Variable(targets).cuda(async=True) if not args.parallel: inputs = inputs.cuda() # Get the low resolution agent images inputs_agent = inputs.clone() inputs_agent = torch.nn.functional.interpolate( inputs_agent, (args.lr_size, args.lr_size)) probs = F.sigmoid( agent.forward(inputs_agent, args.model.split('_')[1], 'lr')) probs = probs * args.alpha + (1 - probs) * (1 - args.alpha) # Sample the policies from the Bernoulli distribution characterized by agent's output distr = Bernoulli(probs) policy_sample = distr.sample() # Test time policy - used as baseline policy in the training step policy_map = probs.data.clone() policy_map[policy_map < 0.5] = 0.0 policy_map[policy_map >= 0.5] = 1.0 # Agent sampled high resolution images inputs_map = inputs.clone() inputs_sample = inputs.clone() inputs_map = utils.agent_chosen_input(inputs_map, policy_map, mappings, patch_size) inputs_sample = utils.agent_chosen_input(inputs_sample, policy_sample.int(), mappings, patch_size) # Get the predictions for baseline and sampled policy preds_map = rnet.forward(inputs_map, args.model.split('_')[1], 'hr') preds_sample = rnet.forward(inputs_sample, args.model.split('_')[1], 'hr') # Get the rewards for both policies reward_map, match = utils.compute_reward(preds_map, targets, policy_map.data, args.penalty) reward_sample, _ = utils.compute_reward(preds_sample, targets, policy_sample.data, args.penalty) # Find the joint loss from the classifier and agent advantage = reward_sample - reward_map loss = -distr.log_prob(policy_sample).sum( 1, keepdim=True) * Variable(advantage) loss = loss.mean() loss += F.cross_entropy(preds_sample, targets) optimizer.zero_grad() loss.backward() optimizer.step() matches.append(match.cpu()) rewards.append(reward_sample.cpu()) rewards_baseline.append(reward_map.cpu()) policies.append(policy_sample.data.cpu()) accuracy, reward, sparsity, variance, policy_set = utils.performance_stats( policies, rewards, matches) print('Train: %d | Acc: %.3f | Rw: %.2E | S: %.3f | V: %.3f | #: %d' % (epoch, accuracy, reward, sparsity, variance, len(policy_set))) log_value('train_accuracy', accuracy, epoch) log_value('train_reward', reward, epoch) log_value('train_sparsity', sparsity, epoch) log_value('train_variance', variance, epoch) log_value('train_baseline_reward', torch.cat(rewards_baseline, 0).mean(), epoch) log_value('train_unique_policies', len(policy_set), epoch)
def test(epoch): agent.eval() rnet.eval() matches, rewards, policies = [], [], [] for batch_idx, (inputs, targets) in tqdm.tqdm(enumerate(testloader), total=len(testloader)): inputs, targets = Variable( inputs, volatile=True), Variable(targets).cuda(async=True) if not args.parallel: inputs = inputs.cuda() # Get the low resolution agent images inputs_agent = inputs.clone() inputs_agent = torch.nn.functional.interpolate( inputs_agent, (args.lr_size, args.lr_size)) probs = F.sigmoid( agent.forward(inputs_agent, args.model.split('_')[1], 'lr')) # Sample Test time Policy Using Bernoulli Distribution policy = probs.data.clone() policy[policy < 0.5] = 0.0 policy[policy >= 0.5] = 1.0 # Get the Agent Determined Images inputs = utils.agent_chosen_input(inputs, policy, mappings, patch_size) # Get the predictions from the high resolution classifier preds = rnet.forward(inputs, args.model.split('_')[1], 'hr') # Get the reward for the sampled policy and given predictions reward, match = utils.compute_reward(preds, targets, policy.data, args.penalty) matches.append(match) rewards.append(reward) policies.append(policy.data) accuracy, reward, sparsity, variance, policy_set = utils.performance_stats( policies, rewards, matches) print('Test - Acc: %.3f | Rw: %.2E | S: %.3f | V: %.3f | #: %d' % (accuracy, reward, sparsity, variance, len(policy_set))) log_value('test_accuracy', accuracy, epoch) log_value('test_reward', reward, epoch) log_value('test_sparsity', sparsity, epoch) log_value('test_variance', variance, epoch) log_value('test_unique_policies', len(policy_set), epoch) # Save the Policy Network and High-res Classifier agent_state_dict = agent.module.state_dict( ) if args.parallel else agent.state_dict() rnet_state_dict = rnet.module.state_dict( ) if args.parallel else rnet.state_dict() state = { 'agent': agent_state_dict, 'resnet_hr': rnet_state_dict, 'epoch': epoch, 'reward': reward, 'acc': accuracy } torch.save( state, args.cv_dir + '/ckpt_E_%d_A_%.3f_R_%.2E' % (epoch, accuracy, reward))
def test(epoch): dices, rewards, policies = [], [], [] for batch_idx, (input, target) in tqdm.tqdm(enumerate(testloader), total=len(testloader)): input, target = input, target.cuda() if not args.parallel: input = input.cuda() probs, _ = agent(input) policy = probs.data.clone() policy[policy < 0.5] = 0.0 policy[policy >= 0.5] = 1.0 policy = Variable(policy) if args.cl_step < num_blocks: policy[:, :-args.cl_step] = 1 preds = torch.sigmoid(seg_model.forward(input, policy)) preds = F.interpolate(preds, size=(target.size(1), target.size(2), target.size(3)), mode="trilinear", align_corners=True) reward, dice = get_reward(preds, target, policy.data) dices.append(dice) rewards.append(reward) policies.append(policy.data) dice, reward, sparsity, variance, policy_set, policy_list = utils.performance_stats( policies, rewards, dices) log_str = 'TS - D: %.3f | R: %.2E | S: %.3f | V: %.3f | #: %d' % ( dice, reward, sparsity, variance, len(policy_set)) print(log_str) print("policy_list:", policy_list) writer.add_scalar('test_accuracy', dice, epoch) writer.add_scalar('test_reward', reward, epoch) writer.add_scalar('test_sparsity', sparsity, epoch) writer.add_scalar('test_variance', variance, epoch) writer.add_scalar('test_unique_policies', len(policy_set), epoch) # save the model agent_state_dict = agent.module.state_dict( ) if args.parallel else agent.state_dict() global best_dice if dice >= best_dice: state = { 'agent': agent_state_dict, 'epoch': epoch, 'reward': reward, 'dice': dice } torch.save( state, args.cv_dir + '/ckpt_E_%d_D_%.3f_R_%.2E_S_%.2f_#_%d.t7' % (epoch, dice, reward, sparsity, len(policy_set))) torch.save(state, args.cv_dir + '/best.t7')
def train(epoch): dices, rewards, policies = [], [], [] for batch_idx, (input, target) in tqdm.tqdm(enumerate(trainloader), total=len(trainloader)): input, target = input, target.cuda() if not args.parallel: input = input.cuda() probs, value = agent(input) policy_map = probs.data.clone() policy_map[policy_map < 0.5] = 0.0 policy_map[policy_map >= 0.5] = 1.0 policy_map = Variable(policy_map) probs = probs * args.alpha + (1 - probs) * (1 - args.alpha) distr = Bernoulli(probs) policy = distr.sample() if args.cl_step < num_blocks: policy[:, :-args.cl_step] = 1 policy_map[:, :-args.cl_step] = 1 policy_mask = Variable(torch.ones(input.size(0), policy.size(1))).cuda() policy_mask[:, :-args.cl_step] = 0 else: policy_mask = None seg_map = torch.sigmoid(seg_model.forward(input, policy_map)) seg_sample = torch.sigmoid(seg_model.forward(input, policy)) seg_map = F.interpolate(seg_map, size=(target.size(1), target.size(2), target.size(3)), mode="trilinear", align_corners=True) seg_sample = F.interpolate(seg_sample, size=(target.size(1), target.size(2), target.size(3)), mode="trilinear", align_corners=True) reward_map, _ = get_reward(seg_map, target, policy_map.data) reward_sample, dice = get_reward(seg_sample, target, policy.data) advantage = reward_sample - reward_map loss = -distr.log_prob(policy) loss = loss * advantage.expand_as(policy) if policy_mask is not None: loss = policy_mask * loss # mask for curriculum learning loss = loss.sum() probs = probs.clamp(1e-15, 1 - 1e-15) entropy_loss = -probs * torch.log(probs) entropy_loss = args.beta * entropy_loss.sum() loss = (loss - entropy_loss) / input.size(0) # ---------------------------------------------------------------------# optimizer.zero_grad() loss.backward() optimizer.step() dices.append(dice.cpu()) rewards.append(reward_sample.cpu()) policies.append(policy.data.cpu()) dice, reward, sparsity, variance, policy_set, policy_list = utils.performance_stats( policies, rewards, dices) log_str = 'TRAIN - E: %d | D: %.3f | R: %.2E | S: %.3f | V: %.3f | #: %d' % ( epoch, dice, reward, sparsity, variance, len(policy_set)) print(log_str) print("policy_list:", policy_list) writer.add_scalar('train_dice', dice, epoch) writer.add_scalar('train_reward', reward, epoch) writer.add_scalar('train_sparsity', sparsity, epoch) writer.add_scalar('train_variance', variance, epoch) writer.add_scalar('train_unique_policies', len(policy_set), epoch)
def train(epoch): agent.train() matches, rewards, policies = [], [], [] for batch_idx, (inputs, locations, targets) in enumerate(trainloader): inputs, targets = Variable(inputs), Variable(targets).cuda(async=True) locations = Variable(locations) if not args.parallel: inputs = inputs.cuda() locations = locations.cuda() #probs, value = agent(inputs) probs = agent(inputs, locations) #---------------------------------------------------------------------# policy_map = probs.data.clone() policy_map[policy_map < 0.5] = 0.0 policy_map[policy_map >= 0.5] = 1.0 policy_map = Variable(policy_map) probs = probs * args.alpha + (1 - probs) * (1 - args.alpha) distr = Bernoulli(probs) policy = distr.sample() if args.cl_step < num_blocks: policy[:, :-args.cl_step] = 1 policy_map[:, :-args.cl_step] = 1 policy_mask = Variable(torch.ones(inputs.size(0), policy.size(1))).cuda() policy_mask[:, :-args.cl_step] = 0 else: policy_mask = None v_inputs = Variable(inputs.data, volatile=True) preds_map = rnet.forward(v_inputs, policy_map) preds_sample = rnet.forward(v_inputs, policy) reward_map, _ = get_reward(preds_map, targets, policy_map.data) reward_sample, match = get_reward(preds_sample, targets, policy.data) advantage = reward_sample - reward_map loss = -distr.log_prob(policy) loss = loss * Variable(advantage).expand_as(policy) if policy_mask is not None: loss = policy_mask * loss # mask for curriculum learning loss = loss.sum() probs = probs.clamp(1e-15, 1 - 1e-15) entropy_loss = -probs * torch.log(probs) entropy_loss = args.beta * entropy_loss.sum() loss = (loss - entropy_loss) / inputs.size(0) #---------------------------------------------------------------------# optimizer.zero_grad() loss.backward() optimizer.step() matches.append(match.cpu()) rewards.append(reward_sample.cpu()) policies.append(policy.data.cpu()) accuracy, reward, sparsity, variance, policy_set = utils.performance_stats( policies, rewards, matches) log_str = 'E: %d | A: %.3f | R: %.2E | S: %.3f | V: %.3f | #: %d' % ( epoch, accuracy, reward, sparsity, variance, len(policy_set)) print log_str
def train(epoch): agent.train() matches, rewards, policies = [], [], [] for batch_idx, (inputs, targets) in tqdm.tqdm(enumerate(trainloader), total=len(trainloader)): noiseType = "gaussian" noiseType = "poisson" noiseType = "salt_pepper" showIamge(inputs[0:4].permute(0, 3, 2, 1), 1) noisy_inputs = addImageNoise(inputs.permute(0, 3, 2, 1), noiseType) showIamge(noisy_inputs[0:4].permute(0, 3, 2, 1), 2) targets_img = inputs.clone() inputs = noisy_inputs.clone() # inputs, targets = Variable(inputs), Variable(targets).cuda(async=True) inputs, targets = Variable(inputs), Variable(targets) if not args.parallel: # inputs = inputs.cuda() inputs = inputs probs, value = agent(inputs) #---------------------------------------------------------------------# policy_map = probs.data.clone() policy_map[policy_map < 0.5] = 0.0 policy_map[policy_map >= 0.5] = 1.0 policy_map = Variable(policy_map) probs = probs * args.alpha + (1 - probs) * (1 - args.alpha) distr = Bernoulli(probs) policy = distr.sample() if args.cl_step < num_blocks: policy[:, :-args.cl_step] = 1 policy_map[:, :-args.cl_step] = 1 # policy_mask = Variable(torch.ones(inputs.size(0), policy.size(1))).cuda() policy_mask = Variable(torch.ones(inputs.size(0), policy.size(1))) policy_mask[:, :-args.cl_step] = 0 else: policy_mask = None v_inputs = Variable(inputs.data, volatile=True) preds_map = rnet.forward(v_inputs, policy_map) preds_sample = rnet.forward(v_inputs, policy) reward_map, _ = get_reward(preds_map, targets, policy_map.data) reward_sample, match = get_reward(preds_sample, targets, policy.data) advantage = reward_sample - reward_map loss = -distr.log_prob(policy) loss = loss * Variable(advantage).expand_as(policy) if policy_mask is not None: loss = policy_mask * loss # mask for curriculum learning loss = loss.sum() probs = probs.clamp(1e-15, 1 - 1e-15) entropy_loss = -probs * torch.log(probs) entropy_loss = args.beta * entropy_loss.sum() loss = (loss - entropy_loss) / inputs.size(0) #---------------------------------------------------------------------# optimizer.zero_grad() loss.backward() optimizer.step() matches.append(match.cpu()) rewards.append(reward_sample.cpu()) policies.append(policy.data.cpu()) accuracy, reward, sparsity, variance, policy_set = utils.performance_stats( policies, rewards, matches) log_str = 'E: %d | A: %.3f | R: %.2E | S: %.3f | V: %.3f | #: %d' % ( epoch, accuracy, reward, sparsity, variance, len(policy_set)) print log_str log_value('train_accuracy', accuracy, epoch) log_value('train_reward', reward, epoch) log_value('train_sparsity', sparsity, epoch) log_value('train_variance', variance, epoch) log_value('train_unique_policies', len(policy_set), epoch)
import tensorflow as tf from tensorflow.keras.datasets import cifar10 from tensorflow.keras.preprocessing.image import ImageDataGenerator from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten from tensorflow.keras.layers import Conv2D, Convolution2D, MaxPooling2D, BatchNormalization import numpy as np from tensorflow.keras.callbacks import TensorBoard import pickle import time import utils from collections import Counter from sklearn.metrics import classification_report #build model model_1 = utils.create_model(128, 3, 3) #check performance utils.performance_stats(model_1)