def main(): # Let's be very verbose! logging.basicConfig(level=logging.INFO) # Let's do multiprocessing this time with a lock (which is default) filename = os.path.join('hdf5', 'example_23.hdf5') env = Environment( trajectory='Example_23_BRIAN2', filename=filename, file_title='Example_23_Brian2', comment='Go Brian2!', dynamically_imported_classes=[Brian2MonitorResult, Brian2Parameter]) traj = env.trajectory # 1st a) add the parameters add_params(traj) # 1st b) prepare, we want to explore the different network sizes and different tauw time scales traj.f_explore( cartesian_product({ traj.f_get('N').v_full_name: [50, 60], traj.f_get('tauw').v_full_name: [30 * ms, 40 * ms] })) # 2nd let's run our experiment env.run(run_net) # You can take a look at the results in the hdf5 file if you want! # Finally disable logging and close all log-files env.disable_logging()
def main(): # Let's be very verbose! logging.basicConfig(level = logging.INFO) # Let's do multiprocessing this time with a lock (which is default) filename = os.path.join('hdf5', 'example_07.hdf5') env = Environment(trajectory='Example_07_BRIAN', filename=filename, file_title='Example_07_Brian', comment = 'Go Brian!', dynamically_imported_classes=[BrianMonitorResult, BrianParameter], multiproc=True, wrap_mode='QUEUE', ncores=2) traj = env.trajectory # 1st a) add the parameters add_params(traj) # 1st b) prepare, we want to explore the different network sizes and different tauw time scales traj.f_explore(cartesian_product({traj.f_get('N').v_full_name:[50,60], traj.f_get('tauw').v_full_name:[30*ms,40*ms]})) # 2nd let's run our experiment env.run(run_net) # You can take a look at the results in the hdf5 file if you want! # Finally disable logging and close all log-files env.disable_logging()
def main(): # Let's be very verbose! logging.basicConfig(level = logging.INFO) # Let's do multiprocessing this time with a lock (which is default) env = Environment(trajectory='Example_07_BRIAN', filename='experiments/example_07/HDF5/example_07.hdf5', file_title='Example_07_Euler_Integration', log_folder='experiments/example_07/LOGS/', comment = 'Go Brian!', dynamically_imported_classes=[BrianMonitorResult, BrianParameter], multiproc=True, wrap_mode='QUEUE', ncores=2) traj = env.v_trajectory # 1st a) add the parameters add_params(traj) # 1st b) prepare, we want to explore the different network sizes and different tauw time scales traj.f_explore(cartesian_product({traj.f_get('N').v_full_name:[50,60], traj.f_get('tauw').v_full_name:[30*ms,40*ms]})) # 2nd let's run our experiment env.f_run(run_net)
def explore_mp(self, traj): self.explored = { 'x': [0.0, 1.0, 2.0, 3.0, 4.0], 'y': [0.1, 2.2, 3.3, 4.4, 5.5] } traj.f_explore(cartesian_product(self.explored))
def main(): try: # Create an environment that handles running env = Environment(trajectory='Example1_Quick_And_Not_So_Dirty',filename='experiments/example_01/HDF5/', file_title='Example1_Quick_And_Not_So_Dirty', log_folder='experiments/example_01/LOGS/', comment='The first example!', complib='blosc', small_overview_tables=False, git_repository='./', git_message='Im a message!', sumatra_project='./', sumatra_reason='Testing!') # Get the trajectory from the environment traj = env.v_trajectory # Add both parameters traj.f_add_parameter('x', 1, comment='Im the first dimension!') traj.f_add_parameter('y', 1, comment='Im the second dimension!') # Explore the parameters with a cartesian product: traj.f_explore(cartesian_product({'x':[1,2,3], 'y':[6,7,8]})) # Run the simulation env.f_run(multiply) print("Python git test successful") # traj.f_expand({'x':[3,3],'y':[42,43]}) # # env.f_run(multiply) except Exception as e: print(repr(e)) sys.exit(1)
def explore(self): matrices = [] for irun in range(3): spsparse_lil = spsp.lil_matrix((111, 111)) spsparse_lil[3, 2] = 44.5 * irun matrices.append(spsparse_lil) self.explore_dict = cartesian_product( { 'npstr': [ np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez']) ], 'val0': [1, 2, 3], 'spsparse_lil': matrices }, (('npstr', 'val0'), 'spsparse_lil')) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist)
def explore(self): matrices = [] for irun in range(3): spsparse_lil = spsp.lil_matrix((111,111)) spsparse_lil[3,2] = 44.5*irun matrices.append(spsparse_lil) self.explore_dict=cartesian_product({'npstr':[np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez'])], 'val0':[1,2,3], 'spsparse_lil' : matrices}, (('npstr','val0'),'spsparse_lil')) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist)
def main(): # pypet environment env = Environment(trajectory=SIM_NAME, comment="Experiment on density with binary covariates", log_config=None, multiproc=False, ncores=1, filename=SIM_PATH + "/results/", overwrite_file=True) traj = env.trajectory # parameters (data generation) traj.f_add_parameter("data.N", np.int64(500), "Number of nodes") traj.f_add_parameter("data.K", np.int64(5), "True number of latent components") traj.f_add_parameter("data.p_cts", np.int64(0), "Number of continuous covariates") traj.f_add_parameter("data.p_bin", np.int64(0), "Number of binary covariates") traj.f_add_parameter("data.var_adj", np.float64(1.), "True variance in the link Probit model") traj.f_add_parameter("data.var_cov", np.float64(1.), "True variance in the covariate model (cts and bin)") traj.f_add_parameter("data.missing_rate", np.float64(0.1), "Missing rate") traj.f_add_parameter("data.seed", np.int64(1), "Random seed") traj.f_add_parameter("data.alpha_mean", np.float64(-1.85), "Mean of the heterogeneity parameter") # parameters (model) traj.f_add_parameter("model.K", np.int64(5), "Number of latent components in the model") traj.f_add_parameter("model.adj_model", "Logistic", "Adjacency model") traj.f_add_parameter("model.bin_model", "Logistic", "Binary covariate model") # parameters (fit) traj.f_add_parameter("fit.n_iter", np.int64(20), "Number of VEM iterations") traj.f_add_parameter("fit.n_vmp", np.int64(5), "Number of VMP iterations per E-step") traj.f_add_parameter("fit.n_gd", np.int64(5), "Number of GD iterations per M-step") traj.f_add_parameter("fit.step_size", np.float64(0.01), "GD Step size") # experiment explore_dict = { "data.alpha_mean": np.array([-3.2, -2.8, -2.4, -2., -1.6, -1.2, -0.8, -0.4, 0.0, 0.4]), "data.p_bin": np.array([10, 100, 500]), "data.seed": np.arange(0, 100, 1) } experiment = cartesian_product(explore_dict, tuple(explore_dict.keys())) traj.f_explore(experiment) env.add_postprocessing(post_processing) env.run(run) env.disable_logging()
def setUp(self): env = Environment(trajectory='Test_'+repr(time.time()).replace('.','_'), filename=make_temp_dir(os.path.join( 'experiments', 'tests', 'briantests', 'HDF5', 'briantest.hdf5')), file_title='test', log_config=get_log_config(), dynamic_imports=['pypet.brian.parameter.BrianParameter', BrianMonitorResult], multiproc=False) traj = env.v_trajectory #env._set_standard_storage() #env._hdf5_queue_writer._hdf5storageservice = LazyStorageService() traj = env.v_trajectory #traj.set_storage_service(LazyStorageService()) add_params(traj) #traj.mode='Parallel' traj.f_explore(cartesian_product({traj.f_get('N').v_full_name:[50,60], traj.f_get('tauw').v_full_name:[30*ms,40*ms]})) self.traj = traj self.env = env self.traj = traj
def setUp(self): logging.basicConfig(level = logging.DEBUG) env = Environment(trajectory='Test_'+repr(time.time()).replace('.','_'), filename=make_temp_file('experiments/tests/briantests/HDF5/briantest.hdf5'), file_title='test', log_folder=make_temp_file('experiments/tests/briantests/log'), dynamically_imported_classes=['pypet.brian.parameter.BrianParameter', BrianMonitorResult], multiproc=True, use_pool=True, complib='blosc', wrap_mode='QUEUE', ncores=2) traj = env.v_trajectory #env._set_standard_storage() #env._hdf5_queue_writer._hdf5storageservice = LazyStorageService() traj = env.v_trajectory #traj.set_storage_service(LazyStorageService()) add_params(traj) #traj.mode='Parallel' traj.f_explore(cartesian_product({traj.f_get('N').v_full_name:[50,60], traj.f_get('tauw').v_full_name:[30*ms,40*ms]})) self.traj = traj self.env = env self.traj = traj
def setUp(self): env = Environment( trajectory='Test_' + repr(time.time()).replace('.', '_'), filename=make_temp_dir( os.path.join('experiments', 'tests', 'briantests', 'HDF5', 'briantest.hdf5')), file_title='test', log_config=get_log_config(), dynamic_imports=[ 'pypet.brian.parameter.BrianParameter', BrianMonitorResult ], multiproc=False) traj = env.v_trajectory #env._set_standard_storage() #env._hdf5_queue_writer._hdf5storageservice = LazyStorageService() traj = env.v_trajectory #traj.set_storage_service(LazyStorageService()) add_params(traj) #traj.mode='Parallel' traj.f_explore( cartesian_product({ traj.f_get('N').v_full_name: [50, 60], traj.f_get('tauw').v_full_name: [30 * ms, 40 * ms] })) self.traj = traj self.env = env self.traj = traj
def test_cartesian_product(self): cartesian_dict=cartesian_product({'param1':[1,2,3], 'param2':[42.0, 52.5]}, ('param1','param2')) result_dict = {'param1':[1,1,2,2,3,3],'param2': [42.0,52.5,42.0,52.5,42.0,52.5]} self.assertTrue(nested_equal(cartesian_dict,result_dict), '%s != %s' % (str(cartesian_dict),str(result_dict)))
def explore(self): self.explore_dict=cartesian_product({'npstr':[np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez'])], 'val0':[1,2,3]}) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist)
def test_cartesian_product_combined_params(self): cartesian_dict=cartesian_product( {'param1': [42.0, 52.5], 'param2':['a', 'b'],\ 'param3' : [1,2,3]}, (('param3',),('param1', 'param2'))) result_dict={'param3':[1,1,2,2,3,3],'param1' : [42.0,52.5,42.0,52.5,42.0,52.5], 'param2':['a','b','a','b','a','b']} self.assertTrue(nested_equal(cartesian_dict,result_dict), '%s != %s' % (str(cartesian_dict),str(result_dict)))
def expand(self): self.expanded ={'Normal.trial': [1], 'Numpy.double': [np.array([1.0,2.0,3.0,4.0]), np.array([-1.0,3.0,5.0,7.0])], 'csr_mat' :[spsp.csr_matrix((2222,22)), spsp.csr_matrix((2222,22))]} self.expanded['csr_mat'][0][1,2]=44.0 self.expanded['csr_mat'][1][2,2]=33 self.traj.f_expand(cartesian_product(self.expanded))
def explore(self): matrices_csr = [] for irun in range(3): spsparse_csr = spsp.csr_matrix((111, 111)) spsparse_csr[3, 2 + irun] = 44.5 * irun matrices_csr.append(spsparse_csr) matrices_csc = [] for irun in range(3): spsparse_csc = spsp.csc_matrix((111, 111)) spsparse_csc[3, 2 + irun] = 44.5 * irun matrices_csc.append(spsparse_csc) matrices_bsr = [] for irun in range(3): spsparse_bsr = spsp.csr_matrix((111, 111)) spsparse_bsr[3, 2 + irun] = 44.5 * irun matrices_bsr.append(spsparse_bsr.tobsr()) matrices_dia = [] for irun in range(3): spsparse_dia = spsp.csr_matrix((111, 111)) spsparse_dia[3, 2 + irun] = 44.5 * irun matrices_dia.append(spsparse_dia.todia()) self.explore_dict = cartesian_product( { 'npstr': [ np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez']) ], 'val0': [1, 2, 3], 'spsparse_csr': matrices_csr, 'spsparse_csc': matrices_csc, 'spsparse_bsr': matrices_bsr, 'spsparse_dia': matrices_dia }, (('npstr', 'val0'), ('spsparse_csr', 'spsparse_csc', 'spsparse_bsr', 'spsparse_dia'))) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist)
def explore(self, traj): self.explored = cartesian_product({ 'Normal.trial': [0, 1], 'Numpy.double': [np.array([1.0, 2.0, 3.0, 4.0]), np.array([-1.0, 3.0, 5.0, 7.0])] }) traj.f_explore(self.explored)
def test_cartesian_product_combined_params(self): cartesian_dict=cartesian_product( {'param1': [42.0, 52.5], 'param2':['a', 'b'],\ 'param3' : [1,2,3]}, (('param3',),('param1', 'param2'))) result_dict = { 'param3': [1, 1, 2, 2, 3, 3], 'param1': [42.0, 52.5, 42.0, 52.5, 42.0, 52.5], 'param2': ['a', 'b', 'a', 'b', 'a', 'b'] } self.assertTrue(nested_equal(cartesian_dict, result_dict), '%s != %s' % (str(cartesian_dict), str(result_dict)))
def explore(self): self.explore_dict = cartesian_product({#'brian2_array_a': [np.array([1., 2.]) * mV], # 'brian2_array_b': [2 * mV], # Arrays need to be of the same size! 'brian2_array_c': [np.array([5., 8.]) * mV, np.array([7., 8.]) * mV], }) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist) self.assertTrue(self.param[key].v_explored and self.param[key].f_has_range())
def expand(self): self.expanded ={'Normal.trial': [1], 'Numpy.double': [np.array([1.0,2.0,3.0,4.0]), np.array([-1.0,3.0,5.0,7.0])], 'csr_mat' :[spsp.lil_matrix((2222,22)), spsp.lil_matrix((2222,22))]} self.expanded['csr_mat'][0][1,2]=44.0 self.expanded['csr_mat'][1][2,2]=33 self.expanded['csr_mat'][0]=self.expanded['csr_mat'][0].tocsr() self.expanded['csr_mat'][1]=self.expanded['csr_mat'][1].tocsr() self.traj.f_expand(cartesian_product(self.expanded)) self.traj.f_store()
def explore(self, traj): self.explored ={'Normal.trial': [0], 'Numpy.double': [np.array([1.0,2.0,3.0,4.0]), np.array([-1.0,3.0,5.0,7.0])], 'csr_mat' :[spsp.lil_matrix((2222,22)), spsp.lil_matrix((2222,22))]} self.explored['csr_mat'][0][1,2]=44.0 self.explored['csr_mat'][1][2,2]=33 self.explored['csr_mat'][0] = self.explored['csr_mat'][0].tocsr() self.explored['csr_mat'][1] = self.explored['csr_mat'][0].tocsr() traj.f_explore(cartesian_product(self.explored))
def explore(self): matrices_csr = [] for irun in range(3): spsparse_csr = spsp.csr_matrix((111,111)) spsparse_csr[3,2+irun] = 44.5*irun matrices_csr.append(spsparse_csr) matrices_csc = [] for irun in range(3): spsparse_csc = spsp.csc_matrix((111,111)) spsparse_csc[3,2+irun] = 44.5*irun matrices_csc.append(spsparse_csc) matrices_bsr = [] for irun in range(3): spsparse_bsr = spsp.csr_matrix((111,111)) spsparse_bsr[3,2+irun] = 44.5*irun matrices_bsr.append(spsparse_bsr.tobsr()) matrices_dia = [] for irun in range(3): spsparse_dia = spsp.csr_matrix((111,111)) spsparse_dia[3,2+irun] = 44.5*irun matrices_dia.append(spsparse_dia.todia()) self.explore_dict=cartesian_product({'npstr':[np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez'])], 'val0':[1,2,3], 'spsparse_csr' : matrices_csr, 'spsparse_csc' : matrices_csc, 'spsparse_bsr' : matrices_bsr, 'spsparse_dia' : matrices_dia}, (('npstr','val0'),('spsparse_csr', 'spsparse_csc', 'spsparse_bsr','spsparse_dia')) ) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist)
def explore(self): self.explore_dict=cartesian_product({'npstr':[np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez'])], 'val0':[1,2,3], 'alist':[[1,2,3,4],[3,4,5,6]]}) ## Explore the parameter: for key, vallist in self.explore_dict.items(): old_data = self.param[key]._data self.param[key]._data = None with self.assertRaises(TypeError): self.param[key]._explore(vallist) self.param[key]._data = old_data self.param[key]._explore(vallist)
def explore(self): self.explore_dict = cartesian_product({ #'npstr': [np.array(['Uno', 'Dos', 'Tres']), # np.array(['Cinco', 'Seis', 'Siette']), # np.array(['Ocho', 'Nueve', 'Diez'])], 'ampere1': [1*mA], #'val0': [1, 2, 3], 'mV1': [42.0*mV, 3*mV, 4*mV], 'b2a': [np.array([1., 2.]) * mV]}) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist) self.assertTrue(self.param[key].v_explored and self.param[key].f_has_range())
def main(path, name, explore_dict): comment = "\n".join( ["{}: {}".format(k, v) for k, v in explore_dict.items()]) # pypet environment env = Environment(trajectory=name, comment=comment, log_config=None, multiproc=False, ncores=1, filename=path + name + "/results/", overwrite_file=True) traj = env.trajectory traj.f_add_parameter("path", path + name, "Path") # parameters (data generation) traj.f_add_parameter("data.N", np.int64(500), "Number of nodes") traj.f_add_parameter("data.K", np.int64(5), "True number of latent components") traj.f_add_parameter("data.p_cts", np.int64(0), "Number of continuous covariates") traj.f_add_parameter("data.p_bin", np.int64(0), "Number of binary covariates") traj.f_add_parameter("data.var_cov", np.float64(1.), "True variance in the covariate model (cts and bin)") traj.f_add_parameter("data.missing_rate", np.float64(0.1), "Missing rate") traj.f_add_parameter("data.seed", np.int64(1), "Random seed") traj.f_add_parameter("data.center", np.int64(1), "Ego-network center") traj.f_add_parameter("data.alpha_mean", np.float64(-1.85), "Mean of the heterogeneity parameter") # parameters (model) traj.f_add_parameter("model.K", np.int64(5), "Number of latent components in the model") # parameters (fit) traj.f_add_parameter("fit.algo", "MLE", "Inference algorithm") traj.f_add_parameter("fit.max_iter", np.int64(500), "Number of VEM iterations") traj.f_add_parameter("fit.n_sample", np.int64(1), "Number of samples for VIMC") traj.f_add_parameter("fit.eps", np.float64(1.0e-6), "convergence threshold") traj.f_add_parameter("fit.lr", np.float64(0.01), "GD Step size") # experiment experiment = cartesian_product(explore_dict, tuple(explore_dict.keys())) traj.f_explore(experiment) env.add_postprocessing(post_processing) env.run(run) env.disable_logging()
def test_cartesian_product(self): cartesian_dict = cartesian_product( { 'param1': [1, 2, 3], 'param2': [42.0, 52.5] }, ('param1', 'param2')) result_dict = { 'param1': [1, 1, 2, 2, 3, 3], 'param2': [42.0, 52.5, 42.0, 52.5, 42.0, 52.5] } self.assertTrue(nested_equal(cartesian_dict, result_dict), '%s != %s' % (str(cartesian_dict), str(result_dict)))
def explore(self): matrices = [] self.explore_dict=cartesian_product({'npstr':[np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez'])], 'val0':[1,2,3], 'myinttuple':[(1,2,1),(4,5,6),(5,6,7)]} ,(('npstr','val0'),'myinttuple')) ### Convert the explored stuff into numpy arrays #for idx, val in enumerate(self.explore_dict['myinttuple']): # self.explore_dict['myinttuple'][idx] = np.array(val) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist)
def main(inputargs=None): if inputargs is None: inputargs = sys.argv[1:] if len(sys.argv) > 1 else "" args = docopt(__doc__, argv=inputargs) wavpath = path.join(modulePath, "resources", "tone_in_noise") stimuli = [path.join(wavpath, i) for i in glob.glob(path.join(wavpath, "*.wav"))] outfile = path.realpath(path.expanduser(args["--out"])) env = Environment(trajectory='tone-in-noise', filename=outfile, overwrite_file=True, file_title="Tone in noise at different SNR", comment="some comment", large_overview_tables="False", # freeze_input=True, # use_pool=True, multiproc=True, ncores=3, graceful_exit=True, #wrap_mode=pypetconstants.WRAP_MODE_QUEUE, ) traj = env.trajectory traj.f_add_parameter('periphery', 'verhulst', comment="which periphery was used") traj.f_add_parameter('brainstem', 'nelsoncarney04', comment="which brainstem model was used") traj.f_add_parameter('weighting', "--no-cf-weighting ", comment="weighted CFs") traj.f_add_parameter('wavfile', '', comment="Which wav file to run") traj.f_add_parameter('level', 80, comment="stimulus level, spl") traj.f_add_parameter('neuropathy', "none", comment="") parameter_dict = { "periphery" : ['verhulst', 'zilany'], "brainstem" : ['nelsoncarney04', 'carney2015'], "weighting" : [cf_weighting, ""], "wavfile" : stimuli, "level" : [80], "neuropathy": ["none", "moderate", "severe", "ls-moderate", "ls-severe"] } traj.f_explore(cartesian_product(parameter_dict)) env.run(tone_in_noise) return 0
def main(): # Create an environment that handles running filename = os.path.join('hdf5','example_18.hdf5') env = Environment(trajectory='Multiplication', filename=filename, file_title='Example_18_Many_Runs', overwrite_file=True, comment='Contains many runs', multiproc=True, use_pool=True, freeze_input=True, ncores=2, wrap_mode='QUEUE') # The environment has created a trajectory container for us traj = env.trajectory # Add both parameters traj.f_add_parameter('x', 1, comment='I am the first dimension!') traj.f_add_parameter('y', 1, comment='I am the second dimension!') # Explore the parameters with a cartesian product, yielding 2500 runs traj.f_explore(cartesian_product({'x': range(50), 'y': range(50)})) # Run the simulation env.run(multiply) # Disable logging env.disable_logging() # turn auto loading on, since results have not been loaded, yet traj.v_auto_load = True # Use the `v_idx` functionality traj.v_idx = 2042 print('The result of run %d is: ' % traj.v_idx) # Now we can rely on the wildcards print(traj.res.crunset.crun.z) traj.v_idx = -1 # Or we can use the shortcuts `rts_X` (run to set) and `r_X` to get particular results print('The result of run %d is: ' % 2044) print(traj.res.rts_2044.r_2044.z)
def explore(self): matrices = [] self.explore_dict=cartesian_product({'npstr':[np.array(['Uno', 'Dos', 'Tres']), np.array(['Cinco', 'Seis', 'Siette']), np.array(['Ocho', 'Nueve', 'Diez'])], 'val0':[1,2,3], 'myinttuple':[(1,2,1),(4,5,6),(5,6,7)], 'alist':[[1,2,3,4],['wooot']]} , (('npstr','val0'),'myinttuple', 'alist')) ### Convert the explored stuff into numpy arrays #for idx, val in enumerate(self.explore_dict['myinttuple']): # self.explore_dict['myinttuple'][idx] = np.array(val) ## Explore the parameter: for key, vallist in self.explore_dict.items(): self.param[key]._explore(vallist)
def main(inputargs): args = docopt(__doc__, argv=inputargs) wavpath = path.join(modulePath, "resources", "tone_in_noise") stimuli = [path.join(wavpath, i) for i in glob.glob(path.join(wavpath, "*.wav"))] outfile = path.realpath(path.expanduser(args["--out"])) env = Environment(trajectory='tone-in-noise', filename=outfile, overwrite_file=True, file_title="Tone in noise at different SNR", comment="some comment", large_overview_tables="False", # freeze_input=True, # use_pool=True, multiproc=True, ncores=3, graceful_exit=True, #wrap_mode=pypetconstants.WRAP_MODE_QUEUE, ) traj = env.trajectory traj.f_add_parameter('periphery', 'verhulst', comment="which periphery was used") traj.f_add_parameter('brainstem', 'nelsoncarney04', comment="which brainstem model was used") traj.f_add_parameter('weighting', "--no-cf-weighting ", comment="weighted CFs") traj.f_add_parameter('wavfile', '', comment="Which wav file to run") traj.f_add_parameter('level', 80, comment="stimulus level, spl") traj.f_add_parameter('neuropathy', "none", comment="") parameter_dict = { "periphery" : ['verhulst', 'zilany'], "brainstem" : ['nelsoncarney04', 'carney2015'], "weighting" : [cf_weighting, ""], "wavfile" : stimuli, "level" : [80], "neuropathy": ["none", "moderate", "severe", "ls-moderate", "ls-severe"] } traj.f_explore(cartesian_product(parameter_dict)) env.run(tone_in_noise) return 0
"""Sophisticated simulation of multiplication""" z=traj.x*traj.y traj.f_add_result('z',z=z, comment='I am the product of two reals!') # Create an environment that handles running. # Let's enable multiprocessing with 2 workers. env = Environment(trajectory='Example_04_MP', filename='experiments/example_04/HDF5/example_04.hdf5', file_title='Example_04_MP', log_folder='experiments/example_04/LOGS/', comment = 'Multiprocessing example!', multiproc=True, ncores=2, use_pool=True, wrap_mode=pypetconstants.WRAP_MODE_LOCK) # Get the trajectory from the environment traj = env.v_trajectory # Add both parameters traj.f_add_parameter('x', 1.0, comment='I am the first dimension!') traj.f_add_parameter('y', 1.0, comment='I am the second dimension!') # Explore the parameters with a cartesian product, but we want to explore a bit more traj.f_explore(cartesian_product({'x':[float(x) for x in range(15)], 'y':[float(y) for y in range(15)]})) # Run the simulation env.f_run(multiply)
def main(): """Main function to protect the *entry point* of the program. If you want to use multiprocessing with SCOOP you need to wrap your main code creating an environment into a function. Otherwise the newly started child processes will re-execute the code and throw errors (also see http://scoop.readthedocs.org/en/latest/usage.html#pitfalls). """ # Load settings from file settings_file = 'pypet_settings.pkl' settings = load_obj(settings_file) # Print settings dictionary print('\nSettings dictionary:') for key, value in settings.items(): print(key, ' : ', value) print('\nParameters to explore:') for key, value in settings.items(): if isinstance(value, list): print(key, ' : ', value) # Create new folder to store results traj_dir = os.getcwd() # Read output path (if provided) if len(sys.argv) > 1: # Only use specified folder if it exists if os.path.isdir(sys.argv[1]): # Get name of directory traj_dir = os.path.dirname(sys.argv[1]) # Convert to full path traj_dir = os.path.abspath(traj_dir) # Add time stamp (final '' is to make sure there is a trailing slash) traj_dir = os.path.join(traj_dir, datetime.now().strftime("%Y_%m_%d_%Hh%Mm%Ss"), '') # Create directory with time stamp os.makedirs(traj_dir) # Change current directory to the one containing the trajectory files os.chdir(traj_dir) print('Trajectory and results will be stored in: {0}'.format(traj_dir)) # Create an environment that handles running. # Let's enable multiprocessing with scoop: env = Environment( trajectory='traj', comment='', add_time=False, log_config='DEFAULT', log_stdout= True, # log everything that is printed, will make the log file HUGE filename= traj_dir, # filename or just folder (name will be automatic in this case) multiproc=False, #use_pool=True, #ncores=10, #freeze_input=True, use_scoop=False, #wrap_mode=pypetconstants.WRAP_MODE_LOCAL, memory_cap=1, swap_cap=1 #cpu_cap=30 #,git_repository='' #path to the root git folder. The commit code will be added in the trajectory #,git_fail=True #no automatic commits #,sumatra_project='' #path to sumatra root folder, #graceful_exit=True ) traj = env.trajectory # Add config parameters (those that DO NOT influence the final result of the experiment) traj.f_add_config('parallel_target_analysis', True) #traj.f_add_config('debug', False) #traj.f_add_config('max_mem_frac', 0.7) # Set up trajectory parameters param_to_explore = {} for key, val in settings.items(): if isinstance(val, list): param_to_explore[key] = val traj.f_add_parameter(key, val[0]) else: traj.f_add_parameter(key, val) # Define parameter combinations to explore (a trajectory in # the parameter space). The second argument, the tuple, specifies the order # of the cartesian product. # The variable on the right most side changes fastest and defines the # 'inner for-loop' of the cartesian product explore_dict = cartesian_product(param_to_explore, tuple(param_to_explore.keys())) # explore_dict = cartesian_product( # { # 'network_inference.algorithm': ['bMI_greedy', 'bTE_greedy', 'mTE_greedy'], # #'node_coupling.initial.weight_distribution': ['fixed'], # 'repetition_i': np.arange(0, 5, 1).tolist(), # 'topology.initial.nodes_n': np.arange(50, 50+1, 300).tolist(), # 'node_dynamics.samples_n': np.array([1000, 10000]).tolist(), # 'network_inference.p_value': np.array([0.001]).tolist(), # #'node_coupling.initial.self_coupling': np.arange(-0.5, 0.5 + 0.001, 0.1).tolist(), # #'node_coupling.initial.total_cross_coupling': np.arange(-1., 1 + 0.001, 0.2).tolist(), # #'topology.initial.WS_p': np.around(np.logspace(-2.2, 0, 10), decimals=4).tolist(), # }, # ( # 'network_inference.algorithm', # #'node_coupling.initial.weight_distribution', # 'network_inference.p_value', # 'node_dynamics.samples_n', # 'topology.initial.nodes_n', # #'topology.initial.WS_p', # #'node_coupling.initial.self_coupling', # #'node_coupling.initial.total_cross_coupling', # 'repetition_i', # ) # ) traj.f_explore(explore_dict) # Store trajectory parameters to disk pypet_utils.print_traj_leaves(traj, 'parameters', 'traj_parameters.txt') # Run the experiment env.run(information_network_inference) # env.run(bTE_on_existing_links) # Check that all runs are completed assert traj.f_is_completed() # Finally disable logging and close all log-files env.disable_logging()
def explore2(self, traj): self.explored2 ={'Normal.trial': [0,1], 'Normal.int': [44, 45]} traj.f_explore(cartesian_product(self.explored2, ('Normal.int','Normal.trial') ))
def explore_large(self, traj): self.explored ={'Normal.trial': [0,1]} traj.f_explore(cartesian_product(self.explored))
file_title='Example_01_First_Steps', comment='The first example!', large_overview_tables=True, # To see a nice overview of all # computed `z` values in the resulting HDF5 file. # Per default disabled for more compact HDF5 files. ) # The environment has created a trajectory container for us traj = env.trajectory # Add both parameters traj.f_add_parameter('x', 1, comment='I am the first dimension!') traj.f_add_parameter('y', 1, comment='I am the second dimension!') # Explore the parameters with a cartesian product traj.f_explore(cartesian_product({'x':[1,2,3,4], 'y':[6,7,8]})) # Run the simulation env.run(multiply) # Now let's see how we can reload the stored data from above. # We do not need an environment for that, just a trajectory. from pypet.trajectory import Trajectory # So, first let's create a new trajectory and pass it the path and name of the HDF5 file. # Yet, to be very clear let's delete all the old stuff. del traj # Before deleting the environment let's disable logging and close all log-files env.disable_logging()
def explore_cartesian(self,traj): self.explore_dict=cartesian_product({'x':[-1,1,2,3,4, 5, 6],'y':[1,1,2,2,3,4,4]}) traj.f_explore(self.explore_dict)
def main(): # pypet environment env = Environment( trajectory="missing_rate", comment="Test experiment with varying missing rate", log_config=None, multiproc=False, ncores=1, # use_pool=True, # freeze_input=True, # wrap_mode=pypetconstants.WRAP_MODE_QUEUE, # graceful_exit=True, filename="./simulations/results/test/", overwrite_file=True ) traj = env.trajectory # parameters (data generation) traj.f_add_parameter( "data.N", np.int64(500), "Number of nodes" ) traj.f_add_parameter( "data.K", np.int64(5), "True number of latent components" ) traj.f_add_parameter( "data.p_cts", np.int64(10), "Number of continuous covariates" ) traj.f_add_parameter( "data.p_bin", np.int64(0), "Number of binary covariates" ) traj.f_add_parameter( "data.var_adj", np.float64(1.), "True variance in the link Probit model" ) traj.f_add_parameter( "data.var_cov", np.float64(1.), "True variance in the covariate model (cts and bin)" ) traj.f_add_parameter( "data.missing_rate", np.float64(0.2), "Missing rate" ) traj.f_add_parameter( "data.seed", np.int64(1), "Random seed" ) traj.f_add_parameter( "data.alpha_mean", np.float64(-1.85), "Mean of the heterogeneity parameter" ) # parameters (model) traj.f_add_parameter( "model.K", np.int64(3), "Number of latent components in the model" ) traj.f_add_parameter( "model.adj_model", "Logistic", "Adjacency model" ) traj.f_add_parameter( "model.bin_model", "Logistic", "Binary covariate model" ) # parameters (fit) traj.f_add_parameter( "fit.n_iter", np.int64(10), "Number of VEM iterations" ) traj.f_add_parameter( "fit.n_vmp", np.int64(10), "Number of VMP iterations per E-step" ) traj.f_add_parameter( "fit.n_gd", np.int64(10), "Number of GD iterations per M-step" ) traj.f_add_parameter( "fit.step_size", np.float64(0.01), "GD Step size" ) # experiment explore_dict = { "data.missing_rate": np.array([0.05]), "data.p_cts": np.array([10]), "data.seed": np.array([1]) } experiment = cartesian_product(explore_dict, ('data.missing_rate', "data.p_cts", "data.seed")) traj.f_explore(experiment) env.add_postprocessing(post_processing) env.run(run) env.disable_logging()
env2 = Environment(trajectory='Traj2',filename='experiments/example_03/HDF5/example_03.hdf5', file_title='Example_03', log_folder='experiments/example_03/LOGS/', comment = 'I am going to be merged into some other trajectory!') # Get the trajectories from the environment traj1 = env1.v_trajectory traj2 = env2.v_trajectory # Add both parameters traj1.f_add_parameter('x', 1.0, comment='I am the first dimension!') traj1.f_add_parameter('y', 1.0, comment='I am the second dimension!') traj2.f_add_parameter('x', 1.0, comment='I am the first dimension!') traj2.f_add_parameter('y', 1.0, comment='I am the second dimension!') # Explore the parameters with a cartesian product for the first trajectory: traj1.f_explore(cartesian_product({'x':[1.0,2.0,3.0,4.0], 'y':[6.0,7.0,8.0]})) # Let's explore slightly differently for the second: traj2.f_explore(cartesian_product({'x':[3.0,4.0,5.0,6.0], 'y':[7.0,8.0,9.0]})) # Run the simulations with all parameter combinations env1.f_run(multiply) env2.f_run(multiply) # Now we merge them together into traj1 # We want to remove duplicate entries # like the parameter space point x=3.0, y=7.0. # Several points have been explored by both trajectories and we need them only once. # Therefore, we set remove_duplicates=True (Note this takes O(N1*N2)!). # We also want to backup both trajectories, but we let the system choose the filename. # Accordingly we choose backup_filename=True instead of providing a filename.
file_title='Example_01_First_Steps', comment='The first example!', large_overview_tables=True, # To see a nice overview of all # computed `z` values in the resulting HDF5 file. # Per default disabled for more compact HDF5 files. ) # The environment has created a trajectory container for us traj = env.v_trajectory # Add both parameters traj.f_add_parameter('x', 1, comment='I am the first dimension!') traj.f_add_parameter('y', 1, comment='I am the second dimension!') # Explore the parameters with a cartesian product traj.f_explore(cartesian_product({'x':[1,2,3,4], 'y':[6,7,8]})) # Run the simulation env.f_run(multiply) # Now let's see how we can reload the stored data from above. # We do not need an environment for that, just a trajectory. from pypet.trajectory import Trajectory # So, first let's create a new trajectory and pass it the path and name of the HDF5 file. # Yet, to be very clear let's delete all the old stuff. del traj # Before deleting the environment let's disable logging and close all log-files env.f_disable_logging()
def explore_mp(self, traj): self.explored={'x':[0.0, 1.0, 2.0, 3.0, 4.0], 'y':[0.1, 2.2, 3.3, 4.4, 5.5]} traj.f_explore(cartesian_product(self.explored))
def explore(self, traj): self.explored =cartesian_product({'Normal.trial': [0,1], 'Numpy.double': [np.array([1.0,2.0,3.0,4.0]), np.array([-1.0,3.0,5.0,7.0])]}) traj.f_explore(self.explored)
def main(): """Main function to protect the *entry point* of the program.""" # Load settings from file settings_file = 'pypet_settings.pkl' settings = load_obj(settings_file) # Print settings dictionary print('\nSettings dictionary:') for key, value in settings.items(): print(key, ' : ', value) print('\nParameters to explore:') for key, value in settings.items(): if isinstance(value, list): print(key, ' : ', value) # Create new folder to store results traj_dir = os.getcwd() # Read output path (if provided) if len(sys.argv) > 1: # Add trailing slash if missing dir_provided = os.path.join(sys.argv[1], '') # Check if provided directory exists if os.path.isdir(dir_provided): # Convert to full path traj_dir = os.path.abspath(dir_provided) else: print( 'WARNING: Output path not found, current directory will be used instead' ) else: print( 'WARNING: Output path not provided, current directory will be used instead' ) # Add time stamp (the final '' is to make sure there is a trailing slash) traj_dir = os.path.join(traj_dir, datetime.now().strftime("%Y_%m_%d_%Hh%Mm%Ss"), '') # Create directory with time stamp os.makedirs(traj_dir) # Change current directory to the one containing the trajectory files os.chdir(traj_dir) print('Trajectory and results will be stored in: {0}'.format(traj_dir)) # Create new pypet Trajectory object traj_filename = 'traj.hdf5' traj_fullpath = os.path.join(traj_dir, traj_filename) traj = Trajectory(filename=traj_fullpath) # ------------------------------------------------------------------- # Add config parameters (those that DO NOT influence the final result of the experiment) traj.f_add_config('debug', False, comment='Activate debug mode') # #traj.f_add_config('max_mem_frac', 0.7, comment='Fraction of global GPU memory to use') # Set up trajectory parameters param_to_explore = {} for key, val in settings.items(): if isinstance(val, list): param_to_explore[key] = val traj.f_add_parameter(key, val[0]) else: traj.f_add_parameter(key, val) # Define parameter combinations to explore (a trajectory in # the parameter space). The second argument, the tuple, specifies the order # of the cartesian product. # The variable on the right most side changes fastest and defines the # 'inner for-loop' of the cartesian product explore_dict = cartesian_product(param_to_explore, tuple(param_to_explore.keys())) print(explore_dict) traj.f_explore(explore_dict) # Store trajectory parameters to disk pypet_utils.print_traj_leaves(traj, 'parameters', file=os.path.join(traj_dir, 'traj_parameters.txt')) # Store trajectory traj.f_store() # Define PBS script bash_lines = '\n'.join([ '#! /bin/bash', '#PBS -P InfoDynFuncStruct', '#PBS -l select=1:ncpus=1:mem=1GB', #'#PBS -l select=1:ncpus=1:ngpus=1:mem=1GB', '#PBS -M [email protected]', '#PBS -m abe', 'module load java', 'module load python/3.5.1', 'module load cuda/8.0.44', 'source /project/RDS-FEI-InfoDynFuncStruct-RW/Leo/idtxl_env/bin/activate', 'cd ${traj_dir}', 'python ${python_script_path} ${traj_dir} ${traj_filename} ${file_prefix} $PBS_ARRAY_INDEX' ]) # Save PBS script file (automatically generated) bash_script_name = 'run_python_script.pbs' job_script_path = os.path.join(traj_dir, bash_script_name) with open(job_script_path, 'w', newline='\n') as bash_file: bash_file.writelines(bash_lines) # Run job array job_walltime_hours = 0 job_walltime_minutes = 5 #after_job_array_ends = 1573895 job_settings = { 'N': 'run_traj', 'l': 'walltime={0}:{1}:00'.format(job_walltime_hours, job_walltime_minutes), #'W': 'depend=afteranyarray:{0}[]'.format(after_job_array_ends), 'q': 'defaultQ' } if len(traj.f_get_run_names()) > 1: job_settings['J'] = '{0}-{1}'.format(0, len(traj.f_get_run_names()) - 1) job_args = { 'python_script_path': '/project/RDS-FEI-InfoDynFuncStruct-RW/Leo/inference/hpc_pypet_single_run.py', 'traj_dir': traj_dir, 'traj_filename': traj_filename, 'file_prefix': 'none' } run_job_array(job_script_path, job_settings, job_args)
def main(): # Get current directory traj_dir = os.getcwd() # Read output path (if provided) if len(sys.argv) > 1: # Only use specified folder if it exists if os.path.isdir(sys.argv[1]): # Get name of directory traj_dir = os.path.dirname(sys.argv[1]) # Convert to full path traj_dir = os.path.abspath(traj_dir) # Add time stamp (final '' is to make sure there is a trailing slash) traj_dir = os.path.join(traj_dir, datetime.now().strftime("%Y_%m_%d_%Hh%Mm%Ss"), '') # Create directory with time stamp os.makedirs(traj_dir) # Change current directory to the one containing the trajectory files os.chdir(traj_dir) print('Trajectory and results will be stored to: {0}'.format(traj_dir)) # Create an environment that handles running. # Let's enable multiprocessing with scoop: env = Environment( trajectory='traj', comment='', add_time=False, log_config='DEFAULT', log_stdout= True, # log everything that is printed, will make the log file HUGE filename= traj_dir, # filename or just folder (name will be automatic in this case) multiproc=True, use_scoop=True, wrap_mode=pypetconstants.WRAP_MODE_LOCAL, memory_cap=10, swap_cap=1) traj = env.trajectory # ------------------------------------------------------------------- # Add config parameters (those that DO NOT influence the final result of the experiment) traj.f_add_config('parallel_target_analysis', False, comment='Analyse targets in parallel') # ------------------------------------------------------------------- # Parameters characterizing the initial topology of the network traj.f_add_parameter('topology.initial.model', 'BA') #traj.f_add_parameter('topology.initial.model', 'WS') traj.f_add_parameter('topology.initial.nodes_n', 5, comment='Number of nodes') #traj.f_add_parameter('topology.initial.WS_k', 4, comment='Number of neighbours (and mean degree) in the Watts-Strogatz model') #traj.f_add_parameter('topology.initial.WS_p', 0.0, comment='Rewiring probability in the Watts-Strogatz model') traj.f_add_parameter( 'topology.initial.BA_m', 1, comment= 'Number of edges to attach from a new node to existing nodes in the Barabási–Albert model' ) # ------------------------------------------------------------------- # Parameters characterizing the coupling between the nodes traj.f_add_parameter( 'node_coupling.initial.model', 'linear', comment= 'Linear coupling model: the input to each target node is the weighted sum of the outputs of its source nodes' ) traj.f_add_parameter('node_coupling.initial.weight_distribution', 'fixed') traj.f_add_parameter('node_coupling.initial.fixed_coupling', 0.1) # ------------------------------------------------------------------- # Parameters characterizing the delay traj.f_add_parameter('delay.initial.distribution', 'uniform') traj.f_add_parameter('delay.initial.delay_links_n_max', 1, comment='Maximum number of delay links') traj.f_add_parameter('delay.initial.delay_min', 1, comment='') traj.f_add_parameter('delay.initial.delay_max', 1, comment='') traj.f_add_parameter('delay.initial.delay_self', 1, comment='') # ------------------------------------------------------------------- # Parameters characterizing the estimator traj.f_add_parameter('estimation.history_source', 1, comment='Embedding length for the source') traj.f_add_parameter('estimation.history_target', 14, comment='Embedding length for the target') # ------------------------------------------------------------------- # Parameters characterizing the dynamics of the nodes traj.f_add_parameter('node_dynamics.model', 'AR_gaussian_discrete') #traj.f_add_parameter('node_dynamics.model', 'boolean_random') traj.f_add_parameter('node_dynamics.samples_n', 100, comment='Number of samples (observations) to record') traj.f_add_parameter( 'node_dynamics.samples_transient_n', 1000 * traj.topology.initial.nodes_n, comment= 'Number of initial samples (observations) to skip to leave out the transient' ) traj.f_add_parameter('node_dynamics.replications', 1, comment='Number of replications (trials) to record') traj.f_add_parameter('node_dynamics.noise_std', 1, comment='Standard deviation of Gaussian noise') #traj.f_add_parameter('node_dynamics.RBN_r', 0.5, comment='Activity level (i.e. probability of state "1") in Boolean dynamics') #traj.f_add_parameter('node_dynamics.noise_flip_p', 0.005, comment='Probability of flipping bit in Boolean dynamics') # ------------------------------------------------------------------- # Parameters characterizing the repetitions of the same run traj.f_add_parameter( 'repetition_i', 0, comment='Index of the current repetition') # Normally starts from 0 # ------------------------------------------------------------------- # Define parameter combinations to explore (a trajectory in # the parameter space) # The second argument, the tuple, specifies the order of the cartesian product, # The variable on the right most side changes fastest and defines the # 'inner for-loop' of the cartesian product explore_dict = cartesian_product( { 'node_coupling.initial.weight_distribution': ['fixed'], 'repetition_i': np.arange(0, 10000, 1).tolist(), 'topology.initial.nodes_n': np.arange(100, 100 + 1, 30).tolist(), 'node_dynamics.samples_n': np.array([100]).tolist(), #'topology.initial.WS_p': np.around(np.logspace(-2.2, 0, 10), decimals=4).tolist(), }, ( 'node_coupling.initial.weight_distribution', 'node_dynamics.samples_n', 'topology.initial.nodes_n', #'topology.initial.WS_p', 'repetition_i', )) print(explore_dict) traj.f_explore(explore_dict) # Run the experiment env.run(compute_bTE_all_pairs) # Check that all runs are completed assert traj.f_is_completed() # Finally disable logging and close all log-files env.disable_logging()
def explore_trials_differently(self, traj): self.explored ={'Normal.trial': [0,1], 'Numpy.double': [np.array([-1.0,2.0,3.0,5.0]), np.array([-1.0,3.0,5.0,7.0])]} traj.f_explore(cartesian_product(self.explored, ('Numpy.double','Normal.trial')))
traj.f_add_parameter('dThetha', np.float64(0)) traj.f_add_parameter('dPhi', np.float64(0)) traj.f_add_parameter('ux', np.float64(1)) traj.f_add_parameter('uy', np.float64(1)) traj.f_add_parameter('uz', np.float64(1)) traj.f_add_parameter('uThetha', np.float64(0)) traj.f_add_parameter('uPhi', np.float64(0)) # Explore the parameters with a cartesian product space_range = np.arange(-2, 2, 0.5) dx_range = 2.5 + space_range dy_range = 0.8 + space_range dz_range = [0] trajectory = { 'dx': dx_range, 'dy': dx_range, 'dz': dx_range, 'dThetha': [np.float64(0.006)], 'dPhi': [np.float64(0.1)], 'ux': [np.float64(0)], 'uy': [np.float64(0)], 'uz': [np.float64(0)], 'uThetha': [np.float64(-0.001)], 'uPhi': [np.float64(-0.003)] } traj.f_explore(cartesian_product(trajectory)) # Run the simulation env.run(cross_tune)
# Create an environment that handles running env = Environment(trajectory='Example10',filename='experiments/example_08/HDF5/example_10.hdf5', file_title='Example10', log_folder='experiments/example_08/LOGS/', comment='Another example!') # Get the trajectory from the environment traj = env.v_trajectory # Add both parameters traj.f_add_parameter('x', 1, comment='I am the first dimension!') traj.f_add_parameter('y', 1, comment='I am the second dimension!') # Explore the parameters with a cartesian product: x_length = 15 y_length = 15 traj.f_explore(cartesian_product({'x':range(x_length), 'y':range(y_length)})) # Run the simulation env.f_run(multiply) # We load all results traj.f_load(load_results=pypetconstants.LOAD_DATA) # We access the ranges for plotting xs = traj.f_get('x').f_get_range() ys = traj.f_get('y').f_get_range() # Now we want to directly get all numbers z from all runs # for plotting. # We use `fast_access=True` to directly get access to # the values.