
# Reaalajas kohanduv sünteetiliste andmete genereerimine Edge AI jaoks driftiteadliku tugevdusõppe abil

Edge AI liigub uurimishuvist tootmiskvaliteediga tehnoloogiani, mis juhib kõike alates autonoomsetest droonidest kuni nutikate kaamerateni. Üks suurimaid väljakutseid, millega edge‑paigaldused silmitsi seisavad, on **andmete nappus**: reaalsete andmete kogumine, märgistamine ja nende suurte koguste edastamine pilve on sageli võimatu ribalaiuse piirangute, privaatsusregulatsioonide ja latentsuspiirangute tõttu. Sünteetilised andmed pakuvad veenvat alternatiivi, kuid traditsioonilised torujuhtmed loovad staatilisi andmekogumeid, mis kiiresti vananevad, kui kasutuskeskkond muutub.

Selles artiklis tutvustame **driftiteadlikku tugevdusõppe (RL) tsüklit**, mis kohandab pidevalt sünteetiliste andmete genereerimist edge‑voogude reaalajas omadustele. Raamistik ühendab kolm põhitalit:

1. **Jaotuse driftide tuvastamine** – kergekaalulised statistilised monitorid, mis märgivad, kui edge‑andmete jaotus kõrvalekaldub sünteetilisest baasjoonest.  
2. **Tugevdusõppe põhine valik** – RL‑agent, mis õpib kohandama generaatori hüperparameetreid (nt latentruumi uurimine, tingimuslikud muutujad), et maksimeerida kvaliteeditasu.  
3. **Selgitav AI (XAI) tagasiside** – mudelist sõltumatud selgitused, mis näitavad, miks teatud sünteetilisi näiteid eelistatakse, võimaldades auditeerijatel ja inseneridel kontrollida vastavust.  

Tulemuseks on **enesetäiendav sünteetiliste andmete torujuhe**, mis pakub nõudmisel kõrgekvaliteedilisi, privaatsust säilitavaid andmeid, hoides edge‑mudelid täpsed, samal ajal järgides regulatiivseid piiranguid.

---

## 1. Miks traditsioonilised sünteetiliste andmete torujuhtmed ebaõnnestuvad edge‑keskkonnas

| Piirang | Mõju Edge AI-le |
|------------|-------------------|
| **Staatiline genereerimine** | Sünteetilisi andmeid luuakse üks kord ja seejärel jäetakse külmutatud. Kui keskkond muutub (nt valgustus, sensori drift), halveneb mudeli jõudlus. |
| **Keskne koolitus** | Andmed tuleb genereerimiseks saata pilve, mis tekitab latentsuse ja ribalaiuse kulud. |
| **Pime valik** | Juhuslik või heuristiline valik ei taga, et genereeritud näited kataksid tekkivaid edge‑juhtumeid. |
| **Selgitatavuse puudumine** | Insenerid ei suuda jälgida, miks sünteetiline näide loodi, muutes vastavusauditeid keeruliseks. |

Need puudused viivad **mudeli driftini**, suurema inferentsivea ning võimalike privaatsusregulatsioonide, nagu GDPR või CCPA, rikkumisteni. Vajalik on dünaamiline, tagasisidepõhine lähenemine.

## 2. Põhikontseptsioonid

### 2.1 Driftide tuvastamine edge‑seadmes

Driftide tuvastamise algoritmid peavad olema **kergekaalulised**, et töötada piiratud ressurssidega seadmetel. Kaks perekonda toimivad hästi:

* **Statistilised testid** – Kolmogorovi‑Smirnovi (KS) test, Population Stability Index (PSI).  
* **Sisemiste esinduste monitorid** – lühike auto‑enkooder töötab edge‑seadmes, luues sisemisi esindusi, mida võrreldakse viitejaotusega kosinuse sarnasuse abil.

Kui driftisignaal ületab konfigureeritava läve, käivitab torujuhe **uuesti genereerimise päringu**.

### 2.2 Tugevdusõpe kohanduva valiku jaoks

RL‑agent käsitleb sünteetiliste andmete genereerimist kui **Markovi otsustusprotsessi (MDP)**:

* **Oleku (s)** – praegused driftimõõdikud, hiljutine tasuajalugu ja generaatori konfiguratsioon.  
* **Tegevus (a)** – generaatori hüperparameetrite kohandused (nt latentvektori variatsioon, uute sensormoodalite tingimused).  
* **Tasu (r)** – koostatud skoor, mis tasakaalustab **sünteetilise täpsust**, **privaatsuse eelarve kasutamist** ja **mudeli jõudluse kasvu** valideerimisosa peal.

**Proximal Policy Optimization (PPO)** algoritm toimib hästi, kuna see on näidissäästlik ja saab treenida offline keskserveris, enne kui see destilleeritakse kergekaalulisse poliisivõrku, mis töötab edge‑seadmes.

### 2.3 Selgitav AI tagasiside tsükkel

Selgitavus saavutatakse **SHAP** (Shapley Additive Explanations) abil, mida rakendatakse RL‑poliitika otsustele. Määrates tasu panused konkreetsetele tegevustele, saavad insenerid:

* Kinnitada, et privaatsuspiiranguid austatakse.  
* Tuua välja, millised driftidimensioonid (nt temperatuur, valgustus) juhivad sünteetilisi kohandusi.  
* Luua auditilogid regulatiivse vastavuse jaoks.

## 3. Arhitektuuri ülevaade

Allpool on Mermaid diagramm, mis kajastab lõpuni sujuvat voogu.

```mermaid
flowchart TD
    A[Edge Sensor Stream] --> B[Drift Detector]
    B -->|No Drift| C[Edge Inference Engine]
    B -->|Drift Detected| D[RL Policy (Edge)]
    D --> E[Generator Config Update]
    E --> F[Synthetic Data Generator (Cloud/Edge Hybrid)]
    F --> G[Synthetic Sample Pool]
    G --> H[Model Retraining Scheduler]
    H --> I[Updated Edge Model]
    I --> C
    D --> J[Explainability Module]
    J --> K[Audit Log & Dashboard]
    K --> L[Compliance Review]
```

*Diagramm illustreerib, kuidas driftide tuvastamine käivitab RL‑poliitika, mis seejärel juhib generaatorit. Selgitavus suunab vastavuse poole.*

## 4. Üksikasjalik läbivaade

### 4.1 Edge‑driftide jälgimine

1. **Funktsioonide ekstraheerimine** – iga N sekundi järel ekstraheerib edge‑seade madala dimensiooniga funktsioonivektori (nt gradientide histogramm, sensori statistika).  
2. **Viitevärskendus** – viimase M funktsioonivektori liikuva akna põhjal moodustub **viitejaotus**.  
3. **Statistiline test** – arvuta KS kaugus praeguse partitsiooni ja viite vahel. Kui `KS > τ`, tõsta driftilipp.

```python
def detect_drift(current_batch, reference_batch, threshold=0.05):
    ks_stat = ks_2samp(current_batch, reference_batch).statistic
    return ks_stat > threshold
```

### 4.2 RL‑poliitika täitmine

Poliitikavõrk saab sisendiks vektori:

```
state = [ks_stat, psi_score, recent_reward, generator_lr, latent_variance]
```

Ta väljastab tõenäosusjaotuse diskreetsete tegevuste üle:

```
actions = {
    0: "increase latent variance",
    1: "decrease latent variance",
    2: "add new conditioning variable",
    3: "reduce privacy budget usage",
    4: "no change"
}
```

Valitud tegevus rakendatakse generaatori konfiguratsioonile, mis seejärel saadetakse **hübriidgeneraatorile** (osaliselt seadmes, osaliselt pilves).

### 4.3 Hübriidgeneraatori kujundus

* **Edge‑seadmes paiknev dekooder** – kergekaaluline dekooder töötab seadmes, et kiiresti renderdada sünteetilisi näiteid kohese inferentsi testimiseks.  
* **Pilve‑skaala generaator** – täisresolutsiooniga difusioonimudel või GAN asub pilves, pakkudes vajadusel kõrge resolutsiooniga andmeid.

Edge‑seade küsib **partitsiooni suuruse**, mis on proportsionaalne driftide tõsidusega, tagades, et ribalaiust kasutatakse ainult siis, kui kasu ületab kulu.

### 4.4 Tasude arvutamine

Tasu koosneb kolmest komponendist:

```
reward = α * fidelity_score
       + β * privacy_score
       + γ * performance_gain
```

* **Täpsuse skoor** – mõõdetakse **Fréchet Inception Distance (FID)** abil, võrreldes sünteetilisi ja väikest eraldatud reaalset partitsiooni.  
* **Privaatsuse skoor** – pöördvõrdeliselt sõltuv **ε** väärtusest diferentseeritud privaatsuse arvestaja poolt.  
* **Jõudluse kasv** – erinevus edge‑mudeli täpsuses enne ja pärast lühikest peenhäälestust sünteetilisel partitsioonil.

Hüperparameetrid `α, β, γ` määrab vastavusmeeskond, et vajadusel eelistada privaatsust või jõudlust.

### 4.5 Selgitavuse integreerimine

Pärast iga RL‑sammu käivitab süsteem SHAP-i poliitikavõrgul:

```python
import shap
explainer = shap.Explainer(policy_network)
shap_values = explainer(state)
```

Tulemuseks saadud atribuutide kaart salvestatakse **auditilogisse**, visualiseeritakse armatuurlaual ja saab eksportida regulaatori ülevaatuseks.

## 5. Rakendamise kontrollnimekiri

| Samm | Kirjeldus | Tööriistad / Teegid |
|------|-----------|----------------------|
| 1️⃣ | Edge‑funktsioonide ekstraheerimine & driftide tuvastamine | NumPy, SciPy, TensorFlow Lite |
| 2️⃣ | RL‑poliitika treenimine (offline) | PyTorch, Stable‑Baselines3 (PPO) |
| 3️⃣ | Poliitika destilleerimine edge‑seadmele | ONNX, TensorFlow Lite Converter |
| 4️⃣ | Hübriidgeneraatori kasutuselevõtt | NVIDIA TensorRT, Diffusers (Hugging Face) |
| 5️⃣ | Tasude arvutamise torujuhe | scikit‑learn (FID), Opacus (DP), PyTorch Lightning |
| 6️⃣ | Selgitavus & auditilogimine | SHAP, Elastic Stack (ELK) |
| 7️⃣ | Jätkuv integreerimine & monitooring | GitHub Actions, Prometheus, Grafana |

## 6. Kasu traditsiooniliste lähenemiste ees

| Metrika | Traditsiooniline staatiline torujuhe | Kohanduv RL‑põhine torujuhe |
|--------|--------------------------------------|-----------------------------|
| **Kohandamise latentsus** | Tunnid‑kuni päevad (käsitsi ümbertreenimine) | Sekundid‑kuni minutid (automatiseeritud tsükkel) |
| **Ribalaiuse kokkuhoid** | Iga tsükli täisandmekogumi üleslaadimine | Inkriementaalsed partitsioonipäringud ainult driftide korral |
| **Mudeli täpsus** | Halveneb 5‑15 % pärast driftide esinemist | Säilib 1‑2 % optimaalsest |
| **Privaatsuse eelarve** | Fikseeritud tarbimine, sageli ületatud | Dünaamiline eelarve, austab ε piire |
| **Vastavuse läbipaistvus** | Piiratud auditilogi | Täielikud SHAP‑põhised selgitused iga iteratsiooni kohta |

## 7. Reaalsed kasutusjuhtumid

1. **Nutikas linna jälgimine** – kaamerad kogevad päeva jooksul valgustuse muutusi. Kohanduv torujuhe genereerib pidevalt sünteetilisi öökaadreid, hoides objektituvastusmudelid teravad, ilma reaalset videot salvestamata.  
2. **Tööstus‑IoT ennustav hooldus** – sensori drift kulumise tõttu tuvastatakse, mis käivitab sünteetilised vibratsioonimustrid, aidates edge‑mudelil varakult rikkeid ennustada.  
3. **Tervishoiu kantavad seadmed** – füsioloogiliste signaalide drift (nt südame löögisageduse baasjoone muutus) käivitab sünteetilise EKG genereerimise, võimaldades seadmesiseselt arütmia tuvastamist ilma toorandmeid edastamata.

## 8. Väljakutsed ja leevendused

| Väljakutse | Leevendus |
|-----------|-----------|
| **Poliitika üle‑sobitamine** – RL võib ära kasutada tasuõõne. | Perioodilised poliitika auditid, tasu regulariseerimine ja adversaaltestid. |
| **Edge‑ressursside piirangud** – SHAPi käivitamine võib olla koormav. | Käita SHAP pilves valitud alamhulga jaoks; salvestada selgitused lokaalselt. |
| **Privaatsuse arvestamise keerukus** – ε tasakaalustamine paljude generatsioonide vahel. | Kasutada **privaatsusraamatut**, mis koondab ε väärtused seadme kohta ja kehtestab limiite. |
| **Mudeli driftide tuvastamise valepositiivid** – müra sensorid käivitavad tarbetu uuesti genereerimise. | Kombineerida mitu detektorit (statistiline + sisemiste esinduste) ja rakendada histereesi. |

## 9. Tuleviku suunad

* **Meta‑RL poliitika ülekandeks** – treenida meta‑poliitika, mis suudab kiiresti kohaneda uute edge‑seadmete tüüpidega minimaalse peenhäälestusega.  
* **Föderatiivne RL** – jagada poliitika gradientid seadmete vahel, säilitades andmete lokaalsuse, vähendades veelgi keskset koordineerimist.  
* **Kausalne driftimudeldus** – integreerida kausaalseid graafe, et eristada heatahtlikke keskkonnamuutusi ja pahatahtlikke andmete mürgitamiskatseid.  
* **Zero‑Trust sünteetiliste andmete turg** – laiendada raamistikku turuplatsiks, kus sünteetilisi andmeid kaubeldakse verifitseeritavate zero‑trust lepingute alusel, kasutades detsentraliseeritud identiteeti.

## 10. Alustamine – minimaalne prototüüp

Allpool on lühike Python‑koodilõik, mis demonstreerib põhitsüklit simuleeritud edge‑seadmel.

```python
import numpy as np
from scipy.stats import ks_2samp
import torch
import shap
from stable_baselines3 import PPO

# 1. Simuleeritud edge funktsioonivoog
def edge_stream(batch_size=128):
    while True:
        # Simuleeri sensori drift pärast 500 iteratsiooni
        drift = np.random.randn(batch_size, 10) * (1 + 0.001 * edge_stream.counter)
        edge_stream.counter += 1
        yield drift
edge_stream.counter = 0

# 2. Drift detector
def detect_drift(current, reference, thr=0.04):
    ks = ks_2samp(current.ravel(), reference.ravel()).statistic
    return ks > thr, ks

# 3. Laadi eelnevalt treenitud RL poliitika (offline treenitud)
policy = PPO.load("drift_aware_policy.zip")
policy.set_env(None)  # Inference‑il pole keskkonda vaja

# 4. Selgitavuse hook
explainer = shap.Explainer(policy.policy)

# 5. Peamine tsükkel
reference = np.random.randn(1024, 10)  # algne viitejaotus
for batch in edge_stream():
    drifted, ks_val = detect_drift(batch, reference)
    if drifted:
        state = np.concatenate([ [ks_val], np.mean(batch, axis=0) ])
        action, _ = policy.predict(state, deterministic=True)
        # Kaardista tegevus generaatori konfiguratsiooniks (lihtsustatud)
        config = {"latent_var": 0.5 + 0.1*action}
        # Taotle sünteetiline partitsioon (kohatäitja)
        synthetic = np.random.randn(64, 10) * config["latent_var"]
        # Arvuta tasu (näidis)
        reward = -np.mean(np.abs(synthetic - batch))
        # Logi SHAP väärtused
        shap_vals = explainer(state)
        print(f"Drift detected (KS={ks_val:.3f}), action={action}, reward={reward:.3f}")
        print("SHAP contribution:", shap_vals.values)
        # Uuenda viitejaotust aeglaselt
        reference = np.vstack([reference[batch_size:], batch])[:1024]
    else:
        # Tavaline inferentsitee
        pass
```

See prototüüp näitab, kuidas driftide tuvastamine käivitab RL‑poliitika, mis seejärel kohandab generaatori parameetreid, ning kuidas SHAP‑põhist selgitust kasutatakse auditiks.

## 11. Kokkuvõte

Sünteetilised andmed ei ole enam ühekordne andmete suurendamise trikk; need peavad muutuma **elavaks, kohanemisvõimelisteks teenuseks**, mis reageerib pidevalt muutuvale edge‑keskkonnale. Kombineerides **driftide tuvastamise**, **tugevdusõppe** ja **selgitava AI**, saame luua torujuhtmeid, mis:

* Pakuvad reaalajas kõrgekvaliteedilisi, privaatsust säilitavaid andmeid.  
* Hoiavad edge‑mudeleid jõudluselt head ilma kulukate pilve‑sõidukordadeta.  
* Pakuvad läbipaistvaid auditilogisid, mis rahuldavad regulaatoreid ja auditeerijaid.

Selle driftiteadliku RL‑raamistiku kasutuselevõtt asetab organisatsioonid **vastutustundliku Edge AI** esirinda, avades uusi kasutusjuhtumeid, säilitades samal ajal andmesuveräänsuse.

## Vaata ka

- [Google AI Blog – “Andmete driftide tuvastamine tootmises masinõppe süsteemides”](https://ai.googleblog.com/2023/03/detecting-data-drift.html)  
- [Diferentsiaalse privaatsuse teek – Opacus dokumentatsioon](https://opacus.ai/)