Rust для машинного обучения: возможности и ограничения на практике

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Введение: Почему Rust в машинном обучении?

Мир машинного обучения долгое время безраздельно принадлежал Python. Однако с ростом объёмов данных и требований к производительности инженеры всё чаще обращают внимание на системные языки. Rust — один из главных кандидатов на роль "ускорителя" для ML-пайплайнов. Он предлагает производительность C/C++ с уникальной гарантией безопасности памяти.

Но готов ли Rust заменить Python в задачах ML? В этой статье мы разберём реальные возможности языка, его ограничения и покажем практические примеры кода. Вы узнаете, где Rust действительно силён, а где пока уступает зрелому экосистеме Python.

Ключевые преимущества Rust для машинного обучения

1. Производительность без компромиссов

Rust компилируется в нативный код и не использует сборщик мусора. Это даёт предсказуемую производительность на уровне C++. Для ML это критично при работе с большими тензорами, матричными операциями и циклами обучения.

Пример: простой цикл для вычисления суммы квадратов. В Python с NumPy это быстро, но если нужно написать кастомную операцию — скорость падает.

// Rust: быстрая кастомная операция
fn sum_of_squares(data: &[f64]) -> f64 {
    data.iter().map(|x| x * x).sum()
}

fn main() {
    let data: Vec<f64> = (0..1_000_000).map(|x| x as f64).collect();
    let start = std::time::Instant::now();
    let result = sum_of_squares(&data);
    let duration = start.elapsed();
    println!("Результат: {}, время: {:?}", result, duration);
}

Этот код выполняется за миллисекунды. Аналогичный чистый Python-цикл будет в десятки раз медленнее.

2. Безопасность памяти на уровне компилятора

В ML часто работают с многопоточностью: параллельная загрузка данных, распределённое обучение. Rust гарантирует отсутствие гонок данных (data races) на этапе компиляции. Это исключает целый класс багов, которые в Python ловятся только в рантайме.

3. Современная экосистема: linfa и burn

Два главных фреймворка для ML на Rust:

linfa — аналог scikit-learn. Реализует линейную регрессию, SVM, кластеризацию, PCA.
burn — фреймворк для глубокого обучения с поддержкой GPU (CUDA, Vulkan, WebGPU).

Пример: обучение линейной регрессии с помощью linfa:

use linfa::prelude::*;
use linfa_linear::LinearRegression;
use ndarray::Array2;

fn main() {
    // Данные: x = [[1], [2], [3]], y = [2, 4, 6]
    let x = Array2::from_shape_vec((3, 1), vec![1.0, 2.0, 3.0]).unwrap();
    let y = vec![2.0, 4.0, 6.0];

    let dataset = Dataset::new(x, y);
    let model = LinearRegression::default().fit(&dataset).unwrap();

    println!("Коэффициент: {:?}", model.params());
}

Код лаконичен, типизирован и безопасен.

Ограничения Rust в ML: что нужно знать

1. Малое количество готовых моделей

В Python для любой задачи есть библиотека: sklearn, xgboost, transformers. В Rust выбор ограничен. Нет нативных реализаций градиентного бустинга (XGBoost/LightGBM) или сложных трансформеров. Придётся либо писать с нуля, либо использовать FFI-привязки к C/C++.

2. Отсутствие интерактивной среды

Jupyter Notebook — стандарт для прототипирования ML. Rust не имеет аналогичного инструмента. Есть evcxr (Rust Kernel для Jupyter), но он работает медленно и не поддерживает все фичи языка.

3. Крутой порог входа

Rust сложен для новичков. Система владения (ownership), заимствования (borrowing) и времени жизни (lifetimes) требует времени на освоение. Для быстрого прототипирования Python остаётся королём.

4. Экосистема в стадии роста

Библиотеки типа burn активно развиваются, но API часто меняется. Документация неполная, а сообщество малочисленнее, чем у Python. Найти готовое решение для нестандартной задачи сложно.

Где Rust уже побеждает Python?

1. Предобработка данных и ETL

Rust отлично подходит для написания высокопроизводительных пайплайнов обработки данных. Библиотека polars (аналог pandas) работает в разы быстрее и потребляет меньше памяти.

use polars::prelude::*;

fn main() -> Result<()> {
    let df = CsvReader::from_path("data.csv")?
        .with_columns(Some(vec!["feature1", "feature2"]))
        .finish()?;

    let result = df
        .lazy()
        .filter(col("feature1").gt(lit(0.5)))
        .group_by([col("category")])
        .agg([col("feature2").mean()])
        .collect()?;

    println!("{:?}", result);
    Ok(())
}

Для задач, где Python падает из-за нехватки памяти, Rust — спасение.

2. Инференс моделей на продакшене

Rust идеален для сервисов, где важна низкая задержка (low latency). Вы можете обучить модель на Python, сохранить её в ONNX или TensorFlow SavedModel, а затем загрузить и выполнять инференс на Rust через tract или ort.

use ort::Environment;

fn main() -> ort::Result<()> {
    let env = Environment::builder().build()?;
    let session = env.new_session_builder()?
        .with_model_from_file("model.onnx")?;

    let input = ndarray::Array2::from_shape_vec((1, 10), vec![0.5f32; 10])?;
    let outputs = session.run(vec![input.into()])?;
    
    println!("Результат инференса: {:?}", outputs[0]);
    Ok(())
}