🤖 Как написать собственного ИИ на Rust

ИИ Rust машинное обучение нейросети LLM

Создание искусственного интеллекта — это увлекательное путешествие, которое стало доступнее благодаря экосистеме Rust. В этой статье мы разберём как написать собственный ИИ на Rust — от маленьких обучаемых моделей до развёртывания больших языковых моделей (LLM), с кодом, библиотеками и архитектурными решениями.

1. 🧠 Зачем Rust для ИИ?

Rust предлагает сочетание, которое делает его привлекательным для систем ИИ:

Безопасность памяти: компилятор исключает целые классы ошибок, критичных для долгих инференс-процессов.
Производительность: Rust компилируется в машинный код и не уступает C++.
Экосистема: активно растёт — от тензорных библиотек до готовых ML-фреймворков.

💡 Сравнение с Python: Rust даёт контроль над памятью и скорость исполнения, что критично для продакшн-систем, в то время как Python остаётся лидером по скорости прототипирования [citation:2].

2. 🔧 Инструментарий: ключевые библиотеки

Библиотека	Назначение	Аналог в Python
tch-rs	Обёртка над PyTorch C++ API	PyTorch
candle	Минималистичный ML-фреймворк	PyTorch
linfa	Классическое ML (scikit-learn-подобный)	scikit-learn
llama-cpp-rs	Взаимодействие с GGUF-моделями	llama-cpp-python

💡 Выбор инструмента:

tch-rs и candle — для нейросетей и глубокого обучения.
linfa — для классических алгоритмов: линейная регрессия, кластеризация, наивный Байес [citation:2][citation:7].
llama-cpp-rs — для работы с большими языковыми моделями [citation:9].

3. 📈 Классический ML: линейная регрессия на Linfa

Начнём с простого: линейная регрессия. Для этого используем крейт linfa-linear.

Шаг 1: Добавляем зависимости


[dependencies]
linfa = "0.5.0"
linfa-linear = "0.5.0"
ndarray = "0.15.4"

Шаг 2: Генерируем данные

Создаём синтетический датасет y = 2x + 1 [citation:2].


use ndarray::{Array2, s};
 
fn generate_data() -> Array2<f64> {
    let x = Array2::from_shape_vec((10, 1), vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]).unwrap();
    let y = x.mapv(|v| 2.0 * v + 1.0);
    ndarray::stack(ndarray::Axis(1), &[x.view(), y.view()]).unwrap()
}

Шаг 3: Обучаем модель


use linfa::prelude::*;
use linfa_linear::LinearRegression;
 
fn train_model(data: Array2<f64>) -> LinearRegression<f64> {
    let (x, y) = (data.slice(s![.., 0..1]).to_owned(), data.slice(s![.., 1..2]).to_owned());
    LinearRegression::default().fit(&x, &y).unwrap()
}

Шаг 4: Предсказания

fn main() {
    let data = generate_data();
    let model = train_model(data);
    let input = Array2::from_shape_vec((5, 1), vec![11.0, 12.0, 13.0, 14.0, 15.0]).unwrap();
    let predictions = model.predict(&input);
    println!("Предсказания: {:?}", predictions);
}

Результат:

[[23.0], [25.0], [27.0], [29.0], [31.0]] , что соответствует 2x+1 [citation:2].

4. 🧠 Нейросети: MNIST на tch-rs

Для глубокого обучения используем tch-rs — обёртку над PyTorch [citation:3][citation:8].

Зависимости


[dependencies]
tch = "0.2.1"

Определяем нейросеть


use tch::{nn, nn::Module, nn::OptimizerConfig, Device};
 
const IMAGE_DIM: i64 = 784;
const HIDDEN_NODES: i64 = 128;
const LABELS: i64 = 10;
 
fn net(vs: &nn::Path) -> impl Module {
    nn::seq()
        .add(nn::linear(vs / "layer1", IMAGE_DIM, HIDDEN_NODES, Default::default()))
        .add_fn(|xs| xs.relu())
        .add(nn::linear(vs / "layer2", HIDDEN_NODES, LABELS, Default::default()))
}

Тренировочный цикл (упрощённо)


pub fn run() -> anyhow::Result<()> {
    let vs = nn::VarStore::new(Device::Cpu);
    let model = net(&vs.root());
 
    // ... загрузка данных MNIST ...
 
    let mut opt = nn::Adam::default().build(&vs, 1e-3)?;
 
    for epoch in 0..50 {
        // ... итерация по батчам ...
        let loss = model.forward(&input).cross_entropy_for_logits(&target);
        opt.backward_step(&loss);
    }
    Ok(())
}

📌 Что происходит:

Сеть: входной слой (784 пикселя) → скрытый слой (128) → выход (10 классов).
Функция активации: ReLU.
Оптимизатор: Adam.
Loss: CrossEntropy.

Полный код обучения на MNIST доступен в примерах tch-rs [citation:3][citation:8].

5. 🗣️ Большие языковые модели (LLM) на Rust

Для работы с современными LLM (LLaMA, Mistral, Qwen) есть два основных подхода:

Подход 1: `llama-cpp-rs`

Высокоуровневая обёртка над llama.cpp, поддерживает GGUF-формат и CUDA [citation:9].

# Сборка и запуск простого примера
cargo run --release --bin simple -- --prompt "Как убить процесс в Linux —" hf-model TheBloke/Llama-2-7B-GGUF llama-2-7b.Q4_K_M.gguf

Подход 2: `candle`

Минималистичный фреймворк, поддерживающий множество моделей: LLaMA, Mistral, Phi, Whisper, Stable Diffusion и другие [citation:10].

# Пример запуска квантованной модели
cargo run --example quantized --release

💡 Совет: Для быстрого старта с LLM:

Скачай GGUF-модель с Hugging Face.
Используй llama-cpp-rs или candle.
Запускай с минимальными требованиями: 8–16 ГБ RAM.

6. 🕵️ Создание простого AI-агента

Если не хочется использовать тяжёлые фреймворки, можно построить агента на базе цикла наблюдать → решать → действовать → рефлексировать [citation:6].

Наблюдение: агент читает входные данные и логи.
Решение: отправляет запрос к модели (через llama-cpp-rs или candle).
Действие: выполняет вызов инструментов (чтение/запись файлов, работа с API).
Рефлексия: записывает результаты в журнал для улучшения решений.


fn agent_loop() {
    loop {
        let input = read_input();
        let action = ask_model(&input);
        execute_action(&action);
        log_result(&action);
    }
}

🧪 Этот подход:

Не требует сложных фреймворков.
Даёт полный контроль над потоком данных.
Может быть реализован за несколько часов [citation:6].

7. 📊 Сравнение подходов

Задача	Рекомендуемый инструмент	Сложность
Линейная регрессия	`linfa-linear`	⭐
Кластеризация (K-Means)	`linfa-clustering`	⭐⭐
Нейросеть (MNIST)	`tch-rs`	⭐⭐⭐
LLM (локально)	`llama-cpp-rs`	⭐⭐⭐
LLM (высокопроизводительно)	`candle`	⭐⭐⭐

8. ❌ Ошибки новичков

❌ Игнорирование устройства: всегда указывай Device::Cpu или Device::Cuda(0) в тензорах [citation:10].
❌ Неправильные версии библиотек: tch-rs и linfa активно обновляются.
❌ Отсутствие оптимизации: используй --release при сборке.
❌ Забывают про квантование: для LLM всегда используй GGUF-формат, чтобы экономить память [citation:9].

9. 🧠 Материалы для изучения

Официальная документация: tch, linfa, candle.
Примеры кода: репозитории tch-rs/examples [citation:3][citation:8].
Сообщества: GyaanSetu AI (LinkedIn), где разработчики делятся опытом [citation:6].

🎯 Итог

Написать собственный ИИ на Rust — вполне реально. У тебя есть выбор:

Для классических задач: linfa.
Для нейросетей: tch-rs или candle.
Для LLM: llama-cpp-rs или candle.
Для экспериментов: собственный агент на файловой системе и цикле.

Главное — начать с простого, изучить библиотеки и не бояться экспериментировать.