domain-ml

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Machine Learning Domain

机器学习领域

Layer 3: Domain Constraints

第3层：领域约束

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

领域规则	设计约束	Rust 实现要点
大数据量	高效内存利用	零拷贝、流式处理
GPU加速	CUDA/Metal支持	candle, tch-rs
模型可移植性	标准格式	ONNX
批量处理	吞吐量优先于延迟	批量推理
数值精度	浮点数处理	ndarray、谨慎使用f32/f64
可复现性	确定性	种子随机数、版本控制

Critical Constraints

关键约束

Memory Efficiency

内存效率

RULE: Avoid copying large tensors
WHY: Memory bandwidth is bottleneck
RUST: References, views, in-place ops

规则：避免复制大型张量
原因：内存带宽是瓶颈
Rust实现：引用、视图、原地操作

GPU Utilization

GPU利用率

RULE: Batch operations for GPU efficiency
WHY: GPU overhead per kernel launch
RUST: Batch sizes, async data loading

规则：批量操作提升GPU效率
原因：GPU核函数启动存在开销
Rust实现：批量大小、异步数据加载

Model Portability

模型可移植性

RULE: Use standard model formats
WHY: Train in Python, deploy in Rust
RUST: ONNX via tract or candle

规则：使用标准模型格式
原因：在Python中训练，在Rust中部署
Rust实现：通过tract或candle使用ONNX

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

从约束到设计（第2层）：

"需要高效的数据流水线"
    ↓ m10-performance: 流式处理、批量处理
    ↓ polars: 惰性求值

"需要GPU推理"
    ↓ m07-concurrency: 异步数据加载
    ↓ candle/tch-rs: CUDA后端

"需要模型加载"
    ↓ m12-lifecycle: 惰性初始化、缓存
    ↓ tract: ONNX运行时

Use Case → Framework

使用场景 → 框架选择

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

使用场景	推荐方案	原因
仅推理场景	tract (ONNX)	轻量、可移植
训练+推理场景	candle, burn	纯Rust实现、支持GPU
PyTorch模型	tch-rs	直接绑定
数据流水线	polars	快速、惰性求值

Key Crates

关键依赖库（Crates）

Purpose	Crate
Tensors	ndarray
ONNX inference	tract
ML framework	candle, burn
PyTorch bindings	tch-rs
Data processing	polars
Embeddings	fastembed

用途	Crate
张量处理	ndarray
ONNX推理	tract
机器学习框架	candle, burn
PyTorch绑定	tch-rs
数据处理	polars
嵌入向量处理	fastembed

Design Patterns

设计模式

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

模式	用途	实现方式
模型加载	一次性加载、复用	`OnceLock<Model>`
批量处理	提升吞吐量	先收集再处理
流式处理	处理大数据量	基于迭代器
GPU异步处理	并行处理	数据加载与计算并行

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())
}

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())
}

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
}

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) {
        // 堆叠输入为批量张量
        let batch_tensor = stack_inputs(batch);

        // 对批量数据执行推理
        let batch_output = model.run(batch_tensor).await;

        // 拆分结果
        results.extend(unstack_outputs(batch_output));
    }

    results
}

Common Mistakes

常见错误

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

错误做法	违反的领域原则	修复方案
复制张量	内存浪费	使用视图
单条推理	GPU利用率不足	批量处理
每次请求加载模型	性能缓慢	单例模式
同步数据加载	GPU空闲	异步流水线

Trace to Layer 1

追溯到第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

约束	第2层模式	第1层实现
内存效率	零拷贝	ndarray视图
模型单例	惰性初始化	OnceLock<Model>
批量处理	分块迭代	chunks() + 并行处理
GPU异步处理	并发加载	tokio::spawn + GPU

domain-ml

Original

Translation

Machine Learning Domain

机器学习领域

Domain Constraints → Design Implications

领域约束 → 设计影响

Critical Constraints

关键约束

Memory Efficiency

内存效率

GPU Utilization

GPU利用率

Model Portability

模型可移植性

Trace Down ↓

向下追溯 ↓

Use Case → Framework

使用场景 → 框架选择

Key Crates

关键依赖库（Crates）

Design Patterns

设计模式

Code Pattern: Inference Server

代码模式：推理服务器

Code Pattern: Batched Inference

代码模式：批量推理

Common Mistakes

常见错误

Trace to Layer 1

追溯到第1层

Related Skills

相关技能

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

适用场景	参考内容
性能优化	m10-performance
惰性初始化	m12-lifecycle
异步模式	m07-concurrency
内存效率	m01-ownership