candle Rust: Hugging Face का हल्का ML फ्रेमवर्क

candle एक आधुनिक मशीन लर्निंग फ्रेमवर्क है जो Rust में लिखा गया है और Hugging Face टीम द्वारा विकसित किया गया है। PyTorch या TensorFlow जैसे भारी समाधानों के विपरीत, candle प्रदर्शन, मेमोरी सुरक्षा और न्यूनतम संसाधन खपत पर केंद्रित है। यह CPU और GPU (CUDA और Vulkan के माध्यम से) पर न्यूरल नेटवर्क मॉडल चलाने की अनुमति देता है, बिना विशाल रनटाइम इंस्टॉल किए।

candle की आवश्यकता क्यों है? सबसे पहले, यह एम्बेडेड सिस्टम, वेब असेंबलर (WASM) और एज डिवाइसों के लिए आदर्श है, जहां बाइनरी फ़ाइल का आकार और लोडिंग स्पीड महत्वपूर्ण है। दूसरा, Rust थ्रेड-सेफ्टी और गार्बेज कलेक्टर की अनुपस्थिति सुनिश्चित करता है - यह इन्फ्रेंस के लिए अनुमानित प्रदर्शन देता है। तीसरा, candle PyTorch (safetensors, bin) और Hugging Face Hub से मॉडल लोड करने का समर्थन करता है, जो इसे प्रोडक्शन के लिए एक उत्कृष्ट विकल्प बनाता है।

इस लेख को लिखने के समय, candle सक्रिय रूप से विकसित हो रहा है: यह ट्रांसफॉर्मर (BERT, GPT, LLaMA, Whisper), कन्वोल्यूशनल नेटवर्क (ResNet, ViT) और यहां तक कि जनरेटिव मॉडल (Stable Diffusion) का समर्थन करता है। इस गाइड में, हम इंस्टॉलेशन, प्रमुख मेथड्स को समझेंगे और टेक्स्ट क्लासिफिकेशन का एक पूर्ण उदाहरण लिखेंगे।

इंस्टॉलेशन

candle एक Rust लाइब्रेरी है, इसलिए इंस्टॉलेशन Cargo के माध्यम से किया जाता है। Cargo.toml में डिपेंडेंसी जोड़ें:

[dependencies]
candle-core = "0.7"
candle-nn = "0.7"
candle-transformers = "0.7"
tokenizers = "0.21"  # टोकनाइज़र के लिए
anyhow = "1.0"       # एरर हैंडलिंग के लिए

अगर आपको CUDA सपोर्ट चाहिए, तो --features cuda फ्लैग का उपयोग करें:

cargo add candle-core --features cuda
cargo add candle-nn --features cuda
cargo add candle-transformers --features cuda

वेब असेंबलर (WASM) के लिए --features wasm जोड़ें।

त्वरित शुरुआत: न्यूनतम कार्यशील उदाहरण

एक टेंसर बनाएं और एक सरल ऑपरेशन करें - मैट्रिक्स गुणा:

use candle_core::{Device, Tensor};

fn main() -> Result<(), Box> {
    // CPU पर टेंसर बनाएं
    let a = Tensor::new(&[[1.0f32, 2.0], [3.0, 4.0]], &Device::Cpu)?;
    let b = Tensor::new(&[[5.0f32, 6.0], [7.0, 8.0]], &Device::Cpu)?;

    // मैट्रिक्स गुणा
    let c = a.matmul(&b)?;
    println!("परिणाम: {:?}", c.to_vec2::()?);

    Ok(())
}

यह कोड आउटपुट देगा:

परिणाम: [[19.0, 22.0], [43.0, 50.0]]

ध्यान दें: सभी ऑपरेशन Result लौटाते हैं, इसलिए हम एरर हैंडलिंग के लिए ? का उपयोग करते हैं।

मुख्य मेथड्स और फंक्शन्स

candle-core और candle-nn के 10 प्रमुख मेथड्स देखें जिनकी आपको 90% प्रोजेक्ट्स में आवश्यकता होगी।

1. `Tensor::new` — टेंसर बनाना

सिग्नेचर: pub fn new, D: Into>(data: impl Into>, device: D) -> Result<Tensor>

विवरण: फ्लोटिंग पॉइंट नंबरों के फ्लैट वेक्टर से टेंसर बनाता है। आकार Shape के माध्यम से दिया जाता है (जैसे, Shape::from((2, 3)))।

use candle_core::{Device, Tensor, Shape};

fn main() -> anyhow::Result<()> {
    // वेक्टर से 2x3 टेंसर बनाएं
    let t = Tensor::new(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &Device::Cpu)?;
    // आकार बदलें
    let t_reshaped = t.reshape(&Shape::from((2, 3)))?;
    println!("{:?}", t_reshaped.to_vec2::()?);
    Ok(())
}