1. O que é e para que serve

Burn é um framework moderno para deep learning, escrito em Rust. Ele oferece um conjunto completo de ferramentas para criar, treinar e implantar redes neurais, com foco em desempenho, segurança de memória e flexibilidade. Diferente de frameworks tradicionais como PyTorch ou TensorFlow, o Burn aproveita todos os benefícios do Rust: abstrações de custo zero, garantias de segurança em tempo de compilação e ausência de garbage collector. Isso o torna ideal para sistemas onde desempenho previsível e baixo consumo de recursos são críticos — por exemplo, em robótica, sistemas embarcados, servidores de alta carga e dispositivos edge.

Burn oferece uma arquitetura única baseada no conceito de "backend-neutralidade". Isso significa que o mesmo código pode ser executado em CPU (através do próprio motor tensorial), GPU (via CUDA/WGPU) e, futuramente, em aceleradores especializados. O framework suporta diferenciação automática, otimizadores (Adam, SGD, AdamW), funções de perda, camadas (Linear, Conv2d, BatchNorm, Dropout, entre outras), além de datasets e DataLoader integrados. Uma característica fundamental é a capacidade de compilar modelos em bibliotecas estáticas para implantação sem dependências do Python ou do runtime CUDA.

Por que usar o Burn? Primeiro, para projetos que exigem desempenho máximo e controle sobre a memória. Segundo, para criar soluções multiplataforma que funcionam em CPU, GPU e até WebAssembly. Terceiro, para implantar modelos em produção com segurança, onde erros em tempo de execução (como null pointer ou type mismatch) são inaceitáveis. O Burn é ativamente desenvolvido pela comunidade e já é utilizado em áreas como visão computacional, PLN, sistemas de recomendação e aprendizado por reforço.

2. Instalação

Para instalar o Burn, você precisa do Rust (recomenda-se a versão 1.75 ou superior). Se o Rust ainda não estiver instalado, use o rustup.

Crie um novo projeto e adicione as dependências no Cargo.toml:

cargo new my_burn_project
cd my_burn_project

Adicione ao Cargo.toml:

[dependencies]
burn = { version = "0.15", features = ["ndarray"] }  # para CPU
# ou para GPU (CUDA):
# burn = { version = "0.15", features = ["cuda"] }
# ou para WGPU (GPU multiplataforma):
# burn = { version = "0.15", features = ["wgpu"] }

Em seguida, execute:

cargo build

Para usar CUDA, é necessário ter o CUDA Toolkit 11.x ou 12.x instalado. Para WGPU, são necessários Vulkan, Metal ou DirectX 12 (dependendo do sistema operacional).

3. Início rápido — exemplo mínimo funcional

Vamos criar uma rede neural simples para uma tarefa de regressão com dados sintéticos. Este exemplo demonstra as etapas principais: definição do modelo, criação dos dados, treinamento e inferência.

use burn::{
    module::Module,
    nn::{Linear, Relu},
    tensor::{backend::Backend, Tensor},
    train::{Adam, Learner},
    data::dataloader::DataLoaderBuilder,
};

// Define a estrutura do modelo
#[derive(Module, Debug)]
struct MyModel {
    linear1: Linear,
    linear2: Linear,
    activation: Relu,
}

impl MyModel {
    fn new() -> Self {
        Self {
            linear1: Linear::new(1, 16),
            linear2: Linear::new(16, 1),
            activation: Relu::new(),
        }
    }

    fn forward(&self, input: Tensor) -> Tensor {
        let x = self.linear1.forward(input);
        let x = self.activation.forward(x);
        se