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()