def initialize(self, file_name, to_csv=False): dismod_at.create_database(file_name, self.age_list, self.time_list, self.integrand_table, self.node_table, self.weight_table, self.covariate_table, self.avgint_table, self.data_table, self.prior_table, self.smooth_table, list(), self.rate_table, self.mulcov_table, self.option_table) if to_csv: flag = subprocess.call([program, file_name, 'init']) if flag != 0: sys.exit('command failed: flag = ' + str(flag)) dismod_at.db2csv_command(file_name)
def init_database(self, db2csv: bool = True): dismod_at.create_database(self.path, self.age_list, self.time_list, self.integrand_table, self.node_table, self.weight_table, self.covariate_table, self.avgint_table, self.data_table, self.prior_table, self.smooth_table, list(), self.rate_table, self.mulcov_table, self.option_table) if not os.path.exists(self.path): os.mknod(self.path) command = [program, self.path, 'init'] print(' '.join(command)) flag = subprocess.call(command) if flag != 0: sys.exit('The dismod_at init command failed') if db2csv is True: dismod_at.db2csv_command(self.path)
def example_db(file_name): from math import log def fun_iota_world(a, t): value = 'prior_iota_world_value' dage = 'prior_iota_world_smooth' return ('prior_iota_world_value', None, None) def fun_iota_child(a, t): return ('prior_iota_child_value', None, None) def fun_omega_world(a, t): return (omega_true['world'], None, None) def fun_omega_child_1(a, t): return (omega_true['child_1'], None, None) def fun_omega_child_2(a, t): return (omega_true['child_2'], None, None) # ---------------------------------------------------------------------- # age table: age_list = [0.0, 100.0] # # time table: time_list = [1990.0, 2200.0] # # integrand table: integrand_table = [{'name': 'susceptible'}] # # node table: node_table = [{ 'name': 'world', 'parent': '' }, { 'name': 'child_1', 'parent': 'world' }, { 'name': 'child_2', 'parent': 'world' }] # # weight table: weight_table = list() # # covariate table: covariate_table = list() # # mulcov table: mulcov_table = list() # # avgint table: empty avgint_table = list() # ---------------------------------------------------------------------- # data table: data_table = list() # values that are the same for all data rows row = { 'meas_value': 0.0, # not used (will be simulated) 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000., 'time_upper': 2000., 'integrand': 'susceptible', 'meas_std': 0.005, 'subgroup': 'world' } # values that change between rows: node_name = ['world', 'child_1', 'child_2'] age_value = [10, 100, 10, 100] time_value = [time_list[0], time_list[0], time_list[-1], time_list[-1]] for data_id in range(n_data): age = age_value[data_id % 4] time = time_value[data_id % 4] row['age_lower'] = age row['age_upper'] = age row['time_lower'] = time row['time_upper'] = time row['node'] = node_name[data_id % 3] data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota_world_value 'name': 'prior_iota_world_value', 'density': 'uniform', 'lower': iota_true['world'] / 10., 'upper': iota_true['world'] * 10., 'mean': iota_true['world'] * 2.0, },{ # prior_iota_child_value 'name': 'prior_iota_child_value', 'density': 'gaussian', 'mean': 0.0, 'std': 1.0 },{ # prior_iota_world_smooth 'name': 'prior_iota_world_smooth', 'density': 'gaussian', 'mean': 0.0, 'std': iota_true['world'] / 10.0 } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_iota_world 'name': 'smooth_iota_world', 'age_id': [0, 1], 'time_id': [0, 1], 'fun': fun_iota_world }, { # smooth_iota_child 'name': 'smooth_iota_child', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_child }, { # smooth_omega_world 'name': 'smooth_omega_world', 'age_id': [0, 1], 'time_id': [0, 1], 'fun': fun_omega_world }, { # smooth_omega_child_1 'name': 'smooth_omega_child_1', 'age_id': [0], 'time_id': [0], 'fun': fun_omega_child_1 }, { # smooth_omega_child_2 'name': 'smooth_omega_child_2', 'age_id': [0], 'time_id': [0], 'fun': fun_omega_child_2 } ] # # nslist_table: nslist_table = dict() nslist_table['omega_nslist'] = [('child_1', 'smooth_omega_child_1'), ('child_2', 'smooth_omega_child_2')] # ---------------------------------------------------------------------- # rate table: rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota_world', 'child_smooth': 'smooth_iota_child', }, { 'name': 'omega', 'parent_smooth': 'smooth_omega_world', 'child_nslist': 'omega_nslist', }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'random_seed', 'value': str(random_seed) }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'max_num_iter_fixed', 'value': '50' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-8' }, { 'name': 'max_num_iter_random', 'value': '50' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-10' }, { 'name': 'zero_sum_child_rate', 'value': 'iota' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db(file_name, meas_noise_effect): # ---------------------------------------------------------------------- # age table: age_list = [0.0, 100.0] # # time table: time_list = [1990.0, 2200.0] # # integrand table: integrand_table = [{'name': 'Sincidence'}] # # node table: node_table = [{'name': 'world', 'parent': ''}] # # weight table: # The constant function 1.0, note any valid age and time id would work name = 'constant' fun = weight_fun age_id = 0 time_id = 0 weight_table = [{ 'name': name, 'age_id': [age_id], 'time_id': [time_id], 'fun': fun }] # # covariate table: covariate_table = [{'name': 'one', 'reference': 0.0}] # # mulcov table: mulcov_table = [{ 'covariate': 'one', 'type': 'meas_noise', 'effected': 'Sincidence', 'group': 'world', 'smooth': 'smooth_gamma' }] # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # values that are the same for all data rows row = { 'meas_value': 0.0, # not used (will be simulated) 'density': 'gaussian', 'weight': 'constant', 'hold_out': False, 'time_lower': 2000., 'time_upper': 2000., 'integrand': 'Sincidence', 'meas_std': data_std, 'node': 'world', 'subgroup': 'world', 'one': 1.0 } if meas_noise_effect == 'add_std_scale_all': delta = data_std * (1.0 + gamma_true_scale) gamma_true = gamma_true_scale elif meas_noise_effect == 'add_std_scale_log': delta = data_std * (1.0 + gamma_true_scale) gamma_true = gamma_true_scale * data_std elif meas_noise_effect == 'add_var_scale_all': delta = data_std * math.sqrt(1.0 + gamma_true_scale) gamma_true = gamma_true_scale else: assert meas_noise_effect == 'add_var_scale_log' delta = data_std * math.sqrt(1.0 + gamma_true_scale) gamma_true = gamma_true_scale * data_std * data_std # values that change between rows: for data_id in range(n_data): row['meas_value'] = random.gauss(iota_true, delta) fraction = data_id / float(n_data - 1) age = age_list[0] + (age_list[-1] - age_list[0]) * fraction row['age_lower'] = age row['age_upper'] = age data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota 'name': 'prior_iota', 'density': 'uniform', 'lower': iota_true / 100.0, 'upper': 1.0, 'mean': iota_true / 10.0 }, { # prior_gamma 'name': 'prior_gamma', 'density': 'uniform', 'lower': 0.0, 'upper': 10.0 * gamma_true, 'mean': gamma_true / 10.0 } ] # ---------------------------------------------------------------------- # smooth table name = 'smooth_iota' fun = fun_iota age_id = 0 time_id = 0 smooth_table = [{ 'name': name, 'age_id': [age_id], 'time_id': [time_id], 'fun': fun }] name = 'smooth_iota' # name = 'smooth_gamma' fun = fun_gamma smooth_table.append({ 'name': name, 'age_id': [age_id], 'time_id': [time_id], 'fun': fun }) # ---------------------------------------------------------------------- # rate table: rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota', 'child_smooth': None }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'meas_noise_effect', 'value': meas_noise_effect }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'random_seed', 'value': '0' }, { 'name': 'zero_sum_child_rate', 'value': 'iota' }, { 'name': 'quasi_fixed', 'value': 'false' }, { 'name': 'derivative_test_fixed', 'value': 'second-order' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-10' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db(file_name): def fun_rate_child(a, t): return ('prior_rate_child', None, 'prior_child_diff') def fun_rate_parent(a, t): return ('prior_rate_parent', None, 'prior_parent_diff') import dismod_at # ---------------------------------------------------------------------- # age table age_list = [0.0, 50.0, 100.0] # # time table time_list = [1995.0, 2005.0, 2015.0] # # integrand table integrand_table = [{'name': 'Sincidence'}] # # node table: world -> north_america # north_america -> (united_states, canada) node_table = [{ 'name': 'world', 'parent': '' }, { 'name': 'north_america', 'parent': 'world' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # avgint table: avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # write out data row = { 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000.0, 'time_upper': 2000.0, 'age_lower': 50.0, 'age_upper': 50.0, 'integrand': 'Sincidence', 'subgroup': 'world', } row['node'] = 'north_america' row['meas_value'] = iota_parent_true row['meas_std'] = row['meas_value'] * 1e-1 data_table.append(copy.copy(row)) # row['node'] = 'united_states' row['meas_value'] = iota_parent_true * exp(united_states_random_effect) row['meas_std'] = row['meas_value'] * 1e-1 data_table.append(copy.copy(row)) # row['node'] = 'canada' row['meas_value'] = iota_parent_true * exp(-united_states_random_effect) row['meas_std'] = row['meas_value'] * 1e-1 data_table.append(copy.copy(row)) # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_rate_parent 'name': 'prior_rate_parent', 'density': 'uniform', 'lower': iota_parent_true / 100., 'upper': iota_parent_true * 100., # set prior so north_amaerica is set to value for united_states 'mean': iota_parent_true * exp( united_states_random_effect ) },{ # prior_rate_child 'name': 'prior_rate_child', 'density': 'gaussian', 'mean': 0.0, # std is very large so like a uniform distribution 'std': 100.0, },{ # prior_parent_diff 'name': 'prior_parent_diff', 'density': 'log_gaussian', 'mean': 0.0, 'std': 0.1, 'eta': 1e-8 },{ # prior_child_diff 'name': 'prior_child_diff', 'density': 'gaussian', 'mean': 0.0, 'std': 0.1, } ] # ---------------------------------------------------------------------- # smooth table last_time_id = 2 smooth_table = [ { # smooth_rate_child 'name': 'smooth_rate_child', 'age_id': [0], 'time_id': [0, last_time_id], 'fun': fun_rate_child }, { # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': [0], 'time_id': [0, last_time_id], 'fun': fun_rate_parent } ] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': 'smooth_rate_child', }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'north_america' }, { 'name': 'derivative_test_random', 'value': 'second-order' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'tolerance_random', 'value': '1e-10' }, { 'name': 'method_random', 'value': 'ipopt_solve' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db(file_name): def fun_iota_parent(a, t): return ('prior_iota_parent_value', None, None) def fun_iota_child(a, t): return ('prior_iota_child', None, None) def fun_iota_group(a, t): return ('prior_iota_group', None, None) def fun_iota_subgroup(a, t): return ('prior_iota_subgroup', None, None) # # age_table age_list = [0.0, 100.0] # # time_table time_list = [1990.0, 2020.0] # # node_table node_table = [ { 'name': 'p1', 'parent': '' }, { 'name': 'c1', 'parent': 'p1' }, { 'name': 'c2', 'parent': 'p1' }, ] # # subgroup_table subgroup_table = [ { 'subgroup': 'none', 'group': 'none' }, { 'subgroup': 's1', 'group': 'g1' }, { 'subgroup': 's2', 'group': 'g1' }, ] # rate_table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota_parent', 'child_smooth': 'smooth_iota_child', }] # covariate_table covariate_table = [{'name': 'one', 'reference': 0.0}] # mulcov_table mulcov_table = [{ 'covariate': 'one', 'type': 'rate_value', 'effected': 'iota', 'group': 'g1', 'smooth': 'smooth_iota_group', 'subsmooth': 'smooth_iota_subgroup', }] # prior_table prior_table = [ { # prior_iota_parent_value 'name': 'prior_iota_parent_value', 'density': 'uniform', 'lower': iota_parent_true / 100.0, 'upper': iota_parent_true * 100.0, 'mean': iota_parent_true / 2.0, },{ # prior_iota_child 'name': 'prior_iota_child', 'density': 'uniform', 'mean': 1e-3, },{ # prior_iota_group 'name': 'prior_iota_group', 'density': 'uniform', 'mean': 0.0, },{ # prior_iota_subgroup 'name': 'prior_iota_subgroup', 'density': 'uniform', 'mean': 1e-3, } ] # smooth_table smooth_table = [ { # smooth_iota_parent 'name': 'smooth_iota_parent', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_parent }, { # smooth_iota_child 'name': 'smooth_iota_child', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_child }, { # smooth_iota_group 'name': 'smooth_iota_group', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_group }, { # smooth_iota_subgroup 'name': 'smooth_iota_subgroup', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_subgroup } ] # weight table: weight_table = list() # nslist_table nslist_table = dict() # option_table option_table = [ { 'name': 'parent_node_name', 'value': 'p1' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'zero_sum_child_rate', 'value': 'iota' }, { 'name': 'zero_sum_mulcov_group', 'value': 'g1' }, { 'name': 'quasi_fixed', 'value': 'false' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-12' }, { 'name': 'derivative_test_fixed', 'value': 'adaptive' }, ] # integrand_table integrand_table = [{'name': 'Sincidence'}] # ------------------------------------------------------------------------ # data_table data_table = list() # values that are the same for all data points row = { 'integrand': 'Sincidence', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'age_lower': 50.0, 'age_upper': 50.0, 'time_lower': 2000.0, 'time_upper': 2000.0, 'one': 1.0, } for child in ['c1', 'c2']: for subgroup in ['s1', 's2', 'none']: # true value of iota for this child, subgroup iota = avg_integrand(child, subgroup) # measurement standard deviation is used during fittting meas_std = iota * meas_cv # for this example, measurements are simulated without any noise meas_value = iota # row['node'] = child row['subgroup'] = subgroup row['meas_value'] = meas_value row['meas_std'] = meas_std data_table.append(copy.copy(row)) # ------------------------------------------------------------------------ # avgint_table avgint_table = list() # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)
def example_db(file_name): def fun_meas_subgroup(a, t): return ('prior_meas_subgroup', None, 'prior_gauss_diff') def fun_rate_parent(a, t): return ('prior_rate_parent', None, 'prior_gauss_diff') import dismod_at # ---------------------------------------------------------------------- # age list age_list = [0.0, 50.0, 100.0] # # time list time_list = [1990.0, 2010.0] # # integrand table integrand_table = [{'name': 'Sincidence'}, {'name': 'remission'}] # # node table: north_america -> (united_states, canada) node_table = [{ 'name': 'north_america', 'parent': '' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # # subgroup_table subgroup_table = [ { 'subgroup': 'united_states', 'group': 'north_america' }, { 'subgroup': 'canada', 'group': 'north_america' }, ] # # mulcov table mulcov_table = [ { # subgroup covariate multiplers effecting Sincidence 'covariate': 'one', 'type': 'meas_value', 'effected': 'Sincidence', 'group': 'north_america', 'smooth': None, 'subsmooth': 'smooth_meas_subgroup' }, { # subgroup covariate multipliers effecting remissions 'covariate': 'one', 'type': 'meas_value', 'effected': 'remission', 'group': 'north_america', 'smooth': None, 'subsmooth': 'smooth_meas_subgroup' } ] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = [{ 'name': 'one', 'reference': 0.0, 'max_difference': None }] # # avgint table: same order as list of integrands avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table data_table = list() # write out data row = { 'density': 'gaussian', 'weight': '', 'hold_out': False, 'age_lower': 50.0, 'age_upper': 50.0, 'one': 1.0, } for data_id in range(number_data): if data_id % 2 == 0: row['node'] = 'united_states' row['subgroup'] = 'united_states' row['data_name'] = 'us_' + str(data_id / 2) effect_true = -subgroup_mulcov if data_id % 3 == 2: row['node'] = 'canada' row['subgroup'] = 'canada' row['data_name'] = 'ca_' + str(data_id / 2) effect_true = +subgroup_mulcov if data_id % 4 < 2: row['time_lower'] = 1990.0 row['time_upper'] = 1990.0 else: row['time_lower'] = 2010.0 row['time_upper'] = 2010.0 # if data_id < number_data / 2: rate_true = iota_parent row['integrand'] = 'Sincidence' else: rate_true = rho_parent row['integrand'] = 'remission' # meas_mean = math.exp(effect_true) * rate_true meas_std = meas_mean * measurement_cv row['meas_value'] = random.gauss(meas_mean, meas_std) row['meas_std'] = meas_std data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_rate_parent 'name': 'prior_rate_parent', 'density': 'uniform', 'lower': min(iota_parent, rho_parent) / 100.0, 'upper': max(iota_parent, rho_parent) * 100.0, 'mean': 2.0 * max(iota_parent, rho_parent), },{ # prior_meas_subgroup 'name': 'prior_meas_subgroup', 'density': 'gaussian', 'mean': 0.0, 'std': 100.0, # very large so like uniform distribution },{ # prior_gauss_diff 'name': 'prior_gauss_diff', 'density': 'uniform', 'mean': 0.0, 'std': 100.0, # very large so like uniform distribution } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_meas_subgroup 'name': 'smooth_meas_subgroup', 'age_id': [0], 'time_id': [0, 1], 'fun': fun_meas_subgroup }, { # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': [0], 'time_id': [0, 1], 'fun': fun_rate_parent } ] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': None, }, { 'name': 'rho', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': None, }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'north_america' }, { 'name': 'zero_sum_mulcov_group', 'value': 'north_america' }, { 'name': 'random_seed', 'value': '0' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_pos' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'derivative_test_fixed', 'value': 'first-order' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-7' }, { 'name': 'derivative_test_random', 'value': 'second-order' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-10' }] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)
def create_database(): import dismod_at import copy # # file_name, age_list, time_list, integrand_table file_name = 'example.db' age_list = [50.0] time_list = [2000.0] integrand_table = [{'name': 'mtother', 'minimum_meas_cv': 0.0}] # # node_table node_table = [{ 'name': 'world', 'parent': '' }, { 'name': 'north_america', 'parent': 'world' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # weight_table fun = constant_weight_fun weight_table = [{ 'name': 'constant', 'age_id': [0], 'time_id': [0], 'fun': fun }] # covariate_table covariate_table = [{ 'name': 'sex', 'reference': 0.0, 'max_difference': 0.6 }] # data_table data_table = [] row = { 'integrand': 'mtother', 'density': 'log_gaussian', 'weight': 'constant', 'hold_out': False, 'meas_std': 1e-5, 'age_lower': 0.0, 'age_upper': 100.0, 'time_lower': 1990.0, 'time_upper': 2010.0, 'sex': 0.5, 'subgroup': 'world', } row['data_name'] = 'one' row['node'] = 'north_america' row['meas_value'] = 1.0e-5 data_table.append(copy.copy(row)) row['data_name'] = 'two' row['node'] = 'united_states' row['meas_value'] = 1.5e-5 data_table.append(copy.copy(row)) row['data_name'] = 'three' row['node'] = 'canada' row['meas_value'] = 0.5e-5 data_table.append(copy.copy(row)) # # prior_table prior_table = [{ 'name': 'zero', 'density': 'uniform', 'lower': 0.0, 'upper': 0.0, 'mean': 0.0, }, { 'name': 'one', 'density': 'uniform', 'lower': 1.0, 'upper': 1.0, 'mean': 1.0, }, { 'name': 'uniform_01', 'density': 'uniform', 'lower': 0.0, 'upper': 1.0, 'mean': 0.1, }, { 'name': 'gaussian_01', 'density': 'gaussian', 'mean': 0.0, 'std': 1.0, }, { 'name': 'log_gaussian', 'density': 'log_gaussian', 'mean': 0.0, 'eta': 1e-6 }] # # smooth list smooth_table = [{ 'name': 'uniform_01_constant', 'age_id': [0], 'time_id': [0], 'mulstd_value_prior_name': None, 'mulstd_dage_prior_name': None, 'mulstd_dtime_prior_name': None, 'fun': smooth_uniform_01_fun }, { 'name': 'gaussian_01_constant', 'age_id': [0], 'time_id': [0], 'mulstd_value_prior_name': None, 'mulstd_dage_prior_name': None, 'mulstd_dtime_prior_name': None, 'fun': smooth_gaussian_01_fun }] # # rate_table rate_table = [{ 'name': 'pini', 'parent_smooth': 'uniform_01_constant', 'child_smooth': 'gaussian_01_constant', 'child_nslist': None }, { 'name': 'iota', 'parent_smooth': 'uniform_01_constant', 'child_smooth': 'gaussian_01_constant', 'child_nslist': None }, { 'name': 'rho', 'parent_smooth': 'uniform_01_constant', 'child_smooth': 'gaussian_01_constant', 'child_nslist': None }, { 'name': 'chi', 'parent_smooth': 'uniform_01_constant', 'child_smooth': 'gaussian_01_constant', 'child_nslist': None }, { 'name': 'omega', 'parent_smooth': 'uniform_01_constant', 'child_smooth': 'gaussian_01_constant', 'child_nslist': None }] # # mulcov_table mulcov_table = [{ 'covariate': 'sex', 'type': 'rate_value', 'effected': 'omega', 'group': 'world', 'smooth': 'uniform_01_constant' }] # # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'random_seed', 'value': '0' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_pos' }, { 'name': 'tolerance', 'value': '1e-8' }, { 'name': 'max_num_iter', 'value': '100' }, { 'name': 'print_level', 'value': '0' }, { 'name': 'derivative_test', 'value': 'second-order' }] # avgint_table avgint_table = [] row = { 'integrand': 'mtother', 'weight': 'constant', 'age_lower': 0.0, 'age_upper': 100.0, 'time_lower': 1990.0, 'time_upper': 2010.0, 'sex': 0.5, 'subgroup': 'world', } row['node'] = 'north_america' avgint_table.append(copy.copy(row)) row['node'] = 'united_states' avgint_table.append(copy.copy(row)) row['node'] = 'canada' row['meas_value'] = 0.5e-5 avgint_table.append(copy.copy(row)) # nslist_table nslist_table = dict() # # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- # Check database # ---------------------------------------------------------------------- # # connection new = False connection = dismod_at.create_connection(file_name, new) # # age_table tbl_name = 'age' col_name = ['age'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) col_list = column_as_list(row_list, 0) assert col_list == age_list # # time_table tbl_name = 'time' col_name = ['time'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) col_list = column_as_list(row_list, 0) assert col_list == time_list # # intergrand_table tbl_name = 'integrand' col_name = ['integrand_name'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['mtother']] assert row_list == check_list # # weight_table tbl_name = 'weight' col_name = ['weight_name', 'n_age', 'n_time'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['constant', 1, 1]] assert row_list == check_list # # weight_grid_table tbl_name = 'weight_grid' col_name = ['weight_id', 'age_id', 'time_id', 'weight'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [[0, 0, 0, 1.0]] assert row_list == check_list # # covariate_table tbl_name = 'covariate' col_name = ['covariate_name', 'reference'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['sex', 0.0]] assert row_list == check_list # # node_table tbl_name = 'node' col_name = ['node_name', 'parent'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['world', None], ['north_america', 0], ['united_states', 1], ['canada', 1]] assert row_list == check_list # # data_table tbl_name = 'data' col_name = ['integrand_id', 'node_id', 'meas_value', 'meas_std'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [[0, 1, 1.0e-5, 1e-5], [0, 2, 1.5e-5, 1e-5], [0, 3, 0.5e-5, 1e-5]] assert row_list == check_list # # prior_table tbl_name = 'prior' col_name = ['prior_name', 'density_id', 'lower', 'upper'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['zero', 0, 0.0, 0.0], ['one', 0, 1.0, 1.0], ['uniform_01', 0, 0.0, 1.0], ['gaussian_01', 1, None, None], ['log_gaussian', 4, None, None]] assert row_list == check_list # # smooth_table tbl_name = 'smooth' col_name = [ 'smooth_name', 'n_age', 'n_time', 'mulstd_value_prior_id', 'mulstd_dage_prior_id', 'mulstd_dtime_prior_id' ] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['uniform_01_constant', 1, 1, None, None, None], ['gaussian_01_constant', 1, 1, None, None, None]] assert row_list == check_list # # smooth_grid_table tbl_name = 'smooth_grid' col_name = [ 'smooth_id', 'age_id', 'time_id', 'value_prior_id', 'dage_prior_id', 'dtime_prior_id' ] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [[0, 0, 0, 2, None, None], [1, 0, 0, 3, None, None]] assert row_list == check_list # # rate_table tbl_name = 'rate' col_name = ['rate_name', 'parent_smooth_id', 'child_smooth_id'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['pini', 0, 1], ['iota', 0, 1], ['rho', 0, 1], ['chi', 0, 1], ['omega', 0, 1]] assert row_list == check_list # # mulcov_table tbl_name = 'mulcov' col_name = [ 'mulcov_type', 'rate_id', 'integrand_id', 'covariate_id', 'group_id', 'subgroup_smooth_id', 'group_smooth_id' ] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['rate_value', 4, None, 0, 0, None, 0]] assert row_list == check_list # # option_table tbl_name = 'option' col_name = ['option_name', 'option_value'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [['parent_node_name', 'world'], ['ode_step_size', '10.0'], ['random_seed', '0'], ['rate_case', 'iota_pos_rho_pos'], ['tolerance', '1e-8'], ['max_num_iter', '100'], ['print_level', '0'], ['derivative_test', 'second-order']] assert row_list == check_list # # avgint_table tbl_name = 'avgint' col_name = ['integrand_id', 'node_id', 'age_lower', 'age_upper'] row_list = dismod_at.get_row_list(connection, tbl_name, col_name) check_list = [[0, 1, 0.0, 100.0], [0, 2, 0.0, 100.0], [0, 3, 0.0, 100.0]] assert row_list == check_list # ---------------------------------------------------------------------- connection.close() print('create_database: OK')
def example_db (file_name) : # ---------------------------------------------------------------------- # age table: age_list = [ 0.0, 5.0, 15.0, 35.0, 50.0, 75.0, 90.0, 100.0 ] # # time table: time_list = [ 1990.0, 2000.0, 2010.0, 2200.0 ] # # integrand table: integrand_table = [ { 'name':'prevalence', 'minimum_meas_cv':0.0 } ] # # node table: node_table = [ { 'name':'world', 'parent':'' } ] for i in range(n_children) : name = 'child_' + str(i + 1) node_table.append( { 'name':name, 'parent':'world' } ) # # weight table: weight_table = list() # # covariate table: covariate_table = [ {'name':'income', 'reference':0.5, 'max_difference':None} ] # # mulcov table: mulcov_table = [ { 'covariate': 'income', 'type': 'rate_value', 'effected': 'iota', 'group': 'world', 'smooth': 'smooth_mulcov' } ] # ---------------------------------------------------------------------- # data table: data_table = list() # density_list = [ "gaussian", "students", "log_gaussian", "log_students" ] # values that are the same for all data rows row = { 'meas_value': 1., # measurement is way off truth and not used 'eta': 1e-6, 'nu': 10, 'weight': '', 'hold_out': False, 'time_lower': 2000., 'time_upper': 2000., 'subgroup': 'world', } # values that change between rows: for data_id in range( n_data ) : density = density_list[ data_id % 4 ] row['density'] = density # # one percent coefficient of variation if density == 'gaussian' or density == 'students' : row['meas_std'] = iota_parent_true / 100. else : row['meas_std'] = row['meas_value'] / 100. fraction = data_id / float(n_data-1) age = age_list[0] + (age_list[-1] - age_list[0])*fraction row['age_lower'] = age row['age_upper'] = age row['node'] = 'child_' + str( (data_id % n_children) + 1 ) row['income'] = fraction row['integrand'] = integrand_table[0]['name'] data_table.append( copy.copy(row) ) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_zero 'name': 'prior_zero', 'density': 'uniform', 'lower': 0.0, 'upper': 0.0, 'mean': 0.0, 'std': None, 'eta': None }, { # prior_none 'name': 'prior_none', 'density': 'uniform', 'lower': None, 'upper': None, 'mean': 0.0, 'std': None, 'eta': None },{ # prior_gauss_zero 'name': 'prior_gauss_zero', 'density': 'gaussian', 'lower': None, 'upper': None, 'mean': 0.0, 'std': 0.01, 'eta': None },{ # prior_loggauss_zero 'name': 'prior_loggauss_zero', 'density': 'log_gaussian', 'lower': None, 'upper': None, 'mean': 0.0, 'std': 0.1, 'eta': 1e-6 },{ # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'uniform', 'lower': iota_parent_true / 100., 'upper': iota_parent_true * 10.0, 'mean': iota_parent_true / 2.0, 'std': None, 'eta': None },{ # prior_mulcov 'name': 'prior_mulcov', 'density': 'uniform', 'lower': -2.0, 'upper': +2.0, 'mean': 0.0, 'std': None, 'eta': None } ] # ---------------------------------------------------------------------- # smooth table name = 'smooth_rate_child' fun = fun_rate_child age_id = int( len( age_list ) / 2 ) time_id = int( len( time_list ) / 2 ) smooth_table = [ {'name':name, 'age_id':[age_id], 'time_id':[time_id], 'fun':fun } ] name = 'smooth_iota_parent' fun = fun_iota_parent smooth_table.append( {'name':name, 'age_id':[age_id], 'time_id':[time_id], 'fun':fun } ) name = 'smooth_mulcov' fun = fun_mulcov smooth_table.append( {'name':name, 'age_id':[age_id], 'time_id':[time_id], 'fun':fun } ) # no standard deviation multipliers for dictionary in smooth_table : for name in [ 'value' , 'dage', 'dtime' ] : key = 'mulstd_' + name + '_prior_name' value = None dictionary[key] = value # ---------------------------------------------------------------------- # rate table: rate_table = [ { 'name': 'iota', 'parent_smooth': 'smooth_iota_parent', 'child_smooth': 'smooth_rate_child', 'child_nslist': None }, ] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name':'rate_case', 'value':'iota_pos_rho_zero' }, { 'name':'parent_node_name', 'value':'world' }, { 'name':'ode_step_size', 'value':'10.0' }, { 'name':'random_seed', 'value':random_seed_str }, { 'name':'zero_sum_child_rate', 'value':'iota' }, { 'name':'quasi_fixed', 'value':'true' }, { 'name':'derivative_test_fixed', 'value':'none' }, { 'name':'max_num_iter_fixed', 'value':'100' }, { 'name':'print_level_fixed', 'value':'0' }, { 'name':'tolerance_fixed', 'value':'1e-6' }, { 'name':'derivative_test_random', 'value':'none' }, { 'name':'max_num_iter_random', 'value':'100' }, { 'name':'print_level_random', 'value':'0' }, { 'name':'tolerance_random', 'value':'1e-8' }, { 'name':'method_random', 'value':'ipopt_random' } ] # ---------------------------------------------------------------------- # avgint table: empty avgint_table = list() # ---------------------------------------------------------------------- # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [ { 'subgroup':'world', 'group':'world' } ] # ---------------------------------------------------------------------- # create database dismod_at.create_database( file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table ) # ---------------------------------------------------------------------- return
def example_db (file_name) : def fun_rate_parent(a, t) : return ('prior_iota_parent', None, None) import dismod_at # ---------------------------------------------------------------------- # age table age_list = [ 0.0, 50.0, 100.0 ] # # time table time_list = [ 1995.0, 2005.0, 2015.0 ] # # integrand table integrand_table = [ { 'name':'Sincidence' } ] # # node table: north_america -> (united_states, canada) node_table = [ { 'name':'north_america', 'parent':'' }, { 'name':'united_states', 'parent':'north_america' }, { 'name':'canada', 'parent':'north_america' } ] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # avgint table: same order as list of integrands avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: same order as list of integrands data_table = list() meas_std = meas_cv * iota_true row = { 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000.0, 'time_upper': 2000.0, 'age_lower': 50.0, 'age_upper': 50.0, 'integrand': 'Sincidence', 'meas_std': meas_std, 'nu': nu } random.seed(random_seed) for data_id in range( n_data ): row['node'] = 'north_america' meas_value = random.gauss(iota_true, meas_std) # if data_id < n_outlier : meas_value = random.gauss( 10.0 * iota_true, 2.0 * iota_true ) row['meas_value'] = meas_value data_table.append( copy.copy(row) ) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'uniform', 'lower': 1e-4, 'upper': 1.0, 'mean': 0.1, } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': [ 0 ], 'time_id': [ 0 ], 'fun': fun_rate_parent } ] # ---------------------------------------------------------------------- # rate table rate_table = [ { 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', } ] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name':'parent_node_name', 'value':'north_america' }, { 'name':'ode_step_size', 'value':'10.0' }, { 'name':'rate_case', 'value':'iota_pos_rho_zero' }, { 'name':'quasi_fixed', 'value':'false' }, { 'name':'max_num_iter_fixed', 'value':'100' }, { 'name':'print_level_fixed', 'value':'0' }, { 'name':'tolerance_fixed', 'value':'1e-11' }, ] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [ { 'subgroup':'world', 'group':'world' } ] # ---------------------------------------------------------------------- # create database dismod_at.create_database( file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table )
def get_started_db(): import dismod_at from math import exp # ---------------------------------------------------------------------- # age list age_list = [0.0, 100.0] # # time list time_list = [1995.0, 2015.0] # # only one integrand in this example integrand_table = [{'name': 'susceptible'}] # # just the world (which has no parent) node_table = [{'name': 'world', 'parent': ''}] # # weight table is represented by one (age, time) point with value 1.0 fun = constant_one_fun weight_table = [{ 'name': 'constant_one', 'age_id': [0], 'time_id': [0], 'fun': fun }] # # covariate table: the reference value for income is zero covariate_table = [{'name': 'income', 'reference': 0.0}] # --------------------------------------------------------------------- # avgint table: predict the susceptible fraction for no income at age 100 avgint_table = [{ 'avgint_info': 'a0', 'integrand': 'susceptible', 'node': 'world', 'subgroup': 'world', 'weight': 'constant_one', 'age_lower': 100.0, 'age_upper': 100.0, 'time_lower': 2000.0, 'time_upper': 2000.0, 'income': 0.0, }] # --------------------------------------------------------------------- # data table: measure the susceptible fraction for income 1000 at age 50 # (no noise in this simulated data, but modeled as having noise) adjusted_omega = unknown_omega_world * exp( known_income_multiplier * 1000.0) meas_value = exp(-adjusted_omega * 50.0) meas_std = meas_value / 20. data_table = [{ 'c_data_info': 'd1', 'integrand': 'susceptible', 'node': 'world', 'subgroup': 'world', 'weight': 'constant_one', 'age_lower': 50.0, 'age_upper': 50.0, 'time_lower': 2000.0, 'time_upper': 2000.0, 'income': 1000.0, 'density': 'gaussian', 'hold_out': False, 'meas_value': meas_value, 'meas_std': meas_std, }] # --------------------------------------------------------------------- # prior_table prior_table = [ { # prior_not_used # (not used because there are no age or time differences) 'name': 'prior_not_used', 'density': 'uniform', 'mean': 0.0, },{ # prior_omega_parent # omega for the parent is constant in (age, time) and # and is a uniform distribution on the interval [1e-4, 1.0]. # Becasue the prior is uniform, its mean 1e-1 is only used to # start the optimization 'name': 'prior_omega_parent', 'density': 'uniform', 'lower': 1e-4, 'upper': 1.0, 'mean': 1e-1, },{ # prior_income_multiplier # (constrained to be equal to know_income_multiplier) 'name': 'prior_income_multiplier', 'density': 'uniform', 'lower': known_income_multiplier, 'upper': known_income_multiplier, 'mean': known_income_multiplier, } ] # --------------------------------------------------------------------- # smooth table: smooth_table = [ { # smooth_omega_parent 'name': 'smooth_omega_parent', 'age_id': [0], 'time_id': [0], 'fun': fun_omega_parent }, { # smooth_income_multiplier 'name': 'smooth_income_multiplier', 'age_id': [0], 'time_id': [0], 'fun': fun_income_multiplier } ] # --------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'omega', 'parent_smooth': 'smooth_omega_parent', }] # ------------------------------------------------------------------- # mulcov table: there is one covariate multiplier for income and it # affects the other cause mortality rate: mulcov_table = [{ 'covariate': 'income', 'type': 'rate_value', 'effected': 'omega', 'group': 'world', 'smooth': 'smooth_income_multiplier' }] # ------------------------------------------------------------------- # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'age_avg_split', 'value': '5.0' }, { 'name': 'rate_case', 'value': 'iota_zero_rho_zero' }, { 'name': 'avgint_extra_columns', 'value': 'avgint_info' }, { 'name': 'data_extra_columns', 'value': 'c_data_info' }] # --------------------------------------------------------------------- # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database file_name = 'get_started.db' dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)
def example_db(file_name): def fun_chi(a, t): return ('prior_chi', 'prior_dchi', None) # ---------------------------------------------------------------------- # age table: age_list = [0.0, 100.0] # # time table: time_list = [1990.0, 2010.0] # # integrand table: integrand_table = [{'name': 'mtexcess'}] # # node table: node_table = [{'name': 'world', 'parent': ''}] # # weight table: weight_table = list() # # covariate table: empty covariate_table = list() # # mulcov table: empty mulcov_table = list() # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # # values that are the same for all data rows row = { 'meas_value': chi_bar, 'density': 'gaussian', 'weight': '', 'hold_out': False, 'age_lower': age_list[0], 'age_upper': age_list[0], 'time_lower': 2000., 'time_upper': 2000., 'integrand': 'mtexcess', 'meas_std': sigma, 'node': 'world' } data_table.append(row) # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_chi 'name': 'prior_chi', 'density': 'uniform', 'lower': 0.0, 'upper': 1.0, 'mean': 0.0 }, { # prior_dchi 'name': 'prior_dchi', 'density': 'gaussian', 'lower': None, 'upper': None, 'mean': 0.0, 'std': delta } ] # ---------------------------------------------------------------------- # smooth table name = 'smooth_chi' fun = fun_chi smooth_table = [{ 'name': name, 'age_id': [0, 1], 'time_id': [0], 'fun': fun }] # ---------------------------------------------------------------------- # rate table: rate_table = [{ 'name': 'chi', 'parent_smooth': 'smooth_chi', 'child_smooth': None }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'rate_case', 'value': 'iota_zero_rho_zero' }, { 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'random_seed', 'value': '0' }, { 'name': 'quasi_fixed', 'value': 'false' }, { 'name': 'derivative_test_fixed', 'value': 'second-order' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-8' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db(file_name): def fun_rate_parent(a, t): return ('prior_rate_parent', None, 'prior_gauss_zero') # ---------------------------------------------------------------------- # age table age_list = [0.0, 50.0, 100.0] # # time table time_list = [1995.0, 2005.0, 2015.0] # # integrand table integrand_table = [{ 'name': 'prevalence' }, { 'name': 'Sincidence' }, { 'name': 'remission' }, { 'name': 'mtexcess' }, { 'name': 'mtother' }] # # node table: world -> north_america # north_america -> (united_states, canada) node_table = [{ 'name': 'world', 'parent': '' }, { 'name': 'north_america', 'parent': 'world' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # avgint table: same order as list of integrands avgint_table = list() # values that are the same for all data rows row = { 'node': 'canada', 'subgroup': 'world', 'weight': '', 'time_lower': 2000.0, 'time_upper': 2000.0, 'age_lower': 0.0 } # values that change between rows: (one data point for each integrand) for avgint_id in range(len(integrand_table)): integrand = integrand_table[avgint_id]['name'] row['integrand'] = integrand if integrand == 'prevalence': # prevalence is measured at age zero row['age_upper'] = 0.0 else: # other integrands are averaged from age zero to one hundred row['age_upper'] = 100.0 avgint_table.append(copy.copy(row)) # ---------------------------------------------------------------------- # data table: same order as list of integrands data_table = list() # values that are the same for all data rows row = { 'node': 'canada', 'subgroup': 'world', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000.0, 'time_upper': 2000.0, 'age_lower': 0.0 } # values that change between rows: (one data point for each integrand) for integrand_id in range(len(integrand_table)): rate_id = integrand_id meas_value = 1e-2 * (rate_id + 1) meas_std = 0.2 * meas_value integrand = integrand_table[integrand_id]['name'] row['meas_value'] = meas_value row['meas_std'] = meas_std row['integrand'] = integrand if integrand == 'prevalence': # prevalence is measured at age zero row['age_upper'] = 0.0 else: # other integrands are averaged from age zero to one hundred row['age_upper'] = 100.0 # data_id = rate_id = integand_id data_table.append(copy.copy(row)) # # add one outlyer at end of data table with hold_out true row['hold_out'] = True # if outlyer were false, fit would fail row['integrand'] = data_table[0]['integrand'] row['meas_std'] = data_table[0]['meas_std'] row['eta'] = None row['age_upper'] = data_table[0]['age_upper'] row['meas_value'] = 10. * data_table[0]['meas_value'] data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_rate_parent 'name': 'prior_rate_parent', 'density': 'uniform', 'lower': 1e-4, 'upper': 1.0, 'mean': 1e-1, },{ # prior_gauss_zero 'name': 'prior_gauss_zero', 'density': 'gaussian', 'mean': 0.0, 'std': 1e-2, } ] # ---------------------------------------------------------------------- # smooth table middle_age_id = 1 last_time_id = 2 smooth_table = [{ # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': [middle_age_id], 'time_id': [0, last_time_id], 'fun': fun_rate_parent }] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'pini', 'parent_smooth': 'smooth_rate_parent', }, { 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', }, { 'name': 'rho', 'parent_smooth': 'smooth_rate_parent', }, { 'name': 'chi', 'parent_smooth': 'smooth_rate_parent', }, { 'name': 'omega', 'parent_smooth': 'smooth_rate_parent', }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'canada' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'random_seed', 'value': '0' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_pos' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'derivative_test_fixed', 'value': 'first-order' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-10' }, { 'name': 'derivative_test_random', 'value': 'second-order' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-10' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- n_smooth = len(smooth_table) rate_true = [] for rate_id in range(len(data_table)): # for this particular example data_id = rate_id meas_value = data_table[data_id]['meas_value'] rate_true.append(meas_value) # return (n_smooth, rate_true)
def example_db (file_name) : # ---------------------------------------------------------------------- # time table time_list = [ 1990.0, 2015.0 ] # # integrand table integrand_table = [ { 'name':'Sincidence', 'minimum_meas_cv':0.0 } ] # # node table: world node_table = [ { 'name':'world', 'parent':'' } ] # # weight table: The constant function 1.0 (one age and one time point) weight_table = [ { 'name':'weight_one', 'age_id':[1], 'time_id':[1], 'fun':fun_one } ] # # covariate table: covariate_table = list() # # mulcov table mulcov_table = list() # # ---------------------------------------------------------------------- # data table: order for value_list # 'integrand', 'density', 'node', 'weight', 'hold_out', # 'meas_value', 'meas_std', 'age_lower', 'age_upper', # 'time_lower', 'time_upper', 'sex', 'one', 'subgroup' data_table = list() # # Sincidence value_list = [ 'Sincidence', 'log_gaussian', 'world', 'weight_one', 0, 4.0e-3, 2.0e-3, 1e-6, 40, 40, 1995, 1995, 0.0, 1, 'world' ] data_table.append( data_list2dict( value_list ) ); # value_list = [ 'Sincidence', 'log_gaussian', 'world', 'weight_one', 0, 4.0e-2, 2.0e-2, 1e-6, 100, 100, 1995, 1995, 0.0, 1, 'world' ] data_table.append( data_list2dict( value_list ) ); # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_zero 'name': 'prior_zero', 'density': 'uniform', 'lower': 0.0, 'upper': 0.0, 'mean': 0.0, 'std': None, 'eta': None },{ # prior_rate 'name': 'prior_rate', 'density': 'log_gaussian', 'lower': 1e-5, 'upper': 1e+0, 'mean': 1e-2, 'std': 1e-0, 'eta': 1e-6 },{ # prior_difference 'name': 'prior_difference', 'density': 'log_gaussian', 'lower': None, 'upper': None, 'mean': 0.0, 'std': 1.0, 'eta': 1e-6 } ] # ---------------------------------------------------------------------- # smooth table middle_age_id = 1 last_time_id = 2 smooth_table = [ { # smooth_rate 'name': 'smooth_rate', 'age_id': range(len(age_list)), 'time_id': [0], 'mulstd_value_prior_name': None, 'mulstd_dage_prior_name': None, 'mulstd_dtime_prior_name': None, 'fun': fun_rate } ] # ---------------------------------------------------------------------- # rate table rate_table = [ { 'name': 'pini', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None },{ 'name': 'iota', 'parent_smooth': 'smooth_rate', 'child_smooth': None, 'child_nslist': None },{ 'name': 'rho', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None },{ 'name': 'chi', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None },{ 'name': 'omega', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None } ] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name':'parent_node_name', 'value':'world' }, { 'name':'rate_case', 'value':'iota_pos_rho_zero' }, # { 'name':'quasi_fixed', 'value':'false' }, { 'name':'derivative_test_fixed', 'value':'first-order' }, # { 'name':'derivative_test_random', 'value':'second-order' } ] # ---------------------------------------------------------------------- # avgint table: same order as list of integrands avgint_table = list() # ---------------------------------------------------------------------- # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [ { 'subgroup':'world', 'group':'world' } ] # ---------------------------------------------------------------------- # create database dismod_at.create_database( file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table ) return
def example_db(file_name): def fun_prevalence(a, t): return ('prior_prevalence', 'prior_dage', 'prior_dtime') def fun_mulcov(a, t): return ('prior_mulcov', None, None) # ---------------------------------------------------------------------- # age table: age_list = [0.0, 5.0, 10.0, 20.0, 40.0, 60.0, 80.0, 100.0] # # time table: time_list = [1990.0, 2200.0] # # integrand table: integrand_table = [{'name': 'remission'}] # # node table: node_table = [{'name': 'world', 'parent': ''}] # # weight table: weight_table = list() # # covariate table: covariate_table = [{'name': 'income', 'reference': income_reference}] # # mulcov table: if income_mulcov_type == 'rate_value': effected = 'rho' else: assert income_mulcov_type == 'meas_value' effected = 'remission' mulcov_table = [{ 'covariate': 'income', 'type': income_mulcov_type, 'effected': effected, 'group': 'world', 'smooth': 'smooth_mulcov' }] # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # # values that are the same for all data rows row = { 'node': 'world', 'subgroup': 'world', 'integrand': 'remission', 'density': 'log_gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000., 'time_upper': 2000., 'eta': prevalence_eta } n_data = 2000 n_income = 30 for data_id in range(n_data): age = 100.0 * data_id / float(n_data - 1) income = (data_id % n_income) / float(n_income - 1) income_effect = (income - income_reference) * income_multiplier eta = prevalence_eta sigma = prevalence_sigma log_noise = random.gauss(0, sigma) y = exp(log_noise) * Prevalence(age) * exp(income_effect) delta = (exp(sigma) - 1) * (y + eta) row['age_lower'] = age row['age_upper'] = age row['income'] = income row['meas_value'] = y row['meas_std'] = delta data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_prevalence 'name': 'prior_prevalence', 'density': 'uniform', 'lower': 0.0, 'upper': 1.0, 'mean': 0.01, },{ # prior_dage 'name': 'prior_dage', 'density': 'log_gaussian', 'mean': 0.0, 'std': 2.0, 'eta': prevalence_eta, },{ # prior_dtime 'name': 'prior_dtime', 'density': 'log_gaussian', 'mean': 0.0, 'std': 0.1, 'eta': prevalence_eta, }, { # prior_mulcov 'name': 'prior_mulcov', 'density': 'uniform', 'lower': -2.0, 'upper': +2.0, 'mean': 0.0, } ] # ---------------------------------------------------------------------- # smooth table smooth_table = list() # name = 'smooth_prevalence' fun = fun_prevalence age_id = range(len(age_list)) time_id = range(len(time_list)) smooth_table.append({ 'name': name, 'age_id': age_id, 'time_id': time_id, 'fun': fun }) name = 'smooth_mulcov' fun = fun_mulcov smooth_table.append({ 'name': name, 'age_id': [0], 'time_id': [0], 'fun': fun }) # ---------------------------------------------------------------------- # rate table: rate_table = [{ 'name': 'rho', 'parent_smooth': 'smooth_prevalence', 'child_smooth': None, }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'rate_case', 'value': 'no_ode' }, { 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'ode_step_size', 'value': '5.0' }, { 'name': 'random_seed', 'value': random_seed }, { 'name': 'quasi_fixed', 'value': 'false' }, { 'name': 'derivative_test_fixed', 'value': 'first-order' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-8' }, { 'name': 'derivative_test_random', 'value': 'second-order' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-8' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db(file_name): # note that the a, t values are not used for this case def fun_rate_child(a, t): return ('prior_gauss_zero', 'prior_gauss_zero', 'prior_gauss_zero') def fun_rate_parent(a, t): return ('prior_value_parent', 'prior_diff_parent', 'prior_diff_parent') # ---------------------------------------------------------------------- # age table age_list = [0.0, 50.0, 100.0] # # time table time_list = [1995.0, 2005.0, 2015.0] # # integrand table integrand_table = [{ 'name': 'Sincidence' }, { 'name': 'remission' }, { 'name': 'mtexcess' }, { 'name': 'mtother' }] # # node table: world -> north_america # north_america -> (united_states, canada) node_table = [{ 'name': 'world', 'parent': '' }, { 'name': 'north_america', 'parent': 'world' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: same order as list of integrands data_table = list() # values that are the same for all data rows row = { 'node': 'world', 'subgroup': 'world', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 1995.0, 'time_upper': 1995.0, 'age_lower': 0.0, 'age_upper': 0.0 } # values that change between rows: (one data point for each integrand) for integrand_id in range(len(integrand_table)): rate_id = integrand_id meas_value = 0.05 meas_std = 0.2 * meas_value integrand = integrand_table[integrand_id]['name'] row['meas_value'] = meas_value row['meas_std'] = meas_std row['integrand'] = integrand # data_id = rate_id = integand_id data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_gauss_zero 'name': 'prior_gauss_zero', 'density': 'gaussian', 'mean': 0.0, 'std': 0.01, },{ # prior_value_parent 'name': 'prior_value_parent', 'density': 'uniform', 'lower': 0.01, 'upper': 1.00, 'mean': 0.1, },{ # prior_diff_parent 'name': 'prior_diff_parent', 'density': 'gaussian', 'lower': 0.01, 'upper': 1.0, 'mean': 0.01, 'std': 0.01, } ] # ---------------------------------------------------------------------- # smooth table middle_age_id = 1 middle_time_id = 1 last_age_id = 2 last_time_id = 2 smooth_table = [ { # smooth_rate_child 'name': 'smooth_rate_child', 'age_id': [0, last_age_id], 'time_id': [0, last_time_id], 'fun': fun_rate_child }, { # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': [0, last_age_id], 'time_id': [0, last_time_id], 'fun': fun_rate_parent } ] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': 'smooth_rate_child', }, { 'name': 'rho', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': 'smooth_rate_child', }, { 'name': 'chi', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': 'smooth_rate_child', }, { 'name': 'omega', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': 'smooth_rate_child', }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'random_seed', 'value': '0' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_pos' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'derivative_test_fixed', 'value': 'first-order' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-10' }, { 'name': 'derivative_test_random', 'value': 'second-order' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-10' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)
def initDatabase(self, max_iter=500): if len(self.age_list) == 0: max_age = -float('inf') min_age = float('inf') for i in range(self.n): max_age = max(max_age, self.data.loc[i, 'age_end']) min_age = min(min_age, self.data.loc[i, 'age_start']) age_list = [int(round(x)) for x in np.linspace(min_age,max_age,\ round((max_age-min_age)/5)+1)] age_list = sorted(list(set(age_list))) #if len(age_list) == 1: # age_list.insert(0,age_list[0]-1) self.age_list = age_list if len(self.time_list) == 0: max_time = -float('inf') min_time = float('inf') for i in range(self.n): max_time = max(max_time, self.data.loc[i, 'year_end']) min_time = min(min_time, self.data.loc[i, 'year_start']) time_list = [int(round(x)) for x in np.linspace(min_time, max_time,\ round((max_time - min_time)/3+1))] time_list = sorted(list(set(time_list))) self.time_list = time_list #print(self.age_list) #print(self.time_list) avgint_table = list() nslist_table = dict() # smoothing integrand_table = [] for intg in self.integrand: integrand_table.append({'name': intg}) node_table = [{'name': 'world', 'parent': ''}] weight_table = [{ 'name': 'constant', 'age_id': range(len(self.age_list)), 'time_id': range(len(self.time_list)), 'fun': lambda a, t: 1.0 }] rate_table = list() for rate in self.rates: rate_table.append({ 'name': rate, 'parent_smooth': 'smooth_rate_' + rate }) covariate_table = list() for cov in self.covariates: covariate_table.append({'name': cov['name'], 'reference': 0.0}) mulcov_table = list() for cov in self.covariates: mulcov_table.append({ 'covariate': cov['name'], 'type': cov['type'], 'effected': cov['effected'], 'smooth': 'smooth_mulcov_' + cov['name'] }) smooth_table = list() for rate in self.rates: smooth_table.append({ 'name': 'smooth_rate_' + rate, 'age_id': range(len(self.age_list)), 'time_id': range(len(self.time_list)), 'fun': lambda a, t, r=rate: ('value_prior_' + r, 'dage_prior_' + r, 'dtime_prior_' + r) }) for cov in self.covariates: name = cov['name'] smooth_table.append({ 'name': 'smooth_mulcov_' + cov['name'], 'age_id': range(len(self.age_list)), 'time_id': range(len(self.time_list)), 'fun': lambda a, t, name=name: ('value_prior_' + name, 'dage_prior_' + name, 'dtime_prior_' + name) }) #for row in smooth_table: # print(row['fun'](0,0)) prior_table = [] for i in range(len(self.rates)): prior_table.append({'name': 'value_prior_' + self.rates[i]}) prior_table[-1].update(self.rate_priors[i][0]) prior_table.append({'name': 'dage_prior_' + self.rates[i]}) prior_table[-1].update(self.rate_priors[i][1]) prior_table.append({'name': 'dtime_prior_' + self.rates[i]}) prior_table[-1].update(self.rate_priors[i][2]) for i in range(len(self.covariates)): prior_table.append( {'name': 'value_prior_' + self.covariates[i]['name']}) prior_table[-1].update(self.cov_priors[i][0]) prior_table.append( {'name': 'dage_prior_' + self.covariates[i]['name']}) prior_table[-1].update(self.cov_priors[i][1]) prior_table.append( {'name': 'dtime_prior_' + self.covariates[i]['name']}) prior_table[-1].update(self.cov_priors[i][2]) data_table = list() row = { 'node': 'world', 'weight': 'constant', 'hold_out': False, } row.update(self.meas_noise_density) for data_id in range(self.n): if self.data.loc[data_id, 'measure'] in self.integrand: row['integrand'] = self.data.loc[data_id, 'measure'] for k, v in self.meas_noise_density[row['integrand']].items(): row[k] = v row['meas_value'] = self.data.loc[data_id, 'meas_value'] row['meas_std'] = self.data.loc[data_id, 'meas_std'] row['age_lower'] = self.data.loc[data_id, 'age_start'] row['age_upper'] = self.data.loc[data_id, 'age_end'] row['time_lower'] = self.data.loc[data_id, 'year_start'] row['time_upper'] = self.data.loc[data_id, 'year_end'] for cov in self.covariates: row[cov['name']] = self.data.loc[data_id, cov['name']] data_table.append(copy.copy(row)) option_table = [ { 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'quasi_fixed', 'value': 'false' }, { 'name': 'max_num_iter_fixed', 'value': max_iter }, { 'name': 'print_level_fixed', 'value': '5' }, { 'name': 'tolerance_fixed', 'value': '1e-8' }, ] if self.integrand == ['Sincidence']: option_table.append({ 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }) elif self.integrand == 'remission': option_table.append({ 'name': 'rate_case', 'value': 'iota_zero_rho_pos' }) else: option_table.append({ 'name': 'rate_case', 'value': 'iota_pos_rho_pos' }) option_name_id = {} for i in range(len(option_table)): option_name_id[option_table[i]['name']] = i for option in self.options: if option['name'] in option_name_id: option_table[option_name_id[ option['name']]]['value'] = option['value'] else: option_table.append(option) dismod_at.create_database(self.path, self.age_list, self.time_list, integrand_table, node_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) command = [program, self.path, 'init'] print(' '.join(command)) flag = subprocess.call(command) if flag != 0: sys.exit('The dismod_at init command failed') dismod_at.db2csv_command(self.path)
def example_db(file_name): # note that the a, t values are not used for this case def fun_iota(a, t): return ('prior_iota', None, None) def fun_gamma(a, t): return ('prior_gamma', None, None) # ---------------------------------------------------------------------- # age table: age_list = [0.0, 100.0] # # time table: time_list = [1990.0, 2010.0] # # integrand table: integrand_table = [{'name': 'Sincidence'}] # # node table: node_table = [{'name': 'world', 'parent': ''}] # # weight table: weight_table = list() # # covariate table: covariate_table = [{'name': 'one', 'reference': 0.0}] # # mulcov table: mulcov_table = [{ 'covariate': 'one', 'type': 'meas_noise', 'effected': 'Sincidence', 'group': 'world', 'smooth': 'smooth_gamma' }] # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # values that are the same for all data rows row = { 'weight': '', 'hold_out': False, 'node': 'world', 'subgroup': 'world', 'one': 1.0, 'age_lower': 50.0, 'age_upper': 50.0, 'time_lower': 2000., 'time_upper': 2000., 'integrand': 'Sincidence', 'density': data_density, 'meas_std': meas_std, 'eta': iota_true / 100.0, 'nu': 10 } # values that change between rows: for data_id in range(n_data): if data_id % 2 == 0: row['meas_value'] = 0.9 * iota_true else: row['meas_value'] = 1.1 * iota_true data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota 'name': 'prior_iota', 'density': 'uniform', 'lower': iota_true / 100.0, 'upper': 1.0, 'mean': iota_true / 10.0 }, { # prior_gamma 'name': 'prior_gamma', 'density': 'uniform', 'lower': 0.0, 'upper': 10.0 * gamma_true(), 'mean': gamma_true() / 10.0 } ] # ---------------------------------------------------------------------- # smooth table name = 'smooth_iota' fun = fun_iota age_id = 0 time_id = 0 smooth_table = [{ 'name': name, 'age_id': [age_id], 'time_id': [time_id], 'fun': fun }] name = 'smooth_iota' # name = 'smooth_gamma' fun = fun_gamma smooth_table.append({ 'name': name, 'age_id': [age_id], 'time_id': [time_id], 'fun': fun }) # ---------------------------------------------------------------------- # rate table: rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota', 'child_smooth': None }] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name': 'meas_noise_effect', 'value': meas_noise_effect }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'random_seed', 'value': '0' }, ] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db (file_name) : # note that the a, t values are not used for this case def fun_rate_child(a, t) : return ('prior_iota_child', None, None) def fun_iota_parent(a, t) : return ('prior_iota_parent', None, None) def fun_mulcov(a, t) : return ('prior_mulcov', None, None) # ---------------------------------------------------------------------- # age table: age_list = [ 0.0, 5.0, 15.0, 35.0, 50.0, 75.0, 90.0, 100.0 ] # # time table: time_list = [ 1990.0, 2000.0, 2010.0, 2200.0 ] # # integrand table: integrand_table = [ { 'name':'prevalence' } ] # # node table: node_table = [ { 'name':'world', 'parent':'' } ] for i in range(n_children) : name = 'child_' + str(i + 1) node_table.append( { 'name':name, 'parent':'world' } ) # # weight table: weight_table = list() # # covariate table: covariate_table = [ {'name':'income', 'reference':0.5} ] # # mulcov table: mulcov_table = [ { 'covariate': 'income', 'type': 'rate_value', 'effected': 'iota', 'group': 'world', 'smooth': 'smooth_mulcov' } ] # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # values that are the same for all data rows row = { 'meas_value': 0.0, # not used (will be simulated) 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000., 'time_upper': 2000. } # values that change between rows: for data_id in range( n_data ) : fraction = data_id / float(n_data-1) age = age_list[0] + (age_list[-1] - age_list[0])*fraction row['age_lower'] = age row['age_upper'] = age row['node'] = 'child_' + str( (data_id % n_children) + 1 ) row['income'] = fraction row['integrand'] = integrand_table[0]['name'] row['meas_std'] = 1e-3 data_table.append( copy.copy(row) ) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota_child 'name': 'prior_iota_child', 'density': 'gaussian', 'mean': 0.0, 'std': 0.5, },{ # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'uniform', 'lower': iota_parent_true / 100., 'upper': 1.0, 'mean': 0.1, },{ # prior_mulcov 'name': 'prior_mulcov', 'density': 'uniform', 'lower': -2.0, 'upper': +2.0, 'mean': 0.0, } ] # ---------------------------------------------------------------------- # smooth table name = 'smooth_rate_child' fun = fun_rate_child age_id = int( len( age_list ) / 2 ) time_id = int( len( time_list ) / 2 ) smooth_table = [ {'name':name, 'age_id':[age_id], 'time_id':[time_id], 'fun':fun } ] name = 'smooth_iota_parent' fun = fun_iota_parent smooth_table.append( {'name':name, 'age_id':[age_id], 'time_id':[time_id], 'fun':fun } ) name = 'smooth_mulcov' fun = fun_mulcov smooth_table.append( {'name':name, 'age_id':[age_id], 'time_id':[time_id], 'fun':fun } ) # no standard deviation multipliers for dictionary in smooth_table : for name in [ 'value' , 'dage', 'dtime' ] : key = 'mulstd_' + name + '_prior_name' value = None dictionary[key] = value # ---------------------------------------------------------------------- # rate table: rate_table = [ { 'name': 'iota', 'parent_smooth': 'smooth_iota_parent', 'child_smooth': 'smooth_rate_child', } ] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name':'rate_case', 'value':'iota_pos_rho_zero' }, { 'name':'parent_node_name', 'value':'world' }, { 'name':'ode_step_size', 'value':'10.0' }, { 'name':'random_seed', 'value':'0' }, { 'name':'zero_sum_child_rate', 'value':'iota' }, { 'name':'quasi_fixed', 'value':'true' }, { 'name':'derivative_test_fixed', 'value':'first-order' }, { 'name':'max_num_iter_fixed', 'value':'100' }, { 'name':'print_level_fixed', 'value':'0' }, { 'name':'tolerance_fixed', 'value':'1e-8' }, { 'name':'derivative_test_random', 'value':'second-order' }, { 'name':'max_num_iter_random', 'value':'100' }, { 'name':'print_level_random', 'value':'0' }, { 'name':'tolerance_random', 'value':'1e-8' } ] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [ { 'subgroup':'world', 'group':'world' } ] # ---------------------------------------------------------------------- # create database dismod_at.create_database( file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table ) # ---------------------------------------------------------------------- return
def example_db(file_name): def fun_income(a, t): return ('prior_income_value', 'prior_income_dage', 'prior_income_dtime') def fun_iota_parent(a, t): return ('prior_iota_parent', None, None) # ---------------------------------------------------------------------- # age table # # time table node_table = [ { 'name': 'north_america', 'parent': '' }, ] # # weight table: weight_table = list() # integrand table integrand_table = [{'name': 'Sincidence'}, {'name': 'mulcov_0'}] # # covariate table: covariate_table = [{'name': 'income', 'reference': income_reference}] # # mulcov table: one multiplier with mulcov_id = 0 mulcov_table = [{ 'covariate': 'income', 'type': 'rate_value', 'effected': 'iota', 'group': 'world', 'smooth': 'smooth_income' }] # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'uniform', 'lower': iota_reference, 'upper': iota_reference, 'mean': iota_reference, },{ # prior_income_value 'name': 'prior_income_value', 'density': 'uniform', 'mean': 0.0, 'lower': -1.0, 'upper': +1.0, },{ # prior_income_dage 'name': 'prior_income_dage', 'density': 'uniform', 'mean': 0.0, },{ # prior_income_dtime 'name': 'prior_income_dtime', 'density': 'uniform', 'mean': 0.0, } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_iota_parent 'name': 'smooth_iota_parent', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_parent }, { # smooth_income 'name': 'smooth_income', 'age_id': [0, 1], 'time_id': [0, 1], 'fun': fun_income } ] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota_parent', }] # -------------------------------------------------------------------- # option_table option_table = [ { 'name': 'parent_node_name', 'value': 'north_america' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'max_num_iter_fixed', 'value': '30' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-10' }, ] # ---------------------------------------------------------------------- # data table: data_table = list() row = { 'node': 'north_america', 'subgroup': 'world', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'integrand': 'Sincidence', 'income': 2.0, } for age in age_list: for time in time_list: alpha = alpha_true(age, time) effect = alpha * (row['income'] - income_reference) iota = iota_reference * math.exp(effect) row['age_lower'] = age row['age_upper'] = age row['time_lower'] = time row['time_upper'] = time row['meas_value'] = iota row['meas_std'] = iota / 10.0 data_table.append(copy.copy(row)) # ---------------------------------------------------------------------- # avgint table: avgint_table = list() # values that are the same for all rows does_not_matter = 5.0 row = { 'node': 'north_america', 'subgroup': 'world', 'integrand': 'mulcov_0', 'weight': '', 'income': does_not_matter, } for age in age_list: for time in time_list: row['age_lower'] = age row['age_upper'] = age row['time_lower'] = time row['time_upper'] = time avgint_table.append(copy.copy(row)) # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)
def example_db (file_name) : # note that the a, t values are not used for this case def fun_iota(a, t) : if (a, t) == (0, 2000) : return ('prior_value_0_2000', 'prior_diff', 'prior_diff') elif (a, t) == (100, 2000) : return ('prior_value_100_2000', 'prior_diff', 'prior_diff') elif (a, t) == (0, 2020) : return ('prior_value_0_2020', 'prior_diff', 'prior_diff') elif (a, t) == (100, 2020) : return ('prior_value_100_2020', 'prior_diff', 'prior_diff') else : assert False # ---------------------------------------------------------------------- # age table: age_list = [ 0.0, 100.0 ] # # time table: time_list = [ 2000.0, 2020.0 ] # # integrand table: integrand_table = [ { 'name': 'Sincidence' }, { 'name': 'prevalence' }, ] # # node table: node_table = [ { 'name':'world', 'parent':'' } ] # # weight table: weight_table = list() # # covariate table: covariate_table = list() # # mulcov table: mulcov_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # values that are the same for all data rows age_lower = 10.0 age_upper = 90.0 time_lower = 2000.0 time_upper = 2020.0 row = { 'weight': '', 'hold_out': False, 'node': 'world', 'subgroup': 'world', 'density': 'gaussian', 'meas_std': 0.01, 'age_lower': age_lower, 'age_upper' : age_upper, 'time_lower' : time_lower, 'time_upper' : time_upper, } # max_step = 1.0 age_grid = uniform_grid(age_lower, age_upper, max_step) time_grid = uniform_grid(time_lower, time_upper, max_step) grid = { 'age' : age_grid, 'time' : time_grid } # # Sincidence meas_value = average_integrand('Sincidence', grid) row['integrand'] = 'Sincidence' row['meas_value'] = meas_value data_table.append( copy.copy(row) ) # # prevalence meas_value = average_integrand('prevalence', grid) row['integrand'] = 'prevalence' row['meas_value'] = meas_value data_table.append( copy.copy(row) ) # # avgint table: avgint_table = data_table # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_value_0_2000 'name': 'prior_value_0_2000', 'density': 'uniform', 'lower': iota_true(0, 2000) / 100.0, 'upper': iota_true(0, 2000) * 100.0, 'mean': iota_true(0, 2000) },{ # prior_value_100_2000 'name': 'prior_value_100_2000', 'density': 'uniform', 'lower': iota_true(100, 2000) / 100.0, 'upper': iota_true(100, 2000) * 100.0, 'mean': iota_true(100, 2000) },{ # prior_value_0_2020 'name': 'prior_value_0_2020', 'density': 'uniform', 'lower': iota_true(0, 2020) / 100.0, 'upper': iota_true(0, 2020) * 100.0, 'mean': iota_true(0, 2020) },{ # prior_value_100_2020 'name': 'prior_value_100_2020', 'density': 'uniform', 'lower': iota_true(100, 2020) / 100.0, 'upper': iota_true(100, 2020) * 100.0, 'mean': iota_true(100, 2020) },{ # prior_diff 'name': 'prior_diff', 'density': 'uniform', 'mean': 0.0 } ] # ---------------------------------------------------------------------- # smooth table name = 'smooth_iota' fun = fun_iota age_id = [0, 1] time_id = [0, 1] smooth_table = [ {'name':name, 'age_id':age_id, 'time_id':time_id, 'fun':fun } ] name = 'smooth_iota' # ---------------------------------------------------------------------- # rate table: rate_table = [ { 'name': 'iota', 'parent_smooth': 'smooth_iota', 'child_smooth': None } ] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name':'rate_case', 'value':'iota_pos_rho_zero' }, { 'name':'parent_node_name', 'value':'world' }, { 'name':'ode_step_size', 'value':'1.0' }, ] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [ { 'subgroup':'world', 'group':'world' } ] # ---------------------------------------------------------------------- # create database dismod_at.create_database( file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table ) # ---------------------------------------------------------------------- return
def example_db(file_name): def fun_rate_world(a, t): return ('prior_rate_world', None, 'prior_world_diff') import dismod_at # ---------------------------------------------------------------------- # age table age_list = [0.0, 100.0] # # time table time_list = [1995.0, 2015.0] # # integrand table integrand_table = list() # # node table: node_table = [{'name': 'world', 'parent': ''}] # # weight table weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # avgint table: same order as list of integrands avgint_table = list() # # nslist_table: nslist_table = dict() # # data table: data_table = list() # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_rate_world 'name': 'prior_rate_world', 'density': 'gaussian', 'mean': omega_world_mean, 'std': omega_world_mean }, { # prior_world_diff 'name': 'prior_world_diff', 'density': 'gaussian', 'mean': 0.0, 'std': omega_world_mean } ] # ---------------------------------------------------------------------- # smooth table last_time_id = len(time_list) - 1 smooth_table = [{ # smooth_rate_world 'name': 'smooth_rate_world', 'age_id': [0], 'time_id': [0, last_time_id], 'fun': fun_rate_world }] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'omega', 'parent_smooth': 'smooth_rate_world', 'child_smooth': None, }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'rate_case', 'value': 'iota_zero_rho_zero' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'derivative_test_fixed', 'value': 'first-order' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-11' }, { 'name': 'derivative_test_random', 'value': 'second-order' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-11' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db (file_name) : def fun_rate_parent(a, t) : return ('prior_rate_parent', 'prior_none', 'prior_none') # ---------------------------------------------------------------------- # age table age_list = list( range(0, 101, 10) ) age_index = list( range(1, len(age_list) - 1, 1) ) # # time table time_list = list( range(1980, 2021, 10) ) time_index = list( range(1, len(time_list) - 1, 1) ) # # integrand table integrand_table = [ { 'name':'Sincidence' }, { 'name':'remission' }, { 'name':'mtexcess' }, ] # # node table: world -> north_america # north_america -> (united_states, canada) node_table = [ { 'name':'world', 'parent':'' }, { 'name':'north_america', 'parent':'world' }, { 'name':'united_states', 'parent':'north_america' }, { 'name':'canada', 'parent':'north_america' } ] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # nslist_table: nslist_table = dict() # # avgint table: avgint_table = list() # ---------------------------------------------------------------------- # data table: same order as list of integrands data_table = list() # values that are the same for all data rows row = { 'node': 'canada', 'subgroup': 'world', 'density': 'gaussian', 'weight': '', 'hold_out': False, } # values that change between rows: (one data point for each integrand) for integrand_id in range( len(integrand_table) ) : integrand_name = integrand_table[integrand_id]['name'] rate_name = integrand2rate[integrand_name] # for age_id in age_index : for time_id in time_index : age = age_list[age_id] time = time_list[time_id] true_value = rate_true(rate_name, age, time) meas_std = meas_cv * true_value row['age_lower'] = age row['age_upper'] = age row['time_lower'] = time row['time_upper'] = time row['integrand'] = integrand_name row['meas_value'] = true_value row['meas_std'] = true_value * 0.2 data_table.append( copy.copy(row) ) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_rate_parent 'name': 'prior_rate_parent', 'density': 'uniform', 'lower': 1e-4, 'upper': 1.0, 'mean': 0.1, },{ # prior_none 'name': 'prior_none', 'density': 'uniform', 'mean': 0.0, } ] # ---------------------------------------------------------------------- # smooth table last_time_id = len(time_list) - 1 smooth_table = [ { # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': age_index, 'time_id': time_index, 'fun': fun_rate_parent } ] # ---------------------------------------------------------------------- # rate table rate_table = [ { 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', },{ 'name': 'rho', 'parent_smooth': 'smooth_rate_parent', },{ 'name': 'chi', 'parent_smooth': 'smooth_rate_parent', } ] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name':'parent_node_name', 'value':'canada' }, { 'name':'random_seed', 'value':random_seed }, { 'name':'rate_case', 'value':'iota_pos_rho_pos' }, { 'name':'quasi_fixed', 'value':'false' }, { 'name':'derivative_test_fixed', 'value':'first-order' }, { 'name':'max_num_iter_fixed', 'value':'30' }, { 'name':'print_level_fixed', 'value':'5' }, { 'name':'tolerance_fixed', 'value':'1e-12' }, { 'name':'derivative_test_random', 'value':'second-order' }, { 'name':'max_num_iter_random', 'value':'100' }, { 'name':'print_level_random', 'value':'0' }, { 'name':'tolerance_random', 'value':'1e-12' } ] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [ { 'subgroup':'world', 'group':'world' } ] # ---------------------------------------------------------------------- # create database dismod_at.create_database( file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table ) # ---------------------------------------------------------------------- n_smooth = len( smooth_table )
def example_db(file_name): def fun_iota_parent(a, t): return ('prior_iota_parent', 'prior_gauss_zero', 'prior_gauss_zero') # ---------------------------------------------------------------------- # age_list age_list = [0.0, 100.0] # # time_list time_list = [1990.0, 2200.0] # # integrand table: integrand_table = [ { 'name': 'Sincidence' }, ] # # node table: node_table = [{'name': 'world', 'parent': ''}] # # weight table: weight_table = list() # # covariate table: covariate_table = list() # # mulcov table: mulcov_table = list() # ----------------------------------------------------------------------- # data table: data_table = list() # # values that are the same for all data rows row = { 'integrand': 'Sincidence', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'age_lower': 50.0, 'age_upper': 50.0, 'time_lower': 2000.0, 'time_upper': 2000.0, 'node': 'world', 'subgroup': 'world', } # N = 2, y_0 = iota_true - noise , y1 = iota_true + noise noise = 0.9 * iota_true Sincidence = [ iota_true - noise, iota_true + noise, ] for meas_value in Sincidence: row['meas_value'] = meas_value row['meas_std'] = meas_value # 100 % coefficient of variation data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_gauss_zero 'name': 'prior_gauss_zero', 'density': 'gaussian', 'mean': 0.0, 'std': 0.01, },{ # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'uniform', 'lower': 1e-19, 'upper': 1.0, 'mean': 1.01e-06, } ] # # smooth table name = 'smooth_iota_parent' fun = fun_iota_parent age_grid = [0] time_grid = [0] smooth_table = [{ 'name': name, 'age_id': age_grid, 'time_id': time_grid, 'fun': fun }] # # rate table: rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota_parent', 'child_smooth': None, }] # # option_table option_table = [ { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'quasi_fixed', 'value': 'false' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-9' }, { 'name': 'tolerance_random', 'value': '1e-10' }, ] # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- return
def example_db(file_name): def fun_rate_parent(a, t): return ('prior_rate_parent', 'prior_gauss_zero', None) # ---------------------------------------------------------------------- # age table age_list = [0.0, 50.0, 100.0] # # time table time_list = [1995.0, 2005.0, 2015.0] # # integrand table integrand_table = [{'name': 'Sincidence'}] # # node table: world -> north_america # north_america -> (united_states, canada) node_table = [{ 'name': 'world', 'parent': '' }, { 'name': 'north_america', 'parent': 'world' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # nslist_table: nslist_table = dict() # # avgint_table avgint_table = list() # ---------------------------------------------------------------------- # data table: same order as age_list data_table = list() # values that are the same for all data rows row = { 'node': 'canada', 'subgroup': 'world', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000.0, 'time_upper': 2000.0, 'integrand': 'Sincidence', 'age_lower': 0.0 } # values that change between rows: (one data point for each integrand) for age_id in range(len(age_list)): age = age_list[age_id] meas_value = 1e-4 * (50.0 + age) row['meas_value'] = meas_value row['meas_std'] = 1e-4 * (50.0 + age_list[0]) row['age_lower'] = age row['age_upper'] = age data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_rate_parent 'name': 'prior_rate_parent', 'density': 'uniform', 'lower': 1e-4, 'upper': 1.0, 'mean': 0.01, },{ # prior_gauss_zero 'name': 'prior_gauss_zero', 'density': 'gaussian', 'mean': 0.0, 'std': 1e-6, } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [{ # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': range(len(age_list)), 'time_id': [0], 'fun': fun_rate_parent }] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', }] # ---------------------------------------------------------------------- # option_table: max_num_iter_fixed will be set later option_table = [{ 'name': 'parent_node_name', 'value': 'canada' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'random_seed', 'value': '0' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'warn_on_stderr', 'value': 'false' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'derivative_test_fixed', 'value': 'first-order' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-12' }, { 'name': 'derivative_test_random', 'value': 'second-order' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-10' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) return
def example_db(file_name): import copy import dismod_at import math # ---------------------------------------------------------------------- # age table age_list = [0.0, 100.0] # # time table time_list = [1995.0, 2015.0] # # integrand table integrand_table = [{'name': 'Sincidence', 'minimum_meas_cv': 0.0}] # # node table: world -> north_america # north_america -> (united_states, canada) node_table = [{ 'name': 'world', 'parent': '' }, { 'name': 'north_america', 'parent': 'world' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # # weight table: The constant function 1.0 (one age and one time point) fun = constant_weight_fun weight_table = [{ 'name': 'constant', 'age_id': [0], 'time_id': [0], 'fun': fun }] # # covariate table: covariate_table = list() # # mulcov table mulcov_table = list() # ---------------------------------------------------------------------- # data table: data_table = list() # values that are the same for all data rows row = { 'density': 'gaussian', 'weight': 'constant', 'hold_out': False, 'time_lower': time_list[0], 'time_upper': time_list[-1], 'age_lower': age_list[0], 'age_upper': age_list[-1], 'meas_value': iota_true, 'meas_std': iota_true * 0.1, 'eta': None, 'integrand': 'Sincidence', 'subgroup': 'world', } # values that change between rows: for data_id in range(n_data): if data_id % 2 == 0: row['node'] = 'north_america' else: row['node'] = 'canada' data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_zero 'name': 'prior_zero', 'density': 'uniform', 'lower': 0.0, 'upper': 0.0, 'mean': 0.0, 'std': None, 'eta': None }, { # prior_none 'name': 'prior_none', 'density': 'uniform', 'lower': None, 'upper': None, 'mean': 0.0, 'std': None, 'eta': None }, { # prior_gauss_zero 'name': 'prior_gauss_zero', 'density': 'gaussian', 'lower': None, 'upper': None, 'mean': 0.0, 'std': 0.1, 'eta': None }, { # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'gaussian', 'lower': iota_lower, 'upper': iota_upper, 'mean': iota_initial, 'std': 0.1, 'eta': 1e-6 } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_rate_child 'name': 'smooth_rate_child', 'age_id': [0], 'time_id': [0], 'mulstd_value_prior_name': None, 'mulstd_dage_prior_name': None, 'mulstd_dtime_prior_name': None, 'fun': fun_rate_child }, { # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': [0], 'time_id': [0], 'mulstd_value_prior_name': None, 'mulstd_dage_prior_name': None, 'mulstd_dtime_prior_name': None, 'fun': fun_iota_parent }, { # smooth_zero 'name': 'smooth_zero', 'age_id': [0], 'time_id': [0], 'mulstd_value_prior_name': None, 'mulstd_dage_prior_name': None, 'mulstd_dtime_prior_name': None, 'fun': fun_zero } ] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'pini', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None }, { 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': 'smooth_rate_child', 'child_nslist': None }, { 'name': 'rho', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None }, { 'name': 'chi', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None }, { 'name': 'omega', 'parent_smooth': None, 'child_smooth': None, 'child_nslist': None }] # ---------------------------------------------------------------------- # option_table # use very large tolerance_fixed to avoid warning during test. option_table = [{ 'name': 'parent_node_name', 'value': 'north_america' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'max_num_iter_fixed', 'value': '0' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e+10' }, { 'name': 'bound_frac_fixed', 'value': str(bound_frac) }] # ---------------------------------------------------------------------- # avgint table: empty avgint_table = list() # ---------------------------------------------------------------------- # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table) # ---------------------------------------------------------------------- n_smooth = len(smooth_table) return
def example_db(file_name): def fun_iota_n1(a, t): return ('prior_iota_n1_value', None, None) def fun_iota_child(a, t): return ('prior_iota_child', None, None) def fun_iota_subgroup(a, t): return ('prior_iota_subgroup', None, None) # # node_table node_table = [ { 'name': 'n1', 'parent': '' }, { 'name': 'n11', 'parent': 'n1' }, { 'name': 'n12', 'parent': 'n1' }, { 'name': 'n111', 'parent': 'n11' }, { 'name': 'n112', 'parent': 'n11' }, { 'name': 'n121', 'parent': 'n12' }, { 'name': 'n122', 'parent': 'n12' }, ] # age_table age_list = [0.0, 100.0] # time_table time_list = [1990.0, 2020.0] # rate_table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota_n1', 'child_smooth': 'smooth_iota_child', }] # # subgroup_table subgroup_table = [ { 'subgroup': 'none', 'group': 'none' }, { 'subgroup': 'n111', 'group': 'n11' }, { 'subgroup': 'n112', 'group': 'n11' }, { 'subgroup': 'n121', 'group': 'n12' }, { 'subgroup': 'n122', 'group': 'n12' }, ] # covariate_table covariate_table = [{'name': 'one', 'reference': 0.0}] # mulcov_table mulcov_table = [{ 'covariate': 'one', 'type': 'rate_value', 'effected': 'iota', 'group': 'n11', 'smooth': None, 'subsmooth': 'smooth_iota_subgroup', }, { 'covariate': 'one', 'type': 'rate_value', 'effected': 'iota', 'group': 'n12', 'smooth': None, 'subsmooth': 'smooth_iota_subgroup', }] # prior_table prior_table = [ { # prior_iota_n1_value 'name': 'prior_iota_n1_value', 'density': 'uniform', 'lower': iota_n1(0) / 100.0, 'upper': iota_n1(100) * 100.0, 'mean': iota_n1(50) / 2.0, },{ # prior_iota_child 'name': 'prior_iota_child', 'density': 'uniform', 'mean': 0.0, },{ # prior_iota_subgroup 'name': 'prior_iota_subgroup', 'density': 'uniform', 'mean': 0.0, } ] # smooth_table smooth_table = [ { # smooth_iota_n1 'name': 'smooth_iota_n1', 'age_id': [0, 1], 'time_id': [0], 'fun': fun_iota_n1 }, { # smooth_iota_child 'name': 'smooth_iota_child', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_child }, { # smooth_iota_subgroup 'name': 'smooth_iota_subgroup', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_subgroup } ] # weight table: weight_table = list() # nslist_table nslist_table = dict() # option_table option_table = [ { 'name': 'parent_node_name', 'value': 'n1' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'zero_sum_child_rate', 'value': 'iota' }, { 'name': 'quasi_fixed', 'value': 'false' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-12' }, ] # integrand_table integrand_table = [{'name': 'Sincidence'}] # ------------------------------------------------------------------------ # data_table data_table = list() # values that are the same for all data points row = { 'integrand': 'Sincidence', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000.0, 'time_upper': 2000.0, 'one': 1.0, } random.seed(random_seed) for age_id in range(len(age_list)): age = age_list[age_id] for node in ['n1', 'n11', 'n12', 'n111', 'n112', 'n121', 'n122']: for i in range(data_per_node): iota = avg_integrand(age, node) meas_std = iota * meas_cv meas_value = random.gauss(iota, meas_std) if node in ['n1', 'n11', 'n12']: row['subgroup'] = 'none' else: row['subgroup'] = node row['node'] = node row['meas_value'] = meas_value row['meas_std'] = meas_std row['age_lower'] = age row['age_upper'] = age data_table.append(copy.copy(row)) # ------------------------------------------------------------------------ # avgint_table avgint_table = list() # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)
def example_db (file_name) : def constant_weight_fun(a, t) : return 1.0 def fun_iota_parent(a, t) : return ('prior_iota_parent', None, None) # ---------------------------------------------------------------------- # age table age_list = [ 0.0, 50.0, 100.0 ] # # time table time_list = [ 1995.0, 2005.0, 2015.0 ] # # integrand table integrand_table = [ { 'name':'Sincidence' } ] # # node table: world -> north_america # north_america -> (united_states, canada) node_table = [ { 'name':'world', 'parent':'' }, ] # # weight table: The constant function 1.0 (one age and one time point) fun = constant_weight_fun weight_table = [ { 'name':'constant', 'age_id':[1], 'time_id':[1], 'fun':fun } ] # # covariate table: covariate_table = list() # # mulcov table mulcov_table = list() # # avgint table: empty avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() # Values that are the same for all data rows # (because the simultion censors the data) meas_std = iota_true; eta = iota_true / 2.0 # large so get zeros for log scaled cases row = { 'node': 'world', 'subgroup': 'world', 'integrand': 'Sincidence', 'density': density_name, 'weight': 'constant', 'hold_out': False, 'age_lower': 0.0, 'age_upper': 0.0, 'time_lower': 1995.0, 'time_upper': 1995.0, 'eta': eta } sigma = meas_std mu = iota_true if density_name in [ 'cen_log_gaussian', 'cen_log_laplace' ] : sigma = math.log(iota_true + eta + meas_std) sigma -= math.log(iota_true + eta) mu = math.log(iota_true + eta ) scale = sigma / math.sqrt(2.0) for data_id in range( n_data ) : # simulate the data for distribution without censoring if density_name in [ 'cen_laplace', 'cen_log_laplace' ] : meas_value = numpy.random.laplace(mu, scale) else : meas_value = numpy.random.normal(mu, sigma) # check for log transform case if density_name in [ 'cen_log_gaussian', 'cen_log_laplace' ] : meas_value = math.exp(meas_value) - eta # censor the data; i.e., replace negative values by zero values. meas_value = max(meas_value, 0.0) row['meas_value'] = meas_value # delta = meas_std if density_name in [ 'cen_log_gaussian', 'cen_log_laplace' ] : # sigma = log(meas_value + eta + delta) - log(meas_value + eta) delta = (math.exp(sigma) - 1.0) * (meas_value + eta) row['meas_std'] = delta # data_table.append( copy.copy(row) ) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'uniform', 'lower': 0.001, 'upper': 1.00, 'mean': 0.1, } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_iota_parent 'name': 'smooth_iota_parent', 'age_id': [ 0 ], 'time_id': [ 0 ], 'fun': fun_iota_parent } ] # ---------------------------------------------------------------------- # rate table rate_table = [ { 'name': 'iota', 'parent_smooth': 'smooth_iota_parent', } ] # ---------------------------------------------------------------------- # option_table option_table = [ { 'name':'random_seed', 'value':str(random_seed) }, { 'name':'parent_node_name', 'value':'world' }, { 'name':'rate_case', 'value':'iota_pos_rho_zero' }, { 'name':'quasi_fixed', 'value':'false' }, { 'name':'max_num_iter_fixed', 'value':'100' }, { 'name':'print_level_fixed', 'value':'0' }, { 'name':'tolerance_fixed', 'value':'1e-13' }, ] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [ { 'subgroup':'world', 'group':'world' } ] # ---------------------------------------------------------------------- # create database dismod_at.create_database( file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table ) # ---------------------------------------------------------------------- return
def example_db(file_name): def fun_iota_child(a, t): return ('prior_iota_child', None, None) def fun_iota_parent(a, t): return ('prior_iota_parent', None, None) # ---------------------------------------------------------------------- # age table age_list = [0.0, 100.0] # # time table time_list = [1995.0, 2015.0] node_table = [{ 'name': 'north_america', 'parent': '' }, { 'name': 'united_states', 'parent': 'north_america' }, { 'name': 'canada', 'parent': 'north_america' }] # # weight table: weight_table = list() # integrand table integrand_table = [{'name': 'Sincidence'}, {'name': 'susceptible'}] # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_iota_parent 'name': 'prior_iota_parent', 'density': 'uniform', 'lower': iota_north_america / 100.0, 'upper': iota_north_america * 100.0, 'mean': iota_north_america * 3.0, },{ # prior_iota_child 'name': 'prior_iota_child', 'density': 'uniform', 'mean': 0.0, } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_iota_parent 'name': 'smooth_iota_parent', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_parent }, { # smooth_iota_child 'name': 'smooth_iota_child', 'age_id': [0], 'time_id': [0], 'fun': fun_iota_child } ] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_iota_parent', 'child_smooth': 'smooth_iota_child', }] # -------------------------------------------------------------------- # option_table option_table = [ { 'name': 'parent_node_name', 'value': 'north_america' }, { 'name': 'ode_step_size', 'value': '1.0' }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'max_num_iter_fixed', 'value': '30' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-10' }, ] # ---------------------------------------------------------------------- # data table: data_table = list() row = { 'density': 'log_gaussian', 'eta': '0.0', 'weight': '', 'hold_out': False, 'time_lower': 2000.0, 'time_upper': 2000.0, 'age_lower': 0.0, 'age_upper': 100.0, 'integrand': 'Sincidence', 'subgroup': 'world', } # north_america row['node'] = 'north_america' row['meas_value'] = iota_north_america row['meas_std'] = row['meas_value'] / 10.0 data_table.append(copy.copy(row)) # canada row['node'] = 'canada' row['meas_value'] = math.exp(canada_effect) * iota_north_america row['meas_std'] = row['meas_value'] / 10.0 data_table.append(copy.copy(row)) # united_states row['node'] = 'united_states' row['meas_value'] = math.exp(united_states_effect) * iota_north_america row['meas_std'] = row['meas_value'] / 10.0 data_table.append(copy.copy(row)) # ---------------------------------------------------------------------- # avgint table: avgint_table = list() # values that are the same for all data rows row = { 'integrand': 'susceptible', 'weight': '', 'time_lower': 2000.0, 'time_upper': 2000.0, 'age_lower': 50.0, 'age_upper': 50.0, 'subgroup': 'world' } row['node'] = 'north_america' avgint_table.append(copy.copy(row)) row['node'] = 'canada' avgint_table.append(copy.copy(row)) row['node'] = 'united_states' avgint_table.append(copy.copy(row)) # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)
def example_db(file_name): def fun_rate_child(a, t): return ('prior_gauss_zero', None, None) def fun_rate_parent(a, t): return ('prior_rate_parent', None, None) # ---------------------------------------------------------------------- # age table age_list = [0.0, 100.0] # # time table time_list = [1995.0, 2015.0] # # integrand table integrand_table = [{'name': 'Sincidence'}] # node_table = [ { 'name': 'world', 'parent': '' }, { 'name': 'child_0', 'parent': 'world' }, { 'name': 'child_1', 'parent': 'world' }, ] # # weight table: weight_table = list() # # covariate table: no covriates covariate_table = list() # # mulcov table mulcov_table = list() # # avgint table: avgint_table = list() # # nslist_table: nslist_table = dict() # ---------------------------------------------------------------------- # data table: data_table = list() row = { 'node': 'child_0', 'subgroup': 'world', 'density': 'gaussian', 'weight': '', 'hold_out': False, 'time_lower': 2000.0, 'time_upper': 2000.0, 'age_lower': 50.0, 'age_upper': 50.0, 'integrand': 'Sincidence', 'meas_value': y_0, 'meas_std': standard_dev, } data_table.append(copy.copy(row)) # row['node'] = 'child_1' row['meas_value'] = y_1 data_table.append(copy.copy(row)) # # ---------------------------------------------------------------------- # prior_table prior_table = [ { # prior_rate_parent 'name': 'prior_rate_parent', 'density': 'uniform', 'lower': 1e-2 * theta_true, 'upper': 1e+2 * theta_true, 'mean': theta_true / 3.0, # only used for start and scale },{ # prior_gauss_zero 'name': 'prior_gauss_zero', 'density': 'gaussian', 'mean': 0.0, 'std': standard_dev, } ] # ---------------------------------------------------------------------- # smooth table smooth_table = [ { # smooth_rate_parent 'name': 'smooth_rate_parent', 'age_id': [0], 'time_id': [0], 'fun': fun_rate_parent }, { # smooth_rate_child 'name': 'smooth_rate_child', 'age_id': [0], 'time_id': [0], 'fun': fun_rate_child } ] # ---------------------------------------------------------------------- # rate table rate_table = [{ 'name': 'iota', 'parent_smooth': 'smooth_rate_parent', 'child_smooth': 'smooth_rate_child', }] # ---------------------------------------------------------------------- # option_table option_table = [{ 'name': 'parent_node_name', 'value': 'world' }, { 'name': 'ode_step_size', 'value': '10.0' }, { 'name': 'random_seed', 'value': str(random_seed) }, { 'name': 'rate_case', 'value': 'iota_pos_rho_zero' }, { 'name': 'quasi_fixed', 'value': 'true' }, { 'name': 'derivative_test_fixed', 'value': 'none' }, { 'name': 'max_num_iter_fixed', 'value': '100' }, { 'name': 'print_level_fixed', 'value': '0' }, { 'name': 'tolerance_fixed', 'value': '1e-12' }, { 'name': 'derivative_test_random', 'value': 'none' }, { 'name': 'max_num_iter_random', 'value': '100' }, { 'name': 'print_level_random', 'value': '0' }, { 'name': 'tolerance_random', 'value': '1e-12' }] # ---------------------------------------------------------------------- # subgroup_table subgroup_table = [{'subgroup': 'world', 'group': 'world'}] # ---------------------------------------------------------------------- # create database dismod_at.create_database(file_name, age_list, time_list, integrand_table, node_table, subgroup_table, weight_table, covariate_table, avgint_table, data_table, prior_table, smooth_table, nslist_table, rate_table, mulcov_table, option_table)