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)