El óxido está ganando tracción rápidamente en el mundo de la inteligencia artificial (IA) y el aprendizaje automático (ML) debido a su rendimiento, seguridad y características de concurrencia. Al 31 de marzo de 2025, construir un motor de inferencia de modelo AI en Rust es una forma emocionante de aprovechar estas fortalezas para una implementación de modelo rápida y confiable. Ya sea que sea un principiante sumergiendo los dedos de los pies en ML o un desarrollador experimentado que busca una inferencia eficiente, esta guía ultra detallada lo guiará a través del proceso paso a paso utilizando tres potentes bibliotecas de óxido: tracto, onnxruntime y quemado. La inferencia, el proceso de uso de un modelo capacitado para hacer predicciones, es un paso crítico en la implementación de soluciones de IA. En este artículo, cubriremos todo, desde configurar su entorno de óxido hasta ejecutar un modelo previamente capacitado con cada biblioteca, completo con ejemplos de código, pros, contras y consejos. Al final, tendrá un motor de inferencia completamente funcional adaptado a sus necesidades. ¡Comencemos! ¿Por qué usar Rust para la inferencia del modelo de IA? Rust ofrece ventajas únicas para la inferencia de IA: rendimiento: velocidad cercana a C ++ con abstracciones de costo cero. Seguridad: las garantías de seguridad de la memoria eliminan los errores comunes. Portabilidad: implementa en escritorios, servidores o incluso websembly. Ecosistema en crecimiento: las bibliotecas como Tract, Onnxruntime y Burn están madurando rápidamente. En comparación con Python, el óxido brilla en entornos de producción donde importan la latencia y la eficiencia de los recursos. Esta guía se centra en tres bibliotecas: Tracto: un motor de inferencia ONNX de alianza pura y ligera. Tiempo de ejecución de ONNX (ORT): un envoltorio de óxido para el tiempo de ejecución ONNX de alto rendimiento de Microsoft. Burn: un marco de aprendizaje profundo flexible y nativo de óxido para capacitación e inferencia. Prerrequisitos Antes de sumergirse, asegúrese de tener: Rust instalado: ejecutar curl –proto ‘= https’ -tlsv1.2 -ssf https://sh.rustup.rs | SH para instalar Rust (versión 1.75+ recomendada a partir de 2025). Cargo: Gerente de paquetes de Rust, incluido con Rust. Un modelo previamente capacitado: utilizaremos un modelo ONNX (por ejemplo, un clasificador de dígitos MNIST simple) descargable del zoológico del modelo ONNX. Conocimiento básico de óxido: familiaridad con estructuras, enums y carga.toml. Opcional: GPU NVIDIA con CUDA para la aceleración de GPU (para OnXruntime). Descargue el modelo MNIST ONNX del zoológico del modelo ONNX (p. Ej., Mnist-8.onnx) y colóquelo en su directorio de proyecto para este tutorial. Paso 1: Configuración de su proyecto de óxido Cree un nuevo proyecto de óxido: Cargo Nuevo Rust-Ai-Inferencia CD Rust-AI-Inference Editar carga.toml Para incluir dependencias para las tres bibliotecas (las usaremos selectivamente): [package]
name = «Rust-Ai-Inference» Version = «0.1.0» edition = «2021»

[dependencies]
tract-onnx = «0.21» # para tract ort = «2.0» # para onnxruntime burn = {versión = «0.13», características = [«ndarray», «onnx»] } # Para Burn nDarray = «0.15» # para la imagen de manejo de tensor = «0.24» # para el preprocesamiento de las imágenes MNIST ejecutan la compilación de carga a las dependencias de recuperación. Esto prepara el escenario para nuestro motor de inferencia. Paso 2: Preparación de datos de entrada (ejemplo de MNIST) Para obtener consistencia, preprocesaremos una imagen de muestra MNIST (dígito de escala de grises 28 × 28) para usar con las tres bibliotecas. Cree una función en src/main.rs: use Image :: {ImageBuffer, Luma}; use nDarray :: {array, array4}; fn preprocess_image (ruta: & str) -> array4 {let img = image :: open (ruta) .unwrap (). to_luma8 (); Letimensione = Image :: ImageOps :: RESIZE (& IMG, 28, 28, Image :: ImageOps :: FilterType :: más cercano); Sea tensor = array :: from_shape_vec ((1, 1, 28, 28), reeding.into_raw ()) .unwrap () .mapv (| x | x como f32 / 255.0); // Normalizar a [0, 1]
tensor} Guardar una imagen de dígitos MNIST de muestra (por ejemplo, digit.png) en su directorio de proyecto. Esta función carga, cambia de tamaño y normaliza la imagen en un tensor 4D (tamaño por lotes, canales, altura, ancho). Opción 1: Ejecución de inferencia con el tracto ¿Qué es el tracto? El tracto es una biblioteca de altura pura para ejecutar modelos ONNX y TensorFlow. Es liviano, no se basa en dependencias externas de C ++ y admite WebAssembly, lo que lo hace ideal para la inferencia portátil. Paso 3A: Cargue y configure el modelo en SRC/Main.rs, agregue este código de inferencia basado en el tracto: use tract_onnx :: prelude ::*; fn run_tract_inference (model_path: & str, input: array4) -> de todos modos :: resultado> {let model = tract_onnx :: onnx () .model_for_path (model_path)? .with_input_fact (0, InferenceFact :: DT_SHAPE (F32 :: Datum_Type (), TVEC! (1, 1, 28, 28)))? .into_optimizado ()? .into_runnable ()?; Let input_tensor: tensor = input.into (); dejar resultado = model.run (tvec! (input_tensor))?; Sea la salida = resultado[0].to_array_view: :() ?. to_vec (); OK (salida)} Paso 4a: Ejecutar Infrezing Update Main para usar Tract: Fn Main () -> de todos modos :: Resultado<()> {let input = preprocess_image («digit.png»); dejar salida = run_tract_inference («mnist-8.onnx», entrada)?; println! («Salida del tracto: {:?}», salida); OK (())} Run Cargo Run. La salida es un vector de 10 elementos que representa las probabilidades para los dígitos 0-9. El valor más alto indica el dígito predicho. Pros y contras de Pros del tracto: Rust Pure, sin dependencias externas, soporte de WebAssembly. Contras: Aceleración limitada de hardware (solo CPU), comunidad más pequeña. Opción 2: Ejecución de inferencia con ONNX Runtime (ORT) ¿Qué es el tiempo de ejecución de ONNX? El tiempo de ejecución de ONNX (a través de la caja ORT) es un envoltorio de óxido para el motor de inferencia de alto rendimiento de Microsoft. Admite la aceleración de CPU y GPU (p. Ej., CUDA), lo que lo hace ideal para aplicaciones críticas de rendimiento. Paso 3B: Cargue y configure el modelo Agregar este código de inferencia basado en ORT: use ort :: {entorno, sesión, graphoptimizationLevel, entradas}; fn run_ort_inference (model_path: & str, input: array4) -> anyhow :: resultado> {dejar entorno = ambiente :: builder () .with_name («inferencia») .with_log_level (ort :: logginglevel :: advertencia) .Build ()?;; Let Session = Session :: Builder ()? .with_optimization_level (GraphoptimizationLevel :: Level3)? .with_intra_threads (1)? .Commit_From_File (model_path)?; Let input_tensor = input.into_tensor (); Let outings = session.run (entradas![«data» => input_tensor]?)?; Sea la salida = salidas[«Plus214_Output_0»]
.try_extract_tensor: :()? .to_vec (); OK (salida)} Nota: Reemplace «Datos» y «Plus214_output_0» con los nombres de entrada/salida de su modelo (verifique con Netron). Paso 4B: Ejecutar la actualización de inferencia principal para ORT: FN Main () -> de todos modos :: Resultado<()> {let input = preprocess_image («digit.png»); dejar salida = run_ort_inference («mnist-8.onnx», entrada)?; println! («outt outt {:?}», salida); Ok (())} Para soporte de GPU, asegúrese de que CUDA esté instalado y agregue .With_Execution_Providers ([ort::CUDAExecutionProvider::default()])? al constructor de sesiones. Pros y contras de ONNX Runtime Pros: alto rendimiento, soporte de GPU, amplia compatibilidad del modelo. Contras: dependencia externa de C ++, configuración más pronunciada para GPU. Opción 3: Ejecutar inferencia con Burn ¿Qué es Burn? Burn es un marco de aprendizaje profundo nativo de óxido que ofrece flexibilidad para el entrenamiento e inferencia. Admite modelos ONNX y backends múltiples (por ejemplo, CPU, GPU a través de WGPU), lo que lo hace versátil para la investigación y la implementación. Paso 3C: Cargue y configure el modelo Agregar este código de inferencia basado en quemaduras: Use Burn :: Backend :: NDarray :: NDarray; use Burn :: Module :: Module; usar Burn :: Nn :: Onnxruntime; Use Burn :: Tensor :: Tensor; fn run_burn_inference (model_path: & str, input: array4) -> anyhow :: resultado> {type backend = nDarray; Let Model: onnxruntime = onnxruntime :: new (model_path)?; Dejar input_tensor = tensor ::::: from_data (entrada); Let output_tensor = model.forward (input_tensor); Let output = output_tensor.into_data (). to_vec ()?; OK (salida)} Para GPU, reemplace nDarray con wgpu y agregue quemar = {versión = «0.13», características = [«wgpu»] } a CARGO.TOML. Paso 4C: Ejecutar la actualización de inferencia principal para quemar: fn main () -> de todos modos :: resultado<()> {let input = preprocess_image («digit.png»); dejar salida = run_burn_inference («mnist-8.onnx», entrada)?; println! («Burn salida: {:?}», salida); OK (())} Pros y contras de Pros de quemaduras: óxido-nativo, backends flexibles, soporte de entrenamiento. Contras: ecosistema más joven, complejidad de configuración de WGPU. Paso 5: Comparación de resultados Ejecute las tres implementaciones y compare salidas. Para MNIST, cada uno debe predecir el mismo dígito (por ejemplo, un «7» con una alta probabilidad en el índice 7). Las diferencias pueden surgir de los niveles de precisión u optimización de punto flotante, pero las predicciones deberían alinearse estrechamente. Paso 6: Optimización del tracto de motor de inferencia: use .into_optimized () para las optimizaciones de gráficos. ORT: Habilitar GraphoptimizationLevel :: nivel3 y proveedores de ejecución de GPU. BURN: Cambie al backend o perfil de WGPU con carga de carga. Rendimiento de perfil con ejecución de carga: liberación y herramientas como Perf en Linux. Paso 7: Implementación de su escritorio/servidor del motor: paquete con compilación de carga –lelease. Web: use el tracto con WebAssembly (WASM-Pack). Incrustado: compilación cruzada con quemadura o tracto para el brazo. Conclusión: Elegir el tracto de su ruta de inferencia: Mejor para inferencia ligera y portátil sin dependencias externas. Tiempo de ejecución de ONNX: ideal para necesidades de alto rendimiento con soporte de GPU. Burn: Perfecto para los entusiastas del óxido que desean flexibilidad y a prueba de futuro. Esta guía Ultra Long lo ha equipado para construir su primer motor de inferencia de modelos de IA en Rust Using TRACT, ONNXRUTIME o Burn. ¡Experimente con cada uno para encontrar su ajuste y feliz codificación en 2025!