Calculations Parameter Space Exploration

[sbastiaens]

Calculations for medium and large size parameter space exploration for each model (Generic2DOscillator, Wilson-Cowan, Jansen-Riit

[sbastiaens]

After multiple runs, this is the estimated time I deduced corresponding to one simulation run (for each model): Generic 2D Oscillator : 1.14 seconds Wilson-Cowan: 3.67 s Jansen-Rit : 1.2 s Therefore, the general formula I used was : number of variables ^(number of parameters) x time taken for one combination of parameters.

After looking at the TVB documentation, I am proposing the range of each parameters to be the value closest to their range limit (not always the limit values itself as some combinations don't compute). From the range, I chose a granularity to obtain 11 variables per parameters. Proposal of first runs for each model:

• Generic2DOscillator: params_g = [-5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0] params_alpha = -5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0] params_b = [-3.5, -2.8, -2.1, -1.4, -0.7, 0.0, 0.7, 1.4, 2.1, 2.8, 3.5] params_c = [-0.5, -0.4, -0.3, -0.2, -0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5]

• Wilson-Cowan: params_c_ee = [11.0, 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5, 15.0, 15.5, 16.0] params_c_ei = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 22.0]
  params_c_ie = [2.0, 3.3, 4.6, 5.9, 7.2, 8.5, 9.8, 11.1, 12.4, 13.7, 15.0]
  params_c_ii = [2.0, 3.3, 4.6, 5.9, 7.2, 8.5, 9.8, 11.1, 12.4, 13.7, 15.0]

• Jansen-Rit params_J= [65, 118.5, 172, 225.5, 279, 332.5, 386, 439.5, 493, 546.5, 600] params_A = [4.75, 5.25, 5.75, 6.25, 6.75, 7.25, 7.75, 8.25, 8.75, 9.25, 9.75] params_B = [22.0, 30.0, 38.0, 46.0, 54.0, 62.0, 70.0, 78.0, 86.0, 94.0, 102.0] params_mu = [0.02, 0.04, 0.06, 0.08, 0.10, 0.12, 0.14, 0.16, 0.18, 0.20, 0.22]

Here is the approximate time it would take for 4 parameters and 11 variables:

• Generic 2D Oscillator: 4h37min
• Wilson-Cowan: 14h55min
• Jansen-Rit: 4h52min

I am still working on the code to generate the database. Since, Wilson-Cowan simulations take a much longer time to run then the other two, maybe these simulations could be run on a grid? Let me know what you think of the first run proposals and if I need to make other proposal

[JohnGriffiths]

Thinking about how this would be used in a HPC context (i.e. batch submission of jobs to a compute grid).

Because each execution time is on the order of seconds, we wouldn't want to submit a single job for each parameter comb.

Depending on the specific grid capacity, you generally want each individual grid jobs to run between a few dozen minutes to a few hours.

So the right way to do this would be to send small lists of parameter combs to each grid job.

This is actually convenient because it makes the grid submission use case somewhat similar to the local machine use case.

What we need to have is a python file that runs something like this from the command line

python make_funit_db.py params.txt outfile.csv

make_funit_db.py should have, minimally, the following two methods:

def make_db - makes the database file for a param list and output filename (TVB_database in the current code seems fine for this)

def main.... - controls the command line execution. Reads in the text file defining the parameter set and the output filename, supplied during the command line call. Gives that info to a make_db call

We also want to be able to run within python. So that would be something like

from make_funit_db import make_db
make_db(input_args)

...which would correspond to the current usage in the nb.

[rgerkin]

@JohnGriffiths And do you imagine that the python file you described is run once per job? So then there needs to be another controller to split up the big params list into each of the params.txt that get sent to each job, and finally a script (one or two lines) to collect and merge the resulting outfile.csv files.