Abstract
Testing new, innovative technologies is a crucial task for safety and acceptance. But how can new systems be tested if no historical real-world data exist? Simulation provides an answer to this important question. Classical simulation tools such as event-based simulation are well accepted. But most of these established simulation models require the specification of many parameters. Furthermore, simulation runs, e.g., CFD simulations, are very time consuming. Generative Adversarial Networks (GANs) are powerful tools for generating new data for a variety of tasks. Currently, their most frequent application domain is image generation. This article investigates the applicability of GANs for imitating simulations. We are comparing the simulation output of a technical system with the output of a GAN. To exemplify this approach, a well-known multi-car elevator system simulator was chosen. Our study demonstrates the feasibility of this approach. It also discusses pitfalls and technical problems that occurred during the implementation. Although we were able to show that in principle, GANs can be used as substitutes for expensive simulation runs, we also show that they cannot be used "out of the box". Fine tuning is needed. We present a proof-of-concept, which can serve as a starting point for further research.
Introduction
Testing innovative hardware, such as cable-less multi-car elevators powered by linear motors, presents a significant data challenge. Optimizing control algorithms requires massive datasets, yet real-world data is unavailable until the system is fully operational. While traditional event-based simulators like MceSim provide a solution, they are often computationally expensive and slow. This research explores the use of Generative Adversarial Networks (GANs) as high-speed emulators to generate synthetic simulation logs, providing a faster alternative for system optimization and safety testing.
Methodology: GAN Architecture for Simulation
The proposed approach involves training a GAN to imitate the output of a technical simulator. The framework consists of two competing networks: a Generator and a Discriminator.
The Generator (G) is implemented as a character-level Recurrent Neural Network (RNN) using Long Short-Term Memory (LSTM) layers. A character-level approach was chosen to accommodate the unique IDs and timestamps found in elevator logs, which would be difficult to represent with a fixed word-level vocabulary. The Discriminator (D) utilizes a Convolutional Neural Network (CNN). Although RNNs are more common for sequence data, the CNN was selected for its superior training speed. In this architecture, the Discriminator's role is to distinguish between "real" logs from the MceSim simulator and "fake" logs produced by the Generator.
The Challenge of Discrete Data and the "Sampling Gap"
A primary hurdle in using GANs for text-based logs is the "sampling gap." Unlike image generation, where pixel values are continuous, text generation involves discrete characters. To pass data to the Discriminator, the Generator must sample a specific character from its output probability distribution.
As shown in the table above, the Generator outputs a distribution where one character (e.g., 'i') may have a high probability. However, the actual selection of that character is a non-differentiable step. This breaks the backpropagation of gradients from the Discriminator to the Generator, meaning the feedback from the Discriminator cannot easily be used to update the Generator's weights. This study highlights that while the Generator can learn the syntax of a log file (e.g., correct formatting and keywords), it struggles with the underlying semantics and logical consistency, such as ensuring timestamps are strictly increasing.
Results and Discussion
The standalone Discriminator proved exceptionally effective, reaching near-perfect accuracy almost immediately. While this demonstrates the stark differences between simulated and generated data, it also creates a training imbalance where the Discriminator provides little useful feedback to the Generator.
Quantitatively, the current GAN implementation faces an efficiency paradox: generating 1 million characters took 2.5 hours on a high-end GPU, whereas the original CPU-based simulator completed the task in just 10 minutes. Qualitatively, however, the Generator successfully produced correctly formatted strings, such as:
999762 - Unload call: c194291 on car_02_01 overtravel 0.
Conclusion and Future Work
This research provides a proof-of-concept for using GANs to emulate complex technical simulations. While the syntax of log files can be learned, maintaining logical and physical consistency remains a challenge. Future work will focus on bridging the sampling gap using Reinforcement Learning-based approaches like SeqGAN and incorporating structural constraints to ensure generated data adheres to the physical laws of the elevator system.
Summary updated