
# Niezmienna wersja danych syntetycznych i audytowalny łańcuch pochodzenia z kontraktami danych opartymi na blockchainie

Dane syntetyczne stały się kamieniem węgielnym nowoczesnego rozwoju AI, umożliwiając prywatności‑zachowujące trenowanie modeli, szybkie prototypowanie i redukcję uprzedzeń. Jednak wraz ze wzrostem złożoności potoków danych syntetycznych — obejmujących wiele zespołów, regionów chmurowych i urządzeń brzegowych — organizacje mają trudności z odpowiedzią na dwa podstawowe pytania:

1. **Która wersja syntetycznego zestawu danych została użyta do wytrenowania konkretnego modelu?**  
2. **Czy możemy udowodnić, że proces generowania danych spełniał regulacyjne i etyczne polityki?**

Tradycyjne rozwiązania katalogów danych opierają się na mutowalnych magazynach metadanych, które są podatne na przypadkowe nadpisania, manipulacje wewnętrzne i rozproszone ścieżki audytu. W tym artykule przedstawiamy **architekturę kontraktu danych opartą na blockchainie**, która zapewnia **niezmienną wersję**, **kryptograficznie weryfikowalny łańcuch pochodzenia** oraz **automatyczne raportowanie zgodności** dla danych syntetycznych. Podejście opiera się na trzech filarach:

* **Niezmienny rejestr** – Uprawniony blockchain zapisuje każdą transakcję kontraktu danych, gwarantując dowód niezmienności.  
* **Kontrakty danych sterowane smart‑contractami** – Samowykonujące się kontrakty kodują parametry generacji, potwierdzenia zgody i ograniczenia polityk.  
* **Automatyczne wydobywanie łańcucha pochodzenia** – Agenci zdarzeniowi tłumaczą stan kontraktu na jednolity graf pochodzenia, który może być zapytany przez narzędzia MLOps.

Po przeczytaniu tego przewodnika zrozumiesz pełny przepływ end‑to‑end, zobaczysz konkretną implementację przy użyciu Hyperledger Fabric i Formize oraz dowiesz się, jak zintegrować rozwiązanie z pipeline’ami CI/CD w celu ciągłej zgodności.

---

## 1. Dlaczego niezmienna wersja jest ważna dla danych syntetycznych

Potoki danych syntetycznych zazwyczaj obejmują następujące etapy:

1. **Ingestja danych źródłowych** – Dane rzeczywiste są zbierane zgodnie ze zgodą i politykami prywatności.  
2. **Transformacja prywatności** – Różnicowa prywatność, GAN‑y lub modele dyfuzyjne generują syntetyczne rekordy.  
3. **Zapewnienie jakości** – Testy statystyczne, wykrywanie uprzedzeń i ocena użyteczności walidują wynik.  
4. **Dystrybucja** – Zestawy danych są przechowywane w jeziorach danych, udostępniane przez API lub podawane bezpośrednio do zadań treningowych.

Każdy etap może generować wiele **iteracji** (np. przeszukiwanie hiper‑parametrów, aktualizacje modeli). Bez niezmiennej wersji:

* **Reprodukowalność modeli cierpi** – Zespoły nie mogą wiarygodnie odtworzyć modelu wytrenowanego na „Dataset v3.2”.  
* **Ryzyko regulacyjne rośnie** – Audytorzy nie mogą zweryfikować, że zestaw danych spełniał wymogi [GDPR](https://gdpr.eu/) lub [HIPAA](https://www.hhs.gov/hipaa/index.html) w momencie użycia.  
* **Luki w pochodzeniu danych** – Gdy pojawia się problem z uprzedzeniami, odtworzenie dokładnych parametrów generacji jest czasochłonne.

Niezmienny rejestr rozwiązuje te problemy, dostarczając **jedno źródło prawdy**, którego nie można retroaktywnie zmienić.

---

## 2. Przegląd podstawowej architektury

Poniżej znajduje się diagram wysokiego poziomu proponowanej architektury. Diagram jest zapisany w składni Mermaid, którą Hugo może renderować automatycznie.

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

**Kluczowe interakcje**

* **Zarządzanie zgodą (Formize)** zbiera zgodę użytkownika i emituje podpisany dowód, który jest przechowywany w łańcuchu.  
* **Silnik danych syntetycznych** (np. GAN lub model dyfuzyjny) odczytuje dowód, generuje dane i wywołuje **Kontrakt danych** z parametrami generacji.  
* **Kontrakt danych** zapisuje transakcję w **Uprawnionym blockchainie**, tworząc niezmienny rekord zawierający:
  * Hash zestawu danych  
  * Wersję algorytmu generacji  
  * Hiper‑parametry  
  * Odniesienie do dowodu zgody  
  * Flagi zgodności z polityką  
* **Usługa łańcucha pochodzenia** subskrybuje zdarzenia blockchaina, buduje skierowany acykliczny graf (DAG) wersji zestawów danych i udostępnia API GraphQL.  
* **Pipeline CI/CD** pobiera najnowszy hash wersji zestawu danych z rejestru przed uruchomieniem zadania treningowego, zapewniając reprodukowalność.  
* **Dashboard audytu** wizualizuje graf pochodzenia i udostępnia eksportowalne raporty zgodności.

---

## 3. Kontrakty danych jako smart‑contracty

**Kontrakt danych** to lekki smart‑contract, który kapsułkuje cały kontekst generacji danych syntetycznych. Poniżej znajduje się uproszczony pseudo‑kod w stylu Solidity, który można skompilować jako chaincode dla Hyperledger Fabric.

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

**Dlaczego ten projekt działa**

* **Dowód niezmienności** – Po wywołaniu `registerGeneration` rekord jest nieodwracalny w łańcuchu.  
* **Samodokumentujący się** – Wszystkie istotne metadane są przechowywane w jednej transakcji, eliminując potrzebę zewnętrznych magazynów metadanych.  
* **Powiązanie z polityką** – `policyDigest` łączy zestaw danych z konkretną wersją polityki zgodności, umożliwiając automatyczne wykrywanie odchyleń polityki.

---

## 4. Integracja Formize w zakresie zgody i zarządzania politykami

Formize wyróżnia się **dynamicznym zbieraniem zgód** oraz **wersjonowaniem polityk**. Przebieg integracji:

1. **Zbieranie zgody** – Użytkownik wypełnia formularz w Formize; platforma podpisuje dowód przy użyciu zdecentralizowanego identyfikatora (DID) i zapisuje go w blockchainie.  
2. **Pobieranie polityki** – Przed generacją danych silnik syntetyczny zapytuje Formize o aktualną politykę prywatności (np. GDPR‑Article‑6‑1‑a) i otrzymuje jej hash.  
3. **Wywołanie kontraktu** – Silnik przekazuje identyfikator transakcji zgody oraz hash polityki do kontraktu danych.

Takie ścisłe powiązanie zapewnia, że każdy syntetyczny zestaw danych jest **kryptograficznie powiązany** z dokładną zgodą i polityką, które go regulowały.

---

## 5. Usługa automatycznego wydobywania łańcucha pochodzenia

**Usługa łańcucha pochodzenia** to mikrousługa napisana w Go (lub Rust), która subskrybuje zdarzenia blockchaina za pomocą SDK Fabric. Jej zadania:

* **Nasłuchiwanie zdarzeń** – Na zdarzenia `DataGenerated` pobiera pełny `GenerationRecord`.  
* **Budowa grafu** – Wstawia węzeł do bazy grafowej Neo4j lub JanusGraph, łącząc go z rodzicem (jeśli istnieje) krawędzią `DERIVED_FROM`.  
* **Tagowanie wersji** – Przypisuje semantyczne numery wersji (`v1.0.0`, `v1.1.0`) w zależności od zmian w algorytmie lub hiper‑parametrach.  
* **Udostępnianie API** – Oferuje endpoint GraphQL dla narzędzi downstream (CI/CD, UI audytu).

Przykładowe zapytanie GraphQL zwracające pełny łańcuch pochodzenia zestawu danych:

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

---

## 6. Integracja CI/CD dla reprodukowalnego trenowania modeli

Włączenie niezmiennej wersji do CI/CD gwarantuje, że **każde zbudowanie modelu jest odtwarzalne**. Poniżej fragment typowego workflow w 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
```

Kluczowe elementy:

* Workflow **pytanie usługi łańcucha pochodzenia** o najnowszy hash zestawu danych, zapewniając, że użyta wersja jest dokładnie zapisana.  
* Po treningu artefakt modelu jest rejestrowany razem z hashem zestawu danych, tworząc **dwukierunkowe powiązanie** między modelem a danymi.

---

## 7. Audytowalne raportowanie zgodności

Regulatory coraz częściej żądają **dowodów w czasie rzeczywistym**, że potoki danych syntetycznych respektują zasady prywatności i sprawiedliwości. Dzięki architekturze opartej na blockchainie generowanie raportu zgodności sprowadza się do zapytania do łańcucha.

Przykładowy skrypt w Pythonie generujący raport PDF:

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

Wygenerowany PDF zawiera **kryptograficzne odniesienia**, które audytorzy mogą zweryfikować w publicznym rejestrze, co drastycznie skraca czas potrzebny na kontrole zgodności.

---

## 8. Bezpieczeństwo i wydajność – najważniejsze uwagi

| Aspekt                | Rekomendacja                                                                 |
|-----------------------|----------------------------------------------------------------------------|
| **Uprawnienia**      | Używaj **uprawnionego blockchaina** (Hyperledger Fabric lub Corda), aby ograniczyć prawo zapisu wyłącznie do zaufanych usług. |
| **Prywatność danych**| Przechowuj w łańcuchu jedynie **hashe** i metadane; rzeczywiste zestawy danych pozostają w zaszyfrowanym magazynie obiektów. |
| **Skalowalność**      | Grupuj wiele wywołań `registerGeneration` w jedną transakcję, aby zmniejszyć narzut. |
| **Zarządzanie kluczami** | Wykorzystuj HSM do podpisywania dowodów zgody i wywołań kontraktów. |
| **Odzyskiwanie po awarii** | Replikuj łańcuch w kilku centrach danych i włącz migawki baz grafowych. |

---

## 9. Przykład z życia: konsorcjum badawcze w ochronie zdrowia

Konsorcjum obejmujące wiele instytucji medycznych potrzebowało udostępniać syntetyczne rekordy pacjentów, spełniając jednocześnie wymogi [HIPAA](https://www.hhs.gov/hipaa/index.html) i [GDPR](https://gdpr.eu/). Po przyjęciu modelu kontraktu danych opartego na blockchainie:

* **Śledzenie wersji** pozwoliło badaczom odtworzyć opublikowany model dokładnie po trzech latach.  
* **Powiązanie zgody** zapewniło, że każdy pacjent, który wycofał zgodę, wywołał automatyczne zdarzenie unieważnienia, które usługa łańcucha pochodzenia propagowała do zależnych zestawów danych.  
* **Audyt regulacyjny** został zakończony w jeden dzień zamiast kilku tygodni, ponieważ audytor mógł pobrać niezmienny rejestr i zweryfikować każdy zestaw danych.

Konsorcjum odnotowało **40 % redukcję kosztów zgodności** oraz **30 % przyspieszenie cyklu rozwoju modeli**.

---

## 10. Jak zacząć – minimalny prototyp

1. **Uruchom lokalną sieć Fabric** korzystając z oficjalnych obrazów Docker.  
2. **Wdroż kontrakt `SyntheticDataContract`** (patrz sekcja 3).  
3. **Zainstaluj Formize** i skonfiguruj formularz zgody, który zapisuje dowody w tym samym kanale Fabric.  
4. **Zaimplementuj prostą usługę łańcucha pochodzenia** w Go, nasłuchując zdarzeń `DataGenerated` i przechowując węzły w pamięci.  
5. **Uruchom generator danych syntetycznych** (np. pre‑trenowany CTGAN), który po każdym przebiegu wywołuje `registerGeneration`.  
6. **Zapytaj rejestr** aby potwierdzić, że każda wersja zestawu danych jest niezmienna.

Ten sandbox dostarcza proof‑of‑concept, który można rozbudować do produkcji poprzez dodanie trwałej bazy grafowej, kontroli dostępu opartej na rolach oraz integracji z istniejącymi platformami MLOps (Kubeflow, MLflow).

---

## 11. Kierunki rozwoju

* **Zero‑Knowledge Proofs** – Osadź zk‑SNARKs w kontrakcie danych, aby dowieść, że zestaw danych spełnia budżet prywatności bez ujawniania samych danych.  
* **Interoperacyjność między łańcuchami** – Wykorzystaj Cosmos IBC lub mosty Polkadot, aby udostępniać łańcuch pochodzenia danych syntetycznych poza granicami organizacji, zachowując suwerenność.  
* **Ewolucja polityk napędzana AI** – Zastosuj modele LLM do automatycznego proponowania aktualizacji polityk na podstawie wykrytych dryftów w jakości lub uprzedzeniach danych syntetycznych.  

Ciągłe rozwijanie niezmiennej ramy kontraktów danych pozwala organizacjom wyprzedzać nowe regulacje i utrzymywać zaufanie do systemów AI opartych na danych syntetycznych.