environments.py

import os
import io
import sys
import ipdb
import numpy as np
import pandas as pd
import pyscipopt as scip

from logger import logger
from contextlib import redirect_stdout

SEPA_LIST = [  # 缺gomorymi, knapsackcover
            'closecuts',
            'disjunctive',
            'minor',
            'mixing',
            'rlt',
            'interminor',
            # '#SM',
            # '#CS',
            'convexproj',
            'gauge',
            'impliedbounds',
            'intobj',
            'gomory',
            'cgmip',
            'strongcg',
            'aggregation',
            'clique',
            'zerohalf',
            'mcf',
            'eccuts',
            'oddcycle',
            'flowcover',
            'cmir',
            'rapidlearning'
        ]


class SCIPSepaSelEnv():
    def __init__(
        self,
        instance_file_path,
        scip_seed,
        seed,
        scip_time_limit=3600,
        single_instance_file=None,
        **init_scip_kwargs
    ):
        self.instance_file_path = instance_file_path
        self.instances = os.listdir(instance_file_path)
        self.single_instance_file = single_instance_file
        self.scip_seed = scip_seed
        self.seed = seed
        self.scip_time_limit = scip_time_limit
        self.init_scip_kwargs = init_scip_kwargs
        self.sepa_list = SEPA_LIST

        # self.reset()
        self.set_seed()

    def _set_scip_separator_params(self, max_rounds_root=-1, max_rounds=-1, max_cuts_root=10000, max_cuts=10000,
                                frequency=10):
        """
        Function for setting the separator params in SCIP. It goes through all separators, enables them at all points
        in the solving process,
        Args:
            scip: The SCIP Model object
            max_rounds_root: The max number of separation rounds that can be performed at the root node
            max_rounds: The max number of separation rounds that can be performed at any non-root node
            max_cuts_root: The max number of cuts that can be added per round in the root node
            max_cuts: The max number of cuts that can be added per node at any non-root node
            frequency: The separators will be called each time the tree hits a new multiple of this depth
        Returns:
            The SCIP Model with all the appropriate parameters now set
        """

        assert type(max_cuts) == int and type(max_rounds) == int
        assert type(max_cuts_root) == int and type(max_rounds_root) == int

        model = self.m

        # First for the aggregation heuristic separator
        model.setParam('separating/aggregation/freq', frequency)
        model.setParam('separating/aggregation/maxrounds', max_rounds)
        model.setParam('separating/aggregation/maxroundsroot', max_rounds_root)
        model.setParam('separating/aggregation/maxsepacuts', max_cuts)
        model.setParam('separating/aggregation/maxsepacutsroot', max_cuts_root)

        # Now the Chvatal-Gomory w/ MIP separator
        model.setParam('separating/cgmip/freq', frequency)
        model.setParam('separating/cgmip/maxrounds', max_rounds)
        model.setParam('separating/cgmip/maxroundsroot', max_rounds_root)

        # The clique separator
        model.setParam('separating/clique/freq', 10)
        model.setParam('separating/clique/maxsepacuts', max_cuts)

        # The close-cuts separator
        model.setParam('separating/closecuts/freq', 10)

        # The CMIR separator
        model.setParam('separating/cmir/freq', frequency)

        # The Convex Projection separator
        model.setParam('separating/convexproj/freq', frequency)
        model.setParam('separating/convexproj/maxdepth', -1)

        # The disjunctive cut separator
        model.setParam('separating/disjunctive/freq', frequency)
        model.setParam('separating/disjunctive/maxrounds', max_rounds)
        model.setParam('separating/disjunctive/maxroundsroot', max_rounds_root)
        model.setParam('separating/disjunctive/maxinvcuts', max_cuts)
        model.setParam('separating/disjunctive/maxinvcutsroot', max_cuts_root)
        model.setParam('separating/disjunctive/maxdepth', -1)

        # The separator for edge-concave function
        model.setParam('separating/eccuts/freq', frequency)
        model.setParam('separating/eccuts/maxrounds', max_rounds)
        model.setParam('separating/eccuts/maxroundsroot', max_rounds_root)
        model.setParam('separating/eccuts/maxsepacuts', max_cuts)
        model.setParam('separating/eccuts/maxsepacutsroot', max_cuts_root)
        model.setParam('separating/eccuts/maxdepth', -1)

        # The flow cover cut separator
        model.setParam('separating/flowcover/freq', frequency)

        # The gauge separator
        model.setParam('separating/gauge/freq', frequency)

        # Gomory MIR cuts
        model.setParam('separating/gomory/freq', 10)
        model.setParam('separating/gomory/maxrounds', max_rounds)
        model.setParam('separating/gomory/maxroundsroot', max_rounds_root)
        model.setParam('separating/gomory/maxsepacuts', max_cuts)
        model.setParam('separating/gomory/maxsepacutsroot', max_cuts_root)

        # The implied bounds separator
        model.setParam('separating/impliedbounds/freq', frequency)

        # The integer objective value separator
        model.setParam('separating/intobj/freq', 10)

        # The knapsack cover separator
        model.setParam('separating/knapsackcover/freq', frequency)

        # The multi-commodity-flow network cut separator
        model.setParam('separating/mcf/freq', frequency)
        model.setParam('separating/mcf/maxsepacuts', max_cuts)
        model.setParam('separating/mcf/maxsepacutsroot', max_cuts_root)

        # The odd cycle separator
        model.setParam('separating/oddcycle/freq', 10)
        model.setParam('separating/oddcycle/maxrounds', max_rounds)
        model.setParam('separating/oddcycle/maxroundsroot', max_rounds_root)
        model.setParam('separating/oddcycle/maxsepacuts', max_cuts)
        model.setParam('separating/oddcycle/maxsepacutsroot', max_cuts_root)

        # The rapid learning separator
        model.setParam('separating/rapidlearning/freq', frequency)

        # The strong CG separator
        # model.setParam('separating/strongcg/freq', frequency)
        # model.setParam('separating/strongcg/maxrounds', max_rounds)
        # model.setParam('separating/strongcg/maxroundsroot', max_rounds_root)
        # model.setParam('separating/strongcg/maxsepacuts', max_cuts)
        # model.setParam('separating/strongcg/maxsepacutsroot', max_cuts_root)

        # The zero-half separator
        model.setParam('separating/zerohalf/freq', 10)
        model.setParam('separating/zerohalf/maxcutcands', max(max_cuts, max_cuts_root))
        model.setParam('separating/zerohalf/maxrounds', max_rounds)
        model.setParam('separating/zerohalf/maxroundsroot', max_rounds_root)
        model.setParam('separating/zerohalf/maxsepacuts', max_cuts)
        model.setParam('separating/zerohalf/maxsepacutsroot', max_cuts_root)

        # The mixing separator
        model.setParam('separating/mixing/freq', frequency)

        # The minor separator
        model.setParam('separating/minor/freq', frequency)

        # The rlt separator
        model.setParam('separating/rlt/freq', frequency)

        # The interminor separator
        model.setParam('separating/interminor/freq', frequency)

        # Now the general cut and round parameters
        model.setParam("separating/maxroundsroot", max_rounds_root)
        model.setParam("separating/maxstallroundsroot", max_rounds_root)
        model.setParam("separating/maxcutsroot", max_cuts_root)

        model.setParam("separating/maxrounds", max_rounds)
        model.setParam("separating/maxstallrounds", 1)
        model.setParam("separating/maxcuts", max_cuts)

    def _init_scip_params(self, **init_scip_kwargs):
        seed = self.scip_seed % 2147483648  # SCIP seed range

        # set up randomization
        self.m.setBoolParam('randomization/permutevars', True)
        self.m.setIntParam('randomization/permutationseed', seed)
        self.m.setIntParam('randomization/randomseedshift', seed)

        # separators
        self._set_scip_separator_params(init_scip_kwargs['max_rounds_root'], init_scip_kwargs['max_rounds'], 10000, 100, 10)

        # separation only at root node
        # self.m.setIntParam('separating/maxrounds', 0)
        self.m.setIntParam('separating/maxrounds', init_scip_kwargs['max_rounds'])

        # no restart
        self.m.setIntParam('presolving/maxrestarts', 0)


        # if asked, disable presolving
        if not init_scip_kwargs['presolving']:
            self.m.setIntParam('presolving/maxrounds', 0)
            self.m.setIntParam('presolving/maxrestarts', 0)

        # if asked, disable separating (cuts)
        if not init_scip_kwargs['separating']:
            self.m.setIntParam('separating/maxroundsroot', 0)

        # if asked, disable conflict analysis (more cuts)
        if not init_scip_kwargs['conflict']:
            self.m.setBoolParam('conflict/enable', False)

        # if asked, disable primal heuristics
        if not init_scip_kwargs['heuristics']:
            self.m.setHeuristics(scip.SCIP_PARAMSETTING.OFF)

    def set_seed(self, seed=None):
        if seed:
            self.seed = seed
            self.rng = np.random.RandomState(seed)
        else:
            self.rng = np.random.RandomState(self.seed)
        
    def reset(self):
        # create scip model
        self.m = scip.Model()
        if self.single_instance_file == 'all':
            instance_file = self.rng.choice(self.instances)
        else:
            instance_file = self.single_instance_file
        # instance_file = 'instance_9575.lp'
        # instance_file = 'supportcase37__trans__seed__1.mps'
        logger.log(f"instance_file: {instance_file}")
        instance_file = os.path.join(self.instance_file_path, instance_file)
        self.m.setIntParam('display/verblevel', 1)  # disable statistic timing inside sub SCIP and output to console
        # 0: only error and warning messages are displayed
        # 1: only interactive dialogs, errors, and warnings are displayed
        # 2: only important messages are displayed
        # 3: standard messages are displayed
        # 4: a lot of information is displayed
        # 5: all messages are displayed
        self.m.readProblem(instance_file)
        self.m.setRealParam('limits/time', self.scip_time_limit) # self.init_scip_kwargs['scip_time_limit']
        self.m.setIntParam('timing/clocktype', 2)
        self._init_scip_params(**self.init_scip_kwargs)

        return instance_file

    def step(self, SepaSel=None, CutSel=None, Event=None):
        # include cutsel
        if SepaSel is not None:
            self.m.includeSepa(
                SepaSel,
                SepaSel.name,
                SepaSel.desc,
                SepaSel.priority,
                SepaSel.freq,
                SepaSel.maxbounddist,
                SepaSel.usessubscip,
                SepaSel.delay)
        
        if CutSel is not None:   
            self.m.includeCutsel(
                cutsel=CutSel,
                name=CutSel.name,
                desc=CutSel.desc,
                priority=CutSel.priority
            )

        if Event is not None:
            for event in Event:
                self.m.includeEventhdlr(
                    eventhdlr=event,
                    name=event.name,
                    desc=event.desc
                )
        # optimize the scip model 
        self.m.optimize()
        # self.m.printStatistics()
        
        # get statstics which can be chosen as reward signal
        stats={}
        stats['solving_time'] = self.m.getSolvingTime() # not include reading time
        stats['ntotal_nodes'] = self.m.getNTotalNodes()
        stats['primal_dual_gap'] = self.m.getGap()
        stats['primaldualintegral'] = self.m.getPrimalDualIntegral()
        stats['last_neg_reward'] = SepaSel._get_reward_info()
        stats['config_time'] = self.m.getSepaFeatures(SepaSel.name)['time']
        # stats['sepa_neg_reward'] = SepaSel._getSepaNegReward()
        # stats['lp_solution'] = self.m.getLPObjVal()
        # stats['milp_solution'] = self.m.getObjVal()
        # stats['dual_bound'] = self.m.getDualbound()
        # stats['separator_statistics'] = sepa_stats
        stats['separator_priority'] = self.m.sepaGetPriority()
        stats['separator_freq'] = self.m.sepaGetFreq()
        stats['separator_cutoffs'] = self.m.sepaGetNCutoffs()
        stats['separator_domreds'] = self.m.sepaGetNDomredsFound()
        stats['separator_appliedcuts'] = self.m.sepaGetNCutsApplied()
        stats['separator_foundcuts'] = self.m.sepaGetNCutsFound()
        stats['separator_num'] = self.m.sepaGetNExecute()
        # stats['primal_dual_integral'] = self.m.getPrimalDualInte()

        # free problem 
        self.m.freeProb()

        return stats

    def set_random_seed(self, seed):
        self.rng = np.random.RandomState(seed)



# test
if __name__ == '__main__':
    # test SCIPSepaSelEnv
    instance_file_path = "../dataset/data/instances/setcover/train_500r_1000c_0.05d"
    seed = 0
    init_scip_kwargs = {
        'presolving': True,
        'separating': True,
        'conflict': True,
        'heuristics': True
    }
    env = SCIPSepaSelEnv(
        instance_file_path,
        seed,
        scip_time_limit=3600,
        **init_scip_kwargs   
    )

    instance_file = env.reset()
    print(f"instance_file: {instance_file}")