candle para Rust: el framework de ML minimalista de Hugging Face

candle es un framework moderno para machine learning, escrito en Rust y desarrollado por el equipo de Hugging Face. A diferencia de soluciones pesadas como PyTorch o TensorFlow, candle está diseñado para ofrecer rendimiento, seguridad en la memoria y un consumo mínimo de recursos. Permite ejecutar modelos de redes neuronales en CPU y GPU (a través de CUDA y Vulkan) sin necesidad de instalar enormes runtimes.

¿Para qué sirve candle? Primero, es ideal para sistemas embebidos, WebAssembly (WASM) y dispositivos edge, donde el tamaño del binario y la velocidad de carga son críticos. Segundo, Rust garantiza seguridad en la concurrencia y ausencia de garbage collector, lo que proporciona un rendimiento predecible para inferencia. Tercero, candle admite la carga de modelos desde formatos de PyTorch (safetensors, bin) y Hugging Face Hub, lo que lo convierte en una excelente opción para producción.

Al momento de escribir este artículo, candle está en pleno desarrollo: soporta transformers (BERT, GPT, LLaMA, Whisper), redes convolucionales (ResNet, ViT) e incluso modelos generativos (Stable Diffusion). En esta guía, veremos la instalación, los métodos clave y crearemos un ejemplo completo de clasificación de texto.

Instalación

candle es una biblioteca de Rust, por lo que la instalación se realiza a través de Cargo. Agrega la dependencia en tu Cargo.toml:

[dependencies]
candle-core = "0.7"
candle-nn = "0.7"
candle-transformers = "0.7"
tokenizers = "0.21"  # para trabajar con tokenizadores
anyhow = "1.0"       # para manejo de errores

Si necesitas soporte para CUDA, usa la flag --features cuda:

cargo add candle-core --features cuda
cargo add candle-nn --features cuda
cargo add candle-transformers --features cuda

Para trabajar con WebAssembly (WASM), agrega --features wasm.

Inicio rápido: ejemplo mínimo funcional

Vamos a crear un tensor y realizar una operación simple: multiplicación de matrices:

use candle_core::{Device, Tensor};

fn main() -> Result<(), Box> {
    // Creamos tensores en CPU
    let a = Tensor::new(&[[1.0f32, 2.0], [3.0, 4.0]], &Device::Cpu)?;
    let b = Tensor::new(&[[5.0f32, 6.0], [7.0, 8.0]], &Device::Cpu)?;

    // Multiplicación de matrices
    let c = a.matmul(&b)?;
    println!("Resultado: {:?}", c.to_vec2::()?);

    Ok(())
}

Este código mostrará:

Resultado: [[19.0, 22.0], [43.0, 50.0]]

Nota: todas las operaciones devuelven un Result, por lo que usamos ? para manejar errores.

Métodos y funciones principales

Veamos 10 métodos clave de candle-core y candle-nn que necesitarás en el 90% de tus proyectos.

1. Tensor::new — creación de tensores

Firma: pub fn new, D: Into>(data: impl Into>, device: D) -> Result<Tensor>

Descripción: Crea un tensor a partir de un vector plano de números de punto flotante. La forma se define mediante Shape (por ejemplo, Shape::from((2, 3))).

use candle_core::{Device, Tensor, Shape};

fn main() -> anyhow::Result<()> {
    // Creamos un tensor 2x3 a partir de un vector
    let t = Tensor::new(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &Device::Cpu)?;
    // Cambiamos la forma
    let t_reshaped = t.reshape(&Shape::from((2, 3)))?;
    println!("{:?}", t_reshaped.to_vec2::()?);
    Ok(())
}

2. Tensor::matmul — multiplicación de matrices

Firma: pub fn matmul(&self, other: &Tensor) -> Result<Tensor>

Descripción: Realiza la multiplicación matricial de dos tensores. Soporta broadcasting para lotes.

use candle_core::{D