(BETA) Autoencoder (New)

Modified on Wed, 27 Sep, 2023 at 2:02 PM

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.

3D Training Data	This 3D dataset contains your historic designs which you wish parameterise.
3D Test Data (optional)	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.
Number of model training steps	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	Critical - The representation the current model learns is very sensitive to model orientation. We currently have no way of enforcing a canonical orientation.
Centre	Geometrically similar meshes should have a common origin	Medium - We centre meshes automatically to their bounding box centre. However, this may not be optimal for some datasets 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.	Low - We automatically scale mesh bounding boxes to the unit cube. 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.

More on this step

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).