Converting TensorFlow.js Models to ONNX with Python

In the world of machine learning and AI, one common problem is the interchangeability of models between various frameworks. This is where model conversion tools like ONNX come into play. Open Neural Network Exchange (ONNX) is a powerful open-source AI model interchange format that allows the interoperability between AI models irrespective of the frameworks they were built on. It is a great tool to have in your AI toolbox if you often work with models from different frameworks.

In this article, we will walk through a Python script that converts TensorFlow.js models to the ONNX format.

Code Overview

The script provided leverages the tf2onnx and tensorflowjs Python libraries to load, convert, and save the models. Let's break it down:

Importing Required Libraries

import os
import tf2onnx
import tensorflowjs as tfjs
import onnx
  • os is a standard Python library that allows you to interact with the operating system.
  • tf2onnx is a library that allows for the conversion of TensorFlow models to ONNX.
  • tensorflowjs is a library to run and use TensorFlow models with JavaScript.
  • onnx is a library that provides functionalities for ONNX, an open format to represent deep learning models.

Setting Directories
models_dir = '.'
onnx_models_dir = '.'
os.makedirs(onnx_models_dir, exist_ok=True)
Here we specify two directories: models_dir, which is where the TensorFlow.js models are located, and onnx_models_dir, where the converted ONNX models will be saved. os.makedirs is used to ensure the onnx_models_dir directory exists.

Looping Through Models and Converting
for model_folder in os.listdir(models_dir):
    model_path = os.path.join(models_dir, model_folder)
    if os.path.isdir(model_path):
        model = tfjs.converters.load_keras_model(os.path.join(model_path, 'model.json'))
        onnx_model_proto, _ = tf2onnx.convert.from_keras(model)
        onnx_model_path = os.path.join(onnx_models_dir, f'{model_folder}.onnx')
        with open(onnx_model_path, 'wb') as f:
In this section, the script loops through all the directories in models_dir. For each directory, it checks if it is indeed a directory and not a file.

If it is a directory, it assumes that this directory contains a TensorFlow.js model (in the form of a model.json file). It loads this model using tfjs.converters.load_keras_model.

The loaded model is then converted to ONNX using tf2onnx.convert.from_keras. The conversion process returns two values: the converted model (onnx_model_proto) and a list of unused operations that were not needed in the ONNX model. We only need the onnx_model_proto here, so we use _ to ignore the second return value.

Finally, the ONNX model is serialized (converted to a byte string) and saved to a .onnx file in the onnx_models_dir directory. The filename of the model is the same as the name of the directory in models_dir.


This Python script is a useful tool for converting TensorFlow.js models into ONNX format, allowing for interoperability with different machine learning frameworks. It uses the tf2onnx and tensorflowjs libraries to perform the conversion and saves the converted models into a specified directory.

Remember that the successful conversion of models between different formats is not always guaranteed, as different machine learning frameworks may have different capabilities, features, and specific implementation details. However, the ONNX format has been widely adopted and continues to gain support, making it a highly valuable asset for machine learning practitioners working across multiple platforms.

Additionally, while this script automates the conversion process, understanding the fundamentals of these different formats and how to effectively transition between them is still important for troubleshooting and handling complex scenarios.

Lastly, after conversion, it's crucial to verify the accuracy and performance of the ONNX models to ensure that the conversion hasn't affected the model's outputs or performance. Standard procedures like running the model on a test dataset and comparing results to the original TensorFlow.js model can provide insights on the model's integrity post-conversion.

In conclusion, this script provides a practical example of how you can leverage existing Python libraries to bridge the gap between machine learning models developed in different environments, thereby increasing the versatility and utility of your machine learning solutions.
Back to articles


Explore Aber Vulgue's blog for expert articles on programming, software development, and DevOps. Dive into practical guides on JavaScript, C++, mobile app development, neural networks, and more to enhance your tech skills.


Non penis canina est!