(BETA) Autoencoder (New)

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


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.


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. 

  1. Instantly predicting the performance of a 3D design you have created yourself.
  2. 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 stoppingIf 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 SmoothingMesh 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.


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

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.

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

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


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:  

Failure Effects


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


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 


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


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

Was this article helpful?

That’s Great!

Thank you for your feedback

Sorry! We couldn't be helpful

Thank you for your feedback

Let us know how can we improve this article!

Select atleast one of the reasons
CAPTCHA verification is required.

Feedback sent

We appreciate your effort and will try to fix the article