ml4co-kit 0.2.1__tar.gz → 0.2.2__tar.gz

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ml4co-kit
-Version: 0.2.1
+Version: 0.2.2
 Summary: ml4co-kit provides convenient dataset generators for the combinatorial optimization problem
 Home-page: https://github.com/Thinklab-SJTU/ML4CO-Kit
 Author: SJTU-ReThinkLab
@@ -126,7 +126,7 @@ tsp_data_lkh = TSPDataGenerator(
     num_threads=8,
     nodes_num=50,
     data_type="uniform",
-    solver="lkh",
+    solver="LKH",
     train_samples_num=16,
     val_samples_num=16,
     test_samples_num=16,

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/README.md

@@ -101,7 +101,7 @@ tsp_data_lkh = TSPDataGenerator(
     num_threads=8,
     nodes_num=50,
     data_type="uniform",
-    solver="lkh",
+    solver="LKH",
     train_samples_num=16,
     val_samples_num=16,
     test_samples_num=16,

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/__init__.py

@@ -57,15 +57,14 @@ from .solver import (
 #                    Utils Function                   #
 #######################################################
 from .utils import download, compress_folder, extract_archive, _get_md5
-from .utils import iterative_execution_for_file, iterative_execution
+from .utils import iterative_execution_for_file, iterative_execution, Timer
 from .utils import np_dense_to_sparse, np_sparse_to_dense, GraphData, tsplib95
 from .utils import MISGraphData, MVCGraphData, MClGraphData, MCutGraphData
 from .utils import sat_to_mis_graph, cnf_folder_to_gpickle_folder, cnf_to_gpickle
 
 #######################################################
-#                  Extension Function                 #
+#           Extension Function (matplotlib)           #
 #######################################################
-# expand - matplotlib
 found_matplotlib = importlib.util.find_spec("matplotlib")
 if found_matplotlib is not None:
     from .draw.cvrp import draw_cvrp_problem, draw_cvrp_solution
@@ -75,7 +74,9 @@ if found_matplotlib is not None:
     from .draw.mvc import draw_mvc_problem, draw_mvc_solution
     from .draw.tsp import draw_tsp_problem, draw_tsp_solution
 
-# expand - pytorch_lightning
+#######################################################
+#        Extension Function (pytorch_lightning)       #
+#######################################################
 found_pytorch_lightning = importlib.util.find_spec("pytorch_lightning")
 if found_pytorch_lightning is not None:
     from .learning.env import BaseEnv
@@ -86,5 +87,5 @@ if found_pytorch_lightning is not None:
     from .learning.utils import points_to_distmat, sparse_points
 
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 __author__ = "SJTU-ReThinkLab"

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/generator/atsp_data.py

@@ -7,7 +7,6 @@ import numpy as np
 import pathlib
 from tqdm import tqdm
 from typing import Union
-from multiprocessing import Pool
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
 from ml4co_kit.solver import ATSPSolver, ATSPLKHSolver
 
@@ -18,6 +17,7 @@ warnings.filterwarnings("ignore")
 class ATSPDataGenerator:
     def __init__(
         self,
+        only_instance_for_us: bool = False,
         num_threads: int = 1,
         nodes_num: int = 55,
         data_type: str = "sat",
@@ -70,12 +70,17 @@ class ATSPDataGenerator:
         if self.data_type == "sat":
             self.nodes_num = 2 * sat_clauses_nums * sat_vars_nums + sat_clauses_nums
         
-        # check the input variables
-        self.sample_types = ["train", "val", "test"]
-        self.check_num_threads()
+        # only instance for us
+        self.only_instance_for_us = only_instance_for_us
         self.check_data_type()
-        self.check_solver()
-        self.get_filename()
+        
+        # generate and solve
+        if only_instance_for_us == False:
+            # check the input variables
+            self.sample_types = ["train", "val", "test"]
+            self.check_num_threads()    
+            self.check_solver()
+            self.get_filename()
 
     def check_num_threads(self):
         self.samples_num = 0
@@ -177,6 +182,12 @@ class ATSPDataGenerator:
         if not os.path.exists(self.save_path):
             os.makedirs(self.save_path)
 
+    def generate_only_instance_for_us(self, samples: int) -> np.ndarray:
+        self.num_threads = samples
+        dists = self.generate_func()[0]
+        self.solver.from_data(dists=dists)
+        return self.solver.dists
+
     def generate(self):
         start_time = time.time()
         for _ in tqdm(

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/generator/cvrp_data.py

@@ -5,8 +5,7 @@ import shutil
 import numpy as np
 import pathlib
 from tqdm import tqdm
-from typing import Union
-from multiprocessing import Pool
+from typing import Union, Sequence
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
 from ml4co_kit.solver import (
     CVRPSolver, CVRPPyVRPSolver, CVRPLKHSolver, CVRPHGSSolver
@@ -16,6 +15,7 @@ from ml4co_kit.solver import (
 class CVRPDataGenerator:
     def __init__(
         self,
+        only_instance_for_us: bool = False,
         num_threads: int = 1,
         nodes_num: int = 50,
         data_type: str = "uniform",
@@ -73,21 +73,29 @@ class CVRPDataGenerator:
         self.test_samples_num = test_samples_num
         self.save_path = save_path
         self.filename = filename
+        
         # special for demand and capacity
         self.min_demand = min_demand
         self.max_demand = max_demand
         self.min_capacity = min_capacity
         self.max_capacity = max_capacity
+        
         # special for gaussian
         self.gaussian_mean_x = gaussian_mean_x
         self.gaussian_mean_y = gaussian_mean_y
         self.gaussian_std = gaussian_std
-        # check the input variables
-        self.sample_types = ["train", "val", "test"]
-        self.check_num_threads()
+        
+        # only instance for us
+        self.only_instance_for_us = only_instance_for_us
         self.check_data_type()
-        self.check_solver()
-        self.get_filename()
+        
+        # generate and solve
+        if only_instance_for_us == False:
+            # check the input variables
+            self.sample_types = ["train", "val", "test"]
+            self.check_num_threads()    
+            self.check_solver()
+            self.get_filename()
 
     def check_num_threads(self):
         self.samples_num = 0
@@ -195,6 +203,22 @@ class CVRPDataGenerator:
         if not os.path.exists(self.save_path):
             os.makedirs(self.save_path)
 
+    def generate_only_instance_for_us(self, samples: int) -> Sequence[np.ndarray]:
+        self.num_threads = samples
+        batch_depots_coord, batch_nodes_coord = self.generate_func()
+        batch_demands = self.generate_demands()
+        batch_capacities = self.generate_capacities()
+        self.solver.from_data(
+            depots=batch_depots_coord,
+            points=batch_nodes_coord,
+            demands=batch_demands,
+            capacities=batch_capacities
+        )
+        return (
+            self.solver.depots, self.solver.points, 
+            self.solver.demands, self.solver.capacities
+        )
+
     def generate(self):
         start_time = time.time()
         for _ in tqdm(

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/generator/mcl_data.py

@@ -6,7 +6,7 @@ import random
 import numpy as np
 import networkx as nx
 from tqdm import tqdm
-from typing import Union
+from typing import Union, List
 from ml4co_kit.utils.graph.mcl import MClGraphData
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
 from ml4co_kit.solver import MClSolver, MClGurobiSolver
@@ -15,6 +15,7 @@ from ml4co_kit.solver import MClSolver, MClGurobiSolver
 class MClDataGenerator:
     def __init__(
         self,
+        only_instance_for_us: bool = False,
         num_threads: int = 1,
         nodes_num_min: int = 700,
         nodes_num_max: int = 800,
@@ -92,13 +93,18 @@ class MClDataGenerator:
         self.ws_prob = ws_prob
         self.ws_ring_neighbors = ws_ring_neighbors
 
-        # check the input variables
-        self.sample_types = ["train", "val", "test"]
-        self.check_num_threads()
+        # only instance for us
+        self.only_instance_for_us = only_instance_for_us
         self.check_data_type()
-        self.check_solver()
-        self.check_save_path()
-        self.get_filename()
+        
+        # generate and solve
+        if only_instance_for_us == False:
+            # check the input variables
+            self.sample_types = ["train", "val", "test"]
+            self.check_num_threads()    
+            self.check_solver()
+            self.check_save_path()
+            self.get_filename()
 
     def check_num_threads(self):
         self.samples_num = 0
@@ -187,6 +193,11 @@ class MClDataGenerator:
     def random_weight(self, n, mu=1, sigma=0.1):
         return np.around(np.random.normal(mu, sigma, n)).astype(int).clip(min=0)
 
+    def generate_only_instance_for_us(self, samples: int) -> List[MClGraphData]:
+        nx_graphs = [self.generate_func() for _ in range(samples)]
+        self.solver.from_nx_graph(nx_graphs=nx_graphs)
+        return self.solver.graph_data
+    
     def generate(self):
         start_time = time.time()
         for _ in tqdm(

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/generator/mcut_data.py

@@ -1,12 +1,11 @@
 import os
 import time
-import pickle
 import pathlib
 import random
 import numpy as np
 import networkx as nx
 from tqdm import tqdm
-from typing import Union
+from typing import Union, List
 from ml4co_kit.utils.graph.mcut import MCutGraphData
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
 from ml4co_kit.solver import MCutSolver, MCutGurobiSolver
@@ -15,6 +14,7 @@ from ml4co_kit.solver import MCutSolver, MCutGurobiSolver
 class MCutDataGenerator:
     def __init__(
         self,
+        only_instance_for_us: bool = False,
         num_threads: int = 1,
         nodes_num_min: int = 700,
         nodes_num_max: int = 800,
@@ -92,13 +92,18 @@ class MCutDataGenerator:
         self.ws_prob = ws_prob
         self.ws_ring_neighbors = ws_ring_neighbors
 
-        # check the input variables
-        self.sample_types = ["train", "val", "test"]
-        self.check_num_threads()
+        # only instance for us
+        self.only_instance_for_us = only_instance_for_us
         self.check_data_type()
-        self.check_solver()
-        self.check_save_path()
-        self.get_filename()
+        
+        # generate and solve
+        if only_instance_for_us == False:
+            # check the input variables
+            self.sample_types = ["train", "val", "test"]
+            self.check_num_threads()    
+            self.check_solver()
+            self.check_save_path()
+            self.get_filename()
 
     def check_num_threads(self):
         self.samples_num = 0
@@ -195,6 +200,11 @@ class MCutDataGenerator:
     def random_weight(self, n, mu=1, sigma=0.1):
         return np.around(np.random.normal(mu, sigma, n)).astype(int).clip(min=0)
 
+    def generate_only_instance_for_us(self, samples: int) -> List[MCutGraphData]:
+        nx_graphs = [self.generate_func() for _ in range(samples)]
+        self.solver.from_nx_graph(nx_graphs=nx_graphs)
+        return self.solver.graph_data
+    
     def generate(self):
         start_time = time.time()
         for _ in tqdm(

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/generator/mis_data.py

@@ -6,7 +6,7 @@ import random
 import numpy as np
 import networkx as nx
 from tqdm import tqdm
-from typing import Union
+from typing import Union, List
 from ml4co_kit.utils.graph.mis import MISGraphData
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
 from ml4co_kit.solver import MISSolver, KaMISSolver, MISGurobiSolver
@@ -15,6 +15,7 @@ from ml4co_kit.solver import MISSolver, KaMISSolver, MISGurobiSolver
 class MISDataGenerator:
     def __init__(
         self,
+        only_instance_for_us: bool = False,
         num_threads: int = 1,
         nodes_num_min: int = 700,
         nodes_num_max: int = 800,
@@ -92,14 +93,19 @@ class MISDataGenerator:
         self.ws_prob = ws_prob
         self.ws_ring_neighbors = ws_ring_neighbors
 
-        # check the input variables
-        self.sample_types = ["train", "val", "test"]
-        self.check_num_threads()
+        # only instance for us
+        self.only_instance_for_us = only_instance_for_us
         self.check_data_type()
-        self.check_solver()
-        self.check_save_path()
-        self.get_filename()
-
+        
+        # generate and solve
+        if only_instance_for_us == False:
+            # check the input variables
+            self.sample_types = ["train", "val", "test"]
+            self.check_num_threads()    
+            self.check_solver()
+            self.check_save_path()
+            self.get_filename()
+            
     def check_num_threads(self):
         self.samples_num = 0
         for sample_type in self.sample_types:
@@ -194,6 +200,11 @@ class MISDataGenerator:
     def random_weight(self, n, mu=1, sigma=0.1):
         return np.around(np.random.normal(mu, sigma, n)).astype(int).clip(min=0)
 
+    def generate_only_instance_for_us(self, samples: int) -> List[MISGraphData]:
+        nx_graphs = [self.generate_func() for _ in range(samples)]
+        self.solver.from_nx_graph(nx_graphs=nx_graphs)
+        return self.solver.graph_data
+    
     def generate(self):
         if self.solver_type == SOLVER_TYPE.KAMIS:
             # check

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/generator/mvc_data.py

@@ -1,12 +1,11 @@
 import os
 import time
-import pickle
 import pathlib
 import random
 import numpy as np
 import networkx as nx
 from tqdm import tqdm
-from typing import Union
+from typing import Union, List
 from ml4co_kit.utils.graph.mvc import MVCGraphData
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
 from ml4co_kit.solver import MVCSolver, MVCGurobiSolver
@@ -15,6 +14,7 @@ from ml4co_kit.solver import MVCSolver, MVCGurobiSolver
 class MVCDataGenerator:
     def __init__(
         self,
+        only_instance_for_us: bool = False,
         num_threads: int = 1,
         nodes_num_min: int = 700,
         nodes_num_max: int = 800,
@@ -92,13 +92,18 @@ class MVCDataGenerator:
         self.ws_prob = ws_prob
         self.ws_ring_neighbors = ws_ring_neighbors
 
-        # check the input variables
-        self.sample_types = ["train", "val", "test"]
-        self.check_num_threads()
+        # only instance for us
+        self.only_instance_for_us = only_instance_for_us
         self.check_data_type()
-        self.check_solver()
-        self.check_save_path()
-        self.get_filename()
+        
+        # generate and solve
+        if only_instance_for_us == False:
+            # check the input variables
+            self.sample_types = ["train", "val", "test"]
+            self.check_num_threads()    
+            self.check_solver()
+            self.check_save_path()
+            self.get_filename()
 
     def check_num_threads(self):
         self.samples_num = 0
@@ -187,6 +192,11 @@ class MVCDataGenerator:
     def random_weight(self, n, mu=1, sigma=0.1):
         return np.around(np.random.normal(mu, sigma, n)).astype(int).clip(min=0)
 
+    def generate_only_instance_for_us(self, samples: int) -> List[MVCGraphData]:
+        nx_graphs = [self.generate_func() for _ in range(samples)]
+        self.solver.from_nx_graph(nx_graphs=nx_graphs)
+        return self.solver.graph_data
+
     def generate(self):
         start_time = time.time()
         for _ in tqdm(

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/generator/tsp_data.py

@@ -22,6 +22,7 @@ warnings.filterwarnings("ignore")
 class TSPDataGenerator:
     def __init__(
         self,
+        only_instance_for_us: bool = False,
         num_threads: int = 1,
         nodes_num: int = 50,
         data_type: str = "uniform",
@@ -96,13 +97,18 @@ class TSPDataGenerator:
         self.regret_save_path = regret_save_path
         self.regret_solver = regret_solver
         
-        # check the input variables
-        self.sample_types = ["train", "val", "test"]
-        self.check_num_threads()
+        # only instance for us
+        self.only_instance_for_us = only_instance_for_us
         self.check_data_type()
-        self.check_solver()
-        self.get_filename()
-        self.check_regret()
+        
+        # generate and solve
+        if only_instance_for_us == False:
+            # check the input variables
+            self.sample_types = ["train", "val", "test"]
+            self.check_num_threads()    
+            self.check_solver()
+            self.get_filename()
+            self.check_regret()
 
     def check_num_threads(self):
         self.samples_num = 0
@@ -239,6 +245,12 @@ class TSPDataGenerator:
         if not os.path.exists(self.regret_save_path):
             os.makedirs(self.regret_save_path)
 
+    def generate_only_instance_for_us(self, samples: int) -> np.ndarray:
+        self.num_threads = samples
+        points = self.generate_func()
+        self.solver.from_data(points=points)
+        return self.solver.points
+
     def generate(self):
         start_time = time.time()
         cnt = 0

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/solver/atsp/lkh.py

@@ -1,5 +1,4 @@
 import os
-import time
 import uuid
 import pathlib
 import numpy as np
@@ -8,7 +7,7 @@ from multiprocessing import Pool
 from subprocess import check_call
 from ml4co_kit.solver.atsp.base import ATSPSolver
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
-from ml4co_kit.utils.time_utils import iterative_execution
+from ml4co_kit.utils.time_utils import iterative_execution, Timer
 
 
 class ATSPLKHSolver(ATSPSolver):
@@ -100,7 +99,8 @@ class ATSPLKHSolver(ATSPSolver):
         # prepare
         self.from_data(dists=dists, normalize=normalize)
         self.tmp_solver = ATSPSolver(scale=self.scale)
-        start_time = time.time()
+        timer = Timer(apply=show_time)
+        timer.start()
 
         # solve
         tours = list()
@@ -126,14 +126,13 @@ class ATSPLKHSolver(ATSPSolver):
                     tours.append(tour)
         
         # format
-        tours = np.array(tours)
-        if tours.ndim == 2 and tours.shape[0] == 1:
-            tours = tours[0]
         self.from_data(tours=tours, ref=False)
-        end_time = time.time()
-        if show_time:
-            print(f"Use Time: {end_time - start_time}")
-        return tours
+        
+        # show time
+        timer.end()
+        timer.show_time()
+        
+        return self.tours
     
     def __str__(self) -> str:
         return "ATSPLKHSolver"

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/solver/cvrp/base.py

@@ -264,7 +264,7 @@ class CVRPSolver(SolverBase):
             points_list.append([client.x, client.y])
             demands_list.append(client.demand if CP38 else client.delivery)
         points = np.array(points_list)
-        demands = np.array(demands_list)
+        demands = np.array(demands_list).reshape(-1)
         
         # capacity
         capacity = _vehicle_types.capacity
@@ -650,7 +650,7 @@ class CVRPSolver(SolverBase):
         # demands and capacities need be int
         demands = demands.astype(np.int32)
         capacities = capacities.astype(np.int32)
-        
+
         # .vrp files
         if vrp_save_dir is not None:
             # filename

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/solver/cvrp/hgs.py

@@ -1,12 +1,11 @@
 import os
 import uuid
-import time
 import numpy as np
 from typing import Union
 from multiprocessing import Pool
 from ml4co_kit.solver.cvrp.base import CVRPSolver
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
-from ml4co_kit.utils.time_utils import iterative_execution
+from ml4co_kit.utils.time_utils import iterative_execution, Timer
 from ml4co_kit.solver.cvrp.c_hgs import cvrp_hgs_solver, HGS_TMP_PATH
 
 
@@ -87,9 +86,8 @@ class CVRPHGSSolver(CVRPSolver):
             depots=depots, points=points, demands=demands,
             capacities=capacities, norm=norm, normalize=normalize
         )
-        
-        # start time
-        start_time = time.time()
+        timer = Timer(apply=show_time)
+        timer.start()
 
         # solve
         tours = list()
@@ -127,9 +125,11 @@ class CVRPHGSSolver(CVRPSolver):
 
         # format
         self.from_data(tours=tours, ref=False)
-        end_time = time.time()
-        if show_time:
-            print(f"Use Time: {end_time - start_time}")
+        
+        # show time
+        timer.end()
+        timer.show_time()
+
         return self.tours
     
     def __str__(self) -> str:

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/solver/cvrp/lkh.py

@@ -1,5 +1,4 @@
 import os
-import time
 import uuid
 import pathlib
 import numpy as np
@@ -9,7 +8,7 @@ from subprocess import check_call
 from ml4co_kit.utils import tsplib95
 from ml4co_kit.solver.cvrp.base import CVRPSolver
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
-from ml4co_kit.utils.time_utils import iterative_execution
+from ml4co_kit.utils.time_utils import iterative_execution, Timer
 
 
 class CVRPLKHSolver(CVRPSolver):
@@ -145,9 +144,8 @@ class CVRPLKHSolver(CVRPSolver):
             capacities=capacities, norm=norm, normalize=normalize
         )
         self.tmp_solver = CVRPSolver()
-        
-        # start time
-        start_time = time.time()
+        timer = Timer(apply=show_time)
+        timer.start()
         
         # solve
         tours = list()
@@ -187,9 +185,11 @@ class CVRPLKHSolver(CVRPSolver):
 
         # format
         self.from_data(tours=tours, ref=False)
-        end_time = time.time()
-        if show_time:
-            print(f"Use Time: {end_time - start_time}")
+        
+        # show time
+        timer.end()
+        timer.show_time()
+        
         return self.tours    
 
     def __str__(self) -> str:

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/solver/cvrp/pyvrp.py

@@ -7,7 +7,7 @@ from pyvrp import Model
 from pyvrp.stop import MaxRuntime
 from ml4co_kit.solver.cvrp.base import CVRPSolver
 from ml4co_kit.utils.type_utils import SOLVER_TYPE
-from ml4co_kit.utils.time_utils import iterative_execution
+from ml4co_kit.utils.time_utils import iterative_execution, Timer
 
 
 if sys.version_info.major == 3 and sys.version_info.minor == 8:
@@ -54,9 +54,9 @@ class CVRPPyVRPSolver(CVRPSolver):
         cvrp_model.add_vehicle_type(capacity=capacity, num_available=max_num_available)
         clients = [
             cvrp_model.add_client(
-                self.round_func(nodes_coord[idx][0]), 
-                self.round_func(nodes_coord[idx][1]), 
-                self.round_func(demands[idx])
+                int(self.round_func(nodes_coord[idx][0])), 
+                int(self.round_func(nodes_coord[idx][1])), 
+                int(self.round_func(demands[idx]))
             ) for idx in range(0, len(nodes_coord))
         ]
         locations = [depot] + clients
@@ -91,9 +91,8 @@ class CVRPPyVRPSolver(CVRPSolver):
             capacities=capacities, norm=norm, normalize=normalize
         )
         self.round_func = self.get_round_func(round_func)
-
-        # start time
-        start_time = time.time()
+        timer = Timer(apply=show_time)
+        timer.start()
 
         # solve
         tours = list()
@@ -133,9 +132,11 @@ class CVRPPyVRPSolver(CVRPSolver):
 
         # format
         self.from_data(tours=tours)
-        end_time = time.time()
-        if show_time:
-            print(f"Use Time: {end_time - start_time}")
+        
+        # show time
+        timer.end()
+        timer.show_time()
+
         return self.tours
     
     def __str__(self) -> str:

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/solver/mcl/gurobi.py

@@ -23,7 +23,7 @@ class MClGurobiSolver(MClSolver):
         graph_data: List[MClGraphData] = None,
         num_threads: int = 1,
         show_time: bool = False
-    ) -> np.ndarray:
+    ) -> List[MClGraphData]:
         # preparation
         if graph_data is not None:
             self.graph_data = graph_data

{ml4co-kit-0.2.1 → ml4co-kit-0.2.2}/ml4co_kit/solver/mcut/gurobi.py

@@ -22,7 +22,7 @@ class MCutGurobiSolver(MCutSolver):
         graph_data: List[MCutGraphData] = None,
         num_threads: int = 1,
         show_time: bool = False
-    ) -> np.ndarray:
+    ) -> List[MCutGraphData]:
         # preparation
         if graph_data is not None:
             self.graph_data = graph_data