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
• Synthetic Data Generation Pipelines
• Azure OpenAI Integration for Text Synthesis
• Balancing Class Imbalances with Synthetic Samples
• Privacy-Preserving Synthetic Data
• Validation of Synthetic Data Quality
• Referanser
• 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:

# 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

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:

# 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

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

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

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

# 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

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 -- Azure AI Evaluation Simulator
• Generate synthetic data for fine-tuning in Microsoft Foundry -- Foundry syntetisk data UI
• Design training data for AI workloads on Azure -- Well-Architected Framework for treningsdata
• Azure OpenAI for big data -- SynapseML + OpenAI på Fabric
• Azure OpenAI On 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.