Method for generating training data and method for training combinatorial optimization model by using same

Abstract

The present invention relates to a method for generating training data and a method for training a combinatorial optimization model by using same. More particularly, the present invention relates to a method for generating training data for learning a Steiner tree problem (STP), and training a combinatorial optimization model by using the generated training data.

Description

Method for generating training data and training a combinatorial optimization model using the same

[0001] The present invention relates to a method for generating training data and a method for training a combinatorial optimization model using the same. More specifically, the present invention relates to a method for generating training data for learning the Steiner Tree Problem (STP) and training a combinatorial optimization model using the generated training data.

[0002] The Steiner Tree Problem (STP) is an NP-hard combinatorial optimization problem with diverse applications. More specifically, the Steiner Tree Problem is a key area of ​​combinatorial optimization (CO), and its goal is to find a minimum-cost tree that includes all terminal nodes in a graph.

[0003] Solving these Steiner tree problems is essential for optimizing connections between various objects or locations while minimizing costs and resources. For example, the Steiner tree problem is utilized in various industrial fields, including printed circuit board (PCB) design, circuit design, network design, facility layout, and image processing.

[0004] Meanwhile, in recent research related to artificial intelligence (especially neural combinatorial optimization (NCO)), research on problems such as the traveling salesman problem (TSP), the capacitated vehicle routing problem (CVRP), and the maximum independent set (MIS) is actively being conducted.

[0005] However, learning-based research on the Steiner tree problem has been relatively neglected compared to research in other combinatorial optimization fields. This is due to the lack of large-scale data sets required for supervised learning (SL)-based neural network combinatorial optimization algorithms, or the lack of environments (e.g., Markov decision process (MDP) environments) required for reinforcement learning (RL)-based neural network combinatorial optimization algorithms.

[0006] Furthermore, there is still a need for methods to solve the Steiner tree problem, as small changes in the solution space can have a large impact on the overall optimization result.

[0007] The present invention provides a method for generating training data for learning the Steiner Tree Problem (STP).

[0008] More specifically, the present invention provides a method capable of generating a large-scale data set for learning and evaluating the Steiner tree problem.

[0009] Furthermore, the present invention is intended to provide a large-scale, high-quality data set that can be universally utilized in various learning environments.

[0010] More specifically, the present invention is intended to provide a large-scale data set and environment capable of solving the Steiner tree problem.

[0011] Furthermore, the present invention is intended to provide a combinatorial optimization model that can be universally utilized in various industries and services.

[0012] More specifically, the present invention provides a learning method of a combinatorial optimization model capable of solving a Steiner tree problem and generating an optimal solution.

[0013] In order to solve the problem discussed above, a method for generating learning data for learning a Steiner Tree Problem according to the present invention may include a step of generating a graph based on a plurality of graph types and parameters until nodes of the graph are connected by edges, a step of adding the generated graph to a data set to generate an instance for the Steiner Tree Problem, a step of calculating an optimal solution for the instance using a specific solver, and a step of constructing a data set including the instance and the optimal solution.

[0014] In an embodiment, the step of generating the graph may repeat the generation of the graph so that, if there are separated nodes, the nodes are connected in all graphs.

[0015] In an embodiment, the graph may be generated based on the number of instances.

[0016] In an embodiment, the node in the graph is selected as a terminal according to a preset probability, and the cost of the edge can be assigned as a random integer from a truncated Gaussian distribution.

[0017] In an embodiment, the costs of the graph, the terminal and the edge may be grouped in the instance and included in the data set.

[0018] In an embodiment, the method of connecting the edges may vary depending on the plurality of graph types.

[0019] In an embodiment, a graph corresponding to at least one of the plurality of graph types may be generated by sampling an edge creation probability from a uniform distribution, sampling a degree of the graph, or sampling an average node degree.

[0020] In an embodiment, the plurality of graph types include a type different from at least one of the above, and the graph of the other type can be generated with the cost of the edge fixed.

[0021] A learning method of a combination optimization model (Neural Combinatorial Optimization) for calculating a Steiner Tree Problem according to the present invention may include a step of generating a graph based on a plurality of graph types and parameters until nodes of the graph are connected by edges, a step of adding the generated graph to a data set to generate an instance for the Steiner Tree Problem, a step of calculating an optimal solution for the instance using a specific solver, and a step of constructing a data set including the instance and the optimal solution, and a step of training at least one of the combinational optimization models using the constructed data set.

[0022] In an embodiment, the step of generating the graph may repeat the generation of the graph so that, if there are separated nodes, the nodes are connected in all graphs.

[0023] In an embodiment, the graph may be generated based on the number of instances.

[0024] In an embodiment, the node in the graph is selected as a terminal according to a preset probability, and the cost of the edge can be assigned as a random integer from a truncated Gaussian distribution.

[0025] In an embodiment, the costs of the graph, the terminal and the edge may be grouped in the instance and included in the data set.

[0026] In an embodiment, the combinatorial optimization model may include at least one of a supervised learning model and a reinforcement learning model.

[0027] In the embodiment, the supervised learning model and the reinforcement learning model can be classified into multiple model types based on the characteristics of autoregressive and non-autoregressive, respectively.

[0028] In an embodiment, the method may further include a step of performing inference on the Steiner Tree Problem using an artificial intelligence model having the non-autoregressive characteristic among the reinforcement learning models.

[0029] In an embodiment, the learning step may select one of the combination optimization models based on the size of the graph, and train the selected combination optimization model using the constructed data set.

[0030] A program according to the present invention is a program that is executed by one or more processes in an electronic device and can be stored in a computer-readable recording medium, and may include instructions for performing a step of generating a graph based on a plurality of graph types and parameters until nodes of the graph are connected by edges, a step of adding the generated graph to a data set to generate an instance for a Steiner Tree Problem, a step of calculating an optimal solution for the instance using a specific solver, and a step of constructing a data set including the instance and the optimal solution.

[0031] As discussed above, the method for generating learning data and the method for learning a combinatorial optimization model using the same can provide an environment in which an artificial intelligence model can learn by interacting with various scenarios by generating a large-scale data set that includes various scenarios such as graphs, number of terminal nodes, data size, and edge distribution.

[0032] In addition, according to the method for generating learning data according to the present invention and the method for learning a combinatorial optimization model using the same, by providing a data set or learning environment that can be universally utilized in various learning environments, it is possible to provide an optimal environment in which various types of models with different characteristics can learn the Steiner Tree Problem (STP).

[0033] Furthermore, according to the method for generating learning data according to the present invention and the method for learning a combinatorial optimization model using the same, a large-scale high-quality data set that can be utilized in various learning environments can be constructed, and the generalization performance of an artificial intelligence model that solves the Steiner tree problem can be improved by training an artificial intelligence model using the constructed data set.

[0034] Furthermore, the method for generating learning data according to the present invention and the method for training a combinatorial optimization model using the same selectively train an AI model based on the size of the graph included in the dataset. This minimizes the costs and resource usage required for model training and inference, and enables universal support for a variety of graph sizes. This allows for optimal solutions tailored to various graph sizes, while leveraging the strengths of each model to maximize performance and efficiency.

[0035] Furthermore, the method for generating learning data according to the present invention and the method for training a combinatorial optimization model using the same utilize a dataset constructed to enhance the expressive power of partial solutions. This allows the combinatorial optimization model to be trained, thereby solving the Steiner tree problem, which relies on partial solution information, and significantly increasing the usability of the combinatorial optimization model. This allows the combinatorial optimization model to alleviate smoothing issues and produce more accurate solutions across large-scale instances.

[0036] That is, according to the method for generating learning data according to the present invention and the method for learning a combinatorial optimization model using the same, it is possible to provide an environment for solving complex combinatorial optimization problems in various industrial fields, services, research, etc., by providing a large-scale data set and learning environment including an accurate optimal solution.

[0037] Figure 1 is a conceptual diagram for explaining a combination optimization system according to the present invention.

[0038] Figure 2 is a conceptual diagram for explaining the tree structure.

[0039] Figure 3 is a diagram to compare and explain the traveling salesman problem and the Steiner tree problem.

[0040] Figures 4a and 4b are flowcharts for explaining a method for generating learning data according to the present invention.

[0041] Figures 5, 6, 7, 8, 9 and 10 are conceptual diagrams for explaining a learning data generation method according to the present invention.

[0042] Figures 11, 12, 13, 14, 15, 16, 17, 18 and 19 are formulas for explaining a method of generating learning data according to the present invention and a method of learning a combinatorial optimization model using the same.

[0043] Hereinafter, embodiments disclosed in this specification will be described in detail with reference to the attached drawings. Regardless of the drawing numbers, identical or similar components will be given the same reference numbers, and redundant descriptions thereof will be omitted. The suffixes "module" and "part" used for components in the following description are assigned or used interchangeably only for the convenience of writing the specification, and do not in themselves have distinct meanings or roles. In addition, when describing the embodiments disclosed in this specification, if it is determined that a specific description of a related known technology may obscure the gist of the embodiments disclosed in this specification, a detailed description thereof will be omitted. In addition, the attached drawings are only intended to facilitate easy understanding of the embodiments disclosed in this specification, and the technical ideas disclosed in this specification are not limited by the attached drawings, and should be understood to include all modifications, equivalents, and substitutes included in the spirit and technical scope of the present invention.

[0044] Terms that include ordinal numbers, such as first, second, etc., may be used to describe various components, but the components are not limited by these terms. These terms are used solely to distinguish one component from another.

[0045] When a component is referred to as being "connected" or "connected" to another component, it should be understood that it may be directly connected or connected to that other component, but that there may be other components intervening. Conversely, when a component is referred to as being "directly connected" or "connected" to another component, it should be understood that there are no other components intervening.

[0046] Singular expressions include plural expressions unless the context clearly indicates otherwise.

[0047] In this application, terms such as “include” or “have” are intended to specify the presence of a feature, number, step, operation, component, part or combination thereof described in the specification, but should be understood not to exclude in advance the possibility of the presence or addition of one or more other features, numbers, steps, operations, components, parts or combinations thereof.

[0048] Hereinafter, the present invention will be examined in more detail with reference to the attached drawings. Fig. 1 is a conceptual diagram for explaining a combinatorial optimization system according to the present invention, Fig. 2 is a conceptual diagram for explaining a tree structure, and Fig. 3 is a diagram for comparing and explaining a traveling salesman problem and a Steiner tree problem. Figs. 4a and 4b are flowcharts for explaining a learning data generation method according to the present invention, and Figs. 5, 6, 7, 8, 9, and 10 are conceptual diagrams for explaining a learning data generation method according to the present invention. Furthermore, Figs. 11, 12, 13, 14, 15, 16, 17, 18, and 19 are equations for explaining a method for generating learning data according to the present invention and a learning method of a combinatorial optimization model using the same.

[0049] The present invention relates to a method for generating learning data and a method for training a combinatorial optimization model using the same. The method for generating learning data according to the present invention and the method for training a combinatorial optimization model using the same can be usefully utilized in various situations. The present invention provides a method and system for generating learning data for training a Steiner Tree Problem (STP), and a large-scale, high-quality data set for training and evaluating the Steiner Tree Problem. In addition, the present invention provides a method and system for training a combinatorial optimization model (Neural Combinatorial Optimization (NCO)) that computes a Steiner Tree Problem using the constructed (or generated) data set. For convenience of explanation, the system for generating learning data and the system for training a combinatorial optimization model are not separately named, but are uniformly referred to as a “combinatory optimization system.”

[0050] The Steiner Tree Problem (STP) can be defined as an NP-hard combinatorial optimization problem with diverse applications. More specifically, the Steiner Tree Problem is a key area of ​​combinatorial optimization (CO), and can be understood as a combinatorial optimization problem that aims to find a minimum-cost tree that includes all terminal nodes in a graph. Solving this Steiner Tree Problem can be essential for optimizing connections between various objects or locations while minimizing costs or resources. For example, the Steiner Tree Problem can be utilized in various industrial fields such as printed circuit board (PCB) design, circuit design, network design, facility layout, and image processing.

[0051] Here, combinatorial optimization, a branch of optimization, can be defined as finding a solution that satisfies an optimal objective value from a finite set of discrete candidate solutions. For example, the traveling salesman problem, a combinatorial optimization problem, can be defined as the problem of determining the order of cities visited by a traveling salesman, given a set of cities to visit, so that each city is visited once and the total travel distance is minimized. In this case, the objective of the traveling salesman problem can be the total travel distance between cities.

[0052] Meanwhile, the method for generating learning data according to the present invention and the method for training a combinatorial optimization model using the same can be applied to various industries and services. For example, the present invention can be applied to and usefully utilized in systems (or applications, software, websites, programs, etc.) based on at least one of an artificial neural network, a generative AI model (e.g., a diffusion model), and an artificial intelligence algorithm (e.g., a shortest path search algorithm, an algorithm related to combinatorial optimization, etc.).

[0053] In addition, the present invention can be usefully applied to various fields such as research related to neural network combination optimization, PCB design, circuit design, network design, facility layout, and image processing.

[0054] Meanwhile, industries and services to which the combinatorial optimization system according to the present invention can be applied will be briefly reviewed with reference to FIG. 1. The combinatorial optimization system according to FIG. 1 may include various combinatorial optimization models or artificial intelligence models, and by using these, the system may generate an optimal solution (i.e., an optimal wiring path) that satisfies various constraints required for PCB design (e.g., a no-wiring zone, wiring width and spacing, wiring angle, multi-layer wiring, etc.), or search for the shortest path for wiring terminals at the minimum cost (or cost) based on PCB data input by the user.

[0055] The combinatorial optimization system according to the present invention aims to generate a large-scale, high-quality data set capable of solving the Steiner tree problem, and to provide a combinatorial optimization model that can be applied to various industries and services to generate optimal solutions.

[0056] Meanwhile, as illustrated in FIG. 1, the combinatorial optimization system (100) according to the present invention may include at least one of an input unit (110), an output unit (120), a communication unit (130), a storage unit (140), a graph generation unit (150), an optimal solution generation unit (160), a control unit (170), and a combinatorial optimization model (181, 182, 183, 184).

[0057] The combination optimization system (100) according to the present invention may include at least one processor and at least one memory containing computer program code. In this case, the memory may function as the storage unit (140) described above. In the present invention, the memory and the program code may cooperate with the processor to perform a series of processes described below.

[0058] Although not shown, the combinatorial optimization system (100) according to the present invention may include one or more processors, which may include one or more general-purpose processors and / or one or more special-purpose processors (e.g., digital signal processors, tensor processing units (TPUs), graphics processing units (GPUs), neural network processing units (NPUs), application-specific integrated circuits, application-specific integrated circuits (ASICs), etc.). The one or more processors may be configured to execute instructions stored (or included) in the storage unit (140), computer-readable instructions, and / or other instructions described herein. The combinatorial optimization system and method according to the present invention may enable the memory and at least one processor to cooperate to perform data processing as described below. The processor may perform a series of operations and data processing using data and information stored in the memory. In this case, the memory may be a component of the storage unit (140).

[0059] Meanwhile, the input unit (110) may be configured as a means for data input and may be configured in various types. For example, the input unit (110) may be configured to receive user input. The input unit (110) may be configured to receive user input from a user terminal (10). Here, “receiving input” may mean receiving an input signal (or selection signal) corresponding to the user’s input based on the input being made by the user through the input unit configuration provided in the user terminal (10).

[0060] In addition, in the present invention, the input unit (110) does not necessarily mean a hardware means, and can be understood as a passage for receiving input from a user.

[0061] The input unit (110) may also be referred to as a user interface module. The input unit (110) may include a touch screen, computer mouse, keyboard, keypad, touch pad, trackball, joystick, voice recognition module, or other similar device. However, the present invention does not limit the type of input unit (110).

[0062] Here, the user input may include documents, text, images (or videos), voice, etc. In this case, the combination optimization system (100) may further include a module that converts voice into text.

[0063] Next, the output unit (120) can output information through an output unit configuration (e.g., a display unit, a touch screen, a speaker, etc.) provided in a user terminal (10) linked with the combination optimization system (100) according to the present invention. For example, the output unit (120) can output a page (or service page, 1000) linked with the combination optimization system (100) according to the present invention to the display unit of the user terminal (10). In addition, the output unit (120) does not necessarily mean a hardware means, and can be understood as a passage for outputting results to the user.

[0064] Next, the communication unit (130) may be connected to a user terminal (10), a server (e.g., a central server, an external server, etc.), a device, and at least one network through a wireless or wired network, and may be configured to receive or transmit overall data and information necessary for the operation of the combination optimization system (100) according to the present invention.

[0065] Here, the user terminal (10) may include at least one of a mobile phone, a smart phone, a notebook computer, a laptop computer, a slate PC, a tablet PC, an ultrabook, a desktop computer, a digital broadcasting terminal, a personal digital assistant (PDA), a portable multimedia player (PMP), a navigation device, and a wearable device (e.g., a smartwatch, a smart glass, a head mounted display (HMD)).

[0066] Furthermore, the communication unit (130) can support various communication methods according to the communication standards of the communicating device.

[0067] For example, the communication unit (130) may be configured to communicate with a communication target using at least one of WLAN (Wireless LAN), Wi-Fi (Wireless-Fidelity), Wi-Fi (Wireless Fidelity) Direct, DLNA (Digital Living Network Alliance), WiBro (Wireless Broadband), WiMAX (World Interoperability for Microwave Access), HSDPA (High Speed ​​Downlink Packet Access), HSUPA (High Speed ​​Uplink Packet Access), LTE (Long Term Evolution), LTE-A (Long Term Evolution-Advanced), 5G (5th Generation Mobile Telecommunication), Bluetooth™, RFID (Radio Frequency Identification), Infrared Data Association (IrDA), UWB (Ultra-Wideband), ZigBee, NFC (Near Field Communication), Wi-Fi Direct, and Wireless USB (Wireless Universal Serial Bus) technologies.

[0068] Next, the storage unit (140, or memory) serves to store various data related to the present invention, and may include one or more non-transitory computer-readable storage media that can be read and / or accessed by at least one of the one or more processors.

[0069] The one or more computer-readable storage media may include volatile and / or non-volatile storage components, such as optical, magnetic, organic, or other memory or disk storage devices. In some examples, the storage (140) may be implemented using a single physical device (e.g., a single optical, magnetic, organic, or other memory or disk storage device), while in other examples, the storage (140) may be implemented using two or more physical devices.

[0070] The storage unit (140) may include computer-readable instructions and additional data. The storage unit (140) may include storage necessary to perform at least some of the methods, scenarios, and techniques described herein and / or at least some of the functions of the devices and networks.

[0071] Furthermore, at least a portion of the storage unit (140) may be a cloud storage or a cloud server. At least a portion of data corresponding to user input received from the input unit (110) and learning data may be stored in the storage unit (140).

[0072] That is, it can be understood that the storage unit (140) is sufficient as a space in which information necessary for the operation of the combination optimization system (100) according to the present invention is stored, and there are no restrictions on the physical space.

[0073] Furthermore, the storage unit (140) may store a computer program including computer program instructions. Furthermore, the storage unit (140) may store a computer program including computer program instructions that control the operation of the system (100) or control the operation of the control unit (170) when loaded onto the processor of the system (100).

[0074] Next, the graph generation unit (150) may be configured to perform a role of generating various types (or types) of graphs including (or composed of, formed of) nodes and edges. To this end, the graph generation unit (150) may include at least one model that generates different types of graphs composed of nodes and edges. For example, the graph generation unit (150) may include at least one of a first model (151), a second model (152), a third model (153), and a fourth model (154).

[0075] The first model (151) may also be called an “ER (Erdos-Renyi) model” and may be a model that generates a first type of graph among a plurality of preset graph types. For example, as illustrated in (a) of FIG. 5, the first model (151) may generate a first type of graph (510) by connecting edges with the same probability for all pairs of nodes in the graph. The first type of graph (510) may include an ER graph. This first type of graph (510) is a type of random graph, and the probability that an edge exists between any pair of nodes may be “r”. In order to generate the first type of graph, the graph generation unit (150) may sample the edge generation probability from a uniform distribution and use (or utilize, utilize, etc.) the sampled value as a parameter of the first model (151).

[0076] The second model (152) may also be referred to as a “random-regular (RR) model” and may be a model that generates a second type of graph among a plurality of preset graph types. For example, as illustrated in (b) of FIG. 5 , the second model (152) may generate a second type of graph (520) in which all nodes of the graph have the same degree. The second type of graph (520) may include a random-regular (RR) graph. This second type of graph (520) is a type of random graph and may have the characteristic that all nodes have the same degree. The graph generation unit (150) sets all nodes to have the same number of neighbors in order to generate a second type of graph. At this time, the number of neighbors is sampled from “Uniform({3,4,5})”, which is a uniform (or equal) distribution of the degree of the graph, and the sampled degree value can be used as a parameter of the second model (152).

[0077] The third model (153) may also be called the “WS (Watts-Strogatz) model” and may be a model that generates a third type of graph among a plurality of preset graph types. For example, as illustrated in (c) of FIG. 5 , the third model (153) may generate a third type of graph (530) having small-world properties that include both minimum path length and high clustering. The third type of graph (530) may include a WS graph. This third type of graph (530) is a graph generated to simulate (or imitate) small-world networks, and provides a balance between regular connections and random connections, thereby reproducing the small-world effect and clustering observed in the real world. The third model (153) can sample the average node degree from the uniform distribution “Uniform({3,4,5,6})” and the rewiring probability from “Uniform(0, 1)” to generate a third type of graph.

[0078] The fourth model (154) may also be called a “grid model” and may be a model that generates a fourth type of graph among a plurality of preset graph types. For example, as illustrated in (d) of FIG. 5, the fourth model (154) may generate a fourth type of graph (540) in which all nodes are arranged in a grid shape. The fourth type of graph (540) may include a grid or a lattice graph. This fourth type of graph (540) may be understood as a graph having a structure in which nodes and edges are arranged in a grid shape. When generating the fourth type of graph (540), the fourth model (154) may sample a combination of width and height for the input number of nodes (n) and set it to be a product of n. For example, when n = 20, the fourth model (154) can generate a graph by sampling from combinations such as 4X5 or 5X4, and ensuring that one dimension is greater than a preset value (e.g., 4). In this case, unlike other graph types, the edge cost of the fourth type graph-based instance can be set to a specific fixed value (e.g., 1). That is, the fourth type graph (540) generated from the fourth model (154) among multiple graph types (510, 520, 530, 540) can be generated with a fixed edge cost. This can be understood to allow the instance to have properties similar to those searched (or discovered) in a Euclidean space.

[0079] However, in the present invention, the models included in the graph generation unit (150, or combinatorial optimization system (100)) for generating multiple graph types are not necessarily limited to the mentioned models, and may further include other models in addition to the first model (151), second model (152), third model (153), and fourth model (154) above. It goes without saying that the models applied in the present invention may be variously changed and / or set to one or more depending on the purpose of use or situation (or case).

[0080] Next, the optimal solution calculation unit (or optimal solution calculation unit, etc., instance calculation unit, etc. 160) may be configured to perform the role of calculating (or calculating) an optimal solution (or optimal solution) for an instance for a Steiner tree problem (or combinatorial optimization problem).

[0081] The optimal solution generating unit (160) may include a mixed-integer linear programming (MILP)-based SCIP-Jack solver for calculating an optimal solution. Mixed-integer linear programming is an extension of linear programming, and can be understood as a method of modeling and solving a problem by combining integer variables and real-valued variables. The optimal solution generating unit (160) may calculate the optimal cost of an instance for a Steiner tree problem generated based on a graph, and may calculate an optimal solution based on the calculated result.

[0082] Next, the control unit (170) may perform a role of controlling the overall operation of the combination optimization system (100) related to the present invention. The control unit (170) may process signals, data, information, etc. input or output through the components of the combination optimization system (100) discussed above, or perform a series of data processing to provide or process appropriate information and functions to the user. The control unit (170) may be physically implemented by the processor discussed above.

[0083] In one embodiment, the control unit (170) may generate a plurality of types of graphs composed of nodes and edges using the graph generation unit (150), and add the generated graphs to the data set (200) to generate instances for the Steiner Tree Problem (STP). In addition, the control unit (170) may generate an optimal solution for each of the instances included in the data set (200) using the optimal solution generation unit (160), and construct a data set (200) including the instances and the optimal solutions generated for each of the instances.

[0084] Below, we will briefly look at the tree structure and components together with Figure 2.

[0085] As illustrated in FIG. 2, a tree (20) is abstract data that represents a hierarchical structure with a series of connected nodes, and is named a tree because it resembles a tree. A tree (20) is composed of connected nodes like a linked list, and is broadly included in a graph. Like a graph, it is a set of hierarchical data composed of nodes (vertices) and edges (or edges, edges, etc.). However, unlike a graph, a tree (20) has a parent-child relationship between nodes. The direction of a tree (20) is always unidirectional, and edges are connected from a parent node (N3) to a child node (N7). If there is an edge connecting a child node (N7) to a parent node (N3) or a sibling node (N6), it is not a tree. A tree (20) may have no or multiple connected child nodes. For example, in a real tree, branches and leaves grow upward from the root at the bottom, but a tree structure is usually expressed as a tree that grows upside down.

[0086] Furthermore, a tree with N nodes can be made to include “N-1” edges. For example, a tree (20) with “9” nodes can include “8” edges.

[0087] Looking at the components of the tree (20), first, nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9) are basic elements that make up the tree (20) and can also be called vertices.

[0088] Edges (21, 22, 23, 24, 25, 26, 27, 28) are lines (or links) connecting nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9), and the number of edges (21, 22, 23, 24, 25, 26, 27, 28) in the tree (20) is equal to “the number of nodes - 1.” The converse of this proposition is also valid.

[0089] The root node (N1) is located at the very top (top) of the tree (20) and may include nodes without parent nodes. The tree (20) may be configured to have only one root node.

[0090] Leaf nodes (N8, N9) are located at the very bottom (bottom, end) of the tree. Because they are located at the very bottom, they can contain nodes that do not have child nodes. Leaf nodes may also be called “terminal nodes.”

[0091] Internal nodes include all nodes located between the root node and the leaf nodes, and may also be called branch nodes.

[0092] A nom-terminal node, unlike a leaf node, can contain nodes that have child nodes.

[0093] These root nodes, leaf nodes, and internal nodes can all have different names depending on their location. For example, if a tree has only one root node, that node can have the characteristics of both root and leaf nodes.

[0094] As discussed above, the tree (20) has a hierarchical structure, so all nodes have parent-child relationships with each other. For example, in one node of the tree (20), the node (N3) adjacent to the root node (N1) becomes the parent node, and the nodes (N6, N7) adjacent in the opposite direction become child nodes. All nodes except the root node (N1) can have exactly one parent node.

[0095] Sibling nodes can include child nodes (N6, N7) that have the same parent node (N3). They are generally expressed in order from the left node.

[0096] A path is a sequence of nodes along a path from a specific node to another specific node. For example, the path from node H (N8) to node E (N5) in a tree (20) may be “HDBE.”

[0097] The length of a path can mean the number of nodes that must be passed through from the starting node of the path to the destination node.

[0098] The size of a node can refer to the number of all descendant nodes, including itself. For example, the size of node B (N2) can be “3.”

[0099] The depth of a node can refer to the length of the path from the root node (N1) to a specific node. For example, the depth of node H (N8) can be “3,” the depth of node B (N2) can be “1,” and the depth of the root node (N1) can be “0.”

[0100] A level may refer to a set of nodes with the same depth in a tree (20). For example, level 2 in a tree (20) may include node D (N4), node E (N5), node F (N6), and node G (N7). As another example, the level of node A (N1) may be “0”, and the levels of node D (N4), node E (N5), node F (N6), and node G (N7) may be “2”.

[0101] The height of a tree can mean the length of the path from the root node (N1) to the deepest leaf node (N8, N9).

[0102] The degree of a node can refer to the number of nodes that are children of a specific node. Since the tree (20) is one-way, from a graph perspective, it can refer to the degree of a node's entry. For example, "the number of subtrees / the number of edges (degree) = the number of edges each node has" can be expressed as follows. In this case, the degree of node A (N1) can be "2", and the degree of node B (N2) can be "2".

[0103] The degree of a tree can mean the maximum value (or maximum degree) among the degrees of nodes existing within the tree. For example, the degree of a tree (20) can be understood as “2.”

[0104] The size of a tree may refer to the number of nodes that constitute the tree (20). For example, since the total number of nodes that constitute the tree (20) is 10, the number of trees (20) may be “10”.

[0105] The width of a tree can mean the size of a particular level or the size of the level containing the most nodes in the tree (20).

[0106] Meanwhile, as examined above, the Steiner tree problem is an important combinatorial optimization problem in graph theory, and as illustrated in (a) of Fig. 15, in an instance of the Steiner tree problem, the graph can be expressed as an undirected graph s = (V, E). Here, V may represent a set of nodes (vertices) of the graph, and E may represent a set of edges connecting the nodes of the graph. At this time, a subset of nodes expressed (or specified) as terminals among the set of nodes of the graph may be defined as in (b) of Fig. 15.

[0107] The node set (V) refers to a set that includes all nodes in the graph, and the edge set (E) represents connections between nodes included in the node set (V), and each edge included in the edge set (E) may be assigned a specific cost. Furthermore, the method of connecting edges may vary depending on the graph type. For example, in a first type of graph, pairs of nodes may be connected with random probability, while in a second type of graph, edges may be connected so that all nodes have the same degree.

[0108] Meanwhile, the Steiner tree problem aims to find a tree structure that includes all nodes of a terminal set (T). The tree structure and its characteristics can be represented as shown in (c) and (d) of Fig. 15. Such a tree must connect all nodes of the terminal set (T) with the minimum cost. In other words, the sum of the total costs of the edges constituting the tree (as shown in (e) of Fig. 15) must be minimized. The optimal solution (or optimal solution, optimal tree, as shown in (g) of Fig. 15) can be defined as shown in (f) of Fig. 15.

[0109] In this regard, although both the Steiner tree problem and the traveling salesman traversal problem are problems of finding a path that satisfies the minimum cost in a graph, there are differences between the Steiner tree problem and the traveling salesman traversal problem.

[0110] For example, referring to Figure 3 (a), the traveling salesman traversal problem requires that each node be visited exactly once, minimizing the total path length. In the traveling salesman traversal problem, even if the node locations are changed, the path structure only slightly changes, and the solution can be highly stable.

[0111] On the other hand, referring to Figure 3(b), the Steiner tree problem focuses on connections between terminals, and there is no need to visit every node. In the Steiner tree problem, changing the location of a node can significantly change the entire edge set of the solution. Furthermore, the solution complexity can increase because it can include additional intermediate nodes in addition to the terminals.

[0112] As illustrated in Figures 3(a) and (b), comparing the traveling salesman problem with the Steiner tree problem, the Steiner tree problem can have dependencies between terminals spanning a wider range. In other words, in the Steiner tree problem, small changes (perturbations) in the solution space can affect distant regions, meaning that small changes can have a significant impact on the overall optimization result.

[0113] Meanwhile, the present invention aims to provide a large-scale data set and environment capable of solving the Steiner tree problem. More specifically, the present invention aims to provide a large-scale, high-quality data set that can be universally utilized in various learning environments. Below, we will examine in more detail a method for generating training data for learning the Steiner tree problem.

[0114] In the present invention, a process of generating a graph can be performed until nodes of the graph are connected by edges based on multiple graph types and parameters (S410, see FIG. 4b).

[0115] First, the control unit (170) can proceed with an initial setup process (or step) of setting multiple graph types and parameters (S401, see FIG. 4a).

[0116] During the initial setup process, various setting values ​​(or information) required for graph generation can be set. As illustrated in (a) of Fig. 11, the control unit (170) can set the number of instances (N), the number of nodes (n), a preset probability for selecting terminal nodes, and the graph type (or type).

[0117] Here, the number of instances (or count), the number of nodes (or count), the preset probability of selecting a terminal node, and at least one (or some) of the graph types can also be understood as input data input to each of the multiple models (151, 152, 153, 154) included in the graph generation unit (150) discussed above.

[0118] The number of instances represents the number of Steiner tree problems to be generated. For example, a specific instance may include a specific graph and a Steiner tree problem within that graph. The more instances generated, the more environments the AI ​​model can learn about diverse graph structures and problem situations.

[0119] The number of nodes represents the number of nodes in a graph and can be a factor in determining the size of the graph. For example, since the connectivity and complexity of a graph vary depending on the number of nodes, it can be important to set the number of nodes to various sizes.

[0120] The preset probability of selecting a terminal node may represent the probability that each node included in the graph can be specified (or selected) as a terminal (a node that must be connected). For example, if the preset probability is set to “0.2,” each node can be specified as a terminal with a probability of 20%. Although the present invention is described on the premise that the preset probability is “0.2,” it is not necessarily limited thereto, and it is obvious that the preset probability can be variously changed (or set) by the administrator of the combinatorial optimization system (100) or the combinatorial optimization system (100) itself.

[0121] Graph types can be utilized to determine the structural characteristics of the graph to be generated. For example, as illustrated in (a) to (d) of FIG. 5, multiple graph types may include a first graph type (510), a second graph type (520), a third graph type (530), and a fourth graph type (540). Since each of these graph types has different characteristics, they can provide an environment in which an AI model can learn diverse structures.

[0122] In this regard, the method of connecting edges may vary depending on the plurality of graph types in the present invention. A graph corresponding to at least one of the plurality of graph types may be generated by sampling edge creation probabilities from a uniform distribution, sampling the degree of the graph, or sampling the average node degree.

[0123] First, at least one of the multiple graph generation models (151, 152, 153, 154) can generate a graph by sampling edge generation probabilities from a uniform distribution.

[0124] More specifically, the first model (151) that generates a first type of graph (510) among multiple graph types (510, 520, 530) can generate the graph (510) by connecting edges with the same probability for all pairs of nodes in the graph. In this case, the first model (510) can generate the first type of graph (510) by sampling the edge generation probability from a uniform distribution.

[0125] Additionally, at least one of the plurality of graph generation models (151, 152, 153, 154) can generate a graph by sampling the degree of the graph from a uniform distribution.

[0126] More specifically, the second model (152) that generates a second type of graph (520) among multiple graph types (510, 520, 530) can generate the graph (520) so that all nodes of the graph have the same degree. In this case, the second model (152) can generate the second type of graph (520) by sampling the degree of the graph from a uniform distribution, “Uniform({3,4,5}).”

[0127] Furthermore, at least one of the plurality of graph generation models (151, 152, 153, 154) can generate a graph by sampling an average node degree from a uniform distribution.

[0128] More specifically, the third model (153) that generates a third type of graph (530) among multiple graph types (510, 520, 530) can generate a graph (530) having small-world properties that include both minimum path length and high clustering. In this case, the third model (153) can generate the third type of graph (530) by sampling the average node degree from a uniform distribution, “Uniform({3,4,5,6})”, and sampling the rewiring probability from “Uniform(0, 1)”.

[0129] Meanwhile, the plurality of graph types may further include at least one graph type (e.g., a first type graph (510), a second type graph (520), a third type graph (530)) as discussed above and another type (e.g., a fourth type graph (540)).

[0130] At least one of the multiple graph generation models (151, 152, 153, 154) can generate a graph by ensuring that the cost of an edge is fixed.

[0131] More specifically, the fourth model (154), which is different from the first model (151), second model (152), and third model (153) above, can generate a fourth type of graph (540) in which all nodes are arranged in a grid shape. In this case, the fourth model (154) can generate the fourth type of graph (540) by fixing the edge cost to a specific fixed value (e.g., 1). That is, unlike other graph types, the fourth type of graph (540) can be generated in a state in which the edge cost is fixed.

[0132] That is, each of the multiple models (151, 152, 153, 154) included in the graph generation unit (150) can generate different types of graphs based on the set number of instances, the set number of nodes, the set probability of selecting a terminal node, and the graph type.

[0133] Next, in the present invention, in the process of generating a graph based on the set graph type and parameters, the graph can be generated until the nodes of the graph are connected by edges.

[0134] When a graph is generated from each of a plurality of models (151, 152, 153, 154), the graph generation unit (150, or control unit (170)) can perform a verification process on the generated graph (S403, see FIG. 4a).

[0135] The process (or process) of performing verification on a graph generated in the present invention and repeating the generation (or regeneration) of the graph until unconnected nodes in the graph are connected can be performed in the same manner for all types of graphs generated from multiple models (151, 152, 153, 154). Accordingly, in the following, for convenience of explanation and to avoid duplication of explanation, the above process will be explained on the premise that a graph is generated from at least one of the multiple models (151, 152, 153, 154).

[0136] Each of the multiple models (151, 152, 153, 154) can generate a graph based on the set graph type and parameters. As illustrated in (b) of Fig. 11, the graph generation unit (150) can generate a specific graph according to the graph type. In this case, in (b) of Fig. 11, V may denote a node set, and E may denote an edge set (see (c) of Fig. 11).

[0137] In one embodiment, let's assume that the graph type is set to "first type graph", the number of instances is set to "100", the number of nodes is set to "10", and the preset probability is set to "0.2". The graph generation unit (150) can generate a graph using the first model (510) among the plurality of models (151, 152, 153, 154). The first model (510) can generate a plurality (e.g., 100) of the first type graphs (510) including the number of nodes (e.g., 10) according to the number of nodes, based on the number of instances and the number of nodes.

[0138] In another embodiment, let's assume that the graph type is set to "second type graph", the number of instances is set to "200", the number of nodes is set to "10", and the preset probability is set to "0.2". The graph generation unit (150) can generate a graph using the second model (520) among the plurality of models (151, 152, 153, 154). The second model (520) can generate a plurality (e.g., 200) of the second type graphs (520) including the number of nodes (e.g., 10) according to the number of nodes, based on the number of instances and the number of nodes.

[0139] And, once the graph is generated, the graph generation unit (150) can perform connectivity verification (or inspection) on the generated graph. In this case, verification on the generated graph can also be performed by the model itself. In the connectivity verification process, if there are isolated nodes (i.e., isolated nodes) among the nodes included in each of the generated graphs, graph generation can be repeatedly performed so that the nodes are connected in all graphs. This can also be called a "graph generation loop" process.

[0140] More specifically, as illustrated in FIG. 6, a specific model (hereinafter, the first model (151)) can analyze the generated graph (600) to verify the connectivity of the graph (600) when the graph (600) is generated. The first model (151) can analyze a plurality of nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10) included in the generated graph (600) to determine whether to repeat the generation of the graph.

[0141] The first model (151) can repeatedly perform the generation of a graph until a specific node (N9) specified as a separated node is connected by an edge, based on the verification result through analysis of a plurality of nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10) included in the graph (600) and the identification of a separated node (N9) among the plurality of nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10).

[0142] For example, it can be confirmed that edges (601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614) connecting the remaining nodes (N1, N2, N3, N4, N5, N6, N7, N8, N10) except for the separated ninth node (N9) are included in the graph (600). At this time, since there is no edge connecting the sixth node (N6) and the ninth node (N9), the ninth node (N9) can be identified as a separated node in the process of verifying graph connectivity.

[0143] The first model (151) can repeat the generation of the graph (600) so that the ninth node (N9), which is specified as a separated node in the graph (600), is connected. As illustrated in FIG. 7, in the graph loop process, the first model (151) can repeat the generation of the graph (600) until the separated ninth node (N9) is connected to the sixth node (N6) by an edge (615). Through this process, all nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10) included in the graph (600) are connected through edges (601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615), so that a graph (600) that does not include any separated nodes can be created.

[0144] Meanwhile, in the present invention, a process of creating an instance for a Steiner Tree Problem by adding the generated graph to a data set can be performed (S420, see FIG. 4b).

[0145] As seen above, the number of instances represents the number of Steiner tree problem data that needs to be generated, for example, one specific instance may include one specific graph and a Steiner tree problem in said specific graph.

[0146] The control unit (170) can add the generated graph (600) to the data set (200) and create an instance for the Steiner tree problem added to the data set (200).

[0147] Specifically, when a graph (600) in which all nodes are connected is generated, as illustrated in (d) of Fig. 11, the control unit (170) can set each node included in the graph (600) as a terminal with a preset probability. The control unit (170) can select (or specify) a node that must be necessarily connected among the nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10) included in the graph (600).

[0148] Nodes that must be connected on the graph (600) can be selected based on the preset probability set above. In this case, the selected nodes can be understood as terminals.

[0149] The control unit (170) can select a node corresponding to a terminal from among a plurality of nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10) included in the graph (600) based on a preset probability. For example, as illustrated in FIG. 8, the control unit (170) can select at least one specific node (N1, N7, N10) that must be necessarily connected from among a plurality of nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10) included in the graph (600) based on a preset probability (ex: 0.2).

[0150] In this case, the first node (N1), the seventh node (N7), and the tenth node (N10), which are selected according to the preset probability, can be understood as terminals (or terminal nodes) that must be necessarily connected through edges on the graph (600). That is, the graph (600) may include terminal nodes, which are nodes that must be necessarily connected in the process of calculating (or producing) the optimal solution. When such terminal nodes are selected, the nodes selected as terminals must be included in the tree (or subtree) that constitutes the optimal solution.

[0151] And, the control unit (170) can allocate a cost (or cost) to the edges (601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615) included in the graph (600).

[0152] As illustrated in (e) of FIG. 11, the control unit (170) can assign a cost (c(e)) to each edge. In this case, as illustrated in (f) of FIG. 11, the cost assigned (or given) to each edge can be randomly sampled from a preset range (or a specific range) using a Gaussian distribution. More specifically, the cost of an edge can be sampled as a random integer from a truncated Gaussian distribution having a mean and variance.

[0153] The control unit (170) can generate a random integer (or random number) of a specific range and allocate it as a cost for all edges (601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615) connecting multiple nodes (N1, N2, N3, N4, N5, N6, N7, N8, N9, N10) included in the graph (600) using a Gaussian distribution.

[0154] In this case, as integers are randomly sampled, the cost size (or value) assigned to each of the edges (601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615) included in the graph (600) may be different. For example, as illustrated in FIG. 9, a cost (or cost value) of “4” may be assigned to a first edge (601), and a cost of “7” may be assigned to a second edge (602). As another example, a cost of “10” may be assigned to a third edge (603), and a cost of “3” may be assigned to a fourth edge (604). For another example, the ninth edge (609) may be assigned a cost of “11”, the tenth edge (610) may be assigned a cost of “5”, and the eleventh edge (611) may be assigned a cost of “4”.

[0155] Furthermore, the control unit (170) can create an instance for a Steiner tree by adding the generated graph (600) to the data set (200).

[0156] A specific instance of a Steiner tree may include a graph (600) generated above, a set of terminal nodes (T), and costs assigned to each of a plurality of edges. The control unit (170) may group the costs assigned to each of the graph (600), terminals selected according to a preset probability (e.g., a first node (N1), a seventh node (N7), a tenth node (N10), etc.), and a plurality of edges (601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615), and store the grouped data in a storage unit (140, or memory). In addition, the control unit (170) can include the costs of the grouped graph (600), terminal nodes, and edges as instances for the Steiner tree in the data set (200) (the data set is represented as in (g) of FIG. 11). That is, the costs assigned to the graph, terminals, and edges can be grouped into instances and included in the data set (200).

[0157] As an example related to this, a first type graph (510) instance in which the number of nodes is set to “10” can be represented as in (h) of Fig. 11.

[0158] Meanwhile, in the present invention, a process of calculating an optimal solution for an instance using a specific solver can be performed (S430, see FIG. 4b).

[0159] The control unit (170) can use the optimal solution calculation unit (160) to calculate an optimal solution for at least one instance included in the data set (200) (S405, see FIG. 4a).

[0160] As discussed above, the optimal solution calculation unit (160) can be configured to perform the role of calculating an optimal solution for an instance of the Steiner tree problem.

[0161] In the present invention, the optimal solution calculation unit (160) may include at least one solver for calculating an optimal solution for an instance. The optimal solution calculation unit (160) may include at least one of a first solver, a second solver, a third solver, and a fourth solver for calculating an optimal solution.

[0162] The first solver is a mixed-integer linear programming (MILP)-based solver, also known as the "SCIP-Jack solver." Mixed-integer linear programming (MILP) is an extension of linear programming, and can be understood as a method for modeling and solving problems by combining integer and real-valued variables. The first solver can compute the optimal cost for instances of a Steiner tree problem generated from a graph and derive an optimal solution based on the computed results.

[0163] The second solver may also be referred to as a “combinatorial optimization solver.” When the set of all possible solutions (or solutions) for a combinatorial optimization problem instance is represented as (a) in Fig. 12, S may be the space of instances to which a cost function is assigned (see (b) in Fig. 12). As illustrated in (c) in Fig. 12, the learning objective of the second solver is to produce an optimal solution (as illustrated in (a) in Fig. 12) that minimizes the cost for the input (or given) instance (s), and the optimal solution may be defined as illustrated in (d) in Fig. 12. Here, the second solver may be a probabilistic algorithm, and may produce (or return) a predicted solution (or solution) for the input instance (s), as illustrated in (e) in Fig. 12. In this case, the second solver may be parameterized as illustrated in (f) in Fig. 12.

[0164] Additionally, for the learning-based combinatorial second solver, as illustrated in (g) of Fig. 12, it is necessary to find parameters so that the second solver can produce the optimal solution for the input instance(s) (i.e., for all instances, as illustrated in (h) of Fig. 12). That is, the goal of the learning-based second solver may be to adjust the parameters so that the optimal solution is accurately predicted for all instances.

[0165] Tertiary solvers can also be called "autoregressive solvers." Tertiary solvers incrementally generate a sequence (or sequence) of partial solutions by applying conditions to previous solutions, and can iteratively perform this step-by-step approach until a feasible optimal solution is reached. In other words, a tertiary solver predicts the next sequence value based on the current sequence, and can incrementally expand the partial solutions to generate an optimal solution.

[0166] The fourth solver can also be called a "non-autoregressive solver." The fourth solver can generate the optimal solution for the input instance(s) in a single step. This means that the fourth solver can be computationally fast because it generates the entire solution in a single run.

[0167] The control unit (170) can specify any one of the multiple solvers included in the optimal solution calculation unit (160) as a specific solver for calculating the optimal solution for an instance. For convenience of explanation, the following description will be given on the assumption that the first solver among the multiple solvers included in the optimal solution calculation unit (160) is specified as a specific solver.

[0168] In an instance of the Steiner tree problem, the goal is to find a tree that minimizes the total cost (or sum of costs) of paths connecting terminal nodes that must be connected among multiple nodes in a graph. Alternatively, this problem can be understood as finding a subtree that connects all terminal nodes (terminals) while minimizing the sum of edge costs.

[0169] The control unit (170) can use a specific solver to derive an optimal solution for an instance. The specific solver can derive an optimal solution for an instance in which the costs of a graph, terminal nodes, and edges are grouped. For example, as illustrated in FIG. 10, when a specific solver is input with a grouped instance of a graph (600), terminal nodes (N1, N7, N10), and costs assigned to each of a plurality of edges (601, 602, 603, 604, 605, 606, 607, 608, 609, 610, 611, 612, 613, 614, 615), it can calculate a path that can connect the terminal nodes (N1, N7, N10) with the minimum cost, and specify edges (601, 603, 610, 611, 613, 614) that connect the terminal nodes (N1, N7, N10) with the minimum cost. And, a specific solver can produce a tree that minimizes the total cost (or sum of costs) of the paths connecting terminal nodes (N1, N7, N10) based on a specific edge as the optimal solution for the instance.

[0170] Furthermore, when the calculation of the optimal solution is completed, the process of constructing a data set including the instance and the optimal solution may be performed in the present invention (S440, see FIG. 4).

[0171] When all instances are created and the optimal solution for all instances is calculated, the control unit (170) can store the calculated result in the storage unit (140) and return the calculated result to the data set (200) (S407, see FIG. 4a).

[0172] That is, the control unit (170) can construct a data set (200) including an instance for a Steiner tree problem and an optimal solution produced for the instance from a specific solver.

[0173] In one embodiment, the control unit (170) can construct a data set (200) using a tree or a graph (600) including the tree that minimizes the total cost of the path connecting the terminal nodes (N1, N7, N10).

[0174] The data set (200) according to the present invention generated through the process discussed above is composed of various instances including graphs of different sizes and structures, various terminal node configurations, and edge costs assigned as random integers, thereby providing an environment in which an artificial intelligence model can learn various learning scenarios.

[0175] In this regard, the data set (200) according to the present invention can be divided into a learning data set and a verification (test) data set. In this case, the divided learning data set and verification data set can be configured with different sizes (node ​​sizes). For example, the node sizes included in the learning data set can be configured with sizes such as 10, 20, 30, 50, 100, etc. In another example, the node sizes included in the verification data set can be configured with sizes such as 200, 500, 1000, etc. in addition to the node sizes included in the learning data set. The data set (200) generated in the present invention is a large-scale data set for learning and evaluating the Steiner tree problem, and can also be named “Steiner Tree Problem Benchmark (SteBen).”

[0176] Meanwhile, the present invention aims to provide a combinatorial optimization model that can be universally applied across various industries and services. More specifically, the present invention aims to provide a combinatorial optimization model capable of solving the Steiner tree problem and generating an optimal solution. Below, we will examine the learning method of the combinatorial optimization model in more detail.

[0177] Meanwhile, in the learning process of the combination optimization model (Neural Combinatorial Optimization) according to the present invention, a process of generating a graph based on multiple graph types and parameters until the nodes of the graph are connected by edges, a process of adding the generated graph to a data set to generate an instance for a Steiner Tree Problem, a process of calculating an optimal solution for the instance using a specific solver, and a process of constructing a data set including the instance and the optimal solution and training at least one of the combination optimization models using the constructed data set may be performed.

[0178] The control unit (170) can proceed with learning of a combination optimization model using a data set (200) constructed through a learning data generation process.

[0179] In the present invention, the combinatorial optimization model may include at least one of a supervised learning model and a reinforcement learning model. For example, as illustrated in FIG. 1, the combinatorial optimization model according to the present invention may include at least one of a first artificial intelligence model (181), a second artificial intelligence model (182), a third artificial intelligence model (183), and a fourth artificial intelligence model (184).

[0180] In one embodiment, in supervised learning, a supervised learning model can be trained using a data set (200). The control unit (170) can train the supervised learning model using the data set (200) (the data set is illustrated as in (a) of FIG. 13). As described above, the data set (200) can be constructed using all instances and the optimal solution for each of the instances. Accordingly, the instances included in the data set (200) can be associated with a label indicating the optimal solution (or optimal solution). As illustrated in (b) of FIG. 13, each instance (s) can be paired with a label indicating the optimal solution. In this case, as illustrated in (c) of FIG. 13, the control unit (170) can train the supervised learning model so that the difference between the correct label (i.e., the label indicating the optimal solution) and the supervised learning model is minimized. The supervised learning model can be trained using a loss function defined to minimize the difference between its final output and the correct label. This loss function can be represented as in (d) of Fig. 13.

[0181] In another embodiment, as illustrated in (a) of FIG. 14, in reinforcement learning, a reinforcement learning model (or solver) can be trained using feedback from a cost function without relying on a data set (or labeled data). Here, the reinforcement learning model can be regarded as a policy, the instance (s) can be regarded as a state, and the output of the reinforcement learning model can be regarded as an action (see (b) of FIG. 14). When an action is selected from the reinforcement learning model, the control unit (170) can provide a reward (as illustrated in (c) of FIG. 14) for the selected action to the reinforcement learning model. Through a Markov decision process (MDP), the reinforcement learning model can improve the policy through an iterative process of exploration and exploitation. The learning objective of a reinforcement learning model is to minimize the expected cost for a distribution of instances (s) (as shown in (d) of Figure 14), and to minimize the expected cost (as shown in (f) of Figure 14) when instances (s) are sampled from the distribution. In other words, the reinforcement learning model can be trained to produce a solution with the lowest average cost. This objective can be defined as shown in (e) of Figure 14. In this case, the function for calculating the cost of the solution in (e) of Figure 14 can be represented as shown in (g) of Figure 14.

[0182] Meanwhile, in the present invention, the supervised learning model and the reinforcement learning model can be classified into multiple model types based on different characteristics.

[0183] More specifically, the supervised learning model and reinforcement learning model included in the combinatorial optimization model can be classified into multiple model types (e.g., autoregressive as type 1, non-autoregressive as type 2) based on the characteristics of autoregressive and non-autoregressive, respectively.

[0184] Autoregressive methods use information from previous time points in sequential data to predict or calculate the output at the current time point. In time series data or natural language processing, this can be a method of calculating the next step by referencing the state of the previous step. Non-autoregressive methods process data in parallel, without relying on the output of previous time points. In other words, non-autoregressive methods process the entire sequence at once to generate a solution, potentially offering the advantage of faster computational speeds.

[0185] For example, models with autoregressive properties may include Pointer Networks and Attention Models (AMs), while models with non-autoregressive properties may include Variational Autoencoders (VAEs), Generative Adversarial Networks (GANs), and Graph Neural Network-based Diffusion Models.

[0186] The supervised learning model according to the present invention can be classified into multiple model types based on the characteristics of autoregression and non-autoregression. The control unit (170) can analyze the characteristics of each of the multiple models included in the supervised learning model, and based on the analysis results, can specify the supervised learning model with autoregression characteristics and the supervised learning model with non-autoregression characteristics, and classify them into multiple types. For example, the supervised learning model can include a first artificial intelligence model (181) and a second artificial intelligence model (182). In this case, the first artificial intelligence model (181) with autoregression characteristics can be classified as a first type of supervised learning model, and conversely, the second artificial intelligence model (182) with non-autoregression characteristics can be classified as a second type of supervised learning model.

[0187] In addition, the reinforcement learning model according to the present invention can be classified into multiple model types based on the characteristics of autoregression and non-autoregression. The control unit (170) can analyze the characteristics of each of the multiple models included in the reinforcement learning model, and based on the analysis results, can specify a reinforcement learning model having autoregression characteristics and a reinforcement learning model having non-autoregression characteristics, and classify them into multiple types. For example, the reinforcement learning model can include a third artificial intelligence model (183) and a fourth artificial intelligence model (184). In this case, the third artificial intelligence model (183) having autoregression characteristics can be classified as a first type reinforcement learning model, and conversely, the fourth artificial intelligence model (184) having non-autoregression characteristics can be classified as a second type reinforcement learning model.

[0188] In this regard, the control unit (170) can select one of the combination optimization models during the process of learning the combination optimization model, and use the constructed data set (200) to learn the selected combination optimization model.

[0189] The control unit (170) can selectively train a combination optimization model based on the size of the graph included in the data set (200). The control unit (170) can selectively train a combination optimization model based on the size of the graph included in the data set (200) based on preset criteria.

[0190] The preset criteria can be variously set based on the size of the graph. For example, the preset criteria can include at least one of the number of nodes included in the graph (the number of nodes), the number of edges (the number of edges), the node-edge ratio (the degree of density of the graph), the diameter of the graph (the difference between the nodes that are the farthest apart in the graph), and the size of the connected components of the graph. However, the preset criteria can include various criteria in addition to those mentioned above, and it is obvious that the preset criteria can be variously set by the administrator of the combinatorial optimization system (100) according to the present invention or the combinatorial optimization system (100) itself. For the convenience of explanation, the following description will be made on the assumption that the preset criteria are set based on the number of nodes.

[0191] The control unit (170) analyzes the size of at least one graph included in the data set (200) based on a preset criterion (e.g., the number of nodes is “500” or less), and, based on the size of the analyzed graph, can specify a combinatorial optimization model to be the target of learning. Here, analyzing the size of the graph can also be understood as analyzing at least one of the costs of the graph, terminal nodes, and edges included in the grouped instance.

[0192] For example, as a result of the analysis, if the size of the graph satisfies a preset criterion (indicating that the size of the graph is small), the control unit (170) may select the first artificial intelligence model (or the first type of supervised learning model, 181) included in the supervised learning model among the combinatorial optimization models according to the present invention. Then, the control unit (170) may train the first artificial intelligence model (181) using the data set (200). The first artificial intelligence model (181) specified based on satisfying the preset criterion is effective in a graph of a small size, and may provide a practical inference time and high prediction performance.

[0193] For another example, if the analysis result shows that the size of the graph does not satisfy the preset criteria (indicating that the size of the graph is large), the control unit (170) may select the second artificial intelligence model (or the second type of supervised learning model, 182) included in the supervised learning model among the combinatorial optimization models according to the present invention. Then, the control unit (170) may train the second artificial intelligence model (182) using the data set (200). The second artificial intelligence model (182) specified based on satisfying the preset criteria is capable of stable learning through high computational efficiency and parallel processing (or sampling), which is effective in large-scale graphs and can produce efficient solutions even in large-scale complex problems.

[0194] In this regard, the second artificial intelligence model (182) formulates an NP-hard problem in the field of combinatorial optimization as a {0, 1}-vector optimization problem, and can generate a high-quality solution. In the present invention, edge feature initialization can be modified in an anisotropic graph to incorporate additional details related to edge cost and terminal information. The modified edge feature initialization can be represented as in (a) of Fig. 16. The embedding function in (a) of Fig. 16 can be represented as in (b) of Fig. 16, and the embedding function for the input graph can be represented as in (c) of Fig. 16. In addition, each learnable weight parameter can be represented as in (d) of Fig. 16, and the edge cost matrix and the indicator matrix indicating the presence or absence of an edge can be represented as in (e) and (f) of Fig. 16, respectively. That is, in the present invention, by directly integrating edge cost information and terminal node indicators into the edge embedding vector, the second artificial intelligence model (182) can effectively determine the unique characteristics of the Steiner tree problem and produce a more accurate and cost-effective optimal solution.

[0195] Meanwhile, the solution to the Steiner tree problem is represented as a tree, and such a tree must be represented sequentially. In the present invention, a tree traversal (or level-order tree traversal) method can be used to serialize the tree's nodes. In other words, the present invention serializes the tree's nodes using the tree traversal method, allowing the tree to be represented as a node list.

[0196] If the number of child nodes in a tree is not limited to multiple (2), nodes can be rearranged through level-order traversal, pre-order traversal, and post-order traversal.

[0197] Level-order traversal, also known as breadth-first search (BFS), visits all children of the current node before exploring nodes in the next level. Pre-order traversal, also known as depth-first search (DFS), visits sibling subtrees after traversing a node deeply. This method prioritizes visiting the root before its children. Furthermore, post-order traversal visits all child nodes before each parent node.

[0198] The present invention constructs a tree based on node indices, designating the root as the last sorted terminal node and sorting child nodes in descending order. This allows the present invention to fix the terminal's location to the most recent embedding and assign consistent labels.

[0199] Furthermore, while conventional methods rely on lexicographic ordering, the present invention allows nodes to be sorted based on the minimum distance to the terminal node. Nodes closer to the terminal have higher priority in the sequence, and this approach can provide valuable information about terminal-adjacent nodes prior to the decoding stage.

[0200] In addition, in the present invention, various embedding or decoding methods (or techniques) can be utilized to apply a model having autoregressive or non-autoregressive characteristics to the Steiner tree problem domain.

[0201] First, when a node is input to a model with autoregressive characteristics, the node feature (distance to terminal) used may omit edge cost information or may not sufficiently reflect the overall topology (structure) of the graph. To prevent (or supplement) this, the present invention can add a GNN (Graph Neural Network) embedding to the node embedding. The embedding of node i can be calculated using the mathematical formula of Fig. 17(a). The embedding of node i can be represented as in Fig. 17(b), and the set of neighboring nodes of node i can be represented as in Fig. 17(c). In addition, Fig. 17(d) represents the normalized edge cost, and the normalized edge cost can be defined as in Fig. 17(e). Furthermore, the maximum value among the edge costs of the entire graph can be represented as in (g) of Fig. 17, where the embedding of the neighboring node can be added in a form weighted by the cost of the corresponding edge (see (h) of Fig. 17).

[0202] Next, the problem state of the Steiner tree can be represented using a context embedding vector derived (or derived) from the previously selected nodes and their position encodings. This vector can play an important role in summarizing the current state and guiding the selection of the next node of the model. This can induce the selection of the next node based on the attention mechanism. Specifically, as illustrated in (a) of Fig. 18, the input at time point t can be composed of the embedding of the graph, the previous node, and the embedding of the first node. In the present invention, this can be modified as illustrated in (b) of Fig. 18. The sequence of nodes selected up to time point t can be represented as illustrated in (c) of Fig. 18, and the average embedding of the selected nodes can be represented as illustrated in (d) and (e) of Fig. 18. The average embedding of the selected nodes (or the average value of the embedding vector) can provide a summary of the partial solution. And, the set of remaining nodes (terminals) excluding the selected nodes can be represented as in (f) of Fig. 18. The average embedding of the remaining terminal nodes can be represented as in (g) and (h) of Fig. 18, and these terminals can summarize the remaining targets.

[0203] In this way, by adjusting context embedding, the present invention enables a model with autoregressive properties to effectively handle the Steiner tree problem. This adjustment reflects the remaining terminals that need to be connected to the current partial solution, allowing the model to focus on the key aspects of the Steiner tree problem.

[0204] Furthermore, in artificial intelligence (or neural network) models for combinatorial optimization problems, it is necessary to decode the raw output of the neural network into a solution that satisfies specific constraints of the combinatorial optimization problem.

[0205] Constraints in combinatorial optimization problems, unlike those in general large-scale language models (LLMs), are explicit and strict, and can include feasible solutions for specific combinatorial optimization tasks. For example, in the Steiner tree problem, i) all terminal nodes must be connected, ii) the selected set of edges must not form cycles to maintain the tree structure, and iii) duplicate edges connecting terminals must be excluded.

[0206] In the decoding process (or algorithm) for a Steiner tree according to the present invention, edges can be iteratively selected based on previously selected edges. In the present invention, an arbitrary terminal can be initially selected, and a graph containing only that terminal can be defined as a partial solution. Thereafter, edges that can be added to the current partial solution can be defined as a set of candidate edges. Among these candidates, edges can be selected based on scores calculated from the raw output of the neural network. The raw output of the neural network and a feasible solution (a solution that satisfies constraints) can each be represented as shown in Figure 19 (a).

[0207] And, as illustrated in (b) of Fig. 19, in the decoding process, the partial tree solution can be initialized as a node set. Here, a randomly selected terminal can be represented as in (c) of Fig. 19. In addition, as illustrated in (d) of Fig. 19, the edge set is initialized, and if not all terminal nodes are included in Vp (see (e) of Fig. 19), the process described below is repeated thereafter. At this time, in the case of a non-autoregressive approach, the edge with the highest score in the candidate edge set is selected (see (f) of Fig. 19). Conversely, in the case of an autoregressive approach, the node with the highest score in the node set is selected (see (g) of Fig. 19). Furthermore, as illustrated in (h) of Fig. 19, the edge with the minimum weight is selected, and the selected node is added to the node set, or the selected edge is added to the edge set (see (i) and (j) of Fig. 19).

[0208] Meanwhile, in the inference process, when input data related to the Steiner tree problem is input, the control unit (170) can perform inference on the Steiner tree problem using one of the previously learned combinatorial optimization models.

[0209] The industries and services to which the combinatorial optimization model according to the present invention can be applied may be diverse. For example, as illustrated in FIG. 1, at least one combinatorial optimization model according to the present invention may be utilized in a PCB design system that generates an optimal solution (i.e., an optimal wiring path) that satisfies various constraints required for PCB design (e.g., wiring no-go zones, wiring width and spacing, wiring angles, multi-layer wiring, etc.), or searches for the shortest path for wiring terminals at the minimum cost (or cost) based on user-entered PCB data.

[0210] In this case, the control unit (170) can perform inference on the Steiner tree problem by using an artificial intelligence model (e.g., the fourth artificial intelligence model (184)) having a non-autoregressive characteristic among the reinforcement learning models included in the combinatorial optimization model.

[0211] In one embodiment, when PCB data (200) including a net list (210), terminal information (220), and constraint information (230) is input from a user terminal (10) through a service page (1000), the control unit (170) can use the fourth artificial intelligence model (184) to conduct inference on PCB design, which is one of the Steiner tree problem fields. The fourth artificial intelligence model (184) can produce an optimal solution (or optimal path) that wires terminals (nodes) defined in the net list at the minimum cost while satisfying constraints, according to the PCB data.

[0212] As discussed above, the method for generating learning data and the method for learning a combinatorial optimization model using the same can provide an environment in which an artificial intelligence model can learn by interacting with various scenarios by generating a large-scale data set that includes various scenarios such as graphs, number of terminal nodes, data size, and edge distribution.

[0213] In addition, according to the method for generating learning data according to the present invention and the method for learning a combinatorial optimization model using the same, by providing a data set or learning environment that can be universally utilized in various learning environments, it is possible to provide an optimal environment in which various types of models with different characteristics can learn the Steiner Tree Problem (STP).

[0214] Furthermore, according to the method for generating learning data according to the present invention and the method for learning a combinatorial optimization model using the same, a large-scale high-quality data set that can be utilized in various learning environments can be constructed, and the generalization performance of an artificial intelligence model that solves the Steiner tree problem can be improved by training an artificial intelligence model using the constructed data set.

[0215] Furthermore, the method for generating learning data according to the present invention and the method for training a combinatorial optimization model using the same selectively train an AI model based on the size of the graph included in the dataset. This minimizes the costs and resource usage required for model training and inference, and enables universal support for a variety of graph sizes. This allows for optimal solutions tailored to various graph sizes, while leveraging the strengths of each model to maximize performance and efficiency.

[0216] Furthermore, the method for generating learning data according to the present invention and the method for training a combinatorial optimization model using the same utilize a dataset constructed to enhance the expressive power of partial solutions. This allows the combinatorial optimization model to be trained, thereby solving the Steiner tree problem, which relies on partial solution information, and significantly increasing the usability of the combinatorial optimization model. This allows the combinatorial optimization model to alleviate smoothing issues and produce more accurate solutions across large-scale instances.

[0217] That is, according to the method for generating learning data according to the present invention and the method for learning a combinatorial optimization model using the same, it is possible to provide an environment for solving complex combinatorial optimization problems in various industrial fields, services, research, etc., by providing a large-scale data set and learning environment including an accurate optimal solution.

[0218] Meanwhile, the present invention discussed above can be implemented as a program that is executed by one or more processes on a computer and can be stored on a medium (or recording medium) that can be read by the computer.

[0219] Furthermore, the present invention discussed above can be implemented as computer-readable code or instructions on a program-recorded medium. In other words, the present invention can be provided in the form of a program.

[0220] Meanwhile, computer-readable media include all types of recording devices that store data that can be read by a computer system. Examples of computer-readable media include hard disk drives (HDDs), solid-state disk drives (SSDs), silicon disk drives (SDDs), ROMs, RAMs, CD-ROMs, magnetic tapes, floppy disks, and optical data storage devices.

[0221] Furthermore, the computer-readable medium may include a storage device and may be a server or cloud storage device accessible via communication. In this case, the computer may download the program according to the present invention from the server or cloud storage device via wired or wireless communication.

[0222] Furthermore, in the present invention, the computer described above is an electronic device equipped with a processor, i.e., a CPU (Central Processing Unit), and there is no particular limitation on its type.

[0223] Meanwhile, the above detailed description should not be construed as limiting in any respect and should be considered illustrative. The scope of the present invention should be determined by a reasonable interpretation of the appended claims, and all modifications within the equivalent scope of the present invention are intended to be included within the scope of the present invention.

Claims

1. In a method for generating training data for learning the Steiner Tree Problem, A step of generating a graph based on multiple graph types and parameters until the nodes of the graph are connected by edges; A step of creating an instance for the Steiner Tree Problem by adding the generated graph to the data set; A step of calculating an optimal solution for the above instance using a specific solver; and A method for generating learning data, comprising the step of constructing a data set including the above instances and the above optimal solutions.

2. In paragraph 1, The steps for generating the above graph are: A method for generating learning data, characterized in that when there is a disconnected node, the generation of the graph is repeated so that the nodes are connected in all graphs.

3. In paragraph 2, A method for generating learning data, characterized in that the above graph is generated based on the number of instances.

4. In paragraph 1, In the above graph, the node is selected as a terminal according to a preset probability, A method for generating training data, wherein the cost of the above edge is assigned as a random integer from a truncated Gaussian distribution.

5. In paragraph 4, A method for generating training data in which the costs of the above graph, the above terminal, and the above edge are grouped in the above instance and included in the above data set.

6. In paragraph 1, A method for generating learning data, characterized in that the connection method of the edges changes depending on the plurality of graph types.

7. In paragraph 6, A method for generating learning data, characterized in that a graph corresponding to at least one of the plurality of graph types is generated by sampling an edge generation probability from a uniform distribution, sampling a degree of the graph, or sampling an average node degree.

8. In paragraph 7, The above plurality of graph types include at least one type different from the above, A method for generating learning data, characterized in that the above-mentioned different types of graphs are generated with the cost of the edges fixed.

9. In the learning method of the combinatorial optimization model (Neural Combinatorial Optimization) that calculates the Steiner Tree Problem, A step of generating a graph based on multiple graph types and parameters until the nodes of the graph are connected by edges; A step of creating an instance for the Steiner Tree Problem by adding the generated graph to the data set; A step of calculating an optimal solution for the above instance using a specific solver; and A method for learning a combinatorial optimization model, comprising the steps of constructing a data set including the above instances and the optimal solution, and training at least one of the combinatorial optimization models using the constructed data set.

10. In paragraph 9, The steps for generating the above graph are: A learning method for a combinatorial optimization model, characterized in that when there is a disconnected node, the generation of the graph is repeated so that the nodes are connected in all graphs.

11. In paragraph 10, A learning method for a combinatorial optimization model, characterized in that the above graph is generated based on the number of instances.

12. In paragraph 9, In the above graph, the node is selected as a terminal according to a preset probability, A learning method for a combinatorial optimization model, characterized in that the cost of the above edge is assigned as a random integer from a truncated Gaussian distribution.

13. In paragraph 12, A learning method for a combinatorial optimization model in which the costs of the above graph, the above terminal, and the above edge are grouped in the above instance and included in the above data set.

14. In paragraph 9, A learning method for a combinatorial optimization model, characterized in that the combinatorial optimization model includes at least one of a supervised learning model and a reinforcement learning model.

15. In paragraph 14, A learning method of a combinatorial optimization model, characterized in that the supervised learning model and the reinforcement learning model are classified into multiple model types based on the characteristics of autoregressive and non-autoregressive, respectively.

16. In paragraph 15, A learning method for a combinatorial optimization model, characterized in that it further includes a step of performing inference for the Steiner Tree Problem using an artificial intelligence model having the non-autoregressive characteristic among the reinforcement learning models.

17. In paragraph 9, The above learning steps are: A method for learning a combination optimization model, characterized in that one of the combination optimization models is selected based on the size of the graph, and the selected combination optimization model is trained using the constructed data set.

18. A program that is executed by one or more processes in an electronic device and can be stored in a computer-readable recording medium, The above program is, A step of generating a graph based on multiple graph types and parameters until the nodes of the graph are connected by edges; Step of creating an instance for the Steiner Tree Problem by adding the generated graph to the dataset; A step of calculating an optimal solution for the above instance using a specific solver; and A program stored on a computer-readable recording medium, characterized in that it includes commands for performing a step of constructing a data set including the above instance and the above optimal solution.

Images