ms-ai-architect/skills/ms-ai-engineering/references/data-engineering/synthetic-data-generation.md

# Synthetic Data Generation for AI Training

**Last updated:** 2026-06-24
**Status:** GA / Preview (varies by feature)
**Category:** Data Engineering for AI
**Type:** reference
**Source:** https://learn.microsoft.com/azure/foundry-classic/openai/concepts/use-your-data

---

## Innhold

- [Introduksjon](#introduksjon)
- [Synthetic Data Generation Pipelines](#synthetic-data-generation-pipelines)
- [Azure OpenAI Integration for Text Synthesis](#azure-openai-integration-for-text-synthesis)
- [Balancing Class Imbalances with Synthetic Samples](#balancing-class-imbalances-with-synthetic-samples)
- [Privacy-Preserving Synthetic Data](#privacy-preserving-synthetic-data)
- [Validation of Synthetic Data Quality](#validation-of-synthetic-data-quality)
- [Referanser](#referanser)
- [For arkitekten](#for-arkitekten)

## Introduksjon

Syntetisk datagenerering er en stadig viktigere teknikk for AI-utvikling, spesielt i situasjoner der reelle data er begrenset, ubalansert, eller underlagt strenge personvernkrav. Ved å generere kunstige datasett som etterligner statistiske egenskaper ved reelle data, kan organisasjoner utvide treningsdata, adressere klasseimbalanser, og beskytte personvern -- uten å eksponere faktiske sensitive opplysninger.

For norsk offentlig sektor er syntetisk data spesielt relevant fordi tilgangen til treningsdata ofte er begrenset av GDPR, taushetsplikt og sikkerhetsklassifiseringer. Helsesektoren kan ikke dele pasientdata fritt, veisektoren har begrensninger på GPS-spor, og NAV har strenge regler for bruk av personopplysninger i maskinlæring. Syntetisk data tilbyr en lovlig vei til å bygge AI-modeller uten å bryte disse begrensningene.

Denne referansen dekker Azure AI Evaluation SDK sin Simulator-klasse for syntetisk datagenerering, integrasjon med Azure OpenAI for tekstsyntese, teknikker for klassebalansering, personvernbevarende syntetiske data, og validering av syntetisk datakvalitet.

---

## Synthetic Data Generation Pipelines

### Azure AI Evaluation SDK Simulator

Azure AI Evaluation SDK inneholder en `Simulator`-klasse (preview) som genererer syntetiske samtaler og oppgavebaserte interaksjoner:

```python
# Installasjon
# pip install azure-identity azure-ai-evaluation promptflow-azure

from azure.ai.evaluation.simulator import Simulator

# Konfigurer modell
model_config = {
    "azure_endpoint": "https://<endpoint>.openai.azure.com/",
    "azure_deployment": "gpt-4o",
    "api_version": "2024-12-01-preview"
}

simulator = Simulator(model_config=model_config)
```

### Generer fra tekst-input

```python
import wikipedia

# Hent kildedokument
wiki_page = wikipedia.page("Norwegian Public Roads Administration")
source_text = wiki_page.summary[:5000]

# Generer syntetiske spørsmål-svar-par
outputs = await simulator(
    target=my_callback_function,
    text=source_text,
    num_queries=50,
    max_conversation_turns=3,
    tasks=[
        f"Svar på spørsmål basert på følgende tekst:\n{source_text}"
    ]
)

# Resultater i OpenAI messages-format
for conversation in outputs:
    for message in conversation["messages"]:
        print(f"{message['role']}: {message['content'][:100]}...")
```

### Microsoft Foundry Synthetic Data (Preview)

Microsoft Foundry tilbyr en UI-drevet opplevelse for syntetisk data:

1. Åpne Microsoft Foundry Portal
2. Naviger til Fine-tuning > Generate Data
3. Last opp kildedokumenter eller beskriv ønsket data
4. Velg generatortype:

| Generator-type | Beskrivelse | Output-format |
|---|---|---|
| **Simple Q&A** | Spørsmål-svar fra dokumenter | JSONL (messages) |
| **Tool Use** | API-kall fra OpenAPI spec | JSONL (tool calls) |
| **Conversation** | Multi-turn dialoger | JSONL (conversation) |

5. Velg antall samples (50-1000)
6. Velg generator-modell (GPT-4o eller lignende)
7. Valgfritt: 80/20 train-validation split

---

## Azure OpenAI Integration for Text Synthesis

### Batch-generering med SynapseML

For stor-skala syntetisk tekstgenerering i Fabric:

```python
# SynapseML + Azure OpenAI for batch-generering
import synapse.ml.core
from synapse.ml.services.openai import OpenAICompletion

# Konfigurer OpenAI-klient
completion = (
    OpenAICompletion()
    .setSubscriptionKey("<api-key>")
    .setDeploymentName("gpt-4o")
    .setCustomServiceName("<endpoint>")
    .setMaxTokens(500)
    .setPromptCol("prompt")
    .setErrorCol("error")
    .setOutputCol("generated_text")
)

# Lag prompts for syntetisk datagenerering
prompts_df = spark.createDataFrame([
    ("Generer en realistisk kundehenvendelse til Direktoratet for digital tjenesteutvikling om saksbehandling-fornyelse.",),
    ("Generer en syntetisk trafikkrapport for E6 ved Lillehammer med kødata.",),
    ("Generer et eksempel på en byggesøknad til Plan- og bygningsetaten.",),
], ["prompt"])

# Kjør batch-generering over Spark
results = completion.transform(prompts_df)
display(results.select("prompt", "generated_text"))
```

### Strukturert syntetisk data med JSON-modus

```python
from openai import AzureOpenAI
import json

client = AzureOpenAI(
    api_key="<key>",
    api_version="2024-12-01-preview",
    azure_endpoint="https://<endpoint>.openai.azure.com/"
)

def generate_synthetic_records(template_schema, num_records=100, domain="trafikk"):
    """Generer strukturerte syntetiske poster."""
    records = []
    for batch_start in range(0, num_records, 10):
        response = client.chat.completions.create(
            model="gpt-4o",
            response_format={"type": "json_object"},
            messages=[
                {"role": "system", "content": f"""
                Du er en datagenerator for {domain}-domenet i norsk offentlig sektor.
                Generer realistiske men helt fiktive dataposter.
                Bruk ALDRI ekte personnummer, navn eller adresser.
                Returner JSON med nøkkel 'records' som inneholder en liste.
                Skjema: {json.dumps(template_schema)}
                """},
                {"role": "user", "content": f"Generer 10 syntetiske poster."}
            ],
            temperature=0.8
        )
        batch = json.loads(response.choices[0].message.content)
        records.extend(batch["records"])
    return records

# Eksempel: Trafikkhendelses-data
schema = {
    "incident_id": "string (UUID)",
    "road": "string (E6, E18, Rv4, etc.)",
    "location_km": "float",
    "incident_type": "string (ulykke, køkjøring, veiarbeid, dyr_i_veien)",
    "severity": "int (1-5)",
    "timestamp": "ISO datetime",
    "description": "string (norsk tekst, 1-3 setninger)"
}

synthetic_incidents = generate_synthetic_records(schema, num_records=500, domain="trafikk")
```

---

## Balancing Class Imbalances with Synthetic Samples

### Oversamplings-teknikker

| Teknikk | Beskrivelse | Bruk for AI |
|---|---|---|
| **SMOTE** | Syntetisk oversampling i feature-rom | Tabelldata, klassifisering |
| **ADASYN** | Adaptiv syntetisk sampling | Fokuserer på vanskelige grensetilfeller |
| **LLM-generert** | Tekstgenerering for minoritetsklasser | NLP, chatbot-trening |
| **Augmentasjon** | Transformasjon av eksisterende data | Bilde, tekst-variasjon |
| **Kopiert undersampling** | Fjern majoritetsklasse-samples | Rask, men taper informasjon |

### SMOTE i Fabric Notebook

```python
from imblearn.over_sampling import SMOTE, ADASYN
from sklearn.model_selection import train_test_split
import pandas as pd

# Les treningsdata fra Lakehouse
df = spark.read.format("delta").table("gold.churn_features").toPandas()

# Sjekk klassebalanse
print("Klassefordeling:")
print(df["churned"].value_counts())
# churned
# 0    8500  (85%)
# 1    1500  (15%)

# Splitt features og target
X = df.drop(columns=["churned", "customer_id"])
y = df["churned"]

# SMOTE: Oversampler minoritetsklassen
smote = SMOTE(random_state=42, sampling_strategy=0.5)
X_resampled, y_resampled = smote.fit_resample(X, y)

print(f"\nEtter SMOTE:")
print(f"Ikke-churned: {sum(y_resampled == 0)}")
print(f"Churned: {sum(y_resampled == 1)}")
# Ikke-churned: 8500
# Churned: 4250 (50% av majoritetsklassen)

# Konverter tilbake og lagre
resampled_df = pd.DataFrame(X_resampled, columns=X.columns)
resampled_df["churned"] = y_resampled
spark.createDataFrame(resampled_df).write.format("delta") \
    .mode("overwrite").saveAsTable("gold.churn_features_balanced")
```

### LLM-basert tekst-augmentasjon

```python
def augment_text_samples(texts, labels, target_class, num_augmented=100):
    """Generer syntetiske teksteksempler for en underrepresentert klasse."""
    examples = [t for t, l in zip(texts, labels) if l == target_class]
    sample_examples = "\n".join(examples[:5])

    augmented = []
    for i in range(0, num_augmented, 10):
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": f"""
                Generer 10 nye teksteksempler som ligner på følgende,
                men med variasjoner i ordvalg og formulering.
                Behold den samme semantiske betydningen og klassifiseringen.
                Eksempler:
                {sample_examples}
                """},
                {"role": "user", "content": "Generer 10 variasjoner."}
            ],
            temperature=0.9
        )
        new_texts = response.choices[0].message.content.strip().split("\n")
        augmented.extend([t.strip() for t in new_texts if t.strip()])

    return augmented[:num_augmented]
```

---

## Privacy-Preserving Synthetic Data

### Teknikker for personvernbevarende syntetiske data

| Teknikk | Personverngaranti | Kompleksitet | Bruk |
|---|---|---|---|
| **Differential Privacy** | Matematisk bevisbar | Høy | Aggregerte statistikker |
| **k-Anonymity** | Grupper >= k individer | Medium | Tabelldata |
| **l-Diversity** | Minimum l distinkte sensitive verdier per gruppe | Medium | Sensitive attributter |
| **LLM-generert** | Ingen direkte kobling til kildedata | Lav | Tekst, samtaler |
| **Copula-basert** | Bevarer korrelasjoner statistisk | Medium | Multi-variabel data |

### Differential Privacy med PySpark

```python
# Generer syntetiske data med differensiell personvern
# Bruk OpenDP-biblioteket

# pip install opendp

from opendp.measurements import make_base_laplace
from opendp.transformations import make_mean, make_count
import numpy as np

def add_laplace_noise(true_value, epsilon=1.0, sensitivity=1.0):
    """Legg til Laplace-støy for differensiell personvern."""
    scale = sensitivity / epsilon
    noise = np.random.laplace(0, scale)
    return true_value + noise

# Eksempel: Generer syntetisk aldersfordeling
# Ekte data: gjennomsnittsalder = 42.3, standardavvik = 15.2
true_mean = 42.3
true_std = 15.2
epsilon = 1.0  # Personvernbudsjett

# Legg til støy på statistikkene
noisy_mean = add_laplace_noise(true_mean, epsilon=epsilon/2)
noisy_std = add_laplace_noise(true_std, epsilon=epsilon/2)

# Generer syntetiske data fra støyete distribusjon
synthetic_ages = np.random.normal(noisy_mean, abs(noisy_std), size=10000)
synthetic_ages = np.clip(synthetic_ages, 18, 100).astype(int)
```

### Anonymiseringsworkflow

```
Ekte data (Dataverse/Lakehouse)
        │
        ▼
┌───────────────────────┐
│ Steg 1: Klassifiser   │  Purview identifiserer PII
│ med Purview           │
└───────┬───────────────┘
        │
        ▼
┌───────────────────────┐
│ Steg 2: Anonymiser    │  Fjern/erstatt direkte identifikatorer
│ - Fødselsnummer → hash│
│ - Navn → pseudonym    │
│ - Adresse → postnr    │
└───────┬───────────────┘
        │
        ▼
┌───────────────────────┐
│ Steg 3: Syntetiser    │  Generer nye poster basert på
│ - Bevar distribusjoner│  statistiske egenskaper
│ - Bevar korrelasjoner │
│ - Legg til DP-støy    │
└───────┬───────────────┘
        │
        ▼
┌───────────────────────┐
│ Steg 4: Valider       │  Verifiser kvalitet og personvern
│ - Statistisk likhet   │
│ - Privacy-test        │
│ - ML-nytteverdi       │
└───────────────────────┘
```

---

## Validation of Synthetic Data Quality

### Kvalitetsdimensjoner

| Dimensjon | Metrikk | Terskelverdier |
|---|---|---|
| **Statistisk likhet** | Jensen-Shannon Divergence | < 0.1 (god), < 0.05 (utmerket) |
| **Kolonnekorrelasjoner** | Pearson/Spearman korrelasjon | Δ < 0.05 mellom ekte og syntetisk |
| **Distribusjonsmatch** | KS-test (Kolmogorov-Smirnov) | p-verdi > 0.05 |
| **ML-nytteverdi** | Train on synthetic, test on real (TSTR) | Accuracy-tap < 5% |
| **Personvern** | Re-identifiseringsrisiko | < 0.01 (1%) |
| **Dekningsgrad** | Andel unike verdier representert | > 90% av originale kategorier |

### Validerings-kode

```python
from scipy.stats import ks_2samp, pearsonr
import numpy as np
import pandas as pd

def validate_synthetic_data(real_df, synthetic_df, numeric_cols, cat_cols):
    """Valider kvaliteten på syntetiske data mot ekte data."""
    results = {}

    # 1. KS-test for numeriske kolonner
    for col in numeric_cols:
        stat, pvalue = ks_2samp(real_df[col].dropna(), synthetic_df[col].dropna())
        results[f"ks_test_{col}"] = {
            "statistic": round(stat, 4),
            "p_value": round(pvalue, 4),
            "passed": pvalue > 0.05
        }

    # 2. Kategorifordeling
    for col in cat_cols:
        real_dist = real_df[col].value_counts(normalize=True)
        synth_dist = synthetic_df[col].value_counts(normalize=True)
        common_cats = set(real_dist.index) & set(synth_dist.index)
        coverage = len(common_cats) / len(real_dist) * 100
        results[f"category_coverage_{col}"] = {
            "coverage_pct": round(coverage, 1),
            "passed": coverage > 90
        }

    # 3. Korrelasjonsmatrise-likhet
    real_corr = real_df[numeric_cols].corr()
    synth_corr = synthetic_df[numeric_cols].corr()
    corr_diff = (real_corr - synth_corr).abs().mean().mean()
    results["correlation_difference"] = {
        "mean_abs_diff": round(corr_diff, 4),
        "passed": corr_diff < 0.05
    }

    # 4. TSTR (Train on Synthetic, Test on Real)
    # Implementeres med faktisk ML-modell

    return results

# Kjør validering
validation = validate_synthetic_data(real_data, synthetic_data,
    numeric_cols=["age", "income", "score"],
    cat_cols=["region", "category"])

for metric, result in validation.items():
    status = "PASS" if result["passed"] else "FAIL"
    print(f"[{status}] {metric}: {result}")
```

---

## Referanser

- [Generate synthetic and simulated data for evaluation](https://learn.microsoft.com/en-us/azure/foundry-classic/how-to/develop/simulator-interaction-data) -- Azure AI Evaluation Simulator
- [Generate synthetic data for fine-tuning in Microsoft Foundry](https://learn.microsoft.com/en-us/azure/foundry/fine-tuning/data-generation) -- Foundry syntetisk data UI
- [Design training data for AI workloads on Azure](https://learn.microsoft.com/en-us/azure/well-architected/ai/training-data-design) -- Well-Architected Framework for treningsdata
- [Azure OpenAI for big data](https://learn.microsoft.com/en-us/fabric/data-science/open-ai) -- SynapseML + OpenAI på Fabric
- [Azure OpenAI On Your Data](https://learn.microsoft.com/en-us/azure/foundry-classic/openai/concepts/use-your-data) -- RAG for datagenerering

---

## For arkitekten

- **Bruk denne referansen** når brukeren har begrensede treningsdata, klasseimbalanser, eller personvernkrav som hindrer bruk av reelle data for AI-trening.
- For norsk offentlig sektor: Syntetisk data er ofte **den eneste lovlige veien** til å bygge ML-modeller med sensitive data (helse, NAV, politi). Fremhev at syntetiske data aldri inneholder reelle personopplysninger.
- Anbefal en **kombinasjon av teknikker**: SMOTE for tabelldata, LLM-generering for tekst, og differensiell personvern for statistisk baserte syntetiske datasett.
- **Valider alltid** syntetiske data med TSTR-tilnærmingen (Train on Synthetic, Test on Real) for å sikre at syntetiske data faktisk forbedrer modellytelsen.
- Bruk Azure AI Evaluation SDK **Simulator** for å generere test-data for chatboter og RAG-systemer -- dette er spesielt nyttig for Copilot Studio-prosjekter der man mangler historiske samtaledata.