279 lines
11 KiB
Python
279 lines
11 KiB
Python
"""
|
|
Persona bank for the IfixKart customer swarm.
|
|
|
|
The local LLM is used offline to create a diverse bank of shopper personas.
|
|
Each of the 10k agents then gets a persona sampled (with jitter) from that bank,
|
|
so the LLM is never in the per-request hot path.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import random
|
|
import re
|
|
from dataclasses import asdict, dataclass, field
|
|
from typing import Any
|
|
|
|
import httpx
|
|
|
|
DEFAULT_OLLAMA = "http://127.0.0.1:11434"
|
|
DEFAULT_MODEL = "qwen3.5:4b"
|
|
|
|
CATEGORY_KEYWORDS = [
|
|
"display",
|
|
"touch screen",
|
|
"battery",
|
|
"back panel",
|
|
"screen guard",
|
|
"charger",
|
|
"camera",
|
|
"speaker",
|
|
"motorola",
|
|
"samsung",
|
|
"redmi",
|
|
"realme",
|
|
"vivo",
|
|
"oppo",
|
|
"iphone",
|
|
]
|
|
|
|
INDIAN_CITIES = [
|
|
("Bengaluru", "Karnataka", "560001"),
|
|
("Mysuru", "Karnataka", "570001"),
|
|
("Hyderabad", "Telangana", "500001"),
|
|
("Chennai", "Tamil Nadu", "600001"),
|
|
("Coimbatore", "Tamil Nadu", "641001"),
|
|
("Mumbai", "Maharashtra", "400001"),
|
|
("Pune", "Maharashtra", "411001"),
|
|
("Delhi", "Delhi", "110001"),
|
|
("Noida", "Uttar Pradesh", "201301"),
|
|
("Jaipur", "Rajasthan", "302001"),
|
|
("Ahmedabad", "Gujarat", "380001"),
|
|
("Kochi", "Kerala", "682001"),
|
|
("Kolkata", "West Bengal", "700001"),
|
|
("Visakhapatnam", "Andhra Pradesh", "530001"),
|
|
("Indore", "Madhya Pradesh", "452001"),
|
|
("Chandigarh", "Chandigarh", "160001"),
|
|
]
|
|
|
|
|
|
@dataclass
|
|
class Persona:
|
|
persona_id: str
|
|
name: str
|
|
age: int
|
|
city: str
|
|
state: str
|
|
pincode: str
|
|
budget_max: float
|
|
browse_depth: int
|
|
conversion_prob: float
|
|
cart_abandon_prob: float
|
|
payment_fail_prob: float
|
|
preferred_keywords: list[str] = field(default_factory=list)
|
|
quantity_pref: int = 1
|
|
device: str = "mobile"
|
|
notes: str = ""
|
|
|
|
def to_dict(self) -> dict[str, Any]:
|
|
return asdict(self)
|
|
|
|
@classmethod
|
|
def from_dict(cls, data: dict[str, Any]) -> "Persona":
|
|
def num(key: str, default: float) -> float:
|
|
# Use an explicit None check: a legitimate 0.0 must not fall back
|
|
# to the default (e.g. zero cart-abandonment for verification runs).
|
|
value = data.get(key)
|
|
return default if value is None else float(value)
|
|
|
|
return cls(
|
|
persona_id=str(data.get("persona_id") or "p"),
|
|
name=str(data.get("name") or "Shopper"),
|
|
age=int(num("age", 30)),
|
|
city=str(data.get("city") or "Bengaluru"),
|
|
state=str(data.get("state") or "Karnataka"),
|
|
pincode=str(data.get("pincode") or "560001"),
|
|
budget_max=num("budget_max", 15000),
|
|
browse_depth=max(1, min(8, int(num("browse_depth", 3)))),
|
|
conversion_prob=max(0.005, min(0.6, num("conversion_prob", 0.06))),
|
|
cart_abandon_prob=max(0.0, min(0.95, num("cart_abandon_prob", 0.55))),
|
|
payment_fail_prob=max(0.0, min(0.5, num("payment_fail_prob", 0.05))),
|
|
preferred_keywords=[
|
|
str(k).lower() for k in (data.get("preferred_keywords") or [])
|
|
if str(k).strip()
|
|
][:5],
|
|
quantity_pref=max(1, min(3, int(num("quantity_pref", 1)))),
|
|
device=str(data.get("device") or "mobile"),
|
|
notes=str(data.get("notes") or "")[:400],
|
|
)
|
|
|
|
|
|
def _extract_json(text: str) -> Any:
|
|
text = text.strip()
|
|
text = re.sub(r"^```(?:json)?\s*", "", text)
|
|
text = re.sub(r"\s*```$", "", text)
|
|
start = text.find("[")
|
|
end = text.rfind("]")
|
|
if start >= 0 and end > start:
|
|
candidate = text[start:end + 1]
|
|
try:
|
|
return json.loads(candidate)
|
|
except json.JSONDecodeError:
|
|
# Small local models emit slightly malformed JSON; salvage objects
|
|
# one by one and keep whatever parses cleanly.
|
|
objects = []
|
|
for m in re.finditer(r"\{", candidate):
|
|
depth = 0
|
|
in_str = False
|
|
esc = False
|
|
for idx in range(m.start(), len(candidate)):
|
|
ch = candidate[idx]
|
|
if in_str:
|
|
if esc:
|
|
esc = False
|
|
elif ch == "\\":
|
|
esc = True
|
|
elif ch == '"':
|
|
in_str = False
|
|
continue
|
|
if ch == '"':
|
|
in_str = True
|
|
elif ch == "{":
|
|
depth += 1
|
|
elif ch == "}":
|
|
depth -= 1
|
|
if depth == 0:
|
|
try:
|
|
objects.append(json.loads(candidate[m.start():idx + 1]))
|
|
except json.JSONDecodeError:
|
|
pass
|
|
break
|
|
if objects:
|
|
return objects
|
|
start = text.find("{")
|
|
end = text.rfind("}")
|
|
if start >= 0 and end > start:
|
|
return json.loads(text[start:end + 1])
|
|
raise ValueError("no JSON found")
|
|
|
|
|
|
def llm_personas(
|
|
count: int = 30,
|
|
model: str = DEFAULT_MODEL,
|
|
ollama_url: str = DEFAULT_OLLAMA,
|
|
timeout: int = 180,
|
|
seed: int = 42,
|
|
) -> list[Persona]:
|
|
"""Ask the local Ollama model for a diverse bank of shopper personas."""
|
|
prompt = f"""You are generating synthetic but realistic Indian e-commerce shoppers for a mobile-parts store (displays, batteries, back panels, screen guards).
|
|
|
|
Return ONLY a JSON array of {count} objects. No markdown, no commentary.
|
|
Each object must have exactly these fields:
|
|
persona_id (string p01...), name (Indian name), age (18-55), city, state, pincode (valid 6 digits),
|
|
budget_max (number between 1500 and 30000), browse_depth (1-6),
|
|
conversion_prob (0.01-0.20), cart_abandon_prob (0.35-0.85), payment_fail_prob (0.01-0.15),
|
|
preferred_keywords (array of 1-3 from: display, touch screen, battery, back panel, screen guard, motorola, samsung, redmi, realme, vivo, oppo, iphone),
|
|
quantity_pref (1-2), device (mobile/tablet/laptop), notes (short sentence about their shopping style).
|
|
|
|
Make the personas diverse in age, city, budget, patience, device type and intent. Vary conversion_prob realistically (low for browsers, higher for repair-shop owners)."""
|
|
payload = {
|
|
"model": model,
|
|
"prompt": prompt,
|
|
"stream": False,
|
|
"options": {"temperature": 0.9, "num_predict": 4096, "seed": seed},
|
|
}
|
|
with httpx.Client(timeout=timeout) as client:
|
|
r = client.post(f"{ollama_url.rstrip('/')}/api/generate", json=payload)
|
|
r.raise_for_status()
|
|
body = r.json()
|
|
raw = body.get("response", "")
|
|
data = _extract_json(raw)
|
|
if isinstance(data, dict):
|
|
data = data.get("personas") or [data]
|
|
personas = [Persona.from_dict(item) for item in data if isinstance(item, dict)]
|
|
if not personas:
|
|
raise ValueError("LLM returned no personas")
|
|
return personas[:count]
|
|
|
|
|
|
def fallback_personas(seed: int = 42) -> list[Persona]:
|
|
"""Deterministic diverse bank used when Ollama is unavailable."""
|
|
rng = random.Random(seed)
|
|
templates = [
|
|
("repair-shop owner", 0.18, 0.35, ["display", "touch screen", "battery"], 2, 26000),
|
|
("budget student", 0.05, 0.70, ["battery", "screen guard"], 1, 4500),
|
|
("working professional", 0.08, 0.55, ["display", "back panel"], 1, 18000),
|
|
("small reseller", 0.22, 0.30, ["display", "battery", "motorola"], 2, 30000),
|
|
("careful comparer", 0.04, 0.78, ["screen guard", "battery"], 1, 9000),
|
|
("urgent repair", 0.25, 0.20, ["display", "touch screen"], 1, 15000),
|
|
("gift buyer", 0.06, 0.65, ["screen guard", "back panel"], 1, 7000),
|
|
("loyal Samsung user", 0.10, 0.50, ["samsung", "display"], 1, 22000),
|
|
("Xiaomi enthusiast", 0.09, 0.52, ["redmi", "battery"], 1, 12000),
|
|
("tablet owner", 0.07, 0.60, ["display", "touch screen"], 1, 20000),
|
|
("laptop gamer", 0.05, 0.72, ["battery", "screen guard"], 1, 10000),
|
|
("impulse buyer", 0.16, 0.40, ["screen guard", "back panel"], 2, 6000),
|
|
]
|
|
out: list[Persona] = []
|
|
for i in range(40):
|
|
label, conv, abandon, keys, qty, budget = templates[i % len(templates)]
|
|
city, state, pin = rng.choice(INDIAN_CITIES)
|
|
out.append(
|
|
Persona(
|
|
persona_id=f"p{i + 1:03d}",
|
|
name=f"Shopper {i + 1}",
|
|
age=rng.randint(18, 55),
|
|
city=city,
|
|
state=state,
|
|
pincode=pin,
|
|
budget_max=round(budget * rng.uniform(0.75, 1.2), 2),
|
|
browse_depth=rng.randint(1, 6),
|
|
conversion_prob=max(0.01, conv * rng.uniform(0.7, 1.35)),
|
|
cart_abandon_prob=min(0.9, abandon * rng.uniform(0.85, 1.15)),
|
|
payment_fail_prob=rng.uniform(0.01, 0.10),
|
|
preferred_keywords=keys,
|
|
quantity_pref=qty,
|
|
device=rng.choice(["mobile", "mobile", "mobile", "tablet", "laptop"]),
|
|
notes=label,
|
|
)
|
|
)
|
|
return out
|
|
|
|
|
|
def build_personas(
|
|
count: int,
|
|
*,
|
|
model: str | None = DEFAULT_MODEL,
|
|
ollama_url: str = DEFAULT_OLLAMA,
|
|
seed: int = 42,
|
|
) -> list[Persona]:
|
|
"""Create a base bank, using the local LLM when possible and falling back."""
|
|
if model:
|
|
try:
|
|
base = llm_personas(count=count, model=model, ollama_url=ollama_url, seed=seed)
|
|
print(f"[personas] generated {len(base)} personas with {model}")
|
|
return base
|
|
except Exception as exc:
|
|
print(f"[personas] LLM unavailable ({exc}); using deterministic bank")
|
|
return fallback_personas(seed=seed)
|
|
|
|
|
|
def persona_for_agent(base: list[Persona], index: int, rng: random.Random) -> Persona:
|
|
"""Sample one base persona and jitter it so 10k agents are not clones."""
|
|
p = rng.choice(base)
|
|
city, state, pin = rng.choice(INDIAN_CITIES)
|
|
return Persona(
|
|
persona_id=f"{p.persona_id}-{index:06d}",
|
|
name=p.name,
|
|
age=max(18, min(60, p.age + rng.randint(-4, 4))),
|
|
city=city,
|
|
state=state,
|
|
pincode=pin,
|
|
budget_max=round(p.budget_max * rng.uniform(0.85, 1.15), 2),
|
|
browse_depth=max(1, min(7, p.browse_depth + rng.choice([-1, 0, 0, 1]))),
|
|
conversion_prob=max(0.005, min(0.5, p.conversion_prob * rng.uniform(0.7, 1.4))),
|
|
cart_abandon_prob=max(0.0, min(0.95, p.cart_abandon_prob * rng.uniform(0.85, 1.15))),
|
|
payment_fail_prob=max(0.0, min(0.4, p.payment_fail_prob * rng.uniform(0.7, 1.3))),
|
|
preferred_keywords=list(p.preferred_keywords),
|
|
quantity_pref=p.quantity_pref,
|
|
device=p.device,
|
|
notes=p.notes,
|
|
)
|