topic eIQ Auto ML Toolkit for Python-based SOH Deployment on S32K3 in S32K

eIQ Auto ML Toolkit for Python-based SOH Deployment on S32K3

SonHyunTaek — Mon, 13 Apr 2026 06:19:19 GMT

Hello,

I am currently working on a battery SOH (State of Health) estimation workflow, and I am trying to understand how to deploy a Python-based deep learning model and the full processing pipeline to an NXP S32K3 series target.

First, I would like to mention that I am still a beginner in this area. My understanding of eIQ, S32DS, MCU deployment structure, and runtime concepts is still limited, and I also have limited background in hardware and embedded development. I apologize if some of my questions are basic or too broad. If possible, I would really appreciate explanations from a beginner-friendly perspective.

My current development PC is running Windows 11, and I do not yet have an Ubuntu/Linux environment set up.

At the moment, the Python-based workflow consists of:

voltage (V), current (I), and temperature (T) input
preprocessing and input feature generation
normalization
deep learning model inference
postprocessing and SOH output

So my goal is not only to deploy a trained model, but to deploy the full estimation pipeline, including real-time input handling, feature generation, normalization, inference, postprocessing, and SOH output on the board.

The model I am currently considering is an LSTM-based SOH estimation model using voltage, current, and temperature inputs, and I am trying to determine the most practical deployment path after training in Python.

At the moment, I am considering the following three approaches:

Reconstruct the full workflow in MATLAB/Simulink and convert it to C/C++ using Embedded Coder
Reconstruct preprocessing, feature generation, normalization, and related functions in C, and integrate the trained model separately using ONNX or another format
Use NXP eIQ Auto ML Toolkit together with S32DS for board deployment

Since my final target is the S32K3 series, the eIQ Auto ML Toolkit-based approach seems to be the most direct path, but I do not yet understand the actual workflow, host environment requirements, or how much of the full pipeline can be covered by the toolkit.

My questions are as follows.

1. Development environment and support scope

Is eIQ Auto ML Toolkit a separate standalone development environment from S32 Design Studio, or is it intended to be used together with S32DS?
Is the recommended host environment for eIQ Auto ML Toolkit Ubuntu/Linux, or is there any practical Windows-based workflow?
To what extent does eIQ Auto ML Toolkit support the S32K3 series, and are there any example projects or reference workflows available?
Within the S32K3 family, which specific devices or board combinations are actually used in examples or verified workflows?

2. Model format and runtime-related questions

If a model is already trained in Python, is ONNX the recommended export path, or can pth, TorchScript, or other formats also be used?
I often see the term runtime in eIQ-related explanations, but I am not sure what it exactly means. For example, does runtime simply mean an engine that executes an ONNX model, does it mean an execution environment inside eIQ Toolkit, or is it something that gets added to an S32DS project as a separate library? I would appreciate a beginner-friendly explanation.
When using an ONNX file in eIQ or S32DS, does the ONNX file contain only the model structure and weights? Do preprocessing, feature generation, and normalization still need to be implemented separately? What part of the real board-side workflow is typically handled by ONNX?
To what extent does eIQ Auto ML Toolkit support recurrent network structures such as LSTM and GRU?
After applying eIQ Auto ML Toolkit, what kinds of final outputs or artifacts are typically generated or provided? For example, libraries, model binaries, header files, example projects, or runtime API calling code.
At the moment, I am not sure whether eIQ Auto ML Toolkit should be understood as a model execution tool, a code generation tool, or a separate IDE/SDK-type environment, so I would appreciate clarification on this point as well.

3. Full pipeline deployment

Is eIQ Auto ML Toolkit mainly intended for model deployment and inference execution, or can it also cover more of the full pipeline, such as preprocessing, feature generation, and normalization?
If preprocessing, feature generation, and normalization are not handled directly inside the toolkit, is the recommended approach to implement those parts separately in C/C++ inside the S32DS environment?
When deploying a full Python-based workflow to an MCU, is C/C++ implementation essentially required for preprocessing, feature generation, and normalization, or is there any more direct way to leverage Python-based results?
In a real-time board-side implementation, where voltage, current, and temperature are collected in real time, how is the overall flow typically structured in eIQ Auto ML Toolkit and S32DS, including input feature generation, normalization, model inference, and SOH output?
In a real-time inference structure, are things like input buffer management and sequence construction usually implemented as external C/C++ code outside the toolkit?
Is the overall deployment procedure with eIQ Auto ML Toolkit generally understood as something like model preparation, ONNX export, toolkit import, target selection, optimization or compilation, runtime integration, and S32DS project integration? If not, I would appreciate guidance on a more accurate step-by-step process.

4. Development direction and getting started

Between the MATLAB/Simulink-based code generation approach and the eIQ Auto ML Toolkit-based approach, which one is currently the most efficient and practical from the perspective of deployment to the S32K3 series?
From a beginner’s perspective, what would be the most realistic first step for trying eIQ Auto ML Toolkit on the S32K3 series?

If possible, I would also appreciate any of the following:

installation guides
supported host OS information
S32K3 example projects
eIQ Auto ML Toolkit usage examples
S32DS integration examples
comparison with MATLAB/Simulink or recommended direction
related documents, videos, or tutorials

My final goal is not only to run a trained model, but to establish a deployable structure for the full SOH estimation pipeline, including preprocessing, feature generation, normalization, inference, and output, on the target board.

If possible, I would greatly appreciate a recommended step-by-step development procedure or any reference projects, documentation, or tutorial materials you can share.

Thank you!

Re: eIQ Auto ML Toolkit for Python-based SOH Deployment on S32K3

sabind — Fri, 17 Apr 2026 05:07:38 GMT

Hello,

I will try to provide high‑level guidance first, and then I will answer the questions. Most of these questions are covered in the documentation included in the K3 release package (see docs folder). First, if you don't have an eIQ Auto license, please use this form to request it: https://contact.nxp.com/eIQ-Auto-DL-Toolkit-Req.

1. eIQ Auto is supported on Linux (Ubuntu 20.04 and 22.04). Windows is not officially supported; some users use WSL2 or a Linux VM as a workaround. eIQ Auto can be used as a standalone development environment with two stages: offline (model import/convert/optimize on the host) and runtime (target inference). The entry point is a trained model. Everything is explained in detail in the User Guide and Tutorial Guide included in the package. S32DS can be used for runtime stage development/debug (but it is not required). eIQ Auto is supported on S32K344 and S32K396.

2. ONNX, Keras and TFLite models are supported. I would suggest starting with ONNX or Keras. PyTorch models are not directly supported but can be easily exported to ONNX. The runtime contains optimized libraries that can be linked into your application (the tutorials include CMake files as examples). An ONNX file typically contains the model graph (operators/topology) and parameters (weights/biases). It does not automatically include your application’s data plumbing unless you explicitly model it as ONNX operators inside the graph.

Preprocessing / feature generation / normalization usually still needs to be implemented separately unless you have baked it into the ONNX graph. What ONNX typically covers on the board side is the inference part: loading the network + weights into the chosen runtime, running the forward pass, and producing outputs. Everything around it (sensor acquisition, framing/windowing, scaling, feature extraction, post‑processing) is usually handled by your application code unless represented as model ops.

LSTM and GRU are supported on S32K3, but there is no dedicated NPU on this device. Inference runs on the Cortex‑M7, and the performance comes from optimized kernels rather than a specific neural accelerator. There is an LSTM tutorial in the release package. The tutorial explains the outputs of the offline conversion stage and provides a runtime application example and API usage. The offline tools convert trained neural network models into optimized formats for embedded targets, while the runtime library executes inference on the target hardware. It is not a full code‑generation tool for the entire application. The runtime application is a C++ application.

3. eIQ Auto is mainly intended for model deployment and inference execution. Preprocessing, feature generation, normalization, buffering, and application control flow are not handled directly by the toolkit. The offline stage starts from a trained model and produces artifacts for running inference on the target. Yes, implement preprocessing, feature generation, and normalization in C++ within your runtime application.

A full Python pipeline cannot be deployed “as‑is” to the MCU because Python does not run on the target in this environment. In practice, you need to re‑implement the Python preprocessing logic in C/C++, or bake some of it into the exported model graph (where feasible).
The neural network input must be provided in the exact tensor shape and data type expected by the model. The eIQ Auto API is simple: you copy the correct input data into the runtime input tensors/buffers and then invoke inference.

The typical flow is: Train model in Python -> Export to ONNX -> Import into eIQ Auto offline tools -> Select target and optimize -> Generate runtime artifacts -> Runtime application. Offline tools = model conversion/optimization; Runtime app = sensors + buffering + preprocessing + calling runtime + postprocessing + output; You can start by adapting one of the runtime tutorials to your use case.

4. For neural network inference on S32K3, eIQ Auto ML Toolkit is the recommended approach and it is not currently supported in MATLAB. Start with the provided tutorials in the release package. Run an existing example project on your S32K3 board first to verify the setup works. Then replace the example model with a simple model of your own and adapt the preprocessing code to your use case. This step-by-step approach is the most practical way to learn the workflow.

Please note that eIQA support for K3 is limited. If you need broader support and hardware acceleration, I recommend checking K5, which also includes an NPU accelerator.

Hope it helps,

Sabin