Upload 28 files

Code/GBDT_train.py

@@ -0,0 +1,57 @@
+import numpy as np
+import argparse
+import pickle
+import random
+import os
+from model.gbdt_regressor import GradientBoostingRegressor
+
+def train_GBDT(number:int):
+    '''
+    Function Description:
+    Train GBDT based on the given problem instances and the neural encoding results of the decision variables.
+
+    Parameters:
+    - number: Number of problem instances.
+
+    Return: 
+    The trained GBDT is generated and packaged as data.pickle. The function does not have a return value.
+    '''
+    print("Tesing the performance of GBDT regressor...")
+    # Load data
+    data = []
+    label = []
+    max_num = 200000
+    now_num = 0
+    for num in range(number):
+        # Check if data.pickle exists and read it if it exists.
+        if(os.path.exists('./example/node' + str(num) + '.pickle') == False):
+            print("No problem file!")
+            return 
+        with open('./example/node' + str(num) + '.pickle', "rb") as f:
+            node = pickle.load(f)
+        now_data = node[0]
+        now_label = node[1]
+        p = max_num / (len(node[0]) * number)
+        for i in range(len(now_data)):
+            if(random.random() <= p):
+                data.append(now_data[i])
+                label.append(now_label[i])
+                now_num += 1
+    # Train model
+    print(now_num)
+    reg = GradientBoostingRegressor()
+    #print(data)
+    reg.fit(data=np.array(data), label=np.array(label), n_estimators=30, learning_rate=0.1, max_depth=5, min_samples_split=2)
+    # Model evaluation
+    with open('./GBDT.pickle', 'wb') as f:
+        pickle.dump([reg], f)
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--number", type = int, default = 10, help = 'The number of instances.')
+    return parser.parse_args()
+
+if __name__ == '__main__':
+    args = parse_args()
+    #print(vars(args))
+    train_GBDT(**vars(args))

Code/GNN_GBDT.yml

@@ -0,0 +1,169 @@
+name: GNN_GBDT
+channels:
+  - gurobi
+  - pytorch
+  - nvidia
+  - conda-forge
+  - http://conda.anaconda.org/gurobi
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - ampl-mp=3.1.0=h2cc385e_1006
+  - blas=1.0=mkl
+  - brotlipy=0.7.0=py39h27cfd23_1003
+  - bzip2=1.0.8=h7b6447c_0
+  - ca-certificates=2022.12.7=ha878542_0
+  - certifi=2022.12.7=pyhd8ed1ab_0
+  - cffi=1.15.1=py39h5eee18b_3
+  - charset-normalizer=2.0.4=pyhd3eb1b0_0
+  - cppad=20210000.6=h9c3ff4c_0
+  - cryptography=38.0.1=py39h9ce1e76_0
+  - cuda=11.7.1=0
+  - cuda-cccl=11.7.91=0
+  - cuda-command-line-tools=11.7.1=0
+  - cuda-compiler=11.7.1=0
+  - cuda-cudart=11.7.99=0
+  - cuda-cudart-dev=11.7.99=0
+  - cuda-cuobjdump=11.7.91=0
+  - cuda-cupti=11.7.101=0
+  - cuda-cuxxfilt=11.7.91=0
+  - cuda-demo-suite=12.0.76=0
+  - cuda-documentation=12.0.76=0
+  - cuda-driver-dev=11.7.99=0
+  - cuda-gdb=12.0.90=0
+  - cuda-libraries=11.7.1=0
+  - cuda-libraries-dev=11.7.1=0
+  - cuda-memcheck=11.8.86=0
+  - cuda-nsight=12.0.78=0
+  - cuda-nsight-compute=12.0.0=0
+  - cuda-nvcc=11.7.99=0
+  - cuda-nvdisasm=12.0.76=0
+  - cuda-nvml-dev=11.7.91=0
+  - cuda-nvprof=12.0.90=0
+  - cuda-nvprune=11.7.91=0
+  - cuda-nvrtc=11.7.99=0
+  - cuda-nvrtc-dev=11.7.99=0
+  - cuda-nvtx=11.7.91=0
+  - cuda-nvvp=12.0.90=0
+  - cuda-runtime=11.7.1=0
+  - cuda-sanitizer-api=12.0.90=0
+  - cuda-toolkit=11.7.1=0
+  - cuda-tools=11.7.1=0
+  - cuda-visual-tools=11.7.1=0
+  - ecole=0.7.3=py39h0db7e46_1
+  - ffmpeg=4.3=hf484d3e_0
+  - fftw=3.3.9=h27cfd23_1
+  - flit-core=3.6.0=pyhd3eb1b0_0
+  - fmt=8.1.1=h4bd325d_0
+  - freetype=2.12.1=h4a9f257_0
+  - gds-tools=1.5.0.59=0
+  - giflib=5.2.1=h7b6447c_0
+  - gmp=6.2.1=h295c915_3
+  - gnutls=3.6.15=he1e5248_0
+  - gurobi=10.0.0=py39_0
+  - idna=3.4=py39h06a4308_0
+  - intel-openmp=2021.4.0=h06a4308_3561
+  - ipopt=3.14.1=h7ede334_0
+  - jpeg=9e=h7f8727e_0
+  - lame=3.100=h7b6447c_0
+  - lcms2=2.12=h3be6417_0
+  - ld_impl_linux-64=2.38=h1181459_1
+  - lerc=3.0=h295c915_0
+  - libblas=3.9.0=12_linux64_mkl
+  - libcublas=11.10.3.66=0
+  - libcublas-dev=11.10.3.66=0
+  - libcufft=10.7.2.124=h4fbf590_0
+  - libcufft-dev=10.7.2.124=h98a8f43_0
+  - libcufile=1.5.0.59=0
+  - libcufile-dev=1.5.0.59=0
+  - libcurand=10.3.1.50=0
+  - libcurand-dev=10.3.1.50=0
+  - libcusolver=11.4.0.1=0
+  - libcusolver-dev=11.4.0.1=0
+  - libcusparse=11.7.4.91=0
+  - libcusparse-dev=11.7.4.91=0
+  - libdeflate=1.8=h7f8727e_5
+  - libedit=3.1.20191231=he28a2e2_2
+  - libffi=3.4.2=h6a678d5_6
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgfortran-ng=11.2.0=h00389a5_1
+  - libgfortran5=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libiconv=1.16=h7f8727e_2
+  - libidn2=2.3.2=h7f8727e_0
+  - liblapack=3.9.0=12_linux64_mkl
+  - libnpp=11.7.4.75=0
+  - libnpp-dev=11.7.4.75=0
+  - libnvjpeg=11.8.0.2=0
+  - libnvjpeg-dev=11.8.0.2=0
+  - libpng=1.6.37=hbc83047_0
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - libtasn1=4.16.0=h27cfd23_0
+  - libtiff=4.4.0=hecacb30_2
+  - libunistring=0.9.10=h27cfd23_0
+  - libwebp=1.2.4=h11a3e52_0
+  - libwebp-base=1.2.4=h5eee18b_0
+  - lz4-c=1.9.4=h6a678d5_0
+  - metis=5.1.0=h58526e2_1006
+  - mkl=2021.4.0=h06a4308_640
+  - mkl-service=2.4.0=py39h7f8727e_0
+  - mkl_fft=1.3.1=py39hd3c417c_0
+  - mkl_random=1.2.2=py39h51133e4_0
+  - mumps-include=5.2.1=ha770c72_11
+  - mumps-seq=5.2.1=h2104b81_11
+  - ncurses=6.3=h5eee18b_3
+  - nettle=3.7.3=hbbd107a_1
+  - nsight-compute=2022.4.0.15=0
+  - numpy=1.23.4=py39h14f4228_0
+  - numpy-base=1.23.4=py39h31eccc5_0
+  - openh264=2.1.1=h4ff587b_0
+  - openssl=1.1.1s=h7f8727e_0
+  - pillow=9.3.0=py39hace64e9_1
+  - pip=22.3.1=py39h06a4308_0
+  - pycparser=2.21=pyhd3eb1b0_0
+  - pyopenssl=22.0.0=pyhd3eb1b0_0
+  - pyscipopt=3.5.0=py39he80948d_0
+  - pysocks=1.7.1=py39h06a4308_0
+  - python=3.9.15=h7a1cb2a_2
+  - python_abi=3.9=2_cp39
+  - pytorch=1.13.1=py3.9_cuda11.7_cudnn8.5.0_0
+  - pytorch-cuda=11.7=h67b0de4_1
+  - pytorch-mutex=1.0=cuda
+  - readline=8.2=h5eee18b_0
+  - requests=2.28.1=py39h06a4308_0
+  - scip=7.0.3=hf5bcbcd_1
+  - scipy=1.9.3=py39h14f4228_0
+  - scotch=6.0.9=h3858553_1
+  - setuptools=65.5.0=py39h06a4308_0
+  - six=1.16.0=pyhd3eb1b0_1
+  - sqlite=3.40.0=h5082296_0
+  - tbb=2020.2=h4bd325d_4
+  - tk=8.6.12=h1ccaba5_0
+  - torchaudio=0.13.1=py39_cu117
+  - torchvision=0.14.1=py39_cu117
+  - typing_extensions=4.4.0=py39h06a4308_0
+  - tzdata=2022g=h04d1e81_0
+  - unixodbc=2.3.10=h583eb01_0
+  - urllib3=1.26.13=py39h06a4308_0
+  - wheel=0.37.1=pyhd3eb1b0_0
+  - xz=5.2.8=h5eee18b_0
+  - zlib=1.2.13=h5eee18b_0
+  - zstd=1.5.2=ha4553b6_0
+  - pip:
+      - jinja2==3.1.2
+      - joblib==1.2.0
+      - markupsafe==2.1.1
+      - psutil==5.9.4
+      - pyg-lib==0.1.0+pt113cu117
+      - pyparsing==3.0.9
+      - pytorch-metric-learning==1.6.3
+      - scikit-learn==1.2.0
+      - threadpoolctl==3.1.0
+      - torch-cluster==1.6.0+pt113cu117
+      - torch-geometric==2.2.0
+      - torch-scatter==2.0.9
+      - torch-sparse==0.6.16+pt113cu117
+      - torch-spline-conv==1.2.1+pt113cu117
+      - tqdm==4.64.1
+prefix: /home/anaconda3/envs/GNN_GBDT

Code/GNN_inference.py

@@ -0,0 +1,138 @@
+import argparse
+import pickle
+from pathlib import Path
+from typing import Union
+
+import os
+import torch
+import torch.nn.functional as F
+import torch_geometric
+from pytorch_metric_learning import losses
+
+from model.graphcnn import GNNPolicy
+
+class BipartiteNodeData(torch_geometric.data.Data):
+    """
+    Class Description:
+    This class encode a node bipartite graph observation as returned by the `ecole.observation.NodeBipartite`
+    observation function in a format understood by the pytorch geometric data handlers.
+    """
+
+    def __init__(
+        self,
+        constraint_features,
+        edge_indices,
+        edge_features,
+        variable_features,
+        assignment1,
+        assignment2
+    ):
+        super().__init__()
+        self.constraint_features = constraint_features
+        self.edge_index = edge_indices
+        self.edge_attr = edge_features
+        self.variable_features = variable_features
+        self.assignment1 = assignment1
+        self.assignment2 = assignment2
+
+    def __inc__(self, key, value, store, *args, **kwargs):
+        """
+        Function Description:
+        We overload the pytorch geometric method that tells how to increment indices when concatenating graphs
+        for those entries (edge index, candidates) for which this is not obvious.
+        """
+        if key == "edge_index":
+            return torch.tensor(
+                [[self.constraint_features.size(0)], [self.variable_features.size(0)]]
+            )
+        elif key == "candidates":
+            return self.variable_features.size(0)
+        else:
+            return super().__inc__(key, value, *args, **kwargs)
+
+
+class GraphDataset(torch_geometric.data.Dataset):
+    """
+    Class Description:
+    This class encodes a collection of graphs, as well as a method to load such graphs from the disk.
+    It can be used in turn by the data loaders provided by pytorch geometric.
+    """
+
+    def __init__(self, sample_files):
+        super().__init__(root=None, transform=None, pre_transform=None)
+        self.sample_files = sample_files
+
+    def len(self):
+        return len(self.sample_files)
+
+    def get(self, index):
+        """
+        Function Description:
+        This method loads a node bipartite graph observation as saved on the disk during data collection.
+        """
+        with open(self.sample_files[index], "rb") as f:
+            [variable_features, constraint_features, edge_indices, edge_features, solution1, solution2] = pickle.load(f)
+
+        graph = BipartiteNodeData(
+            torch.FloatTensor(constraint_features),
+            torch.LongTensor(edge_indices),
+            torch.FloatTensor(edge_features),
+            torch.FloatTensor(variable_features),
+            torch.LongTensor(solution1),
+            torch.LongTensor(solution2),
+        )
+
+        # We must tell pytorch geometric how many nodes there are, for indexing purposes
+        graph.num_nodes = len(constraint_features) + len(variable_features)
+        graph.cons_nodes = len(constraint_features)
+        graph.vars_nodes = len(variable_features)
+
+        return graph
+
+def make(number: int,
+         model_path : str,
+         device : torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")):
+    """
+    Function Description:
+    Obtain the encoding information of the decision variables based on the input problem data and package the output.
+    """
+    policy = GNNPolicy().to(device)
+    policy.load_state_dict(torch.load(model_path, policy.state_dict()))
+    File = []
+    for num in range(number):
+        if(os.path.exists('./example/pair' + str(num) + '.pickle') == False):
+            print("No input file!")
+            return 
+        File.append('example/pair' + str(num) + '.pickle')
+    
+    data = GraphDataset(File)
+    loader = torch_geometric.loader.DataLoader(data, batch_size = 1)
+
+    now_site = 0
+    for batch in loader:
+        batch = batch.to(device)
+        # Compute the logits (i.e. pre-softmax activations) according to the policy on the concatenated graphs
+        logits = policy(
+            batch.constraint_features,
+            batch.edge_index,
+            batch.edge_attr,
+            batch.variable_features,
+        )
+        print(logits)
+        with open('./example/sample' + str(now_site) + '.pickle', "rb") as f:
+            solution = pickle.load(f)
+        with open('./example/node' + str(now_site) + '.pickle', 'wb') as f:
+            pickle.dump([logits.tolist(), solution[4]], f)
+            print(now_site)
+            now_site += 1
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--number", type=int, default=30)
+    parser.add_argument("--model_path", type=str, default="trained_model.pkl")
+    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu", help="Device to use for training.")
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    args = parse_args()
+    make(**vars(args))

Code/GNN_train.py

@@ -0,0 +1,208 @@
+import argparse
+import pickle
+from pathlib import Path
+from typing import Union
+
+import torch
+import torch.nn.functional as F
+import torch_geometric
+from pytorch_metric_learning import losses
+
+from model.graphcnn import GNNPolicy
+
+__all__ = ["train"]
+
+class BipartiteNodeData(torch_geometric.data.Data):
+    """
+    Class Description:
+    This class encode a node bipartite graph observation as returned by the `ecole.observation.NodeBipartite`
+    observation function in a format understood by the pytorch geometric data handlers.
+    """
+    def __init__(
+        self,
+        constraint_features,
+        edge_indices,
+        edge_features,
+        variable_features,
+        assignment1,
+        assignment2
+    ):
+        super().__init__()
+        self.constraint_features = constraint_features
+        self.edge_index = edge_indices
+        self.edge_attr = edge_features
+        self.variable_features = variable_features
+        self.assignment1 = assignment1
+        self.assignment2 = assignment2
+
+    def __inc__(self, key, value, store, *args, **kwargs):
+        """
+        Function Description:
+        Overload the pytorch geometric method that tells how to increment indices when concatenating graphs for those entries (edge index, candidates) for which this is not obvious.
+        """
+        if key == "edge_index":
+            return torch.tensor(
+                [[self.constraint_features.size(0)], [self.variable_features.size(0)]]
+            )
+        elif key == "candidates":
+            return self.variable_features.size(0)
+        else:
+            return super().__inc__(key, value, *args, **kwargs)
+
+
+class GraphDataset(torch_geometric.data.Dataset):
+    """
+    Class Description:
+    This class encodes a collection of graphs, as well as a method to load such graphs from the disk.
+    It can be used in turn by the data loaders provided by pytorch geometric.
+    """
+
+    def __init__(self, sample_files):
+        super().__init__(root=None, transform=None, pre_transform=None)
+        self.sample_files = sample_files
+
+    def len(self):
+        return len(self.sample_files)
+
+    def get(self, index):
+        """
+        Function Description:
+        This method loads a node bipartite graph observation as saved on the disk during data collection.
+        """
+        with open(self.sample_files[index], "rb") as f:
+            [variable_features, constraint_features, edge_indices, edge_features, solution1, solution2] = pickle.load(f)
+
+        graph = BipartiteNodeData(
+            torch.FloatTensor(constraint_features),
+            torch.LongTensor(edge_indices),
+            torch.FloatTensor(edge_features),
+            torch.FloatTensor(variable_features),
+            torch.LongTensor(solution1),
+            torch.LongTensor(solution2),
+        )
+
+        # We must tell pytorch geometric how many nodes there are, for indexing purposes
+        graph.num_nodes = len(constraint_features) + len(variable_features)
+        graph.cons_nodes = len(constraint_features)
+        graph.vars_nodes = len(variable_features)
+
+        return graph
+
+
+def pad_tensor(input_, pad_sizes, pad_value=-1e8):
+    """
+    Function Description:
+    This utility function splits a tensor and pads each split to make them all the same size, then stacks them.
+    """
+    max_pad_size = pad_sizes.max()
+    output = input_.split(pad_sizes.cpu().numpy().tolist())
+    output = torch.stack(
+        [
+            F.pad(slice_, (0, max_pad_size - slice_.size(0)), "constant", pad_value)
+            for slice_ in output
+        ],
+        dim=0,
+    )
+    return output
+
+def process(policy, data_loader, device, optimizer=None):
+    """
+    Function Description:
+    This function will process a whole epoch of training or validation, depending on whether an optimizer is provided.
+    """
+    mean_loss = 0
+    mean_acc = 0
+
+    n_samples_processed = 0
+    with torch.set_grad_enabled(optimizer is not None):
+        for batch in data_loader:
+            #print("QwQ")
+            batch = batch.to(device)
+            # Compute the logits (i.e. pre-softmax activations) according to the policy on the concatenated graphs
+            logits = policy(
+                batch.constraint_features,
+                batch.edge_index,
+                batch.edge_attr,
+                batch.variable_features,
+            )
+            # Graph partitioning related metric functions, where num_classes represents the number of partitions in the graph.
+            loss_funcA = losses.ProxyAnchorLoss(num_classes = 10, embedding_size = 16)
+            # Metric functions related to the optimal solution. In general integer programming problems, clustering the solution values and modifying num_classes can be done.
+            loss_funcB = losses.ProxyAnchorLoss(num_classes = 2, embedding_size = 16)
+            loss = loss_funcA(logits, batch.assignment1.to(torch.int64)) + loss_funcB(logits, batch.assignment2.to(torch.int64))
+            
+            loss_optimizerA = torch.optim.SGD(loss_funcA.parameters(), lr = 0.01)
+            loss_optimizerB = torch.optim.SGD(loss_funcB.parameters(), lr = 0.01)
+            
+            if optimizer is not None:
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                loss_optimizerA.step()
+                loss_optimizerB.step()
+
+            mean_loss += loss.item() * batch.num_graphs
+            n_samples_processed += batch.num_graphs
+
+    mean_loss /= n_samples_processed
+    return mean_loss
+
+def train(
+    model_save_path: Union[str, Path],
+    batch_size: int = 1,
+    learning_rate: float = 1e-3,
+    num_epochs: int = 20,
+    device: torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+):
+    """
+    Function Description:
+    This function trains a GNN policy on training data. 
+
+    Parameters:
+    - data_path: Path to the data directory.
+    - model_save_path: Path to save the model.
+    - batch_size: Batch size for training.
+    - learning_rate: Learning rate for the optimizer.
+    - num_epochs: Number of epochs to train for.
+    - device: Device to use for training.
+    """
+    # load samples from data_path and divide them
+    sample_files = [str(path) for path in Path('./example').glob("pair*.pickle")]
+    print(sample_files)
+    train_files = sample_files[: int(0.6 * len(sample_files))]
+    valid_files = sample_files[int(0.9 * len(sample_files)) :]
+
+    train_data = GraphDataset(train_files)
+    train_loader = torch_geometric.loader.DataLoader(train_data, batch_size=batch_size, shuffle = False)
+    valid_data = GraphDataset(valid_files)
+    valid_loader = torch_geometric.loader.DataLoader(valid_data, batch_size=batch_size, shuffle = False)
+
+    policy = GNNPolicy().to(device)
+
+    optimizer = torch.optim.Adam(policy.parameters(), lr=learning_rate)
+    for epoch in range(num_epochs):
+        train_loss = process(policy, train_loader, device, optimizer)
+        #valid_loss = process(policy, valid_loader, device, None)
+        valid_loss = 0
+        print(f"Epoch {epoch+1}: Train Loss: {train_loss:0.3f}, Valid Loss: {valid_loss:0.3f}")
+
+    torch.save(policy.state_dict(), model_save_path)
+    print(f"Trained parameters saved to {model_save_path}")
+
+def parse_args():
+    """
+    Function Description:
+    This function parses the command line arguments.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_save_path", type=str, default="trained_model.pkl", help="Path to save the model.")
+    parser.add_argument("--batch_size", type=int, default=1, help="Batch size for training.")
+    parser.add_argument("--learning_rate", type=float, default=1e-4, help="Learning rate for the optimizer.")
+    parser.add_argument("--num_epochs", type=int, default=10, help="Number of epochs to train for.")
+    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu", help="Device to use for training.")
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+    train(**vars(args))

Code/data_generation.py

@@ -0,0 +1,336 @@
+import numpy as np
+import argparse
+import pickle
+import random
+import time
+import os
+
+def generate_IS(N, M):
+    '''
+    Function Description:
+    Generate instances of the maximum independent set problem in a general graph.
+    
+    Parameters:
+    - N: Number of vertices in the graph.
+    - M: Number of edges in the graph.
+
+    Return: 
+    Relevant parameters of the generated maximum independent set problem.
+    '''
+    
+    # n represents the number of decision variables, where each vertex in the graph corresponds to a decision variable.
+    # m represents the number of constraints, where each edge in the graph corresponds to a constraint.
+    # k[i] represents the number of decision variables in the i-th constraint.
+    n = N
+    m = M
+    k = []
+
+    # site[i][j] represents which decision variable the j-th decision variable corresponds to in the i-th constraint.
+    # value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    # constraint[i] represents the right-hand side value of the i-th constraint.
+    # constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+    # coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    site = []
+    value = []
+    for i in range(m):
+        site.append([])
+        value.append([])
+        k.append(0)
+    constraint = np.zeros(m)
+    constraint_type = np.zeros(m)
+    coefficient = {}
+
+    # Add constraint: randomly generate an edge and impose a constraint that the vertices connected by the edge cannot be selected simultaneously.
+    for i in range(M):
+        x = random.randint(0, N - 1)
+        y = random.randint(0, N - 1)
+        while(x == y) :
+            x = random.randint(0, N - 1)
+            y = random.randint(0, N - 1)
+        site[i].append(x)
+        value[i].append(1)
+        site[i].append(y) 
+        value[i].append(1)
+        constraint[i] = 1
+        constraint_type[i] = 1
+        k[i] = 2
+    
+    # Set the coefficients of the objective function, where the coefficient value of each decision variable corresponding to a vertex is a random value.
+    for i in range(N):
+        coefficient[i] = random.random()
+    
+    return(n, m, k, site, value, constraint, constraint_type, coefficient)
+
+def generate_MVC(N, M):
+    '''
+    Function Description:
+    Generate instances of the minimum vertex cover problem in a general graph.
+
+    Parameters:
+    - N: Number of vertices in the graph.
+    - M: Number of edges in the graph.
+
+    Return: 
+    Relevant parameters of the generated minimum vertex cover problem.
+    '''
+    
+    # n represents the number of decision variables, where each vertex in the graph corresponds to a decision variable.
+    # m represents the number of constraints, where each edge in the graph corresponds to a constraint.
+    # k[i] represents the number of decision variables in the i-th constraint.
+    n = N
+    m = M
+    k = []
+
+    # site[i][j] represents which decision variable the j-th decision variable corresponds to in the i-th constraint.
+    # value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    # constraint[i] represents the right-hand side value of the i-th constraint.
+    # constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+    # coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    site = []
+    value = []
+    for i in range(m):
+        site.append([])
+        value.append([])
+        k.append(0)
+    constraint = np.zeros(m)
+    constraint_type = np.zeros(m)
+    coefficient = {}
+
+    # Add constraint: randomly generate an edge and impose a constraint that at least one of the vertices connected by the edge must be selected.
+    for i in range(M):
+        x = random.randint(0, N - 1)
+        y = random.randint(0, N - 1)
+        while(x == y) :
+            x = random.randint(0, N - 1)
+            y = random.randint(0, N - 1)
+        k[i] = 2
+        site[i].append(x)
+        value[i].append(1)
+        site[i].append(y)
+        value[i].append(1)
+        constraint[i] = 1
+        constraint_type[i] = 2
+    
+    # Set the coefficients of the objective function, where the coefficient value of each decision variable corresponding to a vertex is a random value.
+    for i in range(N):
+        coefficient[i] = random.random()
+    
+    return(n, m, k, site, value, constraint, constraint_type, coefficient)
+
+def generate_SC(N, M):
+    '''
+    Function Description:
+    Generate instances of the set cover problem, where each item is guaranteed to appear in exactly 4 sets.
+
+    Parameters:
+    - N: Number of sets.
+    - M: Number of items.
+
+    Return: 
+    Relevant parameters of the generated set cover problem.
+    '''
+
+    # n represents the number of decision variables, where each set corresponds to a decision variable.
+    # m represents the number of constraints, where each item corresponds to a constraint.
+    # k[i] represents the number of decision variables in the i-th constraint.
+    n = N
+    m = M
+    k = []
+
+    # site[i][j] represents which decision variable the j-th decision variable corresponds to in the i-th constraint.
+    # value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    # constraint[i] represents the right-hand side value of the i-th constraint.
+    # constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+    # coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    site = []
+    value = []
+    for i in range(m):
+        site.append([])
+        value.append([])
+        k.append(0)
+    constraint = np.zeros(m)
+    constraint_type = np.zeros(m)
+    coefficient = {}
+
+    # Add constraint: At least one of the four sets in which each item appears must be selected.
+    for i in range(M):
+        vis = {}
+        for j in range(4):
+            now = random.randint(0, N - 1)
+            while(now in vis.keys()):
+                now = random.randint(0, N - 1)
+            vis[now] = 1
+
+            site[i].append(now)
+            value[i].append(1)
+        k[i] = 4   
+    for i in range(M):
+        constraint[i] = 1
+        constraint_type[i] = 2
+    
+    # Set the coefficients of the objective function, where the coefficient value of each decision variable corresponding to a set is a random value.
+    for i in range(N):
+        coefficient[i] = random.random()
+    
+    
+    return(n, m, k, site, value, constraint, constraint_type, coefficient)
+
+def generate_CAT(N, M):
+    '''
+    Function Description:
+    Generate instances of the set cover problem, where each item is guaranteed to appear in exactly 5 sets.
+
+    Parameters:
+    - N: Number of sets.
+    - M: Number of items.
+
+    Return: 
+    Relevant parameters of the generated set cover problem.
+    '''
+    # n represents the number of decision variables, where each set corresponds to a decision variable.
+    # m represents the number of constraints, where each item corresponds to a constraint.
+    # k[i] represents the number of decision variables in the i-th constraint.
+    n = N
+    m = M
+    k = []
+
+    # site[i][j] represents which decision variable the j-th decision variable corresponds to in the i-th constraint.
+    # value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    # constraint[i] represents the right-hand side value of the i-th constraint.
+    # constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+    # coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    
+    site = []
+    value = []
+    for i in range(m):
+        site.append([])
+        value.append([])
+        k.append(0)
+    constraint = np.zeros(m)
+    constraint_type = np.zeros(m)
+    coefficient = {}
+
+    # Add constraints.
+    for i in range(M):
+        vis = {}
+        for j in range(5):
+            now = random.randint(0, N - 1)
+            while(now in vis.keys()):
+                now = random.randint(0, N - 1)
+            vis[now] = 1
+
+            site[i].append(now)
+            value[i].append(1)
+        k[i] = 5   
+    for i in range(M):
+        constraint[i] = 1
+        constraint_type[i] = 1
+    
+    # Set the coefficients of the objective function, where the coefficient value of each decision variable corresponding to a set is a random value.
+    for i in range(N):
+        coefficient[i] = random.random() * 1000
+    
+    
+    return(n, m, k, site, value, constraint, constraint_type, coefficient)
+
+def generate_samples(
+    problem_type : str,
+    difficulty_mode : str,
+    seed : int, 
+    number : int
+):
+    '''
+    Function Description:
+    Generate problem instances based on the provided parameters and package the output as data.pickle.
+
+    Parameters:
+    - problem_type: Available options are ['IS', 'MVC', 'MAXCUT', 'SC'], representing the maximum independent set problem, minimum vertex cover problem, maximum cut problem, minimum set cover problem, and Meituan flash sale problem, respectively.
+    - difficulty_mode: Available options are ['easy', 'medium', 'hard'], representing easy (small-scale), medium (medium-scale), and hard (large-scale) difficulties.
+    - seed: Integer value indicating the starting random seed used for problem generation.
+    - number: Integer value indicating the number of instances to generate.
+
+    Return: 
+    The problem instances are generated and packaged as data.pickle. The function does not have a return value.
+    '''
+    # Set the random seed.
+    random.seed(seed) 
+
+    # Check and create using the os module.
+    dir_name = 'example'
+    if not os.path.exists(dir_name):  
+        os.mkdir(dir_name)
+
+    for i in range(number):
+        # Randomly generate instances of the maximum independent set problem and package the output.
+        if(problem_type == 'IS'):
+            if(difficulty_mode == 'easy'):
+                N = 10000
+                M = 30000
+            elif(difficulty_mode == 'medium'):
+                N = 100000
+                M = 300000
+            else:
+                N = 1000000
+                M = 3000000  
+            n, m, k, site, value, constraint, constraint_type, coefficient = generate_IS(N, M)
+            with open('./example/data' + str(i) + '.pickle', 'wb') as f:
+                pickle.dump(['maximize', n, m, k, site, value, constraint, constraint_type, coefficient], f)
+        
+        # Randomly generate instances of the minimum vertex cover problem and package the output.
+        if(problem_type == 'MVC'):
+            if(difficulty_mode == 'easy'):
+                N = 10000
+                M = 30000
+            elif(difficulty_mode == 'medium'):
+                N = 100000
+                M = 300000
+            else:
+                N = 1000000
+                M = 3000000 
+            n, m, k, site, value, constraint, constraint_type, coefficient = generate_MVC(N, M)
+            with open('./example/data' + str(i) + '.pickle', 'wb') as f:
+                pickle.dump(['minimize', n, m, k, site, value, constraint, constraint_type, coefficient], f)
+        
+        # Randomly generate instances of the minimum set cover problem and package the output.
+        if(problem_type == 'SC'):
+            if(difficulty_mode == 'easy'):
+                N = 20000
+                M = 20000
+            elif(difficulty_mode == 'medium'):
+                N = 200000
+                M = 200000
+            else:
+                N = 2000000
+                M = 2000000 
+            n, m, k, site, value, constraint, constraint_type, coefficient = generate_SC(N, M)
+            with open('./example/data' + str(i) + '.pickle', 'wb') as f:
+                pickle.dump(['minimize', n, m, k, site, value, constraint, constraint_type, coefficient], f)
+        
+        # Randomly generate instances of the combinatorial auction problem and package the output.
+        if(problem_type == 'CAT'):
+            if(difficulty_mode == 'easy'):
+                N = 10000
+                M = 10000
+            elif(difficulty_mode == 'medium'):
+                N = 100000
+                M = 100000
+            else:
+                N = 1000000
+                M = 1000000 
+            n, m, k, site, value, constraint, constraint_type, coefficient = generate_CAT(N, M)
+            with open('./example/data' + str(i) + '.pickle', 'wb') as f:
+                pickle.dump(['maximize', n, m, k, site, value, constraint, constraint_type, coefficient], f)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--problem_type", choices = ['IS', 'MVC', 'SC',  'CAT'], default = 'SC', help = "Problem type selection")
+    parser.add_argument("--difficulty_mode", choices = ['easy', 'medium', 'hard'], default = 'easy', help = "Difficulty level.")
+    parser.add_argument('--seed', type = int, default = 0, help = 'Random generator seed.')
+    parser.add_argument("--number", type = int, default = 10, help = 'The number of instances.')
+    return parser.parse_args()
+
+if __name__ == '__main__':
+    args = parse_args()
+    #print(vars(args))
+    generate_samples(**vars(args))

Code/data_partition.py

@@ -0,0 +1,106 @@
+from functools import cmp_to_key
+import numpy as np
+import argparse
+import pickle
+import random
+import time
+import os
+
+class pair: 
+    def __init__(self): 
+        self.x = 0
+        self.y = 0
+        self.val = 0
+
+def cmp(a, b):
+    if a.val > b.val: 
+        return -1
+    else:
+        return 1
+    
+def FENNEL(n, m, k, site):
+    '''
+    Function Description:
+    Use the FENNEL algorithm to partition the bipartite representation of the problem instance.
+
+    Parameters:
+    - n: Number of decision variables in the problem instance.
+    - m: Number of constraints in the problem instance.
+    - k: k[i] represents the number of decision variables in the i-th constraint.
+    - site: site[i][j] represents which decision variable the j-th decision variable of the i-th constraint corresponds to.
+
+    Return: 
+    The result of the graph partitioning.
+    '''
+    raise NotImplementedError('FENNEL method should be implemented')
+
+def generate_pair(
+    number : int
+):
+    '''
+    Function Description:
+    Partition the problem based on the given problem instances and generate training data.
+
+    Parameters:
+    - number: Number of problem instances.
+
+    Return: 
+    The training data is generated and packaged as data.pickle. The function does not have a return value.
+    '''
+    for turn in range(number):
+        print("=====", turn)
+        # Check if data.pickle exists and read it if it exists.
+        if(os.path.exists('./example/data' + str(turn) + '.pickle') == False):
+            print("No problem file!")
+            return 
+        with open('./example/data' + str(turn) + '.pickle', "rb") as f:
+            problem = pickle.load(f)
+        
+        # Check if solution.pickle exists and read it if it exists.
+        if(os.path.exists('./example/sample' + str(turn) + '.pickle') == False):
+            print("No solutuion file!")
+            return 
+        with open('./example/sample' + str(turn) + '.pickle', "rb") as f:
+            solution = pickle.load(f)
+
+        # obj_type represents the problem type (maximization/minimization).
+        # n represents the number of decision variables.
+        # m represents the number of constraints.
+        # k[i] represents the number of decision variables in the i-th constraint.
+        # site[i][j] represents which decision variable the j-th decision variable of the i-th constraint corresponds to.
+        # value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+        # constraint[i] represents the right-hand side value of the i-th constraint.
+        # constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+        # coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+        obj_type = problem[0]
+        n = problem[1]
+        m = problem[2]
+        k = problem[3]
+        site = problem[4]
+        value = problem[5]
+        constraint = problem[6]
+        constraint_type = problem[7]
+        coefficient = problem[8]
+
+        variable_features = solution[0]
+        constraint_features = solution[1]
+        edge_indices = solution[2]
+        edge_features = solution[3]
+        optX = solution[4]
+        
+        # Get the graph partitioning result.
+        new_color = FENNEL(n, m, k, site)
+        
+        with open('./example/pair' + str(turn) + '.pickle', 'wb') as f:
+            pickle.dump([variable_features, constraint_features, edge_indices, edge_features, new_color, optX], f)
+
+    
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--number", type = int, default = 10, help = 'The number of instances.')
+    return parser.parse_args()
+
+if __name__ == '__main__':
+    args = parse_args()
+    #print(vars(args))
+    generate_pair(**vars(args))

Code/data_solution.py

@@ -0,0 +1,121 @@
+import numpy as np
+import argparse
+import pickle
+import random
+import time
+import os
+
+
+def get_best_solution(n, m, k, site, value, constraint, constraint_type, coefficient, time_limit, obj_type):
+    '''
+    Function Description:
+    Solve the problem using an optimization solver based on the provided problem instance.
+
+    Parameters:
+    - n: Number of decision variables in the problem instance.
+    - m: Number of constraints in the problem instance.
+    - k: k[i] represents the number of decision variables in the i-th constraint.
+    - site: site[i][j] represents which decision variable the j-th decision variable of the i-th constraint corresponds to.
+    - value: value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    - constraint: constraint[i] represents the right-hand side value of the i-th constraint.
+    - constraint_type: constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =..
+    - coefficient: coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    - time_limit: Maximum solving time.
+    - obj_type: Whether the problem is a maximization problem or a minimization problem.
+
+    Return: 
+    The optimal solution of the problem, represented as a list of values for each decision variable in the optimal solution.
+    '''
+
+    raise NotImplementedError('get_best_solution method should be implemented')
+
+
+def optimize(
+    time : int,
+    number : int,
+):
+    '''
+    Function Description:
+    Based on the specified parameter design, invoke the designated algorithm and solver to optimize the optimization problem in data.pickle in the current directory.
+
+    Parameters:
+    - number: Integer value indicating the number of instances to generate.
+    - suboptimal: Integer value indicating the number of suboptimal solutions to generate.
+
+    Return: 
+    The optimal solution is generated and packaged as data.pickle. The function does not have a return value.
+    '''
+
+
+    for num in range(number):
+        # Check if data.pickle exists and read it if it exists.
+        if(os.path.exists('./example/data' + str(num) + '.pickle') == False):
+            print("No input file!")
+            return 
+        with open('./example/data' + str(num) + '.pickle', "rb") as f:
+            data = pickle.load(f)
+    
+        # n represents the number of decision variables.
+        # m represents the number of constraints.
+        # k[i] represents the number of decision variables in the i-th constraint.
+        # site[i][j] represents which decision variable the j-th decision variable of the i-th constraint corresponds to.
+        # value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+        # constraint[i] represents the right-hand side value of the i-th constraint.
+        # constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+        # coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+        n = data[1]
+        m = data[2]
+        k = data[3]
+        site = data[4]
+        value = data[5]
+        constraint = data[6]
+        constraint_type = data[7]
+        coefficient = data[8]
+        # IS and CAT are maximization problems.
+        # MVC and SC are minimization problems.
+        obj_type = data[0]
+        optimal_solution = get_best_solution(n, m, k, site, value, constraint, constraint_type, coefficient, time, obj_type)
+        
+
+        variable_features = []
+        constraint_features = []
+        edge_indices = [[], []] 
+        edge_features = []
+
+        for i in range(n):
+            now_variable_features = []
+            now_variable_features.append(coefficient[i])
+            now_variable_features.append(0)
+            now_variable_features.append(1)
+            now_variable_features.append(1)
+            now_variable_features.append(random.random())
+            variable_features.append(now_variable_features)
+        
+        for i in range(m):
+            now_constraint_features = []
+            now_constraint_features.append(constraint[i])
+            now_constraint_features.append(constraint_type[i])
+            now_constraint_features.append(random.random())
+            constraint_features.append(now_constraint_features)
+        
+        for i in range(m):
+            for j in range(k[i]):
+                edge_indices[0].append(i)
+                edge_indices[1].append(site[i][j])
+                edge_features.append([value[i][j]])
+
+        with open('./example/sample' + str(num) + '.pickle', 'wb') as f:
+                pickle.dump([variable_features, constraint_features, edge_indices, edge_features, optimal_solution], f)
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--time', type = int, default = 10, help = 'Running wall-clock time.')
+    parser.add_argument("--number", type = int, default = 10, help = 'The number of instances.')
+    return parser.parse_args()
+
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    #print(vars(args))
+    optimize(**vars(args))

Code/model/gbdt_regressor.py

@@ -0,0 +1,66 @@
+import numpy as np
+from numpy import ndarray
+
+
+class GradientBoostingRegressor():
+    '''
+    Class Description:
+    GBDT class, which stores the trained GBDT.
+    '''
+    def __init__(self):
+        '''
+        Function Description:
+        Initialize the GBDT.
+        '''
+        raise NotImplementedError('GradientBoostingRegressor __init__ method should be implemented')
+
+    def fit(self, data: ndarray, 
+            label: ndarray, 
+            n_estimators: int, 
+            learning_rate: float,
+            max_depth: int, 
+            min_samples_split: int, 
+            subsample=None):
+        '''
+        Function Description:
+        Train the GBDT based on the given decision variable neural encoding and optimal solution values.
+
+        Parameters:
+        - data: Neural encoding results of the decision variables.
+        - label: Values of the decision variables in the optimal solution.
+        - n_estimators: Number of decision trees.
+        - learning_rate: Learning rate.
+        - max_depth: Maximum depth of the decision trees.
+        - min_samples_split: Minimum number of samples required to split a leaf node.
+        - subsample: Subsample rate without replacement.
+
+        Return: 
+        The training results are stored in the class. There is no return value.
+        '''
+        raise NotImplementedError('GradientBoostingRegressor fit method should be implemented')
+
+    def predict(self, data: ndarray) -> ndarray:
+        '''
+        Function Description:
+        Use the trained GBDT to predict the initial solution based on the given decision variable neural encoding, and return the predicted initial solution.
+
+        Parameters:
+        - data: Neural encoding results of the decision variables.
+
+        Return: 
+        The predicted initial solution.
+        '''
+        raise NotImplementedError('GradientBoostingRegressor predict method should be implemented')
+    
+    def calc(self, data: ndarray) -> ndarray:
+        '''
+        Function Description:
+        Use the trained GBDT to predict the initial solution based on the given decision variable neural encoding, and return the prediction loss.
+
+        Parameters:
+        - data: Neural encoding results of the decision variables.
+
+        Return: 
+        The prediction loss generated when predicting the initial solution for each decision variable.
+        '''
+        raise NotImplementedError('GradientBoostingRegressor calc method should be implemented')

Code/model/graphcnn.py

@@ -0,0 +1,81 @@
+import numpy as np
+import torch
+import torch_geometric
+
+__all__ = ["GNNPolicy"]
+
+class BipartiteGraphConvolution(torch_geometric.nn.MessagePassing):
+    """
+    Class Description:
+    Based on graph convolution, define the bipartite graph semi-convolution process.
+    """
+
+    def __init__(self):
+        '''
+        Function Description:
+        Define the size of the encoding space, and implement the semi-convolution layer and output layer.
+        '''
+        raise NotImplementedError('BipartiteGraphConvolution __init__ method should be implemented')
+
+    def forward(self, left_features, edge_indices, edge_features, right_features):
+        '''
+        Function Description:
+        Based on the given node and edge features, output the result of forward propagation after semi-convolution.
+
+        Parameters:
+        - left_features: Features of the nodes on the left side of the bipartite graph.
+        - edge_indices: Edge information.
+        - edge_features: Edge features.
+        - right_features: Features of the nodes on the right side of the bipartite graph.
+
+        Return: The result after forward propagation.
+        '''
+        raise NotImplementedError('BipartiteGraphConvolution forward method should be implemented')
+
+    def message(self, node_features_i, node_features_j, edge_features):
+        '''
+        Function Description:
+        This method sends the messages, computed in the message method.
+        
+        Parameters:
+        - node_features_i: Features of the nodes on the left side of the bipartite graph.
+        - node_features_j: Features of the nodes on the right side of the bipartite graph.
+        - edge_features: Edge features.
+
+        Return: The result after the message passing in the semi-convolution.
+        '''
+        raise NotImplementedError('BipartiteGraphConvolution message method should be implemented')
+
+
+class GNNPolicy(torch.nn.Module):
+    """
+    Class Description:
+    Based on the semi-convolutional layer, define the entire GNN network structure.
+    """
+    def __init__(self):
+        '''
+        Function Description:
+        Define the size of the encoding space, and define the layers for decision variable encoding, edge feature encoding, and constraint feature encoding.
+        Define two semi-convolutional layers and the final output layer.
+        '''
+        raise NotImplementedError('GNNPolicy __init__ method should be implemented')
+
+        
+
+    def forward(
+        self, constraint_features, edge_indices, edge_features, variable_features
+    ):
+        '''
+        Function Description:
+        Based on the given constraint, edge, and variable features, output the result of forward propagation after GNN.
+
+        Parameters:
+        - constraint_features: Features of the constraint points.
+        - edge_indices: Edge information.
+        - edge_features: Edge features.
+        - variable_features: Features of the variable points.
+
+        Return: The result after forward propagation.
+        '''
+        raise NotImplementedError('GNNPolicy forward method should be implemented')
+

Code/test.py

@@ -0,0 +1,308 @@
+import os
+import time
+import torch
+import random
+import pickle
+import argparse
+import torch_geometric
+
+import numpy as np
+import torch.nn.functional as F
+from pytorch_metric_learning import losses
+
+from gurobipy import *
+from typing import Union
+from pathlib import Path
+from functools import cmp_to_key
+from model.graphcnn import GNNPolicy
+from model.gbdt_regressor import GradientBoostingRegressor
+
+def make(constraint_features,
+         edge_index,
+         edge_attr,
+         variable_features,
+         model_path : str,
+         device : torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")):
+    '''
+    Function Description:
+    Use the trained GNN to obtain the neural encoding results of the decision variables based on the given problem instances.
+
+    Parameters:
+    - constraint_features: Initial feature encoding of constraint points in the bipartite representation of the problem.
+    - edge_index: Edges in the bipartite representation of the problem.
+    - edge_attr: Edge features in the bipartite representation of the problem.
+    - variable_features: Initial feature encoding of decision variable points in the bipartite representation of the problem.
+    - model_path: Path to the trained GNN model.
+    - device: Select the computing device.
+
+    Return: 
+    The neural encoding results of the decision variables.
+    '''
+    policy = GNNPolicy().to(device)
+    policy.load_state_dict(torch.load(model_path, policy.state_dict()))
+    logits = policy(
+        torch.FloatTensor(constraint_features).to(device),
+        torch.LongTensor(edge_index).to(device),
+        torch.FloatTensor(edge_attr).to(device),
+        torch.FloatTensor(variable_features).to(device),
+    )
+    #print(logits)
+    return logits.tolist()
+
+class pair: 
+    def __init__(self): 
+        self.site = 0
+        self.loss = 0
+
+def cmp(a, b):
+    if a.loss < b.loss: 
+        return -1
+    else:
+        return 1
+
+def cmp2(a, b):
+    if a.loss > b.loss: 
+        return -1
+    else:
+        return 1
+
+def get_best_solution(n, m, k, site, value, constraint, constraint_type, coefficient, time_limit, obj_type, now_sol, now_col):
+    '''
+    Function Description:
+    Solve the problem using an optimization solver based on the provided problem instance.
+
+    Parameters:
+    - n: Number of decision variables in the problem instance.
+    - m: Number of constraints in the problem instance.
+    - k: k[i] represents the number of decision variables in the i-th constraint.
+    - site: site[i][j] represents which decision variable the j-th decision variable of the i-th constraint corresponds to.
+    - value: value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    - constraint: constraint[i] represents the right-hand side value of the i-th constraint.
+    - constraint_type: constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+    - coefficient: coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    - time_limit: Maximum solving time.
+    - obj_type: Whether the problem is a maximization problem or a minimization problem.
+
+    Return: 
+    The optimal solution of the problem.
+    '''
+    raise NotImplementedError('get_best_solution method should be implemented')
+
+def initial_solution_search(n, m, k, site, value, constraint, constraint_type, coefficient, set_time, obj_type, predict, loss):
+    '''
+    Function Description:
+    Perform an initial solution search using fixed-radius neighborhood search based on the given problem instance and the predicted results from GBDT.
+
+    Parameters:
+    - n: Number of decision variables in the problem instance.
+    - m: Number of constraints in the problem instance.
+    - k: k[i] represents the number of decision variables in the i-th constraint.
+    - site: site[i][j] represents which decision variable the j-th decision variable of the i-th constraint corresponds to.
+    - value: value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    - constraint: constraint[i] represents the right-hand side value of the i-th constraint.
+    - constraint_type: constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+    - coefficient: coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    - time_limit: Maximum solving time.
+    - obj_type: Whether the problem is a maximization problem or a minimization problem.
+    - predict: Predicted results from GBDT.
+    - loss: Prediction loss from GBDT.
+
+    Return: 
+    The initial feasible solution of the problem and its corresponding objective function value.
+    '''
+    raise NotImplementedError('initial_solution_search method should be implemented')
+
+def cross_generate_blocks(n, loss, rate, predict, nowX, GBDT, data):
+    '''
+    Function Description:
+    Obtain the neighborhood partitioning result based on the given problem instance, the predicted results from GBDT, and the current solution.
+
+    Parameters:
+    - n: Number of decision variables in the problem instance.
+    - loss: Prediction loss from GBDT.
+    - rate: Neighborhood radius.
+    - predict: Predicted results from GBDT.
+    - nowX: Current solution of the problem instance.
+    - GBDT: Trained Gradient Boosting Decision Tree.
+    - data: Neural encoding results of the decision variables.
+
+    Return: A set of partitioning results of the neighborhood.
+    '''
+    raise NotImplementedError('cross_generate_blocks method should be implemented')
+
+def cross(n, m, k, site, value, constraint, constraint_type, coefficient, obj_type, rate, solA, blockA, solB, blockB, set_time):
+    '''
+    Function Description:
+    Obtain the crossover solution of two neighborhoods based on the given problem instance, the neighborhood information and search results of neighborhood A, the neighborhood information and search results of neighborhood B.
+
+    Parameters:
+    - n: Number of decision variables in the problem instance.
+    - m: Number of constraints in the problem instance.
+    - k: k[i] represents the number of decision variables in the i-th constraint.
+    - site: site[i][j] represents which decision variable the j-th decision variable of the i-th constraint corresponds to.
+    - value: value[i][j] represents the coefficient of the j-th decision variable in the i-th constraint.
+    - constraint: constraint[i] represents the right-hand side value of the i-th constraint.
+    - constraint_type: constraint_type[i] represents the type of the i-th constraint, where 1 represents <=, 2 represents >=, and 3 represents =.
+    - coefficient: coefficient[i] represents the coefficient of the i-th decision variable in the objective function.
+    - rate: Neighborhood radius.
+    - solA: Search result of neighborhood A.
+    - blockA: Neighborhood information of neighborhood A.
+    - solB: Search result of neighborhood B.
+    - blockB: Neighborhood information of neighborhood B.
+    - set_time: Set running time.
+
+    Return: 
+    The crossover solution of the two neighborhoods and their corresponding objective function values.
+    '''
+    raise NotImplementedError('cross method should be implemented')
+        
+        
+def optimize(fix : float,
+             set_time : int,
+             rate : float,
+             model_path : str,
+             device : torch.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")):
+    begin_time = time.time()
+
+    if(os.path.exists('./example-IS-h/data0.pickle') == False):
+        print("No problem file!")
+
+    with open('./example-IS-h/data0.pickle', "rb") as f:
+        problem = pickle.load(f)
+
+    obj_type = problem[0]
+    n = problem[1]
+    m = problem[2]
+    k = problem[3]
+    site = problem[4]
+    value = problem[5]
+    constraint = problem[6]
+    constraint_type = problem[7]
+    coefficient = problem[8]
+
+
+    variable_features = []
+    constraint_features = []
+    edge_indices = [[], []] 
+    edge_features = []
+
+    for i in range(n):
+        now_variable_features = []
+        now_variable_features.append(coefficient[i])
+        now_variable_features.append(0)
+        now_variable_features.append(1)
+        now_variable_features.append(1)
+        now_variable_features.append(random.random())
+        variable_features.append(now_variable_features)
+    
+    for i in range(m):
+        now_constraint_features = []
+        now_constraint_features.append(constraint[i])
+        now_constraint_features.append(constraint_type[i])
+        now_constraint_features.append(random.random())
+        constraint_features.append(now_constraint_features)
+    
+    for i in range(m):
+        for j in range(k[i]):
+            edge_indices[0].append(i)
+            edge_indices[1].append(site[i][j])
+            edge_features.append([value[i][j]])
+    data = make(constraint_features, edge_indices, edge_features, variable_features, model_path, device)
+
+
+    if(os.path.exists('./GBDT-IS-h.pickle') == False):
+        print("No problem file!")
+
+    with open('./GBDT-IS-h.pickle', "rb") as f:
+        GBDT = pickle.load(f)[0]
+    predict = GBDT.predict(np.array(data))
+    loss =  GBDT.calc(np.array(data))
+
+    
+    # Initial solution search.
+    ansTime = []
+    ansVal = []
+    nowX, nowVal = initial_solution_search(n, m, k, site, value, constraint, constraint_type, coefficient, set_time, obj_type, predict, loss) 
+    ansTime.append(time.time() - begin_time)
+    ansVal.append(nowVal)
+
+    while(time.time() - begin_time < set_time):
+        turnX = []
+        turnVal = []
+        block_list, _, _ = cross_generate_blocks(n, loss, rate, predict, nowX, GBDT, data)
+        # GBDT-guided neighborhood partitioning and neighborhood search.
+        for i in range(4):
+            max_time = set_time - (time.time() - begin_time)
+            if(max_time <= 0):
+                break
+            newX, newVal = get_best_solution(n, m, k, site, value, constraint, constraint_type, coefficient, max_time, obj_type, nowX, block_list[i])
+            turnX.append(newX)
+            turnVal.append(newVal)
+        
+        # First-level crossover between neighborhoods.
+        if(len(turnX) == 4):
+            max_time = set_time - (time.time() - begin_time)
+            if(max_time <= 0):
+                break
+            newX, newVal = cross(n, m, k, site, value, constraint, constraint_type, coefficient, obj_type, rate, turnX[0], block_list[0], turnX[1], block_list[1], max_time)
+            if(turnVal != -1):
+                turnX.append(newX)
+                turnVal.append(newVal)
+
+            newX, newVal = cross(n, m, k, site, value, constraint, constraint_type, coefficient, obj_type, rate, turnX[2], block_list[2], turnX[3], block_list[3],  max_time)
+            if(turnVal != -1):
+                turnX.append(newX)
+                turnVal.append(newVal)
+        
+        # Second-level crossover between neighborhoods.
+        if(len(turnX) == 6):
+            max_time = set_time - (time.time() - begin_time)
+            if(max_time <= 0):
+                break
+
+            block_list.append(np.zeros(n, int))
+            for i in range(n):
+                if(block_list[0][i] == 1 or block_list[1][i] == 1):
+                    block_list[4][i] = 1
+            block_list.append(np.zeros(n, int))
+            for i in range(n):
+                if(block_list[2][i] == 1 or block_list[3][i] == 1):
+                    block_list[5][i] = 1
+            
+            newX, newVal = cross(n, m, k, site, value, constraint, constraint_type, coefficient, obj_type, rate, turnX[4], block_list[4], turnX[5], block_list[5], max_time)
+            if(turnVal != -1):
+                turnX.append(newX)
+                turnVal.append(newVal)
+        
+        # Update the current solution as the current optimal solution.
+        for i in range(len(turnVal)):
+            if(obj_type == 'maximize'):
+                if(turnVal[i] > nowVal):
+                    nowVal = turnVal[i]
+                    for j in range(n):
+                        nowX[j] = turnX[i][j]
+            else:
+                if(turnVal[i] < nowVal):
+                    nowVal = turnVal[i]
+                    for j in range(n):
+                        nowX[j] = turnX[i][j]
+        
+        ansTime.append(time.time() - begin_time)
+        ansVal.append(nowVal)
+    print(ansTime)
+    print(ansVal)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--fix", type = float, default = 0.1, help = 'time.')
+    parser.add_argument("--set_time", type = int, default = 100, help = 'set_time.')
+    parser.add_argument("--rate", type = float, default = 0.2, help = 'sub rate.')
+    parser.add_argument("--model_path", type=str, default="trained_model-IS-h.pkl")
+    parser.add_argument("--device", type=str, default="cuda" if torch.cuda.is_available() else "cpu", help="Device to use for training.")
+    return parser.parse_args()
+
+if __name__ == '__main__':
+    args = parse_args()
+    #print(vars(args)["model_path"])
+    optimize(**vars(args))

README.md

@@ -0,0 +1,60 @@
+## GNN&GBDT-Guided Fast Optimizing Framework for Large-scale Integer Programming
+
+### Overview
+
+This release contains the key processes of the GNN&GBDT-Guided Fast Optimizing Framework, as described in the paper. The provided code implements the main components of the approach, covering data generation, training, and inference. We also provide interfaces that are left to be implemented by the user so that the code can be flexibly used in different contexts.
+
+The following gives a brief overview of the contents; more detailed documentation is available within each file:
+
+*   __Code/data_generation.py__: Generating integer programming problems for training and testing.
+*   __Code/data_solution.py__: Generate optimal solutions to integer programming problems for training.
+*   __Code/data_partition.py__: Generate graph partition results for bipartite graph representations of integer programming problems used for training.
+*   __Code/GNN_train.py__: Use prepared training data to train GNN to generate neural embeddings of decision variables.
+*   __Code/GNN_inference.py__: Using a trained GNN to generate neural embeddings of decision variables for training data.
+*   __Code/GBDT_train.py__: Train GBDT using the training data and the resulting neural embeddings results.
+*   __Code/test.py__: Run test data to get optimized results.
+*   __Code/model/graphcnn.py__: GNN model.
+*   __Code/model/gbdt_regressor.py__: GBDT model.
+*   __Result/CA__: Running results of the very large-scale version of the Combinatorial Auction problem.
+*   __Result/MIS__: Running results of the very large-scale version of the Maximum Independent Set problem.
+*   __Result/MVC__: Running results of the very large-scale version of the Minimum Vertex Covering problem.
+*   __Result/SC__: Running results of the very large-scale version of the Set Covering problem.
+*   __Paper/paper.pdf__: PDF version of the paper.
+
+## Requirements
+
+The required environment is shown in GNN_GBDT.yml.
+
+## Usage
+
+1. Implement the interfaces respectively.
+
+3. Perform training according to the following code running order:
+
+   ```
+   Code/data_generation.py
+   Code/data_solution.py
+   Code/data_partition.py
+   Code/GNN_train.py
+   Code/GNN_inference.py
+   Code/GBDT_train.py
+   ```
+
+3. Run tests with test.py.
+
+## Citing this work
+
+Paper: [GNN&GBDT-Guided Fast Optimizing Framework for Large-scale Integer Programming](https://openreview.net/pdf?id=tX7ajV69wt)
+
+If you use the code here please cite this paper:
+
+    @inproceedings{ye2023gnn,
+      title={GNN\&GBDT-Guided Fast Optimizing Framework for Large-scale Integer Programming},
+      author={Ye, Huigen and Xu, Hua and Wang, Hongyan and Wang, Chengming and Jiang, Yu},
+      booktitle={ICML},
+      year={2023}
+    }
+
+## Contact
+
+Welcome to academic and business collaborations with funding support. For more details, please contact us via email at [xuhua@tsinghua.edu.cn](mailto:xuhua@tsinghua.edu.cn).

Result/CA/2-h1-S-CA2-100.log

@@ -0,0 +1,37 @@
+nohup: ignoring input
+feasible solution found by trivial heuristic after 5.3 seconds, objective value 1.106511e+06
+presolving:
+(round 1, fast)       6664 del vars, 0 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 1000000 clqs
+   (18.0s) running MILP presolver
+   (21.5s) MILP presolver (2 rounds): 0 aggregations, 70822 fixings, 0 bound changes
+(round 2, medium)     77486 del vars, 0 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 992975 clqs
+(round 3, fast)       84443 del vars, 13982 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 986018 clqs
+(round 4, exhaustive) 84523 del vars, 13986 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 986014 upgd conss, 0 impls, 986014 clqs
+(round 5, medium)     104575 del vars, 14188 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 19272 chg coeffs, 986014 upgd conss, 0 impls, 985812 clqs
+(round 6, fast)       105397 del vars, 14852 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 19272 chg coeffs, 986014 upgd conss, 0 impls, 985148 clqs
+   (44.4s) probing: 51/894550 (0.0%) - 0 fixings, 0 aggregations, 0 implications, 0 bound changes
+   (44.4s) probing aborted: 50/50 successive totally useless probings
+   (46.5s) symmetry computation started: requiring (bin +, int -, cont +), (fixed: bin -, int +, cont -)
+   (47.6s) no symmetry present
+presolving (7 rounds: 7 fast, 4 medium, 2 exhaustive):
+ 105450 deleted vars, 14857 deleted constraints, 0 added constraints, 0 tightened bounds, 0 added holes, 0 changed sides, 19306 changed coefficients
+ 0 implications, 985143 cliques
+presolved problem has 894550 variables (894550 bin, 0 int, 0 impl, 0 cont) and 985143 constraints
+ 985143 constraints of type <setppc>
+Presolving Time: 45.52
+
+ time | node  | left  |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr|  dualbound   | primalbound  |  gap   | compl. 
+t51.0s|     1 |     0 |     0 |     - | trivial|   0 | 894k| 985k|   0 |   0 |  0 |   0 |   0 | 4.573383e+08 | 2.006270e+07 |2179.55%| unknown
+p9324s|     1 |     0 | 65810 |     - |  clique|   0 | 894k| 985k| 985k|   0 |  0 |   0 |   0 | 4.573383e+08 | 1.152777e+08 | 296.73%| unknown
+ 1000m|     1 |     0 |619298 |     - |  6581M |   0 | 894k| 985k| 985k|   0 |  0 |   0 |   0 | 4.573383e+08 | 1.152777e+08 | 296.73%| unknown
+(node 1) LP solver hit time limit in LP 3 -- using pseudo solution instead
+
+SCIP Status        : solving was interrupted [time limit reached]
+Solving Time (sec) : 59978.53
+Solving Nodes      : 1
+Primal Bound       : +1.15277654568253e+08 (4 solutions)
+Dual Bound         : +4.57338288629170e+08
+Gap                : 296.73 %
+0.0
+[60105.98654079437]
+[115277654.56825252]

Result/MIS/2-h1-S-MIS2-100.log

@@ -0,0 +1,36 @@
+nohup: ignoring input
+feasible solution found by trivial heuristic after 16.7 seconds, objective value 3.983191e+02
+presolving:
+(round 1, fast)       17431 del vars, 15004 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2984987 clqs
+(round 2, fast)       25267 del vars, 59925 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2940066 clqs
+   (54.3s) running MILP presolver
+   (64.1s) MILP presolver (2 rounds): 0 aggregations, 195 fixings, 0 bound changes
+(round 3, exhaustive) 25989 del vars, 62494 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2937506 clqs
+(round 4, exhaustive) 25992 del vars, 62497 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 2937503 upgd conss, 0 impls, 2937503 clqs
+   (135.5s) probing: 51/974008 (0.0%) - 0 fixings, 0 aggregations, 0 implications, 0 bound changes
+   (135.5s) probing aborted: 50/50 successive totally useless probings
+   (141.0s) symmetry computation started: requiring (bin +, int -, cont +), (fixed: bin -, int +, cont -)
+   (148.9s) no symmetry present
+presolving (5 rounds: 5 fast, 3 medium, 3 exhaustive):
+ 25992 deleted vars, 62497 deleted constraints, 0 added constraints, 0 tightened bounds, 0 added holes, 0 changed sides, 0 changed coefficients
+ 0 implications, 2937503 cliques
+presolved problem has 974008 variables (974008 bin, 0 int, 0 impl, 0 cont) and 2937503 constraints
+2937503 constraints of type <setppc>
+Presolving Time: 141.03
+
+ time | node  | left  |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr|  dualbound   | primalbound  |  gap   | compl. 
+t 156s|     1 |     0 |     0 |     - | trivial|   0 | 974k|2937k|   0 |   0 |  0 |   0 |   0 | 4.952963e+05 | 9.025819e+03 |5387.55%| unknown
+p 368m|     1 |     0 |     0 |     - |   locks|   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 4.952963e+05 | 1.858086e+05 | 166.56%| unknown
+i 384m|     1 |     0 |  1126 |     - |  oneopt|   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 4.952963e+05 | 1.884205e+05 | 162.87%| unknown
+  999m|     1 |     0 |  1229k|     - |  9844M |   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 4.952963e+05 | 1.884205e+05 | 162.87%| unknown
+(node 1) LP solver hit time limit in LP 2 -- using pseudo solution instead
+
+SCIP Status        : solving was interrupted [time limit reached]
+Solving Time (sec) : 59948.10
+Solving Nodes      : 1
+Primal Bound       : +1.88420496002484e+05 (5 solutions)
+Dual Bound         : +4.95296290213063e+05
+Gap                : 162.87 %
+0.0
+[60134.32302713394]
+[188420.496002484]

Result/MVC/2-h1-S-MVC2-100.log

@@ -0,0 +1,36 @@
+nohup: ignoring input
+feasible solution found by trivial heuristic after 68.6 seconds, objective value 4.996566e+05
+presolving:
+(round 1, fast)       17431 del vars, 15004 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2984987 clqs
+(round 2, fast)       25267 del vars, 59925 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2940066 clqs
+   (185.8s) running MILP presolver
+   (218.2s) MILP presolver (2 rounds): 0 aggregations, 195 fixings, 0 bound changes
+(round 3, exhaustive) 25989 del vars, 62494 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2937506 clqs
+(round 4, exhaustive) 25992 del vars, 62497 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 2937503 upgd conss, 0 impls, 2937503 clqs
+   (545.8s) probing: 51/974008 (0.0%) - 0 fixings, 0 aggregations, 0 implications, 0 bound changes
+   (545.8s) probing aborted: 50/50 successive totally useless probings
+   (579.7s) symmetry computation started: requiring (bin +, int -, cont +), (fixed: bin -, int +, cont -)
+   (621.0s) no symmetry present
+presolving (5 rounds: 5 fast, 3 medium, 3 exhaustive):
+ 25992 deleted vars, 62497 deleted constraints, 0 added constraints, 0 tightened bounds, 0 added holes, 0 changed sides, 0 changed coefficients
+ 0 implications, 2937503 cliques
+presolved problem has 974008 variables (974008 bin, 0 int, 0 impl, 0 cont) and 2937503 constraints
+2937503 constraints of type <setppc>
+Presolving Time: 606.48
+
+ time | node  | left  |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr|  dualbound   | primalbound  |  gap   | compl. 
+t 675s|     1 |     0 |     0 |     - | trivial|   0 | 974k|2937k|   0 |   0 |  0 |   0 |   0 | 5.174453e+03 | 4.914449e+05 |9397.52%| unknown
+p 404m|     1 |     0 |     0 |     - |   locks|   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 5.174453e+03 | 3.146621e+05 |5981.07%| unknown
+i 423m|     1 |     0 |  1126 |     - |  oneopt|   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 5.174453e+03 | 3.120502e+05 |5930.59%| unknown
+  998m|     1 |     0 |  1274k|     - |    10G |   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 5.174453e+03 | 3.120502e+05 |5930.59%| unknown
+(node 1) LP solver hit time limit in LP 2 -- using pseudo solution instead
+
+SCIP Status        : solving was interrupted [time limit reached]
+Solving Time (sec) : 59892.56
+Solving Nodes      : 1
+Primal Bound       : +3.12050247079965e+05 (5 solutions)
+Dual Bound         : +5.17445286937992e+03
+Gap                : 5930.59 %
+0.0
+[60219.669788360596]
+[312050.24707996455]

Result/SC/2-h1-S-SC2-100.log

@@ -0,0 +1,82 @@
+nohup: ignoring input
+feasible solution found by trivial heuristic after 26.5 seconds, objective value 3.983191e+02
+presolving:
+(round 1, fast)       17431 del vars, 15004 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2984987 clqs
+(round 2, fast)       25267 del vars, 59925 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2940066 clqs
+   (77.7s) running MILP presolver
+   (90.4s) MILP presolver (2 rounds): 0 aggregations, 195 fixings, 0 bound changes
+(round 3, exhaustive) 25989 del vars, 62494 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 2937506 clqs
+(round 4, exhaustive) 25992 del vars, 62497 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 2937503 upgd conss, 0 impls, 2937503 clqs
+   (190.3s) probing: 51/974008 (0.0%) - 0 fixings, 0 aggregations, 0 implications, 0 bound changes
+   (190.3s) probing aborted: 50/50 successive totally useless probings
+   (199.5s) symmetry computation started: requiring (bin +, int -, cont +), (fixed: bin -, int +, cont -)
+   (214.0s) no symmetry present
+presolving (5 rounds: 5 fast, 3 medium, 3 exhaustive):
+ 25992 deleted vars, 62497 deleted constraints, 0 added constraints, 0 tightened bounds, 0 added holes, 0 changed sides, 0 changed coefficients
+ 0 implications, 2937503 cliques
+presolved problem has 974008 variables (974008 bin, 0 int, 0 impl, 0 cont) and 2937503 constraints
+2937503 constraints of type <setppc>
+Presolving Time: 205.12
+
+ time | node  | left  |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr|  dualbound   | primalbound  |  gap   | compl. 
+t 228s|     1 |     0 |     0 |     - | trivial|   0 | 974k|2937k|   0 |   0 |  0 |   0 |   0 | 4.952963e+05 | 9.025819e+03 |5387.55%| unknown
+p 468m|     1 |     0 |     0 |     - |   locks|   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 4.952963e+05 | 1.858086e+05 | 166.56%| unknown
+i 489m|     1 |     0 |  1126 |     - |  oneopt|   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 4.952963e+05 | 1.884205e+05 | 162.87%| unknown
+  999m|     1 |     0 |  1224k|     - |  9844M |   0 | 974k|2937k|2937k|   0 |  0 |   0 |   0 | 4.952963e+05 | 1.884205e+05 | 162.87%| unknown
+(node 1) LP solver hit time limit in LP 2 -- using pseudo solution instead
+
+SCIP Status        : solving was interrupted [time limit reached]
+Solving Time (sec) : 59936.37
+Solving Nodes      : 1
+Primal Bound       : +1.88420496002484e+05 (5 solutions)
+Dual Bound         : +4.95296290213063e+05
+Gap                : 162.87 %
+0.0
+[60132.21912121773]
+[188420.496002484]
+nohup: ignoring input
+nohup: ignoring input
+No problem file!
+Traceback (most recent call last):
+  File "/home/yehuigen/GNN_GBDT/08-SC2-SCIP.py", line 481, in <module>
+    optimize(**vars(args))
+  File "/home/yehuigen/GNN_GBDT/08-SC2-SCIP.py", line 238, in optimize
+    with open('./example-SC-h/node1.pickle', "rb") as f:
+FileNotFoundError: [Errno 2] No such file or directory: './example-SC-h/node1.pickle'
+nohup: ignoring input
+feasible solution found by trivial heuristic after 23.7 seconds, objective value 9.876481e+05
+presolving:
+(round 1, fast)       36806 del vars, 0 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 0 upgd conss, 0 impls, 0 clqs
+   (61.1s) running MILP presolver
+   (69.1s) MILP presolver found nothing
+(round 2, exhaustive) 36806 del vars, 0 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 2000000 upgd conss, 0 impls, 0 clqs
+(round 3, fast)       132962 del vars, 1 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 0 chg coeffs, 2000000 upgd conss, 0 impls, 0 clqs
+(round 4, fast)       134745 del vars, 1 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 96152 chg coeffs, 2000000 upgd conss, 0 impls, 37 clqs
+(round 5, exhaustive) 138451 del vars, 57 del conss, 0 add conss, 0 chg bounds, 0 chg sides, 98058 chg coeffs, 2000000 upgd conss, 0 impls, 1931 clqs
+   (164.1s) probing: 51/1861533 (0.0%) - 0 fixings, 0 aggregations, 0 implications, 0 bound changes
+   (164.1s) probing aborted: 50/50 successive totally useless probings
+   (171.4s) symmetry computation started: requiring (bin +, int -, cont +), (fixed: bin -, int +, cont -)
+   (184.4s) no symmetry present
+presolving (6 rounds: 6 fast, 3 medium, 3 exhaustive):
+ 138479 deleted vars, 57 deleted constraints, 0 added constraints, 0 tightened bounds, 0 added holes, 0 changed sides, 101639 changed coefficients
+ 0 implications, 2028 cliques
+presolved problem has 1861533 variables (1861533 bin, 0 int, 0 impl, 0 cont) and 1999943 constraints
+1999943 constraints of type <logicor>
+Presolving Time: 180.11
+
+ time | node  | left  |LP iter|LP it/n|mem/heur|mdpt |vars |cons |rows |cuts |sepa|confs|strbr|  dualbound   | primalbound  |  gap   | compl. 
+t 202s|     1 |     0 |     0 |     - | trivial|   0 |1861k|1999k|   0 |   0 |  0 |   0 |   0 | 2.666364e+00 | 9.193624e+05 |  Large | unknown
+p7332s|     1 |     0 |     0 |     - |   locks|   0 |1861k|1999k|1999k|   0 |  0 |   0 |   0 | 2.666364e+00 | 2.535118e+05 |  Large | unknown
+i7338s|     1 |     0 |     0 |     - |  oneopt|   0 |1861k|1999k|1999k|   0 |  0 |   0 |   0 | 2.666364e+00 | 2.521799e+05 |  Large | unknown
+  999m|     1 |     0 |753936 |     - |    10G |   0 |1861k|1999k|1999k|   0 |  0 |   0 |   0 | 2.666364e+00 | 2.521799e+05 |  Large | unknown
+(node 1) LP solver hit time limit in LP 1 -- using pseudo solution instead
+
+SCIP Status        : solving was interrupted [time limit reached]
+Solving Time (sec) : 59942.29
+Solving Nodes      : 1
+Primal Bound       : +2.52179898788591e+05 (5 solutions)
+Dual Bound         : +2.66636350119586e+00
+Gap                : 9457721.44 %
+0.0
+[60210.22903895378]
+[252179.89878859147]