Optimization Using a Surrogate Model

This sample demonstrates how to use Femtet to create training data and optimize using surrogate models.

Sample Files

Note

Keep the sample project, sample script 1 to create training data with Femtet and sample script 2 to make a surrogate model without Femtet and optimize on same folder.

How to run this Sample

When you double-click on gal_ex13_create_training_data.py, the creation of training data for the surrogate model using Femtet will begin.

Once the number of Femtet analysis executions exceeds approximately 100, please double-click on gal_ex13_optimize_with_surrogate.py to run it. (The optimization results at the bottom of the page are based on a model created from 100 analysis data points.)

Note

Since the surrogate model optimization requires no Femtet execution, you can run gal_ex13_optimize_with_surrogate.py during running gal_ex13_create_training_data.py without any additional Femtet license.

Tip

What’s Surrogate Model?

The surrogate model handled by PyFemtet is a machine learning model that predicts values of the objective function for unknown design variables by learning a set of known design variables and objective functions.

Generally, to create high-quality training data, more FEM analysis data is required than what is typically needed for regular optimization, as mentioned in the examples. However, once training data has been created, it allows for very fast calculations of the objective function.

Therefore, in situations where the items for design variables and objective functions are somewhat fixed and problems frequently arise with varying ranges or target values, it becomes possible to quickly approximate design variables that meet desired target values.

Note

For details on the FEM problem, please refer to FemtetHelp / Examples / Stress Analysis / Example 13.

Design Variables

Appearance of the Model

Variable Name	Description
length	Length of the tuning fork
width	Thickness of the tuning fork
base_radius	Thickness of the base (fixed in optimization)

Objective Function

• First resonance frequency (aim to 1000 and 2000)

Sample Code

gal_ex13_create_training_data.py

import os
from time import sleep

from optuna.samplers import RandomSampler

from pyfemtet.opt import FEMOpt, FemtetInterface, OptunaOptimizer


def get_res_freq(Femtet):
    Galileo = Femtet.Gogh.Galileo
    Galileo.Mode = 0
    sleep(0.01)
    return Galileo.GetFreq().Real


if __name__ == '__main__':

    os.chdir(os.path.dirname(__file__))

    # Connect to Femtet.
    fem = FemtetInterface(
        femprj_path='gal_ex13_parametric.femprj',
    )

    # Initialize the optimization object.
    # However, this script is not for optimization;
    # instead, it is for creating training data.
    # Therefore, we will use Optuna's random sampling
    # class to select the design variables.
    opt = OptunaOptimizer(
        sampler_class=RandomSampler,
    )

    # We will set up the FEMOpt object. 
    femopt = FEMOpt(
        fem=fem,
        opt=opt,
    )

    # Set the design variables.
    femopt.add_parameter('length', 0.1, 0.02, 0.2)
    femopt.add_parameter('width', 0.01, 0.001, 0.02)
    femopt.add_parameter('base_radius', 0.008, 0.006, 0.01)

    # Set the objective function. Since this is random
    # sampling, specifying the direction does not affect
    # the sampling.
    femopt.add_objective(fun=get_res_freq, name='First Resonant Frequency (Hz)')

    # Create the training data.
    # If no termination condition is specified,
    # it will continue creating training data until
    # manually stopped.
    # To refer to history_path in the optimization script, we will
    # specify a clear CSV file name.
    femopt.set_random_seed(42)
    femopt.optimize(
        history_path='training_data.csv',
        # n_trials=100
    )

gal_ex13_optimize_with_surrogate.py

import os

from optuna.samplers import TPESampler

from pyfemtet.opt import FEMOpt, OptunaOptimizer
from pyfemtet.opt.interface import PoFBoTorchInterface


def main(target):

    os.chdir(os.path.dirname(__file__))

    # Instead of connecting with Femtet, create
    # a surrogate model. Read the CSV file created
    # by the training data creation script to build
    # the surrogate model.
    fem = PoFBoTorchInterface(
        history_path='training_data.csv'
    )

    # Set up the optimization object.
    opt = OptunaOptimizer(
        sampler_class=TPESampler,
    )

    # Set up the FEMOpt object.
    femopt = FEMOpt(
        fem=fem,
        opt=opt,
    )

    # Set up the design variables.
    # The upper and lower limits can differ from
    # those in the training data creation script,
    # but please note that extrapolation will
    # occur outside the range that has not been
    # trained, which may reduce the prediction
    # accuracy of the surrogate model.
    femopt.add_parameter('length', 0.1, 0.02, 0.2)
    femopt.add_parameter('width', 0.01, 0.001, 0.02)

    # If there are parameters that were set as
    # design variables during training and wanted
    # to fix during optimization, specify only the
    # `initial_value` and set the `fix` argument True.
    # You cannot add design variables that were not
    # set during training for optimization.
    femopt.add_parameter('base_radius', 0.008, fix=True)

    # Specify the objective functions set during
    # training that you want to optimize.
    # You may provide the fun argument, but it will
    # be overwritten during surrogate model creation,
    # so it will be ignored.
    # You cannot use objective functions that were
    # not set during training for optimization.
    obj_name = 'First Resonant Frequency (Hz)'
    femopt.add_objective(
        name=obj_name,
        fun=None,
        direction=target,
    )

    # Execute the optimization.
    femopt.set_random_seed(42)
    df = femopt.optimize(
        n_trials=50,
        confirm_before_exit=False,
        history_path=f'optimized_result_target_{target}.csv'
    )

    # Display the optimal solution.
    prm_names = femopt.opt.history.prm_names
    obj_names = femopt.opt.history.obj_names
    prm_values = df[df['optimality'] == True][prm_names].values[0]
    obj_values = df[df['optimality'] == True][obj_names].values[0]

    message = f'''
===== Optimization Results =====
Target Value: {target}
Prediction by Surrogate Model:
'''
    for name, value in zip(prm_names, prm_values):
        message += f'  {name}: {value}\n'
    for name, value in zip(obj_names, obj_values):
        message += f'  {name}: {value}\n'

    return message


if __name__ == '__main__':
    # Using the surrogate model created from the training data,
    # we will find a design that results in a resonant frequency of 1000.
    message_1000 = main(target=1000)

    # Next, using the same surrogate model,
    # we will find a design that results in a resonant frequency of 2000.
    message_2000 = main(target=2000)

    print(message_1000)
    print(message_2000)

Execution Result of the Sample Code

Optimization result (target: 1000 Hz)

Optimization result (target: 2000 Hz)

The design variables for a tuning fork with first resonance frequencies of 1000 or 2000 were explored using a surrogate model. The resulting design variables are listed in the upper right corner of the figure.

Using these design variables, we recreated the model in Femtet and executed analyses, with results shown in the lower right corner of each figure, allowing for comparison between the surrogate model and FEM results.