Zero PII Customer Intelligence - Parte 1.1: Generando Datos de Muestra (e Imágenes) Localmente (Español (Spanish))

In Parte 1 cubrimos la filosofía: segmentación transparente sin PII. Parte 2 abarca los perfiles de sesión, las señales y las definiciones de segmentos.

Pero primero: ¿Cómo se valida todo esto sin tocar los datos reales del cliente?

Para esta serie genero un conjunto completo de datos de comercio electrónico sintético localmente:

Catálogo de productos (nombres, descripciones, etiquetas, precios)
Anonymous “perfiles” / personas (intereses + señales)
Imágenes del producto (y retratos de perfil) a través de ComfyUI
Importación de DB opcional para que la aplicación real pueda ejecutarse contra ella

Este es uno de esos flujos de trabajo “se siente como engañar”: obtienes entradas realistas, puedes regenerarlas en cualquier momento, y nunca introduces PII en tu entorno de desarrollo.

Por qué los datos sintéticos locales son tan poderosos

Si está construyendo segmentación / personalización, necesita conjuntos de datos que:

Tener suficiente variación para romper la heurística ingenua
Son seguros para compartir (en código, pruebas, demos)
Son reproducibles (por lo que puede comparar los cambios de modelo)

Los datos reales son lo contrario: sensibles, desordenados, difíciles de mover, y llenos de prejuicios históricos.

Los datos sintéticos le dan tres superpoderes:

Iteración rápida: cambiar la lógica de segmentación, regenerar, volver a ejecutar.
Endurecimiento: simular extraños comportamientos de cola larga que no verás en un pequeño conjunto de datos dev.
Pruebas de explicación: usted puede inspeccionar cada campo generado y confirma tu "muéstrame por qué" UI es veraz.

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

La herramienta (lo que realmente se ejecuta)

El generador vive en Mostlylucid.SegmentCommerce.SampleData.

intencionalmente no es “un marco”; es un CLI pragmático que habla con:

Ollama (LLM local) para la generación JSON estructurada.
ComfyUI (Stable Diffusion local) para imágenes al estilo de la fotografía del producto.
A taxonomía JSON que mantiene las salidas coherentes (categorías, tipos, variantes, rangos de precios).

La configuración está cableada para que pueda conducirla a través de variables de entorno:

// Mostlylucid.SegmentCommerce.SampleData/Program.cs
var configuration = new ConfigurationBuilder()
    .SetBasePath(AppContext.BaseDirectory)
    .AddJsonFile("appsettings.json", optional: true)
    .AddEnvironmentVariables("SAMPLEDATA_")
    .Build();

Inicio rápido

Normalmente ejecutará tres servicios locales junto al generador:

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

Ejecute el generador desde la raíz de repo:

dotnet run --project Mostlylucid.SegmentCommerce.SampleData -- status

A continuación, generar un conjunto de datos:

# 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

Interruptores útiles:

# 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

Nota: si ComfyUI no está disponible, el generador v1 cae de nuevo a las imágenes del marcador de posición (utiliza picsum.photos, por lo que el camino no está “totalmente desconectado”). Si desea estrictamente local, ejecutar con --no-images.

v2 Generador: Vendedores → Productos → Clientes → Pedidos → Incrustaciones

También hay un nuevo comando de generador (gen) que construye un conjunto de datos “formado por el mercado” más completo:

# 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

Está orquestado como una tubería multifase:

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

Y puedes ver esas fases directamente en código:

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

Incrustaciones (ONNX local, en cacheado después de la primera ejecución)

El generador v2 puede calcular incrustaciones usando un modelo ONNX (predeterminado: all-MiniLM-L6-v2La primera vez que lo ejecutas, descarga el modelo y vocabulario en tu carpeta de salida.

Eso significa:

La primera ejecución necesita acceso a la red (descarga del modelo)
Las siguientes carreras son locales y rápidas
Si quiere “ninguna red nunca”, ejecute --no-embeddings

// 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);
}

Cómo generamos productos con “forma de LLM” (sólo JSON)

El prompt de generación de productos es deliberadamente estricto: el LLM solo debe devolver JSON, con un ejemplo de esquema JSON integrado.

// 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:
    """;

Esto importa porque los sistemas descendentes (generación de imágenes + importación + incrustaciones) quieren datos estructurados. entradas a una tubería, no escribir prosa.

Respuestas LLM: Analice JSON o retroceda

Los LLMs no son compiladores. Incluso con “JSON only”, usted todavía necesita análisis defensivo y retroactividad elegante.

El generador v2 lo hace a través de un pequeño ayudante (LlmService) que extrae el primero {...} lo bloquea y lo deserializa:

// 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<T>(jsonStr, new JsonSerializerOptions
    {
        PropertyNameCaseInsensitive = true
    });
}

Y la tubería de generación general verifica explícitamente la disponibilidad y baja a plantillas deterministas cuando es necesario:

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

Ejemplo: Customer Personas (v2)

El prompt persona para los clientes es corto y estructurado por lo que se puede generar rápidamente con un pequeño modelo local:

// 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: Fotografía de producto a través de API

ComfyUI es genial porque le da una tubería controlable (flujos de trabajo) en lugar de un “endpoint de imagen de caja negra simple”.

El generador:

Carga una plantilla de flujo de trabajo (ComfyUI/workflows/product_image.json)
Parchea el prompt en CLIPTextEncode
Colas /prompt
Encuestas /history/{promptId}
Descargas de la imagen a través de /view?...

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

La selección de modelos ComfyUI también se parchea en el flujo de trabajo en tiempo de ejecución (para que pueda intercambiar puntos de control sin editar el JSON):

// 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");

Y el parche de flujo de trabajo es intencionalmente simple y robusto:

// 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<string>() ?? "";
        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;
    }
}

Perfiles y personas (útiles, no espeluznantes)

El generador v1 crea perfiles anónimos y luego los enriquece con una persona (todavía no hay PII). Terminas con datos de prueba realistas en forma de personas sin correos electrónicos, direcciones o cualquier cosa que puedas enviar accidentalmente.

En v1, los perfiles están keyed usando un hash de un solo sentido, por lo que no hay nada que “recuperar”:

// 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();
}

Esa es exactamente la mentalidad de toda la serie: no se puede filtrar lo que nunca almacenaste.

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

Validación: lo que esto le permite probar

Esta tubería local es poderosa porque soporta validación del modelo, no sólo demos.

Segmentación cordura: ¿Los segmentos que usted calcula “siente” son coherentes cuando usted inspecciona nombres de productos/etiquetas y personas generadas?
Explicabilidad de las recomendaciones: ¿"muéstrame por qué" apunta a una señal real que puedes verificar?
Inicio en frío: si se borra el conjunto de datos y se regenera, ¿el sistema se comporta previsiblemente?
Ensayos de regresión: regenerar la misma forma de datos y asegurar que sus cambios no rompan la clasificación, puntuación, o interfaz de usuario.

La sutileza importante: al generar tanto el texto y el imágenes, usted puede validar toda la experiencia del producto, no sólo las matemáticas de fondo.

¿Qué sigue?

Parte 2: Perfiles de sesión, señales y definiciones de segmento—donde conectamos estos datos de muestra en la segmentación de trabajo.

Parte 3 (coming): Patrón de salida, cola de trabajo, y la interfaz de usuario de transparencia.

Código del generador: Mostlylucid.SegmentCommerce.SampleData/