2024-03 - Data Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba92b949-fae3-4b69-9310-139bdfca6bf4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import itertools\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "import matplotlib.animation\n",
    "\n",
    "from datetime import datetime, timedelta\n",
    "from dateutil import rrule\n",
    "from matplotlib import pyplot as plt\n",
    "from matplotlib import dates as mdates\n",
    "from matplotlib import colors as mcolors\n",
    "from matplotlib import patheffects as mpeffects\n",
    "\n",
    "import IPython\n",
    "from IPython.display import HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24697eab-6a72-404a-8d09-99d9b88f6ca7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01200953-0fa5-452d-b628-799f0bce6274",
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_theme(style='white')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60757d98-935e-4d0f-83ab-24822d3ab723",
   "metadata": {},
   "outputs": [],
   "source": [
    "FULL_SIZE_FIG = (16, 8)\n",
    "SAVEFIG_OPTIONS = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7b8d4f0-e290-47bf-b03e-8cb9f80914fe",
   "metadata": {},
   "source": [
    "# Relative vs. Absolute Pitch Figure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74616e9c-2225-4b3a-ab1a-516e7bfaf1d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_packet(t, freq, t0, width=0.5):\n",
    "    envelope = np.exp(-(t-t0)**2/(width**2))\n",
    "    carrier = np.sin(2 * np.pi * freq * t)\n",
    "    return carrier * envelope\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "989f90af-3ae8-4871-8157-c15a3cb75421",
   "metadata": {},
   "source": [
    "This figure shows multiple waveforms at different frequencies. It's not easy to tell by eye what frequencies they are, but you can tell which ones are higher and lower frequency than one another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75328fcc-35c5-4795-a89f-347617f0fa37",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = 2**16\n",
    "\n",
    "ew = 1\n",
    "hz_freqs = [2.5, 7.5, 15]\n",
    "window =  6 * ew * len(hz_freqs)\n",
    "\n",
    "t = np.linspace(0, window, N)\n",
    "plt.figure(figsize=FULL_SIZE_FIG)\n",
    "\n",
    "for ii, freq in enumerate(hz_freqs):\n",
    "    plt.plot(t, make_packet(t, freq, t0=(3 + 6 * ii) * ew, width=ew), lw=2.5)\n",
    "\n",
    "plt.plot(t, [0] * len(t), 'k-', lw=2.5)\n",
    "\n",
    "ax = plt.gca()\n",
    "ax.tick_params(axis='x', labelsize=20)\n",
    "ax.set_yticks([])\n",
    "ax.set_xlim(0, window)\n",
    "ax.set_xlabel(\"Time (ms)\", fontsize=32);\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"images/frequencies.png\", **SAVEFIG_OPTIONS)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9322032b-b60b-4748-9090-aac4b9b9228f",
   "metadata": {},
   "source": [
    "This figure represents the three waveforms in the Fourier domain (plotting frequency vs. amplitude), where it is easy to see the absolute frequency of each wave."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8dd2359-709e-40c9-a562-b32ead8308c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def do_fft(signal, convolution_kernel_size=0):\n",
    "    output = np.real(np.sqrt(np.fft.rfft(signal)**2))\n",
    "    if convolution_kernel_size > 0:\n",
    "        kernel = np.ones(convolution_kernel_size) / convolution_kernel_size\n",
    "        output = np.convolve(output, kernel, mode=\"same\")\n",
    "    return output\n",
    "\n",
    "signal_width = window * 30\n",
    "\n",
    "t2 = np.linspace(0, signal_width, N)\n",
    "d = t2[1]-t2[0]\n",
    "f = np.fft.rfftfreq(N, d=d)\n",
    "ss = slice(0, np.where(f <= max(hz_freqs) + (0.75 * min(hz_freqs)))[0].max())\n",
    "\n",
    "spectrum_max = 0\n",
    "plt.figure(figsize=FULL_SIZE_FIG)\n",
    "for freq in hz_freqs:\n",
    "    spectrum = do_fft(make_packet(t2, freq, t0=signal_width/2, width=ew))\n",
    "    spectrum /= spectrum.sum()\n",
    "    spectrum_max = max(spectrum_max, spectrum.max())\n",
    "    plt.plot(f[ss], spectrum[ss], lw=5)\n",
    "\n",
    "plt.plot(f[ss], [0] * len(f[ss]), '-k', lw=5)\n",
    "\n",
    "ax = plt.gca()\n",
    "ax.set_yticks([])\n",
    "ax.tick_params(axis='x', labelsize=20)\n",
    "ax.set_xlabel(\"Frequency (kHz)\", fontsize=32);\n",
    "ax.set_xlim(f[ss].min(), f[ss].max())\n",
    "ax.set_ylim(0, spectrum_max.real * 1.1)\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"images/frequencies_fft.png\", **SAVEFIG_OPTIONS)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcdbccd5-b290-43a1-9be0-667d4e445cb3",
   "metadata": {},
   "source": [
    "# Analysis of Progression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c728c04-9d32-4e73-877a-2e1e50bdbecf",
   "metadata": {},
   "outputs": [],
   "source": [
    "color_dates = [\n",
    "    (\"yellow\", datetime(2023, 5, 24)),\n",
    "    (\"blue\", datetime(2023, 6, 11)),\n",
    "    (\"black\", datetime(2023, 7, 13)),\n",
    "    (\"green\", datetime(2023, 8, 7)),\n",
    "    (\"orange\", datetime(2023, 8, 21)),\n",
    "    (\"purple\", datetime(2023, 11, 11)),\n",
    "    (\"pink\", datetime(2023, 11, 28)),\n",
    "]\n",
    "\n",
    "import itertools\n",
    "a, b = itertools.tee(iter(color_dates))\n",
    "next(b)\n",
    "for (old_color, old_date), (new_color, new_date) in zip(a, b):\n",
    "    diff = (new_date - old_date) / timedelta(days=1)\n",
    "    print(f\"{old_color} → {new_color}: {diff:0.1f} days\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3069a063-579e-46bf-8e68-843996a6a600",
   "metadata": {},
   "outputs": [],
   "source": [
    "color_dates = [\n",
    "    (\"orange\", datetime(2023, 12, 10)),\n",
    "    (\"purple\", datetime(2023, 12, 27)),\n",
    "    (\"pink\", datetime(2024, 1, 14)),\n",
    "    (\"brown\", datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)),\n",
    "]\n",
    "\n",
    "import itertools\n",
    "a, b = itertools.tee(iter(color_dates))\n",
    "next(b)\n",
    "for (old_color, old_date), (new_color, new_date) in zip(a, b):\n",
    "    diff = (new_date - old_date) / timedelta(days=1)\n",
    "    print(f\"{old_color} → {new_color}: {diff:0.1f} days\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec302e03-8db1-4159-9be0-aa2409dff989",
   "metadata": {},
   "source": [
    "# Analysis of responses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ddbb6a0-ab26-443b-89d1-43dca5ef18af",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the data from a history file\n",
    "with open(\"data/cim_history.json\") as f:\n",
    "    json_data = json.load(f)\n",
    "\n",
    "# Should only be one profile in here, so we'll extract that\n",
    "assert len(json_data) == 1, \"Need to select a profile in multi-profile histories\"\n",
    "json_data = next(iter(json_data.values()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3e5ccafb-5331-4f52-85df-7a591a4a7394",
   "metadata": {},
   "outputs": [],
   "source": [
    "COLORS = [\n",
    "    \"red\",\n",
    "    \"yellow\",\n",
    "    \"blue\",\n",
    "    \"black\",\n",
    "    \"green\",\n",
    "    \"orange\",\n",
    "    \"purple\",\n",
    "    \"pink\",\n",
    "    \"brown\"\n",
    "]\n",
    "\n",
    "def to_idx(color):\n",
    "    return COLORS.index(color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1de6f9d-aa57-4e5d-9fa0-4990605960fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_date_formatter(ax):\n",
    "    start = datetime.max\n",
    "    end = datetime.min\n",
    "    for line in ax.lines:\n",
    "        x_data = line.get_xdata()\n",
    "        x_min = min(x_data).replace(tzinfo=None)\n",
    "        x_max = max(x_data).replace(tzinfo=None)\n",
    "        start = min(start, x_min)\n",
    "        end = max(end, x_max)\n",
    "    \n",
    "    if end - start < timedelta(days=120):\n",
    "        rule = mdates.rrulewrapper(rrule.MONTHLY, bymonthday=range(1, 31, 3))\n",
    "    elif end - start < timedelta(days=210):\n",
    "        rule = mdates.rrulewrapper(rrule.MONTHLY, bymonthday=range(1,31,5))\n",
    "    elif end - start < timedelta(days=365):\n",
    "        rule = mdates.rrulewrapper(rrule.WEEKLY, bymonthday=1)\n",
    "    else:\n",
    "        rule = mdates.rrulewrapper(rrule.MONTHLY, bymonthday=1)\n",
    "\n",
    "    xrange = (start, end)\n",
    "\n",
    "    locator = mdates.RRuleLocator(rule)\n",
    "    \n",
    "    ax.set_xticks(ax.get_xticks(), labels=ax.get_xticklabels(), rotation=45)\n",
    "    ax.xaxis.set_major_locator(locator)\n",
    "    ax.xaxis.set_major_formatter(\n",
    "        mdates.ConciseDateFormatter(\n",
    "            ax.xaxis.get_major_locator(),\n",
    "            show_offset=False,\n",
    "            formats=[\n",
    "                \"%Y\",\n",
    "                r\"$\\bf{%b}$\",\n",
    "                \"%d\",\n",
    "                \"%H:%M\",\n",
    "                \"%H:%M\",\n",
    "                \"%S.%f\",\n",
    "            ],\n",
    "        )\n",
    "    )\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e17ac8e2-d6aa-424c-8013-be46fac47dc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_session_history(history):\n",
    "    all_sessions = []\n",
    "\n",
    "    def to_datetime(df, col):\n",
    "        return pd.to_datetime(df[col], unit=\"s\", utc=True).dt.tz_convert(\"America/New_York\")\n",
    "    \n",
    "    for color, data in history.items():\n",
    "        if not data:\n",
    "            continue\n",
    "        session_df = pd.DataFrame(data)\n",
    "        session_df = session_df[[\"current_chord\", \"start_time\", \"updated_time\", \"identifications\", \"correct\"]]\n",
    "        all_sessions.append(session_df)\n",
    "\n",
    "    joined_df = pd.concat(all_sessions)\n",
    "    joined_df = joined_df.rename({\"current_chord\": \"color\"}, axis=1)\n",
    "    joined_df[\"start_time\"] = to_datetime(joined_df, \"start_time\")\n",
    "    joined_df[\"updated_time\"] = to_datetime(joined_df, \"updated_time\")\n",
    "    joined_df = joined_df.sort_values(by=\"start_time\")\n",
    "    joined_df[\"percent_correct\"] = (joined_df[\"correct\"] / joined_df[\"identifications\"]) * 100\n",
    "    return joined_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2beb46aa-923f-4842-828e-f6d66276da2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "session_history = get_session_history(json_data)\n",
    "session_history = session_history[session_history[\"color\"] != \"red\"] # These are not interesting"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eb1ab71-4e2c-4364-8cc5-e8c41d723060",
   "metadata": {},
   "source": [
    "In December 2023, we realized that we had moved on from Orange too quickly, because all through Purple and Pink, almost all the confusion was coming because he didn't have Orange down, so we jumped back to Orange. At the same time, we also switched to the \"new\" chords (using Tone.js), so I've divided the history into \"old\" and \"new\".\n",
    "\n",
    "This history starts after we had already been using the program for a few months."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ab4228f-9a4c-4e2f-86a3-3910738a8574",
   "metadata": {},
   "outputs": [],
   "source": [
    "switch_point = datetime(2023, 12, 10, 10)\n",
    "o_df = session_history.loc[session_history[\"start_time\"].dt.tz_localize(None) < switch_point]\n",
    "n_df = session_history.loc[session_history[\"start_time\"].dt.tz_localize(None) >= switch_point]\n",
    "\n",
    "o_df = o_df[o_df[\"color\"] != \"red\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ebc036d-3552-46a1-80aa-e847120e4bd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_session_history(df):\n",
    "    fig = plt.figure(figsize=(12, 5))\n",
    "    plt.plot(df[\"start_time\"], df[\"percent_correct\"].rolling(window=12).mean(), \"-\", zorder=0)\n",
    "    plt.scatter(df[\"start_time\"], df[\"percent_correct\"], color=df[\"color\"], zorder=1)\n",
    "    set_date_formatter(plt.gca())\n",
    "    ax = fig.gca()\n",
    "    ax.set_xlim(df[\"start_time\"].min() - timedelta(days=2), df[\"start_time\"].max() + timedelta(days=2))\n",
    "    ax.set_ylim(50, 102)\n",
    "    ax.set_ylabel(\"% Correct\", weight=\"bold\")\n",
    "    plt.tight_layout()\n",
    "\n",
    "with sns.axes_style(\"dark\"):\n",
    "    plot_session_history(o_df)\n",
    "    plt.savefig(\"images/response_history.png\", **SAVEFIG_OPTIONS)\n",
    "    plot_session_history(n_df)\n",
    "    plt.savefig(\"images/response_history_phase2.png\", **SAVEFIG_OPTIONS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7b506bd-5563-4519-85ba-ba6ee7590c13",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_confusion_matrix(history, color):\n",
    "    history_size = COLORS.index(color) + 1\n",
    "    sessions = history[color]\n",
    "    arr = np.zeros((history_size, history_size, len(sessions)))\n",
    "    for ii, session in enumerate(sessions):\n",
    "        for target_color in session[\"confusion_matrix\"]:\n",
    "            for act_color, num in session[\"confusion_matrix\"][target_color].items():\n",
    "                arr[to_idx(target_color), to_idx(act_color), ii] = num\n",
    "    \n",
    "    timestamps = np.asarray([session[\"start_time\"] for session in sessions]).astype(\"datetime64[s]\")\n",
    "    return arr, timestamps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75f54911-cd41-472c-887e-4761acb89f8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def replace_value(arr, value, new_value):\n",
    "    arr_cp = arr.copy()\n",
    "    arr_cp[arr_cp == value] = new_value\n",
    "    return arr_cp\n",
    "\n",
    "def normalize_cm(cm):\n",
    "    off_diagonal = np.eye(cm.shape[0], dtype=bool)\n",
    "    n_cm = cm.copy()\n",
    "    n_cm[off_diagonal] = n_cm[off_diagonal] / (n_cm[off_diagonal].sum() or 1)\n",
    "    n_cm[~off_diagonal] = n_cm[~off_diagonal] / (n_cm[~off_diagonal].sum() or 1)\n",
    "\n",
    "    return n_cm\n",
    "\n",
    "default_palette = sns.diverging_palette(10, 220, sep=10, n=20, as_cmap=True)\n",
    "\n",
    "def plot_cm(cm, i, ts=None, cmap=default_palette, subsample=1, ax=None, title=None, suptitle=None, show_numbers=True):\n",
    "    if ax is None:\n",
    "        ax = plt.gca()\n",
    "\n",
    "    off_diagonal_mask = ~np.eye(cm.shape[0], dtype=bool)\n",
    "    all_off_diagonal_mask = np.tile(np.atleast_3d(off_diagonal_mask), (1, 1, cm.shape[2]))\n",
    "    vmin = (-cm[all_off_diagonal_mask]).min()\n",
    "\n",
    "    tick_labels = COLORS[:cm.shape[0]]\n",
    "    sub_cm = cm[:, :, i*subsample:(i + 1)*subsample].sum(axis=2)\n",
    "    new_cm = normalize_cm(sub_cm)\n",
    "    if ts is not None:\n",
    "        ts_ss = ts[i*subsample:(i + 1)*subsample]\n",
    "        ts_start = ts_ss.min()\n",
    "        ts_end = ts_ss.max()\n",
    "    else:\n",
    "        ts_start = None\n",
    "        ts_end = None\n",
    "    max_val = 1\n",
    "    new_cm[off_diagonal_mask] = -new_cm[off_diagonal_mask]\n",
    "    annot = sub_cm[::-1, :] if show_numbers else False\n",
    "    hm = sns.heatmap(new_cm[::-1,:],\n",
    "                cmap=cmap,\n",
    "                vmax=max_val,\n",
    "                vmin=vmin,\n",
    "                norm=mcolors.TwoSlopeNorm(vcenter=0),\n",
    "                xticklabels=tick_labels,\n",
    "                yticklabels=tick_labels[::-1],\n",
    "                cbar=False,\n",
    "                annot=annot,\n",
    "                fmt='g',\n",
    "                ax=ax)\n",
    "\n",
    "    if title is None:\n",
    "        if ts_start is None:\n",
    "            title = f\"{i}\"\n",
    "        else:\n",
    "            title = f\"{np.datetime_as_string(ts_start, unit='D')} — {np.datetime_as_string(ts_end, unit='D')}\"\n",
    "\n",
    "    if suptitle is not None:\n",
    "        if not title:\n",
    "            title = suptitle\n",
    "        elif title:\n",
    "            title = f\"{suptitle}\\n{title}\"\n",
    "    if title:\n",
    "        ax.set_title(title, weight=\"bold\", fontsize=16 if suptitle is not None else 18)\n",
    "\n",
    "    ax.set_xlabel(\"Guess\", weight=\"bold\")\n",
    "    ax.set_ylabel(\"Correct\", weight=\"bold\")\n",
    "    plt.tight_layout()\n",
    "\n",
    "    return hm\n",
    "\n",
    "def animated_cm(cm, ts = None, subsample = 10):\n",
    "    fig = plt.figure(figsize=(10, 6))\n",
    "    ax = fig.gca()\n",
    "        \n",
    "    def animate(i):\n",
    "        ax.clear()\n",
    "        plot_cm(cm, i, ts, subsample=subsample, ax=ax)\n",
    "    animation = matplotlib.animation.FuncAnimation(fig, animate, frames=cm.shape[2] // subsample)\n",
    "    plt.close()  # After the animation is done we don't need the plot anymore\n",
    "    return animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "346245df-e9c3-4161-bfd9-fa0d638723b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Split between old and new\n",
    "def split_cm(cm, ts):\n",
    "    mask = ts < switch_point\n",
    "    old_cm = cm[:, :, mask]\n",
    "    old_ts = ts[mask]\n",
    "    new_cm = cm[:, :, ~mask]\n",
    "    new_ts = ts[~mask]\n",
    "\n",
    "    return (old_cm, old_ts), (new_cm, new_ts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9f2bb73-9b4b-4ce6-b7eb-195669c36f07",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate confusion matrices\n",
    "o_cm, o_ts = make_confusion_matrix(json_data, \"orange\")\n",
    "(o_cm1, o_ts1), (o_cm2, o_ts2) = split_cm(o_cm, o_ts)\n",
    "\n",
    "k_cm, k_ts = make_confusion_matrix(json_data, \"black\")\n",
    "k_cm = k_cm[:, :, :-1]\n",
    "k_ts = k_ts[:-1]\n",
    "\n",
    "g_cm, g_ts = make_confusion_matrix(json_data, \"green\")\n",
    "g_cm = g_cm[:, :, :-1]\n",
    "g_ts = g_ts[:-1]\n",
    "\n",
    "p_cm, p_ts = make_confusion_matrix(json_data, \"pink\")\n",
    "(p_cm1, p_ts1), (p_cm2, p_ts2) = split_cm(p_cm, p_ts)\n",
    "\n",
    "v_cm, v_ts = make_confusion_matrix(json_data, \"purple\")\n",
    "(v_cm1, v_ts1), (v_cm2, v_ts2) = split_cm(v_cm, v_ts)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa9b997c-21aa-4690-bbba-9dca80fb4c45",
   "metadata": {},
   "outputs": [],
   "source": [
    "HEAT_MAP_FIGSIZE=(7, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9af65724-84b1-4916-8f08-0a1b3a86a92b",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=HEAT_MAP_FIGSIZE)\n",
    "plot_cm(v_cm1, 0, subsample=20, ts=v_ts1, suptitle=\"Pink\");\n",
    "plt.savefig(\"images/purple_phase1.png\", **SAVEFIG_OPTIONS)\n",
    "\n",
    "plt.figure(figsize=HEAT_MAP_FIGSIZE)\n",
    "plot_cm(v_cm2, 5, subsample=10, ts=v_ts, suptitle=\"Pink\");\n",
    "plt.savefig(\"images/purple_phase2.png\", **SAVEFIG_OPTIONS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "729bffa4-ecbe-4407-857f-41e43654907b",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=HEAT_MAP_FIGSIZE)\n",
    "plot_cm(p_cm1, 0, subsample=25, ts=p_ts1, suptitle=\"Pink\");\n",
    "plt.savefig(\"images/pink_phase1.png\", **SAVEFIG_OPTIONS)\n",
    "\n",
    "plt.figure(figsize=HEAT_MAP_FIGSIZE)\n",
    "plot_cm(p_cm2, 2, subsample=50, ts=p_ts2, suptitle=\"Pink\");\n",
    "plt.savefig(\"images/pink_phase2.png\", **SAVEFIG_OPTIONS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cbcd08d-ec02-47ff-84a3-529a05aed848",
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML(animated_cm(o_cm1, ts=o_ts1).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7aa74233-6ae2-413f-8a7a-dc5fe10cd1a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "HTML(animated_cm(o_cm2, ts=o_ts2, subsample=2).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e82ff01-91e8-40de-8a11-2c9b554c5f0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Purple\n",
    "HTML(animated_cm(v_cm1, ts=v_ts1, subsample=2).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c47d1306-59a0-4ac5-b717-1447a154a89e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Purple\n",
    "HTML(animated_cm(v_cm2, ts=v_ts2, subsample=2).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9c8fce97-a602-45be-9f2d-84bc86a25924",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Black\n",
    "HTML(animated_cm(k_cm, ts=k_ts, subsample=2).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d31e9d78-f4ec-4659-a991-637d7a10ada3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Green\n",
    "HTML(animated_cm(g_cm, ts=g_ts, subsample=2).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7734fbe4-9148-4e56-afe3-034ea33f958d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pink\n",
    "HTML(animated_cm(p_cm2, ts=p_ts2, subsample=2).to_jshtml())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fb2dcf6-9c8a-4e8d-a79f-84ec2d484e95",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pink\n",
    "HTML(animated_cm(p_cm1, ts=p_ts1, subsample=2).to_jshtml())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51877606-1fda-47dc-ab11-8bfb85e50978",
   "metadata": {},
   "source": [
    "# Adaptive Mode Figures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d6fea43-e7cd-4d53-9629-8dc3ed1f8133",
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrix_to_json(arr):\n",
    "    out = {}\n",
    "    for i, ci in zip(range(arr.shape[0]), COLORS):\n",
    "        out[ci] = {}\n",
    "        for j, cj in zip(range(arr.shape[0]), COLORS):\n",
    "            out[ci][cj] = int(arr[i, j])\n",
    "            \n",
    "    return json.dumps(out)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7764b4db-aee5-420a-9299-f97b14d20dba",
   "metadata": {},
   "outputs": [],
   "source": [
    "adaptive_mode_data = [\n",
    "    {\"confusion_matrix\": np.array(\n",
    "      [[ 100,   0,   0,   0,],\n",
    "       [  0,  100,   0,   0,],\n",
    "       [  0,   0,  100,   0,],\n",
    "       [  0,   0,   0,  100,]\n",
    "      ]),\n",
    "     \"coefficients\": np.array([ 0.25, 0.25, 0.25, 0.25 ]),\n",
    "    },\n",
    "    {\"confusion_matrix\": np.array(\n",
    "      [[ 100,   0,   0,   0,],\n",
    "       [  0,  100,   0,   0,],\n",
    "       [  1,   0,  110,   10,],\n",
    "       [  0,   0,   20,  120,]\n",
    "      ]),\n",
    "     \"coefficients\": np.array([ 0.16072842438638163, 0.1583531274742676, 0.3087885985748218, 0.3721298495645289 ])},\n",
    "    {\"confusion_matrix\": np.array(\n",
    "      [[ 100,   0,   0,   0,],\n",
    "       [  0,  100,   0,   0,],\n",
    "       [  1,   0,  110,   0,],\n",
    "       [  0,   0,   100,  120,]\n",
    "      ]),\n",
    "     \"coefficients\": np.array([ 0.09341923607915324, 0.09203865623561897, 0.24390243902439024, 0.5706396686608376 ])\n",
    "    }\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3aa35f4-fa52-4c72-8f91-9d0ff8e24c41",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, data in enumerate(adaptive_mode_data):\n",
    "    confusion_matrix = data[\"confusion_matrix\"].astype(\"float64\")\n",
    "    coefficients = data[\"coefficients\"]\n",
    "    \n",
    "    print(matrix_to_json(confusion_matrix))\n",
    "    plt.figure(figsize=(8, 5))\n",
    "    plot_cm(np.reshape(confusion_matrix,(*confusion_matrix.shape, 1)), 0, title=\"\", show_numbers=False)\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(f\"images/adaptive_example_cm_{i}.png\")\n",
    "    plt.figure(figsize=(6, 5))\n",
    "    plt.pie(coefficients, autopct=\"%1.1f%%\",\n",
    "            textprops={\"color\":\"w\", \"fontsize\": 14, \"fontweight\": \"bold\",\n",
    "                       \"path_effects\": [\n",
    "                           mpeffects.Stroke(linewidth=2, foreground=\"k\"),\n",
    "                           #mpeffects.SimplePatchShadow(alpha=0.5),\n",
    "                           mpeffects.Normal()]},\n",
    "            colors=COLORS[:len(coefficients)])\n",
    "    plt.tight_layout()\n",
    "    plt.savefig(f\"images/adaptive_example_pie_{i}.png\", **SAVEFIG_OPTIONS)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}