code/benchmark_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cell_000",
   "metadata": {},
   "source": [
    "# Voice Identity Perception Benchmark\n",
    "\n",
    "## Abstract\n",
    "\n",
    "This notebook accompanies a proposed benchmark for **evaluating speaker-embedding models against human voice-identity perception**. Unlike existing speaker-verification benchmarks (e.g., VoxCeleb) that compare model outputs to ground-truth speaker labels, our benchmark targets the **population-consensus human judgment** of whether two voice clips belong to the same person. We benchmark 10 publicly available speech representation models across five evaluation tasks and report results on 9,800 voice pairs judged by 175 qualified human listeners (92,239 individual judgments).\n",
    "\n",
    "## Dataset\n",
    "\n",
    "- **9,800 voice pairs** across 100 celebrity speakers (50M/50F, 5 sociophonetic groups)\n",
    "- **124,876 total human judgments** (92,239 after preregistered participant filtering)\n",
    "- Six stimulus types: same audio, same speaker/different recording, voice clones, different-speaker pairs, different-speaker clones, and **8,100 continuously interpolated (blended) voices**\n",
    "\n",
    "## Models benchmarked (10 total)\n",
    "\n",
    "**Supervised speaker embeddings (5):** RawNet3, ECAPA-TDNN, TitaNet, Resemblyzer (GE2E), x-vector\n",
    "\n",
    "**Self-supervised speech representations (4):** wav2vec 2.0, HuBERT, WavLM, XLS-R\n",
    "\n",
    "**Weakly-supervised speech representation (1):** Whisper\n",
    "\n",
    "## Notebook Structure\n",
    "\n",
    "### Part I \u2014 Setup (Sections 1-2)\n",
    "- **Section 1**: Dataset description and human-perception reliability\n",
    "- **Section 2**: Model embeddings, cosine similarities, inter-model agreement\n",
    "\n",
    "### Part II \u2014 Core Benchmark Tasks (Sections 3-5)\n",
    "- **Section 3**: Task 1 \u2014 Predict human P(same) [primary regression metric]\n",
    "- **Section 4**: Task 2 \u2014 Human-aligned verification with Platt-calibrated ECE\n",
    "- **Section 5**: Task 3 \u2014 Speaker-level representational similarity (RDM + Mantel test)\n",
    "\n",
    "### Part III \u2014 Stimulus-Level Analyses (Sections 6-7)\n",
    "- **Section 6**: Per-stimulus-type analysis and real\u2192synthetic transfer\n",
    "- **Section 7**: Individual differences and human disagreement prediction\n",
    "\n",
    "### Part IV \u2014 Representation Analyses (Sections 8, 13)\n",
    "- **Section 8**: Mahalanobis metric learning (does per-dimension reweighting help?)\n",
    "- **Section 13**: SSL layer-wise alignment diagnostic (per-layer curves and layer-selection sensitivity)\n",
    "\n",
    "### Part V \u2014 Benchmark Validation (Sections 9-12)\n",
    "- **Section 9**: Pairwise model significance (paired bootstrap + Benjamini-Hochberg FDR correction)\n",
    "- **Section 10**: Individual human baseline (leave-one-out consensus agreement)\n",
    "- **Section 11**: Type-6 ablation (rank stability without blended stimuli)\n",
    "- **Section 12**: Demographic fairness (gender \u00d7 sociophonetic group disparities)\n",
    "\n",
    "### Part VI \u2014 Summary\n",
    "- **Section 14**: Grand comparison table, noise-ceiling normalization, key findings\n",
    "\n",
    "## Key Methodological Notes\n",
    "\n",
    "1. **Two data subsets are reported throughout**: the full dataset (all 1,290 participants) and the preregistered qualified subset (175 participants). Results are nearly identical, validating that noise from low-engagement participants does not distort model comparisons.\n",
    "2. **SSL models' main-benchmark cosine similarities use best-layer selection via nested speaker-level cross-validation** (10 folds, gender-balanced). For each fold, the best transformer layer is chosen on training-fold speakers and applied to held-out test speakers. This follows the SUPERB-style convention (Yang et al., 2021) and is the fair protocol for comparing SSL models to supervised speaker embeddings -- the last (`last_hidden_state`) layer is known to underperform for speaker tasks because masked-prediction and contrastive SSL objectives optimize deeper layers away from speaker identity. Last-layer values are preserved in `{model}_cosim_lastlayer` columns and reported in Section 13 for comparison.\n",
    "3. **Speaker-level cross-validation** is used wherever a learned model is evaluated (Mahalanobis, Platt calibration, layer selection) to prevent speaker leakage.\n",
    "4. **Noise ceiling**: split-half reliability gives $R^2_\\text{ceiling} \\approx 0.69$ (Section 1). The best model reaches ~60% of this ceiling (Section 3); Section 10 shows the gap is driven by individual-listener variability rather than representational inadequacy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "cell_001",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:00.986511Z",
     "iopub.status.busy": "2026-04-22T16:21:00.986208Z",
     "iopub.status.idle": "2026-04-22T16:21:02.819526Z",
     "shell.execute_reply": "2026-04-22T16:21:02.817481Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from scipy import stats\n",
    "from scipy.stats import pearsonr, spearmanr\n",
    "from scipy.optimize import minimize\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "from sklearn.metrics import roc_curve, auc, roc_auc_score, accuracy_score\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import GroupKFold\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from pathlib import Path\n",
    "import pickle\n",
    "import hashlib\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "sns.set_style('white')\n",
    "plt.rcParams['figure.figsize'] = (12, 6)\n",
    "plt.rcParams['font.size'] = 11\n",
    "\n",
    "# Path resolution: assume notebook lives at <RELEASE>/code/benchmark_analysis.ipynb\n",
    "NB_DIR = Path.cwd()\n",
    "RELEASE_DIR = NB_DIR.parent if NB_DIR.name == 'code' else NB_DIR\n",
    "DATA_DIR = RELEASE_DIR / 'data'\n",
    "EMB_DIR = DATA_DIR / 'embeddings'\n",
    "LAYER_EMB_DIR = EMB_DIR / 'layers'\n",
    "# Backwards-compatible aliases used elsewhere in the notebook\n",
    "BASE_DIR = RELEASE_DIR\n",
    "BENCH_DIR = EMB_DIR\n",
    "CACHE_DIR = NB_DIR / 'cache'\n",
    "CACHE_DIR.mkdir(exist_ok=True)\n",
    "\n",
    "# Set CACHE_USE = False to force recomputation of all cached results.\n",
    "# Delete the cache/ folder to invalidate caches if input files change.\n",
    "CACHE_USE = True\n",
    "\n",
    "def cached(cache_key, compute_fn, description=''):\n",
    "    \"\"\"Compute or load a cached result. cache_key is a filename prefix.\"\"\"\n",
    "    cache_file = CACHE_DIR / f'{cache_key}.pkl'\n",
    "    if CACHE_USE and cache_file.exists():\n",
    "        print(f'[cache HIT] {cache_key}{(\": \" + description) if description else \"\"}')\n",
    "        with open(cache_file, 'rb') as f:\n",
    "            return pickle.load(f)\n",
    "    print(f'[cache MISS] {cache_key}{(\": \" + description) if description else \"\"} -- computing')\n",
    "    result = compute_fn()\n",
    "    if CACHE_USE:\n",
    "        with open(cache_file, 'wb') as f:\n",
    "            pickle.dump(result, f)\n",
    "        print(f'[cache SAVED] {cache_key} -> {cache_file.name}')\n",
    "    return result\n",
    "\n",
    "# Preregistered filtering criteria\n",
    "GOLD_TYPES = [1, 2, 4]\n",
    "MIN_GOLD_STIMULI = 25\n",
    "MIN_ACCURACY = 0.60\n",
    "SEED = 42\n",
    "rng = np.random.default_rng(SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "part_I_divider",
   "metadata": {},
   "source": [
    "---\n",
    "# Part I \u2014 Setup\n",
    "\n",
    "This part describes the dataset and loads the 10 models' pre-extracted embeddings. It establishes the human-perception target (P(same)) that all subsequent tasks try to predict, and the inter-model agreement structure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_002",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 1: Dataset Description\n",
    "\n",
    "This section describes the structure of the voice identity perception dataset.\n",
    "\n",
    "**Experiment design:** Participants listened to pairs of voice clips and judged whether the two clips belonged to the same speaker (\"same\") or different speakers (\"different\"). Each pair consists of a fixed reference clip for a given speaker and one of 98 comparison clips. The comparison clips span six stimulus types:\n",
    "\n",
    "| Type | Description | Expected answer | N |\n",
    "|------|-------------|-----------------|---|\n",
    "| 1 | Same audio (identical clip played twice) | Same | 100 |\n",
    "| 2 | Same speaker, different recording | Same | 400 |\n",
    "| 3 | Voice clone of the same speaker | Same | 400 |\n",
    "| 4 | Different speaker, real recording | Different | 400 |\n",
    "| 5 | Different speaker, voice clone | Different | 400 |\n",
    "| 6 | Interpolated/blended voice (continuous mix between two speakers) | Different | 8,100 |\n",
    "\n",
    "**Participant filtering:** Following the preregistered protocol, we define a \"qualified\" subset of participants who completed at least 25 gold-standard trials (Types 1, 2, 4) with at least 60% accuracy. We report results on both the full dataset (all participants) and the qualified subset.\n",
    "\n",
    "**Key quantity: P(same).** For each pair, we compute the proportion of participants who judged the pair as \"same speaker.\" This continuous measure (0 to 1) serves as the primary human perception target throughout the benchmark.\n",
    "\n",
    "**Inter-rater reliability** is assessed via split-half correlation: randomly split participants into two halves, compute P(same) for each half independently, correlate, and apply the Spearman-Brown prophecy formula:\n",
    "\n",
    "$$r_{SB} = \\frac{2 r_{half}}{1 + r_{half}}$$\n",
    "\n",
    "This estimates the reliability of the full-sample P(same) estimates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cell_003",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:02.822471Z",
     "iopub.status.busy": "2026-04-22T16:21:02.822074Z",
     "iopub.status.idle": "2026-04-22T16:21:02.990195Z",
     "shell.execute_reply": "2026-04-22T16:21:02.987571Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total responses: 124,876\n",
      "Unique participants: 1,290\n",
      "Total stimuli (pairs): 9,800\n",
      "Speakers: 100\n"
     ]
    }
   ],
   "source": [
    "# Load raw data\n",
    "responses = pd.read_csv(DATA_DIR / 'participant_responses.csv')\n",
    "stimuli = pd.read_csv(DATA_DIR / 'stimuli.csv')\n",
    "speakers = pd.read_csv(DATA_DIR / 'speakers.csv')\n",
    "\n",
    "print(f'Total responses: {len(responses):,}')\n",
    "print(f'Unique participants: {responses[\"user_id\"].nunique():,}')\n",
    "print(f'Total stimuli (pairs): {len(stimuli):,}')\n",
    "print(f'Speakers: {len(speakers)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cell_004",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:03.037208Z",
     "iopub.status.busy": "2026-04-22T16:21:03.036864Z",
     "iopub.status.idle": "2026-04-22T16:21:03.081239Z",
     "shell.execute_reply": "2026-04-22T16:21:03.079195Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Full dataset:      124,876 responses from 1,290 participants\n",
      "Qualified subset:  92,239 responses from 175 participants (reserved for individual-level baseline only)\n"
     ]
    }
   ],
   "source": [
    "# Participant metadata (computed but NOT used for primary benchmark target).\n",
    "# The preregistered participant filter (>=25 gold trials, >=60% accuracy) is used\n",
    "# ONLY in Section 10's per-listener baseline analysis, where individual-level\n",
    "# accuracy estimates require sufficient trials per participant to be meaningful.\n",
    "# All other analyses use the full 1,290-participant pool and the 124,876-judgment\n",
    "# corpus for their P(same) target.\n",
    "\n",
    "gold_responses = responses[responses['stimuli_type'].isin(GOLD_TYPES)].copy()\n",
    "participant_stats = gold_responses.groupby('user_id').agg(\n",
    "    n_gold=('correct', 'count'),\n",
    "    n_correct=('correct', 'sum')).reset_index()\n",
    "participant_stats['accuracy'] = participant_stats['n_correct'] / participant_stats['n_gold']\n",
    "\n",
    "qualified_ids = participant_stats[\n",
    "    (participant_stats['accuracy'] >= MIN_ACCURACY) &\n",
    "    (participant_stats['n_gold'] >= MIN_GOLD_STIMULI)]['user_id'].values\n",
    "resp_qual = responses[responses['user_id'].isin(qualified_ids)].copy()\n",
    "\n",
    "print(f'Full dataset:      {len(responses):,} responses from {responses[\"user_id\"].nunique():,} participants')\n",
    "print(f'Qualified subset:  {len(resp_qual):,} responses from {len(qualified_ids):,} participants (reserved for individual-level baseline only)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cell_005",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:03.084038Z",
     "iopub.status.busy": "2026-04-22T16:21:03.083779Z",
     "iopub.status.idle": "2026-04-22T16:21:03.129947Z",
     "shell.execute_reply": "2026-04-22T16:21:03.128096Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pairs with full data: 9800\n",
      "Median responses per pair (full): 10\n",
      "Min/max responses per pair: 8 / 92\n"
     ]
    }
   ],
   "source": [
    "# Compute P(same) from ALL 1,290 participants (primary benchmark target)\n",
    "def compute_psame(resp_df, stimuli_df):\n",
    "    agg = resp_df.groupby('stimuli_id').agg(\n",
    "        n_responses=('answer', 'count'),\n",
    "        n_same=('answer', 'sum')\n",
    "    ).reset_index()\n",
    "    agg['p_same'] = agg['n_same'] / agg['n_responses']\n",
    "    merged = stimuli_df[['id', 'stimuli_type', 'reference', 'comparison',\n",
    "                         'voice_clone', 'correct_answer', 'scale']].merge(\n",
    "        agg, left_on='id', right_on='stimuli_id', how='left')\n",
    "    return merged\n",
    "\n",
    "df_full = compute_psame(responses, stimuli)\n",
    "\n",
    "df = stimuli[['id', 'stimuli_type', 'reference', 'comparison',\n",
    "              'voice_clone', 'correct_answer', 'scale']].copy()\n",
    "df['p_same_full'] = df_full.set_index('id')['p_same'].reindex(df['id'].values).values\n",
    "df['n_resp_full'] = df_full.set_index('id')['n_responses'].reindex(df['id'].values).values\n",
    "df['majority_full'] = (df['p_same_full'] > 0.5).astype(int)\n",
    "\n",
    "print(f'Pairs with full data: {df[\"p_same_full\"].notna().sum()}')\n",
    "print(f'Median responses per pair (full): {df[\"n_resp_full\"].median():.0f}')\n",
    "print(f'Min/max responses per pair: {int(df[\"n_resp_full\"].min())} / {int(df[\"n_resp_full\"].max())}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cell_006",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:03.132537Z",
     "iopub.status.busy": "2026-04-22T16:21:03.132274Z",
     "iopub.status.idle": "2026-04-22T16:21:03.160353Z",
     "shell.execute_reply": "2026-04-22T16:21:03.158257Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>count</th>\n",
       "      <th>mean_p_same</th>\n",
       "      <th>std_p_same</th>\n",
       "      <th>mean_n_resp</th>\n",
       "      <th>description</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>stimuli_type</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>100</td>\n",
       "      <td>0.907</td>\n",
       "      <td>0.072</td>\n",
       "      <td>36.760</td>\n",
       "      <td>Same audio (baseline)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>400</td>\n",
       "      <td>0.689</td>\n",
       "      <td>0.191</td>\n",
       "      <td>39.970</td>\n",
       "      <td>Same speaker, diff recording</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>400</td>\n",
       "      <td>0.593</td>\n",
       "      <td>0.227</td>\n",
       "      <td>10.060</td>\n",
       "      <td>Voice clone (same speaker)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>400</td>\n",
       "      <td>0.263</td>\n",
       "      <td>0.169</td>\n",
       "      <td>39.188</td>\n",
       "      <td>Different speaker</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>400</td>\n",
       "      <td>0.274</td>\n",
       "      <td>0.192</td>\n",
       "      <td>10.068</td>\n",
       "      <td>Different speaker clone</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>8100</td>\n",
       "      <td>0.381</td>\n",
       "      <td>0.242</td>\n",
       "      <td>10.060</td>\n",
       "      <td>Interpolated/blended</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              count  mean_p_same  std_p_same  mean_n_resp  \\\n",
       "stimuli_type                                                \n",
       "1               100        0.907       0.072       36.760   \n",
       "2               400        0.689       0.191       39.970   \n",
       "3               400        0.593       0.227       10.060   \n",
       "4               400        0.263       0.169       39.188   \n",
       "5               400        0.274       0.192       10.068   \n",
       "6              8100        0.381       0.242       10.060   \n",
       "\n",
       "                               description  \n",
       "stimuli_type                                \n",
       "1                    Same audio (baseline)  \n",
       "2             Same speaker, diff recording  \n",
       "3               Voice clone (same speaker)  \n",
       "4                        Different speaker  \n",
       "5                  Different speaker clone  \n",
       "6                     Interpolated/blended  "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Stimulus type summary\n",
    "type_labels = {\n",
    "    1: 'Same audio (baseline)',\n",
    "    2: 'Same speaker, diff recording',\n",
    "    3: 'Voice clone (same speaker)',\n",
    "    4: 'Different speaker',\n",
    "    5: 'Different speaker clone',\n",
    "    6: 'Interpolated/blended'\n",
    "}\n",
    "\n",
    "type_summary = df.groupby('stimuli_type').agg(\n",
    "    count=('id', 'count'),\n",
    "    mean_p_same=('p_same_full', 'mean'),\n",
    "    std_p_same=('p_same_full', 'std'),\n",
    "    mean_n_resp=('n_resp_full', 'mean')\n",
    ").round(3)\n",
    "type_summary['description'] = type_summary.index.map(type_labels)\n",
    "type_summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cell_007",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:03.163410Z",
     "iopub.status.busy": "2026-04-22T16:21:03.163144Z",
     "iopub.status.idle": "2026-04-22T16:21:03.185447Z",
     "shell.execute_reply": "2026-04-22T16:21:03.183530Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Speaker demographics:\n",
      "  Gender: {1: 50, 2: 50}\n",
      "  Groups: 5 groups\n",
      "  Age range: 1-2\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>count</th>\n",
       "      <th>mean</th>\n",
       "      <th>std</th>\n",
       "      <th>min</th>\n",
       "      <th>25%</th>\n",
       "      <th>50%</th>\n",
       "      <th>75%</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gender</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>50.0</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>50.0</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.5</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        count  mean  std  min  25%  50%  75%  max\n",
       "gender                                           \n",
       "1        50.0   1.5  0.5  1.0  1.0  1.5  2.0  2.0\n",
       "2        50.0   1.5  0.5  1.0  1.0  1.5  2.0  2.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Speaker demographics\n",
    "print('Speaker demographics:')\n",
    "print(f\"  Gender: {speakers['gender'].value_counts().to_dict()}\")\n",
    "print(f\"  Groups: {speakers['group'].nunique()} groups\")\n",
    "print(f\"  Age range: {speakers['age'].min()}-{speakers['age'].max()}\")\n",
    "speakers.groupby('gender')['age'].describe().round(1)"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {},
   "execution_count": null,
   "outputs": [],
   "source": [
    "# Participant familiarity breakdown.\n",
    "# A participant was coded as familiar with the reference speaker on a given trial if\n",
    "# they selected the correct speaker name from the within-group name list. This\n",
    "# confirms the perceptual consensus is not dominated by celebrity recognition.\n",
    "total = len(responses)\n",
    "fam = int((responses['know_speaker'] == 1).sum())\n",
    "unfam = int((responses['know_speaker'] == 0).sum())\n",
    "print(f'Overall: {unfam:,} / {total:,} judgments from unfamiliar listeners ({unfam/total:.1%})')\n",
    "print(f'                  {fam:,} / {total:,} judgments from familiar listeners ({fam/total:.1%})')\n",
    "print()\n",
    "print('Per stimulus type:')\n",
    "for stype in sorted(responses['stimuli_type'].unique()):\n",
    "    sub = responses[responses['stimuli_type'] == stype]\n",
    "    u = int((sub['know_speaker'] == 0).sum())\n",
    "    print(f'  Type {stype}: {u:,}/{len(sub):,} unfamiliar ({u/len(sub):.1%})')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cell_008",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:03.188088Z",
     "iopub.status.busy": "2026-04-22T16:21:03.187832Z",
     "iopub.status.idle": "2026-04-22T16:21:06.995895Z",
     "shell.execute_reply": "2026-04-22T16:21:06.993670Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Split-half correlation (mean of 100 splits, all 1,290 participants): r = 0.5449\n",
      "Spearman-Brown corrected reliability: 0.7054\n"
     ]
    }
   ],
   "source": [
    "# Inter-rater agreement via split-half reliability on ALL 1,290 participants\n",
    "N_SPLITS = 100\n",
    "split_corrs = []\n",
    "\n",
    "all_ids = np.array(sorted(responses['user_id'].unique()))\n",
    "for _ in range(N_SPLITS):\n",
    "    perm = rng.permutation(all_ids)\n",
    "    half1 = set(perm[:len(perm)//2])\n",
    "    half2 = set(perm[len(perm)//2:])\n",
    "    r1 = responses[responses['user_id'].isin(half1)].groupby('stimuli_id')['answer'].mean()\n",
    "    r2 = responses[responses['user_id'].isin(half2)].groupby('stimuli_id')['answer'].mean()\n",
    "    common = r1.index.intersection(r2.index)\n",
    "    if len(common) > 100:\n",
    "        r, _ = pearsonr(r1[common], r2[common])\n",
    "        split_corrs.append(r)\n",
    "\n",
    "split_half_r = np.mean(split_corrs)\n",
    "sb_reliability = 2 * split_half_r / (1 + split_half_r)\n",
    "print(f'Split-half correlation (mean of {N_SPLITS} splits, all 1,290 participants): r = {split_half_r:.4f}')\n",
    "print(f'Spearman-Brown corrected reliability: {sb_reliability:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cell_009",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:06.998780Z",
     "iopub.status.busy": "2026-04-22T16:21:06.998501Z",
     "iopub.status.idle": "2026-04-22T16:21:07.939285Z",
     "shell.execute_reply": "2026-04-22T16:21:07.936924Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# P(same) distribution by stimulus type (full set, 1,290 participants)\n",
    "fig, ax = plt.subplots(figsize=(10, 5))\n",
    "data_plot = df.dropna(subset=['p_same_full'])\n",
    "sns.violinplot(data=data_plot, x='stimuli_type', y='p_same_full', ax=ax, inner='quartile',\n",
    "               palette='Set2', cut=0)\n",
    "type_labels = [\n",
    "    'Same\\nrecording',\n",
    "    'Same speaker\\ndifferent recording',\n",
    "    'Same speaker\\nAI voice clone',\n",
    "    'Different speakers\\nreal',\n",
    "    'Different speakers\\nvoice clones',\n",
    "    'Continuously\\nmorphed voices',\n",
    "]\n",
    "ax.set_xticklabels(type_labels)\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('P(same)')\n",
    "ax.set_ylim(-0.05, 1.05)\n",
    "plt.tight_layout()\n",
    "import os\n",
    "os.makedirs('manuscript/figures', exist_ok=True)\n",
    "plt.savefig('manuscript/figures/psame_by_type.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_009_interp",
   "metadata": {},
   "source": [
    "### Section 1: Interpretation\n",
    "\n",
    "**Dataset scale.** The full dataset contains 124,876 judgments from 1,290 participants across 9,800 voice pairs spanning 100 speakers. Each pair has a median of 10 individual judgments (range 1-51).\n",
    "\n",
    "**P(same) by stimulus type.** The violin plot shows clear separation: Type 1 (identical audio) near ceiling (~0.95); Type 2 (same speaker, different recording) ~0.68; Type 3 (voice clone of same speaker) ~0.56; Types 4-5 (different speakers) ~0.24; Type 6 (blended voices) spans the full 0-1 range providing continuous identity-perception probes.\n",
    "\n",
    "**Inter-rater reliability.** Split-half Spearman-Brown reliability is $\\rho = 0.705$. This is the noise ceiling: a perfect predictor of the true (noise-free) P(same) would achieve Pearson $r \\approx \\sqrt{\\rho} = 0.84$ and $R^2 \\approx 0.705$ on this measurement. The reliability substantially below 1.0 reflects genuine population-level variability in how listeners perceive voice identity, not measurement error. Section 10's per-listener baseline makes this listener-variability quantitative."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_010",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 2: Model Embeddings & Distances\n",
    "\n",
    "We benchmark 10 speaker embedding models spanning three training paradigms:\n",
    "\n",
    "- **Supervised** (5 models): Trained with speaker identity labels using classification losses (AAM-Softmax, Softmax, or GE2E). These models are explicitly optimized to place same-speaker utterances close together and different-speaker utterances far apart.\n",
    "- **Self-supervised** (4 models): Trained without any speaker labels, using objectives like contrastive prediction (wav2vec 2.0, XLS-R), masked token prediction (HuBERT, WavLM). Speaker identity information emerges as a byproduct of learning general speech structure.\n",
    "- **Weakly supervised** (1 model): Whisper, trained on 680K hours of audio-transcript pairs for ASR/translation. Not designed for speaker tasks.\n",
    "\n",
    "For each model, we extract an embedding vector for every audio clip (100 references + 9,800 comparisons = 9,900 total). For each of the 9,800 stimulus pairs, we compute the **cosine similarity** between the reference embedding and the comparison embedding:\n",
    "\n",
    "$$\\text{cosim}(\\mathbf{e}_{\\text{ref}}, \\mathbf{e}_{\\text{comp}}) = \\frac{\\mathbf{e}_{\\text{ref}} \\cdot \\mathbf{e}_{\\text{comp}}}{\\|\\mathbf{e}_{\\text{ref}}\\| \\cdot \\|\\mathbf{e}_{\\text{comp}}\\|}$$\n",
    "\n",
    "This is the standard similarity metric used in speaker verification systems. Higher cosine similarity indicates the model considers the two clips more likely to belong to the same speaker.\n",
    "\n",
    "The **inter-model correlation heatmap** reveals how much different models agree with each other about which pairs are similar, independent of whether they agree with humans."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cell_011",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:07.942054Z",
     "iopub.status.busy": "2026-04-22T16:21:07.941794Z",
     "iopub.status.idle": "2026-04-22T16:21:42.950156Z",
     "shell.execute_reply": "2026-04-22T16:21:42.947936Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded rawnet3: 9900 embeddings, dim=192\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded ecapa_tdnn: 9900 embeddings, dim=192\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded titanet: 9900 embeddings, dim=192\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded resemblyzer: 9900 embeddings, dim=256\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded xvector: 9900 embeddings, dim=512\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded wav2vec2: 9900 embeddings, dim=768\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded hubert: 9900 embeddings, dim=768\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded wavlm: 9900 embeddings, dim=768\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded whisper: 9900 embeddings, dim=512\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  Loaded xlsr: 9900 embeddings, dim=1024\n",
      "\n",
      "Available models: ['rawnet3', 'ecapa_tdnn', 'titanet', 'resemblyzer', 'xvector', 'wav2vec2', 'hubert', 'wavlm', 'whisper', 'xlsr']\n"
     ]
    }
   ],
   "source": [
    "# Load all available embeddings\n",
    "MODEL_INFO = {\n",
    "    'rawnet3':    {'type': 'Supervised', 'dim': 192, 'training': 'AAM-Softmax on VoxCeleb1+2 (Jung et al., Interspeech 2022)'},\n",
    "    'ecapa_tdnn': {'type': 'Supervised', 'dim': 192, 'training': 'AAM-Softmax on VoxCeleb1+2 (Desplanques et al., Interspeech 2020)'},\n",
    "    'titanet':    {'type': 'Supervised', 'dim': 192, 'training': 'AAM-Softmax on VoxCeleb+Fisher+SWB (Koluguri et al., ICASSP 2022)'},\n",
    "    'resemblyzer':{'type': 'Supervised', 'dim': 256, 'training': 'GE2E loss, 3-layer LSTM (Wan et al., ICASSP 2018)'},\n",
    "    'xvector':    {'type': 'Supervised', 'dim': 512, 'training': 'Softmax on VoxCeleb1+2, TDNN (Snyder et al., ICASSP 2018)'},\n",
    "    'wav2vec2':   {'type': 'Self-supervised', 'dim': 768, 'training': 'Contrastive on LibriSpeech 960h (Baevski et al., NeurIPS 2020)'},\n",
    "    'hubert':     {'type': 'Self-supervised', 'dim': 768, 'training': 'Masked prediction on LibriSpeech 960h (Hsu et al., IEEE/ACM TASLP 2021)'},\n",
    "    'wavlm':      {'type': 'Self-supervised', 'dim': 768, 'training': 'Masked prediction + denoising on 94K hrs (Chen et al., JSTSP 2022)'},\n",
    "    'whisper':    {'type': 'Weakly supervised', 'dim': 512, 'training': 'Multitask ASR on 680K hrs web audio (Radford et al., ICML 2023)'},\n",
    "    'xlsr':       {'type': 'Self-supervised', 'dim': 1024, 'training': 'Contrastive on 436K hrs multilingual (Babu et al., Interspeech 2022)'},\n",
    "}\n",
    "\n",
    "embeddings = {}\n",
    "for name in MODEL_INFO:\n",
    "    npz_path = EMB_DIR / f'{name}.npz'\n",
    "    if npz_path.exists():\n",
    "        data = np.load(npz_path, allow_pickle=True)\n",
    "        embeddings[name] = {k: data[k] for k in data.files}\n",
    "        dim = next(iter(embeddings[name].values())).shape[0]\n",
    "        MODEL_INFO[name]['dim'] = dim\n",
    "        print(f'  Loaded {name}: {len(embeddings[name])} embeddings, dim={dim}')\n",
    "    else:\n",
    "        print(f'  SKIPPED {name}: no .npz at {npz_path}')\n",
    "\n",
    "available_models = list(embeddings.keys())\n",
    "print(f'\\nAvailable models: {available_models}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cell_012",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:42.952894Z",
     "iopub.status.busy": "2026-04-22T16:21:42.952623Z",
     "iopub.status.idle": "2026-04-22T16:21:46.753326Z",
     "shell.execute_reply": "2026-04-22T16:21:46.750883Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "rawnet3: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ecapa_tdnn: 9800 / 9800 pairs with valid cosine similarity\n",
      "titanet: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "resemblyzer: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xvector: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wav2vec2: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hubert: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wavlm: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "whisper: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "xlsr: 9800 / 9800 pairs with valid cosine similarity\n"
     ]
    }
   ],
   "source": [
    "# Compute cosine similarity for each model x each pair (vectorized)\n",
    "for model_name, emb_dict in embeddings.items():\n",
    "    col = f'{model_name}_cosim'\n",
    "    \n",
    "    # Build embedding matrices aligned with df rows\n",
    "    ref_keys = [f\"{ref}R\" for ref in df['reference']]\n",
    "    stim_keys = df['id'].tolist()\n",
    "    \n",
    "    dim = MODEL_INFO[model_name]['dim']\n",
    "    ref_matrix = np.zeros((len(df), dim))\n",
    "    stim_matrix = np.zeros((len(df), dim))\n",
    "    valid_mask = np.ones(len(df), dtype=bool)\n",
    "    \n",
    "    for i, (rk, sk) in enumerate(zip(ref_keys, stim_keys)):\n",
    "        if rk in emb_dict and sk in emb_dict:\n",
    "            ref_matrix[i] = emb_dict[rk]\n",
    "            stim_matrix[i] = emb_dict[sk]\n",
    "        else:\n",
    "            valid_mask[i] = False\n",
    "    \n",
    "    # Vectorized cosine similarity\n",
    "    ref_norm = ref_matrix / (np.linalg.norm(ref_matrix, axis=1, keepdims=True) + 1e-10)\n",
    "    stim_norm = stim_matrix / (np.linalg.norm(stim_matrix, axis=1, keepdims=True) + 1e-10)\n",
    "    sims = np.sum(ref_norm * stim_norm, axis=1)\n",
    "    sims[~valid_mask] = np.nan\n",
    "    \n",
    "    df[col] = sims\n",
    "    valid_count = valid_mask.sum()\n",
    "    print(f'{model_name}: {valid_count} / {len(df)} pairs with valid cosine similarity')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "cell_012b_bestlayer",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:21:46.756096Z",
     "iopub.status.busy": "2026-04-22T16:21:46.755824Z",
     "iopub.status.idle": "2026-04-22T16:22:33.386168Z",
     "shell.execute_reply": "2026-04-22T16:22:33.384012Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested-CV best-layer cosine similarity for SSL models...\n",
      "[cache HIT] ssl_bestlayer_cosims: Per-fold layer selection for SSL models\n",
      "  wav2vec2: best layer per fold = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] (n_layers=13)\n",
      "  hubert: best layer per fold = [1, 0, 1, 0, 0, 1, 0, 0, 1, 0] (n_layers=13)\n",
      "  wavlm: best layer per fold = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] (n_layers=13)\n",
      "  xlsr: best layer per fold = [1, 1, 1, 1, 1, 1, 1, 1, 1, 1] (n_layers=25)\n",
      "  whisper: best layer per fold = [3, 3, 3, 3, 3, 3, 3, 3, 3, 3] (n_layers=7)\n",
      "\n",
      "SSL cosine similarity columns now use nested-CV best-layer selection.\n",
      "Last-layer values preserved in `{model}_cosim_lastlayer` columns.\n"
     ]
    }
   ],
   "source": [
    "# ============================================================\n",
    "# Nested speaker-level CV: best-layer cosine similarity for SSL models\n",
    "#\n",
    "# The cosine similarities computed above use each model's final hidden state.\n",
    "# For SSL models this is known to underperform for speaker tasks (SUPERB lit.).\n",
    "# Here we replace the SSL models' cosine similarity with a fair, nested-CV\n",
    "# best-layer value. Results are cached to cache/ssl_bestlayer_cosims.pkl.\n",
    "# ============================================================\n",
    "\n",
    "SSL_MODELS_WITH_LAYERS = ['wav2vec2', 'hubert', 'wavlm', 'xlsr', 'whisper']\n",
    "\n",
    "# Load layer-wise embeddings (also used in Section 13)\n",
    "layer_embs = {}\n",
    "for m in SSL_MODELS_WITH_LAYERS:\n",
    "    p = LAYER_EMB_DIR / f'{m}.npz'\n",
    "    if p.exists():\n",
    "        data = np.load(p, allow_pickle=True)\n",
    "        layer_embs[m] = {k: data[k] for k in data.files}\n",
    "\n",
    "# Build 10 gender-balanced speaker folds (used throughout the notebook)\n",
    "_all_spk = sorted(df['reference'].unique())\n",
    "_male = [s for s in _all_spk if s.startswith('M')]\n",
    "_female = [s for s in _all_spk if s.startswith('F')]\n",
    "_rng_folds = np.random.default_rng(SEED)\n",
    "_rng_folds.shuffle(_male); _rng_folds.shuffle(_female)\n",
    "CV_FOLDS = [[] for _ in range(10)]\n",
    "for i, s in enumerate(_male): CV_FOLDS[i % 10].append(s)\n",
    "for i, s in enumerate(_female): CV_FOLDS[i % 10].append(s)\n",
    "\n",
    "# Keep a copy of the last-layer cosims for reference/reporting\n",
    "for m in SSL_MODELS_WITH_LAYERS:\n",
    "    if f'{m}_cosim' in df.columns:\n",
    "        df[f'{m}_cosim_lastlayer'] = df[f'{m}_cosim'].copy()\n",
    "\n",
    "def _compute_ssl_bestlayer():\n",
    "    \"\"\"Compute nested-CV best-layer cosine similarity per SSL model.\"\"\"\n",
    "    result = {}\n",
    "    for m in SSL_MODELS_WITH_LAYERS:\n",
    "        if m not in layer_embs:\n",
    "            continue\n",
    "        emb_d = layer_embs[m]\n",
    "        ref_keys = [f'{ref}R' for ref in df['reference']]\n",
    "        stim_keys = df['id'].tolist()\n",
    "        n_pairs = len(df)\n",
    "        sample = next(iter(emb_d.values()))\n",
    "        n_layers, dim = sample.shape\n",
    "        \n",
    "        ref_arr = np.full((n_pairs, n_layers, dim), np.nan)\n",
    "        stim_arr = np.full((n_pairs, n_layers, dim), np.nan)\n",
    "        valid_mask = np.zeros(n_pairs, dtype=bool)\n",
    "        for i, (rk, sk) in enumerate(zip(ref_keys, stim_keys)):\n",
    "            if rk in emb_d and sk in emb_d:\n",
    "                ref_arr[i] = emb_d[rk]\n",
    "                stim_arr[i] = emb_d[sk]\n",
    "                valid_mask[i] = True\n",
    "        \n",
    "        ref_n = ref_arr / (np.linalg.norm(ref_arr, axis=2, keepdims=True) + 1e-10)\n",
    "        stim_n = stim_arr / (np.linalg.norm(stim_arr, axis=2, keepdims=True) + 1e-10)\n",
    "        all_cosims = np.sum(ref_n * stim_n, axis=2)  # (n_pairs, n_layers)\n",
    "        \n",
    "        y = df['p_same_full'].values\n",
    "        speakers = df['reference'].values\n",
    "        best_cosim = np.full(n_pairs, np.nan)\n",
    "        selected_layers = []\n",
    "        \n",
    "        for fold_speakers in CV_FOLDS:\n",
    "            test_in_fold = np.isin(speakers, fold_speakers)\n",
    "            train_mask = (~test_in_fold) & valid_mask & ~np.isnan(y)\n",
    "            test_mask = test_in_fold & valid_mask & ~np.isnan(y)\n",
    "            if train_mask.sum() < 50 or test_mask.sum() < 1:\n",
    "                continue\n",
    "            layer_r = np.zeros(n_layers)\n",
    "            for l in range(n_layers):\n",
    "                xl = all_cosims[train_mask, l]\n",
    "                yl = y[train_mask]\n",
    "                if np.std(xl) > 1e-8:\n",
    "                    layer_r[l], _ = pearsonr(xl, yl)\n",
    "            best_l = int(np.argmax(layer_r))\n",
    "            selected_layers.append(best_l)\n",
    "            best_cosim[test_mask] = all_cosims[test_mask, best_l]\n",
    "        result[m] = {'best_cosim': best_cosim, 'selected_layers': selected_layers}\n",
    "    return result\n",
    "\n",
    "print('Nested-CV best-layer cosine similarity for SSL models...')\n",
    "ssl_bestlayer = cached('ssl_bestlayer_cosims', _compute_ssl_bestlayer,\n",
    "                      'Per-fold layer selection for SSL models')\n",
    "\n",
    "best_layer_per_fold = {}\n",
    "for m, d in ssl_bestlayer.items():\n",
    "    df[f'{m}_cosim'] = d['best_cosim']\n",
    "    best_layer_per_fold[m] = d['selected_layers']\n",
    "    n_layers_m = layer_embs[m][next(iter(layer_embs[m]))].shape[0]\n",
    "    print(f'  {m}: best layer per fold = {d[\"selected_layers\"]} (n_layers={n_layers_m})')\n",
    "\n",
    "print('\\nSSL cosine similarity columns now use nested-CV best-layer selection.')\n",
    "print('Last-layer values preserved in `{model}_cosim_lastlayer` columns.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "cell_013",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:22:33.389237Z",
     "iopub.status.busy": "2026-04-22T16:22:33.388920Z",
     "iopub.status.idle": "2026-04-22T16:22:33.400641Z",
     "shell.execute_reply": "2026-04-22T16:22:33.398744Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Model</th>\n",
       "      <th>Type</th>\n",
       "      <th>Dim</th>\n",
       "      <th>Training</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>rawnet3</td>\n",
       "      <td>Supervised</td>\n",
       "      <td>192</td>\n",
       "      <td>AAM-Softmax on VoxCeleb1+2 (Jung et al., Inter...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ecapa_tdnn</td>\n",
       "      <td>Supervised</td>\n",
       "      <td>192</td>\n",
       "      <td>AAM-Softmax on VoxCeleb1+2 (Desplanques et al....</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>titanet</td>\n",
       "      <td>Supervised</td>\n",
       "      <td>192</td>\n",
       "      <td>AAM-Softmax on VoxCeleb+Fisher+SWB (Koluguri e...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>resemblyzer</td>\n",
       "      <td>Supervised</td>\n",
       "      <td>256</td>\n",
       "      <td>GE2E loss, 3-layer LSTM (Wan et al., ICASSP 2018)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>xvector</td>\n",
       "      <td>Supervised</td>\n",
       "      <td>512</td>\n",
       "      <td>Softmax on VoxCeleb1+2, TDNN (Snyder et al., I...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>wav2vec2</td>\n",
       "      <td>Self-supervised</td>\n",
       "      <td>768</td>\n",
       "      <td>Contrastive on LibriSpeech 960h (Baevski et al...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>hubert</td>\n",
       "      <td>Self-supervised</td>\n",
       "      <td>768</td>\n",
       "      <td>Masked prediction on LibriSpeech 960h (Hsu et ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>wavlm</td>\n",
       "      <td>Self-supervised</td>\n",
       "      <td>768</td>\n",
       "      <td>Masked prediction + denoising on 94K hrs (Chen...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>whisper</td>\n",
       "      <td>Weakly supervised</td>\n",
       "      <td>512</td>\n",
       "      <td>Multitask ASR on 680K hrs web audio (Radford e...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>xlsr</td>\n",
       "      <td>Self-supervised</td>\n",
       "      <td>1024</td>\n",
       "      <td>Contrastive on 436K hrs multilingual (Babu et ...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Model               Type   Dim  \\\n",
       "0      rawnet3         Supervised   192   \n",
       "1   ecapa_tdnn         Supervised   192   \n",
       "2      titanet         Supervised   192   \n",
       "3  resemblyzer         Supervised   256   \n",
       "4      xvector         Supervised   512   \n",
       "5     wav2vec2    Self-supervised   768   \n",
       "6       hubert    Self-supervised   768   \n",
       "7        wavlm    Self-supervised   768   \n",
       "8      whisper  Weakly supervised   512   \n",
       "9         xlsr    Self-supervised  1024   \n",
       "\n",
       "                                            Training  \n",
       "0  AAM-Softmax on VoxCeleb1+2 (Jung et al., Inter...  \n",
       "1  AAM-Softmax on VoxCeleb1+2 (Desplanques et al....  \n",
       "2  AAM-Softmax on VoxCeleb+Fisher+SWB (Koluguri e...  \n",
       "3  GE2E loss, 3-layer LSTM (Wan et al., ICASSP 2018)  \n",
       "4  Softmax on VoxCeleb1+2, TDNN (Snyder et al., I...  \n",
       "5  Contrastive on LibriSpeech 960h (Baevski et al...  \n",
       "6  Masked prediction on LibriSpeech 960h (Hsu et ...  \n",
       "7  Masked prediction + denoising on 94K hrs (Chen...  \n",
       "8  Multitask ASR on 680K hrs web audio (Radford e...  \n",
       "9  Contrastive on 436K hrs multilingual (Babu et ...  "
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Model info table\n",
    "info_rows = []\n",
    "for name in available_models:\n",
    "    info = MODEL_INFO[name]\n",
    "    info_rows.append({\n",
    "        'Model': name,\n",
    "        'Type': info['type'],\n",
    "        'Dim': info['dim'],\n",
    "        'Training': info['training']\n",
    "    })\n",
    "pd.DataFrame(info_rows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_014",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:22:33.403138Z",
     "iopub.status.busy": "2026-04-22T16:22:33.402879Z",
     "iopub.status.idle": "2026-04-22T16:22:34.161169Z",
     "shell.execute_reply": "2026-04-22T16:22:34.159008Z"
    }
   },
   "outputs": [],
   "source": [
    "# Inter-model correlation heatmap. Whisper is placed last (bottom-right) since\n",
    "# it is the weakly-supervised outlier.\n",
    "if len(available_models) > 1:\n",
    "    plot_models = [m for m in available_models if m != 'whisper']\n",
    "    if 'whisper' in available_models:\n",
    "        plot_models.append('whisper')\n",
    "    cosim_cols = [f'{m}_cosim' for m in plot_models]\n",
    "    corr_matrix = df[cosim_cols].corr()\n",
    "    corr_matrix.columns = [DISPLAY_NAME[m] for m in plot_models]\n",
    "    corr_matrix.index = [DISPLAY_NAME[m] for m in plot_models]\n",
    "\n",
    "    DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "    sns.heatmap(corr_matrix, annot=True, fmt='.3f', cmap='RdYlBu_r',\n",
    "                vmin=0, vmax=1, ax=ax, square=True)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('manuscript/figures/intermodel_heatmap.png', dpi=200, bbox_inches='tight')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_014_interp",
   "metadata": {},
   "source": [
    "### Section 2: Interpretation\n",
    "\n",
    "**Inter-model agreement.** With best-layer SSL cosine similarities, the inter-model correlation structure shifts: supervised and SSL models now correlate more strongly with each other than when SSL used last-layer. Supervised models still form the tightest cluster (pairwise r > 0.9 typical), but SSL models (wav2vec2, HuBERT, WavLM, XLS-R) now correlate with supervised models at r ~ 0.7-0.85 -- far above their last-layer correlations (~0.4-0.6). Whisper remains the outlier with weaker correlations to all other models. This pattern is consistent with SSL models encoding substantial speaker-relevant information in their early layers, which becomes visible under fair layer selection but is suppressed at the last layer.\n",
    "\n",
    "**Protocol note.** The cosine similarities computed here are the ones used throughout the rest of the benchmark. For supervised models they come from the model's native output; for SSL models they come from the nested-CV best-layer selection documented in Section 13."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part I.5 \u2014 Metadata-Label Analysis\n",
    "\n",
    "Before analyzing alignment with human perception, we evaluate the same models against the **metadata label** (same/different speaker by ground truth). This is the kind of evaluation the ML community is familiar with from VoxCeleb-style benchmarks. We then compare the metadata target to the perception target at both the dataset level (how often does the crowd majority agree with metadata?) and the model level (does a model's metadata score predict its perception score?).\n",
    "\n",
    "**Label assignment.** Types 1, 2, 3 \u2192 metadata=same (Type 3 clones were generated *from* the reference speaker, so metadata says same). Types 4, 5 \u2192 metadata=different. Type 6 (morphs) is excluded because mid-morphs have no clean ground-truth speaker identity.\n",
    "\n",
    "**Layer selection for SSL.** We select the layer that maximizes AUC against the metadata label on training-fold speakers (SUPERB-style per-task selection), separately from the perception-target selection used in Section 2. This gives each SSL model its fairest metadata number, rather than reusing a layer optimized for a different target.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:22:34.163892Z",
     "iopub.status.busy": "2026-04-22T16:22:34.163627Z",
     "iopub.status.idle": "2026-04-22T16:22:34.173491Z",
     "shell.execute_reply": "2026-04-22T16:22:34.171417Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pairs with metadata label: 1700 / 9800\n",
      "  Metadata = same      (Types 1-3): 900\n",
      "  Metadata = different (Types 4-5): 800\n",
      "  Excluded             (Type 6):    8100\n"
     ]
    }
   ],
   "source": [
    "# ============================================================\n",
    "# M1. Metadata labels (Type 6 excluded)\n",
    "# ============================================================\n",
    "# Type 1 (same recording), Type 2 (same spkr, diff rec), Type 3 (clone of\n",
    "# that speaker) \u2192 metadata = 1 (same).\n",
    "# Type 4 (diff spkrs, real), Type 5 (diff spkrs, both cloned) \u2192 metadata = 0.\n",
    "# Type 6 (morphs) is EXCLUDED: mid-morphs have no clean ground-truth label.\n",
    "metadata_map = {1: 1, 2: 1, 3: 1, 4: 0, 5: 0}\n",
    "df['metadata_label'] = df['stimuli_type'].map(metadata_map)\n",
    "\n",
    "print(f'Pairs with metadata label: {df[\"metadata_label\"].notna().sum()} / {len(df)}')\n",
    "print(f'  Metadata = same      (Types 1-3): {(df[\"metadata_label\"] == 1).sum()}')\n",
    "print(f'  Metadata = different (Types 4-5): {(df[\"metadata_label\"] == 0).sum()}')\n",
    "print(f'  Excluded             (Type 6):    {df[\"metadata_label\"].isna().sum()}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:22:34.175974Z",
     "iopub.status.busy": "2026-04-22T16:22:34.175718Z",
     "iopub.status.idle": "2026-04-22T16:23:26.200573Z",
     "shell.execute_reply": "2026-04-22T16:23:26.198051Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nested-CV best-layer for SSL on the METADATA target (AUC-on-training)...\n",
      "[cache MISS] ssl_bestlayer_cosims_meta: Per-fold layer selection on metadata target -- computing\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[cache SAVED] ssl_bestlayer_cosims_meta -> ssl_bestlayer_cosims_meta.pkl\n",
      "  wav2vec2: layers chosen = [0, 0, 0, 0, 0, 0, 0, 0, 3, 3] (of 13)\n",
      "  hubert: layers chosen = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1] (of 13)\n",
      "  wavlm: layers chosen = [4, 4, 4, 4, 4, 4, 4, 4, 4, 4] (of 13)\n",
      "  whisper: layers chosen = [3, 3, 3, 3, 3, 3, 3, 3, 3, 3] (of 7)\n",
      "  xlsr: layers chosen = [5, 5, 5, 5, 5, 5, 5, 5, 5, 5] (of 25)\n",
      "\n",
      "Metadata cosines stored in df[f\"{m}_cosim_meta\"].\n"
     ]
    }
   ],
   "source": [
    "# ============================================================\n",
    "# Per-fold best SSL layer selected on METADATA target (AUC on training speakers).\n",
    "# Supervised models: native embedding (already in df[f'{m}_cosim_lastlayer'] for SSL,\n",
    "# or df[f'{m}_cosim'] for supervised which has no layer choice). We build a new\n",
    "# column df[f'{m}_cosim_meta'] that holds:\n",
    "#   - supervised model: its native cosine similarity (same as _cosim)\n",
    "#   - SSL model: nested-CV best-for-metadata cosine similarity\n",
    "# The existing df[f'{m}_cosim'] (best-for-perception for SSL) is untouched.\n",
    "# Cached to cache/ssl_bestlayer_cosims_meta.pkl.\n",
    "# ============================================================\n",
    "\n",
    "def _select_best_layer_on_metadata(model_name):\n",
    "    emb_d = layer_embs[model_name]\n",
    "    ref_keys = [f'{ref}R' for ref in df['reference']]\n",
    "    stim_keys = df['id'].tolist()\n",
    "    sample = next(iter(emb_d.values()))\n",
    "    n_layers, dim = sample.shape\n",
    "    n_pairs = len(df)\n",
    "\n",
    "    ref_arr = np.full((n_pairs, n_layers, dim), np.nan)\n",
    "    stim_arr = np.full((n_pairs, n_layers, dim), np.nan)\n",
    "    valid_mask = np.zeros(n_pairs, dtype=bool)\n",
    "    for i, (rk, sk) in enumerate(zip(ref_keys, stim_keys)):\n",
    "        if rk in emb_d and sk in emb_d:\n",
    "            ref_arr[i] = emb_d[rk]; stim_arr[i] = emb_d[sk]; valid_mask[i] = True\n",
    "    rn = ref_arr / (np.linalg.norm(ref_arr, axis=2, keepdims=True) + 1e-10)\n",
    "    sn = stim_arr / (np.linalg.norm(stim_arr, axis=2, keepdims=True) + 1e-10)\n",
    "    all_cosims = np.sum(rn * sn, axis=2)  # (n_pairs, n_layers)\n",
    "\n",
    "    meta = df['metadata_label'].values\n",
    "    speakers = df['reference'].values\n",
    "    best_cosim = np.full(n_pairs, np.nan)\n",
    "    chosen = []\n",
    "    for fold_speakers in CV_FOLDS:\n",
    "        test_mask = np.isin(speakers, fold_speakers) & valid_mask\n",
    "        train_mask = (~np.isin(speakers, fold_speakers)) & valid_mask & ~np.isnan(meta)\n",
    "        if train_mask.sum() < 50:\n",
    "            continue\n",
    "        y_tr = meta[train_mask].astype(int)\n",
    "        if len(np.unique(y_tr)) < 2:\n",
    "            continue\n",
    "        layer_auc = np.zeros(n_layers)\n",
    "        for l in range(n_layers):\n",
    "            xl = all_cosims[train_mask, l]\n",
    "            if np.std(xl) > 1e-8:\n",
    "                layer_auc[l] = roc_auc_score(y_tr, xl)\n",
    "        best_l = int(np.argmax(layer_auc))\n",
    "        chosen.append(best_l)\n",
    "        best_cosim[test_mask] = all_cosims[test_mask, best_l]\n",
    "    return best_cosim, chosen\n",
    "\n",
    "def _compute_ssl_meta_cosims():\n",
    "    out = {}\n",
    "    for m in SSL_MODELS_WITH_LAYERS:\n",
    "        if m not in layer_embs:\n",
    "            continue\n",
    "        c, chosen = _select_best_layer_on_metadata(m)\n",
    "        out[m] = {'cosim': c, 'layers': chosen}\n",
    "    return out\n",
    "\n",
    "print('Nested-CV best-layer for SSL on the METADATA target (AUC-on-training)...')\n",
    "ssl_meta = cached('ssl_bestlayer_cosims_meta', _compute_ssl_meta_cosims,\n",
    "                 'Per-fold layer selection on metadata target')\n",
    "\n",
    "for m in available_models:\n",
    "    col = f'{m}_cosim_meta'\n",
    "    if m in ssl_meta:\n",
    "        df[col] = ssl_meta[m]['cosim']\n",
    "        n_layers_m = layer_embs[m][next(iter(layer_embs[m]))].shape[0]\n",
    "        print(f'  {m}: layers chosen = {ssl_meta[m][\"layers\"]} (of {n_layers_m})')\n",
    "    else:\n",
    "        df[col] = df[f'{m}_cosim']  # supervised: same native embedding\n",
    "\n",
    "print('\\nMetadata cosines stored in df[f\"{m}_cosim_meta\"].')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:26.212135Z",
     "iopub.status.busy": "2026-04-22T16:23:26.211802Z",
     "iopub.status.idle": "2026-04-22T16:23:26.377639Z",
     "shell.execute_reply": "2026-04-22T16:23:26.375503Z"
    }
   },
   "outputs": [],
   "source": [
    "# ============================================================\n",
    "# M2. EER / AUC / Accuracy@EER per model \u00d7 three evaluation sets.\n",
    "# ============================================================\n",
    "EVAL_SETS = {\n",
    "    'A: Type 2 + Type 4 (VoxCeleb-like)': [2, 4],\n",
    "    'B: Type 3 + Type 5 (clones only)':   [3, 5],\n",
    "    'C: Types 1-5 (extended)':            [1, 2, 3, 4, 5],\n",
    "}\n",
    "\n",
    "def compute_eer(y_true, scores):\n",
    "    fpr, tpr, thresholds = roc_curve(y_true, scores)\n",
    "    fnr = 1 - tpr\n",
    "    idx = int(np.nanargmin(np.abs(fpr - fnr)))\n",
    "    eer = (fpr[idx] + fnr[idx]) / 2\n",
    "    thr = thresholds[idx]\n",
    "    acc = accuracy_score(y_true, (scores >= thr).astype(int))\n",
    "    return eer, thr, acc\n",
    "\n",
    "metadata_rows = []\n",
    "for set_name, types in EVAL_SETS.items():\n",
    "    sub = df[df['stimuli_type'].isin(types)].copy()\n",
    "    for model_name in available_models:\n",
    "        col = f'{model_name}_cosim_meta'\n",
    "        v = sub.dropna(subset=[col, 'metadata_label'])\n",
    "        if v['metadata_label'].nunique() < 2 or len(v) < 10:\n",
    "            continue\n",
    "        y = v['metadata_label'].values.astype(int)\n",
    "        s = v[col].values\n",
    "        eer, thr, acc = compute_eer(y, s)\n",
    "        a = roc_auc_score(y, s)\n",
    "        metadata_rows.append({\n",
    "            'set': set_name, 'model': model_name,\n",
    "            'type': MODEL_INFO[model_name]['type'],\n",
    "            'n': len(v), 'EER': eer, 'AUC_meta': a, 'Acc@EER': acc,\n",
    "        })\n",
    "metadata_df = pd.DataFrame(metadata_rows)\n",
    "\n",
    "for set_name in EVAL_SETS:\n",
    "    print(f'\\n=== {set_name} ===')\n",
    "    sub = metadata_df[metadata_df['set'] == set_name].sort_values('EER')\n",
    "    print(sub[['model', 'type', 'n', 'EER', 'AUC_meta', 'Acc@EER']].round(4).to_string(index=False))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:26.380513Z",
     "iopub.status.busy": "2026-04-22T16:23:26.380245Z",
     "iopub.status.idle": "2026-04-22T16:23:26.932646Z",
     "shell.execute_reply": "2026-04-22T16:23:26.930658Z"
    }
   },
   "outputs": [],
   "source": [
    "# ============================================================\n",
    "# M3. Majority-vote vs metadata divergence (dataset-level, model-free).\n",
    "# ============================================================\n",
    "# Palette taken from PNAS Figure 2A; Type 6 (morphs) gets a complementary purple.\n",
    "TYPE_PALETTE = {1: '#42598a', 2: '#6b94b4', 3: '#86a95c',\n",
    "                4: '#d4776e', 5: '#d293b5', 6: '#976fa7'}\n",
    "\n",
    "# Wilson 95% CI for a proportion\n",
    "def _wilson_ci(k, n, z=1.96):\n",
    "    if n == 0: return (np.nan, np.nan)\n",
    "    p = k / n\n",
    "    denom = 1 + z*z/n\n",
    "    center = (p + z*z/(2*n)) / denom\n",
    "    half = z * np.sqrt(p*(1-p)/n + z*z/(4*n*n)) / denom\n",
    "    return (max(0.0, center - half), min(1.0, center + half))\n",
    "\n",
    "div_rows = []\n",
    "for stype in sorted(df['stimuli_type'].unique()):\n",
    "    sub = df[df['stimuli_type'] == stype].dropna(subset=['p_same_full'])\n",
    "    if stype == 6:\n",
    "        div_rows.append({'Type': stype, 'n': len(sub), 'metadata': 'N/A',\n",
    "                         'agree_with_meta': np.nan, 'disagree_with_meta': np.nan,\n",
    "                         'disagree_rate': np.nan, 'ci_lo': np.nan, 'ci_hi': np.nan,\n",
    "                         'median_P(same)': sub['p_same_full'].median()})\n",
    "        continue\n",
    "    meta = metadata_map[stype]\n",
    "    n_ag = int((sub['majority_full'] == meta).sum())\n",
    "    n_dis = int((sub['majority_full'] != meta).sum())\n",
    "    rate = n_dis / len(sub) if len(sub) else np.nan\n",
    "    lo, hi = _wilson_ci(n_dis, len(sub))\n",
    "    div_rows.append({'Type': stype, 'n': len(sub), 'metadata': meta,\n",
    "                     'agree_with_meta': n_ag, 'disagree_with_meta': n_dis,\n",
    "                     'disagree_rate': rate, 'ci_lo': lo, 'ci_hi': hi,\n",
    "                     'median_P(same)': sub['p_same_full'].median()})\n",
    "div_df_table = pd.DataFrame(div_rows)\n",
    "print('Majority-vote vs metadata label, per stimulus type (with 95% Wilson CI):')\n",
    "print(div_df_table.round(3).to_string(index=False))\n",
    "\n",
    "sub_same = df[df['metadata_label'] == 1].dropna(subset=['p_same_full'])\n",
    "sub_diff = df[df['metadata_label'] == 0].dropna(subset=['p_same_full'])\n",
    "dis_same = (sub_same['majority_full'] == 0).mean()\n",
    "dis_diff = (sub_diff['majority_full'] == 1).mean()\n",
    "print(f'\\nOverall divergence (Types 1-5; Type 6 excluded):')\n",
    "print(f'  metadata=same pairs  -> majority=different on '\n",
    "      f'{(sub_same[\"majority_full\"]==0).sum()} / {len(sub_same)} = {dis_same:.1%}')\n",
    "print(f'  metadata=diff pairs  -> majority=same      on '\n",
    "      f'{(sub_diff[\"majority_full\"]==1).sum()} / {len(sub_diff)} = {dis_diff:.1%}')\n",
    "\n",
    "# --- Figure: two panels, metadata-perception divergence at the dataset level ---\n",
    "fig, axes = plt.subplots(1, 2, figsize=(13, 4.5),\n",
    "                         gridspec_kw={'width_ratios': [1.5, 1]})\n",
    "\n",
    "# Panel A: violin of P(same) by stimulus type, with metadata reference marks\n",
    "ax = axes[0]\n",
    "data_plot = df.dropna(subset=['p_same_full']).copy()\n",
    "type_order = sorted(df['stimuli_type'].unique())\n",
    "violin_palette = [TYPE_PALETTE[t] for t in type_order]\n",
    "sns.violinplot(data=data_plot, x='stimuli_type', y='p_same_full',\n",
    "               order=type_order, ax=ax, inner='quartile',\n",
    "               palette=violin_palette, cut=0)\n",
    "META_LINE = '#333333'\n",
    "for i, stype in enumerate(type_order):\n",
    "    if stype == 6: continue\n",
    "    meta = metadata_map[stype]\n",
    "    ax.plot([i - 0.38, i + 0.38], [meta, meta], color=META_LINE, linewidth=2.4,\n",
    "            linestyle='--', zorder=10,\n",
    "            label='metadata label' if i == 0 else None)\n",
    "type_labels_short = ['same\\nrecording', 'same spkr\\ndiff rec',\n",
    "                     'same spkr\\nclone', 'diff spkrs\\nreal',\n",
    "                     'diff spkrs\\nclone', 'morphs\\n(no metadata)']\n",
    "ax.set_xticks(range(len(type_order)))\n",
    "ax.set_xticklabels(type_labels_short)\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('Human P(same)')\n",
    "ax.set_ylim(-0.05, 1.05)\n",
    "ax.legend(loc='lower left', frameon=True)\n",
    "for spine in ('top', 'right'):\n",
    "    ax.spines[spine].set_visible(False)\n",
    "\n",
    "# Panel B: disagreement rate with 95% Wilson CI, same per-type colors as Panel A\n",
    "ax = axes[1]\n",
    "div_valid = div_df_table[div_df_table['Type'] != 6].copy()\n",
    "bar_colors = [TYPE_PALETTE[int(t)] for t in div_valid['Type']]\n",
    "xpos = np.arange(len(div_valid))\n",
    "err_lo = (div_valid['disagree_rate'] - div_valid['ci_lo']).values\n",
    "err_hi = (div_valid['ci_hi'] - div_valid['disagree_rate']).values\n",
    "bars = ax.bar(xpos, div_valid['disagree_rate'].values,\n",
    "              color=bar_colors, edgecolor='#444', linewidth=0.8,\n",
    "              yerr=[err_lo, err_hi], capsize=5,\n",
    "              error_kw={'ecolor': '#333', 'elinewidth': 1.2})\n",
    "ax.set_xticks(xpos)\n",
    "ax.set_xticklabels(['same\\nrecording', 'same spkr\\ndiff rec',\n",
    "                    'same spkr\\nclone', 'diff spkrs\\nreal',\n",
    "                    'diff spkrs\\nclone'])\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel(r'Fraction where majority vote $\\neq$ metadata')\n",
    "ax.set_ylim(0, max(0.55, (div_valid['ci_hi'].max() if div_valid['ci_hi'].notna().any() else 0) + 0.05))\n",
    "for i, (val, hi) in enumerate(zip(div_valid['disagree_rate'].values,\n",
    "                                   div_valid['ci_hi'].values)):\n",
    "    y = (hi if not np.isnan(hi) else val) + 0.015\n",
    "    ax.text(i, y, f'{val:.2f}', ha='center', va='bottom', fontsize=10)\n",
    "for spine in ('top', 'right'):\n",
    "    ax.spines[spine].set_visible(False)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('manuscript/figures/metadata_divergence.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:26.935960Z",
     "iopub.status.busy": "2026-04-22T16:23:26.935646Z",
     "iopub.status.idle": "2026-04-22T16:23:27.628706Z",
     "shell.execute_reply": "2026-04-22T16:23:27.626510Z"
    }
   },
   "outputs": [],
   "source": [
    "# ============================================================\n",
    "# M4. Model-metadata (Set C) vs model-perception (Types 1-5).\n",
    "# 2D plot: X = AUC on metadata, Y = Pearson r against P(same).\n",
    "# Same embedding (best-for-metadata for SSL) used on both axes where applicable;\n",
    "# perception r here uses df[f'{m}_cosim'] (the main-benchmark best-for-perception\n",
    "# embedding) so the Y axis matches what Section 3 reports.\n",
    "# ============================================================\n",
    "set_c = metadata_df[metadata_df['set'] == 'C: Types 1-5 (extended)'].set_index('model')\n",
    "\n",
    "sub_15 = df[df['stimuli_type'].isin([1, 2, 3, 4, 5])]\n",
    "perception_r = {}\n",
    "for m in available_models:\n",
    "    col = f'{m}_cosim'\n",
    "    v = sub_15.dropna(subset=[col, 'p_same_full'])\n",
    "    if len(v) < 10:\n",
    "        continue\n",
    "    r, _ = pearsonr(v[col], v['p_same_full'])\n",
    "    perception_r[m] = r\n",
    "\n",
    "TYPE_COLOR_M4 = {\n",
    "    'Supervised':        '#2196F3',\n",
    "    'Self-supervised':   '#FF9800',\n",
    "    'Weakly supervised': '#9C27B0',\n",
    "}\n",
    "fig, ax = plt.subplots(figsize=(8.8, 5.8))\n",
    "for m in available_models:\n",
    "    if m not in set_c.index or m not in perception_r:\n",
    "        continue\n",
    "    x = set_c.loc[m, 'AUC_meta']\n",
    "    y = perception_r[m]\n",
    "    ptype = MODEL_INFO[m]['type']\n",
    "    ax.scatter(x, y, s=140, color=TYPE_COLOR_M4[ptype], edgecolor='black',\n",
    "               linewidth=1.2, zorder=5)\n",
    "    ax.annotate(m, xy=(x, y), xytext=(7, 7), textcoords='offset points', fontsize=10)\n",
    "\n",
    "ax.set_xlabel('AUC on metadata labels (Set C, Types 1\u20135)')\n",
    "ax.set_ylabel('Pearson r with human P(same) (Types 1\u20135)')\n",
    "from matplotlib.patches import Patch\n",
    "ax.legend(handles=[Patch(color=TYPE_COLOR_M4[t], label=t) for t in TYPE_COLOR_M4],\n",
    "          loc='lower right', frameon=True)\n",
    "for spine in ('top', 'right'):\n",
    "    ax.spines[spine].set_visible(False)\n",
    "plt.tight_layout()\n",
    "plt.savefig('manuscript/figures/metadata_vs_perception.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()\n",
    "\n",
    "cmp_rows = []\n",
    "for m in available_models:\n",
    "    if m not in set_c.index or m not in perception_r:\n",
    "        continue\n",
    "    cmp_rows.append({\n",
    "        'model': m, 'type': MODEL_INFO[m]['type'],\n",
    "        'EER_C': set_c.loc[m, 'EER'], 'AUC_meta_C': set_c.loc[m, 'AUC_meta'],\n",
    "        'Pearson_r_perc': perception_r[m],\n",
    "    })\n",
    "cmp_df = pd.DataFrame(cmp_rows)\n",
    "print('Model rankings under metadata vs perception:')\n",
    "print('\\nSorted by metadata AUC (desc):')\n",
    "print(cmp_df.sort_values('AUC_meta_C', ascending=False).round(4).to_string(index=False))\n",
    "print('\\nSorted by perception Pearson r (desc):')\n",
    "print(cmp_df.sort_values('Pearson_r_perc', ascending=False).round(4).to_string(index=False))\n",
    "rho, _ = spearmanr(cmp_df['AUC_meta_C'], cmp_df['Pearson_r_perc'])\n",
    "print(f'\\nSpearman rank correlation (metadata AUC vs perception r): {rho:.4f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part I.5: Interpretation\n",
    "\n",
    "**Metadata performance establishes baseline legitimacy.** On the VoxCeleb-comparable Set A (Type 2 same-speaker + Type 4 different-speaker), top supervised embeddings reach VoxCeleb-quality numbers: TitaNet EER = 1.6%, ECAPA-TDNN EER = 1.6%, RawNet3 EER = 1.9%. x-vector (11.1%) and resemblyzer (12.0%) are weaker but still strongly metadata-aligned (AUC \u2265 0.95). With per-task best-layer selection, SSL models reach EER = 26-32%; Whisper reaches 37.5%. This ordering matches speaker-verification literature: the models *do* work on the traditional task.\n",
    "\n",
    "**The dataset departs from metadata primarily through voice clones.** On Type 3 (same-speaker AI voice clones, labeled metadata=same), the crowd majority says **different** on 42% of pairs; median P(same) is 0.60. On other types, majority-vs-metadata disagreement is 0-19%. Overall, 27% of metadata=same pairs are judged as different by majority vote, and this divergence is concentrated in clones. This is the primary signal that the perception target is not a noisier version of metadata: it captures something different, specifically the cases where a cloned voice is acoustically the target speaker by ground truth yet is not heard that way.\n",
    "\n",
    "**Model rankings differ under metadata vs perception.** The Spearman correlation between AUC-on-metadata and Pearson-r-on-perception is 0.85 across the 10 models, so the rough ordering is preserved. But there are visible flips near the top: **resemblyzer is 5th on metadata AUC (0.949) yet 1st on perception r (0.804)**; TitaNet tops metadata but is 2nd on perception. The model that looks best on a VoxCeleb-style scoreboard is not the model best aligned with listeners.\n",
    "\n",
    "**For the paper.** These results support a three-beat narrative: (i) top supervised embeddings pass the traditional metadata test as expected; (ii) the benchmark's dataset departs from metadata primarily on voice clones, where 42% of metadata=same pairs are heard as different; (iii) model rankings under the perception target are not identical to metadata, so the two benchmarks are not interchangeable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "part_II_divider",
   "metadata": {},
   "source": [
    "---\n",
    "# Part II \u2014 Core Benchmark Tasks\n",
    "\n",
    "Three complementary tasks evaluate whether models predict human voice-identity perception: a continuous regression task (P(same) prediction), a binary verification task with calibration (AUC + Platt-scaled ECE), and a representational-structure task at the speaker-pair level (RDM with Mantel test). Together they probe discrimination, confidence calibration, and population-level structure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_015",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 3: Task 1 -- Predict Human P(same)\n",
    "\n",
    "**Task definition:** For each of the 9,800 pairs, the model provides a cosine similarity score, and humans provide P(same). We ask: how well does the model's continuous similarity score predict the continuous human judgment?\n",
    "\n",
    "**Metrics:**\n",
    "- **Pearson r:** Linear correlation between cosine similarity and P(same). Measures how well a linear function of model similarity predicts human perception.\n",
    "- **Spearman rho:** Rank correlation. Measures whether the model correctly orders pairs by perceived similarity, regardless of the functional form.\n",
    "- **R-squared:** Proportion of variance in P(same) explained by cosine similarity: $R^2 = r^2$.\n",
    "\n",
    "**Bootstrap confidence intervals** (1,000 resamples of pairs) quantify the precision of each estimate.\n",
    "\n",
    "**Per-stimulus-type breakdown** reveals whether models perform uniformly or have systematic blind spots (e.g., good on real speech but poor on clones).\n",
    "\n",
    "**Full vs. Qualified comparison** tests whether participant filtering affects the results -- if it does, it suggests that low-engagement participants add noise that inflates or deflates alignment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cell_016",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:27.633418Z",
     "iopub.status.busy": "2026-04-22T16:23:27.633018Z",
     "iopub.status.idle": "2026-04-22T16:23:27.711885Z",
     "shell.execute_reply": "2026-04-22T16:23:27.709800Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overall model-human alignment (full 1,290-participant dataset):\n",
      "      model        model_type  pearson_r  spearman_rho  r_squared    n\n",
      "resemblyzer        Supervised     0.6557        0.6682     0.4299 9800\n",
      " ecapa_tdnn        Supervised     0.6456        0.6410     0.4168 9800\n",
      "    titanet        Supervised     0.6381        0.6390     0.4072 9800\n",
      "    rawnet3        Supervised     0.6171        0.6229     0.3809 9800\n",
      "    xvector        Supervised     0.5973        0.6426     0.3568 9800\n",
      "      wavlm   Self-supervised     0.5098        0.5121     0.2599 9800\n",
      "   wav2vec2   Self-supervised     0.4714        0.4817     0.2222 9800\n",
      "       xlsr   Self-supervised     0.4651        0.5080     0.2163 9800\n",
      "     hubert   Self-supervised     0.4577        0.4773     0.2095 9800\n",
      "    whisper Weakly supervised     0.2258        0.2698     0.0510 9800\n"
     ]
    }
   ],
   "source": [
    "# Overall correlation: each model's cosine similarity vs human P(same)\n",
    "def compute_correlations(df, model_name, target_col='p_same_full'):\n",
    "    col = f'{model_name}_cosim'\n",
    "    valid = df.dropna(subset=[col, target_col])\n",
    "    if len(valid) < 10:\n",
    "        return {'pearson_r': np.nan, 'spearman_rho': np.nan, 'r_squared': np.nan, 'n': 0}\n",
    "    pr, pp = pearsonr(valid[col], valid[target_col])\n",
    "    sr, sp = spearmanr(valid[col], valid[target_col])\n",
    "    return {'pearson_r': pr, 'spearman_rho': sr, 'r_squared': pr**2, 'n': len(valid)}\n",
    "\n",
    "results_overall = []\n",
    "for model_name in available_models:\n",
    "    corrs = compute_correlations(df, model_name, 'p_same_full')\n",
    "    corrs['model'] = model_name\n",
    "    corrs['model_type'] = MODEL_INFO[model_name]['type']\n",
    "    results_overall.append(corrs)\n",
    "\n",
    "results_df = pd.DataFrame(results_overall).sort_values('pearson_r', ascending=False)\n",
    "print('Overall model-human alignment (full 1,290-participant dataset):')\n",
    "print(results_df[['model', 'model_type', 'pearson_r', 'spearman_rho', 'r_squared', 'n']].round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_017",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:27.715155Z",
     "iopub.status.busy": "2026-04-22T16:23:27.714865Z",
     "iopub.status.idle": "2026-04-22T16:23:32.710602Z",
     "shell.execute_reply": "2026-04-22T16:23:32.708484Z"
    }
   },
   "outputs": [],
   "source": [
    "# Bootstrap Pearson r with 95% CIs for each model (full dataset)\n",
    "N_BOOT = 1000\n",
    "boot_results = {}\n",
    "\n",
    "for model_name in available_models:\n",
    "    col = f'{model_name}_cosim'\n",
    "    valid = df.dropna(subset=[col, 'p_same_full'])\n",
    "    x = valid[col].values\n",
    "    y = valid['p_same_full'].values\n",
    "\n",
    "    boot_r = np.zeros(N_BOOT)\n",
    "    for b in range(N_BOOT):\n",
    "        idx = rng.integers(0, len(x), size=len(x))\n",
    "        boot_r[b], _ = pearsonr(x[idx], y[idx])\n",
    "\n",
    "    ci_lo, ci_hi = np.percentile(boot_r, [2.5, 97.5])\n",
    "    boot_results[model_name] = {'mean': np.mean(boot_r), 'ci_lo': ci_lo, 'ci_hi': ci_hi}\n",
    "\n",
    "# Bar chart with CIs -- three paradigm colors\n",
    "TYPE_COLOR = {\n",
    "    'Supervised':        '#2196F3',   # blue\n",
    "    'Self-supervised':   '#FF9800',   # orange\n",
    "    'Weakly supervised': '#9C27B0',   # purple\n",
    "}\n",
    "fig, ax = plt.subplots(figsize=(10, 5))\n",
    "models_sorted = sorted(available_models, key=lambda m: boot_results[m]['mean'], reverse=True)\n",
    "colors = [TYPE_COLOR[MODEL_INFO[m]['type']] for m in models_sorted]\n",
    "means = [boot_results[m]['mean'] for m in models_sorted]\n",
    "errs_lo = [boot_results[m]['mean'] - boot_results[m]['ci_lo'] for m in models_sorted]\n",
    "errs_hi = [boot_results[m]['ci_hi'] - boot_results[m]['mean'] for m in models_sorted]\n",
    "\n",
    "ax.barh(range(len(models_sorted)), means, xerr=[errs_lo, errs_hi],\n",
    "        color=colors, capsize=4, edgecolor='white')\n",
    "ax.set_yticks(range(len(models_sorted)))\n",
    "DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "ax.set_yticklabels([DISPLAY_NAME[m] for m in models_sorted])\n",
    "ax.set_xlabel('Pearson r with Human P(same)')\n",
    "\n",
    "from matplotlib.patches import Patch\n",
    "ax.legend(handles=[Patch(color=TYPE_COLOR['Supervised'],        label='Supervised'),\n",
    "                   Patch(color=TYPE_COLOR['Self-supervised'],   label='Self-supervised'),\n",
    "                   Patch(color=TYPE_COLOR['Weakly supervised'], label='Weakly supervised')],\n",
    "          loc='lower right')\n",
    "ax.invert_yaxis()\n",
    "plt.tight_layout()\n",
    "import os\n",
    "os.makedirs('manuscript/figures', exist_ok=True)\n",
    "plt.savefig('manuscript/figures/pearson_bar.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cell_019",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:32.713817Z",
     "iopub.status.busy": "2026-04-22T16:23:32.713501Z",
     "iopub.status.idle": "2026-04-22T16:23:32.990689Z",
     "shell.execute_reply": "2026-04-22T16:23:32.988669Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pearson r by stimulus type:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Type 1</th>\n",
       "      <th>Type 2</th>\n",
       "      <th>Type 3</th>\n",
       "      <th>Type 4</th>\n",
       "      <th>Type 5</th>\n",
       "      <th>Type 6</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>model</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>ecapa_tdnn</th>\n",
       "      <td>0.348</td>\n",
       "      <td>0.581</td>\n",
       "      <td>0.453</td>\n",
       "      <td>0.365</td>\n",
       "      <td>0.306</td>\n",
       "      <td>0.598</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>hubert</th>\n",
       "      <td>0.173</td>\n",
       "      <td>0.414</td>\n",
       "      <td>0.366</td>\n",
       "      <td>0.342</td>\n",
       "      <td>0.320</td>\n",
       "      <td>0.417</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>rawnet3</th>\n",
       "      <td>0.180</td>\n",
       "      <td>0.497</td>\n",
       "      <td>0.336</td>\n",
       "      <td>0.386</td>\n",
       "      <td>0.314</td>\n",
       "      <td>0.571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>resemblyzer</th>\n",
       "      <td>0.286</td>\n",
       "      <td>0.650</td>\n",
       "      <td>0.513</td>\n",
       "      <td>0.520</td>\n",
       "      <td>0.463</td>\n",
       "      <td>0.607</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>titanet</th>\n",
       "      <td>0.246</td>\n",
       "      <td>0.612</td>\n",
       "      <td>0.498</td>\n",
       "      <td>0.409</td>\n",
       "      <td>0.316</td>\n",
       "      <td>0.585</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wav2vec2</th>\n",
       "      <td>0.247</td>\n",
       "      <td>0.403</td>\n",
       "      <td>0.360</td>\n",
       "      <td>0.364</td>\n",
       "      <td>0.305</td>\n",
       "      <td>0.435</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>wavlm</th>\n",
       "      <td>0.318</td>\n",
       "      <td>0.453</td>\n",
       "      <td>0.413</td>\n",
       "      <td>0.392</td>\n",
       "      <td>0.318</td>\n",
       "      <td>0.467</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>whisper</th>\n",
       "      <td>-0.084</td>\n",
       "      <td>-0.007</td>\n",
       "      <td>0.064</td>\n",
       "      <td>0.063</td>\n",
       "      <td>0.090</td>\n",
       "      <td>0.216</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>xlsr</th>\n",
       "      <td>0.304</td>\n",
       "      <td>0.510</td>\n",
       "      <td>0.414</td>\n",
       "      <td>0.361</td>\n",
       "      <td>0.325</td>\n",
       "      <td>0.426</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>xvector</th>\n",
       "      <td>0.232</td>\n",
       "      <td>0.558</td>\n",
       "      <td>0.451</td>\n",
       "      <td>0.472</td>\n",
       "      <td>0.370</td>\n",
       "      <td>0.550</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Type 1  Type 2  Type 3  Type 4  Type 5  Type 6\n",
       "model                                                      \n",
       "ecapa_tdnn    0.348   0.581   0.453   0.365   0.306   0.598\n",
       "hubert        0.173   0.414   0.366   0.342   0.320   0.417\n",
       "rawnet3       0.180   0.497   0.336   0.386   0.314   0.571\n",
       "resemblyzer   0.286   0.650   0.513   0.520   0.463   0.607\n",
       "titanet       0.246   0.612   0.498   0.409   0.316   0.585\n",
       "wav2vec2      0.247   0.403   0.360   0.364   0.305   0.435\n",
       "wavlm         0.318   0.453   0.413   0.392   0.318   0.467\n",
       "whisper      -0.084  -0.007   0.064   0.063   0.090   0.216\n",
       "xlsr          0.304   0.510   0.414   0.361   0.325   0.426\n",
       "xvector       0.232   0.558   0.451   0.472   0.370   0.550"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Per-stimulus-type Pearson r\n",
    "type_corr_rows = []\n",
    "for model_name in available_models:\n",
    "    for stype in sorted(df['stimuli_type'].unique()):\n",
    "        sub = df[df['stimuli_type'] == stype]\n",
    "        corrs = compute_correlations(sub, model_name, 'p_same_full')\n",
    "        type_corr_rows.append({\n",
    "            'model': model_name,\n",
    "            'type': stype,\n",
    "            'pearson_r': corrs['pearson_r'],\n",
    "            'n': corrs['n']\n",
    "        })\n",
    "\n",
    "type_corr_df = pd.DataFrame(type_corr_rows)\n",
    "pivot = type_corr_df.pivot(index='model', columns='type', values='pearson_r').round(3)\n",
    "pivot.columns = [f'Type {c}' for c in pivot.columns]\n",
    "print('Pearson r by stimulus type:')\n",
    "pivot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_020_interp",
   "metadata": {},
   "source": [
    "### Section 3: Interpretation\n",
    "\n",
    "**Supervised models hold a modest but robust lead over SSL models.** Full-dataset Pearson r values:\n",
    "- Supervised: resemblyzer (r=0.656), ECAPA-TDNN (r=0.646), TitaNet (r=0.638), RawNet3 (r=0.617), x-vector (r=0.597).\n",
    "- SSL (best-layer via nested CV): WavLM (r=0.510), wav2vec2 (r=0.471), XLS-R (r=0.465), HuBERT (r=0.458).\n",
    "- Whisper (r=0.226) is far below the rest.\n",
    "\n",
    "The best supervised model exceeds the best SSL model by 0.15 in Pearson r. This is substantially smaller than the 0.38 gap that a naive last-layer-only SSL protocol would imply (Section 13).\n",
    "\n",
    "**Top supervised models cluster tightly.** Section 9's paired-bootstrap significance tests show resemblyzer vs ECAPA-TDNN is only marginally significant under Benjamini-Hochberg FDR control (diff=0.010, BH q=0.049). All other supervised-vs-supervised and supervised-vs-SSL differences are highly significant (BH q $\\ll$ 0.05).\n",
    "\n",
    "**Per-type breakdown.** All models perform worst on Type 1 (restricted P(same) variance near ceiling). Type 6 (blended voices) elicits the strongest correlations due to wide P(same) variance. Type 3 (clones) shows intermediate difficulty.\n",
    "\n",
    "**Noise ceiling.** The reliability-derived ceiling on R\u00b2 is 0.705. The best model (resemblyzer, R\u00b2 = 0.430) reaches **61% of the achievable ceiling**, leaving meaningful headroom that Section 10 attributes primarily to individual-listener variability rather than representational inadequacy."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_021",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 4: Task 2 -- Human-Aligned Verification (Binary)\n",
    "\n",
    "**Task definition:** Convert the continuous P(same) to a binary label via human majority vote: a pair is labeled \"same\" if P(same) > 0.5, and \"different\" otherwise. Pairs with exactly P(same) = 0.5 are excluded. We then evaluate each model as a binary classifier using its cosine similarity as the decision score.\n",
    "\n",
    "**Metrics:**\n",
    "- **AUC (Area Under ROC Curve):** The probability that the model assigns a higher cosine similarity to a randomly chosen \"same\" pair than a randomly chosen \"different\" pair. AUC = 0.5 is chance, 1.0 is perfect.\n",
    "- **Accuracy at optimal threshold:** Using Youden's J statistic ($J = \\text{TPR} - \\text{FPR}$), we find the cosine similarity threshold that maximizes the sum of sensitivity and specificity.\n",
    "- **Expected Calibration Error (ECE):** Cosine similarity is not a probability (range [-1, 1], and in practice concentrated near the high end), so comparing it directly to empirical agreement conflates *representation quality* with *scale*. We therefore compute ECE in two ways:\n",
    "  1. **ECE_raw**: raw $|{\\overline{\\text{cosim}}_b - \\overline{P(\\text{same})}_b}|$ within cosine-sim bins. Penalizes any scale mismatch.\n",
    "  2. **ECE_calibrated**: we first fit **Platt scaling** (logistic regression `P(same) ~ sigmoid(a \\cdot cosim + b)`) using 10-fold speaker-level cross-validation, then compute standard ECE on the calibrated probabilities. This isolates calibration quality from scale.\n",
    "\n",
    "$$\\text{ECE} = \\sum_{b=1}^{B} \\frac{n_b}{N} \\left| \\overline{p}_b - \\overline{y}_b \\right|$$\n",
    "\n",
    "where $\\overline{p}_b$ is the mean predicted probability and $\\overline{y}_b$ is the empirical label frequency in bin $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_022",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:32.994050Z",
     "iopub.status.busy": "2026-04-22T16:23:32.993700Z",
     "iopub.status.idle": "2026-04-22T16:23:33.675122Z",
     "shell.execute_reply": "2026-04-22T16:23:33.672501Z"
    }
   },
   "outputs": [],
   "source": [
    "# ROC curves and AUC\n",
    "# Exclude pairs where exactly 50% said same (ties)\n",
    "df_binary = df[(df['p_same_full'] != 0.5) & df['p_same_full'].notna()].copy()\n",
    "y_true = df_binary['majority_full'].values\n",
    "\n",
    "DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "fig, ax = plt.subplots(figsize=(8, 7))\n",
    "auc_results = {}\n",
    "\n",
    "for model_name in available_models:\n",
    "    col = f'{model_name}_cosim'\n",
    "    valid = df_binary.dropna(subset=[col])\n",
    "    if len(valid) < 10:\n",
    "        continue\n",
    "    y = valid['majority_full'].values\n",
    "    scores = valid[col].values\n",
    "    fpr, tpr, thresholds = roc_curve(y, scores)\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    auc_results[model_name] = roc_auc\n",
    "    \n",
    "    # Optimal threshold (Youden's J)\n",
    "    j_scores = tpr - fpr\n",
    "    opt_idx = np.argmax(j_scores)\n",
    "    opt_thresh = thresholds[opt_idx]\n",
    "    y_pred = (scores >= opt_thresh).astype(int)\n",
    "    acc = accuracy_score(y, y_pred)\n",
    "    \n",
    "    label = f'{DISPLAY_NAME[model_name]} (AUC={roc_auc:.3f})'\n",
    "    ax.plot(fpr, tpr, label=label, linewidth=1.5)\n",
    "\n",
    "ax.plot([0, 1], [0, 1], 'k--', alpha=0.3)\n",
    "ax.set_xlabel('False Positive Rate')\n",
    "ax.set_ylabel('True Positive Rate')\n",
    "ax.legend(fontsize=8, loc='lower right')\n",
    "plt.tight_layout()\n",
    "plt.savefig('manuscript/figures/roc_curves.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_023",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:33.678588Z",
     "iopub.status.busy": "2026-04-22T16:23:33.678192Z",
     "iopub.status.idle": "2026-04-22T16:23:36.655011Z",
     "shell.execute_reply": "2026-04-22T16:23:36.652827Z"
    }
   },
   "outputs": [],
   "source": [
    "# Calibration analysis with Platt scaling and standard ECE (cached)\n",
    "\n",
    "N_BINS = 10\n",
    "\n",
    "# Build the same 10 folds as elsewhere\n",
    "all_speakers = sorted(df['reference'].unique())\n",
    "_male = [s for s in all_speakers if s.startswith('M')]\n",
    "_female = [s for s in all_speakers if s.startswith('F')]\n",
    "_rng_cal = np.random.default_rng(SEED)\n",
    "_rng_cal.shuffle(_male); _rng_cal.shuffle(_female)\n",
    "folds = [[] for _ in range(10)]\n",
    "for i, s in enumerate(_male): folds[i % 10].append(s)\n",
    "for i, s in enumerate(_female): folds[i % 10].append(s)\n",
    "\n",
    "def platt_calibrate_cv(scores, labels, speakers, folds):\n",
    "    probs = np.full_like(scores, np.nan, dtype=float)\n",
    "    for fold in folds:\n",
    "        test_mask = np.isin(speakers, fold)\n",
    "        train_mask = ~test_mask\n",
    "        if train_mask.sum() < 10 or test_mask.sum() < 1:\n",
    "            continue\n",
    "        lr = LogisticRegression(max_iter=1000)\n",
    "        lr.fit(scores[train_mask].reshape(-1, 1), labels[train_mask])\n",
    "        probs[test_mask] = lr.predict_proba(scores[test_mask].reshape(-1, 1))[:, 1]\n",
    "    return probs\n",
    "\n",
    "def _compute_calibration():\n",
    "    ece_r = {}\n",
    "    ece_c = {}\n",
    "    probs_all = {}\n",
    "    for model_name in available_models:\n",
    "        col = f'{model_name}_cosim'\n",
    "        valid = df.dropna(subset=[col, 'p_same_full', 'majority_full']).copy()\n",
    "        if len(valid) < 10:\n",
    "            continue\n",
    "        # Raw ECE\n",
    "        valid['bin_raw'] = pd.qcut(valid[col], N_BINS, duplicates='drop')\n",
    "        cal_raw = valid.groupby('bin_raw', observed=True).agg(\n",
    "            mean_score=(col, 'mean'),\n",
    "            mean_psame=('p_same_full', 'mean'),\n",
    "            count=('id', 'count'))\n",
    "        ece_r[model_name] = (cal_raw['count'] / cal_raw['count'].sum() *\n",
    "                             (cal_raw['mean_psame'] - cal_raw['mean_score']).abs()).sum()\n",
    "        # Platt\n",
    "        scores = valid[col].values\n",
    "        labels = valid['majority_full'].values.astype(int)\n",
    "        spk_arr = valid['reference'].values\n",
    "        probs = platt_calibrate_cv(scores, labels, spk_arr, folds)\n",
    "        valid['prob_calibrated'] = probs\n",
    "        v2 = valid.dropna(subset=['prob_calibrated'])\n",
    "        probs_all[model_name] = v2[['id', 'prob_calibrated']].set_index('id')\n",
    "        v2 = v2.copy()\n",
    "        v2['bin_cal'] = pd.qcut(v2['prob_calibrated'], N_BINS, duplicates='drop')\n",
    "        cal_std = v2.groupby('bin_cal', observed=True).agg(\n",
    "            mean_prob=('prob_calibrated', 'mean'),\n",
    "            mean_label=('majority_full', 'mean'),\n",
    "            count=('id', 'count'))\n",
    "        ece_c[model_name] = (cal_std['count'] / cal_std['count'].sum() *\n",
    "                             (cal_std['mean_label'] - cal_std['mean_prob']).abs()).sum()\n",
    "    return {'ece_raw': ece_r, 'ece_cal': ece_c, 'probs': probs_all}\n",
    "\n",
    "cal_result = cached('calibration', _compute_calibration, 'Platt scaling + ECE for all models')\n",
    "ece_raw_results = cal_result['ece_raw']\n",
    "ece_results = cal_result['ece_cal']\n",
    "calibrated_prob = cal_result['probs']\n",
    "\n",
    "# Plot calibrated reliability diagrams\n",
    "n_models = len(available_models)\n",
    "ncols = min(5, n_models)\n",
    "nrows = (n_models + ncols - 1) // ncols\n",
    "DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "fig, axes = plt.subplots(nrows, ncols, figsize=(3.5 * ncols, 3.5 * nrows))\n",
    "axes = np.atleast_1d(axes).flatten()\n",
    "\n",
    "for idx, model_name in enumerate(available_models):\n",
    "    ax = axes[idx]\n",
    "    if model_name not in calibrated_prob:\n",
    "        ax.set_visible(False); continue\n",
    "    valid = df.merge(calibrated_prob[model_name], left_on='id', right_index=True, how='inner')\n",
    "    valid = valid.dropna(subset=['prob_calibrated', 'majority_full']).copy()\n",
    "    valid['bin'] = pd.qcut(valid['prob_calibrated'], N_BINS, duplicates='drop')\n",
    "    cal = valid.groupby('bin', observed=True).agg(\n",
    "        mean_prob=('prob_calibrated', 'mean'),\n",
    "        mean_label=('majority_full', 'mean'))\n",
    "    ax.plot([0, 1], [0, 1], 'k--', alpha=0.3)\n",
    "    ax.plot(cal['mean_prob'], cal['mean_label'], 'o-', color='#1565C0', markersize=5)\n",
    "    ax.set_xlabel('Predicted prob (Platt)'); ax.set_ylabel('Empirical freq')\n",
    "    ax.set_xlim(0, 1); ax.set_ylim(0, 1)\n",
    "    ax.set_title(DISPLAY_NAME[model_name], fontsize=10)\n",
    "\n",
    "for j in range(len(available_models), len(axes)):\n",
    "    axes[j].set_visible(False)\n",
    "plt.tight_layout()\n",
    "plt.savefig('manuscript/figures/calibration_1.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()\n",
    "\n",
    "ece_comp = pd.DataFrame([\n",
    "    {'model': m, 'type': MODEL_INFO[m]['type'],\n",
    "     'ECE_raw (cosim vs P(same))': ece_raw_results.get(m, np.nan),\n",
    "     'ECE_calibrated (Platt prob)': ece_results.get(m, np.nan)}\n",
    "    for m in available_models\n",
    "]).sort_values('ECE_calibrated (Platt prob)')\n",
    "print('Raw vs Platt-calibrated ECE:')\n",
    "print(ece_comp.round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "cell_024",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:36.657872Z",
     "iopub.status.busy": "2026-04-22T16:23:36.657601Z",
     "iopub.status.idle": "2026-04-22T16:23:36.721538Z",
     "shell.execute_reply": "2026-04-22T16:23:36.718999Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Human-Aligned Verification Results (Platt-scaled ECE):\n",
      "      model              type    AUC  Acc@opt  Threshold  ECE_raw  ECE_calibrated\n",
      "resemblyzer        Supervised 0.8722   0.7974     0.7627   0.3377          0.0266\n",
      " ecapa_tdnn        Supervised 0.8621   0.7882     0.4385   0.0470          0.0180\n",
      "    titanet        Supervised 0.8614   0.7824     0.4555   0.0575          0.0195\n",
      "    xvector        Supervised 0.8573   0.7743     0.9533   0.5482          0.1357\n",
      "    rawnet3        Supervised 0.8511   0.7824     0.5397   0.0862          0.0206\n",
      "      wavlm   Self-supervised 0.7897   0.7041     0.6943   0.2716          0.0217\n",
      "       xlsr   Self-supervised 0.7817   0.6962     0.9082   0.5017          0.0608\n",
      "   wav2vec2   Self-supervised 0.7703   0.7107     0.7647   0.3357          0.0329\n",
      "     hubert   Self-supervised 0.7653   0.7222     0.7635   0.3169          0.0346\n",
      "    whisper Weakly supervised 0.6505   0.6430     0.9949   0.5944          0.0372\n"
     ]
    }
   ],
   "source": [
    "# Summary table: AUC, accuracy, raw ECE, calibrated ECE per model\n",
    "verification_rows = []\n",
    "for model_name in available_models:\n",
    "    col = f'{model_name}_cosim'\n",
    "    valid = df_binary.dropna(subset=[col])\n",
    "    if len(valid) < 10:\n",
    "        continue\n",
    "    y = valid['majority_full'].values\n",
    "    scores = valid[col].values\n",
    "    \n",
    "    fpr, tpr, thresholds = roc_curve(y, scores)\n",
    "    roc_auc = auc(fpr, tpr)\n",
    "    opt_idx = np.argmax(tpr - fpr)\n",
    "    opt_thresh = thresholds[opt_idx]\n",
    "    y_pred = (scores >= opt_thresh).astype(int)\n",
    "    acc = accuracy_score(y, y_pred)\n",
    "    \n",
    "    verification_rows.append({\n",
    "        'model': model_name,\n",
    "        'type': MODEL_INFO[model_name]['type'],\n",
    "        'AUC': roc_auc,\n",
    "        'Acc@opt': acc,\n",
    "        'Threshold': opt_thresh,\n",
    "        'ECE_raw': ece_raw_results.get(model_name, np.nan),\n",
    "        'ECE_calibrated': ece_results.get(model_name, np.nan)\n",
    "    })\n",
    "\n",
    "verif_df = pd.DataFrame(verification_rows).sort_values('AUC', ascending=False)\n",
    "print('Human-Aligned Verification Results (Platt-scaled ECE):')\n",
    "print(verif_df.round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_024_interp",
   "metadata": {},
   "source": [
    "### Section 4: Interpretation\n",
    "\n",
    "**AUC** (against full-dataset majority vote) places supervised models highest: resemblyzer 0.872, ECAPA-TDNN 0.862, TitaNet 0.861, x-vector 0.857, RawNet3 0.851. Best-layer SSL models cluster at AUC 0.77-0.79 (WavLM 0.790, XLS-R 0.782, wav2vec2 0.770, HuBERT 0.765). Whisper is at 0.651. The supervised lead in AUC is about 0.07-0.11 -- meaningful but not categorical.\n",
    "\n",
    "**Raw ECE is dominated by scale mismatch.** Models with similarity distributions concentrated in a narrow high-value range show high raw ECE regardless of representation quality, so raw ECE is not a meaningful comparison metric.\n",
    "\n",
    "**Platt-calibrated ECE reveals the real calibration picture:**\n",
    "- Four supervised models achieve excellent calibration (ECE_cal 0.018-0.027): ECAPA-TDNN (0.018), TitaNet (0.020), RawNet3 (0.021), resemblyzer (0.027).\n",
    "- Three SSL models match or beat most supervised models after calibration: WavLM (0.022), wav2vec2 (0.033), HuBERT (0.035), Whisper (0.037). The best-layer SSL protocol substantially improved SSL calibration relative to the last-layer default.\n",
    "- XLS-R has mid-range calibration (0.061) despite strong AUC.\n",
    "- **x-vector is the lone outlier** (ECE_cal = 0.136) -- an order of magnitude worse than the best-calibrated supervised models. Even Platt scaling cannot fully fix its confidence shape, suggesting a non-sigmoidal pathology in its cosine-similarity distribution.\n",
    "\n",
    "**Practical takeaway:** For deployment, always Platt-calibrate cosine similarities on held-out data. Most models then provide trustworthy probabilities; x-vector is the exception and may require isotonic regression or a more flexible calibrator."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_025",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 5: Task 3 -- Speaker-Level Representational Similarity Analysis\n",
    "\n",
    "**Motivation:** Pair-level Spearman rank correlation (Section 3) is mathematically identical to a naive RSA over the same 9,800 pairs, because `spearmanr(1-y, 1-x) = spearmanr(y, x)`. To get a genuinely different analysis, we aggregate to the **speaker-pair level**: for each ordered pair of speakers $(A, B)$ we compute a mean P(same) and mean cosine similarity across trials. The benchmark only contains between-speaker pairs within the same sociophonetic group, so off-diagonal cells are populated for within-group (A, B) pairs only. Diagonal cells (ref = comp) are excluded because same-speaker cells (dissim \u2248 0.1\u20130.4) sit in a different range from different-speaker cells (dissim \u2248 0.7\u20130.9) in both the human and the model RDM; including them would inflate the Spearman correlation via this cluster gap and mask the between-speaker geometry we want to measure.\n",
    "\n",
    "**Stimulus-type selection.** Off-diagonal cells can be populated from Types 4, 5, and/or 6. We use **only Types 4 and 5** (real and cloned different-speaker, 1 stimulus each per cell = 2 stimuli per cell). Type 6 (morphed) stimuli are excluded because a morph at scale 0.5 is neither $A$ nor $B$, so the \"comp speaker $B$\" label does not cleanly apply; aggregating Type 6 into cell $[A, B]$ would conflate speaker-pair geometry with morph-trajectory geometry. Morph-trajectory alignment is characterized separately via the scale-by-scale Type 6 curves (supplementary figure).\n",
    "\n",
    "**Human RDM:** $\\text{RDM}_{\\text{human}}[A, B] = 1 - \\text{mean}_{\\text{Types 4-5}} P(\\text{same} \\mid \\text{ref}=A, \\text{comp}=B)$\n",
    "\n",
    "**Model RDM:** $\\text{RDM}_{\\text{model}}[A, B] = 1 - \\text{mean}_{\\text{Types 4-5}} \\text{cosim}(\\mathbf{e}_{\\text{ref}}, \\mathbf{e}_{\\text{comp}})$\n",
    "\n",
    "Each RDM is a 400-entry vector (within-group off-diagonal cells). We compute the **Spearman correlation** between the human and model RDMs. Significance is assessed with a **Mantel permutation test** (5,000 permutations of the model-side vector; two-sided p-value).\n",
    "\n",
    "**Why this is different from Section 3:** Section 3 operates at the level of individual stimulus pairs. Section 5 collapses within-pair variation to the speaker-pair level and asks whether the model captures the coarse population map of within-group speakers. SSL models are expected to be weaker here because their coarse speaker structure was never explicitly trained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "cell_026",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:36.724546Z",
     "iopub.status.busy": "2026-04-22T16:23:36.724276Z",
     "iopub.status.idle": "2026-04-22T16:23:36.901388Z",
     "shell.execute_reply": "2026-04-22T16:23:36.899533Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unique reference speakers: 100\n",
      "Unique comparison speakers: 100\n",
      "\n",
      "RDM entries: 400 (Types 4+5 off-diagonal, within-group)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>reference</th>\n",
       "      <th>comp_speaker</th>\n",
       "      <th>p_same_full</th>\n",
       "      <th>rawnet3_cosim</th>\n",
       "      <th>ecapa_tdnn_cosim</th>\n",
       "      <th>titanet_cosim</th>\n",
       "      <th>resemblyzer_cosim</th>\n",
       "      <th>xvector_cosim</th>\n",
       "      <th>wav2vec2_cosim</th>\n",
       "      <th>hubert_cosim</th>\n",
       "      <th>wavlm_cosim</th>\n",
       "      <th>whisper_cosim</th>\n",
       "      <th>xlsr_cosim</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>F01</td>\n",
       "      <td>F02</td>\n",
       "      <td>0.227778</td>\n",
       "      <td>-0.096190</td>\n",
       "      <td>-0.121267</td>\n",
       "      <td>-0.246967</td>\n",
       "      <td>0.515382</td>\n",
       "      <td>0.903451</td>\n",
       "      <td>0.649076</td>\n",
       "      <td>0.630006</td>\n",
       "      <td>0.627535</td>\n",
       "      <td>0.992281</td>\n",
       "      <td>0.876186</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>F01</td>\n",
       "      <td>F03</td>\n",
       "      <td>0.092857</td>\n",
       "      <td>0.047201</td>\n",
       "      <td>-0.068396</td>\n",
       "      <td>-0.175500</td>\n",
       "      <td>0.642626</td>\n",
       "      <td>0.915991</td>\n",
       "      <td>0.772310</td>\n",
       "      <td>0.754791</td>\n",
       "      <td>0.704805</td>\n",
       "      <td>0.992008</td>\n",
       "      <td>0.897529</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>F01</td>\n",
       "      <td>F04</td>\n",
       "      <td>0.101282</td>\n",
       "      <td>0.146979</td>\n",
       "      <td>0.213859</td>\n",
       "      <td>0.094361</td>\n",
       "      <td>0.662321</td>\n",
       "      <td>0.911609</td>\n",
       "      <td>0.781893</td>\n",
       "      <td>0.759821</td>\n",
       "      <td>0.722003</td>\n",
       "      <td>0.994985</td>\n",
       "      <td>0.914280</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>F01</td>\n",
       "      <td>F05</td>\n",
       "      <td>0.217568</td>\n",
       "      <td>0.269810</td>\n",
       "      <td>0.160787</td>\n",
       "      <td>0.132544</td>\n",
       "      <td>0.661223</td>\n",
       "      <td>0.912715</td>\n",
       "      <td>0.814192</td>\n",
       "      <td>0.777687</td>\n",
       "      <td>0.812477</td>\n",
       "      <td>0.994951</td>\n",
       "      <td>0.932798</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>F02</td>\n",
       "      <td>F01</td>\n",
       "      <td>0.103191</td>\n",
       "      <td>0.066491</td>\n",
       "      <td>0.008276</td>\n",
       "      <td>-0.045909</td>\n",
       "      <td>0.522276</td>\n",
       "      <td>0.918945</td>\n",
       "      <td>0.592994</td>\n",
       "      <td>0.681269</td>\n",
       "      <td>0.548130</td>\n",
       "      <td>0.990653</td>\n",
       "      <td>0.830665</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  reference comp_speaker  p_same_full  rawnet3_cosim  ecapa_tdnn_cosim  \\\n",
       "0       F01          F02     0.227778      -0.096190         -0.121267   \n",
       "1       F01          F03     0.092857       0.047201         -0.068396   \n",
       "2       F01          F04     0.101282       0.146979          0.213859   \n",
       "3       F01          F05     0.217568       0.269810          0.160787   \n",
       "4       F02          F01     0.103191       0.066491          0.008276   \n",
       "\n",
       "   titanet_cosim  resemblyzer_cosim  xvector_cosim  wav2vec2_cosim  \\\n",
       "0      -0.246967           0.515382       0.903451        0.649076   \n",
       "1      -0.175500           0.642626       0.915991        0.772310   \n",
       "2       0.094361           0.662321       0.911609        0.781893   \n",
       "3       0.132544           0.661223       0.912715        0.814192   \n",
       "4      -0.045909           0.522276       0.918945        0.592994   \n",
       "\n",
       "   hubert_cosim  wavlm_cosim  whisper_cosim  xlsr_cosim  \n",
       "0      0.630006     0.627535       0.992281    0.876186  \n",
       "1      0.754791     0.704805       0.992008    0.897529  \n",
       "2      0.759821     0.722003       0.994985    0.914280  \n",
       "3      0.777687     0.812477       0.994951    0.932798  \n",
       "4      0.681269     0.548130       0.990653    0.830665  "
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Speaker-level RDM from Types 4+5 off-diagonal (different-speaker real + clone).\n",
    "# Type 6 (morphed) is excluded: at scale 0.5 a morph is neither A nor B, so the\n",
    "# speaker-pair identity is ill-defined for those stimuli. Diagonal cells (ref == comp)\n",
    "# are excluded because all models trivially recover self-similarity.\n",
    "\n",
    "def parse_comp_speaker(row):\n",
    "    \"\"\"Return the comparison speaker for each stimulus.\"\"\"\n",
    "    if row['stimuli_type'] in [1, 2, 3]:\n",
    "        return row['reference']\n",
    "    if row['stimuli_type'] in [4, 5]:\n",
    "        comp = str(row['comparison'])\n",
    "        return comp if comp not in ['nan', 'None', ''] else row['reference']\n",
    "    if row['stimuli_type'] == 6:\n",
    "        parts = str(row['id']).split('_')\n",
    "        if len(parts) >= 3:\n",
    "            return parts[2][:3]\n",
    "    return row['reference']\n",
    "\n",
    "df['comp_speaker'] = df.apply(parse_comp_speaker, axis=1)\n",
    "print(f\"Unique reference speakers: {df['reference'].nunique()}\")\n",
    "print(f\"Unique comparison speakers: {df['comp_speaker'].nunique()}\")\n",
    "\n",
    "cosim_cols = [f'{m}_cosim' for m in available_models]\n",
    "agg_spec = {'p_same_full': 'mean'}\n",
    "for c in cosim_cols:\n",
    "    agg_spec[c] = 'mean'\n",
    "\n",
    "off_diag_mask = df['reference'] != df['comp_speaker']\n",
    "rdm_df = (df[off_diag_mask & df['stimuli_type'].isin([4, 5])]\n",
    "          .groupby(['reference', 'comp_speaker'])\n",
    "          .agg(agg_spec)\n",
    "          .reset_index())\n",
    "\n",
    "print(f'\\nRDM entries: {len(rdm_df)} (Types 4+5 off-diagonal, within-group)')\n",
    "rdm_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "cell_027",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:23:36.904534Z",
     "iopub.status.busy": "2026-04-22T16:23:36.904225Z",
     "iopub.status.idle": "2026-04-22T16:24:02.348391Z",
     "shell.execute_reply": "2026-04-22T16:24:02.346056Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Speaker-level RDM (Types 4+5, within-group different-speaker geometry):\n",
      "      model              type  rsa_rho  mantel_p  n_pairs\n",
      "resemblyzer        Supervised   0.5419    0.0000      400\n",
      "    xvector        Supervised   0.4793    0.0000      400\n",
      "      wavlm   Self-supervised   0.3923    0.0000      400\n",
      "    rawnet3        Supervised   0.3856    0.0000      400\n",
      "     hubert   Self-supervised   0.3829    0.0000      400\n",
      "    titanet        Supervised   0.3792    0.0000      400\n",
      "       xlsr   Self-supervised   0.3771    0.0000      400\n",
      "   wav2vec2   Self-supervised   0.3569    0.0000      400\n",
      " ecapa_tdnn        Supervised   0.3393    0.0000      400\n",
      "    whisper Weakly supervised   0.1274    0.0092      400\n"
     ]
    }
   ],
   "source": [
    "# Mantel test: permute the model-side vector and compute empirical p-value.\n",
    "\n",
    "def mantel_test(x, y, n_perm=5000, seed=SEED):\n",
    "    rng_m = np.random.default_rng(seed)\n",
    "    observed, _ = spearmanr(x, y)\n",
    "    null = np.zeros(n_perm)\n",
    "    y_perm = y.copy()\n",
    "    for i in range(n_perm):\n",
    "        rng_m.shuffle(y_perm)\n",
    "        null[i], _ = spearmanr(x, y_perm)\n",
    "    p = (np.abs(null) >= np.abs(observed)).mean()\n",
    "    return observed, p\n",
    "\n",
    "# Speaker-level RDM correlations (Types 4+5 off-diagonal only)\n",
    "speaker_rsa = []\n",
    "for model_name in available_models:\n",
    "    col = f'{model_name}_cosim'\n",
    "    if col not in rdm_df.columns:\n",
    "        continue\n",
    "    valid = rdm_df[col].notna() & rdm_df['p_same_full'].notna()\n",
    "    h = 1 - rdm_df.loc[valid, 'p_same_full'].values\n",
    "    mv = 1 - rdm_df.loc[valid, col].values\n",
    "    rho, p = mantel_test(h, mv, n_perm=5000)\n",
    "    speaker_rsa.append({\n",
    "        'model': model_name,\n",
    "        'type': MODEL_INFO[model_name]['type'],\n",
    "        'rsa_rho': rho,\n",
    "        'mantel_p': p,\n",
    "        'n_pairs': int(valid.sum())\n",
    "    })\n",
    "\n",
    "rsa_df = pd.DataFrame(speaker_rsa).sort_values('rsa_rho', ascending=False)\n",
    "print('Speaker-level RDM (Types 4+5, within-group different-speaker geometry):')\n",
    "print(rsa_df.round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_027_interp",
   "metadata": {},
   "source": [
    "### Section 5: Interpretation\n",
    "\n",
    "The speaker-level RDM (Types 4+5, 400 within-group off-diagonal entries) produces a ranking that **differs from pair-level Pearson r** in the middle tier:\n",
    "\n",
    "- Supervised: resemblyzer 0.535, x-vector 0.475, RawNet3 0.374, TitaNet 0.367, ECAPA-TDNN 0.329.\n",
    "- SSL (best-layer): WavLM 0.389, HuBERT 0.382, XLS-R 0.375, wav2vec 2.0 0.355.\n",
    "- Whisper 0.126 (Mantel p = 0.011; weakest model).\n",
    "\n",
    "**resemblyzer leads on both metrics**, but the rest of the ordering changes. **ECAPA-TDNN is the weakest supervised model on the speaker-level RDM** despite its second-highest Pearson r. Best-layer SSL models (0.36--0.39) sit between x-vector and the weaker supervised models, overlapping with them. This shows that models that rank individual voice pairs well are not necessarily models that preserve the speaker-to-speaker population map.\n",
    "\n",
    "**Whisper is a consistent outlier.** Its RDM correlation of 0.126 is significant (Mantel p = 0.011) but more than three times below every other model. This is consistent with its multitask ASR training discarding speaker-specific information at every layer.\n",
    "\n",
    "**Morph stimuli (Type 6) are not used in the RDM.** Aggregating morphs into a speaker-pair cell would conflate speaker-pair geometry with morph-trajectory geometry; a scale-0.5 morph is neither A nor B, so the \"comp speaker B\" label breaks down. Morph-trajectory behavior is examined separately via the Type 6 scale-by-scale curves (supplementary figure).\n",
    "\n",
    "**Scientific implication.** Pair-level and speaker-level metrics probe complementary properties. Strong pair-level alignment does not guarantee strong speaker-level geometry, and vice versa; benchmarks should report both."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "part_III_divider",
   "metadata": {},
   "source": [
    "---\n",
    "# Part III \u2014 Stimulus-Level Analyses\n",
    "\n",
    "These sections examine where model-human alignment varies across the stimulus space. Section 6 asks whether predictors fit on real speech transfer to synthetic speech. Section 7 asks whether models can predict when humans will disagree with each other."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_028",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 6: Per-Stimulus-Type Analysis\n",
    "\n",
    "**Motivation:** Current speaker verification benchmarks evaluate only on real speech. But voice cloning introduces synthetic stimuli that may behave differently in embedding space. This section asks: **do models generalize from real speech to synthetic speech?**\n",
    "\n",
    "**Cross-type transfer experiment:** For each model, we:\n",
    "1. Fit a linear regression on real-speech pairs only (Types 1, 2, 4): $P(\\text{same}) \\sim \\beta_0 + \\beta_1 \\cdot \\text{cosim}$\n",
    "2. Use this fitted model to predict P(same) on synthetic pairs (Types 3, 5, 6)\n",
    "3. Compare the prediction quality to a model fitted on all types\n",
    "\n",
    "If the transfer gap is zero, the relationship between model similarity and human perception is the same for real and synthetic speech. A positive gap would mean the model needs exposure to synthetic data to predict human perception of it.\n",
    "\n",
    "**Type 6 analysis:** The blended voices provide a unique continuous manipulation. Each blend has a \"scale\" parameter (0 = fully Speaker A, 100 = fully Speaker B). We plot both model cosine similarity and human P(same) as a function of this scale to visualize whether models track the same identity gradient that humans perceive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "cell_030",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:02.351352Z",
     "iopub.status.busy": "2026-04-22T16:24:02.351075Z",
     "iopub.status.idle": "2026-04-22T16:24:02.466448Z",
     "shell.execute_reply": "2026-04-22T16:24:02.464293Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cross-type transfer (REAL->SYNTH) with proper MSE/R^2 metrics:\n",
      "Columns:\n",
      "  R2_transfer:   R^2 on synthetic using linear map fit on REAL\n",
      "  R2_oracle:     R^2 on synthetic using linear map fit on SYNTHETIC itself (oracle)\n",
      "  R2_gap:        difference -- positive means real->synth transfer is LOSSY\n",
      "  slope/intercept: reveal whether the real and synth mappings differ\n",
      "\n",
      "      model  R2_transfer  R2_oracle  R2_gap  slope_real  slope_synth  intercept_real  intercept_synth\n",
      "    whisper      -0.1457     0.0455  0.1912     22.9004      10.8986        -22.2535         -10.4315\n",
      "       xlsr       0.0033     0.1858  0.1825      4.9458       2.6242         -4.0101          -1.9717\n",
      "    xvector       0.1408     0.3122  0.1714     10.5981       6.4585         -9.5866          -5.7224\n",
      "   wav2vec2       0.0449     0.1921  0.1473      1.8367       1.1045         -0.8944          -0.4209\n",
      "    rawnet3       0.1845     0.3301  0.1457      0.8226       0.6739          0.1046           0.0834\n",
      "     hubert       0.0392     0.1790  0.1399      1.6520       0.9722         -0.7325          -0.3053\n",
      "      wavlm       0.1314     0.2232  0.0918      1.6428       1.0092         -0.6885          -0.2836\n",
      "    titanet       0.2658     0.3509  0.0851      0.8015       0.6903          0.1440           0.1196\n",
      "resemblyzer       0.2974     0.3793  0.0819      2.4693       1.9108         -1.3698          -1.0148\n",
      " ecapa_tdnn       0.2823     0.3618  0.0795      0.8154       0.7242          0.1548           0.1217\n"
     ]
    }
   ],
   "source": [
    "# Cross-stimulus-type transfer: train Platt-scaled predictor on real, test on synthetic\n",
    "# Use MSE and noise-ceiling-normalized R^2 on raw predicted values -- NOT Pearson r,\n",
    "# which is invariant to affine transformations and therefore trivially zero transfer gap.\n",
    "\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "real_types = [1, 2, 4]\n",
    "synth_types = [3, 5, 6]\n",
    "\n",
    "transfer_results = []\n",
    "\n",
    "for model_name in available_models:\n",
    "    col = f'{model_name}_cosim'\n",
    "    valid = df.dropna(subset=[col, 'p_same_full']).copy()\n",
    "    real_data = valid[valid['stimuli_type'].isin(real_types)]\n",
    "    synth_data = valid[valid['stimuli_type'].isin(synth_types)]\n",
    "    \n",
    "    if len(real_data) < 50 or len(synth_data) < 50:\n",
    "        continue\n",
    "    \n",
    "    # Fit linear predictor on REAL, predict P(same) on SYNTHETIC\n",
    "    X_real = real_data[[col]].values\n",
    "    y_real = real_data['p_same_full'].values\n",
    "    X_synth = synth_data[[col]].values\n",
    "    y_synth = synth_data['p_same_full'].values\n",
    "    \n",
    "    from sklearn.linear_model import LinearRegression\n",
    "    lr_real = LinearRegression().fit(X_real, y_real)\n",
    "    pred_synth_from_real = lr_real.predict(X_synth)\n",
    "    \n",
    "    # Also fit on synth itself (oracle) for comparison\n",
    "    lr_synth = LinearRegression().fit(X_synth, y_synth)\n",
    "    pred_synth_from_synth = lr_synth.predict(X_synth)\n",
    "    \n",
    "    # MSE and R^2 on RAW values (not Pearson, so slope/intercept matter)\n",
    "    mse_transfer = mean_squared_error(y_synth, pred_synth_from_real)\n",
    "    mse_oracle = mean_squared_error(y_synth, pred_synth_from_synth)\n",
    "    \n",
    "    # R^2 = 1 - MSE / Var(y)\n",
    "    var_y_synth = np.var(y_synth)\n",
    "    r2_transfer = 1 - mse_transfer / var_y_synth\n",
    "    r2_oracle = 1 - mse_oracle / var_y_synth\n",
    "    \n",
    "    # Also report the fitted parameters to see the actual difference\n",
    "    intercept_real, slope_real = lr_real.intercept_, lr_real.coef_[0]\n",
    "    intercept_synth, slope_synth = lr_synth.intercept_, lr_synth.coef_[0]\n",
    "    \n",
    "    transfer_results.append({\n",
    "        'model': model_name,\n",
    "        'R2_transfer': r2_transfer,\n",
    "        'R2_oracle': r2_oracle,\n",
    "        'R2_gap': r2_oracle - r2_transfer,\n",
    "        'MSE_transfer': mse_transfer,\n",
    "        'MSE_oracle': mse_oracle,\n",
    "        'slope_real': slope_real,\n",
    "        'slope_synth': slope_synth,\n",
    "        'intercept_real': intercept_real,\n",
    "        'intercept_synth': intercept_synth\n",
    "    })\n",
    "\n",
    "transfer_df = pd.DataFrame(transfer_results).sort_values('R2_gap', ascending=False)\n",
    "print('Cross-type transfer (REAL->SYNTH) with proper MSE/R^2 metrics:')\n",
    "print('Columns:')\n",
    "print('  R2_transfer:   R^2 on synthetic using linear map fit on REAL')\n",
    "print('  R2_oracle:     R^2 on synthetic using linear map fit on SYNTHETIC itself (oracle)')\n",
    "print('  R2_gap:        difference -- positive means real->synth transfer is LOSSY')\n",
    "print('  slope/intercept: reveal whether the real and synth mappings differ')\n",
    "print()\n",
    "print(transfer_df[['model', 'R2_transfer', 'R2_oracle', 'R2_gap', 'slope_real', 'slope_synth', 'intercept_real', 'intercept_synth']].round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_031",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:02.468963Z",
     "iopub.status.busy": "2026-04-22T16:24:02.468705Z",
     "iopub.status.idle": "2026-04-22T16:24:03.092480Z",
     "shell.execute_reply": "2026-04-22T16:24:03.090474Z"
    }
   },
   "outputs": [],
   "source": [
    "# Type 6 special analysis: P(same) vs scale (human) and cosine sim vs scale (models).\n",
    "# Output two figures:\n",
    "#   - type6_human.png   : human P(same) vs scale (standalone)\n",
    "#   - type6_models.png  : model cosine vs scale, RAW (left) + min-max normalized (right)\n",
    "type6 = df[df['stimuli_type'] == 6].dropna(subset=['scale']).copy()\n",
    "\n",
    "PARADIGM_COLOR = {'Supervised': '#2196F3', 'Self-supervised': '#FF9800', 'Weakly supervised': '#9C27B0'}\n",
    "DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "ORDER_BY_PARADIGM = {'Supervised': 0, 'Self-supervised': 1, 'Weakly supervised': 2}\n",
    "\n",
    "if len(type6) > 0 and len(available_models) > 0:\n",
    "    bins = np.arange(0, 105, 5)\n",
    "    type6['scale_bin'] = pd.cut(type6['scale'], bins, include_lowest=True)\n",
    "    agg_h = type6.groupby('scale_bin', observed=True)['p_same_full'].agg(['mean', 'sem']).dropna()\n",
    "\n",
    "    # ----- Figure: human P(same) only -----\n",
    "    fig, ax = plt.subplots(figsize=(7, 4.5))\n",
    "    ax.errorbar(range(len(agg_h)), agg_h['mean'], yerr=1.96*agg_h['sem'],\n",
    "                fmt='o-', color='#2196F3', markersize=4, capsize=2)\n",
    "    ax.set_xlabel('Interpolation Scale (binned)')\n",
    "    ax.set_ylabel('Human P(same)')\n",
    "    ax.set_xticks(range(0, len(agg_h), 4))\n",
    "    ax.set_xticklabels([f'{int(b.left)}' for b in agg_h.index[::4]], rotation=45)\n",
    "    for spine in ('top','right'): ax.spines[spine].set_visible(False)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('manuscript/figures/type6_human.png', dpi=200, bbox_inches='tight')\n",
    "    plt.show()\n",
    "\n",
    "    # ----- Figure: model curves, raw (left) + normalized (right) -----\n",
    "    sorted_models = sorted(available_models,\n",
    "                           key=lambda m: (ORDER_BY_PARADIGM[MODEL_INFO[m]['type']], m))\n",
    "    LINESTYLES = {'Supervised':['-','--','-.',':',(0,(3,1,1,1))],\n",
    "                  'Self-supervised':['-','--','-.',':'],\n",
    "                  'Weakly supervised':['-']}\n",
    "    fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
    "    for ax, mode in zip(axes, ['raw', 'norm']):\n",
    "        style_idx = {p:0 for p in PARADIGM_COLOR}\n",
    "        for m in sorted_models:\n",
    "            col = f'{m}_cosim'\n",
    "            if col not in type6.columns: continue\n",
    "            agg_m = type6.groupby('scale_bin', observed=True)[col].mean().dropna()\n",
    "            if agg_m.std() < 1e-10: continue\n",
    "            v = agg_m.values\n",
    "            if mode == 'norm':\n",
    "                v = (v - v.min()) / (v.max() - v.min() + 1e-12)\n",
    "            ptype = MODEL_INFO[m]['type']\n",
    "            ls = LINESTYLES[ptype][style_idx[ptype] % len(LINESTYLES[ptype])]\n",
    "            style_idx[ptype] += 1\n",
    "            ax.plot(range(len(agg_m)), v, marker='o', markersize=3, linestyle=ls,\n",
    "                    color=PARADIGM_COLOR[ptype], label=DISPLAY_NAME[m], alpha=0.85, linewidth=1.6)\n",
    "        ax.set_xlabel('Interpolation Scale (binned)')\n",
    "        ax.set_ylabel('Cosine similarity' if mode=='raw'\n",
    "                      else 'Cosine similarity (min-max normalized per model)')\n",
    "        ax.set_xticks(range(0, len(agg_h), 4))\n",
    "        ax.set_xticklabels([f'{int(b.left)}' for b in agg_h.index[::4]], rotation=45)\n",
    "        for spine in ('top','right'): ax.spines[spine].set_visible(False)\n",
    "    axes[1].legend(fontsize=8, loc='lower right', ncol=2, frameon=True, framealpha=0.9)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('manuscript/figures/type6_models.png', dpi=200, bbox_inches='tight')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_031_interp",
   "metadata": {},
   "source": [
    "### Section 6: Interpretation\n",
    "\n",
    "**With best-layer SSL, real-to-synthetic transfer is no longer catastrophic.** The earlier finding of deeply negative R^2 for SSL models (when using last-layer) was substantially a layer-choice artifact. With nested-CV best-layer SSL, R^2_transfer is near-zero or weakly positive for most models:\n",
    "- Supervised: positive R^2_transfer (0.14-0.30); oracle R^2 is 0.31-0.38; R^2 gap ~0.08-0.17.\n",
    "- SSL (best-layer): near-zero R^2_transfer (0.003-0.13); oracle R^2 is 0.18-0.22; R^2 gap ~0.09-0.18.\n",
    "- Whisper is the clear exception: R^2_transfer = -0.15, R^2_oracle = 0.05, gap = 0.19.\n",
    "\n",
    "**The slope differences persist but vary in magnitude.** For most models, the real-speech calibration slope is 1.1-2.1x steeper than the synthetic-speech slope. Representative values:\n",
    "- wav2vec2: slope_real=1.84, slope_synth=1.10 (ratio 1.66)\n",
    "- HuBERT: slope_real=1.65, slope_synth=0.97 (ratio 1.70)\n",
    "- Whisper: slope_real=22.9, slope_synth=10.9 (ratio 2.10; large magnitudes reflect Whisper's narrow cosim range)\n",
    "- resemblyzer: slope_real=2.47, slope_synth=1.91 (ratio 1.29)\n",
    "- ECAPA-TDNN: slope_real=0.82, slope_synth=0.72 (ratio 1.13)\n",
    "\n",
    "Supervised models (ECAPA-TDNN, TitaNet, RawNet3) have slope ratios closest to 1.0, meaning their real-vs-synthetic calibration curves are most similar.\n",
    "\n",
    "**Scientific implication.** Voice cloning and interpolation produce systematic distribution shifts in cosine similarity even when the representation captures identity well. A benchmark that evaluates only on real speech mis-estimates synthetic-speech calibration. This is now a calibration issue rather than a representation failure.\n",
    "\n",
    "**Paper framing.** The real\u2192synth transfer finding is a **methodological warning**: regardless of architecture, a model deployed for voice-clone evaluation needs its similarity-to-probability mapping calibrated on synthetic data, not just real data. The effect is largest for weaker models (Whisper) but present for all."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_032",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 7: Individual Differences in Human Perception\n",
    "\n",
    "**Motivation:** Not all voice pairs are equally easy to judge. Some pairs elicit strong consensus (nearly all listeners agree), while others provoke maximal disagreement (close to 50/50 split). Can models predict *which pairs humans will disagree on*?\n",
    "\n",
    "**Human disagreement** is quantified via the binary entropy of the vote distribution for each pair:\n",
    "\n",
    "$$H = -[p \\log_2 p + (1-p) \\log_2 (1-p)]$$\n",
    "\n",
    "where $p = P(\\text{same})$. Entropy is 0 when all listeners agree (p=0 or p=1) and 1 when they are maximally split (p=0.5). Human agreement is defined as $1 - H$.\n",
    "\n",
    "**Model confidence** is defined as the absolute distance from the model's optimal verification threshold: $|\\text{cosim} - \\theta_{\\text{opt}}|$. A pair far from the threshold is \"easy\" for the model.\n",
    "\n",
    "If model confidence correlates with human agreement, it means the model's uncertainty tracks human uncertainty -- pairs that are hard for humans are also ambiguous in the embedding space."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "cell_033",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:03.095890Z",
     "iopub.status.busy": "2026-04-22T16:24:03.095560Z",
     "iopub.status.idle": "2026-04-22T16:24:03.136535Z",
     "shell.execute_reply": "2026-04-22T16:24:03.134575Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean human entropy: 0.7537\n",
      "Median human entropy: 0.8813\n",
      "Pairs with high disagreement (entropy > 0.9): 3167\n"
     ]
    }
   ],
   "source": [
    "# Human disagreement: entropy of vote distribution per pair\n",
    "def binary_entropy(p):\n",
    "    \"\"\"Entropy of Bernoulli distribution.\"\"\"\n",
    "    if p <= 0 or p >= 1:\n",
    "        return 0.0\n",
    "    return -(p * np.log2(p) + (1-p) * np.log2(1-p))\n",
    "\n",
    "df['human_entropy'] = df['p_same_full'].apply(lambda p: binary_entropy(p) if pd.notna(p) else np.nan)\n",
    "df['human_agreement'] = 1 - df['human_entropy']\n",
    "\n",
    "print(f'Mean human entropy: {df[\"human_entropy\"].mean():.4f}')\n",
    "print(f'Median human entropy: {df[\"human_entropy\"].median():.4f}')\n",
    "print(f'Pairs with high disagreement (entropy > 0.9): {(df[\"human_entropy\"] > 0.9).sum()}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "cell_034",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:03.139270Z",
     "iopub.status.busy": "2026-04-22T16:24:03.139002Z",
     "iopub.status.idle": "2026-04-22T16:24:03.237449Z",
     "shell.execute_reply": "2026-04-22T16:24:03.235070Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model confidence vs human agreement:\n",
      "      model  r_confidence_agreement   p\n",
      "resemblyzer                  0.3440 0.0\n",
      "    xvector                  0.3033 0.0\n",
      " ecapa_tdnn                  0.2853 0.0\n",
      "    titanet                  0.2764 0.0\n",
      "    rawnet3                  0.2755 0.0\n",
      "      wavlm                  0.2415 0.0\n",
      "     hubert                  0.2185 0.0\n",
      "   wav2vec2                  0.2167 0.0\n",
      "       xlsr                  0.2094 0.0\n",
      "    whisper                  0.1082 0.0\n"
     ]
    }
   ],
   "source": [
    "# Can models predict human disagreement?\n",
    "disagree_results = []\n",
    "\n",
    "for model_name in available_models:\n",
    "    col = f'{model_name}_cosim'\n",
    "    valid = df.dropna(subset=[col, 'human_entropy'])\n",
    "    if len(valid) < 10:\n",
    "        continue\n",
    "    \n",
    "    # Model confidence: distance from optimal threshold\n",
    "    if model_name in auc_results:\n",
    "        # Recompute optimal threshold\n",
    "        valid_b = df_binary.dropna(subset=[col])\n",
    "        fpr, tpr, thresholds = roc_curve(valid_b['majority_full'], valid_b[col])\n",
    "        opt_thresh = thresholds[np.argmax(tpr - fpr)]\n",
    "    else:\n",
    "        opt_thresh = valid[col].median()\n",
    "    \n",
    "    model_confidence = np.abs(valid[col] - opt_thresh)\n",
    "    \n",
    "    # Higher model confidence should predict higher human agreement (lower entropy)\n",
    "    r, p = pearsonr(model_confidence, valid['human_agreement'])\n",
    "    disagree_results.append({'model': model_name, 'r_confidence_agreement': r, 'p': p})\n",
    "\n",
    "disagree_df = pd.DataFrame(disagree_results).sort_values('r_confidence_agreement', ascending=False)\n",
    "print('Model confidence vs human agreement:')\n",
    "print(disagree_df.round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "cell_035",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:03.240276Z",
     "iopub.status.busy": "2026-04-22T16:24:03.240006Z",
     "iopub.status.idle": "2026-04-22T16:24:03.254749Z",
     "shell.execute_reply": "2026-04-22T16:24:03.252797Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "High-disagreement pairs: 3167\n",
      "\n",
      "By stimulus type:\n",
      "stimuli_type\n",
      "1       2\n",
      "2     149\n",
      "3     177\n",
      "4     110\n",
      "5      99\n",
      "6    2630\n",
      "Name: count, dtype: int64\n",
      "\n",
      "Proportion of each type that is high-disagreement:\n",
      "  Type 1: 2/100 = 2.0%\n",
      "  Type 2: 149/400 = 37.2%\n",
      "  Type 3: 177/400 = 44.2%\n",
      "  Type 4: 110/400 = 27.5%\n",
      "  Type 5: 99/400 = 24.8%\n",
      "  Type 6: 2630/8100 = 32.5%\n"
     ]
    }
   ],
   "source": [
    "# Characterize high-disagreement pairs\n",
    "high_disagree = df[df['human_entropy'] > 0.9].copy()\n",
    "print(f'High-disagreement pairs: {len(high_disagree)}')\n",
    "print(f'\\nBy stimulus type:')\n",
    "print(high_disagree['stimuli_type'].value_counts().sort_index())\n",
    "print(f'\\nProportion of each type that is high-disagreement:')\n",
    "for stype in sorted(df['stimuli_type'].unique()):\n",
    "    total = (df['stimuli_type'] == stype).sum()\n",
    "    high = ((df['stimuli_type'] == stype) & (df['human_entropy'] > 0.9)).sum()\n",
    "    print(f'  Type {stype}: {high}/{total} = {high/total:.1%}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_035_interp",
   "metadata": {},
   "source": [
    "### Section 7: Interpretation\n",
    "\n",
    "**Substantial human disagreement exists.** Mean pair-level entropy is 0.75 and 32% of pairs (3,167 of 9,800) have entropy > 0.9 (near-maximal disagreement).\n",
    "\n",
    "**High-disagreement pairs are concentrated in Type 3 (clones, 44%) and Type 6 (blends, 33%)** -- exactly the stimulus types designed to probe identity boundaries. Type 1 (same audio) has only 2% high-disagreement pairs, confirming it is a reliable baseline.\n",
    "\n",
    "**Model confidence modestly predicts human agreement.** Correlations between model confidence (distance from optimal threshold) and human agreement (1 - entropy):\n",
    "- Supervised: 0.28-0.34 (resemblyzer 0.34, x-vector 0.30, ECAPA-TDNN 0.29, TitaNet 0.28, RawNet3 0.28).\n",
    "- SSL (best-layer): 0.21-0.24 (WavLM 0.24, HuBERT 0.22, wav2vec2 0.22, XLS-R 0.21).\n",
    "- Whisper: 0.11.\n",
    "\n",
    "**Practical implication.** No current model reliably flags pairs humans will find ambiguous -- even the best model achieves only r=0.34. For confidence-aware verification systems, additional signals (e.g., stimulus-level features, listener priors, context) would be needed to anticipate disagreement zones."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "part_IV_divider",
   "metadata": {},
   "source": [
    "---\n",
    "# Part IV \u2014 Representation Analyses\n",
    "\n",
    "These sections ask structural questions about the embedding spaces themselves: Section 8 (Mahalanobis metric learning) tests whether per-dimension reweighting improves prediction \u2014 revealing whether the space is isotropically aligned with perception. Section 13 (at the end of Part V) tests whether SSL models benefit from choosing a non-default transformer layer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_036",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 8: Mahalanobis Metric Learning\n",
    "\n",
    "**Motivation:** Cosine similarity treats all dimensions of the embedding space equally. But human perception may weight certain acoustic/representational dimensions more than others. A **diagonal Mahalanobis metric** learns per-dimension weights that best predict human judgments.\n",
    "\n",
    "**Method:** For each pair, compute the embedding difference $\\mathbf{d} = \\mathbf{e}_{\\text{ref}} - \\mathbf{e}_{\\text{comp}}$. The weighted distance is:\n",
    "\n",
    "$$d_M(\\mathbf{e}_{\\text{ref}}, \\mathbf{e}_{\\text{comp}}) = \\sum_{i=1}^{D} w_i \\cdot (e_{\\text{ref},i} - e_{\\text{comp},i})^2$$\n",
    "\n",
    "where $w_i \\geq 0$ are learnable per-dimension weights. We optimize $\\mathbf{w}$ to minimize MSE between $d_M$ and human dissimilarity $(1 - P(\\text{same}))$, with L2 regularization:\n",
    "\n",
    "$$\\min_{\\mathbf{w}} \\frac{1}{N} \\sum_j \\left( d_M^{(j)} - (1 - P_{\\text{same}}^{(j)}) \\right)^2 + \\lambda \\|\\mathbf{w}\\|^2$$\n",
    "\n",
    "Weights are parameterized as $w_i = e^{\\alpha_i}$ to ensure positivity, and optimized with L-BFGS-B.\n",
    "\n",
    "**Evaluation:** 10-fold cross-validation with speaker-level splits (gender-balanced: 5M/5F per fold). We compare $R^2$ of the learned Mahalanobis distance against isotropic (uniform-weight) distance on held-out speakers.\n",
    "\n",
    "**For high-dimensional models** (dim > 256), we first reduce to 50 dimensions with PCA to prevent overfitting (9,800 pairs cannot support learning 768+ independent weights).\n",
    "\n",
    "**What this tells us:** If Mahalanobis significantly outperforms isotropic distance, the model's embedding space is **anisotropic** with respect to human perception -- some dimensions matter more than others for identity. If it does not help, the space is already approximately isotropically aligned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "cell_037",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:03.258211Z",
     "iopub.status.busy": "2026-04-22T16:24:03.257879Z",
     "iopub.status.idle": "2026-04-22T16:24:03.269004Z",
     "shell.execute_reply": "2026-04-22T16:24:03.267179Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mahalanobis metric learning with 10-fold speaker-level CV...\n",
      "(This may take a few minutes for high-dimensional models)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Learn per-dimension weights (diagonal Mahalanobis) via cross-validation\n",
    "from scipy.special import expit as sigmoid\n",
    "\n",
    "def prepare_diffs(df_rows, emb_dict):\n",
    "    \"\"\"Compute embedding differences for all pairs (vectorized).\"\"\"\n",
    "    ref_keys = [f\"{ref}R\" for ref in df_rows['reference']]\n",
    "    stim_keys = df_rows['id'].tolist()\n",
    "    p_same = df_rows['p_same_full'].values\n",
    "    \n",
    "    valid = []\n",
    "    for j, (rk, sk, ps) in enumerate(zip(ref_keys, stim_keys, p_same)):\n",
    "        if rk in emb_dict and sk in emb_dict and not np.isnan(ps):\n",
    "            valid.append(j)\n",
    "    \n",
    "    if not valid:\n",
    "        return np.array([]), np.array([]), []\n",
    "    \n",
    "    dim = next(iter(emb_dict.values())).shape[0]\n",
    "    diffs = np.zeros((len(valid), dim))\n",
    "    targets = np.zeros(len(valid))\n",
    "    for idx, j in enumerate(valid):\n",
    "        diffs[idx] = emb_dict[ref_keys[j]] - emb_dict[stim_keys[j]]\n",
    "        targets[idx] = p_same[j]\n",
    "    return diffs, targets, valid\n",
    "\n",
    "def fit_diagonal_mahalanobis(diffs_train, y_train, diffs_test, y_test, reg_lambda=1e-3):\n",
    "    \"\"\"Fit diagonal Mahalanobis: learn per-dimension weights.\"\"\"\n",
    "    dim = diffs_train.shape[1]\n",
    "    sq_diffs_train = diffs_train ** 2\n",
    "    sq_diffs_test = diffs_test ** 2\n",
    "    \n",
    "    dissim_train = 1 - y_train\n",
    "    dissim_test = 1 - y_test\n",
    "    \n",
    "    def objective(log_w):\n",
    "        w = np.exp(log_w)\n",
    "        d_M = sq_diffs_train @ w\n",
    "        residuals = d_M - dissim_train\n",
    "        return np.mean(residuals ** 2) + reg_lambda * np.sum(w ** 2)\n",
    "    \n",
    "    log_w0 = np.zeros(dim)\n",
    "    result = minimize(objective, log_w0, method='L-BFGS-B',\n",
    "                      options={'maxiter': 500, 'ftol': 1e-8})\n",
    "    w_opt = np.exp(result.x)\n",
    "    \n",
    "    d_M_test = sq_diffs_test @ w_opt\n",
    "    if np.std(d_M_test) < 1e-10 or np.std(dissim_test) < 1e-10:\n",
    "        return 0.0, 0.0, w_opt\n",
    "    r_mahal, _ = pearsonr(d_M_test, dissim_test)\n",
    "    \n",
    "    d_iso_test = sq_diffs_test @ np.ones(dim)\n",
    "    if np.std(d_iso_test) < 1e-10:\n",
    "        r_iso = 0.0\n",
    "    else:\n",
    "        r_iso, _ = pearsonr(d_iso_test, dissim_test)\n",
    "    \n",
    "    return r_mahal ** 2, r_iso ** 2, w_opt\n",
    "\n",
    "print('Mahalanobis metric learning with 10-fold speaker-level CV...')\n",
    "print('(This may take a few minutes for high-dimensional models)\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_038",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:03.272481Z",
     "iopub.status.busy": "2026-04-22T16:24:03.272119Z",
     "iopub.status.idle": "2026-04-22T16:24:03.294152Z",
     "shell.execute_reply": "2026-04-22T16:24:03.292117Z"
    }
   },
   "outputs": [],
   "source": [
    "# Mahalanobis CV: for SSL models, uses the SAME per-fold best layer as Section 2.\n",
    "# For supervised models, uses the model's native (only) embedding.\n",
    "# Results are cached; delete cache/mahalanobis.pkl to force recomputation.\n",
    "\n",
    "def _prepare_diffs_at_layer(df_rows, emb_dict_layers, layer_idx):\n",
    "    \"\"\"Compute embedding differences using the specified layer.\"\"\"\n",
    "    ref_keys = [f'{ref}R' for ref in df_rows['reference']]\n",
    "    stim_keys = df_rows['id'].tolist()\n",
    "    p_same = df_rows['p_same_full'].values\n",
    "    valid = []\n",
    "    for j, (rk, sk, ps) in enumerate(zip(ref_keys, stim_keys, p_same)):\n",
    "        if rk in emb_dict_layers and sk in emb_dict_layers and not np.isnan(ps):\n",
    "            valid.append(j)\n",
    "    if not valid:\n",
    "        return np.array([]), np.array([])\n",
    "    sample = next(iter(emb_dict_layers.values()))\n",
    "    _, dim = sample.shape\n",
    "    diffs = np.zeros((len(valid), dim))\n",
    "    targets = np.zeros(len(valid))\n",
    "    for idx, j in enumerate(valid):\n",
    "        diffs[idx] = emb_dict_layers[ref_keys[j]][layer_idx] - emb_dict_layers[stim_keys[j]][layer_idx]\n",
    "        targets[idx] = p_same[j]\n",
    "    return diffs, targets\n",
    "\n",
    "def _compute_mahalanobis():\n",
    "    all_speakers_local = sorted(df['reference'].unique())\n",
    "    male_spk_local = [s for s in all_speakers_local if s.startswith('M')]\n",
    "    female_spk_local = [s for s in all_speakers_local if s.startswith('F')]\n",
    "    _rng_m = np.random.default_rng(SEED)\n",
    "    _rng_m.shuffle(male_spk_local); _rng_m.shuffle(female_spk_local)\n",
    "    folds_m = [[] for _ in range(10)]\n",
    "    for i, s in enumerate(male_spk_local): folds_m[i % 10].append(s)\n",
    "    for i, s in enumerate(female_spk_local): folds_m[i % 10].append(s)\n",
    "    \n",
    "    results_out = []\n",
    "    for model_name in available_models:\n",
    "        is_ssl_with_layers = model_name in SSL_MODELS_WITH_LAYERS and model_name in layer_embs\n",
    "        dim = MODEL_INFO[model_name]['dim']\n",
    "        if is_ssl_with_layers:\n",
    "            sample = next(iter(layer_embs[model_name].values()))\n",
    "            _, dim = sample.shape\n",
    "        use_pca = dim > 256\n",
    "        pca_dim = 50 if use_pca else dim\n",
    "        \n",
    "        fold_r2_mahal = []\n",
    "        fold_r2_iso = []\n",
    "        for fold_idx, fold_speakers in enumerate(folds_m):\n",
    "            test_speakers = set(fold_speakers)\n",
    "            train_speakers = set(all_speakers_local) - test_speakers\n",
    "            train_mask = df['reference'].isin(train_speakers)\n",
    "            test_mask = df['reference'].isin(test_speakers)\n",
    "            \n",
    "            if is_ssl_with_layers:\n",
    "                layer_idx = best_layer_per_fold[model_name][fold_idx] if fold_idx < len(best_layer_per_fold[model_name]) else 0\n",
    "                diffs_train, y_train = _prepare_diffs_at_layer(df[train_mask], layer_embs[model_name], layer_idx)\n",
    "                diffs_test, y_test = _prepare_diffs_at_layer(df[test_mask], layer_embs[model_name], layer_idx)\n",
    "            else:\n",
    "                emb_dict = embeddings[model_name]\n",
    "                diffs_train, y_train, _ = prepare_diffs(df[train_mask], emb_dict)\n",
    "                diffs_test, y_test, _ = prepare_diffs(df[test_mask], emb_dict)\n",
    "            \n",
    "            if len(diffs_train) < 50 or len(diffs_test) < 10:\n",
    "                continue\n",
    "            if use_pca:\n",
    "                pca = PCA(n_components=pca_dim)\n",
    "                diffs_train = pca.fit_transform(diffs_train)\n",
    "                diffs_test = pca.transform(diffs_test)\n",
    "            r2_m, r2_i, _ = fit_diagonal_mahalanobis(diffs_train, y_train, diffs_test, y_test)\n",
    "            fold_r2_mahal.append(r2_m)\n",
    "            fold_r2_iso.append(r2_i)\n",
    "        \n",
    "        if fold_r2_mahal:\n",
    "            results_out.append({\n",
    "                'model': model_name,\n",
    "                'type': MODEL_INFO[model_name]['type'],\n",
    "                'dim': dim,\n",
    "                'pca': pca_dim if use_pca else 'N/A',\n",
    "                'R2_isotropic': np.mean(fold_r2_iso),\n",
    "                'R2_mahalanobis': np.mean(fold_r2_mahal),\n",
    "                'improvement': np.mean(fold_r2_mahal) - np.mean(fold_r2_iso),\n",
    "                'fold_R2_iso': list(map(float, fold_r2_iso)),\n",
    "                'fold_R2_mahal': list(map(float, fold_r2_mahal)),\n",
    "                'n_folds': len(fold_r2_mahal),\n",
    "                'used_best_layer': is_ssl_with_layers,\n",
    "            })\n",
    "    return pd.DataFrame(results_out).sort_values('R2_mahalanobis', ascending=False)\n",
    "\n",
    "print('Mahalanobis metric learning with 10-fold speaker-level CV')\n",
    "print('  (SSL models use per-fold best-layer embeddings, consistent with Section 2 / main benchmark)')\n",
    "mahal_df = cached('mahalanobis', _compute_mahalanobis, 'Diagonal Mahalanobis CV for all models')\n",
    "print('\\nMahalanobis results:')\n",
    "print(mahal_df.round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_039",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:03.297095Z",
     "iopub.status.busy": "2026-04-22T16:24:03.296807Z",
     "iopub.status.idle": "2026-04-22T16:24:03.841265Z",
     "shell.execute_reply": "2026-04-22T16:24:03.838929Z"
    }
   },
   "outputs": [],
   "source": [
    "# Visualization: improvement from metric learning (with 95% CI from 10 folds)\n",
    "if len(mahal_df) > 0:\n",
    "    from scipy.stats import t as _t_dist\n",
    "    DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                    'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                    'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                    'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                    'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "    _t_crit = _t_dist.ppf(0.975, df=9)  # 10-fold CV\n",
    "    def _ci_half(folds):\n",
    "        a = np.asarray(folds, dtype=float)\n",
    "        return _t_crit * a.std(ddof=1) / np.sqrt(len(a))\n",
    "    fig, ax = plt.subplots(figsize=(10, 5))\n",
    "    models_m = [DISPLAY_NAME[m] for m in mahal_df['model']]\n",
    "    x = np.arange(len(models_m))\n",
    "    width = 0.35\n",
    "    ci_iso   = mahal_df['fold_R2_iso'].apply(_ci_half).values\n",
    "    ci_mahal = mahal_df['fold_R2_mahal'].apply(_ci_half).values\n",
    "    ax.bar(x - width/2, mahal_df['R2_isotropic'].values, width,\n",
    "           yerr=ci_iso, capsize=4,\n",
    "           label='Isotropic (cosine)', color='#90CAF9',\n",
    "           error_kw={'ecolor':'#333', 'elinewidth':1.0})\n",
    "    ax.bar(x + width/2, mahal_df['R2_mahalanobis'].values, width,\n",
    "           yerr=ci_mahal, capsize=4,\n",
    "           label='Mahalanobis (learned)', color='#1565C0',\n",
    "           error_kw={'ecolor':'#333', 'elinewidth':1.0})\n",
    "    ax.set_xlabel('Model')\n",
    "    ax.set_ylabel(r'$R^2$ (cross-validated)')\n",
    "    ax.set_xticks(x)\n",
    "    ax.set_xticklabels(models_m, rotation=30, ha='right')\n",
    "    ax.legend()\n",
    "    for spine in ('top','right'): ax.spines[spine].set_visible(False)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig('manuscript/figures/mahalanobis_bar.png', dpi=200, bbox_inches='tight')\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_039_interp",
   "metadata": {},
   "source": [
    "### Section 8: Interpretation\n",
    "\n",
    "**Protocol.** Mahalanobis learning uses each model's **main-benchmark embedding**: supervised models use their native output (192-512 dim); SSL models use the **per-fold best-layer embedding** (consistent with Section 2 and all downstream analyses). High-dimensional embeddings (> 256 dim) are reduced to 50 dim via PCA to keep parameter count tractable.\n",
    "\n",
    "**For supervised models, Mahalanobis does NOT improve over isotropic distance** (deltas near zero or negative: resemblyzer -0.032, ECAPA-TDNN -0.014, RawNet3 -0.005, TitaNet -0.002, x-vector +0.014). Supervised speaker embeddings are already approximately isotropically aligned with human identity perception.\n",
    "\n",
    "**For best-layer SSL embeddings, Mahalanobis provides modest but consistent improvement** (XLS-R +0.035, HuBERT +0.032, wav2vec2 +0.028, WavLM +0.019, Whisper +0.104). SSL representations, even at their best-aligned layer, contain identity-relevant information distributed non-uniformly across dimensions. Learned reweighting helps, but not enough to close the supervised-vs-SSL gap (SSL Mahalanobis R^2 remains 0.18-0.20 vs supervised 0.32-0.40).\n",
    "\n",
    "**Whisper's anomalously large Mahalanobis gain** (+0.104) is notable: its representations are dominated by ASR-relevant features that are largely orthogonal to speaker identity, so a learned metric can preferentially weight the small subset of dimensions carrying speaker information. Its absolute ceiling remains low (R^2=0.13).\n",
    "\n",
    "**Practical recommendation.** For supervised speaker embeddings, simple cosine similarity is optimal. For best-layer SSL representations, a learned diagonal metric yields a small non-trivial improvement but does not close the supervised gap.\n",
    "\n",
    "**Limitation.** We use only a diagonal (per-dimension) Mahalanobis. A full-matrix metric could capture cross-dimension interactions but would need more data or stronger regularization."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "part_V_divider",
   "metadata": {},
   "source": [
    "---\n",
    "# Part V \u2014 Benchmark Validation & Robustness\n",
    "\n",
    "These sections check that the benchmark's conclusions are robust: pairwise significance tests (Section 9) tell us which rank orderings are real vs. noise; the human baseline (Section 10) anchors model performance to individual listeners; the Type-6 ablation (Section 11) checks that the dominant blended-voice stimuli do not drive the main rankings; fairness analyses (Section 12) check demographic disparities; and Section 13 addresses the SSL layer-choice question."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec09_header",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 9: Pairwise Model Significance (Paired Bootstrap)\n",
    "\n",
    "**Motivation:** We have reported raw Pearson r for each model, but differences between models (e.g., resemblyzer r=0.645 vs ECAPA-TDNN r=0.633) may or may not be statistically reliable. Because all models are evaluated on the **same** 9,800 pairs, the correlations are dependent. We use a **paired bootstrap** to test pairwise significance:\n",
    "\n",
    "1. For each bootstrap replicate, resample pair indices with replacement.\n",
    "2. Compute Pearson r for both models on the same resampled set.\n",
    "3. Record the difference $r_A - r_B$.\n",
    "4. The 95% CI of the difference tells us whether it excludes zero.\n",
    "\n",
    "This is more appropriate than unpaired comparison (which ignores the within-pair correlation between models) and more flexible than Steiger's Z (which requires Gaussian assumptions).\n",
    "\n",
    "We report a 10 x 10 matrix of pairwise p-values, corrected for multiple comparisons (Benjamini-Hochberg FDR control)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sec09_code",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:03.844762Z",
     "iopub.status.busy": "2026-04-22T16:24:03.844430Z",
     "iopub.status.idle": "2026-04-22T16:24:05.500074Z",
     "shell.execute_reply": "2026-04-22T16:24:05.498089Z"
    }
   },
   "outputs": [],
   "source": [
    "# Paired bootstrap test for pairwise model correlation differences (cached).\n",
    "# Multiple-comparison correction: Benjamini-Hochberg FDR control across the 45 unique pairs.\n",
    "# Whisper is placed last (bottom-right) in the heatmaps as the weakly-supervised outlier.\n",
    "N_BOOT_PAIRED = 2000\n",
    "\n",
    "valid_rows = df.dropna(subset=[f'{m}_cosim' for m in available_models] + ['p_same_full'])\n",
    "y = valid_rows['p_same_full'].values\n",
    "cosim_mat = np.stack([valid_rows[f'{m}_cosim'].values for m in available_models], axis=1)\n",
    "n = len(y)\n",
    "M = len(available_models)\n",
    "\n",
    "observed_r = np.array([pearsonr(cosim_mat[:, m_idx], y)[0] for m_idx in range(M)])\n",
    "\n",
    "def _compute_boot():\n",
    "    rng_pb = np.random.default_rng(SEED)\n",
    "    boot_r_local = np.zeros((N_BOOT_PAIRED, M))\n",
    "    for b in range(N_BOOT_PAIRED):\n",
    "        idx = rng_pb.integers(0, n, n)\n",
    "        yb = y[idx]\n",
    "        xb = cosim_mat[idx]\n",
    "        for m_idx in range(M):\n",
    "            boot_r_local[b, m_idx] = pearsonr(xb[:, m_idx], yb)[0]\n",
    "    return boot_r_local\n",
    "\n",
    "boot_r = cached('paired_bootstrap', _compute_boot, f'{N_BOOT_PAIRED} paired bootstrap replicates')\n",
    "\n",
    "# Pairwise raw p-values, mean diffs, and 95% bootstrap CIs\n",
    "p_matrix = np.ones((M, M))\n",
    "diff_mean = np.zeros((M, M))\n",
    "ci_low = np.zeros((M, M))\n",
    "ci_high = np.zeros((M, M))\n",
    "for i in range(M):\n",
    "    for j in range(M):\n",
    "        if i == j: continue\n",
    "        d = boot_r[:, i] - boot_r[:, j]\n",
    "        diff_mean[i, j] = d.mean()\n",
    "        ci_low[i, j], ci_high[i, j] = np.percentile(d, [2.5, 97.5])\n",
    "        p_matrix[i, j] = 2 * min((d <= 0).mean(), (d >= 0).mean())\n",
    "\n",
    "# Benjamini-Hochberg FDR-adjusted q-values across the 45 unique pairs (i<j).\n",
    "upper_ij = [(i, j) for i in range(M) for j in range(i+1, M)]\n",
    "p_flat = np.array([p_matrix[i, j] for i, j in upper_ij])\n",
    "order = np.argsort(p_flat)\n",
    "m_tests = len(p_flat)\n",
    "sorted_p = p_flat[order]\n",
    "q_flat = np.zeros_like(p_flat)\n",
    "running_min = 1.0\n",
    "for rank_idx in range(len(sorted_p) - 1, -1, -1):\n",
    "    k = rank_idx + 1  # 1-indexed\n",
    "    val = min(1.0, m_tests * sorted_p[rank_idx] / k)\n",
    "    running_min = min(running_min, val)\n",
    "    q_flat[order[rank_idx]] = running_min\n",
    "\n",
    "q_matrix = np.ones((M, M))\n",
    "for k, (i, j) in enumerate(upper_ij):\n",
    "    q_matrix[i, j] = q_flat[k]\n",
    "    q_matrix[j, i] = q_flat[k]\n",
    "\n",
    "# Reorder for plotting: Whisper last (bottom-right)\n",
    "plot_models = [m for m in available_models if m != 'whisper']\n",
    "if 'whisper' in available_models:\n",
    "    plot_models.append('whisper')\n",
    "plot_idx = [available_models.index(m) for m in plot_models]\n",
    "diff_mean_plot = diff_mean[np.ix_(plot_idx, plot_idx)]\n",
    "q_matrix_plot = q_matrix[np.ix_(plot_idx, plot_idx)]\n",
    "\n",
    "DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "fig, axes = plt.subplots(1, 2, figsize=(16, 7))\n",
    "for ax, mat, title in zip(axes, [diff_mean_plot, q_matrix_plot],\n",
    "                           ['Mean bootstrap diff r(row) - r(col)',\n",
    "                            'BH-adjusted q-value']):\n",
    "    if 'diff' in title:\n",
    "        sns.heatmap(mat, annot=True, fmt='.3f', cmap='RdBu_r', center=0,\n",
    "                    xticklabels=[DISPLAY_NAME[m] for m in plot_models], yticklabels=[DISPLAY_NAME[m] for m in plot_models],\n",
    "                    ax=ax, square=True, cbar_kws={'label': 'r_row - r_col'})\n",
    "    else:\n",
    "        sns.heatmap(mat, annot=True, fmt='.3f', cmap='Reds_r', vmin=0, vmax=0.1,\n",
    "                    xticklabels=[DISPLAY_NAME[m] for m in plot_models], yticklabels=[DISPLAY_NAME[m] for m in plot_models],\n",
    "                    ax=ax, square=True, cbar_kws={'label': 'q (BH-corrected)'})\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha='right')\n",
    "plt.tight_layout()\n",
    "plt.savefig('manuscript/figures/pairwise_sig_1.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()\n",
    "\n",
    "n_signif = (q_flat < 0.05).sum()\n",
    "print(f'Of {m_tests} pairwise comparisons, {n_signif} are significant at BH FDR alpha=0.05.')\n",
    "print(f'\\nresemblyzer (top) vs each other model:')\n",
    "top_idx = available_models.index('resemblyzer') if 'resemblyzer' in available_models else 0\n",
    "for j in range(M):\n",
    "    if j == top_idx: continue\n",
    "    print(f'  resemblyzer vs {available_models[j]:15s}  diff = {diff_mean[top_idx, j]:+.4f}  '\n",
    "          f'[{ci_low[top_idx, j]:+.4f}, {ci_high[top_idx, j]:+.4f}]  q_BH = {q_matrix[top_idx, j]:.4f}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec09_interp",
   "metadata": {},
   "source": [
    "### Section 9: Interpretation\n",
    "\n",
    "**Of 45 unique pairwise comparisons between the 10 models, 43 are statistically significant under Benjamini-Hochberg false-discovery-rate control at $\\alpha = 0.05$.** The two non-significant comparisons sit within the SSL middle tier (wav2vec 2.0 vs XLS-R, BH q=0.367; HuBERT vs XLS-R, BH q=0.288). The resemblyzer vs ECAPA-TDNN comparison is significant but only marginally so (BH q=0.049), placing those two on adjacent boundaries of the supervised top tier rather than as a clean joint tier.\n",
    "\n",
    "**Supervised-vs-SSL separations are all highly significant** (diff > 0.08, BH q $\\ll$ 0.05), substantially smaller in absolute magnitude than the 0.38 gap a last-layer-only SSL protocol would produce.\n",
    "\n",
    "**Within the SSL cluster**, WavLM (r=0.510) is significantly ahead of every other SSL model (BH q < 0.05). The remaining three SSL models (wav2vec 2.0, XLS-R, HuBERT) overlap (XLS-R is not significantly different from wav2vec 2.0 or HuBERT under BH).\n",
    "\n",
    "**For the paper:** the three-tier structure (supervised > SSL > Whisper) is supported, with within-tier ties documented in the BH q matrix. Include the pairwise significance heatmap as a supplementary figure."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec10_header",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 10: Individual Human Baseline\n",
    "\n",
    "**Motivation:** How do models compare to an **individual human listener**? This converts abstract R^2 numbers into a concrete question: does the model do better than an average person?\n",
    "\n",
    "**Estimator requirement.** To compute a reliable per-participant accuracy we need enough trials from each participant. We include all participants who completed **at least 25 trials** (regardless of their accuracy on gold-standard items). This is a data-analytic requirement for a reliable per-subject estimator, not a quality filter.\n",
    "\n",
    "**The target, stated precisely.** We use the **leave-one-out population-consensus label** as the target for both individuals and models: for a given pair, the label is \"same\" if the majority of the *other* participants judged it as same, and \"different\" otherwise (ties are excluded). This is *not* absolute ground truth \u2014 it is an operational aggregation of how this listener population collectively perceived each pair.\n",
    "\n",
    "**Procedure:**\n",
    "1. For each participant who completed >=25 trials, compute the leave-one-out consensus label on each of their judged pairs.\n",
    "2. Compute the participant's agreement rate with the consensus.\n",
    "3. For each model, compute its agreement with the full-sample majority using the threshold chosen in Section 4.\n",
    "4. Compare the distributions.\n",
    "\n",
    "**What this analysis does and does not claim.**\n",
    "- It *does* claim: state-of-the-art supervised embeddings agree with the population consensus more often than the average individual listener does.\n",
    "- It *does not* claim: models are \"correct\" and low-agreement individuals are \"wrong.\" For high-entropy pairs (voice clones, blends near 50/50), consensus is close to a coin flip, so agreeing with it is not objective correctness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sec10_code",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:05.503535Z",
     "iopub.status.busy": "2026-04-22T16:24:05.503172Z",
     "iopub.status.idle": "2026-04-22T16:24:20.043613Z",
     "shell.execute_reply": "2026-04-22T16:24:20.041721Z"
    }
   },
   "outputs": [],
   "source": [
    "# Individual human accuracy vs leave-one-out consensus (full 1,290-participant dataset).\n",
    "# Minimum-trials filter set to 10 (instead of 25): with <10 trials, per-participant\n",
    "# accuracy can only take a handful of discrete values (0, 1/n, ..., 1), producing\n",
    "# artificial spikes at 0 and 1 that are not meaningful.\n",
    "MIN_TRIALS_FOR_BASELINE = 10\n",
    "\n",
    "pair_votes = responses.groupby('stimuli_id').agg(\n",
    "    n_total=('answer', 'count'),\n",
    "    n_same=('answer', 'sum')\n",
    ").reset_index()\n",
    "pair_votes_dict = pair_votes.set_index('stimuli_id').to_dict('index')\n",
    "\n",
    "trial_counts = responses.groupby('user_id').size()\n",
    "eligible_ids = trial_counts[trial_counts >= MIN_TRIALS_FOR_BASELINE].index.values\n",
    "print(f'Participants with >={MIN_TRIALS_FOR_BASELINE} trials: {len(eligible_ids)} / {len(trial_counts)}')\n",
    "\n",
    "participant_acc = []\n",
    "for uid in eligible_ids:\n",
    "    user_resp = responses[responses['user_id'] == uid]\n",
    "    hits = 0\n",
    "    total = 0\n",
    "    for _, r in user_resp.iterrows():\n",
    "        sid = r['stimuli_id']\n",
    "        if sid not in pair_votes_dict: continue\n",
    "        stats_p = pair_votes_dict[sid]\n",
    "        n_minus = stats_p['n_total'] - 1\n",
    "        if n_minus < 1: continue\n",
    "        n_same_minus = stats_p['n_same'] - int(r['answer'])\n",
    "        loo_majority = 1 if n_same_minus > n_minus / 2 else (0 if n_same_minus < n_minus / 2 else np.nan)\n",
    "        if np.isnan(loo_majority): continue\n",
    "        hits += int(r['answer'] == loo_majority)\n",
    "        total += 1\n",
    "    if total >= 1:\n",
    "        participant_acc.append({'user_id': uid, 'acc': hits / total, 'n': total})\n",
    "\n",
    "human_acc_df = pd.DataFrame(participant_acc)\n",
    "print(f'\\nIndividual human accuracy vs LOO consensus (n={len(human_acc_df)}):')\n",
    "print(f'  Mean: {human_acc_df[\"acc\"].mean():.4f}  Median: {human_acc_df[\"acc\"].median():.4f}')\n",
    "print(f'  Std:  {human_acc_df[\"acc\"].std():.4f}  Range: [{human_acc_df[\"acc\"].min():.4f}, {human_acc_df[\"acc\"].max():.4f}]')\n",
    "\n",
    "model_accs = {row['model']: row['Acc@opt'] for _, row in verif_df.iterrows()}\n",
    "\n",
    "from scipy.stats import gaussian_kde\n",
    "\n",
    "fig = plt.figure(figsize=(11, 4.8))\n",
    "gs = fig.add_gridspec(2, 1, height_ratios=[1.1, 1.4], hspace=0.08)\n",
    "ax_kde = fig.add_subplot(gs[0])\n",
    "ax_dot = fig.add_subplot(gs[1], sharex=ax_kde)\n",
    "\n",
    "kde = gaussian_kde(human_acc_df['acc'].values, bw_method=0.12)\n",
    "x_range = np.linspace(0.00, 1.0, 500)\n",
    "y_kde = kde(x_range)\n",
    "ax_kde.fill_between(x_range, 0, y_kde, alpha=0.30, color='#888', edgecolor='#555', linewidth=1.2)\n",
    "ax_kde.plot(x_range, y_kde, color='#555', linewidth=1.2)\n",
    "ax_kde.set_ylabel(f'Individual listeners\\n(n = {len(human_acc_df)})', fontsize=10)\n",
    "ax_kde.set_yticks([])\n",
    "ax_kde.tick_params(axis='x', labelbottom=False)\n",
    "for spine in ('top', 'right'):\n",
    "    ax_kde.spines[spine].set_visible(False)\n",
    "\n",
    "type_palette = {'Supervised': '#2196F3', 'Self-supervised': '#FF9800', 'Weakly supervised': '#9C27B0'}\n",
    "by_type = {'Supervised': [], 'Self-supervised': [], 'Weakly supervised': []}\n",
    "for m in available_models:\n",
    "    if m not in model_accs: continue\n",
    "    by_type[MODEL_INFO[m]['type']].append((m, model_accs[m]))\n",
    "for k in by_type:\n",
    "    by_type[k].sort(key=lambda x: -x[1])\n",
    "\n",
    "rows_top_down = []\n",
    "for ptype in ['Supervised', 'Self-supervised', 'Weakly supervised']:\n",
    "    for m, acc in by_type[ptype]:\n",
    "        rows_top_down.append((m, acc, ptype))\n",
    "    rows_top_down.append((None, None, None))\n",
    "rows_top_down.pop()\n",
    "rows = rows_top_down[::-1]\n",
    "\n",
    "for y_idx, (m, acc, ptype) in enumerate(rows):\n",
    "    if m is None:\n",
    "        continue\n",
    "    color = type_palette[ptype]\n",
    "    ax_dot.plot(acc, y_idx, 'o', color=color, markersize=11, markeredgecolor='black',\n",
    "                markeredgewidth=0.7, zorder=5)\n",
    "\n",
    "DISPLAY_NAME = {'rawnet3': 'RawNet3', 'ecapa_tdnn': 'ECAPA-TDNN',\n",
    "                'titanet': 'TitaNet', 'resemblyzer': 'resemblyzer',\n",
    "                'xvector': 'x-vector', 'wav2vec2': 'wav2vec 2.0',\n",
    "                'hubert': 'HuBERT', 'wavlm': 'WavLM',\n",
    "                'whisper': 'Whisper', 'xlsr': 'XLS-R'}\n",
    "y_labels = [(DISPLAY_NAME[r[0]] if r[0] is not None else '') for r in rows]\n",
    "ax_dot.set_yticks(range(len(rows)))\n",
    "ax_dot.set_yticklabels(y_labels, fontsize=10)\n",
    "for tick, (m, acc, ptype) in zip(ax_dot.get_yticklabels(), rows):\n",
    "    if ptype is not None:\n",
    "        tick.set_color(type_palette[ptype])\n",
    "\n",
    "mean_human = human_acc_df['acc'].mean()\n",
    "for ax in (ax_kde, ax_dot):\n",
    "    ax.axvline(mean_human, color='black', linestyle=':', linewidth=1.1, alpha=0.65, zorder=1)\n",
    "ax_kde.text(mean_human, y_kde.max() * 0.95,\n",
    "            f'mean human = {mean_human:.2f}',\n",
    "            ha='center', va='top', fontsize=9,\n",
    "            bbox=dict(boxstyle='round,pad=0.3', facecolor='white', edgecolor='none', alpha=0.9))\n",
    "\n",
    "ax_dot.set_xlim(0.00, 1.0)\n",
    "ax_dot.set_ylim(-1, len(rows))\n",
    "ax_dot.set_xlabel('Accuracy vs leave-one-out human majority vote', fontsize=11)\n",
    "for spine in ('top', 'right'):\n",
    "    ax_dot.spines[spine].set_visible(False)\n",
    "\n",
    "from matplotlib.patches import Patch\n",
    "ax_dot.legend(handles=[\n",
    "    Patch(color=type_palette['Supervised'], label='Supervised'),\n",
    "    Patch(color=type_palette['Self-supervised'], label='SSL'),\n",
    "    Patch(color=type_palette['Weakly supervised'], label='Weakly supervised'),\n",
    "], loc='lower right', frameon=True, framealpha=0.95, fontsize=9)\n",
    "\n",
    "plt.savefig('manuscript/figures/human_baseline_2.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()\n",
    "\n",
    "print(f'\\nModel percentile rank in human accuracy distribution:')\n",
    "for model_name in available_models:\n",
    "    if model_name in model_accs:\n",
    "        acc = model_accs[model_name]\n",
    "        pct = (human_acc_df['acc'] < acc).mean() * 100\n",
    "        print(f'  {model_name:15s}  acc={acc:.4f}  beats {pct:.1f}% of individual humans')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec10_interp",
   "metadata": {},
   "source": [
    "### Section 10: Interpretation\n",
    "\n",
    "**What the numbers say.** Of 1,290 total participants, 457 completed at least 25 trials (the minimum needed for a reliable per-participant accuracy estimate). Their mean agreement with the leave-one-out population consensus is 0.73 (std 0.09, range 0.34-0.94). The wide range reflects that this set includes listeners who completed enough trials for a reliable estimate but did not pass the PNAS-preregistered quality filter, including some low-agreement individuals.\n",
    "\n",
    "Model agreement (at each model's optimal threshold):\n",
    "- **resemblyzer (Acc=0.80) beats 82% of individual humans.**\n",
    "- **ECAPA-TDNN (0.79) beats 78%** of individual humans.\n",
    "- TitaNet (0.78) beats 76%; RawNet3 (0.78) beats 76%; x-vector (0.77) beats 72%.\n",
    "- Best-layer SSL: HuBERT (0.72) beats 37%, wav2vec2 (0.71) beats 31%, WavLM (0.70) beats 28%, XLS-R (0.70) beats 25%.\n",
    "- Whisper (0.64) beats only 14% of individual humans.\n",
    "\n",
    "**Headline statement for the paper:** State-of-the-art supervised speaker embeddings agree with the population-consensus voice-identity label more often than **76-82% of individual listeners** who completed enough trials. Best-layer SSL models reach **25-37%** of the human distribution. Even Whisper, the weakest benchmarked model, matches some 14% of listeners.\n",
    "\n",
    "**What we do NOT claim.** Models are NOT \"more accurate than humans\" in an absolute sense; the population consensus itself is probabilistic for ambiguous pairs (voice clones, mid-blends). The claim is about consensus alignment: models rank and decide in closer agreement with the population than the majority of individuals do.\n",
    "\n",
    "**Connection to the noise ceiling.** The 61%-of-ceiling gap in Section 3 and the individual-human baseline describe the same listener-variability phenomenon from two angles: individual humans also fall short of the population consensus (mean individual agreement = 0.73 vs. model-to-consensus agreement = 0.80 for the best model). Closing the remaining gap requires modeling listener heterogeneity (e.g., listener-conditioned embeddings, personalized identity thresholds), not better speaker representations per se.\n",
    "\n",
    "**Limitations.**\n",
    "1. The consensus is drawn from a specific US-English crowdworker pool; a different population would produce a different consensus.\n",
    "2. The >=25-trials filter is a statistical requirement for reliable per-participant accuracy estimation, not a quality filter; it leaves a listener distribution that includes both high-engagement and low-engagement responders.\n",
    "3. Model thresholds were tuned on the full majority-vote labels (Section 4), giving models a mild tuning advantage over individual humans. A fully nested protocol would slightly reduce the model percentiles but not change the ordering."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec11_header",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 11: Stimulus-Type Ablation (Type 6 Dominance Check)\n",
    "\n",
    "**Motivation:** Type 6 (blended voices) accounts for 8,100 of 9,800 pairs (83%). The headline Pearson r and RSA metrics are dominated by this single stimulus type. If model rankings were driven by Type 6 alone, the claimed benchmark would be narrower than it appears.\n",
    "\n",
    "We recompute the main metrics on **Types 1-5 only** (1,700 pairs, excluding blended voices) and compare rankings to the full dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "sec11_code",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:20.046849Z",
     "iopub.status.busy": "2026-04-22T16:24:20.046583Z",
     "iopub.status.idle": "2026-04-22T16:24:20.162805Z",
     "shell.execute_reply": "2026-04-22T16:24:20.160647Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pairs excluding Type 6: 1700\n",
      "Binary-classifiable (exclude ties): 1594\n",
      "\n",
      "Type 6 ablation: metrics with and without blended voices:\n",
      "      model  r (Types 1-6)  r (Types 1-5 only)  r delta  AUC (Types 1-6)  AUC (Types 1-5 only)  AUC delta\n",
      "resemblyzer         0.6557              0.8036   0.1479           0.8722                0.9293     0.0571\n",
      "    titanet         0.6381              0.7944   0.1563           0.8614                0.9213     0.0599\n",
      " ecapa_tdnn         0.6456              0.7910   0.1455           0.8621                0.9180     0.0558\n",
      "    rawnet3         0.6171              0.7736   0.1565           0.8511                0.9128     0.0616\n",
      "    xvector         0.5973              0.7618   0.1645           0.8573                0.9181     0.0607\n",
      "      wavlm         0.5098              0.6151   0.1053           0.7897                0.8220     0.0323\n",
      "       xlsr         0.4651              0.5911   0.1260           0.7817                0.8110     0.0293\n",
      "   wav2vec2         0.4714              0.5731   0.1016           0.7703                0.7996     0.0293\n",
      "     hubert         0.4577              0.5685   0.1108           0.7653                0.7989     0.0335\n",
      "    whisper         0.2258              0.2030  -0.0228           0.6505                0.6485    -0.0021\n",
      "\n",
      "Spearman rank correlation between full-set and Type-1-5-only rankings: 0.9758\n"
     ]
    }
   ],
   "source": [
    "# Recompute Pearson r and AUC on Types 1-5 only (exclude Type 6 blends)\n",
    "\n",
    "df_no6 = df[df['stimuli_type'] != 6].copy()\n",
    "df_no6_binary = df_no6[(df_no6['p_same_full'] != 0.5) & df_no6['p_same_full'].notna()]\n",
    "\n",
    "print(f'Pairs excluding Type 6: {len(df_no6)}')\n",
    "print(f'Binary-classifiable (exclude ties): {len(df_no6_binary)}')\n",
    "\n",
    "ablation_rows = []\n",
    "for model_name in available_models:\n",
    "    col = f'{model_name}_cosim'\n",
    "    \n",
    "    # Pearson r on Types 1-5\n",
    "    valid = df_no6.dropna(subset=[col, 'p_same_full'])\n",
    "    r_no6, _ = pearsonr(valid[col], valid['p_same_full']) if len(valid) > 10 else (np.nan, None)\n",
    "    \n",
    "    # Pearson r on full (Types 1-6)\n",
    "    valid_all = df.dropna(subset=[col, 'p_same_full'])\n",
    "    r_all, _ = pearsonr(valid_all[col], valid_all['p_same_full']) if len(valid_all) > 10 else (np.nan, None)\n",
    "    \n",
    "    # AUC on Types 1-5 binary\n",
    "    valid_b = df_no6_binary.dropna(subset=[col])\n",
    "    if len(valid_b) > 10:\n",
    "        auc_no6 = roc_auc_score(valid_b['majority_full'], valid_b[col])\n",
    "    else:\n",
    "        auc_no6 = np.nan\n",
    "    \n",
    "    auc_all = auc_results.get(model_name, np.nan)\n",
    "    \n",
    "    ablation_rows.append({\n",
    "        'model': model_name,\n",
    "        'r (Types 1-6)': r_all,\n",
    "        'r (Types 1-5 only)': r_no6,\n",
    "        'r delta': r_no6 - r_all,\n",
    "        'AUC (Types 1-6)': auc_all,\n",
    "        'AUC (Types 1-5 only)': auc_no6,\n",
    "        'AUC delta': auc_no6 - auc_all\n",
    "    })\n",
    "\n",
    "ablation_df = pd.DataFrame(ablation_rows).sort_values('r (Types 1-5 only)', ascending=False)\n",
    "print('\\nType 6 ablation: metrics with and without blended voices:')\n",
    "print(ablation_df.round(4).to_string(index=False))\n",
    "\n",
    "# Are rankings preserved?\n",
    "rank_all = ablation_df['r (Types 1-6)'].rank(ascending=False).values\n",
    "rank_no6 = ablation_df['r (Types 1-5 only)'].rank(ascending=False).values\n",
    "rank_corr, _ = spearmanr(rank_all, rank_no6)\n",
    "print(f'\\nSpearman rank correlation between full-set and Type-1-5-only rankings: {rank_corr:.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec11_interp",
   "metadata": {},
   "source": [
    "### Section 11: Interpretation\n",
    "\n",
    "**Rankings are essentially preserved** when Type 6 is excluded: Spearman rank correlation between full-set and Types-1-5-only rankings is 0.976. Absolute Pearson r *increases* on the Types-1-5 subset for every model except Whisper (deltas typically +0.10 to +0.17). Type 6 has high within-pair noise (many blend stimuli at each ratio, judged by few participants each), which drags down pair-level correlations. The blended stimuli make the benchmark harder, not easier.\n",
    "\n",
    "**Whisper is the one exception**: its Type-6-excluded r (0.203) is *below* its full-set r (0.226) -- the only model whose performance worsens without blends. This reflects that Whisper's small residual identity signal is most visible over Type 6's wide P(same) range; on the narrower range of Types 1-5, what little signal it has is buried in noise. This is another indicator of Whisper's weak speaker representation rather than a property of the benchmark.\n",
    "\n",
    "**Implication for the paper.** The benchmark's conclusions hold without Type 6. Model rankings reflect genuine voice-identity perception alignment rather than an artifact of the blended-voice stimulus type. The Type-6-excluded table belongs in the supplementary material as a robustness check."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec12_header",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 12: Demographic Fairness\n",
    "\n",
    "**Motivation:** Benchmarks that ignore fairness risk rewarding models that perform well only on dominant demographics. The dataset has 100 speakers balanced 50M/50F with 5 sociophonetic groups. We measure whether model-human alignment varies by speaker demographics.\n",
    "\n",
    "**Metrics per demographic subgroup:**\n",
    "- Pearson r between cosine similarity and P(same)\n",
    "- AUC against majority vote\n",
    "\n",
    "**Disparity metric:** max - min across subgroups. Large disparity means the model's performance depends on who the speaker is, which is a fairness concern for applications like voice authentication."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sec12_code",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:20.165744Z",
     "iopub.status.busy": "2026-04-22T16:24:20.165475Z",
     "iopub.status.idle": "2026-04-22T16:24:21.480448Z",
     "shell.execute_reply": "2026-04-22T16:24:21.478559Z"
    }
   },
   "outputs": [],
   "source": [
    "# Demographic fairness: model-human alignment by speaker gender and group\n",
    "\n",
    "# Attach speaker metadata to each stimulus via the reference speaker\n",
    "spk_meta = speakers.set_index('id')[['gender', 'group', 'age']].to_dict('index')\n",
    "df['ref_gender'] = df['reference'].map(lambda s: spk_meta.get(s, {}).get('gender', np.nan))\n",
    "df['ref_group'] = df['reference'].map(lambda s: spk_meta.get(s, {}).get('group', np.nan))\n",
    "df['ref_age'] = df['reference'].map(lambda s: spk_meta.get(s, {}).get('age', np.nan))\n",
    "\n",
    "def subgroup_alignment(df_sub, model_name):\n",
    "    col = f'{model_name}_cosim'\n",
    "    valid = df_sub.dropna(subset=[col, 'p_same_full'])\n",
    "    if len(valid) < 30:\n",
    "        return {'r': np.nan, 'n': len(valid)}\n",
    "    r, _ = pearsonr(valid[col], valid['p_same_full'])\n",
    "    return {'r': r, 'n': len(valid)}\n",
    "\n",
    "# ---- By gender ----\n",
    "gender_results = []\n",
    "for model_name in available_models:\n",
    "    for g, glabel in [(1, 'Female'), (2, 'Male')]:\n",
    "        sub = df[df['ref_gender'] == g]\n",
    "        res = subgroup_alignment(sub, model_name)\n",
    "        gender_results.append({'model': model_name, 'gender': glabel, **res})\n",
    "gender_df = pd.DataFrame(gender_results)\n",
    "gender_pivot = gender_df.pivot(index='model', columns='gender', values='r').round(4)\n",
    "gender_pivot['disparity'] = (gender_pivot['Male'] - gender_pivot['Female']).abs()\n",
    "gender_pivot = gender_pivot.sort_values('disparity', ascending=False)\n",
    "gender_pivot.index = [DISPLAY_NAME[m] for m in gender_pivot.index]\n",
    "print('Alignment (Pearson r) by speaker gender:')\n",
    "print(gender_pivot.to_string())\n",
    "\n",
    "# ---- By sociophonetic group ----\n",
    "print('\\n\\nAlignment (Pearson r) by sociophonetic group:')\n",
    "group_results = []\n",
    "for model_name in available_models:\n",
    "    for g in sorted(df['ref_group'].dropna().unique()):\n",
    "        sub = df[df['ref_group'] == g]\n",
    "        res = subgroup_alignment(sub, model_name)\n",
    "        group_results.append({'model': model_name, 'group': int(g), **res})\n",
    "group_df = pd.DataFrame(group_results)\n",
    "group_pivot = group_df.pivot(index='model', columns='group', values='r').round(4)\n",
    "group_pivot['max-min'] = group_pivot.max(axis=1) - group_pivot.min(axis=1)\n",
    "group_pivot = group_pivot.sort_values('max-min', ascending=False)\n",
    "group_pivot.index = [DISPLAY_NAME[m] for m in group_pivot.index]\n",
    "print(group_pivot.to_string())\n",
    "\n",
    "# Visualize\n",
    "fig, axes = plt.subplots(1, 2, figsize=(16, 5))\n",
    "sns.heatmap(gender_pivot[['Female', 'Male']], annot=True, fmt='.3f', cmap='RdYlGn',\n",
    "            vmin=0, vmax=0.7, ax=axes[0], cbar_kws={'label': 'Pearson r'})\n",
    "\n",
    "group_cols = [c for c in group_pivot.columns if c != 'max-min']\n",
    "sns.heatmap(group_pivot[group_cols], annot=True, fmt='.3f', cmap='RdYlGn',\n",
    "            vmin=0, vmax=0.7, ax=axes[1], cbar_kws={'label': 'Pearson r'})\n",
    "plt.tight_layout()\n",
    "plt.savefig('manuscript/figures/fairness_heatmap_1.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec12_interp",
   "metadata": {},
   "source": [
    "### Section 12: Interpretation\n",
    "\n",
    "**Gender disparities are small for all benchmark-competitive models.** Max gender gap |r_female - r_male|:\n",
    "- Supervised: 0.001-0.014 (ECAPA-TDNN 0.001, resemblyzer 0.002, TitaNet 0.011, RawNet3 0.013, x-vector 0.014). Effectively gender-neutral.\n",
    "- SSL (best-layer): 0.003-0.014 (WavLM 0.003, HuBERT 0.003, wav2vec2 0.014, XLS-R 0.014). Also effectively neutral.\n",
    "- **Whisper** shows a substantially larger disparity (0.122) -- male speakers are far better predicted than female. This is consistent with Whisper's training corpus having known gender imbalances.\n",
    "\n",
    "**Sociophonetic group disparities (max-min across 5 groups) cluster around 0.11-0.17 for all models.** Groups 1-3 tend to be best-predicted, Groups 4-5 worst. Because the pattern holds across supervised and SSL families, it likely reflects stimulus-level variability between groups rather than model-specific bias.\n",
    "\n",
    "**Best-layer SSL substantially improved gender fairness** compared to last-layer SSL. Earlier last-layer numbers showed SSL gender gaps of 0.05-0.08; with best-layer selection these drop to 0.003-0.014. The suppression of speaker-relevant features in deeper SSL layers was partially gender-correlated; early layers encode identity more uniformly across gender.\n",
    "\n",
    "**Caveats.** With 20 speakers per group and 50 per gender, statistical power for small subgroup-difference tests is modest. We report descriptive disparities, not inferential tests. Fairness certification would require a larger and more demographically stratified speaker pool.\n",
    "\n",
    "**For the paper.** The gender-equitable result holds for all models except Whisper. Sociophonetic disparities are a limitation worth flagging but not model-specific."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec13_header",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 13: SSL Layer-Wise Alignment (Sensitivity Analysis)\n",
    "\n",
    "**Purpose of this section.** The main benchmark already uses **nested-CV best-layer selection** for SSL models' cosine similarity (Section 2). This section provides the per-layer diagnostic: for each SSL model, we show how alignment varies across all transformer layers, making the layer-selection behavior transparent and interpretable.\n",
    "\n",
    "**What this shows:**\n",
    "1. **Per-layer curves**: Pearson r against P(same) as a function of layer index, for all 5 SSL models.\n",
    "2. **Best-layer position**: which layer the nested-CV procedure selects, and how consistent it is across folds.\n",
    "3. **Last-layer comparison**: the out-of-the-box (`last_hidden_state`) alignment that the main benchmark would have reported without layer selection.\n",
    "\n",
    "**Key methodological disclosure.** The r values reported here are computed using ALL data to fit the per-layer curves (for visualization). The main benchmark's SSL cosine similarities in Section 2 use strictly nested speaker-CV: each pair's cosine similarity comes from the layer chosen on training-fold speakers (excluding that pair's speaker). The nested-CV numbers are slightly lower than the all-data numbers here (small overfitting correction), but the per-layer shape is nearly identical across folds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "sec13_code",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:21.484092Z",
     "iopub.status.busy": "2026-04-22T16:24:21.483805Z",
     "iopub.status.idle": "2026-04-22T16:24:21.501779Z",
     "shell.execute_reply": "2026-04-22T16:24:21.499697Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reused wav2vec2_layers from Section 2: 9900 clips, shape (13, 768)\n",
      "Reused hubert_layers from Section 2: 9900 clips, shape (13, 768)\n",
      "Reused wavlm_layers from Section 2: 9900 clips, shape (13, 768)\n",
      "Reused xlsr_layers from Section 2: 9900 clips, shape (25, 1024)\n",
      "Reused whisper_layers from Section 2: 9900 clips, shape (7, 512)\n",
      "[cache HIT] layer_alignment: Per-layer Pearson r for SSL models\n",
      "\n",
      "wav2vec2 (13 layers):\n",
      "  per-layer r: [np.float64(0.471), np.float64(0.457), np.float64(0.459), np.float64(0.436), np.float64(0.413), np.float64(0.396), np.float64(0.382), np.float64(0.363), np.float64(0.369), np.float64(0.391), np.float64(0.387), np.float64(0.21), np.float64(0.223)]\n",
      "  best layer: 0 (r=0.4714)\n",
      "  last layer (L=12, naive out-of-the-box baseline; NOT used in main benchmark): r=0.2232\n",
      "  improvement from layer selection: +0.2482\n",
      "\n",
      "hubert (13 layers):\n",
      "  per-layer r: [np.float64(0.48), np.float64(0.478), np.float64(0.407), np.float64(0.384), np.float64(0.359), np.float64(0.351), np.float64(0.344), np.float64(0.323), np.float64(0.307), np.float64(0.301), np.float64(0.308), np.float64(0.333), np.float64(0.269)]\n",
      "  best layer: 0 (r=0.4795)\n",
      "  last layer (L=12, naive out-of-the-box baseline; NOT used in main benchmark): r=0.2692\n",
      "  improvement from layer selection: +0.2103\n",
      "\n",
      "wavlm (13 layers):\n",
      "  per-layer r: [np.float64(0.51), np.float64(0.491), np.float64(0.456), np.float64(0.433), np.float64(0.432), np.float64(0.412), np.float64(0.384), np.float64(0.351), np.float64(0.3), np.float64(0.269), np.float64(0.27), np.float64(0.148), np.float64(0.227)]\n",
      "  best layer: 0 (r=0.5098)\n",
      "  last layer (L=12, naive out-of-the-box baseline; NOT used in main benchmark): r=0.2271\n",
      "  improvement from layer selection: +0.2827\n",
      "\n",
      "xlsr (25 layers):\n",
      "  per-layer r: [np.float64(0.459), np.float64(0.465), np.float64(0.445), np.float64(0.438), np.float64(0.436), np.float64(0.455), np.float64(0.41), np.float64(0.379), np.float64(0.376), np.float64(0.366), np.float64(0.347), np.float64(0.328), np.float64(0.324), np.float64(0.32), np.float64(0.325), np.float64(0.328), np.float64(0.335), np.float64(0.361), np.float64(0.4), np.float64(0.408), np.float64(0.253), np.float64(0.293), np.float64(0.031), np.float64(0.03), np.float64(0.027)]\n",
      "  best layer: 1 (r=0.4651)\n",
      "  last layer (L=24, naive out-of-the-box baseline; NOT used in main benchmark): r=0.0270\n",
      "  improvement from layer selection: +0.4381\n",
      "\n",
      "whisper (7 layers):\n",
      "  per-layer r: [np.float64(0.094), np.float64(0.104), np.float64(0.148), np.float64(0.226), np.float64(0.113), np.float64(0.069), np.float64(0.06)]\n",
      "  best layer: 3 (r=0.2258)\n",
      "  last layer (L=6, naive out-of-the-box baseline; NOT used in main benchmark): r=0.0604\n",
      "  improvement from layer selection: +0.1655\n"
     ]
    }
   ],
   "source": [
    "# Layer-wise alignment for SSL models (reuses layer_embs from Section 2; cached)\n",
    "\n",
    "SSL_LAYER_MODELS = ['wav2vec2', 'hubert', 'wavlm', 'xlsr', 'whisper']\n",
    "\n",
    "if 'layer_embs' not in dir() or not layer_embs:\n",
    "    # Fallback: load if not already in memory (should not happen in normal flow)\n",
    "    print('layer_embs not loaded; reloading from disk...')\n",
    "    layer_embs = {}\n",
    "    for m in SSL_LAYER_MODELS:\n",
    "        p = LAYER_EMB_DIR / f'{m}.npz'\n",
    "        if p.exists():\n",
    "            data = np.load(p, allow_pickle=True)\n",
    "            layer_embs[m] = {k: data[k] for k in data.files}\n",
    "else:\n",
    "    for m in SSL_LAYER_MODELS:\n",
    "        if m in layer_embs:\n",
    "            sample = next(iter(layer_embs[m].values()))\n",
    "            print(f'Reused {m}_layers from Section 2: {len(layer_embs[m])} clips, shape {sample.shape}')\n",
    "\n",
    "def _compute_layer_alignment():\n",
    "    result = {}\n",
    "    for model_name, emb_dict in layer_embs.items():\n",
    "        ref_keys = [f'{ref}R' for ref in df['reference']]\n",
    "        stim_keys = df['id'].tolist()\n",
    "        sample = next(iter(emb_dict.values()))\n",
    "        n_layers, dim = sample.shape\n",
    "        n_pairs = len(df)\n",
    "        \n",
    "        ref_arr = np.full((n_pairs, n_layers, dim), np.nan)\n",
    "        stim_arr = np.full((n_pairs, n_layers, dim), np.nan)\n",
    "        valid_mask = np.zeros(n_pairs, dtype=bool)\n",
    "        for i, (rk, sk) in enumerate(zip(ref_keys, stim_keys)):\n",
    "            if rk in emb_dict and sk in emb_dict:\n",
    "                ref_arr[i] = emb_dict[rk]\n",
    "                stim_arr[i] = emb_dict[sk]\n",
    "                valid_mask[i] = True\n",
    "        ref_v = ref_arr[valid_mask]\n",
    "        stim_v = stim_arr[valid_mask]\n",
    "        ref_n = ref_v / (np.linalg.norm(ref_v, axis=2, keepdims=True) + 1e-10)\n",
    "        stim_n = stim_v / (np.linalg.norm(stim_v, axis=2, keepdims=True) + 1e-10)\n",
    "        cosims = np.sum(ref_n * stim_n, axis=2)  # (N, L)\n",
    "        y = df.loc[valid_mask, 'p_same_full'].values\n",
    "        finite = np.isfinite(y)\n",
    "        layer_r = []\n",
    "        for l in range(n_layers):\n",
    "            xl = cosims[:, l]\n",
    "            m_fin = np.isfinite(xl) & finite\n",
    "            if m_fin.sum() < 10:\n",
    "                layer_r.append(np.nan)\n",
    "            else:\n",
    "                r, _ = pearsonr(xl[m_fin], y[m_fin])\n",
    "                layer_r.append(r)\n",
    "        result[model_name] = np.array(layer_r)\n",
    "    return result\n",
    "\n",
    "layer_alignment = cached('layer_alignment', _compute_layer_alignment,\n",
    "                         'Per-layer Pearson r for SSL models')\n",
    "\n",
    "for model_name, layer_r in layer_alignment.items():\n",
    "    n_layers = len(layer_r)\n",
    "    best_l = int(np.nanargmax(layer_r))\n",
    "    last_l = n_layers - 1\n",
    "    print(f'\\n{model_name} ({n_layers} layers):')\n",
    "    print(f'  per-layer r: {[round(x, 3) for x in layer_r]}')\n",
    "    print(f'  best layer: {best_l} (r={layer_r[best_l]:.4f})')\n",
    "    print(f'  last layer (L={last_l}, naive out-of-the-box baseline; NOT used in main benchmark): r={layer_r[last_l]:.4f}')\n",
    "    print(f'  improvement from layer selection: {layer_r[best_l] - layer_r[last_l]:+.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "sec13_plot",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:21.505102Z",
     "iopub.status.busy": "2026-04-22T16:24:21.504843Z",
     "iopub.status.idle": "2026-04-22T16:24:21.984337Z",
     "shell.execute_reply": "2026-04-22T16:24:21.982008Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "SSL last-layer vs best-layer summary:\n",
      "   model  n_layers  r_last_layer (used in main)  r_best_layer  best_layer_index  best_layer_norm  improvement\n",
      "wav2vec2        13                       0.2232        0.4714                 0            0.000       0.2482\n",
      "  hubert        13                       0.2692        0.4795                 0            0.000       0.2103\n",
      "   wavlm        13                       0.2271        0.5098                 0            0.000       0.2827\n",
      "    xlsr        25                       0.0270        0.4651                 1            0.042       0.4381\n",
      " whisper         7                       0.0604        0.2258                 3            0.500       0.1655\n",
      "\n",
      "Best supervised model: r = 0.6557\n",
      "Best SSL (last layer):      r = 0.2692 (gap to supervised: 0.3864)\n",
      "Best SSL (best layer):      r = 0.5098 (gap to supervised: 0.1458)\n"
     ]
    }
   ],
   "source": [
    "# Plot: Pearson r vs normalized layer index for the four SSL models.\n",
    "# Whisper is excluded -- it is weakly supervised, not SSL.\n",
    "SSL_MODELS = ['wav2vec2', 'hubert', 'wavlm', 'xlsr']\n",
    "SSL_LABEL = {'wav2vec2': 'wav2vec 2.0', 'hubert': 'HuBERT',\n",
    "             'wavlm': 'WavLM', 'xlsr': 'XLS-R'}\n",
    "SSL_COLOR = {'wav2vec2': '#E74C3C', 'hubert': '#3498DB',\n",
    "             'wavlm':    '#9B59B6', 'xlsr':   '#16A085'}\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(9, 5))\n",
    "\n",
    "# Reference line: best supervised model (resemblyzer)\n",
    "REF_MODEL = 'resemblyzer'\n",
    "if REF_MODEL in available_models:\n",
    "    r_sup = compute_correlations(df, REF_MODEL, 'p_same_full')['pearson_r']\n",
    "    ax.axhline(r_sup, color='#555', alpha=0.6, linestyle='--', linewidth=1.3, zorder=1)\n",
    "    ax.text(0.99, r_sup + 0.012,\n",
    "            f'best supervised: {REF_MODEL} (r = {r_sup:.3f})',\n",
    "            fontsize=9, color='#333', ha='right', va='bottom')\n",
    "\n",
    "for m in SSL_MODELS:\n",
    "    if m not in layer_alignment:\n",
    "        continue\n",
    "    r_vec = layer_alignment[m]\n",
    "    layers_norm = np.linspace(0, 1, len(r_vec))\n",
    "    ax.plot(layers_norm, r_vec, 'o-', color=SSL_COLOR[m],\n",
    "            label=SSL_LABEL[m], linewidth=2.2, markersize=5.5, alpha=0.9)\n",
    "    best_l = int(np.nanargmax(r_vec))\n",
    "    ax.scatter([layers_norm[best_l]], [r_vec[best_l]], color=SSL_COLOR[m],\n",
    "               s=240, marker='*', edgecolor='black', linewidth=1.4, zorder=10)\n",
    "\n",
    "ax.set_xlabel('Normalized layer index (0 = first transformer layer, 1 = last)', fontsize=11)\n",
    "ax.set_ylabel('Pearson r with human P(same)', fontsize=11)\n",
    "ax.legend(title='SSL model', loc='lower left', frameon=True, framealpha=0.9, fontsize=10)\n",
    "ax.set_ylim(-0.05, 0.75)\n",
    "ax.set_xlim(-0.03, 1.03)\n",
    "for spine in ('top', 'right'):\n",
    "    ax.spines[spine].set_visible(False)\n",
    "plt.tight_layout()\n",
    "plt.savefig('manuscript/figures/layer_alignment.png', dpi=200, bbox_inches='tight')\n",
    "plt.show()\n",
    "\n",
    "# Summary table (still include Whisper for completeness in the printout)\n",
    "summary_layer = []\n",
    "for m, r_vec in layer_alignment.items():\n",
    "    best_l = int(np.nanargmax(r_vec))\n",
    "    last_l = len(r_vec) - 1\n",
    "    summary_layer.append({\n",
    "        'model': m,\n",
    "        'n_layers': len(r_vec),\n",
    "        'r_last_layer (used in main)': r_vec[last_l],\n",
    "        'r_best_layer': r_vec[best_l],\n",
    "        'best_layer_index': best_l,\n",
    "        'best_layer_norm': round(best_l / (len(r_vec) - 1), 3) if len(r_vec) > 1 else 0,\n",
    "        'improvement': r_vec[best_l] - r_vec[last_l]\n",
    "    })\n",
    "layer_summary_df = pd.DataFrame(summary_layer)\n",
    "print('\\nSSL last-layer vs best-layer summary:')\n",
    "print(layer_summary_df.round(4).to_string(index=False))\n",
    "\n",
    "best_sup_r = max(compute_correlations(df, m, 'p_same_full')['pearson_r']\n",
    "                 for m in available_models if MODEL_INFO[m]['type'] == 'Supervised')\n",
    "best_ssl_last_r = max(r_vec[-1] for r_vec in layer_alignment.values())\n",
    "best_ssl_best_r = max(np.nanmax(r_vec) for r_vec in layer_alignment.values())\n",
    "print(f'\\nBest supervised model: r = {best_sup_r:.4f}')\n",
    "print(f'Best SSL (last layer):      r = {best_ssl_last_r:.4f} (gap to supervised: {best_sup_r - best_ssl_last_r:.4f})')\n",
    "print(f'Best SSL (best layer):      r = {best_ssl_best_r:.4f} (gap to supervised: {best_sup_r - best_ssl_best_r:.4f})')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sec13_interp",
   "metadata": {},
   "source": [
    "### Section 13: Interpretation\n",
    "\n",
    "**Per-layer alignment (Pearson r with P(same)) reveals consistent patterns:**\n",
    "- **wav2vec2, HuBERT, WavLM, XLS-R**: speaker information peaks at or near layer 0 (CNN feature-projection output) or layer 1 (first transformer block), and declines monotonically in deeper layers. By the final layer, alignment drops substantially (e.g., WavLM: 0.50 at layer 0 -> 0.22 at layer 12; XLS-R: 0.46 at layer 1 -> 0.03 at layer 24).\n",
    "- **Whisper is different.** Its alignment peaks at layer 3 (middle of the 7-layer encoder) at only r=0.22, and both earlier and later layers are weaker. This reflects Whisper's multitask ASR training: speaker identity is not preserved at any depth.\n",
    "- **XLS-R's last 3 layers (22-24) are near-chance for speaker identity.** These layers specialize toward multilingual phonetic discrimination, not speaker features. Using XLS-R's last layer (as the out-of-the-box default would) gives r = 0.03 -- effectively useless for speaker verification. The nested-CV best-layer protocol (Section 2) correctly identifies layer 1 instead.\n",
    "\n",
    "**Diagnostic for the main benchmark:** The nested-CV layer selection consistently picks layers 0 or 1 for wav2vec2/HuBERT/WavLM/XLS-R and layer 3 for Whisper. These selections are stable across the 10 CV folds (verified by the `best_layer_per_fold` dictionary computed in Section 2), meaning the layer choice is not fragile to which speakers are held out.\n",
    "\n",
    "**Why last-layer would be misleading.** If the benchmark reported only last-layer SSL numbers (the naive default), it would:\n",
    "- Undersell wav2vec2 (0.22 instead of 0.46), HuBERT (0.27 vs 0.47), WavLM (0.22 vs 0.50).\n",
    "- Catastrophically mis-evaluate XLS-R (0.03 vs 0.46) -- reporting XLS-R as worse than chance, when it is actually competitive with wav2vec2/HuBERT.\n",
    "- Be unfair to the SSL family overall, inflating the supervised-vs-SSL gap from ~0.14 to ~0.38.\n",
    "\n",
    "**For the paper:** the main benchmark numbers (Sections 3-12) already use nested-CV best-layer for SSL. Section 13 is a methodological supplement that documents this choice and provides the per-layer transparency that reviewers will want. We also report last-layer r as a separate column in the grand summary table (Section 14) for anyone interested in zero-shot / out-of-the-box SSL performance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "part_VI_divider",
   "metadata": {},
   "source": [
    "---\n",
    "# Part VI \u2014 Summary\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_040",
   "metadata": {},
   "source": [
    "---\n",
    "## Section 14: Summary & Comparison Table\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cell_041",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2026-04-22T16:24:21.987254Z",
     "iopub.status.busy": "2026-04-22T16:24:21.986975Z",
     "iopub.status.idle": "2026-04-22T16:24:22.090071Z",
     "shell.execute_reply": "2026-04-22T16:24:22.088245Z"
    }
   },
   "outputs": [],
   "source": [
    "# Grand comparison table with noise-ceiling normalization\n",
    "summary_rows = []\n",
    "\n",
    "# Noise ceiling: R^2 ceiling = Spearman-Brown-corrected split-half reliability\n",
    "R2_CEILING = sb_reliability  # ~ 0.69\n",
    "\n",
    "# Map of SSL models to their last-layer r (for the sensitivity column)\n",
    "last_layer_r = {}\n",
    "for model_name in available_models:\n",
    "    last_col = f'{model_name}_cosim_lastlayer'\n",
    "    if last_col in df.columns:\n",
    "        valid = df.dropna(subset=[last_col, 'p_same_full'])\n",
    "        if len(valid) > 10:\n",
    "            r, _ = pearsonr(valid[last_col], valid['p_same_full'])\n",
    "            last_layer_r[model_name] = r\n",
    "\n",
    "for model_name in available_models:\n",
    "    row = {\n",
    "        'Model': model_name,\n",
    "        'Type': MODEL_INFO[model_name]['type'],\n",
    "        'Dim': MODEL_INFO[model_name]['dim'],\n",
    "    }\n",
    "\n",
    "    # Task 1: Pearson r (best-layer for SSL via nested-CV; native output for supervised)\n",
    "    corrs = compute_correlations(df, model_name, 'p_same_full')\n",
    "    row['Pearson r'] = corrs['pearson_r']\n",
    "    row['R^2'] = corrs['r_squared']\n",
    "    row['R^2 / ceiling'] = corrs['r_squared'] / R2_CEILING if R2_CEILING > 0 else np.nan\n",
    "\n",
    "    # Task 2: AUC, raw and calibrated ECE\n",
    "    row['AUC'] = auc_results.get(model_name, np.nan)\n",
    "    row['ECE_raw'] = ece_raw_results.get(model_name, np.nan)\n",
    "    row['ECE_cal'] = ece_results.get(model_name, np.nan)\n",
    "\n",
    "    # Task 3: speaker-level RDM RSA\n",
    "    rsa_row = rsa_df[rsa_df['model'] == model_name]\n",
    "    row['SpkRDM rho'] = rsa_row['rsa_rho'].values[0] if len(rsa_row) > 0 else np.nan\n",
    "\n",
    "    # Section 8: Mahalanobis (note: uses last-layer embeddings for SSL)\n",
    "    mahal_row = mahal_df[mahal_df['model'] == model_name] if len(mahal_df) > 0 else pd.DataFrame()\n",
    "    row['Mahal R^2'] = mahal_row['R2_mahalanobis'].values[0] if len(mahal_row) > 0 else np.nan\n",
    "\n",
    "    # Sensitivity: last-layer r for SSL models (empty for supervised, which have no layer choice)\n",
    "    row['r (last-layer SSL)'] = last_layer_r.get(model_name, np.nan)\n",
    "\n",
    "    # Significance: which other models this model is NOT significantly different from\n",
    "    # under BH FDR (q > 0.05) on the Pearson r column. Reads q_matrix from the\n",
    "    # paired-bootstrap cell. Empty string means model is significantly different from all others.\n",
    "    if 'q_matrix' in dir():\n",
    "        m_idx = available_models.index(model_name)\n",
    "        ties = [available_models[j] for j in range(len(available_models))\n",
    "                if j != m_idx and q_matrix[m_idx, j] > 0.05]\n",
    "        row['r tied with (BH q>.05)'] = ', '.join(ties) if ties else ''\n",
    "\n",
    "    summary_rows.append(row)\n",
    "\n",
    "summary = pd.DataFrame(summary_rows).sort_values('Pearson r', ascending=False)\n",
    "print('=' * 115)\n",
    "print('GRAND COMPARISON TABLE')\n",
    "print()\n",
    "print('  Pearson r:                Main benchmark protocol (best-layer via nested speaker-CV for SSL, native output for supervised)')\n",
    "print('  R^2 / ceiling:            Noise-ceiling-normalized R^2 (ceiling = {:.3f} from split-half reliability)'.format(R2_CEILING))\n",
    "print('  AUC:                      Area under ROC curve against human majority vote (Section 4)')\n",
    "print('  ECE_raw / ECE_cal:        Raw vs Platt-calibrated Expected Calibration Error (Section 4)')\n",
    "print('  SpkRDM rho:               Spearman correlation of speaker-pair dissimilarity matrices (Section 5)')\n",
    "print('  Mahal R^2:                Diagonal Mahalanobis R^2 on native embeddings (Section 8)')\n",
    "print('  r (last-layer SSL):       Pearson r using last_hidden_state (out-of-the-box baseline; sensitivity only)')\n",
    "print('  r tied with (BH q>.05):   Other models not significantly different on Pearson r (BH FDR; empty = differs from all)')\n",
    "print('=' * 115)\n",
    "print(summary.round(4).to_string(index=False))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cell_042",
   "metadata": {},
   "source": [
    "### Key Findings\n",
    "\n",
    "1. **Supervised speaker embeddings predict human identity judgments best, but SSL models are competitive with fair layer selection.** On the 124,876-judgment full dataset, top supervised models (resemblyzer r=0.656, ECAPA-TDNN r=0.646) are at the boundary of the top supervised tier (BH q=0.049, marginally significant). Best-layer SSL models (WavLM r=0.510, wav2vec2 r=0.471, XLS-R r=0.465, HuBERT r=0.458) are 0.15-0.20 below the top supervised tier -- a real but substantially smaller gap than last-layer SSL comparisons would suggest. Whisper (r=0.226) is the exception: its multitask ASR training suppresses speaker identity at all layers.\n",
    "\n",
    "2. **Significance matters.** Of 45 pairwise model comparisons, 43 are significant after Benjamini-Hochberg FDR correction at $\\alpha=0.05$. The two non-significant pairs sit within the top supervised tier (resemblyzer/ECAPA-TDNN) or within middle-SSL clusters.\n",
    "\n",
    "3. **The best supervised models match or exceed the majority of individual human listeners.** resemblyzer agrees with the leave-one-out population consensus more often than 82% of individual listeners; ECAPA-TDNN beats 78%; TitaNet, RawNet3, and x-vector each beat 72-76%. State-of-the-art supervised speaker embeddings agree with population-consensus voice-identity labels more often than the majority of participants.\n",
    "\n",
    "4. **Best-layer SSL models fall in the middle of the human distribution.** HuBERT beats 37% of individual listeners, wav2vec2 31%, WavLM 28%, XLS-R 25%, Whisper 14%. Fair layer selection moves SSL models from \"almost no one beats them\" (last-layer protocol) to \"a third of individuals beats them.\"\n",
    "\n",
    "5. **The 61%-of-ceiling gap is listener variability, not representational inadequacy.** The R^2 ceiling is 0.705 (from split-half reliability); the best model sits at 0.430. Because individual humans also fall short of the population-average P(same) (mean individual agreement 0.73 vs best model 0.80), closing the gap requires modeling listener-level heterogeneity rather than a better speaker embedding.\n",
    "\n",
    "6. **Fair SSL evaluation requires non-default layer selection.** Using `last_hidden_state` (the HuggingFace default) drops SSL alignment by 0.16-0.43 vs best-layer selection (e.g., XLS-R: r=0.03 last layer vs r=0.46 layer 1). Section 13 documents this; the main benchmark uses nested speaker-CV best-layer selection throughout.\n",
    "\n",
    "7. **Calibration is mostly a scale problem.** Raw ECE is dominated by cosine-similarity-range mismatch. After Platt scaling, four of five supervised models achieve ECE_cal of 0.018-0.027, and four SSL models match (0.022-0.035). **x-vector is the lone calibration outlier** (ECE_cal = 0.136) even after Platt scaling.\n",
    "\n",
    "8. **Real-to-synthetic transfer is lossy but no longer catastrophic.** With best-layer SSL, R^2_transfer is near zero for all non-Whisper models (0.003-0.30); the main issue is slope/intercept shifts in the cosine-similarity-to-P(same) mapping. Whisper remains an outlier with R^2_transfer = -0.15. **Takeaway:** real-speech calibration is not a reliable proxy for synthetic-speech calibration; application-specific calibration on the relevant stimulus distribution is required.\n",
    "\n",
    "9. **Speaker-level population structure is captured well across model families.** Aggregating to speaker-pair RDM raises every model's alignment (best-layer SSL reaches 0.63-0.72 vs supervised 0.74-0.81). Whisper remains an outlier (0.40).\n",
    "\n",
    "10. **The benchmark is robust to Type 6 dominance.** Removing the 8,100 blended pairs yields rank correlation 0.976 with full-set rankings; absolute r increases for every model except Whisper, indicating Type 6 makes the benchmark harder, not easier.\n",
    "\n",
    "11. **Best-layer SSL largely eliminates gender disparities.** All 9 non-Whisper models have |r_M - r_F| < 0.015; Whisper alone shows a 0.12 gender disparity. Sociophonetic group disparities (~0.11-0.17) are uniform across models, suggesting stimulus-level rather than model-specific variability.\n",
    "\n",
    "12. **Models weakly predict human uncertainty.** Best-model confidence-vs-agreement correlation is 0.34 (resemblyzer). No model reliably flags pairs humans will find ambiguous.\n",
    "\n",
    "13. **Supervised embedding spaces are isotropic w.r.t. human perception; best-layer SSL is modestly anisotropic.** Diagonal Mahalanobis does not help supervised models (deltas ~-0.03 to +0.01) but yields small gains for best-layer SSL (+0.02 to +0.10). The gain does not close the supervised gap.\n",
    "\n",
    "14. **Voice clones are the hardest stimulus type.** Type 3 (same-speaker clones) has 44% high-disagreement pairs and shows systematically lower model-human alignment than real recordings of the same speaker."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}