WO2010047388A1 - 計算処理システム、プログラム作成方法、および、プログラム作成プログラム - Google Patents
計算処理システム、プログラム作成方法、および、プログラム作成プログラム Download PDFInfo
- Publication number
- WO2010047388A1 WO2010047388A1 PCT/JP2009/068271 JP2009068271W WO2010047388A1 WO 2010047388 A1 WO2010047388 A1 WO 2010047388A1 JP 2009068271 W JP2009068271 W JP 2009068271W WO 2010047388 A1 WO2010047388 A1 WO 2010047388A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- node
- network
- program
- calculation
- agent
- Prior art date
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N3/00—Computing arrangements based on biological models
- G06N3/12—Computing arrangements based on biological models using genetic models
- G06N3/126—Evolutionary algorithms, e.g. genetic algorithms or genetic programming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N3/00—Computing arrangements based on biological models
- G06N3/02—Neural networks
- G06N3/08—Learning methods
Definitions
- the present invention relates to a calculation processing system for creating a program, a program creating method, and a program creating program.
- Neumann-type computers stores programs as data in a storage device, and reads and executes programs stored in the storage device in order.
- non-Neumann type computers also exist. Examples of non-Neumann type computers include data flow type computers (see, for example, non-patent document 1) and neurocomputers (see, for example, non-patent document 2).
- a dataflow type computer represents a program in the form of a graph including nodes representing operations and links between nodes representing data transfer relationships between operations.
- the data flow type computer starts execution of a certain process when all the processes that are the premise of that process are finished.
- the dataflow computer uses tokens to control the start timing of each process.
- Neurocomputers perform calculations using neural networks, ie, multiple units coupled together. Each unit is a simple computing element modeled on a nerve cell.
- the neurocomputer repeats adjustment of the degree of coupling between units (referred to as learning) so as to reduce an error with a desired output (referred to as a teacher signal). As a result of repeated learning, the neurocomputer comes to output correct output.
- genetic programming is known for program creation (see, for example, Non-Patent Document 3).
- a program is represented by nodes and node topologies (such as a tree structure) that represent operations.
- node topologies such as a tree structure
- a plurality of such graph type programs are prepared, and appropriate graphs are screened by crossover, mutation, selection, etc. to create an appropriate program.
- Peer-to-Peer Technology and Distributed Computing Technology As another technology trend, there is Peer-to-Peer (P2P) technology that enables distributed computing and the like on the Internet.
- P2P Peer-to-Peer
- clients for example, personal computers
- the peer-to-peer scheme is characterized in that communication can be performed as long as there is room in the circuit bandwidth even if the number of terminals is enormous.
- distributed computing is a type of information processing method.
- individual parts of a program, or task (job) are run concurrently on multiple computers, which communicate with one another over a network.
- job By using a plurality of computers via a network to perform calculations that require a large amount of computing resources, it is possible to increase throughput rather than performing calculations with one computer.
- Peer-to-peer technology may be one architecture for such distributed computing.
- Network virtualization By the way, in general, whether it is a system called a communication network or more specifically a peer-to-peer system as described above, the network physically includes a plurality of information communication devices (nodes) and these. It consists of communication lines (links) that interconnect each other.
- Non-Patent Document 4 a system that manages and operates a network topology (network configuration) is regarded as practical, assuming that a virtual communication line between information devices not directly connected is actually regarded as a physical communication line. It is done.
- the virtualization of such a network is described, for example, in Non-Patent Document 4.
- a system that manages and operates the system topology by regarding (virtual) communication lines between information devices that are not directly connected in this way as physical communication lines is an overlay. It is called a system or overlay network.
- a program executed by a conventional Neumann-type computer is created by coding an algorithm of processing to be executed by a user's own computer. Thus, the program does not change unless edited by the user.
- the von Neumann computer can not output the correct calculation result desired by the user. For example, if the situation or environment changes, the user can not create a complete algorithm, and therefore, the computer can not output the correct calculation result.
- an algorithm that outputs a correct operation result to an input is called a "complete" algorithm.
- Dataflow computers have the same problems as Neumann computers. That is, even the data flow type computer can not output the correct calculation result if the user can not prepare a complete program.
- a network that constitutes a neurocomputer is usually a network consisting of only operation nodes combining product-sum calculations and sigmoid functions etc., and it is usually applied only to a specific problem such as pattern recognition. is there. It is not always clear to the user what kind of neural network outputs the desired calculation result.
- the present invention has been made to solve the problems as described above, and provides a calculation processing system, a program creation method, and a program creation program for creating a program for outputting a computation result desired by a user. To be an issue.
- a calculation processing system which executes calculation using a network representing an algorithm structure of a program by a plurality of operation nodes and a plurality of edges respectively connecting operation nodes.
- the plurality of operation nodes include operation nodes corresponding to various operations of the program, and further include a network updating unit that corrects the network using a calculation result of the calculation execution unit and a learning algorithm.
- the plurality of operation nodes include operation nodes that perform calculations on control values representing the flow of the algorithm.
- the plurality of operation nodes include operation nodes corresponding to arithmetic operations. More preferably, the network updating unit performs processing of changing, adding or deleting a computing node to the network.
- the plurality of operation nodes include an operation node having a node variable
- the network update unit calculates an error from the training value of the calculation result, calculates a contribution of the node variable to the error, and calculates the node based on the contribution. Modify the variable
- the network updating unit calculates an energy error based on the error, calculates a derivative of the energy error for the node variable as a contribution, subtracts a value obtained by multiplying the derivative by the learning coefficient, and calculates the variable Update.
- the learning coefficient is a value determined such that the energy error is (1-- 1 p ) times ( ⁇ 1 p is a real number greater than 0 and less than 1 ) by updating the variable.
- an input unit for receiving an input from the outside, and a network creation unit for creating a network based on a program received by the input unit are further provided.
- the program accepted by the input unit is source code written in a high-level language
- the network creation unit converts the source code into language-independent intermediate code and creates a network based on the intermediate code.
- the network updating unit changes an operation node whose output value does not continuously change a predetermined number of times or more to a constant node that outputs a constant value.
- the network update unit randomly selects two or more operation nodes from among the plurality of operation nodes, and generates a new operation node connected to the selected operation node.
- the network updating unit randomly selects a first operation node and a second operation node from among a plurality of operation nodes, and generates a bridge from the second operation node to the first operation node. .
- the network updating unit randomly selects an operation node from among the plurality of operation nodes, and creates a branch for the selected operation node.
- the network updating unit rewrites a plurality of constant nodes, each outputting a constant value, into one constant node according to a coupling law.
- the network update unit splits operation nodes having node variables that are continuously corrected a predetermined number of times or more.
- a program creation method using a computing system in which a computing system represents an algorithmic structure of a program by a plurality of operation nodes and a plurality of edges connecting operation nodes.
- the plurality of operation nodes include operation nodes corresponding to various operations of the program, and further comprising the step of the calculation processing system modifying the network using the result of the calculation and the learning algorithm.
- a program creation program for causing a computer processing system to create a program, the algorithm of the program having a plurality of operation nodes and a plurality of edges connecting operation nodes to the computer system.
- the method includes the step of executing calculations using a network representing a structure, wherein the plurality of operation nodes include operation nodes corresponding to various operations of the program and cause the calculation processing system to correct the network using calculation results and a learning algorithm It further comprises a step.
- the network corresponding to the program is modified using a learning algorithm. As a result, it is possible to create a program desired by the user.
- the program created by the user can be modified to create a more complete program.
- FIG. 5 is a diagram showing an intermediate code of GIMPLE format corresponding to the source code shown in FIG. 3. It is a figure which shows an example of ATN created based on a source code. It is a figure for demonstrating the firing timing of a calculation node.
- FIG. 16 is a diagram showing an example of a node operation definition 135.
- FIG. 6 is a diagram showing network information 134. It is a figure which shows the learning variable 136.
- FIG. It is a figure which shows the 1st calculation process of the forward propagation using the network of FIG. It is a figure which shows the 2nd operation process of the forward propagation using the network of FIG. It is a figure which shows the 3rd operation process of the forward propagation which used the network of FIG.
- FIG. 7 is a diagram showing a fourth operation process of forward propagation using the network of FIG. 6; It is a figure which shows the 5th calculation process of the forward propagation using the network of FIG.
- FIG. 7 is a diagram showing a sixth operation process of forward propagation using the network of FIG.
- FIG. 7 is a diagram showing an eighth operation process of forward propagation using the network of FIG. 6; It is a figure which shows the 9th calculation process of the forward propagation using the network of FIG. It is a figure which shows the 10th calculation process of the forward propagation using the network of FIG.
- FIG. 7 is a diagram showing an eleventh operation process of forward propagation using the network of FIG. 6; It is a figure which shows the 12th calculation process of the forward propagation using the network of FIG.
- FIG. 7 is a diagram showing a thirteenth operation process of forward propagation using the network of FIG. 6; FIG.
- FIG. 7 is a diagram showing a fourteenth operation process of forward propagation using the network of FIG. 6; It is a figure which shows the 15th calculation process of the forward propagation using the network of FIG. It is a figure which shows the 16th calculation process of the forward propagation using the network of FIG. It is a figure which shows the 17th operation process of the forward propagation using the network of FIG. It is a figure which shows the 18th operation process of the forward propagation using the network of FIG. It is a figure which shows the 19th calculation process of the forward propagation using the network of FIG. It is a figure which shows the twentieth operation process of the forward propagation which used the network of FIG. It is a figure which shows the 21st operation process of the forward propagation using the network of FIG.
- FIG. 7 illustrates forward propagation using the network of FIG. 6; It is a figure which shows the 34th operation process of the forward propagation which used the network of FIG. It is a figure which shows the 35th calculation process of the forward propagation using the network of FIG. It is a figure which shows the 36th calculation process of the forward propagation using the network of FIG. It is a figure which shows the 37th calculation process of the forward propagation which used the network of FIG.
- FIG. 7 is a diagram showing a forty-first operation process of forward propagation using the network of FIG. 6; It is a figure for demonstrating a chain rule. It is a figure for demonstrating the back propagation of the derivative of an error. It is a figure for demonstrating the derivative regarding the node constant of an error. It is a figure for demonstrating constantization. It is a flowchart which shows the flow of the process which the topology learning part 228b performs in constant-izing.
- FIG. 74 is a diagram for describing an ATN obtained by converting the code shown in FIG. 73.
- FIG. 2 is a conceptual diagram for explaining a computing system 1000 using peer-to-peer technology.
- the calculation processing apparatus 100 corrects a program (hereinafter also referred to as an initial program) given from the outside, and creates a program that outputs a more appropriate calculation result.
- the calculation processing device roughly performs the following three processes. (1) Conversion of program to network (2) Execution of calculation using network (3) Modification of network The outline of each processing will be described below.
- the computing device 100 creates a network type program based on the given initial program. That is, the computing device 100 creates a network that represents the structure of the algorithm of the initial program.
- the computing device 100 converts an initial program into a network of ATN (Algorithmically Transitive Network) format.
- the ATN type network represents the structure of an algorithm by a plurality of operation nodes each representing an operation and a plurality of edges connecting any two operation nodes of the plurality of operation nodes.
- An edge has a direction that represents the order of operations.
- the calculation processing device 100 executes the calculation using the created network. That is, the calculation processing device 100 performs the operation by the operation node on the input value in the order represented by the edge.
- the calculation processing apparatus 100 performs an operation by each operation node on a shuttle agent (hereinafter simply referred to as an agent) having information necessary for the operation.
- the operation node receives the input of one or more agents, performs operation on the agent input from the edge based on a predetermined rule, and outputs the agent after operation to the edge.
- the agent output from the operation node is input to the operation node of the edge destination. Details of the agent and details of the processing rules for the agent will be described later.
- the calculation processing apparatus 100 corrects the network based on the calculation result using the network using a learning algorithm. That is, the computing device 100 modifies the network so that the calculation result by the network approaches the value desired by the user. More specifically, the computation processing device 100 performs back propagation learning that changes constant values of operation nodes, and topology learning that changes the topology of the network. Details of back propagation learning and topology learning will be described later.
- the calculation processing apparatus 100 can create a network (that is, a program) that outputs a value desired by the user by repeating (2) execution of calculation using the network and (3) modification of the network. .
- FIG. 1 is a diagram schematically showing the flow of processing performed by the calculation processing device 100. As shown in FIG.
- step S1 the calculation processing apparatus 100 first converts the input program to prepare an initial network ((1)). Next, the calculation processing device 100 sets the mode to the forward mode. In the Forward mode, the computing device 100 executes network calculations, but does not execute network change processing. Then, the calculation processing apparatus 100 substitutes the input into the Start node at the start point of the operation, and causes the Start node to execute the calculation (fire the Start node) ((2)).
- the calculation processing device 100 performs the process of step S2. If not, the calculation processing device 100 proceeds to the process after step S4.
- the calculation processing apparatus 100 uses the counter to determine whether the agent has not moved for a while.
- step S 2 the calculation processing apparatus 100 first determines, at the ans node, an energy error E and a differential coefficient D x of the energy error E determined based on the difference between the operation result ⁇ x>, the correct result (teacher value) and the operation result. , D r ((1)). Details of these values will be described later.
- the calculation processing device 100 sets the mode to Backward ((2)).
- the computing device 100 performs back propagation learning.
- the calculation processing device 100 ends the process when the calculation result satisfies the end criterion in step S3. In the present embodiment, the calculation processing device 100 ends the process when the energy error E is equal to or less than a predetermined value. If the calculation result does not satisfy the termination criterion, the calculation processing device 100 continues the subsequent processing.
- the calculation processing device 100 performs the process of step S4 when the agent does not move for a while in the backward mode, that is, when the calculation for all agents is completed in the back propagation learning. If not, the calculation processing device 100 proceeds to the process after step S5.
- the calculation processing apparatus 100 uses the counter to determine whether the agent has not moved for a while.
- step S3 the calculation processing device 100 first calculates the learning coefficient ⁇ , and updates the node variable ⁇ z ⁇ based on the learning coefficient ⁇ ((1)). Details of this process will be described later.
- the computing device 100 executes topology learning ((2)). That is, based on predetermined rules such as CON, MKV, BRG, FRK, MGT, MGN, and DIV, generation or deletion of operation nodes and edges is performed.
- predetermined rules such as CON, MKV, BRG, FRK, MGT, MGN, and DIV.
- step S5 the computing device 100 executes an agent operation by the operation node. Further, the calculation processing device 100 moves all agents to the next operation node in step S6.
- the processing of one step S5 and step S6 corresponds to one time step of the calculation.
- step S2 or step S3 is performed.
- the program changes to one which outputs the user's desired data according to the principle of the steepest descent learning and the self-organizing learning. That is, the user can obtain a program environment in which the algorithm of the program coded by the user is automatically modified.
- FIG. 2 is a block diagram showing the configuration of the calculation processing apparatus 100 according to the present embodiment.
- the calculation processing device 100 includes a computer main body 102, a monitor 104 as a display device, and a keyboard 110 and a mouse 112 as input devices.
- the monitor 104, the keyboard 110, and the mouse 112 are connected to the computer body 102 via the bus 105.
- the computer main body 102 includes a flexible disk (Flexible Disc, hereinafter referred to as "FD") drive 106, an optical disk drive 108, a CPU (Central Processing Unit) 120, a memory 122, and a direct access memory device, for example, a hard disk 124. And a communication interface 128. These components are connected to one another by a bus 105.
- FD Flexible disk
- a CPU Central Processing Unit
- the FD drive 106 reads and writes information from and to the FD 116.
- the optical disc drive 108 reads information on an optical disc such as a compact disc read-only memory (CD-ROM) 118 or the like.
- the communication interface 128 exchanges data with the outside.
- the CD-ROM 118 may be another medium, for example, a DVD-ROM (Digital Versatile Disc) or a memory card, as long as it is a medium capable of recording information such as a program installed in the computer main body.
- the computer main body 102 is provided with a drive device capable of reading these media.
- a magnetic tape device to which a cassette type magnetic tape is detachably attached and accessed may be connected to the bus 105.
- the memory 122 includes a read only memory (ROM) and a random access memory (RAM).
- ROM read only memory
- RAM random access memory
- the hard disk 124 stores an initial program 131, a network creation program 132, a network correction program 133, network information 134, a node operation definition 135, and a learning variable 136.
- the initial program 131 is a program that is the basis of program creation.
- the hard disk 124 can store a program created by the user as an initial program 131.
- the initial program 131 may be supplied by a storage medium such as the FD 116 or the CD-ROM 118, or may be supplied by another computer via the communication interface 128.
- the network creation program 132 creates a network corresponding to the initial program 131 based on the initial program 131.
- the network creation program 132 also stores the network information 134 on the created network in the hard disk 124.
- the network correction program 133 corrects the network created by the network creation program 132. More specifically, the network correction program 133 creates a new network with the network information 134 corrected, if the energy error between the execution result of the operation based on the network information 134 and the desired value is equal to or more than a predetermined threshold. Do.
- the network information 134 includes information on the network created by the network creation program 132, and information created by the network modification program 133 at the time of operation by the network or modification of the network.
- the node operation definition 135 represents a rule of operation by operation nodes included in the network.
- the node operation definition 135 includes information specifying an operation node (operation code), the number of edges input to the operation node (input number), and the like. Details of the node operation definition 135 will be described later.
- the learning variable 136 is information required to correct the network.
- the learning variable 136 includes, for example, a teacher value desired by the user as a calculation result, an energy error E calculated based on an error between the calculation result by the network and the teacher value, and the like. Details of the learning variable 136 will be described later.
- node operation definition 135 and the learning variable 136 those created by the user using the input device can be used. However, these may be supplied by a storage medium such as the FD 116 or the CD-ROM 118, or may be supplied by the other computer via the communication interface 128.
- the network creation program 132 and the network modification program 133 may be supplied by a storage medium such as the FD 116 or the CD-ROM 118 or may be supplied by another computer via the communication interface 128.
- the CPU 120 functioning as an arithmetic processing unit executes processing corresponding to each program described above, using the memory 122 as a working memory.
- the network creation program 132 and the network correction program 133 are software executed by the CPU 120 as described above.
- such software is stored and distributed in a storage medium such as a CD-ROM 118 or an FD 116, read from the storage medium by the optical disk drive 108 or the FD drive 106 or the like, and temporarily stored in the hard disk 124.
- the computing device 100 is connected to the network, it is copied from the server on the network to the hard disk 124 once. Then, it is further read from the hard disk 124 to the RAM in the memory 122 and executed by the CPU 120.
- the program may be directly loaded to the RAM and executed without being stored in the hard disk 124.
- the hardware itself of the computer shown in FIG. 2 and its operating principle are general. Therefore, the essential part in realizing the functions of the present invention is software stored in a storage medium such as the FD 116, the CD-ROM 118, the hard disk 124 and the like.
- FIG. 3 is a block diagram showing a functional configuration of the calculation processing apparatus 100 according to the present embodiment.
- the calculation processing device 100 includes an input unit 210 that receives data from the outside, an operation unit 220, an output unit 230 that outputs the operation result of the operation unit 220 to the outside, and a storage unit 240.
- Arithmetic unit 220 performs an operation on the data stored in storage unit 240.
- Arithmetic unit 220 includes a network creation unit 222, a calculation execution unit 226, and a network update unit 228.
- the network creation unit 222 creates the network information 134 based on the initial program 131 stored in the storage unit 240.
- the network creation unit 222 includes a format conversion unit 224.
- the format conversion unit 224 converts the initial program 131 into an intermediate format that does not depend on the program description language.
- the calculation execution unit 226 executes the calculation using the network based on the network information 134 and the node calculation definition 135. Details of the process performed by the calculation execution unit 226 will be described later.
- the network updating unit 228 corrects the network information 134 using a learning algorithm. More specifically, the network updating unit 228 includes a constant learning unit 228a and a topology learning unit 228b.
- the constant learning unit 228a corrects the constant value of the operation node included in the network based on the error included in the learning variable 136.
- the topology learning unit 228 b executes network update processing such as generation and deletion of operation nodes and generation and deletion of edges as needed based on a predetermined rule. Details of the processing performed by the network update unit 228 will be described later.
- the network created by the network creation unit 222 will be described by taking a specific example.
- the initial program 131 is a source code described in C language shown in FIG.
- FIG. 4 is a diagram showing an example of the initial program 131.
- the initial program 131 may be source code described in a programming language other than C language.
- the initial program 131 may be written in a high-level language such as C, C ++, Fortran, Ada, Objective-C, Java (registered trademark), Pascal, or COBOL.
- the format conversion unit 224 included in the network creation unit 222 converts the source code into an intermediate code in the GIMPLE format, and converts the intermediate code into a network.
- Intermediate code in GIMPLE format (hereinafter simply referred to as GIMPLE) is a source code described in GCC (GNU Complier Collection) internal representation.
- GCC GNU Complier Collection
- Source code depends on the language in which the source code is written.
- GIMPLE is independent of high-level language and independent of architecture. Therefore, the network creation unit 222 can convert source code described in various languages into a network by a unique algorithm.
- GIMPLE is an intermediate result of the high-level language compiler compilation process. That is, GIMPLE is a code before generation of an object code in machine language.
- the format conversion unit 224 can create GIMPLE according to one of various known methods of creating GIMPLE. For example, the format conversion unit 224 can create GIMPLE by using the gcc -fdump-tree-gimple option of GCC 4.1 or later.
- the network creation unit 222 creates a network type program corresponding to GIMPLE.
- the network creation unit 222 creates an ATN type network.
- the rules for creating a network in ATN format from intermediate code in GIMPLE format will be described later.
- a network in ATN format may be simply referred to as ATN.
- the method of creating the ATN is not limited to the above.
- the network creation unit 222 may create a ATN by executing a program specialized to a specific type of initial program that creates the ATN from the initial program without passing through an intermediate format.
- the network creation unit 222 may create an ATN based on an object code written in a manner that can be understood by a computer.
- the user may manually create the ATN.
- FIG. 6 An example of the ATN created by the network creation unit 222 based on the source code according to the above procedure is shown in FIG.
- the characters or symbols in the figure indicate the operation type of the node.
- the edges are represented by solid arrows or broken arrows. Solid arrows represent the flow of agents including arithmetic values.
- the dashed arrows represent agent flows that include only control values.
- a portion enclosed by a frame 500 represents loop operation processing.
- the control value represents the likelihood of the presence of the agent.
- the control value takes a value of 0 or more and 1 or less. The lower the judgment value by the conditional branch performed during calculation execution, the smaller the control value of the agent present in the branch.
- the calculation execution unit 226 deletes a branch having a control value smaller than a predetermined threshold so that the calculation can be completed in finite time and memory resources.
- Operation nodes represent data generated by individual local computations or computations.
- the edge connecting the operation nodes represents register transfer.
- An agent represents data to be calculated or used for calculation. The agent is generated by the operation node each time the calculation is executed, and the operation node gives the generated agent the calculation result.
- the calculation by the agent is realized by propagation from the input node to the output node.
- the principle of calculation by the agent is the following two. [Principle 1] A set of values (x, r) propagates from edge-attached agents to agents. [Principle 2] The binary label vector of the agent is inherited from the parent agent to the child agent.
- the set of values is a set of an arithmetic value and a control value.
- Each agent has a set of values.
- the operation node performs an operation according to the type of operation node on the set of agent values input to the operation node. Then, the operation node outputs an agent having a set of values after the operation.
- the agent input to the operation node is called a "parent agent”, and the agent output by the operation node is called a "child agent”.
- a binary label vector indicates what kind of conditional branch the agent has traced.
- the binary label vector contains information on the number of branch points that the agent has passed and information on whether the agent has taken a True or False branch at each branch point.
- the binary label vector is simply referred to as a label.
- the quotation mark (') represents the negation of the Boolean variable to the left of the quotation mark.
- the lower case alphabets (a, b,...) Or the negation thereof indicate the determination result in each branch. Lower case letters without a negative sign indicate that the judgment result is True. A small letter with a negative sign indicates that the judgment result is False.
- the boolean variable corresponding to the newer branch is placed to the left of the label.
- An operation node that does not cause a conditional branch gives the child agent the same label as that of the parent agent.
- the operation node causing the branch gives the child agent a new label obtained by multiplying the label of the parent agent by the new Boolean variable.
- FIG. 7 is a diagram for explaining the firing timing of the operation node.
- the firing timing of the operation node differs depending on whether one or more agents are input to the operation node.
- a one-input operation node fires according to the following rule 1. [Rule 1] (In the case of one-input operation) The operation node fires independently.
- FIG. 7A is a diagram for describing an operation performed by the operation node 304 having one input and two outputs on the agent.
- the one-input operation node 304 alone fires upon receiving the parent agent 402 output from the operation node 302. That is, upon receiving the parent agent 402, the operation node 304 outputs the child agent 404 and the child agent 406.
- the operation node 304 determines the set of values (X, R) of the child agent 404 and the child agent 406 based on the set of values (x 0 , r 0 ) of the parent agent 402.
- the binary label vector of the parent agent 402 is inherited by the child agents 404,406.
- the binary label vector will be represented by the number and color of circles representing the agent.
- the binary label vectors of the parent agent 402 and the child agents 404 and 406 are common, and they are represented by one black circle.
- multi-input operation nodes fire according to the following rule 2.
- Rule 2 (In the case of multi-input operation) The operation node fires if labels A and B of two agents input to the operation node satisfy AB ⁇ 0.
- FIG. 7B is a diagram for describing an operation performed by the 2-input 2-output operation node 314 on an agent having the same label.
- Operation node 314 receives agent 408 and agent 410 from operation node 310 and operation node 312, respectively.
- the operation node 314 outputs the agent 412 and the agent 414 having the label a to the operation node 316 and the operation node 318, respectively.
- an operation node to which an agent with the same label is input gives a child agent the same label as the label of the input agent.
- FIG. 7C is a diagram for explaining an operation performed by an operation node 319 having two inputs and one output on agents having different labels.
- negation expresses the bar of superscript.
- This agent is fireable. That is, the agent having the shorter label remains as a fireable agent.
- the remaining agents are waiting. That is, the remaining agents are not operated until a new agent arrives at the operation node.
- the labels of waiting agents are indicated by diagonal lines.
- the shaded circle from top left to bottom right corresponds to the wait state of the positive Boolean variable (open circle).
- the shaded circle from top right to bottom left corresponds to the wait state of the negative boolean variable (black circle).
- the label (here, AB ') of the agent remaining as the fireable agent is called "complementary label".
- the reason for calling in this way is that the label of the agent remaining as the fireable agent is paired with the label of the child agent.
- Boolean variable “1” indicates that the result of the corresponding branch may be True or False (Don't care).
- FIG. 8 is a diagram showing an example of the node operation definition 135.
- the node operation definition 135 includes the operation name of the operation node, one character code uniquely determined in association with the operation node, the number of inputs indicating the number of agents input to the operation node, arithmetic / control
- the parameter includes an output arithmetic value X and an output control value R.
- the arithmetic / control parameter takes a value of “A (initial letter of Arithmetic)” when the operation node performs an operation on an arithmetic value. Further, the arithmetic / control parameter takes a value of “R (Regitive initial)” when the operation node performs an operation on the control value. Further, the arithmetic / control parameter takes a value of “A / R” when the operation node performs an operation on both the arithmetic value and the control value.
- the output arithmetic value X indicates the arithmetic value of the agent output by the operation node.
- x 0 , x 1 and x l indicate the arithmetic value of the agent input to the operation node.
- two output operation values are indicated by X 0 and X 1 respectively.
- the output control value R indicates the control value of the agent output by the operation node.
- r 0 and r 1 indicate control values of the agent input to the operation node.
- the two output control values are respectively indicated by R 0 and R 1 .
- the Start node is represented by the letter S.
- the Start node is located at the start point of the operation.
- the number of inputs of the Start node is zero.
- Arithmetic const. (Arithmetic constant) nodes are represented by the letter c.
- the number of inputs of the Arithmetic const. Node is one.
- Arithmetic const. Node performs an operation on an arithmetic value.
- the Arithmetic const. Node gives a constant v as an arithmetic value to the output agent regardless of the arithmetic value of the input agent.
- v is one of the node variables set for each operation node.
- numerical values (1.0 and 3.0) near the circled c represent v of the Arithmetic const. Node.
- the Arithmetic const. Node does not perform an operation on the control value. That is, the Arithmetic const. Node gives the output agent the control value r 0 of the input agent as a control value.
- operation nodes can generally output a set of values after operation to one or more operation nodes.
- the Regulating const. Node is represented by the letter C.
- the number of inputs of Regulating const. Node is 1.
- the number of outputs of Regulating const. is 2.
- the Regulating const. Node performs an operation on a control value.
- the Regulating const. Node gives an agent that outputs 0 as an arithmetic value regardless of the input agent's arithmetic value.
- s is one of the node variables.
- s takes a value of 0 or more and 1 or less.
- the number of outputs of the Regulating const. Node is limited to two.
- the number of inputs of Equal node is one.
- the Equal node gives an agent that outputs the same set of values as the input agent has.
- the Equal node outputs a set of values to one or more agents. That is, the Equal node can pass the operation result of one operation node to one or more other operation nodes.
- D **** (such as D2533) surrounded by a frame also represents an Equal node. D **** is described for convenience in order to show the correspondence with GIMPLE. In the network actually created, the operation node represented by D **** is the same as the Equal node.
- Negative nodes are represented by the letter n.
- the number of inputs of Equal node is one.
- the negative node gives the output agent the inverted sign of the input agent's arithmetic value.
- Inverse nodes are represented by the letter i.
- the number of Inverse node inputs is one.
- the Inverse node provides the agent which outputs the inverse of the input agent's arithmetic value.
- Subtraction nodes are represented by the character-.
- the number of inputs of Subtraction node is two.
- the Subtraction node gives an agent the output of the difference between the arithmetic values of two input agents.
- the Subtraction node gives the smaller one of the control values of the two input agents to the output agent. This is because the existence probability of the edge exiting the Subtraction node does not exceed this value. Since the Subtraction node outputs a control value as low as possible, branch tracking becomes easy.
- the Division node is represented by the character /.
- the number of inputs of Division node is two.
- the Division node provides the agent that outputs the quotient of the arithmetic values of the two input agents. Also, as in the case of the Subtraction node, the Division node gives the smaller one of the control values of the two input agents to the output agent.
- a Less than node (or a decision node) is represented by the letter L.
- the number of inputs of the Less than node is two.
- the Less than node performs an operation on the control value.
- the Less than node gives an agent that outputs 0 as an arithmetic value regardless of the input agent's arithmetic value.
- ⁇ is a constant and ⁇ r is a node variable. That is, agents output by the Less than node are classified into two types according to the value of the control value. Each type of agent may be one or more.
- the Write node is represented by the letter w.
- the number of inputs of the Write node is one.
- the Write node performs operations on arithmetic values and control values.
- the Write node outputs two edges.
- the Read node is represented by the letter r.
- the number of inputs of the Read node is two.
- the Read node performs an operation on the control value.
- the Read node does not depend on the agent's arithmetic value on one input edge (in FIG. 6, an edge whose “0” is drawn in the vicinity), and the other input edge (in FIG. Output the agent's arithmetic value x 1 on the drawn edge). Also, the Read node outputs the smaller one of the two input control values.
- the network can express a conditional branch such as an if statement.
- the Addition node is represented by the character +.
- the number of inputs of Addition node is 2 or more (represented by 2+ in FIG. 8).
- the Addition node sums all the arithmetic values of the input agents. Also, the Addition node outputs the smallest control value of the input agent.
- the Multiplication node is represented by the character *.
- the number of inputs of the Multiplication node is 2 or more (represented by 2+ in FIG. 8).
- the Multiplication node takes the product of the arithmetic values of all the agents entered. Also, the Addition node outputs the smallest control value of the input agent.
- the operation nodes include operation nodes corresponding to various operations in the program, for example, four operations.
- the operation nodes are not limited to operation nodes corresponding to calculations other than product-sum or sigmoid calculation used in the conventional neural network.
- the network is represented by various operation nodes. Therefore, the network is versatile and can represent various programs.
- storage part 240 stores are demonstrated in detail following the description about a network, an agent, and a computing node.
- FIG. 9 is a diagram showing the network information 134.
- network information 134 includes node information 134a, edge information 134b, agent information 134c, and a deletion label list 134d.
- the node information 134a is defined for each operation node included in the network.
- the node information includes: an operation code, a node variable, a differential coefficient of an energy error E between the operation result by the network and a teacher value, a set of value sets generated by firing at the node, and a node It includes a pointer to an edge, output information, and an index of the edge.
- the operation code represents the type of operation node.
- An operation name or a one-character code can be used as the operation code.
- the derivative of the error E with respect to the node variable is used in constant learning of the network described later.
- the pointer from node to edge represents the edge connected to the node.
- the output information is a binary variable representing whether the edge connected to the node is an edge from which the operation node exits. If the output information has a value of True, the edge leaves the operation node. If the output information has the value of False, the edge enters the operation node.
- the index of an edge is a value of 0 or 1 defined for an edge output from an operation node that outputs two types of values, such as a determination node. The index represents the kind of output value that the agent on the edge has.
- the edge information 134 b indicates how each edge connects operation nodes.
- the edge information 134 b includes a pointer to an operation node (start point node) connected to the start point of the edge and a pointer to an operation node (end point node) connected to the end point of the edge.
- the agent information 134c is created during execution of an operation using a network with respect to various information possessed by the agent.
- the agent information 134c includes a set of values, a binary label vector, a derivative with respect to a set of values of energy error E, a partial derivative of a set of values of a child agent with respect to a set of values of this agent, and a child agent And a pointer to a parent / child agent and a pointer to an edge at which the agent is located.
- Each derivative and each partial derivative are used in constant learning of a network described later.
- the pointers to parent / child agents represent genealogy between agents, that is, the branching structure of operations. Pointers to parent / child agents are required for back propagation learning, which will be described later.
- FIG. 10 is a diagram showing a learning variable 136.
- a learning variable 136 is provided for network updates, regardless of the structure of the network.
- the learning variables 136 include a learning coefficient, a learning rate per one pass, a teacher value, an energy error E, and an in-E coefficient. The details of these variables will be described in the description of the network update process.
- the calculation execution unit 226 executes forward propagation in accordance with the following rules.
- the rules 1 to 5 have already been described.
- [Rule 1] In the case of one-input operation
- the agent fires independently.
- [Rule 2] In the case of multi-input operation)
- the operation node fires if labels A and B of two agents input to the operation node satisfy AB ⁇ 0.
- [Rule 3] A Boolean product AB of labels A and B of the input agent is inherited to the child agent.
- labels A and B of the input agent change to AB 'and A'B, respectively.
- Agents with label 0 can not fire.
- FIGS. 11 to 51 are diagrams showing an operation process of forward propagation using the network shown in FIG. 6, respectively. 11 to 51 do not show identifiers (0, 1) of inputs or outputs of the determination node, the write node, and the read node, but they are the same as those shown in FIG.
- calculation execution unit 226 causes node N1 to output an agent having a value set (..., 1).
- agent (x, r) an agent having a value set (x, r) will be denoted as agent (x, r).
- x ... indicates that there is no value of arithmetic value.
- node N2 that has received agent (... 1) outputs agent (0, 1).
- node N2 that has received agent (0,1) outputs agent (0,1) to node N3. Further, the node N2 outputs the agent (... 1) to the node N13.
- node N 4 outputs agent (0, 1) to node N 9 and outputs agent (0, 1) to node N 5. Further, the node N13 outputs the agent (0, 1) to the node N14.
- node N 14 outputs agent (0, 1) to node N 15. Also, the node N14 outputs the agent (... 1) to the node N17.
- the agent (0, 1) that has arrived at the node N9 is ready because it can be fired but the other agent does not arrive at the node N9.
- the agent arriving at the node N5 likewise enters the waiting state.
- node N15 outputs agent (0,1) to node N11 and agent (0,1) to node N18. Further, the node N17 outputs the agent (..., 1) to the node N18 and the agent (..., 1) to the node N19.
- node N18 In the next step, two agents are input to node N18, and node N18 fires. This is because the Boolean product of the labels of these agents is not zero.
- the node N18 outputs the agent (0, 1) to the node N20.
- the agent on which the operation has been performed can not fire.
- the agent that can not be fired is not shown because it does not affect the subsequent operations.
- the node N19 outputs the agent (1.5, 1) to the node N20.
- the agent input to the node N11 is in a waiting state.
- node N20 In the next step, two agents are input to node N20, and node N20 fires. This is because the Boolean product of the labels of these agents is not zero.
- the node N20 outputs the agent (..., 1) to the node N21, and outputs the agent (..., 0) to the node N22.
- the node N20 adds different Boolean variables to two child agents.
- the agent (... 0) can not be fired according to rule 5, and its label [black, black] is stored in the deletion label list.
- a new Boolean variable is added to the label of each of the fireable agents (the node N5, the node N9 and the agent before the node N15).
- the labels of these agents are [black, white].
- the negation of the label stored in the deletion label list is applied to all the labels in the network, and the labels of agents waiting at node N5, node N9 and node N15 change.
- node N21 outputs an agent (... 1) to nodes N5 and N6.
- node N5 In the next step, two agents are input to node N5, and node N5 fires.
- the node N5 outputs the agent (0, 1) to the node N7.
- the node N6 outputs the agent (3, 1) to the node N7.
- node N7 fires agent (3, 1) to node N8.
- node N8 outputs agent (3, 1) to node N4, and agent (..., 1) to nodes N10 and N11.
- node N4 In the next step, two agents are input to node N4, and node N4 fires.
- the node N4 outputs the agent (3, 1) to the node N9.
- the agent (0, 1) which has been waiting at the node N 9 previously, can not fire.
- the node N10 outputs the agent (1,1) to the node N12.
- the node N11 outputs the agent (0, 1) to the node N12.
- node N12 In the next step, two agents enter node N12, and node N12 fires.
- the node N12 outputs the agent (1,1) to the node N16.
- node N16 outputs agent (1,1) to node N15 and agent (..., 1) to node N17.
- node N17 outputs agent (..., 1) to node N18, and agent (..., 1) to node N19. Also, the node N15 outputs the agent (1,1) to the node N18.
- node N18 In the next step, two agents enter node N18, and node N18 fires.
- the node N18 outputs the agent (1,1) to the node N20.
- the node N19 outputs the agent (1.5, 1) to the node N20.
- the two agents input to node N 20 fire.
- the node N20 outputs the agent (..., 0.8) to the node N21, and outputs the agent (..., 0.2) to the node N22.
- the node N20 adds different Boolean variables to two child agents.
- node N21 outputs an agent (..., 0.8) to node N6. Also, the node N22 outputs the agent (... 0.2) to the node N9.
- node N5 outputs agent (3, 0.8) to node N7.
- the node N6 outputs the agent (3, 0.8) to the node N7.
- the Boolean product of the labels of the two agents input to the node N9 that is, the Boolean product of the labels [black and white] and the labels [black and white, black] is not zero. Therefore, the node N9 fires.
- an agent with a shorter label is a fireable agent with a complementary label.
- Agents with shorter labels are not limited to those that fired. All agents in the network and with the shorter label are fireable agents with complementary labels.
- node N9 outputs agent (3, 0.2) to node N23. Since node N23 is an ans node, rule 8 is applied, and the label of the agent input to node N23 is stored in the deletion label list.
- FIGS. 32 to 51 shows the state of the agent when the third operation result is output to the node N23.
- the calculation execution unit 226 ends forward propagation calculation when there is no agent moving in the network.
- the calculation execution unit 226 outputs a plurality of value pairs (x l , r l ) as the calculation result.
- l is a subscript representing an agent.
- the calculation execution unit 226 outputs the weighted average ⁇ x> by the control value of the arithmetic value as a final calculation result.
- the calculation result obtained as described above may be different from the user's desired value (teaching value).
- the network updating unit 228 corrects the network if the energy error between the calculation result and the training value is larger than a predetermined value.
- the energy error is expressed as a function of x l and r l output to the ans node.
- the calculation execution unit 226 calculates the energy error E according to the following equation (1).
- t is a teacher value.
- ⁇ and ⁇ are error coefficients.
- the error coefficient is a constant that is predetermined or determined by the user as appropriate.
- the first term represents the square of the error between the calculation result ⁇ x> and the training value t. The closer the calculation result is to t, the smaller the energy error.
- the second and third terms are provided to reflect that the sum of control values is preferably one. If the sum of control values is not 1, this means that the number of branches removed is too large or too small, and the calculation may not be performed correctly.
- the calculation execution unit 226 passes the energy error E to the network updating unit 228.
- the network updating unit 228 corrects the network using a learning algorithm based on the energy error E.
- the network updating unit 228 corrects the network using, for example, a learning algorithm similar to error back propagation learning or hebb learning in a neural network.
- the network updating unit 228 obtains the derivative of the error for the node variable as a contribution, and updates ⁇ z ⁇ by the steepest descent method. That is, the network updating unit 228 updates ⁇ z ⁇ according to the following equation (2).
- ⁇ is a learning coefficient.
- D z is the derivative of E for z.
- the network updating unit 228 obtains Dz of each node based on back propagation of the derivative of the energy error.
- Back propagation of the derivative of the energy error refers to the property that the derivative of the energy error parent agent variable can be calculated based on the derivative of the energy error child agent variable.
- the network updating unit 228 sequentially calculates the derivative of the energy error for each operation node from the operation node on the output side of the network to the operation node on the input side.
- the network updating unit 228 determines in what order the derivative of the energy error is to be obtained based on the pointer (family tree) to the parent / child agent.
- the chain rule is a rule that the derivative of an input variable of a function is equal to the sum of products of partial derivatives of all the nodes from the terminal node to the variable.
- FIG. 52 is a diagram for explaining a chain rule.
- z a 2 x.
- the derivative of y for a can be expressed as the following equation (*).
- the first term on the right-hand side is the product of partial derivatives of the path of the solid line.
- the second term on the right side is the product of the partial derivatives for the dashed line path. Therefore, it can be understood that the chain rule is established. Note that, as can be inferred from the equation (*), the chain rule is a paraphrased version of the partial differential method of the composite function. Therefore, chain rules always hold.
- the derivative of the error is back-propagated. That is, the derivative of x and r of the parent agent of the error can be calculated based on the derivative of X and R of the child agent of the error and the partial derivative of the node operation. More specifically, the error derivative D xl (or D rl ) for the parent agent x l (or r l ) is the error derivative for the child agent X, R and x l (or The sum of products of partial derivatives for r l ) is added for all child agents.
- FIG. 53 is a diagram for describing back propagation of a differential coefficient of an error.
- the differential coefficients D xl and D rl of errors for x l and r l of the parent agent in FIG. 53 can be expressed as the following equations (3) and (4), respectively.
- the network updating unit 228 can obtain the differential coefficients for x and r of errors for all agents in order from the agent on the output side of the network to the agent on the input side.
- partial derivatives ( ⁇ X / ⁇ x, ⁇ R / ⁇ x, ⁇ X / ⁇ r, ⁇ R / ⁇ r) of the node operation can be individually obtained for each operation node.
- calculation forwarder 226 obtains a partial differential of the node operation at the time of forward propagation.
- the partial differential can be calculated more efficiently than the network update unit 228 calculates the partial differential during back propagation.
- the program can be simplified as a whole.
- the derivative of the error about the node variable ⁇ z ⁇ can be calculated from the derivative of the child agent and the partial derivative of the node operation. More specifically, the derivative D z of the error for z of a node is the product sum of the derivative of the error for X, R of the child agent generated at the firing of that node and the partial derivative of z for X, R For all child agents.
- FIG. 54 is a diagram for describing a derivative related to a node constant of an error.
- Derivative D v of error for v arithmetic constants nodes of FIG. 54 can be expressed as the following equation (5).
- control constants node with s as a node variables Similarly, the decision node having a beta r as node variables, it is possible to determine the differential coefficient D z error for the node variables.
- Network update unit 228, the above procedure, the variable nodes, i.e., for all the operation node with node variables, determine the differential coefficient D z error for the node variables. Then, the network updating unit 228 substitutes the obtained D z into the equation (2), and updates the node variable z of each variable node.
- the network updating unit 228 determines that the learning coefficient ⁇ is multiplied by (1 ⁇ lp ) by one update of ⁇ z ⁇ .
- ⁇ lp represents a learning rate in one pass and is a constant greater than 0 and less than 1.
- Equation (6) The deformation of the right side in equation (6) is due to Taylor expansion.
- Equation (7) the following Equation (7) can be obtained for the learning coefficient ⁇ .
- the network updating unit 228 may obtain the learning coefficient ⁇ according to the equation (7). That is, the network updating unit 228 obtains a learning coefficient ⁇ for each variable node based on the energy error E and D z obtained by back propagation according to the equation (7).
- the value of ⁇ lp may be predetermined or may be determined by the user. According to the inventor's trial, the preferable value of ⁇ lp is about 0.5 to 0.7. However, the value of ⁇ lp is not limited to this.
- the network updating unit 228 can update the network by changing the structure of the network, in addition to the above-mentioned updating of the node variable. That is, the topology learning unit 228 b included in the network updating unit 228 can update the network by performing addition and deletion of operation nodes and reconnection of edges. Such node creation / deletion and edge reconnection lead to modification of the network topology and change the algorithm. This update is called topology learning.
- the topology learning unit 228 b changes the structure of the network in accordance with the following rules.
- the topology learning unit 228 b may change the structure of the network according to some rules instead of following all the rules below.
- FIG. 55 is a diagram for describing constantization.
- FIG. 55 (a) is a diagram showing a part of the network before constantization.
- FIG. 55 (b) shows a part of the network after constantization.
- the topology learning unit 228b displays the network in FIG. 55 (b) when the Addition node (+) shown in FIG. 55 (a) continuously supplies the same arithmetic value to the output agent for a predetermined number of times or more. Change to state. That is, the topology learning unit 228 b changes the Addition node (+) to an arithmetic constant node (c). Further, the topology learning unit 228b sets an edge input to the arithmetic constant node as one having the smallest sum of r values in the past among the edges input to the Addition node. The topology learning unit 228b deletes the remaining edges input to the Addition node.
- FIG. 56 is a flow chart showing the flow of processing performed by the topology learning unit 228b in making it constant.
- topology learning unit 228b sets, for each operation node, a set of output values (arithmetic value or control value) based on a set (x [], r []) of a set of values included in node information 134a. It is determined whether or not the predetermined number or more continuously has the same value.
- topology learning unit 228b performs arithmetic constant node operation in step S103. c) or change to a control constant node (C).
- topology learning unit 228b extracts the input edge input to the operation node that has the smallest sum of control values r in the past.
- topology learning unit 228b deletes the input edge not extracted at step S105.
- topology learning unit 228b does not perform the process of steps S103 to S107.
- variable generation New nodes are created as a function of randomly chosen nodes. This rule is called making variable (MKV). According to variable generation, the algorithm can be complicated without affecting the calculation result. Thus, variable generation can prevent the algorithm from falling into an inappropriate equilibrium state. In addition, according to variable generation, it is possible to prevent the network scale from being reduced by constantization and the like, and to maintain the network scale.
- FIG. 57 is a diagram for describing variable generation.
- FIG. 57 (a) shows a part of the network before variable generation.
- FIG. 57 (b) is a diagram showing a part of the network after variable generation.
- the topology learning unit 228 b randomly selects two operation nodes.
- FIG. 57 (a) shows two selected operation nodes. Then, topology learning unit 228b generates an Addition node (+) shown in FIG. 57 (b). The topology learning unit 228 b also generates an edge to be input to the Addition node (+) from the two selected operation nodes.
- the topology learning unit 228 b may select three or more operation nodes and connect the selected operation node to the Addition node. Also, the topology learning unit 228 b may generate operation nodes other than the Addition node.
- FIG. 58 is a flowchart showing a flow of processing performed by the topology learning unit 228b in variable generation.
- step S201 topology learning unit 228b randomly selects a plurality of operation nodes.
- topology learning unit 228b generates a new operation node.
- the topology learning unit 228 b generates operation nodes having the same number of inputs as the number of operation nodes selected in step S 201.
- step S205 the topology learning unit 228b generates an edge to be input to the operation node generated in step S203 from each operation node selected in step S201.
- FIG. 59 is a diagram for describing a bridge.
- FIG. 59 (a) shows a part of the network before bridge processing.
- FIG. 59 (b) shows a part of the network after the bridge process.
- the topology learning unit 228 b randomly selects the operation node a and the operation node b.
- FIG. 59 (a) shows the operation node a and the operation node b.
- FIG. 60 is a flowchart showing a flow of processing performed by the topology learning unit 228b for bridge.
- topology learning unit 228b randomly selects operation node a and operation node b.
- topology learning unit 228b generates an edge directed from operation node b to c node.
- topology learning unit 228b generates a Multiplication (*) node.
- the topology learning unit 228b generates an edge from the operation nodes b and c to the * node.
- the topology learning unit 228 b generates an Addition (+) node in step S 311.
- topology learning unit 228b generates an edge from operation node a, * toward + node.
- ⁇ Branch> The randomly selected node a branches depending on the determination between the nodes b and c.
- nodes b and c are nodes randomly selected from among nodes whose sum of past control values r is larger than the sum of past control values r of node a. This process is called branching (Fork, FRK).
- FIG. 61 is a diagram for explaining a branch.
- FIG. 61A shows a part of the network before the branching process.
- FIG. 61 (b) shows a part of the network after the branching process.
- the topology learning unit 228 b selects the operation node a. Also, topology learning unit 228 b randomly selects operation node b and operation node c from among nodes whose sum of control values r in the past is larger than the sum of control values r in the past of operation node a.
- FIG. 61 (a) shows the operation node a, the operation node b, and the operation node c.
- Topology learning unit 228b generates a determination node (L) that receives inputs from operation node b and operation node c, as shown in FIG. 61 (b). Also, topology learning unit 228 b generates a first Read node (r) that receives the output of operation node a and the first output of the determination node. Topology learning unit 228 b generates a second Read node (r) receiving the output of operation node a and the second output of the determination node. Further, the topology learning unit 228 b generates an edge for inputting the calculation result of the first Read node and the second Read node to each operation node to which the operation node a is connected.
- Branch processing can complicate the algorithm without changing the calculation result.
- branch processing can prevent the algorithm from falling into an inappropriate equilibrium state.
- branching process it is possible to prevent the network scale from being reduced by constantization or the like, and to maintain the network scale.
- FIG. 62 is a flowchart showing the flow of processing performed by the topology learning unit 228b at the time of branching.
- step S401 topology learning unit 228b randomly selects operation node a.
- topology learning unit 228b randomly selects operation node b and operation node c from among nodes whose sum of control values r in the past is larger than the sum of control values r in the past of operation node a.
- topology learning unit 228b generates a determination node (L) that receives inputs from operation node b and operation node c. That is, topology learning unit 228 b generates a determination node, and generates an edge directed to the determination node generated from operation node b and operation node c.
- topology learning unit 228b generates a first r node and a second r node.
- topology learning unit 228b connects operation node a to the first r node and the second r node. That is, the topology learning unit 228 b generates an edge from the operation node a toward the first r node and the second r node.
- topology learning unit 228b connects the determination node to the first r node and the second r node. That is, the topology learning unit 228b generates an edge from the determination node toward the first r node and the second r node.
- topology learning unit 228b generates an edge from operation node a to operation node a from the first r node and the second r node.
- topology learning unit 228b deletes the edge that was originally output by operation node a.
- ⁇ Tuple merge> Two vertically linked Addition nodes or Multiplication nodes merge according to a coupling rule.
- the “vertical connection” of two Addition nodes means that the two Addition nodes are directly connected by an edge. This process is called Tuple merge (MGT). Tuple merge can simplify the algorithm without affecting the calculation result.
- FIG. 63 is a diagram for explaining the Tuple merge.
- FIG. 63 (a) shows a part of the network before Tuple merge.
- FIG. 63 (b) shows a part of the network after Tuple merge.
- the topology learning unit 228b deletes one Addition node from the two Addition nodes. Also, the topology learning unit 228 b connects the edge that has been connected to the deleted Addition node to the remaining Addition nodes. The topology learning unit 228 b performs the same processing on two vertically connected Multiplication nodes.
- FIG. 64 is a flowchart showing a flow of processing performed by the topology learning unit 228b in Tuple merge.
- topology learning unit 228b selects one + node (or * node).
- topology learning unit 228 b determines whether or not the + node (or * node) selected in step S 501 has a + node (or * node) as a connection destination.
- topology learning unit 228 b deletes the + node (or * node) selected in step S 501 in step S 505.
- step S507 the topology learning unit 228b connects the edge that has been input to the deleted + node (or * node) to the + node (or * node) of the connection destination.
- topology learning unit 228 b does not perform the processing in steps S 505 and S 507.
- ⁇ Node merge> A plurality of constant nodes input to the Addition node or the Multiplication node merge according to a connection rule. This process is called "Merge Node (MGN)". Node merging can simplify the algorithm without affecting the calculation results.
- FIG. 65 is a diagram for describing node merge.
- FIG. 65 (a) shows a part of the network before node merging.
- FIG. 65 (b) is a diagram showing a part of the network after node merging.
- the topology learning unit 228b makes two constant nodes into two constant nodes as shown in FIG. 65 (b). Replace with one constant node with constant value added constant value of.
- topology learning unit 228 b adds constant values obtained by adding constant values of all constant nodes input in Addition node to constant nodes input in Addition node. Rewrite to one constant node you have.
- the topology learning unit 228 b performs the same processing on two vertically connected Multiplication nodes.
- FIG. 66 is a flowchart showing a flow of processing performed by the topology learning unit 228b for node merging.
- topology learning unit 228b selects one + node (or * node).
- step S603 the topology learning unit 228b determines whether or not a plurality of constant nodes are input to the + node (or * node) selected in step S601.
- topology learning unit 228b calculates the sum (or product) of constant values of constant nodes to be input in step S605, and newly obtains the value obtained by the calculation. Constant value.
- topology learning unit 228 b generates a new constant node having a new constant value.
- the topology learning unit 228 b also generates an edge from the new constant node to the + node (or * node) selected in step S 601. Furthermore, the topology learning unit 228 b replaces the edge input to the original constant node with the new constant node.
- topology learning unit 228b deletes the original constant node.
- topology learning unit 228b When a plurality of constant nodes are not input (NO in step S603), topology learning unit 228b does not perform the process of steps S605 to S609.
- FIG. 67 is a diagram for describing constant node split.
- FIG. 67 (a) is a diagram showing part of the network before constant node split.
- FIG. 67 (b) is a diagram showing a part of the network after constant node splitting.
- the topology learning unit 228b When the constant value of the arithmetic constant node shown in FIG. 67 (a) is continuously changed by the correction based on the error a predetermined number of times or more, the topology learning unit 228b performs as shown in FIG. 67 (b). , Create a new arithmetic constant node with the same constant value as the arithmetic constant node.
- the topology learning unit 228 b creates (the number of outputs of the original arithmetic constant node ⁇ 1) number of new arithmetic constant nodes. Since the number of outputs of the arithmetic constant node shown in FIG. 67 (a) is 2, the topology learning unit 228b creates one new arithmetic constant node.
- the topology learning unit 228 b creates an edge directed to a new arithmetic constant node from an operation node giving an input to the original arithmetic constant node. Furthermore, the topology learning unit 228 b creates an edge from each of the original or new arithmetic constant nodes to one of the operation nodes of the output destination of the original arithmetic constant node. The topology learning unit 228 b deletes the edge output from the original arithmetic constant node.
- FIG. 68 is a flow chart showing a flow of processing performed by the topology learning unit 228b at constant node division.
- topology learning unit 228 b determines, for each constant node, whether or not the constant value of the constant node has been continuously changed by a correction based on an error a predetermined number of times or more.
- topology learning unit 228b creates a new constant node of the same constant value as the constant node in step S703.
- the topology learning unit 228b creates (the number of outputs of the original arithmetic constant node-1) new constant nodes.
- topology learning unit 228 b connects the edge input to the original constant node to the new constant node. Also, the topology learning unit 228 b creates an edge from each of the original or new arithmetic constant nodes to one of the operation nodes of the output destination of the original arithmetic constant node.
- topology learning unit 228b does not perform the process of steps S703 and S705.
- a constant node whose value does not determine is one of the causes of network instability.
- the computation node 100 can create a stable network by excluding such a constant node by constant node splitting.
- the network creation unit 222 converts GIMPLE into ATN based on the following rules.
- the network creation unit 222 generates an arithmetic constant node having the right side value (R value) as a constant.
- the network creation unit 222 also creates a virtual variable node of the left side value (L value).
- the L-valued virtual variable node is a combination of a Write node, an Equal node, and an edge from the Write node to the Equal node. Furthermore, the network creation unit generates an edge from the constant node to the virtual variable node of L value, and connects the constant node and the virtual variable node of L value.
- the operation node 320 corresponds to the constant value “1” on the right side.
- Operation nodes 322 and 324 connected by an edge are virtual variable nodes of L value.
- the network creation unit 222 creates a virtual variable node of R value.
- the virtual variable node of R value is a combination of an Equal node, a Read node, and an edge from the Equal node to the Read node.
- the network creation unit 222 also creates a virtual variable node of L value. Furthermore, the network creation unit 222 generates an edge from the virtual variable node of R value toward the virtual variable node of L value, and connects the virtual variable node of R value and the virtual variable node of L value.
- Operation nodes 326 and 328 connected by an edge are virtual variable nodes of R value.
- Operation nodes 330 and 332 connected by an edge are virtual variable nodes of L value.
- ⁇ op> is a binary operator such as addition (+) or multiplication (*).
- the network creation unit 222 creates an operation node (referred to as an op node) corresponding to the binary operator.
- the network creation unit 222 also generates an arithmetic constant node or a virtual variable node corresponding to the R value, and a virtual variable node of the L value.
- the network creation unit 222 connects the node of R value to the op node.
- the network creation unit 222 connects the op node to the virtual variable node of L value.
- the operation node 332 and the operation node 336 correspond to “1” and “2” on the right side of the instruction, respectively.
- the operation node 336 is an op node.
- Operation nodes 340 and 342 connected by edges are virtual variable nodes of L value.
- the network creation unit 222 replaces the branch instruction “goto ⁇ label>;” in GIMPLE with an edge connected to a separately generated Equal node. That is, the network creation unit 222 creates a new edge connected to the Equal node having the label specified by the branch instruction.
- the network creation unit 222 generates an Equal node having a label designated by GIMPLE, corresponding to the label “ ⁇ label>:;” in GIMPLE.
- the network creation unit 222 sets the conditional branch instruction “if (R-value1 ⁇ op> R-value2) block1 else block2” (for example, if (1> 0) block1 else block2) in GIMPLE to a network element as follows: replace.
- the network creation unit 222 creates an op node corresponding to the binary operator in the if statement. Also, the network creation unit 222 creates a node corresponding to the constant or variable in the if statement. The network creation unit 222 connects the output on the TRUE side of the op node to block1. Also, the network creation unit 222 connects the output on the FALSE side of the op node to block2.
- virtual variable nodes and L variable virtual variable nodes are generated. Furthermore, the network creation unit 222 connects the node of R value to the op node. Also, the network creation unit 222 connects the op node to the virtual variable node of L value.
- FIG. 3 A network element corresponding to the instruction “if (1> 0) block 1 else block 2” in GIMPLE is shown in FIG.
- the operation node 344 and the operation node 346 correspond to “1” and “0” in the if statement, respectively.
- the operation node 348 is an op node.
- the output on the TRUE side of the operation node 348 is output to the first block 350.
- the output on the FALSE side of the operation node 352 is output to the second block 352.
- the network creation unit 222 first creates the start node N101.
- the network creation unit 222 creates an edge from the start node N101 to the node N102.
- the network creation unit 222 converts “ ⁇ D1283> :;” on the GIMPLE fourth line into the node N104 according to the label conversion rule.
- the network creation unit 222 creates an edge from the node N102 toward the node N103.
- the network creation unit 222 creates an edge from the node N104 toward the node N105 and the node N106.
- the network creation unit 222 converts “if (i ⁇ 9)” in the GIMPLE sixth line into nodes N 109 to N 111 and an edge connecting these according to the conversion rule of the conditional branch.
- the network creation unit 222 creates an edge from the node N108 toward the node N109 and the node N110.
- the network creation unit 222 is an edge that connects “goto ⁇ D1283>” on the eighth line GIMPLE, which is performed when the determination result of the conditional branch is True according to the conversion rule of the branch, from the 0 side output of the node N111 to the node N104. Convert to
- the network creation unit 222 executes “goto ⁇ D1283>” on the GIMPLE 12th line, which is performed when the judgment result of the conditional branch is False (that is, in the else statement) according to the conversion rule of the branch, 1 of the node N111.
- the side output is converted into an edge connected to the node N112.
- the network creation unit 222 converts “ ⁇ D1285> :;” on the GIMPLE 14th line into the node N112 according to the label conversion rule.
- the network creation unit 222 creates the ans node N113 and creates an edge from the node N112 toward the ans node 113.
- a program obtained by converting a program is simply referred to as a “network”, and a network connecting a plurality of computers by communication is referred to as a “communication network”. Furthermore, a virtual network configured on a communication network is called an "overlay network”.
- calculations can be performed using a plurality of computers, and ultimately, communication of a plurality of computers distributed on a global scale It is also possible to perform ATN-type network calculations on the network.
- FIG. 75 is a conceptual diagram for describing a computer processing system 1000 according to the second embodiment using such peer-to-peer technology.
- Peers 1010.1 to 1010.n participating in the computing system 1000 according to the second embodiment. It is assumed that a tool (application software) for executing calculations of ATN-type network is installed in n. Such tools are available in each computer 1010.1 to 1010. Run in the background using n extra computing resources.
- ATN type networks correspond to virtual communication networks (overlay networks) created on top of computer communication networks.
- the nodes of the ATN network are one peer (node computer)
- the edges of the ATN network are virtual links between peers
- the agents of the ATN network are It is implemented as a packet (or data flow) communicated between peers.
- the peers include an input peer that functions as an input node of the ATN format network and an output peer that functions as an output node.
- the peers participating in the computing system 1000 are actually assigned nodes of the ATN type network at present, and participate in computation / learning "real nodes (real peers)" and nodes of the ATN type network currently. It is divided into unallocated “hidden nodes (hidden peers)".
- a virtual link connecting real peers is called “real edge”
- a link connecting real peers and hidden peers, or links connecting hidden peers is called “hidden edge”.
- the agent transfers data related to forward propagation and back propagation shown in FIGS. 7, 53 and 54, “data transfer agent”, and “topology learning agent” related to topology modification shown in FIGS. 55 to 68.
- inter-monitoring agent that performs inter-monitoring between peers.
- the data transfer agent transfers data related to forward propagation and back propagation by exchanging agent information 134c and the deletion label list 134d among the information shown in FIG. Perform processing such as numerical correction.
- the topology learning agent carries out processing for topology modification by switching between real peers and hidden peers, occasionally staying at a certain peer, and executing its own function program. At this time, if it is necessary to newly create a node, a special topology learning agent is multicasted from the real peer and relayed and forwarded through the real / hidden peer to search and identify the peer. Ru. The hidden peer found is newly assigned as a real peer.
- Mutual monitoring agents perform mutual monitoring between adjacent peers to guarantee fault tolerance and free participation. This agent always goes back and forth between adjacent peers, searches for and identifies an alternative hidden peer when a real peer fails, and assigns the found hidden peer to the real peer.
- the management node (hidden node) 1010. c, user node (hidden node) 1010. u, input node (real node) 1010. i, and an output node (real node) 1010. o is set.
- Management node 1010. c is the user node 1010.
- I / O nodes are assigned, and execution of the ATN format network is instructed to start.
- the completion of the completed algorithm (network topology), Transfer to u.
- each agent can manage the management node 1010. has address information c and manages the progress of the operation on the node 1010. Notify c.
- Input node 1010. i is a management node 1010. Hold input data for learning received from c. Output node 1010. o holds training data for learning, and performs differential coefficient calculation based on error.
- the nodes on the virtual network and the physical node computers do not necessarily have to correspond one to one, for example, on the virtual network.
- the plurality of nodes may be realized by one physical computer.
- the computing system 1000 of the second embodiment is not limited to server-client type (centralized type) such as grid computing as a method of distributed computing, but is peer-to-peer based on peer-to-peer communication. Implemented as a peer type (autonomous distributed type) application.
- the computer processing system is a feature of peer-to-peer communication: 1) fault tolerance that another peer can take over even if some peer fails, 2) each node Has the advantages of free participation, where you can join and leave at any time, and 3) resource dispersability, where you do not have to put together a large amount of data in one place.
- Examples of applications of the calculation processing apparatus include the following. (1) A compilation and execution system that self-repairs a program defect based on the ideal data given by the user (PC embedded software etc.) (2) A system that acquires an algorithm for finding out necessary information by searching from ambiguous information by learning (next-generation network communication etc.) (3) Robust knowledge transfer system (factory, hospital, etc.) that learns its own algorithm based on the teacher data given by the expert
- the user gives the calculation processing apparatus a rough coded program as an initial program, and gives control output data by an expert as teacher data.
- the computer can repeat program updating, and can create a program that represents the knowledge of a skilled person who could not be handed down because it is complicated and difficult to be clearly written.
- the user can construct a machine system that operates stably using the created program.
- Robot program that adapts to the environment to make optimal decisions, controls, and plans based on teacher data (care, exploration, disaster, space field, etc.) (5) System biology model (metabolism map, signal pathway, etc.) having the ability to estimate in vivo algorithms based on biometric data
- 100 computing device 102 computer main unit, 104 monitor, 105 bus, 106 FD drive, 108 optical disk drive, 110 keyboard, 112 mouse, 122 memory, 124 hard disk, 128 communication interface, 131 initial program, 132 network creation program, 133 network Fix program, 134 network information, 134a node information, 134b connection information, 134c agent information, 134d deletion label list, 135 node operation definition, 136 learning variable, 210 input unit, 220 operation unit, 222 network creation unit, 224 format conversion unit , 226 calculation execution unit, 228 network update unit, 230 output unit, 240 storage unit, 1000 Calculation processing system, 1010.1 to 1010. n-node computer.
Abstract
Description
なお、他の技術トレンドとして、インターネットにおける分散コンピューティング等を可能にするピア・ツー・ピア(P2P:Peer to Peer)技術がある。ピア・ツー・ピアのシステムにおいては、専用のサーバのない環境で、クライエント(たとえば、パーソナルコンピュータ)同士が分散的にデータの交換や処理を行う(たとえば、非特許文献5を参照)。ピア・ツー・ピア方式は、端末数が膨大になっても回線帯域などに余裕がある限り通信が可能という特徴がある。
ところで、一般に、通信ネットワークと呼ばれるシステムであれ、より特定的に、上述したようなピア・ツー・ピアシステムであれ、ネットワークは、物理的には、複数の情報通信機器(ノード)と、これらを相互接続する通信回線(リンク)から構成されている。
さらに好ましくは、ネットワーク更新部は、ネットワークに対し、演算ノードの変更、追加または削除処理を行なう。
(1.概要)
本実施の形態に係る計算処理装置100は、外部から与えられたプログラム(以下、初期プログラムとも呼ぶ)を修正し、より適切な演算結果を出力するプログラムを作成する。計算処理装置は、大まかに分けて、次の3つの処理を行なう。
(1)プログラムのネットワークへの変換
(2)ネットワークを用いた計算の実行
(3)ネットワークの修正
以下、各処理の概要を説明する。
計算処理装置100は、与えられた初期プログラムに基づいて、ネットワーク型のプログラムを作成する。すなわち、計算処理装置100は、初期プログラムのアルゴリズムの構造を表現するネットワークを作成する。
計算処理装置100は、作成したネットワークを用いて計算を実行する。すなわち、計算処理装置100は、入力値に対し、エッジで表わされる順序に従って、演算ノードによる演算を施す。
計算処理装置100は、学習アルゴリズムを用いて、ネットワークを用いた計算結果に基づいてネットワークを修正する。すなわち、計算処理装置100は、ネットワークによる計算結果が、ユーザが所望する値に近づくように、ネットワークを修正する。より詳しくは、計算処理装置100は、演算ノードの定数値を変更する逆伝播学習と、ネットワークのトポロジーを変更するトポロジー学習とを行なう。逆伝播学習およびトポロジー学習の詳細については後述する。
本実施の形態に係る計算処理装置100のハードウェア構成について、図2を参照して説明する。図2は、本実施の形態に係る計算処理装置100の構成をブロック図形式で表す図である。
図3を参照して、本実施の形態に係る計算処理装置100の機能的構成について説明する。図3は、本実施の形態に係る計算処理装置100の機能的構成をブロック図形式で示す図である。
ネットワーク作成部222が作成するネットワークについて、具体例を挙げて説明する。ここでは、初期プログラム131が、図4に示すC言語で記述されたソースコードであるとして説明する。図4は、初期プログラム131の一例を示す図である。ただし、初期プログラム131は、C言語以外のプログラム言語で記述されたソースコードであってもよい。初期プログラム131は、例えば、C、C++、Fortran、Ada、Objective-C、Java(登録商標)、Pascal、COBOLなどの高級言語で記述されていてもよい。
ここから、ネットワークに含まれる演算ノード、ならびに、演算ノードの演算対象であるエージェントについて説明する。
[原則1] 値の組(x,r)がエッジ付随のエージェントからエージェントへ伝播していく。
[原則2] エージェントの持つ2進ラベルベクトルが親エージェントから子エージェントへと遺伝する。
[規則1] (1入力演算の場合)演算ノードは、単独で発火する。
[規則2] (多入力演算の場合)演算ノードは、演算ノードに入力する2つのエージェントのラベルA,BがAB≠0を満たすならば、発火する。
[規則3] 入力エージェントのラベルA,Bのブール積ABが、子エージェントに遺伝する。
[規則4] 演算ノードの発火後、入力エージェントのラベルA,Bは、それぞれ、AB’とA’Bに変わる。
[規則5] ラベル=0のエージェントは、発火不能になる。すなわち、ラベル=0のエージェントが演算ノードに入力しても、演算ノードは発火しない。
A’B=(ba’)’・cba’=(b’+a)cba’=0
となる。したがって、規則5によれば、ラベルBを持っていたエージェントは発火不能となる。つまり、長い方のラベルを持っていたエージェントは、発火不能となる。
AB’=ba’・(cba’)’=ba’(c’+b’+a)=c’ba’
となる。このエージェントは、発火可能である。つまり、短い方のラベルを持っていたエージェントは、発火可能なエージェントとして残る。残ったエージェントは、待ち状態となる。つまり、残ったエージェントは、新たなエージェントが演算ノードに来るまで演算が施されない。図では、待ち状態にあるエージェントのラベルを斜線で表わす。左上から右下への斜線を引いた丸は、肯定のブール変数(白丸)の待ち状態に対応する。右上から左下への斜線を引いた丸は、否定のブール変数(黒丸)の待ち状態に対応する。
AB’=(ba’)・(dcba’)’=(ba’)・(d’+c’+b’+a)=d’1ba’+1c’ba’
となる。
Startノードは、文字Sで表わされる。Startノードは、演算の開始点に配置される。Startノードの入力数は0である。Startノードから出力されるエージェントは、算術値を有しない。計算の開始時点では分岐がないため、Startノードは、出力するエージェントに対し、取りうる最大の制御値R=1を与える。
R0=sig(κβr(x0-x1))・Min(r0,r1)と
R1=sig(κβr(x1-x0))・Min(r0,r1)と
を出力するエージェントに与える。ここで、sigは、シグモイド関数であり、
sig(z)=1/{1+exp(-z)}
で定義される。また、κは定数、βrはノード変数である。つまり、Less thanノードが出力するエージェントは、制御値の値によって2種類に区別される。各種類のエージェントは、1つであっても複数であってもよい。 Writeノードは、文字wで表わされる。Writeノードの入力数は、1である。Writeノードは、算術値および制御値に対し演算を行なう。Writeノードは、2つのエッジを出力する。Writeノードは、1つのエッジ(図6では、近辺に“0”が描かれたエッジ)の上のエージェントに対し、算術値を出力せず、制御値R0=r0のみを出力する。Writeノードは、もう1つのエッジ(図6では、近辺に“1”が描かれたエッジ)の上のエージェントに対し、X1=x1およびR1=r0を出力する。
ネットワーク、エージェント、および演算ノードについての説明に続いて、記憶部240が格納するネットワーク情報134および学習変数136について詳しく説明しておく。
ここから、ATNを用いた計算について、詳細に説明する。ATNを用いた計算は、エージェントに対し、矢印に沿った順序で演算ノードによる演算が施されることで、実現される。この性質のため、以下、ATNを用いた計算を、順伝播(Forward Propagation)とも呼ぶ。
[規則1] (1入力演算の場合)エージェントは、単独で発火する。
[規則2] (多入力演算の場合)演算ノードは、演算ノードに入力する2つのエージェントのラベルA,BがAB≠0を満たすならば、発火する。
[規則3] 入力エージェントのラベルA,Bのブール積ABが、子エージェントに遺伝する。
[規則4] 演算ノードの発火後、入力エージェントのラベルA,Bは、それぞれ、AB’とA’Bに変わる。
[規則5] ラベル=0のエージェントは、発火不能になる。すなわち、ラベル=0のエージェントが演算ノードに入力しても、演算ノードは発火しない。
[規則6] 0に近い制御値を持つエージェントは、‘発火不能’となり、そのラベルは削除ラベルリストに格納される。ここでは、r<rth=0.01のエージェントが、発火不能になるとする。ただし、rthの値は、これに限られるものではない。
[規則7] 判断ノードLは、子エージェントに新しいブール変数を加える。
[規則8] 最終的な演算結果が入力されるansノードに到着したエージェントのラベルは、削除ラベルリストに格納される。
[規則9] 新たに削除ラベルリストに登録されたラベルの否定がネットワーク内のすべてのラベルに掛けられる。
[規則10] 判断ノードLで生成されるエージェントのラベルには新しいブール変数が掛けられる。
以上のようにして求めた計算結果は、ユーザの所望する値(教師値)と異なることがある。特に、ユーザが、ラフにコードしたプログラムを初期プログラム131とした場合は、普通、順伝播による計算結果は、教師値とは異なる。そこで、ネットワーク更新部228は、計算結果と教師値との間のエネルギー誤差が所定の値より大きい場合、ネットワークを修正する。
∂y/∂a=1+x=1+x・1=∂y/∂a1+∂z/∂a2・∂y/∂z …(*)
ここで最右辺の第1項は、実線の経路についての偏微分の積である。また、最右辺の第2項は、破線の経路についての偏微分の積である。したがって、チェインルールが成り立っていることが分かる。なお、式(*)から類推できるように、チェインルールは、合成関数の偏微分法を言い換えたものである。したがって、チェインルールは、常に成り立つ。
式(6)を変形することで、学習係数ηについて次の式(7)が得られる。
ネットワーク更新部228は、上述のノード変数の更新に加え、ネットワークの構造を変化させることでネットワークを更新することができる。すなわち、ネットワーク更新部228に含まれるトポロジー学習部228bは、演算ノードの追加や削除、エッジのつなぎかえを行なって、ネットワークを更新することができる。このようなノードの生成・削除やエッジのつなぎかえは、ネットワークトポロジーの改変をもたらし、アルゴリズムを変化させる。この更新をトポロジー学習と呼ぶ。
発火で計算される(X,R)値が長い間変化しないノードは、算術定数ノード(c)または制御定数ノード(C)に変わる。この規則を定数化(Constantification、CON)と呼ぶ。定数化により、計算結果に影響を与えることなく、アルゴリズムを簡略化することができる。
ランダムに選ばれたノードの関数として新しいノードが作られる。この規則を変数生成(Making Variable、MKV)と呼ぶ。変数生成によれば、計算結果に影響を与えることなく、アルゴリズムを複雑化することができる。したがって、変数生成によって、アルゴリズムが不適切な均衡状態に陥ることを防ぐことができる。また、変数生成によれば、定数化などによりネットワークの規模が縮小することを防ぎ、ネットワークの規模を保つことができる。
ランダムに選ばれたノードaは、ランダムに選ばれたノードbを使って(a+0*b)に変わる。この処理をブリッジ(Bridge、BRG)と呼ぶ。
ランダムに選ばれたノードaは、ノードb、c間の判定により分岐する。ただし、ノードb、cは、各々、過去の制御値rの和が、ノードaの過去の制御値rの和よりも大きいノードの中からランダムに選ばれたノードである。この処理を分岐(Fork、FRK)と呼ぶ。
2つの縦つながりのAdditionノードまたはMultiplicationノードは、結合法則により合体する。2つのAdditionノードが「縦つながり」とは、2つのAdditionノードがエッジで直接接続されていることを意味する。この処理をTupleマージ(Merge Tuple;MGT)と呼ぶ。Tupleマージにより、計算結果に影響を与えることなく、アルゴリズムを簡略化することができる。
AdditionノードまたはMultiplicationノードに入力する複数の定数ノードは、結合法則により合体する。この処理をノードマージ(Merge Node,MGN)と呼ぶ。ノードマージにより、計算結果に影響を与えることなく、アルゴリズムを簡略化することができる。
算術定数ノードまたは制御定数ノードは、その定数値がいつまでも定まらない場合は分裂する。この処理を、定数ノード分裂(Division、DIV)と呼ぶ。
説明を省略していた、GIMPLEからATNへの変換の詳細について、ここで説明する。ネットワーク作成部222は、以下の規則に基づいて、GIMPLEをATNに変換する。
ネットワーク作成部222は、GIMPLEにおいて左辺の変数に右辺の定数を代入する命令"L-value=R-value;"(例えば、x=1;)を、次のようにネットワーク要素(演算ノードおよびエッジ)に置き換える。
ネットワーク作成部222は、GIMPLEにおいて左辺の変数に右辺の変数を代入する命令"L-value=R-value;"(例えば、x=y;)を、次のようにネットワーク要素に置き換える。
ネットワーク作成部222は、GIMPLEにおける2項演算命令"L-value=R-value1 <op> R-value2;"(例えば、x=1+2;)を、次のようにネットワーク要素に置き換える。なお、ここで、<op>は、加法(+)、乗法(*)などの2項演算子である。
ネットワーク作成部222は、GIMPLEにおける分岐命令"goto<label>;"を、別途生成されるEqualノードに接続するエッジで置き換える。すなわち、ネットワーク作成部222は、分岐命令が指定するラベルをもつEqualノードに接続する新たなエッジを生成する。
ネットワーク作成部222は、GIMPLEにおけるラベル"<label>:;"に対応して、GIMPLEが指定するラベルを持つEqualノードを生成する。
ネットワーク作成部222は、GIMPLEにおける条件分岐命令"if (R-value1 <op> R-value2) block1 else block2"(例えば、if (1>0) block1 else block2)を、次のようにネットワーク要素に置き換える。
ネットワーク作成部222は、GIMPLE3行目の"i=0;"を、代入(R値が定数)の変換規則により、ノードN102、ノードN103、およびこれらを結ぶエッジに変換する。ネットワーク作成部222は、スタートノードN101からノードN102に向かうエッジを生成する。
実施の形態1では、ネットワークに変換されたプログラムの実行とネットワークの修正・学習は、図2に示すような単一のコンピュータで実行されるものとして説明した。
(1)ユーザの与える理想データをもとにプログラムの欠陥を自己修復するコンパイル・実行システム(パソコン組み込みソフトウェアなど)
(2)曖昧な情報の中から検索によって必要な情報を探し出すアルゴリズムを学習によって獲得するシステム(次世代ネットワーク通信など)
(3)エキスパートが与えた教師データをもとに自らアルゴリズムを学習するロバスト知識伝承システム(工場、病院など)
ユーザは、計算処理装置に、ラフにコードしたプログラムを初期プログラムとして与え、また、熟練者による制御出力データを教師データとして与える。計算処理装置は、プログラムの更新を繰り返し、複雑で多岐にわたり明文化することが困難であるため伝承できなかった熟練者の知識を表わすプログラムを作成することができる。ユーザは、作成されたプログラムを用いて、安定して動作する機械システムを構築することができる。
(5)生物計測データをもとに生体内のアルゴリズムを推定する能力を持ったシステム生物学モデル(代謝マップ、シグナル経路など)
Claims (19)
- 計算処理システムであって、
複数の演算ノードおよび2つの前記演算ノードの間を各々つなぐ複数のエッジによりプログラムのアルゴリズム構造を表わすネットワークを用いて計算を実行する計算実行部を備え、
前記複数の演算ノードは、プログラムの各種演算に対応する演算ノードを含み、
前記計算実行部の計算結果および学習アルゴリズムを用いて、前記計算結果を変化させることなくトポロジーを変更するネットワーク更新部をさらに備える、計算処理システム。 - 前記複数の演算ノードは、アルゴリズムの流れを表わす制御値に対する計算を行なう演算ノードを含む、請求の範囲第1項に記載の計算処理システム。
- 前記複数の演算ノードは、四則演算に対応する演算ノードを含む、請求の範囲第1項または第2項に記載の計算処理システム。
- 前記ネットワーク更新部は、前記ネットワークに対し、前記演算ノードの変更、追加または削除処理を行なう、請求の範囲第1項または第2項に記載の計算処理システム。
- 前記ネットワーク更新部は、出力値が所定の回数以上連続して変化しない前記演算ノードを一定の値を出力する定数ノードに変更する、請求の範囲第4項に記載の計算処理システム。
- 前記ネットワーク更新部は、前記複数の演算ノードの中から2以上の前記演算ノードを近傍のノードの中からランダムに選択し、選択された前記演算ノードと接続される新たな前記演算ノードを生成する、請求の範囲第4項に記載の計算処理システム。
- 前記ネットワーク更新部は、前記複数の演算ノードの中から第1の演算ノードと第2の演算ノードを近傍のノードの中からランダムに選択し、前記第2の演算ノードから前記第1の演算ノードへのブリッジを生成する、請求の範囲第4項に記載の計算処理システム。
- 前記ネットワーク更新部は、前記複数の演算ノードの中から前記演算ノードを近傍のノードの中からランダムに選択し、選択された前記演算ノードについて分岐を作成する、請求の範囲第4項に記載の計算処理システム。
- 前記ネットワーク更新部は、各々一定の値を出力する複数の定数ノードを、結合法則により、1つの前記定数ノードに書き換える、請求の範囲第4項に記載の計算処理システム。
- 前記ネットワーク更新部は、所定の回数以上連続して修正を受ける前記ノード変数をもつ前記演算ノードを分裂させる、請求の範囲第4項に記載の計算処理システム。
- 前記複数の演算ノードは、ノード変数を有する演算ノードを含み、
前記ネットワーク更新部は、前記計算結果の教師値からの誤差を計算し、前記誤差に対する前記ノード変数の寄与を計算し、前記寄与に基づいて前記ノード変数を修正する、請求の範囲第1項または第2項に記載の計算処理システム。 - 前記ネットワーク更新部は、前記誤差に基づいてエネルギー誤差を計算し、前記寄与として前記ノード変数についての前記エネルギー誤差の微係数を計算し、前記変数から前記微係数に学習係数をかけた値を引いて前記変数を更新する、請求の範囲第11項に記載の計算処理システム。
- 前記学習係数は、前記変数の更新により、前記エネルギー誤差が(1-η1p)倍(η1pは、0より大きく1未満の実数)になるように定められた値である、請求の範囲第12項に記載の計算処理システム。
- 外部からの入力を受け付ける入力部と、
前記入力部が受け付けるプログラムに基づいて、前記ネットワークを作成するネットワーク作成部とをさらに備える、請求の範囲第1項または第2項に記載の計算処理システム。 - 前記入力部が受け付けるプログラムは、高級言語で記述されたソースコードであり、
前記ネットワーク作成部は、前記ソースコードを言語非依存の中間コードに変換し、前記中間コードに基づいて前記ネットワークを作成する、請求の範囲第14項に記載の計算処理システム。 - 前記計算処理システムは、分散型の計算処理環境で動作する複数の計算処理装置を含み、
各前記計算処理装置が、前記計算実行部の実行する処理および前記ネットワーク更新部の行う処理を分散して処理する、請求の範囲第1項に記載の計算処理システム。 - 計算処理システムを用いたプログラム作成方法であって、
前記計算処理システムが複数の演算ノードおよび前記演算ノードの間を各々つなぐ複数のエッジによりプログラムのアルゴリズム構造を表わすネットワークを用いて計算を実行するステップを備え、
前記複数の演算ノードは、プログラムの各種演算に対応する演算ノードを含み、
前記計算処理システムが前記計算の結果および学習アルゴリズムを用いて、前記ネットワークのトポロジーを、前記学習の結果を保存しつつ修正するステップをさらに備える、プログラム作成方法。 - 計算処理システムにプログラムを作成させるためのプログラム作成プログラムを記録したコンピュータ読取可能な記録媒体であって、前記プログラム作成プログラムは、コンピュータに、
前記計算処理システムに複数の演算ノードおよび前記演算ノードの間を各々つなぐ複数のエッジによりプログラムのアルゴリズム構造を表わすネットワークを用いて計算を実行させるステップを備え、
前記複数の演算ノードは、プログラムの各種演算に対応する演算ノードを含み、
前記計算処理システムに前記計算の結果および学習アルゴリズムを用いて、前記ネットワークのトポロジーを、前記学習の結果を保存しつつ修正させるステップをさらに備える、プログラム作成プログラムを実行させる、コンピュータ読取可能な記録媒体。 - 計算処理システムにプログラムを作成させるためのプログラム作成プログラムであって、
前記計算処理システムに複数の演算ノードおよび前記演算ノードの間を各々つなぐ複数のエッジによりプログラムのアルゴリズム構造を表わすネットワークを用いて計算を実行させるステップを備え、
前記複数の演算ノードは、プログラムの各種演算に対応する演算ノードを含み、
前記計算処理システムに前記計算の結果および学習アルゴリズムを用いて、前記ネットワークのトポロジーを、前記学習の結果を保存しつつ修正させるステップをさらに備える、プログラム作成プログラム。
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US13/125,540 US8984103B2 (en) | 2008-10-24 | 2009-10-23 | Calculation processing system, program creation method, and program creation program |
JP2010534850A JP5534524B2 (ja) | 2008-10-24 | 2009-10-23 | 計算処理システム、プログラム作成方法、コンピュータ読取可能な記録媒体、および、プログラム作成プログラム |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
JP2008-274282 | 2008-10-24 | ||
JP2008274282 | 2008-10-24 |
Publications (1)
Publication Number | Publication Date |
---|---|
WO2010047388A1 true WO2010047388A1 (ja) | 2010-04-29 |
Family
ID=42119424
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/JP2009/068271 WO2010047388A1 (ja) | 2008-10-24 | 2009-10-23 | 計算処理システム、プログラム作成方法、および、プログラム作成プログラム |
Country Status (3)
Country | Link |
---|---|
US (1) | US8984103B2 (ja) |
JP (1) | JP5534524B2 (ja) |
WO (1) | WO2010047388A1 (ja) |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JP2016021262A (ja) * | 2015-10-01 | 2016-02-04 | 国立研究開発法人情報通信研究機構 | 論理推論システム、計算学習装置および論理推論方法 |
WO2017038104A1 (ja) * | 2015-09-03 | 2017-03-09 | 株式会社Preferred Networks | 実装装置および実装方法 |
US11521070B2 (en) | 2015-10-29 | 2022-12-06 | Preferred Networks, Inc. | Information processing device and information processing method |
Families Citing this family (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9710764B1 (en) * | 2011-07-15 | 2017-07-18 | Sentient Technologies (Barbados) Limited | Data mining technique with position labeling |
CN111512306A (zh) * | 2017-12-19 | 2020-08-07 | 区块链信息技术科研有限公司 | 实施计算机网络的系统及方法 |
US20230080172A1 (en) * | 2020-03-13 | 2023-03-16 | Hewlett-Packard Development Company, L.P. | Transmitting node instructions |
Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JPH08272622A (ja) * | 1995-03-31 | 1996-10-18 | Hitachi Software Eng Co Ltd | プログラム変換装置 |
JP2001101251A (ja) * | 1999-09-30 | 2001-04-13 | Japan Science & Technology Corp | 自動設計装置及び設計処理方法 |
Family Cites Families (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JP3168204B2 (ja) * | 1989-12-20 | 2001-05-21 | 富士通株式会社 | ネットワーク構成データ処理装置 |
JPH04211802A (ja) * | 1990-07-25 | 1992-08-03 | Toshiba Corp | ニュ−ラルネットワ−ク装置 |
JPH04160463A (ja) * | 1990-10-24 | 1992-06-03 | Hitachi Ltd | ニューラルネットワークによる最適化方法 |
US5259064A (en) * | 1991-01-25 | 1993-11-02 | Ricoh Company, Ltd. | Signal processing apparatus having at least one neural network having pulse density signals as inputs and outputs |
KR100514681B1 (ko) * | 2000-09-22 | 2005-09-13 | 주식회사 케이티 | 비동기 전송 모드 통신망에서의 라우팅 방법 및 장치 |
US20020141342A1 (en) * | 2000-12-07 | 2002-10-03 | Furman Elliot M. | Method and system for automatically directing data in a computer network |
US7457257B2 (en) * | 2005-11-17 | 2008-11-25 | International Business Machines Corporation | Apparatus, system, and method for reliable, fast, and scalable multicast message delivery in service overlay networks |
US7844663B2 (en) * | 2006-07-10 | 2010-11-30 | International Business Machines Corporation | Methods, systems, and computer program products for gathering information and statistics from a community of nodes in a network |
US8069229B2 (en) * | 2006-12-28 | 2011-11-29 | Computer Associates Think, Inc. | Topology static zones |
-
2009
- 2009-10-23 WO PCT/JP2009/068271 patent/WO2010047388A1/ja active Application Filing
- 2009-10-23 JP JP2010534850A patent/JP5534524B2/ja not_active Expired - Fee Related
- 2009-10-23 US US13/125,540 patent/US8984103B2/en not_active Expired - Fee Related
Patent Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JPH08272622A (ja) * | 1995-03-31 | 1996-10-18 | Hitachi Software Eng Co Ltd | プログラム変換装置 |
JP2001101251A (ja) * | 1999-09-30 | 2001-04-13 | Japan Science & Technology Corp | 自動設計装置及び設計処理方法 |
Non-Patent Citations (1)
Title |
---|
TETSUYA SEKIOKA ET AL.: "Identeki Programming o Mochiita Kansu Gosei Algorithm no Kairyoho no Teian", THE TRANSACTIONS OF THE INSTITUTE OF ELECTRONICS, INFORMATION AND COMMUNICATION ENGINEERS (J83-D-I) NO.4, 25 APRIL 2000, vol. J83-D-I, no. 4, 25 April 2000 (2000-04-25), pages 407 - 417 * |
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO2017038104A1 (ja) * | 2015-09-03 | 2017-03-09 | 株式会社Preferred Networks | 実装装置および実装方法 |
JP2016021262A (ja) * | 2015-10-01 | 2016-02-04 | 国立研究開発法人情報通信研究機構 | 論理推論システム、計算学習装置および論理推論方法 |
US11521070B2 (en) | 2015-10-29 | 2022-12-06 | Preferred Networks, Inc. | Information processing device and information processing method |
US11915146B2 (en) | 2015-10-29 | 2024-02-27 | Preferred Networks, Inc. | Information processing device and information processing method |
Also Published As
Publication number | Publication date |
---|---|
JPWO2010047388A1 (ja) | 2012-03-22 |
US8984103B2 (en) | 2015-03-17 |
US20110202639A1 (en) | 2011-08-18 |
JP5534524B2 (ja) | 2014-07-02 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
Gad | Pygad: An intuitive genetic algorithm python library | |
Ciaburro et al. | Neural Networks with R: Smart models using CNN, RNN, deep learning, and artificial intelligence principles | |
WO2010047388A1 (ja) | 計算処理システム、プログラム作成方法、および、プログラム作成プログラム | |
Hemmi et al. | Development and evolution of hardware behaviors | |
Ding et al. | Modeling self-adaptive software systems with learning Petri nets | |
Lakhmiri et al. | HyperNOMAD: Hyperparameter optimization of deep neural networks using mesh adaptive direct search | |
CN113449858A (zh) | 一种神经网络模型的处理方法以及相关设备 | |
CN111914378B (zh) | 一种单振幅量子计算模拟方法及装置 | |
Braune et al. | A genetic programming learning approach to generate dispatching rules for flexible shop scheduling problems | |
JP2013008221A (ja) | 論理推論システム、計算学習装置および論理推論方法 | |
Cruz et al. | A linear logic programming language for concurrent programming over graph structures | |
CN113128015B (zh) | 预估单振幅模拟量子计算所需资源的方法和系统 | |
Pencheva et al. | Generalized net models of basic genetic algorithm operators | |
Bernard et al. | New techniques for inferring L-systems using genetic algorithm | |
Kreowski et al. | Graph transformation through graph surfing in reaction systems | |
Ismkhan | Effective three-phase evolutionary algorithm to handle the large-scale colorful traveling salesman problem | |
JP6044691B2 (ja) | 論理推論システム、計算学習装置および論理推論方法 | |
Gao et al. | An expanded lateral interactive clonal selection algorithm and its application | |
WO2004068342A1 (ja) | ソフトウェア開発前処理方法、ソフトウェア制御方法、ソフトウェア開発方法並びにソフトウェア開発装置 | |
Nehaniv | Self-replication, evolvability and asynchronicity in stochastic worlds | |
Kalenkova et al. | Application of a Genetic Algorithm for Finding Edit Distances between Process Models | |
KR102090109B1 (ko) | 학습 및 추론 장치 및 그 방법 | |
Liang | Decentralized learning of randomization-based neural networks | |
Peterson et al. | A distributed blossom algorithm for minimum-weight perfect matching | |
Kurth | Multiscale graph grammars can generate cayley graphs of groups and monoids |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
121 | Ep: the epo has been informed by wipo that ep was designated in this application |
Ref document number: 09822085 Country of ref document: EP Kind code of ref document: A1 |
|
ENP | Entry into the national phase |
Ref document number: 2010534850 Country of ref document: JP Kind code of ref document: A |
|
WWE | Wipo information: entry into national phase |
Ref document number: 13125540 Country of ref document: US |
|
NENP | Non-entry into the national phase |
Ref country code: DE |
|
122 | Ep: pct application non-entry in european phase |
Ref document number: 09822085 Country of ref document: EP Kind code of ref document: A1 |