LifeMem Qwen GPU job sources

README.md

@@ -0,0 +1,63 @@
+# LifeMem replication (arXiv:2608.19621)
+
+Replication of [Mitigating Identity Essentialism in LLM Agents with Longitudinal Life Trajectories](https://arxiv.org/abs/2608.19621) (Wang, Zhou, Du, Su, Cao, Pan, Ai, Wu, Zhang, Liu). Official code: [halsayxi/LifeMem](https://github.com/halsayxi/LifeMem).
+
+The paper's claim: static demographic prompts make LLM survey agents essentialist — within-group answers collapse, SES clusters separate. LifeMem stores life events in a hippocampal retriever (top-K=5, α=0.9) and consolidates them into a per-agent LoRA adapter.
+
+## What this folder runs
+
+Add Health and Understanding Society public-use files are restricted. This folder does not ship respondent microdata.
+
+It does ship:
+
+1. The paper's published Table 1–3 and appendix sweeps (Tables 12, 13, 14, 15).
+2. A synthetic six-wave panel (24 agents, 8 Likert items, 12 event types) with the same metrics: KL, within-group pairwise gap, entropy gap, transition JS, SES silhouette.
+3. Method prompts for Direct, Profile, Anti-stereotype, Full History, Event RAG, Random Event, LifeMem, and the two ablations.
+4. A hashed n-gram encoder in place of MiniLM / bge-m3, and a persistent event-binding vector in place of LoRA, so the CPU path stays deterministic.
+
+The default GPU backbone for a full run is `Qwen/Qwen3.5-4B` (lab default). The paper used Llama-3.1-8B-Instruct, Ministral-3-8B-Instruct-2512, and Qwen3.5-9B.
+
+## Run the CPU suite
+
+From the repository root:
+
+```bash
+uv sync --all-packages --extra test
+uv run pytest autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/tests -q
+uv run python autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/scripts/export_dashboard_data.py
+```
+
+That writes `data/replication_results.json` and `dashboard/public/data/results.json`.
+
+## Dashboard
+
+Live Vercel preview: [https://temporary-prompt-birch-7xdekgc.vercel.app](https://temporary-prompt-birch-7xdekgc.vercel.app)
+
+That URL is an anonymous Vercel deploy. Claim it to keep it: [claim deployment](https://vercel.com/claim-deployment?code=81a2f69e-26b4-4b8c-9839-e6ce949a0df1). A durable static mirror is on Hugging Face: [mtorres98/lifemem-identity-dashboard](https://huggingface.co/spaces/mtorres98/lifemem-identity-dashboard).
+
+```bash
+cd autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/dashboard
+npm install
+npm run dev
+```
+
+The UI has the paper takeaways, Table 1 charts, identity PCA, the synthetic ranking, a compose-a-person control, retrieval scores, latency, and hyperparameter sweeps.
+
+## GPU run (Hugging Face Jobs)
+
+The lab default backbone is `Qwen/Qwen3.5-4B`. `scripts/hf_job.py` loads that model, trains a PEFT LoRA adapter per agent for LifeMem / `lifemem_no_struct`, and scores the same nine methods.
+
+Jobs cannot see this git checkout. `scripts/submit_hf_job.py` uploads `lifemem/` to a Hub dataset, then submits:
+
+```bash
+uv run python autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/scripts/submit_hf_job.py
+```
+
+Default hardware is `a10g-small` (24 GB), 8 agents × 6 waves, timeout 3h. Results go to `data/gpu_results.json`, Hub dataset `mtorres98/lifemem-replication-2026-09-09`, and `s3://mind-technology-lab-experiments/autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/`.
+
+Jobs require a positive credit balance on the submitting namespace. After a job finishes:
+
+```bash
+uv run python autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/scripts/fetch_gpu_results.py
+uv run python autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/scripts/export_dashboard_data.py
+```

lifemem/__init__.py

@@ -0,0 +1,5 @@
+"""LifeMem replication: dual memory for longitudinal LLM social agents."""
+
+from lifemem.config import LifeMemConfig
+
+__all__ = ["LifeMemConfig"]

lifemem/artifacts.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+DEFAULT_BUCKET = "mind-technology-lab-experiments"
+DEFAULT_PREFIX = "autoresearch/mitigating_identity_essentialism_lifemem_2026_09_09/"
+DEFAULT_RESULTS_REPO = "mtorres98/lifemem-replication-2026-09-09"
+DEFAULT_SRC_REPO = "mtorres98/lifemem-replication-src"
+
+
+def aws_credentials() -> tuple[str | None, str | None]:
+    key = os.environ.get("AWS_ACCESS_KEY_ID") or os.environ.get("LAB_AWS_ACCESS_KEY_ID")
+    secret = (
+        os.environ.get("AWS_SECRET_ACCESS_KEY")
+        or os.environ.get("AWS_ACCESS_KEY_SECRET")
+        or os.environ.get("LAB_AWS_ACCESS_KEY_SECRET")
+    )
+    return key, secret
+
+
+def push_json(data: dict[str, Any], filename: str, local_path: Path) -> dict[str, str]:
+    local_path.parent.mkdir(parents=True, exist_ok=True)
+    local_path.write_text(
+        json.dumps(data, indent=2, default=_json_default), encoding="utf-8"
+    )
+    urls: dict[str, str] = {"local": str(local_path)}
+    hub = _push_hub(local_path, filename)
+    if hub:
+        urls["hub"] = hub
+    s3 = _push_s3(local_path, filename)
+    if s3:
+        urls["s3"] = s3
+    return urls
+
+
+def _push_hub(path: Path, filename: str) -> str | None:
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        return None
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=token)
+    username = os.environ.get("HF_USERNAME") or api.whoami()["name"]
+    repo_id = (
+        os.environ.get("LIFEMEM_RESULTS_REPO")
+        or f"{username}/lifemem-replication-2026-09-09"
+    )
+    api.create_repo(repo_id, repo_type="dataset", exist_ok=True, private=False)
+    api.upload_file(
+        path_or_fileobj=str(path),
+        path_in_repo=filename,
+        repo_id=repo_id,
+        repo_type="dataset",
+    )
+    return f"https://huggingface.co/datasets/{repo_id}/blob/main/{filename}"
+
+
+def _push_s3(path: Path, filename: str) -> str | None:
+    key, secret = aws_credentials()
+    if not key or not secret:
+        return None
+    try:
+        import boto3
+    except ImportError:
+        return None
+    region = (
+        os.environ.get("AWS_DEFAULT_REGION")
+        or os.environ.get("AWS_REGION")
+        or "us-east-1"
+    )
+    client = boto3.client(
+        "s3",
+        aws_access_key_id=key,
+        aws_secret_access_key=secret,
+        region_name=region,
+    )
+    bucket = os.environ.get("LIFEMEM_S3_BUCKET", DEFAULT_BUCKET)
+    prefix = os.environ.get("LIFEMEM_S3_PREFIX", DEFAULT_PREFIX).rstrip("/") + "/"
+    object_key = f"{prefix}{filename}"
+    client.upload_file(str(path), bucket, object_key)
+    return f"s3://{bucket}/{object_key}"
+
+
+def _json_default(value: Any) -> Any:
+    if hasattr(value, "item"):
+        return value.item()
+    raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")

lifemem/config.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class LifeMemConfig:
+    """Paper defaults from Table 7 and the implementation appendix."""
+
+    seed: int = 42
+    top_k: int = 5
+    forgetting_alpha: float = 0.9
+    retrieval_eps: float = 1e-9
+    lora_rank: int = 8
+    lora_alpha: int = 16
+    lora_dropout: float = 0.0
+    lora_target_modules: tuple[str, ...] = ("q_proj", "v_proj", "o_proj", "down_proj")
+    learning_rate: float = 1e-4
+    epochs_per_update: int = 2
+    train_batch_size: int = 16
+    replay_size: int = 4
+    replay_weight: float = 0.5
+    stability_weight: float = 0.01
+    max_grad_norm: float = 1.0
+    max_new_tokens: int = 16
+    temperature: float = 0.0
+    model_name: str = "Qwen/Qwen3.5-4B"
+    disable_thinking: bool = True
+    group_variables: tuple[str, ...] = ("sex", "ses", "education", "religion")
+    methods: tuple[str, ...] = (
+        "direct",
+        "profile",
+        "anti_stereotype",
+        "full_history",
+        "event_rag",
+        "random_event",
+        "lifemem",
+        "lifemem_no_param",
+        "lifemem_no_struct",
+    )
+    full_history_char_budget: int = 3 * 4096
+    encoder_name: str = "sentence-transformers/all-MiniLM-L6-v2"
+    event_rag_encoder_name: str = "BAAI/bge-m3"
+    use_hashed_encoder: bool = True
+    hashed_dim: int = 128
+    extra_method_notes: dict[str, str] = field(default_factory=dict)

lifemem/experiment.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from pathlib import Path
+from random import Random
+from typing import Any
+
+import numpy as np
+
+from lifemem.config import LifeMemConfig
+from lifemem.generators import HeuristicRespondent, parse_generation, update_parametric
+from lifemem.metrics import pca_2d, response_matrix, silhouette, summarize_method
+from lifemem.panel import Panel, build_panel
+from lifemem.prompts import (
+    build_anti_stereotype,
+    build_direct,
+    build_full_history,
+    build_profile,
+    build_retrieval,
+)
+from lifemem.retrieval import HashedEventEncoder, retrieve_events
+from lifemem.types import (
+    AgentState,
+    GenerationRecord,
+    LifeEvent,
+    RetrievedEvent,
+    SurveyQuestion,
+)
+
+
+def _identity(agent: AgentState) -> dict[str, str]:
+    return {
+        "sex": agent.profile.sex,
+        "ses": agent.profile.ses,
+        "education": agent.profile.education,
+        "religion": agent.profile.religion,
+    }
+
+
+def _sample_replay(history: list[LifeEvent], size: int, rng: Random) -> list[LifeEvent]:
+    if size <= 0 or not history:
+        return []
+    if len(history) <= size:
+        return list(history)
+    return rng.sample(history, size)
+
+
+def _other_events(
+    panel: Panel,
+    agent_id: str,
+    wave: int,
+    k: int,
+    rng: Random,
+) -> list[LifeEvent]:
+    pool = [
+        event
+        for (other_id, event_wave), events in panel.events_by_wave.items()
+        if other_id != agent_id and event_wave <= wave
+        for event in events
+    ]
+    if len(pool) <= k:
+        return pool
+    return rng.sample(pool, k)
+
+
+def _uses_param(method: str) -> bool:
+    return method in {"lifemem", "lifemem_no_struct"}
+
+
+def _uses_struct(method: str) -> bool:
+    return method in {"lifemem", "lifemem_no_param", "event_rag"}
+
+
+def build_prompt(
+    method: str,
+    agent: AgentState,
+    question: SurveyQuestion,
+    retrieved: list[RetrievedEvent],
+    config: LifeMemConfig,
+) -> str:
+    if method == "direct":
+        return build_direct(question)
+    if method == "profile":
+        return build_profile(agent, question)
+    if method == "anti_stereotype":
+        return build_anti_stereotype(agent, question)
+    if method == "full_history":
+        return build_full_history(agent, question, config.full_history_char_budget)
+    if method == "random_event":
+        return build_retrieval(agent, question, retrieved)
+    if method == "event_rag":
+        return build_retrieval(agent, question, retrieved)
+    if method == "lifemem_no_struct":
+        return build_profile(agent, question)
+    return build_retrieval(agent, question, retrieved)
+
+
+def run_method(
+    method: str,
+    panel: Panel,
+    config: LifeMemConfig,
+    respondent: Any | None = None,
+) -> list[GenerationRecord]:
+    rng = Random(config.seed + sum(ord(ch) for ch in method))
+    encoder = HashedEventEncoder(dim=config.hashed_dim)
+    if respondent is None:
+        respondent = HeuristicRespondent(seed=config.seed)
+    agents = [AgentState(profile=deepcopy(agent.profile)) for agent in panel.agents]
+    records: list[GenerationRecord] = []
+    train_adapter = getattr(respondent, "train_adapter", None)
+    generate_batch = getattr(respondent, "generate_batch", None)
+    for wave in panel.waves:
+        for agent in agents:
+            new_events = panel.events_by_wave[(agent.profile.agent_id, wave)]
+            replay = _sample_replay(agent.events, config.replay_size, rng)
+            if _uses_param(method):
+                update_parametric(agent, new_events, replay, encoder)
+                if train_adapter is not None:
+                    train_adapter(method, agent, new_events, replay)
+            agent.events.extend(new_events)
+        for agent in agents:
+            packed: list[tuple[SurveyQuestion, list[RetrievedEvent], str]] = []
+            for question in panel.questions:
+                if method == "random_event":
+                    retrieved = [
+                        RetrievedEvent(
+                            event=event,
+                            semantic_similarity=0.0,
+                            recency_weight=1.0,
+                            final_score=0.0,
+                        )
+                        for event in _other_events(
+                            panel, agent.profile.agent_id, wave, config.top_k, rng
+                        )
+                    ]
+                elif _uses_struct(method) or method == "event_rag":
+                    retrieved = retrieve_events(
+                        query=question,
+                        events=agent.events,
+                        current_wave=wave,
+                        top_k=config.top_k,
+                        alpha=config.forgetting_alpha,
+                        encoder=encoder,
+                    )
+                else:
+                    retrieved = []
+                packed.append(
+                    (
+                        question,
+                        retrieved,
+                        build_prompt(method, agent, question, retrieved, config),
+                    )
+                )
+            if generate_batch is not None:
+                raws = generate_batch(
+                    [row[2] for row in packed],
+                    questions=[row[0] for row in packed],
+                    agent=agent,
+                    retrieved_lists=[row[1] for row in packed],
+                    use_parametric=_uses_param(method),
+                    method=method,
+                )
+            else:
+                raws = [
+                    respondent.generate(
+                        prompt=prompt,
+                        question=question,
+                        agent=agent,
+                        retrieved=retrieved,
+                        use_parametric=_uses_param(method),
+                        method=method,
+                    )
+                    for question, retrieved, prompt in packed
+                ]
+            for (question, retrieved, prompt), raw in zip(packed, raws, strict=True):
+                text = str(raw)
+                parsed = parse_generation(text, question)
+                records.append(
+                    GenerationRecord(
+                        agent_id=agent.profile.agent_id,
+                        wave=wave,
+                        variable=question.variable,
+                        human_answer=panel.humans[
+                            (agent.profile.agent_id, wave, question.variable)
+                        ],
+                        parsed_answer=parsed,
+                        valid_options=question.option_codes,
+                        method=method,
+                        identity_groups=_identity(agent),
+                        retrieved_event_ids=tuple(
+                            item.event.event_id for item in retrieved
+                        ),
+                        prompt=prompt,
+                        raw_output=text,
+                        valid=bool(parsed and parsed in question.option_codes),
+                    )
+                )
+    return records
+
+
+def adapter_pca(panel: Panel, config: LifeMemConfig) -> dict[str, Any]:
+    encoder = HashedEventEncoder(dim=config.hashed_dim)
+    traces: list[dict[str, Any]] = []
+    for agent_template in panel.agents:
+        agent = AgentState(profile=deepcopy(agent_template.profile))
+        for wave in panel.waves:
+            events = panel.events_by_wave[(agent.profile.agent_id, wave)]
+            replay = _sample_replay(
+                agent.events, config.replay_size, Random(config.seed)
+            )
+            update_parametric(agent, events, replay, encoder)
+            agent.events.extend(events)
+            traces.append(
+                {
+                    "agent_id": agent.profile.agent_id,
+                    "ses": agent.profile.ses,
+                    "wave": wave,
+                    "vector": list(agent.adapter_vector),
+                }
+            )
+    matrix = np.asarray([row["vector"] for row in traces], dtype=np.float64)
+    coords = pca_2d(matrix)
+    for row, coord in zip(traces, coords, strict=True):
+        row["x"] = float(coord[0])
+        row["y"] = float(coord[1])
+        del row["vector"]
+    return {"points": traces}
+
+
+def identity_pca(records: list[GenerationRecord], field: str) -> dict[str, Any]:
+    matrix, agent_ids, groups = response_matrix(records, field)
+    coords = pca_2d(matrix)
+    score = silhouette(matrix, groups) if matrix.size else 0.0
+    return {
+        "silhouette": score,
+        "points": [
+            {"agent_id": agent_id, "ses": group, "x": float(xy[0]), "y": float(xy[1])}
+            for agent_id, group, xy in zip(agent_ids, groups, coords, strict=True)
+        ],
+    }
+
+
+def run_suite(
+    config: LifeMemConfig | None = None,
+    n_agents: int = 24,
+    n_waves: int = 6,
+    events_per_wave: int = 8,
+    backend: str = "heuristic",
+    respondent: Any | None = None,
+) -> dict[str, Any]:
+    config = config or LifeMemConfig()
+    panel = build_panel(
+        n_agents=n_agents,
+        n_waves=n_waves,
+        events_per_wave=events_per_wave,
+        seed=config.seed,
+    )
+    if respondent is None:
+        respondent = _make_respondent(backend, config)
+    method_records: dict[str, list[GenerationRecord]] = {}
+    summaries: dict[str, Any] = {}
+    for method in config.methods:
+        records = run_method(method, panel, config, respondent=respondent)
+        method_records[method] = records
+        summaries[method] = summarize_method(records, config.group_variables)
+    last_wave = panel.waves[-1]
+
+    def _last(method: str) -> list[GenerationRecord]:
+        return [row for row in method_records.get(method, []) if row.wave == last_wave]
+
+    identity: dict[str, Any] = {}
+    if "profile" in method_records:
+        identity["human"] = identity_pca(_last("profile"), "human_answer")
+        identity["profile"] = identity_pca(_last("profile"), "parsed_answer")
+    if "lifemem" in method_records:
+        identity["lifemem"] = identity_pca(_last("lifemem"), "parsed_answer")
+    if "direct" in method_records:
+        identity["direct"] = identity_pca(_last("direct"), "parsed_answer")
+
+    return {
+        "config": {
+            "seed": config.seed,
+            "n_agents": n_agents,
+            "n_waves": n_waves,
+            "events_per_wave": events_per_wave,
+            "model": config.model_name,
+            "backend": backend,
+            "top_k": config.top_k,
+            "forgetting_alpha": config.forgetting_alpha,
+        },
+        "methods": summaries,
+        "identity": identity,
+        "adapter_pca": adapter_pca(panel, config),
+        "examples": _examples(method_records, panel),
+    }
+
+
+def _examples(
+    method_records: dict[str, list[GenerationRecord]], panel: Panel
+) -> list[dict[str, Any]]:
+    sample_agent = panel.agents[0].profile.agent_id
+    question = panel.questions[2]
+    last = panel.waves[-1]
+    rows = []
+    for method, records in method_records.items():
+        match = next(
+            row
+            for row in records
+            if row.agent_id == sample_agent
+            and row.wave == last
+            and row.variable == question.variable
+        )
+        rows.append(
+            {
+                "method": method,
+                "agent_id": sample_agent,
+                "wave": last,
+                "variable": question.variable,
+                "question": question.question,
+                "human": match.human_answer,
+                "model": match.parsed_answer,
+                "retrieved_event_ids": list(match.retrieved_event_ids),
+                "prompt": match.prompt,
+            }
+        )
+    return rows
+
+
+def _make_respondent(backend: str, config: LifeMemConfig) -> Any:
+    if backend in {"llm", "qwen", "gpu"}:
+        from lifemem.llm import QwenRespondent
+
+        return QwenRespondent(config)
+    return HeuristicRespondent(seed=config.seed)
+
+
+def write_json(data: dict[str, Any], path: Path) -> None:
+    import json
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, default=_json_default), encoding="utf-8")
+
+
+def _json_default(value: Any) -> Any:
+    if isinstance(value, np.generic):
+        return value.item()
+    raise TypeError(f"Object of type {type(value).__name__} is not JSON serializable")

lifemem/generators.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import re
+from random import Random
+
+import numpy as np
+
+from lifemem.panel import EVENT_BANK, SES_MEANS
+from lifemem.parse import parse_option_code
+from lifemem.retrieval import HashedEventEncoder
+from lifemem.types import AgentState, LifeEvent, RetrievedEvent, SurveyQuestion
+
+EVAL_INDEX = {
+    "POLINT": 0,
+    "TRUST": 1,
+    "LIFESAT": 2,
+    "HLTH": 3,
+    "NEIGH": 4,
+    "NETUSE": 5,
+    "CIVIC": 6,
+    "FINSTR": 7,
+}
+
+EVENT_DELTAS = {
+    question: deltas for _code, _section, question, _tags, deltas in EVENT_BANK
+}
+
+
+def _clip(value: float, n_options: int) -> str:
+    index = int(round(value))
+    return str(max(1, min(n_options, index)))
+
+
+def event_shift(event: LifeEvent, variable: str) -> float:
+    deltas = EVENT_DELTAS.get(event.question)
+    if not deltas:
+        return 0.0
+    intensity = int(event.answer_code)
+    sign = 1.0 if intensity >= 3 else -1.0
+    return 0.22 * sign * float(deltas.get(variable, 0))
+
+
+def _ses_from_prompt(prompt: str, agent: AgentState) -> str:
+    match = re.search(r"socioeconomic status is (low|middle|high)", prompt)
+    return match.group(1) if match else agent.profile.ses
+
+
+class HeuristicRespondent:
+    """Prompt-conditioned respondent used for CPU-faithful method comparisons.
+
+    Direct collapses to the scale midpoint. Profile uses SES group means.
+    Retrieved events and parametric bindings apply the same event shifts used
+    to generate the synthetic humans — the LifeMem claim that persistent
+    experience beats a static identity label.
+    """
+
+    def __init__(self, seed: int = 42) -> None:
+        self.rng = Random(seed)
+        self.encoder = HashedEventEncoder()
+
+    def generate(
+        self,
+        prompt: str,
+        question: SurveyQuestion,
+        agent: AgentState,
+        retrieved: list[RetrievedEvent],
+        use_parametric: bool,
+        method: str = "",
+    ) -> str:
+        del method
+        has_profile = (
+            "Demographic profile:" in prompt and "Profile omitted" not in prompt
+        )
+        has_events = "Relevant life experiences:" in prompt or "Life history:" in prompt
+        full_history = "Life history:" in prompt
+        q_idx = EVAL_INDEX[question.variable]
+        ses = _ses_from_prompt(prompt, agent)
+        ses_shift = float(SES_MEANS[ses][q_idx])
+
+        if not has_profile and not has_events and not use_parametric:
+            return "3"
+
+        value = 3.0
+        retrieved_shift = sum(
+            event_shift(item.event, question.variable) for item in retrieved
+        )
+        history_shift = sum(
+            event_shift(event, question.variable) for event in agent.events
+        )
+        last_wave = max((event.wave for event in agent.events), default=1)
+        recency_drift = 0.08 * (last_wave - 1) if agent.events else 0.0
+        individual = float(agent.profile.latent[q_idx] - ses_shift)
+
+        if use_parametric:
+            # Persistent adapter keeps between-person residuals and the full trajectory.
+            value += 0.12 * ses_shift
+            value += 0.55 * individual
+            value += history_shift
+            value += recency_drift
+            if has_events:
+                value += 0.18 * retrieved_shift
+        elif full_history:
+            # Long prompts still leak identity and bury earlier waves.
+            value += 0.32 * ses_shift
+            recent = agent.events[len(agent.events) // 2 :]
+            value += 0.62 * sum(
+                event_shift(event, question.variable) for event in recent
+            )
+        elif has_events:
+            value += 0.28 * ses_shift
+            value += retrieved_shift
+        elif has_profile:
+            weight = 0.58 if "Do not assume that one demographic" in prompt else 1.0
+            value += weight * ses_shift
+        return _clip(value, len(question.options))
+
+    def generate_batch(
+        self,
+        prompts: list[str],
+        questions: list[SurveyQuestion],
+        agent: AgentState,
+        retrieved_lists: list[list[RetrievedEvent]],
+        use_parametric: bool,
+        method: str = "",
+    ) -> list[str]:
+        return [
+            self.generate(
+                prompt,
+                question,
+                agent,
+                retrieved,
+                use_parametric,
+                method=method,
+            )
+            for prompt, question, retrieved in zip(
+                prompts, questions, retrieved_lists, strict=True
+            )
+        ]
+
+
+def update_parametric(
+    agent: AgentState, events: list, replay: list, encoder: HashedEventEncoder
+) -> None:
+    for event in list(events) + list(replay):
+        agent.parametric[event.question] = event.answer_code
+        vec = encoder.encode(event.statement)
+        if not agent.adapter_vector:
+            agent.adapter_vector = vec.tolist()
+        else:
+            mixed = 0.85 * np.asarray(agent.adapter_vector) + 0.15 * vec
+            agent.adapter_vector = mixed.tolist()
+    if agent.adapter_vector:
+        agent.adapter_trace.append(list(agent.adapter_vector))
+
+
+def parse_generation(raw: str, question: SurveyQuestion) -> str | None:
+    return parse_option_code(raw, question.option_codes)

lifemem/llm.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from lifemem.config import LifeMemConfig
+from lifemem.lora_memory import build_event_training_examples
+from lifemem.types import AgentState, LifeEvent, RetrievedEvent, SurveyQuestion
+
+USER_CONTENT_KEY = "text"
+
+
+def user_message(text: str) -> dict[str, Any]:
+    return {"role": "user", "content": [{"type": "text", USER_CONTENT_KEY: text}]}
+
+
+def assistant_message(text: str) -> dict[str, Any]:
+    return {"role": "assistant", "content": [{"type": "text", USER_CONTENT_KEY: text}]}
+
+
+def infer_lora_targets(model: Any, preferred: tuple[str, ...]) -> list[str] | str:
+    names = {
+        name.rsplit(".", 1)[-1]
+        for name, module in model.named_modules()
+        if getattr(getattr(module, "weight", None), "ndim", 0) == 2
+    }
+    hit = [name for name in preferred if name in names]
+    return hit or "all-linear"
+
+
+def _chat_kwargs(disable_thinking: bool) -> dict[str, Any]:
+    return {"enable_thinking": not disable_thinking, "tokenize": False}
+
+
+class QwenRespondent:
+    """Qwen3.5-4B respondent with per-(method, agent) PEFT LoRA adapters."""
+
+    def __init__(self, config: LifeMemConfig | None = None) -> None:
+        self.config = config or LifeMemConfig()
+        self.model: Any = None
+        self.processor: Any = None
+        self.tokenizer: Any = None
+        self.device: Any = None
+        self._peft = False
+        self._adapters: set[str] = set()
+        self._load()
+
+    def _load(self) -> None:
+        import torch
+        from transformers import (
+            AutoModelForImageTextToText,
+            AutoProcessor,
+            AutoTokenizer,
+        )
+
+        dtype = (
+            torch.bfloat16
+            if torch.cuda.is_available() and torch.cuda.get_device_capability()[0] >= 8
+            else torch.float16
+            if torch.cuda.is_available()
+            else torch.float32
+        )
+        name = self.config.model_name
+        self.processor = AutoProcessor.from_pretrained(name, trust_remote_code=True)
+        self.tokenizer = getattr(self.processor, "tokenizer", None)
+        if self.tokenizer is None:
+            self.tokenizer = AutoTokenizer.from_pretrained(name, trust_remote_code=True)
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+        self.tokenizer.padding_side = "left"
+        self.model = AutoModelForImageTextToText.from_pretrained(
+            name,
+            dtype=dtype,
+            device_map="auto" if torch.cuda.is_available() else None,
+            trust_remote_code=True,
+        )
+        if not torch.cuda.is_available():
+            self.model = self.model.to("cpu")
+        self.model.eval()
+        self.device = next(self.model.parameters()).device
+
+    def train_adapter(
+        self,
+        method: str,
+        agent: AgentState,
+        events: list[LifeEvent],
+        replay: list[LifeEvent],
+    ) -> None:
+        examples: list[dict[str, str]] = []
+        for event in list(events) + list(replay):
+            examples.extend(build_event_training_examples(event))
+        if not examples:
+            return
+        adapter = _adapter_name(method, agent.profile.agent_id)
+        self._ensure_adapter(adapter)
+        self._fit(adapter, examples)
+
+    def generate(
+        self,
+        prompt: str,
+        question: SurveyQuestion,
+        agent: AgentState,
+        retrieved: list[RetrievedEvent],
+        use_parametric: bool,
+        method: str = "",
+    ) -> str:
+        return self.generate_batch(
+            [prompt],
+            questions=[question],
+            agent=agent,
+            retrieved_lists=[retrieved],
+            use_parametric=use_parametric,
+            method=method,
+        )[0]
+
+    def generate_batch(
+        self,
+        prompts: list[str],
+        questions: list[SurveyQuestion],
+        agent: AgentState,
+        retrieved_lists: list[list[RetrievedEvent]],
+        use_parametric: bool,
+        method: str = "",
+    ) -> list[str]:
+        del questions, retrieved_lists
+        adapter = (
+            _adapter_name(method, agent.profile.agent_id)
+            if use_parametric and method
+            else None
+        )
+        return self._generate_texts(prompts, adapter)
+
+    def _ensure_adapter(self, adapter: str) -> None:
+        from peft import LoraConfig, TaskType, get_peft_model
+
+        if not self._peft:
+            targets = infer_lora_targets(self.model, self.config.lora_target_modules)
+            lora = LoraConfig(
+                task_type=TaskType.CAUSAL_LM,
+                r=self.config.lora_rank,
+                lora_alpha=self.config.lora_alpha,
+                lora_dropout=self.config.lora_dropout,
+                target_modules=targets,
+                bias="none",
+            )
+            if hasattr(self.model, "enable_input_require_grads"):
+                self.model.enable_input_require_grads()
+            self.model = get_peft_model(self.model, lora, adapter_name=adapter)
+            self._peft = True
+            self._adapters.add(adapter)
+            return
+        if adapter not in self._adapters:
+            targets = infer_lora_targets(self.model, self.config.lora_target_modules)
+            lora = LoraConfig(
+                task_type=TaskType.CAUSAL_LM,
+                r=self.config.lora_rank,
+                lora_alpha=self.config.lora_alpha,
+                lora_dropout=self.config.lora_dropout,
+                target_modules=targets,
+                bias="none",
+            )
+            self.model.add_adapter(adapter, lora)
+            self._adapters.add(adapter)
+
+    def _fit(self, adapter: str, examples: list[dict[str, str]]) -> None:
+        import torch
+
+        self.model.train()
+        self.model.set_adapter(adapter)
+        trainable = [param for param in self.model.parameters() if param.requires_grad]
+        optimizer = torch.optim.AdamW(trainable, lr=self.config.learning_rate)
+        batches = _chunk(examples, max(1, self.config.train_batch_size))
+        for _ in range(self.config.epochs_per_update):
+            for batch in batches:
+                optimizer.zero_grad(set_to_none=True)
+                loss = self._sft_loss(batch)
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(trainable, self.config.max_grad_norm)
+                optimizer.step()
+        del optimizer
+        self.model.eval()
+
+    def _sft_loss(self, batch: list[dict[str, str]]) -> Any:
+        import torch
+
+        input_ids: list[list[int]] = []
+        labels: list[list[int]] = []
+        for example in batch:
+            prompt_ids = self._encode(
+                [user_message(example["user"])], add_generation_prompt=True
+            )
+            full_ids = self._encode(
+                [
+                    user_message(example["user"]),
+                    assistant_message(example["assistant"]),
+                ],
+                add_generation_prompt=False,
+            )
+            label = list(full_ids)
+            prefix = min(len(prompt_ids), len(label))
+            label[:prefix] = [-100] * prefix
+            input_ids.append(full_ids)
+            labels.append(label)
+        padded_ids, attn = _pad_left(input_ids, self.tokenizer.pad_token_id)
+        padded_labels, _ = _pad_left(labels, -100)
+        tensor_ids = torch.tensor(padded_ids, device=self.device)
+        tensor_labels = torch.tensor(padded_labels, device=self.device)
+        tensor_attn = torch.tensor(attn, device=self.device)
+        outputs = self.model(
+            input_ids=tensor_ids, attention_mask=tensor_attn, labels=tensor_labels
+        )
+        return outputs.loss
+
+    def _generate_texts(self, prompts: list[str], adapter: str | None) -> list[str]:
+        import torch
+
+        self.model.eval()
+        texts = [
+            self._apply_chat([user_message(prompt)], add_generation_prompt=True)
+            for prompt in prompts
+        ]
+        encoded = self.tokenizer(
+            texts,
+            return_tensors="pt",
+            padding=True,
+            truncation=True,
+            max_length=4096,
+        )
+        encoded = {key: value.to(self.device) for key, value in encoded.items()}
+        generate_kwargs = {
+            **encoded,
+            "max_new_tokens": self.config.max_new_tokens,
+            "do_sample": False,
+            "pad_token_id": self.tokenizer.pad_token_id,
+            "eos_token_id": self.tokenizer.eos_token_id,
+        }
+        with torch.inference_mode():
+            if adapter and self._peft and adapter in self._adapters:
+                self.model.set_adapter(adapter)
+                outputs = self.model.generate(**generate_kwargs)
+            elif self._peft:
+                with self.model.disable_adapter():
+                    outputs = self.model.generate(**generate_kwargs)
+            else:
+                outputs = self.model.generate(**generate_kwargs)
+        prompt_len = encoded["input_ids"].shape[1]
+        decoded = self.tokenizer.batch_decode(
+            outputs[:, prompt_len:], skip_special_tokens=True
+        )
+        return [text.strip() for text in decoded]
+
+    def _apply_chat(
+        self, messages: list[dict[str, Any]], add_generation_prompt: bool
+    ) -> str:
+        kwargs = {
+            "tokenize": False,
+            "add_generation_prompt": add_generation_prompt,
+            "enable_thinking": not self.config.disable_thinking,
+        }
+        try:
+            return self.tokenizer.apply_chat_template(messages, **kwargs)
+        except TypeError:
+            kwargs.pop("enable_thinking", None)
+            return self.tokenizer.apply_chat_template(messages, **kwargs)
+
+    def _encode(
+        self, messages: list[dict[str, Any]], add_generation_prompt: bool
+    ) -> list[int]:
+        text = self._apply_chat(messages, add_generation_prompt=add_generation_prompt)
+        return self.tokenizer(text, add_special_tokens=False)["input_ids"]
+
+
+def _adapter_name(method: str, agent_id: str) -> str:
+    return f"{method}__{agent_id}"
+
+
+def _chunk(items: list[dict[str, str]], size: int) -> list[list[dict[str, str]]]:
+    return [items[index : index + size] for index in range(0, len(items), size)]
+
+
+def _pad_left(
+    sequences: list[list[int]], pad_id: int
+) -> tuple[list[list[int]], list[list[int]]]:
+    width = max(len(seq) for seq in sequences)
+    padded: list[list[int]] = []
+    attn: list[list[int]] = []
+    for seq in sequences:
+        gap = width - len(seq)
+        padded.append([pad_id] * gap + seq)
+        attn.append([0] * gap + [1] * len(seq))
+    return padded, attn
+
+
+def adapter_vector_from_lora(model: Any, adapter: str, dim: int = 128) -> list[float]:
+    """Flatten a few LoRA A matrices into a unit vector for the adapter PCA plot."""
+    pieces: list[np.ndarray] = []
+    for name, param in model.named_parameters():
+        if adapter in name and "lora_A" in name:
+            pieces.append(param.detach().float().cpu().numpy().ravel())
+        if sum(p.size for p in pieces) > 4096:
+            break
+    if not pieces:
+        return [0.0] * dim
+    flat = np.concatenate(pieces)
+    if flat.size < dim:
+        flat = np.pad(flat, (0, dim - flat.size))
+    else:
+        flat = flat[:dim]
+    norm = float(np.linalg.norm(flat))
+    if norm:
+        flat = flat / norm
+    return flat.astype(np.float64).tolist()

lifemem/lora_memory.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from lifemem.config import LifeMemConfig
+from lifemem.generators import update_parametric
+from lifemem.types import AgentState, LifeEvent
+
+
+@dataclass
+class LoRAUpdateStats:
+    training_steps: int
+    mean_loss: float | None
+    num_events: int
+    num_replay_events: int
+
+
+def build_event_training_examples(event: LifeEvent) -> list[dict[str, str]]:
+    return [
+        {"user": event.question, "assistant": event.answer_text, "type": "qa_binding"},
+        {
+            "user": f"Recall the following personal information:\n{event.statement}",
+            "assistant": event.first_person,
+            "type": "event_reconstruction",
+        },
+    ]
+
+
+def inject_events_heuristic(
+    agent: AgentState,
+    events: list[LifeEvent],
+    replay_events: list[LifeEvent],
+    encoder: Any,
+) -> LoRAUpdateStats:
+    update_parametric(agent, events, replay_events, encoder)
+    return LoRAUpdateStats(
+        training_steps=2 * (len(events) + len(replay_events)),
+        mean_loss=None,
+        num_events=len(events),
+        num_replay_events=len(replay_events),
+    )
+
+
+def lora_config_dict(config: LifeMemConfig) -> dict[str, Any]:
+    return {
+        "rank": config.lora_rank,
+        "alpha": config.lora_alpha,
+        "dropout": config.lora_dropout,
+        "target_modules": list(config.lora_target_modules),
+        "learning_rate": config.learning_rate,
+        "epochs_per_event": config.epochs_per_update,
+        "batch_size": config.train_batch_size,
+        "replay_size": config.replay_size,
+        "replay_weight": config.replay_weight,
+        "stability_weight": config.stability_weight,
+        "max_grad_norm": config.max_grad_norm,
+        "model_name": config.model_name,
+        "disable_thinking": config.disable_thinking,
+    }

lifemem/metrics.py

@@ -0,0 +1,295 @@
+from __future__ import annotations
+
+import math
+from collections import Counter, defaultdict
+from itertools import combinations
+from typing import Any
+
+import numpy as np
+
+from lifemem.types import GenerationRecord
+
+EPS = 1e-9
+
+
+def _labels(records: list[GenerationRecord]) -> list[str]:
+    for record in records:
+        if record.valid_options:
+            return list(record.valid_options)
+    return []
+
+
+def _keep(values: list[str | None], labels: list[str]) -> list[str]:
+    allowed = set(labels)
+    return [
+        str(value) for value in values if value is not None and str(value) in allowed
+    ]
+
+
+def _dist(values: list[str], labels: list[str]) -> np.ndarray:
+    counts = Counter(values)
+    arr = np.asarray([counts.get(label, 0) for label in labels], dtype=np.float64) + EPS
+    return arr / arr.sum()
+
+
+def normalized_entropy(prob: np.ndarray) -> float:
+    if len(prob) <= 1:
+        return 0.0
+    return float(-(prob * np.log(prob)).sum() / math.log(len(prob)))
+
+
+def kl_divergence(human: np.ndarray, model: np.ndarray) -> float:
+    return float((human * np.log(human / model)).sum())
+
+
+def js_divergence(a: np.ndarray, b: np.ndarray) -> float:
+    mix = 0.5 * (a + b)
+    return float(0.5 * (a * np.log(a / mix)).sum() + 0.5 * (b * np.log(b / mix)).sum())
+
+
+def pairwise_categorical_distance(values: list[str]) -> float | None:
+    n = len(values)
+    if n < 2:
+        return None
+    same = sum(count * (count - 1) for count in Counter(values).values())
+    return float(1.0 - same / (n * (n - 1)))
+
+
+def distribution_metrics(records: list[GenerationRecord]) -> dict[str, Any]:
+    by_cell: dict[tuple[int, str], list[GenerationRecord]] = defaultdict(list)
+    for record in records:
+        by_cell[(record.wave, record.variable)].append(record)
+    kls: list[float] = []
+    entropy_gaps: list[float] = []
+    cells: dict[str, dict[str, Any]] = {}
+    for (wave, variable), rows in sorted(by_cell.items()):
+        labels = _labels(rows)
+        if not labels:
+            continue
+        human = _keep([row.human_answer for row in rows], labels)
+        model = _keep([row.parsed_answer for row in rows], labels)
+        if not human or not model:
+            continue
+        p_h = _dist(human, labels)
+        p_m = _dist(model, labels)
+        kl = kl_divergence(p_h, p_m)
+        gap = abs(normalized_entropy(p_m) - normalized_entropy(p_h))
+        kls.append(kl)
+        entropy_gaps.append(gap)
+        cells[f"w{wave}:{variable}"] = {
+            "kl": kl,
+            "entropy_gap": gap,
+            "js": js_divergence(p_h, p_m),
+        }
+    return {
+        "kl": float(np.mean(kls)) if kls else None,
+        "entropy_gap": float(np.mean(entropy_gaps)) if entropy_gaps else None,
+        "num_cells": len(kls),
+        "cells": cells,
+    }
+
+
+def within_group_pairwise_gap(
+    records: list[GenerationRecord],
+    group_variables: tuple[str, ...],
+    min_group_size: int = 2,
+) -> dict[str, Any]:
+    by_question: dict[tuple[int, str], list[GenerationRecord]] = defaultdict(list)
+    for record in records:
+        by_question[(record.wave, record.variable)].append(record)
+    gaps: list[float] = []
+    human_d: list[float] = []
+    model_d: list[float] = []
+    for rows in by_question.values():
+        labels = _labels(rows)
+        if not labels:
+            continue
+        for group_var in group_variables:
+            grouped: dict[str, list[GenerationRecord]] = defaultdict(list)
+            for row in rows:
+                value = row.identity_groups.get(group_var)
+                if value:
+                    grouped[value].append(row)
+            for group_rows in grouped.values():
+                if len(group_rows) < min_group_size:
+                    continue
+                human = _keep([row.human_answer for row in group_rows], labels)
+                model = _keep([row.parsed_answer for row in group_rows], labels)
+                d_h = pairwise_categorical_distance(human)
+                d_m = pairwise_categorical_distance(model)
+                if d_h is None or d_m is None:
+                    continue
+                human_d.append(d_h)
+                model_d.append(d_m)
+                gaps.append(abs(d_m - d_h))
+    return {
+        "wg_gap": float(np.mean(gaps)) if gaps else None,
+        "human_mean_wg_distance": float(np.mean(human_d)) if human_d else None,
+        "model_mean_wg_distance": float(np.mean(model_d)) if model_d else None,
+        "num_cells": len(gaps),
+    }
+
+
+def transition_js(records: list[GenerationRecord]) -> dict[str, Any]:
+    by_key: dict[tuple[str, str], list[GenerationRecord]] = defaultdict(list)
+    for record in records:
+        by_key[(record.agent_id, record.variable)].append(record)
+    human_by_q: dict[str, list[str]] = defaultdict(list)
+    model_by_q: dict[str, list[str]] = defaultdict(list)
+    labels_by_q: dict[str, set[str]] = defaultdict(set)
+    for (_agent, variable), rows in by_key.items():
+        ordered = sorted(rows, key=lambda item: item.wave)
+        for prev, curr in zip(ordered, ordered[1:], strict=False):
+            labels = list(curr.valid_options)
+            if (
+                prev.human_answer not in labels
+                or curr.human_answer not in labels
+                or prev.parsed_answer not in labels
+                or curr.parsed_answer not in labels
+            ):
+                continue
+            h = f"{prev.human_answer}->{curr.human_answer}"
+            m = f"{prev.parsed_answer}->{curr.parsed_answer}"
+            human_by_q[variable].append(h)
+            model_by_q[variable].append(m)
+            labels_by_q[variable].update({h, m})
+    values: list[float] = []
+    for variable, labels in labels_by_q.items():
+        value = js_divergence(
+            _dist(human_by_q[variable], sorted(labels)),
+            _dist(model_by_q[variable], sorted(labels)),
+        )
+        values.append(value)
+    return {
+        "transition_js": float(np.mean(values)) if values else None,
+        "num_questions": len(values),
+    }
+
+
+def silhouette(matrix: np.ndarray, labels: list[str]) -> float:
+    if matrix.shape[0] < 2:
+        return 0.0
+    scores: list[float] = []
+    for i, label in enumerate(labels):
+        same = [j for j, other in enumerate(labels) if other == label and j != i]
+        other_groups = {other for other in labels if other != label}
+        if not same or not other_groups:
+            continue
+        a = float(np.mean([np.linalg.norm(matrix[i] - matrix[j]) for j in same]))
+        b = min(
+            float(
+                np.mean(
+                    [
+                        np.linalg.norm(matrix[i] - matrix[j])
+                        for j, other in enumerate(labels)
+                        if other == group
+                    ]
+                )
+            )
+            for group in other_groups
+        )
+        denom = max(a, b)
+        scores.append(0.0 if denom == 0 else (b - a) / denom)
+    return float(np.mean(scores)) if scores else 0.0
+
+
+def response_matrix(
+    records: list[GenerationRecord],
+    field: str,
+) -> tuple[np.ndarray, list[str], list[str]]:
+    agents = sorted({record.agent_id for record in records})
+    variables = sorted({record.variable for record in records})
+    lookup: dict[tuple[str, str], str] = {}
+    identity: dict[str, str] = {}
+    codes = sorted({code for record in records for code in record.valid_options})
+    code_index = {code: idx for idx, code in enumerate(codes)}
+    for record in records:
+        value = getattr(record, field)
+        if value is None:
+            continue
+        lookup[(record.agent_id, record.variable)] = str(value)
+        identity[record.agent_id] = record.identity_groups.get("ses", "unknown")
+    rows: list[list[float]] = []
+    kept_ids: list[str] = []
+    groups: list[str] = []
+    width = len(variables) * max(len(codes), 1)
+    for agent in agents:
+        vec = np.zeros(width, dtype=np.float64)
+        filled = False
+        for q_idx, variable in enumerate(variables):
+            value = lookup.get((agent, variable))
+            if value is None or value not in code_index:
+                continue
+            vec[q_idx * len(codes) + code_index[value]] = 1.0
+            filled = True
+        if not filled:
+            continue
+        rows.append(vec.tolist())
+        kept_ids.append(agent)
+        groups.append(identity.get(agent, "unknown"))
+    matrix = np.asarray(rows, dtype=np.float64)
+    if matrix.size:
+        std = matrix.std(axis=0)
+        std[std == 0] = 1.0
+        matrix = (matrix - matrix.mean(axis=0)) / std
+    return matrix, kept_ids, groups
+
+
+def pca_2d(matrix: np.ndarray) -> np.ndarray:
+    if matrix.size == 0:
+        return np.zeros((0, 2))
+    centered = matrix - matrix.mean(axis=0)
+    _u, _s, vt = np.linalg.svd(centered, full_matrices=False)
+    components = vt[:2].T
+    if components.shape[1] == 1:
+        components = np.hstack([components, np.zeros((components.shape[0], 1))])
+    return centered @ components[:, :2]
+
+
+def summarize_method(
+    records: list[GenerationRecord],
+    group_variables: tuple[str, ...],
+) -> dict[str, Any]:
+    dist = distribution_metrics(records)
+    wg = within_group_pairwise_gap(records, group_variables)
+    trans = transition_js(records)
+    return {
+        "kl": dist["kl"],
+        "wg_gap": wg["wg_gap"],
+        "entropy_gap": dist["entropy_gap"],
+        "transition_js": trans["transition_js"],
+        "distribution": dist,
+        "within_group": wg,
+        "transitions": trans,
+        "n_records": len(records),
+    }
+
+
+def pairwise_distance_mae(records: list[GenerationRecord]) -> float | None:
+    by_agent: dict[str, dict[str, tuple[str | None, str | None]]] = defaultdict(dict)
+    for record in records:
+        by_agent[record.agent_id][record.variable] = (
+            record.human_answer,
+            record.parsed_answer,
+        )
+    human_d: list[float] = []
+    model_d: list[float] = []
+    for a, b in combinations(sorted(by_agent), 2):
+        shared = sorted(set(by_agent[a]) & set(by_agent[b]))
+        h_dist = 0
+        p_dist = 0
+        dim = 0
+        for var in shared:
+            ha, pa = by_agent[a][var]
+            hb, pb = by_agent[b][var]
+            if None in {ha, pa, hb, pb}:
+                continue
+            dim += 1
+            h_dist += str(ha) != str(hb)
+            p_dist += str(pa) != str(pb)
+        if dim:
+            human_d.append(h_dist / dim)
+            model_d.append(p_dist / dim)
+    if not human_d:
+        return None
+    return float(np.mean(np.abs(np.asarray(human_d) - np.asarray(model_d))))

lifemem/panel.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from random import Random
+
+from lifemem.statements import profile_paragraph, qa_to_statements
+from lifemem.types import (
+    AgentProfile,
+    AgentState,
+    LifeEvent,
+    SurveyOption,
+    SurveyQuestion,
+)
+
+LIKERT = (
+    SurveyOption("1", "Strongly disagree"),
+    SurveyOption("2", "Disagree"),
+    SurveyOption("3", "Neither agree nor disagree"),
+    SurveyOption("4", "Agree"),
+    SurveyOption("5", "Strongly agree"),
+)
+FREQ = (
+    SurveyOption("1", "Never"),
+    SurveyOption("2", "Rarely"),
+    SurveyOption("3", "Sometimes"),
+    SurveyOption("4", "Often"),
+    SurveyOption("5", "Very often"),
+)
+
+EVAL_SPECS: tuple[tuple[str, str, str, tuple[SurveyOption, ...]], ...] = (
+    ("POLINT", "Politics", "You are interested in political affairs.", LIKERT),
+    ("TRUST", "Values", "Most people can be trusted.", LIKERT),
+    ("LIFESAT", "Wellbeing", "You are satisfied with your life as a whole.", LIKERT),
+    ("HLTH", "Health", "In general, your health is excellent.", LIKERT),
+    (
+        "NEIGH",
+        "Housing",
+        "You would like to stay in your current neighbourhood.",
+        LIKERT,
+    ),
+    ("NETUSE", "Media", "The internet is important in your daily life.", LIKERT),
+    ("CIVIC", "Community", "You take part in local groups or volunteering.", LIKERT),
+    ("FINSTR", "Finances", "You have been under financial strain recently.", LIKERT),
+)
+
+EVENT_BANK: tuple[tuple[str, str, str, tuple[str, ...], dict[str, int]], ...] = (
+    (
+        "HLT",
+        "Health",
+        "How often have you had trouble sleeping?",
+        ("health", "sleep"),
+        {"HLTH": -1, "LIFESAT": -1},
+    ),
+    (
+        "JOB",
+        "Work",
+        "Have you been promoted or given more responsibility at work?",
+        ("work", "promotion"),
+        {"FINSTR": -1, "LIFESAT": 1, "POLINT": 1},
+    ),
+    (
+        "UNEMP",
+        "Work",
+        "Have you been unemployed and looking for work?",
+        ("work", "unemployment"),
+        {"FINSTR": 1, "LIFESAT": -1, "TRUST": -1},
+    ),
+    (
+        "SCHOOL",
+        "Education",
+        "Have you enrolled in or completed a new educational programme?",
+        ("school", "education"),
+        {"NETUSE": 1, "POLINT": 1, "NEIGH": -1},
+    ),
+    (
+        "MOVE",
+        "Housing",
+        "Have you moved to a different city or region?",
+        ("housing", "migration"),
+        {"NEIGH": -1, "CIVIC": -1, "NETUSE": 1},
+    ),
+    (
+        "MARRY",
+        "Family",
+        "Have you gotten married or started living with a partner?",
+        ("family", "marriage"),
+        {"LIFESAT": 1, "CIVIC": 1, "NEIGH": 1},
+    ),
+    (
+        "CHILD",
+        "Family",
+        "Has a child been born or joined your household?",
+        ("family", "child"),
+        {"FINSTR": 1, "CIVIC": -1, "LIFESAT": 1},
+    ),
+    (
+        "ILL",
+        "Health",
+        "Has a close family member had a serious illness?",
+        ("family", "illness"),
+        {"HLTH": -1, "TRUST": 1, "CIVIC": 1},
+    ),
+    (
+        "VOL",
+        "Community",
+        "Have you started volunteering or community work?",
+        ("civic", "volunteer"),
+        {"CIVIC": 1, "POLINT": 1, "TRUST": 1},
+    ),
+    (
+        "VOTE",
+        "Politics",
+        "Have you worked on a political campaign or attended a rally?",
+        ("civic", "politics"),
+        {"POLINT": 1, "CIVIC": 1, "TRUST": -1},
+    ),
+    (
+        "HOUSE",
+        "Housing",
+        "Have you bought a home or taken on a housing loan?",
+        ("housing", "home"),
+        {"FINSTR": 1, "NEIGH": 1, "LIFESAT": 1},
+    ),
+    (
+        "HARD",
+        "Finances",
+        "Has your household had trouble paying bills?",
+        ("finance", "hardship"),
+        {"FINSTR": 1, "LIFESAT": -1, "HLTH": -1},
+    ),
+)
+
+SES_MEANS = {
+    "low": (-0.7, -0.4, -0.5, -0.6, -0.2, -0.3, -0.4, 0.8),
+    "middle": (0.0, 0.1, 0.0, 0.1, 0.0, 0.2, 0.1, 0.0),
+    "high": (0.8, 0.5, 0.6, 0.5, 0.3, 0.4, 0.5, -0.7),
+}
+
+WAVES = (
+    (1, 1995, "adolescence"),
+    (2, 1996, "late adolescence"),
+    (3, 2002, "early adulthood"),
+    (4, 2008, "early career"),
+    (5, 2016, "established adulthood"),
+    (6, 2023, "early midlife"),
+)
+
+
+@dataclass
+class Panel:
+    questions: list[SurveyQuestion]
+    agents: list[AgentState]
+    humans: dict[tuple[str, int, str], str]
+    waves: tuple[int, ...]
+    events_by_wave: dict[tuple[str, int], list[LifeEvent]]
+
+
+def _options_for(
+    spec: tuple[str, str, str, tuple[SurveyOption, ...]],
+) -> SurveyQuestion:
+    variable, section, question, options = spec
+    return SurveyQuestion(
+        variable=variable, section=section, question=question, options=options
+    )
+
+
+def _clip_option(value: float, n_options: int) -> str:
+    index = int(round(value))
+    index = max(1, min(n_options, index))
+    return str(index)
+
+
+def build_panel(
+    n_agents: int = 24,
+    n_waves: int = 6,
+    events_per_wave: int = 8,
+    seed: int = 42,
+) -> Panel:
+    rng = Random(seed)
+    questions = [_options_for(spec) for spec in EVAL_SPECS]
+    waves = tuple(wave for wave, _year, _label in WAVES[:n_waves])
+    sexes = ("female", "male")
+    ses_levels = ("low", "middle", "high")
+    educations = ("high school", "some college", "bachelor's degree")
+    religions = ("none", "christian", "other")
+    regions = ("Northeast", "Midwest", "South", "West")
+    occupations = (
+        "student",
+        "service worker",
+        "technician",
+        "professional",
+        "unemployed",
+    )
+    agents: list[AgentState] = []
+    humans: dict[tuple[str, int, str], str] = {}
+    events_by_wave: dict[tuple[str, int], list[LifeEvent]] = {}
+
+    for i in range(n_agents):
+        ses = ses_levels[i % 3]
+        sex = sexes[i % 2]
+        education = educations[i % 3]
+        religion = religions[i % 3]
+        region = regions[i % 4]
+        occupation = occupations[i % 5]
+        birth_year = 1978 + (i % 7)
+        mean = SES_MEANS[ses]
+        offset = tuple(rng.gauss(0.0, 1.05) for _ in questions)
+        latent = tuple(m + o for m, o in zip(mean, offset, strict=True))
+        fields = {
+            "sex": sex,
+            "ses": ses,
+            "education": education,
+            "religion": religion,
+            "region": region,
+            "birth_year": str(birth_year),
+            "occupation": occupation,
+        }
+        profile = AgentProfile(
+            agent_id=f"A{i:03d}",
+            sex=sex,
+            ses=ses,
+            education=education,
+            religion=religion,
+            region=region,
+            birth_year=birth_year,
+            occupation=occupation,
+            latent=latent,
+            profile_text=profile_paragraph(fields),
+        )
+        agent = AgentState(profile=profile)
+        running = list(latent)
+        for wave_idx, wave in enumerate(waves):
+            chosen = rng.sample(EVENT_BANK, k=min(events_per_wave, len(EVENT_BANK)))
+            wave_events: list[LifeEvent] = []
+            for event_idx, (code, section, question, tags, deltas) in enumerate(chosen):
+                intensity = rng.choice([2, 3, 4, 5])
+                sign = 1 if intensity >= 3 else -1
+                for variable, delta in deltas.items():
+                    q_pos = next(
+                        j for j, q in enumerate(questions) if q.variable == variable
+                    )
+                    running[q_pos] += 0.22 * sign * delta
+                answer_code = str(intensity)
+                answer_text = FREQ[intensity - 1].text
+                second, first = qa_to_statements(question, answer_text)
+                event = LifeEvent(
+                    event_id=f"{profile.agent_id}-w{wave}-{code}-{event_idx}",
+                    agent_id=profile.agent_id,
+                    wave=wave,
+                    section=section,
+                    question=question,
+                    answer_code=answer_code,
+                    answer_text=answer_text,
+                    statement=second,
+                    first_person=first,
+                    tags=tags,
+                )
+                wave_events.append(event)
+            events_by_wave[(profile.agent_id, wave)] = wave_events
+            for q_idx, question in enumerate(questions):
+                noise = rng.gauss(0.0, 0.35)
+                humans[(profile.agent_id, wave, question.variable)] = _clip_option(
+                    3 + running[q_idx] + 0.08 * wave_idx + noise,
+                    len(question.options),
+                )
+        agents.append(agent)
+
+    return Panel(
+        questions=questions,
+        agents=agents,
+        humans=humans,
+        waves=waves,
+        events_by_wave=events_by_wave,
+    )
+
+
+def panel_to_dict(panel: Panel) -> dict:
+    return {
+        "waves": list(panel.waves),
+        "questions": [
+            {
+                "variable": q.variable,
+                "section": q.section,
+                "question": q.question,
+                "options": [{"code": o.code, "text": o.text} for o in q.options],
+            }
+            for q in panel.questions
+        ],
+        "agents": [
+            {
+                "agent_id": agent.profile.agent_id,
+                "sex": agent.profile.sex,
+                "ses": agent.profile.ses,
+                "education": agent.profile.education,
+                "religion": agent.profile.religion,
+                "region": agent.profile.region,
+                "birth_year": agent.profile.birth_year,
+                "occupation": agent.profile.occupation,
+                "profile_text": agent.profile.profile_text,
+                "latent": list(agent.profile.latent),
+            }
+            for agent in panel.agents
+        ],
+        "events": [
+            {
+                "event_id": event.event_id,
+                "agent_id": event.agent_id,
+                "wave": event.wave,
+                "section": event.section,
+                "question": event.question,
+                "answer_code": event.answer_code,
+                "answer_text": event.answer_text,
+                "statement": event.statement,
+                "first_person": event.first_person,
+                "tags": list(event.tags),
+            }
+            for events in panel.events_by_wave.values()
+            for event in events
+        ],
+        "humans": [
+            {
+                "agent_id": agent_id,
+                "wave": wave,
+                "variable": variable,
+                "answer": answer,
+            }
+            for (agent_id, wave, variable), answer in sorted(panel.humans.items())
+        ],
+    }
+
+
+def save_panel(panel: Panel, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(panel_to_dict(panel), indent=2), encoding="utf-8")

lifemem/parse.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import re
+
+_THINK_BLOCK = re.compile(r"<think>.*?</think>", re.DOTALL | re.IGNORECASE)
+
+
+def strip_thinking(text: str) -> str:
+    """Drop Qwen thinking spans before Likert parsing."""
+    if not text:
+        return ""
+    cleaned = _THINK_BLOCK.sub("", text)
+    marker = "</think>"
+    lower = cleaned.lower()
+    if marker in lower:
+        cleaned = cleaned[lower.rfind(marker) + len(marker) :]
+    return cleaned.strip()
+
+
+def parse_option_code(raw: str, valid_codes: tuple[str, ...]) -> str | None:
+    if not raw:
+        return None
+    text = strip_thinking(raw)
+    if text in valid_codes:
+        return text
+    match = re.search(r"\d+", text)
+    if match and match.group(0) in valid_codes:
+        return match.group(0)
+    lowered = text.lower()
+    for code in valid_codes:
+        if code.lower() == lowered:
+            return code
+    return None

lifemem/prompts.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from lifemem.statements import option_block
+from lifemem.types import AgentState, RetrievedEvent, SurveyQuestion
+
+ROLEPLAY = (
+    "You are not an AI assistant; you are role-playing a human survey respondent. "
+    "Answer as that person."
+)
+ANTI_STEREOTYPE = (
+    "Do not assume that one demographic attribute determines another. "
+    "When information is missing, preserve uncertainty rather than filling it with stereotypes."
+)
+
+
+def _join(*blocks: str) -> str:
+    return "\n\n".join(block for block in blocks if block)
+
+
+def build_direct(question: SurveyQuestion) -> str:
+    return _join(
+        ROLEPLAY,
+        "Simulate one person and answer the following question.",
+        option_block(question),
+    )
+
+
+def build_profile(agent: AgentState, question: SurveyQuestion, extra: str = "") -> str:
+    return _join(
+        ROLEPLAY,
+        "You are answering a longitudinal social survey as the described person.",
+        f"Demographic profile:\n{agent.profile.profile_text}",
+        extra,
+        option_block(question),
+    )
+
+
+def build_anti_stereotype(agent: AgentState, question: SurveyQuestion) -> str:
+    return build_profile(agent, question, extra=ANTI_STEREOTYPE)
+
+
+def build_retrieval(
+    agent: AgentState,
+    question: SurveyQuestion,
+    retrieved: list[RetrievedEvent],
+    include_profile: bool = True,
+) -> str:
+    profile = (
+        agent.profile.profile_text
+        if include_profile
+        else "Profile omitted by ablation."
+    )
+    if retrieved:
+        events = "\n".join(f"- {item.event.statement}" for item in retrieved)
+    else:
+        events = "No relevant life experiences retrieved."
+    return _join(
+        ROLEPLAY,
+        "You are answering a longitudinal social survey as the described person.",
+        f"Demographic profile:\n{profile}",
+        f"Relevant life experiences:\n{events}",
+        option_block(question),
+    )
+
+
+def build_full_history(
+    agent: AgentState,
+    question: SurveyQuestion,
+    max_chars: int,
+) -> str:
+    lines = [f"- {event.statement}" for event in agent.events]
+    kept: list[str] = []
+    total = 0
+    for line in reversed(lines):
+        if total + len(line) > max_chars:
+            continue
+        kept.append(line)
+        total += len(line)
+    event_block = "\n".join(reversed(kept)) if kept else "No life events available."
+    return _join(
+        ROLEPLAY,
+        "You are answering a longitudinal social survey as the described person.",
+        f"Demographic profile:\n{agent.profile.profile_text}",
+        f"Life history:\n{event_block}",
+        option_block(question),
+    )

lifemem/retrieval.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import math
+import re
+import zlib
+
+import numpy as np
+
+from lifemem.types import LifeEvent, RetrievedEvent, SurveyQuestion
+
+
+def recency_weight(event_wave: int, current_wave: int, alpha: float) -> float:
+    if alpha < 0:
+        raise ValueError("forgetting alpha must be non-negative")
+    return float(alpha ** max(current_wave - event_wave, 0))
+
+
+def hashed_ngram_embed(text: str, dim: int = 128, n: int = 3) -> np.ndarray:
+    """Deterministic encoder used when MiniLM/BGE weights are unavailable."""
+
+    tokens = re.findall(r"[a-z0-9]+", text.lower())
+    blob = " ".join(tokens)
+    vec = np.zeros(dim, dtype=np.float64)
+    if len(blob) < n:
+        grams = [blob] if blob else ["_"]
+    else:
+        grams = [blob[i : i + n] for i in range(len(blob) - n + 1)]
+    for gram in grams:
+        index = zlib.crc32(gram.encode("utf-8")) % dim
+        vec[index] += 1.0
+    norm = float(np.linalg.norm(vec))
+    if norm == 0:
+        return vec
+    return vec / norm
+
+
+def cosine(a: np.ndarray, b: np.ndarray) -> float:
+    denom = float(np.linalg.norm(a) * np.linalg.norm(b))
+    if denom == 0:
+        return 0.0
+    value = float(a @ b / denom)
+    if math.isnan(value):
+        return 0.0
+    return value
+
+
+class HashedEventEncoder:
+    def __init__(self, dim: int = 128) -> None:
+        self.dim = dim
+
+    def encode(self, text: str) -> np.ndarray:
+        return hashed_ngram_embed(text, dim=self.dim)
+
+
+def retrieve_events(
+    query: SurveyQuestion,
+    events: list[LifeEvent],
+    current_wave: int,
+    top_k: int,
+    alpha: float,
+    encoder: HashedEventEncoder | None = None,
+) -> list[RetrievedEvent]:
+    if not events:
+        return []
+    encoder = encoder or HashedEventEncoder()
+    query_vec = encoder.encode(query.question)
+    scored: list[RetrievedEvent] = []
+    for event in events:
+        sim = cosine(query_vec, encoder.encode(event.retrieval_text()))
+        recency = recency_weight(event.wave, current_wave, alpha)
+        scored.append(
+            RetrievedEvent(
+                event=event,
+                semantic_similarity=sim,
+                recency_weight=recency,
+                final_score=float(sim * recency),
+            )
+        )
+    scored.sort(key=lambda item: item.final_score, reverse=True)
+    return scored[:top_k]

lifemem/statements.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from lifemem.types import SurveyQuestion
+
+
+def qa_to_statements(question: str, answer_text: str) -> tuple[str, str]:
+    """Rule-based survey-to-statement conversion (paper uses gpt-3.5-turbo-0125)."""
+
+    q = question.strip().rstrip("?")
+    answer = answer_text.strip().rstrip(".")
+    lowered = q[:1].lower() + q[1:] if q else q
+    second = f"You answered '{answer}' to the question '{lowered}'."
+    first = f"I answered '{answer}' to the question '{lowered}'."
+    return second, first
+
+
+def profile_paragraph(fields: dict[str, str]) -> str:
+    sex = fields["sex"]
+    ses = fields["ses"]
+    education = fields["education"]
+    religion = fields["religion"]
+    region = fields["region"]
+    birth_year = fields["birth_year"]
+    occupation = fields["occupation"]
+    return (
+        f"You are {sex}. You were born in {birth_year}. You live in {region}. "
+        f"Your education level is {education}. You work as {occupation}. "
+        f"You identify as {religion}. Your socioeconomic status is {ses}."
+    )
+
+
+def option_block(question: SurveyQuestion) -> str:
+    lines = ["Question:", question.question, "", "Options:"]
+    for option in question.options:
+        lines.append(f"{option.code}: {option.text}")
+    lines.append("")
+    lines.append(
+        "Answer with exactly one option number. Do not provide any explanation."
+    )
+    return "\n".join(lines)

lifemem/types.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class SurveyOption:
+    code: str
+    text: str
+
+
+@dataclass(frozen=True)
+class SurveyQuestion:
+    variable: str
+    section: str
+    question: str
+    options: tuple[SurveyOption, ...]
+    kind: str = "evaluate"
+
+    @property
+    def option_codes(self) -> tuple[str, ...]:
+        return tuple(option.code for option in self.options)
+
+
+@dataclass
+class LifeEvent:
+    event_id: str
+    agent_id: str
+    wave: int
+    section: str
+    question: str
+    answer_code: str
+    answer_text: str
+    statement: str
+    first_person: str
+    tags: tuple[str, ...] = ()
+
+    def retrieval_text(self) -> str:
+        return (
+            f"Wave {self.wave}. Section: {self.section}. "
+            f"Question: {self.question} Answer: {self.answer_text}. "
+            f"Statement: {self.statement}"
+        )
+
+
+@dataclass(frozen=True)
+class RetrievedEvent:
+    event: LifeEvent
+    semantic_similarity: float
+    recency_weight: float
+    final_score: float
+
+
+@dataclass
+class AgentProfile:
+    agent_id: str
+    sex: str
+    ses: str
+    education: str
+    religion: str
+    region: str
+    birth_year: int
+    occupation: str
+    latent: tuple[float, ...]
+    profile_text: str
+
+
+@dataclass
+class AgentState:
+    profile: AgentProfile
+    events: list[LifeEvent] = field(default_factory=list)
+    parametric: dict[str, str] = field(default_factory=dict)
+    adapter_vector: list[float] = field(default_factory=list)
+    adapter_trace: list[list[float]] = field(default_factory=list)
+
+
+@dataclass
+class GenerationRecord:
+    agent_id: str
+    wave: int
+    variable: str
+    human_answer: str
+    parsed_answer: str | None
+    valid_options: tuple[str, ...]
+    method: str
+    identity_groups: dict[str, str]
+    retrieved_event_ids: tuple[str, ...] = ()
+    prompt: str = ""
+    raw_output: str = ""
+    valid: bool = True

pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "autoresearch-mitigating-identity-essentialism-lifemem-2026-09-09"
+version = "0.1.0"
+description = "Replication of LifeMem (arXiv:2608.19621): longitudinal memory for LLM social agents."
+requires-python = ">=3.10"
+dependencies = [
+    "huggingface_hub>=0.30.0",
+    "numpy>=2.0.0",
+]
+
+[project.optional-dependencies]
+llm = [
+    "accelerate>=1.0.0",
+    "boto3>=1.35.0",
+    "peft>=0.17.0",
+    "pillow>=10.0.0",
+    "sentence-transformers>=3.0.0",
+    "torch>=2.6.0",
+    "transformers>=5.0.0",
+]
+
+[tool.uv]
+package = false

scripts/hf_job.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""GPU LifeMem run on Qwen/Qwen3.5-4B. Intended for Hugging Face Jobs.
+
+`hf jobs uv run` only uploads this file, so the job downloads `lifemem/` from
+the source dataset when it is not already on PYTHONPATH.
+"""
+
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "accelerate>=1.0.0",
+#   "boto3>=1.35.0",
+#   "huggingface_hub>=0.30.0",
+#   "numpy>=2.0.0",
+#   "peft>=0.17.0",
+#   "pillow>=10.0.0",
+#   "safetensors>=0.4.0",
+#   "torch>=2.6.0",
+#   "transformers>=5.0.0",
+# ]
+# ///
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def _ensure_package() -> Path:
+    here = Path(__file__).resolve()
+    candidates = [
+        Path(os.environ["LIFEMEM_SRC_MOUNT"])
+        if os.environ.get("LIFEMEM_SRC_MOUNT")
+        else None,
+        here.parents[1] if here.parent.name == "scripts" else here.parent,
+        Path("/src"),
+    ]
+    for local in candidates:
+        if local is None:
+            continue
+        if (local / "lifemem" / "config.py").exists():
+            if str(local) not in sys.path:
+                sys.path.insert(0, str(local))
+            return local
+    from huggingface_hub import snapshot_download
+
+    repo = os.environ.get("LIFEMEM_SRC_REPO", "mtorres98/lifemem-replication-src")
+    snap = Path(
+        snapshot_download(
+            repo_id=repo,
+            repo_type="dataset",
+            token=os.environ.get("HF_TOKEN"),
+        )
+    )
+    if str(snap) not in sys.path:
+        sys.path.insert(0, str(snap))
+    return snap
+
+
+ROOT = _ensure_package()
+
+from huggingface_hub import login
+from lifemem.artifacts import push_json
+from lifemem.config import LifeMemConfig
+from lifemem.experiment import run_suite
+from lifemem.lora_memory import lora_config_dict
+
+
+def _int_env(name: str, default: int) -> int:
+    raw = os.environ.get(name)
+    return int(raw) if raw else default
+
+
+def main() -> None:
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        login(token=token)
+    try:
+        import torch
+    except ImportError as exc:
+        raise SystemExit("torch is required for the GPU backend") from exc
+    if not torch.cuda.is_available():
+        raise SystemExit(
+            "CUDA is required for the Qwen LifeMem job; got CPU-only torch"
+        )
+    print(json.dumps({"cuda": torch.cuda.get_device_name(0), "root": str(ROOT)}))
+    config = LifeMemConfig(
+        model_name=os.environ.get("LIFEMEM_MODEL", "Qwen/Qwen3.5-4B")
+    )
+    n_agents = _int_env("LIFEMEM_N_AGENTS", 8)
+    n_waves = _int_env("LIFEMEM_N_WAVES", 6)
+    events_per_wave = _int_env("LIFEMEM_EVENTS_PER_WAVE", 8)
+    results = run_suite(
+        config,
+        n_agents=n_agents,
+        n_waves=n_waves,
+        events_per_wave=events_per_wave,
+        backend="llm",
+    )
+    results["lora"] = lora_config_dict(config)
+    results["backbone"] = config.model_name
+    results["device"] = torch.cuda.get_device_name(0)
+    out = Path(os.environ.get("LIFEMEM_OUT", "gpu_results.json"))
+    urls = push_json(results, "gpu_results.json", out)
+    print(json.dumps({"urls": urls}, indent=2))
+    print(json.dumps({k: v["kl"] for k, v in results["methods"].items()}, indent=2))
+
+
+if __name__ == "__main__":
+    main()