
# Nekintama sintetinių duomenų versijavimas ir audituojama kilmė su blokų grandinės pagrįstomis duomenų sutartimis

Sintetiniai duomenys tapo kertiniu šiuolaikinio DI vystymo akmeniu, leidžiančiu privatumo išsaugojimą mokymui, greitą prototipų kūrimą ir šališkumo mažinimą. Tačiau augant sintetinių duomenų konvejerių sudėtingumui – jie apima kelias komandas, debesų regionus ir krašto įrenginius – organizacijos susiduria su dviem pagrindiniais klausimais:

1. **Kuri sintetinių duomenų rinkinio versija buvo naudojama konkrečiam modeliui mokyti?**  
2. **Ar galime įrodyti, kad duomenų generavimo procesas atitiko reguliacinius ir etinius reikalavimus?**

Tradiciniai duomenų katalogų sprendimai remiasi keičiamais metaduomenų saugyklomis, kurios yra pažeidžiamos atsitiktinių perrašymų, vidinių manipuliacijų ir fragmentuotų audito takų. Šiame straipsnyje pristatome **blokų grandinės pagrįstą duomenų sutarties architektūrą**, kuri suteikia **nekintamą versijavimą**, **kriptografiškai patikrinamą kilmę** ir **automatizuotą atitikties ataskaitų generavimą** sintetiniams duomenims. Požiūris remiasi trimis stulpeliais:

* **Nekintamas ledžeris** – leidžiamas blokų grandinės įrašas fiksuoja kiekvieną duomenų sutarties sandorį, garantuodamas nepažeidžiamumą.  
* **Išmanioji sutartimi valdomos duomenų sutartys** – savarankiškai vykdomos sutartys koduoja generavimo parametrus, sutikimo kvitus ir politikos apribojimus.  
* **Automatizuotas kilmės išgavimas** – įvykių valdomi agentai verčia sutarties būseną į vieningą kilmės grafą, kurį gali užklausti MLOps įrankiai.

Pasibaigus šiam vadovui, suprasite visą procesą nuo pradžios iki pabaigos, pamatysite konkretų įgyvendinimą naudojant Hyperledger Fabric ir Formize, bei išmoksite, kaip integruoti sprendimą į CI/CD konvejerius nuolatinei atitikties užtikrinimui.

---

## 1. Kodėl nekintamas versijavimas svarbus sintetiniams duomenims

Sintetinių duomenų konvejeriai paprastai susideda iš šių etapų:

1. **Šaltinių duomenų įkėlimas** – realaus pasaulio duomenys renkami pagal sutikimą ir privatumo politiką.  
2. **Privatumo transformacija** – diferencialinė privatumas, GAN arba difuzijos modeliai generuoja sintetinius įrašus.  
3. **Kokybės užtikrinimas** – statistiniai testai, šališkumo aptikimas ir naudingumo įvertinimas patikrina išvestį.  
4. **Distribucija** – duomenų rinkiniai saugomi duomenų ežeruose, dalijami per API arba tiesiogiai tiekiami mokymo darbams.

Kiekvienas etapas gali sukurti kelis **iteracijas** (pvz., hiperparametrų peržiūras, modelio atnaujinimus). Be nekinto versijavimo:

* **Modelio pakartojamumas kenčia** – komandos negali patikimai atkurti modelio, mokyto „Duomenų rinkinys v3.2”.  
* **Reguliacinė rizika didėja** – auditoriai negali patvirtinti, kad duomenų rinkinys laikėsi [BDAR](https://gdpr.eu/) arba [HIPAA](https://www.hhs.gov/hipaa/index.html) reikalavimų naudojimo metu.  
* **Duomenų kilmės spragos** – kai iškyla šališkumo problema, grįžti prie tikslių generavimo parametrų užtrunka daug laiko.

Nekintamas ledžeris išsprendžia šias problemas, suteikdamas **vienintelį tiesos šaltinį**, kurio negalima retroaktyviai keisti.

---

## 2. Pagrindinė architektūros apžvalga

Žemiau pateikiamas aukšto lygio architektūros diagramos pavyzdys. Diagrama parašyta Mermaid sintakse, kurią Hugo gali automatiškai atvaizduoti.

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

**Pagrindiniai sąveikos taškai**

* **Sutikimo valdymas (Formize)** renka vartotojo sutikimą ir išsiunčia pasirašytą kvitą, kuris saugomas blokų grandinėje.  
* **Sintetinių duomenų variklis** (pvz., GAN arba difuzijos modelis) perskaito kvitą, generuoja duomenis ir iškviečia **Duomenų sutartį** su generavimo parametrais.  
* **Duomenų sutartis** įrašo sandorį į **Leidžiamą blokų grandinę**, sukurdama nekintamą įrašą, kuriame yra:  
  * Duomenų rinkinio maiša (hash)  
  * Generavimo algoritmo versija  
  * Hiperparametrai  
  * Sutikimo kvito nuoroda  
  * Politikos atitikties žymės  
* **Kilmės paslauga** prenumeruoja blokų grandinės įvykius, kuria nukreiptą aštrųjį grafą (DAG) duomenų rinkinių versijoms ir teikia GraphQL API.  
* **CI/CD konvejeris** prieš paleisdamas mokymo darbą gauna naujausios duomenų rinkinio maišos reikšmę iš ledžerio, užtikrindamas pakartojamumą.  
* **Audito skydelis** vizualizuoja kilmės grafiką ir teikia ištraukiamas atitikties ataskaitas.

---

## 3. Duomenų sutartys kaip išmaniosios sutartys

**Duomenų sutartis** – tai supaprastinta išmanioji sutartis, kuri apima visą sintetinių duomenų generavimo kontekstą. Žemiau pateiktas supaprastintas Solidity‑panašus pseudo‑kodas, kurį galima kompiliuoti į Hyperledger Fabric grandinės kodą.

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

**Kodėl šis dizainas veikia**

* **Neįmanoma manipuliuoti** – kai `registerGeneration` iškviečiamas, įrašas tampa nekintamas blokų grandinėje.  
* **Savarankiškai aprašomas** – visi svarbūs metaduomenys saugomi vienoje sandorio įraše, pašalinant poreikį naudoti išorines metaduomenų saugyklas.  
* **Politikos susiejimas** – `policyDigest` susieja duomenų rinkinį su konkrečios atitikties politikos versija, leidžiant automatizuotai aptikti politikos pasikeitimus.

---

## 4. Formize integravimas sutikimui ir politikos valdymui

Formize puikiai tinka **dinaminio sutikimo rinkimui** ir **politikų versijavimui**. Integracijos eiga:

1. **Sutikimo surinkimas** – vartotojas užpildo Formize internetinę formą; platforma pasirašo kvitą su decentralizuotu identifikatoriumi (DID) ir įrašo kvitą į blokų grandinę.  
2. **Politikos gavimas** – prieš duomenų generavimą sintetinis variklis užklausia Formize dėl galiojančios privatumo politikos (pvz., BDAR‑straipsnis‑6‑1‑a) ir gauna jos maišą.  
3. **Sutarties iškvietimas** – variklis perduoda sutikimo sandorio ID ir politikos maišą Duomenų sutarčiai.

Šis glaustas susiejimas užtikrina, kad kiekvienas sintetinis duomenų rinkinys būtų **kriptografiškai susietas** su tikslu sutikimu ir politika, kuri valdė jo kūrimą.

---

## 5. Automatizuota kilmės išgavimo paslauga

**Kilmės paslauga** – mikroservisas, parašytas Go (arba Rust), kuris prenumeruoja blokų grandinės įvykius per Fabric SDK. Jo atsakomybės:

* **Įvykių klausytojas** – gaunant `DataGenerated` įvykius, ištraukia visą `GenerationRecord`.  
* **Grafų kūrimas** – įterpia mazgą į Neo4j arba JanusGraph duomenų bazę, susiedamas jį su tėviniu duomenų rinkiniu per `DERIVED_FROM` ryšį.  
* **Versijavimas** – priskiria semantinę versiją (`v1.0.0`, `v1.1.0`) pagal algoritmo ar hiperparametrų pokyčius.  
* **API teikimas** – suteikia GraphQL galutinį tašką, kurį naudoja CI/CD, audito UI ir kiti įrankiai.

Pavyzdinė užklausa, skirta gauti visą duomenų rinkinio kilmę:

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

---

## 6. CI/CD integravimas dėl pakartojamo modelio mokymo

Įterpiant nekintamą versijavimą į CI/CD, **kiekvienas modelio kūrimas tampa pakartojamas**. Žemiau pateiktas tipinis GitHub Actions darbo srauto fragmentas:

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

Svarbūs momentai:

* Darbo eiga **užklausia Kilmės paslaugą** dėl naujausios duomenų rinkinio maišos, užtikrinant, kad naudojama tiksliai ta versija.  
* Po mokymo modelio artefaktas registruojamas kartu su duomenų rinkinio maiša, sukuriant **dvipusį ryšį** tarp modelio ir duomenų.

---

## 7. Audituojamos atitikties ataskaitos

Reguliuotojai vis dažniau reikalauja **realaus laiko įrodymų**, kad sintetinių duomenų konvejeriai gerbia privatumo ir teisingumo reikalavimus. Su blokų grandinės pagrindu architektūra, ataskaitos generavimas tampa paprastu duomenų užklausimu.

Pavyzdinis Python skriptas, generuojantis PDF audito ataskaitą:

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

Gautas PDF turi **kriptografines nuorodas**, kurias auditoriai gali patikrinti prieš viešąjį ledžerį, taip žymiai sumažindami audito laiką.

---

## 8. Saugumo ir našumo svarstymai

| Sritis                | Rekomendacija                                                                 |
|-----------------------|-------------------------------------------------------------------------------|
| **Leidžiamumas**      | Naudokite **leidžiamą blokų grandinę** (Hyperledger Fabric arba Corda), kad apribotumėte rašymo prieigą tik patikimoms paslaugoms. |
| **Duomenų privatumas**| Laikykite tik **maišas** ir metaduomenis grandinėje; tikruosius sintetinius duomenis saugokite šifruotoje objektų saugykloje. |
| **Mastelio galimybės**| Grupėkite kelis `registerGeneration` kvietimus į vieną bloką, kad sumažintumėte sandorių perkrovą. |
| **Raktų valdymas**    | Pasinaudokite aparatūriniais saugumo moduliais (HSM) sutikimo kvitų ir sutarties iškvietimų pasirašymui. |
| **Avarinės atkūrimo** | Dubliuokite ledžerį keliuose duomenų centruose ir įgalinkite momentinių kopijų atsargines kopijas grafinės duomenų bazės. |

---

## 9. Realus atvejis: sveikatos tyrimų konsorciumas

Daugelio institucijų sveikatos tyrimų konsorciui reikėjo dalintis sintetinių pacientų įrašų duomenimis, laikantis [HIPAA](https://www.hhs.gov/hipaa/index.html) ir [BDAR](https://gdpr.eu/) reikalavimų. Įgyvendindami blokų grandinės pagrįstą duomenų sutarties modelį:

* **Versijų sekimas** leido tyrėjams tiksliai atkurti publikuotą modelį po trijų metų.  
* **Sutikimo susiejimas** užtikrino, kad bet kuris pacientas, atšaukiantis sutikimą, sukeltų automatinį atšaukimo įvykį, kurį Kilmės paslauga persiuntė į visus priklausomus duomenų rinkinius.  
* **Reguliacinis auditas** buvo baigtas per vieną dieną, o ne per kelias savaites, nes auditorius galėjo atsisiųsti nekintamą ledžerį ir patikrinti kiekvieną duomenų rinkinio versiją.

Konsorciumas pranešė apie **40 % sumažėjimą atitikties išlaidų** ir **30 % pagreitėjimą modelio kūrimo cikluose**.

---

## 10. Pradžia – minimalus prototipas

1. **Sukurkite vietinį Fabric tinklą** naudodami oficialius Docker pavyzdžius.  
2. **Įdiekite `SyntheticDataContract` grandinės kodą** (žr. 3 skyrių).  
3. **Įdiekite Formize** ir sukonfigūruokite sutikimo formą, kuri rašo kvitus į tą patį Fabric kanalą.  
4. **Įgyvendinkite paprastą Kilmės paslaugą** Go kalba, kuri klausosi `DataGenerated` įvykių ir saugo mazgus atmintyje.  
5. **Paleiskite sintetinių duomenų generatorių** (pvz., iš anksto apmokytą CTGAN), kuris po kiekvieno vykdymo iškviečia `registerGeneration`.  
6. **Užklauskite ledžerį**, kad patvirtintumėte, jog kiekviena duomenų rinkinio versija yra nekintama.

Šis smėlio dėžės (sandbox) prototipas suteikia įrodymą, kurį galima išplėsti į gamybą, pridedant nuolatinę grafinę duomenų bazę, rolės pagrindu paremtą prieigos kontrolę ir integraciją su esamomis MLOps platformomis, pvz., Kubeflow arba MLflow.

---

## 11. Ateities kryptys

* **Nulinio žinojimo įrodymai (Zero‑Knowledge Proofs)** – įterpkite zk‑SNARK į duomenų sutartį, kad įrodytumėte, jog duomenų rinkinys atitinka privatumo biudžetą, neatskleidžiant paties duomenų.  
* **Tarpų grandinių interoperabilumas** – naudokite Cosmos IBC arba Polkadot tiltus, kad dalintumėtės sintetinių duomenų kilme per organizacines ribas, išlaikydami suverenitetą.  
* **Lietuvių kalbos modelio politikos evoliucija** – pasitelkite LLM, kad automatiškai siūlytų politikos atnaujinimus, remiantis aptiktais duomenų kokybės ar šališkumo pokyčiais.  

Nuolat plečiant nekintamą duomenų sutarties rėmą, organizacijos gali išlikti priekyje besikeičiančių reguliavimų ir išlaikyti pasitikėjimą DI sistemomis, kurios remiasi sintetinių duomenų naudojimu.

---

## Žiūrėti taip pat

- [Hyperledger Fabric dokumentacija](https://hyperledger-fabric.readthedocs.io) – oficialus leidžiamų blokų grandinių kūrimo vadovas.  
- [Formize sutikimo valdymo platforma](https://formize.com/consent) – kaip Formize tvarko decentralizuotą identifikavimą ir dinaminį sutikimą.  
- [Nulinio žinojimo įrodymai privatumo išsaugojimui DI srityje](https://zokrates.github.io) – įvadas į zk‑SNARK ir jų taikymą sintetiniams duomenims.