Crate tenflowers 

TenfloweRS - Pure Rust Deep Learning Framework

TenfloweRS is a comprehensive machine learning framework implemented in pure Rust, providing TensorFlow-compatible APIs with Rust’s safety and performance guarantees. Built on the robust SciRS2 scientific computing ecosystem, TenfloweRS offers:

• Production-Ready: Full-featured neural networks, training, and deployment
• High Performance: GPU acceleration, SIMD optimization, mixed precision
• Type Safety: Rust’s type system prevents common ML bugs at compile time
• Cross-Platform: CPU, GPU (CUDA, Metal, Vulkan), and WebGPU support
• Ecosystem Integration: Seamless integration with SciRS2, NumRS2, and OptiRS

Quick Start

Basic Tensor Operations

use tenflowers::prelude::*;

// Create tensors
let a = Tensor::<f32>::zeros(&[2, 3]);
let b = Tensor::<f32>::ones(&[2, 3]);

// Arithmetic operations
let c = ops::add(&a, &b)?;
let d = ops::mul(&a, &b)?;

// Matrix multiplication
let x = Tensor::<f32>::ones(&[2, 3]);
let y = Tensor::<f32>::ones(&[3, 4]);
let z = ops::matmul(&x, &y)?;

Building Neural Networks

use tenflowers::prelude::*;

// Create a simple feedforward network
let model = Sequential::<f32>::new(vec![])
    .add(Box::new(Dense::new(784, 128, true).with_activation("relu".to_string())))
    .add(Box::new(Dense::new(128, 10, true).with_activation("sigmoid".to_string())));

// Forward pass
let input = Tensor::zeros(&[32, 784]);
let output = model.forward(&input)?;

Training Models

use tenflowers::prelude::*;

// Create model and data
let model = Sequential::<f32>::new(vec![])
    .add(Box::new(Dense::new(10, 64, true).with_activation("relu".to_string())))
    .add(Box::new(Dense::new(64, 3, true)));
let x_train = Tensor::<f32>::zeros(&[100, 10]);
let y_train = Tensor::<f32>::zeros(&[100, 3]);

// Create optimizer and loss function
let optimizer = SGD::<f32>::new(0.01);
// Training loop would go here using Trainer

GPU Acceleration

use tenflowers::prelude::*;

// Move computation to GPU
let device = Device::try_gpu(0)?;
let gpu_tensor = Tensor::<f32>::zeros(&[1000, 1000]).to_device(device)?;
let result = ops::matmul(&gpu_tensor, &gpu_tensor)?;

Automatic Differentiation

use tenflowers::prelude::*;

let mut tape = GradientTape::new();

// Create tracked tensors
let x = tape.watch(Tensor::<f32>::ones(&[2, 2]));
let y = tape.watch(Tensor::<f32>::ones(&[2, 2]));

// Compute gradients
let z = tape.watch(Tensor::<f32>::ones(&[2, 2]));
let gradients = tape.gradient(&[z], &[x, y])?;

Data Loading

use tenflowers::prelude::*;
use tenflowers::dataset::RandomSampler;

// Load dataset
let dataset: CsvDataset<f32> = CsvDatasetBuilder::new()
    .from_path("data.csv")
    .has_header(true)
    .build()?;

// Create data loader with batching and shuffling
let loader = DataLoaderBuilder::new(dataset)
    .batch_size(32)
    .num_workers(4)
    .build(RandomSampler::new());

// Iterate through batches
for batch in loader.iter() {
    let (features, labels) = batch?.into_collated()?;
    // Training step...
}

Architecture

TenfloweRS is organized into several focused crates:

• core: Tensor operations and device management
• autograd: Automatic differentiation engine
• neural: Neural network layers and models
• dataset: Data loading and preprocessing

Feature Flags

Default Features

• std: Standard library support
• parallel: Parallel execution via Rayon

GPU Acceleration

• gpu: GPU acceleration via WGPU (Metal, Vulkan, DirectX, WebGPU)
• cuda: CUDA support (Linux/Windows only)
• cudnn: cuDNN support (requires CUDA)
• opencl: OpenCL support
• metal: Metal support (macOS only)
• rocm: ROCm support (AMD GPUs)
• nccl: NCCL for distributed GPU training

BLAS Acceleration

• blas: Generic BLAS support
• blas-openblas: OpenBLAS acceleration
• blas-mkl: Intel MKL acceleration
• blas-accelerate: Apple Accelerate framework (macOS only)

Performance & Optimization

• simd: SIMD vectorization optimizations

Serialization & I/O

• serialize: Serialization support (JSON, MessagePack)
• compression: Compression support for checkpoints
• onnx: ONNX model import/export

Platform Support

• wasm: WebAssembly support

Development

• autograd: Automatic differentiation support
• benchmark: Benchmarking utilities

Language Bindings

• python: Python bindings via PyO3

Convenience

• full: Enable most features (gpu, blas-openblas, simd, serialize, compression, onnx, autograd, python)

SciRS2 Integration

TenfloweRS is built on top of the SciRS2 ecosystem:

TenfloweRS (Deep Learning Framework)
    ↓ builds upon
OptiRS (ML Optimization)
    ↓ builds upon
SciRS2 (Scientific Computing Foundation)

This integration provides:

• Advanced numerical operations via scirs2-core
• Automatic differentiation via scirs2-autograd
• Neural network abstractions via scirs2-neural
• Optimized algorithms via optirs

Re-exports

pub use tenflowers_autograd as autograd;

pub use tenflowers_core as core;

pub use tenflowers_dataset as dataset;

pub use tenflowers_neural as neural;

Modules

common

Common types and utilities

data

Data pipeline and dataset utilities

macros

Convenience macros for the TenfloweRS framework.

nn

Neural network layers, activations, and models

optim

Optimization algorithms

prelude

Prelude module for convenient imports

Macros

tensor

Creates a 1D [Tensor] from a list of values.

Structs

VersionInfo

Structured version metadata for the TenfloweRS framework.

Constants

VERSION

The version of the TenfloweRS framework

Functions

version

Returns the version string of TenfloweRS

version_info

Returns structured version metadata populated at compile time.