WO2016174725A1 - Computer, and calculation method using neural network - Google Patents

Abstract

A computer for performing a calculation process using a neural network that is composed of a plurality of layers, each including one or more neurons, said computer being provided with: a storage unit which stores graph data comprising a plurality of nodes and one or more edges interconnecting the plurality of nodes, and also stores sample data including one or more values to be input to a neural network; and a creation unit which creates the neural network using the graph data, wherein the creation unit creates the neural network by first generating one or more neurons for each of a plurality of layers on the basis of the plurality of nodes included in the graph data, and then generating connections between the generated neurons in the plurality of layers on the basis of the one or more edges included in the graph data.

Description

Calculation method using computer and neural network

The present invention relates to a computer and a calculation method for executing processing of an optimization problem using a neural network.

In order to efficiently design and operate social infrastructure and cities, etc., process real-world and cyberspace data, analyze or predict the state of social infrastructure, etc., or control or guide social infrastructure, etc. Technology is drawing attention.

Processed data consists of environmental sensing data such as temperature and humidity, log data of machines such as automobiles, and log data of humans or organizations such as mail and SNS. The process using data is an optimization process for searching for an optimum state of elements (people, things, information, etc.) constituting the society.

The optimization process is a problem for obtaining a combination of input data that minimizes or maximizes a value (evaluation value) of a predefined evaluation function. In general, in order to search for a combination of input data having a minimum or maximum evaluation value from among all combinations of input data, a huge amount of calculation is required. This calculation amount is obtained by multiplying the number of searches by the calculation amount of the evaluation function. Therefore, in order to reduce the amount of calculation, a calculation method for obtaining an approximate solution and reducing the number of searches is widely used.

However, when the evaluation function is a very complicated problem, the above-described method cannot provide a sufficient speedup of processing.

For example, in the case of a warehouse layout problem that maximizes the number of pickings per unit time, the evaluation function is a composite function such as the total number of shelves, whether all shelves can be reached by a passage, or the degree of congestion. Therefore, an enormous amount of calculation is required to calculate this evaluation function.

In response to the above-mentioned problems, there is a method of speeding up processing by learning a calculation method using a neural network (NN) and improving efficiency. Patent Document 1 proposes a method of learning an image filter operation and FFT using a neural network and obtaining an approximate solution with low power. Also, referring to Patent Document 2, the image recognition processing by the convolutional neural network (CNN) is accelerated.

US Pat. No. 8,655,815 US Patent Application Publication No. 2014/0180989

However, the neural network used in the above-described two conventional techniques has a problem that it is difficult to learn a complicated evaluation function. The complex evaluation function deals with a problem such as a path problem that has a complicated interrelationship between elements of input data. In Patent Document 1, the input data is a vector, and in Patent Document 2, the input data is an image (matrix). For this reason, complex interrelationships cannot be reflected in the structure of the neural network.

In the technique described in Patent Document 1, when the input data is a vector, the structure of the neural network is connected to each element of the vector and the synapse of the first layer of the neural network in a complete bipartite graph. That is, a certain element of input data is connected to all the synapses of the first layer of the neural network, and the relationship between the elements of the input data is not reflected in the internal structure of the neural network. This becomes a factor of great deterioration of convergence in the learning process of the neural network.

In the technique described in Patent Document 2, when the input data is a matrix, each element in a specified window is connected to the synapse (feature map) of the first layer of the neural network for the input. The size of the window is 3 × 3, 5 × 5, etc., as in the filter operation of an image, and the mutual relationship between the elements of the input data is uniform (for example, the image has a lattice shape, Any pixel can be applied to the upper, lower, left and right pixels). However, this is not applicable when the interrelationship between the elements of the input data is not uniform. For example, in a scale free graph such as SNS, most elements have a correlation with a small number of elements, but a limited element (called a hub) has a correlation with a large number of elements.

Therefore, with the conventional technology, it is not possible to realize high-speed processing of optimization problems with complicated evaluation functions such as the aforementioned social infrastructure.

The present invention is to provide a technique capable of speeding up the processing of an optimization problem with a complicated evaluation function.

A typical example of the invention disclosed in the present application is as follows. That is, a computer that includes a processor and a memory connected to the processor and that performs arithmetic processing using a neural network including a plurality of layers including one or more neurons, and is included in one layer A connection is configured between one neuron and at least one neuron included in another layer, and the value input to one neuron included in the one layer is connected by the connection together with the weight. Output to at least one neuron included in the other layer, and the computer is input to a neural network and graph data including a plurality of nodes and one or more edges connecting the plurality of nodes. A storage unit for storing sample data for storing one or more values, and the graph data. A construction section for constructing a neural network; and a learning processing section for executing a learning process for determining the weights of a plurality of connections in the neural network by inputting the sample data to the neural network, The construction unit generates one or more neurons of each of the plurality of layers based on the plurality of nodes included in the graph data, and based on the one or more edges included in the graph data, The neural network is constructed by generating the connection between the one or more neurons included in each of the plurality of layers, and information on the constructed neural network is stored in the storage unit. To do.

According to the present invention, it is possible to construct a neural network reflecting a complex correlation in an optimization problem with a complicated evaluation function. This enables high-speed computation of optimization problem processing. Problems, configurations, and effects other than those described above will become apparent from the following description of embodiments.

FIG. 3 is an explanatory diagram illustrating an example of a configuration of a computer system according to the first embodiment. 3 is an explanatory diagram illustrating an example of a neural network according to Embodiment 1. FIG. FIG. 6 is an explanatory diagram illustrating an example of graph data according to the first embodiment. FIG. 6 is an explanatory diagram illustrating an example of graph data according to the first embodiment. It is explanatory drawing which shows another example of the graph data of Example 1. FIG. It is explanatory drawing which shows an example of the weight table of Example 1. FIG. 3 is a flowchart for describing learning processing executed by the computer according to the first embodiment. 6 is a flowchart for explaining a neural network construction process executed by the computer according to the first embodiment. It is explanatory drawing which shows the flow of construction of the characteristic map graph of Example 1. FIG. It is explanatory drawing which shows the flow of construction of the characteristic map graph of Example 1. FIG. FIG. 3 is an explanatory diagram illustrating an example of a neural network constructed by the computer according to the first embodiment. 4 is a flowchart for explaining identification processing executed by the computer according to the first embodiment. It is explanatory drawing which shows the conversion from the input data x of Example 2 to graph data. 10 is a flowchart for explaining optimization problem processing executed by the computer according to the second embodiment; It is explanatory drawing which shows an example of cell expression and graphing of the shelf arrangement | positioning layout candidate of Example 3. FIG. FIG. 10 is an explanatory diagram illustrating an example of an edge label allocation method in a shelf arrangement layout candidate graph according to a third embodiment. It is explanatory drawing which shows an example of the graph data of the shelf arrangement layout candidate of Example 3. 10 is a flowchart for explaining processing of an optimal layout problem executed by a computer according to a third embodiment. It is a flowchart explaining the process of the optimization problem based on the approximation algorithm which the conventional computer performs. It is a flowchart explaining the process of the optimal layout problem which the conventional computer performs.

In Example 1, a method for constructing a neural network using graph data as an input will be described.

FIG. 1 is an explanatory diagram illustrating an example of a configuration of a computer system according to the first embodiment.

As shown in FIG. 1, the computer system 100 according to the first embodiment includes a plurality of computers 101 and a storage system 102, and the plurality of computers 101 and the storage system 102 are connected via a network 103.

The computer system 100 of this embodiment includes three computers 101-1, 101-2, and 101-3. Note that the number of computers 101 may be smaller than three or larger than three.

The network 103 may be WAN (Wide Area Network), LAN (Local Area Network), SAN (Storage Area Network), and the like. Note that the present embodiment is not limited to the type of the network 103. In addition, the network connecting each of the plurality of computers 101 and the network connecting each of the plurality of computers 101 and the storage system 102 may be different networks.

The computer 101 executes neural network construction processing, arithmetic processing using the neural network, and the like. The computer 101 includes a processor 110, a memory 111, and a communication interface 112, and each component is connected to each other via a bus 114.

The processor 110 includes one or more CPUs 115 that execute arithmetic processing. The CPU 115 implements the functions of the computer 101 by executing a program stored in the memory 111. In addition, processing executed on the computer 101 is executed by one or more CPUs 115. One CPU 115 may execute a plurality of processes. Note that the CPU 115 may be an arithmetic unit such as an FPGA and a GPU.

The memory 111 stores a program executed by the CPU 115 (processor 110) and information used by the program. In addition, the memory 111 includes a memory space allocated to one process executed by the CPU 115. Note that the memory space may be secured on the memory areas of the plurality of memories 111, or may be secured on the memory area of one memory 111. The memory 111 may include a memory space for a plurality of processes. The program and information stored in the memory 111 will be described later.

The communication interface 112 communicates with an external device via the network 103. In this embodiment, the processor 110 accesses another computer 101 or the storage system 102 via the communication interface 112.

The storage system 102 stores various data used by the computer 101. The storage system 102 includes a processor 130, a memory 131, a communication interface 132, a disk interface 133, and a plurality of HDDs (Hard Disk Drives) 134, and each component is connected to each other via a bus 135.

The processor 130, the memory 131, and the communication interface 132 are the same as the processor 110, the memory 111, and the communication interface 112. The disk interface 133 is an interface for connecting to a plurality of HDDs 134. The HDD 134 is a storage device that stores various data.

Here, the program and information stored in the memory 111 of the computer 101 will be described.

The memory 111 stores a program for realizing the data processing unit 120. The CPU 115 that executes the data processing unit 120 executes a learning process and an identification process. In the learning process, the CPU 115 constructs a neural network and determines connection (edge) weights between neurons in the constructed neural network. In the identification process, the CPU 115 performs predetermined identification by inputting data to be identified into the constructed neural network.

The data processing unit 120 may be composed of a plurality of program modules. For example, the data processing unit 120 may include a construction unit that builds a neural network, a learning processing unit that executes learning processing, and an identification processing unit that executes identification processing. Moreover, the structure with which each computer module is provided in a different computer 101 may be sufficient.

Here, the neural network will be described. FIG. 2 is an explanatory diagram illustrating an example of the neural network according to the first embodiment.

The neural network 200 shown in FIG. 2 includes three layers: an input layer 201, an intermediate layer 202, and an output layer 203. Each layer is composed of one or more neurons 211. The neuron 211 in each layer is connected to at least one neuron 211 in another layer. Specifically, the neuron 211 in the input layer 201 is connected to at least one neuron 211 in the intermediate layer 202, and the neuron 211 in the intermediate layer 202 is connected to at least one neuron 211 in the output layer 203. In the following description, an edge connecting between the neurons 211 is also referred to as a connection 212. Connection 212 represents the output of data between neurons 211. A value input to each neuron 211 is output to a neuron 211 in another layer connected by the connection 212 together with an arbitrary weight. The weight represents the strength of connection between the neurons 211, and is determined by a learning process described later. The above is the description of the neural network. Returning to the description of FIG.

The memory 111 stores graph data 121, sample data 122, and a weight table 123.

The graph data 121 is data defining a graph structure composed of nodes corresponding to arbitrary elements and edges connecting the nodes. Details of the graph data 121 will be described later with reference to FIG. The sample data 122 is data used in learning processing using a neural network. The weight table 123 is information for managing weights that are processing results of the neural network learning process. Details of the weight table 123 will be described later with reference to FIG.

Note that the graph data 121 and the sample data 122 are information stored in the storage system 102. The CPU 115 acquires the graph data 121 and the sample data 122 from the storage system 102 and loads the acquired graph data 121 and the sample data 122 into the memory 111.

FIG. 3 is an explanatory diagram illustrating an example of the graph data 121 according to the first embodiment.

The graph data 121 includes an edge ID 301, a node ID 302, a label 303, and an edge attribute 304.

Edge ID 301 is edge identification information. The node ID 302 is identification information of a node connected via an edge corresponding to the edge ID 301. The direction of the edge is managed by an edge attribute 304 described later. The label 303 is an edge label given by classifying edges based on length, direction, and the like.

The edge attribute 304 is edge attribute information. In this embodiment, edge length, edge direction, and the like are managed as edge attribute information.

Here, edge labels will be described with reference to FIGS. FIG. 4 is an explanatory diagram illustrating an example of the graph of the first embodiment.

The graph shown in FIG. 4 is a graph corresponding to the graph data 121 shown in FIG. The graph shown in FIG. 4 includes three nodes I0, I1, and I2, and includes five edges E0, E1, E2, E3, and E4.

As shown in FIGS. 3 and 4, the edge E0 and the edge E2 have the edge length “1” and the same direction “south”. The edge E1 and the edge E3 have an edge length of “1” and an orientation of “north”. The edge 4 has an edge length of “2” and a direction of “north”. Therefore, the same label “0” is given to the edge E0 and the edge E2, and the same label “1” is also given to the edge E1 and the edge E3. On the other hand, the label “2” is given to the edge 4.

・ The number of labels to be given is more than the combination of edge length and orientation set. Here, since there are three types of combinations (length 1, south direction), (length 1, north direction), and (length 2, north direction), the labels are also 0, 1, 2, and so on. Are prepared, and combinations and labels are associated with each other.

Note that the graph data 121 may be managed separately for data for managing the node structure and data for managing the edge structure.

FIG. 5 is an explanatory diagram showing another example of the graph data 121 of the first embodiment.

The graph data 121 shown in FIG. 5 includes edge structure information 500 and node structure information 510. The edge ID 501, node ID 502, label 503, and edge attribute 504 of the edge structure information 500 are the same as the edge ID 301, node ID 302, label 303, and edge attribute 304.

The node structure information 510 includes a node ID 511, an edge ID (outflow) 512, an edge ID (inflow) 513, and a node attribute 514. The node ID 511 is the same as the node ID 302.

The edge ID (outflow) 512 is identification information of an edge flowing out from the node corresponding to the node ID 511. That is, the node is a node that is the start point of the edge corresponding to the edge ID (outflow) 512. The edge ID (inflow) 513 is identification information of an edge flowing into the node corresponding to the node ID 511. That is, the node is a node that is an end point of the edge corresponding to the edge ID (inflow) 513.

The node attribute 514 is node attribute information. In this embodiment, the node type and the like are managed as edge attribute information. For example, in the case of graph data representing the layout of a warehouse, the node type indicates a shelf or a passage.

FIG. 6 is an explanatory diagram illustrating an example of the weight table 123 according to the first embodiment.

The weight table 123 includes a label 601, a weight label 602, and edge information 603. The label 601 is the same as the label 303.

The weight label 602 is a label given by classifying the edge weights in the neural network. The weight label 602 corresponds to the label 601. That is, the label 601 is an edge label in the graph data, and the weight label 602 is an edge label in the neural network.

Edge information 603 is identification information of connections in the neural network to which the same weight label 602 is assigned. In this embodiment, the connection is also described as a map edge.

In the graph data 121, a map edge composed of edges having the same correlation (topology) between nodes, that is, the same length, direction, etc., is subjected to the same correction when the weight is corrected in the learning process. For this reason, in this embodiment, the computer 101 holds the weight table 123 that abstracts and manages the topology between nodes, thereby realizing high-speed learning processing and identification processing.

Here, the abstraction of topology between nodes will be described in detail. When the correlation between the elements (nodes) of the input data (graph data) is the same, the correlation between all the elements of the input data, that is, the topology is abstracted by making the edge weights in the neural network the same. Turn into.

For example, as graph data, consider data indicating a road network in which nodes represent intersections and edges represent connections between intersections. The correlation between the elements of the graph data is that there is a second intersection at a north distance 1 of the first intersection, the first intersection and the second intersection are connected by the first edge, and the third intersection It is assumed that there is a fourth intersection at a distance 1 in the north direction, and the third intersection and the fourth intersection are connected by the second edge.

The above-mentioned four intersections have the same topology even if they represent the intersections of different points, so the first edge and the second edge should be handled in the same manner in the neural network. Therefore, the same label determined based on the attribute of the edge (length 1, facing north) is given to the first edge and the second edge. Thus, edges with the same label also share the neural network weight label.

Thus, even if edges connect between different nodes, if the topology between the nodes is the same, each edge can be handled without distinction. That is, the topology between nodes is abstracted.

Next, processing executed by the computer 101 will be described. First, the learning process will be described with reference to FIG. FIG. 7 is a flowchart illustrating the learning process executed by the computer 101 according to the first embodiment.

When the computer 101 receives an instruction to start processing, the computer 101 starts processing described below.

First, the CPU 115 acquires the graph data 121 from the storage system 102 and stores it in the memory 111 (step S701). The CPU 115 executes a neural network construction process using the acquired graph data 121 (step S702). Details of the construction process of the neural network will be described later with reference to FIG.

Next, the CPU 115 acquires the sample data 122 from the storage system 102 and stores it in the memory 111 (step S703).

Next, the CPU 115 starts a loop process of error back propagation processing (step S704). In this loop process, the CPU 115 repeatedly executes the processes from step S704 to step S708. When the error calculated by the error back-propagation process executed in this loop process falls below a preset threshold value, or when the error back-propagation process is executed a predetermined number of times, the loop process Ends. Further, the CPU 115 starts a loop process for sample data (step S705). In the loop processing of sample data, the processing inside the loop is executed for each piece of sample data for the plurality of sample data acquired in step S703. Further, the CPU 115 executes error back propagation processing for one sample data (step S706).

In the error back-propagation process, the CPU 115 receives a certain sample data, compares the output result of the neural network with respect to the input and the teacher data corresponding to the sample data, and reduces the error between the two data. The weights from the layer close to the output layer (intermediate layer) to the input layer are updated in order. That is, the weight of the input data is updated in the direction opposite to the output direction.

In the sample data loop processing, the CPU 115 executes the above-described processing for each of the plurality of sample data 122. In the error back-propagation process in step S706, the update of the weight for arbitrary sample data is performed only once.

On the other hand, in the loop process of the error back propagation process, the error back propagation process is executed a plurality of times in order to minimize the error. Specifically, the CPU 115 repeatedly performs error back propagation processing on each of the plurality of sample data 122 until a predetermined condition is satisfied.

That is, the loop process of the error back propagation process is performed for convergence of the total error of a plurality of sample data by the error back propagation method. In the sample data loop processing, the weights of the plurality of sample data 122 are updated.

Next, the CPU 115 determines whether or not error back-propagation processing has been executed for all sample data (step S707).

If it is determined that the error back-propagation process has not been performed on all sample data, the CPU 115 returns to step S705 and executes the same process.

If it is determined that the error back-propagation processing has been performed on all sample data, the CPU 115 determines whether or not a predetermined condition is satisfied (step S708).

If it is determined that the predetermined condition is not satisfied, the CPU 115 returns to step S704 and executes the same processing.

If it is determined that the predetermined condition is satisfied, the CPU 115 stores the learning result in the memory 111 (step S709). Thereafter, the CPU 115 ends the process. Note that the learning result may be stored in the storage system 102.

The learning result includes information such as information indicating the configuration of the constructed neural network and information in which the edge label is associated with the calculated weight.

FIG. 8 is a flowchart illustrating a neural network construction process executed by the computer 101 according to the first embodiment. 9A and 9B are explanatory diagrams illustrating a flow of construction of a feature map graph according to the first embodiment. FIG. 10 is an explanatory diagram illustrating an example of a neural network constructed by the computer 101 according to the first embodiment.

In the neural network construction processing, definition information including graph data 121, parameters related to the structure of the neural network, the number of dimensions of the output layer (number of nodes), and the like are input. The parameters relating to the structure of the neural network include the number of layers of the neural network, the number of feature map graphs included in one intermediate layer, and the like.

Here, the feature map graph shows a group of neurons constituting one intermediate layer. That is, the intermediate layer includes one or more feature map graphs. As will be described later, the feature map graph includes a plurality of map nodes. Map nodes correspond to neurons.

CPU 115 sets an input layer and an output layer of the neural network (step S801).

Specifically, the CPU 115 sets a node group of the graph data 121 as an input layer. That is, one node of the graph data 121 is set as one neuron in the input layer. Further, the CPU 115 sets an output layer including the same number of nodes as the number of dimensions of the output layer.

Next, the CPU 115 starts loop processing for constructing a feature map graph using the graph data 121 (step S802). The loop processing for constructing the feature map graph is repeatedly executed for the number of stages of the designated neural network.

First, the CPU 115 generates a map node (neuron) of the feature map graph (step S803).

Here, the feature map graph indicates the feature corresponding to the weight table for each map node included in the previous layer of the intermediate layer including the feature map graph.

For example, in a road network, when the weight table fires on a three-way road with a distance of “1” (fires for a relationship of distance 1 in the direction of north, south, west, etc.), the previous layer (eg, input layer) Among the neurons included in, the map node corresponding to the neuron that is the three-way is fired, and the other map nodes are not fired. Here, firing means that the output takes a large positive value. Therefore, the feature map graph is a graph showing the characteristics of the three-way road. A plurality of such feature map graphs are generated in one layer, and a complex topology can be expressed by configuring a neural network using layers including a plurality of feature map graphs. That is, a complicated evaluation function such as a nonlinear evaluation function can be expressed.

In step S803, specifically, the CPU 115 assigns identification information of the feature map graph, and generates the same number of map nodes as the number of nodes included in the graph data 121 as shown in FIG. 9A. That is, intermediate layer neurons are generated. At this time, the nodes of the graph data 121 and the map nodes of the feature map graph are associated one-to-one. In FIG. 9A, map node F0 corresponds to node I0, map node F1 corresponds to node I1, and map node F2 corresponds to node I2.

When it is necessary to set a plurality of feature map graphs in one layer, the CPU 115 generates a map node of the feature map graph according to the same procedure as described above.

Next, the CPU 115 generates a map edge connecting the node of the graph data 121 and the map node of the feature map graph based on the graph data 121 (step S804).

Specifically, the CPU 115 generates an edge connecting the nodes of the graph data 121 as a map edge connecting the node of the graph data 121 and the node of the feature map graph. That is, a connection that connects the neurons in the input layer and the neurons in the intermediate layer is generated.

The CPU 115 first selects a target map node from among a plurality of map nodes included in the graph data 900 corresponding to the input layer. Based on the graph data 900, the CPU 115 identifies a node connected to the node corresponding to the target map node via an edge. The CPU 115 generates a map edge between the map node corresponding to the identified node included in the feature map graph and the target map node.

When generating a map edge between two intermediate layers, a map edge is generated based on the same procedure. That is, the CPU 115 selects a target map node from a plurality of map nodes included in the input side intermediate layer. Based on the graph data 900, the CPU 115 identifies a node connected to the node corresponding to the target map node via an edge. The CPU 115 generates a map edge between a map node corresponding to the identified node included in the output-side feature map graph and the target map node.

For example, since the edge E0 of the graph data 121 is an edge from the node I0 to the node I1, an edge is generated from the node I0 to the node F1 corresponding to the node I1, and temporarily stored in the memory 111 as the map edge FM0_E0. . Further, since the edge E1 of the graph data 121 is an edge from the node I1 to the node I0, an edge is generated from the node I1 to the node F0 corresponding to the node I0, and temporarily stored in the memory 111 as the map edge FM0_E1. . Similar processing is executed for other map edges. The map edge as shown in FIG. 9B is generated by the processing described above.

Next, the CPU 115 generates a weight table 123 for the weight of the map edge connecting the graph data and the feature map graph (step S805). Specifically, the following processing is executed.

First, the CPU 115 generates an empty weight table 123. The CPU 115 refers to the label 303 of the graph data 121 and creates as many entries in the weight table 123 as the number of label types.

The CPU 115 sets the value of the label 303 to the label 601 of each generated entry. Further, the CPU 115 generates a weight label associated with each label according to a predetermined standard, and sets the generated weight label in the weight label 602.

The CPU 115 acquires the edge ID 301 of the edge having the same value of the label 303, specifies the map edge corresponding to the acquired edge ID 301, and sets the specified map edge identification information in the edge information 603. The above is the description of the process in step S805.

CPU 115 determines whether or not the number of layers of the designated neural network has been generated (step S806).

When it is determined that the number of layers of the designated neural network is not generated, the CPU 115 returns to step S802 and repeatedly executes the same processing.

When it is determined that the number of layers of the designated neural network is generated, the CPU 115 generates a connection between the output layer and the intermediate layer immediately before the output layer (step S807). Thereafter, the CPU 115 ends the neural network construction process.

Specifically, the CPU 115 connects a map node and all the neurons included in the output layer to each map node included in the feature map graph of the intermediate layer immediately before the output layer. Create an edge. That is, each neuron included in the output layer and each map node (neuron) included in the feature map graph of the intermediate layer immediately before the output layer are connected in a complete bipartite graph.

The neural network as shown in FIG. 10 is constructed by the above processing.

The neural network in FIG. 10 includes graph data 900 that is an input layer, three intermediate layers, and an output layer 920. Each intermediate layer is composed of a two-stage feature map graph 910. In addition, a weight table 123-1 is provided from the nodes included in the graph data 900 to the feature map graph 910-2 for the edges connecting the nodes included in the graph data 900 and the nodes included in the feature map graph 910-1. A weight table 123-2 is generated for edges to included nodes. The feature map graph 910-3 has a weight table 123-3, the feature map graph 910-4 has a weight table 123-4, the feature map graph 910-5 has a weight table 123-5, and the feature map graph 910-6. The weight table 123-6 is generated.

Information on the constructed neural network is stored in the memory 111 in the form of input layer node and edge information, number of feature map graphs of each layer, weight table of each feature map graph, and output layer weight table. . Information about the constructed neural network may be stored in the storage system 102.

Next, the identification process will be described with reference to FIG. FIG. 11 is a flowchart illustrating the identification processing executed by the computer 101 according to the first embodiment.

The computer 101 starts the processing described below when receiving an instruction to start processing or when data to be identified is input.

First, the CPU 115 acquires the graph data 121 from the storage system 102 and stores it in the memory 111 (step S1101). The topology of the graph data 121 acquired during the learning process and the topology of the graph data 121 acquired during the identification process may be different.

The CPU 115 executes a neural network reconstruction process using the acquired graph data 121 (step S1102). In the reconfiguration processing of the neural network, the same processing as in FIG. 8 is executed using the acquired graph data 121. However, the processing in step S805 is partially different.

Specifically, the CPU 115 acquires the weight label generated in the learning process from the memory 111 without generating the weight label again, and generates the weight table 123 using the acquired weight label. Further, since the weight corresponding to the weight label is calculated in the learning process, a weight is given to each edge of the neural network based on the calculated value.

In the learning process, the weight label is assigned based on the attribute of the edge connecting the nodes. Therefore, even if the graph data 121 is different, the same weight label is assigned to the edge having the same attribute. Therefore, processing using the learning result is executed.

Next, the CPU 115 acquires the target data from the storage system 102 or the like and stores it in the memory 111 (step S1103).

Next, the CPU 115 performs signal propagation using a neural network (step S1104), and stores an output result (output vector) in the memory 111 (step S1105). Note that the output result may be stored in the storage system 102.

According to the first embodiment, by inputting a complex interrelation between nodes as graph data and constructing a neural network, the complex interrelation can be reflected in the structure of the neural network. That is, it becomes possible to learn a complicated evaluation function.

In the second embodiment, the speeding up of the optimization problem processing using the neural network described in the first embodiment will be described. Hereinafter, the second embodiment will be described focusing on differences from the first embodiment.

Since the configuration of the computer system 100 according to the second embodiment is the same as that of the computer system 100 according to the first embodiment, the description thereof is omitted. The configurations of the computer 101 and the storage system 102 according to the second embodiment are the same as those of the computer 101 and the storage system 102 according to the first embodiment, and thus description thereof is omitted.

Generally, when the optimization problem is input data x1 to xn and an evaluation function f (x1,..., Xn), the value of the evaluation function, that is, the input data x1 to The problem is to determine the value or state of xn.

At this time, if the combination of the values of the input data x1 to xn is very large, the amount of calculation related to the optimization problem will be very large. Therefore, an approximation algorithm is used to reduce the calculation amount. Examples of the approximation algorithm include a Monte Carlo method, a particle method, a genetic algorithm, and simulated annealing. The approximation algorithm as described above reduces the amount of calculation related to the optimization problem by reducing the combination of the input data x1 to xn.

FIG. 18 is a flowchart for explaining processing of an optimization problem based on an approximation algorithm executed by a conventional computer. Here, an optimization problem is considered in which a vector x composed of n components xi is input data and the evaluation function f (x1,..., Xn) is minimized. The subscript i is an integer from 1 to n.

After the computer initializes the input data x (step S1801), the computer proceeds to step S1802. The calculator calculates an evaluation function using the value of the input data x (step S1802). Specifically, the calculator calculates an evaluation value by substituting the initial value of each component xi into the evaluation function after determining the initial value of each component xi of the input data.

Next, the computer determines whether or not the calculated evaluation value is smaller than the current minimum value (step S1803). If the evaluation value is calculated using the initial value of the input data x, there is no minimum value at this point. Therefore, the computer proceeds to step S1807 without executing the determination process in step S1803.

When it is determined that the calculated evaluation value is greater than or equal to the current minimum value, the calculator determines a combination (search point) of the values of each component xi (step S1807). Thereafter, the computer returns to step S1802 and executes the same processing. Note that the search point determination method varies depending on the approximation algorithm used.

When it is determined that the calculated evaluation value is smaller than the current minimum value, the calculator updates the calculated evaluation value as the minimum value (step S1804).

Next, the computer determines whether or not the current minimum value is smaller than the threshold value (step S1805).

If it is determined that the current minimum value is greater than or equal to the threshold, the computer determines a combination (search point) of the values of each component xi (step S1807). When it is determined that the current minimum value is smaller than the threshold value, the computer outputs a combination of values of each component xi that minimizes the evaluation value (step S1806), and ends the process.

The conventional approximation algorithm reduces the number of searches. However, when the target problem is complicated, the amount of calculation of the evaluation function for each search point increases, which becomes a problem of speeding up the processing of the optimization problem.

Example 2 shows an example in which the calculation processing of the evaluation function is accelerated using a neural network.

First, the computer 101 converts the input data x into graph data, and executes the learning process of the first embodiment using the graph data as an input. Here, a method for converting the input data x into graph data will be described.

FIG. 12 is an explanatory diagram showing conversion from input data x to graph data in the second embodiment. In the example shown in FIG. 12, it is assumed that the input data x is a three-dimensional vector. The components of the input data x are x0, x1, and x2.

The computer 101 defines each component x0, x1, and x2 of the input data 1100 as a node. The computer 101 generates an edge connecting nodes based on the characteristics of the vector x in the three-dimensional space. For example, a method of generating an edge when the average value of the vector x is smaller than a threshold value, or an edge when a distance from a reference point in a three-dimensional space (for example, Euclidean distance or Manhattan distance) is smaller than the threshold value. A generation method is conceivable.

Also, as a method for determining an edge label in the learning process, for example, when a method of generating an edge based on a distance is used, it can be determined based on a positional relationship between a reference point and each coordinate.

Further, in the error back propagation process, the process is executed using the evaluation value corresponding to the vector x converted into the graph data as the teacher data. In this embodiment, since this is an optimization problem for obtaining the minimum evaluation value, the teacher data is “0” when the evaluation value is less than or equal to the threshold value, and the teacher data is “1” when the evaluation value is greater than the threshold value. Shall. By defining in this way, when the evaluation value is smaller than the threshold value, the neural network is constructed so that the output becomes “0”.

After the learning process as described above is completed, the computer 101 starts a specific optimization problem process. FIG. 13 is a flowchart for explaining the optimization problem processing executed by the computer 101 according to the second embodiment. The same steps as those of the conventional optimization problem processing are denoted by the same reference numerals, and the description of the processing is omitted.

The computer 101 initializes the input data x (step S1801), and then calculates an evaluation value using a neural network (step S1301).

Specifically, the computer 101 executes the arithmetic processing using the neural network by inputting the value of each component of the input data to the node of the input layer in the neural network corresponding to the component xi. The evaluation value calculation process using the neural network can be performed at high speed because the calculation amount is smaller than that of a general evaluation function calculation process.

In this embodiment, when the evaluation value calculated using the neural network is smaller than the threshold value, the output is “0”.

Next, the computer 101 determines whether or not the evaluation value calculated using the neural network is “0” (step S1302).

If it is determined that the evaluation value calculated using the neural network is not “0”, the computer 101 proceeds to step S1807.

When it is determined that the evaluation value calculated using the neural network is “0”, the computer 101 calculates an evaluation function using the value of the input data x (step S1802).

In general, the calculation processing of the neural network, which is a combination of the product-sum calculation processing, requires less calculation amount than the calculation processing using a complicated evaluation function. On the other hand, the accuracy of the evaluation value calculated using the neural network is lower than that using the evaluation function.

Therefore, in the second embodiment, the processing of the optimization problem is speeded up by using the evaluation value calculation processing using the neural network as a kind of filter. That is, by calculating the evaluation function only when the evaluation value is “0”, the number of executions of the arithmetic processing using the evaluation function can be reduced.

As described above, in the second embodiment, the arithmetic processing using the neural network is handled as the search processing for the optimum solution with a coarse granularity. Normally, different algorithms need to be constructed in search processing for optimal solutions with different granularities. However, in the second embodiment, it is possible to realize search processing for optimal solutions with different granularities using the same algorithm.

In the third embodiment, as a specific example, the speeding up of the optimal layout problem processing of warehouse shelves and passages will be described.

Since the configuration of the computer system 100 of the third embodiment is the same as that of the computer system 100 of the first embodiment, the description thereof is omitted. The configurations of the computer 101 and the storage system 102 according to the third embodiment are the same as those of the computer 101 and the storage system 102 according to the first embodiment, and a description thereof will be omitted. In the third embodiment, the data processing unit 120 has a function (graph data generation unit) that analyzes input data and generates graph data based on the analysis result. The analysis result includes the arrangement of a plurality of nodes, the distance between edges connecting the nodes, and the like.

FIG. 19 is a flowchart for explaining the optimal layout problem processing executed by a conventional computer.

First, the computer receives an initial layout 1920 (step S1901). Here, the initial layout 1920 includes information such as the shape of the target warehouse and the restricted entry area 1921 in the warehouse.

Next, the computer sets the entrance / exit of the warehouse which is the initial layout 1920 (step S1902). Specifically, the computer sets a predetermined number of gateways 1922 at predetermined positions in the initial layout 1920. In addition, the number and position of an entrance / exit shall be given previously. The layout in which the entrance / exit is set becomes a layout 1930 as shown in FIG.

Next, the computer generates a plurality of shelf arrangement layout candidates 1940 by setting a predetermined number of shelves 1923 at predetermined positions in the warehouse corresponding to the layout 1930 (step S1903).

Specifically, the computer receives the layout 1930 and outputs a plurality of shelf arrangement layout candidates 1940 having different numbers of shelves and different arrangements of shelves. As an arrangement method of the shelves, for example, an optimization method such as simulated annealing is used. Here, it is assumed that N shelf arrangement layout candidates having different shelf arrangements are output. Here, as an evaluation function for optimizing the shelf arrangement, for example, the number of shelves and the shape of the arrangement can be considered.

Next, the computer starts a loop process for the shelf arrangement layout candidate 1940 (step S1904). Specifically, the computer selects a target shelf arrangement layout candidate 1940 from among a plurality of shelf arrangement layout candidates 1940.

Next, the computer executes a path optimization process for the selected shelf arrangement layout candidate 1940 (step S1905).

Here, the optimization process of the passage and the passage direction is executed on the target shelf arrangement layout candidate 1940. The computer calculates a passage layout layout candidate 1950 as a result of the optimization process. An arrow 1924 of the path layout layout candidate 1950 indicates the path and the direction of the path. One passage arrangement layout candidate 1950 is output for one shelf arrangement layout candidate 1940.

Note that the passage and passage direction indicate, for example, a passage such as a shelf or a cart on which a load is placed and the traveling direction thereof. Here, as the evaluation function of the optimization process in the passage and the passage direction, the entrance / exit and the path length of each shelf can be considered. Further, it is assumed that the layout having the smallest evaluation value is output as the path layout layout candidate 1950.

Next, the computer determines whether or not the passage optimization processing has been completed for all shelf arrangement layout candidates 1940 (step S1906).

When it is determined that the path optimization process has not been completed for all the shelf arrangement layout candidates 1940, the computer selects a new shelf arrangement layout candidate 1940 and executes the same process. On the other hand, when it is determined that the path optimization process has been completed for all the shelf layout layout candidates 1940, the computer selects the optimal layout 1960 from the N path layout layout candidates 1950 (step S1907).

Specifically, the computer selects the optimum layout 1960 from the passage arrangement layout candidates 1950 based on the value of the evaluation function of the shelf arrangement optimization, that is, the evaluation value, and processes the selected optimum layout 1960. Output as a result.

In the above-described optimal layout problem processing, two optimizations are performed: loop processing of the shelf layout layout candidate 1940 and passage optimization processing. Here, the path optimization process for one shelf arrangement layout candidate 1940 corresponds to an evaluation function calculation process. Therefore, in this embodiment, the processing speed is increased by applying arithmetic processing using a neural network to the path optimization processing.

In the passage optimization process, one shelf arrangement layout candidate 1940 is input to the computer, and the computer outputs one passage arrangement layout candidate 1950 as an output.

The computer 101 according to the third embodiment first converts the input shelf arrangement layout candidate 1940 into graph data in order to realize the optimization processing shown in the first and second embodiments. Here, a method of converting the shelf arrangement layout candidate 1940 into graph data will be described with reference to FIGS.

FIG. 14 is an explanatory diagram illustrating an example of cell representation and graphing of the shelf arrangement layout candidate 1940 according to the third embodiment. FIG. 15 is an explanatory diagram illustrating an example of an edge label assignment method in the graph of the shelf arrangement layout candidate 1940 according to the third embodiment. FIG. 16 is an explanatory diagram illustrating an example of the graph data of the shelf arrangement layout candidate 1940 according to the third embodiment.

The computer 101 divides the shelf arrangement layout candidate 1940 into cells as shown in FIG. Further, the computer 101 sets values corresponding to the restricted entry area 1921, the entrance 1922, the shelf 1923, and the passage 1924 in each cell. Here, it is assumed that “−1” is set in the restricted entry area 1921, “0.5” is set in the entrance 1922, “0” is set in the shelf 1923, and “1” is set in the passage 1924.

Through the above processing, the shelf arrangement layout candidate 1940 can be expressed as a set of cells as shown in FIG.

Next, the computer 101 graphs the set of cells. Here, graphing of a set of cells focusing on the cell 1410-1 and the cell 1410-2 will be described.

The computer 101 generates a node corresponding to each cell such as the cell 1410-1 and the cell 1410-2. The computer 101 generates an edge between the node 1440-1 corresponding to the cell 1410-1 and another node, and also generates an edge between the node 1411-1 corresponding to the cell 1410-2 and the other node. Is generated.

In this embodiment, an edge is generated between two cells in the vertical direction from the cell 1410-1 and the cell 1410-1, and two cells in the horizontal direction of the cell 1410-1 and the cell 1410-1 are generated. An edge is generated between -1. Further, in this embodiment, an edge is generated between two cells in the upward direction from the cell 1410-2 and the cell 1410-2, and two cells in the left-right direction of the cell 1410-2 An edge is generated with the cell 1410-2. For example, an edge is generated between the node 1440-1 and the node 1440-2, and an edge is generated between the node 1440-1 and the node 1440-3.

Through the above processing, the set of cells focused on the cell 1410-1 is converted into a graph as shown in the graph 1 (1430-1), and the set of cells focused on the cell 1410-2 is converted to the graph 2 ( 1430-2).

Note that the edge connecting the nodes can be freely set to a specific shape such as a square or a rhombus, and a size. In the present embodiment, it is assumed that the prohibition rule that no edge is generated between cells having a value of “−1” is applied.

Next, the computer 101 assigns a label to the edge. A pre-defined label table 1600 is used for assigning labels to edges. In the label table 1600 shown in FIG. 16, numbers (labels) “1” to “8” are assigned according to the direction and distance of the cell that is the end point of the edge from the cell that is the start point of the edge. The computer 101 assigns labels to the edges based on the direction and distance between the cell of interest and other cells.

For example, in the case of graph 1 (1430-1), the edge 1510-1 is an edge that is connected to the node 1440-2 that is “distance 1” “upward” from the node 1440-1, so The label “1” is assigned to 1510-1. Further, since the edge 1510-2 is an edge that is connected to the node 1440-2 that is “distance 2” “upward” from the node 1440-1, the computer 101 assigns the label “5” to the edge 1510-2. . On the other hand, different labels are assigned to the edges 1510-3 and 1510-4 whose directions are opposite to those of the edges 1510-3 and 1510-4. That is, since the edge 1510-3 is an edge that is connected “downward” to the node 1440-1 “distance 1” from the node 1440-2, the computer 101 assigns the label “2” to the edge 1510-3. . Further, since the edge 1510-4 is an edge that is connected “downward” to the node 1440-1 at “distance 2” from the node 1440-3, the computer 101 assigns the label “6” to the edge 1510-4. .

The computer 101 executes the above-described processing for all edges. By executing the above processing for all the cells, the shelf arrangement layout candidate 1940 is converted into graph data as shown in FIG. In FIG. 16, in order to avoid the complexity of the figure, the labels “5”, “6”, “7”, and “8” assigned to the edge of “distance 2” are connected by the edge and the edge. No nodes are omitted.

The computer 101 executes a neural network construction process using a plurality of graph data of each of the plurality of shelf arrangement layout candidates 1940 as input data. Note that the neural network construction process is the same as that of the first embodiment, and a description thereof will be omitted.

FIG. 17 is a flowchart for explaining the optimum layout problem processing executed by the computer 101 according to the third embodiment. The same steps as those of the conventional optimization problem processing are denoted by the same reference numerals, and the description of the processing is omitted.

The computer 101 receives the shelf arrangement layout candidate 1940 selected in step S1904 and calculates an evaluation value using a neural network (step S1701). Here, the same processing as step S1301 of the second embodiment is executed. However, the evaluation function is different. In this embodiment, when the evaluation value calculated using the neural network is smaller than the threshold value, the output is “0”.

Next, the computer 101 determines whether or not the evaluation value calculated using the neural network is “0” (step S1702).

If it is determined that the evaluation value calculated using the neural network is not “0”, the computer 101 proceeds to step S1906.

When it is determined that the evaluation value calculated using the neural network is “0”, the computer 101 executes a path optimization process (step S1905).

Here, taking a specific warehouse as an example, the accuracy and speed of arithmetic processing when FIG. 17 is applied will be described. Here, it is assumed that the warehouse is “23” vertically and “23” horizontally. In step S1903, “923” shelf layout layout candidates 1940 are determined. Of the “923” shelf layout layout candidates 1940, “200” shelf layout layout candidates 1940 are input to the computer 101 as sample data for the learning process. The remaining “723” shelf layout layout candidates 1940 are handled as unknown data.

At this time, the learning accuracy for “200” sample data is 100%, and the learning accuracy for all data including unknown data is 97%.

In this embodiment, since it is a problem of obtaining the minimum value of the evaluation function, when attention is paid to the 10th sample data from the bottom of the evaluation value, it is determined that the sample data has a low evaluation value in all the neural networks. Therefore, the final output result does not change even if the calculation function of the evaluation function for the predetermined data is skipped by using the output of the neural network for the problem of obtaining the minimum value of the evaluation function. Therefore, the processing of the present embodiment outputs the same optimal layout 1960 as the conventional optimization problem processing. Therefore, the calculation result has the same accuracy as the conventional one.

On the other hand, the number of data on which the passage optimization process has been executed is about 3% of the “923” shelf layout layout candidates 1940, which can realize a speed increase of 5 times that of the conventional process.

In addition, this invention is not limited to the above-mentioned Example, Various modifications are included. Further, for example, the above-described embodiments are described in detail for easy understanding of the present invention, and are not necessarily limited to those provided with all the described configurations. Further, a part of the configuration of each embodiment can be added to, deleted from, or replaced with another configuration.

In addition, each of the above-described configurations, functions, processing units, processing means, and the like may be realized by hardware by designing a part or all of them with, for example, an integrated circuit. The present invention can also be realized by software program codes that implement the functions of the embodiments. In this case, a storage medium in which the program code is recorded is provided to the computer, and a CPU included in the computer reads the program code stored in the storage medium. In this case, the program code itself read from the storage medium realizes the functions of the above-described embodiments, and the program code itself and the storage medium storing it constitute the present invention. Examples of storage media for supplying such program codes include flexible disks, CD-ROMs, DVD-ROMs, hard disks, SSDs (Solid State Drives), optical disks, magneto-optical disks, CD-Rs, magnetic tapes, A non-volatile memory card, ROM, or the like is used.

Further, the program code for realizing the functions described in this embodiment can be implemented by a wide range of programs or script languages such as assembler, C / C ++, Perl, Shell, PHP, Java, and the like.

Furthermore, by distributing the program code of the software that realizes the functions of the embodiments via a network, the program code is stored in a storage means such as a hard disk or memory of a computer or a storage medium such as a CD-RW or CD-R. The CPU included in the computer may read and execute the program code stored in the storage unit or the storage medium.

In the above-described embodiments, the control lines and information lines indicate those that are considered necessary for the explanation, and do not necessarily indicate all the control lines and information lines on the product. All the components may be connected to each other.

Claims (14)

1. A computer comprising a processor and a memory connected to the processor, and executing a calculation process using a neural network composed of a plurality of layers including one or more neurons,
   A connection is formed between one neuron included in one layer and at least one neuron included in another layer,
   A value input to one neuron included in the one layer is output to at least one neuron included in the other layer connected by the connection together with a weight,
   The calculator is
   A storage unit for storing a plurality of nodes and graph data composed of one or more edges connecting the plurality of nodes, and sample data for storing one or more values input to the neural network;
   Using the graph data, a construction unit that constructs the neural network;
   A learning processing unit that executes a learning process for determining the weights of a plurality of connections in the neural network by inputting the sample data to the neural network;
   With
   The construction unit
   Generating one or more neurons of each of the plurality of layers based on the plurality of nodes included in the graph data;
   Constructing the neural network by generating the connection between the one or more neurons included in each of the plurality of layers based on the one or more edges included in the graph data;
   A computer characterized in that information of the constructed neural network is stored in the storage unit.
2. The computer according to claim 1,
   The plurality of layers includes an input layer including a plurality of neurons, one or more intermediate layers including the plurality of neurons, and an output layer including the one or more neurons,
   The construction unit
   Receiving definition information including first setting information regarding the setting of the output layer;
   Based on the first setting information, the output layer is generated,
   Generating the input layer including neurons corresponding to each of a plurality of nodes included in the graph data;
   An intermediate layer is generated by generating one or more map graphs including neurons corresponding to each of a plurality of nodes included in the graph data.
3. The computer according to claim 2,
   The definition information includes second setting information regarding the number of the map graphs included in one intermediate layer,
   The construction unit
   When configuring the neural network including the input layer, the intermediate layer, and the output layer, generating the intermediate layer by generating one or more map graphs based on the second setting information,
   Select one neuron included in the input layer,
   With reference to the graph data, a node connected to the node corresponding to the selected neuron via an edge is identified,
   Creating the connection between a neuron included in the intermediate layer and corresponding to the identified node and the selected neuron;
   A computer that generates the connection between each of a plurality of neurons included in the one or more map graphs and all neurons included in the output layer.
4. The computer according to claim 3, wherein
   The graph data includes an edge label determined based on a correlation between the nodes;
   The construction unit generates a weight table in which one label is associated with the plurality of connections generated based on the edge to which the label is attached, and stores the generated weight table in the storage unit And
   The learning processing unit
   By performing an error back propagation process using the sample data and the weight table, the weight of the connection given the same label is determined,
   Information that associates the label with the connection weight is stored in the storage unit.
5. The computer according to claim 3, wherein
   The computer includes an identification processing unit that executes identification processing for arbitrary data using an evaluation function used for identification of arbitrary data and a learned neural network output by the learning processing unit,
   The neural network is a neural network corresponding to the evaluation function;
   The identification processing unit
   When receiving input of target data, the first calculation process is executed by inputting the target data to the neural network,
   Based on the output value of the first calculation process, it is determined whether to execute the second calculation process using the evaluation function,
   If it is determined to execute the second arithmetic processing, the second arithmetic processing is executed by inputting the target data into the evaluation function;
   A computer that identifies the target data based on an output value of the second arithmetic processing.
6. The computer according to claim 5, wherein
   Analyzing the target data, generating the plurality of nodes based on the result of the analysis, and generating the graph data by generating one or more edges based on a correlation between the plurality of nodes And a graph data generation unit stored in the storage unit.
7. The computer according to claim 6, wherein
   The correlation between the plurality of nodes is an arrangement of each of the plurality of nodes and a distance between the nodes.
8. An arithmetic method using a neural network executed by a processor and a computer having a memory connected to the processor,
   The neural network is composed of a plurality of layers including one or more neurons,
   A connection is formed between one neuron included in one layer and at least one neuron included in another layer,
   A value input to one neuron included in the one layer is output to at least one neuron included in the other layer connected by the connection together with a weight,
   The memory stores graph data composed of a plurality of nodes and one or more edges connecting the plurality of nodes, and sample data for storing one or more values input to a neural network,
   The calculation method using the neural network is:
   A first step of generating a one or more neurons of each of the plurality of layers based on the plurality of nodes included in the graph data;
   The processor constructs the neural network by generating the connection between the one or more neurons included in each of the plurality of layers based on the one or more edges included in the graph data. A second step of storing information of the constructed neural network in the memory;
   The processor executes a learning process for determining the weights of a plurality of connections in the neural network by inputting the sample data to the neural network, and stores a result of the learning process in the memory. Steps,
   A calculation method using a neural network characterized by comprising:
9. A calculation method using the neural network according to claim 8,
   The plurality of layers includes an input layer including a plurality of neurons, one or more intermediate layers including the plurality of neurons, and an output layer including the one or more neurons,
   The first step includes
   The processor accepting definition information including first setting information relating to the setting of the output layer;
   The processor generating the output layer based on the first setting information;
   The processor generating the input layer including a neuron corresponding to each of a plurality of nodes included in the graph data;
   Using the neural network, wherein the processor includes generating an intermediate layer by generating one or more map graphs including neurons corresponding to each of a plurality of nodes included in the graph data. Calculation method.
10. A calculation method using the neural network according to claim 9,
    The definition information includes second setting information regarding the number of the map graphs included in one intermediate layer,
    In the first step, when the processor constitutes the neural network including the input layer, the intermediate layer, and the output layer, one or more map graphs are generated based on the second setting information. Generating the intermediate layer by generating,
    The second step includes
    The processor selecting a neuron included in the input layer;
    The processor refers to the graph data and identifies a node connected to a node corresponding to the selected neuron via an edge;
    The processor generating the connection between a neuron included in the intermediate layer and corresponding to the identified node and the selected neuron;
    Generating a connection between each of a plurality of neurons included in the one or more map graphs and all of the neurons included in the output layer; Calculation method using a network.
11. A calculation method using the neural network according to claim 10,
    The graph data includes an edge label determined based on a correlation between the nodes;
    In the second step, the processor generates a weight table in which one label is associated with the plurality of connections generated based on an edge to which the label is attached, and the generated weight table Storing in the memory,
    The third step includes
    The processor determines a weight of the connection given the same label by executing an error back propagation process using the sample data and the weight table;
    And a step of storing, in the memory, information in which the processor associates the label with the connection weight in the memory.
12. A calculation method using the neural network according to claim 10,
    The neural network is a neural network corresponding to an evaluation function used for identifying arbitrary data,
    The calculation method using the neural network is:
    When the processor receives input of target data, executing the first calculation process by inputting the target data to the neural network on which the learning process has been executed;
    A step of determining whether or not the processor executes a second calculation process using the evaluation function based on an output value of the first calculation process;
    When it is determined that the processor executes the second arithmetic processing, the second arithmetic processing is executed by inputting the target data into the evaluation function;
    A step of identifying the target data based on an output value of the second calculation process; and a calculation method using a neural network.
13. A calculation method using the neural network according to claim 12,
    The processor analyzing the data of interest;
    The processor generates the graph data by generating the plurality of nodes based on a result of the analysis, and generating one or more edges based on a correlation between the plurality of nodes, and the memory And a step of storing in a neural network.
14. A calculation method using the neural network according to claim 13,
    The correlation method between the plurality of nodes is an arrangement of each of the plurality of nodes and a distance between the nodes.

Images