def setup(): global args, config, simconfig parser = argparse.ArgumentParser() parser.add_argument( "--experiment", help= "provide name for experiment, to be used as prefix for database collections" ) parser.add_argument("--debug", help="turn on debugging output") parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost") parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017") parser.add_argument("--configuration", help="Path to configuration file") parser.add_argument("--model", choices=['axelrod', 'extensible', 'treestructured'], required=True) parser.add_argument( "--finalized", help="Only export runs which finalized after convergence", action="store_true") parser.add_argument("--filename", help="path to file for export", required=True) args = parser.parse_args() simconfig = utils.TreeStructuredConfiguration(args.configuration) if args.model == 'axelrod': simconfig = utils.AxelrodConfiguration(args.configuration) elif args.model == 'extensible': simconfig = utils.AxelrodExtensibleConfiguration(args.configuration) elif args.model == 'treestructured': simconfig = utils.TreeStructuredConfiguration(args.configuration) else: log.error("This shouldn't happen - args.model = %s", args.model) if args.debug == 1: log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') else: log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s') #### main program #### log.info("EXPORT DATA TO CSV - Experiment: %s", args.experiment) data.set_experiment_name(args.experiment) data.set_database_hostname(args.dbhost) data.set_database_port(args.dbport) config = data.getMingConfiguration(data.modules) ming.configure(**config)
def setup(): global args, simconfig parser = argparse.ArgumentParser() parser.add_argument("--experiment", help="provide name for experiment", required=True) parser.add_argument("--debug", help="turn on debugging output") parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost") parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017") parser.add_argument("--configuration", help="Configuration file for experiment", required=True) parser.add_argument("--filename", help="path to file for export", required=True) args = parser.parse_args() simconfig = utils.TreeStructuredConfiguration(args.configuration) if args.debug == '1': log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') else: log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s') log.debug("experiment name: %s", args.experiment) #### main program #### data.set_experiment_name(args.experiment) data.set_database_hostname(args.dbhost) data.set_database_port(args.dbport) config = data.getMingConfiguration(data.modules) ming.configure(**config)
def setUp(self): self.tf = tempfile.NamedTemporaryFile(dir="/tmp", delete=False) self.tf.write(""" { "REPLICATIONS_PER_PARAM_SET" : 5, "POPULATION_SIZES_STUDIED" : [500,1000], "NUMBER_OF_DIMENSIONS_OR_FEATURES" : [1,2,4,8,16], "NUMBER_OF_TRAITS_PER_DIMENSION" : [2,3,4,6,8,12,16,32] } """) self.tf.flush() self.sc = utils.TreeStructuredConfiguration(self.tf.name) self.sc.branching_factor = 4 self.sc.depth_factor = 4
def setup(): global args, simconfig parser = argparse.ArgumentParser() parser.add_argument("--experiment", help="provide name for experiment", required=True) parser.add_argument("--debug", help="turn on debugging output") parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost") parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017") parser.add_argument("--configuration", help="Configuration file for experiment", required=True) parser.add_argument("--parallelism", help="Number of concurrent processes to run", default="4") parser.add_argument("--savetraitgraphs", help="Saves a snapshot of trait tree graphs", action="store_true") parser.add_argument( "--samplinginterval", help= "Interval between samples, once sampling begins, defaults to 1M steps", default="1000000") parser.add_argument( "--samplingstarttime", help="Time at which sampling begins, defaults to 1M steps", default="6000000") parser.add_argument( "--simulationendtime", help= "Time at which simulation and sampling end, defaults to 10000000 steps", default="10000000") args = parser.parse_args() simconfig = utils.TreeStructuredConfiguration(args.configuration) if args.debug == '1': log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') else: log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s') log.debug("experiment name: %s", args.experiment)
def queue_simulations(queue, args): basic_config = utils.TreeStructuredConfiguration(args.configuration) if basic_config.INTERACTION_RULE_CLASS == 'madsenlab.axelrod.rules.MultipleTreePrerequisitesLearningCopyingRule': state_space = [ basic_config.POPULATION_SIZES_STUDIED, basic_config.TRAIT_LEARNING_RATE, basic_config.MAXIMUM_INITIAL_TRAITS, basic_config.NUM_TRAIT_TREES, basic_config.TREE_BRANCHING_FACTOR, basic_config.TREE_DEPTH_FACTOR, basic_config.TRAIT_LOSS_RATE, basic_config.INNOVATION_RATE, ] else: log.error( "This parallel sim runner not compatible with rule class: %s", basic_config.INTERACTION_RULE_CLASS) exit(1) if basic_config.NETWORK_FACTORY_CLASS == 'madsenlab.axelrod.population.WattsStrogatzSmallWorldFactory': state_space.append(basic_config.WS_REWIRING_FACTOR) for param_combination in itertools.product(*state_space): # for each parameter combination, make a copy of the base configuration # set the specific param combo values, and queue the object for repl in range(0, basic_config.REPLICATIONS_PER_PARAM_SET): #log.debug("param combination: %s", param_combination) sc = copy.deepcopy(basic_config) sc.popsize = int(param_combination[0]) sc.learning_rate = float(param_combination[1]) sc.maxtraits = int(param_combination[2]) sc.num_trees = int(param_combination[3]) sc.branching_factor = float(param_combination[4]) sc.depth_factor = float(param_combination[5]) sc.loss_rate = float(param_combination[6]) sc.innov_rate = float(param_combination[7]) if len(param_combination) == 9: sc.ws_rewiring = float(param_combination[8]) sc.maxtime = sc.SIMULATION_CUTOFF_TIME sc.sim_id = uuid.uuid4().urn sc.script = __file__ sc.periodic = 0 queue.put(sc) log.info("All simulation configurations queued")
def setup(): global args, config, simconfig parser = argparse.ArgumentParser() parser.add_argument( "--experiment", required=True, help= "provide name for experiment, to be used as prefix for database collections" ) parser.add_argument("--debug", help="turn on debugging output") parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost") parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017") parser.add_argument( "--dryrun", help= "Do the calculations but do not change the database (handiest with --debug 1 to see the results", action="store_true") parser.add_argument("--configuration", help="Configuration file for experiment", required=True) args = parser.parse_args() simconfig = utils.TreeStructuredConfiguration(args.configuration) if int(args.debug) == 1: log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') else: log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s') #### main program #### log.info("CALCULATING GRAPH SYMMETRY STATS - Experiment: %s", args.experiment) data.set_experiment_name(args.experiment) data.set_database_hostname(args.dbhost) data.set_database_port(args.dbport) config = data.getMingConfiguration(data.modules) ming.configure(**config)
def setup(): global args, simconfig parser = argparse.ArgumentParser() parser.add_argument("--debug", help="turn on debugging output") parser.add_argument("--configuration", help="Configuration file for experiment", required=True) args = parser.parse_args() simconfig = utils.TreeStructuredConfiguration(args.configuration) if args.debug == '1': log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') else: log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s')
def setUp(self): log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') self.tf = tempfile.NamedTemporaryFile(dir="/tmp", delete=False) self.tf.write(""" { "REPLICATIONS_PER_PARAM_SET" : 10, "POPULATION_SIZES_STUDIED" : [64,100], "TRAIT_ADDITION_RATE" : [0.01, 0.05, 0.1, 0.25], "MAXIMUM_INITIAL_TRAITS" : [4,8,16,32], "NUM_TRAIT_TREES" : [1,4,8,16], "TREE_BRANCHING_FACTOR" : [2,3,4,8], "TREE_DEPTH_FACTOR" : [4,5,6,8], "POPULATION_STRUCTURE_CLASS" : "madsenlab.axelrod.population.ExtensibleTraitStructurePopulation", "INTERACTION_RULE_CLASS" : "madsenlab.axelrod.rules.ExtensibleAxelrodRule", "NETWORK_FACTORY_CLASS" : "madsenlab.axelrod.population.SquareLatticeFactory", "TRAIT_FACTORY_CLASS" : "madsenlab.axelrod.traits.BalancedTreeStructuredTraitFactory" } """) self.tf.flush() self.config = utils.TreeStructuredConfiguration(self.tf.name)
def main(): structure_class_name = simconfig.POPULATION_STRUCTURE_CLASS log.info( "Configuring TreeStructured Axelrod model with structure class: %s", structure_class_name) log.debug("Will open %s output files given parallelism", args.parallelism) basic_config = utils.TreeStructuredConfiguration(args.configuration) if basic_config.INTERACTION_RULE_CLASS == 'madsenlab.axelrod.rules.MultipleTreePrerequisitesLearningCopyingRule': state_space = [ basic_config.POPULATION_SIZES_STUDIED, basic_config.TRAIT_LEARNING_RATE, basic_config.MAXIMUM_INITIAL_TRAITS, basic_config.NUM_TRAIT_TREES, basic_config.TREE_BRANCHING_FACTOR, basic_config.TREE_DEPTH_FACTOR, basic_config.TRAIT_LOSS_RATE, basic_config.INNOVATION_RATE, ] else: log.error( "This parallel sim runner not compatible with rule class: %s", basic_config.INTERACTION_RULE_CLASS) exit(1) if basic_config.NETWORK_FACTORY_CLASS == 'madsenlab.axelrod.population.WattsStrogatzSmallWorldFactory': state_space.append(basic_config.WS_REWIRING_FACTOR) num_runs = 0 for param_combination in itertools.product(*state_space): for replication in range(0, basic_config.REPLICATIONS_PER_PARAM_SET): num_runs += 1 log.info("Total number of runs: %s", num_runs)
else: log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s') ####### main loop ####### if __name__ == "__main__": setup() if args.model == 'axelrod': simconfig = utils.AxelrodConfiguration(args.configuration) elif args.model == 'extensible': simconfig = utils.AxelrodExtensibleConfiguration(args.configuration) elif args.model == 'treestructured': simconfig = utils.TreeStructuredConfiguration(args.configuration) else: log.error("This shouldn't happen - args.model = %s", args.model) if args.caption: caption = args.caption else: caption = None if args.format == 'pandoc': print simconfig.to_pandoc_table(args.experiment, caption=caption) elif args.format == 'latex': print simconfig.to_latex_table(args.experiment, caption=caption) else: print "Unrecognized format: %s" % args.format
def setup(): global args, simconfig parser = argparse.ArgumentParser() parser.add_argument("--experiment", help="provide name for experiment", required=True) parser.add_argument("--debug", help="turn on debugging output") parser.add_argument("--dbhost", help="database hostname, defaults to localhost", default="localhost") parser.add_argument("--dbport", help="database port, defaults to 27017", default="27017") parser.add_argument("--configuration", help="Configuration file for experiment", required=True) parser.add_argument("--popsize", help="Population size", required=True) parser.add_argument("--maxinittraits", help="Max initial number of traits per indiv", required=True) parser.add_argument( "--learningrate", help="Rate at which traits are learned during interactions", required=True) parser.add_argument( "--lossrate", help= "Rate at which traits are lost randomly by individuals (0.0 turns this off)", required=True) parser.add_argument("--innovrate", help="Rate at which innovations occur in population", required=True) parser.add_argument("--periodic", help="Periodic boundary condition", choices=['1', '0'], required=True) parser.add_argument("--diagram", help="Draw a diagram of the converged model", action="store_true") parser.add_argument( "--swrewiring", help="Rewiring probability for Watts-Strogatz population graph", required=False) parser.add_argument("--numtraittrees", help="Number of trait trees in the design space", required=True) parser.add_argument("--branchingfactor", help="Value or mean for tree branching factor", required=True) parser.add_argument("--depthfactor", help="Value or mean for tree depth factor", required=True) parser.add_argument("--savetraitgraphs", help="Saves a snapshot of trait tree graphs", action="store_true") parser.add_argument( "--samplinginterval", help= "Interval between samples, once sampling begins, defaults to 250K steps", default="250000") parser.add_argument( "--samplingstarttime", help="Time at which sampling begins, defaults to 1000000 steps", default="1000000") args = parser.parse_args() simconfig = utils.TreeStructuredConfiguration(args.configuration) if args.debug == '1': log.basicConfig(level=log.DEBUG, format='%(asctime)s %(levelname)s: %(message)s') else: log.basicConfig(level=log.INFO, format='%(asctime)s %(levelname)s: %(message)s') log.debug("experiment name: %s", args.experiment) data.set_experiment_name(args.experiment) data.set_database_hostname(args.dbhost) data.set_database_port(args.dbport) config = data.getMingConfiguration(data.modules) ming.configure(**config) if args.swrewiring: simconfig.ws_rewiring = float(args.swrewiring) simconfig.popsize = int(args.popsize) simconfig.maxtraits = int(args.maxinittraits) simconfig.learning_rate = float(args.learningrate) simconfig.num_trees = int(args.numtraittrees) simconfig.branching_factor = float(args.branchingfactor) simconfig.depth_factor = float(args.depthfactor) simconfig.loss_rate = float(args.lossrate) simconfig.innov_rate = float(args.innovrate) simconfig.maxtime = simconfig.SIMULATION_CUTOFF_TIME simconfig.script = __file__ simconfig.save_graphs = args.savetraitgraphs simconfig.sim_id = uuid.uuid4().urn if args.periodic == '1': simconfig.periodic = 1 else: simconfig.periodic = 0
def main(): fieldnames = data.axelrod_run_treestructured.columns_to_export_for_analysis() orig_fields = fieldnames[:] fieldnames.extend(["cultureid", "culture_count", "mean_radii", "sd_radii", "orbit_number", "autgroupsize", "remaining_density", "mean_degree", "sd_degree", "mean_orbit_multiplicity", "sd_orbit_multiplicity", "max_orbit_multiplicity","order", "msg_lambda", "msg_beta", "mem_beta"]) ofile = open(args.filename, "wb") writer = csv.DictWriter(ofile, fieldnames=fieldnames, quotechar='"', quoting=csv.QUOTE_ALL) headers = dict((n,n) for n in fieldnames) writer.writerow(headers) structure_class_name = simconfig.POPULATION_STRUCTURE_CLASS log.info("Configuring TreeStructured Axelrod model with structure class: %s", structure_class_name) basic_config = utils.TreeStructuredConfiguration(args.configuration) if basic_config.INTERACTION_RULE_CLASS == 'madsenlab.axelrod.rules.MultipleTreePrerequisitesLearningCopyingRule': state_space = [ basic_config.POPULATION_SIZES_STUDIED, basic_config.TRAIT_LEARNING_RATE, basic_config.MAXIMUM_INITIAL_TRAITS, basic_config.NUM_TRAIT_TREES, basic_config.TREE_BRANCHING_FACTOR, basic_config.TREE_DEPTH_FACTOR, basic_config.TRAIT_LOSS_RATE, basic_config.INNOVATION_RATE, ] else: log.error("This analytics calss not compatible with rule class: %s", basic_config.INTERACTION_RULE_CLASS) exit(1) if basic_config.NETWORK_FACTORY_CLASS == 'madsenlab.axelrod.population.WattsStrogatzSmallWorldFactory': state_space.append(basic_config.WS_REWIRING_FACTOR) num_samples = basic_config.REPLICATIONS_PER_PARAM_SET fieldnames = data.axelrod_run_treestructured.columns_to_export_for_analysis() orig_fields = fieldnames[:] fieldnames.extend(["cultureid", "culture_count", "mean_radii", "sd_radii", "orbit_number", "autgroupsize", "remaining_density", "mean_degree", "sd_degree", "mean_orbit_multiplicity", "sd_orbit_multiplicity", "max_orbit_multiplicity","order", "msg_lambda", "msg_beta", "mem_beta"]) ofile = open(args.filename, "wb") writer = csv.DictWriter(ofile, fieldnames=fieldnames, quotechar='"', quoting=csv.QUOTE_ALL) headers = dict((n,n) for n in fieldnames) writer.writerow(headers) # The basic idea here is that we run through all parameter combinations # and for each one, we: # # 1. Find all simulation_run_id's in the database with that parameter combination # 2. Sample n = REPLICATIONS_PER_PARAM_SET from the sim run id list # 3. For each of the sampled simulation run ID's: # 4. Get all records for that simulation run ID from the database # 5. Write those records to CSV # # The end result of this procedure should be a constant number of simulation run ID's per parameter set # This will not result in a constant number of ROWS, however, because a simulation run will have multiple # samples, and each of those samples may result in a different number of culture region solutions, each # of which will contribute a row to the result. for param_combination in itertools.product(*state_space): popsize = int(param_combination[0]) lrate = float(param_combination[1]) maxtraits = int(param_combination[2]) num_trees = int(param_combination[3]) branching_factor = float(param_combination[4]) depth_factor = float(param_combination[5]) loss_rate = float(param_combination[6]) innov_rate = float(param_combination[7]) # Find all simulation ID's with the combination of params... res = data.AxelrodStatsTreestructured.m.find(dict(population_size=popsize, learning_rate=lrate, max_init_traits=maxtraits, num_trait_trees=num_trees, branching_factor=branching_factor, depth_factor=depth_factor, loss_rate=loss_rate, innovation_rate=innov_rate), dict(simulation_run_id=1)).all() simruns = set([run.simulation_run_id for run in [x for x in res ]]) if len(simruns) < num_samples: sample_simruns = simruns log.info("pc only has %s rows: LR: %s NT: %s BF: %s DF: %s IR: %s", len(simruns), lrate, num_trees, branching_factor, depth_factor, innov_rate) else: sample_simruns = set(random.sample(simruns, num_samples)) log.debug("num ids for param combo: %s ", len(simruns)) id_count = 0 for simid in sample_simruns: id_count += 1 cursor = data.AxelrodStatsTreestructured.m.find(dict(simulation_run_id=simid)) for sample in cursor: row = dict() for field in sorted(orig_fields): row[field] = sample[field] # now pull apart the trait graph list - producing a row for each element of the trait graph list tg_stats = sample['trait_graph_stats'] for tg in tg_stats: #log.info("tg: %s", tg) row['cultureid'] = tg['cultureid'] row['culture_count'] = tg['culture_count'] row['mean_radii'] = tg['mean_radii'] row['sd_radii'] = tg['sd_radii'] row['mean_degree'] = tg['mean_degree'] row['sd_degree'] = tg['sd_degree'] row['orbit_number'] = tg['orbit_number'] row['autgroupsize'] = tg['autgroupsize'] row['remaining_density'] = tg['remaining_density'] row['mean_orbit_multiplicity'] = tg['mean_orbit_multiplicity'] row['sd_orbit_multiplicity'] = tg['sd_orbit_multiplicity'] row['max_orbit_multiplicity'] = tg['max_orbit_multiplicity'] row['order'] = tg['order'] row['msg_lambda'] = tg['msg_lambda'] row['msg_beta'] = tg['msg_beta'] row['mem_beta'] = tg['mem_beta'] #log.info("row: %s", row) writer.writerow(row) log.debug("sampled %s rows from param combo", id_count)
def test_latex_output(self): config = utils.TreeStructuredConfiguration(self.tf.name) table = config.to_latex_table("test") print table
def test_configuration(self): print "tempfile: %s" % self.tf.name config = utils.TreeStructuredConfiguration(self.tf.name) print "configured REPLICATIONS_PER_PARAM_SET: %s" % config.REPLICATIONS_PER_PARAM_SET self.assertEqual(10, config.REPLICATIONS_PER_PARAM_SET, "Config file value does not match")
def main(): structure_class_name = simconfig.POPULATION_STRUCTURE_CLASS log.info( "Configuring TreeStructured Axelrod model with structure class: %s", structure_class_name) log.debug("Opening %s output files given parallelism", args.parallelism) num_files = int(args.parallelism) file_list = [] base_name = "simrunner-exp-" base_name += args.experiment base_name += "-" for i in range(0, num_files): filename = '' filename += base_name filename += str(i) filename += ".sh" f = open(filename, 'w') f.write("#!/bin/sh\n\n") file_list.append(f) file_cycle = itertools.cycle(file_list) basic_config = utils.TreeStructuredConfiguration(args.configuration) if basic_config.INTERACTION_RULE_CLASS == 'madsenlab.axelrod.rules.MultipleTreePrerequisitesLearningCopyingRule': state_space = [ basic_config.POPULATION_SIZES_STUDIED, basic_config.TRAIT_LEARNING_RATE, basic_config.MAXIMUM_INITIAL_TRAITS, basic_config.NUM_TRAIT_TREES, basic_config.TREE_BRANCHING_FACTOR, basic_config.TREE_DEPTH_FACTOR, basic_config.TRAIT_LOSS_RATE, basic_config.INNOVATION_RATE, ] else: log.error( "This parallel sim runner not compatible with rule class: %s", basic_config.INTERACTION_RULE_CLASS) exit(1) if basic_config.NETWORK_FACTORY_CLASS == 'madsenlab.axelrod.population.WattsStrogatzSmallWorldFactory': state_space.append(basic_config.WS_REWIRING_FACTOR) for param_combination in itertools.product(*state_space): for replication in range(0, basic_config.REPLICATIONS_PER_PARAM_SET): cmd = "simulations/sim-treestructured-single.py " cmd += " --experiment " cmd += args.experiment cmd += " --configuration " cmd += args.configuration cmd += " --popsize " cmd += str(param_combination[0]) cmd += " --maxinittraits " cmd += str(param_combination[2]) cmd += " --learningrate " cmd += str(param_combination[1]) cmd += " --lossrate " cmd += str(param_combination[6]) cmd += " --innovrate " cmd += str(param_combination[7]) cmd += " --periodic 0 " cmd += " --numtraittrees " cmd += str(param_combination[3]) cmd += " --branchingfactor " cmd += str(param_combination[4]) cmd += " --depthfactor " cmd += str(param_combination[5]) cmd += " --debug " cmd += args.debug if len(param_combination) == 9: cmd += " --swrewiring " cmd += str(param_combination[8]) if args.savetraitgraphs: cmd += " --savetraitgraphs " cmd += " --samplingstarttime 5000000" cmd += " --samplinginterval 1000000" cmd += '\n' fc = file_cycle.next() fc.write(cmd) for fh in file_list: fh.close()