The Beginner’s Guide to Machine Learning with Rust

 

The Beginner’s Guide to Machine Learning with Rust
Image by Editor | Midjourney

Machine learning has become an essential tool for solving complex problems across various domains, from finance to healthcare. While languages like Python and R dominate the machine learning landscape, Rust is emerging as a powerful alternative due to its performance, safety, and concurrency features.

Rust’s memory safety guarantees and zero-cost abstractions make it an excellent choice for building high-performance machine learning applications, especially when working with large datasets or real-time processing. Though the Rust machine learning ecosystem is still growing, libraries like ndarray, tch-rs (Torch for Rust), and linfa are making it easier to implement machine learning models.

In this article, we’ll explore the fundamentals of machine learning in Rust, walk through essential libraries, and build a simple machine learning model. Whether you’re a Rust developer curious about machine learning or an machine learning practitioner looking for a high-performance alternative, this article will help you get started.

Why Rust for Machine Learning?

Rust is becoming popular in the machine learning community for several reasons:

• Memory Safety: Rust prevents bugs like null pointer errors and buffer overflows. This makes machine learning code safer.
• High Performance: Rust runs as fast as C and C++. It has no garbage collection, so machine learning models run efficiently.
• Concurrency: Rust supports parallel computing. It helps machine learning models run faster on multi-core processors.
• Interoperability: Rust works well with C and Python. You can use existing machine learning frameworks while getting Rust’s speed benefits.

Setting Up Your Rust Environment

Before using machine learning in Rust, you need to set up your tools.

Installing Rust

Use Rustup to install Rust. Run this command:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

After installation, check if Rust is installed:

cargo --version

Setting Up a Rust Project

Use Cargo to start a new project:

cargo new ml_project cd ml_project

This initializes a new Rust project with a basic structure.

Adding Dependencies

To use machine learning libraries — or crates, in Rust — add the necessary dependencies. A Rust crate is a package of Rust code that cargo compiles into either a binary or a library. It contains the project’s source code, metadata, and dependency information, making it easy to distribute and reuse code across different projects. When a crate is intended for use as reusable functionality rather than as an executable, it is often referred to as a library crate, or even simply a library.

cargo add ndarray linfa linfa-datasets tch-rs

Run cargo build to fetch the dependencies and compile the project.

Overview of Popular Rust Machine Learning Libraries

Here are some of the most widely used machine learning libraries in Rust:

• SmartCore: A comprehensive machine learning library that provides algorithms for classification, regression, clustering, and more. It is a great choice for traditional machine learning applications.
• Linfa: A simple and flexible machine learning framework. It includes basic algorithms like support vector machines and k-nearest neighbors.
• Ndarray: Ndarray is not an machine learning library, but it is important for math in Rust. It works like NumPy in Python.
• tch-rs: A Rust library that connects to PyTorch. It helps build deep learning applications using the Torch system.

Building a Simple Machine Learning Model in Rust

Loading and Preprocessing Data

Before training an machine learning model, we need to prepare data. Rust provides libraries like ndarray and csv for handling datasets. Here’s an example of loading a dataset:

use ndarray::Array2; use std::error::Error; use csv::Reader;   fn load_data(file_path: &str) -> Result<Array2<f64>, Box<dyn Error>> {     let mut reader = Reader::from_path(file_path)?;     let data: Vec = reader.records()         .filter_map(|r| r.ok())         .flat_map(|r| r.iter().map(|val| val.parse::<f64>().unwrap_or(0.0)))         .collect();     Ok(Array2::from_shape_vec((data.len() / 4, 4), data)?) }

An explanation of the above code:

1. Opens a CSV file at the given file path using the csv crate
2. Iterates over each record in the CSV, filtering out any errors during record reading
3. Parses each field in every record into a floating point number (f64), defaulting to 0.0 if parsing fails
4. Flattens the parsed numbers into a single vector and reshapes it into a 2D array with 4 columns using the ndarray crate

Training a Model

Using linfa, we can train a simple logistic regression model:

use linfa::prelude::*; use linfa::Dataset; use linfa_logistic::LogisticRegression;   fn train_model(dataset: Dataset) -> Result<LogisticRegression, Box<dyn std::error::Error>> {     let model = LogisticRegression::default().fit(&dataset)?;     Ok(model) }

What the code is doing:

• Initializes a logistic regression model with default parameters
• Trains the model using the provided dataset
• Propagates any errors encountered during training
• Returns the trained model upon successful fitting

Evaluating Model Performance

Once trained, we can evaluate the model:

fn evaluate_model(model: &LogisticRegression, dataset: &Dataset) -> Result<(), Box<dyn std::error::Error>> {     let accuracy = model.predict(dataset).mean().ok_or("Failed to compute mean")?;     println!("Model Accuracy: {:.2}%", accuracy * 100.0);     Ok(()) }

Here is what the code above is doing:

• Computes predictions using the logistic regression model on the provided dataset
• Calculates the mean of the predictions to determine model accuracy
• Prints the accuracy as a percentage
• Returns an error if the accuracy calculation fails

Working with Neural Networks in Rust

Rust can be used for deep learning via the tch-rs library, which is a binding for PyTorch. It provides tensor operations and model-building capabilities.

use tch::{nn, nn::Module, Device, Tensor};   fn build_nn(vs: &nn::Path) -> impl nn::Module {     nn::seq()         .add(nn::linear(vs, 784, 128, Default::default()))         .add_fn(|xs| xs.relu())         .add(nn::linear(vs, 128, 10, Default::default())) }

In the above code:

• Imports necessary modules from the tch crate
• Constructs a sequential neural network
• Adds a linear layer converting 784 inputs to 128 outputs, followed by a ReLU activation
• Adds a final linear layer that maps 128 features to 10 outputs

Integrating Rust with Other Machine Learning Frameworks

Rust is fast, safe, and good at handling multiple tasks. Its machine learning ecosystem is still growing. Many machine learning frameworks, like TensorFlow and PyTorch, use Python or C++. Rust can work with these frameworks. This combines Rust’s speed with powerful machine learning tools.

Two primary approaches to integrating Rust with other machine learning frameworks are:

• Using Rust with Python (PyO3): Calling Rust functions from Python to improve performance
• Deploying machine learning Models in Rust: Running pre-trained models in Rust for efficient inference

Using Rust with Python (PyO3)

Python is popular in machine learning with libraries like NumPy, TensorFlow, and PyTorch. However, Python’s performance limitations can be a bottleneck for certain tasks. The PyO3 library helps connect Rust with Python. It lets you compile Rust code into a Python extension. You can then use it like a normal Python module.

Let’s say we want to speed up a simple mathematical operation using Rust.

First, create a Rust crate library:

cargo new --lib rust_ml_extension cd rust_ml_extension

Next, add PyO3 to Cargo.toml:

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

Then write Rust code for the Python extension (lib.rs):

use pyo3::prelude::*;   #[pyfunction] fn square(x: f64) -> f64 {     x * x }   #[pymodule] fn rust_ml_extension(_py: Python, m: &PyModule) -> PyResult<()> {     m.add_function(wrap_pyfunction!(square, m)?)?;     Ok(()) }

Deploying Machine Learning Models in Rust

After training a machine learning model in Python, it must be deployed for use. ONNX is a format that works across different platforms. Rust has a library to run ONNX models. This makes it easy to use trained models in Rust programs.

Let’s take a look at the steps to use ONNX with Rust.

First, add ONNX Runtime to Cargo.toml:

[dependencies] onnxruntime = "0.15"

Then load and run an ONNX model in Rust:

use onnxruntime::{environment::Environment, session::Session};   fn main() -> Result<(), Box<dyn std::error::Error>> {     let environment = Environment::builder().build()?;     let session = Session::new(&environment, "model.onnx")?;          // Input data processing and inference code here          Ok(()) }

Real-World Applications

Rust’s growing ecosystem and performance benefits make it a great choice for machine learning applications. While still maturing compared to Python, Rust is already being used in various real-world machine learning projects where speed, safety, and efficiency are important.

Financial Market Prediction

Rust’s low latency and concurrency capabilities make it an excellent fit for high-frequency trading (HFT) and financial forecasting. Machine learning models can analyze stock market trends and execute trades in microseconds.

Cybersecurity and Fraud Detection

Machine learning is widely used in cybersecurity to detect anomalies in network traffic and prevent fraud in online transactions. Rust’s strong type safety ensures security tools are less prone to vulnerabilities.

Autonomous Vehicles

Self-driving cars and drones rely on machine learning models for object detection and navigation. Rust’s low-level control and real-time processing capabilities make it an perfect choice for embedded AI applications.

Rust-Based AI Chatbots

Natural language processing (NLP) models power chatbots, voice assistants, and text analytics tools. Rust’s efficiency makes it a great option for processing large-scale text data.

Conclusion

Rust is emerging as a powerful language for machine learning, offering safety, speed, and interoperability with existing frameworks. While the ecosystem is still growing, libraries (crates) like linfa and tch-rs make it possible to build machine learning models. Additionally, Rust’s seamless integration with Python via PyO3 and its ability to deploy models using ONNX lets developers to leverage the best of both worlds — Rust’s performance and Python’s extensive machine learning ecosystem.