Download code/population/_coupling.py from chiron-group/chiron-data: direct link, hf CLI and curl.
- Browser
- Download file 11.6 kB
-
https://huggingface.co/datasets/chiron-group/chiron-data/resolve/main/code/population/_coupling.py
- Command line
-
hf download hf://datasets/chiron-group/chiron-data/code/population/_coupling.py
-
curl -L -o _coupling.py https://huggingface.co/datasets/chiron-group/chiron-data/resolve/main/code/population/_coupling.py
11.6 kB
| """Pure joint-response coupling and recorded semantic corrections. | |
| Shared empirical ranks are a model prior, not recovered human correlations. | |
| All indices are zero based; answer option IDs are one based. Inputs are never | |
| modified, and this module performs no file or network access. | |
| """ | |
| from __future__ import annotations | |
| import copy | |
| import json | |
| import re | |
| import numpy as np | |
| from scipy.optimize import linear_sum_assignment | |
| from scipy.spatial.distance import cdist | |
| from scipy.stats import rankdata | |
| def components(inp): | |
| """Keep items used by one canonical statistic in an indivisible group.""" | |
| n = len(inp["prompts"][0]["questions"]) | |
| parent = list(range(n)) | |
| used = set() | |
| def root(i): | |
| while parent[i] != i: | |
| parent[i] = parent[parent[i]] | |
| i = parent[i] | |
| return i | |
| def join(items): | |
| items = sorted(set(items)) | |
| assert all(0 <= j < n for j in items) | |
| used.update(items) | |
| for j in items[1:]: | |
| parent[root(j)] = root(items[0]) | |
| for effect in inp["effects"]: | |
| metadata = {"identifiability": effect["identifiability"], | |
| "statistic_spec": effect["statistic_spec"]} | |
| join([int(s) - 1 for s in re.findall(r"item_(\d+)", json.dumps(metadata))]) | |
| for block in inp["blocks"]: | |
| join([j for j, _ in block]) | |
| join(inp["categorical"]) | |
| groups = {} | |
| for j in sorted(used): | |
| groups.setdefault(root(j), []).append(j) | |
| free = sorted(set(range(n)) - used) | |
| return sorted(groups.values(), key=lambda x: x[0]), free | |
| def rank_matrix(a): | |
| return rankdata(a, axis=0, method="average") / (len(a) + 1.) | |
| def joint_diagnostic(a, reference, groups, free): | |
| blocks = groups + ([free] if free else []) | |
| owner = {j: k for k, block in enumerate(blocks) for j in block} | |
| with np.errstate(divide="ignore", invalid="ignore"): | |
| ca = np.atleast_2d(np.corrcoef(rank_matrix(a), rowvar=False)) | |
| cr = np.atleast_2d(np.corrcoef(rank_matrix(reference), rowvar=False)) | |
| diffs = [] | |
| inversions = 0 | |
| for i in range(a.shape[1]): | |
| for j in range(i): | |
| if owner[i] == owner[j]: | |
| continue | |
| if np.isfinite(ca[i, j]) and np.isfinite(cr[i, j]): | |
| diffs.append(abs(float(ca[i, j] - cr[i, j]))) | |
| inversions += ca[i, j] * cr[i, j] < 0 and min(abs(ca[i, j]), abs(cr[i, j])) > .1 | |
| return {"between_component_rank_correlation_MAE": float(np.mean(diffs)) if diffs else None, | |
| "correlation_pairs": len(diffs), | |
| "opposite_sign_pairs_above_0_1": int(inversions), | |
| "unique_joint_vectors": len(np.unique(a, axis=0)), | |
| "constant_items": int((np.std(a, axis=0) == 0).sum())} | |
| def couple(prompt, a, initial, groups, free, rng): | |
| """Transport whole fitted components to a shared initial-model rank prior.""" | |
| n, _ = a.shape | |
| assert initial.shape == a.shape | |
| proposals = [] | |
| for _ in range(4): | |
| out = initial.copy() | |
| permutations = [] | |
| cost = 0. | |
| for block in groups: | |
| if len(groups) == 1 and not free: | |
| ix = np.arange(n) | |
| else: | |
| target = rank_matrix(initial[:, block]) | |
| donors = rank_matrix(a[:, block]) | |
| distances = cdist(target, donors, "sqeuclidean") / len(block) | |
| _, ix = linear_sum_assignment(distances + rng.uniform(0, 1e-10, distances.shape)) | |
| cost += float(distances[np.arange(n), ix].mean()) | |
| out[:, block] = a[ix][:, block] | |
| permutations.append(ix) | |
| assert sorted(map(tuple, out[:, block])) == sorted(map(tuple, a[:, block])) | |
| assert not free or np.array_equal(out[:, free], initial[:, free]) | |
| diag = joint_diagnostic(out, initial, groups, free) | |
| score = diag["between_component_rank_correlation_MAE"] | |
| proposals.append((float(score) if score is not None else 0., cost, out, permutations, diag)) | |
| _, _, out, permutations, after = min(proposals, key=lambda x: x[:2]) | |
| before = joint_diagnostic(a, initial, groups, free) | |
| retained = False | |
| if (not free and before["between_component_rank_correlation_MAE"] is not None | |
| and after["between_component_rank_correlation_MAE"] | |
| > before["between_component_rank_correlation_MAE"] + 1e-10): | |
| out = a.copy() | |
| permutations = [np.arange(n) for _ in groups] | |
| retained = True | |
| result = {key: copy.deepcopy(prompt[key]) for key in | |
| ("study_id", "condition_key", "condition_id", "original_n", "questions", "messages")} | |
| result["respondents"] = out.tolist() | |
| result["protected_components"] = copy.deepcopy(groups) | |
| result["free_items"] = list(free) | |
| result["retained_coupling"] = retained | |
| result["respondent_provenance"] = [] | |
| for i in range(n): | |
| parts = [{"items": list(block), "source": "fitted", | |
| "condition_key": prompt["condition_key"], "respondent_index": int(ix[i])} | |
| for block, ix in zip(groups, permutations)] | |
| if free: | |
| parts.append({"items": list(free), "source": "initial", | |
| "condition_key": prompt["condition_key"], "respondent_index": i}) | |
| result["respondent_provenance"].append({"components": parts}) | |
| return result | |
| def balance_audience(populations): | |
| """Preserve pooled response vectors and n; audience balance is a prior.""" | |
| by = {q["condition_id"]: q for q in populations} | |
| rng = np.random.default_rng(20260908) | |
| for left, right in [("A", "B"), ("C", "D"), ("E", "F")]: | |
| p, q = by[left], by[right] | |
| n1, n2 = p["original_n"], q["original_n"] | |
| x, y = np.array(p["respondents"]), np.array(q["respondents"]) | |
| x[:, 0] = 4 - x[:, 0] | |
| y[:, 0] = y[:, 0] - 4 | |
| pool = np.concatenate([x, y]) | |
| provenance = p["respondent_provenance"] + q["respondent_provenance"] | |
| features = np.column_stack([pool, pool ** 2]).astype(float) | |
| features /= np.maximum(features.std(0), 1.) | |
| target = features.sum(0) * n1 / (n1 + n2) | |
| best = np.arange(n1 + n2) | |
| best_cost = float("inf") | |
| for _ in range(1000): | |
| ix = rng.permutation(n1 + n2) | |
| err = features[ix[:n1]].sum(0) - target | |
| cost = float(err @ err) | |
| if cost < best_cost: | |
| best, best_cost = ix, cost | |
| err = features[best[:n1]].sum(0) - target | |
| for _ in range(20000): | |
| i = int(rng.integers(n1)) | |
| j = int(rng.integers(n1, n1 + n2)) | |
| trial = err - features[best[i]] + features[best[j]] | |
| cost = float(trial @ trial) | |
| if cost < best_cost - 1e-12: | |
| best[i], best[j] = best[j], best[i] | |
| err = trial | |
| best_cost = cost | |
| a = pool[best[:n1]].copy() | |
| b = pool[best[n1:]].copy() | |
| assert sorted(map(tuple, pool)) == sorted(map(tuple, np.concatenate([a, b]))) | |
| a[:, 0] = 4 - a[:, 0] | |
| b[:, 0] = b[:, 0] + 4 | |
| for dest, values, indices in [(p, a, best[:n1]), (q, b, best[n1:])]: | |
| dest["respondents"] = values.tolist() | |
| new_provenance = [] | |
| for ix in indices: | |
| pr = copy.deepcopy(provenance[int(ix)]) | |
| source_condition = left if ix < n1 else right | |
| pr["audience_reassignment"] = { | |
| "from_condition": source_condition, "to_condition": dest["condition_id"], | |
| "recoded_item": 0, | |
| "option_mapping": "8-option_id" if source_condition != dest["condition_id"] else "identity"} | |
| new_provenance.append(pr) | |
| dest["respondent_provenance"] = new_provenance | |
| def repair_prompts(populations, policy): | |
| """Apply recorded wording corrections supplied with the study inputs.""" | |
| for row in populations: | |
| for edit in policy["wording_corrections"]: | |
| selectors = {key: edit[key] for key in ("condition_key", "study_id") if key in edit} | |
| if not selectors: | |
| raise ValueError("A wording correction must identify its study or condition") | |
| if any(row[key] != value for key, value in selectors.items()): | |
| continue | |
| text = row["messages"][1]["content"] | |
| if edit["only_if_present"] and edit["match"] not in text: | |
| continue | |
| assert text.count(edit["match"]) == 1 | |
| assert all(fragment in text for fragment in edit["required"]) | |
| row["messages"][1]["content"] = text.replace(edit["before"], edit["after"]) | |
| def semantic_rules(populations, free_items, policy): | |
| """Correct only explicitly specified free-item facts, not human frequencies.""" | |
| for q in populations: | |
| key = q["condition_key"] | |
| for edit in policy["prompt_edits"]: | |
| if edit["condition_key"] != key: | |
| continue | |
| text = q["messages"][1]["content"] | |
| assert text.count(edit["before"]) == 1, (key, "stimulus source changed") | |
| q["messages"][1]["content"] = text.replace(edit["before"], edit["after"]) | |
| for rule in policy["facts"]: | |
| if rule["condition_key"] != key: | |
| continue | |
| j, value = rule["item_index"], rule["expected_option_id"] | |
| assert j in free_items, (key, j, "cannot alter canonical dependency") | |
| assert rule["question"] in q["messages"][1]["content"] | |
| assert q["questions"][j]["options"][value - 1]["text"] == rule["expected_option_text"] | |
| for answer, lineage in zip(q["respondents"], q["respondent_provenance"]): | |
| if answer[j] == value: | |
| continue | |
| lineage.setdefault("semantic_overrides", []).append({ | |
| "rule_id": rule["rule_id"], "item_index": j, | |
| "before_option_id": answer[j], "after_option_id": value}) | |
| answer[j] = value | |
| q["semantic_rules"] = [r["rule_id"] for r in policy["facts"] if r["condition_key"] == key] | |
| def finalize_study(inp, respondents, recipe, policy): | |
| """Finalize fitted responses without reading saved final populations. | |
| Preserve prompt order and the shared per-study RNG stream. The caller | |
| supplies integer option matrices after construct/moment transformations. | |
| """ | |
| groups, free = components(inp) | |
| rng = np.random.default_rng(int(recipe["transport_seed"])) | |
| expected_keys = {q["condition_key"] for q in inp["prompts"]} | |
| assert len(expected_keys) == len(inp["prompts"]) | |
| assert set(respondents) == expected_keys | |
| populations = [] | |
| for prompt in inp["prompts"]: | |
| assert prompt["study_id"] == inp["study"] | |
| key = prompt["condition_key"] | |
| a = np.array(respondents[key], dtype=int) | |
| assert np.array_equal(a, np.asarray(respondents[key])) | |
| assert a.shape == (prompt["original_n"], len(prompt["questions"])) | |
| initial = np.array(inp["sources"]["Chiron"][key], dtype=int) | |
| populations.append(couple(prompt, a, initial, groups, free, rng)) | |
| if inp["study"] == "JEP_1_6b": | |
| balance_audience(populations) | |
| repair_prompts(populations, policy) | |
| semantic_rules(populations, free, policy) | |
| for q in populations: | |
| a = np.array(q["respondents"]) | |
| assert a.shape == (q["original_n"], len(q["questions"])) | |
| assert all(1 <= int(value) <= len(q["questions"][j]["options"]) | |
| for row in a for j, value in enumerate(row)) | |
| assert len(q["respondent_provenance"]) == q["original_n"] | |
| return populations | |