Domain Ml

by actionbook5c40d3ad7851No license1.5K starsListed Oct 8, 2026Updated Oct 8, 2026Repository updated 6 weeks ago

Use when building ML/AI apps in Rust. Keywords: machine learning, ML, AI, tensor, model, inference, neural network, deep learning, training, prediction, ndarray, tch-rs, burn, candle, 机器学习, 人工智能, 模型推理

Instructions onlySoftware Development AI & Agents

AI-generated overview

Guides Rust machine-learning and AI application design, covering frameworks, memory efficiency, GPU batching and model loading.

What it does: This skill provides domain constraints and design guidance for building machine-learning and AI applications in Rust. It maps domain rules such as large data, GPU acceleration and model portability to Rust design implications, and recommends crates for tensors, ONNX inference, ML frameworks, PyTorch bindings, data processing and embeddings. It also supplies code patterns for an inference server and batched inference, plus tables of common mistakes and related skills.
When to use it: Use it when designing or implementing ML/AI applications in Rust, such as inference servers, batched prediction pipelines or model loading. It is also relevant when choosing between Rust ML crates or addressing memory, GPU and portability constraints.
Requirements: No scripts are shipped; it is instructions only. The guidance references Rust crates such as ndarray, tract, candle, burn, tch-rs, polars and fastembed, and assumes a Rust project with possible GPU (CUDA/Metal) support.

Machine Learning Domain

Layer 3: Domain Constraints

Domain Constraints → Design Implications

Domain Rule	Design Constraint	Rust Implication
Large data	Efficient memory	Zero-copy, streaming
GPU acceleration	CUDA/Metal support	candle, tch-rs
Model portability	Standard formats	ONNX
Batch processing	Throughput over latency	Batched inference
Numerical precision	Float handling	ndarray, careful f32/f64
Reproducibility	Deterministic	Seeded random, versioning

Critical Constraints

Memory Efficiency

RULE: Avoid copying large tensorsWHY: Memory bandwidth is bottleneckRUST: References, views, in-place ops

RULE: Avoid copying large tensorsWHY: Memory bandwidth is bottleneckRUST: References, views, in-place ops

GPU Utilization

RULE: Batch operations for GPU efficiencyWHY: GPU overhead per kernel launchRUST: Batch sizes, async data loading

RULE: Batch operations for GPU efficiencyWHY: GPU overhead per kernel launchRUST: Batch sizes, async data loading

Model Portability

Trace Down ↓

From constraints to design (Layer 2):

"Need efficient data pipelines"    ↓ m10-performance: Streaming, batching    ↓ polars: Lazy evaluation
"Need GPU inference"    ↓ m07-concurrency: Async data loading    ↓ candle/tch-rs: CUDA backend
"Need model loading"    ↓ m12-lifecycle: Lazy init, caching    ↓ tract: ONNX runtime

"Need efficient data pipelines"    ↓ m10-performance: Streaming, batching    ↓ polars: Lazy evaluation
"Need GPU inference"    ↓ m07-concurrency: Async data loading    ↓ candle/tch-rs: CUDA backend
"Need model loading"    ↓ m12-lifecycle: Lazy init, caching    ↓ tract: ONNX runtime

Use Case → Framework

Key Crates

Design Patterns

Code Pattern: Inference Server

rust

use std::sync::OnceLock;use tract_onnx::prelude::*;
static MODEL: OnceLock<SimplePlan<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>>> = OnceLock::new();
fn get_model() -> &'static SimplePlan<...> {    MODEL.get_or_init(|| {        tract_onnx::onnx()            .model_for_path("model.onnx")            .unwrap()            .into_optimized()            .unwrap()            .into_runnable()            .unwrap()    })}
async fn predict(input: Vec<f32>) -> anyhow::Result<Vec<f32>> {    let model = get_model();    let input = tract_ndarray::arr1(&input).into_shape((1, input.len()))?;    let result = model.run(tvec!(input.into()))?;    Ok(result[0].to_array_view::<f32>()?.iter().copied().collect())}

use std::sync::OnceLock;use tract_onnx::prelude::*;
static MODEL: OnceLock<SimplePlan<TypedFact, Box<dyn TypedOp>, Graph<TypedFact, Box<dyn TypedOp>>>> = OnceLock::new();
fn get_model() -> &'static SimplePlan<...> {    MODEL.get_or_init(|| {        tract_onnx::onnx()            .model_for_path("model.onnx")            .unwrap()            .into_optimized()            .unwrap()            .into_runnable()            .unwrap()    })}
async fn predict(input: Vec<f32>) -> anyhow::Result<Vec<f32>> {    let model = get_model();    let input = tract_ndarray::arr1(&input).into_shape((1, input.len()))?;    let result = model.run(tvec!(input.into()))?;    Ok(result[0].to_array_view::<f32>()?.iter().copied().collect())}

Code Pattern: Batched Inference

rust

async fn batch_predict(inputs: Vec<Vec<f32>>, batch_size: usize) -> Vec<Vec<f32>> {    let mut results = Vec::with_capacity(inputs.len());
    for batch in inputs.chunks(batch_size) {        // Stack inputs into batch tensor        let batch_tensor = stack_inputs(batch);
        // Run inference on batch        let batch_output = model.run(batch_tensor).await;
        // Unstack results        results.extend(unstack_outputs(batch_output));    }
    results}

async fn batch_predict(inputs: Vec<Vec<f32>>, batch_size: usize) -> Vec<Vec<f32>> {    let mut results = Vec::with_capacity(inputs.len());
    for batch in inputs.chunks(batch_size) {        // Stack inputs into batch tensor        let batch_tensor = stack_inputs(batch);
        // Run inference on batch        let batch_output = model.run(batch_tensor).await;
        // Unstack results        results.extend(unstack_outputs(batch_output));    }
    results}

Common Mistakes

Trace to Layer 1

Constraint	Layer 2 Pattern	Layer 1 Implementation
Memory efficiency	Zero-copy	ndarray views
Model singleton	Lazy init	OnceLock<Model>
Batch processing	Chunked iteration	chunks() + parallel
GPU async	Concurrent loading	tokio::spawn + GPU

Related Skills

Source and attribution

Source:actionbook/rust-skillsinskills/domain-mlat commit5c40d3a

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Use Case	Recommended	Why
Inference only	tract (ONNX)	Lightweight, portable
Training + inference	candle, burn	Pure Rust, GPU
PyTorch models	tch-rs	Direct bindings
Data pipelines	polars	Fast, lazy eval

Pattern	Purpose	Implementation
Model loading	Once, reuse	`OnceLock<Model>`
Batching	Throughput	Collect then process
Streaming	Large data	Iterator-based
GPU async	Parallelism	Data loading parallel to compute

Mistake	Domain Violation	Fix
Clone tensors	Memory waste	Use views
Single inference	GPU underutilized	Batch processing
Load model per request	Slow	Singleton pattern
Sync data loading	GPU idle	Async pipeline

Domain Ml

Machine Learning Domain

Domain Constraints → Design Implications

Critical Constraints

Memory Efficiency

GPU Utilization

Model Portability

Trace Down ↓

Use Case → Framework

Key Crates

Design Patterns

Code Pattern: Inference Server

Code Pattern: Batched Inference

Common Mistakes

Trace to Layer 1

Related Skills

Source and attribution

More from actionbook/rust-skills

Rust Trait Explorer

Rust Symbol Analyzer

Rust Skill Creator

Rust Router

Rust Refactor Helper

Rust Daily

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices

When	See
Performance	m10-performance
Lazy initialization	m12-lifecycle
Async patterns	m07-concurrency
Memory efficiency	m01-ownership