## Description

Autoencoders are powerful AI models which automatically parameterise a dataset of 3D designs. The autoencoder learns to compress the geometric shape information in your designs into a small number of latent parameters. The latent space parameters are then like the DNA of your 3D designs: every existing design has a specific set of latent space values; and similar unseen designs can be generated by exploring new sets of latent space values. This step returns both an encoder model (to parametrise a geometry) and a decoder model (to generate a geometry from numerical latent parameters).

### How does this differ from the “Autoencoder: Parts 1, 2, & 3” steps?

Our new Autoencoder is an iterative improvement on our previous one. The main differences are:

- The previous Autoencoder relied on voxelisation as a necessary pre-processing step to “scan” 3D meshes before modelling. Voxelising a mesh means producing a discrete approximation of it as a 64x64 cubic grid. This means details in the meshes (which might have a high impact of design performance) couldn't be encoded.
- The reliance on voxelisation also meant that decoded designs didn't have a smooth surface, which can cause issues when wanting to export performance-optimised generated by a Decoder.
- Training the previous Autoencoder required running three separate manipulators successively. The new one is contained within a single one.

## Application

Although Machine Learning can be used for a wide range of applications, it is currently mainly used on tabular or numerical data. Models like Random Forests or Neural Networks learn from numbers to predict numbers. However, for engineering applications, CAD files are one of the most widely used data formats, and they are often the only design data available. Autoencoders enable you to learn from your CAD data, by parametrising CAD datasets and linking this parametric data to performance data.

In the Monolith platform, Autoencoders are commonly used for two applications.

- Instantly predicting the performance of a 3D design you have created yourself.
- Generating new performance-optimised 3D designs.

For either application, you should follow the steps below to train your Autoencoder model.

## How to use

This feature requires 3D data. Use the 3D Data Loader to load a dataset of 3D meshes in your notebook. Then, configure these parameters within the Autoencoder step.

| This 3D dataset contains your historic designs which you wish parameterise. |

| The Autoencoder, unlike other deep learning models such as Neural Networks, doesn't need to rely on producing a train/validation split to be trained. As such, by default, it will utilise all the 3D Training Data available. However, we understand you may wish to specify a test dataset against which the model will iteratively be evaluated as it is being trained. If you do not specify 3D Test Data, there will be no validation loss curve, and no early stopping since there will be no method of assessing criteria for it. To create a 3D Test dataset, we encourage you to use the Train-Test Split manipulator. |

| Choosing a high number of training steps will increase training time but will produce a more accurate model. |

Encoder Name | The Encoder Model produced by this step can be used to transform a geometry in a list of latent parameters. |

Decoder Name | The Decoder Model produced by this step can be used to generate a new geometry from a new list of latent parameters. These parameters can be set manually or identified through an optimisation process. |

Early stopping | If early stopping is enabled, the incremental training of the model will be monitored to understand when loss curves have converged - meaning that the model has maximised learning, and running additional training steps will not improve its accuracy. This avoids you wasting time waiting for remaining training steps to complete even after a model has maximised learning. |

Meshelizer Resolution | The Autoencoder uses a series of pre-processing steps to scan/codify each 3D mesh before training. Configuring a resolution for the meshelizer means having control over how much detail is extracted from each 3D mesh during this pre-training process. A finer resolution means longer training time but more accruate parameterisation. |

Mesh Smoothing | Mesh Smoothing is a post-processing part of the Decoder Model, to improve the surface of 3D meshes generated by it. Changing the value of Mesh Smoothing will not have any impact on Encoding. |

After running the Autoencoder step, you will have both a Decoder and an Encoder.

The Encoder model is used to parameterise the geometric information of new 3D meshes into the latent parameters. The Decoder model uses new combination of latent space parameters to generate new 3D meshes.

To know more about how to assess the quality of an Autoencoder, click here.

## Requirements on 3D data

The performance of the auto encoder model relies crucially on the quality of the 3D input it receives. Input quality can be categorised at the Dataset level and the Mesh level.

**Dataset:**

Meshes should adhere to the following specifications at the dataset level:

Property | Description | Severity |

Orientation | All meshes should be oriented canonically i.e. geometrically similar meshes in the dataset should be facing in the same direction |
We currently have no way of enforcing a canonical orientation. |

Centre | Geometrically similar meshes should have a common origin |
This renders translation based data augmentation as ineffectual. The learnt representations will also not contain translation information. If translation is important for down stream tasks then it should be appended manually to the latent representation. |

Scale | Similar geometries should not have different scales. |
This renders scaling based data augmentation as ineffectual. The learnt representations will also not contain scale information. If scale is important for down stream tasks then it should be appended manually to the latent representation. |

**Mesh:**

The geometry should have a well defined inside and outside in order for the model to output proper reconstructions. Each input therefore, should be a manifold triangular mesh and satisfy the following criteria:

Criteria | Description | Failure Effects | Mitigation |
---|---|---|---|

Triangular | The input should be composed exclusively of triangular polygons | The underlying ground truth cannot be calculated at all and no training is possible | Ensure that geometries are exported as STL files |

Watertight | There should be no missing faces in the geometry. These can be obvious but more often are small defects | The input would not have a well defined inside/outside and the reconstructions may have artefacts or fail entirely. | Fix any large missing faces in CAD software and export to STL with smaller tolerance to prevent small defects |

Oriented | Each triangle in the mesh should be oriented consistently either clockwise or anticlockwise Inconsistent triangle orientations mean that there may be patches of the geometry where inside/outside is flipped | The input would not have a well defined inside/outside and the reconstructions may have artefacts or fail entirely. | If possible ensure the consistent orientation option is selected when exporting to STL |

Intersections | This amounts to having triangles defined inside the volume of a geometry. Examples include: tetrahedral meshes used for FEM, unjoined geometries that pass through each other, features inside the external geometry | The inside faces will interfere with the ground truth value calculation and produce artefacts such as extra faces on the outside or undesired holes in the surface | Remove any inside geometry and perform a union of all solids before exporting to STL. Do not directly use FEM meshes, but process them in appropriate CAD software to extract only the surface faces. |

An Autoencoder is a mathematical tool that shares some similarities with a neural network as it contains different layers. When training an auto-encoder, the main aim is to be able to “compress” the data from the full geometry (X, Y, Z for every point) to a relatively small set of parameters, and then being able to “decompress” the data back to the initial geometry. As a result, an auto-encoder will be made of two parts: (i) an Encoder, which transform the geometry into parameters, and (ii) a Decoder, which transforms the parameters into geometries.

The main layers are:

- An input layer (in blue), which gathers all the inputs (generally X, Y, Z coordinates) of the design.
- A latent layer containing the latent parameters (in red). The size of this layer corresponds to defined the
**number of latent parameters**to represent all 3D designs. - An output layer (in yellow), which is similar to the input layer.

If the latent layer is too small, it won’t be able to “compress” the designs properly, and the reconstructed designs (output) will not be similar to the initial design (input layer). The aim is to find a number of parameters as small as possible, but big enough to contain all the information of the design. These parameters can then be used for new predictions or optimisation (see Tutorial series 3).

Was this article helpful?

That’s Great!

Thank you for your feedback

Sorry! We couldn't be helpful

Thank you for your feedback

Feedback sent

We appreciate your effort and will try to fix the article