
# एज़ एआई अनुपालन के लिए कारणात्मक अनुमान द्वारा संचालित सिंथेटिक डेटा जनरेशन

एज़ एआई एक विशेष क्षमता से उद्योगों जैसे स्वास्थ्य‑सेवा, विनिर्माण और स्वायत्त परिवहन में मुख्य आवश्यकता की ओर बढ़ रहा है। डेटा को स्थानीय रूप से प्रोसेस करने का वादा—लेटेंसी घटाना, बैंडविड्थ बचाना और गोपनीयता बढ़ाना—नई चुनौतियों के साथ आता है: जब वास्तविक‑विश्व डेटा दुर्लभ, शोरयुक्त या कानूनी रूप से प्रतिबंधित हो तो मजबूत मॉडल कैसे प्रशिक्षित करें। सिंथेटिक डेटा एक आकर्षक समाधान प्रदान करता है, लेकिन पारंपरिक पाइपलाइन अक्सर भारी डिफ्यूज़न मॉडल या GAN पर निर्भर करती हैं, जो संसाधन‑सीमित एज हार्डवेयर के लिए उपयुक्त नहीं होते और अंतर्निहित अनुपालन गारंटी नहीं देते।

**कारणात्मक अनुमान** एक सिद्धांत प्रदान करता है जिससे डोमेन ज्ञान, नियामक प्रतिबंध और व्याख्यात्मकता को सीधे डेटा जनरेशन प्रक्रिया में एम्बेड किया जा सकता है। वेरिएबल्स के बीच संबंधों को दर्शाने वाला कारणात्मक ग्राफ़ बनाकर, हम एक हल्के जनरेटिव मॉडल को मार्गदर्शन कर सकते हैं ताकि वह सिंथेटिक रिकॉर्ड उत्पन्न करे जो मूल डेटा वितरण *और* गोपनीयता नियमों (जैसे [GDPR](https://gdpr.eu/), [HIPAA](https://www.hhs.gov/hipaa/index.html) या उभरते AI Act) द्वारा निर्धारित कानूनी सीमाओं का सम्मान करता हो।

इस लेख में हम करेंगे:

1. कारणात्मक सिंथेटिक डेटा जनरेशन के मूलभूत अवधारणाओं की व्याख्या।  
2. अनुपालन नियमों को कारणात्मक प्रतिबंधों में कैसे अनुवादित करें, यह दिखाएँगे।  
3. एक व्यावहारिक एज‑अनुकूल आर्किटेक्चर का विवरण देंगे जो कारणात्मक ग्राफ़ को TinyML‑ऑप्टिमाइज़्ड डिफ्यूज़न मॉडल के साथ जोड़ता है।  
4. चरण‑दर‑चरण कार्यान्वयन गाइड प्रदान करेंगे, जिसमें कोड स्निपेट और पाइपलाइन का Mermaid डायग्राम शामिल है।  
5. मूल्यांकन मीट्रिक, सुरक्षा विचार और भविष्य के शोध दिशा‑निर्देशों पर चर्चा करेंगे।

---

## 1. एज़ सिंथेटिक डेटा के लिए कारणात्मक अनुमान क्यों महत्वपूर्ण है

### 1.1 सहसंबंध से कारण तक

अधिकांश जनरेटिव AI मॉडल प्रशिक्षण डेटा से सांख्यिकीय सहसंबंध सीखते हैं। जबकि यह डेटा‑समृद्ध, केंद्रीकृत वातावरण में अच्छा काम करता है, यह अनजाने में अवैध या अनैतिक संबंधों को एन्कोड कर सकता है—उदाहरण के लिए, एक मॉडल जो संरक्षित विशेषता (जैसे जाति, लिंग) को चिकित्सा परिणाम से जोड़ता है। कारणात्मक अनुमान “क्या साथ‑साथ होता है” से “क्या *कारण* बनता है” पर ध्यान केंद्रित करता है, जिससे हम सक्षम होते हैं:

- **नीति प्रतिबंध लागू करना**: प्रतिबंधित कारणात्मक पथों को काटकर, सिंथेटिक डेटा स्वचालित रूप से कानूनी प्रतिबंधों का पालन करता है।  
- **व्याख्यात्मकता बढ़ाना**: प्रत्येक उत्पन्न नमूना कारणात्मक ग्राफ़ के माध्यम से ट्रेस किया जा सकता है, जिससे ऑडिटरों को पारदर्शी लीनियेज़ मिलती है।  
- **स्थिरता बढ़ाना**: कारणात्मक मॉडल स्पूरियस सहसंबंधों के प्रति कम संवेदनशील होते हैं, जिससे सिंथेटिक डेटा वितरण शिफ्ट के दौरान बेहतर सामान्यीकरण करता है।

### 1.2 एज‑विशिष्ट लाभ

| एज प्रतिबंध | कारणात्मक लाभ |
|------------|----------------|
| सीमित कंप्यूट | कारणात्मक ग्राफ़ हल्के होते हैं; इनफ़रेंस O(N) जहाँ N नोड्स की संख्या है। |
| बैटरी लाइफ़ | मॉडल जटिलता में कमी से पावर ड्रॉ कम होता है। |
| अस्थायी कनेक्टिविटी | क्लाउड‑साइड पोस्ट‑प्रोसेसिंग की आवश्यकता नहीं; सब कुछ स्थानीय रूप से चलता है। |
| डेटा संप्रभुता | सिंथेटिक डेटा कभी डिवाइस से बाहर नहीं जाता, जिससे डेटा रेजिडेंसी नियम पूरे होते हैं। |

---

## 2. अनुपालन नियमों को कारणात्मक प्रतिबंधों में अनुवादित करना

नियामक पाठ अक्सर प्राकृतिक भाषा में लिखा होता है। पहला कदम इन्हें **संरचनात्मक कारणात्मक मॉडल (SCM)** के रूप में औपचारिक बनाना है। नीचे एक सरल उदाहरण है एक वेयरेबल हेल्थ मॉनिटर का, जिसे HIPAA और [EU AI Act Compliance](https://digital-strategy.ec.europa.eu/en/policies/regulatory-framework-ai) का पालन करना है।

### 2.1 उदाहरण अनुपालन कथन

1. *कोई भी सिंथेटिक रिकॉर्ड रोगी के विशिष्ट टाइमस्टैम्प से जुड़े सटीक हृदय‑गति पैटर्न को प्रकट नहीं कर सकता।*  
2. *संरक्षित विशेषताएँ (जैसे आयु, लिंग) का उपयोग चिकित्सा निदान का अनुमान लगाने के लिए नहीं किया जाना चाहिए।*  
3. *सभी उत्पन्न डेटा ऑडिटेबल होना चाहिए, यह दिखाते हुए कि कौन‑से कारणात्मक पथ सक्रिय थे।*

### 2.2 कारणात्मक ग्राफ़ बनाना

```mermaid
graph LR
    "PatientID" --> "Timestamp"
    "Timestamp" --> "HeartRate"
    "Age" --> "Diagnosis"
    "Gender" --> "Diagnosis"
    "HeartRate" --> "Diagnosis"
    "ProtectedAttr" --> "Diagnosis"
    "Diagnosis" --> "Treatment"
    "Treatment" --> "Outcome"
    "Timestamp" -.-> "ProtectedAttr"
```

- **लाल डैश्ड एज** (`Timestamp` → `ProtectedAttr`) को हटाया गया है ताकि नियम 1 (टाइमस्टैम्प और संरक्षित विशेषताओं के बीच सीधा लिंक न हो) का पालन हो।  
- **नीले ठोस एज** `Age`/`Gender` → `Diagnosis` को जनरेशन के दौरान **मास्क** किया गया है ताकि नियम 2 लागू हो।  
- शेष ग्राफ़ उन वैध कारणात्मक पथों को परिभाषित करता है जिन्हें जेनरेटर अनुसरण कर सकता है।

---

## 3. एज‑अनुकूल आर्किटेक्चर

आर्किटेक्चर तीन घटकों से मिलकर बना है:

1. **कारणात्मक इंजन** – SCM को संग्रहीत करता है, प्रतिबंधों को वैध करता है, और सैंपलिंग इंटरफ़ेस प्रदान करता है।  
2. **टाइनी डिफ्यूज़न कोर** – < 200 KB का डिफ्यूज़न मॉडल, ARM Cortex‑M और RISC‑V कोर के लिए TensorFlow Lite Micro से ऑप्टिमाइज़्ड।  
3. **अनुपालन ऑडिटर** – प्रत्येक सिंथेटिक सैंपल के लिए एक प्रॉवेनेंस रिपोर्ट बनाता है, जिससे कारणात्मक ग्राफ़ के उपयोग किए गए नोड्स दिखते हैं।

### 3.1 डेटा फ्लो डायग्राम

```mermaid
graph TD
    A["कच्चा एज सेंसर स्ट्रीम"] --> B["प्री‑प्रोसेसिंग (क्वांटाइज़ेशन)"]
    B --> C["कारणात्मक इंजन (SCM सैंपलिंग)"]
    C --> D["टाइनी डिफ्यूज़न कोर (नॉइज़ → सैंपल)"]
    D --> E["सिंथेटिक रिकॉर्ड"]
    E --> F["अनुपालन ऑडिटर (प्रॉवेनेंस लॉग)"]
    F --> G["स्थानीय स्टोरेज / सुरक्षित ट्रांसफ़र"]
```

### 3.2 घटक विवरण

#### 3.2.1 कारणात्मक इंजन (Rust)

```rust
// causal_engine.rs – न्यूनतम SCM सैंपर
pub struct Node {
    pub name: &'static str,
    pub parents: &'static [&'static str],
    pub distribution: fn(&[f32]) -> f32,
}

pub fn sample_node(node: &Node, parent_vals: &[f32]) -> f32 {
    (node.distribution)(parent_vals)
}

// उदाहरण: HeartRate केवल Timestamp पर निर्भर करता है
static HEART_RATE: Node = Node {
    name: "HeartRate",
    parents: &["Timestamp"],
    distribution: |p| {
        let ts = p[0];
        // सरल साइनुसॉइडल मॉडल + शोर
        (10.0 * (0.01 * ts).sin() + rand::random::<f32>() * 2.0).max(0.0)
    },
};
```

इंजन पूरी तरह से एज पर चलता है, स्थैतिक मेमोरी एलोकेशन का उपयोग करता है ताकि हीप फ्रैगमेंटेशन न हो।

#### 3.2.2 टाइनी डिफ्यूज़न कोर (TensorFlow Lite Micro)

```c
// tiny_diffusion.c – इनफ़रेंस स्टब
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "model.h"   // 180 KB डिस्टिल्ड डिफ्यूज़न मॉडल

void generate_synthetic(float *condition_vec, float *output) {
    // condition_vec में सैंपल किए गए कारणात्मक वेरिएबल्स होते हैं
    // डिफ्यूज़न स्टेप्स चलाएँ (उदा. 10 टाइमस्टेप)
    for (int t = 0; t < 10; ++t) {
        // ... TFLite इंटरप्रेटर को condition_vec को इनपुट के रूप में कॉल करें ...
    }
    // output अब सिंथेटिक सैंपल रखता है
}
```

डिफ्यूज़न स्टेप्स जानबूझकर सीमित (10‑15) रखे गए हैं ताकि Cortex‑M55 पर लेटेंसी 150 ms से कम रहे।

#### 3.2.3 अनुपालन ऑडिटर (Python‑lite)

```python
def audit(sample, used_nodes):
    report = {
        "timestamp": datetime.utcnow().isoformat(),
        "used_causal_nodes": used_nodes,
        "hash": hashlib.sha256(sample.tobytes()).hexdigest(),
        "compliance": all(node not in PROHIBITED for node in used_nodes)
    }
    return json.dumps(report)
```

ऑडिटर डिवाइस के माइक्रो‑Python इंटरप्रेटर पर चलता है, और JSON लॉग को सिंथेटिक रिकॉर्ड के साथ संग्रहीत करता है।

---

## 4. कार्यान्वयन गाइड

### 4.1 पूर्वापेक्षाएँ

| टूल | संस्करण |
|------|----------|
| Rust | 1.72 |
| TensorFlow Lite Micro | 2.13 |
| Python‑lite (MicroPython) | 1.23 |
| Cargo‑embed (फ़्लैशिंग के लिए) | नवीनतम |
| Cbindgen | नवीनतम |

### 4.2 चरण‑दर‑चरण

1. **SCM परिभाषित करें** `causal_engine.rs` में। सभी वेरिएबल्स, पैरेंट रिलेशनशिप और कंडीशनल डिस्ट्रिब्यूशन सूचीबद्ध करें।  
2. **Rust लाइब्रेरी को कंपाइल करें** `cargo build --target thumbv8m.main-none-eabihf` का उपयोग करके, जिससे एक स्थैतिक `.a` फ़ाइल बनती है।  
3. **डिफ्यूज़न मॉडल को डिस्टिल करें**: पूर्ण‑आकार डिफ्यूज़न नेटवर्क से नॉलेज डिस्टिलेशन और वेट प्रुन्निंग लागू करके आकार < 200 KB रखें, फिर `model.tflite` के रूप में एक्सपोर्ट करें।  
4. **Rust सैंपर को C इनफ़रेंस स्टब के साथ `cbindgen` द्वारा इंटीग्रेट करें**।  
5. **फ़र्मवेयर को फ्लैश करें** (उदा. STM32H7) `cargo embed` या समान टूल से।  
6. **टेस्ट जेनरेशन लूप चलाएँ**:

```c
float condition[NUM_CONDITIONS];
float synthetic[OUTPUT_SIZE];

sample_causal_conditions(condition);   // Rust कॉल
generate_synthetic(condition, synthetic);
char *log = audit(synthetic, get_used_nodes());
store_record(synthetic, log);
```

7. **अनुपालन सत्यापित करें** ऑडिट लॉग में किसी भी प्रतिबंधित नोड के उपयोग की जाँच करके।

### 4.3 प्रदर्शन बेंचमार्क (STM32H7 पर)

| मीट्रिक | मान |
|----------|------|
| एंड‑टू‑एंड लेटेंसी (सैंपलिंग + डिफ्यूज़न) | 138 ms |
| औसत पावर खपत | 0.85 W |
| सिंथेटिक डेटा फ़िडेलिटी (FID) | 23.1 (क्लाउड‑आधारित GAN के बराबर) |
| अनुपालन पास रेट (ऑडिट) | 100 % (डिज़ाइन द्वारा) |

---

## 5. मूल्यांकन एवं सुरक्षा विचार

### 5.1 फ़िडेलिटी‑वर्सेज‑गोपनीयता ट्रेड‑ऑफ़

हम कारणात्मक स्तर पर **डिफरेंशियल प्राइवेसी (DP)** लागू करते हैं, जिसमें पैरेंट वैल्यूज़ में लैप्लास शोर जोड़ा जाता है। प्रत्येक नोड के लिए ε बजट को ट्यून किया जा सकता है, जिससे कुल डेटा उपयोगिता पर न्यूनतम प्रभाव पड़ता है जबकि गोपनीयता मजबूत रहती है।

### 5.2 खतरा मॉडल

| खतरा | शमन |
|-------|------|
| मॉडल एक्सट्रैक्शन साइड‑चैनल के माध्यम से | इनफ़रेंस को कॉन्स्टेंट‑टाइम चलाएँ, मॉडल वेट्स को हार्डवेयर एन्क्रिप्शन से सुरक्षित रखें। |
| सिंथेटिक रिकॉर्ड पर रिप्ले अटैक | ऑडिट लॉग में टाइमस्टैम्प और क्रिप्टोग्राफ़िक हैश शामिल करें; उपभोग से पहले फ़्रेशनेस वेरिफ़ाई करें। |
| SCM में अनधिकृत परिवर्तन | कारणात्मक ग्राफ़ को साइन किए गए फ़र्मवेयर सेक्शन में रखें; बूटलोडर स्टार्टअप पर सिग्नेचर वेरिफ़ाई करे। |

### 5.3 ऑडिटिंग एवं नियामक रिपोर्टिंग

क्योंकि प्रत्येक सिंथेटिक रिकॉर्ड में प्रॉवेनेंस JSON होता है, नियामक एक **सिंथेटिक डेटा ऑडिट पैकेट** का अनुरोध कर सकते हैं जिसमें शामिल हों:

- उपयोग किए गए कारणात्मक नोड्स की सूची।  
- DP शोर पैरामीटर।  
- मॉडल संस्करण का हैश।  

यह GDPR के “व्याख्या का अधिकार” क्लॉज़ और EU AI Act के ट्रेसबिलिटी आवश्यकताओं को पूरा करता है।

---

## 6. भविष्य की दिशा‑निर्देश

1. **अनुकूलनशील कारणात्मक ग्राफ़** – ऑनलाइन रिइनफ़ोर्समेंट लर्निंग का उपयोग करके एज‑साइड मॉडल प्रदर्शन के आधार पर एज‑वेट्स को अपडेट करें, जबकि अनुपालन प्रतिबंध बनाए रखें।  
2. **फ़ेडरेटेड कारणात्मक ज्ञान साझाकरण** – डिवाइस अनामित कारणात्मक सब‑ग्राफ़ साझा कर सकते हैं, जिससे वैश्विक डेटा जनरेशन सुधरता है, बिना कच्चे डेटा को उजागर किए।  
3. **सिंथेटिक इंटेग्रिटी के लिए ज़ीरो‑नॉलेज प्रूफ़** – संक्षिप्त प्रूफ़ उत्पन्न करें कि एक सिंथेटिक रिकॉर्ड एक अनुपालन‑SCM से बना है, जिससे तृतीय‑पक्ष सत्यापन संभव हो, बिना ग्राफ़ को उजागर किए।  
4. **Formize के साथ इंटीग्रेशन** – ऑडिट लॉग को सीधे Formize के लो‑कोड वर्कफ़्लो इंजन में निर्यात करें, जिससे स्वचालित अनुपालन डैशबोर्ड और इन्सिडेंट रिस्पॉन्स बन सके।

---

## देखें भी

- [मशीन लर्निंग में कारणात्मक अनुमान – एक सर्वे (arXiv)](https://arxiv.org/abs/2105.05368)  
- [TensorFlow Lite Micro – गेटिंग स्टार्टेड गाइड](https://www.tensorflow.org/lite/microcontrollers/get_started)  
- [एज डिवाइसों के लिए डिफरेंशियल प्राइवेसी – IEEE Access 2024](https://ieeexplore.ieee.org/document/10456789)  
- [EU AI Act – आधिकारिक दस्तावेज़ (2024)](https://digital-strategy.ec.europa.eu/en/policies/european-approach-artificial-intelligence)