JP7318383B2 - Information processing program, information processing method, and information processing apparatus - Google Patents

Description

The present invention relates to an information processing program, an information processing method, and an information processing apparatus.

In recent years, structural analysis and fluid analysis simulations have come to be used to verify the stress applied to the structure of products and to verify the behavior of gases and liquids. In analytical simulation, an iterative method such as Newton's method is used for nonlinear analysis, solving a linear solver at each iteration. Linear solvers themselves are also often solved iteratively.

Convergence of the solution matrix by the nonlinear equation by changing the convergence judgment condition according to whether the solution matrix obtained from the equation using the predetermined condition for the analysis of the device characteristics satisfies the convergence judgment of the linear equation Techniques and the like for shortening the calculation time until the conditions are satisfied are known.

JP-A-2003-162517 JP 2017-123160 A JP 2016-146139 A JP-A-2000-339179

Nonlinear analysis may be performed in simulations of structural analysis and fluid analysis. In nonlinear analysis, iterative methods such as Newton's method have a residual threshold value as a convergence condition. , the optimal residual threshold cannot be obtained.

Accordingly, one aspect of the present invention aims at shortening the computation time by making it possible to set an optimum residual threshold and reducing the number of iterations of the nonlinear analysis.

According to one aspect, one or more computers are caused to perform a first process of repeating linear analysis to perform nonlinear analysis, and the first process determines for each residual threshold with a plurality of experimental values a second process of inferring a residual threshold value used for determining convergence of the linear analysis by the NN based on the residual transition and the computation time for each iteration of the linear analysis; There is provided an information processing program characterized in that the data exchange between the processes of 2 is performed by inter-process communication using a shared memory set in the memory.

Further, according to the present disclosure, an information processing method and an information processing apparatus are provided.

By making it possible to set the optimum residual threshold and reducing the number of iterations of the nonlinear analysis, the computation time can be shortened.

It is a figure which shows the hardware structural example of an information processing apparatus. It is a figure which shows the functional structural example of an information processing apparatus. It is a figure for demonstrating a learning process. FIG. 4 is a diagram for explaining inference processing; It is a figure which shows the graph of a verification result. FIG. 4 is a diagram for explaining data transmission/reception by inter-process communication in the first embodiment; 1 is a diagram for explaining an overview of interprocess communication between different types of programming languages; FIG. FIG. 4 is a diagram for explaining an overview of inter-process communication when AI is used in simulation; FIG. 7 is a diagram showing an implementation example in FIG. 6; FIG. 8 is a diagram showing an implementation example in FIG. 7; FIG. 10 is a flowchart for explaining simulation processing; FIG. 10 is a flow chart for explaining machine learning processing that operates in cooperation with a simulation; FIG. 10 is a diagram for explaining an example of processing related to inter-process communication in the main process of simulation; FIG. 10 is a diagram for explaining an example of processing related to inter-process communication in the main process of simulation; FIG. 4 is a diagram for explaining an example of processing related to inter-process communication in a Python child process; FIG. 4 is a diagram showing an example of states in inter-process communication; It is a figure which shows the verification result example of an overhead. FIG. 10 is a diagram showing verification results for each data size by input/output to/from a disk; FIG. 10 is a diagram showing verification results for each data size by input/output to/from a disk; It is a figure for demonstrating a nonlinear analysis. FIG. 12 is a diagram for explaining an outline of a learning unit in the first functional configuration example of the information processing apparatus in the second embodiment; FIG. 11 is a diagram for explaining an outline of an inference unit in the first functional configuration example of the information processing apparatus in the second embodiment; FIG. 11 is a diagram illustrating an example of verification of simulation time for each candidate threshold; FIG. 5 is a flowchart for explaining learning processing in the first functional configuration example; FIG. 4 is a flowchart for explaining inference processing in the first functional configuration example; FIG. 12 is a diagram for explaining an overview of a learning unit in a second functional configuration example of the information processing apparatus in the second embodiment; FIG. 11 is a diagram for explaining an outline of an inference unit in the first functional configuration example of the information processing apparatus in the second embodiment; FIG. 11 is a flowchart for explaining a first example of learning processing in the second functional configuration example; FIG. 11 is a flowchart for explaining inference processing in the second functional configuration example; FIG. 11 is a flowchart for explaining a second example of learning processing in the second functional configuration example; FIG. 11 is a flowchart for explaining a third example of learning processing in the second functional configuration example; FIG. 10 is a diagram showing learning results for each candidate threshold value according to the first example of learning processing; FIG. 33 is a diagram showing learning results based on the labeling of FIG. 32; FIG. 10 is a diagram showing learning results for each candidate threshold value according to a second example of learning processing; FIG. 35 is a diagram showing learning results based on the labeling of FIG. 34; FIG. 10 is a diagram showing learning results for each candidate threshold value according to a second example of learning processing; It is a figure which shows the verification result of execution time. It is a figure which shows the verification result of a simulation result. It is a figure which shows the example of a change of a threshold value. It is a figure which shows the progress example of processing time. It is a figure which shows the progress example of the number of iterations. FIG. 11 is a diagram showing an example of an execution log in the second embodiment; FIG.

BEST MODE FOR CARRYING OUT THE INVENTION An embodiment of the present invention will be described below with reference to the drawings. In structural analysis and fluid analysis simulations, nonlinear equation analysis (called "nonlinear analysis") is sometimes performed, and in nonlinear analysis, solutions are obtained by iteratively solving a linear solver using Newton's method or the like. The linear solver itself often uses an iterative method (such as CG (Conjugate Gradient)) to obtain a solution for a large-scale problem.

In order to speed up the calculation time of the simulation, the inventors let AI (Artificial Intelligence) learn the adjustment direction of the residual threshold, which is the convergence condition of iterative processing in nonlinear analysis, and dynamically increase or We found that the simulation was performed by reducing In this case, by passing the series of residuals over time until convergence by the iterative process of the linear solver (called "residual curve" or "residual transition") from the simulation program to the machine learning program, the residual Threshold learning is performed. This technique will be described in detail in the second embodiment.

However, since simulation programs and machine learning programs generally use different languages, it takes time to access files for exchanging data between simulation and learning. To solve this problem, the inventors found inter-process communication according to the first embodiment. In the second embodiment, a dynamic residual threshold adjustment technique will be described.

The first to second embodiments described later can be implemented in an information processing apparatus having a hardware configuration as shown in FIG. 1, and either or both of the first to second embodiments can be implemented. By doing so, the processing speed of the simulation can be improved.

FIG. 1 is a diagram illustrating a hardware configuration example of an information processing apparatus. 1, the information processing apparatus 100 is a computer, and includes a CPU (Central Processing Unit) 11, a main memory 12, a disk 13, a GPU (Graphics Processing Unit) 14g, a GPU memory 14m, and an input device 15. , a display device 16, a communication I/F 17, and a drive device 18, and are connected to the bus B. This hardware configuration is the same in the second embodiment.

The CPU 11 corresponds to a processor that controls the entire information processing apparatus 100, and executes a simulation program read from a disk 13 and stored in a main memory 12 (for example, a RAM (random access memory)) to execute the present embodiment described below. Realize the processing in The CPU 11 also performs various processes other than simulation.

The GPU 14g corresponds to a processor for AI inference, and performs AI inference for estimating the adjustment direction of the residual threshold in this embodiment using simulation data obtained by executing simulation. The GPU 14m is a local memory used by the GPU 14g and stores a program of the NN 270 (FIG. 3) that performs AI inference. AI inference learns the optimal parameter values of the NN 270 by executing a program stored in the GPU 14m by the GPU 14g.

The input device 15 is operated by a user to input data according to the operation, and the display device 16 displays various screens as a user interface. Communication I/F 17 controls communication with an external device.

A simulation program according to the present embodiment stored in a storage medium 19 (for example, a CD-ROM (Compact Disc Read-Only Memory) or the like) is installed on the disc 13 via the drive device 18 and can be executed by the CPU 11. . Similarly, the machine learning program is installed from the storage medium 19 to the disk 13 via the drive device 18, and can be executed by the GPU 14g.

A simulation program and a machine learning program according to the present embodiment stored in a storage medium 19 (for example, a CD-ROM (Compact Disc Read-Only Memory), etc.) are installed in the storage unit 130 via the drive device 18, and the CPU 11 can be executed by The simulation program and the machine learning program may be installed from separate storage media 19, respectively.

Note that the storage medium 19 for storing the program according to the present embodiment is not limited to a CD-ROM, and one or more computer-readable, non-transitory, tangible (tangible) medium. As a computer-readable storage medium, in addition to a CD-ROM, a DVD (Digital Versatile Disk) disk, a portable recording medium such as a USB memory, and a semiconductor memory such as a flash memory may be used.

[First embodiment]
Also, in the first embodiment, a technique for speeding up simulation by inter-process communication in the information processing apparatus 100 having the functional configuration as shown in FIG. 2 will be described. FIG. 2 is a diagram illustrating a functional configuration example of an information processing apparatus.

As shown in FIG. 2, the information processing apparatus 100 mainly includes a simulation unit 30 and a machine learning unit 40 as processing units. Further, the problem data 2, the threshold value Th, the simulation data 204d, the simulation result 5, the inference result 71, etc. are stored in the main memory 12 by using a part thereof as the shared memory 12a (FIG. 8) as described in the first embodiment. are shown as being stored in

The simulation unit 30 is a processing unit realized by the CPU 11 executing a simulation program, performs a predetermined analysis on the problem data 2, and mainly has a nonlinear analysis unit 32 and a linear analysis unit 34. . The predetermined analysis includes structural analysis, fluid analysis, and the like. The analysis results obtained by the simulation unit 30 may be displayed on the display device 16 .

The nonlinear analysis unit 32 is a processing unit that reads the problem data 2 and performs nonlinear analysis. In nonlinear analysis, an iterative method such as the Newton-Raphson method is used to obtain the solution. The nonlinear analysis unit 32 repeats the nonlinear number of times for a predetermined number of times. and let it be analyzed by linear equations. Nonlinear analysis data obtained by nonlinear analysis corresponds to nonlin_data described later.

The linear analysis unit 34 repeats the analysis using the linear equation until the threshold Th is satisfied, and outputs the residual indicating the difference between the solution for each iteration and the threshold Th and the linear analysis data such as the simulation time to the main memory 12. do. A linear solver is used for the process of repeating the analysis using the linear equations until the threshold Th is satisfied. The linear analysis data obtained by the linear analysis unit 34 corresponds to lin_data described later.

Nonlinear analysis data is data obtained for each iteration of nonlinear analysis, and linear analysis data is data accumulated for each iteration. Nonlinear analysis data and linear analysis data, including various parameter values, solutions, etc., correspond to the simulation data 204d. The simulation data 204d is read into the machine learning unit 40 for each AI inference.

Also, a collection of data indicating the execution environment and the execution state indicated by the passage of time from the start to the end of the simulation is called an execution log 4a (FIG. 42). The execution log 4a includes simulation data 204d. A target solution for the problem data 2 is called a simulation result 5 .

In the first embodiment, in the information processing apparatus 100 that uses linear analysis to perform nonlinear analysis, the residual error is calculated based on log data indicating the transition of the residual error for each iteration, the calculation time, etc. obtained for each threshold value Th using experimental values. to determine the threshold Th.

The machine learning unit 40 includes a learning unit 50 that learns the parameter values of the NN 270 that adjusts the threshold Th used in the linear analysis unit 34, and an inference unit 60 that infers the increase or decrease (adjustment direction) of the threshold Th using the trained NN 270. and

As shown in FIG. 3, the learning unit 50 inputs the learning data 6g created by labeling the simulation data 204d to the NN 270, and the inference result 71 indicating the class inferred by the NN 270 and the label of the learning data 6g. The error is fed back to NN270.

The inference unit 60 obtains an inference result 71 indicating an increase or decrease in the threshold Th from the trained NN 270 . As an example, the inference result 71 indicates one of the classes "1", "2", and "3" classified by the NN270. In this case, class "1" designates an increase in the threshold Th (threshold up), class "2" designates no need to adjust the threshold Th (threshold keep), and class "3" designates a decrease in the threshold Th. (threshold down).

The inference unit 60 infers a class to the trained NN 270 so as to reduce the residual for the simulation data 204d. The inference result 71 is stored in the main memory 12 and serves as a return value to the nonlinear analysis section 32 of the simulation section 30 .

The nonlinear analysis unit 32 updates the threshold value Th based on the inference result 71 inferred by the inference unit 60 and provides it to the linear analysis unit 34 . By adjusting the threshold value Th in this way, it is possible to shorten the time required for the simulation.

The threshold Th is one of the convergence conditions in the iterative method, and how the threshold Th is given to the linear analysis unit 34 affects solution accuracy and execution time. Even if the threshold value Th is set to an arbitrary value, as long as the nonlinear analysis converges, it is considered that the accuracy of the final solution is not affected. However, if the optimal residual threshold can be estimated quickly, the entire nonlinear analysis can be speeded up.

From this point of view, the inventors use the NN 270 to learn the increase and decrease of the threshold Th, and also use the trained NN 270 to predict the increase and decrease of the threshold Th, thereby adjusting the threshold Th to the optimum value. It was found that the number of iterations until the linear analysis converges and the processing time can be shortened. An overview of the processing performed by the information processing apparatus 100 will be described with reference to FIGS. 3 and 4. FIG. In this example, a case where a CNN (Convolutional Neural Network) is used as the NN 270 will be described, but the NN is not limited to the CNN.

FIG. 3 is a diagram for explaining the learning process. In FIG. 3, referring to the simulation data 204d for each simulation using different candidate thresholds for the problem data 2, the candidate thresholds to be used for learning are selected from among the candidate thresholds based on the transition of the residual error for each iteration, the calculation time, etc. Determine a baseline threshold. Then, each residual curve data 4d is labeled based on the difference between the reference threshold and the candidate threshold, and is used as learning data 6g. The candidate thresholds correspond to experimental values.

The simulation data 204d using the candidate threshold smaller than the reference threshold is labeled "1". Simulation data 204d using a candidate threshold greater than the reference threshold is labeled "3". The simulation data 204d using the candidate threshold that matches the reference threshold is given the label "2". That is, the label "2" is assigned to the simulation data 204d when the simulation is finished in the shortest time.

An inference result 71 is obtained by inputting the simulation data 204 d to the NN 270 . As an example, the inference result 71 indicates any one of class 1 that raises the threshold Th, class 2 that maintains the threshold Th, and class 3 that lowers the threshold Th. The inference result 71 is compared with the label of the learning data 6g, and the error as the comparison result is fed back to the NN270. This error feedback updates the NN 270 parameter values. A trained NN 270 is used in the reasoning unit 60 .

In the above description, the classification into classes 1, 2, and 3 is taken as an example, but the classification may be limited to cases where the threshold value Th is raised and other cases. In that case, the learning unit 50 assigns the label 0 when the candidate threshold 3 is lower than the reference threshold 3ref during learning, and assigns the label 1 otherwise. may be inferred.

FIG. 4 is a diagram for explaining inference processing. FIG. 4 shows pseudo code 31 as an example of a simulation program that causes the CPU 11 to function as the simulation unit 30 .

In the pseudo code 31, when the nonlinear analysis is executed by "call fstr_Newton", the reasoning section 60 of the machine learning section 40 is called by "call auto_threshold" in the nonlinear analysis section 32. FIG. The inference unit 60 inputs the simulation data 204 d to the NN 270 and obtains an inference result 71 . The obtained inference result 71 is passed to the nonlinear analysis unit 32 as the return value of "call auto_threshold". The nonlinear analysis unit 32 updates the threshold Th based on the inference result 71, executes "call solve_LINEQ", and performs processing with the linear solver with the updated threshold Th.

Acquisition of the inference result 71 by “call auto_threshold” does not have to be performed each time the linear solver is executed. The inference result 71 may be acquired and the threshold Th may be updated for each predetermined number of times the linear solver is executed.

In the configuration as described above, the inventors verified the overhead when the simulation data 204d has a data size of 1 GB. FIG. 5 is a diagram showing a graph of verification results. In FIG. 5, the vertical axis indicates the overhead per iteration in time (seconds), and the horizontal axis indicates the number of iterations. The overhead due to the input and output of simulation data 204d indicates the processing time of the linear analysis for each iteration.

Graph 3a of FIG. 5 shows processing time 3b with file access to simulation data 204d for 86 iterations of linear analysis in the simulation. From this verification result, it can be seen that the speed of the simulation can be increased by adjusting the threshold value Th using the NN270.

By the way, as described above, the language of the simulation program that implements the simulation unit 30 and the machine learning program that implements the machine learning unit 40 are different. As an example, if the simulation program is a structural analysis solver, it is a procedural language program for scientific calculation such as FrontISTR. As for machine learning programs, a deep learning language is used in a script language such as Python for constructing a NN, and a library such as Keras that can be used from Python or the like.

Therefore, the programming language of the simulation unit 30 and the script language using the NN 270 in the machine learning unit 40 are executed by the CPU 11, the NN 270 is stored in the GPUm as a library, and executed by the GPU 15g.

Although the programming language and the script language are executed by the CPU 11, the programming languages are different. File access is performed for data transmission/reception. This file access has the problem of consuming simulation time. More specifically, file access is performed when the inference unit 60 acquires the simulation data 204d and the nonlinear analysis unit 32 acquires the inference result 71 in FIG.

In the first embodiment, a mechanism for improving consumption of processing time due to file access will be described with reference to FIGS. 6 and 7. FIG. Input data to the NN 270 such as the simulation data 204d and inference results 71, which are return values from the NN, are transferred via shared memory to avoid accessing the disk 13. FIG. Also, access to the shared memory by the simulation unit 30 is blocked until the threshold Th is updated.

FIG. 6 is a diagram for explaining data transmission/reception by inter-process communication in the first embodiment. In FIG. 6, dotted lines indicate the flow of data, and solid lines indicate the flow of processing. In the following, the information processing apparatus 100 will be described as having a UNIX-based OS (LINUX, for example), but the OS is not limited.

In FIG. 6, a High-Performance Computing (HPC) application 230 including an iterative loop outputs simulation data 204d for each iteration of processing. The simulation data 234d here is data input to the NN 270 in order to adjust values relating to speeding up of the simulation processing.

The high performance application 232 is part of the high performance application 230 and corresponds to the part having the data transfer function. The high performance application 232 writes (send_data()) the simulation data 204d to the shared memory 12a and sets data transfer complete to the named pipe 12b. Specifically, the completion of data transfer is indicated by setting the start address of the simulation data 204d.

On the other hand, the machine learning main program 250 reads the top address from the named pipe 12b, accesses the shared memory 12a, reads the simulation data 204d, and inputs it to the NN 270. FIG. AI inference by NN 270 is performed. When the machine learning main program 250 obtains the inference result 71 from the NN 270, it sets the inference result 71 in the named pipe 12b.

The high performance application 232 obtains the inference result 71 from the named pipe 12b and continues the simulation. That is, the acquired inference result 71 is used to increase/decrease or maintain the threshold Th (X<-get_AI_prediction()), and the simulation is continued using the adjusted threshold Th (variable X) (continue_simulation(X)).

6, the simulation unit 30, the nonlinear analysis unit 32, and the linear analysis unit 34 in FIG. 2 respectively correspond to the high performance application 230, the high performance application 232, and continue_simulation(X). Also, the machine learning unit 40 in FIG. 2 is realized by the machine learning main program 250 . In the following description, similar correspondences are used in similar figures.

FIG. 7 is a diagram for explaining an overview of interprocess communication between different types of programming languages. In FIG. 7, the simulation 38 is processing executed by the simulation unit 30, and accesses the main memory 12 via the OS virtual memory 12v using the virtual memory address 38ad. The machine learning process 48 is a process executed by the machine learning unit 40, and accesses the main memory 12 via the OS virtual memory 12v using the virtual memory address 48ad.

Simulation data 204d, which serves as input data for the NN 270, is written from the disk 13 to the main memory 12 by the simulation 38 using the virtual memory address 38ad. Also, the machine learning process 48 reads the simulation data 204d from the main memory 12 using the virtual memory address 48ad.

The named pipe 12b preferably has a named pipe 12b-1 used for transmitting and receiving the simulation data 204d and a named pipe 12b-2 for outputting the inference result 71 (ie return value).

FIG. 8 is a diagram for explaining an overview of interprocess communication when AI is used in simulation. In FIG. 8, the main memory 12 has a CM area 12m-1, a shared memory 12a, a named pipe area 12p, and an ML area 12m-2.

The CM area 12m-1 stores simulation program instructions (hereinafter referred to as "simulation instructions") and processing data, and the ML area 12m-2 stores machine learning program instructions (hereinafter referred to as "script instructions"). ) and data are stored. The shared memory 12a also stores simulation data 204d transferred from the disk 13 by DMA (Direct Memory Access). The named pipe area 12p is an area used as the named pipe 12b-1 and the named pipe 12b-2.

The CPU 11 performs a simulation by sequentially executing simulation commands from the CM area 12m-1, stores the simulation data 204d obtained by the simulation in the disk 13, and issues a data transfer instruction. The latest simulation data 204d is transferred to the shared memory 12a by DMA. On the other hand, the CPU 11 writes the leading address to the named pipe 12b-1 in the named pipe area 12. FIG.

The CPU 11 executes script commands in order from the ML regions 12 and -2 when learning to adjust the threshold value Th by machine learning and when making an inference. The CPU 11 reads the simulation data 204d to be given to the NN 270 from the shared memory 12a and gives it to the NN 270 as input data. NN 270 is executed by GPU 14g using GPU 14m.

Next, mounting examples are shown in FIGS. 9 and 10. FIG. FIG. 9 is a diagram showing an implementation example in FIG. FIG. 9 shows an example of a program language that can be implemented in the functional configuration of FIG. 2 in association with FIG.

The high-performance applications 230 and 232 are programmed in FrontISTR, which is a Fortran language. Contains a log showing the residual evolution of the linear analysis of . The machine learning main program 250 is programmed in the script language Python, and uses the NN 270 by Tensorflow or the like manufactured by Google via an API (Application Programming Interface) such as Keras.

FIG. 10 is a diagram showing an implementation example in FIG. In FIG. 10, the simulation 38 is implemented by programming processing based on the Newton-Raphson method (Newton-Raphson processing) in Fortran, C, C++, or the like. Machine learning processing 48 is implemented by programming deep learning processing in Python or the like.

Next, processing of the information processing apparatus 100 through interprocess communication will be described with reference to FIGS. 11 and 12. FIG. 11 and 12, the named pipe 12b-1 is specified by "sync" and the named pipe 12b-2 is specified by "return". FIG. 11 is a flowchart for explaining simulation processing.

11, when the simulation process is started, the simulation unit 30 sets the shared memory 12a (step S311), and starts (forks) the Python process (step S312). The shared memory 12a is expanded in the OS virtual memory 12v by a memory-mapped file. Then, machine learning by the machine learning unit 40 starts (FIG. 12).

Then, the nonlinear analysis unit 32 starts a nonlinear analysis loop (step S313), and determines whether or not to perform AI inference (step S314). In the first embodiment, AI inference corresponds to machine learning processing for predicting an increase or decrease in the residual threshold Th. Also, as an example of determining the necessity of AI inference, it may be determined whether or not there is an event of calling machine learning processing by “call auto_threshold” as illustrated in FIG.

When AI inference is not performed (NO in step S314), the simulation unit 30 executes a linear solver (step S315). A linear analysis is performed by the linear analysis unit 34 . After that, the simulation unit 30 returns to step S313 and repeats the nonlinear analysis. On the other hand, if AI inference is to be performed (YES in step S314), the nonlinear analysis unit 32 connects to the named pipe "sync" and waits for unlock (step S317).

Upon detecting unlocking, the nonlinear analysis unit 32 copies (writes) the simulation data 204d to the shared memory 12a (step S318). The simulation data 204d is written to the shared memory 12a by DMA data transfer. On the other hand, the nonlinear analysis unit 32 calls the machine learning unit 40 and makes an adjustment request.

After that, the nonlinear analysis unit 32 reads and acquires the inference result 71 from the named pipe “return” (step S321), and uses the obtained inference result 71 to execute the linear solver with the updated threshold value Th (step S322). ). When the linear solver process ends, the nonlinear analysis unit 32 returns to step S313 and repeats the same process as described above.

FIG. 12 is a flowchart for explaining machine learning processing that operates in cooperation with simulation. In FIG. 12, it is assumed that the machine learning unit 40 is programmed in Python. In response to the start of the Python process from the simulation process, machine learning processing by the machine learning unit 40 is started (step S410). Also, in the following description, the case where the inference processing by the inference unit 60 is performed will be described. The learning process of the learning section 50 will be described in detail in the second embodiment.

The machine learning unit 40 sets the shared memory 12a (step S411), and the inference unit 60 loads the trained model (step S412). The shared memory 12a is configured with the same memory mapped file as the simulation process. A trained model corresponds to the NN 270 trained by the learning unit 50 .

Then, the inference unit 60 starts an infinite loop (step S413). The start of an infinite loop connects to the named pipe "sync" (step S414). Unlocking is notified to the nonlinear analysis unit 32 by connecting to the named pipe "sync". The inference unit 60 determines whether or not there is a new adjustment request (step S415).

The inference unit 60 constructs input data from the simulation data 204d for the NN 270 (step S17), inputs the input data to the NN 270, and infers the adjustment direction of the threshold Th (step S418).

Inter-process communication will now be described using an example. 13 and 14 are diagrams for explaining an example of processing related to inter-process communication in the main process of simulation.

From FIG. 13, the simulation unit 30 sets the shared memory 12a at the start of the simulation (step S351). Then, the simulation unit 30 starts (forks) the Python process (step S352). A Python child process is activated and notified of the shared memory address and timing for sharing the shared memory 12a with the Python child process. Timing specifies when the reconciliation request is made. When the timing indicates 2, it indicates that an adjustment request is made every two nonlinear analyses.

The simulation unit 30 initializes the threshold lin_th for linear analysis (step S353). The threshold lin_th is a variable corresponding to the threshold Th in FIG. The initial set value of the threshold lin_th may be incorporated in the program of the simulation unit 30, or may be set by the user at the start of the simulation.

When the threshold lin_th is initialized, a simulation loop is started (step S354). That is, #nonlin_iter is set to the iteration value indicating the number of repetitions so that the nonlinear analysis processing by the nonlinear analysis unit 32 is repeated a predetermined number of times (#nonlin_iter). Since the initial value of #nonlin_iter is 0, the iteration value is set to 0 at the time of initialization. Then, the nonlinear analysis unit 32 executes preprocessing (step S355). Specific contents of the preprocessing will be described in steps S356 to S361.

It is determined whether or not the iteration value is 0 (step S356). At the same time, a request for adjusting the threshold value Th is sent to the machine learning unit 40 . If the iteration value is 0 (YES in step S356), the nonlinear analysis unit 32 proceeds to step S362.

On the other hand, if the iteration value is not 0 (NO in step S356), the nonlinear analysis unit 32 opens the named pipe "sync" in write mode (step S357). The nonlinear analysis unit 32 waits for unlocking from the machine learning unit 40 and starts writing to the shared memory 12a.

Upon detection of unlocking, the nonlinear analysis unit 32 writes the simulation data 204d to the shared memory 12a (step S358). The simulation data 204d stored on the disk 13 is copied to the shared memory 12a by DMA data transfer.

Next, the nonlinear analysis unit 32 writes to the shared memory 12a in the following procedures W1 to W4. In the following description, an example in which the shared memory 12a has 24 (=4×6) cells will be described, but the memory size is not limited to this.

Also, addresses_1 indicates the address of the cell where #nonlin_iter (number of iterations of nonlinear analysis) is stored, addresses_2 indicates the address of the cell where #lin_iter (number of iterations of linear analysis) is stored, and addresses_3 indicates the address of the nonlinear analysis data. Indicates the starting address. Since the nonlinear analysis data is accumulated each time the nonlinear analysis is repeated, the number of cells is accumulated. Therefore, the start address of the linear analysis data is indicated by adding #nonlin_iter to addresses_3.

W1: Write non-linear data from addresses_3.
W2: Write linear data from an address obtained by adding #nonlin_iter to addresses_3.
W3: Store #nonlin_iter in addresses_1. #nonlin_iter is updated.
W4: Store #lin_iter in addresses_2. #lin_iter is updated.
After writing the nonlinear data and linear data, #nonlin_iter and #lin_iter, which are counters, are updated. At the end of W1 to W4, writing of new data is completed.

14, the nonlinear analysis unit 32 opens the named pipe "return" in read mode (step S359). In response to the unlocking by the machine learning unit 40, the nonlinear analysis unit 32 reads the value from the named pipe "return" to obtain the current inference result 71 (step S360).

Then, the nonlinear analysis unit 32 acquires the current threshold lin_th from the obtained inference result and the previous threshold lin_th (step S361). As an example, a processing unit (algorithm) that updates the threshold lin_th based on the inference result may be provided.

When the current threshold lin_th is obtained by updating, the nonlinear analysis unit 32 causes the linear analysis unit 34 to perform linear analysis after exiting the conditional clause of step S356, and obtains a linear analysis result (step S362). The current threshold lin_th is notified to the linear analysis unit 34 . Then, the number of iterations iteration is incremented by 1 (step S364).

The nonlinear analysis unit 32 determines whether the nonlinear analysis has reached a convergence condition (step S364). If the nonlinear analysis does not reach the convergence condition (NO in step S364), the nonlinear analysis unit 32 returns to step S356 in FIG. 13 and repeats the same processing as described above. On the other hand, if the nonlinear analysis reaches the convergence condition (YES in step S364), the nonlinear analysis unit 32 terminates the simulation loop.

When the simulation loop ends, the simulation unit 30 opens the named pipe "sync" in write mode (step S365). Then this main process ends.

FIG. 15 is a diagram for explaining an example of processing related to inter-process communication in a Python child process; In FIG. 15, a Python child process is activated in response to notification of a shared memory address and timing from the simulation unit 30, and machine learning related to adjustment of the threshold value Th is performed by the machine learning unit 40 within the Python child process. .

The machine learning unit 40 sets the shared memory 12a based on the shared memory address notified from the simulation unit 30 (step S471), and loads the trained model (step S472). Then, an infinite loop is started by the machine learning unit 40 (step S473). The contents of processing performed in each infinite loop will be explained in steps S474 to S483.

The machine learning unit 40 opens the named pipe "sync" in read mode (step S474). The unlocking is notified to the simulation main process (simulation unit 30). The machine learning unit 40 executes a new adjustment request presence/absence determination loop (step S475).

That is, the machine learning unit 40 reads #nonlin_iter and #lin_iter indicating the number of times of analysis from the shared memory 12a (step S476), and determines whether or not data is written (step S477). Specifically, the following processing is performed.

If #nonlin_iter does not match the previous nonlinear analysis count plus timing (condition A), or if #lin_iter matches the previous linear analysis count (condition B), the count is incremented by one. If both condition A and condition B are satisfied, or if the current count is equal to or greater than a set value (eg, "1000") after updating the count, the machine learning unit 40 determines that there is no new adjustment request. and exit the Python program.

On the other hand, if condition A and condition B are not satisfied, that is, if data writing can be confirmed, the machine learning unit 40 determines that there is a new adjustment request, and exits from this new adjustment request presence/absence determination loop. (step S478), the data is read from the shared memory 12a (step S479).

The inference unit 40 constructs input data used for inference (step S480), and uses the NN 270 to infer adjustment of the threshold Th (step S481). The NN 270 is Kerase or the like and operates on the GPU 14g. An inference result 71 is output from the inference unit 40 .

The machine learning unit 40 opens the named pipe "return" in write mode (step S482), and writes the inference result to the named pipe "return" in "return" mode. After that, the infinite loop is terminated and the processing by the machine learning unit 40 is terminated. Python child process exits.

FIG. 16 is a diagram showing a state example in interprocess communication. Assume that the timing at which an adjustment request is made is 2. FIG. 16A shows an example of the state of the shared memory 12a immediately after the simulation has been repeated four times. In the shared memory 12a, #nonlin_iter indicates 4 times, and nonlinear analysis data is written in 4 cells. #lin_iter indicates 12 times, and linear analysis data is written in 12 cells.

It is assumed that the machine learning unit 40 recognizes that the current #nonlin_iter is 2 times and #lin_iter is 6 times. Assume that the timing is 2. In this case, the value "4" obtained by adding the current #nonlin_iter "2 times" and the timing "2" matches #nonlin_iter "4 times" in the shared memory 12a. Also, the current #lin_iter "6 times" and #lin_iter "12 times" do not match. In this case, it is determined that there is a new adjustment request.

FIG. 16B shows an example of a state in which data has been written by simulation but the counter has not been updated. In the shared memory 12a, #nonlin_iter indicates 4 times, and nonlinear analysis data are stored in 6 cells. #lin_iter indicates 12 times, and linear analysis data are stored in 16 cells.

The nonlinear analysis is performed twice and each result is written to each cell, so that a total of 6 cells are used. Using the threshold value Th updated in FIG. 16A, linear analysis is executed twice, and linear analysis data is written to two cells each time. cells are in use. #lin_iter is in an unupdated state.

The machine learning unit 40 recognizes that the current #nonlin_iter is 4 times and #lin_iter is 12 times. In this case, the value "6" obtained by adding the current #nonlin_iter "4 times" and the timing "2" does not match the #nonlin_iter "4 times" of the shared memory 12a. On the other hand, the current #lin_iter "12 times" matches #lin_iter "12 times". In this case, it is determined that there is no new adjustment request.

FIG. 16C shows an example of a state in which the simulation has stored the counter in the shared memory after data writing is completed. #nonlin_iter is updated 6 times in the shared memory 12a. Also, #lin_iter is updated to 16 times.

The machine learning unit 40 recognizes that the current #nonlin_iter is 4 times and #lin_iter is 12 times. In this case, the value "6" obtained by adding the current #nonlin_iter "4 times" and the timing "2" matches #nonlin_iter "6 times" in the shared memory 12a. Also, the current #lin_iter "12 times" and #lin_iter "12 times" match. In this case, it is determined that there is a new adjustment request.

FIG. 17 is a diagram illustrating an example of overhead verification results. In FIG. 17, the horizontal axis indicates the number of iterations of the simulation (that is, the nonlinear analysis), and the vertical axis indicates the overhead time per iteration.

As for the operating environment, when the data size is 1 GB, the overhead 17a is caused by using the shared memory 12a according to the first embodiment and making the data shared between the simulation unit 30 and the machine learning unit 40 a memory-mapped file. Overhead 17b indicates overhead due to input/output to disk 13. FIG.

From the total overhead 17b and the overhead 17a in the first embodiment, it can be seen that the overhead can be reduced by the first embodiment.

Furthermore, FIG. 18 and FIG. 19 show the results of verifying the overhead due to the difference in data size.

FIG. 18 is a diagram showing verification results for each data size by input/output to/from a disk. FIG. 18 shows the respective times of overhead and simulation for each data size, and the ratio of the overhead to the total time.

FIG. 19 is a diagram showing verification results for each data size in input/output to/from a disk. FIG. 18 shows the respective times of overhead and simulation for each data size, and the ratio of the overhead to the total time.

As described above, in simulations using machine learning, the processing time according to the first embodiment can be clearly shortened.

A mechanism for improving the adjustment accuracy of the threshold value Th by machine learning in the second embodiment will be described in detail below.

[Second embodiment]
In the second embodiment, in the simulation of structural analysis, fluid analysis, etc. by nonlinear analysis that finds a solution by repeatedly solving linear analysis, the threshold value Th used for determining convergence in the linear analysis is set according to the execution status of the simulation. , dynamically adjusted by machine learning.

FIG. 20 is a diagram for explaining nonlinear analysis. A linear solver that performs linear analysis often finds a solution using a CG method as an iterative method. From FIG. 20, for iteration, the solution vector x is repeatedly updated until the convergence condition is satisfied. A residual threshold Th is used as one of the convergence conditions. The residual is expressed by the norm of the residual vector r, which is initialized with r ₀ =b−Ax. When the residual becomes equal to or less than the threshold Th, it is considered that the solution vector x has converged, and the iteration ends.

The threshold Th affects solution accuracy and execution time. The smaller the threshold value, the higher the accuracy of the solution, but the number of iterations increases and the execution time increases. Therefore, it is preferable to set the threshold value so that the solution with the required accuracy can be obtained with as few iterations as possible. However, the threshold Th is set by the user's judgment based on empirical rules or heuristics. Therefore, a method of estimating the optimum residual threshold Th at high speed by machine learning and speeding up the entire nonlinear analysis (that is, the entire simulation) will be described.

FIG. 21 is a diagram for explaining an outline of a learning unit in the first functional configuration example of the information processing apparatus according to the second embodiment. In FIG. 21, information processing apparatus 100 mainly includes simulation section 30 and machine learning section 40 . The main memory 12 stores question data 2, log data 4c, candidate threshold 3, reference threshold 3ref, learning data 6g, and the like. As described in the first embodiment, part of the main memory 12 is used as the shared memory 12a.

The simulation unit 30 has the nonlinear analysis unit 32 and the linear analysis unit 34, as described with reference to FIG. 2, acquires the residual error and time for each iteration of the linear analysis, and outputs the log data 4c. In the log data 4c, the residuals and times of the linear analysis repeatedly executed until the residuals converge within the threshold value Th are recorded for a predetermined number of iterations of the nonlinear analysis.

Further, when called by the learning unit 50 , the simulation unit 30 performs simulation with the fixed threshold value Th given by the learning unit 50 . That is, simulation is performed without using machine learning. Specifically, the simulation is performed with "call auto_threshold" in the pseudo code 31 of FIG. 4 disabled.

The machine learning unit 40 has a learning unit 50 that learns adjustment of the threshold Th by the NN 270 as shown in FIG. 4, and an inference unit 60 that adjusts the threshold Th during simulation. The reasoning unit 60 will be described with reference to FIG.

The learning unit 50 learns the NN 270 that adjusts the threshold Th using the log data 4c obtained by the simulation unit 30 giving each of the plurality of candidate thresholds 3 of the candidate threshold 3 for each problem data 2 . Each of the plurality of candidate threshold values 3 is given to the simulation unit 30 to perform simulation, and log data 4c is obtained. Alternatively, the learning unit 50 may have a processing unit that causes each of the plurality of candidate threshold values 3 to be simulated.

The learning unit 50 supplies the selected candidate threshold value 3 to the simulation unit 30 to cause the simulation unit 30 to perform a simulation for the question data 2 . The simulation unit 30 outputs log data 4c representing the time taken for each iteration of the linear analysis and the residual r. Log data 4c obtained for each candidate threshold 3 can be obtained. The input/output of the log data 4c may be performed by the same inter-process communication using the shared memory 12a as described in the first embodiment.

The learning unit 50 refers to the log data 4c obtained for each candidate threshold value 3, determines the reference threshold value 3ref from among the candidate threshold values 3, and saves the reference threshold value 3ref in the main memory by using the transition of the residual error for each iteration, the calculation time, and the like. 12.

The learning unit 50 creates learning data 6g by assigning a label to each piece of log data 4c based on the reference threshold value 3ref. Labeling is performed based on the result of comparison between the candidate threshold 3 of the log data 4c and the reference threshold 3ref.

As an example of labeling, the log data 4c with the candidate threshold 3 smaller than the reference threshold 3ref is given the label "1", and the log data 4c with the candidate threshold 3 larger than the reference threshold 3ref is given the label "3". The learning unit 50 assigns the label "2" to the log data 4c using the candidate threshold 3 that matches the reference threshold 3ref.

In the learning unit 50, when the input data 6g is constructed from the learning data 6g and input to the NN 270 to obtain the inference result 71, the error obtained by comparing the label assigned to the learning data 6g is fed back to the NN 270. The learning unit 50 learns the NN 270 using all the log data 4c obtained by the simulation unit 30. FIG.

FIG. 22 is a diagram for explaining an outline of an inference unit in the first functional configuration example of the information processing apparatus in the second embodiment. In FIG. 22, in the information processing apparatus 100, the simulation unit 30 and the inference unit 60 of the machine learning unit 40 mainly operate during inference. The main memory 12 stores problem data 2, log data 4c, simulation results 5, threshold Th, reasoning results 71, and the like. Here, the inference unit 60 will be described.

The simulation unit 30 analyzes the unknown problem data 2 and outputs the obtained log data 4c. The log data 4c corresponds to the simulation data 204d in the first embodiment, and may be treated as a memory-mapped file. The log data 4c is stored in the shared memory 12a, and the top address of the log data 4c is specified in the named pipe 12b-1.

In response to a call from the nonlinear analysis unit 32 of the simulation unit 30, the inference unit 60 uses the log data 4c obtained by the simulation unit 30 to infer an increase or decrease in the threshold Th using the trained NN 270, and obtains output the inference result 71 obtained. The inference result 71 is notified to the nonlinear analysis unit 32 as a return value. The return value should be set in the named pipe 12b-2 (FIGS. 7 and 11).

Next, an example of determining the reference threshold value 3ref will be described. As an example, the simulation time for each candidate threshold may be verified in advance, and the candidate threshold 3, which is the shortest execution time among the obtained execution times, may be set as the reference threshold 3ref.

FIG. 23 is a diagram illustrating an example of simulation time verification for each candidate threshold.

The shortest candidate threshold is set as the reference threshold 3 ref from the simulation time when the simulation is performed with each candidate threshold 3 . Using the reference threshold value 3ref determined in this manner as a boundary, a change in the threshold value is determined based on the boundary.

FIG. 24 is a flowchart for explaining the learning process in the first functional configuration example. In FIG. 24, in the machine learning unit 40, the learning unit 50 sequentially provides the plurality of candidate threshold values 3 to the simulation unit 30, performs simulation, and acquires the log data 4c for each candidate threshold value 3 (step S1110). The log data 4c includes residuals for each iteration of the linear analysis and the run time of the simulation.

After obtaining the log data 4c, the learning unit 50 identifies the candidate threshold value 3 for which the simulation was completed in the shortest time from among the plurality of log data 4c (step S1120). Then, the learning unit 50 sets the specified candidate threshold 3 as a reference threshold 3ref, labels the log data 4c based on the magnitude relationship between the reference threshold 3ref and the candidate threshold 3, and generates learning data 6g. (step S1130).

The learning unit 50 learns the NN 270 using the generated learning data 6g (step S1150). When the learning unit 50 completes learning using the learning data 6g with different candidate threshold values 3 for the plurality of question data 2, the learning process ends.

On the other hand, in the simulation 30, the simulation is started in response to the reception of the threshold candidate 3, one question data 2 is read, and the threshold candidate 3 is set to the threshold Th. Then, the nonlinear analysis unit 32 performs preprocessing for nonlinear analysis (step S2011).

Next, after the linear analysis unit 34 performs preprocessing (step S2012), an approximate solution is calculated by linear analysis (step S2013), and the obtained residual and time are stored in the main memory 12 (step S2014). ). The linear analysis unit 34 uses the threshold Th (=candidate threshold 3) to perform convergence determination as to whether or not the solution of the linear analysis has converged (step S2015). If it is determined that the convergence has not occurred (NO in step S2015), the linear analysis unit 34 returns to step S2013 and repeats the same processing as described above.

If it is determined that convergence has occurred (YES in step S2015), the nonlinear analysis unit 32 performs post-processing of the nonlinear analysis (calculation of an approximate solution) (step S2016), and determines whether or not the solution of the nonlinear analysis has converged. (step S2017). The determination of convergence of nonlinear analysis uses a threshold value for nonlinear analysis.

As a result, when it is determined that the convergence has not occurred (NO in step S2017), the nonlinear analysis unit 32 returns to step S2011 and repeats the same processing as described above. On the other hand, if it is determined that convergence has occurred (YES in step S2017), the simulation unit 30 stores the simulation end time in the main memory 12 and ends this simulation. At the end of the simulation, the residual may be set to 0 and the simulation end time may be stored.

The simulation unit 30 may notify the learning unit 50 of the machine learning unit 40 of the end each time the simulation for each of the question data 2 ends, or notify the end after the simulation for the last candidate threshold value 3 ends. may Alternatively, the simulation unit 30 may output the log data 4c for all combinations of the problem data 2 and the candidate threshold values 3, and then notify the learning unit 50 of the end of the simulation. The same applies to other functional configuration examples in the second embodiment.

FIG. 25 is a flowchart for explaining inference processing in the first functional configuration example. In FIG. 25, when the simulation unit 30 is activated, the simulation time is reset and time measurement is started.

The simulation unit 30 initializes the threshold value Th at the start of the simulation, and the nonlinear analysis unit 32 performs preprocessing for nonlinear analysis (step S3011). Then, the linear analysis unit 34 performs preprocessing of the linear analysis (step S3012), calculates an approximate solution of the linear analysis (step S3013), and uses a threshold Th to determine whether the solution of the linear analysis has converged. A determination is made (step S3014). If it is determined that the convergence has not occurred (NO in step S3014), the linear analysis unit 34 returns to step S3013 and repeats the same processing as described above.

If it is determined that convergence has occurred (YES in step S3014), the nonlinear analysis unit 32 performs post-processing of the nonlinear analysis (calculation of an approximate solution) (step S3015), and determines whether or not the solution of the nonlinear analysis has converged. (step S3016). The determination of convergence of nonlinear analysis uses a threshold value for nonlinear analysis.

As a result, when it is determined that convergence has not occurred (NO in step S3016), the nonlinear analysis unit 32 issues an adjustment request, causes the inference unit 60 to infer adjustment of the threshold Th, and obtains an inference result 71 as is used to update the threshold Th (step S3017), the process returns to step S3011, and the same processing as described above is repeated. If it is determined that convergence has occurred (YES in step S3016), the nonlinear analysis unit 32 returns to step S3013 and repeats the same processing as described above.

On the other hand, in response to the adjustment request, the inference unit 60 uses the trained NN 270 to infer whether the current linear analysis threshold Th is lower or higher than the reference threshold 3ref from the most recently obtained log data 4c (step S4010). ). The inference unit 60 outputs the obtained inference result 71 (step S4020), and ends this inference processing.

In the first functional configuration example, the log data 4c is used as it is, but the log data 4c is divided into predetermined sections and learned to extend the data, and the adjustment accuracy of the threshold Th in the first functional configuration example can be improved.

In the first functional configuration example, classification into classes 1, 2, and 3 was taken as an example. In that case, the learning unit 40 assigns the label 0 when the candidate threshold 3 is lower than the reference threshold 3ref during learning, and assigns the label 1 otherwise. may be inferred. Also, the nonlinear analysis unit 32 may be a stationary analysis including a linear solver therein. The same applies to the following second functional configuration example.

FIG. 26 is a diagram for explaining an outline of a learning unit in the second functional configuration example of the information processing apparatus according to the second embodiment. In FIG. 26, the same processing units and data as those in FIG. 21 are denoted by the same reference numerals, and the description thereof is omitted. In the second embodiment, a plurality of pieces of input data are created and learned by dividing the residual curve into certain sections. The data representing the residual curve included in the log data 4c is referred to as residual curve data 4d.

Similar to the first functional configuration example, the learning unit 50 calculates a plurality of residual curve data 4d obtained by the simulation unit 30 giving each of the plurality of candidate thresholds 3 of the candidate thresholds 3 for each problem data 2. , the reference threshold 3ref is determined. The learning unit 50 identifies the candidate threshold value 3 for which the simulation is completed in the shortest time, and sets it as the reference threshold value 3ref. Also, the learning unit 50 determines a label based on whether or not the candidate threshold 3 of the residual curve data 4d is smaller than the reference threshold 3ref.

After that, in the second functional configuration example, the learning unit 50 creates a plurality of input data 6a by dividing the residual curve data 4d into predetermined sections, and stores the residual curve data in each of the plurality of input data 6a. 4d is given the determined label to generate a plurality of learning data 6g. Labeling is as described above.

The learning unit 50 feeds back to the NN 270 the error between the estimation result 71 obtained by inputting each generated learning data 6g to the NN 270 and the label assigned to the learning data 6g, and calculates the correct accuracy of the NN 270. Improve.

FIG. 27 is a diagram for explaining an outline of an inference unit in the first functional configuration example of the information processing apparatus according to the second embodiment. In FIG. 27, in the information processing apparatus 100, the simulation unit 30 and the inference unit 60 of the machine learning unit 40 mainly operate during inference. The main memory 12 stores the problem data 2, the residual curve data 4d, the threshold value Th, the inference result 71, and the like. As described in the first embodiment, part of the main memory 12 is used as the shared memory 12a. Here, the inference unit 60 will be described.

The simulation unit 30 outputs residual curve data 4d, and the inference unit 60 uses the residual curve data 4d obtained by the simulation unit 30 in response to an adjustment request from the nonlinear analysis unit 32 of the simulation unit 30. , the trained NN 270 infers the increase or decrease of the threshold Th, and outputs the obtained inference result 71 . The inference result 71 is notified to the nonlinear analysis unit 32 as a return value.

When using the trained NN 270, the inference unit 60 uses the residual curve data 4d obtained by the simulation unit 30 in response to an adjustment request from the nonlinear analysis unit 32 of the simulation unit 30, and uses the trained NN 270 increases or decreases the threshold value Th, and outputs the obtained inference result 71 . The inference result 71 is notified to the nonlinear analysis unit 32 as a return value.

FIG. 28 is a flowchart for explaining a first example of learning processing in the second functional configuration example. In FIG. 28, the same step numbers are given to the same contents as in FIG. 24, and the description thereof is omitted. In FIG. 28, in the machine learning unit 40, the learning unit 50 sequentially provides the plurality of candidate threshold values 3 to the simulation unit 30, causes the simulation unit 30 to perform simulation, and obtains the residual curve data 4d for each candidate threshold value 3 (step S1110). ). The residual curve data 4d includes the residuals for each iteration of the linear analysis and the simulation execution time.

After obtaining the residual curve data 4d, the learning unit 50 identifies the candidate threshold value 3 for which the simulation is completed in the shortest time from among the plurality of residual curve data 4d (step S1120). Then, the learning unit 50 sets the identified candidate threshold 3 as the reference threshold 3ref, and determines a label for the residual curve data 4d based on the magnitude relationship between the reference threshold 3ref and the candidate threshold 3 (step S1131). .

The learning unit 50 creates a plurality of input data 6a by dividing the residual curve into certain intervals, assigns the labels determined in S1130 to each of the created plurality of input data, and generates learning data 6g ( step S1140).

The learning unit 50 learns the NN 270 using the generated learning data 6g (step S1150). When the learning unit 50 completes learning using the learning data 6g with different candidate threshold values 3 for the plurality of question data 2, the learning process ends.

The processing by the simulation 30 is the same as the processing (FIG. 24) in the first functional configuration example, so the description thereof is omitted.

FIG. 29 is a flowchart for explaining inference processing in the second functional configuration example. In FIG. 29, the same step numbers are given to the same contents as in FIG. 25, and the description thereof is omitted. In the second functional configuration example, an example of adjusting the threshold Th using the inference result 71 by the simulation unit 30 will be described. Since the processing by the inference unit 60 is the same as in the first functional configuration example, the description thereof is omitted.

In FIG. 29, the nonlinear analysis unit 32 designates the residual curve data 4d and makes an adjustment request to the adjustment unit 60, and according to the inference result 71 obtained from the adjustment unit 60, the residual threshold change rate The threshold value Th is adjusted by n or 1/n (step S3018), the process returns to step S3011, and the same processing as described above is repeated.

Specifically, in step S3018, the nonlinear analysis unit 32 multiplies the threshold Th by n when the inference result 71 indicates that the threshold Th is to be increased using the rate of change n (n is a natural number of 2 or more). On the other hand, when lowering, the nonlinear analysis unit 32 multiplies the threshold Th by 1/n (reciprocal times the rate of change). As another example, the threshold Th may be multiplied by 1/n if the inference result 71 does not indicate that the threshold Th should be raised.

FIG. 30 is a flowchart for explaining a second example of learning processing in the second functional configuration example. In FIG. 30, the same step numbers are given to the same contents as in FIG. 28, and the description thereof is omitted. In the second example of the learning process, instead of specifying the reference threshold 3ref from the candidate thresholds 3, the reference threshold 3ref is created by comparing simulation results 5 among a plurality of candidate thresholds 3 for each problem data 2. FIG.

In FIG. 30 , in the machine learning unit 40, the learning unit 50 sequentially provides a plurality of candidate threshold values 3 to the simulation unit 30, performs a simulation, and obtains the residual curve data 4d for each candidate threshold value 3 and the simulation result 5. Acquire (step S1112). The residual curve data 4d includes the residuals for each iteration of the linear analysis and the simulation execution time.

The learning unit 50 calculates the result error between the simulation result 5 with each candidate threshold 3 and the simulation result 5 with the lowest candidate threshold 3 for each problem data 2 (step S1123). As an example of calculating the result error, the learning unit 50 calculates the difference between each element of the simulation result 5 and the value of the element when the candidate threshold 3 is the lowest in the same problem, and calculates the mean absolute error (MAE: Mean Absolute error) to obtain the resulting error.

Then, the learning unit 50 sets the reference threshold 3ref based on the result of comparing the result error and the execution time for each candidate threshold 3 for each problem data 2, and sets the reference threshold 3ref and the candidate threshold 3. A label for the residual curve data 4d is determined based on the magnitude relationship (step S1145). As an example of a method for determining the reference threshold 3ref, the learning unit 50 refers to both the result error (ie precision) and the execution time (ie speed) to obtain the candidate threshold 3 that is closest to the predetermined condition. As an example of the condition, the candidate threshold 3 that is the fastest among the accuracies that satisfy the user's usage may be set as the reference threshold 3ref. Alternatively, the candidate threshold 3 when minimizing the product of the resulting error and the execution time may be applied to the reference threshold 3ref.

For each of the residual curve data 4d of each question data 2, the learning unit 50 creates a plurality of input data 6a by dividing the residual curve into certain intervals, and applies S1146 to each of the created plurality of input data 6a. The label determined in step S1147 is added to generate learning data 6g. The learning unit 50 then learns the NN 270 using the generated learning data 6g (step S1150).

FIG. 31 is a flowchart for explaining a third example of learning processing in the second functional configuration example. In FIG. 31, the same step numbers are given to the same contents as in FIG. 30, and the description thereof is omitted. In the third example of the learning process, the reference threshold value 3ref is specified from the candidate threshold value 3 in consideration of the simulation accuracy desired by the user. Since the processing of the simulation unit 30 is the same as that of FIG. 30, it is simplified and the description thereof is omitted.

In FIG. 30, the machine learning unit 40 sets the simulation accuracy desired by the user as the reference value of the result error (step S1150). An example is MAE<0.0001. Therefore, step S1146 is performed instead of step S1145 of FIG.

In step S1146, the learning unit 50 sets the candidate threshold value 3 when the execution time is the shortest among results error satisfying the accuracy desired by the user for each question data 2 as the reference threshold value 3ref. and the candidate threshold 3, the label for the residual curve data is determined. Since steps S1147 and S1150 are the same as those in FIG. 30, description thereof will be omitted.

As a learning environment in the first and second embodiments described above,
・NN270
As an example, a CNN may be configured using AlexNet.
・AI framework
Keras or the like may be used as TensorFlow and an API to TensorFlow. In the information processing apparatus 100 having such a learning environment, a method for dynamically adjusting the threshold value Th for linear analysis developed by the inventors was applied to the simulation, and various results obtained as a result of applying the method were applied. Information is presented below.

Next, FIG. 32 and FIG. 33 show learning results of the first example of the learning process in the second functional configuration example. FIG. 32 is a diagram showing learning results for each candidate threshold value according to the first example of the learning process. In this example, 15 candidate thresholds 3 within the residual threshold range of the linear analysis described in FIG. 23 are used.

In FIG. 32, for each of candidate threshold values 3, residual curves are shown every two times the linear residual curve converges. Also, the label "0" is set for candidate threshold values 3 smaller than the reference threshold value 3ref, and the label "1" is set for other candidate threshold values 3.

FIG. 33 shows the learning result when using the learning data 6g labeled in this way. FIG. 33 is a diagram showing learning results based on the labeling in FIG.

From the above verification, the loss graph 33a in FIG. 33(A) shows the learning loss value 33a-1 and the verification loss value 33a-2. A value 33b-1 and a verification accuracy value 33b-2 are shown. The loss improves rapidly in the period with few epochs, and the validation data shows the same tendency as during training. In addition, the accuracy also improved rapidly when there were few epochs, and the verification data showed the same tendency as during learning. It can be said that appropriate learning was carried out.

Next, the learning result of the second example of the learning process in the second functional configuration example will be described with reference to FIGS. 34 and 35. FIG. FIG. 34 is a diagram showing learning results for each candidate threshold value according to the second example of the learning process. In this example, 15 candidate thresholds 3 for residual thresholds of linear analysis are used.

In FIG. 34, for each of the candidate threshold values 3, the residual curve is shown every two times the linear residual curve converges. A structural analysis model using CG and AMG (Algebraic Multigrid) is used. Also, if the accuracy of the simulation result is sufficient and is smaller than the candidate threshold 3 for the fastest time, the label "0" is set, and the label "1" is set for the other candidate threshold 3.

FIG. 35 shows the learning result when using the learning data 6g labeled in this way. FIG. 35 is a diagram showing learning results based on the labeling of FIG.

Through the verification described above, a loss graph 35a shown in FIG. 35(A) and an accuracy graph 35b shown in FIG. 35(B) were obtained. The loss graph 35a in FIG. 35(A) shows a learning loss value 35a-1 and a verification loss value 35a-2, and the accuracy graph 35b shown in FIG. 35(B) shows a learning accuracy value 35b-1 and A verification accuracy value 35b-2 is shown. The loss improves rapidly in the period with few epochs, and the validation data shows the same tendency as during training. In addition, the accuracy also improved rapidly when there were few epochs, and the verification data showed the same tendency as during learning. In the second example of the learning process, in particular, the verification loss value 35a-2 and the verification accuracy value 35b-2 transition very smoothly, and the accuracy is higher than in the first example of the learning process. It can be said that learning has taken place.

Furthermore, the result of comparing and verifying the first example of the learning process and the second example of the learning process in the second embodiment is shown below. The verification environment is as follows.
Call interval of learning unit 50 (AI unit): 2 nonlinear loops each Trained model:
- Labeling for the first example:
set the label 0 when the residual threshold of the linear analysis is less than the candidate threshold 3 at the fastest time,
Otherwise, set label 1.

- Labeling for the second example:
The accuracy of the simulation results is sufficient, and
Set label 0 when less than candidate threshold 3 at fastest time,
Otherwise, set label 1.

Rate of change of residual threshold for linear analysis: results when doubled or halved.

FIG. 36 is a diagram for explaining an example of generating learning data. In FIG. 36, in the second embodiment, the learning unit 50 divides the residual curve data 4d-1 and 4d-2 into predetermined sections to create the input data 6a.

An example is shown in which the label "1" is given to all the divided input data 6a when the candidate threshold value 3 of the residual curve data 4d is equal to or greater than the reference threshold value 3ref, and the label "0" is given otherwise. there is As an example, it is assumed that 12 pieces of learning data 6g are generated for one residual curve data 4d.

The learning unit 50 learns the NN 270 using a plurality of learning data 6g assigned the same label for one residual curve data 4d. The error is fed back to the NN 270, and in the second embodiment, a plurality of learning data 6g with the same label can be obtained from one residual curve data 4d. can be made Therefore, the inference unit 60 can appropriately change the threshold value Th to an optimum value, thereby speeding up the simulation time.

The result of verifying the simulation execution time and the accuracy of the simulation result 5 is shown below.

FIG. 37 is a diagram showing verification results of the execution time. In FIG. 37, the vertical axis indicates time (seconds), and from the left: When the simulation is executed with the default value “1.0e-08” used for initial setting. In the case of the second example,
・In the case of the first example,
Each execution time is shown when the simulation is executed with the threshold for the fastest execution time as illustrated in FIG. 23 .

The execution time decreases in the order of initial setting, second example, first example, and fastest setting. The fastest setting has the shortest execution time, but the second example and the first example achieve speed-up with respect to the initial setting with the longest execution time.

FIG. 38 is a diagram showing verification results of simulation results. In FIG. 38, the vertical axis indicates the error of the simulation result, and similarly to FIG. 37, the error is indicated in the order of the initial setting, the second example, the first example, and the fastest setting.

The initial setting has reached the criterion 38a of 4 significant digits match on average. The second example shows an error that exceeds the criterion 38a but an accuracy that is close to the criterion 38a. On the other hand, in the accuracy of the first example and the fastest setting, although the significant digits exceed the standard 38b of coincidence of 3 digits on average, the errors are approximately the same.

From the above verification, from the viewpoint of trying to speed up while maintaining the accuracy of the simulation result 5, in the first example and the second example, it can be said that the accuracy is maintained while improving the execution speed.

FIG. 39 is a diagram showing an example of threshold change. In FIG. 39, the vertical axis indicates the threshold value for linear analysis, and the horizontal axis indicates the number of Newton's method steps. A threshold change 39a of the simulation in this embodiment and a threshold change 39b of an existing simulation that does not use this embodiment are shown at predetermined steps.

The simulation in this embodiment corresponds to the simulation performed by the information processing apparatus 100 having the functional configuration illustrated in the first and second embodiments. The steps correspond to steps in a linear solver based on Newton's method, and the predetermined steps are two steps in this example.

From FIG. 39 , the threshold change 39 a in the information processing apparatus 100 is that the threshold Th is set to the initial value in step 1 and rises up to step 41 , and then the linear analysis is performed while dynamically changing. I understand. On the other hand, the existing simulation threshold change 39b indicates a state in which the initial value is maintained.

FIG. 40 is a diagram showing an example of elapsed processing time. In FIG. 40, the vertical axis indicates the execution time, and the horizontal axis indicates the number of Newton's method steps. The execution time indicates the time taken for one step of Newton's method. The processing time lapse 40a in this embodiment and the existing processing time lapse 40b that does not use this embodiment are shown, which are measured for each step.

In the existing processing time lapse 40b, the execution time repeats transition within a constant variation range. On the other hand, in the processing time lapse 40a in the present embodiment, the execution time is shortened each time the step is repeated, and after about the 35th step, the transition is repeated within a constant variation range. The variation range of the processing time lapse 40a in this embodiment is clearly faster than the variation range of the existing processing time lapse 40b.

FIG. 41 is a diagram showing an example of progress of the number of iterations. In FIG. 41, the vertical axis indicates the number of iterations of the linear analysis, and the horizontal axis indicates the number of Newton's method steps. The progress 41a of the number of iterations of linear analysis in the simulation of this embodiment and the progress 41b of the number of iterations of linear analysis in an existing simulation that does not use this embodiment are shown.

In the iteration number progress 41b, even if the number of steps increases, the linear analysis continues to be performed with approximately the same number of iterations, and in this example, the linear analysis does not converge at 60 times or less. On the other hand, the progress 41a of the number of iterations continues to decrease and fluctuates between constant number of iterations.

The verification according to the second embodiment described above is shown as an example using the following languages and libraries.
・Simulation unit 30
FrontISTR, which is structural analysis OSS (Open Source Software), is used.
・Machine learning unit 40
The main programs of the learning unit 50 and the inference unit 60 may use a general-purpose script language such as Python that can be embedded in many applications.

A program that performs AI inference (corresponding to NN270) called from the learning unit 50 and the inference unit 60 may use TensorFlow, which is a library for machine learning, and use the Keras API that easily calls TensorFlow.

Thus, the simulation unit 30 and the machine learning unit 40 have different program language structures. Data can be exchanged between the simulation unit 30 and the machine learning unit 40 via the existing disk 13 (FIG. 1), so implementation of the first embodiment is not essential. However, as shown in FIGS. 37 and 38, the execution speed and the accuracy of the simulation result 5 are in a trade-off relationship. From the viewpoint of speeding up the simulation while maintaining the accuracy of the simulation, it is more preferable to implement inter-process communication as described in the first embodiment.

Also, in the second embodiment using the language and library described above, when a simulation is executed, an execution log such as that shown in FIG. 42 can be obtained. FIG. 42 is a diagram showing an example of an execution log in the second embodiment.

The execution log 4a illustrated in FIG. 42 corresponds to a log output when the simulation section 30 programmed with FrontISTR is executed. In the execution log 4a, a processor that executes AI processing corresponding to the NN 270 is called by the log description 42a. A processor is indicated by the product name of the GPU 14 or the like. The log description 42b indicates that the AI framework was called, and that Tensorflow was called in this example.

From the log descriptions 42c and 42d, it can be seen that the residual threshold Th has changed from approximately 1e-08 to approximately 2e-08. In existing simulations to which the second embodiment is not applied, the threshold Th does not fluctuate in this way. For example, if the threshold Th is 1e-08, a log indicating 1e-08 is always recorded.

Note that in the information processing apparatus 100 that implements the first and second embodiments,
・For programs that perform AI processing, if the main program is Python,
python_main_path=/path/to/ai_main.py
A setting file such as is created and saved in a specific storage area. Also, in this particular storage area,
- Once the trained AI model is generated, so that it can be used by the reasoning unit 60, for example:
trained_model_path=/path/to/trained_model.h5
A configuration file such as is created and saved.

In the above description, the residual curve is an example of data representing residual transition, the execution time is an example of simulation computation time, and the NN 270 is an example of an inference model.

The invention is not limited to the specifically disclosed embodiments, which are capable of major variations and modifications without departing from the scope of the claims.

Further, the following additional remarks are disclosed regarding the embodiments including the above-described first to second examples.
(Appendix 1)
on one or more computers,
Execute a first process of repeating linear analysis to perform nonlinear analysis,
Residual threshold used for determining convergence of the linear analysis by the inference model based on the residual transition and computation time for each iteration of the linear analysis obtained for each residual threshold with a plurality of experimental values in the first process and a second process for inferring
An information processing program, characterized in that data exchange between the first process and the second process is performed by inter-process communication using a shared memory set in a memory.
(Appendix 2)
The first processing is
storing in the shared memory the residual transition and the computation time for each iteration of the linear analysis in the shared memory, and setting an address to a first named pipe;
obtaining an inference result of the inference model written in the second process from a second named pipe;
The second processing is
obtaining the residual transition and the computation time from the address specified by the first named pipe in the shared memory;
causing the inference model to learn to infer the residual threshold from the residual transition and a reference threshold determined from the residual transition and the computation time; 2. The information processing program according to claim 1, wherein the information processing program writes to 2 named pipes.
(Appendix 3)
The second processing is
setting the experimental value when the calculation time is the shortest as the reference threshold;
generating learning data by labeling the residual transition according to the result of comparing the experimental value used for each residual transition with the reference threshold;
The information processing program according to appendix 2, wherein the inference model is performed using the learning data.
(Appendix 4)
The second processing is
setting the experimental value when the calculation time is the shortest as the reference threshold;
determining a label for the residual transition according to a result of comparing the experimental value used for each residual transition with the reference threshold;
creating a plurality of input data by dividing the residual transition into certain intervals, assigning the determined label to each of the plurality of created input data to generate a plurality of learning data;
The information processing program according to appendix 2, wherein the inference model is applied to each of the plurality of learning data.
(Appendix 5)
The second processing is
The experimental value when the computation time is the shortest is specified for each problem data of the nonlinear analysis, and the first result obtained in the first process when using the specified experimental value; calculating the result error with each of the second results obtained in the first process when using the experimental value of
setting the reference threshold based on the result of comparing the result error and the execution time for each experimental value for each problem data;
determining a label for the residual transition according to a result of comparing the experimental value used for each residual transition with the reference threshold;
creating a plurality of input data by dividing the residual transition into certain intervals, assigning the determined label to each of the plurality of created input data to generate a plurality of learning data;
The information processing program according to appendix 2, wherein the inference model is applied to each of the plurality of learning data.
(Appendix 6)
The second processing is
In response to a call from the first process, using the residual transition obtained by the first process, obtaining the inference result of inferring the residual threshold by a trained model, writing to the second named pipe as a return value to the first process;
Any one of Appendices 3 to 5, wherein the first process reads the inference result from the second named pipe, and uses the read inference result and a predetermined change rate to update the residual threshold. 1. The information processing program according to item 1.
(Appendix 7)
The first processing is
connecting to said first named pipe and waiting for a first unlock from said second process;
writing the nonlinear analysis data obtained by the nonlinear analysis and the linear analysis data obtained by the linear analysis into the shared memory in response to detection of the first unlocking;
writing the number of iterations of the nonlinear analysis and the number of iterations of the linear analysis into the shared memory;
connecting to said second named pipe and waiting for a second unlock from said second process;
7. The information processing program according to any one of appendices 2 to 6, wherein the inference result is obtained from the second named pipe in response to the second unlocking.
(Appendix 8)
The second processing is
connecting to the first named pipe and unlocking the first named pipe;
reading the linear analysis data and the nonlinear analysis data from the shared memory in response to a request from the first process, obtaining the residual transition and the operation time from each, and obtaining the trained inference model; to infer the residual threshold,
Appendix 7, connecting to the second named pipe, writing inference results from the trained inference model to the second named pipe, and unlocking the second named pipe. The information processing program described in .
(Appendix 9)
The first process is performed by a first processor executing a first program in a procedural language for scientific computing,
The second process is performed by the first processor executing a second program in a script language different from the first program,
9. The information processing according to any one of appendices 1 to 8, wherein the inference model is performed by the second processor, which is different from the first processor, executing a program written in a deep learning language. program.
(Appendix 10)
one or more computers
performing a first process of repeating a linear analysis to perform a nonlinear analysis;
Residual threshold used for determining convergence of the linear analysis by the inference model based on the residual transition and computation time for each iteration of the linear analysis obtained for each residual threshold with a plurality of experimental values in the first process and a second process for inferring
An information processing method, wherein data is transferred between the first process and the second process by inter-process communication using a shared memory set in a memory.
(Appendix 11)
memory;
and one or more processors connected to the memory, the one or more computers comprising:
a first process of repeating linear analysis to perform nonlinear analysis;
Residual threshold used for determining convergence of the linear analysis by the inference model based on the residual transition and computation time for each iteration of the linear analysis obtained for each residual threshold with a plurality of experimental values in the first process and a second process for inferring
An information processing apparatus, wherein data is transferred between the first process and the second process by inter-process communication using a shared memory set in the memory.

2 problem data 3 candidate threshold 3ref reference threshold 4a execution log 4d residual curve data 5 simulation result 6a input data 6g learning data 11 CPU
12 Main memory 12a Shared memory 12m-1 CM area 12m-2 ML area 12p Named pipe area 12v OS virtual memory 13 Disk 14g GPU
14m GPU memory 15 input device 16 display device 17 communication I/F
18 drive unit 19 storage medium 30 simulation unit 32 nonlinear analysis unit 34 linear analysis unit 40 machine learning unit 50 learning unit 60 inference unit 230 high performance application 232 high performance application 204d simulation data 100 information processing device

Claims (10)

on one or more computers,
Execute a first process of repeating linear analysis to perform nonlinear analysis,
Based on the residual transition and the computation time for each iteration of the linear analysis obtained for each residual threshold with a plurality of experimental values in the first process, the NN determines the residual threshold used to determine the convergence of the linear analysis. Execute a second process for inferring,
An information processing program, characterized in that data exchange between the first process and the second process is performed by inter-process communication using a shared memory set in a memory. The first processing is
storing the residual transition and the computation time for each iteration of the linear analysis in the shared memory and setting an address to a first named pipe;
obtaining the inference result of the NN written in the second process from a second named pipe;
The second processing is
obtaining the residual transition and the computation time from the address specified by the first named pipe in the shared memory;
making the NN learn to infer the residual threshold from the residual transition and a reference threshold determined from the residual transition and the computation time; 2. The information processing program according to claim 1, writing to a named pipe. The second processing is
setting the experimental value when the calculation time is the shortest as the reference threshold;
generating learning data by labeling the residual transition according to the result of comparing the experimental value used for each residual transition with the reference threshold;
3. The information processing program according to claim 2, wherein learning of said neural network is performed using said learning data. The second processing is
setting the experimental value when the calculation time is the shortest as the reference threshold;
determining a label for the residual transition according to a result of comparing the experimental value used for each residual transition with the reference threshold;
creating a plurality of input data by dividing the residual transition into certain intervals, assigning the determined label to each of the plurality of created input data to generate a plurality of learning data;
3. The information processing program according to claim 2, wherein learning of said neural network is performed using said plurality of learning data. The second processing is
The experimental value when the computation time is the shortest is specified for each problem data of the nonlinear analysis, and the first result obtained in the first process when using the specified experimental value; calculating the result error with each of the second results obtained in the first process when using the experimental value of
setting the reference threshold based on the result of comparing the result error and the execution time for each experimental value for each problem data;
determining a label for the residual transition according to a result of comparing the experimental value used for each residual transition with the reference threshold;
creating a plurality of input data by dividing the residual transition into certain intervals, assigning the determined label to each of the plurality of created input data to generate a plurality of learning data;
3. The information processing program according to claim 2, wherein learning of said neural network is performed using said plurality of learning data. The second processing is
Acquiring the inference result of inferring the residual threshold by the trained NN using the residual transition obtained by the first process in response to a call from the first process. , writing to said second named pipe as a return value to said first process;
6. The first process reads the inference result from the second named pipe, and uses the read inference result and a predetermined rate of change to update the residual threshold. 1. The information processing program according to 1. The first processing is
connecting to said first named pipe and waiting for a first unlock from said second process;
writing the nonlinear analysis data obtained by the nonlinear analysis and the linear analysis data obtained by the linear analysis into the shared memory in response to detection of the first unlocking;
writing the number of iterations of the nonlinear analysis and the number of iterations of the linear analysis into the shared memory;
connecting to said second named pipe and waiting for a second unlock from said second process;
7. The information processing program according to any one of claims 2 to 6, wherein the inference result is obtained from the second named pipe in response to the second unlocking. The second processing is
connecting to the first named pipe and unlocking the first named pipe;
In response to a request from the first process, read the linear analysis data and the nonlinear analysis data from the shared memory, acquire the residual transition and the operation time from each, and load the trained NN inferring the residual threshold;
8. Connecting to said second named pipe, writing inference results by said trained neural network to said second named pipe, and unlocking said second named pipe. The information processing program described in . one or more computers
performing a first process of repeating a linear analysis to perform a nonlinear analysis;
Based on the residual transition and the computation time for each iteration of the linear analysis obtained for each residual threshold with a plurality of experimental values in the first process, the NN determines the residual threshold used to determine the convergence of the linear analysis. performing a second process for inferring,
An information processing method, wherein data is transferred between the first process and the second process by inter-process communication using a shared memory set in a memory. memory;
and one or more processors connected to the memory, the one or more computers comprising:
a first process of repeating linear analysis to perform nonlinear analysis;
Based on the residual transition and the computation time for each iteration of the linear analysis obtained for each residual threshold with a plurality of experimental values in the first process, the NN determines the residual threshold used to determine the convergence of the linear analysis. performing a second process for inferring,
An information processing apparatus, wherein data is transferred between the first process and the second process by inter-process communication using a shared memory set in the memory.

Images