今天，我們將聊聊 Rust 在機器學習和資料科學領域的應用。雖然 Python 是這些領域的主流語言，但 Rust 的高效能和內存安全性使其成為處理大量資料與實作複雜演算法的有力工具。我們將探討如何使用 Rust 進行資料處理、實作機器學習演算法，並與 Python 生態系統進行整合

1. 使用 ndarray 進行數值計算

ndarray 是 Rust 中一個強大的多維數組運算庫，類似於 Python 的 NumPy，適合用於資料處理和科學運算。

use ndarray::{arr2, Array2};

fn main() {
    let a = arr2(&[[1, 2, 3],
                   [4, 5, 6]]);
    let b = arr2(&[[6, 5, 4],
                   [3, 2, 1]]);

    let c = &a + &b;
    println!("矩陣加法結果：\n{:?}", c);

    let d = a.dot(&b.t());
    println!("矩陣乘法結果：\n{:?}", d);
}

2. 使用 linfa 實作機器學習演算法

linfa 是一個純 Rust 的機器學習庫，提供多種常見的機器學習演算法，例如 k-means、邏輯迴歸等，適合構建簡單且高效的機器學習模型。

use linfa::prelude::*;
use linfa_clustering::KMeans;
use ndarray::{array, Array2};

fn main() {
    let data = array![
        [1.0, 2.0],
        [1.1, 2.1],
        [0.9, 1.9],
        [4.0, 4.0],
        [4.1, 4.1],
        [3.9, 3.9],
    ];
    let dataset = Dataset::from(data);

    let model = KMeans::params(2)
        .fit(&dataset)
        .expect("KMeans 算法失敗");

    let predictions = model.predict(&dataset);
    println!("聚類結果：{:?}", predictions);
}

3. 使用 polars 進行資料處理

polars 是一個用於高效能資料分析與處理的庫，類似於 Python 的 pandas，能夠快速操作大型資料集。

use polars::prelude::*;

fn main() -> Result<(), PolarsError> {
    let df = df![
        "A" => [1, 2, 3, 4, 5],
        "B" => ["a", "b", "c", "d", "e"],
        "C" => [1.0, 2.0, 3.0, 4.0, 5.0]
    ]?;

    println!("{}", df);

    let filtered = df.filter(&df["A"].gt(2))?;
    println!("篩選結果：\n{}", filtered);

    Ok(())
}

4. 使用 tch-rs 實作深度學習模型

tch-rs 是 PyTorch 的 Rust 綁定，讓我們能夠使用 PyTorch 的強大功能在 Rust 中進行深度學習開發。

use tch::{nn, nn::Module, nn::OptimizerConfig, Device};

fn main() {
    let vs = nn::VarStore::new(Device::Cpu);
    let net = nn::seq()
        .add(nn::linear(&vs.root(), 784, 128, Default::default()))
        .add_fn(|xs| xs.relu())
        .add(nn::linear(&vs.root(), 128, 10, Default::default()));

    let mut opt = nn::Adam::default().build(&vs, 1e-3).unwrap();
    
    // 這裡應該加入訓練循環
    // for epoch in 1..100 {
    //     // 計算損失並進行反向傳播
    //     let loss = net.forward(&images) ... ;
    //     opt.backward_step(&loss);
    // }
}

5. 使用 pyo3 與 Python 整合

pyo3 是一個強大的庫，能夠讓我們將 Rust 與 Python 整合，並且可以用來編寫 Python 擴展模組或調用 Python 函數。

use pyo3::prelude::*;
use pyo3::wrap_pyfunction;

#[pyfunction]
fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
    Ok((a + b).to_string())
}

#[pymodule]
fn rust_extension(_py: Python, m: &PyModule) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;
    Ok(())
}

6. 實作簡單的線性迴歸

以下是一個基本的線性迴歸實作範例，展示如何使用 Rust 來實作機器學習演算法。

use ndarray::{Array1, Array2};

struct LinearRegression {
    coefficients: Array1<f64>,
    intercept: f64,
}

impl LinearRegression {
    fn new() -> Self {
        LinearRegression {
            coefficients: Array1::zeros(0),
            intercept: 0.0,
        }
    }

    fn fit(&mut self, x: &Array2<f64>, y: &Array1<f64>) {
        let x_mean = x.mean_axis(ndarray::Axis(0)).unwrap();
        let y_mean = y.mean().unwrap();

        let numerator = x.t().dot(&y) - &x_mean * y.sum();
        let denominator = x.t().dot(x) - &x_mean * x.sum();

        self.coefficients = numerator / denominator;
        self.intercept = y_mean - self.coefficients.dot(&x_mean);
    }

    fn predict(&self, x: &Array2<f64>) -> Array1<f64> {
        x.dot(&self.coefficients) + self.intercept
    }
}

fn main() {
    let x = Array2::from_shape_vec((5, 1), vec![1.0, 2.0, 3.0, 4.0, 5.0]).unwrap();
    let y = Array1::from_vec(vec![2.0, 4.0, 6.0, 8.0, 10.0]);

    let mut model = LinearRegression::new();
    model.fit(&x, &y);

    let predictions = model.predict(&x);
    println!("預測結果：{:?}", predictions);
}

結論

Rust 在機器學習與資料科學領域展現了巨大的潛力。它的高效能和內存安全特性，特別適合處理大量資料和實作複雜的演算法。雖然 Rust 在這些領域的生態系統尚未如 Python 成熟，但它正在快速發展，並在需要高效能與安全性的應用場景中展現出不可忽視的優勢，再次提到了那家量化公司，他們使用Rust打造出處理10TB資料和運算決策到給出決策只需要幾秒，甚至比編譯Rust的時間還快，代表著未來Rust在這種需要快速運算的場域會越來越重要。