
# Peningkatan Kualitas Data Sintetis Loop Tertutup dengan Umpan Balik Manusia dan Pembelajaran Penguatan

Data sintetis telah menjadi fondasi bagi pelatihan model AI yang melindungi privasi, terutama ketika dataset dunia nyata langka, diatur, atau mahal untuk diperoleh. Namun, menghasilkan data sintetis berkualitas tinggi yang secara akurat mencerminkan properti statistik sumber sambil menghormati batasan privasi tetap menjadi tantangan yang tidak sederhana. Pipeline tradisional memperlakukan pembuatan data sebagai operasi satu kali: model dilatih, sampel sintetis dihasilkan, dan proses berhenti. Pada praktiknya, pendekatan “statis” ini menyebabkan drift, bias tersembunyi, dan celah kepatuhan yang baru muncul setelah model hilir dipasang.

Arsitektur **loop umpan balik tertutup** menyelesaikan masalah ini dengan terus‑menerus mengukur kegunaan, keadilan, dan privasi data sintetis, mengirimkan hasil kembali ke generator, dan menggunakan pembelajaran penguatan (RL) untuk mengarahkan perbaikan. Ketika digabungkan dengan **Formize**, platform tata kelola low‑code yang mengotomatiskan jejak audit, penegakan kebijakan, dan manajemen persetujuan, loop menjadi **self‑optimizing** dan **regulation‑ready**.

Dalam artikel ini kita akan:

1. Mendefinisikan komponen inti dari sistem data sintetis loop tertutup.  
2. Menunjukkan bagaimana umpan balik manusia ditangkap, dikuantifikasi, dan diubah menjadi reward RL.  
3. Merinci titik integrasi dengan Formize untuk jejak audit tak dapat diubah, persetujuan dinamis, dan shaping reward berbasis kebijakan.  
4. Menyediakan panduan implementasi langkah‑demi‑langkah, termasuk cuplikan kode dan diagram Mermaid alur kerja.  
5. Membahas skalabilitas, pemantauan, dan praktik terbaik untuk penerapan produksi.

---

## 1. Ikhtisar Arsitektur Inti

Secara umum, sistem loop tertutup terdiri dari lima lapisan:

| Lapisan | Tanggung Jawab | Teknologi Umum |
|---------|----------------|----------------|
| **Ingesti Data** | Mengimpor dataset mentah secara aman, menerapkan de‑identifikasi, dan mencatat metadata persetujuan. | Formize Consent API, Apache Kafka, S3 |
| **Generator Sintetis** | Menghasilkan sampel sintetis multi‑modal (tabular, teks, gambar, audio). | Model difusi, GAN, LLM, Tabular VAE |
| **Mesin Evaluasi** | Menghitung metrik kegunaan, keadilan, privasi, dan kualitas khusus domain. | NIST‑DP‑3T, Fairlearn, skor kesamaan khusus |
| **Antarmuka Manusia‑di‑dalam‑Lingkaran (HITL)** | Mengumpulkan anotasi ahli, penanda bias, dan penilaian kegunaan. | Formize Form Builder, React UI, platform crowdsourcing |
| **Pembelajar Penguatan** | Memperbarui parameter generator menggunakan sinyal reward yang berasal dari evaluasi dan HITL. | Proximal Policy Optimization (PPO), Ray RLlib |

Loop menutup ketika agen RL memperbarui generator, yang kemudian menghasilkan batch data sintetis baru. Formize berada di seluruh lapisan, menyediakan provenance tak dapat diubah, shaping reward berbasis kebijakan, dan pelaporan kepatuhan otomatis.

### Diagram Mermaid dari Loop Tertutup

```mermaid
flowchart LR
    A["Ingesti Data"] --> B["Generator Sintetis"]
    B --> C["Mesin Evaluasi"]
    C --> D["Antarmuka Umpan Balik Manusia"]
    D --> E["Kalkulator Reward"]
    E --> F["Pembelajar Penguatan"]
    F --> B
    B --> G["Lapisan Tata Kelola Formize"]
    G --> A
    G --> C
    G --> D
    G --> F
```

*Semua label node berada dalam tanda kutip ganda sebagaimana diperlukan untuk sintaks Mermaid.*

---

## 2. Menangkap Umpan Balik Manusia sebagai Sinyal Reward

Keahlian manusia tetap menjadi standar emas untuk menilai kualitas data sintetis, terutama pada domain bernuansa seperti citra medis atau teks hukum. Loop umpan balik mengikuti langkah‑langkah berikut:

1. **Presentasi Sampel** – Subset acak (misalnya 200 baris atau 50 gambar) ditampilkan dalam formulir web yang di‑host oleh Formize.  
2. **Skala Penilaian** – Pengguna memberikan skor kegunaan (1‑5) dan secara opsional menandai bias atau masalah privasi.  
3. **Agregasi Berbobot** – Skor dibobotkan menurut keahlian pengguna (misalnya pakar domain = 1,5, pekerja kerumunan = 1,0).  
4. **Pemetaaan Reward** – Skor teragregasi diubah menjadi reward skalar `r ∈ [-1, 1]`. Pemetaan linier sederhana dapat berupa:

   ```python
   def map_score_to_reward(score, bias_flag):
       base = (score - 3) / 2   # memetakan 1‑5 ke -1‑1
       penalty = -0.5 if bias_flag else 0
       return max(min(base + penalty, 1), -1)
   ```

5. **Penyesuaian Berbasis Kebijakan** – Kebijakan Formize (misalnya “tidak ada sampel sintetis yang boleh meningkatkan disparitas demografis > 5 %”) menyuntikkan penalti atau bonus tambahan sebelum reward mencapai agen RL.

### Contoh Penegakan Kebijakan di Formize

```yaml
policy:
  name: "Penegakan Ambang Batas Bias"
  condition: "demographic_disparity > 5"
  action: "apply_penalty"
  penalty: -0.3
```

Ketika mesin evaluasi mendeteksi pelanggaran disparitas, Formize secara otomatis mengurangi reward, mengarahkan agen RL menjauh dari menghasilkan sampel serupa.

---

## 3. Pembelajaran Penguatan untuk Optimasi Generator

Generator diperlakukan sebagai **lingkungan** yang kebijakannya `θ` diperbarui untuk memaksimalkan reward kumulatif yang diharapkan `R`. Pilihan populer adalah **Proximal Policy Optimization (PPO)** karena menyeimbangkan efisiensi sampel dengan stabilitas.

### Sketsa Pembaruan PPO

```python
import torch
from torch.distributions import Normal

class SyntheticPolicy(torch.nn.Module):
    def __init__(self, latent_dim):
        super().__init__()
        self.fc = torch.nn.Linear(latent_dim, latent_dim)
        self.mean_head = torch.nn.Linear(latent_dim, latent_dim)
        self.log_std = torch.nn.Parameter(torch.zeros(latent_dim))

    def forward(self, z):
        h = torch.tanh(self.fc(z))
        mean = self.mean_head(h)
        std = torch.exp(self.log_std)
        return Normal(mean, std)

def ppo_step(policy, optimizer, old_log_probs, rewards, eps=0.2):
    for _ in range(4):  # epoch mini‑batch
        dist = policy(z_batch)
        log_probs = dist.log_prob(z_batch).sum(-1)
        ratio = torch.exp(log_probs - old_log_probs)
        adv = rewards - rewards.mean()
        surr1 = ratio * adv
        surr2 = torch.clamp(ratio, 1-eps, 1+eps) * adv
        loss = -torch.min(surr1, surr2).mean()
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
```

*Vektor laten `z` di‑sampling dari prior, dilewatkan melalui kebijakan untuk menghasilkan data sintetis, dievaluasi, lalu umpan balik ke pembaruan PPO.*

Formize mencatat setiap versi kebijakan, distribusi reward terkait, dan provenance data pelatihan, menciptakan **jejak audit tak dapat diubah** yang memenuhi [GDPR](https://gdpr.eu/), [CCPA](https://oag.ca.gov/privacy/ccpa), dan regulasi AI yang sedang berkembang.

---

## 4. Panduan Implementasi End‑to‑End

Berikut roadmap praktis untuk membangun sistem loop tertutup dari nol.

### Langkah 1: Siapkan Tata Kelola Formize

1. **Buat Proyek** – “Synthetic Data Quality Loop”.  
2. **Definisikan Skema Persetujuan** – Tangkap persetujuan subjek data untuk setiap dataset sumber.  
3. **Konfigurasikan Kebijakan** – Ambang batas bias, anggaran privasi (ε), dan minimum kegunaan.  
4. **Aktifkan Logging Tak Dapat Diubah** – Nyalakan jejak audit berbasis blockchain untuk setiap transaksi.

### Langkah 2: Bangun Generator Sintetis

```python
from diffusers import StableDiffusionPipeline

pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
def generate_images(prompt, num=10):
    images = pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images
    return images
```

Untuk data tabular, ganti pipeline difusi dengan model **CTGAN**.

### Langkah 3: Terapkan Mesin Evaluasi

```python
from sklearn.metrics import pairwise_distances
def utility_score(real, synthetic):
    # Contoh: kesamaan kosinus dari embedding fitur
    real_emb = embed(real)
    synth_emb = embed(synthetic)
    return 1 - pairwise_distances(real_emb, synth_emb, metric="cosine").mean()

def privacy_budget(synthetic):
    # Estimasi epsilon privasi diferensial (placeholder)
    return estimate_epsilon(synthetic)
```

Catat kedua skor ke Formize melalui REST API‑nya.

### Langkah 4: Buat UI Umpan Balik Manusia

Gunakan **Form Builder** Formize untuk merancang formulir penilaian sederhana:

| Kolom | Tipe | Deskripsi |
|-------|------|-----------|
| Sample ID | Hidden | Identifier internal |
| Utility Rating | Radio (1‑5) | Seberapa berguna sampel ini? |
| Bias Flag | Checkbox | Apakah sampel menunjukkan bias? |
| Comments | Textarea | Umpan balik bebas (opsional) |

Sebarkan formulir dan sematkan di portal yang aman. Ekspor respons sebagai JSON untuk pemrosesan selanjutnya.

### Langkah 5: Rakit Kalkulator Reward

```python
def compute_reward(eval_metrics, human_feedback):
    util = eval_metrics["utility"]
    privacy = -eval_metrics["epsilon"] / 10   # penalti epsilon tinggi
    human = map_score_to_reward(human_feedback["rating"], human_feedback["bias"])
    return 0.5*util + 0.3*privacy + 0.2*human
```

### Langkah 6: Latih Agen RL

1. Inisialisasi jaringan kebijakan.  
2. Untuk setiap iterasi:  
   - Sampling vektor laten `z`.  
   - Menghasilkan data sintetis.  
   - Jalankan evaluasi dan kumpulkan umpan balik manusia.  
   - Hitung reward.  
   - Lakukan pembaruan PPO.  
   - Log versi kebijakan dan reward ke Formize.

### Langkah 7: Pemantauan & Peringatan

- **Dashboard Metrik** – Visualisasikan kegunaan, bias, dan privasi seiring waktu.  
- **Deteksi Anomali** – Aktifkan peringatan ketika reward turun > 20 % selama dua siklus berturut‑turut.  
- **Laporan Kepatuhan** – Hasilkan laporan PDF otomatis via engine pelaporan Formize, ditandatangani dengan decentralized identifier (DID).

---

## 5. Menskalakan Loop untuk Produksi

| Tantangan | Solusi |
|-----------|--------|
| **Data Berkecepatan Tinggi** | Gunakan **Ray** untuk pelatihan RL terdistribusi; batch evaluasi pada klaster GPU. |
| **Latensi Umpan Balik Manusia** | Implementasikan **queue** (Kafka) yang menampung sampel; gunakan active learning untuk memprioritaskan sampel dengan ketidakpastian tinggi. |
| **Evolusi Kebijakan** | Simpan kebijakan sebagai JSON versi di Formize; gunakan feature flags untuk meluncurkan batasan baru secara bertahap. |
| **Audit Regulator** | Manfaatkan ledger tak dapat diubah Formize untuk menghasilkan bukti yang tidak dapat dimanipulasi dari setiap perhitungan reward dan pembaruan model. |

---

## 6. Kasus Penggunaan Dunia Nyata

1. **Catatan Medis Sintetis** – Peningkatan berkelanjutan data EMR sintetis sambil menjamin anggaran privasi yang sesuai dengan [HIPAA](https://www.hhs.gov/hipaa/index.html).  
2. **Simulator Transaksi Keuangan** – Mengurangi bias pola penipuan sintetis dengan memasukkan umpan balik analis penipuan ke dalam fungsi reward.  
3. **Skenario Mengemudi Otonom** – UI umpan balik manusia menilai realisme adegan sintetis, menggerakkan generator RL yang menghormati kasus tepi kritis keselamatan.

---

## 7. Pertanyaan yang Sering Diajukan

**T1: Apakah saya memerlukan tim besar ahli untuk langkah HITL?**  
J: Tidak harus. Mulailah dengan panel kecil pakar domain dan lengkapi dengan pekerja kerumunan. Bobotkan skor sesuai keahlian, dan biarkan agen RL belajar dari agregat tersebut.

**T2: Bagaimana Formize menjamin provenance data?**  
J: Formize menulis hash kriptografis setiap artefak (data mentah, batch sintetis, laporan evaluasi) ke ledger berbasis blockchain. Hash, timestamp, dan tanda tangan pengguna menjadi tidak dapat diubah.

**T3: Bisakah loop berjalan secara real‑time?**  
J: Ya, bila Anda mengadopsi ingesti streaming (Kafka) dan evaluasi berlatensi rendah (GPU‑accelerated metrics). Umpan balik manusia biasanya menjadi bottleneck; active learning dapat menjaga loop tetap responsif dengan hanya meminta umpan balik pada sampel berketidakpastian tinggi.

---

## 8. Arah Pengembangan di Masa Depan

- **Meta‑RL untuk Pencarian Kebijakan** – Gunakan agen RL tingkat atas untuk secara otomatis menemukan kebijakan shaping reward yang optimal.  
- **Generasi Sintetis Federated** – Gabungkan loop dengan federated learning untuk menghormati lokalisasi data sambil tetap memanfaatkan umpan balik global.  
- **Atribusi Reward yang Dapat Dijelaskan** – Integrasikan SHAP atau LIME untuk menampilkan mengapa sampel sintetis tertentu menerima reward rendah, membantu petugas kepatuhan.

---

## See Also

- Formize Documentation – Governance APIs  
- NIST Differential Privacy Framework  
- Fairlearn – Assessing Fairness in Machine Learning