def main(): # dsp = display_b.Display() dsp = display_b.Display() dsp.log("George's MK 52") kbd = keypad.Keypad(24, 23, 22, 21, 19, 18, 16, 15, 13, 12, 11, 10, 8, 7) with emulator.Emulator("ws://localhost:8080/", on_display=dsp.show, on_log=dsp.log) as em: for x, y, txt in kbd.get_key_presses(): em.press_button(x, y) time.sleep(0.1)
def configure(args): """create and configure an emulator""" emu = emulator.Emulator(args, frequency=24 * 1000 * 1000 cpu="68070") emu.add_memory(base=0, size=512 * 1024, writable=False, from_file=args.rom) emu.add_memory(base=0x1000000, size=512 * 1024) devices.p90ce201.add_devices(args, emu) emu.add_device(args, CompactFlash, address=0xffe000) return emu
def __init__(self, repeat_num, apple, character, equipment, wait_time, delay_time, fight_turn, side_wait_time, emulator_name, use_rand_time, change_character, fight): self.repeat_num = repeat_num self.apple = apple self.character = character self.equipment = equipment self.wait_time = wait_time self.delay_time = delay_time self.fight_turn = fight_turn self.side_wait_time = side_wait_time self.emulator = emulator.Emulator(emulator_name, fgo_dict.keyboard_key, fgo_dict.mouse_key, use_rand_time) self.change_character = change_character self.fight = fight self.fight_list = self.read_fight() self.count_character = 0
def main(_): #make environment of simple video game. env = emulator.Emulator() #env = gym.make('Breakout-v0') sess = tf.Session() #build network. q_network = Dqn(sess=sess, env=env, name="main") target_network = Dqn(sess=sess, env=env, name="target") sess.run(tf.global_variables_initializer()) #initialize all variables, especially copy q_net weights to the target network copy_weights_op = train.copy_weights(q_scope_name="main", target_scope_name="target") sess.run(copy_weights_op) saver = tf.train.Saver() if FLAGS.model_dir != '': saver.restore(sess, FLAGS.model_dir + "model.ckpt") model_dir = FLAGS.model_dir else : print("TRAINING") start = time.time() train.train(env=env, model=q_network, target_net=target_network, FLAGS=FLAGS) print_time(time.time() - start) send_message() # if not FLAGS.no_save: # print("The model was not saved.") # else : model_dir = save_model.save(saver=saver, sess=q_network.sess)
print(params_mean.shape) # Set file and directory names gptag = traintag + errtag + tag res_dir = '../../clust/results_{}/'.format(statistic) gperr = np.loadtxt(res_dir + "{}_error{}.dat".format(statistic, errtag)) training_dir = '{}training_{}{}/'.format(res_dir, statistic, traintag) testing_dir = '../testing_results/' hyperparams = "../training_results/{}_training_results{}.dat".format( statistic, gptag) print("Building emulator") emu = emulator.Emulator(statistic, training_dir, gperr=gperr, hyperparams=hyperparams, log=log, mean=mean, nhod=nhod, kernel_name=kernel_name) emu.build() print("Emulator built") y_pred = emu.predict(params_mean) if statistic == 'wp': rmin = 0.1 rmax = 50 nbins = 9 rbins = np.logspace(np.log10(rmin), np.log10(rmax), nbins + 1) # Note the + 1 to nbins r = 10**(0.5 * (np.log10(rbins)[1:] + np.log10(rbins)[:-1]))
def run(chain_fn, mode='dynesty', overwrite=False): # TODO: this overwrite check doesn't work bc initialize_chain # creates chain_fn either way. fix! if not overwrite and os.path.exists(chain_fn): raise ValueError(f"ERROR: File {chain_fn} already exists! Set overwrite=True to overwrite.") f = h5py.File(chain_fn, 'r+') ### data params # required cosmo = f.attrs['cosmo'] hod = f.attrs['hod'] ### emu params # required statistics = f.attrs['statistic'] traintags = f.attrs['traintag'] testtags = f.attrs['testtag'] errtags = f.attrs['errtag'] tags = f.attrs['tag'] kernel_names = f.attrs['kernel_name'] # optional logs = f.attrs['log'] means = f.attrs['mean'] nhods = f.attrs['nhod'] ### chain params # required param_names = f.attrs['param_names'] # optional multi = f.attrs['multi'] nwalkers = f.attrs['nwalkers'] nburn = f.attrs['nburn'] nsteps = f.attrs['nsteps'] dlogz = float(f.attrs['dlogz']) print('dlogz:', f.attrs['dlogz'], dlogz) seed = f.attrs['seed'] nbins = f.attrs['nbins'] cov_fn = f.attrs['cov_fn'] icov_fn = f.attrs['icov_fn'] msg = 'Cannot give both cov_fn and icov_fn in config file! But must have one of them' using_cov = isinstance(cov_fn, str) using_icov = isinstance(icov_fn, str) #assert using_cov ^ using_icov, msg # Set file and directory names nstats = len(statistics) training_dirs = [None]*nstats testing_dirs = [None]*nstats hyperparams = [None]*nstats acctags = [None]*nstats gperrs = [None]*nstats ys = [] cov_dir = '../../clust/covariances/' print("WARNING: train tag and test tag no longer used!") for i, statistic in enumerate(statistics): gptag = traintags[i] + errtags[i] + tags[i] acctags[i] = gptag + testtags[i] gperrs[i] = np.loadtxt(cov_dir+"error_aemulus_{}{}.dat".format(statistic, errtags[i])) training_dirs[i] = f'../../clust/results_aemulus_train/results_{statistic}/' testing_dirs[i] = f'../../clust/results_aemulus_test_mean/results_{statistic}/' hyperparams[i] = "../training_results/{}_training_results{}.dat".format(statistic, gptag) # actual calculated stat _, y = np.loadtxt(testing_dirs[i]+'{}_cosmo_{}_HOD_{}_mean.dat'.format(statistic, cosmo, hod), delimiter=',', unpack=True) y = y[:nbins] ys.extend(y) f.attrs['ys'] = ys # number of parameters, out of 11 hod + 7 cosmo num_params = len(param_names) cosmo_names = ['Omega_m', 'Omega_b', 'sigma_8', 'h', 'n_s', 'N_eff', 'w'] cosmos_truth = np.loadtxt('../tables/cosmology_camb_test_box_full.dat') hod_names = ['M_sat', 'alpha', 'M_cut', 'sigma_logM', 'v_bc', 'v_bs', 'c_vir', 'f', 'f_env', 'delta_env', 'sigma_env'] hods_truth = np.loadtxt('../tables/HOD_test_np11_n1000_new_f_env.dat') hods_truth[:, 0] = np.log10(hods_truth[:, 0]) hods_truth[:, 2] = np.log10(hods_truth[:, 2]) fixed_params = {} cosmo_truth = cosmos_truth[cosmo] hod_truth = hods_truth[hod] for (cn, ct) in zip(cosmo_names, cosmo_truth): fixed_params[cn] = ct for (hn, ht) in zip(hod_names, hod_truth): fixed_params[hn] = ht # remove params that we want to vary from fixed param dict and add true values truth = {} for pn in param_names: truth[pn] = fixed_params[pn] fixed_params.pop(pn) #can't store dicts in h5py, so make sure truths (for variable params) are in same order as param names truths = [truth[pname] for pname in param_names] f.attrs['true_values'] = truths if len(fixed_params)>0: fixed_param_names = list(fixed_params.keys()) fixed_param_values = [fixed_params[fpn] for fpn in fixed_param_names] else: fixed_param_names = [] fixed_param_values = [] f.attrs['fixed_param_names'] = fixed_param_names f.attrs['fixed_param_values'] = fixed_param_values # print chain file info print(f"h5 file attributes for chain_fn: {chain_fn}") for k, v in f.attrs.items(): print(f'{k}: {v}') # Set up Covariance matrix #if using_cov: icov = None if True: if os.path.exists(cov_fn): cov = np.loadtxt(cov_fn) else: raise ValueError(f"Path to covmat {cov_fn} doesn't exist!") nbins_tot = 9 #the covmat should have been constructed with 9 bins per stat err_message = f"Cov bad shape! {cov.shape}, but nbins_tot={nbins_tot} and nstats={nstats}" assert cov.shape[0] == nstats*nbins_tot and cov.shape[0] == nstats*nbins_tot, err_message # delete rows/cols of covmat we don't want to use #nbins_tot = cov.shape[0]/nstats if nbins < nbins_tot: print(f"nbins={nbins}, while total in cov nbins_tot={nbins_tot}; removing {nbins_tot-nbins} bins") idxs_toremove = np.array([np.arange(nbins_tot-1, nbins-1, -1)+(ns*nbins_tot) for ns in range(nstats)]).flatten() # remove both row and col cov = np.delete(cov, idxs_toremove, axis=0) cov = np.delete(cov, idxs_toremove, axis=1) print("Covariance matrix:") print(cov) print(cov.shape) print("Condition number:", np.linalg.cond(cov)) f.attrs['covariance_matrix'] = cov #elif using_icov: if using_icov: #if True: if os.path.exists(icov_fn): icov = np.loadtxt(icov_fn) else: raise ValueError(f"Path to inverse covmat {icov_fn} doesn't exist!") print("Inverse covariance matrix:") print(icov) print(icov.shape) f.attrs['inverse_covariance_matrix'] = icov #cov = icov # calling it cov so can pass this variable (this is bad i know) ### Set up chain datasets ### dsetnames = ['chain', 'lnprob', 'lnweight', 'lnevidence', 'varlnevidence'] #for now will overwrite for dsn in dsetnames: if dsn in f.keys(): del f[dsn] f.create_dataset('chain', (0, 0, len(param_names)), chunks = True, compression = 'gzip', maxshape = (None, None, len(param_names))) f.create_dataset('lnprob', (0, 0,) , chunks = True, compression = 'gzip', maxshape = (None, None, )) f.create_dataset('lnweight', (0, 0,), chunks = True, compression = 'gzip', maxshape = (None, None, )) f.create_dataset('lnevidence', (0, 0,), chunks = True, compression = 'gzip', maxshape = (None, None, )) f.create_dataset('varlnevidence', (0, 0,), chunks = True, compression = 'gzip', maxshape = (None, None, )) f.close() print("Building emulators") emus = [None]*nstats for i, statistic in enumerate(statistics): emu = emulator.Emulator(statistic, training_dirs[i], nbins=nbins, fixed_params=fixed_params, gperr=gperrs[i], hyperparams=hyperparams[i], log=logs[i], mean=means[i], nhod=nhods[i], kernel_name=kernel_names[i]) emu.build() emus[i] = emu print(f"Emulator for {statistic} built") ### Set up covariance matrix ### # stat_str = '_'.join(statistics) # #If all of the tags for the stats are the same, just use one of them (usually doing this now!) # if len(set(traintags))==1 and len(set(errtags))==1 and len(set(testtags))==1: # tag_str = traintags[0] + errtags[0] + testtags[0] # else: # # Otherwise will need to join them all # print("Using acctags joined for emu") # tag_str.join(acctags) # # for now, use performance covariance on aemulus test set (see emulator/words/error.pdf) # cov_emuperf_fn = f"{cov_dir}cov_emuperf_{stat_str}{tag_str}.dat" # if os.path.exists(cov_emuperf_fn): # cov = np.loadtxt(cov_emuperf_fn) # else: # raise ValueError(f"Path to covmat {cov_emuperf_fn} doesn't exist!") start = time.time() if mode=='emcee': res = chain.run_mcmc_emcee(emus, param_names, ys, cov, fixed_params=fixed_params, truth=truth, nwalkers=nwalkers, nsteps=nsteps, nburn=nburn, multi=multi, chain_fn=chain_fn) elif mode=='dynesty': res = chain.run_mcmc_dynesty(emus, param_names, ys, cov, icov=icov, using_icov=using_icov, fixed_params=fixed_params, truth=truth, multi=multi, chain_fn=chain_fn, dlogz=dlogz, seed=seed) elif mode=='minimize': res = chain.run_minimizer([emu], param_names, [y], [cov], fixed_params=fixed_params, truth=truth, chain_fn=chain_fn) else: raise ValueError(f"Mode {mode} not recognized!") end = time.time() print(f"Time: {(end-start)/60.0} min ({(end-start)/3600.} hrs) [{(end-start)/(3600.*24.)} days]") return res
def main(): emulator.init(width=960, height=720) machine = emulator.Emulator(boot_rom='emulator/build/boot.rom') machine.run()
def setUp(self): self.chip_emulator = emulator.Emulator()
nhod = 100 # used for training kernel_name = 'M32ExpConst' # xi, upf, mcf #kernel_name = 'M32ExpConst2' # wp tag = '_log_k{}_{}hod'.format(kernel_name, nhod) #tag = '_meansub_xrsq_k{}_{}hod'.format(kernel_name, nhod) log = True mean = False meansub = False xrsq = False gptag = traintag + errtag + tag acctag = gptag + testtag + testsavetag res_dir = '../../clust/results_{}/'.format(statistic) gperr = np.loadtxt("../../clust/covariances/error_aemulus_{}{}{}.dat".format(statistic, errtag, savetag)) training_dir = '{}training_{}{}/'.format(res_dir, statistic, traintag) hyperparams = "../training_results/{}_training_results{}.dat".format(statistic, gptag) predict_savedir = f"../testing_results/predictions_{statistic}{acctag}/" os.makedirs(predict_savedir, exist_ok=True) print("Initializing emu") emu = emulator.Emulator(statistic, training_dir, gperr=gperr, testmean=testmean, hyperparams=hyperparams, log=log, mean=mean, meansub=meansub, xrsq=xrsq, nhod=nhod, kernel_name=kernel_name) print("Building emu") emu.build() print("Testing emu") emu.test_glam4(predict_savedir) print("Done!")
def train(scenario, average_reward_episodes, rendering, hidden_layers, hidden_layers_size, memory_size, minibatch_size, optimizer_learning_rate, gamma, epsilon_decay_factor, maximum_episodes, model_file_name, converge_criteria=None, graphs_suffix='', seed=None, verbose=C_VERBOSE_NONE): ''' Summary: Trains a DQN model for solving the given OpenAI gym scenario. Args: scenario: string The OpenAI gym scenario to be solved. average_reward_episodes: int On how many concecutive episodes the averaged reward should be calculated. rendering: boolean If True, OpenAI gym environment rendering is enabled. hidden_layers: int The number of hidden layers of the Deep Neural Network. Not including the first and last layer. hidden_layers_size: int The size of each hidden layer of the Neural Network. memory_size: int The size of the replay memory feature which will be used by the DQN. minibatch_size: int The minibatch size which will be retrieved randomly from the memory in each iteration in the DQN. optimizer_learning_rate: float The Adam optimizer learning rate used in the DNN. gamma: float The discount factor to be used in the equation (3) of [1]. epsilon_decay_factor: float The decay factor of epsilon parameter, for each iteration step. maximum_episodes: int The maximum number of episodes to be executed. If DQN converges earlier the training stops. model_file_name: string The file in which the DQN trained model (DNN Keras) should be saved. converge_criteria: int or None The DQN converge criteria (when for converge_criteria concecutive episodes average reward is > 200, the DQN assumed that has been converged). If None, the training continues till the maximum_episodes is reached. graphs_suffix: string A suffix added in the graphs file names. To be used in case of multiple trains. seed: int Optional Seed to be used with the OpenAI gym environment, for results reproducability. verbose: int Verbose level (0: None, 1: INFO, 2: DEBUG) Raises: - Returns: convergence_episode: int In which episode the DQN convergences convergence_time: string (time) On how much time the DQN convergences Rturns None if converge_criteria is None notes: - ''' if verbose > C_VERBOSE_NONE: print('\nDQN Training Starts (scenario = ', scenario, ', average_reward_episodes = ', average_reward_episodes, ', rendering = ', rendering, ', hidden_layers = ', hidden_layers, ', hidden_layers_size = ', hidden_layers_size, ', memory_size = ', memory_size, ', minibatch_size = ', minibatch_size, ', optimizer_learning_rate = ', optimizer_learning_rate, ', gamma = ', gamma, ', epsilon_decay_factor = ', epsilon_decay_factor, ', maximum_episodes = ', maximum_episodes, ', model_file_name = ', model_file_name, ', converge_criteria = ', converge_criteria, ', graphs_suffix = ', graphs_suffix, ', seed = ', seed, ')', sep='') #If seed is given the apply it if seed is not None: applySeed(seed, verbose) #Create a Emulator object instance emulator = em.Emulator(scenario, average_reward_episodes, statistics=True, rendering=rendering, seed=seed, verbose=verbose) #Create a Deep Neural Network object instance (Keras with Tensor Flow backend) dnn = deepNeuralNetwork.DeepNeuralNetwork( inputs=emulator.state_size, outputs=emulator.actions_number, hidden_layers=hidden_layers, hidden_layers_size=hidden_layers_size, optimizer_learning_rate=optimizer_learning_rate, seed=seed, verbose=verbose) #Create a DQN object instance (we start always from epsilon = 1.0, we control each value with the epsilon_decay_factor dqn = deepQNetwork.DeepQNetwork(emulator=emulator, dnn=dnn, states_size=emulator.state_size, actions_number=emulator.actions_number, memory_size=memory_size, minibatch_size=minibatch_size, gamma=gamma, epsilon=1.0, epsilon_decay_factor=epsilon_decay_factor, seed=seed, verbose=verbose) #Start measuring training time start_time = time.time() if converge_criteria is not None: #Holds how many concecutive episodes average reward is > 200 convergence_counter = 0 episodes_convergence_counter = [ ] #Holds the convergence_counter for all episodes convergence_episode = 0 #Training starts here for i in range(maximum_episodes): current_state = emulator.start() #See Algorithm 1 in [1] while emulator.emulator_started: action = dqn.decideAction(current_state) #Experience [s, a, r, s'] experience = emulator.applyAction(action) dqn.storeTransition(experience) dqn.sampleRandomMinibatch() #s = s' at the end of the step, before starting the new step current_state = experience[3] if converge_criteria is not None: #Check if convergence counter should be increased or to be reset if emulator.average_reward > 200: convergence_counter += 1 else: convergence_counter = 0 episodes_convergence_counter.append(convergence_counter) if verbose > C_VERBOSE_NONE: print('Convergence Counter: ', convergence_counter, sep='') #DQN model assumed that it has been converged if convergence_counter >= converge_criteria: convergence_episode = i break if converge_criteria is not None: convergence_time = time.time() - start_time if verbose > C_VERBOSE_NONE and converge_criteria is not None: print('\nDQN converged after ', convergence_episode, ' episodes in ', executionTimeToString(convergence_time), sep='') elif verbose > C_VERBOSE_NONE and converge_criteria is None: print('\nDQN trained for ', maximum_episodes, ' episodes in ', executionTimeToString(time.time() - start_time), sep='') #Create Graphs #1. Steps per Episode plt.plot(emulator.execution_statistics.values[:, 0], emulator.execution_statistics.values[:, 1], color='coral', linestyle='-') plt.grid(b=True, which='major', axis='y', linestyle='--') plt.xlabel('Episode', fontsize=12) plt.ylabel('Steps', fontsize=12) plt.title('Steps per Episode', fontsize=12) plt.savefig('Steps_Per_Episode' + graphs_suffix + '.png') plt.clf() #2. Total Reward per Training Episode plt.plot(emulator.execution_statistics.values[:, 0], emulator.execution_statistics.values[:, 2], color='coral', linestyle='-', label='Total Reward') plt.plot(emulator.execution_statistics.values[:, 0], emulator.execution_statistics.values[:, 3], color='midnightblue', linestyle='--', label='Episodes Reward Average') plt.grid(b=True, which='major', axis='y', linestyle='--') plt.xlabel('Episode', fontsize=12) plt.ylabel('Reward', fontsize=12) plt.title('Total Reward per Training Episode', fontsize=12) plt.legend(loc='lower right', fontsize=12) plt.savefig('Total_Reward_Per_Training_Episode' + graphs_suffix + '.png') plt.clf() #Save the trained model dnn.saveModel(model_file_name) if converge_criteria is not None: return convergence_episode
def trial(model_file_name, scenario, number_of_trials, rendering=False, graphs_suffix='', verbose=C_VERBOSE_NONE): ''' Summary: Evaluate the trained DQN for a number of trials (number_of_trials). Args: model_file_name: string The saved trained DQN (Keras DNN h5 file). scenario: string The OpenAI gym scenario to be loaded by the Emulator. number_of_trials: int How many trials to execute. rendering: boolean If True, OpenAI gym environment rendering is enabled. graphs_suffix: string A suffix added in the graphs file names. To be used in case of multiple trials. verbose: int Verbose level (0: None, 1: INFO, 2: DEBUG) Raises: - Returns: trials_average_reward: float The average reward for the trial-episode (100 episodes) notes: - ''' if verbose > C_VERBOSE_NONE: print('\nEvaluate the trained DQN in ', str(number_of_trials), ' trials (episodes).', sep='') print('- model_file_name = ', model_file_name, ', scenario = ', scenario, ', number_of_trials = ', number_of_trials, ', rendering = ', rendering, ', graphs_suffix = ', graphs_suffix, sep='') #Import Numpy for the trial import numpy as np #Create a Emulator object instance (without a seed) emulator = em.Emulator(scenario=scenario, average_reward_episodes=number_of_trials, statistics=True, rendering=rendering, seed=None, verbose=verbose) #Create a Deep Neural Network object instance and load the trained model (model_file_name) dnn = deepNeuralNetwork.DeepNeuralNetwork(file_name=model_file_name, verbose=verbose) #Start measuring Trials time start_time = time.time() #Trials for i in range(number_of_trials): current_state = emulator.start() while emulator.emulator_started: action = np.argmax(dnn.predict(current_state)) #Experience [s, a, r, s'] experience = emulator.applyAction(action) current_state = experience[3] if verbose > C_VERBOSE_NONE: print('\nDQN ', str(number_of_trials), ' trials average = ', emulator.execution_statistics.values[-1, 3], ', in ', executionTimeToString(time.time() - start_time), sep='') return emulator.execution_statistics.values[-1, 3]
def build_emus(f): #chain_fn = f'../chains/chains_{chaintag}.h5' #f = h5py.File(chain_fn, 'r') ### data params cosmo = f.attrs['cosmo'] hod = f.attrs['hod'] ### emu params statistics = f.attrs['statistic'] traintags = f.attrs['traintag'] testtags = f.attrs['testtag'] errtags = f.attrs['errtag'] tags = f.attrs['tag'] kernel_names = f.attrs['kernel_name'] logs = f.attrs['log'] means = f.attrs['mean'] nhods = f.attrs['nhod'] ### chain params param_names = f.attrs['param_names'] # Set file and directory names nstats = len(statistics) training_dirs = [None] * nstats testing_dirs = [None] * nstats hyperparams = [None] * nstats acctags = [None] * nstats gperrs = [None] * nstats ys = [] cov_dir = '../../clust/covariances/' for i, statistic in enumerate(statistics): gptag = traintags[i] + errtags[i] + tags[i] acctags[i] = gptag + testtags[i] res_dir = '../../clust/results_{}/'.format(statistic) gperrs[i] = np.loadtxt( cov_dir + "error_aemulus_{}{}.dat".format(statistic, errtags[i])) training_dirs[i] = '{}training_{}{}/'.format(res_dir, statistic, traintags[i]) testing_dirs[i] = '{}testing_{}{}/'.format(res_dir, statistic, testtags[i]) hyperparams[ i] = "../training_results/{}_training_results{}.dat".format( statistic, gptag) # number of parameters, out of 11 hod + 7 cosmo num_params = len(param_names) cosmo_names = ['Omega_m', 'Omega_b', 'sigma_8', 'h', 'n_s', 'N_eff', 'w'] cosmos_truth = np.loadtxt('../tables/cosmology_camb_test_box_full.dat') hod_names = [ 'M_sat', 'alpha', 'M_cut', 'sigma_logM', 'v_bc', 'v_bs', 'c_vir', 'f', 'f_env', 'delta_env', 'sigma_env' ] hods_truth = np.loadtxt('../tables/HOD_test_np11_n1000_new_f_env.dat') hods_truth[:, 0] = np.log10(hods_truth[:, 0]) hods_truth[:, 2] = np.log10(hods_truth[:, 2]) fixed_params = {} cosmo_truth = cosmos_truth[cosmo] hod_truth = hods_truth[hod] for (cn, ct) in zip(cosmo_names, cosmo_truth): fixed_params[cn] = ct for (hn, ht) in zip(hod_names, hod_truth): fixed_params[hn] = ht # remove params that we want to vary from fixed param dict and add true values truths = f.attrs['true_values'] for pn in param_names: fixed_params.pop(pn) print("Building emulators") emus = [None] * nstats for i, statistic in enumerate(statistics): print(f"Rebuilding emulator for {statistic}") emu = emulator.Emulator(statistic, training_dirs[i], testing_dir=testing_dirs[i], fixed_params=fixed_params, gperr=gperrs[i], hyperparams=hyperparams[i], log=logs[i], mean=means[i], nhod=nhods[i], kernel_name=kernel_names[i]) emu.build() emus[i] = emu #return emus, statistics, param_names, fixed_params, truths, cosmo, hod return emus, fixed_params, gperrs
def main(): chaintag = 'upf_c4h4_fenv_med_nolog' chain_fn = f'../chains/chains_{chaintag}.h5' f = h5py.File(chain_fn, 'r') ### data params # required cosmo = f.attrs['cosmo'] hod = f.attrs['hod'] ### emu params # required statistic = f.attrs['statistic'] traintag = f.attrs['traintag'] testtag = f.attrs['testtag'] errtag = f.attrs['errtag'] tag = f.attrs['tag'] # optional log = f.attrs['log'] #log = True if log is None else log mean = f.attrs['mean'] #mean = False if mean is None else mean ### chain params # required nwalkers = f.attrs['nwalkers'] nburn = f.attrs['nburn'] nsteps = f.attrs['nsteps'] param_names = f.attrs['param_names'] # optional multi = f.attrs['multi'] #multi = True if multi is None else multi f.close() # Set file and directory names gptag = traintag + errtag + tag res_dir = '../../clust/results_{}/'.format(statistic) gperr = np.loadtxt(res_dir + "{}_error{}.dat".format(statistic, errtag)) training_dir = '{}training_{}{}/'.format(res_dir, statistic, traintag) testing_dir = '{}testing_{}{}/'.format(res_dir, statistic, testtag) hyperparams = "../training_results/{}_training_results{}.dat".format( statistic, gptag) #plot_dir = '../plots/plots_2020-01-27' #plot_fn = f'{plot_dir}/prob_{statistic}{gptag}{savetag}.png' #chain_fn = f'../chains/chains_{statistic}{gptag}{savetag}.png' # actual calculated stat if 'parammean' in testtag: rad, y = np.loadtxt(f'../testing_results/{statistic}_parammean.dat', delimiter=',', unpack=True) else: rad, y = np.loadtxt( testing_dir + '{}_cosmo_{}_HOD_{}_mean.dat'.format(statistic, cosmo, hod)) print('y:', y.shape, y) # number of parameters, ex 8 hod + 7 cosmo num_params = len(param_names) #means = np.random.rand(ndim) cosmo_names = ['Omega_m', 'Omega_b', 'sigma_8', 'h', 'n_s', 'N_eff', 'w'] cosmos_truth = np.loadtxt('../tables/cosmology_camb_test_box_full.dat') hod_names = [ 'M_sat', 'alpha', 'M_cut', 'sigma_logM', 'v_bc', 'v_bs', 'c_vir', 'f', 'f_env', 'delta_env', 'sigma_env' ] hods_truth = np.loadtxt('../tables/HOD_test_np11_n1000_new_f_env.dat') hods_truth[:, 0] = np.log10(hods_truth[:, 0]) hods_truth[:, 2] = np.log10(hods_truth[:, 2]) fixed_params = {} if 'parammean' in testtag: names = cosmo_names + hod_names params_mean = np.loadtxt("../testing_results/parammean.dat") for (name, pm) in zip(names, params_mean): fixed_params[name] = pm else: cosmo_truth = cosmos_truth[cosmo] hod_truth = hods_truth[hod] for (cn, ct) in zip(cosmo_names, cosmo_truth): fixed_params[cn] = ct for (hn, ht) in zip(hod_names, hod_truth): fixed_params[hn] = ht # remove params that we want to vary from fixed param dict and add true values truth = {} for pn in param_names: truth[pn] = fixed_params[pn] fixed_params.pop(pn) print("Stat:", statistic) print("True values:") print(truth) print("Building emulator") emu = emulator.Emulator(statistic, training_dir, fixed_params=fixed_params, gperr=gperr, hyperparams=hyperparams, log=log, mean=mean) emu.build() print("Emulator built") #diagonal covariance matrix from error cov = np.diag(emu.gperr) #cov *= 10 print(cov) print(cov.shape) start = time.time()
anntag = traintag + errtag + tag acctag = anntag + testtag + testsavetag res_dir = '../../clust/results_{}/'.format(statistic) gperr = np.loadtxt("../../clust/covariances/error_aemulus_{}{}{}.dat".format( statistic, errtag, savetag)) training_dir = '{}training_{}{}/'.format(res_dir, statistic, traintag) model_dir = "../training_ann_results/{}_training_results{}".format( statistic, anntag) testing_dir = '{}testing_{}{}/'.format(res_dir, statistic, testtag) predict_savedir = f"../testing_results/predictions_{statistic}{acctag}" os.makedirs(predict_savedir, exist_ok=True) emu = emulator.Emulator(statistic, training_dir, testing_dir=testing_dir, gperr=gperr, testmean=testmean, log=log, mean=mean, meansub=meansub, xrsq=xrsq, nhod=nhod, nhod_test=nhod_test, model_dir=model_dir) emu.build_ann() emu.test_ann(predict_savedir) #emu.build_ann_bybin() #emu.test_ann_bybin(predict_savedir)
import server, emulator, sys, threading import tornado.ioloop def usage(): print('Invalid arguments: python %s <rom file>' % (sys.argv[0])) def thread_function(core): core.run() if __name__ == '__main__': if len(sys.argv) != 2: usage() sys.exit(0) # Service instantiation. web_server = server.Server() core = emulator.Emulator(sys.argv[1], web_server) web_server.set_core(core) # Start both services. # Start the emulator service first and run in a background thread. emulator_thread = threading.Thread(target=thread_function, args=(core, )) emulator_thread.start() web_server.listen(8888) tornado.ioloop.IOLoop.instance().start()
def trial(model_file_name, scenario, number_of_trials, rendering=False, graphs_suffix='', verbose=C_VERBOSE_NONE, store_history=False, compute_saliency=False, history_save_path='./output/history_test.pkl'): """ Summary: Evaluate the trained DQN for a number of trials (number_of_trials). Args: model_file_name: string The saved trained DQN (Keras DNN h5 file). scenario: string The OpenAI gym scenario to be loaded by the Emulator. number_of_trials: int How many trials to execute. rendering: boolean If True, OpenAI gym environment rendering is enabled. graphs_suffix: string A suffix added in the graphs file names. To be used in case of multiple trials. verbose: int Verbose level (0: None, 1: INFO, 2: DEBUG) store_history: bool Store history data or not. compute_saliency: bool Computes saliency or not. history_save_path: str Where to store the history file. Raises: - Returns: trials_average_reward: float The average reward for the trial-episode (100 episodes) notes: - """ if verbose > C_VERBOSE_NONE: print('\nEvaluate the trained DQN in ', str(number_of_trials), ' trials (episodes).', sep='') print('- model_file_name = ', model_file_name, ', scenario = ', scenario, ', number_of_trials = ', number_of_trials, ', rendering = ', rendering, ', graphs_suffix = ', graphs_suffix, sep='') # Create a Emulator object instance (without a seed) emulator = em.Emulator(scenario=scenario, average_reward_episodes=number_of_trials, statistics=True, rendering=rendering, seed=42, verbose=verbose) # Create a Deep Neural Network object instance and load the trained model (model_file_name) dnn = deepNeuralNetwork.DeepNeuralNetwork(file_name=model_file_name, verbose=verbose) # Start measuring Trials time start_time = time.time() history = { 'trial': [], 'state': [], 'action': [], 'reward': [], 'next_state': [], 'done': [], 'q_values': [] } if compute_saliency: history['saliency'] = [] # Trials # used as baseline for perturbation # for each feature, apply a random noise of 0.2 * (max(feature) - min(feature)) state_min = np.array([-0.354871, -0.10391249, -0.468456, -0.89336216, -0.15218297, -0.4017307, 0, 0]) state_max = np.array([-0.00462484, 1.4088593, 0.12988918, 0.05392841, 0.5564749, 0.8584606, 1, 1]) for i in range(number_of_trials): current_state = emulator.start() while emulator.emulator_started: q_values = dnn.predict(current_state) action = np.argmax(q_values) if compute_saliency: # compute saliency saliency = np.zeros(NUM_STATE) for _ in range(NUM_SALIENCY_TESTS): for j in range(NUM_STATE): # perturb state perturbed_state = np.array(current_state) if j < 6: # numerical states perturbed_state[j] = SALIENCY_PERTURBATION * np.random.rand() \ * (state_max[j] - state_min[j]) + state_min[j] else: # boolean states perturbed_state = current_state.copy() perturbed_state[j] = 1 - perturbed_state[j] q_values_preturbed = dnn.predict(perturbed_state) max_q = np.max(q_values) q_values /= max_q q_values_preturbed /= max_q q_value_dict = {a: q_values[0, a].astype(np.float64) for a in range(4)} q_value_preturbed_dict = {a: q_values_preturbed[0, a].astype(np.float64) for a in range(4)} saliency[j] = sarfa_saliency.computeSaliencyUsingSarfa(action, q_value_dict, q_value_preturbed_dict)[0] saliency /= NUM_SALIENCY_TESTS # Experience [s, a, r, s'] experience = emulator.applyAction(action) # save data if store_history: history['trial'].append(i) history['state'].append(current_state) history['action'].append(action) history['reward'].append(experience[2]) if experience[3] is not None: history['next_state'].append(experience[3]) history['done'].append(False) else: history['next_state'].append(current_state) history['done'].append(True) history['q_values'].append(q_values) if compute_saliency: history['saliency'].append(saliency) current_state = experience[3] if store_history: for k in history.keys(): history[k] = np.array(history[k]) history_save_dir = os.path.split(history_save_path)[0] if not os.path.exists(history_save_dir): os.makedirs(history_save_dir) pd.to_pickle(history, history_save_path) if verbose > C_VERBOSE_NONE: print('\nDQN ', str(number_of_trials), ' trials average = ', emulator.execution_statistics.values[-1, 3], ', in ', executionTimeToString(time.time() - start_time), sep='') return emulator.execution_statistics.values[-1, 3]