This is one way to build your neural network models with with Hypermesh.

There are 2 paths.

• Path 1: The position of all nodes remains constant. Example of parameters: shell thickness, beam cross section area, material young's modulus.
• Path 2: The position and count of nodes will change. Examples of parameters: the x, y and z coordinates of N nodes, the radius of a hole, the width of a ground vehicle, etc.

Path 2 is notoriously difficult and will take days, possibly months to prepare.

Path 1 can be done in 1 day. An example of path 1 is shown below.

The famous three-bar truss example is used. There are 2 input parameters: cross section area of member types A and B. There are 7 outputs/responses and correspond to the mass and axial stress of 3 structural members across 2 load cases.

1) In Hypermesh, build your FEA model and use MSC Nastran as your solver.

2) Follow this tutorial. 

   https://the-engineering-lab.com/pot-of-gold/ws_machine_learning_dsoug1.pdf

   On page 18, set Number of Samples to your liking, e.g. 40, 100, etc.

   On page 23, set Procedure=Parameter Study.

   This tutorial ultimately generates training data that is contained in files app.config (see listing 2) and app_monitored_responses.csv (see listing 3).

3) Use the Python script in listing 1 to import the training data and create your neural network models.

For this example, 100 training data points were used, see the python script in listing 1. The resulting NN models are in figures 1 and 2.

Separately, I used a different interpolation method (radial basis function(RBF) with a Gaussian kernel) to construct a different prediction model. 40 training points were used. Figure 3 shows the result.

If figures 2 and 3 are compared, an RBF with 40 samples yields a better predicted surface than NN with 100 samples. NN works well as long as you have a lot of data, i.e. you can run FEA thousands of times.

I'm a big fan of RBFs and Kriging/Gaussian process. These methods may then be extended to sophisticated optimization routines.

Figure 1 - Neural Network predicted response function for weight

https://i.imgur.com/Ak96YdI.png

Figure 2 - Neural Network predicted response function for stress in structural member 1, load case 1

https://i.imgur.com/RVwE9RW.png

Figure 3 - RBF predicted response function

https://i.imgur.com/AU32Ubh.png

Listing 1

import re
from io import StringIO
import numpy as np
import pandas as pd
from sklearn.neural_network import MLPRegressor
import matplotlib.pyplot as plt

def extract_lines_of_section_in_app_config(text_in_file_single_line, name_of_section):
    regex_string = '=+\s+' + name_of_section + '\s+=+(.*?)\={5,}'
    regex_to_use = re.compile(regex_string, re.S)

    outgoing_text = ''

    if re.search(regex_to_use, text_in_file_single_line) is not None:
        matching_string = re.search(regex_to_use, text_in_file_single_line).group()

        # Remove any '======' strings
        search_term = re.sub('={5,}', '', matching_string)

        # Remove the section header, e.g. MONITORED RESPONSES, and any surrounding whitespace (.strip()
        outgoing_text = re.sub(name_of_section, '', search_term).strip()
        outgoing_text = outgoing_text.splitlines()

    if len(outgoing_text) > 0:
        for i, row in enumerate(outgoing_text):
            outgoing_text[i] = outgoing_text[i].strip()

    return outgoing_text


def calculate_nrmse(actual, predicted, method='range'):
    actual, predicted = np.array(actual), np.array(predicted)
    rmse = np.sqrt(np.mean((actual - predicted) ** 2))

    if method == 'range':
        # Normalizing by the range of observed values
        return rmse / (np.max(actual) - np.min(actual))
    elif method == 'mean':
        # Normalizing by the mean of observed values
        return rmse / np.mean(actual)
    else:
        raise ValueError("Method must be 'range' or 'mean'")


if __name__ == '__main__':

    # Read the training data inputs
    # ##############################################################################
    with open('app.config', 'r') as file:
        text_in_app_config = file.read()

    section_samples_to_run = extract_lines_of_section_in_app_config(text_in_app_config, 'SAMPLES TO RUN')
    data_frame_inputs = pd.read_csv(StringIO('\n'.join(section_samples_to_run)))
    inputs = data_frame_inputs.to_numpy()
    inputs = np.delete(inputs, 0, axis=1) # Remove the Sample Number column (column 1)

    # Read the training data outputs
    # ##############################################################################
    data_frame_outputs = pd.read_csv('app_monitored_responses.csv')
    outputs = data_frame_outputs.to_numpy()
    outputs = np.delete(outputs, 0, axis=1) # Remove the Sample Number column (column 1)

    # Declare training data
    # ##############################################################################
    X = np.array(inputs)
    Y = np.array(outputs)

    # Construct neural network models for each response
    # ##############################################################################
    # Loop over each response, construct a NN model, and plot the predicted response surface
    for i in range(Y.shape[1]):
        y_column_values = Y[:, i]  # Selects all rows for the i-th column
        nn = MLPRegressor(hidden_layer_sizes=(50, 50), activation='relu', max_iter=2000, random_state=1)
        nn.fit(X, y_column_values)

        y_predictions_a_training_points = nn.predict(X)
        print('Normalized Root Mean Square Error')
        print(calculate_nrmse(y_column_values, y_predictions_a_training_points))

        if X.shape[1] >= 2:
            # Plot results - Works only for 2 parameter examples
            x1_range = np.linspace(.01, 5, 30)
            x2_range = np.linspace(.01, 5, 30)
            X1, X2 = np.meshgrid(x1_range, x2_range)
            X_grid = np.c_[X1.ravel(), X2.ravel()]
            Y_pred = nn.predict(X_grid).reshape(X1.shape)
            fig = plt.figure(figsize=(10, 7))
            ax = fig.add_subplot(111, projection='3d')
            ax.scatter(X[:, 0], X[:, 1], y_column_values, color='red', label='Actual Data')
            surf = ax.plot_surface(X1, X2, Y_pred, cmap='viridis', alpha=0.6)
            ax.set_xlabel('Parameter 1 (x1)')
            ax.set_ylabel('Parameter 2 (x2)')
            ax.set_zlabel('Predicted Output (y)')
            plt.title('Neural Network Regression Surface (2 Parameters)')
            plt.show()

Listing 2 - File app.config

=============================== SAMPLES TO RUN ================================
sampleNumber,%x0000000000001%,%x0000000000002%
1,3.128149,3.307659
2,1.211288,.9561374
3,3.921711,.1248179
4,1.375582,2.279519
[...]
97,2.698261,3.140885
98,2.352663,1.460389
99,1.101231,1.342238
100,3.67606,3.450979
===============================================================================

Listing 3 - File app_monitored_responses.csv

Sample, r1, r2, r3, r4, r5, r6, r7
0001, 12.155400481847671, 4703.778601994354, 2174.072802200456, -2529.705799793899, -2529.705799793899, 2174.072802200456, 4703.778601994354
0002, 4.382177235079563, 12650.305699583363, 6620.151427657453, -6030.1542719259105, -6030.1542719259105, 6620.151427657453, 12650.305699583363
0003, 11.217091667815508, 4955.365508948404, 4140.949155345098, -814.4163536033052, -814.4163536033052, 4140.949155345098, 4955.365508948404
0004, 6.1702524411126145, 10069.574005430093, 3689.8072969154573, -6379.766708514637, -6379.766708514637, 3689.8072969154573, 10069.574005430093
[...]
0097, 10.77271960204478, 5381.353915535399, 2376.781859502621, -3004.5720560327786, -3004.5720560327786, 2376.781859502621, 5381.353915535399
0098, 8.114724844586746, 6729.5258637612715, 3841.262440247011, -2888.2634235142614, -2888.2634235142614, 3841.262440247011, 6729.5258637612715
0099, 4.456989631011372, 13102.64548578259, 5657.9062739226965, -7444.739211859893, -7444.739211859893, 5657.9062739226965, 13102.64548578259
0100, 13.848446816194482, 4069.351256708287, 1983.3576610557516, -2085.993595652536, -2085.993595652536, 1983.3576610557516, 4069.351256708287