Предиктивная аналитика на Rust + Python Altair и ИИ

Для чего нужна данная статья? :

Создать линейную регрессию, для предсказывания значения на основе некоторого набора данных с использованием библиотеки linfa.

Внедрить алгоритм AI/ML для получения информации и создания визуализаций (через привязки Python для Altair).

Зачем Вам это уметь? :

Для реализации предиктивной аналитики с использованием библиотек ndarray, smartcore, linfa.

Для интеграции с Python через FFI используя TensorFlow или PyTorch, для сложных задач предиктивной аналитики.

Для визуализации за счет внедрения алгоритмов AI/ML для получения информации и создания визуализаций (через привязки Python для Altair).

Линейная регрессия, для предсказывания значения на основе некоторого набора данных с использованием библиотеки linfa.

Сначала добавим необходимые зависимости в файл Cargo.toml:

[dependencies]

linfa = "0.6.1"

linfa-linear = "0.6.1"

ndarray = "0.15.4"

Далее создадим простую программу, которая выполняет линейную регрессию.

use linfa::prelude::*;

use linfa_linear::LinearRegression;

use ndarray::{array, Array2, Axis};

fn main() {

// Создаем данные для обучения

let x = array![

[1.0, 2.0],

[2.0, 3.0],

[3.0, 4.0],

[4.0, 5.0],

[5.0, 6.0]

];

let y = array![2.0, 3.0, 4.0, 5.0, 6.0];

// Создаем датасет

let dataset = Dataset::new(x, y);

// Инициализируем модель линейной регрессии

let model = LinearRegression::default();

// Обучаем модель на данных

let model = model.fit(&dataset).expect("Error fitting model");

// Делаем предсказания

let new_data = array![[6.0, 7.0]];

let prediction = model.predict(&new_data);

println!("Prediction: {:?}", prediction);

}

• Создание данных: Мы создаем двумерный массив x для признаков (features) и одномерный массив y для целевого значения (labels).
• Создание датасета: Используем структуру Dataset из linfa для создания датасета.
• Инициализация модели: Инициализируем модель линейной регрессии с помощью библиотеки linfa-linear.
• Обучение модели: Обучаем модель на предоставленных данных.
• Предсказания: Делаем предсказания для новых данных.

Для запуска этого примера, просто выполните команду:

cargo run

Если вы хотите интегрировать Rust с Python для использования библиотек, таких как TensorFlow или PyTorch, то можно использовать библиотеку pyo3. Приведу пример того, как это сделать:

Добавьте pyo3 в Cargo.toml:

[dependencies]

pyo3 = { version = "0.18", features = ["extension-module"] }

Создайте файл src/lib.rs для Rust-кода, который будет взаимодействовать с Python:

use pyo3::prelude::*;

use pyo3::wrap_pyfunction;

#[pyfunction]

fn predict(input: Vec<f64>) -> Vec<f64> {
// Вызов предсказаний
// Здесь мы просто возвращаем исходные данные как пример

input.iter().map(|&x| x * 2.0).collect()

}
#[pymodule]

fn my_predictor(_py: Python, m: &PyModule) -> PyResult<()> {

m.add_function(wrap_pyfunction!(predict, m)?)?;
Ok(())
}

Скомпилируйте и используйте этот модуль в Python:

maturin develop

Теперь вы можете использовать функцию predict в Python:

import my_predictor

result = my_predictor.predict([1.0, 2.0, 3.0])

print(result)

Внедрение алгоритма AI/ML для получения информации и создания визуализаций (через привязки Python для Altair).

Инструменты и библиотеки:

1. Rust : Для высокопроизводительной обработки данных.
2. PyO3 : для взаимодействия с Python и использования Altair для визуализации.
3. Smartcore : библиотека Rust для машинного обучения.
4. Altair : для интерактивной визуализации данных с помощью Python.

Пример использования: прогнозирование цен на жилье

Мы создадим историю данных о прогнозировании цен на жилье на основе исторических данных рынка жилья. Цель — продемонстрировать процесс сбора данных, обучения модели машинного обучения и визуализации результатов.

Шаги:

1. Сбор и предварительная обработка данных (Rust) polars : Rust будет использоваться для загрузки и предварительной обработки набора данных. Мы будем решать такие задачи, как подстановка пропущенных значений, масштабирование признаков и нормализация данных с помощью ящика Rust .
2. Анализ машинного обучения (Rust + AI) : используя библиотеку Rust smartcore, мы обучим регрессионную модель для прогнозирования цен на жилье. Мы подгоним модель, используя различные характеристики, такие как площадь в квадратных футах, количество спален и местоположение.
3. Визуализация (Altair через PyO3) : мы визуализируем как фактические, так и прогнозируемые цены на жилье с помощью Altair для создания наглядной интерактивной диаграммы, демонстрирующей эффективность модели.

1. Сбор и предварительная обработка данных

use polars::prelude::*;

use std::fs::File;

// Load dataset

fn load_data(file_path: &str) -> Result<DataFrame> {

let file = File::open(file_path)?;

let df = CsvReader::new(file)

.infer_schema(None)

.has_header(true)

.finish()?;
Ok(df) }

// Preprocess dataset ( remove missing values)

fn preprocess_data(mut df: DataFrame) -> DataFrame {

// Drop missing values

df.drop_nulls(None).unwrap() }

Здесь мы используем polars для загрузки и предварительной обработки наших данных. Затем мы можем перейти к обучению нашей модели.

2. Анализ машинного обучения с помощью Smartcore

use smartcore::linear::linear_regression::LinearRegression;

use smartcore::linalg::naive::dense_matrix::DenseMatrix;

use smartcore::metrics::mean_squared_error;

// Train a regression model

fn train_model(df: DataFrame) -> LinearRegression<f64, DenseMatrix<f64>> {
let y = df.column("Price").unwrap().f64().unwrap().to_owned();

// Target variable

let x = df.drop("Price").unwrap().to_ndarray::<f64>().unwrap();

// Feature matrix

let x_matrix = DenseMatrix::from_array(x.shape()[0], x.shape()[1], &x);

// Fit linear regression model

let lr = LinearRegression::fit(&x_matrix, &y, Default::default()).unwrap();

lr }

// Predict housing prices

fn predict_model(lr: &LinearRegression<f64, DenseMatrix<f64>>, x:

&DenseMatrix<f64>) -> Vec<f64> {

lr.predict(x).unwrap()

}

Мы используем smartcore

для обучения простой линейной регрессионной модели. Затем модель используется для прогнозирования цен на жилье.

3. Визуализация с помощью Altair с использованием PyO3

Для визуализации данных в Rust мы будем использовать PyO3вызов библиотеки Python Altair. Это позволяет нам без проблем использовать Altair для интерактивных диаграмм.

Сначала установите PyO3 и настройте среду Python для включения Altair.

[dependencies] pyo3 = { version = "0.15", features = ["extension-module"] }

use pyo3::prelude::*;

use pyo3::types::IntoPyDict;

// Generate Altair chart using Python

fn create_chart(data: &Vec<f64>, predicted: &Vec<f64>) {

Python::with_gil(|py| {

let altair = py.import("altair").unwrap();

let pd = py.import("pandas").unwrap();

// Convert data to pandas DataFrame

let locals = [("pd", pd)].into_py_dict(py);

let df = py.eval("pd.DataFrame({'Actual': data, 'Predicted': predicted})",

None, Some(locals)).unwrap();

// Create Altair chart

let chart = altair.call_method1("Chart", (df,)).unwrap()

.call_method1("mark_line", ()) // Line chart .unwrap()

.call_method1("encode", (("x", "Actual"), ("y", "Predicted")))

.unwrap();

chart.call_method0("show").unwrap();

});

}

В этой функции мы используем PyO3 для создания pandas DataFrame и генерации линейной диаграммы Altair. Диаграмма показывает как фактические, так и прогнозируемые цены на жилье, что позволяет легко сравнивать.

Полный рабочий процесс

fn main() {
// Load and preprocess data

let df = load_data("housing_data.csv").unwrap();

let df_clean = preprocess_data(df);

// Train model and make predictions

let model = train_model(df_clean.clone());

let predictions = predict_model(&model, &df_clean);

// Visualize results

create_chart(&df_clean.column("Price").unwrap().f64().unwrap().to_vec(),

&predictions);

}