def __init__(self,
reduced_solutions_input_pickle_name,
output_plot_file_name=None,
output_path=None,
output_filetype="png",
show_feasibility=True,
axis_tick_rarity=1,
execution_id_to_plot=0,
reduced_solutions_input_pickle_name_relative_to=None):
self.logger = util.get_logger(self.__class__.__name__,
make_file=False,
propagate=True,
print_level=logging.DEBUG)
self.reduced_scenario_solution_storage_list = []
pickle_names = [reduced_solutions_input_pickle_name]
if reduced_solutions_input_pickle_name_relative_to is not None:
pickle_names.append(
reduced_solutions_input_pickle_name_relative_to)
for pickle_name in pickle_names:
reduced_solutions_input_pickle_path = os.path.join(
util.ExperimentPathHandler.INPUT_DIR, pickle_name)
if output_plot_file_name is None:
self.full_output_filename = os.path.basename(reduced_solutions_input_pickle_path).split(".")[0] + \
"_plotted." + output_filetype
else:
self.full_output_filename = output_plot_file_name + "." + output_filetype
if output_path is None:
self.output_path = util.ExperimentPathHandler.OUTPUT_DIR
else:
self.output_path = output_path
self.logger.info(
"\nWill read from ..\n\t{} \n\t\tand save plot with name {} into\n\t{}\n"
.format(reduced_solutions_input_pickle_path,
self.full_output_filename, self.output_path))
self.logger.info("Reading pickle file at {}".format(
reduced_solutions_input_pickle_path))
with open(reduced_solutions_input_pickle_path, "rb") as input_file:
self.reduced_scenario_solution_storage_list.append(
pickle.load(input_file))
self.show_feasibility = show_feasibility
self.scenario_range = None
self.axis_tick_rarity = axis_tick_rarity
self.execution_id_to_plot = execution_id_to_plot
def __init__(self,
scenario,
gurobi_settings=None,
optimization_callback=mc.gurobi_callback,
lp_output_file=None,
potential_iis_filename=None,
logger=None,
vine_settings_list=None,
edge_embedding_model_list=None,
lp_objective_list=None,
rounding_procedure_list=None,
repetitions_for_randomized_experiments=1
):
self.gurobi_settings = gurobi_settings
self.optimization_callback = optimization_callback
self.lp_output_file = lp_output_file
self.potential_iis_filename = potential_iis_filename
if logger is None:
logger = util.get_logger(__name__, make_file=False, propagate=True)
if vine_settings_list is None:
if rounding_procedure_list is None or edge_embedding_model_list is None or lp_objective_list is None:
raise ValueError("Either vine_settings or all of the following must be specified: edge_embedding_model, objective, rounding_procedure")
self.vine_settings_list = self._construct_vine_settings_combinations(edge_embedding_model_list,
lp_objective_list,
rounding_procedure_list)
else:
self.vine_settings_list = []
for vine_settings in vine_settings_list:
ViNESettingsFactory.check_vine_settings(vine_settings)
self.vine_settings_list.append(ViNESettingsFactory.get_vine_settings_from_settings(vine_settings))
self.logger = logger
self.scenario = scenario
if repetitions_for_randomized_experiments <= 0:
raise ValueError("Repetitions must be larger than or equal to 1.")
self.repetitions_for_randomized_experiments = repetitions_for_randomized_experiments
self.result = None
def __init__(self,
substrate,
vine_settings,
gurobi_settings=None,
optimization_callback=mc.gurobi_callback,
lp_output_file=None,
potential_iis_filename=None,
logger=None):
self.gurobi_settings = gurobi_settings
self.optimization_callback = optimization_callback
self.lp_output_file = lp_output_file
self.potential_iis_filename = potential_iis_filename
if logger is None:
logger = util.get_logger(__name__, make_file=False, propagate=True)
self.logger = logger
self.original_substrate = substrate
self.residual_capacity_substrate = deepcopy(substrate)
ViNESettingsFactory.check_vine_settings(vine_settings)
self.vine_settings = vine_settings
self.edge_embedding_model = vine_settings.edge_embedding_model
self.lp_objective = vine_settings.lp_objective
self.rounding_procedure = vine_settings.rounding_procedure
self._extended_logging = False
if self.rounding_procedure == ViNERoundingProcedure.DETERMINISTIC:
self.node_mapper = DeterministicNodeMapper()
elif self.rounding_procedure == ViNERoundingProcedure.RANDOMIZED:
self.node_mapper = RandomizedNodeMapper()
else:
raise ValueError("Invalid node mapping method: {}".format(self.rounding_procedure))
if self.edge_embedding_model not in ViNEEdgeEmbeddingModel:
raise ValueError("Invalid edge mapping method: {}".format(self.edge_embedding_model))
self._current_request = None
self._provisional_node_allocations = None
self._provisional_edge_allocations = None
def __init__(self,
scenario,
gurobi_settings=None,
optimization_callback=mc.gurobi_callback,
lp_output_file=None,
potential_iis_filename=None,
logger=None,
vine_settings=None,
edge_embedding_model=None,
lp_objective=None,
rounding_procedure=None
):
self.gurobi_settings = gurobi_settings
self.optimization_callback = optimization_callback
self.lp_output_file = lp_output_file
self.potential_iis_filename = potential_iis_filename
if logger is None:
logger = util.get_logger(__name__, make_file=False, propagate=True)
if vine_settings is None:
if rounding_procedure is None or edge_embedding_model is None or lp_objective is None:
raise ValueError("Either vine_settings or all of the following must be specified: edge_embedding_model, objective, rounding_procedure")
if isinstance(edge_embedding_model, str):
edge_embedding_model= ViNEEdgeEmbeddingModel(edge_embedding_model)
if isinstance(lp_objective, str):
lp_objective = ViNELPObjective(lp_objective)
if isinstance(rounding_procedure, str):
rounding_procedure = ViNERoundingProcedure(rounding_procedure)
self.vine_settings = ViNESettingsFactory.get_vine_settings(edge_embedding_model, lp_objective, rounding_procedure)
else:
ViNESettingsFactory.check_vine_settings(vine_settings)
self.vine_settings = vine_settings
self.logger = logger
self.scenario = scenario
except ImportError:
import pickle
REQUIRED_FOR_PICKLE = solutions # this prevents pycharm from removing this import, which is required for unpickling solutions
BOX_WIDTH = 0.5
BOX_SEPARATION_WITHIN_GROUP = 0.6
BOX_SEPARATION_BETWEEN_GROUPS = 0.3
PLOT_TITLE_FONTSIZE = 18
AXIS_LABEL_FONTSIZE = 16
LEGEND_TITLE_FONTSIZE = 16
LEGEND_LABEL_FONTSIZE = 15
AXIS_TICKLABEL_FONTSIZE = 14.8
logger = util.get_logger(__name__, make_file=False, propagate=True)
def get_list_of_vine_settings():
result = []
for (edge_embedding_model, lp_objective,
rounding_procedure) in itertools.product(
vine.ViNEEdgeEmbeddingModel,
vine.ViNELPObjective,
vine.ViNERoundingProcedure,
):
if lp_objective == vine.ViNELPObjective.ViNE_LB_INCL_SCENARIO_COSTS or lp_objective == vine.ViNELPObjective.ViNE_COSTS_INCL_SCENARIO_COSTS:
continue
result.append(
vine.ViNESettingsFactory.get_vine_settings(
edge_embedding_model=edge_embedding_model,
def execute_single_experiment(process_index, num_processes, parameter_space,
random_seed, repetitions, out_file, timeout,
store_graphs_of_treewidth,
store_only_connected_graphs):
''' Main function for computing the treewidths of random graphs. This function is called in its own process (see above).
Each process generates and stores only the results lying in its range.
'''
random.seed(random_seed)
num_nodes_list = parameter_space["number_of_nodes"]
connection_probabilities_list = parameter_space["probability"]
graph_generator = SimpleRandomGraphGenerator()
logger = util.get_logger("worker_{}_pid_{}".format(process_index,
os.getpid()),
propagate=False,
make_file=True)
for repetition_index, params in enumerate(
itertools.product(num_nodes_list, connection_probabilities_list,
list(range(repetitions)))):
if repetition_index % num_processes == process_index:
num_nodes, prob, repetition_index = params
logger.info(
"Processing graph with {} nodes and {} prob, rep {} (timeout for computation: {})"
.format(num_nodes, prob, repetition_index, timeout))
gen_time_start = time.time()
graph = graph_generator.generate_graph(num_nodes, prob)
gen_time = time.time() - gen_time_start
algorithm_time_start = time.time()
tree_decomp = twm.compute_tree_decomposition(graph,
logger=logger,
timeout=timeout)
algorithm_time = time.time() - algorithm_time_start
treewidth = None
if tree_decomp is not None:
assert tree_decomp.is_tree_decomposition(graph)
treewidth = tree_decomp.width
graph_edge_representation = None
if treewidth is not None and treewidth in store_graphs_of_treewidth:
#generally interesting graph: compute edge_representation
graph_edge_representation = graph.get_edge_representation()
if store_only_connected_graphs:
#if we are only interested in connected graphs, then we only store the representation if it is connected
if not datamodel.is_connected_undirected_edge_representation(
graph_edge_representation):
graph_edge_representation = None
if graph_edge_representation is not None:
logger.debug(
"Storing graph of treewidth {} and number of nodes {}.".
format(treewidth, num_nodes))
result = TreeDecompositionAlgorithmResult(
num_nodes=num_nodes,
edge_probability=prob,
repetition_index=repetition_index,
undirected_graph_edge_representation=graph_edge_representation,
treewidth=treewidth,
runtime_treewidth_computation=algorithm_time,
)
logger.info("Result: {}".format(result.short_representation()))
with open(out_file, "ab") as f:
pickle.dump(result, f)
del graph
if tree_decomp is not None:
del tree_decomp
if graph_edge_representation is not None:
del graph_edge_representation
def __init__(self):
self.logger = util.get_logger(self.__class__.__name__,
make_file=False,
propagate=True)
