Rust para aprendizado de máquina: possibilidades e limitações

Introdução: Rust no mundo do machine learning

O mundo do machine learning (ML) foi monopolizado por muito tempo pelo Python — graças à sua simplicidade, abundância de bibliotecas (NumPy, scikit-learn, PyTorch, TensorFlow) e enorme comunidade. No entanto, nos últimos anos, vozes têm se levantado cada vez mais dizendo que Rust pode se tornar um concorrente sério nesta área.

Rust é uma linguagem de programação de sistema que combina o desempenho de C/C++ com segurança de memória em nível de compilação. Ela promete velocidade, confiabilidade e controle sobre os recursos. Mas isso é suficiente para ML? Neste artigo, analisaremos detalhadamente quais capacidades Rust oferece para machine learning, quais limitações os desenvolvedores enfrentam e se vale a pena migrar do Python habitual para ele.

Por que Rust pode ser interessante para ML?

Desempenho e controle de memória

Uma das principais vantagens do Rust é a velocidade. Graças à compilação para código nativo e à ausência de um garbage collector, programas em Rust podem ser muitas vezes mais rápidos que seus equivalentes em Python. Isso é crítico para tarefas que exigem processamento de grandes volumes de dados ou treinamento de modelos em tempo real.

Além disso, Rust garante segurança de memória em tempo de compilação. Erros como segmentation fault ou vazamentos de memória, comuns em C/C++, são praticamente impossíveis em Rust. Para infraestrutura de ML onde a confiabilidade é crítica (por exemplo, em sistemas autônomos ou algoritmos financeiros), isso é uma enorme vantagem.

Paralelismo e multithreading

Modelos modernos de ML exigem computação paralela. Rust fornece ferramentas poderosas para trabalhar com threads (std::thread) e programação assíncrona (tokio, async-std). Além disso, o sistema de ownership e borrowing previne condições de corrida em tempo de compilação — algo que em Python ou C++ precisa ser detectado em tempo de execução.

use std::thread;

fn main() {    let mut handles = vec![];

    for i in 0..4 {        handles.push(thread::spawn(move || {            println!("Thread {} iniciou os cálculos", i);            // Aqui pode estar o cálculo de gradiente ou pré-processamento de dados            i * i        }));    }

    for handle in handles {        println!("Resultado: {}", handle.join().unwrap());    }}

Ecossistema Rust para machine learning

Linfa — análogo ao scikit-learn

Linfa é um framework para machine learning clássico em Rust. Ele fornece algoritmos para classificação, regressão, clusterização, redução de dimensionalidade e pré-processamento de dados. A ideia é que Linfa se torne o que scikit-learn é para Python.

Exemplo de regressão linear com Linfa:

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

fn main() {    // Dados: matriz de features (X) e variável alvo (y)    let x = Array2::from_shape_vec((5, 2), vec![1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0, 5.0, 5.0, 6.0]).unwrap();    let y = vec![5.0, 7.0, 9.0, 11.0, 13.0];

    let dataset = Dataset::new(x, y);    let model = LinearRegression::default().fit(&dataset).unwrap();

    println!("Coeficientes: {:?}", model.params());}

Atualmente, Linfa suporta cerca de 20 algoritmos — ainda longe de tudo que existe no scikit-learn, mas a base já está estabelecida.

Burn — redes neurais em Rust

Burn é um framework moderno para deep learning escrito em Rust. Ele suporta diferenciação automática, execução em GPU (via WGPU e CUDA) e possui uma arquitetura modular. Burn está em desenvolvimento ativo e já permite criar e treinar redes neurais.

Exemplo de uma rede neural simples em Burn:

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

struct MyModel<B: Backend> {    layer1: Linear<B>,    activation: Relu,