def get_optimal_package_hook(self, *args, **kwargs): # Settings cplex_feasopt = kwargs.get("cplex_feasopt", False) cplex_conflict_refine = kwargs.get("cplex_conflict_refine", False) # They can't both be set to True assert cplex_feasopt is False or cplex_conflict_refine is False self.ilp_problem.cplex_feasopt_active = cplex_feasopt self.ilp_problem.cplex_conflict_refiner_active = cplex_conflict_refine if self.N == 0: # If there's no tuple in the base table, the only candidate is the empty package empty_package = SequenceBasedPackage(self, tuple()) if empty_package.is_valid(): return empty_package else: raise InfeasiblePackageQuery # Solve ILP problem verbose_log("Solving ILP problem...") self.current_run_info.problem_solving_start() optimal_package, cplex_runinfo = self.ilp_problem.get_optimal_package(**kwargs) self.current_run_info.problem_solving_end() verbose_log("ILP problem solved.") # Add running info about ILP solver to the specific running info assert isinstance(cplex_runinfo, CPLEXRunInfo) self.current_run_info.CPLEX_run_info = cplex_runinfo return optimal_package
def setup_problem_parameters(self): verbose_log("Setting CPLEX problem params") # Set time limit for solver timelimit_sec = self.search.get_remaining_time() if timelimit_sec is not None: self.problem.parameters.timelimit.set(timelimit_sec) # Set CPLEX parameters set_cplex_parameters(self.problem)
def init(self, query, store_lp_problems_dir=None, **kwargs): """ Ovverrides init_search of Search class to allow storing LP problems. """ super(ILPDirect, self).init(query, **kwargs) # Settings ilp_solver_interface = kwargs.get("ilp_solver_interface", ILPPackageProblemCplexPy) assert inspect.isclass(ilp_solver_interface) and issubclass(ilp_solver_interface, ILPPackageProblem) problem_type = kwargs.get("problem_type", "lp") self.ilp_problem = ilp_solver_interface( search=self, store_all_solved_problems=self.store_all_solved_problems) assert isinstance(self.ilp_problem, ILPPackageProblem) verbose_log("Loading ILP problem...") self.current_init_info.problem_loading_start() self.ilp_problem.load_ilp_from_paql(problem_type) self.current_init_info.problem_loading_end() verbose_log("ILP problem loaded.") # Store ILP to a file (if needed) if store_lp_problems_dir is not None: verbose_log("Saving ILP problem into folder '{}'...".format(store_lp_problems_dir)) self.current_init_info.storing_problem_start() self.ilp_problem.store_linear_problem_string(store_lp_problems_dir) self.current_init_info.storing_problem_end() verbose_log("ILP problem saved.")
def solve(self, feas_opt=False, conflict_refine=False): if self.store_all_solved_problems: self.store_linear_problem_string("/tmp") # Initialize running time counters cplex_waltime = -self.problem.get_time() cplex_dettime = -self.problem.get_dettime() wallclock_time = -time.time() cputicks_time = -time.clock() # Solve the problem with CPLEX if not feas_opt and not conflict_refine: # Just use the standard CPLEX solve() procedure verbose_log("Running CPLEX solve()...") self.problem.solve() # Solve with CPLEX Feasopt elif feas_opt: # Mode 0 (default): Minimize the sum of all required relaxations in first phase only # Mode 1: Minimize the sum of all required relaxations in first phase and execute second # phase to find optimum among minimal relaxations # Mode 2: Minimize the number of constraints and bounds requiring relaxation in first phase only # Mode 3: Minimize the number of constraints and bounds requiring relaxation in first phase and # execute second phase to find optimum among minimal relaxations # Mode 4: Minimize the sum of squares of required relaxations in first phase only # Mode 5: Minimize the sum of squares of required relaxations in first phase and execute second # phase to find optimum among minimal relaxations self.problem.parameters.feasopt.mode.set(0) verbose_log("Running CPLEX feasopt(...)...") self.problem.feasopt(self.problem.feasopt.linear_constraints()) # Solve after removing constraints with Conflict Refine elif conflict_refine: self.remove_conflicting_global_constraints() verbose_log("Running CPLEX solve()...") self.problem.solve() self.n_solver_solve_calls += 1 # Update running time counters cplex_waltime += self.problem.get_time() cplex_dettime += self.problem.get_dettime() wallclock_time += time.time() cputicks_time += time.clock() cplex_run_info = CPLEXRunInfo( cplex_problem_size=self.problem.variables.get_num(), cplex_n_problem_linear_constraints=self.problem.linear_constraints. get_num(), cplex_wallclock_time=cplex_waltime, cplex_detticks_time=cplex_dettime, sys_wallclock_time=wallclock_time, sys_cputicks_time=cputicks_time, wallclock_time_to_store=None, cputicks_time_to_store=None, cplex_feas_opt_used=feas_opt, cplex_conflict_refiner_used=self.conflicting_linear_constraints is not None, cplex_status=self.problem.solution.get_status()) return cplex_run_info
def compute_conflicting_linear_constraints(self): verbose_log("refining...") self.problem.conflict.refine( self.problem.conflict.linear_constraints()) verbose_log("done.") print "UGC's:" for i, ugc in enumerate(self.search.query.uncoalesced_gcs): print i, "GC:", str_u_gc(ugc) if self.problem.solution.get_status( ) == cplex.Cplex.solution.status.conflict_minimal: conflict_statuses = self.problem.conflict.get() verbose_log("CONFLICT STATUSES:", conflict_statuses) selected_group_ids = [ i for i in xrange(len(conflict_statuses)) if conflict_statuses[i] == self.problem.conflict.group_status. member or conflict_statuses[i] == self.problem.conflict.group_status.possible_member ] verbose_log("SELECTED GROUP IDS:", selected_group_ids) conflict_groups = self.problem.conflict.get_groups( selected_group_ids) verbose_log("CONFLICT GROUPS:", conflict_groups) self.conflicting_linear_constraints = list() print "INCONSISTENT GCs:" for preference, constrs in conflict_groups: # The preference for now is unused (it is possible to assign a weight to each constraint) assert preference == 1.0 for constr_type, constr_id in constrs: verbose_log("CONSTR ID:", constr_id) if constr_type == cplex.Cplex.conflict.constraint_type.linear: verbose_log( "LINEAR RHS:", self.problem.linear_constraints.get_rhs(constr_id)) ugc = self.search.query.uncoalesced_gcs[constr_id] print constr_id, str_u_gc(ugc) linear_constraint = filter( lambda x: x.cid == constr_id, self.linear_constraints)[0] self.conflicting_linear_constraints.append( linear_constraint) elif constr_type == cplex.Cplex.conflict.constraint_type.upper_bound: raise Exception else: raise Exception if len(self.conflicting_linear_constraints) == 0: raise Exception( "Problem was infeasible but didn't find any problematic linear constraint." ) verbose_log("minimial_infeasible_constrs:", self.conflicting_linear_constraints) else: raise Exception("Cplex status unsupported: {}".format( self.problem.solution.get_status()))