def get_train_data(self): mask = np.zeros([self.users_num, self.items_num], dtype=np.float32) corrupt_input = np.zeros([self.users_num, self.items_num], dtype=np.float32) for user, pos_items in self.user_pos_train.items(): pos_len = len(pos_items) if self.corrupt_prob == 0: corrupt_input[user][pos_items] = 1 elif self.corrupt_prob == 1: pass else: # corrupt input remain_num = int(pos_len * (1 - self.corrupt_prob)) remain_pos = random_choice(pos_items, size=remain_num, replace=False) corrupt_input[user][remain_pos] = 1.0 / (1 - self.corrupt_prob) # mask loss neg_num = pos_len * self.neg_num if neg_num < self.items_num - pos_len: neg_items = random_choice(self.all_items, size=neg_num, replace=False, exclusion=pos_items) mask[user][neg_items.flatten()] = 1 mask[user][pos_items.flatten()] = 1 else: mask[user][:] = 1 return csr_matrix(corrupt_input), csr_matrix(mask)
def find_distributions(self, station, clss, kind): if self.source(station, clss, kind) == 'NoArrivals': return lambda: float('Inf') if self.source(station, clss, kind)[0] == 'Uniform': return lambda: uniform( self.source(station, clss, kind)[1], self.source(station, clss, kind)[2]) if self.source(station, clss, kind)[0] == 'Deterministic': return lambda: self.source(station, clss, kind)[1] if self.source(station, clss, kind)[0] == 'Exponential': return lambda: expovariate(self.source(station, clss, kind)[1]) if self.source(station, clss, kind)[0] == 'Normal': return lambda: truncated_normal( self.source(station, clss, kind)[1], self.source(station, clss, kind)[2]) if self.source(station, clss, kind)[0] == 'Custom': return lambda: random_choice( array=self.source(station, clss, kind)[1], probs=self.source(station, clss, kind)[2]) if self.source(station, clss, kind)[0] == 'UserDefined': return lambda: self.check_userdef_dist( self.source(station, clss, kind)[1]) if self.source(station, clss, kind)[0] == 'TimeDependent': return lambda t: self.check_timedependent_dist( self.source(station, clss, kind)[1], kind, t) if self.source(station, clss, kind)[0] == 'Empirical': if isinstance(self.source(station, clss, kind)[1], str): return lambda: random_choice( self.import_empirical(self.source(station, clss, kind)[1])) return lambda: random_choice(self.source(station, clss, kind)[1])
def run(self, input): plain_blocks = self.splitted(input) perturbed_blocks = [] current_pipeline = random_choice(self.sub_pipelines_weights) for pb in plain_blocks: if not probability_boolean(self.stickyness): current_pipeline = random_choice(self.sub_pipelines_weights) perturbed = self.sub_pipelines[current_pipeline].run(pb) perturbed_blocks.append(perturbed) perturbed_blocks = list(chain(*perturbed_blocks)) return self.detokenizer.apply(perturbed_blocks)
def choose_encounter_for_level(level): table = {L0_ENCOUNTER: utils.from_dungeon_level(level, L0_ENCOUNTER_CHANCES), L1_ENCOUNTER: utils.from_dungeon_level(level, L1_ENCOUNTER_CHANCES), L2_ENCOUNTER: utils.from_dungeon_level(level, L2_ENCOUNTER_CHANCES), L3_ENCOUNTER: utils.from_dungeon_level(level, L3_ENCOUNTER_CHANCES), L4_ENCOUNTER: utils.from_dungeon_level(level, L4_ENCOUNTER_CHANCES), L5_ENCOUNTER: utils.from_dungeon_level(level, L5_ENCOUNTER_CHANCES), L6_ENCOUNTER: utils.from_dungeon_level(level, L6_ENCOUNTER_CHANCES), L7_ENCOUNTER: utils.from_dungeon_level(level, L7_ENCOUNTER_CHANCES)} encounter_level = utils.random_choice(table) encounter_table = ENCOUNTERS_TO_ENCOUNTER_TABLES[encounter_level] return utils.random_choice(encounter_table)
def take_turn(self): if self.is_activated(): # Launch choice = utils.random_choice(self.launch_table) if choice == SCOUT: fighter_component = Fighter(player=player, hp=10, defense=0, power=0, xp=30, base_speed=75, death_function=monster_death) ai_component = ScoutMonster(activated=True) enemy = Object(self.owner.x, self.owner.y, 'S', SCOUT, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == FIGHTER: fighter_component = Fighter(player=player, hp=30, defense=0, power=0, xp=50, base_speed=125, death_function=monster_death) ai_component = FighterMonster(activated=True) enemy = Object(self.owner.x, self.owner.y, 'F', FIGHTER, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) objects.append(enemy) enemy.path_towards(player.x, player.y, game_map, objects, fov_map) # If the player is too close, flak burst if self.owner.distance_to(player) <= 4 and self.current_flak_cooldown == 0: fire_small_shotgun(caster=self.owner, target=player, spread=5, pellets=30) self.current_flak_cooldown += self.flak_cooldown if self.current_flak_cooldown > 0: self.current_flak_cooldown -= 1
def validate(args, epoch, val_data, device, model, criterion, supernet, choice=None): model.eval() val_loss = 0.0 val_top1 = utils.AvgrageMeter() with torch.no_grad(): for step, (inputs, targets) in enumerate(val_data): inputs, targets = inputs.to(device), targets.to(device) if supernet: if choice == None: choice = utils.random_choice(args.num_choices, args.layers) outputs = model(inputs, choice) else: outputs = model(inputs) loss = criterion(outputs, targets) val_loss += loss.item() prec1, prec5 = utils.accuracy(outputs, targets, topk=(1, 5)) n = inputs.size(0) val_top1.update(prec1.item(), n) print('[Val_Accuracy epoch:%d] val_loss:%f, val_acc:%f' % (epoch + 1, val_loss / (step + 1), val_top1.avg)) return val_top1.avg
def train(args, epoch, train_loader, model, criterion, optimizer): model.train() lr = optimizer.param_groups[0]["lr"] train_acc = utils.AverageMeter() train_loss = utils.AverageMeter() steps_per_epoch = len(train_loader) for step, (inputs, targets) in enumerate(train_loader): inputs, targets = inputs.to(args.device), targets.to(args.device) optimizer.zero_grad() choice = utils.random_choice(args.num_choices, args.layers) outputs = model(inputs, choice) loss = criterion(outputs, targets) loss.backward() optimizer.step() prec1, prec5 = utils.accuracy(outputs, targets, topk=(1, 5)) n = inputs.size(0) train_loss.update(loss.item(), n) train_acc.update(prec1.item(), n) if step % args.print_freq == 0 or step == len(train_loader) - 1: logging.info( '[Supernet Training] lr: %.5f epoch: %03d/%03d, step: %03d/%03d, ' 'train_loss: %.3f(%.3f), train_acc: %.3f(%.3f)' % (lr, epoch + 1, args.epochs, step + 1, steps_per_epoch, loss.item(), train_loss.avg, prec1, train_acc.avg)) return train_loss.avg, train_acc.avg
def train(args, epoch, train_data, device, model, criterion, optimizer, scheduler, supernet): model.train() train_loss = 0.0 top1 = utils.AvgrageMeter() train_data = tqdm(train_data) train_data.set_description( '[%s%04d/%04d %s%f]' % ('Epoch:', epoch + 1, args.epochs, 'lr:', scheduler.get_lr()[0])) for step, (inputs, targets) in enumerate(train_data): inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() if supernet: choice = utils.random_choice(args.num_choices, args.layers) outputs = model(inputs, choice) else: outputs = model(inputs) loss = criterion(outputs, targets) # if args.dataset == 'cifar10': loss.backward() # elif args.dataset == 'imagenet': # with amp.scale_loss(loss, optimizer) as scaled_loss: # scaled_loss.backward() optimizer.step() prec1, prec5 = utils.accuracy(outputs, targets, topk=(1, 5)) n = inputs.size(0) top1.update(prec1.item(), n) train_loss += loss.item() postfix = { 'train_loss': '%.6f' % (train_loss / (step + 1)), 'train_acc': '%.6f' % top1.avg } train_data.set_postfix(log=postfix)
def get_a_track(self): """ randomly pick a particle, return it's associated list of hits""" event_key = random_choice(list(self.event_list.keys())) train, truth = self.event_list.get(event_key) pID = truth.sample(1).values hits = train[train['particle_id'] == pID[0]]['uID'].values return hits
def choice_one(idx): p_tmp = p[idx] if p is not None else None exc = exclusion[idx] if exclusion is not None else None return random_choice(array, size[idx], replace=replace, p=p_tmp, exclusion=exc)
def _get_element_for_grid(self): if self._use_elemental_rule: if utils.flip_coin(): self._element = utils.random_choice([e for e in Element]) if self._element != Element.NONE: self._has_element = True else: self._element = Element.NONE else: self._element = Element.NONE
def randomtool(request): if request.method == 'POST': formitem = request.POST.getlist('formitem[]',None) formdescription = request.POST.get('formdescription',None) try: rendomchoice = random_choice(formitem) except: return HttpResponse("输入项有误") rendomresult = formdescription + " : " + rendomchoice return HttpResponse(rendomresult) else: return render(request,'randomtool.html')
def find_next_patient(self): next_patient_indices = [ i for i, ind in enumerate(self.all_patients) if ind.service_end_date == self.next_event_date ] if len(next_patient_indices) > 1: next_patient_index = random_choice(next_patient_indices) else: next_patient_index = next_patient_indices[0] return self.all_patients[next_patient_index], next_patient_index
def change_patient_class(self, patient): """ Takes patient and changes patient class according to a probability distribution. """ if self.class_change: patient.prev_class = patient.patient_class patient.patient_class = random_choice( range(self.simulation.network.number_of_classes), self.class_change[patient.prev_class]) patient.prev_priority_class = patient.priority_class patient.priority_class = self.simulation.network.priority_cls_mapping[ patient.patient_class]
def train(args, epoch, train_data, device, model, criterion, optimizer, scheduler, supernet, choice=None, graft=False): model.train() ##### queue ######### input_q = mp.Queue() output_q = mp.Queue() ##################### train_loss = 0.0 top1 = utils.AvgrageMeter() train_data = tqdm(train_data) eps = args.epochs if supernet == 'supernet': if choice is not None: eps = 50 train_data.set_description('[%s%04d/%04d %s%f]' % ('Epoch:', epoch + 1, eps, 'lr:', scheduler.get_lr()[0])) if graft: model.hook_(i1, j1, get_activation_input_by_index(i)) model.hook_(i2, j2, get_activation_output_by_index(i)) for step, (inputs, targets) in enumerate(train_data): inputs, targets = inputs.to(device), targets.to(device) optimizer.zero_grad() if supernet == 'supernet': if choice is None: choice = utils.random_choice(args.num_choices, args.layers) outputs = model(inputs, choice) else: outputs = model(inputs) loss = criterion(outputs, targets) # if args.dataset == 'cifar10': loss.backward() # elif args.dataset == 'imagenet': # with amp.scale_loss(loss, optimizer) as scaled_loss: # scaled_loss.backward() optimizer.step() #model.move_to_cpu(choice) prec1, prec5 = utils.accuracy(outputs, targets, topk=(1, 5)) n = inputs.size(0) top1.update(prec1.item(), n) train_loss += loss.item() postfix = {'train_loss': '%.6f' % (train_loss / (step + 1)), 'train_acc': '%.6f' % top1.avg} train_data.set_postfix(log=postfix)
def validate(args, val_loader, model, criterion): model.eval() val_loss = utils.AverageMeter() val_acc = utils.AverageMeter() with torch.no_grad(): for step, (inputs, targets) in enumerate(val_loader): inputs, targets = inputs.to(args.device), targets.to(args.device) choice = utils.random_choice(args.num_choices, args.layers) outputs = model(inputs, choice) loss = criterion(outputs, targets) prec1, prec5 = utils.accuracy(outputs, targets, topk=(1, 5)) n = inputs.size(0) val_loss.update(loss.item(), n) val_acc.update(prec1.item(), n) return val_loss.avg, val_acc.avg
def find_next_active_station(self): """ Returns the next active station: """ next_event_date = min( [station.next_event_date for station in self.all_stations]) next_active_station_indices = [ i for i, station in enumerate(self.all_stations) if station.next_event_date == next_event_date ] if len(next_active_station_indices) > 1: return self.all_stations[random_choice( next_active_station_indices)] return self.all_stations[next_active_station_indices[0]]
def get_training_data(self): users = [] pos_items = [] neg_items = [] for u, pos in self.user_pos_train.items(): pos_len = len(pos) neg = random_choice(self.all_items, size=pos_len, exclusion=pos) users.extend([u] * pos_len) pos_items.extend(pos.tolist()) neg_items.extend(neg.tolist()) return DataIterator(users, pos_items, neg_items, batch_size=self.batch_size, shuffle=True)
def default_policy(self): # Default policy, used for rollouts. rollout_reward = 0 obs = self.tree.latest_obs while not (self.env.won('x') or self.env.won('o') or self.env.draw()): # Choose a random action in the rollout. possible_actions = self._get_possible_actions() random_action = random_choice(list(possible_actions)) if self.turn: next_obs, R, _, _ = self.env.step(random_action, self.player) else: next_obs, R, _, _ = self.env.step(random_action, \ self.other_player) obs = next_obs rollout_reward += R self.turn = not self.turn return rollout_reward
def _get_neg_items(self, user): pos_item = self.user_pos_train[user] pos_len = len(pos_item) feed = {self.user_h: [user]} logits = self.sess.run(self.all_logits_tensor, feed_dict=feed) logits = np.reshape(logits, newshape=[-1]) neg_pool = random_choice(self.all_items, size=self.neg_num * pos_len, exclusion=pos_item) neg_logits = logits[neg_pool] neg_pool = np.reshape(neg_pool, newshape=[pos_len, self.neg_num]) neg_logits = np.reshape(neg_logits, newshape=[pos_len, self.neg_num]) neg_item = neg_pool[np.arange(pos_len), np.argmax(neg_logits, axis=1)] return [user] * pos_len, pos_item, neg_item
def __getitem__(self, idx): im_src, im_dst, cam_src, cam_dst, _ = self.dataset[idx] h, w = im_src.shape[:2] im1_ori = torch.from_numpy(im_src) im2_ori = torch.from_numpy(im_dst) im1_tensor = self.transform(im_src) im2_tensor = self.transform(im_dst) coord1 = data_utils.generate_query_kpts(im_src, self.config.train_kp, 10 * self.config.num_pts, h, w) # if no keypoints are detected if len(coord1) == 0: return None # prune query keypoints that are not likely to have correspondence in the other image coord1 = utils.random_choice(coord1, self.config.num_pts) coord1 = torch.from_numpy(coord1).float() K_src, T_src = cam_src K_dst, T_dst = cam_dst T_src2dst = torch.from_numpy(T_dst.dot(np.linalg.inv(T_src))) F = compute_fundamental_from_poses(K_src, K_dst, T_src, T_dst) F = torch.from_numpy(F).float() / (F[-1, -1] + 1e-16) out = { 'im1_ori': im1_ori, 'im2_ori': im2_ori, 'intrinsic1': K_src, 'intrinsic2': K_dst, # Additional, for training 'im1': im1_tensor, 'im2': im2_tensor, 'coord1': coord1, 'F': F, 'pose': T_src2dst } return out
def __getitem__(self, idx): im1, im2, K_src, K_dst, F = self.dataset[idx] h, w = im1.shape[:2] im1_ori, im2_ori = torch.from_numpy(im1), torch.from_numpy(im2) im1_tensor = self.transform(im1) im2_tensor = self.transform(im2) coord1 = data_utils.generate_query_kpts(im1, self.config.train_kp, 10 * self.config.num_pts, h, w) # if no keypoints are detected if len(coord1) == 0: return None # prune query keypoints that are not likely to have correspondence in the other image coord1 = utils.random_choice(coord1, self.config.num_pts) coord1 = torch.from_numpy(coord1).float() F = torch.from_numpy(F).float() / (F[-1, -1] + 1e-16) out = { 'im1_ori': im1_ori, 'im2_ori': im2_ori, 'intrinsic1': K_src, 'intrinsic2': K_dst, # Additional, for training 'im1': im1_tensor, 'im2': im2_tensor, 'coord1': coord1, 'F': F, # Pose is required in the base but not used in CAPSModel 'pose': np.eye(4) } return out
def tree_policy(self): # Policy that determines how to move through the MCTS tree. while not (self.env.won('x') or self.env.won('o') or self.env.draw()): # Get current node node = self.tree.nodes[self.tree.curr_node_num] # Get possible actions possible_actions = self._get_possible_actions() # Get already performed actions already_done = set(node.edges.keys()) # What have we not tried? not_tried = possible_actions - already_done # Expand if it is possible to perform a new action if len(not_tried) > 0: self.expand(node, not_tried) self.turn = not self.turn return else: if self.turn: # If our turn, choose what is suggested through UCB action = self.best_action(node, 1) else: action = random_choice(list(possible_actions)) self.move(action) self.turn = not self.turn
def random_choice(self) -> List[int]: return utils.random_choice(self.nb, self.nl)
def __getitem__(self, item): imf1 = self.imf1s[item] imf2 = self.imf2s[item] im1_meta = self.images[imf1] im2_meta = self.images[imf2] im1 = io.imread(imf1) if self.args.use_stylization and self.is_stylized_frame[item]: imf2_s = osp.join(self.stylization_path, imf2[len(self.args.datadir) + 1:]) if osp.isfile(imf2_s): imf2 = imf2_s im2 = io.imread(imf2) h, w = im1.shape[:2] intrinsic1 = self.get_intrinsics(im1_meta) intrinsic2 = self.get_intrinsics(im2_meta) extrinsic1 = self.get_extrinsics(im1_meta) extrinsic2 = self.get_extrinsics(im2_meta) relative = extrinsic2.dot(np.linalg.inv(extrinsic1)) R = relative[:3, :3] # remove pairs that have a relative rotation angle larger than 80 degrees theta = np.arccos(np.clip((np.trace(R) - 1) / 2, -1, 1)) * 180 / np.pi if theta > 80 and self.phase == 'train': return None T = relative[:3, 3] tx = data_utils.skew(T) E_gt = np.dot(tx, R) F_gt = np.linalg.inv(intrinsic2).T.dot(E_gt).dot(np.linalg.inv(intrinsic1)) # generate candidate query points coord1 = data_utils.generate_query_kpts(im1, self.args.train_kp, 10*self.args.num_pts, h, w) # if no keypoints are detected if len(coord1) == 0: return None # prune query keypoints that are not likely to have correspondence in the other image if self.args.prune_kp: ind_intersect = data_utils.prune_kpts(coord1, F_gt, im2.shape[:2], intrinsic1, intrinsic2, relative, d_min=4, d_max=400) if np.sum(ind_intersect) == 0: return None coord1 = coord1[ind_intersect] coord1 = utils.random_choice(coord1, self.args.num_pts) coord1 = torch.from_numpy(coord1).float() im1_ori, im2_ori = torch.from_numpy(im1), torch.from_numpy(im2) F_gt = torch.from_numpy(F_gt).float() / (F_gt[-1, -1] + 1e-10) intrinsic1 = torch.from_numpy(intrinsic1).float() intrinsic2 = torch.from_numpy(intrinsic2).float() pose = torch.from_numpy(relative[:3, :]).float() im1_tensor = self.transform(im1) im2_tensor = self.transform(im2) out = {'im1': im1_tensor, 'im2': im2_tensor, 'im1_ori': im1_ori, 'im2_ori': im2_ori, 'pose': pose, 'F': F_gt, 'intrinsic1': intrinsic1, 'intrinsic2': intrinsic2, 'coord1': coord1} return out
train=False, download=False, transform=valid_transform) val_loader = torch.utils.data.DataLoader(valset, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=8) # random search start = time.time() best_acc = 0.0 acc_list = list() best_choice = list() for epoch in range(args.random_search): choice = utils.random_choice(args.num_choices, args.layers) top1_acc = validate(args, epoch, val_loader, device, model, criterion, super=True, choice=choice) acc_list.append(top1_acc) if best_acc < top1_acc: best_acc = top1_acc best_choice = choice print('acc_list:') for i in acc_list: print(i)
def train(model, device, args, *, bn_process=True, all_iters=None, reporter=None): optimizer = args.optimizer loss_function = args.loss_function scheduler = args.scheduler train_dataprovider = args.train_dataprovider task_id = args.task_id val_interval = args.val_interval display_interval = args.val_interval t1 = time.time() Top1_err, Top5_err = 0.0, 0.0 model.train() # iters 1-> , for iters in range(1, val_interval + 1): if bn_process: adjust_bn_momentum(model, iters) all_iters += 1 d_st = time.time() data, target = train_dataprovider.next() target = target.type(torch.LongTensor) data, target = data.to(device), target.to(device) data_time = time.time() - d_st # search space if args.block==5: # shuffle, 4 choice in one block, 20 choices # get_random_cand = lambda:tuple(np.random.randint(4) for i in range(20)) # imagenet # get_random_cand = lambda:tuple(np.random.randint(2) for i in range(5)) # cifar get_random_cand = lambda:tuple(np.random.randint(args.sample_path) for i in range(args.block)) # cifar # uniform # flops restriction if args.flops_restriction: flops_l, flops_r, flops_step = 290, 360, 10 bins = [[i, i + flops_step] for i in range(flops_l, flops_r, flops_step)] # 300 * 1000 000 def get_uniform_sample_cand(*, timeout=500): idx = np.random.randint(len(bins)) l, r = bins[idx] for i in range(timeout): cand = get_random_cand() # if l*1e6 <= get_cand_flops(cand) <= r*1e6: # return cand return cand return get_random_cand() output = model(data, get_uniform_sample_cand()) else: output = model(data, get_random_cand()) elif args.block==12: # s1, sample_choice=1,45s/epoch, sample_choice=3,65s/epoch choice = random_choice(path_num=args.choice, m=args.sample_path, layers=args.block) output = model(data, choice) elif args.block==4: # cifar_fast # choice = random_choice(path_num=args.choice, m=1, layers=args.block) # batch = {'input': data, 'target': target, 'choice': choice} batch = {'input': data, 'target': target} states = model(batch) output = states['logits'] elif args.block==3: # sample # (0,1,2) * 4 == 3^4= 81 # choice, [(0,1,2) (0,1,2)] *2 # get_random_cand = lambda: tuple(np.random.randint(9) for i in range(2)) # arch = [get_random_cand() for i in range(2)] # 9*9 + architecture = [np.random.randint(1) for i in range(2)] output = model(data, architecture) loss = loss_function(output, target) optimizer.zero_grad() loss.backward() for p in model.parameters(): if p.grad is not None and p.grad.sum() == 0: p.grad = None optimizer.step() scheduler.step() prec1, prec5 = accuracy(output, target, topk=(1, 5)) Top1_err += 1 - prec1.item() / 100 Top5_err += 1 - prec5.item() / 100 if all_iters % display_interval == 0: #20 # print('{}-task_id: {}, lr: {}'.format(args.signal, args.task_id, args.learning_rate)) printInfo = '{}-Task_id: {}, Base_lr: {:.2f},\t'.format(args.signal, args.task_id, args.learning_rate) + \ 'TRAIN Epoch {}: Iters {}, lr = {:.4f}, \tloss = {:.4f},\t'.format(all_iters / display_interval, all_iters, scheduler.get_lr()[0], loss.item()) + \ 'Top-1 err = {:.4f},\t'.format(Top1_err / display_interval) + \ 'Top-5 err = {:.4f},\t'.format(Top5_err / display_interval) + \ 'epoch_train_time = {:.2f}'.format(time.time() - t1) # 'iter_load_data_time = {:.6f},\tepoch_train_time = {:.6f}'.format(data_time, time.time() - t1) # printInfo = '{}-Task_id: {}, Base_lr: {:.2f},\t'.format(args.signal, args.task_id, args.learning_rate) + \ # 'TRAIN Epoch {}: lr = ({}):{:.4f}\{:.4f},\tloss = {:.4f},\t'.format(all_iters / display_interval, len(scheduler.get_lr()), scheduler.get_lr()[0], scheduler.get_lr()[1],loss.item()) + \ # 'Top-1 err = {:.4f},\t'.format(Top1_err / display_interval) + \ # 'Top-5 err = {:.4f},\t'.format(Top5_err / display_interval) + \ # 'epoch_train_time = {:.2f}'.format(time.time() - t1) # 'iter_load_data_time = {:.6f},\tepoch_train_time = {:.6f}'.format(data_time, time.time() - t1) logging.info(printInfo) t1 = time.time() report_top1, report_top5 = 1 - Top1_err/ display_interval, 1 - Top5_err / display_interval # print(all_iters / display_interval, report_top1) reporter(task_id=task_id, epoch=all_iters / display_interval, train_acc=report_top1) # reporter(task_id=task_id, epoch=all_iters / display_interval, train_acc=report_top1, lr_group = args.lr_group if args.lr_group else optimizer.param_groups['initial_lr']) Top1_err, Top5_err = 0.0, 0.0 # lr group log for index, param_group in enumerate(optimizer.param_groups): logging.info("lr_group:({}/{}),update_lr/base_lr:{:.4f}/{:.4f}".format(index+1, len(scheduler.get_lr()), param_group['lr'], param_group['initial_lr'])) val_top1_acc = 0 # initial_lr if all_iters % (args.save_interval * val_interval) == 0: save_checkpoint(args.path, {'state_dict': model.state_dict(),}, all_iters, tag='{}_Supernet_'.format(task_id)) latestfilename = os.path.join("{}/models/{}checkpoint-{:06}.pth.tar".format(args.path, '{}_Supernet_'.format(task_id), all_iters)) logging.info(latestfilename) checkpoint = torch.load(latestfilename, map_location=None) model.load_state_dict(checkpoint['state_dict'], strict=True) val_top1_acc = validate(model, device, args, all_iters=all_iters, architecture=architecture) # reporter(task_id=task_id, epoch=all_iters / display_interval, train_acc=val_top1_acc) return all_iters, val_top1_acc
def place_objects(gm, zone, safe=False): num_satellites = utils.from_dungeon_level(dungeon_level, SATELLITES_PER_LEVEL) for _ in range(num_satellites): (x, y) = zone.random_coordinates() if not is_blocked(x, y, gm, objects): fighter_component = Fighter(player=player, hp=1, defense=9999, power=0, xp=0, death_function=projectile_death) monster = Object(x, y, '#', 'satellite', libtcod.white, blocks=True, fighter=fighter_component) non_interactive_objects.append(monster) # TODO: Hack! gm[x][y].blocked = True if not safe: encounter = tables.choose_encounter_for_level(dungeon_level) else: encounter = tables.EMPTY_ENCOUNTER zone.encounter = encounter enemies = tables.encounters_to_ship_lists[encounter] for choice in enemies: (x, y) = zone.random_unblocked_coordinates(gm, objects) if choice == SCOUT: fighter_component = Fighter(player=player, hp=10, defense=0, power=0, xp=30, base_speed=75, death_function=monster_death) ai_component = ScoutMonster() monster = Object(x, y, 'S', SCOUT, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == FIGHTER: fighter_component = Fighter(player=player, hp=30, defense=0, power=0, xp=50, base_speed=125, death_function=monster_death) ai_component = FighterMonster() monster = Object(x, y, 'F', FIGHTER, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == GUNSHIP: fighter_component = Fighter(player=player, hp=50, defense=4, power=3, xp=100, base_speed=100, death_function=monster_death) ai_component = GunshipMonster() monster = Object(x, y, 'G', GUNSHIP, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == FRIGATE: fighter_component = Fighter(player=player, hp=150, defense=10, power=3, xp=200, base_speed=250, death_function=monster_death) ai_component = FrigateMonster() monster = Object(x, y, 'R', FRIGATE, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == DESTROYER: fighter_component = Fighter(player=player, hp=200, defense=15, power=0, xp=500, base_speed=300, death_function=monster_death) ai_component = DestroyerMonster() monster = Object(x, y, 'D', DESTROYER, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == CRUISER: fighter_component = Fighter(player=player, hp=300, defense=10, power=0, xp=1000, base_speed=400, death_function=monster_death) ai_component = CruiserMonster() monster = Object(x, y, 'C', CRUISER, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == CARRIER: fighter_component = Fighter(player=player, hp=500, defense=0, power=0, xp=2000, base_speed=200, death_function=monster_death) ai_component = CarrierMonster() monster = Object(x, y, 'A', CARRIER, libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) elif choice == 'placeholder': print('placeholder encounter') fighter_component = Fighter(player=player, hp=10, defense=0, power=0, xp=30, base_speed=75, death_function=projectile_death) ai_component = ScoutMonster() monster = Object(x, y, 'P', 'placeholder', libtcod.darker_green, blocks=True, fighter=fighter_component, ai=ai_component) objects.append(monster) max_items = utils.from_dungeon_level(dungeon_level, [[3, 1], [2, 4], [1, 6]]) item_chances = {ITEM_DUCT_TAPE: 45, ITEM_EXTRA_BATTERY: 25, ITEM_RED_PAINT: 10, ITEM_EMP: 10} # Place items num_items = libtcod.random_get_int(0, 0, max_items) for _ in range(num_items): (x, y) = zone.random_unblocked_coordinates(gm, objects) choice = utils.random_choice(item_chances) if choice == ITEM_DUCT_TAPE: item_component = Item(use_function=use_repair_player) item = Object(x, y, 't', ITEM_DUCT_TAPE, libtcod.violet, always_visible=True, item=item_component) elif choice == ITEM_EXTRA_BATTERY: item_component = Item(use_function=boost_player_power) item = Object(x, y, 'b', ITEM_EXTRA_BATTERY, libtcod.light_yellow, always_visible=True, item=item_component) elif choice == ITEM_EMP: item_component = Item(use_function=cast_area_disable) item = Object(x, y, 'p', ITEM_EMP, libtcod.light_blue, always_visible=True, item=item_component) elif choice == ITEM_RED_PAINT: item = Object(x, y, 'r', ITEM_RED_PAINT, libtcod.light_red, always_visible=True, item=Item(use_function=boost_player_speed)) objects.append(item) zone.register_item(item) item.send_to_back(objects)
def expand(self, node, not_tried): # Create a new node from the given node. Chooses an action from the # not_tried set. Also moves to the newly created node. random_action = random_choice(list(not_tried)) self.tree.new_node(random_action) return self.move(random_action)
def __getitem__(self, idx): # 每一个epoch,从前往后读取self.ids,依据id,读取self.names # idx应为第几个batch,i为该次batch的起始点 i = idx * batch_size # length为当前batch的大小 length = min(batch_size, (len(self.names) - i)) batch_x = np.empty((length, img_rows, img_cols, 3), dtype=np.float32) batch_y = np.empty((length, img_rows, img_cols, num_classes), dtype=np.uint8) for i_batch in range(length): ###normal img_name = self.names[i] # xx.jpg img_name_prefix, useless = os.path.splitext(img_name) mask_name = img_name_prefix + '.png' image_path = os.path.join(rgb_image_path, img_name) image = cv2.imread(image_path, 1) mask_path = os.path.join(mask_img_path, mask_name) mask = cv2.imread(mask_path, 0) ###temp # img_name = self.names[i] # xx.jpg # image_path = os.path.join(rgb_image_path, img_name) # image = cv2.imread(image_path,1) # img_name_prefix = img_name.split('split')[0][0:-1] # mask_name = img_name_prefix+'.png' # mask_path = os.path.join(mask_img_path, mask_name) # mask = cv2.imread(mask_path,0) ##mask = (mask!=0)*255 # 随机缩放image和mask,0.5~2.0 image, mask = random_rescale_image_and_mask(image, mask) # 实时处理alpha,得到trimap:128/0/255 trimap = generate_random_trimap(mask) # 定义随机剪裁尺寸 crop_size = (512, 512) # 获得剪裁的起始点,其目的是为了保证剪裁的图像中包含未知像素 x, y = random_choice(trimap, crop_size) # 剪裁image,到指定剪裁尺寸crop_size,并缩放到(img_rows,img_cols) image = safe_crop(image, x, y, crop_size) # 剪裁trimap,到指定剪裁尺寸crop_size,并缩放到(img_rows,img_cols) trimap = safe_crop(trimap, x, y, crop_size) if np.random.random_sample() > 0.5: image = np.fliplr(image) trimap = np.fliplr(trimap) ### save the image/trimap crop patch # patch_save_dir = "show_data_loader" # image_patch_path = "show_data_loader" + '/' + img_name_prefix + '_image_' + str(i_batch) + '.png' # trimap_patch_path = "show_data_loader" + '/' + img_name_prefix + '_trimap_' + str(i_batch) + '.png' # cv2.imwrite(image_patch_path,image) # cv2.imwrite(trimap_patch_path,trimap) batch_x[i_batch] = image / 255.0 batch_y[i_batch] = make_trimap_for_batch_y(trimap) i += 1 return batch_x, batch_y
def next_station(self, patient_class): return random_choice(array=self.simulation.all_stations[1:], probs=self.transition_row[patient_class] + [1.0 - sum(self.transition_row[patient_class])])