
# Muutumatav sünteetiline andmete versioonihaldus ja auditeeritav päritolu plokiahela toetatud andmelepingutega

Sünteetilised andmed on saanud kaasaegse tehisintellekti arenduse nurgakiviks, võimaldades privaatsust säilitavat mudelite treenimist, kiiret prototüüpimist ja eelarvamuste vähendamist. Kuid kuna sünteetiliste andmete töövood muutuvad keerukamaks – hõlmates mitut meeskonda, pilvepiirkondi ja ääre‑seadmeid – seisavad organisatsioonid silmitsi kahe põhilise küsimusega:

1. **Millist sünteetilise andmekogumi versiooni kasutati konkreetse mudeli treenimiseks?**  
2. **Kas suudame tõestada, et andmete genereerimise protsess vastas regulatiivsetele ja eetilistele poliitikatele?**

Traditsioonilised andmekataloogi lahendused tuginevad muudetavatele metaandmete poodidele, mis on haavatavad juhuslike ülekirjutuste, sisemise manipuleerimise ja killustatud auditijälgede suhtes. Selles artiklis tutvustame **plokiahela toetatud andmelepingu arhitektuuri**, mis pakub **muutumatut versioonihaldust**, **krüptograafiliselt verifitseeritavat päritolu** ja **automatiseeritud vastavusraportite koostamist** sünteetiliste andmete jaoks. Lähenemine põhineb kolmel sambal:

* **Muutumatu pearaamat** – Litsenseeritud plokiahel registreerib iga andmelepingu tehingu, tagades võltsimiskindluse.  
* **Nutilepingutega juhitud andmelepingud** – Ise täidetavad lepingud kodeerivad genereerimisparameetrid, nõusoleku kviitungid ja poliitika piirangud.  
* **Automatiseeritud päritolu ekstraheerimine** – Sündmustepõhised agendid tõlgivad lepingu oleku ühtseks päritolugraafikuks, mida saavad pärida MLOpsi tööriistad.  

Selle juhendi lõpus mõistad kogu protsessi, näed konkreetset rakendust, mis kasutab Hyperledger Fabric'i ja Formize'i, ning õpid, kuidas lahendust integreerida CI/CD töövoogudesse pideva vastavuse tagamiseks.

## 1. Miks muutumatu versioonihaldus on sünteetiliste andmete jaoks oluline

Sünteetiliste andmete töövood hõlmavad tavaliselt järgmisi etappe:

1. **Allikaandmete sissetõmbamine** – Reaalmaailma andmeid kogutakse nõusoleku ja privaatsuspoliitikate alusel.  
2. **Privaatsuse transformatsioon** – Diferentsiaalne privaatsus, GAN-id või difusioonimudelid loovad sünteetilisi kirjeid.  
3. **Kvaliteedikontroll** – Statistilised testid, eelarvamuste tuvastamine ja kasulikkuse hindamine valideerivad väljundit.  
4. **Jaotamine** – Andmekogumeid hoitakse andmejärvedes, jagatakse API-de kaudu või suunatakse otse treeningtöödele.  

Iga etapp võib tekitada mitu **iteratsiooni** (nt hüperparameetrite otsingud, mudeli värskendused). Ilma muutumatu versioonihalduseta:

* **Mudeli reprodutseeritavus kannatab** – Meeskonnad ei suuda usaldusväärselt reprodutseerida mudelit, mis treeniti “Dataset v3.2” andmetel.  
* **Regulatiivne risk kasvab** – Audiitorid ei saa kinnitada, et andmekogum vastas [GDPR](https://gdpr.eu/) või [HIPAA](https://www.hhs.gov/hipaa/index.html) nõuetele kasutamise ajal.  
* **Andmete päritolu lüngad** – Kui eelarvamuse probleem ilmneb, on täpsete genereerimisparameetrite jälgimine aeganõudev.  

Muutumatu pearaamat lahendab need probleemid, pakkudes **ainetõestatud tõeallikat**, mida ei saa retrospektiivselt muuta.

## 2. Põhiarhitektuuri ülevaade

Allpool on ettepanekut arhitektuuri kõrgtaseme diagramm. Diagramm on esitatud Mermaid süntaksis, mida Hugo suudab automaatselt renderdada.

```mermaid
graph LR
    subgraph Edge
        A["Real‑world Data Source"]
        B["Consent Management (Formize)"]
    end
    subgraph Core
        C["Synthetic Data Engine"]
        D["Data Contract Smart‑Contract"]
        E["Permissioned Blockchain"]
        F["Lineage Service"]
        G["CI/CD Pipeline"]
        H["Model Registry"]
    end
    subgraph Consumers
        I["Training Job"]
        J["Audit Dashboard"]
    end

    A --> B
    B --> C
    C --> D
    D --> E
    E --> F
    F --> G
    G --> H
    H --> I
    F --> J
```

**Peamised interaktsioonid**

* **Nõusoleku haldamine (Formize)** kogub kasutaja nõusoleku ja väljastab allkirjastatud kviitungi, mis salvestatakse plokiahelasse.  
* **Sünteetiliste andmete mootor** (nt GAN või difusioonimudel) loeb kviitungi, genereerib andmeid ja kutsub **andmelepingu** genereerimisparameetritega.  
* **Andmeleping** kirjutab tehingu **litsenseeritud plokiahelasse**, luues muutumatu kirje, mis sisaldab:
  * Andmekogumi räsi
  * Generatsiooni algoritmi versioon
  * Hüperparameetrid
  * Nõusoleku kviitungi viide
  * Poliitika vastavuse lipud
* **Päritolu teenus** tellib plokiahela sündmusi, koostab suunatud tsüklivaba graafi (DAG) andmekogumi versioonidest ja pakub GraphQL API-d.  
* **CI/CD töövoog** tõmbab viimase andmekogumi räsi pearaamatust enne treeningtöö käivitamist, tagades reprodutseeritavuse.  
* **Mudelite register** salvestab mudeli artefaktid, mis on seotud andmekogumi räsi‑ga.  
* **Treeningtöö** kasutab andmekogumi versiooni.  
* **Auditi armatuurlaud** visualiseerib päritolugraafi ja pakub eksporditavaid vastavusraporte.

## 3. Andmelepingud nutilepingutena

**Andmeleping** on kerge nutileping, mis kapseldab kogu sünteetilise andmegenereerimise konteksti. Allpool on lihtsustatud Solidity‑laadne pseudo‑kood, mida võiks kompileerida Hyperledger Fabric'i kettakoodiks.

```solidity
contract SyntheticDataContract {
    struct GenerationRecord {
        string datasetHash;          // SHA‑256 of the generated dataset
        string algorithmId;          // e.g., "GAN_v2.1"
        string hyperParams;         // JSON string of hyper‑parameters
        string consentTxId;          // Blockchain tx ID of the consent receipt
        uint256 timestamp;           // Unix epoch
        bytes32 policyDigest;        // Hash of the compliance policy applied
    }

    mapping(string => GenerationRecord) public records; // key = datasetHash

    event DataGenerated(string indexed datasetHash, address indexed generator);

    function registerGeneration(
        string memory _datasetHash,
        string memory _algorithmId,
        string memory _hyperParams,
        string memory _consentTxId,
        bytes32 _policyDigest
    ) public {
        require(bytes(_datasetHash).length > 0, "Invalid hash");
        GenerationRecord memory rec = GenerationRecord({
            datasetHash: _datasetHash,
            algorithmId: _algorithmId,
            hyperParams: _hyperParams,
            consentTxId: _consentTxId,
            timestamp: block.timestamp,
            policyDigest: _policyDigest
        });
        records[_datasetHash] = rec;
        emit DataGenerated(_datasetHash, msg.sender);
    }

    function getRecord(string memory _datasetHash) public view returns (GenerationRecord memory) {
        return records[_datasetHash];
    }
}
```

**Miks see disain töötab**

* **Võltsimiskindlus** – Kui `registerGeneration` kutsutakse, on kirje plokiahelas muutumatu.  
* **Ise kirjeldav** – Kõik asjakohased metaandmed salvestatakse ühte tehingusse, eemaldades vajaduse väliste metaandmepoodide järele.  
* **Poliitika sidumine** – `policyDigest` seob andmekogumi konkreetse vastavuspoliitika versiooniga, võimaldades automatiseeritud poliitika drift'i tuvastamist.

## 4. Formize'i integreerimine nõusoleku ja poliitika haldamiseks

Formize paistab silma **dünaamilise nõusoleku kogumisel** ja **poliitika versioonihaldusel**. Integreerimisvoog on:

1. **Nõusoleku kogumine** – Kasutaja täidab Formize veebivormi; platvorm allkirjastab kviitungi detsentraliseeritud identifikaatoriga (DID) ja kirjutab kviitungi plokiahelasse.  
2. **Poliitika päring** – Enne andmete genereerimist küsib sünteetiline mootor Formize'ilt aktiivse privaatsuspoliitika (nt GDPR‑Artikkel‑6‑1‑a) ja saab selle räsi.  
3. **Lepingu väljakutse** – Mootor edastab andmelepingule nõusoleku tehingu ID ja poliitika räsi.  

See tihe sidumine tagab, et iga sünteetiline andmekogum on **krüptograafiliselt seotud** täpselt selle loomiseks kehtiva nõusoleku ja poliitikaga.

## 5. Automatiseeritud päritolu ekstraheerimisteenus

**Päritolu teenus** on Go (või Rust) keeles kirjutatud mikroteenus, mis tellib plokiahela sündmusi Fabric SDK kaudu. Selle ülesanded:

* **Sündmuste kuulaja** – `DataGenerated` sündmuste korral tõmbab täis `GenerationRecord`.  
* **Graafi koostamine** – Lisab sõlme Neo4j või JanusGraph andmebaasi, sidudes selle vanema andmekogumiga (kui olemas) `DERIVED_FROM` serva.  
* **Versiooni märgistamine** – Määrab semantilised versiooninumbrid (`v1.0.0`, `v1.1.0`) algoritmi või hüperparameetrite muudatuste põhjal.  
* **API avaldamine** – Pakub GraphQL lõpp-punkti allvoo tööriistadele (CI/CD, auditi UI).  

Näidispäring täis päritolu andmekogumi kohta:

```graphql
query Lineage($hash: String!) {
  dataset(hash: $hash) {
    hash
    algorithmId
    generatedAt
    parent {
      hash
      algorithmId
    }
    children {
      hash
      algorithmId
    }
  }
}
```

## 6. CI/CD integratsioon korduvate mudelite treenimiseks

Muutumatu versioonihalduse integreerimine CI/CD-sse tagab, et **iga mudeli ehitus on reprodutseeritav**. Allpool on tüüpiline GitHub Actions töövoo näidis:

```yaml
name: Train Model
on:
  push:
    branches: [ main ]

jobs:
  train:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Resolve dataset version
        id: dataset
        run: |
          HASH=$(curl -s https://lineage.api.company.com/dataset/latest | jq -r .hash)
          echo "DATASET_HASH=$HASH" >> $GITHUB_ENV

      - name: Pull dataset from storage
        run: |
          aws s3 cp s3://synthetic-data/${{ env.DATASET_HASH }} ./data.csv

      - name: Train model
        run: |
          python train.py --data data.csv --output model.pkl

      - name: Register model artifact
        run: |
          curl -X POST -H "Content-Type: application/json" \
            -d '{"modelHash":"'"$(sha256sum model.pkl | cut -d' ' -f1)"'","datasetHash":"${{ env.DATASET_HASH }}"}' \
            https://model-registry.api.company.com/register
```

* Töövoog **pärib Lineage Service'ilt** viimase andmekogumi räsi, tagades, et kasutatud täpne versioon on salvestatud.  
* Pärast treeningut registreeritakse mudeli artefakt koos andmekogumi räsi‑ga, luues **kahekordse lingi** mudeli ja andmete vahel.

## 7. Auditeeritav vastavusraport

Regulaatorid nõuavad üha enam **reaalajas tõendeid**, et sünteetilised andmevood austavad privaatsuse ja õigluspiiranguid. Plokiahela toetatud arhitektuuriga muutub vastavusraporti koostamine lihtsalt päringuks pearaamatusse.

Näidis Python skript, mis genereerib PDF auditiaruande:

```python
import json
from web3 import Web3
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas

w3 = Web3(Web3.HTTPProvider("https://fabric-node.company.com"))
contract = w3.eth.contract(address="0xABC123...", abi=contract_abi)

def fetch_record(dataset_hash):
    return contract.functions.getRecord(dataset_hash).call()

def generate_report(dataset_hash, filename):
    rec = fetch_record(dataset_hash)
    c = canvas.Canvas(filename, pagesize=letter)
    c.drawString(72, 720, f"Dataset Hash: {rec[0]}")
    c.drawString(72, 700, f"Algorithm ID: {rec[1]}")
    c.drawString(72, 680, f"Hyper‑Parameters: {rec[2]}")
    c.drawString(72, 660, f"Consent Tx ID: {rec[3]}")
    c.drawString(72, 640, f"Policy Digest: {rec[5].hex()}")
    c.save()

generate_report("0xdeadbeef...", "audit_report.pdf")
```

Tekkinud PDF sisaldab **krüptograafilisi viiteid**, mida auditorid saavad kontrollida avaliku pearaamatu vastu, vähendades oluliselt vastavuskontrollide jaoks kuluvat aega.

## 8. Turvalisus- ja jõudluskaalutlused

| Aspekt                | Soovitus                                                                 |
|-----------------------|--------------------------------------------------------------------------|
| **Litsenseerimine**   | Kasuta **litsenseeritud** plokiahelat (Hyperledger Fabric või Corda), et piirata kirjutamisõigused ainult usaldusväärsetele teenustele. |
| **Andmete privaatsus**| Salvesta plokiahelas ainult **räsid** ja metaandmed; tegelik sünteetiline andmekogum jääb krüpteeritud objektisalvestusse. |
| **Skaleeritavus**     | Koonda mitu `registerGeneration` kutset üheks plokiks, et vähendada tehingukulusid. |
| **Võtmehaldus**       | Kasuta riistvaralisi turvamooduleid (HSM) nõusoleku kviitungite ja lepingukutsungite allkirjastamiseks. |
| **Katastroofi taastamine**| Korda pearaamatut mitmes andmekeskuses ja võimalda graafiandmebaasi hetktõmmiste varukoopiaid. |

## 9. Reaalse maailma kasutusjuht: tervishoiu uurimiskonsortsium

Mitme asutuse tervishoiukonsortsium pidi jagama sünteetilisi patsiendiandmeid, järgides samal ajal [HIPAA](https://www.hhs.gov/hipaa/index.html) ja [GDPR](https://gdpr.eu/) nõudeid. Võttes kasutusele plokiahela toetatud andmelepingu mudeli:

* **Versiooni jälgitavus** võimaldas teadlastel täpselt kolm aastat hiljem avaldatud mudeli reprodutseerida.  
* **Nõusoleku sidumine** tagas, et iga patsient, kes oma nõusoleku tühistas, käivitab automaatse tühistamissündmuse, mida Päritolu teenus edastab allvoo andmekogumitele.  
* **Regulatiivne audit** lõpetati ühe päevaga, mitte nädalatega, kuna auditor sai alla laadida muutumatu pearaamatu ja kontrollida iga andmekogumi versiooni.  

Konsortsium teatas **40 % vähenenud vastavuskulud** ja **30 % kiirenemine** mudelite arendustsüklites.

## 10. Alustamine – minimaalne prototüüp

1. **Seadista kohalik Fabric võrk** ametlike Docker näidiste abil.  
2. **Paigalda `SyntheticDataContract` kettakood** (vt jaotis 3).  
3. **Installeeri Formize** ja konfigureeri nõusoleku vorm, mis kirjutab kviitungid samale Fabric kanali.  
4. **Rakenda lihtne Päritolu teenus** Go keeles, mis kuulab `DataGenerated` sündmusi ja salvestab sõlmed mällukaardisse.  
5. **Käivita sünteetiline andmegenereerija** (nt eelnevalt treenitud CTGAN), mis kutsub iga jooksu järel `registerGeneration`.  
6. **Päringu pearaamatust** veendumaks, et iga andmekogumi versioon on muutumatu.  

See liivakast pakub tõestuskonsepti, mida saab tootmisse skaleerida, lisades püsiva graafiandmebaasi, rollipõhise juurdepääsukontrolli ning integreerides olemasolevate MLOps platvormidega, nagu Kubeflow või MLflow.

## 11. Tuleviku suunad

Jätkuvalt laiendades muutumatut andmelepingu raamistikku, saavad organisatsioonid olla uute regulatsioonide ees ja säilitada usalduse AI-süsteemide vastu, mis sõltuvad sünteetilistest andmetest.

* **Zero‑knowledge tõendid** – Sisesta zk‑SNARKid andmelepingu, et tõestada, et andmekogum vastab privaatsuse eelarvele, ilma andmeid avaldamata.  
* **Ristketi ühilduvus** – Kasuta Cosmos IBC või Polkadot sildasid, et jagada sünteetilise andmete päritolu organisatsioonide vahel, säilitades suveriiklikkuse.  
* **AI‑põhine poliitika areng** – Kasuta LLM-e, et automaatselt soovitada poliitika uuendusi, tuginedes sünteetiliste andmete kvaliteedi või eelarvamuste mõõdikute drift'i tuvastamisele.  

## Vaata ka

* [Hyperledger Fabric Documentation](https://hyperledger-fabric.readthedocs.io) – Ametlik juhend litsenseeritud plokiahelate loomisel.  
* [Formize Consent Management Platform](https://formize.com/consent) – Kuidas Formize haldab detsentraliseeritud identiteeti ja dünaamilist nõusolekut.  
* [Zero‑Knowledge Proofs for Privacy‑Preserving AI](https://zokrates.github.io) – Sissejuhatus zk‑SNARKidesse ja nende rakendustesse sünteetiliste andmete valdkonnas.