1. यह क्या है और क्यों ज़रूरी है

Burn Rust में लिखा गया एक आधुनिक डीप लर्निंग फ्रेमवर्क है। यह न्यूरल नेटवर्क बनाने, ट्रेन करने और तैनात करने के लिए पूरे टूल्स का सेट प्रदान करता है, जिसमें परफॉरमेंस, मेमोरी सुरक्षा और लचीलापन पर जोर दिया गया है। PyTorch या TensorFlow जैसे पारंपरिक फ्रेमवर्क के विपरीत, Burn Rust के सभी फायदों का उपयोग करता है: शून्य लागत वाले एब्स्ट्रैक्शन, कंपाइल टाइम पर सुरक्षा गारंटी और कोई गार्बेज कलेक्टर नहीं। यह इसे उन सिस्टमों के लिए आदर्श बनाता है जहां अनुमानित परफॉरमेंस और कम संसाधन खपत महत्वपूर्ण है - जैसे रोबोटिक्स, एम्बेडेड सिस्टम, हाई-लोड सर्वर और एज डिवाइस।

Burn एक अनोखी आर्किटेक्चर प्रदान करता है जो "बैकएंड-न्यूट्रलिटी" की अवधारणा पर आधारित है। इसका मतलब है कि एक ही कोड CPU (अपने टेंसर इंजन के माध्यम से), GPU (CUDA/WGPU के माध्यम से) और भविष्य में विशेष एक्सेलेरेटर पर चल सकता है। फ्रेमवर्क ऑटोमैटिक डिफरेंशिएशन, ऑप्टिमाइज़र (Adam, SGD, AdamW), लॉस फंक्शन, लेयर (Linear, Conv2d, BatchNorm, Dropout आदि) और बिल्ट-इन डेटासेट और DataLoader को सपोर्ट करता है। मुख्य विशेषता - मॉडल को Python या CUDA runtime पर निर्भरता के बिना तैनात करने के लिए स्टैटिक लाइब्रेरी में कंपाइल करने की क्षमता।

Burn का उपयोग क्यों करें? पहला, उन प्रोजेक्ट्स के लिए जहां अधिकतम परफॉरमेंस और मेमोरी पर नियंत्रण आवश्यक है। दूसरा, CPU, GPU और यहां तक कि WebAssembly पर चलने वाले क्रॉस-प्लेटफॉर्म समाधान बनाने के लिए। तीसरा, प्रोडक्शन में मॉडल को सुरक्षित रूप से तैनात करने के लिए, जहां रनटाइम एरर (जैसे null pointer या type mismatch) अस्वीकार्य हैं। Burn सक्रिय रूप से समुदाय द्वारा विकसित किया जा रहा है और पहले से ही कंप्यूटर विज़न, NLP, रिकमेंडेशन सिस्टम और रीइन्फोर्समेंट लर्निंग जैसे क्षेत्रों में उपयोग किया जा रहा है।

2. इंस्टॉलेशन

Burn को इंस्टॉल करने के लिए Rust (अनुशंसित संस्करण 1.75 या नया) आवश्यक है। अगर Rust अभी तक इंस्टॉल नहीं है, तो rustup का उपयोग करें।

एक नया प्रोजेक्ट बनाएं और Cargo.toml में डिपेंडेंसी जोड़ें:

cargo new my_burn_project
cd my_burn_project

Cargo.toml में जोड़ें:

[dependencies]
burn = { version = "0.15", features = ["ndarray"] }  # CPU के लिए
# या GPU (CUDA) के लिए:
# burn = { version = "0.15", features = ["cuda"] }
# या WGPU (क्रॉस-प्लेटफॉर्म GPU) के लिए:
# burn = { version = "0.15", features = ["wgpu"] }

फिर चलाएं:

cargo build

CUDA के साथ काम करने के लिए CUDA Toolkit 11.x या 12.x इंस्टॉल होना चाहिए। WGPU के लिए - Vulkan, Metal या DirectX 12 (OS पर निर्भर करता है)।

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

सिंथेटिक डेटा पर रिग्रेशन टास्क के लिए एक सरल न्यूरल नेटवर्क बनाते हैं। यह उदाहरण मुख्य चरणों को दर्शाता है: मॉडल परिभाषा, डेटा निर्माण, ट्रेनिंग और इन्फरेंस।

use burn::{
    module::Module,
    nn::{Linear, Relu},
    tensor::{backend::Backend, Tensor},
    train::{Adam, Learner},
    data::dataloader::DataLoaderBuilder,
};

// मॉडल स्ट्रक्चर को परिभाषित करें
#[derive(Module, Debug)]
struct MyModel {
    linear1: Linear,
    linear2: Linear,
    activation: Relu,
}

impl MyModel {
    fn new() -> Self {
        Self {
            linear1: Linear::new(1, 16),
            linear2: Linear::new(16, 1),
            activation: Relu::new(),
        }
    }

    fn forward(&self, input: Tensor) -> Tensor {
        let x = self.linear1.forward(input);
        let x = self.activation.forward(x);
        se