Paper deep dive
ModTrans: Translating Real-world Models for Distributed Training Simulator
Yi Lyu
Intelligence
Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 95%
Last extracted: 4/2/2026, 11:53:54 PM
Summary
ModTrans is a translator tool designed to bridge the gap between real-world machine learning models and distributed training simulators like ASTRA-sim. By converting models from the ONNX format into the layer-wise description files required by ASTRA-sim, ModTrans eliminates the need for manual configuration, enabling researchers to simulate distributed training performance efficiently.
Entities (5)
Relation Signals (3)
ModTrans → parses → ONNX
confidence 100% · ModTrans takes ONNX models and extracts the layer information for the ASTRA-sim.
ModTrans → translatesto → ASTRA-sim
confidence 100% · ModTrans, a translator supporting format translation from any real-world model to the ASTRA-sim simulator's input
ASTRA-sim → simulates → Distributed Training
confidence 90% · ASTRA-sim is a distributed training simulator designed to quickly simulate the training performance
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Large-scale distributed training has been a research hot spot in machine learning systems for industry and academia in recent years. However, conducting experiments without physical machines and corresponding resources is difficult. One solution is to leverage distributed training simulators, but current ones like ASTRA-sim do not support importing real-world developed models, which poses challenges for ML researchers seeking to use them. Based on this challenge, we developed ModTrans, a translator supporting format translation from any real-world model to the ASTRA-sim simulator's input, removing the barrier between machine learning experts and machine learning system researchers. The experiment results show that ModTrans's cost is negligible.
Tags
Links
- Source: https://arxiv.org/abs/2604.01607v1
- Canonical: https://arxiv.org/abs/2604.01607v1
Trouble viewing inline? Open PDF directly →
Full Text
26,090 characters extracted from source content.
Expand or collapse full text
ModTrans: Translating Real-world Models for Distributed Training Simulator Yi Lyu ∗ University of Wisconsin-Madison Madison, WI, USA ylyu76@wisc.edu Abstract Large-scale distributed training has been a research hot spot in machine learning systems for industry and academia in re- cent years. However, conducting experiments without phys- ical machines and corresponding resources is difficult. One solution is to leverage distributed training simulator. Cur- rent distributed training simulators like ASTRA-sim do not support the import from real-world developed models to the simulator, which poses challenges for ML researchers from using the simulator. Based on this challenge, We developed ModTrans, a translator supporting format translation from any real-world model to the ASTRA-sim simulator’s input. It removes the barrier between machine learning experts and machine learning system researchers. The experiment results show that ModTrans’s cost is negligible. 1 Introduction In recent years, machine learning training has become one of the most intensive workloads in data centers because of the increasing demands of machine learning applications and the complexity of the model itself. Giant models (or model experts) are considered the next-generation model, and training these models need intensive computational and communication resource. For example, a recent report from Google shows that the large model PaLM [7] is trained with 81Tbps for each training step, and it takes about 6144 TPU to participate in the training process. Replicating such models’ training on a large scale is ex- tremely difficult because of the huge amount of network and computation usage. This happens in both industry and academia. For industry, it is costly to train models without enough testing, potentially increasing the cost of deploy- ment and management. For academia, it is difficult for edu- cational institutions to acquire a training environment that could replicate the experiments, which poses a barrier to researchers conducting distributed training research. Distributed training simulator is a solution to the prob- lem above. ASTRA-sim is one of the main-stream machine learning simulators in this area. It simulates distributed train- ing by defining the network topology and the computation model, letting developers replicate the distributed training environment in a single machine. It frees users from running the distributed training job in a real machine environment and occupies the resources. However, these simulators are far away from mature. It is due to the fact that distributed training behavior is compli- cated, and the computation and communication modeling are sophisticated. For example, ASTRA-sim only takes model description files as input, which must be written and con- figured manually. In the real scenario, the simulations are conducted by machine learning system researchers, and the ML models are taken from the ML developer, which are two groups of people. Therefore, we think it is not a reasonable design that needs to be decoupled. In this paper, we developed ModTrans, a translator that would like any real-world models and extracted the nec- essary information needed from ASTRA-sim, making the ASTRA-sim supports simulation input directly taken from the model without manually configured. Our translator can also get classic models from the model zoo if users would like to use the simulator to simulate the model training, for example, ResNet50 and VGG16. Note that our translator is applicable to any simulator that takes layer-wise information as input to do simulation. ModTrans removes the barrier between machine learning experts and machine learning system researchers. Our ex- periment results show that ModTrans takes no more than 1 second to translate, and the translation results are identical to the ResNet50 model provided in the ASTRA-sim repository. 2 Background In this section, we will discuss the background. The first subsection introduces the basic concepts like parallelism types in distributed deep learning training [5,6,11]. The second subsection introduces the architecture of state-of-the- art distributed training simulators and the interface layer facing the user. In the final subsection, we introduce the Open Neural Network Exchange (ONNX), an open-source framework for representing AI models. 2.1 Distributed Deep Learning Training Training in giant models introduces new challenges to data centers. How to train models effectively with hundreds of or thousands of computational devices (GPU/TPU) becomes an interesting question. Nvidia’s state-of-the-art Megatron- LM [14] model takes 3072 GPUs across 384 machines to train their large model with the combination of different training approach parallelism[19]. arXiv:2604.01607v1 [cs.DC] 2 Apr 2026 Lyu Data parallelism and Model parallelism are two main paral- lelism strategies that widely use in the data center because of the simplicity of the programmable model. Data parallelism is parallelization across multiple nodes by distributing data into different nodes, which can compute based on data in parallel. Model parallelism is another parallelization method that partitions the deep learning model[12] across multiple devices, within or across instances. However, When models get larger and the architecture becomes more complex, we need to explore better solutions to accelerate the training efficiency. One approach is to combine different types of parallelism strategies within a model according to its charac- teristics. For example, some layers are too huge to fit into the rare GPU memory, and we need to split them into several partitions to train (model parallelism). Model parallelism introduces dependency problems among computational devices, potentially reducing the utilization of the computational devices. Gpipe [9] and Pipedream [13] in- troduce pipeline parallelism to increase device utilization by introducing the pipelining concept. For large model training, pipeline parallelism shows great performance improvement for huge data centers. The main insight from this line of work is trying to utilize workers’ GPUs as much as possi- ble, and they use different pipeline techniques to reduce the stall/bubble under naive execution. At the same time, it is particularly difficult to do large-scale research academically on machine learning systems based on limited resources without industrial support. For example, BytePS [10] system uses 256 GPUs to prove its scalability, and getting the testbed with this amount of GPUs is already a huge challenge for academics. Moreover, system researchers are also exploring different deep-learning platform designs to accelerate the distributed training process. To find the best spot in the large design space, they usually need to try multiple different configurations and test the training performance. However, it is impossible to achieve that when running training jobs on the real testbed, since each training process takes such long GPU-hours. It motivates the need for distributed training simulator that can estimate the training performance to help researchers explore different design choices. 2.2 ASTRA-sim As shown in Figure 1, deep learning platforms have super complex hardware (HW) and software (SW) design space. On the hardware side, multiple accelerators are intercon- nected in different topologies. For accelerators, FPGA, GPU, TPUs, and other special ASICs are now widely used for deep learning training. For interconnection topology, there are dif- ferent inter-package and intra-package fabrics with different bandwidths. In the software design space, there are different strategies for scheduling communication and computation. Figure 1. Deep Learning Platform Software (SW) and Hard- ware (HW) Design Space [16] For communication, the protocol and topology-aware collec- tives can be configured by users. The communication sched- uling can be configured as LIFO or FIFO. And the framework scheduling can be configured as synchronous or asynchro- nous, blocking or nonblocking. With increasingly large deep learning models, both academia and industry are trying to find the best distributed training platform design point inside this complex design space.ASTRA-sim[16] is a distributed training simulator designed to quickly simulate the training performance when navigating the design space. TheASTRA-simis a simulator consisting of multiple layers (network layer, system layer, and workload Layer). Figure 2 shows the high-level overview of the simulator components. Its network layer uses Garnet [4] to simulate the network behavior under different topologies and connectivity. It is mainly used to mainly simulate the communication stage when different nodes want to exchange information in the training process.ASTRA-simis also exploring supporting an- other more common network simulator ns-3, which is more flexible to configure different network protocols and com- munication patterns. The system layer provides topology- aware collective operations and generates traffic to the net- work layer. Also, it contains the scheduler component that pipelines the execution of the collectives across different links. Notice that the system layer deals with the logical topology while the network layer handles the actual net- work topology. The advantage here is that there could be a more flexible mapping between the logical and actual topolo- gies. The workload layer runs the training loop algorithms for the specified deep learning models and generates the sets of data to be communicated during each iteration of training. There are two parts of workload parameters: compute time and communication sizes. For the compute time, it can be extracted from the DNN simulator and GPU simulator for each layer operation. For the communication size, it depends on the parallelism types and also the model itself. The ASTRA-sim simulator takes the DNN description file as input and generates the sets of data to be communicated at different training steps. As shown in Figure 3, the de- scription file specifics the parallelism type and layer-wise ModTrans: Translating Real-world Models for Distributed Training Simulator Figure 2. Overview of ASTRAM-sim[16] Figure 3. DNN description file [16] information (computation & communication). For each layer inside the deep learning model, the description file contains the computation time, communication type, communication size, and local update time. Since deep learning models have more and more layers, it’s time-consuming for users to pro- vide the DNN description file. Also, there could be potential errors when users calculate this information manually. It needs an automatic translator to generate this kind of DNN description file based on model specifications. 2.3 ONNX Open Neural Network Exchange (ONNX) [3] is an open- source format for AI models, both deep learning and tradi- tional machine learning. The ONNX defines an extensible graph model and definitions of built-in operators and stan- dard data types. It is widely supported by many frameworks, tools, and hardware. There are many industry collaborators that use the ONNX format and put it into production. The core insight of ONNX is that deep learning with neu- ral networks is usually expressed as computation over the Figure 4. Visualization on ONNX dataflow graph. Some frameworks use static graphs (E.g., TensorFlow) while other frameworks use dynamic graphs (E.g., Pytorch) [2]. Each framework provides its own inter- face to construct the dataflow graphs. ONNX is designed to provide a common intermediate representation (IR) to represent the dataflow graph. It can be compared to a pro- gramming language specialized in mathematical functions. All the necessary operators are already defined in the ONNX framework. There are five parts inside the model expressed in the ONNX language: input, output, node, initializer, and attributes. The input defines the type of data that should be fed into the model in ONNX. Similarly, the output defines the type of data predicted by the model in ONNX. The initializer is used to store the constant parameters in the model, which won’t change based on the input. Nodes are the output of helper functions inside ONNX likeMatMulandAdd. Listing 1 is a linear regression that written in ONNX language [2] 1 def onnx_linear_regressor(X): 2 "ONNX code for a linear regression" 3 return onnx.Add(onnx.MatMul(X, coefficients), bias) Listing 1. Linear Regression written in ONXX Lyu Figure 5. Linear Regression ONNX Graph As shown in Figure 5, the linear regression example in ONNX represents a graph, which transforms features into ONNX graph [1]. TheAddandMatMulfunctions used in the Linear Regression model are corresponding nodes inside the ONXX graph. The arrow connecting different nodes shows the dataflow graph inside this deep learning model. The ONNX graph can be saved using protobuf to serialize the graph into one single block. It is used to optimize the model size as much as possible. The generated format can be directly loaded into mainstream deep-learning models. Also, some visualization tools can take this binary format model as input to show the complete ONNX graph. 3 Implementation Design In order to support real models in the ASTRA-sim simulator, we need to first understand the necessary information from the ONNX models. 3.1 Astra-SIM’s Input The Astra-SIM simulator input includes three main sections, which are network, system, and workload. The network and the system sections specify the network topology, commu- nication patterns for training and scheduling policies, etc. ModTrans focuses on the workload section, which is the in- put file that describes the detail information of the input model, specifically, it takes layer communication size and layer computation time as input in this file. The compute time of each layer is modeled by SCALE- sim [17], which is a low-level layer-wise computation time calculation simulator. However, the communication time, inferred from the model size, is manually extracted in the current ASTRA-sim design. 3.2 ModTrans Overview The design of ModTrans is to remove the manual steps for extracting the model. In the current ASTRA-sim, if we want to simulate a model developed by ML experts, the simula- tor runner needs to know all the model information from the ML developer, which is not efficient and not well labor- divided. With ModTrans, ML experts only need to develop their model in PyTorch, Tensorflow, or other Machine Learn- ing frameworks that support ONNX. ModTrans takes ONNX models and extracts the layer information for the ASTRA- sim. If developers want to use classic models, for example, ResNet50 [8] and [18], ModTrans also supports getting the models directly from the ONNX zoo [15] by only giving the model name to ModTrans. 3.3 ModTrans Implementation ModTrans is devleoped based on Python. The ONNX API is called to parse the ONNX. Since ONNX is in serialized binary format, we need to deserialize it before getting the data. Our evaluation results in Section??show that the deserialize cost is considerably small. After that, ModTrans calculates the layer size based on the parsed data, for example, the number of parameters for each layer and data type. 4 Evaluation 4.1 Experiment Setup Our experiments are all completed on a machine equipped with Intel(R) Xeon(R) CPU E5-2650 v3 @ 2.30GHz, and Python 3.8.10 installed. The ONNX models used in the following ex- periments come from the ONNX Model Zoo [15]. We picked three classic machine learning models to demonstrate our re- sults, which are ResNet50 [8], VGG16 [18], and VGG19 [18]. In general, ModTrans can be used in any machine with cor- rect ONNX models. 4.2 Execution Overhead The overhead of ModTrans is negligible. Our experiments (Figure 6) on three models show that the execution time for ModTrans are nearly the same and all below a second. VGG16 and VGG19 take about 0.8 seconds, and ResNet50 takes only around 0.1 seconds. The variances are also small. Besides, since ModTrans is not typically in the critical path, users can prepare the models offline. Therefore, we do not consider this is a cost that is needed to be concerned with. 4.3 With different Models Our parser works for any model in the ONNX format. In order to demonstrate the generality of our system, we run the ModTrans and demonstrate the layer-by-layer information ModTrans: Translating Real-world Models for Distributed Training Simulator ResNet50VGG16VGG19 0.0 0.2 0.4 0.6 Time (s) Figure 6. Execution Time for ModTrans for VGG16 and VGG19 in Table 1 and Table 2, respectively. This information includes but is not limited to Layer Name, The Number of Variables, Data Type, and Model Size. As shown in the tables, the layer-wise information is captured. 4.4 Sanity Check To validate the results of our program, we compare the results with the example ResNet50 provided by the model ASTRA- SIm. Table 3 shows the layer size of ModTrans extracted ResNet50 model and ASTRA-SIm provided ResNet50 model. The results show that all the size information in each layer is identical. This demonstrates the correctness of ModTrans and as a sanity check. Layer NameVariablesData TypeModel Size vgg16-conv0-weight1728FLOAT6912 vgg16-conv1-weight36864FLOAT147456 vgg16-conv2-weight73728FLOAT294912 vgg16-conv3-weight147456FLOAT589824 vgg16-conv4-weight294912FLOAT1179648 vgg16-conv5-weight589824FLOAT2359296 vgg16-conv6-weight589824FLOAT2359296 vgg16-conv7-weight1179648FLOAT4718592 vgg16-conv8-weight2359296FLOAT9437184 vgg16-conv9-weight2359296FLOAT9437184 vgg16-conv10-weight2359296FLOAT9437184 vgg16-conv11-weight2359296FLOAT9437184 vgg16-conv12-weight2359296FLOAT9437184 vgg16-dense0-weight102760448FLOAT411041792 vgg16-dense1-weight16777216FLOAT67108864 vgg16-dense2-weight4096000FLOAT16384000 Table 1. Layer-by-layer sizes extracted from VGG16 ONNX model Layer NameVariablesData TypeModel Size vgg19-conv0-weight1728FLOAT6912 vgg19-conv1-weight36864FLOAT147456 vgg19-conv2-weight73728FLOAT294912 vgg19-conv3-weight147456FLOAT589824 vgg19-conv4-weight294912FLOAT1179648 vgg19-conv5-weight589824FLOAT2359296 vgg19-conv6-weight589824FLOAT2359296 vgg19-conv7-weight589824FLOAT2359296 vgg19-conv8-weight1179648FLOAT4718592 vgg19-conv9-weight2359296FLOAT9437184 vgg19-conv10-weight2359296FLOAT9437184 vgg19-conv11-weight2359296FLOAT9437184 vgg19-conv12-weight2359296FLOAT9437184 vgg19-conv13-weight2359296FLOAT9437184 vgg19-conv14-weight2359296FLOAT9437184 vgg19-conv15-weight2359296FLOAT9437184 vgg19-dense0-weight102760448FLOAT411041792 vgg19-dense1-weight16777216FLOAT67108864 vgg19-dense2-weight4096000FLOAT16384000 Table 2. Layer-by-layer sizes extracted from VGG19 ONNX model 5 Conclusion In this paper, we develop ModTrans that can extract the nec- essary information needed by ASTRA-sim from real-world models. It makes ASTRA-sim can support simulation directly from the model without being manually configured. The ModTrans translator can also get classic models from the model zoo if users would like to use the simulator to simulate the model training. Since distributed training simulator is increasingly im- portant and necessary, we believe that there will be more and more researchers exploring this field. It means that our ModTrans in the future can be generalized to any simulators that take layer-wide information as input to do simulation. In the evaluation, we show that ModTrans can translate the given ONNX models in less than 1 second. And the trans- lated result is verified to be the same as the ResNet50 model provided in the official ASTRA-sim repository. ModTrans removes the barrier for users to run different deep learning models on the simulator. References [1][n. d.]. Doc: Open Neural Network Exchange. https://onnx.ai/onnx/ intro/concepts.html Lyu Layer NameExtracted ModelASTRA-SIM Model resnet-conv03763237632 resnet-stage1-conv01638416384 resnet-stage1-conv1147456147456 resnet-stage1-conv26553665536 resnet-stage1-conv36553665536 resnet-stage1-conv46553665536 resnet-stage1-conv5147456147456 resnet-stage1-conv66553665536 resnet-stage1-conv76553665536 resnet-stage1-conv8147456147456 resnet-stage1-conv96553665536 resnet-stage2-conv0131072131072 resnet-stage2-conv1589824589824 resnet-stage2-conv2262144262144 resnet-stage2-conv3524288524288 resnet-stage2-conv4262144262144 resnet-stage2-conv5589824589824 resnet-stage2-conv6262144262144 resnet-stage2-conv7262144262144 resnet-stage2-conv8589824589824 resnet-stage2-conv9262144262144 resnet-stage2-conv10262144262144 resnet-stage2-conv11589824589824 resnet-stage2-conv12262144262144 resnet-stage3-conv05242882097152 resnet-stage3-conv12359296524288 resnet-stage3-conv210485762359296 resnet-stage3-conv320971521048576 resnet-stage3-conv410485761048576 resnet-stage3-conv523592962359296 resnet-stage3-conv610485761048576 resnet-stage3-conv710485761048576 resnet-stage3-conv823592962359296 resnet-stage3-conv910485761048576 resnet-stage3-conv1010485761048576 resnet-stage3-conv1123592962359296 resnet-stage3-conv1210485761048576 resnet-stage3-conv1310485761048576 resnet-stage3-conv1423592962359296 resnet-stage3-conv1510485761048576 resnet-stage3-conv1610485761048576 resnet-stage3-conv1723592962359296 resnet-stage3-conv1810485761048576 resnet-stage4-conv020971528388608 resnet-stage4-conv194371842097152 resnet-stage4-conv241943049437184 resnet-stage4-conv383886084194304 resnet-stage4-conv441943044194304 resnet-stage4-conv594371849437184 resnet-stage4-conv641943044194304 resnet-stage4-conv741943044194304 resnet-stage4-conv894371849437184 resnet-stage4-conv941943044194304 resnet-dense081920008192000 Table 3. Layer-by-layer sizes extracted from ResNet50 ONNX model [2] [n. d.]. Github: Open Neural Network Exchange. https://github.com/ onnx/onnx [3] [n. d.]. Open Neural Network Exchange. https://en.wikipedia.org/ wiki/Open_Neural_Network_Exchange [4]Niket Agarwal, Tushar Krishna, Li-Shiuan Peh, and Niraj K Jha. 2009. GARNET: A detailed on-chip network model inside a full-system sim- ulator. In 2009 IEEE international symposium on performance analysis of systems and software. IEEE, 33–42. [5]Ming Cheng, Bowen Zhang, Ziyu Wang, Ziyi Zhou, Weiqi Feng, Yi Lyu, and Xingjian Diao. 2024. VeTraSS: Vehicle Trajectory Similar- ity Search Through Graph Modeling and Representation Learning. arXiv:2404.08021 [cs.LG] https://arxiv.org/abs/2404.08021 [6]Ming Cheng, Ziyi Zhou, Bowen Zhang, Ziyu Wang, Jiaqi Gan, Ziang Ren, Weiqi Feng, Yi Lyu, Hefan Zhang, and Xingjian Diao. 2024. Efflex: Efficient and Flexible Pipeline for Spatio-Temporal Trajectory Graph Modeling and Representation Learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) Work- shops. 2546–2555. [7]Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts, Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al.2022. Palm: Scaling language modeling with pathways. arXiv preprint arXiv:2204.02311 (2022). [8]K. He, X. Zhang, S. Ren, and J. Sun. 2016. Deep Residual Learning for Image Recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition (CVPR). 770–778. https://doi.org/10.1109/CVPR. 2016.90 [9]Yanping Huang, Youlong Cheng, Ankur Bapna, Orhan Firat, Dehao Chen, Mia Chen, HyoukJoong Lee, Jiquan Ngiam, Quoc V Le, Yonghui Wu, et al.2019. Gpipe: Efficient training of giant neural networks using pipeline parallelism. Advances in neural information processing systems 32 (2019). [10]Yimin Jiang, Yibo Zhu, Chang Lan, Bairen Yi, Yong Cui, and Chuanx- iong Guo. 2020. A Unified Architecture for Accelerating Distributed DNN Training in Heterogeneous GPU/CPU Clusters. In 14th USENIX Symposium on Operating Systems Design and Implementation (OSDI 20). USENIX Association, 463–479. https://w.usenix.org/conference/ osdi20/presentation/jiang [11]Ruqi Liao, Chuqing Zhao, Jin Li, Weiqi Feng, Yi Lyu, Bingxian Chen, and Haochen Yang. 2025. CATP: Cross-Attention Token Pruning for Accuracy Preserved Multimodal Model Inference. In 2025 IEEE Conference on Artificial Intelligence (CAI). 1100–1104. https://doi.org/ 10.1109/CAI64502.2025.00191 [12]Yi Lyu, Shichun Yu, and Joe Catudal. 2026. Safeguard: Security Con- trols at the Software Defined Network Layer. arXiv:2601.17355 [cs.CR] https://arxiv.org/abs/2601.17355 [13]Deepak Narayanan, Aaron Harlap, Amar Phanishayee, Vivek Seshadri, Nikhil R Devanur, Gregory R Ganger, Phillip B Gibbons, and Matei Zaharia. 2019. PipeDream: generalized pipeline parallelism for DNN training. In Proceedings of the 27th ACM Symposium on Operating Systems Principles. 1–15. [14]Deepak Narayanan, Mohammad Shoeybi, Jared Casper, Patrick LeGres- ley, Mostofa Patwary, Vijay Korthikanti, Dmitri Vainbrand, Prethvi Kashinkunti, Julie Bernauer, Bryan Catanzaro, et al.2021. Efficient large-scale language model training on gpu clusters using megatron- lm. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis. 1–15. [15]PcapPlusPlus [n. d.]. ONNX Model Zoo Github Repository. https: //github.com/onnx/models. [16]Saeed Rashidi, Srinivas Sridharan, Sudarshan Srinivasan, and Tushar Krishna. 2020. ASTRA-SIM: Enabling SW/HW Co-Design Exploration for Distributed DL Training Platforms. In IEEE International Sympo- sium on Performance Analysis of Systems and Software, ISPASS 2020, Boston, MA, USA, August 22-26, 2020. IEEE. ModTrans: Translating Real-world Models for Distributed Training Simulator [17]Ananda Samajdar, Yuhao Zhu, Paul Whatmough, Matthew Mattina, and Tushar Krishna. 2018. SCALE-Sim: Systolic CNN Accelerator Simulator. arXiv preprint arXiv:1811.02883 (2018). [18]Karen Simonyan and Andrew Zisserman. 2014. Very deep convo- lutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556 (2014). [19]Lyu Yi, Weiqi Feng, Yuanbiao Wang, and Yuhong Kan. 2025. MonoM: Enhancing Monotonicity in Learned Cardinality Estimators. arXiv:2512.22122 [cs.DB] https://arxiv.org/abs/2512.22122