{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "aa000001",
   "metadata": {},
   "source": [
    "# GlitchGAN \u2014 GravitySpy Classification\n",
    "\n",
    "Standalone classification notebook. Injection pipeline follows `evaluation2.ipynb` exactly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3df13eb8",
   "metadata": {},
   "source": "## Dependencies\n\nThis notebook requires GravitySpy for classification. The PyPI release is broken with modern scipy, so install from GitHub:\n\n```bash\npip install \"glitchgan[eval]\"                                             # core deps + gravityspy runtime deps\npip install git+https://github.com/Gravity-Spy/GravitySpy.git --no-deps   # gravityspy (PyPI broken)\n```\n\n> **Note:** `--no-deps` skips GravitySpy's broken `scipy<=1.2.1` pin. The GitHub version replaces the removed `scipy.misc.imresize` with `skimage`, which is why it is required over the PyPI release."
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "aa000002",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Project root : /Users/tomdooney/Documents/Work/Projects/glitchgan\n",
      "Model exists : True\n"
     ]
    }
   ],
   "source": [
    "import os, sys, io, shutil, warnings, logging\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from pathlib import Path\n",
    "from tqdm.notebook import tqdm\n",
    "from IPython.display import Image as IPyImage, display as ipy_display\n",
    "\n",
    "PROJECT_ROOT = Path('..').resolve()\n",
    "sys.path.insert(0, str(PROJECT_ROOT / 'src'))\n",
    "\n",
    "from glitchgan.tf import GlitchGAN\n",
    "from glitchgan.tf.model_components import ArgmaxLayer, ReduceSumDotLayer\n",
    "from glitchgan.utils import whitened_snr_scaling\n",
    "\n",
    "# \u2500\u2500 paths \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n",
    "DATA_DIR       = PROJECT_ROOT / 'data'\n",
    "PLOTS_DIR      = PROJECT_ROOT / 'evaluation_plots'\n",
    "GENERATOR_PATH = PROJECT_ROOT / 'weights' / 'tensorflow' / 'generator_210_keras3.keras'\n",
    "PATH_TO_MODEL  = PROJECT_ROOT / 'models' / 'sidd-cqg-paper-O3-model.h5'\n",
    "#FIXME: set your local GravitySpy clone path\n",
    "PATH_TO_REPO   = '/path/to/GravitySpy/'\n",
    "\n",
    "os.makedirs(PLOTS_DIR, exist_ok=True)\n",
    "\n",
    "# \u2500\u2500 glitch classes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n",
    "LABEL_ORDER = [\n",
    "    'Blip', 'Fast_Scattering', 'Koi_Fish',\n",
    "    'Low_Frequency_Burst', 'Scattered_Light', 'Tomte', 'Whistle',\n",
    "]\n",
    "NUM_CLASSES = len(LABEL_ORDER)\n",
    "NOISE_DIM   = 100\n",
    "\n",
    "# \u2500\u2500 GravitySpy noise / classification config \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n",
    "IFO            = 'H1'\n",
    "SRATE          = 4096\n",
    "GW_START, GW_END = 1262540000, 1262540040\n",
    "CHANNEL        = f'{IFO}:GDS-CALIB_STRAIN'\n",
    "INIT_TIME      = -20\n",
    "EVENT_TIME     = 0\n",
    "SNR_TARGET     = 50\n",
    "NUM_CLASSIFY   = 10\n",
    "\n",
    "print('Project root :', PROJECT_ROOT)\n",
    "print('Model exists :', PATH_TO_MODEL.exists())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "aa000003",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded: generator_210_keras3.keras\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "\n",
    "gan = GlitchGAN()\n",
    "gan.generator = keras.models.load_model(\n",
    "    str(GENERATOR_PATH), compile=False,\n",
    "    custom_objects={'ArgmaxLayer': ArgmaxLayer, 'ReduceSumDotLayer': ReduceSumDotLayer}\n",
    ")\n",
    "print(f'Loaded: {GENERATOR_PATH.name}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "aa000004",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generated_signals: (70, 8192)\n",
      "labels           : (70,)\n"
     ]
    }
   ],
   "source": [
    "# Generate signals \u2014 same approach as evaluation2: explicit np.eye class vectors,\n",
    "# np.random.randn noise, no fixed seed\n",
    "class_vecs = np.repeat(np.eye(NUM_CLASSES, dtype='float32'), NUM_CLASSIFY, axis=0)\n",
    "noise_vecs = np.random.randn(NUM_CLASSES * NUM_CLASSIFY, NOISE_DIM).astype('float32')\n",
    "\n",
    "generated_signals = gan.generator([noise_vecs, class_vecs], training=False).numpy()\n",
    "labels            = np.repeat(np.array(LABEL_ORDER), NUM_CLASSIFY)\n",
    "\n",
    "print(f'generated_signals: {generated_signals.shape}')\n",
    "print(f'labels           : {labels.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa000005",
   "metadata": {},
   "source": [
    "## GravitySpy Classification\n",
    "\n",
    "Injection pipeline follows `evaluation2.ipynb` exactly: fresh noise fetch \u2192 `to_pycbc()` \u2192 whiten \u2192 pycbc copy \u2192 pycbc `+=` \u2192 gwpy TimeSeries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "aa000006",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/homebrew/Caskroom/miniforge/base/envs/cdvgan/lib/python3.11/site-packages/gwpy/time/_ligotimegps.py:42: UserWarning: Wswiglal-redir-stdio:\n",
      "\n",
      "SWIGLAL standard output/error redirection is enabled in IPython.\n",
      "This may lead to performance penalties. To disable locally, use:\n",
      "\n",
      "with lal.no_swig_redirect_standard_output_error():\n",
      "    ...\n",
      "\n",
      "To disable globally, use:\n",
      "\n",
      "lal.swig_redirect_standard_output_error(False)\n",
      "\n",
      "Note however that this will likely lead to error messages from\n",
      "LAL functions being either misdirected or lost when called from\n",
      "Jupyter notebooks.\n",
      "\n",
      "To suppress this warning, use:\n",
      "\n",
      "import warnings\n",
      "warnings.filterwarnings(\"ignore\", \"Wswiglal-redir-stdio\")\n",
      "import lal\n",
      "\n",
      "  from lal import LIGOTimeGPS\n",
      "PyCBC.libutils: pkg-config call failed, setting NO_PKGCONFIG=1\n",
      "INFO:panoptes_client:libmagic not operational, likely due to lack of shared libraries. Media MIME type determination will be based on file extensions.\n"
     ]
    }
   ],
   "source": [
    "sys.path.insert(0, PATH_TO_REPO)\n",
    "\n",
    "from gwpy.timeseries import TimeSeries\n",
    "from gravityspy.classify import classify\n",
    "import gravityspy.ml.labelling_test_glitches as _lgt\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "for _log in ['gravityspy', 'gwpy', 'astropy', 'tensorflow']:\n",
    "    logging.getLogger(_log).setLevel(logging.ERROR)\n",
    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'\n",
    "\n",
    "GSPY_PLOT_DIR = str(PLOTS_DIR / 'gspy_tmp')\n",
    "\n",
    "\n",
    "def classify_signals(generated_signals, labels, white_noise, noise, label_order, tag):\n",
    "    \"\"\"Classify GlitchGAN signals using GravitySpy.\n",
    "    Injection follows evaluation2 exactly: pycbc copy \u2192 pycbc += \u2192 gwpy TimeSeries.\n",
    "    \"\"\"\n",
    "    ifo          = IFO\n",
    "    srate        = SRATE\n",
    "    init_time    = INIT_TIME\n",
    "    channel_name = CHANNEL\n",
    "    path_to_model = str(PATH_TO_MODEL)\n",
    "    snr_target   = SNR_TARGET\n",
    "\n",
    "    shutil.rmtree(GSPY_PLOT_DIR, ignore_errors=True)\n",
    "    os.makedirs(GSPY_PLOT_DIR, exist_ok=True)\n",
    "\n",
    "    rows  = []\n",
    "    total = NUM_CLASSIFY * len(label_order)\n",
    "    with tqdm(total=total, desc=f'Classifying [{tag}]', unit='glitch') as pbar:\n",
    "        for class_label in label_order:\n",
    "            class_indices  = np.where(labels == class_label)[0]\n",
    "            chosen_indices = np.random.choice(class_indices, NUM_CLASSIFY, replace=False)\n",
    "\n",
    "            for idx in chosen_indices:\n",
    "                glitch = generated_signals[idx].copy()\n",
    "                glitch = whitened_snr_scaling(glitch, snr_target)\n",
    "\n",
    "                len_glitch = len(glitch)\n",
    "                length     = noise.shape[-1]\n",
    "                t_inj      = 0.5 * length / srate\n",
    "                id_start   = int((t_inj * srate / length) * len(white_noise)) - len_glitch // 2\n",
    "\n",
    "                injected_noise = white_noise.copy()\n",
    "                injected_noise[id_start:id_start + len_glitch] += glitch\n",
    "\n",
    "                glitch_series = TimeSeries(\n",
    "                    injected_noise, t0=init_time, sample_rate=srate, name=ifo\n",
    "                )\n",
    "\n",
    "                try:\n",
    "                    result = classify(\n",
    "                        event_time=EVENT_TIME,\n",
    "                        channel_name=channel_name,\n",
    "                        path_to_cnn=path_to_model,\n",
    "                        timeseries=glitch_series,\n",
    "                        plot_directory=GSPY_PLOT_DIR,\n",
    "                    )\n",
    "                    rows.append({\n",
    "                        'true_label': class_label,\n",
    "                        'pred_label': result['ml_label'].value[0],\n",
    "                        'confidence': result['ml_confidence'].value[0],\n",
    "                    })\n",
    "                except Exception as e:\n",
    "                    print(f'  \\u26a0 {class_label}[{idx}]: {type(e).__name__}: {e}')\n",
    "                    rows.append({'true_label': class_label, 'pred_label': 'Error', 'confidence': 0.0})\n",
    "                pbar.update(1)\n",
    "\n",
    "    return pd.DataFrame(rows)\n",
    "\n",
    "\n",
    "def plot_confusion(df, tag, save_name):\n",
    "    if df is None or len(df) == 0:\n",
    "        print(f'No results for {tag}'); return None\n",
    "    df = df[df['pred_label'] != 'Error']\n",
    "    if len(df) == 0:\n",
    "        print(f'All errors for {tag}'); return None\n",
    "\n",
    "    pred_all  = sorted(df['pred_label'].unique())\n",
    "    for lbl in LABEL_ORDER:\n",
    "        if lbl not in pred_all:\n",
    "            pred_all.append(lbl)\n",
    "    pred_cols = ([l for l in LABEL_ORDER if l in pred_all]\n",
    "                 + [l for l in pred_all if l not in LABEL_ORDER])\n",
    "\n",
    "    count_matrix = pd.DataFrame(0, index=LABEL_ORDER, columns=pred_cols)\n",
    "    conf_accum   = {(t, p): [] for t in LABEL_ORDER for p in pred_cols}\n",
    "    for t, p, c in zip(df['true_label'], df['pred_label'], df['confidence']):\n",
    "        if t in LABEL_ORDER and p in pred_cols:\n",
    "            count_matrix.loc[t, p] += 1\n",
    "            conf_accum[(t, p)].append(c)\n",
    "\n",
    "    annot = pd.DataFrame('', index=LABEL_ORDER, columns=pred_cols)\n",
    "    for t in LABEL_ORDER:\n",
    "        for p in pred_cols:\n",
    "            n = count_matrix.loc[t, p]\n",
    "            annot.loc[t, p] = '0' if n == 0 else f\"{n}\\n({np.mean(conf_accum[(t,p)]):.2f})\"\n",
    "\n",
    "    total = count_matrix.values.sum()\n",
    "    acc   = np.trace(count_matrix.values) / total if total > 0 else 0.0\n",
    "\n",
    "    fig_w = max(10, len(pred_cols) * 1.1)\n",
    "    sns.set(style='whitegrid', font_scale=1.0)\n",
    "    fig, ax = plt.subplots(figsize=(fig_w, 6))\n",
    "    sns.heatmap(count_matrix, annot=annot, fmt='', cmap='Blues', cbar=True,\n",
    "                linewidths=0.5, linecolor='gray',\n",
    "                annot_kws={'size': 8, 'color': 'black'}, ax=ax)\n",
    "    ax.set_xlabel('Predicted Label', fontsize=12)\n",
    "    ax.set_ylabel('True Label', fontsize=12)\n",
    "    ax.set_title(f'Gravity Spy \\u2014 {tag}   (accuracy = {acc:.1%})', fontsize=13)\n",
    "    plt.xticks(rotation=45, ha='right', fontsize=8)\n",
    "    plt.yticks(rotation=0, fontsize=9)\n",
    "    plt.tight_layout()\n",
    "    fig.savefig(PLOTS_DIR / f'{save_name}.pdf', bbox_inches='tight')\n",
    "    buf = io.BytesIO()\n",
    "    fig.savefig(buf, format='png', dpi=150, bbox_inches='tight')\n",
    "    plt.close(fig)\n",
    "    buf.seek(0)\n",
    "    ipy_display(IPyImage(buf.read()))\n",
    "    print(f'{tag} accuracy: {acc:.3f}')\n",
    "    return acc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aa000007",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fetching open data and whitening...\n",
      "white_noise: 163840 samples  dtype: float64\n"
     ]
    }
   ],
   "source": [
    "# Fetch and whiten noise \u2014 identical to evaluation2\n",
    "print('Fetching open data and whitening...')\n",
    "noise = TimeSeries.fetch_open_data(IFO, GW_START, GW_END, sample_rate=SRATE)\n",
    "noise = noise.to_pycbc()\n",
    "white_noise, psd = noise.whiten(\n",
    "    len(noise) / (2 * SRATE),\n",
    "    len(noise) / (4 * SRATE),\n",
    "    remove_corrupted=False,\n",
    "    return_psd=True,\n",
    ")\n",
    "print(f'white_noise: {len(white_noise)} samples  dtype: {white_noise.dtype}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aa000008",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d6be0b3c9c9a4e1aa28b4071515ce979",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Classifying [GlitchGAN (epoch 210, SNR=50)]:   0%|          | 0/70 [00:00<?, ?glitch/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved: /Users/tomdooney/Documents/Work/Projects/glitchgan/evaluation_plots/gspy_results.csv\n"
     ]
    }
   ],
   "source": [
    "df = classify_signals(\n",
    "    generated_signals, labels, white_noise, noise,\n",
    "    label_order=LABEL_ORDER,\n",
    "    tag=f'GlitchGAN (epoch 210, SNR={SNR_TARGET})',\n",
    ")\n",
    "df.to_csv(PLOTS_DIR / 'gspy_results.csv', index=False)\n",
    "print(f'Saved: {PLOTS_DIR / \"gspy_results.csv\"}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "aa000009",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GlitchGAN (epoch 210, SNR=50) accuracy: 0.714\n"
     ]
    }
   ],
   "source": [
    "acc = plot_confusion(df, f'GlitchGAN (epoch 210, SNR={SNR_TARGET})', 'gspy_cm')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "cdvgan",
   "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.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}