Rust पर मशीन लर्निंग: ML और डेटा साइंस के लिए लाइब्रेरीज़ का अवलोकन

Rust पर मशीन लर्निंग: आधुनिक लाइब्रेरीज़ और उपकरण

Rust भाषा, जो अपने प्रदर्शन और मेमोरी सुरक्षा के लिए जानी जाती है, सक्रिय रूप से मशीन लर्निंग (ML) के क्षेत्र में प्रवेश कर रही है। हालाँकि Rust पर ML पारिस्थितिकी तंत्र Python की तुलना में छोटा है, फिर भी यह मॉडल बनाने, प्रशिक्षित करने और तैनात करने के लिए परिपक्व समाधान प्रदान करता है। इस लेख में, हम उन प्रमुख लाइब्रेरीज़ की समीक्षा करेंगे जो Rust पर मशीन लर्निंग कार्यों को हल करने में सक्षम बनाती हैं, और व्यावहारिक उदाहरण प्रस्तुत करेंगे।

Rust मशीन लर्निंग के लिए क्यों?

Rust अद्वितीय लाभ प्रदान करता है:

• प्रदर्शन: Rust पर संकलित कोड गति में C/C++ के बराबर है, जो बड़े मॉडलों के प्रशिक्षण के लिए महत्वपूर्ण है।
• सुरक्षा: स्वामित्व (ownership) और उधार (borrowing) प्रणाली त्रुटियों (डेटा रेस, नल पॉइंटर्स) की पूरी श्रेणियों को समाप्त करती है।
• क्रॉस-प्लेटफ़ॉर्म: WebAssembly, मोबाइल उपकरणों और एम्बेडेड सिस्टम के लिए आसानी से संकलित होता है।
• Python के साथ एकीकरण: Rust पर उच्च-प्रदर्शन मॉड्यूल लिख सकते हैं और PyO3 के माध्यम से Python से कॉल कर सकते हैं।

Rust पर ML के लिए मुख्य लाइब्रेरीज़

1. Linfa — ML का स्विस आर्मी चाकू

Linfa Rust के लिए scikit-learn का एक एनालॉग है। यह मानक एल्गोरिदम के लिए एक एकीकृत इंटरफ़ेस प्रदान करता है। यह समर्थन करता है:

• रैखिक और लॉजिस्टिक रिग्रेशन
• सपोर्ट वेक्टर मशीन (SVM)
• क्लस्टरिंग (K-Means, DBSCAN)
• आयाम कम करने के तरीके (PCA)
• निर्णय वृक्ष और रैंडम फ़ॉरेस्ट

Linfa के साथ रैखिक रिग्रेशन का उदाहरण:

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

fn main() -> Result<(), Box<dyn std::error::Error>> {    // सिंथेटिक डेटा बनाएं: 100 बिंदु, 3 विशेषताएँ    let x = Array2::random((100, 3), rand::distributions::Uniform::new(-1.0, 1.0));    let true_weights = arr2(&[[2.0], [-1.0], [0.5]]);    let y = x.dot(&true_weights) + 0.1; // शोर जोड़ें

    let dataset = Dataset::new(x, y);        // मॉडल प्रशिक्षित करें    let model = LinearRegression::default().fit(&dataset)?;        // मॉडल गुणांक    println!("वज़न: {:?}", model.params());        // पूर्वानुमान    let predicted = model.predict(&dataset);    println!("MSE: {:?}", predicted.mean_squared_error(&dataset)?);        Ok(())}

2. Burn — गहन शिक्षण के लिए आधुनिक फ्रेमवर्क

Burn एक लचीला न्यूरल नेटवर्क फ्रेमवर्क है जो पूरी तरह से Rust में लिखा गया है। इसकी विशेषताएँ:

• GPU समर्थन (CUDA, Vulkan, Metal, WebGPU)
• स्वचालित विभेदन (autograd)
• लचीली बैकएंड प्रणाली (torch, ndarray, wgpu)
• डायनामिक कम्प्यूटेशन ग्राफ
• ONNX में निर्यात

Burn पर एक सरल न्यूरल नेटवर्क का उदाहरण:

use burn::tensor::{Tensor, backend::Backend};use burn::nn::{Linear, Relu, Sequential};

// नेटवर्क आर्किटेक्चर परिभाषित करेंstruct MyModel<B: Backend> {    linear1: Linear<B>,    linear2: Linear<B>,    activation: Relu,}

impl<B: Backend> MyModel<B> {    fn new(device: &B::Device) -> Self {        Self {            linear1: Linear::new(784, 256, device),            linear2: Linear::new(256, 10, device),            activation: Relu::new(),        }    }        fn forward(&self, input: Tensor<B, 2>) -> Tensor<B, 2> {        let x = self.linear1.forward(input);        let x = self.activation.forward(x);        self.linear2.forward(x)    }}

fn main() {    // CPU बैकएंड का उपयोग करें (ndarray)    type MyBackend = burn::backend::NdArray;    let device = Default::default();        let model = MyModel::<MyBackend>::new(&device);    let input = Tensor::<MyBackend, 2>::ra