
# Nemenné verzovanie syntetických dát a auditovateľná línia s dátovými kontraktmi podporovanými blockchainom

Syntetické dáta sa stali základným kameňom moderného vývoja AI, umožňujúc trénovanie modelov s ochranou súkromia, rýchle prototypovanie a zmiernenie biasu. Avšak keď syntetické dátové pipeline rastú na zložitosť – zahŕňajú viacero tímov, cloudových regiónov a edge zariadení – organizácie majú problémy odpovedať na dve základné otázky:

1. **Ktorá verzia syntetického datasetu bola použitá na trénovanie konkrétneho modelu?**  
2. **Môžeme preukázať, že proces generovania dát spĺňal regulačné a etické politiky?**

Tradičné riešenia pre dátové katalógy sa spoliehajú na mutovateľné úložiská metadát, ktoré sú náchylné na náhodné prepísanie, vnútorné manipulácie a fragmentované auditové stopy. V tomto článku predstavujeme **architektúru dátových kontraktov podporovanú blockchainom**, ktorá poskytuje **nemenné verzovanie**, **kryptograficky overiteľnú líniu** a **automatizované reportovanie súladu** pre syntetické dáta. Prístup je postavený na troch pilieroch:

* **Nemenný ledger** – Povolený blockchain zaznamenáva každú transakciu dátového kontraktu, zaručujúc dôkaz o manipulácii.  
* **Smart‑kontrakt‑riadené dátové kontrakty** – Samo‑vykonávajúce sa kontrakty kódujú parametre generovania, potvrdenia súhlasu a obmedzenia politík.  
* **Automatizovaná extrakcia línie** – Na udalostiach založené agenty prekladajú stav kontraktu do jednotného grafu línie, ktorý môžu dotazovať nástroje MLOps.

---

## 1. Prečo je nemenné verzovanie dôležité pre syntetické dáta

Syntetické dátové pipeline typicky zahŕňajú nasledujúce fázy:

1. **Ingestia zdrojových dát** – Reálne dáta sa zhromažďujú podľa súhlasu a politík ochrany súkromia.  
2. **Transformácia ochrany súkromia** – Diferenciálna ochrana, GAN‑y alebo difúzne modely generujú syntetické záznamy.  
3. **Zabezpečenie kvality** – Štatistické testy, detekcia biasu a hodnotenie užitočnosti validujú výstup.  
4. **Distribúcia** – Datasets sa ukladajú do dátových jazier, zdieľajú cez API alebo sa priamo podávajú do tréningových úloh.

Každá fáza môže produkovať viacero **iterácií** (napr. prehľadávanie hyper‑parametrov, aktualizácie modelov). Bez nemenného verzovania:

* **Reprodukovateľnosť modelu trpí** – Tímy nemôžu spoľahlivo reprodukovať model, ktorý bol trénovaný na „Dataset v3.2“.  
* **Riziko regulácií sa zvyšuje** – Audítori nemôžu overiť, že dataset spĺňal GDPR alebo HIPAA v čase použitia.  
* **Medzery v pôvode dát** – Keď sa objaví problém s biasom, spätné sledovanie presných parametrov generovania je časovo náročné.

Nemenný ledger rieši tieto problémy tým, že poskytuje **jediný zdroj pravdy**, ktorý nie je možné spätne upraviť.

---

## 2. Prehľad základnej architektúry

Nižšie je vysokúrovňový diagram navrhovanej architektúry. Diagram je napísaný v Mermaid syntaxe, ktorú Hugo dokáže automaticky vykresliť.

```mermaid
graph LR
    subgraph Edge
        A["Zdroj reálnych dát"]
        B["Správa súhlasu (Formize)"]
    end
    subgraph Core
        C["Engine syntetických dát"]
        D["Smart kontrakt dátového kontraktu"]
        E["Povolený blockchain"]
        F["Služba sledovania línie"]
        G["CI/CD pipeline"]
        H["Registr modelov"]
    end
    subgraph Consumers
        I["Tréningová úloha"]
        J["Auditný dashboard"]
    end

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

**Kľúčové interakcie**

* **Správa súhlasu (Formize)** zhromažďuje súhlas používateľov a vydáva podpísané potvrdenie, ktoré je uložené na reťazci.  
* **Engine syntetických dát** (napr. GAN alebo difúzny model) číta potvrdenie, generuje dáta a volá dátový kontrakt s parametrami generovania.  
* **Dátový kontrakt** zapisuje transakciu do povoleného blockchainu, čím vytvára nemenný záznam, ktorý obsahuje:
  * Hash datasetu  
  * Verzia algoritmu generovania  
  * Hyper‑parametre  
  * Referencia na potvrdenie súhlasu  
  * Značky súladu s politikou  
* **Služba sledovania línie** odoberá udalosti z blockchainu, buduje orientovaný acyklický graf (DAG) datasetových verzií a poskytuje GraphQL API.  
* **CI/CD pipeline** ťahá najnovší hash datasetu z ledgeru pred spustením tréningovej úlohy, čím garantuje reprodukovateľnosť.  
* **Auditný dashboard** vizualizuje graf línie a poskytuje exportovateľné súladové reporty.

---

## 3. Dátové kontrakty ako smart kontrakty

**Dátový kontrakt** je ľahký smart kontrakt, ktorý zachytáva celý kontext generovania syntetických dát. Nižšie je zjednodušený Solidity‑podobný pseudo‑kód, ktorý môže byť skompilovaný pre Hyperledger Fabric chaincode.

```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];
    }
}
```

**Prečo tento dizajn funguje**

* **Dôkaz o manipulácii** – Po zavolaní `registerGeneration` je záznam na ledgeri nemenný.  
* **Samo‑opisný** – Všetky relevantné metadáta sú uložené v jednej transakcii, čím sa eliminuje potreba externých úložísk metadát.  
* **Prepojenie politiky** – `policyDigest` viaže dataset na konkrétnu verziu politiky súladu, čo umožňuje automatickú detekciu odchýlok politiky.  

---

## 4. Integrácia Formize pre správu súhlasu a politík

Formize vyniká v **dinamickom zbere súhlasov** a **verzovaní politík**. Priebeh integrácie je:

1. **Zachytenie súhlasu** – Používateľ vyplní webový formulár Formize; platforma podpíše potvrdenie decentralizovaným identifikátorom (DID) a zapíše ho do blockchainu.  
2. **Získanie politiky** – Pred generovaním dát engine syntetických dát dotazuje Formize na aktívnu politiku ochrany súkromia (napr. GDPR‑Article‑6‑1‑a) a získava jej hash.  
3. **Volanie kontraktu** – Engine odovzdá ID transakcie súhlasu a hash politiky dátovému kontraktu.

Toto úzko prepojenie zabezpečuje, že každý syntetický dataset je **kryptograficky spojený** s presným súhlasom a politikou, ktoré riadili jeho vytvorenie.

---

## 5. Automatizovaná služba extrakcie línie

**Služba sledovania línie** je mikroservis napísaný v Go (alebo Rust), ktorý odoberá udalosti z blockchainu pomocou Fabric SDK. Jej úlohy:

* **Počúvanie udalostí** – Na udalostiach `DataGenerated` načíta celý `GenerationRecord`.  
* **Konstrukcia grafu** – Vloží uzol do databázy Neo4j alebo JanusGraph, prepojí ho s rodičovským datasetom (ak existuje) cez hranu `DERIVED_FROM`.  
* **Tagovanie verzií** – Priradí semantické čísla verzií (`v1.0.0`, `v1.1.0`) na základe zmien v algoritme alebo hyper‑parametroch.  
* **Expozícia API** – Poskytne GraphQL endpoint pre downstream nástroje (CI/CD, audit UI).

Ukážkový dotaz na získanie celej línie datasetu:

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

---

## 6. Integrácia CI/CD pre reprodukovateľné tréningy modelov

Vloženie nemenného verzovania do CI/CD zaručuje, že **každá zostava modelu je reprodukovateľná**. Nižšie je typický úryvok workflow pre GitHub Actions:

```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
```

**Kľúčové body**

* Workflow **dotazuje službu Lineage** na najnovší hash datasetu, čím zabezpečuje, že je zaznamenaná presná verzia.  
* Po tréningu je artefakt modelu registrovaný spolu s hashom datasetu, čím sa vytvára **obojstranný odkaz** medzi modelom a dátami.  

---

## 7. Auditovateľné reportovanie súladu

Regulátori čoraz viac požadujú **dôkazy v reálnom čase**, že syntetické dátové pipeline rešpektujú obmedzenia ochrany súkromia a spravodlivosti. S architektúrou podporovanou blockchainom sa generovanie reportu o súlade stáva otázkou dotazu na ledger.

Príklad Python skriptu, ktorý vytvára PDF auditný report:

```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")
```

Výsledné PDF obsahuje **kryptografické referencie**, ktoré audítori môžu overiť proti verejnému ledgeru, čím sa dramaticky skracuje čas potrebný na kontrolu súladu.

---

## 8. Bezpečnostné a výkonnostné úvahy

| Aspekt                     | Odporúčanie                                                                                                                                                     |
|----------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------|
| **Povolenie**              | Použite povolený blockchain (Hyperledger Fabric alebo Corda) na obmedzenie zápisu len na dôveryhodné služby.                                                   |
| **Ochrana dát**            | Na reťazci ukladajte iba hash a metadáta; samotné syntetické dáta zostávajú v šifrovanom úložisku objektov.                                                   |
| **Škálovateľnosť**         | Zoskupujte viacero volaní `registerGeneration` do jedného bloku, aby ste znížili preťaženie transakcií.                                                       |
| **Správa kľúčov**          | Využite hardvérové bezpečnostné moduly (HSM) na podpisovanie potvrdení súhlasu a volaní kontraktov.                                                            |
| **Obnova po havárii**      | Replikujte ledger naprieč viacerými dátovými centrami a povolte snapshot zálohy grafovej databázy.                                                             |

---

## 9. Reálny prípad použitia: Konsorcium zdravotníckych výskumov

Multiinštitucionálne zdravotnícke konsorcium potrebovalo zdieľať syntetické záznamy pacientov a zároveň dodržiavať HIPAA a GDPR. Vďaka nasadeniu modelu dátových kontraktov podporovaného blockchainom:

* **Sledovanie verzií** umožnilo výskumníkom reprodukovať publikovaný model presne o tri roky neskôr.  
* **Prepojenie súhlasu** zabezpečilo, že akýkoľvek pacient, ktorý odvolal súhlas, spustil automatickú revokačnú udalosť, ktorú služba Lineage propagovala do downstream datasetov.  
* **Regulačný audit** bol dokončený za jeden deň namiesto týždňov, pretože audítor mohol stiahnuť nemenný ledger a overiť každú verziu datasetu.  

Konsorcium hlásilo **40 % zníženie nákladov na súlad** a **30 % zrýchlenie cyklov vývoja modelov**.

---

## 10. Začíname – Minimálny prototyp

1. **Nastavte lokálnu Fabric sieť** pomocou oficiálnych Docker vzoriek.  
2. **Nasadiť chaincode `SyntheticDataContract`** (pozri sekciu 3).  
3. **Nainštalujte Formize** a nakonfigurujte formulár súhlasu, ktorý zapisuje potvrdenia do rovnakého Fabric kanála.  
4. **Implementujte jednoduchú službu Lineage v Go**, ktorá počúva na udalosti `DataGenerated` a ukladá uzly do pamäťovej mapy.  
5. **Spustite generátor syntetických dát** (napr. predtrénovaný CTGAN), ktorý po každom spustení volá `registerGeneration`.  
6. **Dotazujte ledger**, aby ste overili, že každá verzia datasetu je nemenná.

Tento sandbox poskytuje proof‑of‑concept, ktorý je možné rozšíriť do produkcie pridaním trvalej grafovej databázy, riadenia prístupu na základe rolí a integrácie s existujúcimi MLOps platformami ako Kubeflow alebo MLflow.

---

## 11. Budúce smerovanie

* **Zero‑knowledge dôkazy** – Vložiť zk‑SNARKs do dátového kontraktu na preukázanie, že dataset spĺňa rozpočet ochrany súkromia bez odhalenia samotných dát.  
* **Cross‑chain interoperabilita** – Použiť Cosmos IBC alebo Polkadot mosty na zdieľanie línie syntetických dát naprieč organizačnými hranicami pri zachovaní suverenity.  
* **AI‑riadený vývoj politík** – Využiť LLM na automatické navrhovanie aktualizácií politík na základe zistených odchýlok v kvalite syntetických dát alebo metrikách biasu.  

Integráciou a neustálym rozširovaním tejto nemennej dátovej kontraktovej platformy môžu organizácie zostať o krok vpred pred novými reguláciami a udržiavať dôveru v AI systémy, ktoré využívajú syntetické dáta.

---

## Ďalšie zdroje

- [Dokumentácia Hyperledger Fabric](https://hyperledger-fabric.readthedocs.io) – Oficiálny sprievodca pre budovanie povolených blockchainov.  
- [Platforma správy súhlasu Formize](https://formize.com/consent) – Ako Formize rieši decentralizovanú identitu a dynamický súhlas.  
- [Zero‑knowledge dôkazy pre AI zachovávajúcu súkromie](https://zokrates.github.io) – Úvod do zk‑SNARKs a ich aplikácií v syntetických dátach.