Rust में मशीन लर्निंग: लाइब्रेरीज़ और टूल्स

Rust में मशीन लर्निंग: Data Science के लिए लाइब्रेरीज़ और टूल्स

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

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

परंपरागत रूप से ML डेवलपमेंट Python में की जाती है क्योंकि इसकी समृद्ध इकोसिस्टम (TensorFlow, PyTorch, scikit-learn) है। हालांकि, Python की स्पीड और मेमोरी खपत की सीमाएँ हैं। Rust प्रदान करता है:

C/C++ के स्तर की परफॉरमेंस — हाई-लोड इन्फरेंस और बड़े डेटा पर ट्रेनिंग के लिए आदर्श।
मेमोरी सुरक्षा — कंपाइलर मेमोरी लीक और डेटा रेस को रोकता है।
Python के साथ इंटीग्रेशन — PyO3 के ज़रिए Python कोड के लिए तेज़ Rust एक्सटेंशन बनाए जा सकते हैं।
एम्बेडेबिलिटी — IoT, वेब सर्विसेज़ और एज डिवाइसेज़ के लिए उपयुक्त।

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

1. Linfa — scikit-learn का Rust वर्ज़न

Linfa क्लासिकल मशीन लर्निंग एल्गोरिदम के लिए एक फ्रेमवर्क है। यह मॉड्यूलर आर्किटेक्चर प्रदान करता है, जहाँ हर एल्गोरिदम एक अलग क्रेट में लागू किया गया है। सपोर्ट करता है:

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

उदाहरण: लीनियर रिग्रेशन

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

fn main() {
    // ट्रेनिंग डेटा: X (फीचर्स), y (टार्गेट वेरिएबल)
    let x = Array2::from_shape_vec((5, 1), vec![1.0, 2.0, 3.0, 4.0, 5.0]).unwrap();
    let y = Array2::from_shape_vec((5, 1), vec![2.0, 4.0, 6.0, 8.0, 10.0]).unwrap();
    
    let dataset = Dataset::new(x, y);
    let model = LinearRegression::default().fit(&dataset).unwrap();
    
    // प्रेडिक्शन
    let test_x = Array2::from_shape_vec((1, 1), vec![6.0]).unwrap();
    let prediction = model.predict(&test_x);
    println!("प्रेडिक्टेड वैल्यू: {:?}", prediction);
}

2. Burn — न्यूरल नेटवर्क और डीप लर्निंग

Burn Rust में लिखा गया एक आधुनिक डीप लर्निंग फ्रेमवर्क है। यह सपोर्ट करता है:

ऑटोमैटिक डिफरेंशिएशन
विभिन्न बैकएंड: CPU (ndarray), GPU (CUDA, Vulkan)
कन्वोल्यूशनल और रिकरंट नेटवर्क
ऑप्टिमाइज़र (Adam, SGD)

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

use burn::tensor::Tensor;
use burn::nn::{Linear, Relu};
use burn::optim::Adam;

fn main() {
    // मॉडल डिफ़ाइन करें
    let model = Linear::new(10, 2);
    let input = Tensor::random([1, 10], burn::tensor::Distribution::Normal);
    
    // फॉरवर्ड पास
    let output = model.forward(input);
    println!("नेटवर्क का आउटपुट: {:?}", output);
}

3. SmartCore — पूरा ML पाइपलाइन

SmartCore एक लाइब्रेरी है जो पूरे ML पाइपलाइन को कवर करती है: डेटा प्रीप्रोसेसिंग से लेकर मॉडल इवैल्यूएशन तक। इसमें शामिल हैं:

नॉर्मलाइज़ेशन, फीचर स्केलिंग
क्लासिफिकेशन (KNN, Naive Bayes)
रिग्रेशन (लीनियर, रिज)
क्वालिटी मेट्रिक्स (accuracy, F1-score)

4. Candle — Hugging Face का हल्का फ्रेमवर्क

Candle एक मिनिमलिस्टिक ML फ्रेमवर्क है जो इन्फरेंस पर फोकस करता है। CPU और एज डिवाइसेज़ पर मॉडल चलाने के लिए बेहतरीन है। PyTorch फॉर्मेट के मॉडल लोड करने का सपोर्ट करता है।