Aprendizaje automático en Rust: revisión de bibliotecas para ML y Data Science

Aprendizaje automático en Rust: bibliotecas y herramientas modernas

El lenguaje Rust, conocido por su rendimiento y seguridad de memoria, está entrando activamente en el campo del aprendizaje automático (ML). Aunque el ecosistema de ML en Rust es más joven que el de Python, ya ofrece soluciones maduras para construir, entrenar e implementar modelos. En este artículo, revisaremos las bibliotecas clave que permiten resolver tareas de aprendizaje automático en Rust y proporcionaremos ejemplos prácticos.

¿Por qué Rust para el aprendizaje automático?

Rust ofrece ventajas únicas:

• Rendimiento: El código compilado en Rust es comparable en velocidad a C/C++, lo cual es crítico para entrenar modelos grandes.
• Seguridad: El sistema de propiedad (ownership) y préstamo (borrowing) elimina clases enteras de errores (data races, punteros nulos).
• Multiplataforma: Se compila fácilmente para WebAssembly, dispositivos móviles y sistemas embebidos.
• Integración con Python: Se pueden escribir módulos de alto rendimiento en Rust y llamarlos desde Python a través de PyO3.

Bibliotecas principales para ML en Rust

1. Linfa — la navaja suiza del ML

Linfa es el equivalente de scikit-learn para Rust. Proporciona una interfaz unificada para algoritmos estándar. Soporta:

• Regresión lineal y logística
• Máquinas de vectores de soporte (SVM)
• Agrupamiento (K-Means, DBSCAN)
• Métodos de reducción de dimensionalidad (PCA)
• Árboles de decisión y bosque aleatorio

Ejemplo de regresión lineal con Linfa:

use linfa::prelude::*;use linfa_linear::LinearRegression;use ndarray::Array2;

fn main() -> Result<(), Box<dyn std::error::Error>> {    // Creamos datos sintéticos: 100 puntos, 3 características    let x = Array2::random((100, 3), rand::distributions::Uniform::new(-1.0, 1.0));    let true_weights = arr2(&[[2.0], [-1.0], [0.5]]);    let y = x.dot(&true_weights) + 0.1; // añadimos ruido

    let dataset = Dataset::new(x, y);        // Entrenamos el modelo    let model = LinearRegression::default().fit(&dataset)?;        // Coeficientes del modelo    println!("Pesos: {:?}", model.params());        // Predicción    let predicted = model.predict(&dataset);    println!("MSE: {:?}", predicted.mean_squared_error(&dataset)?);        Ok(())}

2. Burn — framework moderno para aprendizaje profundo

Burn es un framework flexible para redes neuronales, escrito completamente en Rust. Sus características:

• Soporte para GPU (CUDA, Vulkan, Metal, WebGPU)
• Diferenciación automática (autograd)
• Sistema flexible de backends (torch, ndarray, wgpu)
• Grafos de cómputo dinámicos
• Exportación a ONNX

Ejemplo de una red neuronal simple en Burn:

use burn::tensor::{Tensor, backend::Backend};use burn::nn::{Linear, Relu, Sequential};

// Definimos la arquitectura de la redstruct MyModel<B: Backend> {    linear1: Linear<B>,    linear2: Linear<B>,    activation: Relu,}

impl<B: Backend> MyModel<B> {    fn new(device: &B::Device) -> Self {        Self {            linear1: Linear::new(784, 256, device),            linear2: Linear::new(256, 10, device),            activation: Relu::new(),        }    }        fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {        let x = self.linear1.forward(input);        let x = self.activation.forward(x);        self.linear2.forward(x)    }}

fn main() {    // Usamos backend en CPU (ndarray)    type MyBackend = burn::backend::NdArray;    let device = Default::default();        let model = MyModel::<MyBackend>::new(&device);    let input = Tensor::<MyBackend, 2>::ra