Blame for README.md

# divsim: Reproducibility Bundle

**Paper:** *Disentangling Models from Personas in LLM Social Simulations*
Dani Roytburg & Daphne Ippolito, Carnegie Mellon University.

This bundle reproduces the experiments in the paper: the 5-model dyadic and triadic
sweeps, the four-way (tetradic) sweep, and the lexical/content analyses. Engagement is
analyzed as **comments per post** (CPP = in-degree / posts), which removes the
posting-volume confound. The simulations run on top of OASIS (Open Agent Social
Interaction Simulations), adapted with heterogeneous model support.

---

## Hardware assumptions

| Component | Spec |
|-----------|------|
| GPUs | 8 × NVIDIA L40S 48 GB |
| System RAM | ≥ 128 GB |
| CPU cores | ≥ 32 |
| Storage | ≥ 200 GB free (model weights + DBs) |

All five models run concurrently on a single 8-GPU node. Dyadic runs need any
two models active; triadic runs need any three. The sbatch templates in
`launch/` target this configuration.

---

## Models

| Short name | HuggingFace ID | GPU assignment | Notes |
|-----------|----------------|----------------|-------|
| Qwen | `Qwen/Qwen3-32B` | GPUs 0-1 (TP=2) | thinking disabled via chat-template |
| gpt-oss | `openai/gpt-oss-20b` | GPU 2 (TP=1, mxfp4) | reasoning parser enabled |
| Mag | `mistralai/Magistral-Small-2509` | GPUs 3-4 (TP=2) | mistral tokenizer/loader mode |
| GLM-4 | `zai-org/GLM-4-32B-0414` | GPUs 5-6 (TP=2) | hermes tool parser |
| Gemma | `google/gemma-4-31B-it` | GPUs 3-4 (TP=2) | custom jinja template required |

Note: Gemma shares GPUs 3-4 with Magistral. They cannot run simultaneously on
a single 8-GPU node. For triadic runs involving both, use two separate nodes or
run the Gemma-containing triplets in a separate job.

---

## Quick start

### 1. Environment setup

```bash
git clone https://github.com/camel-ai/oasis.git  # or use bundled oasis/
cd divsim_publish
python -m venv .venv && source .venv/bin/activate
pip install -r env/requirements.txt
```

Set these environment variables before running:

```bash
export HF_HUB_CACHE=/path/to/hf_cache/hub          # HuggingFace model cache
export SAFEMASS_VENV=$(pwd)/.venv                   # or path to your venv
export RUNS_DIR=/path/to/output/runs                # where DBs will be written
export SEED_DB=$(pwd)/oasis/seed_db/hf-zero-50.sqlite
export LOGS_DIR=/path/to/logs
```

### 2. Download models

```bash
python -c "
from huggingface_hub import snapshot_download
import os
os.environ['HF_HUB_CACHE'] = os.environ['HF_HUB_CACHE']
for m in [
    'Qwen/Qwen3-32B',
    'openai/gpt-oss-20b',
    'mistralai/Magistral-Small-2509',
    'zai-org/GLM-4-32B-0414',
    'google/gemma-4-31B-it',
]:
    print(f'Downloading {m}...')
    snapshot_download(m)
    print(f'  done.')
"
```

### 3. Start vLLM servers

Launch each model server in a separate terminal (or as background processes):

```bash
# For a 4-model (non-Gemma) run:
bash launch/vllm_qwen.sh &
bash launch/vllm_gpt_oss.sh &
bash launch/vllm_magistral.sh &
bash launch/vllm_glm4.sh &

# For Gemma runs (requires GPUs 3-4 to be free — stop Magistral first):
bash launch/vllm_gemma.sh &
```

Wait for all target servers to respond at their health endpoints before
proceeding. The sweep scripts perform a pre-flight health check.

### 4. Run the dyadic sweep

```bash
source .venv/bin/activate
python sweep/sweep_dyadic.py --mode 2model --max-parallel 2
```

Optional: `--dry-run` to print all configs without launching.

### 5. Run the triadic sweep

```bash
python sweep/sweep_triadic.py --max-parallel 2
```

### 5b. Run the four-way (tetradic) sweep

Serves all four of {gpt-oss, Qwen, Magistral, GLM-4} concurrently and runs the
2-seed x 12-rotation four-way sweep (`run_v9 --mode hetero4`, 40 agents):

```bash
SAFEMASS_VENV=... OASIS_VENV=... HF_HUB_CACHE=... RUNS_DIR=... bash launch/run_tetradic.sh
```

Resume-safe: completed DBs are skipped, partial ones resume. Outputs land in `$RUNS_DIR/tetradic/`.

### 6. Analyses and figures

Scripts read run DBs from `./runs` (symlink or point at `$RUNS_DIR`), the text corpus
from `./data/texts.jsonl`, and write outputs to `./out/`. Build the corpus once:

```bash
python analyses/extract_texts.py                 # -> data/texts.jsonl (posts+comments by model,persona)
```

Engagement / network structure (Findings 1-2):
```bash
python analyses/plot_fig_variance_overview.py    # Fig: CPP variance (model vs persona) + per-model H by mixture size
python analyses/variance_cpp.py                  # CPP variance decomposition + leave-one-model-out
python analyses/swap_cpp.py                       # gpt-oss->Magistral matched-swap CPP effect
python analyses/engagement_ceiling.py            # how well text predicts per-post engagement (ceiling)
python analyses/cv_and_length.py                 # held-out CV R^2 + length-controlled attractor (Appendix D)
python analyses/absolute_variance.py             # variance components, all regimes
python analyses/temporal_dynamics.py             # temporal H decay by quartile
python analyses/tetradic_recompute_H.py          # four-way per-model H over the 24 runs
python analyses/tetradic_results.py              # four-way H matrix + heatmap figure
python analyses/plot_matrices.py                 # H-matrix heatmaps (dyadic/triadic)
```

Content (Finding 3):
```bash
python analyses/lexical_table.py                 # model/persona classifier from TF-IDF (Table 1)
python analyses/persona_faithfulness.py          # persona recoverability from text (faithfulness)
python analyses/distinctive_words.py             # characteristic phrases per model (log-odds)
python analyses/svd_axes.py                      # SVD style axes + top terms
python analyses/content_engagement.py            # content -> CPP decomposition (length/style/model/persona)
python analyses/style_geometry.py                # model style directions, stability, engagement-direction cosines
python analyses/cluster_model_persona.py         # does style cluster by model vs persona (permutation-adjusted)
python analyses/length_regimes.py                # length/volume confound checks by regime
```

### 7. Smoke test (no GPUs required for the assertion; short GPU run for the full test)

```bash
# Assert-only (uses an existing DB):
python smoke_test/assert_h_matrix.py --db <path/to/sweep_*.db>

# Full end-to-end smoke (requires 2 live vLLM servers, ~5 min on 2 GPUs):
bash smoke_test/run_smoke.sh
```

---

## Expected runtime

| Experiment | Steps | Agents | Time estimate (8× L40S) |
|-----------|-------|--------|------------------------|
| Single dyadic run | 100 | 20 | ~25–45 min |
| Full dyadic sweep (10 pairs × 2 orderings × 5 seeds) | 100 | 20 | ~50–150 GPU-hours |
| Single triadic run | 100 | 30 | ~35–60 min |
| Full triadic sweep (10 triplets × 3 orderings × 3 seeds) | 100 | 30 | ~35–90 GPU-hours |
| Single four-way run | 100 | 40 | ~60–90 min |
| Full four-way sweep (2 seeds × 12 rotations) | 100 | 40 | ~50–70 GPU-hours |

---

## Data

Reference data (SQLite databases, one per run) are listed in `data/MANIFEST.md`
with SHA-256 checksums and sizes. The canonical data lives at:

```
$RUNS_DIR/sweep_*.db
```

The manifest records all valid runs used in the paper (dyadic, triadic, and four-way),
including the four-way DBs under `$RUNS_DIR/tetradic/`. The content analyses additionally
use a text corpus (`data/texts.jsonl`) regenerated by `analyses/extract_texts.py`.

### Consolidated dataset (`divdata`)

Every run is also released as one Parquet dataset indexed by `run_id` and `step`
(`anonymousfileupload/divdata` on the Hub): posts, comments, agents, impressions (the feed
each agent saw, with slate position), actions, and **trajectories** — one row per agent
activation including passive ones, with the tool call the model emitted, its stated
deliberation / reasoning where the family exposes one, and wall-clock timestamps. The two
scripts that build it from the run databases are in `data/`:

```bash
export OASIS_ROOT=/path/containing/runs        # directory that holds runs/*.db + sidecars
python data/build_divdata.py       --out divdata/                        # 6 core tables
python data/build_trajectories.py  --out divdata/ --workers 16 --patch-steps  # trajectories + step back-fill
```

`step` is not stored by the simulator; both scripts reconstruct it from the per-run chat
sidecar and document exactly where the alignment is exact and where it is left NULL. See
the dataset's `README.md` and `BUILD_LOG.md` for the details and for the 2026-09-09 erratum.

---

## Repository layout

```
divsim_publish/
├── README.md                    # this file
├── LICENSE                      # MIT
├── env/
│   ├── requirements.txt         # pinned Python dependencies
│   └── vllm_version.md          # vLLM 0.19.0 per-model launch notes
├── oasis/
│   ├── run_v9.py                # simulation runner
│   ├── seed_db/hf-zero-50.sqlite
│   └── tool_chat_template_gemma4.jinja
├── launch/
│   ├── vllm_qwen.sh / vllm_gpt_oss.sh / vllm_magistral.sh / vllm_glm4.sh / vllm_gemma.sh
│   └── run_tetradic.sh          # four-way sweep driver (serves 4 models, 2 seeds x 12 rotations)
├── sweep/
│   ├── sweep_dyadic.py          # combinatorial 2-model sweep (5-model subset)
│   └── sweep_triadic.py         # preemption-safe 3-model sweep
├── analyses/
│   ├── variance_cpp.py              # CPP variance decomposition + leave-one-model-out
│   ├── absolute_variance.py         # variance components across regimes
│   ├── plot_fig_variance_overview.py# Fig: CPP variance + per-model H by mixture size
│   ├── temporal_dynamics.py         # temporal H decay analysis
│   ├── tetradic_recompute_H.py / tetradic_results.py  # four-way H + heatmap
│   ├── plot_matrices.py / plot_fig1_network.py / housestyle.py  # figures
│   ├── extract_texts.py             # build data/texts.jsonl corpus
│   ├── lexical_table.py             # model/persona classifier (Table 1)
│   ├── svd_axes.py                  # SVD style axes + top terms
│   ├── content_engagement.py        # content -> CPP decomposition
│   ├── style_geometry.py            # style directions + engagement-direction cosines
│   └── cluster_model_persona.py / length_regimes.py  # supporting checks
├── data/
│   ├── MANIFEST.md              # DB paths, SHA-256, size, (pair/triplet, seed) labels
│   ├── build_divdata.py         # run DBs -> divdata Parquet (runs/agents/posts/comments/impressions/actions)
│   └── build_trajectories.py    # + trajectories.parquet (every activation, passive included) and step back-fill
├── smoke_test/
│   ├── run_smoke.sh             # short dyad smoke run (20 steps, 2 agents/family)
│   └── assert_h_matrix.py       # assert H matrix computable + basic sanity checks
└── docs/
    └── EXPERIMENT_PROTOCOL.md   # canonical reproducibility narrative
```