def _report_rouge(self, predictions, references): a_lst = [] predictions = list(predictions) references = list(references) for i, p in enumerate(predictions): a_lst.append((p, references[i])) pool = Pool(24) rouge_scores = {"r1": [], "r2": [], "rl": []} for d in tqdm(pool.imap(_multi_rg, a_lst), total=len(a_lst)): if d is not None: rouge_scores["r1"].append(d[0]) rouge_scores["r2"].append(d[1]) rouge_scores["rl"].append(d[2]) pool.close() pool.join() r1 = np.mean(rouge_scores["r1"]) r2 = np.mean(rouge_scores["r2"]) rl = np.mean(rouge_scores["rl"]) if len(self.args.log_folds) > 0: with open(self.args.log_folds, mode='a') as f: f.write("{:.4f}\t{:.4f}\t{:.4f}".format(r1 / 100, r2 / 100, rl / 100)) f.write('\n') logger.info("Metric\tScore\t95% CI") logger.info("ROUGE-1\t{:.2f}\t({:.2f},{:.2f})".format(r1 * 100, 0, 0)) logger.info("ROUGE-2\t{:.2f}\t({:.2f},{:.2f})".format(r2 * 100, 0, 0)) logger.info("ROUGE-L\t{:.2f}\t({:.2f},{:.2f})".format(rl * 100, 0, 0)) logger.info("Data path: %s" % self.args.bert_data_path) logger.info("Model path: %s" % self.args.model_path) return r1, r2, rl
class ParallDataWraper(): def __init__(self, loader, batch_size, thread=0): self.loader = loader assert loader.shuffle == False, 'Shuffle in loader should be False' self.batch_size = batch_size self.pool = Pool(thread) self.create_loader(self.loader.num_data) def create_loader(self, num): ids = [a for a in range(num)] random.shuffle(ids) self.targets = self.pool.imap(self.loader.next, (id for id in ids)) def reset(self): self.create_loader(self.loader.num_data) def get_iter_epoch(self): return self.loader.get_iter_epoch() def load_batch(self): all_outputs = [] for i in range(self.batch_size): try: outputs = self.targets.__next__() except StopIteration: self.create_loader(self.loader.num_data) outputs = self.targets.__next__() all_outputs.append(outputs) return pack_data(all_outputs)
class ParallDataWraper(): def __init__(self, loader, batch_size, thread=0): self.loader = loader self.batch_size = batch_size self.pool = Pool(thread) self.create_loader(self.loader.num_data) def create_loader(self, num): # print ('--> remap and shuffle iterator') ids = [a for a in range(num)] random.shuffle(ids) self.targets = self.pool.imap(self.loader.next, (id for id in ids)) def reset(self): self.create_loader(self.loader.num_data) def load_batch(self): all_outputs = [] for i in range(self.batch_size): try: outputs = self.targets.__next__() except StopIteration: self.create_loader(self.loader.num_data) outputs = self.targets.__next__() all_outputs.append(outputs) return pack_data(all_outputs)
def tune_from_args(args): params_grid = list( product( torch.linspace(args.alpha_from, args.alpha_to, args.alpha_steps), torch.linspace(args.beta_from, args.beta_to, args.beta_steps))) LOG.info( 'Scheduling {} jobs for alphas=linspace({}, {}, {}), betas=linspace({}, {}, {})' .format(len(params_grid), args.alpha_from, args.alpha_to, args.alpha_steps, args.beta_from, args.beta_to, args.beta_steps)) # start worker processes LOG.info( f"Using {args.num_workers} processes and {args.lm_workers} for each CTCDecoder." ) extract_start = default_timer() if args.unit == 'char': vocab = CharTokenizer(args.vocab_file, reserved_tokens={ 'blank': '<blank>', 'space': args.space_token }) else: vocab = WordTokenizer(args.vocab_file) p = Pool(args.num_workers, init, [ args.logits_targets_file, vocab, args.lm_path, args.lm_trie_path, args.lm_unit, args.beam_size, args.cutoff_prob, args.cutoff_top_n ]) scores = [] best_wer = float('inf') with tqdm.tqdm(p.imap(tune_step, params_grid), total=len(params_grid), desc='Grid search') as pbar: for params in pbar: alpha, beta, wer, cer = params scores.append([alpha, beta, wer, cer]) if wer < best_wer: best_wer = wer pbar.set_postfix(alpha=alpha, beta=beta, wer=wer, cer=cer) LOG.info( f"Finished {len(params_grid)} processes in {default_timer() - extract_start:.1f}s" ) df = pd.DataFrame(scores, columns=['alpha', 'beta', 'wer', 'cer']) df.to_csv(args.output_file, index=False)
net_utils.load_net(trained_model, net) # net.load_from_npz(npz_fname) # net_utils.save_net(h5_fname, net) net.cuda() net.eval() print('load model succ...') t_det = Timer() t_total = Timer() im_fnames = sorted((fname for fname in os.listdir(im_path) if os.path.splitext(fname)[-1] == '.jpg')) im_fnames = (os.path.join(im_path, fname) for fname in im_fnames) pool = Pool(processes=1) for i, (image, im_data) in enumerate(pool.imap( preprocess, im_fnames, chunksize=1)): t_total.tic() im_data = net_utils.np_to_variable( im_data, is_cuda=True, volatile=True).permute(0, 3, 1, 2) t_det.tic() bbox_pred, iou_pred, prob_pred = net(im_data) det_time = t_det.toc() # to numpy bbox_pred = bbox_pred.data.cpu().numpy() iou_pred = iou_pred.data.cpu().numpy() prob_pred = prob_pred.data.cpu().numpy() # print bbox_pred.shape, iou_pred.shape, prob_pred.shape bboxes, scores, cls_inds = yolo_utils.postprocess( bbox_pred, iou_pred, prob_pred, image.shape, cfg, thresh)
th2_vals = np.linspace(th2_min, th2_max, num_th2) th_results = np.zeros((th1_vals.size, th2_vals.size)) rewards = np.zeros((th1_vals.size, th2_vals.size)) last_err = np.zeros((th1_vals.size, th2_vals.size)) end_point = torch.tensor([1.57079633, 0., 0., 0.]) import time start = time.time() print("lets go") for i, res in enumerate( pool.imap(do_rollout_stable, product(th1_vals, th2_vals, [0], [0]))): print("did something") obs_hist, action_hist, reward_hist, _, _ = res last_err.flat[i] = torch.sum(abs(obs_hist[-1] - end_point)) errs = torch.sum(abs(obs_hist[-1:] - end_point), axis=1) < .5 th_results.flat[i] = errs.all() rewards.flat[i] = sum(reward_hist) # # for i,res in enumerate(product(th1_vals, th2_vals, [0], [0])): # obs_hist, action_hist, reward_hist, _, _ = do_rollout_stable(res) # errs = torch.sum(abs(obs_hist[-10:] - end_point) , axis=1) < .2 # th_results.flat[i] = errs.all() # rewards.flat[i] = sum(reward_hist) end = time.time()
th1_min = pi / 2 - .5 th1_max = pi / 2 + .5 th2_min = -1 th2_max = 1 th1dot_min = -5 th1dot_max = 5 th2dot_min = -10 th2dot_max = 10 samples = np.random.random_sample((int(num_trials/2), 4)) samples *= np.array([th1_min - th1_max, th2_min - th2_max, th1dot_min - th1dot_max, th2dot_min - th2dot_max]) samples += np.array([th1_max, th2_max, th1dot_max, th2dot_max]) total_steps = 0 pool = Pool() # defaults to number of available CPU's for i, res in enumerate(pool.imap(do_rollout, zip(samples, range(int(num_trials/2))))): rews, steps = res reward_hist[i, :, :] = rews total_steps += steps X[i, :] = samples[i, :] Y[i] = sum(rews) > env.num_steps*3 - 10 th1_min = 0 th1_max = 2*pi th2_min = -pi th2_max = pi th1dot_min = -10 th1dot_max = 10 th2dot_min = -30 th2dot_max = 30
th2_max = pi num_th2 = 41 th2_vals = np.linspace(th2_min, th2_max, num_th2) th_results = np.zeros((th1_vals.size, th2_vals.size)) th_lqr_results = np.zeros((th1_vals.size, th2_vals.size)) rewards = np.zeros((th1_vals.size, th2_vals.size)) end_point = torch.tensor([1.57079633, 0., 0., 0.]) import time start = time.time() for i, res in enumerate( pool.imap(do_rollout, product(th1_vals, th2_vals, [0], [0]))): obs_hist, action_hist, reward_hist, lqr_on = res errs = torch.sum(abs(obs_hist[-10:] - end_point), axis=1) < .2 th_results.flat[i] = errs.all() th_lqr_results.flat[i] = lqr_on[-1] rewards.flat[i] = sum(reward_hist) end = time.time() print(end - start) # Generate "balance map" at slice th = 0 dth1_min = -10 dth1_max = 10 num_dth1 = 41 dth1_vals = np.linspace(dth1_min, dth1_max, num_dth1)
def tune_from_args(args): # Disable some of the more verbose logging statements logging.getLogger('asr.common.params').disabled = True logging.getLogger('asr.common.registrable').disabled = True # Load from archive _, weights_file = load_archive(args.serialization_dir, args.overrides, args.weights_file) params = Params.load(os.path.join(args.serialization_dir, CONFIG_NAME), args.overrides) prepare_environment(params) # Try to use the validation dataset reader if there is one - otherwise fall back # to the default dataset_reader used for both training and validation. dataset_params = params.pop('val_dataset', params.get('dataset_reader')) logger.info("Reading evaluation data from %s", args.input_file) dataset_params['manifest_filepath'] = args.input_file dataset = datasets.from_params(dataset_params) if os.path.exists(os.path.join(args.serialization_dir, "alphabet")): alphabet = Alphabet.from_file( os.path.join(args.serialization_dir, "alphabet", "tokens")) else: alphabet = Alphabet.from_params(params.pop("alphabet", {})) logits_dir = os.path.join(args.serialization_dir, 'logits') os.makedirs(logits_dir, exist_ok=True) basename = os.path.splitext(os.path.split(args.input_file)[1])[0] logits_file = os.path.join(logits_dir, basename + '.pth') if not os.path.exists(logits_file): model = models.from_params(alphabet=alphabet, params=params.pop('model')) model.load_state_dict( torch.load(weights_file, map_location=lambda storage, loc: storage)['model']) model.eval() decoder = GreedyCTCDecoder(alphabet) loader_params = params.pop("val_data_loader", params.get("data_loader")) batch_sampler = samplers.BucketingSampler(dataset, batch_size=args.batch_size) loader = loaders.from_params(loader_params, dataset=dataset, batch_sampler=batch_sampler) logger.info(f'Logits file `{logits_file}` not found. Generating...') with torch.no_grad(): model.to(args.device) logits = [] for batch in tqdm.tqdm(loader): sample, target, sample_lengths, target_lengths = batch sample = sample.to(args.device) sample_lengths = sample_lengths.to(args.device) output, output_lengths = model(sample, sample_lengths) output = output.to('cpu') references = decoder.tensor2str(target, target_lengths) logits.extend((o[:l, ...], r) for o, l, r in zip( output.to('cpu'), output_lengths, references)) del sample, sample_lengths, output torch.save(logits, logits_file) del model tune_dir = os.path.join(args.serialization_dir, 'tune') os.makedirs(tune_dir, exist_ok=True) params_grid = list( product( torch.linspace(args.alpha_from, args.alpha_to, args.alpha_steps), torch.linspace(args.beta_from, args.beta_to, args.beta_steps))) print( 'Scheduling {} jobs for alphas=linspace({}, {}, {}), betas=linspace({}, {}, {})' .format(len(params_grid), args.alpha_from, args.alpha_to, args.alpha_steps, args.beta_from, args.beta_to, args.beta_steps)) # start worker processes logger.info( f"Using {args.num_workers} processes and {args.lm_workers} for each CTCDecoder." ) extract_start = default_timer() p = Pool(args.num_workers, init, [ logits_file, alphabet, args.lm_path, args.cutoff_top_n, args.cutoff_prob, args.beam_width, args.lm_workers ]) scores = [] best_wer = float('inf') with tqdm.tqdm(p.imap(tune_step, params_grid), total=len(params_grid), desc='Grid search') as pbar: for params in pbar: alpha, beta, wer, cer = params scores.append([alpha, beta, wer, cer]) if wer < best_wer: best_wer = wer pbar.set_postfix(alpha=alpha, beta=beta, wer=wer, cer=cer) logger.info( f"Finished {len(params_grid)} processes in {default_timer() - extract_start:.1f}s" ) df = pd.DataFrame(scores, columns=['alpha', 'beta', 'wer', 'cer']) df.to_csv(os.path.join(tune_dir, basename + '.csv'), index=False)
glob=False)) props.append(prop) print(i) i += 1 # mp = _mp.get_context('forkserver') # set_start_method('spawn') pool = Pool(processes=4) manager = Manager() # mols = manager.list([[] for _ in range(len(datas))]) # mols = manager.list([]) # pool.map(get_mol,datas,chunksize=100) i = 0 for _ in pool.imap(bd_mol, mols, chunksize=100): print(i) # mols[i] = _ i += 1 # props = np.concatenate(props,axis=0) #process based # processes = [] # # indexes = [range(i*3000,(i+1)*3000) for i in range(4)] # for i in range(4): # p = Process(target=get_mols, args=(mols, [datas[j] for j in indexes[i]])) # p.start() # processes.append(p) #
class DatasetSmall(): def __init__(self, hd_folder, reg_folder=None, batch_size=64, ext_list=['.bmp', '.tif', '.png'], img_size=128): # super(DatasetSmall, self).__init__() self.hd_imgs_org = [] self.reg_imgs_org = [] self.batch_size = batch_size self.ratio_pool = np.arange(0.5, 0.75, 0.01) img_count = 0 self.hd_filelist, self.hd_filenames = getfilelist(hd_folder, ext_list, with_ext=True) self.count = 0 self.reset_count = 20000 self.img_size = img_size self.epoch_iteration = 5000 self.pool = Pool(6) for this_hd_path, this_hd_name in zip(self.hd_filelist, self.hd_filenames): this_reg_path = os.path.join(reg_folder, this_hd_name) reg_img_orig = imread(this_reg_path).astype(np.float32) hd_img_orig = imread(this_hd_path).astype(np.float32) hd_row, hd_col, chn = hd_img_orig.shape #reg_row, reg_col, chn = reg_img_orig.shape # now pad the image to at least img_size * 1.4 pad_hd_row, pad_hd_col = max(0, int(1.4 * img_size) - hd_row), max( 0, int(1.4 * img_size) - hd_col) npad3 = ((pad_hd_row // 2, pad_hd_row - pad_hd_row // 2), (pad_hd_col // 2, pad_hd_col - pad_hd_col // 2), (0, 0)) hd_img_orig = np.pad(hd_img_orig, npad3, 'symmetric') reg_img_orig = np.pad(reg_img_orig, npad3, 'symmetric') hd_img = (hd_img_orig / 127.5 - 1) reg_img = (reg_img_orig / 127.5 - 1) self.hd_imgs_org.append(hd_img) self.reg_imgs_org.append(reg_img) img_count += 1 print('Generated {} images'.format(img_count), hd_img_orig.shape) self.num_imgs = len(self.hd_imgs_org) print('start rotate') self.hd_imgs = [] self.reg_imgs = [] self.rotate_img() def rotate_img(self): self.hd_imgs = [] self.reg_imgs = [] targets = self.pool.imap( rotate_thread, ((self.hd_imgs_org[img_idx], self.reg_imgs_org[img_idx]) for i in range(self.num_imgs))) for img_idx in range(self.num_imgs): this_hd_img, this_reg_img = targets.__next__() self.hd_imgs.append(this_hd_img) self.reg_imgs.append(this_reg_img) def get_next(self): if self.count > 0 and self.count % self.reset_count == 0: self.rotate_img() self.count = 0 chose_img_index = np.random.choice(self.num_imgs, self.batch_size) chose_imgs = len(chose_img_index) hd_data_list = [] reg_data_list = [] already_taken = 0 every_taken = int(self.batch_size / chose_imgs) for img_idx in chose_img_index: this_hd = self.hd_imgs[img_idx] this_reg = self.reg_imgs[img_idx] # rotate the image br = self.img_size // 2 + 1 this_chose = min(self.batch_size - already_taken, every_taken) already_taken = already_taken + this_chose #for idx in range(this_chose): this_chose_count = 0 blank_count = 0 while this_chose_count < this_chose: row_size, col_size = this_hd.shape[0:2] try: ridx = random.randint(0, row_size - self.img_size - 1) cidx = random.randint(0, col_size - self.img_size - 1) hd_data = this_hd[ridx:ridx + self.img_size, cidx:cidx + self.img_size, :] if random.random() > 0.3: reg_data = this_reg[ridx:ridx + self.img_size, cidx:cidx + self.img_size, :] else: #sometime, I just use true data and make it small to train the model this_down_ratio = np.random.choice(self.ratio_pool, size=1, replace=False)[0] hd_row, hd_col, chn = hd_data.shape low_row, low_col = int(this_down_ratio * hd_row), int( this_down_ratio * hd_col) low_hd = imresize_shape(hd_data, (low_row, low_col)) #print(np.mean(reg_img_down)) low_hd = imresize_shape(low_hd, (hd_row, hd_col)) #print('max and min value of hd image: ', np.max(low_hd), np.min(low_hd)) sigma = np.random.choice([1, 2], size=1, replace=False)[0] reg_data = skimage.filters.gaussian(low_hd.astype( np.float32), sigma=sigma, multichannel=True) hd_data_list.append(hd_data) reg_data_list.append(reg_data) except: print( 'we have problem cropping the training data, img_size: ', row_size, col_size) this_chose_count += 1 blank_count = 0 #import pdb; pdb.set_trace() #import pdb; pdb.set_trace() hd_data_np = np.asarray(hd_data_list, dtype=np.float32) reg_data_np = np.asarray(reg_data_list, dtype=np.float32) hd_data_np = np.transpose(hd_data_np, (0, 3, 1, 2)) reg_data_np = np.transpose(reg_data_np, (0, 3, 1, 2)) self.count += self.batch_size return {'low': reg_data_np, 'high': hd_data_np}
class Environment(ParamTree): """Environment for executing training and post training evaluations. Takes care of process pool, reporting, and experiment parameters. Parameters ---------- params : dict or str Dictionary containing the parameters or a path to a parameters spec file. """ from .util import (default_params, setup_params, open_data, store_gen, store_gen_metrics, load_gen_metrics, stored_populations, stored_indiv_measurements, store_hof, load_hof, load_pop, load_indiv_measurements, env_path) def __init__(self, params): """Initialize an environment for training or post training analysis.""" super().__init__() self.setup_params(params) self.metrics = list() self.pool = None self.data_file = None self.hall_of_fame = list() # choose task self.task = select_task(self['task', 'name']) # choose adequate type of individuals if self['config', 'backend'].lower() == 'torch': import wann_genetic.individual.torch as backend else: import wann_genetic.individual.numpy as backend if self.task.is_recurrent: self.ind_class = backend.RecurrentIndividual else: self.ind_class = backend.Individual # only use enabled activations functions available_funcs = self.ind_class.Phenotype.available_act_functions enabled_acts = self['population', 'enabled_activation_funcs'] if self['population', 'enabled_activation_funcs'] != 'all': self.ind_class.Phenotype.enabled_act_functions = [ available_funcs[i] for i in enabled_acts ] def seed(self, seed): """Set seed to `seed` or from parameters. Parameters ---------- seed : int Seed to use. """ np.random.seed(seed) @property def elite_size(self): """Size of the elite (:math:`population\\ size * elite\\ ratio`).""" return int( np.floor(self['selection', 'elite_ratio'] * self['population', 'size'])) def sample_weights(self, n=None): if n is None: n = self['sampling']['num_weights_per_iteration'] dist = self['sampling', 'distribution'].lower() if dist == 'one': w = 1 elif dist == 'uniform': lower = self['sampling', 'lower_bound'] upper = self['sampling', 'upper_bound'] assert lower is not None and upper is not None w = np.random.uniform(lower, upper, size=n) elif dist == 'linspace': lower = self['sampling', 'lower_bound'] upper = self['sampling', 'upper_bound'] assert lower is not None and upper is not None w = np.linspace(lower, upper, num=n) elif dist == 'lognormal': mu = self['sampling', 'mean'] sigma = self['sampling', 'sigma'] assert mu is not None and sigma is not None w = np.random.lognormal(mu, sigma, size=n) elif dist == 'normal': mu = self['sampling', 'mean'] sigma = self['sampling', 'sigma'] assert mu is not None and sigma is not None w = np.random.normal(mu, sigma, size=n) else: raise RuntimeError(f'Distribution {dist} not implemented.') self['sampling', 'current_weight'] = w return w def setup_pool(self, n=None): """Setup process pool.""" if n is None: n = self['config', 'num_workers'] if n == 1: self.pool = None else: if self['config', 'backend'].lower() == 'torch': logging.info('Using torch multiprocessing') from torch.multiprocessing import Pool self.pool = Pool(n) else: logging.info('Using usual multiprocessing') from multiprocessing import Pool self.pool = Pool(n) def pool_map(self, func, iter): if self.pool is None: return map(func, iter) else: return self.pool.imap(func, iter) def setup_optimization(self): """Setup everything that is required for training (eg. loading test samples). """ log_path = self.env_path(self['storage', 'log_filename']) logging.info(f"Check log ('{log_path}') for details.") logger = logging.getLogger() fh = logging.FileHandler(log_path) fh.setFormatter( logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s')) logger.addHandler(fh) if self['config', 'debug']: logger.setLevel(logging.DEBUG) else: logger.setLevel(logging.INFO) logging.info(f"Package version {get_version()}") p = os.path.abspath(self['experiment_path']) logging.info(f'Saving data at {p}.') logging.debug('Loading training dataset') self.task.load_training(env=self) # log used parameters params_toml = toml.dumps(self.params) logging.debug(f"Running experiments with the following parameters:\n" f"{params_toml}") with open(self.env_path('params.toml'), 'w') as f: params = dict(self.params) # mark stored params as part of a report params['is_report'] = True toml.dump(params, f) def run(self): """Run optization and post optimization (if enabled).""" # set up logging, write params self.setup_optimization() # set up pool of workers self.setup_pool() with self.open_data('w'): # run optimization self.optimize() if self['postopt', 'run_postopt']: with self.open_data('r'): # evaluate individuals in hall of fame self.post_optimization() if self.pool is not None: logging.info('Closing pool') self.pool.close() def optimize(self): logging.info("Starting evolutionary algorithm") ts = TimeStore() alg = GeneticAlgorithm(self) first_generation = True self.seed(self['sampling', 'seed']) ts.start() for gen in np.arange(self['population', 'num_generations']) + 1: ts.start() pop = alg.ask() seed = self['sampling', 'post_init_seed'] if (first_generation and not isinstance(seed, bool)): self.seed(seed) # evaluate indivs weights = self.sample_weights() logging.debug(f'Sampled weight {weights}') make_measurements(self, pop, weights=weights) obj_values = np.array( [get_objective_values(ind, self.objectives) for ind in pop]) alg.tell(obj_values) logging.debug('Updating hall of fame') self.hall_of_fame = update_hall_of_fame(self, pop) ts.stop() avg = (ts.total / gen) expected_time = (self['population', 'num_generations'] - gen) * avg logging.info( f'Completed generation {gen}; {ts.dt:.02}s elapsed, {avg:.02}s avg, {ts.total:.02}s total. ' f'Expected time remaining: {expected_time:.02}s') self.store_data(gen, pop, dt=ts.dt) self.last_population = pop self.store_hof() def post_optimization(self): r = Report(self).run_evaluations( # run evaluations on test data num_weights=self['postopt', 'num_weights'], num_samples=self['postopt', 'num_samples'] # all ) if self['postopt', 'compile_report']: r.compile() # plot metrics, derive stats else: r.compile_stats() # at least derive and store stats def store_data(self, gen, pop, dt=-1): gen_metrics, indiv_metrics = self.population_metrics( gen=gen, population=pop, return_indiv_measurements=True, dt=dt) metric, metric_sign = self.hof_metric p = ("MAX" if metric_sign > 0 else "MIN") metric_value = gen_metrics[f"{p}:{metric}"] logging.info(f"#{gen} {p}:{metric}: {metric_value:.2}") self.metrics.append(gen_metrics) commit_freq = self['storage', 'commit_elite_freq'] if (commit_freq > 0 and gen % commit_freq == 0): self.store_gen(gen, population=pop[:self.elite_size], indiv_metrics=indiv_metrics) commit_freq = self['storage', 'commit_metrics_freq'] if (commit_freq > 0 and gen % commit_freq == 0): self.store_gen_metrics(pd.DataFrame(data=self.metrics)) def population_metrics(self, population, gen=None, dt=-1, return_indiv_measurements=False): """Get available measurements for all individuals in the population and calculate statistical key metrics. The statistical key metrics include: `Q_{0, 4}` The quartiles :math:`\\{1, 2, 3\\}` as well as the minimum and maximum :math:`(0,4)`. `MEAN`, `STD` Mean and standard deviation. `MIN`, `MEDIAN`, `MAX` Equal to `Q_0`, `Q_2`, `Q_3` Parameters ---------- population : [wann_genetic.Individual] List of individuals that constitute the population. gen : int Current generation index (required for caluclating the individuals age). return_indiv_measurements : bool, optional Whether to return the individual measurements as well. Returns ------- dict Dictionary of the produced measurements (cross product of key metrics and a list of individual measurements). """ if gen is None: gen = self['population', 'num_generations'] rows = list() for ind in population: data = ind.metadata(current_gen=gen) data.update(ind.measurements) rows.append(data) indiv_measurements = pd.DataFrame(data=rows) metrics = dict( num_unique_individuals=len(set(population)), num_individuals=len(population), delta_time=dt, # number of inds without edges num_no_edge_inds=np.sum( indiv_measurements['n_enabled_edges'] == 0), # number of inds without hidden nodes num_no_hidden_inds=np.sum(indiv_measurements['n_hidden'] == 0), # individual with the most occurences biggest_ind=max([population.count(i) for i in set(population)]), ) for name, values in indiv_measurements.items(): metrics[f'Q_0:{name}'] = metrics[f'MIN:{name}'] = values.min() metrics[f'Q_1:{name}'] = np.quantile(values, .25) metrics[f'Q_2:{name}'] = metrics[f'MEDIAN:{name}'] = values.median( ) metrics[f'Q_3:{name}'] = np.quantile(values, .75) metrics[f'Q_4:{name}'] = metrics[f'MAX:{name}'] = values.max() metrics[f'MEAN:{name}'] = values.mean() metrics[f'STD:{name}'] = values.std() if return_indiv_measurements: return metrics, indiv_measurements else: return metrics
net_utils.load_net(trained_model, net) # net.load_from_npz(npz_fname) # net_utils.save_net(h5_fname, net) net.cuda() net.eval() print('load model succ...') t_det = Timer() t_total = Timer() im_fnames = sorted((fname for fname in os.listdir(im_path) if os.path.splitext(fname)[-1] == '.jpg')) im_fnames = (os.path.join(im_path, fname) for fname in im_fnames) pool = Pool(processes=1) for i, (image, im_data) in enumerate(pool.imap( preprocess, im_fnames, chunksize=1)): t_total.tic() im_data = net_utils.np_to_variable( im_data, is_cuda=True, volatile=True).permute(0, 3, 1, 2) t_det.tic() bbox_pred, iou_pred, prob_pred = net(im_data) det_time = t_det.toc() # to numpy bbox_pred = bbox_pred.data.cpu().numpy() iou_pred = iou_pred.data.cpu().numpy() prob_pred = prob_pred.data.cpu().numpy() # print bbox_pred.shape, iou_pred.shape, prob_pred.shape bboxes, scores, cls_inds = yolo_utils.postprocess( bbox_pred, iou_pred, prob_pred, image.shape, cfg, thresh)