def run_aggr(l, n, px, selection_func): # Initialization pop = uniform(n, l) health = l - hamming_distance(pop) # Start loop last_mean_health = health.mean() final_iter_num = N_IT - 1 last_counter = 0 for i in range(1, N_IT): pop = selection_func(pop, health, n) pop = mutate(pop, px) health = l - hamming_distance(pop) mean_health = health.mean() if abs(last_mean_health - mean_health) < EPS: last_counter += 1 else: last_counter = 0 if last_counter >= 10: final_iter_num = i break last_mean_health = mean_health return final_iter_num, last_mean_health
def run(run_id, l, n, px): hist_file = get_empty_histogram(20000, l) mean_health_ar = np.zeros(N_IT) pop = uniform(n, l) health = l - hamming_distance(pop) mean_health_ar[0] = health.mean() append_to_histogram(hist_file, pop, mean_health_ar[0], health.max(), 0) stop = N_IT for i in range(1, N_IT): pop = roulette(pop, health, n) pop = mutate(pop, px) health = l - hamming_distance(pop) mean_health = health.mean() append_to_histogram(hist_file, pop, mean_health, health.max(), i) mean_health_ar[i] = mean_health if converges(mean_health_ar, i): stop = i break if i % 100 == 0: print('Iteration:', i) df = pd.DataFrame(hist_file[:stop+2], columns=get_cols(l)) name = f'task1\\task1_id_{run_id}_L_{l}_N_{n}_px_{px:.4f}' print('saving') df.to_sql(name, engine) print('to_db') write_file(name, df) print('to_file')
def run(cursor, conn, run_id, l, n, px, sql_script, estim, init, sel_type, size_pop_type): cursor.execute( f"SELECT good_locuses, bad_locuses, lethal_locuses FROM locus_helper WHERE l={l}" ) row = cursor.fetchone() kwargs = { 'good': np.array(row[0], dtype=np.int8), 'bad': np.array(row[1], dtype=np.int8), 'lethal': np.array(row[2], dtype=np.int8) } estimation = ESTIM_MAP[estim] initialization = INIT_MAP[init] selection = SELECTION_MAP[sel_type] size_pop = SIZE_POP[size_pop_type] pop = initialization(size_pop(0, 1), l, **kwargs) health = estimation(pop, **kwargs) store_in_db(cursor, conn, sql_script, run_id, pop, health, health.mean(), 0, init, estim, sel_type, size_pop_type, **kwargs) succ = False for i in range(1, N_IT): if i % 50 == 0: print(i) pop = selection(pop, health, size_pop(i, len(pop))) pop = mutate(pop, px) health = estimation(pop, **kwargs) mean_health = health.mean() store_in_db(cursor, conn, sql_script, run_id, pop, health, mean_health, i, init, estim, sel_type, size_pop_type, **kwargs) return succ
def run_aggr(init_func, estimation_func, selection_func, l, n, px, cursor): kwargs = {} if 'locuses' in estimation_func.__name__ or 'locuses' in selection_func.__name__: cursor.execute( f"SELECT good_locuses, bad_locuses, lethal_locuses FROM locus_helper WHERE l={l}" ) row = cursor.fetchone() kwargs.update({ 'good': np.array(row[0], dtype=np.int8), 'bad': np.array(row[1], dtype=np.int8), 'lethal': np.array(row[2], dtype=np.int8) }) pop = init_func(n, l, **kwargs) health = estimation_func(pop, **kwargs) # Start loop last_mean_health = health.mean() final_iter_num = N_IT - 1 last_counter = 0 poly_d1 = [] poly_d2 = [] mean_health_ar = [] for i in range(0, N_IT): pop = selection_func(pop, health, n) pop = mutate(pop, px) health = estimation_func(pop, **kwargs) mean_health = health.mean() mean_health_ar.append(mean_health) if abs(last_mean_health - mean_health) < EPS: last_counter += 1 else: last_counter = 0 if last_counter >= 10: final_iter_num = i break last_mean_health = mean_health if 'good' in kwargs: poly_d1.append(locus_roles_polymorphous(pop, **kwargs)) poly_d2.append(locus_roles_polymorphous(pop, v=1, **kwargs)) else: poly_d1.append(simple_polymorphous(pop)) poly_d2.append(simple_polymorphous(pop, v=1)) return final_iter_num, mean_health_ar, poly_d1, poly_d2
def run_one_simulation( init_func: callable, estimation_func: callable, selection_func: callable, l: int, n: int, px: float, stop_count=STOP_COUNT, ): kwargs = {} pop = init_func(n, l, **kwargs) health = estimation_func(pop, **kwargs) # Start loop last_mean_health = health.mean() final_iter_num = N_IT - 1 last_counter = 0 poly_d1 = [] mean_health_ar = [] for i in range(0, N_IT): pop = selection_func(pop, health, n) pop = mutate(pop, px) health = estimation_func(pop, **kwargs) mean_health = health.mean() mean_health_ar.append(mean_health) if abs(last_mean_health - mean_health) < EPS: last_counter += 1 else: last_counter = 0 if last_counter >= stop_count: final_iter_num = i break last_mean_health = mean_health if 'good' in kwargs: poly_d1.append(locus_roles_polymorphous(pop, **kwargs)) else: poly_d1.append(simple_polymorphous(pop)) return final_iter_num, mean_health_ar, poly_d1
def process_single_run( param_set: ParamSet, pmax: float, run_num: int, test_suite_id=None, run_set_id=None, ): run = Run(number=run_num) init_pop = InitPopulation.get( run_number=run_num, init=param_set.init, L=param_set.L, N=param_set.N, dim_n=param_set.func_case.func_param.dim_n, accuracy_decimals=param_set.func_case.func_param.accuracy_decimals, ) run.init_population = init_pop.id init_pop_seed = init_pop.seed # TODO init disrt run.init_distr_health = None # Helping vars coder_info = param_set.encoding coder_info['a'] = param_set.func_case.func_param.interval_a coder_info['b'] = param_set.func_case.func_param.interval_b f_init = mappers.INIT_MAP[param_set.init] f_select = mappers.SEL_TYPE_MAP[param_set.sel_type] f_estim = get_estimation_function(param_set) STEPS_BACK, MAX_NFE, EPS = get_stop_cond_params(param_set) N = param_set.N L = param_set.L logger.info('Run taken into work', extra={ 'data': { 'param_set_id': param_set.id, 'run_num': run_num, 'run_set_id': run_set_id, 'test_suite_id': test_suite_id, } }) # Initialization # pop: population with decimal values # pop_encoded: population represented as 1s and 0s pop_encoded = f_init(N, L, init_pop_seed) pop = decode(pop_encoded, L, coder_info) health = f_estim(pop) nfe = N iter_num = 0 mean_health_ar = [health.mean()] max_health_ar = [health.max()] step = 0 prev_mean_health = health.mean() while nfe < MAX_NFE and not step > STEPS_BACK: pop_encoded = f_select(pop_encoded, health, N) pop_encoded = crossover(pop_encoded, param_set.crossover_pc) pop_encoded = mutate(pop_encoded, pmax) pop = decode(pop_encoded, L, coder_info) health = f_estim(pop) nfe += N iter_num += 1 mean_health = health.mean() mean_health_ar.append(mean_health) max_health_ar.append(health.max()) if abs(mean_health - prev_mean_health) < EPS: step += 1 else: step = 0 prev_mean_health = mean_health # Last values last_pop = pop last_health = health last_pop_encoded = pop_encoded run.is_succ = nfe < MAX_NFE run.NFE = nfe run.iter_num = iter_num if run.is_succ: # Helping vars optimal_val = np.array([param_set.func_case.extremums[0] ]) # optimal dec X for the function optimal_encoded = encode( optimal_val, L, coder_info) # optimal bin/gray X for this function f_opt = f_estim(optimal_val)[0] # value of function in extremum avg = last_health.mean() # average value of health maxp = last_health.max() best_index = last_health.argmax() maxp_encoded = last_pop_encoded[best_index] run.avg_health = avg run.max_health = last_health.max() run.std_health = last_health.std() run.avg_health_deviation_to_opt_abs = abs(avg - f_opt) run.avg_health_deviation_to_opt_rel = abs((avg - f_opt) / f_opt) run.best_health_deviation_to_opt_abs = abs(maxp - f_opt) run.best_health_deviation_to_opt_rel = abs((maxp - f_opt) / f_opt) run.eucl_d_to_extremum = abs(maxp - f_opt) run.hamm_d_to_extremum = hamming_distance_between( maxp_encoded, optimal_encoded) run.best_ind = last_pop[best_index] run.best_ind_n = len(np.argwhere(last_pop == last_pop[best_index])) # run.final_distr_hamm = target_hamming_distribution( optimal_encoded, pop_encoded) run.final_distr_health = None run.final_distr_pairwise = pairwise_hamming_distribution(pop_encoded) run.max_avg_health_arr = max_health_ar run.avg_avg_health_arr = mean_health_ar if test_suite_id is not None: run.test_suite = test_suite_id else: run.run_set = run_set_id run.save() logger.info('Run completed successfully', extra={'data': { 'run_id': run.id }}) return run