user: text: Write a concise one-sentence TLDR summary of the scientific paper content below.

Title: Unsupervised Learning of Automotive 3D Crash Simulations using LSTMs

Paper content:
Long short-term memory (LSTM) networks allow to exhibit temporal dynamic behavior with feedback connections and seem a natural choice for learning sequences of 3D meshes.
We introduce an approach for dynamic mesh representations as used for numerical simulations of car crashes.
To bypass the complication of using 3D meshes, we transform the surface mesh sequences into spectral descriptors that efficiently encode the shape.
A two branch LSTM based network architecture is chosen to learn the representations and dynamics of the crash during the simulation.
The architecture is based on unsupervised video prediction by an LSTM without any convolutional layer.
It uses an encoder LSTM to map an input sequence into a fixed length vector representation.
On this representation one decoder LSTM performs the reconstruction of the input sequence, while the other decoder LSTM predicts the future behavior by receiving initial steps of the sequence as seed.
The spatio-temporal error behavior of the model is analysed to study how well the model can extrapolate the learned spectral descriptors into the future, that is, how well it has learned to represent the underlying dynamical structural mechanics.
Considering that only a few training examples are available, which is the typical case for numerical simulations, the network performs very well.
Data driven virtual product design is nowadays an essential tool in the automotive industry saving time and resources during the development process.
For a new car model, numerical crash simulations are performed where design parameters are changed to study their effects on physical and functional properties of the car such as firewall intrusion, weight, or cost (Fang et al., 2017) .
Since one simulation run takes a couple of hours on a compute cluster, running a large number of simulation is not feasible.
Therefore, a system that is able to use a limited dataset and predict new simulations would make the development process faster and more efficient.
The rise of deep neural networks (DNNs) in recent years encourages further research and industrial usages.
Besides manifold research for autonomous driving, it is natural for the automotive industry to seek and evaluate the possible applications of DNNs also in the product design stages.
As an example, we investigate car crash tests, in which for example the plate thickness of certain parts strongly influences the bending behavior of structural beams and as a result also the intrusion of the firewall into the passenger compartment.
Here, numerical crash simulations for different variations of such thicknesses are used as a dataset for learning.
The aim is to design a system based on a DNN architecture that learns the crash behavior and would be able to imitate the crash dynamics.
Car crash simulations are based on a mathematical model of the plastic deformations and other physical and mechanical effects.
They are defined on a computing mesh of currently up to three million points and up to a hundred time steps are stored.
Each data instance is a simulation run-of pre-selected parts and/or time steps-that is very high dimensional.
Working with this data directly exasperates any machine learning (ML) method, but a transformation of this data presented in IzaTeran & Garcke (2019) allows to obtain a new representation that uses only a small number of coefficients to represent the high resolution numerical solutions.
The transformed representation is employed here to compress the mesh geometries to feature sets suitable for neural networks, while avoiding to directly handle geometries in the machine learning method.
This way, a network designed for video prediction and embedding based on a long short-term memory (LSTM) based architecture (Srivastava et al., 2015) can be adapted for mesh data.
Since LSTM is a recurrent neural network that allows to exhibit temporal dynamic behavior with feedback connections, it is a natural choice for learning the 3D sequences.
The aim is that the network learns the observed crash behavior including translation, rotation, or deformation of the parts in the model.
Since the contribution of this paper is using DNNs for analyzing car crash data, the related works are categorized into a group of publications in which DNNs are extended for 3D graphics and one that concerns the use of ML techniques for analyzing car crash simulations.
For the latter, one typically uses different embedding techniques to obtain a low dimensional representation for the intrinsic underlying data space and to cluster simulations with similar characteristics together (Bohn et al., 2013; Diez, 2018; Garcke & Iza-Teran, 2015; Iza-Teran & Garcke, 2019; Le Guennec et al., 2018) .
The majority of publications about 3D DNN tried to extend CNN for 3D space and focus on description learning and shape correspondence, also known as geometric deep learning, Monti et al., 2017; Litany et al., 2017; Halimi et al., 2018; Maturana & Scherer, 2015; Su et al., 2015; Wang et al., 2017) and some developed CNN filters for unorganized point clouds (Qi et al., 2017a; b) .
The very active research is so far very compute resource consuming and there is no extension of ConvLSTM for 3D space to our knowledge, but for prediction one would need an LSTM (or GAN) approach.
However, a couple of very recent works introduce new feature sets and architectures for mesh embedding using autoencoders and LSTM (Tan et al., 2018b; Qiao et al., 2018; Tan et al., 2018a) .
The feature representation is using local shape deformations obtained by solving an optimization problem at each node and a global optimization for compensating for rotations.
They have shown that after training the network, a sequences of 3D shapes as an animation can be generated by doing operations in the latent space.
The bidirectional LSTM architecture is shown to outperform autoeconders (Tan et al., 2018a ).
An LSTM based learning network has also been proposed in Qiao et al. (2018) , where the obtained feature representation is then taken as the temporal data to be feed into a CNN that takes the features and represents them in a lower dimensional latent space.
This information is subsequently feed into the LSTM module.
Video frames prediction has been in the center of attention of researchers for a while, but there has been only very few extensions of these works to the 3D case so far.
The problem is addressed here by introducing spectral coefficients to encode functions on the geometry together with a two branch LSTM based architecture without any convolutional layer, which has already proven to be feasible for video embedding and future frames prediction.
The employed LBO basis and the resulting spectral coefficients provide a trade-off between accuracy and required computational resources.
We encode the 3D shapes by a set of features using the eigenvectors of the LBO.
For empirical evaluation, a dataset is employed from a set of numerical simulations of a car during crash under different design conditions, i.e. plate thickness variations.
The appearance of a bifurcation during the crash in the dataset, motivates an error analysis done for both groups to see how good the network performs in the presence of a bifurcation.
In both branches, the network is able to perform very good predictions, while we observe different error localisations for reconstruction versus prediction.
Moreover, the 2D visualization of the reconstruction branch shows the bifurcation as two clusters.
In any case, from a relatively small number of data, the proposed network using spectral coefficients is able to learn complex dynamical structural mechanical behaviors.
Future work could go toward scaling the pipeline for learning the crash dynamics of the entire car and larger mesh sizes, which increases the needed computational effort.
On the other hand, one might be able to use smaller number of eigenvectors by not simply selecting the first few ones, but those with a large variance in the spectral coefficients of the data set.
Furthermore, in practical settings, re-meshing of the parts can take place, here using spectral coefficients can ease this step since one can encode shapes with different vertices number to fixed size feature vectors, as long as the geometry is (approximately) isometric.
Still, there is the overall question, if and how a trained network can be evaluated for changed geometries (relevant question for any 3D DNN approach introduced so far) or different crash setups.
Moreover, adding design parameters could also improve the accuracy but requires modifications of the networks architecture.
For practical applications, as each crash simulation requires hours of heavy computation running computational solvers on a large cluster, a system that is able to learn the representation of experiments with very few training data and generate the predicted simulation results for new design parameters would save much resources.
Moreover, the ultimate goal of research along this direction would be a data driven system that receives very little information about the simulation (like design parameters) and output the crash sequences with minimum error.
Another application of the current system could be feasibility detectors while running the simulation on the compute cluster.
Using the network, one could check if the simulation goes well or if for some reasons it should be terminated.
From the current stage of the system, one would be able to generate the parts of the future simulation simply by extrapolating the learned spectral coefficients from a few initial time steps, which are already computed on the cluster, as inputs.
If the distance between network predicts and simulation gets very large over the iterations, the simulation can be terminated since it failed the feasibility check.
Further, related works such as Qiao et al. (2018) introduce a specific feature set and LSTM autoencoders, where also graph convolution operation is required.
This approach could be applied for car crash data under the assumption that the local optimization can still be applied for large deformations as the ones occurring in our applications.
Further, the resulting features are long vectors, which results in 8 hours for learning on a CPU/GPU system for a data set similar in size to ours, where we need 30 minutes.
Nevertheless, a comparison of these two approach will be worthwhile future work.
A APPENDIX time step 6 time step 7 time step 8 time step 9 time step 10 time step 6 time step 7 time step 8 time step 9 time step 10

assistant: text: A two branch LSTM based network architecture learns the representation and dynamics of 3D meshes of numerical crash simulations.