burn
Um framework de deep learning flexível e agnóstico de backend - treine e infira em Rust com backends de computação plugáveis.
Receita
use burn::backend::NdArray;
use burn::module::Module;
use burn::nn::Linear;
use burn::tensor::Tensor;
type B = NdArray<f32>;
#[derive(Module, Debug)]
struct Model<B: burn::backend::Backend> {
linear: Linear<B>,
}
fn forward<B: burn::backend::Backend>(m: &Model<B>, x: Tensor<B, 2>) -> Tensor<B, 2> {
m.linear.forward(x)
}Quando usar isso:
- Protótipos de pesquisa que podem migrar de CPU para GPU posteriormente
- Ensinar redes neurais com segurança de tipos do Rust
- Treinar modelos pequenos inteiramente em Rust
- Equipes que desejam uma única API para alvos embarcados e de servidor
Exemplo de Trabalho
use burn::backend::NdArray;
use burn::module::Module;
use burn::nn::{Linear, LinearConfig};
use burn::tensor::Tensor;
type B = NdArray<f32>;
#[derive(Module, Debug)]
struct Mlp<B: burn::backend::Backend> {
fc: Linear<B>,
}
fn main() {
let device = <B as burn::backend::Backend>::Device::default();
let mlp = Mlp::<B> {
fc: LinearConfig::new(4, 2).init(&device),
};
let input = Tensor::<B, 2>::from_data([[1.0, 2.0, 3.0, 4.0]], &device);
let out = mlp.fc.forward(input);
println!("{:?}", out.into_data());
}O que isso demonstra:
- Derivação
Modulepara registro de parâmetros - Padrão de builder
LinearConfigpara configuração de camada - Tipagem de tensores de Rank-2 para features em lote
Análise Profunda
Como Funciona
- Backends implementam operações de tensor; o código do usuário é genérico sobre
Backend. - A API
Learnerconecta datasets, otimizadores, métricas e checkpointing. - Importa ONNX para caminhos apenas de inferência; exporta ao interoperar com pilhas Python.
- O backend WGPU tem como alvo GPUs multiplataforma sem instalações CUDA.
Escolhas de Backend
| Backend | Alvo |
|---|---|
| NdArray | Desenvolvimento de CPU, CI |
| WGPU | GPU multiplataforma |
| CUDA | Servidores NVIDIA |
Armadilhas
- Tempos de compilação com backends genéricos - a monomorfização aumenta os binários. Correção: use um alias de tipo para um backend por binário do crate.
- Lacunas na cobertura de ops ONNX - camadas exóticas falham na importação. Correção: simplifique o grafo na exportação do PyTorch ou use
ortcomo fallback. - Problemas de driver WGPU em servidores headless - nenhum adaptador encontrado. Correção: use CUDA ou CPU NdArray em imagens de data center.
- Taxa de aprendizado muito alta no NdArray - NaNs sem proteções de precisão mista estilo GPU. Correção: comece conservadoramente, corte gradientes.
- Mudanças no formato do checkpoint - quebra o resume do treinamento entre versões do burn. Correção: versionar checkpoints nos metadados do armazenamento de objetos.
Alternativas
| Alternativa | Usar Quando | Não Usar Quando |
|---|---|---|
| candle | Pesos de transformadores HF desde o primeiro dia | Você precisa de troca genérica de backend |
| ort | Apenas inferência ONNX em produção | Treinamento dentro do Rust |
| tch | Precisa reutilizar código PyTorch arbitrário | Política de dependência pura de Rust |
| JAX/Python | Treinamento em larga escala em TPU | Implantação na borda sem Python |
FAQs
O burn está pronto para produção?
Os caminhos de inferência amadurecem mais rápido que o treinamento em larga escala. Valide a precisão e o desempenho no seu modelo antes de cortar o Python.
Como troco de backend?
Altere o alias de tipo type B = ... e reconstrua com flags de feature apropriadas - nenhuma reescrita de código fonte para o código do módulo.
O burn suporta CNNs e transformers?
Sim, via burn-import e módulos customizados - o suporte a transformer está ativo, mas verifique os exemplos para sua arquitetura.
Como carrego datasets?
Implemente o trait Dataset ou adapte leitores CSV/Parquet da seção de dados em lotes de tensores.
Posso implantar para WASM?
Existem caminhos experimentais; espere limites de tamanho e SIMD - profile antes de apostar no treinamento no navegador.
Como é o loop de treinamento?
Use LearnerBuilder com configuração de otimizador, rastreadores de métricas e learner.fit(dataloader) - veja o livro do burn para o snippet completo.
Inferência ONNX vs. inferência nativa do burn?
ONNX via ort é ótimo para grafos congelados; módulos nativos do burn permitem caminhos quentes apenas em Rust.
Como comparar com PyTorch?
Execute comparações de tensores dourados em um lote fixo após importação/exportação - não confie apenas nas curvas de perda.
Gerenciamento de memória da GPU?
Backends WGPU/CUDA cacheiam alocações; descarte tensores não utilizados e limite o tamanho do lote quando OOM.
Relação com candle?
candle é focado em HF; burn é geral - veja candle para atalhos do transformer zoo.
Relacionado
- candle - Transformers HF
- ONNX Runtime (ort) - Grafos importados
- GPU & Aceleração - Configuração WGPU/CUDA
- Noções Básicas de ML em Rust - Orientação
Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.