
# Versionarea Imutabilă a Datelor Sintetice și Trasabilitatea Auditată cu Contracte de Date Susținute de Blockchain

Datele sintetice au devenit o piatră de temelie a dezvoltării moderne de AI, permițând antrenarea de modele cu respectarea confidențialității, prototiparea rapidă și reducerea bias‑ului. Totuși, pe măsură ce conductele de date sintetice devin tot mai complexe — cuprinzând multiple echipe, regiuni cloud și dispozitive edge — organizațiile se confruntă cu două întrebări fundamentale:

1. **Ce versiune a unui set de date sintetic a fost folosită pentru antrenarea unui model specific?**  
2. **Putem demonstra că procesul de generare a datelor a respectat politicile regulatorii și etice?**

Soluțiile tradiționale de catalogare a datelor se bazează pe depozite de metadate mutabile, vulnerabile la suprascrieri accidentale, manipulări interne și piste de audit fragmentate. În acest articol prezentăm o **arhitectură de contract de date susținută de blockchain** care oferă **versionare imutabilă**, **trasabilitate criptografic verificabilă** și **raportare automată a conformității** pentru datele sintetice. Abordarea se sprijină pe trei piloni:

* **Registru Imutabil** – Un blockchain permisiv înregistrează fiecare tranzacție a contractului de date, garantând dovezi de manipulare.  
* **Contracte de Date Conduse de Smart‑Contracte** – Contracte auto‑executabile codifică parametrii de generare, chitanțele de consimțământ și constrângerile de politică.  
* **Extracție Automată a Liniei de Proveniență** – Agenți declanșați de evenimente transformă starea contractului într-un grafic unificat de linie de proveniență, interogabil de instrumentele MLOps.

La finalul acestui ghid veți înțelege fluxul end‑to‑end, veți vedea o implementare concretă folosind Hyperledger Fabric și Formize și veți învăța cum să integrați soluția în conductele CI/CD pentru conformitate continuă.

---

## 1. De ce contează Versionarea Imutabilă pentru Datele Sintetice

Conductele de date sintetice implică, de obicei, următoarele etape:

1. **Ingestia Datelor Sursă** – Datele din lumea reală sunt colectate în conformitate cu consimțământul și politicile de confidențialitate.  
2. **Transformarea pentru Confidențialitate** – Diferențială, GAN‑uri sau modele de difuzie generează înregistrări sintetice.  
3. **Asigurarea Calității** – Teste statistice, detectarea bias‑ului și evaluarea utilității validează rezultatul.  
4. **Distribuția** – Seturile de date sunt stocate în lacuri de date, partajate prin API‑uri sau alimentate direct în joburile de antrenament.

Fiecare etapă poate produce multiple **iterații** (de ex., sweep‑uri de hiper‑parametri, actualizări de model). Fără versionare imutabilă:

* **Reproductibilitatea modelelor suferă** – Echipele nu pot reproduce în mod fiabil un model antrenat pe „Dataset v3.2”.  
* **Riscul de reglementare crește** – Auditorii nu pot verifica că un set de date a respectat [GDPR](https://gdpr.eu/) sau [HIPAA](https://www.hhs.gov/hipaa/index.html) în momentul utilizării.  
* **Lacune în provenancea datelor** – Când apare o problemă de bias, identificarea parametrilor exacti de generare este consumatoare de timp.

Un registru imutabil rezolvă aceste probleme prin furnizarea unei **surse unice de adevăr** care nu poate fi modificată retroactiv.

---

## 2. Prezentare Generală a Arhitecturii de Bază

Mai jos este o diagramă de nivel înalt a arhitecturii propuse. Diagrama este exprimată în sintaxa Mermaid, pe care Hugo o poate reda automat.

```mermaid
graph LR
    subgraph Edge
        A["Sursă de Date din Lumea Reală"]
        B["Gestionarea Consimțământului (Formize)"]
    end
    subgraph Core
        C["Motor de Date Sintetice"]
        D["Smart‑Contract de Contract de Date"]
        E["Blockchain Permisiv"]
        F["Serviciu de Linie de Proveniență"]
        G["Conductă CI/CD"]
        H["Registru de Modele"]
    end
    subgraph Consumers
        I["Job de Antrenament"]
        J["Tablou de Audit"]
    end

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

**Interacțiuni cheie**

* **Gestionarea Consimțământului (Formize)** colectează consimțământul utilizatorului și emite o chitanță semnată, stocată pe lanț.  
* **Motorul de Date Sintetice** (de ex., un GAN sau model de difuzie) citește chitanța, generează datele și apelează **Contractul de Date** cu parametrii de generare.  
* **Contractul de Date** scrie o tranzacție pe **Blockchainul Permisiv**, creând o înregistrare imutabilă ce include:  
  * Hash‑ul setului de date  
  * Versiunea algoritmului de generare  
  * Hiper‑parametrii  
  * Referință la chitanța de consimțământ  
  * Indicatori de conformitate a politicii  
* **Serviciul de Linie de Proveniență** se abonează la evenimentele blockchain, construiește un graf orientat aciclic (DAG) al versiunilor de seturi de date și expune un API GraphQL.  
* **Conducta CI/CD** preia hash‑ul ultimei versiuni de set de date din registru înainte de a declanșa un job de antrenament, garantând reproducibilitatea.  
* **Tabloul de Audit** vizualizează graficul de linie de proveniență și furnizează rapoarte de conformitate exportabile.

---

## 3. Contracte de Date ca Smart‑Contracte

Un **Contract de Date** este un smart‑contract ușor care încapsulează întregul context al generării datelor sintetice. Mai jos este un pseudo‑cod simplificat în stil Solidity, care ar putea fi compilat pentru chaincode‑ul Hyperledger Fabric.

```solidity
contract SyntheticDataContract {
    struct GenerationRecord {
        string datasetHash;          // SHA‑256 al setului de date generat
        string algorithmId;          // ex.: "GAN_v2.1"
        string hyperParams;         // șir JSON cu hiper‑parametrii
        string consentTxId;          // ID-ul tranzacției de consimțământ pe blockchain
        uint256 timestamp;           // Epoch Unix
        bytes32 policyDigest;        // Hash al politicii de conformitate aplicate
    }

    mapping(string => GenerationRecord) public records; // cheie = 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];
    }
}
```

**De ce funcționează această proiectare**

* **Dovezi de manipulare** – Odată apelată `registerGeneration`, înregistrarea devine imutabilă pe registru.  
* **Auto‑descriere** – Toate metadatele relevante sunt stocate într-o singură tranzacție, eliminând nevoia de depozite externe de metadate.  
* **Legătură cu politica** – `policyDigest` leagă setul de date de o versiune specifică a politicii de conformitate, permițând detectarea automată a devierilor de politică.

---

## 4. Integrarea Formize pentru Gestionarea Consimțământului și a Politicilor

Formize excelează în **colectarea dinamică a consimțământului** și **versiunea politicilor**. Fluxul de integrare este:

1. **Capturarea Consimțământului** – Un utilizator completează un formular web Formize; platforma semnează chitanța cu un identificator descentralizat (DID) și scrie chitanța pe blockchain.  
2. **Recuperarea Politicii** – Înainte de generarea datelor, motorul sintetic interoghează Formize pentru politica de confidențialitate activă (de ex., GDPR‑Articol‑6‑1‑a) și obține hash‑ul acesteia.  
3. **Invocarea Contractului** – Motorul transmite ID‑ul tranzacției de consimțământ și hash‑ul politicii către Contractul de Date.

Această legătură strânsă asigură că fiecare set de date sintetic este **legat criptografic** la exact consimțământul și politica care au guvernat crearea sa.

---

## 5. Serviciul de Extracție Automată a Liniei de Proveniență

**Serviciul de Linie de Proveniență** este un microserviciu scris în Go (sau Rust) care se abonează la evenimentele blockchain prin SDK‑ul Fabric. Responsabilitățile sale:

* **Listener de Evenimente** – La evenimentele `DataGenerated`, preia complet `GenerationRecord`.  
* **Construcția Graficului** – Inserează un nod într-o bază de date Neo4j sau JanusGraph, legându‑l de setul de date părinte (dacă există) printr‑o muchie `DERIVED_FROM`.  
* **Etichetarea Versiunilor** – Atribuie numere semantice de versiune (`v1.0.0`, `v1.1.0`) pe baza modificărilor în algoritm sau hiper‑parametri.  
* **Expunerea API‑ului** – Oferă un endpoint GraphQL pentru instrumentele downstream (CI/CD, UI de audit).

Exemplu de interogare pentru a obține întreaga linie de proveniență a unui set de date:

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

---

## 6. Integrarea CI/CD pentru Antrenament Reproductibil al Modelului

Încapsularea versionării imutabile în CI/CD garantează că **fiecare construcție de model este reproductibilă**. Mai jos este un fragment tipic de workflow 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
```

Puncte cheie:

* Workflow‑ul **interoghează Serviciul de Linie de Proveniență** pentru hash‑ul ultimei versiuni de set de date, asigurând că versiunea exactă utilizată este înregistrată.  
* După antrenament, artefactul modelului este înregistrat împreună cu hash‑ul setului de date, creând o **legătură bidirecțională** între model și date.

---

## 7. Raportare Auditată a Conformității

Regulatorii solicită din ce în ce mai mult **dovezi în timp real** că conductele de date sintetice respectă constrângerile de confidențialitate și echitate. Cu arhitectura susținută de blockchain, generarea unui raport de conformitate devine o simplă interogare a registrului.

Exemplu de script Python care produce un raport PDF de audit:

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

PDF‑ul rezultat conține **referințe criptografice** pe care auditorii le pot verifica pe registrul public, reducând dramatic timpul necesar pentru verificările de conformitate.

---

## 8. Considerații de Securitate și Performanță

| Aspect                | Recomandare                                                                 |
|-----------------------|------------------------------------------------------------------------------|
| **Permisiuni**       | Utilizați un **blockchain permisiv** (Hyperledger Fabric sau Corda) pentru a restricționa accesul de scriere la servicii de încredere. |
| **Confidențialitatea Datelor** | Stocați pe lanț doar **hash‑uri** și metadate; setul de date sintetic propriu-zis rămâne în stocare criptată. |
| **Scalabilitate**    | Agregați mai multe apeluri `registerGeneration` într-un singur bloc pentru a reduce costul tranzacțional. |
| **Gestionarea Cheilor** | Folosiți module de securitate hardware (HSM) pentru semnarea chitanțelor de consimțământ și a invocărilor contractului. |
| **Recuperare în caz de dezastru** | Replicați registrul în mai multe centre de date și activați backup‑uri de tip snapshot ale bazei de grafuri. |

---

## 9. Caz de Utilizare Real – Consorțiu de Cercetare în Sănătate

Un consorțiu multinațional de instituții medicale a trebuit să partajeze înregistrări pacienților sintetice respectând [HIPAA](https://www.hhs.gov/hipaa/index.html) și [GDPR](https://gdpr.eu/). Adoptând modelul de contract de date susținut de blockchain:

* **Trasabilitatea versiunilor** a permis cercetătorilor să reproducă exact un model publicat la trei ani distanță.  
* **Legătura cu consimțământul** a asigurat că orice pacient care și‑a retras consimțământul a declanșat un eveniment de revocare automat, propagat de Serviciul de Linie de Proveniență către seturile de date dependente.  
* **Auditul regulator** a fost finalizat într-o singură zi în loc de săptămâni, auditorul putând descărca registrul imutabil și verifica fiecare versiune de set de date.

Consorțiul a raportat o **reducere de 40 % a costurilor de conformitate** și o **accelerare de 30 % a ciclurilor de dezvoltare a modelelor**.

---

## 10. Începeți – Un Prototip Minimal

1. **Instalați o rețea locală Fabric** utilizând mostrele Docker oficiale.  
2. **Deplasați chaincode‑ul `SyntheticDataContract`** (vezi Secțiunea 3).  
3. **Instalați Formize** și configurați un formular de consimțământ care scrie chitanțele pe același canal Fabric.  
4. **Implementați un Serviciu de Linie de Proveniență simplu** în Go care ascultă evenimentele `DataGenerated` și stochează nodurile într‑o hartă în memorie.  
5. **Rulați un generator de date sintetice** (de ex., un CTGAN pre‑antrenat) care apelează `registerGeneration` după fiecare rulare.  
6. **Interogați registrul** pentru a verifica că fiecare versiune de set de date este imutabilă.

Acest sandbox oferă o dovadă de concept ce poate fi scalată în producție prin adăugarea unei baze de date de grafuri persistentă, control de acces bazat pe roluri și integrarea cu platforme MLOps existente precum Kubeflow sau MLflow.

---

## 11. Direcții Viitoare

* **Dovezi Zero‑Knowledge** – Încorporați zk‑SNARK‑uri în contractul de date pentru a demonstra că un set de date respectă un buget de confidențialitate fără a expune datele în sine.  
* **Interoperabilitate Cross‑Chain** – Folosiți Cosmos IBC sau poduri Polkadot pentru a partaja linia de proveniență a datelor sintetice între limite organizaționale, menținând suveranitatea.  
* **Evoluție a Politicii Condusă de AI** – Utilizați modele LLM pentru a sugera automat actualizări ale politicilor pe baza drift‑ului detectat în calitatea sau bias‑ul datelor sintetice.  

Prin extinderea continuă a cadrului de contracte de date imutabile, organizațiile pot rămâne în fruntea reglementărilor emergente și pot menține încrederea în sistemele AI care se bazează pe date sintetice.

---

## Vezi și

- [Documentația Hyperledger Fabric](https://hyperledger-fabric.readthedocs.io) – Ghid oficial pentru construirea de blockchainuri permisive.  
- [Platforma de Gestionare a Consimțământului Formize](https://formize.com/consent) – Cum gestionează Formize identitatea descentralizată și consimțământul dinamic.  
- [Dovezi Zero‑Knowledge pentru AI cu Confidențialitate](https://zokrates.github.io) – Introducere în zk‑SNARK‑uri și aplicațiile lor în date sintetice.