ONNX Runtime (ort)
Execute modelos ONNX exportados em Rust com o ONNX Runtime - o caminho padrão do treinamento em Python para inferência nativa.
Receita
use ndarray::Array;
use ort::{inputs, session::Session, value::Tensor};
fn predict(session: &Session, flat: Vec<f32>) -> ort::Result<f32> {
let input = Array::from_shape_vec((1, flat.len()), flat)?;
let outputs = session.run(inputs![Tensor::from_array(input)?])?;
let view = outputs[0].try_extract_tensor::<f32>()?;
Ok(view[0])
}Quando usar isso:
- Implantando modelos sklearn/PyTorch/TensorFlow sem Python
- Padronizando a inferência entre linguagens em um único arquivo ONNX
- Necessitando de provedores de execução CUDA/TensorRT em produção
- Equipes que já exportam ONNX em pipelines de treinamento
Exemplo de Trabalho
use ndarray::Array;
use ort::{inputs, session::Session, value::Tensor};
fn main() -> ort::Result<()> {
let session = Session::builder()?.commit_from_file("model.onnx")?;
let features = vec![0.1f32, 0.2, 0.3, 0.4];
let input = Array::from_shape_vec((1, 4), features)?;
let outputs = session.run(inputs![Tensor::from_array(input)?])?;
let tensor = outputs[0].try_extract_tensor::<f32>()?;
println!("score: {}", tensor[0]);
Ok(())
}O que isso demonstra:
- Construindo uma sessão a partir do disco uma vez no início
- Criando um tensor de entrada de lote 1 com formas ndarray
- Extraindo saídas f32 por índice
Mergulho Profundo
Como Funciona
- O grafo ONNX é composto por operadores congelados com entradas/saídas tipadas.
Session::runmapeia tensores Rust para memória ORT, executa provedores e retorna saídas.- Provedores de execução (CPU, CUDA, TensorRT) são conectados através de opções de sessão.
- Eixos de lote ou sequência dinâmicos exigem dimensões explícitas a cada execução.
Checklist de Exportação
| Etapa | Ação |
|---|---|
| Treinar | PyTorch/sklearn/etc. |
| Exportar | torch.onnx.export ou ferramenta do framework |
| Validar | onnx.checker + inferência de amostra em Rust |
Armadilhas
- Discrepância no nome da entrada - o grafo espera
input_idse nãoinput. Correção: imprimasession.inputse combine as strings. - NCHW vs NHWC - modelos de visão invertem a ordem dos canais. Correção: documente o layout no cartão do modelo; transponha na pré-processamento.
- Derivação no pré-processamento - normalização diferente da do treinamento. Correção: teste de vetor de referência (golden vector) do notebook de exportação Python.
- FP16 no provedor de CPU - caminhos não suportados ou lentos. Correção: mantenha FP32 para implantações apenas de CPU.
- Modelos enormes carregados por solicitação - latência de vários segundos. Correção: singleton
Arc<Session>no início do processo.
Alternativas
| Alternativa | Use Quando | Não Use Quando |
|---|---|---|
| candle | Transformer nativo em Rust sem ONNX | O modelo só existe como ONNX hoje |
| burn import | Permanecer no ecossistema burn | O grafo usa operações ONNX não suportadas |
| Microserviço Python | Iteração rápida | Latência/custo de operação do sidecar |
| TensorRT diretamente | Desempenho máximo apenas NVIDIA | Necessidade de fallback de CPU portátil |
FAQs
Como habilito o CUDA?
Compile ort com recursos CUDA e registre o provedor de execução CUDA em Session::builder() - o driver deve existir no contêiner.
Posso executar vários modelos?
Sim - uma Session por modelo, compartilhe entre threads com Arc se a documentação de segurança de threads do ORT permitir para seu EP.
Tamanho de lote dinâmico?
Defina a dimensão do lote na forma do tensor de entrada em tempo de execução se a exportação usou anotações de eixo dinâmico.
Entradas de string?
A maioria dos classificadores ONNX esperam tensores numéricos - tokeniza o texto antes do ORT, não dentro das APIs genéricas do ORT.
Como depuro inferência lenta?
Flags de perfil do ORT, grafo menor via onnx-simplifier e provedor de GPU quando o tamanho do lote justificar.
Versão do opset do modelo?
Corresponda ao opset suportado pelo ort; reexporte do framework de treinamento se a importação falhar.
Agrupando solicitações?
Empilhe linhas na dimensão do lote quando o grafo suportar lote dinâmico; preencha até o comprimento máximo para sequências.
Segurança dos arquivos do modelo?
Trate ONNX como código - verifique checksums e assine artefatos no armazenamento de objetos.
Como testar?
Verifique em um pequeno fixture ONNX e afirme o tensor de saída dentro de um epsilon da referência Python.
Servir com Axum?
Veja Servindo Modelos com Axum para a conexão HTTP.
Relacionado
- Noções Básicas de ML em Rust - Introdução ao ONNX
- Tokenizers - pré-processamento de texto
- Servindo Modelos com Axum - camada HTTP
- GPU e Aceleração - Provedor de execução CUDA
Versões da Pilha: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.