JP2020035325A - Design system, learned model generation method, and design program - Google Patents

Abstract

To reduce processing load of a computer for designing a tangible object.SOLUTION: A design system includes at least one processor. The at least one processor inputs each of a plurality of initial data indicative of a structure of a tangible object into a calculation model and repeatedly performs enhanced learning. Then, in response to end conditions of predetermined enhancement learning being satisfied, the at least one processor acquires a calculation model obtained by the enhancement learning as a learned model for designing the structure of the tangible object.SELECTED DRAWING: Figure 2

Description

  One aspect of the present invention relates to a design system, a learned model generation method, and a design program.

  Conventionally, a method of designing a tangible object using a computer has been known. For example, Patent Literature 1 describes a pneumatic tire design method that configures a conversion system that associates a nonlinear correspondence between tire design parameters and tire performance with data of a multilayer feedforward neural network. . Patent Literature 2 discloses a method of controlling the rotational position of a multi-degree-of-freedom ultrasonic motor that performs feedback control for each rotation direction to enable construction of an inverse motion model and update during operation.

JP 2001-009838 A Japanese Patent No. 4209291

  In the related art, it is very difficult to obtain a highly versatile calculation model for a certain tangible object. Specifically, a calculation model that can derive a good solution under specific conditions (for example, conditions such as wind speed, temperature, vibration input, etc. from other than a tangible object) can obtain a good solution under other conditions. Can not. Therefore, it is necessary to reconstruct the calculation model from the beginning in accordance with the conditions required for the tangible object, and this increases the processing load of the computer. Therefore, it is desired to reduce the processing load of a computer that designs a tangible object.

  A design system according to one aspect of the present invention includes at least one processor, and at least one processor repeatedly executes reinforcement learning by inputting each of a plurality of initial data indicating a structure of a tangible object to a computation model, In response to the determined termination condition of reinforcement learning being satisfied, a calculation model obtained by reinforcement learning is acquired as a trained model for designing the structure of a tangible object.

  A method for generating a learned model according to one aspect of the present invention includes the steps of repeatedly executing reinforcement learning by inputting each of a plurality of initial data indicating the structure of a tangible object to a calculation model; and a predetermined reinforcement learning termination condition. Obtaining a computation model obtained by reinforcement learning as a trained model for designing the structure of a tangible object in response to the fact that is satisfied.

  A design program according to an aspect of the present invention includes a step of repeatedly executing reinforcement learning by inputting each of a plurality of initial data indicating a structure of a tangible object to a calculation model, and satisfying a predetermined reinforcement learning end condition. Acquiring the calculation model obtained by the reinforcement learning as a learned model for designing the structure of a tangible object.

  In such an aspect, a trained model is obtained by repeating reinforcement learning using a plurality of initial data. Since this learned model is obtained by processing various initial data, it is possible to cope with various conditions. That is, the design of a tangible object under each of various conditions can be completed with one learned model. Since it is not necessary to construct a calculation model for each condition from the beginning, the amount of computer processing required to construct a calculation model is reduced. Therefore, it is possible to reduce the processing load on the computer that designs the tangible object.

  In a design system according to another aspect, at least one processor may repeat reinforcement learning while changing at least a part of input data of a computation model for each of a plurality of initial data. Since the design system repeats the reinforcement learning while automatically changing the input data for one initial data, the amount of the initial data prepared in advance can be reduced.

  In a design system according to another aspect, changing at least a part of the input data may include a process of randomly changing at least a part of the input data. By randomly changing input data, it is possible to generate a learned model corresponding to various conditions.

  In a design system according to another aspect, changing at least a part of the input data may include a process of changing at least a part of the input data based on output data of the previous reinforcement learning. By setting the next input data based on the result of reinforcement learning, a learned model can be efficiently generated.

  In a design system according to another aspect, a tangible object may be selected from at least a part of a building, at least a part of a structure, and at least a part of a moving object. In this case, the processing load of the computer when designing a building, a structure, or a moving object can be reduced.

  In a design system according to another aspect, at least one processor may output design data of a tangible object by inputting input data indicating a structure of the tangible object to a learned model. In this case, a tangible object can be designed while reducing the processing load on the computer.

  According to one embodiment of the present invention, it is possible to reduce the processing load of a computer that designs a tangible object.

FIG. 2 is a diagram illustrating an example of a hardware configuration of a computer used in the design system according to the embodiment. FIG. 1 is a diagram illustrating an example of a functional configuration of a design system according to an embodiment. It is a flowchart which shows the learning process of the design system which concerns on embodiment. 5 is a flowchart illustrating optimization processing of the design system according to the embodiment. It is a graph which shows an example of reinforcement learning in a 2nd embodiment. It is a figure for explaining the design system concerning a 3rd embodiment.

  Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings. In the description of the drawings, the same or equivalent elements will be denoted by the same reference symbols, without redundant description.

[System Overview]
A design system according to the present disclosure is a computer system for designing a tangible object. More specifically, the design system designs the structure of a tangible object. The tangible object is an object that physically occupies a part of the space and has a shape. For example, a tangible object can be any object that is artificially manufactured or built, ie, any man-made object. The tangible object may be a movable property or a real estate. The tangible object may be a building such as a building or a structure such as a bridge. Alternatively, the tangible object may be a mobile object such as a motorcycle, a bicycle, a train, a watercraft, a watercraft, or a flying object. The tangible object may be at least a part of a building, at least a part of a structure, or at least a part of a moving object. Therefore, for example, the tangible object may be a device or a part configuring the moving body. Of course, the tangible entity is not limited to these examples. The structure refers to a combination of various elements constituting a tangible object. Examples of elements that define a structure include, but are not limited to, shape, dimensions, arrangement, and materials. Design refers to the preparation for realizing a tangible object. Typically, design drawings, specifications, and models showing the structure of the intended tangible object are obtained as examples of design products.

  The design system uses reinforcement learning. Reinforcement learning is a type of machine learning that autonomously finds rules or rules by repeatedly learning based on given information. In reinforcement learning, agents in the environment observe the current state and decide what action to take. Agents can get rewards from the environment by choosing actions. The agent learns a strategy to obtain the highest reward through a series of actions. An agent can output an optimal solution by accumulating learning. Here, it should be noted that the optimal solution refers to a solution that is estimated to be optimal, and is not necessarily an optimal solution in practice.

  The design system can generate a calculation model including an agent that has accumulated learning, and acquire this calculation model as a trained model. This corresponds to the learning phase. It should be noted that the trained model is a calculation model that is estimated to be optimal for designing the structure of a tangible object, and is not necessarily a “calculation model that is actually optimal”. Computational models can be built using algorithms and data structures. For example, the calculation model may be constructed to include a neural network that is a model of information processing that simulates the mechanism of the human nervous system.

  The design system can output optimal design data by processing the input data using the trained model. This corresponds to the optimization phase. As described above, optimal design data is not always optimal in practice.

  The configuration of input data and output data is not limited at all for both the calculation model and the learned model. For example, both input data and output data can be represented by a vector composed of one or more parameters. The input data may be input from outside the calculation model, and is also referred to as initial data in the present disclosure. Alternatively, the input data may be set by a calculation model.

  If an agent accumulates learning under various conditions, it is possible to output an optimal solution under various conditions. Therefore, the design system can generate a learned model that can respond to various design conditions. This means that the trained model can be reused under various design conditions. Since the calculation model does not need to be re-created even if the conditions slightly change, the amount of computer processing required for building the calculation model is reduced. Therefore, it is possible to reduce the processing load on the computer that designs the tangible object. When designing the structure of a tangible object using a conventional technique such as a genetic algorithm, it is necessary to construct a calculation model from the beginning each time the design conditions change. Therefore, in the related art, the processing load on the computer is increased, and the burden on the designer is also large. The design system according to the present disclosure has an advantageous technical effect that a processing load on a computer and a burden on a designer can be reduced as compared with the related art.

  The trained model is portable between computer systems. Thus, a trained model generated on one computer system can be used on another computer system. Of course, one computer system may perform both generation and utilization of the trained model. That is, the design system may execute both the learning phase and the design phase, or may not execute any one of the learning phase and the design phase.

[First Embodiment]
An example of the general configuration and operation of the above-described design system will be described as a first embodiment with reference to FIGS. FIG. 1 is a diagram illustrating a general hardware configuration of a computer 100 configuring a design system 1 according to the first embodiment. FIG. 2 is a diagram illustrating an example of a functional configuration of the design system 1. FIG. 3 is a flowchart illustrating an example of the learning process of the design system 1. FIG. 4 is a flowchart illustrating an example of the optimization process of the design system 1. 3 and 4 correspond to the learning phase and the optimization phase, respectively.

  As shown in FIG. 1, the computer 100 may include a processor 101, a main storage unit 102, an auxiliary storage unit 103, a communication control unit 104, an input device 105, and an output device 106. The processor 101 executes an operating system and an application program. The main storage unit 102 includes, for example, a ROM and a RAM. The auxiliary storage unit 103 is composed of, for example, a hard disk or a flash memory, and generally stores a larger amount of data than the main storage unit 102. The communication control unit 104 includes, for example, a network card or a wireless communication module. The input device 105 includes, for example, a keyboard, a mouse, a touch panel, and the like. The output device 106 includes, for example, a monitor and a speaker.

  Each functional element of the design system 1 is realized by the design program 110 stored in the auxiliary storage unit 103 in advance. This is realized by reading the design program 110 into the processor 101 or the main storage unit 102 and executing the design program 110. The processor 101 operates the communication control unit 104, the input device 105, or the output device 106 according to the design program 110 to read and write data in the main storage unit 102 or the auxiliary storage unit 103. Data or a database required for processing is stored in the main storage unit 102 or the auxiliary storage unit 103.

  The design program 110 may be provided after being fixedly recorded on a tangible recording medium such as a CD-ROM, a DVD-ROM, and a semiconductor memory. Alternatively, the design program 110 may be provided via a communication network as a data signal superimposed on a carrier wave.

  The design system 1 may be constituted by one computer 100, or may be constituted by a plurality of computers 100. When a plurality of computers 100 are used, one design system 1 is logically constructed by connecting these computers 100 via a communication network such as the Internet or an intranet.

  In the present embodiment, the design system 1 includes a first system 10 that generates a learned model for designing the structure of a tangible object, and a second system 20 that outputs optimal design data using the learned model. Prepare. The first system 10 includes, as a functional element, a learning unit 11 that generates and acquires a learned model by executing reinforcement learning. The second system 20 includes, as a functional element, an optimization unit 21 that calculates optimal design data from input data using the learned model.

  As mentioned above, the trained model is portable between computer systems. Therefore, as in the present embodiment, the calculation model generated by the first system 10 can be used by the second system 20, which is another computer system. Of course, it is not essential to divide the design system into the first system 10 and the second system 20.

An example of a method of generating a learned model will be described with reference to FIG. In this example, data input to the calculation model for reinforcement learning is indicated by an input vector x _i (n) using variables i and n. The input vector x _i (n) is data indicating the structure of a tangible object, and is an example of input data. The variable i is a value for distinguishing the initial vector, and is assumed to be a value starting from 1. Here, the initial vector is input data prepared outside the calculation model for reinforcement learning, and is an example of initial data. On the other hand, the variable n is a value indicating the number of repetitions of learning based on one initial vector. For any variable i, x _i (0) indicates the initial vector. On the other hand, x _i (1), x _i (2), and the like indicate new input vectors changed from the previous input vector x _i (n−1) inside the calculation model. The data structure of the input vector x _i (n) is not limited, and may be arbitrarily set based on the data structure of the design data to be finally obtained. For example, the input vector x _i (n) may include one or more parameters. The input vector x _i (n) may include a parameter indicating an environmental condition related to an environment surrounding the tangible object, in addition to a parameter indicating the structure of the tangible object. Examples of the environmental conditions include a flow velocity, an air temperature, a pressure, and the like, but the elements constituting the environmental conditions may be arbitrarily selected. By including the environmental condition in the input vector, a learned model applicable to various environmental conditions can be generated.

The learning unit 11 sets the i-th initial vector x _i (0) in step S11. The method for setting the initial vector is not limited. For example, the learning unit 11 may randomly set the initial vector x _i (0). Alternatively, the learning unit 11 may set the input vector provided from the outside as it is as the initial vector x _i (0). For example, the learning unit 11 may set data input by a user of the design system 1 as an initial vector x _i (0). Alternatively, the learning unit 11 may set data read from an arbitrary storage unit such as a database as the initial vector x _i (0).

In step S12, the learning unit 11 obtains a performance value f _i (0) based on the initial vector x _i (0). This performance value f _i (0) can be used to determine a reward for the agent. The data structure of the performance value is not limited, and may be arbitrarily set corresponding to the input vector. For example, a performance value may include one or more parameters. Since it is not essential to use the performance value f _i (0) to determine the reward, this step S12 may be omitted.

Thereafter, the learning unit 11 repeats the reinforcement learning while changing at least a part of the input data of the calculation model for the initial vector x _i (0). For example, the learning unit 11 repeatedly executes the reinforcement learning a predetermined number of times while gradually changing the initial vector x _i (0). However, the learning unit 11 does not change the environmental conditions set by a certain initial vector x _i (0) among a plurality of input vectors x _i (n) having the same value of the variable i. This repetition process will be described as steps S13 to S16. The number of repetitions may be set arbitrarily, and may be, for example, 20 or 50. In the present embodiment, the number of repetitions is represented by M.

In step S13, the learning unit 11 calculates an output vector by executing reinforcement learning on the input vector x _i (n). Immediately after step S12, the learning unit 11 performs reinforcement learning on the initial vector x _i (0). The output vector is data indicating an action to be taken by the agent, and is an example of output data. The data structure of the output vector is not limited, and may be set arbitrarily according to the input vector.

In step S14, the learning unit 11 sets the next input vector x _i (n + 1) based on the output vector. If the previous input vector is x _i (0), the learning unit 11 sets the input vector x _i (1). The setting method of the next input vector is not limited. For example, the learning unit 11 may set the next input vector x _i (n + 1) by changing at least a part of the previous input vector x _i (n). For example, the learning unit 11 sets the next input vector x _i (n + 1) by randomly changing at least a part of the previous input vector x _i (n) based on the output vector of the previous reinforcement learning. You may. Alternatively, for example, the learning section 11 based on the output vector, at least a portion of the previous input vector x _{i (n),} the next input vector x _i by randomly varied within the numerical range defined in advance (N + 1) may be set.

In step S15, the learning unit 11 obtains a performance value f _i (n + 1) based on the input vector x _i (n + 1), and determines a reward to be given to the agent based on the performance value f _i (n + 1). The learning unit 11 gives a reward to the agent based on the determination. The determination and grant of the reward executed in step S15 may be executed at any timing. The learning unit 11 may give a reward at an arbitrary timing during the M repetition processes based on one initial data. For example, the learning unit 11 may provide a reward each time during the M repetition processes, or may provide a reward only in the M-th process. The method of determining the reward and the specific value are not limited. For example, the learning unit 11 _sets the compensation to +1 in the case of _{f i (M)> f i} (0), rewards may be set to 0 otherwise. Alternatively, the learning section _11, the compensation in the case of _{f i (n)> f i} (n-1) is set to _+1, a compensation in the case of _{f i (n) <f i} (n-1) - It may be set to 1. The value of the reward may be calculated based on the performance value.

  As shown in step S16, the processing of steps S13 to S15 is repeatedly executed M times.

In step S17, the learning unit 11 determines whether or not a termination condition is satisfied. The end condition is a condition for ending the reinforcement learning and obtaining the learned model. The termination condition may be set arbitrarily. For example, the learning unit 11 may end the reinforcement learning when the performance value f _i (M) satisfies a predetermined criterion. Alternatively, the learning unit 11 may terminate the reinforcement learning when the predetermined number of initial data has been processed. Here, the number of initial data prepared in advance is not limited at all, and may be, for example, 10,000. In any case, satisfying the termination condition may correspond to obtaining design data satisfying the termination condition. The design data satisfying the termination condition may be indicated by, for example, the last processed input vector.

If the termination condition is not satisfied, the process proceeds to step S18. The learning unit 11 increments the variable i, returns to step S11, and sets the next initial vector x _i (n). Then, the learning unit 11 executes the processing after step S12 again.

  If the end condition is satisfied, the process proceeds to step S19. In step S19, the learning unit 11 acquires the calculation model on which the reinforcement learning has been performed as a learned model. This processing means that a learned model has been generated. The learning unit 11 outputs the learned model. The output method of the trained model is not limited. For example, the learning unit 11 may store the learned model in a storage device such as a memory or a database, or may transmit the learned model to another computer system.

An example of the optimization method using the learned model will be described with reference to FIG. In this example, an input vector for obtaining optimal design data is indicated by x (n) using a variable n. The input vector x (n) is data indicating the structure of a tangible object. The data structure of the input vector x (n) is the same as the input vector x _i (n) used in reinforcement learning by the learning unit 11.

  In step S21, the optimization unit 21 receives an input vector x (0). The method of obtaining the input vector x (0) is not limited. For example, the optimization unit 21 may receive data input by a user of the design system 1 as an input vector x (0). Alternatively, the optimization unit 21 may receive data read from an arbitrary storage unit such as a database as the input vector x (0).

  In step S22, the optimization unit 21 calculates an output vector by inputting the input vector x (n) to the learned model. Immediately after step S21, the optimization unit 21 receives the input vector x (0). The data structure of the output vector is the same as the output vector obtained from the calculation model by the reinforcement learning by the learning unit 11.

  In step S23, the optimizing unit 21 sets the next input vector x (n + 1) based on the output vector.

  In step S24, the optimization unit 21 calculates a performance value f (n + 1) based on the input vector x (n + 1). This processing may be omitted.

  In step S25, the optimization unit 21 determines whether or not the end condition is satisfied. This termination condition is a condition for outputting optimal design data. This end condition may be set to correspond to the end condition used to generate the learned model. Alternatively, the termination condition may be defined by a criterion that the performance value should satisfy. Alternatively, the termination condition may be defined by the number of repetitions of steps S22 to S24.

  If the termination condition is not satisfied, the optimization unit 21 executes the processing of step S22 and subsequent steps again. On the other hand, if the termination condition is satisfied, the process proceeds to step S26. In step S26, the optimization unit 21 outputs, as design data, an input vector that has been processed last by the learned model, that is, an input vector that satisfies the termination condition. The output method of the design data is not limited. For example, the optimization unit 21 may store the design data in a storage device such as a memory or a database, transmit the design data to another computer system, or display the design data on a monitor. The design data is used to design the structure of a tangible object.

[Second embodiment]
An application example of the operation of the design system 1 described in the first embodiment will be described as a second embodiment with reference to FIGS. 3 and 4 again. In the present embodiment, the shape of a wing of a flying object is shown as an example of the structure of a tangible object. That is, in the present embodiment, the design system 1 acquires a learned model for designing the shape of the wing. Further, the design system 1 uses the learned model to output design data relating to the shape of the wing from the prepared input data.

In the present embodiment, the design data indicating the shape of the wing is composed of six parameters p (n), q (n), r (n), s (n), t (n) and u (n). Shall be performed. That is, x (n) = (p (n), q (n), r (n), s (n), t (n), u (n)). The initial value of the six parameters, using seven types have been found to be high from a conventional wing _{W a, W b, W c} , W d, W e, W f, the shape of _{W g} You can decide. When the difference in shape between the wings _{W a} and wings _{W b} and _{z b,} it is possible to create a new shape _{W new new} with variable p. This new shape is represented by W _new = W _a + pz _b . P used in this equation corresponds to the parameter p (n). Similarly, the difference between the shapes of the wings W _a and wings W _c When z _c, it is possible to create a new shape W _{new new} using variable q. This new shape is represented as W _new = W _a + qz _c . Q used in this equation corresponds to the parameter q (n). Similarly, the wing _{W a} and another four wings _{W d, W e, W f} , based on the difference between _{W g,} parameter r, s, t, u are obtained. These six parameters indicate the length and thickness of the wing.

The processing in the learning unit 11 will be described with reference to FIG. In step S11, the learning unit 11 i-th initial vector _{x i (0) = (p} i (0), q i (0), r i (0), s i (0), t i (0), u _i (0)). In step S12, the learning unit 11 obtains a performance value f _i (0) based on the input vector x _i (0). However, step S12 may be omitted.

Thereafter, the learning unit 11 repeats the reinforcement learning while changing the input data little by little. In step S13, the learning unit 11 calculates an output vector by executing reinforcement learning on the input vector x _i (n). In the present embodiment, the output layer of the neural network forming the calculation model is configured with six nodes corresponding to the six parameters. Each node outputs a value indicating whether to change the corresponding parameter. In step S14, the learning unit 11 sets the next input vector x _i (n + 1) based on the output vector. Specifically, the learning unit 11 changes a parameter determined to be changed among the six parameters by an arbitrary method. In step S15, the learning unit 11 obtains a performance value f _i (n + 1) based on the input vector x _i (n + 1), and determines a reward to be given to the agent based on the performance value f _i (n + 1). This step S15 can be omitted. As shown in step S16, the processing of steps S13 to S15 is repeatedly executed M times.

In step S17, the learning unit 11 determines whether the termination condition is satisfied. If the termination condition is not satisfied, the process returns to step S11 via step S18. On the other hand, if the end condition is satisfied, the learning unit 11 acquires a learned model. When the end condition is to process 10,000 initial vectors x _i (0), the learning unit 11 performs a series of reinforcement learning using the initial vector x ₁₀₀₀₀ (0), and then finishes learning. Get the model.

  FIG. 5 is a graph showing an example of the reinforcement learning in the second embodiment. The horizontal axis of the graph indicates aerodynamic performance, and the vertical axis indicates vibration performance. Aerodynamic performance and vibration performance are examples of performance values. In the graph, the aerodynamic performance is better on the left and the vibration performance is better on the upper. Each of the results 201 to 205 in the graph shows the processing result when the reinforcement learning is repeated M times based on one initial data.

  Immediately after the learning is started, as shown in the results 201, 202, and 203, the vibration performance and the aerodynamic performance hardly change even if the learning is performed M times. However, as the agent accumulates learning while obtaining a reward, as shown in results 204 and 205, the agent can obtain an optimal solution from the initial data.

  The process by which an agent arrives at an optimal solution can vary depending on the method of rewarding. For example, the result 204 is an example of a case where reinforcement learning is performed under the constraint that if aerodynamic performance can be increased without lowering vibration performance, a reward for increasing the aerodynamic performance is given. Is shown. On the other hand, the result 205 indicates that the reinforcement learning is performed under the constraint that if the vibration performance is equal to or higher than the threshold value and the aerodynamic performance can be improved, a reward for increasing the aerodynamic performance is given. An example is shown below. FIG. 5 shows the threshold value corresponding to the result 205 by a line 210.

  The processing in the optimization unit 21 will be described with reference to FIG. In step S21, the optimization unit 21 sets the initial vector x (0) = (p (0), q (0), r (0), s (0), t (0), u (0)). . In step S22, the optimization unit 21 calculates an output vector by inputting the input vector x (n) to the learned model. Immediately after step S21, the optimization unit 21 inputs the initial vector x (0) to the learned model. In step S23, the optimizing unit 21 sets the next input vector x (n + 1) based on the output vector. In step S24, the optimization unit 21 calculates a performance value f (n + 1) based on the input vector x (n + 1). As described above, step S24 may be omitted.

  In step S25, the optimization unit 21 determines whether or not the end condition is satisfied. If the termination condition is not satisfied, the optimization unit 21 repeats the processing from step S22. If the end condition is satisfied, the process proceeds to step S26, and the optimizing unit 21 outputs the design data. As a result, the user of the design system 1 can obtain the optimum shape of the wing.

[Third embodiment]
Another application example of the operation of the design system 1 described in the first embodiment will be described as a third embodiment with reference to FIGS. 3 and 4 again. In the present embodiment, the angle of attack of the wing of the flying object is shown as an example of the structure of a tangible object. That is, the design system 1 acquires a learned model for designing the attack angle of the wing. Further, the design system 1 uses the learned model to output design data relating to the angle of attack of the wing from the prepared input data.

The purpose of the design system 1 in the present embodiment is to determine the optimum angle of attack α after the wing shape y and the Reynolds number Re are given. The angle of attack α is selected from {0, 1, 2, ..., 39}. The optimal angle of attack α is a value that maximizes the ratio C _L / C _D of the lift coefficient C _L to the resistance coefficient C _D. In the present embodiment, the ratio C _L / C _D is used as the performance value f.

  In the present embodiment, the input data of the calculation model is normalized, which is the execution result of a two-dimensional steady-state incompressible flow analysis using a k-ε turbulence model. 3 is a color contour image. This image is 400 (pixels) × 400 (pixels), and the individual pixel values, that is, the individual RGB values, include airflow information. Each color contour image input to the calculation model for reinforcement learning can be obtained by randomly setting the wing shape y, the Reynolds number Re, and the initial angle of attack and performing the fluid analysis described above. Can be.

  FIG. 6 shows an example of a calculation model used in the present embodiment. The calculation model in the present embodiment includes a deep neural network 300 that receives a color contour image 310. The deep neural network 300 includes two sets of a convolutional layer and a pooling layer, and three fully connected layers following the two sets. In FIG. 6, all tie layers are denoted by “FC”. The number following “FC” indicates the number of nodes constituting one layer. The deep neural network 300 outputs a result indicating whether the elevation angle is increased by 1 ° or decreased by 1 °.

The processing in the learning unit 11 will be described with reference to FIG. In step S11, the learning unit 11 sets the i-th initial vector _x 1 a (0). This initial vector x ₁ (0) indicates the RGB values of all pixels constituting the color contour image. The angle of attack α and the ratio C _L / C _D are not given to the calculation model, which means that the learning unit 11 can acquire the learned model using only the image. In step S12, the learning unit 11 obtains a performance value f _i (0) based on the input vector x _i (0). However, step S12 may be omitted.

Thereafter, the learning unit 11 repeats the reinforcement learning while changing the input data little by little. In step S13, the learning unit 11 calculates an output vector by executing reinforcement learning on the input vector x _i (n). In the present embodiment, the output layer of the neural network forming the calculation model is composed of two nodes indicating whether to increase or decrease the angle of attack. In step S14, the learning unit 11 sets the next input vector x _i (n + 1) based on the output vector. Specifically, the learning unit 11 generates a new color contour image by performing a numerical analysis based on the output vector, and generates the next input vector indicating the RGB values of all the pixels constituting the new color contour image. x _i (n + 1) is set. In step S15, the learning unit 11 obtains a performance value f _i (n + 1) based on the input vector x _i (n + 1), and determines a reward to be given to the agent based on the performance value f _i (n + 1). For example, the learning unit 11 may determine a reward based on a comparison between _f i (n + 1) and _f i (0). This step S15 can be omitted.

  As shown in step S16, the processing of steps S13 to S15 is repeatedly executed M times.

In step S17, the learning unit 11 determines whether the termination condition is satisfied. End condition in this embodiment, for example, that the last two input vectors are the same, i.e., may be _{x i (n) = x i} (n-1). If the termination condition is not satisfied, the process returns to step S11 via step S18. On the other hand, if the end condition is satisfied, the learning unit 11 acquires a learned model.

  The processing in the optimization unit 21 will be described with reference to FIG. In step S21, the optimization unit 21 sets an initial vector x (0) represented by a color contour image. In step S22, the optimization unit 21 calculates an output vector by inputting the input vector x (n) to the learned model. Immediately after step S21, the optimization unit 21 inputs the initial vector x (0) to the learned model. In step S23, the optimizing unit 21 sets the next input vector x (n + 1) based on the output vector. In step S24, the optimization unit 21 calculates a performance value f (n + 1) based on the input vector x (n + 1). As described above, step S24 may be omitted.

  In step S25, the optimization unit 21 determines whether or not the end condition is satisfied. The termination condition may be, for example, that two latest input vectors are the same, that is, x (n) = x (n−1). If the termination condition is not satisfied, the optimization unit 21 repeats the processing from step S22. If the end condition is satisfied, the process proceeds to step S26, and the optimizing unit 21 outputs the design data. As a result, the user of the design system 1 can obtain the optimum angle of attack of the wing.

[effect]
As described above, a design system according to one aspect of the present invention includes at least one processor, and at least one processor inputs each of a plurality of initial data indicating a structure of a tangible object to a computation model and performs reinforcement learning. Is repeatedly executed, and in response to satisfying a predetermined termination condition of reinforcement learning, a calculation model obtained by reinforcement learning is acquired as a trained model for designing a structure of a tangible object.

  A method for generating a learned model according to one aspect of the present invention includes the steps of repeatedly executing reinforcement learning by inputting each of a plurality of initial data indicating the structure of a tangible object to a calculation model; and a predetermined reinforcement learning termination condition. Obtaining a computation model obtained by reinforcement learning as a trained model for designing the structure of a tangible object in response to the fact that is satisfied.

  A design program according to an aspect of the present invention includes a step of repeatedly executing reinforcement learning by inputting each of a plurality of initial data indicating a structure of a tangible object to a calculation model, and satisfying a predetermined reinforcement learning end condition. Acquiring the calculation model obtained by the reinforcement learning as a learned model for designing the structure of a tangible object.

  In such an aspect, a trained model is obtained by repeating reinforcement learning using a plurality of initial data. Since this learned model is obtained by processing various initial data, it is possible to cope with various conditions. That is, the design of a tangible object under each of various conditions can be completed with one learned model. Since it is not necessary to construct a calculation model for each condition from the beginning, the amount of computer processing required to construct a calculation model is reduced. Therefore, it is possible to reduce the processing load on the computer that designs the tangible object.

  In a design system according to another aspect, at least one processor may repeat reinforcement learning while changing at least a part of input data of a computation model for each of a plurality of initial data. Since the design system repeats the reinforcement learning while automatically changing the input data for one initial data, the amount of the initial data prepared in advance can be reduced. Therefore, it is possible to save the capacity of the memory for storing the initial data.

  In a design system according to another aspect, changing at least a part of the input data may include a process of randomly changing at least a part of the input data. By randomly changing input data, it is possible to generate a learned model corresponding to various conditions.

  In a design system according to another aspect, changing at least a part of the input data may include a process of changing at least a part of the input data based on output data of the previous reinforcement learning. By setting the next input data based on the result of reinforcement learning, a learned model can be efficiently generated.

  In a design system according to another aspect, a tangible object may be selected from at least a part of a building, at least a part of a structure, and at least a part of a moving object. In this case, the processing load of the computer when designing a building, a structure, or a moving object can be reduced.

  In a design system according to another aspect, at least one processor may output design data of a tangible object by inputting input data indicating a structure of the tangible object to a learned model. In this case, a tangible object can be designed while reducing the processing load on the computer.

[Modification]
The present invention has been described in detail based on the embodiments and examples. However, the present invention is not limited to the above embodiments and examples. The present invention can be variously modified without departing from the gist thereof.

  In the second and third embodiments, a wing of a flying object is shown as an example of a tangible object, but the tangible object is not limited as described above. For example, the design system 1 may generate a learned model for designing a mobile engine. More specifically, the design system 1 is capable of generating a learned model for designing a supercharger of a vehicle, for example, learning for designing dimensions of a housing, dimensions of a blade angle, and the like. You can generate a completed model.

  In the above embodiment, the design system 1 includes the learning unit 11 and the optimization unit 21. However, one of the learning unit 11 and the optimization unit 21 may be omitted.

  The processing procedure of the learned model generation method executed by at least one processor is not limited to the example in the above embodiment. Further, the processing procedure of the optimization method executed by at least one processor is not limited to the example in the above embodiment. For example, some of the steps described above may be omitted, or the steps may be executed in another order. Also, any two or more of the steps described above may be combined, or some of the steps may be modified or deleted. Alternatively, other steps may be executed in addition to the above steps.

  When comparing the magnitude relationship between two numerical values in the design system, either of the two criteria of “greater than” and “greater than” may be used, and the two criteria of “less than” and “less than” may be used. Either of them may be used. The selection of such a criterion does not change the technical significance of the processing for comparing the magnitude relation between two numerical values.

  According to one embodiment of the present invention, it is possible to reduce the processing load of a computer that designs a tangible object.

1 Design System 100 Computer 101 Processor 110 Design Program 10 First System 11 Learning Unit 20 Second System 21 Optimization Unit

Claims (8)

With at least one processor,
The at least one processor comprises:
Each of a plurality of initial data indicating the structure of a tangible object is input to a calculation model, and reinforcement learning is repeatedly executed,
In response to the predetermined end condition of the reinforcement learning being satisfied, the calculation model obtained by the reinforcement learning is obtained as a trained model for designing the structure of the tangible object,
Design system. The at least one processor, for each of the plurality of initial data, repeat the reinforcement learning while changing at least a part of the input data of the calculation model,
The design system according to claim 1. At least a part of the change of the input data includes a process of randomly changing at least a part of the input data,
The design system according to claim 2. At least a part of the change of the input data includes a process of changing at least a part of the input data based on output data of the previous reinforcement learning,
The design system according to claim 2. The tangible object is selected from at least a part of a building, at least a part of a structure, and at least a part of a moving object,
The design system according to claim 1. The at least one processor outputs design data of the tangible object by inputting input data indicating a structure of the tangible object to the learned model,
The design system according to claim 1. Inputting each of a plurality of initial data indicating the structure of a tangible object to a calculation model and repeatedly executing reinforcement learning;
Acquiring the calculation model obtained by the reinforcement learning as a trained model for designing the structure of the tangible object in response to the predetermined end condition of the reinforcement learning being satisfied. Includes learned model generation methods. Inputting each of a plurality of initial data indicating the structure of a tangible object to a calculation model and repeatedly executing reinforcement learning;
Acquiring the calculation model obtained by the reinforcement learning as a trained model for designing the structure of the tangible object in response to the predetermined end condition of the reinforcement learning being satisfied. A design program to be executed by a computer.