How to Convert ML Models to ONNX Format: A Complete Guide

ONNX Converter — Fri, 15 Aug 2025 10:34:54 +0000

Making machine learning model deployment effortless across platforms

TL;DR

Converting ML models to ONNX format enables universal deployment across platforms. This guide covers manual conversion methods and introduces a free tool I built to simplify the process: ONNX Converter.

The Problem: ML Deployment Hell 😅

Picture this: You've spent weeks building the perfect scikit-learn model. It's accurate, well-tuned, and ready for production. Then comes deployment day...

Cloud platform: "We need TensorFlow format"
Mobile team: "Can you convert this to Core ML?"
Edge device: "ONNX only, please"
Backend team: "Just give us a REST API"

Sound familiar? This is where ONNX (Open Neural Network Exchange) becomes your best friend.

What is ONNX and Why Should You Care?

ONNX is an open standard for representing machine learning models. Think of it as the "PDF of machine learning" - a universal format that works everywhere.

Key Benefits:

🌐 Universal compatibility - Deploy anywhere
⚡ Optimized performance - Faster inference
🔄 Framework flexibility - Switch between tools easily
📱 Multi-platform - Cloud, edge, mobile, web

Supported Platforms:

Cloud: Azure ML, AWS SageMaker, Google Cloud AI
Edge: NVIDIA Jetson, Intel OpenVINO
Mobile: iOS Core ML, Android NNAPI
Web: ONNX.js for browser deployment

Manual Conversion Methods

1. Scikit-learn to ONNX

# Install required packages
pip install scikit-learn skl2onnx onnx

# Convert sklearn model
from sklearn.ensemble import RandomForestClassifier
from skl2onnx import convert_sklearn
from skl2onnx.common.data_types import FloatTensorType
import pickle

# Load your trained model
with open('model.pkl', 'rb') as f:
    model = pickle.load(f)

# Define input shape (adjust for your model)
initial_types = [('input', FloatTensorType([None, 4]))]

# Convert to ONNX
onnx_model = convert_sklearn(
    model, 
    initial_types=initial_types,
    target_opset=11
)

# Save ONNX model
with open('model.onnx', 'wb') as f:
    f.write(onnx_model.SerializeToString())

2. LightGBM to ONNX

# Install additional package
pip install onnxmltools

import lightgbm as lgb
import onnxmltools
from onnxmltools.convert.common.data_types import FloatTensorType

# Load LightGBM model
model = lgb.Booster(model_file='lightgbm_model.txt')

# Convert to ONNX
initial_types = [('input', FloatTensorType([None, 10]))]
onnx_model = onnxmltools.convert_lightgbm(
    model,
    initial_types=initial_types,
    target_opset=11
)

# Save model
onnxmltools.utils.save_model(onnx_model, 'lightgbm_model.onnx')

3. XGBoost to ONNX

import xgboost as xgb
import onnxmltools
from onnxmltools.convert.common.data_types import FloatTensorType

# Load XGBoost model
model = xgb.Booster()
model.load_model('xgboost_model.json')

# Convert to ONNX
initial_types = [('input', FloatTensorType([None, 8]))]
onnx_model = onnxmltools.convert_xgboost(
    model,
    initial_types=initial_types,
    target_opset=11
)

# Save model
onnxmltools.utils.save_model(onnx_model, 'xgboost_model.onnx')

Common Conversion Challenges

1. Input Shape Issues

Problem: "Cannot determine input shape"

Solution: Always specify the correct input dimensions in FloatTensorType

2. Opset Version Conflicts

Problem: "Unsupported opset version"

Solution: Use target_opset=11 for broad compatibility

3. Custom Preprocessors

Problem: sklearn pipelines with custom transformers

Solution: Convert preprocessing and model separately, or use supported transformers only

4. Large Model Files

Problem: Memory issues with large models

Solution: Use model quantization or chunked processing

The Easy Way: Automated Conversion

While manual conversion gives you full control, it can be time-consuming and error-prone. That's why I built ONNX Converter - a free web tool that handles the complexity for you.

Features:

🚀 Instant conversion - Upload and download in seconds
🔧 Multiple formats - Supports scikit-learn, LightGBM, XGBoost
💰 Free tier - 5 conversions per month, no signup required
🔒 Secure - Files processed safely and deleted immediately
📱 Easy to use - No coding required

How it works:

Visit onnxconverter.com
Select your model type
Upload your model file (.pkl, .txt, .json)
Download the converted ONNX file

Perfect for:

Quick prototyping - Test deployment compatibility
Learning ONNX - See what converted models look like
Production use - Reliable conversion for real projects
Team collaboration - Share converted models easily

Validating Your ONNX Model

After conversion, always validate your model:

import onnx
import onnxruntime as ort
import numpy as np

# Load and check ONNX model
onnx_model = onnx.load('model.onnx')
onnx.checker.check_model(onnx_model)

# Test inference
session = ort.InferenceSession('model.onnx')
input_name = session.get_inputs()[0].name

# Create sample input (adjust shape for your model)
sample_input = np.random.random((1, 4)).astype(np.float32)

# Run inference
result = session.run(None, {input_name: sample_input})
print("ONNX model prediction:", result)

Deployment Examples

Web Deployment with ONNX.js

<!DOCTYPE html>
<html>
<head>
    <script src="https://cdn.jsdelivr.net/npm/onnxjs/dist/onnx.min.js"></script>
</head>
<body>
    <script>
        async function runModel() {
            const session = new onnx.InferenceSession();
            await session.loadModel('./model.onnx');

            const inputTensor = new onnx.Tensor([1, 2, 3, 4], 'float32', [1, 4]);
            const outputMap = await session.run([inputTensor]);
            console.log('Prediction:', outputMap.values().next().value.data);
        }
        runModel();
    </script>
</body>
</html>

Python Inference

import onnxruntime as ort
import numpy as np

# Load model
session = ort.InferenceSession('model.onnx')

# Prepare input
input_data = np.array([[1, 2, 3, 4]], dtype=np.float32)
input_name = session.get_inputs()[0].name

# Run inference
result = session.run(None, {input_name: input_data})
print("Prediction:", result[0])

Best Practices

1. Model Optimization

Use quantization for smaller file sizes
Remove unnecessary operations
Optimize for target hardware

2. Version Management

Tag ONNX models with version numbers
Document input/output schemas
Test across different ONNX runtime versions

3. Performance Testing

Benchmark against original model
Test on target deployment platform
Monitor inference latency

4. Security Considerations

Validate model files before deployment
Use secure model serving infrastructure
Regular security updates

Conclusion

ONNX format is becoming the standard for ML model deployment, and for good reason. It solves the "deployment hell" problem and makes your models truly portable.

Whether you choose manual conversion for full control or automated tools for speed, the key is to start experimenting with ONNX in your workflow.

Quick Start Options:

Manual: Use the code examples above
Automated: Try ONNX Converter for quick results
Learn more: Check out the official ONNX documentation

Resources

What's your experience with ONNX? Share your deployment stories in the comments below! 👇

If you found this helpful, you might also like my other posts about ML deployment and web development.

DEV Community: ONNX Converter