Bei der Entwicklung moderner KI-Anwendungen ist das effiziente und kompatible Ausführen trainierter Machine-Learning-Modelle in Produktionsumgebungen eine kritische Herausforderung. Verschiedene Deep-Learning-Frameworks (PyTorch, TensorFlow usw.) haben ihre eigenen Standards für Modellformate, was die plattformübergreifende Bereitstellung und Leistungsoptimierung erschweren kann. Hier kommen ONNX (Open Neural Network Exchange) und ONNX Runtime ins Spiel.

Was ist ONNX und warum ist es wichtig?

ONNX ist ein Open-Source-Formatstandard für KI-Modelle. Dieser Standard ermöglicht es Entwicklern, Modelle einfach von einem Framework in ein anderes zu übertragen und sie in verschiedenen Hardware-/Softwareumgebungen auszuführen. Durch die Konvertierung eines Modells in das ONNX-Format machen wir es unabhängig von dem Framework, in dem es trainiert wurde. Dies bietet erhebliche Vorteile, insbesondere in den folgenden Szenarien:

• Konsolidierung von Modellen, die in verschiedenen ML-Frameworks entwickelt wurden, in einem einzigen Format.
• Portieren von Modellen auf verschiedene Bereitstellungsziele wie Web, Mobil, Edge-Geräte und die Cloud.
• Nutzung spezieller Beschleuniger (GPU, TPU, NPU usw.) zur Leistungsoptimierung.

ONNX Runtime: Hochleistungs-Inferenz-Engine

ONNX Runtime ist eine plattformübergreifende, hochleistungsfähige Inferenz-Engine, die ONNX-formatierte Modelle ausführt. Sie kann mit gängigen Frameworks wie PyTorch und TensorFlow integriert werden und bietet eine breite Palette an Hardwarebeschleunigung, von CPU über GPU (CUDA, TensorRT) bis hin zu spezialisierter Hardware (Intel OpenVINO, AMD ROCm). Die Hauptvorteile von ONNX Runtime sind:

• Hohe Leistung: Verfügt über integrierte Graph-Optimierungen, die die Inferenzzeit verkürzen und die Ressourcennutzung optimieren.
• Plattformübergreifende Unterstützung: Läuft auf vielen Betriebssystemen wie Windows, Linux, macOS, Android, iOS.
• Flexibilität: Unterstützt verschiedene Hardwarebeschleuniger (Execution Providers).

Konvertieren eines PyTorch-Modells in das ONNX-Format mit Python

Das Konvertieren eines PyTorch-Modells in ONNX ist recht einfach. Zuerst erstellen und trainieren wir ein kleines PyTorch-Modell (oder verwenden ein vorab trainiertes).

import torch
import torch.nn as nn
import torch.optim as optim

# 1. Definiere ein einfaches PyTorch-Modell
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc = nn.Linear(10, 2) # 10 Eingänge, 2 Ausgänge
    
    def forward(self, x):
        return self.fc(x)

# Erstelle das Modell und lade Gewichte (oder trainiere es)
model = SimpleModel()
# Nehmen wir an, Sie haben Ihr Modell hier trainiert oder vorab trainierte Gewichte geladen
# Erstellen wir zum Beispiel zufällige Gewichte
dummy_input = torch.randn(1, 10) # Einzelnes Sample, 10 Features

# Setze das Modell in den Evaluierungsmodus
model.eval()

# 2. Konvertiere das PyTorch-Modell nach ONNX
onnx_path = "simple_pytorch_model.onnx"
torch.onnx.export(
    model,
    dummy_input,
    onnx_path,
    export_params=True,
    opset_version=11, # Wähle eine unterstützte Opset-Version
    do_constant_folding=True,
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}} # Aktiviere dynamische Batch-Größe
)

print(f"PyTorch-Modell erfolgreich in das ONNX-Format konvertiert: {onnx_path}")

Konvertieren eines TensorFlow/Keras-Modells in das ONNX-Format mit Python

Um TensorFlow- oder Keras-Modelle nach ONNX zu konvertieren, können wir die Bibliothek tf2onnx verwenden. Möglicherweise müssen Sie diese Bibliothek zuerst installieren: pip install tf2onnx

import tensorflow as tf
import tf2onnx
from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE

# 1. Definiere ein einfaches Keras-Modell
model = tf.keras.Sequential([
    tf.keras.layers.Dense(10, activation='relu', input_shape=(5,)), # 5 Eingänge
    tf.keras.layers.Dense(2, activation='softmax') # 2 Ausgänge
])

# Trainiere das Modell oder lade Gewichte
# Kompilieren wir das Modell zum Beispiel
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Überprüfe die Modellausgabe mit Zufallsdaten (optional)
dummy_input = tf.random.normal((1, 5))
_ = model(dummy_input) # Stelle sicher, dass das Modell seine Struktur aufbaut

# 2. Konvertiere das Keras-Modell nach ONNX
onnx_path = "simple_keras_model.onnx"
input_signature = [tf.TensorSpec(model.inputs[0].shape, model.inputs[0].dtype, name=model.inputs[0].name)]

model_proto, _ = tf2onnx.convert.from_keras(model, input_signature, opset=11, output_path=onnx_path)

print(f"Keras-Modell erfolgreich in das ONNX-Format konvertiert: {onnx_path}")

Inferenz mit ONNX Runtime durchführen

Sehen wir uns an, wie man das konvertierte ONNX-Modell mit ONNX Runtime ausführt. Dies gilt für Modelle, die sowohl von PyTorch als auch von TensorFlow konvertiert wurden.

import onnxruntime as ort
import numpy as np

# Lade das zuvor gespeicherte ONNX-Modell
onnx_model_path = "simple_pytorch_model.onnx" # oder "simple_keras_model.onnx"

# Erstelle eine ONNX Runtime Session
# Wenn Sie GPU verwenden möchten: providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
# Aber Sie müssen ONNX Runtime für CUDA zuerst installieren (pip install onnxruntime-gpu)
sess_options = ort.SessionOptions()
session = ort.InferenceSession(onnx_model_path, sess_options, providers=['CPUExecutionProvider'])

# Erhalte die Ein- und Ausgabennamen des Modells
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name

# Erstelle zufällige Eingabedaten (in der erwarteten Form und Art des Modells)
# Für PyTorch-Modellbeispiel (1, 10) float32
input_data = np.random.rand(1, 10).astype(np.float32) 
# Für Keras-Modellbeispiel (1, 5) float32
# input_data = np.random.rand(1, 5).astype(np.float32) 

# Inferenz durchführen
outputs = session.run([output_name], {input_name: input_data})

print("Inferenzergebnisse mit ONNX Runtime:")
print(outputs[0])

Leistungstipps und Best Practices

• Korrekte Opset-Version: Stellen Sie sicher, dass die Opset-Version, die Sie während der Konvertierung verwenden, von Ihrer Ziel-ONNX Runtime-Version unterstützt wird.
• Dynamische Eingabeformen: Wenn Ihr Modell verschiedene Batch-Größen oder variable Eingabedimensionen unterstützen muss, geben Sie dies während der ONNX-Konvertierung mit dem Parameter dynamic_axes an.
• Hardwarebeschleunigung (Execution Providers): ONNX Runtime unterstützt verschiedene Hardwarebeschleuniger (Execution Providers). Die Verwendung von CUDAExecutionProvider oder TensorRTExecutionProvider für NVIDIA GPUs kann beispielsweise zu erheblichen Leistungsverbesserungen gegenüber der CPU führen. Denken Sie daran, die entsprechenden Bibliotheken (onnxruntime-gpu) zu installieren und die Liste der providers beim Erstellen der Sitzung anzugeben.
• Graph-Optimierungen: ONNX Runtime optimiert Modellgraphen automatisch. Sie können die Leistung jedoch weiter verbessern, indem Sie zusätzliche Optimierungen oder Techniken wie die Quantisierung für bestimmte Szenarien anwenden.
• Modellvalidierung: Validieren Sie Ihr konvertiertes ONNX-Modell, indem Sie überprüfen, ob es die gleiche Ausgabe wie das Modell im ursprünglichen Framework liefert.

Fazit

ONNX und ONNX Runtime sind ein leistungsstarkes Duo, das die Bereitstellung von Machine-Learning-Modellen vereinfacht und deren Leistung verbessert. Durch die Verwendung dieser Tools können Entwickler Modellabhängigkeiten überwinden, Hochleistungs-Inferenzen auf verschiedenen Hardwareplattformen durchführen und KI-Anwendungen schneller und effizienter in die Produktion bringen. Das Erlernen dieser Technologien wird zu einer unverzichtbaren Fähigkeit für Softwareentwickler und KI-Enthusiasten beim Aufbau moderner KI-Infrastrukturen.