1. ¿Qué es Burn y por qué usarlo?

Burn es un framework moderno de deep learning escrito en Rust. Proporciona un conjunto completo de herramientas para crear, entrenar y desplegar redes neuronales, con un enfoque en rendimiento, seguridad de memoria y flexibilidad. A diferencia de frameworks tradicionales como PyTorch o TensorFlow, Burn aprovecha todas las ventajas de Rust: abstracciones de costo cero, garantías de seguridad en tiempo de compilación y ausencia de recolector de basura. Esto lo convierte en la opción ideal para sistemas donde el rendimiento predecible y el bajo consumo de recursos son críticos, como robótica, sistemas embebidos, servidores de alta carga y dispositivos edge.

Burn ofrece una arquitectura única basada en el concepto de "neutralidad de backend". Esto significa que el mismo código puede ejecutarse en CPU (a través de su motor tensorial nativo), GPU (mediante CUDA/WGPU) y, en el futuro, en aceleradores especializados. El framework soporta diferenciación automática, optimizadores (Adam, SGD, AdamW), funciones de pérdida, capas (Linear, Conv2d, BatchNorm, Dropout, etc.), así como datasets y DataLoader integrados. Una característica clave es la capacidad de compilar modelos en bibliotecas estáticas para su despliegue sin dependencias de Python o CUDA runtime.

¿Por qué usar Burn? Primero, para proyectos que requieren máximo rendimiento y control sobre la memoria. Segundo, para crear soluciones multiplataforma que funcionen en CPU, GPU e incluso WebAssembly. Tercero, para un despliegue seguro de modelos en producción, donde errores en tiempo de ejecución (como punteros nulos o errores de tipo) son inaceptables. Burn es desarrollado activamente por la comunidad y ya se utiliza en áreas como visión por computadora, PLN, sistemas de recomendación y aprendizaje por refuerzo.

2. Instalación

Para instalar Burn necesitas Rust (se recomienda la versión 1.75 o superior). Si aún no tienes Rust instalado, usa rustup.

Crea un nuevo proyecto y agrega las dependencias en Cargo.toml:

cargo new my_burn_project
cd my_burn_project

Agrega lo siguiente a Cargo.toml:

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

Luego ejecuta:

cargo build

Para trabajar con CUDA necesitas tener instalado CUDA Toolkit 11.x o 12.x. Para WGPU, necesitas Vulkan, Metal o DirectX 12 (según el sistema operativo).

3. Inicio rápido — ejemplo mínimo funcional

Vamos a crear una red neuronal simple para una tarea de regresión con datos sintéticos. Este ejemplo muestra los pasos principales: definir el modelo, crear datos, entrenar y hacer inferencia.

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

// Definimos la estructura del 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