# Zero PII Customer Intelligence - Del 1.1: Generera provdata (och bilder) Lokalt
2025-12-24T20:00
Till [Häfte 1](/blog/zero-pii-customer-intelligence-part1) Vi täckte filosofin: transparent segmentering utan PII. [Häfte 2](/blog/zero-pii-customer-intelligence-part2) omfattar sessionsprofiler, signaler och segmentdefinitioner.
Men först: **Hur validerar du något av detta utan att någonsin röra verkliga kunddata?**
För denna serie genererar jag en komplett syntetisk e-handel dataset lokalt:
- Produktkatalog (namn, beskrivningar, taggar, priser)
- Anonyma profiler/personas (intressen + signaler)
- Produktbilder (och profilporträtt) via ComfyUI
- Valfri DB import så att den verkliga appen kan köras mot den
Detta är en av de där "det känns som fusk" arbetsflöden: du får realistiska ingångar, du kan återskapa dem när som helst, och du introducerar aldrig PII i din dev miljö.
## Varför lokala syntetiska data är så kraftfulla
Om du bygger segmentering / personalisering, behöver du dataset som:
- Har tillräckligt med variation för att bryta naiva heuristiker
- Är säkra att dela (i kod, tester, demos)
- Är reproducerbara (så att du kan jämföra modelländringar)
Real data är motsatsen: känslig, rörig, svår att röra sig runt, och full av historiska fördomar.
Syntetiska data ger dig tre superkrafter:
1. **Snabb iteration**: ändra segmenteringslogiken, regenerera, re-run.
2. **Förhårdnad**: simulera konstiga lång-tail beteenden du inte kommer att se i en liten dev dataset.
3. **Förklarande provning**: du kan *inspektera varje genererat fält* och bekräfta din Visa mig varför UI är sanningsenlig.
```mermaid
flowchart LR
Taxonomy[gadget-taxonomy.json] --> Gen[SampleData generator]
Gen --> Products[products.json]
Gen --> Profiles[profiles.json]
Gen --> Images[images/*]
Products --> Import[Import into Postgres]
Profiles --> Import
style Taxonomy stroke:#1971c2,stroke-width:3px
style Gen stroke:#1971c2,stroke-width:3px
style Import stroke:#2f9e44,stroke-width:3px
```
## Verktyget (Vad som faktiskt körs)
Generatorn bor i `Mostlylucid.SegmentCommerce.SampleData`.
Det är avsiktligt inte en ram; det är en pragmatisk CLI som talar till:
- **Ollama Ordförande** (lokal LLM) för strukturerad JSON-generation.
- **KomfyUi Ordförande** (lokal Stable Diffusion) för bilder av produktfotografering.
- En förteckning över de behöriga myndigheter som avses i punkt 1 i denna artikel ska upprättas i enlighet med det förfarande som avses i artikel 4 i förordning (EU) nr 952/2013. **taxonomi JSON** som håller resultaten konsekventa (kategorier, typer, varianter, prisintervall).
Konfigurationen är uppkopplad så att du kan köra den via miljövariabler:
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Program.cs
var configuration = new ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddJsonFile("appsettings.json", optional: true)
.AddEnvironmentVariables("SAMPLEDATA_")
.Build();
```
## Snabbstart
Du kommer vanligtvis köra tre lokala tjänster tillsammans med generatorn:
```mermaid
flowchart LR
CLI[SampleData CLI] --> Ollama["Ollama
http://localhost:11434"]
CLI --> Comfy["ComfyUI
http://localhost:8188"]
CLI -. optional .-> DB[(Postgres)]
style CLI stroke:#1971c2,stroke-width:3px
style Ollama stroke:#1971c2,stroke-width:3px
style Comfy stroke:#2f9e44,stroke-width:3px
style DB stroke:#fab005,stroke-width:3px
```
Kör generatorn från reporoten:
```bash
dotnet run --project Mostlylucid.SegmentCommerce.SampleData -- status
```
Skapa sedan en datauppsättning:
```bash
# v1 generator: taxonomy + optional Ollama + optional ComfyUI
# Writes ./Output/products.json, ./Output/profiles.json, ./Output/images/...
dotnet run --project Mostlylucid.SegmentCommerce.SampleData -- generate --count 20
```
Användbara strömbrytare:
```bash
# No LLM calls, taxonomy only
dotnet run --project Mostlylucid.SegmentCommerce.SampleData -- generate --no-ollama
# No ComfyUI images
dotnet run --project Mostlylucid.SegmentCommerce.SampleData -- generate --no-images
# Write into Postgres (uses configured connection string)
dotnet run --project Mostlylucid.SegmentCommerce.SampleData -- generate --db
```
Observera: om ComfyUI inte är tillgänglig, faller v1-generatorn tillbaka till platshållarbilder (den använder `picsum.photos`, så att sökvägen inte är helt offline). Om du vill strikt lokal, kör med `--no-images`.
## v2 Generator: Säljare → Produkter → Kunder → Beställningar → Inbäddning
Det finns också en nyare generator kommando (`gen`) som bygger en mer komplett marknadsplatsformad datauppsättning:
```bash
# v2 generator
# Writes dataset.json plus sellers/products/customers/orders split files
dotnet run --project Mostlylucid.SegmentCommerce.SampleData -- gen --sellers 50 --products 20 --customers 1000
```
Det är orkestrerat som en flerfas rörledning:
```mermaid
flowchart LR
A[Sellers] --> B[Products]
B --> C[Customers]
C --> D[Orders]
D --> E[Embeddings]
B -. optional .-> I[ComfyUI images]
style A stroke:#1971c2,stroke-width:3px
style B stroke:#1971c2,stroke-width:3px
style C stroke:#1971c2,stroke-width:3px
style D stroke:#1971c2,stroke-width:3px
style E stroke:#2f9e44,stroke-width:3px
style I stroke:#2f9e44,stroke-width:3px
```
Och du kan se dessa faser direkt i kod:
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/DataGenerator.cs
// 1. Generate Sellers
// 2. Generate Products for each seller
// 3. Generate Customers
// 4. Generate Orders (with fake checkout data via Bogus)
// 5. Generate embeddings for all entities
```
### Inbäddningar (lokala ONNX, cached efter första körningen)
V2-generatorn kan beräkna inbäddningar med hjälp av en ONNX-modell (standard: `all-MiniLM-L6-v2`). Första gången du kör den, laddar den ner modellen och vokab till din utdatamapp.
Detta innebär följande:
- Första körningen behöver nätverksåtkomst (modellnedladdning)
- Efterföljande körningar är lokala och snabba
- Om du vill ha inget nätverk någonsin, kör `--no-embeddings`
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/EmbeddingService.cs
private const string ModelUrl = "https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/onnx/model.onnx";
private const string VocabUrl = "https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2/resolve/main/vocab.txt";
// Download model if not exists
if (!File.Exists(_config.ModelPath))
{
await DownloadFileAsync(ModelUrl, _config.ModelPath, ct);
}
```
## Hur vi skapar produkter med LLM-Shaped. (endast JSON)
Produktgenereringsprompten är avsiktligt strikt: LLM måste endast returnera JSON, med ett inbäddat JSON schema exempel.
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/OllamaProductGenerator.cs
return $"""
You are a product catalog generator for an e-commerce store. Generate {count} unique, realistic product listings for the \"{category.DisplayName}\" category.
Category description: {category.Description}
Example products in this category: {category.ExampleProducts}
Price range: £{category.PriceRange.Min:F2} - £{category.PriceRange.Max:F2}
For each product, provide:
1. A compelling product name (realistic brand-style naming)
2. A detailed description (2-3 sentences, highlighting key features and benefits)
3. A realistic price within the range
4. Optional original price if on sale (20-40% higher than current price)
5. 3-5 relevant tags
6. Whether it's trending (about 20% should be trending)
7. Whether it's featured (about 15% should be featured)
8. An image prompt for AI image generation (detailed, product photography style)
9. 2-3 colour variants for the product
IMPORTANT: Respond with ONLY valid JSON, no markdown formatting, no code blocks, no explanations.
Generate {count} diverse products now:
""";
```
Detta spelar roll eftersom nedströmssystem (bildgenerering + import + inbäddningar) vill ha strukturerade data. LLM producerar *tillförsel till en rörledning*, inte skriva prosa.
### Svar från LLM: Parse JSON, eller fall tillbaka
LLMs är inte kompilatorer. Även med JSON bara, du behöver fortfarande defensiva tolkning och graciös reserv.
V2-generatorn gör det via en liten hjälpare (`LlmService`) som utvinner den första `{...}` blockerar och deserialiserar det:
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/LlmService.cs
var jsonStart = response.IndexOf('{');
var jsonEnd = response.LastIndexOf('}');
if (jsonStart >= 0 && jsonEnd > jsonStart)
{
var jsonStr = response.Substring(jsonStart, jsonEnd - jsonStart + 1);
return JsonSerializer.Deserialize(jsonStr, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true
});
}
```
Och den totala produktionsledningen kontrollerar uttryckligen tillgänglighet och nedgraderar till deterministiska mallar vid behov:
```mermaid
flowchart LR
A[EnableLlm=true?] -->|no| F[Fallback templates]
A -->|yes| B[GET /api/tags]
B -->|model present| C[LLM JSON prompts]
B -->|not available| F
style A stroke:#1971c2,stroke-width:3px
style C stroke:#2f9e44,stroke-width:3px
style F stroke:#fab005,stroke-width:3px
```
### Exempel: Kundpersonas (v2)
Personaprompten för kunder är kort och strukturerad så att den kan skapas snabbt med en liten lokal modell:
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/DataGenerator.cs
var prompt = $$"""
Generate a shopper persona interested in: {{string.Join(", ", categoryNames)}}.
Return JSON only:
{
"persona": "Brief persona description (e.g. 'Tech enthusiast who values quality')",
"name": "Realistic first name",
"bio": "One sentence about their shopping habits",
"age": 25,
"shopping_style": "budget|value|premium|luxury",
"preferred_categories": ["category1", "category2"]
}
""";
```
## ComfyUI: Produktfotografering via API
ComfyUI är bra eftersom det ger dig en kontrollerbar pipeline (arbetsflöden) snarare än en enda svart låda bild endpoint.
Generatorn:
1. Laddar en arbetsflödesmall (`ComfyUI/workflows/product_image.json`)
2. Kopplar in prompten i `CLIPTextEncode`
3. Köer `/prompt`
4. Undersökningar `/history/{promptId}`
5. Ladda ner bilden via `/view?...`
```mermaid
sequenceDiagram
participant Gen as SampleData
participant Comfy as ComfyUI
Gen->>Comfy: POST /prompt (workflow + prompt)
Comfy-->>Gen: prompt_id
loop poll
Gen->>Comfy: GET /history/{prompt_id}
Comfy-->>Gen: outputs / images
end
Gen->>Comfy: GET /view?filename=...&type=output
Comfy-->>Gen: PNG bytes
```
ComfyUI modellval är också lappat i arbetsflödet vid körning (så att du kan byta kontrollpunkter utan att redigera JSON):
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/ComfyUIImageGenerator.cs
TryPatchCheckpoint(workflow, _config.ComfyUICheckpointName ?? "sd_xl_base_1.0.safetensors");
TryPatchRefiner(workflow, _config.ComfyUIRefinerName ?? "sd_xl_refiner_1.0.safetensors");
```
Och arbetsflödet patching är avsiktligt enkel och robust:
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/ComfyUIImageGenerator.cs
// Update CLIPTextEncode nodes with our prompt
if (classType == "CLIPTextEncode")
{
var inputs = nodeObj["inputs"]?.AsObject();
if (inputs != null && inputs.ContainsKey("text"))
{
var currentText = inputs["text"]?.GetValue() ?? "";
if (!currentText.Contains("bad") && !currentText.Contains("ugly") && !currentText.Contains("deformed"))
{
inputs["text"] = prompt;
}
}
}
// Update image dimensions
if (classType == "EmptyLatentImage")
{
var inputs = nodeObj["inputs"]?.AsObject();
if (inputs != null)
{
inputs["width"] = _config.ImageWidth;
inputs["height"] = _config.ImageHeight;
}
}
```
## Profiler och personer (användbara, inte läskiga)
V1-generatorn skapar anonyma profiler och berikar dem sedan med en persona (fortfarande ingen PII). Du slutar med realistiska folkformade testdata utan e-post, adresser, eller något du någonsin av misstag kunde skicka.
I v1, profiler är knappade med hjälp av en enkelriktad hash, så det finns inget att återställa:
```csharp
// Mostlylucid.SegmentCommerce.SampleData/Services/ProfileGenerator.cs
var profileKey = Hash($"fp-{Guid.NewGuid():N}");
private static string Hash(string input)
{
using var sha = SHA256.Create();
var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(input));
return Convert.ToHexString(bytes).ToLowerInvariant();
}
```
Det är exakt tänkesättet i hela serien: du kan inte läcka vad du aldrig lagrat.
```mermaid
flowchart TB
Signals["Generated signals
views/cart/purchase weights"] --> Persona["Persona enrichment
Ollama JSON-only"]
Persona --> Portrait[Portrait prompt]
Portrait --> Comfy[ComfyUI]
style Signals stroke:#1971c2,stroke-width:3px
style Persona stroke:#1971c2,stroke-width:3px
style Comfy stroke:#2f9e44,stroke-width:3px
```
## Validering: Vad detta låter dig bevisa
Denna lokala rörledning är kraftfull eftersom den stöder *Modellvalidering*, inte bara demos.
- **Segmenteringssanitet**: Är de segment du beräknar sammanhållna när du inspekterar produktnamn/taggar och genererade personas?
- **Redogörelse för rekommendationen**: visar mig varför pekar du på en riktig signal som du kan verifiera?
- **Kallstart**: om du torkar datasetet och regenererar, beter sig systemet förutsägbart?
- **Provning av regression**: regenerera samma form av data och se till att dina ändringar inte bryta ranking, poäng, eller UI.
Den viktiga subtiliteten: genom att generera båda *Texten* och *bilder*, Du kan validera hela produktupplevelsen, inte bara back-end matte.
## Vad händer härnäst?
**[Häfte 2](/blog/zero-pii-customer-intelligence-part2)**: Sessionsprofiler, signaler och segmentdefinitioner – där vi överför provdata till arbetssegmentering.
**Häfte 3** (kommer): Utkorg mönster, jobb kö, och transparens UI.
---
*Generatorkod: `Mostlylucid.SegmentCommerce.SampleData/`*