Aprendizado de Máquina em Rust: visão geral das bibliotecas para ML e Data Science

Aprendizado de Máquina em Rust: bibliotecas e ferramentas modernas

A linguagem Rust, conhecida por seu desempenho e segurança de memória, está entrando ativamente no campo do aprendizado de máquina (ML). Embora o ecossistema de ML em Rust seja mais jovem que o do Python, ele já oferece soluções maduras para construir, treinar e implantar modelos. Neste artigo, veremos as principais bibliotecas que permitem resolver problemas de aprendizado de máquina em Rust e forneceremos exemplos práticos.

Por que Rust para aprendizado de máquina?

Rust oferece vantagens únicas:

• Desempenho: O código compilado em Rust é comparável em velocidade ao C/C++, o que é crítico para treinar grandes modelos.
• Segurança: O sistema de ownership e borrowing elimina classes inteiras de erros (data races, null pointers).
• Multiplataforma: Compila facilmente para WebAssembly, dispositivos móveis e sistemas embarcados.
• Integração com Python: É possível escrever módulos de alto desempenho em Rust e chamá-los do Python via PyO3.

Principais bibliotecas para ML em Rust

1. Linfa — o canivete suíço do ML

Linfa é o equivalente ao scikit-learn para Rust. Ela fornece uma interface unificada para algoritmos padrão. Suporta:

• Regressão linear e logística
• Máquina de vetores de suporte (SVM)
• Clusterização (K-Means, DBSCAN)
• Métodos de redução de dimensionalidade (PCA)
• Árvores de decisão e floresta aleatória

Exemplo de regressão linear com Linfa:

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

fn main() -> Result<(), Box<dyn std::error::Error>> {    // Criando dados sintéticos: 100 pontos, 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; // adicionando ruído

    let dataset = Dataset::new(x, y);        // Treinando o modelo    let model = LinearRegression::default().fit(&dataset)?;        // Coeficientes do modelo    println!("Pesos: {:?}", model.params());        // Predição    let predicted = model.predict(&dataset);    println!("MSE: {:?}", predicted.mean_squared_error(&dataset)?);        Ok(())}

2. Burn — framework moderno para aprendizado profundo

Burn é um framework flexível para redes neurais, escrito inteiramente em Rust. Suas características:

• Suporte a GPU (CUDA, Vulkan, Metal, WebGPU)
• Diferenciação automática (autograd)
• Sistema flexível de backends (torch, ndarray, wgpu)
• Grafos de computação dinâmicos
• Exportação para ONNX

Exemplo de uma rede neural simples em Burn:

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

// Definindo a arquitetura da redestruct 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() {    // Usando backend na CPU (ndarray)    type MyBackend = burn::backend::NdArray;    let device = Default::default();        let model = MyModel::<MyBackend>::new(&device);    let input = Tensor::<MyBackend, 2>::ra