| """ |
| Does human accuracy improve over the 6 questions each Prolific |
| participant answered? (learning / familiarity effect vs. stagnation) |
| |
| Position (1..6) is derived from timestamp order within each participant. |
| Correctness = consensus_correct from the judged human results. |
| |
| statsmodels is broken against the installed scipy, so the logistic regression |
| and its cluster-robust (by participant) standard errors are implemented by hand |
| via IRLS + a sandwich estimator. |
| """ |
| import json |
| import os |
| import numpy as np |
| import pandas as pd |
| from scipy import stats |
|
|
| |
| ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..") |
| base = json.load(open(os.path.join(ROOT, "data/occlusion_prolific_human_baseline.json"))) |
| judged = json.load(open(os.path.join(ROOT, "data/eval_results_human/human_prolific_judged_results.json"))) |
|
|
| ts = {(r["prolific_pid"], r["image_id"]): r["timestamp"] for r in base} |
|
|
| rows = [] |
| for r in judged: |
| key = (r["prolific_pid"], r["image_id"]) |
| if key not in ts or r.get("consensus_correct") is None: |
| continue |
| rows.append({ |
| "pid": r["prolific_pid"], |
| "image_id": r["image_id"], |
| "timestamp": ts[key], |
| "correct": int(bool(r["consensus_correct"])), |
| "rt_ms": r.get("response_time_ms"), |
| }) |
|
|
| df = pd.DataFrame(rows) |
| df["timestamp"] = pd.to_datetime(df["timestamp"]) |
| df = df.sort_values(["pid", "timestamp"]) |
| df["position"] = df.groupby("pid").cumcount() + 1 |
| df = df[df["position"] <= 6] |
|
|
| print(f"Joined responses: {len(df)} | participants: {df['pid'].nunique()}") |
|
|
| |
| print("\n=== Accuracy by question position ===") |
| g = df.groupby("position")["correct"].agg(["mean", "sum", "count"]) |
| g["se"] = np.sqrt(g["mean"] * (1 - g["mean"]) / g["count"]) |
| for pos, row in g.iterrows(): |
| lo = row["mean"] - 1.96 * row["se"] |
| hi = row["mean"] + 1.96 * row["se"] |
| print(f" Q{pos}: acc={row['mean']:.3f} ({int(row['sum'])}/{int(row['count'])}) " |
| f"95% CI [{lo:.3f}, {hi:.3f}]") |
|
|
| |
| print("\n=== Test 1: Linear trend across positions ===") |
| r_pb, p_pb = stats.pointbiserialr(df["correct"], df["position"]) |
| print(f" Point-biserial r(correct, position) = {r_pb:.4f}, p = {p_pb:.4f}") |
|
|
| counts = df.groupby("position")["correct"].agg(["sum", "count"]) |
| n_i = counts["count"].values.astype(float) |
| x_i = counts.index.values.astype(float) |
| p1_i = counts["sum"].values.astype(float) |
| N = n_i.sum(); R = p1_i.sum(); pbar = R / N |
| xbar = (n_i * x_i).sum() / N |
| num = ((p1_i - n_i * pbar) * (x_i - xbar)).sum() |
| den = pbar * (1 - pbar) * (n_i * (x_i - xbar) ** 2).sum() |
| z_ca = num / np.sqrt(den) |
| p_ca = 2 * (1 - stats.norm.cdf(abs(z_ca))) |
| print(f" Cochran-Armitage trend: z = {z_ca:.3f}, p = {p_ca:.4f}") |
|
|
| |
| def two_prop_z(s1, n1, s2, n2): |
| p1, p2 = s1 / n1, s2 / n2 |
| pp = (s1 + s2) / (n1 + n2) |
| se = np.sqrt(pp * (1 - pp) * (1 / n1 + 1 / n2)) |
| z = (p1 - p2) / se |
| return z, 2 * (1 - stats.norm.cdf(abs(z))) |
| z16, p16 = two_prop_z(counts.loc[1, "sum"], counts.loc[1, "count"], |
| counts.loc[6, "sum"], counts.loc[6, "count"]) |
| print(f" Q1 vs Q6 two-proportion z = {z16:.3f}, p = {p16:.4f} " |
| f"(Q1={g.loc[1,'mean']:.3f} vs Q6={g.loc[6,'mean']:.3f})") |
|
|
| |
| print("\n=== Test 2: Logistic correct ~ position (cluster-robust SE by pid) ===") |
| def logit_irls(X, y, iters=100, tol=1e-10): |
| beta = np.zeros(X.shape[1]) |
| for _ in range(iters): |
| eta = X @ beta |
| mu = 1 / (1 + np.exp(-eta)) |
| W = mu * (1 - mu) |
| WX = X * W[:, None] |
| H = X.T @ WX |
| grad = X.T @ (y - mu) |
| step = np.linalg.solve(H, grad) |
| beta += step |
| if np.max(np.abs(step)) < tol: |
| break |
| return beta, mu |
|
|
| y = df["correct"].values.astype(float) |
| X = np.column_stack([np.ones(len(df)), df["position"].values.astype(float)]) |
| beta, mu = logit_irls(X, y) |
|
|
| |
| W = mu * (1 - mu) |
| bread = np.linalg.inv((X * W[:, None]).T @ X) |
| u = X * (y - mu)[:, None] |
| meat = np.zeros((X.shape[1], X.shape[1])) |
| pid_arr = df["pid"].values |
| for pid in np.unique(pid_arr): |
| idx = pid_arr == pid |
| ug = u[idx].sum(axis=0) |
| meat += np.outer(ug, ug) |
| cov = bread @ meat @ bread |
| se = np.sqrt(np.diag(cov)) |
| z = beta / se |
| pvals = 2 * (1 - stats.norm.cdf(np.abs(z))) |
| print(f" intercept: coef={beta[0]:.4f} se={se[0]:.4f}") |
| print(f" position : coef={beta[1]:.4f} se={se[1]:.4f} OR={np.exp(beta[1]):.4f} " |
| f"z={z[1]:.3f} p={pvals[1]:.4f}") |
| print(f" -> OR>1 = improvement over questions; OR≈1 & p>.05 = stagnation") |
|
|
| |
| print("\n=== Secondary: response time by position (speed-up = familiarity) ===") |
| rtdf = df.dropna(subset=["rt_ms"]) |
| for pos, v in rtdf.groupby("position")["rt_ms"].median().items(): |
| print(f" Q{pos}: median RT = {v/1000:.1f}s") |
| r_rt, p_rt = stats.spearmanr(rtdf["position"], rtdf["rt_ms"]) |
| print(f" Spearman(position, RT) = {r_rt:.4f}, p = {p_rt:.4g}") |
|
|
