diff --git a/notebooks/XGBoost2WWCovertypeHyperparameterSweep.ipynb b/notebooks/XGBoost2WWCovertypeHyperparameterSweep.ipynb index b90afd0..2509d61 100644 --- a/notebooks/XGBoost2WWCovertypeHyperparameterSweep.ipynb +++ b/notebooks/XGBoost2WWCovertypeHyperparameterSweep.ipynb @@ -1,2728 +1,2814 @@ { - "cells": [ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3Ncn0J2aX3CN" + }, + "source": [ + "\"Open\n" + ], + "id": "3Ncn0J2aX3CN" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B8jHkzm_X3CO" + }, + "source": [ + "# xgboost2ww Covertype Hyperparameter Sweep (Underfit → Tuned → Mild Overfit)\n", + "\n", + "## What this notebook does\n", + "- **Dataset**: UCI/Kaggle-style **Forest CoverType** via `sklearn.datasets.fetch_covtype` (581,012 rows, 54 features, 7 classes). Multiclass accuracy is expected to be lower than 90%+ binary examples.\n", + "- **Multiclass objective**: XGBoost `objective='multi:softprob'` with `num_class=7`, evaluating `mlogloss` and `merror`.\n", + "- **Split protocol**: deterministic stratified 80/20 train-test split (`RNG=123`) plus a stratified validation split from train for early stopping.\n", + "- **Runtime controls**: configurable `SAMPLE_N`, `NFOLDS_SWEEP`, `T_POINTS_SWEEP` and optional heavier best-model verification settings so Colab runs remain practical.\n", + "- **xgboost2ww multiclass mode**: main sweep uses `multiclass='stack'` with `return_type='torch'` for a single WeightWatcher-friendly matrix; optional representative configs use `multiclass='per_class'` with `return_type='numpy'` because per-class + torch is unsupported.\n", + "- **WeightWatcher metrics**: `alpha`, `rand_num_spikes` (all configs, always `randomize=True`), and optional `detX` for representative configs only.\n", + "- **Sweep strategy**: Stage A regime sweep (underfit/tuned/overfit seeds + perturbations), Stage B local refinement around top configs.\n", + "- **Expected qualitative pattern**: as in Adult/Spambase, better-generalizing models often have healthier spectral structure (alpha nearer 2, fewer traps), while underfit tends to larger alpha and overfit/unstable regimes often show alpha < 2 and/or more traps.\n", + "- **Reproducibility and persistence**: fixed seeds, explicit requested vs achieved boosting rounds, checkpointed CSV/plots under a Covertype-specific folder.\n", + "\n", + "> We expect to observe the same **qualitative** alpha/performance pattern as binary notebooks, but absolute accuracy values differ because this is a larger 7-class multiclass task.\n" + ], + "id": "B8jHkzm_X3CO" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9eskbjYkX3CO" + }, + "source": [ + "## Google Drive checkpoint locations (duplicated here for run notes)\n", + "- **Checkpoint root path:** `/content/drive/MyDrive/xgboost2ww_checkpoints`\n", + "- **This run folder path:** `/content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep`\n", + "- **Results CSV path:** `/content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_hyperparameter_sweep_results.csv`\n", + "\n", + "When running outside Colab, the notebook uses `./checkpoints/covertype_hparam_sweep/` as the local fallback.\n" + ], + "id": "9eskbjYkX3CO" + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "hYMhlRoGX3CO", + "outputId": "533868ed-a26f-467a-dbf9-5a3fded2dca0", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "view-in-github", - "colab_type": "text" - }, - "source": [ - "\"Open" - ] - }, + "output_type": "stream", + "name": "stdout", + "text": [ + "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n", + "IN_COLAB: True\n", + "CHECKPOINT_DIR: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep\n", + "CHECKPOINT_RESULTS_CSV: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_hyperparameter_sweep_results.csv\n" + ] + } + ], + "source": [ + "from pathlib import Path\n", + "import os\n", + "\n", + "IN_COLAB = False\n", + "try:\n", + " from google.colab import drive\n", + " IN_COLAB = True\n", + "except Exception:\n", + " IN_COLAB = False\n", + "\n", + "CHECKPOINT_ROOT_COLAB = Path('/content/drive/MyDrive/xgboost2ww_checkpoints')\n", + "CHECKPOINT_ROOT_LOCAL = Path('./checkpoints')\n", + "EXPERIMENT_NAME = 'covertype_hparam_sweep'\n", + "OUTPUT_FILENAME = 'covertype_hyperparameter_sweep_results.csv'\n", + "\n", + "if IN_COLAB:\n", + " drive.mount('/content/drive')\n", + " CHECKPOINT_ROOT = CHECKPOINT_ROOT_COLAB\n", + "else:\n", + " CHECKPOINT_ROOT = CHECKPOINT_ROOT_LOCAL\n", + "\n", + "CHECKPOINT_DIR = CHECKPOINT_ROOT / EXPERIMENT_NAME\n", + "CHECKPOINT_DIR.mkdir(parents=True, exist_ok=True)\n", + "CHECKPOINT_RESULTS_CSV = CHECKPOINT_DIR / OUTPUT_FILENAME\n", + "\n", + "print('IN_COLAB:', IN_COLAB)\n", + "print('CHECKPOINT_DIR:', CHECKPOINT_DIR)\n", + "print('CHECKPOINT_RESULTS_CSV:', CHECKPOINT_RESULTS_CSV)\n" + ], + "id": "hYMhlRoGX3CO" + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "crKUqaFRX3CP" + }, + "outputs": [], + "source": [ + "# Optional install cell (useful in Colab)\n", + "!pip -q install xgboost weightwatcher xgboost2ww scikit-learn pandas matplotlib\n" + ], + "id": "crKUqaFRX3CP" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UBEE7EP1X3CP" + }, + "source": [ + "## Imports and reproducibility controls\n" + ], + "id": "UBEE7EP1X3CP" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7O6hz-jUX3CP" + }, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.datasets import fetch_covtype, fetch_openml\n", + "from sklearn.model_selection import train_test_split, StratifiedShuffleSplit\n", + "from sklearn.metrics import accuracy_score, log_loss, balanced_accuracy_score, f1_score\n", + "\n", + "import xgboost as xgb\n", + "import weightwatcher as ww\n", + "from xgboost2ww import convert, to_linear_layer\n" + ], + "id": "7O6hz-jUX3CP" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "d12_Yyg1X3CP" + }, + "outputs": [], + "source": [ + "RNG = 123\n", + "TEST_SIZE = 0.20\n", + "VAL_SIZE_WITHIN_TRAIN = 0.20\n", + "\n", + "# Runtime knobs (safe defaults for Colab)\n", + "USE_SAMPLING = False\n", + "SAMPLE_N = 120_000\n", + "SWEEP_SEEDS = [123, 231, 777]\n", + "NFOLDS_SWEEP = 3\n", + "NFOLDS_BEST = 5\n", + "T_POINTS_SWEEP = 32\n", + "T_POINTS_BEST = 64\n", + "RUN_EXPENSIVE_BEST_VERIFICATION = False\n", + "\n", + "MULTICLASS_MODE_MAIN = 'stack' # 'stack' preferred; fallback to 'avg' if memory is tight\n", + "W_MATRIX_NAME = 'W7'\n", + "\n", + "# Increase WeightWatcher matrix-size cap for large stacked multiclass matrices\n", + "WW_MAX_N = 800000\n" + ], + "id": "d12_Yyg1X3CP" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Drd0saLCX3CP" + }, + "source": [ + "## Load Covertype with deterministic fallback and run sanity checks\n" + ], + "id": "Drd0saLCX3CP" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "LtJfTue2X3CP" + }, + "outputs": [], + "source": [ + "try:\n", + " data = fetch_covtype()\n", + " X, y = data.data, data.target\n", + " loader_used = 'fetch_covtype'\n", + "except Exception:\n", + " data = fetch_openml(name='covertype', version=3, as_frame=False)\n", + " X, y = data.data, data.target\n", + " loader_used = 'fetch_openml(covertype)'\n", + "\n", + "X = np.asarray(X, dtype=np.float32)\n", + "y = np.asarray(y)\n", + "if y.dtype.kind in {'U', 'S', 'O'}:\n", + " y = y.astype(int)\n", + "y = y.astype(np.int64)\n", + "if y.min() == 1:\n", + " y = y - 1\n", + "\n", + "n_classes = int(np.unique(y).shape[0])\n", + "print('loader:', loader_used)\n", + "print('X.shape:', X.shape, 'y.shape:', y.shape)\n", + "print('n_classes:', n_classes)\n", + "\n", + "class_counts = pd.Series(y).value_counts().sort_index()\n", + "print('counts per class:')\n", + "print(class_counts)\n", + "\n", + "if USE_SAMPLING and SAMPLE_N < len(y):\n", + " sss = StratifiedShuffleSplit(n_splits=1, train_size=SAMPLE_N, random_state=RNG)\n", + " idx, _ = next(sss.split(X, y))\n", + " X = X[idx]\n", + " y = y[idx]\n", + " print(f'Applied stratified sample: SAMPLE_N={SAMPLE_N}, new shape={X.shape}')\n" + ], + "id": "LtJfTue2X3CP" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "K2oMbwTbX3CP" + }, + "outputs": [], + "source": [ + "def build_split(seed):\n", + " idx_train, idx_test = train_test_split(\n", + " np.arange(len(y)), test_size=TEST_SIZE, random_state=seed, stratify=y\n", + " )\n", + " X_train, X_test = X[idx_train], X[idx_test]\n", + " y_train, y_test = y[idx_train], y[idx_test]\n", + "\n", + " idx_tr, idx_val = train_test_split(\n", + " np.arange(len(y_train)), test_size=VAL_SIZE_WITHIN_TRAIN, random_state=seed, stratify=y_train\n", + " )\n", + " return {\n", + " 'seed': seed,\n", + " 'X_train': X_train,\n", + " 'X_test': X_test,\n", + " 'y_train': y_train,\n", + " 'y_test': y_test,\n", + " 'idx_tr': idx_tr,\n", + " 'idx_val': idx_val,\n", + " }\n", + "\n", + "base_split = build_split(RNG)\n", + "X_train, X_test = base_split['X_train'], base_split['X_test']\n", + "y_train, y_test = base_split['y_train'], base_split['y_test']\n", + "idx_tr, idx_val = base_split['idx_tr'], base_split['idx_val']\n", + "\n", + "print('Train/Test sizes:', X_train.shape, X_test.shape)\n", + "print('Train class counts:\\n', pd.Series(y_train).value_counts().sort_index().to_string())\n", + "print('Test class counts:\\n', pd.Series(y_test).value_counts().sort_index().to_string())\n", + "print('Inner train/val sizes:', len(idx_tr), len(idx_val))\n", + "print('Sweep seeds:', SWEEP_SEEDS)\n" + ], + "id": "K2oMbwTbX3CP" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "oafvwxynX3CP" + }, + "source": [ + "## Helpers: train/evaluate + xgboost2ww + WeightWatcher (graceful degradation)\n" + ], + "id": "oafvwxynX3CP" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "n5rbUhgOX3CP" + }, + "outputs": [], + "source": [ + "def _run_weightwatcher_summary(row, booster, split_data, run_detx=False):\n", + " X_train_local, y_train_local = split_data['X_train'], split_data['y_train']\n", + " try:\n", + " model_ww = convert(booster, X_train_local, y_train_local, multiclass=MULTICLASS_MODE_MAIN, return_type='torch')\n", + " watcher = ww.WeightWatcher(model=model_ww, log_level='ERROR')\n", + " details = watcher.analyze(\n", + " randomize=True,\n", + " min_evals=10,\n", + " max_evals=200,\n", + " mp_fit=False,\n", + " plot=False,\n", + " savefig=False,\n", + " detX=run_detx,\n", + " max_N=WW_MAX_N,\n", + " )\n", + " details = pd.DataFrame(details)\n", + " if 'alpha' in details.columns:\n", + " row['alpha'] = float(details['alpha'].dropna().iloc[0]) if details['alpha'].notna().any() else np.nan\n", + " if 'rand_num_spikes' in details.columns:\n", + " row['rand_num_spikes'] = float(details['rand_num_spikes'].dropna().iloc[0]) if details['rand_num_spikes'].notna().any() else np.nan\n", + " if run_detx and 'detX_val' in details.columns and details['detX_val'].notna().any():\n", + " row['detX_val'] = float(details['detX_val'].dropna().iloc[0])\n", + " except Exception as e:\n", + " row['ww_note'] = f'skipped/failed: {type(e).__name__}: {e}'\n", + " try:\n", + " model_ww = convert(booster, X_train_local, y_train_local, multiclass='avg', return_type='torch')\n", + " watcher = ww.WeightWatcher(model=model_ww, log_level='ERROR')\n", + " details = pd.DataFrame(\n", + " watcher.analyze(randomize=True, min_evals=10, max_evals=120, mp_fit=False, plot=False, savefig=False, max_N=WW_MAX_N)\n", + " )\n", + " row['multiclass_mode'] = 'avg'\n", + " if 'alpha' in details.columns and details['alpha'].notna().any():\n", + " row['alpha'] = float(details['alpha'].dropna().iloc[0])\n", + " if 'rand_num_spikes' in details.columns and details['rand_num_spikes'].notna().any():\n", + " row['rand_num_spikes'] = float(details['rand_num_spikes'].dropna().iloc[0])\n", + " row['ww_note'] += ' | fallback avg mode applied'\n", + " except Exception as e2:\n", + " row['ww_note'] += f' | fallback failed: {type(e2).__name__}: {e2}'\n", + " return row\n", + "\n", + "\n", + "def fit_eval_config_once(tag, cfg, split_seed, run_ww=False, run_detx=False):\n", + " split_data = build_split(split_seed)\n", + " X_train_local, X_test_local = split_data['X_train'], split_data['X_test']\n", + " y_train_local, y_test_local = split_data['y_train'], split_data['y_test']\n", + " idx_tr_local, idx_val_local = split_data['idx_tr'], split_data['idx_val']\n", + "\n", + " params = dict(\n", + " objective='multi:softprob',\n", + " num_class=n_classes,\n", + " eval_metric=['mlogloss', 'merror'],\n", + " tree_method='hist',\n", + " seed=split_seed,\n", + " verbosity=0,\n", + " )\n", + " params.update(cfg)\n", + " num_boost_round = int(params.pop('num_boost_round', 2000))\n", + " early_stopping_rounds = params.pop('early_stopping_rounds', 100)\n", + "\n", + " dtr = xgb.DMatrix(X_train_local[idx_tr_local], label=y_train_local[idx_tr_local])\n", + " dva = xgb.DMatrix(X_train_local[idx_val_local], label=y_train_local[idx_val_local])\n", + " dtrain_full = xgb.DMatrix(X_train_local, label=y_train_local)\n", + " dtest = xgb.DMatrix(X_test_local, label=y_test_local)\n", + "\n", + " evals_result = {}\n", + " booster = xgb.train(\n", + " params=params,\n", + " dtrain=dtr,\n", + " num_boost_round=num_boost_round,\n", + " evals=[(dtr, 'tr'), (dva, 'va')],\n", + " early_stopping_rounds=early_stopping_rounds,\n", + " evals_result=evals_result,\n", + " verbose_eval=False,\n", + " )\n", + "\n", + " best_iteration = int(getattr(booster, 'best_iteration', num_boost_round - 1))\n", + " train_proba = booster.predict(dtrain_full, iteration_range=(0, best_iteration + 1))\n", + " test_proba = booster.predict(dtest, iteration_range=(0, best_iteration + 1))\n", + "\n", + " train_pred = np.argmax(train_proba, axis=1)\n", + " test_pred = np.argmax(test_proba, axis=1)\n", + "\n", + " row = {\n", + " 'tag': tag,\n", + " 'split_seed': split_seed,\n", + " 'num_boost_round_requested': num_boost_round,\n", + " 'best_iteration': best_iteration,\n", + " 'train_acc': accuracy_score(y_train_local, train_pred),\n", + " 'test_acc': accuracy_score(y_test_local, test_pred),\n", + " 'train_bal_acc': balanced_accuracy_score(y_train_local, train_pred),\n", + " 'test_bal_acc': balanced_accuracy_score(y_test_local, test_pred),\n", + " 'test_macro_f1': f1_score(y_test_local, test_pred, average='macro'),\n", + " 'train_mlogloss': log_loss(y_train_local, train_proba, labels=np.arange(n_classes)),\n", + " 'test_mlogloss': log_loss(y_test_local, test_proba, labels=np.arange(n_classes)),\n", + " 'multiclass_mode': MULTICLASS_MODE_MAIN,\n", + " 'alpha': np.nan,\n", + " 'rand_num_spikes': np.nan,\n", + " 'detX_val': np.nan,\n", + " 'ww_note': '',\n", + " }\n", + " for k, v in cfg.items():\n", + " row[f'hp_{k}'] = v\n", + "\n", + " if run_ww:\n", + " row = _run_weightwatcher_summary(row, booster, split_data, run_detx=run_detx)\n", + "\n", + " print(f\"[{tag}] seed={split_seed} requested={num_boost_round} best_iteration={best_iteration} train_acc={row['train_acc']:.4f} test_acc={row['test_acc']:.4f}\")\n", + " return row, booster\n", + "\n", + "\n", + "def fit_eval_config(tag, cfg, t_points=T_POINTS_SWEEP, run_detx=False):\n", + " per_seed_rows, per_seed_boosters = [], {}\n", + " for seed in SWEEP_SEEDS:\n", + " row, booster = fit_eval_config_once(tag, cfg, split_seed=seed, run_ww=False, run_detx=False)\n", + " per_seed_rows.append(row)\n", + " per_seed_boosters[seed] = booster\n", + "\n", + " per_seed_df = pd.DataFrame(per_seed_rows)\n", + " rep_seed = int(per_seed_df.loc[per_seed_df['test_mlogloss'].idxmin(), 'split_seed'])\n", + " rep_row = per_seed_df.loc[per_seed_df['split_seed'] == rep_seed].iloc[0].to_dict()\n", + "\n", + " for metric in ['train_acc', 'test_acc', 'train_bal_acc', 'test_bal_acc', 'test_macro_f1', 'train_mlogloss', 'test_mlogloss', 'best_iteration']:\n", + " rep_row[metric] = float(per_seed_df[metric].mean())\n", + " rep_row[f'{metric}_std'] = float(per_seed_df[metric].std(ddof=0))\n", + "\n", + " rep_row['rep_split_seed'] = rep_seed\n", + " rep_row['n_sweep_seeds'] = len(SWEEP_SEEDS)\n", + "\n", + " rep_booster = per_seed_boosters[rep_seed]\n", + " rep_row = _run_weightwatcher_summary(rep_row, rep_booster, build_split(rep_seed), run_detx=run_detx)\n", + "\n", + " print(f\"[{tag}] aggregated across seeds={SWEEP_SEEDS}: test_acc={rep_row['test_acc']:.4f}±{rep_row['test_acc_std']:.4f}, test_mlogloss={rep_row['test_mlogloss']:.4f}±{rep_row['test_mlogloss_std']:.4f}, rep_seed={rep_seed}\")\n", + " return rep_row, rep_booster\n" + ], + "id": "n5rbUhgOX3CP" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yLhrndzDX3CP" + }, + "source": [ + "## Debug cell: single-model convert + WeightWatcher deep diagnostics\n", + "\n", + "Use this when `alpha` is NaN or conversion/WW unexpectedly fails. It trains one selected config, runs `xgboost2ww.convert`, and then runs WeightWatcher with `plot=True` plus extra diagnostics." + ], + "id": "yLhrndzDX3CP" + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "sY-Hq3GkX3CQ", + "outputId": "03e0f815-c5b0-44d3-988d-1b0fa0764f22", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + } + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "3Ncn0J2aX3CN" - }, - "source": [ - "\"Open\n" - ], - "id": "3Ncn0J2aX3CN" + "output_type": "stream", + "name": "stdout", + "text": [ + "Debug config: U1 {'max_depth': 2, 'eta': 0.3, 'num_boost_round': 150, 'early_stopping_rounds': 40, 'min_child_weight': 20, 'gamma': 5, 'subsample': 0.6, 'colsample_bytree': 0.6, 'reg_lambda': 50, 'reg_alpha': 0}\n", + "best_iteration: 147 requested: 150\n", + "debug test_acc: 0.7439166666666667\n", + "debug test_mlogloss: 0.585806952159488\n", + "Converting with multiclass= stack return_type= torch\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "B8jHkzm_X3CO" - }, - "source": [ - "# xgboost2ww Covertype Hyperparameter Sweep (Underfit → Tuned → Mild Overfit)\n", - "\n", - "## What this notebook does\n", - "- **Dataset**: UCI/Kaggle-style **Forest CoverType** via `sklearn.datasets.fetch_covtype` (581,012 rows, 54 features, 7 classes). Multiclass accuracy is expected to be lower than 90%+ binary examples.\n", - "- **Multiclass objective**: XGBoost `objective='multi:softprob'` with `num_class=7`, evaluating `mlogloss` and `merror`.\n", - "- **Split protocol**: deterministic stratified 80/20 train-test split (`RNG=123`) plus a stratified validation split from train for early stopping.\n", - "- **Runtime controls**: configurable `SAMPLE_N`, `NFOLDS_SWEEP`, `T_POINTS_SWEEP` and optional heavier best-model verification settings so Colab runs remain practical.\n", - "- **xgboost2ww multiclass mode**: main sweep uses `multiclass='stack'` with `return_type='torch'` for a single WeightWatcher-friendly matrix; optional representative configs use `multiclass='per_class'` with `return_type='numpy'` because per-class + torch is unsupported.\n", - "- **WeightWatcher metrics**: `alpha`, `rand_num_spikes` (all configs, always `randomize=True`), and optional `detX` for representative configs only.\n", - "- **Sweep strategy**: Stage A regime sweep (underfit/tuned/overfit seeds + perturbations), Stage B local refinement around top configs.\n", - "- **Expected qualitative pattern**: as in Adult/Spambase, better-generalizing models often have healthier spectral structure (alpha nearer 2, fewer traps), while underfit tends to larger alpha and overfit/unstable regimes often show alpha < 2 and/or more traps.\n", - "- **Reproducibility and persistence**: fixed seeds, explicit requested vs achieved boosting rounds, checkpointed CSV/plots under a Covertype-specific folder.\n", - "\n", - "> We expect to observe the same **qualitative** alpha/performance pattern as binary notebooks, but absolute accuracy values differ because this is a larger 7-class multiclass task.\n" - ], - "id": "B8jHkzm_X3CO" + "output_type": "stream", + "name": "stderr", + "text": [ + "INFO:weightwatcher:\n", + "\n", + "python version 3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0]\n", + "numpy version 2.0.2\n", + "torch version 2.10.0+cu128\n", + "INFO:weightwatcher:SET MODEL: None, None\n", + "INFO:weightwatcher:SET MODEL: Sequential(\n", + " (0): Linear(in_features=150, out_features=672000, bias=False)\n", + "), None\n", + "INFO:weightwatcher:params {'glorot_fix': False, 'normalize': False, 'conv2d_norm': True, 'randomize': True, 'savedir': 'ww-img', 'savefig': False, 'rescale': True, 'plot': True, 'deltaEs': False, 'intra': False, 'channels': None, 'fft': False, 'conv2d_fft': False, 'ww2x': False, 'pool': True, 'vectors': False, 'smooth': None, 'stacked': False, 'svd_method': 'fast', 'fix_fingers': False, 'fit': 'power_law', 'MAX_FINGERS': 10, 'finger_thresh': 1.0, 'sparsify': True, 'detX': True, 'mp_fit': False, 'min_evals': 10, 'max_evals': 200, 'max_N': 800000, 'tolerance': 1e-06, 'layer_ids_start': 0, 'add_biases': False, 'xmin_max': None, 'pl_package': 'ww', 'xmax': None, 'peft': False, 'inverse': False, 'glorot_fit': False, 'layers': []}\n", + "INFO:weightwatcher:Using \n", + "INFO:weightwatcher:torch version 2.10.0+cu128\n", + "INFO:weightwatcher:framework from model = pytorch\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "9eskbjYkX3CO" - }, - "source": [ - "## Google Drive checkpoint locations (duplicated here for run notes)\n", - "- **Checkpoint root path:** `/content/drive/MyDrive/xgboost2ww_checkpoints`\n", - "- **This run folder path:** `/content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep`\n", - "- **Results CSV path:** `/content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_hyperparameter_sweep_results.csv`\n", - "\n", - "When running outside Colab, the notebook uses `./checkpoints/covertype_hparam_sweep/` as the local fallback.\n" - ], - "id": "9eskbjYkX3CO" + "output_type": "stream", + "name": "stdout", + "text": [ + "convert() success. type = \n", + "torch module count: 2\n", + "layers with weight attr: 1\n", + " layer[0] weight shape: (672000, 150)\n" + ] }, { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "hYMhlRoGX3CO", - "outputId": "533868ed-a26f-467a-dbf9-5a3fded2dca0", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n", - "IN_COLAB: True\n", - "CHECKPOINT_DIR: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep\n", - "CHECKPOINT_RESULTS_CSV: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_hyperparameter_sweep_results.csv\n" - ] - } - ], - "source": [ - "from pathlib import Path\n", - "import os\n", - "\n", - "IN_COLAB = False\n", - "try:\n", - " from google.colab import drive\n", - " IN_COLAB = True\n", - "except Exception:\n", - " IN_COLAB = False\n", - "\n", - "CHECKPOINT_ROOT_COLAB = Path('/content/drive/MyDrive/xgboost2ww_checkpoints')\n", - "CHECKPOINT_ROOT_LOCAL = Path('./checkpoints')\n", - "EXPERIMENT_NAME = 'covertype_hparam_sweep'\n", - "OUTPUT_FILENAME = 'covertype_hyperparameter_sweep_results.csv'\n", - "\n", - "if IN_COLAB:\n", - " drive.mount('/content/drive')\n", - " CHECKPOINT_ROOT = CHECKPOINT_ROOT_COLAB\n", - "else:\n", - " CHECKPOINT_ROOT = CHECKPOINT_ROOT_LOCAL\n", - "\n", - "CHECKPOINT_DIR = CHECKPOINT_ROOT / EXPERIMENT_NAME\n", - "CHECKPOINT_DIR.mkdir(parents=True, exist_ok=True)\n", - "CHECKPOINT_RESULTS_CSV = CHECKPOINT_DIR / OUTPUT_FILENAME\n", - "\n", - "print('IN_COLAB:', IN_COLAB)\n", - "print('CHECKPOINT_DIR:', CHECKPOINT_DIR)\n", - "print('CHECKPOINT_RESULTS_CSV:', CHECKPOINT_RESULTS_CSV)\n" - ], - "id": "hYMhlRoGX3CO" + "output_type": "stream", + "name": "stderr", + "text": [ + "INFO:weightwatcher:Running powerlaw.Fit no xmin, xmax=None. distribution=power_law pl_package=ww\n", + "INFO:weightwatcher:PL FIT running NEW power law method\n" + ] }, { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "crKUqaFRX3CP" - }, - "outputs": [], - "source": [ - "# Optional install cell (useful in Colab)\n", - "!pip -q install xgboost weightwatcher xgboost2ww scikit-learn pandas matplotlib\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "crKUqaFRX3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "markdown", - "metadata": { - "id": "UBEE7EP1X3CP" - }, - "source": [ - "## Imports and reproducibility controls\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "UBEE7EP1X3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "7O6hz-jUX3CP" - }, - "outputs": [], - "source": [ - "import warnings\n", - "warnings.filterwarnings('ignore')\n", - "\n", - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from sklearn.datasets import fetch_covtype, fetch_openml\n", - "from sklearn.model_selection import train_test_split, StratifiedShuffleSplit\n", - "from sklearn.metrics import accuracy_score, log_loss, balanced_accuracy_score, f1_score\n", - "\n", - "import xgboost as xgb\n", - "import weightwatcher as ww\n", - "from xgboost2ww import convert, to_linear_layer\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "7O6hz-jUX3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "d12_Yyg1X3CP" - }, - "outputs": [], - "source": [ - "RNG = 123\n", - "TEST_SIZE = 0.20\n", - "VAL_SIZE_WITHIN_TRAIN = 0.20\n", - "\n", - "# Runtime knobs (safe defaults for Colab)\n", - "USE_SAMPLING = True\n", - "SAMPLE_N = 120_000\n", - "NFOLDS_SWEEP = 3\n", - "NFOLDS_BEST = 5\n", - "T_POINTS_SWEEP = 32\n", - "T_POINTS_BEST = 64\n", - "RUN_EXPENSIVE_BEST_VERIFICATION = False\n", - "\n", - "MULTICLASS_MODE_MAIN = 'stack' # 'stack' preferred; fallback to 'avg' if memory is tight\n", - "W_MATRIX_NAME = 'W7'\n", - "\n", - "# Increase WeightWatcher matrix-size cap for large stacked multiclass matrices\n", - "WW_MAX_N = 800000\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "d12_Yyg1X3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "markdown", - "metadata": { - "id": "Drd0saLCX3CP" - }, - "source": [ - "## Load Covertype with deterministic fallback and run sanity checks\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "Drd0saLCX3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "LtJfTue2X3CP" - }, - "outputs": [], - "source": [ - "try:\n", - " data = fetch_covtype()\n", - " X, y = data.data, data.target\n", - " loader_used = 'fetch_covtype'\n", - "except Exception:\n", - " data = fetch_openml(name='covertype', version=3, as_frame=False)\n", - " X, y = data.data, data.target\n", - " loader_used = 'fetch_openml(covertype)'\n", - "\n", - "X = np.asarray(X, dtype=np.float32)\n", - "y = np.asarray(y)\n", - "if y.dtype.kind in {'U', 'S', 'O'}:\n", - " y = y.astype(int)\n", - "y = y.astype(np.int64)\n", - "if y.min() == 1:\n", - " y = y - 1\n", - "\n", - "n_classes = int(np.unique(y).shape[0])\n", - "print('loader:', loader_used)\n", - "print('X.shape:', X.shape, 'y.shape:', y.shape)\n", - "print('n_classes:', n_classes)\n", - "\n", - "class_counts = pd.Series(y).value_counts().sort_index()\n", - "print('counts per class:')\n", - "print(class_counts)\n", - "\n", - "if USE_SAMPLING and SAMPLE_N < len(y):\n", - " sss = StratifiedShuffleSplit(n_splits=1, train_size=SAMPLE_N, random_state=RNG)\n", - " idx, _ = next(sss.split(X, y))\n", - " X = X[idx]\n", - " y = y[idx]\n", - " print(f'Applied stratified sample: SAMPLE_N={SAMPLE_N}, new shape={X.shape}')\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "LtJfTue2X3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "K2oMbwTbX3CP" - }, - "outputs": [], - "source": [ - "idx_train, idx_test = train_test_split(\n", - " np.arange(len(y)), test_size=TEST_SIZE, random_state=RNG, stratify=y\n", - ")\n", - "X_train, X_test = X[idx_train], X[idx_test]\n", - "y_train, y_test = y[idx_train], y[idx_test]\n", - "\n", - "idx_tr, idx_val = train_test_split(\n", - " np.arange(len(y_train)), test_size=VAL_SIZE_WITHIN_TRAIN, random_state=RNG, stratify=y_train\n", - ")\n", - "\n", - "print('Train/Test sizes:', X_train.shape, X_test.shape)\n", - "print('Train class counts:\\n', pd.Series(y_train).value_counts().sort_index().to_string())\n", - "print('Test class counts:\\n', pd.Series(y_test).value_counts().sort_index().to_string())\n", - "print('Inner train/val sizes:', len(idx_tr), len(idx_val))\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "K2oMbwTbX3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "markdown", - "metadata": { - "id": "oafvwxynX3CP" - }, - "source": [ - "## Helpers: train/evaluate + xgboost2ww + WeightWatcher (graceful degradation)\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "oafvwxynX3CP" + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAAHLCAYAAABoGvp1AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbJBJREFUeJzt3XdYFFfbBvB7WZalg4A0wYZdsWEJMbESG/ZuYu8RE42JRtOMGl+iSSxRNGqM3Rg11sTeY41RCWLBBooFEKV3lvP9MR8bV1AXWBjK/buuvY47c2bm2ZkFHs+cc0YhhBAgIiIiKiJGcgdAREREZQuTDyIiIipSTD6IiIioSDH5ICIioiLF5IOIiIiKFJMPIiIiKlJMPoiIiKhIMfkgIiKiIsXkg4iIiIoUkw8q9davX49atWpBpVLB1ta2UI/19ddfQ6FQFOoxqOiEh4fD1NQUp0+fzvO2165dg7GxMYKDgwshsqIzbNgwVK5cucwcOywsDAqFAmvWrCnS45Y1TD5KkTVr1kChUEChUODUqVM51gsh4O7uDoVCgS5duuisy95OoVDAyMgIrq6uaN++PY4fP/7a4w4bNkxn++dfpqamOnXDwsIwfPhweHh4wNTUFM7OzmjZsiVmzJihU69169Y68VhbW6NmzZoYPHgwDh06pPc5uXHjBoYNGwYPDw+sXLkSK1as0HvbsiY7cYqOjpY7FIM4ePAgRo4ciXr16kGpVObrj9isWbPQvHlztGjRQmf5w4cP0a9fP9ja2sLa2hrdu3fH3bt3derUqVMHvr6++Oqrr/Q61vM/vwqFAsbGxqhQoQKGDRuGhw8f5jl2ouLMWO4AyPBMTU2xadMmvPXWWzrLT5w4gQcPHkCtVue63TvvvIMhQ4ZACIHQ0FAsXboUbdu2xZ9//olOnTq98phqtRo///xzjuVKpVL779u3b6Np06YwMzPDiBEjULlyZTx+/BiXLl3C3LlzMXPmTJ1t3dzc4O/vDwBISkrC7du3sX37dmzYsAH9+vXDhg0boFKpXhnX8ePHkZWVhUWLFqFatWqvrEuly6ZNm/Dbb7+hcePGcHV1zfP2T548wdq1a7F27Vqd5YmJiWjTpg3i4uLw2WefQaVSYcGCBWjVqhUCAwNhb2+vrTtu3Dh07twZd+7cgYeHh17HnTVrFqpUqYLU1FScO3cOa9aswalTpxAcHJwjmS/tVq5ciaysLLnDoMIgqNRYvXq1ACB69eolHBwcREZGhs760aNHCy8vL1GpUiXh6+ursw6A8PPz01kWFBQkAIj27du/8rhDhw4VFhYWr41v/PjxwtjYWISFheVYFxkZqfO+VatWom7dujnqZWZmivHjxwsAYurUqa895syZMwUA8eTJk9fW1VdSUtJL182YMUMU5x8rfWI35LkqTBkZGSItLe2l6x8+fCjS09OFEEL4+vqKSpUq5Wn/8+fPF2ZmZiIhIUFn+dy5cwUA8ffff2uXXb9+XSiVSjF9+nSduunp6aJcuXLiyy+/fO3xsn9+L1y4oLP8008/FQDEb7/9lqf4DWXo0KF5PnclWWhoqAAgVq9eLXcopRpvu5RCAwcOxNOnT3VuT6Snp2Pbtm1499139d6Pp6cnHBwcEBoaapC47ty5Azc3N1SqVCnHOkdHR732oVQq8eOPP6JOnTpYsmQJ4uLiXlq3cuXK2ts55cuXh0KhwNdff61dv3TpUtStWxdqtRqurq7w8/NDbGyszj5at26NevXq4eLFi2jZsiXMzc3x2Wef6RVrttWrV6Nt27ZwdHSEWq1GnTp1sGzZMp06Q4cOhYODAzIyMnJs3759e9SsWVNn2YYNG+Dl5QUzMzPY2dlhwIABCA8PN3jsL3r27Bk++eQTeHp6wtLSEtbW1ujUqRP+/fdfbZ3ExERYWFhg4sSJObZ/8OABlEqltkULAGJjYzFp0iS4u7tDrVajWrVqmDt3rs7/eLPvw3///fdYuHAhPDw8oFarce3atZfG6urq+tqWsVfZuXMnmjdvDktLS53l27ZtQ9OmTdG0aVPtslq1aqFdu3bYsmWLTl2VSoXWrVtj165d+Y7j7bffBiD9/GRLT0/HV199BS8vL9jY2MDCwgJvv/02jh07prPt8+dtxYoV2vPWtGlTXLhwIdfPXK9ePZiamqJevXrYsWNHrjElJSXh448/1l6zmjVr4vvvv4d44SHpCoUCEyZMwNatW1GnTh2YmZnB29sbV65cAQAsX74c1apVg6mpKVq3bo2wsDCd7V/s8/H87dgXX8/30dDnO5Vdb9iwYbCxsYGtrS2GDh2a43cAFQ7edimFKleuDG9vb/z666/a2yX79u1DXFwcBgwYgB9//FGv/cTExCAmJkbv2xW59RUwMTGBtbU1AKBSpUo4fPgwjh49irZt2+r5aXJSKpUYOHAgvvzyS5w6dQq+vr651lu4cCHWrVuHHTt2YNmyZbC0tET9+vUBSP0bZs6cCR8fH7z//vsICQnBsmXLcOHCBZw+fVrnj9bTp0/RqVMnDBgwAIMGDYKTk1Oe4l22bBnq1q2Lbt26wdjYGHv27MH48eORlZUFPz8/AMDgwYOxbt06HDhwQKc/TkREBI4eParTJ2bOnDn48ssv0a9fP4waNQpPnjzB4sWL0bJlS1y+fFmnU21BY3/R3bt3sXPnTvTt2xdVqlRBZGQkli9fjlatWuHatWtwdXWFpaUlevbsid9++w3z58/XufX266+/QgiB9957DwCQnJyMVq1a4eHDhxg7diwqVqyIM2fOYPr06Xj8+DEWLlyoc/zVq1cjNTUVY8aMgVqthp2dXYE+z8tkZGTgwoULeP/993WWZ2VlISgoCCNGjMixTbNmzXDw4EEkJCTAyspKu9zLywu7du1CfHy89mchL7L/IJcrV067LD4+Hj///DMGDhyI0aNHIyEhAatWrUKHDh3w999/o2HDhjr72LRpExISEjB27FgoFArMmzcPvXr1wt27d7Xf9YMHD6J3796oU6cO/P398fTpUwwfPhxubm46+xJCoFu3bjh27BhGjhyJhg0b4sCBA5gyZQoePnyIBQsW6NT/66+/sHv3bu133d/fH126dMHUqVOxdOlSjB8/HjExMZg3bx5GjBiBo0ePvvRcfP755xg1apTOsg0bNuDAgQPa/8Do+50SQqB79+44deoUxo0bh9q1a2PHjh0YOnSofheGCkbehhcypOebbZcsWSKsrKxEcnKyEEKIvn37ijZt2gghxEtvu4wcOVI8efJEREVFifPnz4t27doJAOKHH3545XGHDh0qAOT66tChg7ZecHCwMDMzEwBEw4YNxcSJE8XOnTtzvRXwstsu2Xbs2CEAiEWLFr0yttxuJURFRQkTExPRvn17odFotMuXLFkiAIhffvlFJw4A4qeffnrlcV483vOyr8HzOnToIKpWrap9r9FohJubm+jfv79Ovfnz5wuFQiHu3r0rhBAiLCxMKJVKMWfOHJ16V65cEcbGxjrL8xv7q267pKam6pwzIaRmarVaLWbNmqVdduDAAQFA7Nu3T6du/fr1RatWrbTvZ8+eLSwsLMTNmzd16k2bNk0olUpx//597TEACGtraxEVFaXX53leXm+73L59WwAQixcv1ln+5MkTAUDns2YLCAgQAMSNGzd0lm/atEkAEOfPn3/lMbN/fg8fPiyePHkiwsPDxbZt20T58uWFWq0W4eHh2rqZmZk5bjnFxMQIJycnMWLECO2y7PNmb28vnj17pl2+a9cuAUDs2bNHu6xhw4bCxcVFxMbGapcdPHhQANA5dzt37hQAxDfffKNz/D59+giFQiFu376tXQZAqNVqERoaql22fPlyAUA4OzuL+Ph47fLp06cLADp1X3fL5/Tp00KlUul8Zn2/U9mfY968edo6mZmZ4u233+ZtlyLA2y6lVL9+/ZCSkoI//vgDCQkJ+OOPP157y2XVqlUoX748HB0d0bx5c5w+fRqTJ0/GpEmTXns8U1NTHDp0KMfr22+/1dapW7cuAgMDMWjQIISFhWHRokXo0aMHnJycsHLlyjx9vuym8ISEhDxtBwCHDx9Geno6Jk2aBCOj/34ERo8eDWtra/z555869dVqNYYPH57n42QzMzPT/jsuLg7R0dFo1aoV7t69q71tZGRkhPfeew+7d+/W+UwbN27Em2++iSpVqgAAtm/fjqysLPTr1w/R0dHal7OzM6pXr56j2b2gsb9IrVZrz5lGo8HTp09haWmJmjVr4tKlS9p6Pj4+cHV1xcaNG7XLgoODERQUhEGDBmmXbd26FW+//TbKlSun83l8fHyg0Whw8uRJneP37t0b5cuXN9jneZmnT58C0G1tAICUlBQAyLXTdnZn0Ow62bL3oe8oIh8fH5QvXx7u7u7o06cPLCwssHv3bp0WCKVSCRMTEwBSa8yzZ8+QmZmJJk2a6FyHbP3799f5LNm3crJH6Dx+/BiBgYEYOnQobGxstPXeeecd1KlTR2dfe/fuhVKpxIcffqiz/OOPP4YQAvv27dNZ3q5dO51bJ82bNwcgXcvnW4iyl784auhlIiIi0KdPHzRs2BBLly7VLtf3O7V3714YGxvrtG4plUp88MEHeh2fCoa3XUqp8uXLw8fHB5s2bUJycjI0Gg369Onzym26d++OCRMmQKFQwMrKCnXr1oWFhYVex1MqlfDx8XltvRo1amD9+vXQaDS4du0a/vjjD8ybNw9jxoxBlSpV9NoHIPUrAKDzy0tf9+7dA4Ac/ShMTExQtWpV7fpsFSpU0P6iz4/Tp09jxowZOHv2LJKTk3XWxcXFaX/ZDxkyBHPnzsWOHTswZMgQhISE4OLFi/jpp5+09W/dugUhBKpXr57rsV7s41DQ2F+UPXJo6dKlCA0NhUaj0a57fpRHdjK1bNkyJCcnw9zcHBs3boSpqSn69u2r83mCgoJemlBERUXpvM9OwoqKeKEPQ3YimZaWlqNuamqqTp0X96Hv/C8BAQGoUaMG4uLi8Msvv+DkyZO5Jjtr167FDz/8gBs3buj0FcrtHFWsWFHnfXYiEhMTA+C/n4ncvlcvJpb37t2Dq6trjp+92rVr6+zrZcfO/r67u7vnujw7plfJzMxEv379oNFosH37dp3zo+936t69e3BxccnRp+fF3wtUOJh8lGLvvvsuRo8ejYiICHTq1Om1E2y5ubnp/ce/oJRKJTw9PeHp6Qlvb2+0adMGGzdu1Pv42RM3FcXw2Rf/mOTFnTt30K5dO9SqVQvz58+Hu7s7TExMsHfvXixYsECnA1ydOnXg5eWFDRs2YMiQIdiwYQNMTEzQr18/bZ2srCwoFArs27dPpy9Fthd/kRYk9tz873//w5dffokRI0Zg9uzZsLOzg5GRESZNmpSjM9+QIUPw3XffYefOnRg4cCA2bdqELl266PzPOisrC++88w6mTp2a6/Fq1KhRqJ/nZbITqRf/ENrZ2UGtVuPx48c5tsle9uKw3ux9ODg46HXsZs2aoUmTJgCAHj164K233sK7776LkJAQ7fXdsGEDhg0bhh49emDKlClwdHTUduR9vmNqtty+K0DO5KowvOzYBYlpypQpOHv2LA4fPpyjT0pev1MkDyYfpVjPnj0xduxYnDt3Dr/99pvc4bxU9i/a3H6h50aj0WDTpk0wNzfPMZeJPrJH24SEhKBq1ara5enp6QgNDTVoArZnzx6kpaVh9+7dOv8DfPH2SLYhQ4Zg8uTJePz4MTZt2gRfX1+d5nIPDw8IIVClShVZfolu27YNbdq0wapVq3SWx8bG5vjjWq9ePTRq1AgbN26Em5sb7t+/j8WLF+vU8fDwQGJiYpElvfqqWLEizMzMcoz0MjIygqenJ/75558c25w/fx5Vq1bN0SIQGhoKIyOjfF2v7ISiTZs2WLJkCaZNmwZAug5Vq1bF9u3bdVpUXpysT1/ZPxO3bt3KsS4kJCRH3cOHD+foWHvjxg2dfRWWzZs3Y+HChVi4cCFatWqVY72+36lKlSrhyJEjSExM1EnaX/y8VDjY56MUs7S0xLJly/D111+ja9eucoeDv/76K9ehpHv37gWgX3OnRqPBhx9+iOvXr+PDDz/M1+gBHx8fmJiY4Mcff9T5X9aqVasQFxf30tEz+ZH9v7vnjxMXF4fVq1fnWn/gwIFQKBSYOHEi7t69q9M/AgB69eoFpVKJmTNn5vgfohBC21ehsCiVyhzH3bp160tn4Bw8eDAOHjyIhQsXwt7ePsdkdf369cPZs2dx4MCBHNvGxsYiMzPTcMHngUqlQpMmTXJNMvr06YMLFy7orAsJCcHRo0d1billu3jxIurWravT4pMXrVu3RrNmzbBw4ULtrZ3cvlfnz5/H2bNn83UMFxcXNGzYEGvXrtUZvn7o0KEcw5k7d+4MjUaDJUuW6CxfsGABFArFayckLIjg4GCMGjUKgwYNynUoN6D/d6pz587IzMzUGfau0WhyJMhUONjyUcoV1bCxzMxMbNiwIdd1PXv2hIWFBebOnYuLFy+iV69e2iGvly5dwrp162BnZ5ejY2tcXJx2n8nJydoZTu/cuYMBAwZg9uzZ+Yq1fPnymD59OmbOnImOHTuiW7duCAkJwdKlS9G0adMcf/ALon379jAxMUHXrl0xduxYJCYmYuXKlXB0dMy1pad8+fLo2LEjtm7dCltb2xyJkIeHB7755htMnz4dYWFh6NGjB6ysrBAaGoodO3ZgzJgx+OSTTwoU8/z582Fubq6zzMjICJ999hm6dOmCWbNmYfjw4XjzzTdx5coVbNy4UacF6Xnvvvsupk6dih07duD999/P0SdlypQp2L17N7p06YJhw4bBy8sLSUlJuHLlCrZt24awsDC9b1e8KCgoCLt37wYgza4bFxeHb775BgDQoEGD1ybk3bt3x+eff55jiOz48eOxcuVK+Pr64pNPPoFKpcL8+fPh5OSEjz/+WGcfGRkZOHHiBMaPH5+vz5BtypQp6Nu3L9asWYNx48ahS5cu2L59O3r27AlfX1+Ehobip59+Qp06dbT9ofLK398fvr6+eOuttzBixAg8e/YMixcvRt26dXX22bVrV7Rp0waff/45wsLC0KBBAxw8eBC7du3CpEmT9J7JNT+yO0+3bNkyx++bN998E1WrVtX7O9W1a1e0aNEC06ZNQ1hYGOrUqYPt27e/cu4gMiBZxthQoXjZDIkv0neGU329aqgtnhs6d/r0aeHn5yfq1asnbGxshEqlEhUrVhTDhg0Td+7c0dln9jDR7JelpaWoXr26GDRokDh48KDesb1q+OiSJUtErVq1hEqlEk5OTuL9998XMTExOeJ41ZDflx3vebt37xb169cXpqamonLlymLu3Lnil19+yTGsMNuWLVsEADFmzJiXHuf3338Xb731lrCwsBAWFhaiVq1aws/PT4SEhBQ49txeSqVSCCENtf3444+Fi4uLMDMzEy1atBBnz54VrVq10hlC+7zOnTsLAOLMmTO5rk9ISBDTp08X1apVEyYmJsLBwUG8+eab4vvvv9fOUJo9ZPS7777T+/Nk/zzk9ho6dOhrt4+MjBTGxsZi/fr1OdaFh4eLPn36CGtra2FpaSm6dOkibt26laPevn37BIBc170s3tx+fjUajfDw8BAeHh4iMzNTZGVlif/973+iUqVKQq1Wi0aNGok//vgjx9DUV503AGLGjBk6y37//XdRu3ZtoVarRZ06dcT27dtzHe6akJAgPvroI+Hq6ipUKpWoXr26+O6770RWVlaOY7z4e+VlMR07dkwAEFu3btUue/HYlSpVeuk1fX5orD7fKSGEePr0qRg8eLCwtrYWNjY2YvDgweLy5cscalsEFEIUQY8jItLbrl270KNHD5w8eVI7JLIk69mzJ65cuYLbt2/LHUqejRw5Ejdv3sRff/2Vr+179OgBhULx0plCicoqJh9ExUyXLl1w/fp13L59W+/hmcXV48ePUalSJXz++ef57gwpp/v376NGjRo4cuRIjifbvs7169fh6emJwMBA1KtXr5AiJCqZ2OeDqJjYvHkzgoKC8Oeff2LRokUlOvEIDQ3F6dOn8fPPP0OlUmHs2LFyh5QvFStW1HbyzKvatWvL1mGWqLhj8kFUTAwcOBCWlpYYOXJkgTsoyu3EiRMYPnw4KlasiLVr18LZ2VnukIioGOFtFyIiIipSnOeDiIiIihSTDyIiIipSTD6IiIioSDH5ICKiYmHNmjVQKBQICwvTLvv666+hUCgQHR0tX2BkcEw+iqmrV69i0KBBqFChAtRqNVxdXTFo0KAcz1kwpDlz5kChUOR7ToJXbX/r1i0MGDAAbm5uMDc3R61atTBr1qwcj5gvCmlpafj000/h6uoKMzMzNG/eHIcOHcpR7+rVq+jbty+qVq0Kc3NzODg4oGXLltizZ0+RxyynxMREzJgxAx07doSdnR0UCgXWrFmj9/b6nu+ypKDnFDDsef3333+hUCi0D1VbsGABKleunK99lXX8vutJzulVKXe///67MDExEc7OzuLzzz8XP//8s/jiiy+Ei4uLUKvVYufOnQY/Znh4uDA3NxcWFhZ5mpJbn+3v378vbG1tRaVKlYS/v79Yvny5GDZsmAAgunXrZqiPoLcBAwYIY2Nj8cknn4jly5cLb29vYWxsLP766y+den/++afo0KGD+Prrr8WKFSvEwoULxdtvvy0AiOXLlxd53HLJng67YsWKonXr1nmeelrf862P9PR0kZaWJjQaTZ63LU4Kek6FMOx5Xb58ubCzs9NOj963b1/Rv3//PO+noDIzM0VKSorONO2vekRCcWTI61KaMfkoZm7fvi3Mzc1FrVq1RFRUlM66J0+eiFq1aglLS0tx9+5dgx63f//+om3btnl+Hog+28+ZM0cAEMHBwTrLhwwZIgCIZ8+eFSj2bK1atXrtMzvOnz+f47kSKSkpwsPDQ3h7e7/2GJmZmaJBgwaiZs2aBQ23xEhNTRWPHz8WQghx4cKFPP2hLOj5fvbsmZgzZ45o3LixMDU1FQCEg4OD8Pb2Fo0aNRJNmjQRX375pYiNjc3XZ5NLQc6pEAU/ry8aOXKk6Nixo/a9m5ubmD9/fp73UxhKUvJh6OtSmvG2SzHz3XffITk5GStWrED58uV11jk4OGD58uVITEzEd999Z7Bjnjx5Etu2bcPChQsLZfv4+HgAgJOTk85yFxcXGBkZwcTERGf5w4cPMWLECDg5OUGtVqNu3br45Zdf8hXbi7Zt2walUokxY8Zol5mammLkyJE4e/YswsPDX7m9UqmEu7s7YmNj9TreihUr0LhxY5ibm0OhUOi8XvYk2OJGrVbne5Kwgpzv8PBwfPXVV/D19cWFCxfQuXNnAMDKlStx5swZXLp0CXPmzMHs2bO1TzstKQpyToGCf48BICYmBtHR0YiOjsb58+dRr149REdH4+rVq3jw4AGqV6+O6Ojo1z4lNyEhAZMmTULlypWhVqvh6OiId955B5cuXdLWye63cePGDfTr1w/W1tawt7fHxIkTdWaQza3PR27u3buHatWqoV69eoiMjNQu1+d3hz7x5pchrktZwRlOi5k9e/agcuXKL32gWMuWLVG5cmXs2bMHS5cuBSA9tlvfx0Db2dnByOi/nFOj0eCDDz7AqFGj4Onpmed49dm+devWmDt3LkaOHImZM2fC3t4eZ86cwbJly/Dhhx/CwsJCWzcyMhJvvPEGFAoFJkyYgPLly2Pfvn0YOXIk4uPjMWnSpDzH+LzLly+jRo0aOo9IB4BmzZoBAAIDA+Hu7q6zLikpCSkpKYiLi8Pu3buxb98+9O/f/7XH+uijj7Bw4UK0b98ew4cPx4MHD7BgwQJkZGSgS5cu8PLyKtBneZ2CfC8MJT/nO5uTkxN+/PFH7TTz9+7dg6mpKdq3b6+t0759ezg5OWn7KhSFkn5eszVq1Aj37t3Tvg8ODsb333+vfd+1a1cAwNChQ1/ZH2XcuHHYtm0bJkyYgDp16uDp06c4deoUrl+/jsaNG+vU7devHypXrgx/f3+cO3cOP/74I2JiYrBu3Tq9PjcA3LlzB23btoWdnR0OHToEBwcHAPr/7tAn3vxeY0NclzJD7qYX+k9sbKwAILp37/7Ket26dRMARHx8vBDiv0dR6/N68RHuS5YsETY2NtpbPHm97aLv9rNnzxZmZmY6sXz++ec56o0cOVK4uLiI6OhoneUDBgwQNjY2Ijk5+aWx6HPbpW7duqJt27Y5ll+9elUAED/99FOOdWPHjtXGbGRkJPr06fPaW0UnT54UAMT777+vs3zmzJkCgPj7779fub0hFOR78TJ5vUWQn/Odm4iICKFQKESnTp10lt+9e1cYGxuLESNG6LUfQzD0ec3PbRdDnNdTp06JQ4cOiS+//FIYGxuLffv2iUOHDolOnTqJJk2aiEOHDolDhw6Jq1evvnI/NjY2ws/P75V1sm+dvNjHa/z48QKA+Pfff4UQQqxevTrHeXv+tsv169eFq6uraNq0aY6fQX1/d+gTb36vsaG+72UBWz6KkYSEBACAlZXVK+tlr09ISICVlRUaNGigd2/q55t6nz59iq+++gpffvlljls8+sjL9pUrV0bLli3Ru3dv2Nvb488//8T//vc/ODs7Y8KECQAAIQR+//139OvXD0IInaF1HTp0wObNm3Hp0iW0aNEi1/+ZZGRkIC0tLceQvOf/Z5KSkgK1Wp0jPlNTU+36F02aNAl9+vTBo0ePsGXLFmg0GqSnp7/y8y5YsAB2dnY5bo+1atUKAHDz5k00bdr0lfsoqPx+LwwpP+c7N3v37oUQAl26dNEuCwkJQe/evVGrVi18++23hglYD6XlvGY/pXfv3r1o2rQpOnbsCED6vvft2xc+Pj56xWJra4vz58/j0aNHcHV1fWVdPz8/nfcffPABli5dir1796J+/fqv3DY4OBj9+/dHtWrVsG/fPp3Whbz87tAn3vxeY0N938sCJh/FyPNJxaskJCRAoVBomxvLlSun9y+K533xxRews7PDBx98kPdg87D95s2bMWbMGNy8eRNubm4AgF69eiErKwuffvopBg4cCHt7ezx58gSxsbFYsWIFVqxYkeu+oqKiAACnT59GmzZtcqw/c+YMNm/erLMsNDRUO2zQzMwMaWlpObbLvu9sZmaWY12tWrVQq1YtAMCQIUPQvn17dO3aFefPn8/1ybOZmZk4dOgQunfvrnNLCYA2aXmxWbYw5Pd7YUj5Od+52bdvHwCgadOmWLduHY4cOYJLly5hxIgR8PPzy/UXfmEpDec1Li4OGRkZAIAjR46gbdu2iI6OxrNnz3D16lV88803iI6Ohkqlgo2NzSv3NW/ePAwdOhTu7u7w8vJC586dMWTIkFz7NFWvXl3nvYeHB4yMjF7bxwOQbgM5OTnhwIEDsLS01FmXl98d+sSb32tsqO97WcDkoxixsbGBq6srgoKCXlkvKCgIbm5u2o6a6enpePbsmV7HKF++PJRKJW7duoUVK1Zg4cKFePTokXZ9amoqMjIyEBYWBmtra9jZ2eW6n7xsv3TpUjRq1EibeGTr1q0b1qxZg8uXL8PHxwdZWVkAgEGDBmHo0KG5Hjf7f0e5/c/k448/hrOzM6ZMmaKz/Pn/mbi4uODhw4c59vv48WMAeO3/3ACgT58+GDt2LG7evImaNWvmWB8WFobExMRc5zu5ePEiAOlx64UtP98LQzPE+c5O5jw9PWFjY4Off/4ZV65cwZo1a9C9e3eDx/w6peG8du/eHSdOnNC+DwoK0ukw3rNnTwBSS93x48dfua9+/frh7bffxo4dO3Dw4EF89913mDt3LrZv345OnTq9ctvckveX6d27N9auXYuNGzdi7NixOuvy8rtDn3jze40N8X0vM2S96UM5ZPcveNmY8Oy+BJMnT9Yuy8/9SX22mThx4kvjzMv2NWrUEM2bN8+xj99++00AEPv27RNCSMNYraysxMCBA/N17vTp8/HJJ58IpVIp4uLidJZnDwe+f//+a4+zcOFCAUCcP38+1/WXLl0SAMQPP/ygszwrK0s0btw4R5+YhQsXil69eokBAwYIS0tL4e3tLR4/fizGjx8vbG1thaenp3j48KEQQoiAgADxzjvvCF9fX2Fvby/q1asnrl+/nmscxaHPhyHO94kTJwQAMW3aNCGEEBkZGaJhw4ZCpVKJa9euvXS7knJe89Pno6Dn9Z9//hGHDh0Ss2bNEkqlUtvfo1u3bsLLy0vb3+Off/7RO6ZskZGRokKFCqJFixbaZdn9Ng4cOKBT9/r16wKA8Pf3F0K8us9HVFSUGDlypDAyMhIbN27U2U9BfnfkFm9+r7Ehvu9lBVs+iplPPvkE69evx9ixY3Hy5EnY29tr1z179gzjxo2DtbW1tp8EkL/7k/Xq1cOOHTtyrP/iiy+QkJCARYsWwcPDAwCQnJyM+/fvw8HBQXurJy/b16hRAwcPHsTNmzdRo0YNbd1ff/0VRkZG2v+RKJVK9O7dG5s2bUJwcHCOloMnT57kq2/K8/r06YPvv/8eK1aswCeffAJAmpFw9erVaN68uU5P9KioKDg6Oupsn5GRgXXr1sHMzAx16tTJ9RgVK1YEABw+fBiTJ0/WLl+4cCEuXbqEDRs26NQPCgrC33//jR07duCXX36Bt7c32rVrhx9//BGLFi2Cr68v1q9fj08//RTBwcH4+++/sWvXLrRo0QJjxozBV199hS1btuSIo6j7JuT2PcnL+X6ZvXv3ApBu1QGAsbExZs+eja5du2LNmjWYO3eutm56erq2RZDn9eWyR1r99ddfqFevnra/xxdffAEfHx+9bzloNBokJibq3JpxdHSEq6trrrcfAgICdEYrLV68GABe20ICSK0kK1asQEJCAoYOHQpLS0t069YNgP6/O/SNN7/X2BDf9zJD7uyHctq2bZtQqVTCxcVFfPHFF2LVqlXiyy+/FK6ursLMzEzs2rWr0I6d22iV7P8FzJgxI1/bnzhxQiiVSuHo6ChmzZolAgICRKdOnQQAMWrUKJ26ERERolKlSsLc3FxMnDhRLF++XPj7+4u+ffuKcuXKvfbYr2v5EEKavdHY2FhMmTJFLF++XLz55pvC2NhYnDhxQqdejx49RNu2bcXXX38tVq5cKWbPni1q1aqVa6vGi3r06CEAiHfffVcEBASIgQMH5vp5hRCiSZMm4pdfftHZdtasWdr3H3zwgZgzZ44QQoiWLVvqHPvgwYOiQYMGr/3MBbV48WIxe/Zs8f777wsAolevXmL27Nli9uzZ2gm+XvY90fd850aj0YgqVaqINm3a6CzPysoStWvXFnZ2diIsLEw8evRIzJo1S5w7d05bp7ifV33OqRCFc16ztWvXTjsiKyUlRZiYmOTp90tMTIywsLAQQ4cOFfPnzxcrVqwQ/fr1y/Ezkt164enpKbp27SoCAgLEoEGDtD8j2V432kUIaZbbzp07C7VaLY4cOaKtp8/vDn3jLQhDXJeygMlHMXXlyhXx7rvvCmdnZ2FkZCQACFNT09cOeyuowkg+hJBm/uvUqZNwdnYWKpVK1KhRQ8yZM0dkZGTkqBsZGSn8/PyEu7u7UKlUwtnZWbRr106sWLHitcfWJ/lISUkRn3zyiXB2dhZqtVo0bdpU7N+/P0e9X3/9Vfj4+AgnJydhbGwsypUrJ3x8fPT65RwTEyOGDRsmypUrJ9RqtWjUqJFYtWpVjnoajUaYm5trZ7sUQoiaNWuKCxcuaN936NBBbNu2TQghhL29vbhz54523fr160W7du1eG09BVapUSe9beS9+T/Q93y/SaDTis88+EwMHDhSRkZE51v/zzz/Cw8NDGBkZiXbt2okbN27obFvcz6s+51QIw5/XbJmZmcLS0lKsX79eCCENvcX/397QV1pampgyZYpo0KCBsLKyEhYWFqJBgwZi6dKlOvWyE4hr166JPn36CCsrK1GuXDkxYcIEkZKSoq2nT/IhhBDJycmiVatWwtLSUifhfN3vDn3jLYiCXpeygslHCbF27VqhUCjE4MGD5Q6FDCgkJEQ4Ojpq3ycnJwsTExOdX8guLi7i5s2b4vHjxwL4b34XIYTo1auX+P7774s05uImMzMzxzKe1+KlJE2RTkWD06uXEEOGDIG/vz/Wr1+Pzz77TO5wyECCgoLQoEED7furV6/Cw8NDOy9AdHQ04uLi4OHhgeDgYCiVSvz222/IyMjAzz//jMuXL2P06NFyhV8s5DaahOeVqHhj8lGCfPrppxBC4H//+5/coZCBXLlyReePZG7v69atCyMjIwQHB2PEiBHYvHkz7Ozs8Ouvv+LQoUNFMmdIScPzSlS8KYQQQu4giOj1Ro8ejSZNmuSY44AKhue18H399deYOXMmnjx5oh2xQ2UbWz6ISojg4GDtTKtkODyvhe/rr7+GEIKJB2mx5YOohLCxscHNmzfh5OQkdyilCs8rUdFj8kFERERFirddiIiIqEgx+SAiIqIiVeye7ZKVlYVHjx7BysoqT088JCIiIvkIIZCQkABXV1cYGb26baPYJR+PHj3iw3eIiIhKqPDwcLi5ub2yTrFLPqysrABIwXOSHyIiIgOLigK2bAH69QNeeHJ3QcTHx8Pd3V37d/xVit1ol/j4eNjY2CAuLo7JBxERUQmRl7/f7HBKRERUlsTEAFu3SqVMmHwQERGVJaGh0i2X0FDZQmDyQUREREWq2HU4JSIiyiaEQGZmJjQajdyhlB5CAJUqSWVqap42ValUUCqVBQ6ByQcRERVL6enpePz4MZKTk+UOpXQxNgZ++kkq83jrRaFQwM3NDZaWlgULoUBbExERFYKsrCyEhoZCqVTC1dUVJiYmnHjSUFJTAaUScHMDTE313kwIgSdPnuDBgweoXr16gVpAmHwQEVGxk56ejqysLLi7u8Pc3FzucEoXU1PA1jZfm5YvXx5hYWHIyMgoUPLBDqdERFRsvW6abipahmp94lUlIiIqS5KTgYsXpVImTD6IiIjKEiH+e8mEyQcREREVKSYfREREpYCPjw9u3boldxh6YfJBREQkM0NMonbr1i14eHgYIJrCx+SDiIhIBt26dcP48ePRtGlTrF69Ghs2bECzZs3g6ekJX19fpKWlAQA6d+6Mr776Ci1atEDVqlURHBwMALh69SqaN2+O+vXrY86cOXB2dtYZHfT06VM4OjoiLCxMu2zatGlQ29nh3e++A8zMdOIZMGAAfvjhh8L/4OA8H2XCuQUPtP9+4yM3GSPJKT+xGfLzFOa5Kehne96rti9O5+NV2xfV97A4f9+JnnflyhW0a9cOS5cuBSAlC4MGDQIAjB49GsePH0eHDh0QHByMXr164fTp01i4cCF27dqF6tWro3///vj111/h6emJHj16oH79+jr7nzNnDrp3747KlStrl02fPh1ubm744IMPMGvOHFSrVk277osvvkDLli0xatQo2NjYFOpnZ/JBREQlysuS9MJSGElsQkICNBoNJk6cCECaPXTlypX4/fffkZ6ejvDwcAwaNAjx8fFQKBQYNWoUACAjIwO2trbYuXMnWrVqBU9PTwBA7dq14erqqt1/cnIyVq1ahQMHDugc18bGBiMHDcLEiRNx5dIlneSjXr168PDwwIYNG+Dn52fwz/w83nYhIiIqJKdOnUKzZs1gamoKBwcHLFq0CIB0y+TNN9/U1luzZg1u3LiBkydP4t9//0W5cuVQp04dBAcHo2nTptp6V65cQd26dXHlyhU0bNhQu/zixYs6LR979+6FWq3GG2+8kSOmzNRUmJuaIvjKlRzrunbtis2bNxvio78Skw8iIqJCsHfvXvTs2RPjx49HUFAQxo4di48++ghhYWG4cuWKttUCkJKRFi1awMzMDAEBAUhOTkb58uURHByMBg0aaOtlb2dnZ6ft+3Hw4EEcPnxYJ/n466+/4OXllWtcX8yahcTkZARfu5ZjXbNmzfD3339r+5sUFiYfREREBpaamoqxY8di0aJFGDZsGGrUqIFZs2bBwsICJ0+ezJF8DB48GPPmzcMbb7yB0NBQ7brg4GBtUpGZmYnY2FjY29tj0KBBOHXqFBo1aoT169ejUqVKKFeunHZ/9+7d07kNk+3ixYv4adUq+L71Vq7Jh6urK9LT0xEREWHoU6KDfT6IiIgM7OjRo0hJSUH//v21y5RKJRQKBdRqNX788Ued+g0aNMh1jo7n6xkbGyM0NBQA4OjoiIsXL770+CkpKTB94Ym1WVlZGDt2LCaMHYvmLi4YNGMGMjIyoFKptHXM/n8ETHIhT73Olg8iIiIDO3bsGBo2bKjz5Nfbt28jISEBjRo1KvTjOzg4ICYmRmfZ4sWLER0djVkzZ8LzjTeQkZGBGzdu6NR59uwZAOnptYWJyQcREZGBXb58Genp6TrLli5dCi8vL9SoUaPQj9+oUSNce+62ysOHD/Hll18iICAAFuXKofrbb0OtVmv7jWQLDg6Gm5sbHBwcCjU+Jh9EREQGdvnyZQQHB2PdunUICQnBN998g2XLlmHlypUApNlIfX194eXlhZYtWyIqKgqANPHYxIkT8cYbb6BmzZr4+++/0b17d1SqVEk7HwgA9OzZEwMGDEDTpk3h4eGBf/75R+f4HTp0wNWrV7WtHx9++CE6deoEX19fQKOBcUoKateunSP5+Ouvv9C+ffvCPDUAmHwQEREZ1P379/Hs2TOsX78e3333HerXr49du3Zh//79aNSoEdLS0jB+/HgsX74cFy9exLvvvosVK1YAkEaz1K9fH+fOnUO7du0wZcoUbNiwAceOHcPq1au1xwgKCkLjxo1x4cIFzJo1K8fMpJ6enmjcuDG2bNmCP/74A0ePHtUO80VqKhASAs8Xko/U1FTs3LkTo0ePLvRzxA6nREREBhQYGAg7Ozv4+vpKLQ0v2LlzJ65evYouXboAANLS0jBs2DAkJCRACIGRI0dq63744YewsrJCVFQUrK2tAQCJiYlITU3Fxx9/DECaYGz9+vU5jvPVV19hypQpCA4OztH/AwDWrVwJWFho369evRrNmjXLdW4QQ2PyQUREJUpxnzb/8uXLOsNoX3TlyhX88MMPGDhwoM7yc+fO5ZhQ7LPPPgMg9cXI3mf2RGPZnVkvXbqU6/F8fX1x69YtPHz4EO7u7q+NW6VSYfHixa//gAbA2y5EREQGdPny5RzPWXmes7OzzrTnQUFBAP675ZLtwYMHcHNz067LTjCCgoJw7949ZGRk4OnTp1i8eDHGjRuX67EmTZqkV+IBAKNGjULNmjX1qltQbPkgIiIyoJ07d75y/fDhw3H48GHUqlULarUaHTp0wLx587QPmgOA8PBwnaThypUr2o6gQUFB6Ny5M7y8vCCEwLx58+Dh4aF/gAoFoFJJpUyYfBARERUhCwuLXBOU5ycUc3d3x8mTJ7Xvf/vtN+2/g4KCsGnTJixYsCB/AZibA89N2S4H3nYhIiIqQfTtw1GcMfkgIiIqQe7evVuwHSQnA//+K5UyYfJBRERUlggBZGRIpUyYfBAREVGRYvJBRERERYrJBxERERUpJh9ERERliakpULOmVMokT8nHsmXLUL9+fVhbW8Pa2hre3t7Yt2+fdn1qair8/Pxgb28PS0tL9O7dG5GRkQYPmoiIygYhY6fIUkupBKyspDKPDHU98pR8uLm54dtvv8XFixfxzz//oG3btujevTuuXr0KAPjoo4+wZ88ebN26FSdOnMCjR4/Qq1cvgwRKRERlh0qlAgAkyzgctNRKTwcePJDKPG8qbaPMR+LyvDzNcNq1a1ed93PmzMGyZctw7tw5uLm5YdWqVdi0aRPatm0LQHpCXu3atXHu3LkieUoeERGVDkqlEra2toiKigIAmJubQyHjdOClSnIyEBEhzXRqbq73ZllZWXjy5AnMzc1hbFywCdLzvbVGo8HWrVuRlJQEb29vXLx4ERkZGfDx8dHWqVWrFipWrIizZ8++NPlIS0tDWlqa9n18fHx+QyIiolLE2dkZALQJCBlIejoQHS0938XEJE+bGhkZoWLFigVOBPOcfFy5cgXe3t5ITU2FpaUlduzYgTp16iAwMBAmJiawtbXVqe/k5ISIiIiX7s/f3x8zZ87Mc+BERFS6KRQKuLi4wNHRERkZGXKHU3pcvQqMGwf8/rvU8TQPTExMYGRU8LEqeU4+atasicDAQMTFxWHbtm0YOnQoTpw4ke8Apk+fjsmTJ2vfx8fHl/g564mIyHCUSmWB+xjQcxQK4N49qZRpxEuekw8TExNUq1YNAODl5YULFy5g0aJF6N+/P9LT0xEbG6vT+hEZGaltOsuNWq2GWq3Oe+RERESUd/b2wMiRUimTAredZGVlIS0tDV5eXlCpVDhy5Ih2XUhICO7fvw9vb++CHoaIiIgMoVIl4OefpVImeWr5mD59Ojp16oSKFSsiISEBmzZtwvHjx3HgwAHY2Nhg5MiRmDx5Muzs7GBtbY0PPvgA3t7eHOlCRERUXKSkAHfvAlWrAmZmsoSQp+QjKioKQ4YMwePHj2FjY4P69evjwIEDeOeddwAACxYsgJGREXr37o20tDR06NABS5cuLZTAiYiIKB+uXwe8vICLF4HGjWUJIU/Jx6pVq1653tTUFAEBAQgICChQUERERFR68dkuREREVKSYfBAREVGRYvJBRERUligU0symMk5XX7DJ2YmIiKhkadQIeO6xJnJgywcREREVKSYfREREZcn169IQ2+vXZQuByQcREVFZkpICXL4slTJh8kFERERFiskHERERFSkmH0RERFSkmHwQERGVJVWqAFu2SKVMOM8HERFRWVKuHNC3r6whsOWDiIioLImMBObPl0qZMPkgIiIqSx4+BD7+WCplwuSDiIiIihSTDyIiIipSTD6IiIioSDH5ICIiKktsbICuXaVSJhxqS0REVJZ4eAC7d8saAls+iIiIypKMDODJE6mUCZMPIiKisuTKFcDRUSplwuSDiIiIihSTDyIiIipSTD6IiIioSDH5ICIioiLFobZERERlSYMGQFwcYGEhWwhMPoiIiMoSpRKwtpY1BN52ISIiKktu3QI6dJBKmTD5ICIiKksSEoCDB6VSJkw+iIiIqEgx+SAiIqIixeSDiIiIihSTDyIiorLE3R1YskQqZcKhtkRERGVJ+fKAn5+sIbDlg4iIqCx59gzYsEEqZcLkg4iIqCwJCwMGD5ZKmTD5ICIioiLF5IOIiIiKFJMPIiIiKlJMPoiIiMoSCwvgjTf4VFsiIiIqIjVrAmfPyhoCWz6IiIioSDH5ICIiKksuXQIUCqmUSZ6SD39/fzRt2hRWVlZwdHREjx49EBISolOndevWUCgUOq9x48YZNGgiIiIqufKUfJw4cQJ+fn44d+4cDh06hIyMDLRv3x5JSUk69UaPHo3Hjx9rX/PmzTNo0ERERFRy5anD6f79+3Xer1mzBo6Ojrh48SJatmypXW5ubg5nZ2fDREhERESlSoH6fMTFxQEA7OzsdJZv3LgRDg4OqFevHqZPn47k5OSX7iMtLQ3x8fE6LyIiIiq98j3UNisrC5MmTUKLFi1Qr1497fJ3330XlSpVgqurK4KCgvDpp58iJCQE27dvz3U//v7+mDlzZn7DICIioryoUwe4dQtwc5MthHwnH35+fggODsapU6d0lo8ZM0b7b09PT7i4uKBdu3a4c+cOPDw8cuxn+vTpmDx5svZ9fHw83N3d8xsWERERvYqpKVCtmqwh5Ou2y4QJE/DHH3/g2LFjcHtN5tS8eXMAwO3bt3Ndr1arYW1trfMiIiKiQhIaCgwaJJUyyVPyIYTAhAkTsGPHDhw9ehRVqlR57TaBgYEAABcXl3wFSERERAYUEwNs3CiVMsnTbRc/Pz9s2rQJu3btgpWVFSIiIgAANjY2MDMzw507d7Bp0yZ07twZ9vb2CAoKwkcffYSWLVuifv36hfIBiIiIqGTJU/KxbNkyANJEYs9bvXo1hg0bBhMTExw+fBgLFy5EUlIS3N3d0bt3b3zxxRcGC5iIiIhKtjwlH0KIV653d3fHiRMnChQQERERlW58tgsREVFZ4uICzJghlTLJ91BbIiIiKoFcXICvv5Y1BLZ8EBERlSXx8cCBA1IpEyYfREREZcnt20DHjlIpEyYfREREVKSYfBAREVGRYvJBRERERYrJBxERUVmiVgMeHlIpEw61JSIiKkvq1pW1synAlg8iIiIqYkw+iIiIypKgIKB8eamUCZMPIiKisiQzE4iOlkqZMPkgIiKiIsXkg4iIiIoUkw8iIiIqUkw+iIiIypIaNYAzZ6RSJpzng4iIqCyxtAS8vWUNgS0fREREZcmDB8DkyVIpEyYfREREZUlUFLBggVTKhMkHERERFSkmH0RERFSkmHwQERFRkWLyQUREVJY4OADjx0ulTDjUloiIqCypWBEICJA1BLZ8EBERlSXJycClS1IpEyYfREREZcmNG4CXl1TKhMkHERERFSkmH0RERFSkmHwQERFRkWLyQUREVJYYGQFWVlIpEw61JSIiKksaNgTi42UNgclHITm34L+nBb7xkdtrl+dn+/zuWx+v2teLMRQkTn2On1sM+mxTUPnZnxxx6nMcfa9hfvZX0M+jb5yGPKa+8nP8wvzZy089ouKIt12IiIjKkmvXgLp1pVImbPkgKkxZGpjERwGB0UC09HL66zaMk2NhlJECo8w0KDLTYaTJgCIzHVAoIIyMIYxVyDJSSaXKDFBUBuztATs7qXRwANzdAbVa7k9IRCVNaqqUeKSmyhYCkw+igsrSwPTpfZg9vgHMiQJCQ4GwMDQMvAWTmEcwysoEZv1XvZLSBJnmtsgyMUOWsRrC2ARZShWEsQkAQKHJgEKTAaPMdCiyMmGUlgScigNSUnIe29kZdU1ckF6uAtLs3ADbZkC9ekDt2kX04YmI8o7JB1FeZGlg/jgEVmEXYPEgGOaPrsMs8iaU6f+fGNjZAVWrAlWq4Fn9zkizc0dauQqoNaaO1Frh4IC/V8YCCkWeDvvGR25S8hETAzx9CkRFAffvA/fuIWXvNahjH8EiPAg4vhwQAgDQ0K4iUpxrIMnNE6jdHmjeHChXzsAnhIgo75h8EL2CIjMdVmEXYXX3PKxCL8Dy3mUYpyYgy8gYKS41kexaG9GNuiHZtTZSXGrB66tG2m3vP98pselzHQIVcfkLxsxMerm66iy+a/Ncx8Mx5YDr14GrV/FszVmYR4TA6fQa4OACqULNmoC3N8on10VcjbeQbseOikRU9Jh8EL3o3j1g/37U+GU7bG6dhjItCZmm1kio7IVHbcYhoUpTJFVsiCwTM7kjzcnCAmjSBGjSBPeftZOWCYE3uqYC585Jr7NnUTVwHRQiCynlqyKuxtuIq/k24qu9CY2plbzxE1Hhq1oV2LVLKmXC5IMIgFlECPDVCuD336WOWEoljCs2xsN2foit1RrJrnVlnZCnQBQKoHp16TV4MADgnznBsLl1BjY3/4LtjWNwPr0WWUoV4qu3wDPPTnhWrz0AtooQlUq2tkC3brKGwOSDyizTqDuwv7wH9v/ugXnETcDGBujeHZg5E/DxwbXViXKHWGg05rZ41qAznjXoDABQP70H22tHYXdlP6psm44q26YDR94CevUCBgwAnJxkjpiIDCYiAli9Ghg+HHB2liUEJh9UphilJcH+8h44ntsEq/uXoVFb4Fnd9rjvOw21At59Yehq6U0+XpRmXwmRbw9H5NvDYZz4FOWuHoJH4nFg6lTg44+BTp1gZ98FMXV9IIw5vJeoRHv0CPjsM6BDByYfRIXJIjwIjmc3weHyThilJyOuZivcHPoTYmq3hcjuu8E5MwAAmZb2eNJ8ADw++gR49gzYvBlYuxY1/hiHTDMbRDfqBrSZLE3RTESUD0w+qPTSZMLuyj64Hl8By/uBSLN1weNWoxHVrD9HeejLzg4YPx4YPx6B046h/IXfUf6fbUCj9cBbbwEffACFpimEUiV3pERUguSpB52/vz+aNm0KKysrODo6okePHggJCdGpk5qaCj8/P9jb28PS0hK9e/dGZGSkQYMmehWjtCQ4n/wFDf1bosa68dCoLXFj5Gpc/uIsHnT8mIlHPqU6VUd4l2m4/OVZYOtWqQNu//5oNNsbFQ4uhHFCtNwhElEJkafk48SJE/Dz88O5c+dw6NAhZGRkoH379khKStLW+eijj7Bnzx5s3boVJ06cwKNHj9CrVy+DB070ImVSDNz2zkPjWc1RafcsJFRugqDJ+3D9/V8RW9cHMFLKHWKpIJQqoE8f4MQJ4N9/EVOnHVyPBKDRN96otGMGTGIeyR0iEb2Kra30M2xrK1sIebrtsn//fp33a9asgaOjIy5evIiWLVsiLi4Oq1atwqZNm9C2bVsAwOrVq1G7dm2cO3cOb7zxhuEiJ8oWFwcsXIhG3/4ARVYmorzfw+OWo5BeroLckZV+9esjtN9c3PedBudTa+BychWczqxHdJPeQJdZ0vBeIipeqlaVWi9lVKCJC+LipJka7ezsAAAXL15ERkYGfHx8tHVq1aqFihUr4uzZswU5FFEORmlJwLffAlWqAP7+eNK8PwI/P4173Wcw8ShiGotyeNjhI1z68hzCO0+F7bWjQK1awLvvArdvyx0eET0vPR148EAqZZLvDqdZWVmYNGkSWrRogXr16gEAIiIiYGJiAtsXmnKcnJwQERGR637S0tKQlpamfR8fH5/fkKisyNKg/N9b4L53HpAWB4weDXz2Ge5tEXJHVuZlmVricZtxiHhrGJpbHgTmzJEecjd6NFROo5Bh7Sh3iEQUHAx4eQEXLwKNG8sSQr5bPvz8/BAcHIzNmzcXKAB/f3/Y2NhoX+7u7gXaH5VyJ0/Cc4EvPLZMRVzNlsCtW0BAAFCBLR3FiVCZSqNkbt+WEpBff0XD/70Ft73zoEzhfzCIyrp8JR8TJkzAH3/8gWPHjsHN7b+RA87OzkhPT0dsbKxO/cjISDi/ZCKT6dOnIy4uTvsKDw/PT0hU2oWFAf36Aa1aQShVCP5wF+68twioVEnuyOhVzMykicru3kXEWyPgcmIlGv7vLWD5ckCjkTs6IpJJnpIPIQQmTJiAHTt24OjRo6hSpYrOei8vL6hUKhw5ckS7LCQkBPfv34e3t3eu+1Sr1bC2ttZ5EWVTaDLgenix1HR/6hSwbh2CP9yFxMryNBVSPpUrh/Au0xD42V+IqeMDjBsHNGsGnDkjd2REJIM8JR9+fn7YsGEDNm3aBCsrK0RERCAiIgIpKSkAABsbG4wcORKTJ0/GsWPHcPHiRQwfPhze3t4c6UJ5ZhH+L+rN94X7/h+ADz4Abt6UHoxWUh/wRsiwccbdgfOBs2elB961aAGPTR9BFR8ld2hEVITy9Ft82bJliIuLQ+vWreHi4qJ9/fbbb9o6CxYsQJcuXdC7d2+0bNkSzs7O2L59u8EDp1IsKQkVd89GvYXdACMlrkzaA8ybB1hayh0ZGcobbwDnzwMrVsD2+hE08G8Fp9NrgawsuSMjKv0aNgRSU2V9REKeRrsI8frRBKampggICEBAQEC+g6Iy7PhxYMQIOIc/wn3faXjcajSg5FMASiWlEhg9GoFR3qj451xU+f0LoPUB4OefgRo15I6OqPQyMpL9WVZsv6ZiQZGZDkybBrRtC7i7I2jKITxu+z4TjzJAY26L0L7+uDZ+i/S0zfr1gblzgcxMuUMjKp1u3gRat5ZKmTD5INmZRt1B3R97AD/8IE0advQoUstXee12VLrEV/MGgoKk/j2ffQY0bw6zR9flDouo9ElMlB6PkJgoWwhMPkg+QsDx7CZ4zu8EZVoScO6cNCxTyWewlFnm5sB330kdUtPS4LmwK5xP/gLoccuXiEoOJh8kC2VqAqqvHYeqWz9FtFdvXJm8T5pxjwiQhuH+8w8ivd9D5Z0zUGvlEIBPxyYqNZh8UJEzjbyFegu7wubmXwgZtgKhff2RpTaXOywqbkxNca/nTNwYvQ7mD68Cnp7An3/KHRURGQCTDypa27bBc2FXCCMlgj/6EzH1O8kdERVzsbXbIOiTg1JrSJcuwMSJUgdlIsqfihWBlSulUiZMPqhoZGZK/Tn69kVM7bYInribnUpJb5lWDsCePcDixcCyZaiztB9MYh/LHRZRyeTgAIwaJZUyYfJBhU6ZHAt07AjMnw/Mn4/bgwOQpbaQOywqaRQKYMIE4K+/YBL7CJ7zO8H6FqdnJ8qz6GhpPp3oaNlCYPJBhUr99B7q/dgDCAwEDh8GPvpI+iNClF/Nm+PK5H1Icq2D2j8NhOuRpRwNQ5QX9+8Do0dLpUyYfFChsbx3GfUWdQeyNNLQydat5Q6JSolMS3vcGLMej9qNR8U//VFjzRgYpSXJHRYR6YnJBxUKu3/3ok5AX6SUr4qrH+4CqleXOyQqbYyUCO/8KUJGrILNzb9Qd0lv9gMhKiGYfJBhCQHMn4/q68bhmWcHXB+3CZmWdnJHRaVYTL32CP5gB4yTY1FvYVdYhAfJHRIRvQaTDzIcIYBPPwU+/hiP2vnh9nuLIVSmckdFZUCKa20ET9yNdFsX1Anog3JB++QOiaj4srQEWrWS9UnhTD7IMLKygPHjpamxf/wR4Z0/lZ6cSFREMqwdcXX8FsTWaYcaa8fC5egydkQlyk2NGtITxGV8ejT/OlDBaTLh8etHwIoVwKpV0oPBiGQgTMxwa1AAHvp8gEp//A+YOFFKjInoP1lZQFqarD8bTD6oQBSZaaix7n3YX94N/PorMGKE3CFRWWdkhAedpuBu32+BJUuAwYOBjAy5oyIqPgIDAVNTqZQJkw/KN6P0FNRcNRK214/h5vCVQL9+codEpBXl/R6wZQuwbRvQvTuQxKG4RMUFkw/KF0VGKmr8MhJWoRdwY/RaxNb1kTskopz69JEeRnfyJPDOO8CzZ3JHRERg8kH5oMhMR42142B992/cGLUG8dVbyB0S0cv5+ABHjwIhIVIP/8ecC4RIbkw+KG8yM1Ft44ewCfkLISN+RkI1b7kjInq9Zs2AU6eAmBhppt1Hj+SOiKhMY/JB+svKAoYPR7krB3Br6DLE1Wotd0RE+qtdWxpemJwMtGnDBITKrnr1gPBwqZQJkw/SjxDAuHHApk24PehHxNRrL3dERHlXrRpw7BgTECrbTEwANzeplAmTD9LPJ58AK1cCq1fjWcOuckdDlH9MQKisu3sX6NtXKmXC5INeb+FCYP58ac6EIUPkjoao4JiAUFkWGysNQY+NlS0EJh/0Snb/7gUmTwamTgX8/OQOh8hwqlX7rw+Ijw/w9KncERGVGUw+6KUsQ/9BtY0fSpOH+fvLHQ6R4Xl4AEeOANHRgK8vkJgod0REZQKTD8qV6ZNQ1PxlBBIrNgTWrOFD4qj0qlED2LcPuHYN6NVLeuYFERUq/kWhnKKiUGvFYGRa2CNk+ErpGQBEpZmXF7BrF3DihNSvSaOROyKiwuPqCvzvf1IpE2PZjkzFU1oa0L07jNKTcfXDndBYlJM7IqKi0aYNsHmzNCV7uXLAsmVyR0RUOJydgenTZQ2ByQf9RwipU+nlywgZtxVp9hXljoioaPXsKQ0pHzkSKF8esBsrd0REhhcbKz3vqGVLwNZWlhB424X+s3w5sGoV8NNPSKrUSO5oiOQxYgTw7bfAN9+g/N+/yR0NkeHdvSs96ZnzfJDsTp8GPvwQmDABGDZM7miI5DV1KjB6NKpsnQ6r22fljoao1GHyQcDDh0Dv3sAbb0iTiRGVdQoFEBCAhKrNUWPNGJg+CZU7IqJShclHWZeWJnWwMzYGtm4FVCq5IyIqHlQq3By6DJmW9qj581Dg2TO5IyIqNZh8lHUffABcvgxs3w44OckdDVGxojG3xY1Ra2CcHCu1Dqanyx0SUcGZmgJ16sg6jQKTj7Js/XqpZ//SpUCzZnJHQ1QspTlUxs3hPwNnzkhPdhZC7pCICqZOHeDqVamUCYfallW3bgHjx0sTKo0YIXc0RMVaQtVmwM8/Sz8vjRsD6CF3SEQlGls+yqL0dGDgQGmimSVL5I6GqGQYPBiYOBH46CNYhv4jdzRE+RcYCFhbS6VMmHyURZ9/DgQFSbM5WlnJHQ1RyfHdd0Dz5qixdhxUCU/kjoYof7KygIQEqZQJk4+y5sAB4PvvpafUennJHQ1RyaJSSaPChEC1dX6AJlPuiIhKJCYfZYgq4Yl0z7pDB+Cjj+QOh6hkcnHBraFLYR36NyrunSt3NEQlEpOPsiIrCx6b/j/hWLsWMOKlJ8qvhKrNca/r53A99hPs/t0rdzhEJQ5Hu5QRTqfXwjbkBLB/P+fzIDKAiJajYHXvEjw2T0aySy2kOlaVOyQi/dSqBVy8KJUy4X9/ywD103uo+Kc/Ilr8/y0XIio4hQJ3+n+PdBtnVNswAYpMTkBGJYS5uTRk3NxcthDynHycPHkSXbt2haurKxQKBXbu3KmzftiwYVAoFDqvjh07GipeyqusLFT9bSoyLexxv8tnckdDVKpkqS1wa9BimD++Afd938kdDpF+7t8H/PykUiZ5Tj6SkpLQoEEDBAQEvLROx44d8fjxY+3r119/LVCQVAArVsDm9hnc6T8PWWoLuaMhKnWS3TwR3mkqXI/9BOubp+QOh+j1oqOlma2jo2ULIc99Pjp16oROnTq9so5arYazs3O+gyIDuX8fmDIFkc0HIr7G23JHQ1RqPW49BrYhJ1Bt0yTgm3cAe3u5QyIq1gqlz8fx48fh6OiImjVr4v3338fTp09fWjctLQ3x8fE6LzIAIYDRowFbW9zv9oXc0RCVbkZGuP3uAig06cCoUXz+C9FrGDz56NixI9atW4cjR45g7ty5OHHiBDp16gSNRpNrfX9/f9jY2Ghf7u7uhg6pbFq9Gjh4EFixAhoza7mjISr1Mmyccbf/d8DOndIDG4nopQyefAwYMADdunWDp6cnevTogT/++AMXLlzA8ePHc60/ffp0xMXFaV/h4eGGDqnMUcU+BiZPBoYOBV5zi4yIDCemXgdg7Fhg0iTgxg25wyHKnaOjNNGko6NsIRT6UNuqVavCwcEBt2/fznW9Wq2GtbW1zosKpvKOGYCZGTB/vtyhEJU98+cDlSpJyf9LWnyJZOXmJn1P3dxkC6HQk48HDx7g6dOncHFxKexDEQCbkBOwv7JP+mLZ2ckdDlHZY24O/PILcOECsHCh3NEQ5ZSYCJw9K5UyyXPykZiYiMDAQAT+/6N4Q0NDERgYiPv37yMxMRFTpkzBuXPnEBYWhiNHjqB79+6oVq0aOnByq0KnyExH5R0zEF+1OTBggNzhEJVd3t7SrZcvvgBu3ZI7GiJdN28Cb74plTLJc/Lxzz//oFGjRmjUqBEAYPLkyWjUqBG++uorKJVKBAUFoVu3bqhRowZGjhwJLy8v/PXXX1Cr1QYPnnQ5n1wF0+gwhPaaDSgUcodDVLZ98w3g6iqNfpHx0eVExVGe5/lo3bo1xCuGkR04cKBAAVE+PXwIt4MLEdFiGFJca8sdDRGZmwM//wy0bQssXw68/77cEREVG3y2S2kxZQo0JuZ40PEjuSMhomxt2kijX6ZOlXUqa6LihslHaXDiBPDrrwjvMh0aMxu5oyGi582bB9jaAmPGcPIxKh6MjQEHB6mUCZOPki4jA5gwAfD2xpMmfeSOhoheZG0t3XY5cABYu1buaIiA+vWBJ0+kUiZMPkq6pUuBq1eBJUsAI15OomKpc2dg0CDg44+BVzxugqis4F+rEkyZHAt8/bXUnNu4sdzhENGrfP89kJkJfPml3JFQWXf1KlCtmlTKhMlHCeZ69CcgPV1KQIioeHNyAmbNAn76Cbh0Se5oqCxLSwPu3JFKmTD5KKFUcRFw/muVND+/s7Pc4RCRPvz8gLp1pX5anPuDyjAmHyWU28FFyFKZAlOmyB0KEenL2BhYvFia2nrDBrmjIZINk48SyPRJKBzP/4pHPhMAGw6tJSpRWreWHn8wdSoQFyd3NESyYPJRArnt+w7p1o6IaDFU7lCIKD+++056qNfMmXJHQmVRtWrA/v1SKRMmHyWMRXgQHAL34EGHyRAqU7nDIaL8cHOTRr38+KOsIw6ojLK2Bjp0kEqZMPkoYdz3zkWKYzVOKEZU0k2aBHh4SJ1POfMpFaXHj6VRko8fyxYCk4+S5OhR2IacxP3OUwGlfNPiEpEBqNXAggXA8ePAn3/KHQ2VJY8fS7f8mHzQawkBTJ+OhIqNEOPZUe5oiMgQOnWSOqBOnw5oNHJHQ1RkmHyUFAcPAn//jfDOUwCFQu5oiMgQFArg22+B4GAOvaUyhclHSeHvDzRrhvjqb8kdCREZUvPmQK9ewFdfAampckdDVCSYfJQEZ88CJ05ITbNs9SAqfebMAR48AJYtkzsSKgvKlQPee08qZcLkoyTw9wfq1AG6dZM7EiIqDLVqASNGAHPmQJkSL3c0VNpVqSLd5qtSRbYQmHwUc2aPrgN79gCffgoY8XIRlVpffw0kJcHl+HK5I6HSLjUVuH1b1tt8/GtWzFU4uhSoVAkYOFDuUIioMFWoAEycCJcTK6GKj5Q7GirNrl0DqleXSpkw+SjG1E/vwf7ybuCTTwCVSu5wiKiwffophNIEFQ4ukjsSokLF5KMYcz32EzItykn3gomo9CtXDg/b+cHx3K9QR4fJHQ1RoWHyUUyp4qNQ/u+teNxyJGBuLnc4RFREIt4ahkxzW7ge5cgXKr2YfBRTLid+RpZShcgWQ+QOhYiKkDAxQ0Sr0Sh/YSvw8KHc4RAVCiYfxVFsLBzPrEdkiyHQmNnIHQ0RFbHIFoORZWIO/PCD3KFQadS4sfTIjsaNZQuByUdxtHo1jDLTENFypNyREJEMNKZWiHhrGLB8ORAdLXc4RAbH5KO4ycoCli3Ds/qdkWHtKHc0RCSTiLf/v6P5Io58IQMLCQG8vaVSJkw+ipujR4FbtxDZYrDckRCRjDIt7YBx44DFi4F4znpKBpSUBJw7J5UyYfJR3CxdCtSrh4QqzeSOhIjk9vHHQEqK9HuBqBRh8lGcPHgA7N4NjB/PB8gREeDqCgwfDsyfDyQnyx0NkcEw+ShOVq4EzMyAQYPkjoSIioupU4Fnz4BffpE7EiKDYfJRXGRkSMnH4MGAlZXc0RBRcVG1qvRsp3nzgPR0uaOh0qByZWD9eqmUCZOP4mLXLuDxY+D99+WOhIiKm2nTgPBw4Ndf5Y6ESgM7O6mF3c5OthCYfBQXS5cCb70FeHrKHQkRFTd16wKdOwM//ihNDkVUEE+eAAEBUikTJh/FwfXrwLFjUkdTIqLc+PkBly4B58/LHQmVdOHhwIQJUikTJh/FwU8/AeXLA716yR0JERVXHTtK/T8CAuSOhKjAmHzILSkJWLMGGDUKUKvljoaIiisjI6l1dMsWICpK7miICoTJh9w2bwYSEoCxY+WOhIiKu+HDpSTk55/ljoSoQJh8yG3DBsDHB6hUSe5IiKi4s7MD3ntPulWryZQ7GiqprKyA9u1lndZBIUTx6jodHx8PGxsbxMXFwdra2uD7P7fggV713vjILc/b5HVfJrGP0Wh2c9wZ8AOim/Y16L5JHmXlehT0c5bm81RYn02738uXgcaNETJsBWLqd9I7lhfjeXEdUUHl5e83Wz5kZH95F4TSBDGeHeUOhYhKikaNAG9vOJ9eJ3ckVFJpNNLDCjUa2UJg8iEjh0u7EFPXBxpTzmhKRHkwYQJsbp2CaeQtuSOhkujffwEbG6mUCZMPmZhG3oLFw2BEN+oudyhEVNL07o10Swe2flCJlefk4+TJk+jatStcXV2hUCiwc+dOnfVCCHz11VdwcXGBmZkZfHx8cOsWs/MXOVzahUxTa8TWbiN3KERU0qjViHpjIBwubINRaqLc0RDlWZ6Tj6SkJDRo0AABL5noZt68efjxxx/x008/4fz587CwsECHDh2Qmppa4GBLDSHgcGknntXvBKEylTsaIiqBorwHQZmRgvIXt8sdClGeGed1g06dOqFTp9x7WAshsHDhQnzxxRfo3l26nbBu3To4OTlh586dGDBgQMGiLSUs7gfC9Ok93O37rdyhEFEJlV7OFTF1fOB47ldEthgidzhEeWLQPh+hoaGIiIiAj4+PdpmNjQ2aN2+Os2fPGvJQJZrDpV1It3JEfDVvuUMhohLsSZPesHgYzI6nlDeentIsuTI+yNSgyUdERAQAwMnJSWe5k5OTdt2L0tLSEB8fr/Mq1bI0sA/cjaeNugJGSrmjIaISLLZOW2Sa2cDh4g65Q6GSRKWSniemUskWguyjXfz9/WFjY6N9ubu7yx1SobK+fQYmCU8Q7dVT7lCIqIQTxmo8bdAFDpd2AllZcodDJcWdO0C3blIpE4MmH87OzgCAyMhIneWRkZHadS+aPn064uLitK9wGR/xWxQcLu1ESvkqSHKrL3coRFQKRHv1gOmzcFiF/SN3KFRSxMUBe/ZIpUwMmnxUqVIFzs7OOHLkiHZZfHw8zp8/D2/v3Ps3qNVqWFtb67xKrdRU2AXtw9NGPQCFQu5oiKgUSKjSDGnlKvDWC5UoeU4+EhMTERgYiMDAQABSJ9PAwEDcv38fCoUCkyZNwjfffIPdu3fjypUrGDJkCFxdXdGjRw8Dh14C7d0L49QERDfmxGJEZCBGRohu3AP2gXugyEyTOxoiveR5qO0///yDNm3+mxhr8uTJAIChQ4dizZo1mDp1KpKSkjBmzBjExsbirbfewv79+2FqyvkssHkzEt08keroIXckRFSKRHv1QoUjAbC9fozPiqISIc/JR+vWrfGqB+EqFArMmjULs2bNKlBgpU5GBnDgAGJajJE7EiIqZVKcayCpQl04XNrJ5INer0IF4IcfpFImso92KTPOnAHi4xFbi9OpE5HhRXv1RLmrh6FMka8TIZUQTk7A5MlSKRMmH0Vl3z7AyQlJFerJHQkRlULRjbpDoUmH3b/75A6FiruYGGDrVqmUCZOPorJ3L9CxI2DEU05Ehpdh44y46m/Bgc96odcJDQX69ZNKmfAvYVEIDweuXAE6d5Y7EiIqxZ427gGbO2dhEvNQ7lCIXonJR1HYv19q8XjnHbkjIaJS7Fn9TsgyVsPh0i65QyF6JSYfRWHvXuDNN4Fy5eSOhIhKMY2pFZ7Vaw/7S5xwjIo3Jh+FTJGZDhw+DHTqJHcoRFQGPGvgC4vHN6B+VrofVUEFYGYGNGoklTLJ8zwflDdWoReAxET29yCiIhFX421kGRnD9toRALk/1oLKuNq1gUuXZA2BLR+FzPb6McDFBWjQQO5QiKgM0JhZI6FqM9heOyp3KEQvxeSjkNlePybdcuGD5IioiMTWaQub22eA5GS5Q6Hi6PJlQK2WSpkw+ShEJs8ewDzyJvt7EFGRiqndDkaZacCxY3KHQsWREEB6ulTKhMlHIbK9cQzCSMkhtkRUpFIdPZBqVxH480+5QyHKFZOPQmR7/SgSKjcBbGzkDoWIyhKFArF12krJh4z/uyV6GSYfhUSRmQabW6cRW7ut3KEQURkUU7stcP8+cPWq3KEQ5cDko5BY3zkPZXoKYmrzKbZEVPTiq3kD5ua89UI51a4NBAdLpUyYfBQS2xvHkGbjjBSXWnKHQkRlkFCZAu3aMfmgnMzMgLp1ZZ1kjMlHIbG9fly65cIhtkQkF19f4MwZWR+dTsXQvXvAqFFSKRMmH4XAOCkGZlG3Ee/xhtyhEFFZ1rkzoNEABw7IHQkVJ0+fAqtWSaVMmHwUAsv7gQCAxEqN5A2EiMo2d3egfn3eeqFih8lHIbC4H4gMi3JIs68kdyhEVNb5+gL79kktIETFBJOPQmB57zIS3RuyvwcRyc/XV2pev3BB7kiItJh8GJoQsAwP5C0XIioe3ngDsLPjrRf6j5MTMG2aVMqEyYeBqaPDoEqKQVLFhnKHQkQEKJVAx45MPug/FSoA/v5SKRMmHwam7WzK5IOIigtfX+DyZajiIuSOhIqDhATg+HGplAmTDwOzvB+IFIfKyLQoJ3coRESSjh2BFSuQZWIudyRUHNy6BbRpI5UyYfJhYJb3LiOxIvt7EFExYmcHjB4NjZm13JEQAWDyYVCKzDRYPLzK/h5ERESvwOTDgMwfXYeRJp0jXYiIiF6ByYcBWd4LRJbSBEkV6sgdChERUe5UKmmki0olWwjGsh25FLK8fxnJFepAGKvlDoWIiCh3np7AgweyhsCWDwOyvB/IIbZERESvweTDQJTJsTB7cpcjXYiIqHi7cgVwc5NKmTD5MBA+yZaIiEqEjAzg4UOplAmTDwOxvBeITDMbpDpUljsUIiKiYo3Jh4FYhv9/fw8+yZaIiOiVmHwYghDSzKa85UJERPRaTD4MQP3sPlRJz9jZlIiIir/q1YFjx6RSJpznwwAs710GACRWbCBzJERERK9hZQW0bi1rCGz5MADL+4FIta+ITEt7uUMhIiJ6tYcPgenTpVImTD4MQJpcjLdciIioBIiMBL79ViplwuSjgBSZ6bB4EMzOpkRERHpi8lFA6qf3YJSZhiRXPkyOiIhIH0w+CkiVEA0AyLB2kjkSIiKikoHJRwGpEp8CADKs2NmUiIhKAHt7YORIqZSJwZOPr7/+GgqFQudVq1YtQx+m2FAlRiNLqYLG1FruUIiIiF6vUiXg55+lUiaFMs9H3bp1cfjw4f8OYlx6pxNRJT5FhqU9p1UnIqKSISUFuHsXqFoVMDOTJYRCyQqMjY3h7OxcGLsudlSJ0ci0dJA7DCIiIv1cvw54eQEXLwKNG8sSQqH0+bh16xZcXV1RtWpVvPfee7h///5L66alpSE+Pl7nVZIYJ/x/ywcRERHpxeDJR/PmzbFmzRrs378fy5YtQ2hoKN5++20kJCTkWt/f3x82Njbal7u7u6FDKlSqxGhkWLHlg4iISF8GTz46deqEvn37on79+ujQoQP27t2L2NhYbNmyJdf606dPR1xcnPYVHh5u6JAKlSrxKTIs7OQOg4iIqMQo9J6gtra2qFGjBm7fvp3rerVaDbVaXdhhFBpV4lP2+SAiopJDoQBMTGQdKFHo83wkJibizp07cHFxKexDFTlFZjqMU+I4xwcREZUcjRoBaWlSKRODJx+ffPIJTpw4gbCwMJw5cwY9e/aEUqnEwIEDDX0o2RlnTzDGlg8iIiK9GTz5ePDgAQYOHIiaNWuiX79+sLe3x7lz51C+fHlDH0p22tlNOdqFiIhKiuvXpSG216/LFoLB+3xs3rzZ0LsstlSJ//9cF7Z8EBFRSZGSAly+LJUy4bNdCiC75SOTLR9ERER6Y/JRAKrEaGjUFsgykWd6WiIiopKIyUcBGCc+Y38PIiKiPGLyUQCqxGj29yAiopKlShVgyxaplEnpfdxsEdA+0ZaIiKikKFcO6NtX1hDY8lEAqgS2fBARUQkTGQnMny+VMmHyUQCqxKfI5OymRERUkjx8CHz8sVTKhMlHfgkBY/b5ICIiyjMmH/lklJ4MZUYq+3wQERHlEZOPfOLspkRERPnD5COfVAl8rgsREZVANjZA165SKRMOtc2n7JaPTCu2fBARUQni4QHs3i1rCGz5yCfj7CfampeTORIiIqI8yMgAnjyRSpkw+cgnVWI0MizKAUo2HhERUQly5Qrg6CiVMmHykU+qhKfsbEpERJQPTD7ySZUYjUx2NiUiIsozJh/5JD3XhS0fREREecXkI5+M+VA5IiKifGFvyXxiywcREZVIDRoAcXGAhYVsITD5yI+sLKiSniKDD5UjIqKSRqkErK1lDYG3XfLBOCUOiiwNWz6IiKjkuXUL6NBBKmXC5CMfjLNnN2WfDyIiKmkSEoCDB6VSJkw+8kGVwIfKERER5ReTj3xQZU+tzj4fREREecbkIx9UidHIUqqgMZW3ww4REVFJxOQjH1TZc3woFHKHQkRElDfu7sCSJVIpEw61zQdpanX29yAiohKofHnAz0/WENjykQ/GCZzdlIiISqhnz4ANG6RSJkw+8kGVGI0MK7Z8EBFRCRQWBgweLJUyYfKRD6rEp8iwsJM7DCIiohKJyUc+qBKfss8HERFRPjH5yCNFZjqMU+I4xwcREVE+MfnII+MkqYMOZzclIqISycICeOMNPtW2JNHObsrRLkREVBLVrAmcPStrCGz5yCNVIp/rQkREVBBMPvJIlSC1fPCJtkREVCJduiTN0H3pkmwhMPnII+PEaGjUFsgyMZM7FCIiohKJyUceaZ/rQkRERPnC5COPVInR7O9BRERUAEw+8ogtH0RERAXD5COPVAls+SAiohKsTh3g1i2plAnn+cgjVeJTZHJ2UyIiKqlMTYFq1WQNgS0feSEEjNnng4iISrLQUGDQIKmUSaElHwEBAahcuTJMTU3RvHlz/P3334V1qCJjlJ4MZUYq+3wQEVHJFRMDbNwolTIplOTjt99+w+TJkzFjxgxcunQJDRo0QIcOHRAVFVUYhysynN2UiIio4Aol+Zg/fz5Gjx6N4cOHo06dOvjpp59gbm6OX375pTAOV2SyZzdlywcREVH+GbzDaXp6Oi5evIjp06drlxkZGcHHxwdnc3mQTVpaGtLS0rTv4+LiAADx8fGGDg0AkJSaoFe954+fvY3qWTjiAcQaq5Gp535eti9DKcx9U96VletR0M9Zms9TYX22F38n6rPvV21TWL9jqQRITPyvNOD3IPs7JYR4fWVhYA8fPhQAxJkzZ3SWT5kyRTRr1ixH/RkzZggAfPHFF1988cVXKXiFh4e/NleQfajt9OnTMXnyZO37rKwsPHv2DPb29lAoFDJGVvLEx8fD3d0d4eHhsLa2ljscygWvUfHG61P88RoVX0IIJCQkwNXV9bV1DZ58ODg4QKlUIjIyUmd5ZGQknJ2dc9RXq9VQq9U6y2xtbQ0dVplibW3NH8pijteoeOP1Kf54jYonGxsbveoZvMOpiYkJvLy8cOTIEe2yrKwsHDlyBN7e3oY+HBEREZUwhXLbZfLkyRg6dCiaNGmCZs2aYeHChUhKSsLw4cML43BERERUghRK8tG/f388efIEX331FSIiItCwYUPs378fTk5OhXE4+n9qtRozZszIcRuLig9eo+KN16f44zUqHRRC6DMmhoiIiMgw+GwXIiIiKlJMPoiIiKhIMfkgIiKiIsXkg4iIiIoUk49iLCAgAJUrV4apqSmaN2+Ov//++6V1MzIyMGvWLHh4eMDU1BQNGjTA/v37depoNBp8+eWXqFKlCszMzODh4YHZs2frNw8/5XDy5El07doVrq6uUCgU2Llz52u3OX78OBo3bgy1Wo1q1aphzZo1Oerk5brTyxXG9fH390fTpk1hZWUFR0dH9OjRAyEhIYXzAcqAwvoZyvbtt99CoVBg0qRJBouZDIPJRzH122+/YfLkyZgxYwYuXbqEBg0aoEOHDoiKisq1/hdffIHly5dj8eLFuHbtGsaNG4eePXvi8uXL2jpz587FsmXLsGTJEly/fh1z587FvHnzsHjx4qL6WKVKUlISGjRogICAAL3qh4aGwtfXF23atEFgYCAmTZqEUaNG4cCBA9o6eb3u9HKFcX1OnDgBPz8/nDt3DocOHUJGRgbat2+PpKSkwvoYpVphXKNsFy5cwPLly1G/fn1Dh02GYJCnyZHBNWvWTPj5+WnfazQa4erqKvz9/XOt7+LiIpYsWaKzrFevXuK9997Tvvf19RUjRox4ZR3KHwBix44dr6wzdepUUbduXZ1l/fv3Fx06dNC+z+t1J/0Y6vq8KCoqSgAQJ06cMESYZZohr1FCQoKoXr26OHTokGjVqpWYOHGigaOlgmLLRzGUnp6OixcvwsfHR7vMyMgIPj4+OHv2bK7bpKWlwdTUVGeZmZkZTp06pX3/5ptv4siRI7h58yYA4N9//8WpU6fQqVOnQvgU9KKzZ8/qXFMA6NChg/aa5ue6k+G87vrkJi4uDgBgZ2dXqLGRRN9r5OfnB19f3xx1qfiQ/am2lFN0dDQ0Gk2OGWGdnJxw48aNXLfp0KED5s+fj5YtW8LDwwNHjhzB9u3bodFotHWmTZuG+Ph41KpVC0qlEhqNBnPmzMF7771XqJ+HJBEREble0/j4eKSkpCAmJibP150M53XXx8zMTGddVlYWJk2ahBYtWqBevXpFGWqZpc812rx5My5duoQLFy7IFCXpgy0fpcSiRYtQvXp11KpVCyYmJpgwYQKGDx8OI6P/LvGWLVuwceNGbNq0CZcuXcLatWvx/fffY+3atTJGTlQy+fn5ITg4GJs3b5Y7FPp/4eHhmDhxIjZu3JijJZiKF7Z8FEMODg5QKpWIjIzUWR4ZGQlnZ+dctylfvjx27tyJ1NRUPH36FK6urpg2bRqqVq2qrTNlyhRMmzYNAwYMAAB4enri3r178Pf3x9ChQwvvAxEAwNnZOddram1tDTMzMyiVyjxfdzKc112f502YMAF//PEHTp48CTc3t6IMs0x73TW6ePEioqKi0LhxY+16jUaDkydPYsmSJUhLS4NSqSzqsCkXbPkohkxMTODl5YUjR45ol2VlZeHIkSPw9vZ+5bampqaoUKECMjMz8fvvv6N79+7adcnJyTotIQCgVCqRlZVl2A9AufL29ta5pgBw6NAh7TUtyHWngnvd9QEAIQQmTJiAHTt24OjRo6hSpUpRh1mmve4atWvXDleuXEFgYKD21aRJE7z33nsIDAxk4lGcyN3jlXK3efNmoVarxZo1a8S1a9fEmDFjhK2trYiIiBBCCDF48GAxbdo0bf1z586J33//Xdy5c0ecPHlStG3bVlSpUkXExMRo6wwdOlRUqFBB/PHHHyI0NFRs375dODg4iKlTpxb1xysVEhISxOXLl8Xly5cFADF//nxx+fJlce/ePSGEENOmTRODBw/W1r97964wNzcXU6ZMEdevXxcBAQFCqVSK/fv3a+u87rqT/grj+rz//vvCxsZGHD9+XDx+/Fj7Sk5OLvLPVxoUxjV6EUe7FE9MPoqxxYsXi4oVKwoTExPRrFkzce7cOe26Vq1aiaFDh2rfHz9+XNSuXVuo1Wphb28vBg8eLB4+fKizv/j4eDFx4kRRsWJFYWpqKqpWrSo+//xzkZaWVlQfqVQ5duyYAJDjlX1dhg4dKlq1apVjm4YNGwoTExNRtWpVsXr16hz7fdV1J/0VxvXJbX8Acr2O9HqF9TP0PCYfxZNCCE5vSUREREWHfT6IiIioSDH5ICIioiLF5IOIiIiKFJMPIiIiKlJMPoiIiKhIMfkgIiKiIsXkg4iIiIoUkw8iIiIqUkw+iIiIqEgx+SAiIqIixeSDiIiIihSTDyIiIipS/wc/2TIJb9catAAAAABJRU5ErkJggg==\n" + }, + "metadata": {} }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "n5rbUhgOX3CP" - }, - "outputs": [], - "source": [ - "def fit_eval_config(tag, cfg, t_points=T_POINTS_SWEEP, run_detx=False):\n", - " params = dict(\n", - " objective='multi:softprob',\n", - " num_class=n_classes,\n", - " eval_metric=['mlogloss', 'merror'],\n", - " tree_method='hist',\n", - " seed=RNG,\n", - " verbosity=0,\n", - " )\n", - " params.update(cfg)\n", - " num_boost_round = int(params.pop('num_boost_round', 2000))\n", - " early_stopping_rounds = params.pop('early_stopping_rounds', 100)\n", - "\n", - " dtr = xgb.DMatrix(X_train[idx_tr], label=y_train[idx_tr])\n", - " dva = xgb.DMatrix(X_train[idx_val], label=y_train[idx_val])\n", - " dtrain_full = xgb.DMatrix(X_train, label=y_train)\n", - " dtest = xgb.DMatrix(X_test, label=y_test)\n", - "\n", - " evals_result = {}\n", - " booster = xgb.train(\n", - " params=params,\n", - " dtrain=dtr,\n", - " num_boost_round=num_boost_round,\n", - " evals=[(dtr, 'tr'), (dva, 'va')],\n", - " early_stopping_rounds=early_stopping_rounds,\n", - " evals_result=evals_result,\n", - " verbose_eval=False,\n", - " )\n", - "\n", - " best_iteration = int(getattr(booster, 'best_iteration', num_boost_round - 1))\n", - " train_proba = booster.predict(dtrain_full, iteration_range=(0, best_iteration + 1))\n", - " test_proba = booster.predict(dtest, iteration_range=(0, best_iteration + 1))\n", - "\n", - " train_pred = np.argmax(train_proba, axis=1)\n", - " test_pred = np.argmax(test_proba, axis=1)\n", - "\n", - " row = {\n", - " 'tag': tag,\n", - " 'num_boost_round_requested': num_boost_round,\n", - " 'best_iteration': best_iteration,\n", - " 'train_acc': accuracy_score(y_train, train_pred),\n", - " 'test_acc': accuracy_score(y_test, test_pred),\n", - " 'train_bal_acc': balanced_accuracy_score(y_train, train_pred),\n", - " 'test_bal_acc': balanced_accuracy_score(y_test, test_pred),\n", - " 'test_macro_f1': f1_score(y_test, test_pred, average='macro'),\n", - " 'train_mlogloss': log_loss(y_train, train_proba, labels=np.arange(n_classes)),\n", - " 'test_mlogloss': log_loss(y_test, test_proba, labels=np.arange(n_classes)),\n", - " 'multiclass_mode': MULTICLASS_MODE_MAIN,\n", - " 'alpha': np.nan,\n", - " 'rand_num_spikes': np.nan,\n", - " 'detX_val': np.nan,\n", - " 'ww_note': '',\n", - " }\n", - " for k, v in cfg.items():\n", - " row[f'hp_{k}'] = v\n", - "\n", - " try:\n", - " model_ww = convert(booster, X_train, y_train, multiclass=MULTICLASS_MODE_MAIN, return_type='torch')\n", - " watcher = ww.WeightWatcher(model=model_ww, log_level='ERROR')\n", - " details = watcher.analyze(\n", - " randomize=True,\n", - " min_evals=10,\n", - " max_evals=200,\n", - " mp_fit=False,\n", - " plot=False,\n", - " savefig=False,\n", - " detX=run_detx,\n", - " max_N=WW_MAX_N,\n", - " )\n", - " details = pd.DataFrame(details)\n", - " if 'alpha' in details.columns:\n", - " row['alpha'] = float(details['alpha'].dropna().iloc[0]) if details['alpha'].notna().any() else np.nan\n", - " if 'rand_num_spikes' in details.columns:\n", - " row['rand_num_spikes'] = float(details['rand_num_spikes'].dropna().iloc[0]) if details['rand_num_spikes'].notna().any() else np.nan\n", - " if run_detx and 'detX_val' in details.columns and details['detX_val'].notna().any():\n", - " row['detX_val'] = float(details['detX_val'].dropna().iloc[0])\n", - " except Exception as e:\n", - " row['ww_note'] = f'skipped/failed: {type(e).__name__}: {e}'\n", - " # automatic fallback: lower t_points via avg mode\n", - " try:\n", - " model_ww = convert(booster, X_train, y_train, multiclass='avg', return_type='torch')\n", - " watcher = ww.WeightWatcher(model=model_ww, log_level='ERROR')\n", - " details = pd.DataFrame(watcher.analyze(randomize=True, min_evals=10, max_evals=120, mp_fit=False, plot=False, savefig=False, max_N=WW_MAX_N))\n", - " row['multiclass_mode'] = 'avg'\n", - " if 'alpha' in details.columns and details['alpha'].notna().any():\n", - " row['alpha'] = float(details['alpha'].dropna().iloc[0])\n", - " if 'rand_num_spikes' in details.columns and details['rand_num_spikes'].notna().any():\n", - " row['rand_num_spikes'] = float(details['rand_num_spikes'].dropna().iloc[0])\n", - " row['ww_note'] += ' | fallback avg mode applied'\n", - " except Exception as e2:\n", - " row['ww_note'] += f' | fallback failed: {type(e2).__name__}: {e2}'\n", - "\n", - " print(f\"[{tag}] requested={num_boost_round} best_iteration={best_iteration} train_acc={row['train_acc']:.4f} test_acc={row['test_acc']:.4f} alpha={row['alpha']}\")\n", - " return row, booster\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "n5rbUhgOX3CP" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "markdown", - "metadata": { - "id": "yLhrndzDX3CP" - }, - "source": [ - "## Debug cell: single-model convert + WeightWatcher deep diagnostics\n", - "\n", - "Use this when `alpha` is NaN or conversion/WW unexpectedly fails. It trains one selected config, runs `xgboost2ww.convert`, and then runs WeightWatcher with `plot=True` plus extra diagnostics." - ], - "id": "yLhrndzDX3CP" + "output_type": "stream", + "name": "stdout", + "text": [ + "WW analyze rows: 1\n" + ] }, { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "sY-Hq3GkX3CQ", - "outputId": "03e0f815-c5b0-44d3-988d-1b0fa0764f22", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Debug config: U1 {'max_depth': 2, 'eta': 0.3, 'num_boost_round': 150, 'early_stopping_rounds': 40, 'min_child_weight': 20, 'gamma': 5, 'subsample': 0.6, 'colsample_bytree': 0.6, 'reg_lambda': 50, 'reg_alpha': 0}\n", - "best_iteration: 147 requested: 150\n", - "debug test_acc: 0.7439166666666667\n", - "debug test_mlogloss: 0.585806952159488\n", - "Converting with multiclass= stack return_type= torch\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "INFO:weightwatcher:\n", - "\n", - "python version 3.12.12 (main, Oct 10 2025, 08:52:57) [GCC 11.4.0]\n", - "numpy version 2.0.2\n", - "torch version 2.10.0+cu128\n", - "INFO:weightwatcher:SET MODEL: None, None\n", - "INFO:weightwatcher:SET MODEL: Sequential(\n", - " (0): Linear(in_features=150, out_features=672000, bias=False)\n", - "), None\n", - "INFO:weightwatcher:params {'glorot_fix': False, 'normalize': False, 'conv2d_norm': True, 'randomize': True, 'savedir': 'ww-img', 'savefig': False, 'rescale': True, 'plot': True, 'deltaEs': False, 'intra': False, 'channels': None, 'fft': False, 'conv2d_fft': False, 'ww2x': False, 'pool': True, 'vectors': False, 'smooth': None, 'stacked': False, 'svd_method': 'fast', 'fix_fingers': False, 'fit': 'power_law', 'MAX_FINGERS': 10, 'finger_thresh': 1.0, 'sparsify': True, 'detX': True, 'mp_fit': False, 'min_evals': 10, 'max_evals': 200, 'max_N': 800000, 'tolerance': 1e-06, 'layer_ids_start': 0, 'add_biases': False, 'xmin_max': None, 'pl_package': 'ww', 'xmax': None, 'peft': False, 'inverse': False, 'glorot_fit': False, 'layers': []}\n", - "INFO:weightwatcher:Using \n", - "INFO:weightwatcher:torch version 2.10.0+cu128\n", - "INFO:weightwatcher:framework from model = pytorch\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "convert() success. type = \n", - "torch module count: 2\n", - "layers with weight attr: 1\n", - " layer[0] weight shape: (672000, 150)\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "INFO:weightwatcher:Running powerlaw.Fit no xmin, xmax=None. distribution=power_law pl_package=ww\n", - "INFO:weightwatcher:PL FIT running NEW power law method\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAGzCAYAAAD9pBdvAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAMZBJREFUeJzt3XlcVeW+x/HvZhYHnBEFwTrmjJoD4ZClpBlp3tM101Kv16ybctK8p5JSOWWlTaR1LMrSBjNtUivLMsdKSkM9ga/0OIsmqFmoaIDw3D+87NoyyEbgEfi8X6/1erGf/Txr/dbaC/aXNeztMMYYAQAAWOJhuwAAAFC9EUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAIv+67/+S2FhYbbLqDC7du1S//79FRAQIIfDoWXLltkuqdq56aabNG7cuFKNveaaa/Tggw+WcUUAYQRVyBtvvCGHw6EffvjBdimSpLCwMN18880Vusx169bJ4XAUOS1evNjZNzs7W3PmzFHnzp1Vp04d1a1bV+3atdPdd9+tHTt2OPvlb9f8yc/PT02bNtWAAQP0wgsv6NSpUyWub/To0UpOTtYTTzyht99+W127di3T9f+z/fv3y+Fw6Nlnny23ZVSkI0eOaMqUKbr++utVu3ZtORwOrVu3zq15fPvtt/ryyy/10EMPubTn5eXp6aefVosWLeTn56fw8HC9++67BcY/9NBDmjt3rtLS0i5lVYACvGwXAFRn8+bNU15eXpnP97777lO3bt0KtEdGRjp/vvXWW/X5559r+PDhGjdunHJycrRjxw59+umn6tGjh1q3bu0y9rHHHlOLFi2Uk5OjtLQ0rVu3TpMmTVJ8fLw+/vhjhYeHF1vT2bNnlZiYqEceeUQxMTFls6LVyM6dO/XUU0+pZcuW6tChgxITE92exzPPPKN+/frpL3/5i0v7I488olmzZmncuHHq1q2bli9frhEjRsjhcOj222939rvllltUp04dvfTSS3rssccueZ0AJwNUEQsWLDCSzObNm22XYowxJjQ01ERHR1foMteuXWskmffff7/Yfps2bTKSzBNPPFHguXPnzpnjx487Hxe3XVevXm1q1KhhQkNDzZkzZ4pd5oEDB4wk88wzz5RwbS7u9OnTRT63b9++Ml9eecvMzCzyuZMnT5pffvnFGGPM+++/bySZtWvXlnje6enpxsvLy7z22msu7YcOHTLe3t5mwoQJzra8vDzTu3dvExwcbM6dO+fSPyYmxoSGhpq8vLwSLxu4GE7ToNrZunWrBg4cqDp16qhWrVrq16+fvvvuuwL9fvzxR/Xp00c1atRQcHCwHn/8cS1YsEAOh0P79+8vk1ouvGbkz6cWXn31VV155ZXy9fVVt27dtHnz5jJZpiTt2bNHktSzZ88Cz3l6eqpBgwYlmk/fvn01bdo0HThwQAsXLiyy3z/+8Q+FhoZKkh544AE5HA6X9S7Ja5J/umj9+vUaP368GjdurODg4BLVWZwFCxaob9++aty4sXx9fdW2bVu9/PLLLn1Gjx6thg0bKicnp8D4/v37q1WrVi5tCxcuVJcuXVSjRg3Vr19ft99+u1JTU136XHfddWrfvr2SkpJ07bXXyt/fXw8//HCRddauXVv169cv9XquWLFC586dU1RUlEv78uXLlZOTo/HjxzvbHA6H7r33Xh06dKjAEZgbbrhBBw4c0LZt20pdC3AhTtOgWtm+fbt69+6tOnXq6MEHH5S3t7deeeUVXXfddVq/fr0iIiIkSYcPH9b1118vh8Oh2NhY1axZU6+99pp8fX0rpM5Fixbp1KlTuueee+RwOPT000/rr3/9q/bu3Stvb++Ljj916pSOHz9eoL1BgwZyOBzOYPDOO++oZ8+e8vIq/Z+CkSNH6uGHH9aXX35Z5IWRf/3rX1W3bl3df//9Gj58uG666SbVqlVLUslfk3zjx49Xo0aNNH36dGVmZpa67nwvv/yy2rVrp8GDB8vLy0uffPKJxo8fr7y8PE2YMMG5jm+99Za++OILl+uA0tLStGbNGsXFxTnbnnjiCU2bNk233Xab7rrrLh07dkwvvviirr32Wm3dulV169Z19v3ll180cOBA3X777brzzjsVGBh4yetTlI0bN6pBgwbO1z7f1q1bVbNmTbVp08alvXv37s7ne/Xq5Wzv0qWLpPPXn3Tu3Lnc6kU1Y/vQDFBWSnKaZsiQIcbHx8fs2bPH2fbzzz+b2rVrm2uvvdbZ9re//c04HA6zdetWZ9svv/xi6tevbySZffv2XbSekpymGT16tAkNDXU+zj+10KBBA3PixAln+/Lly40k88knnxQ7v/zTNEVNR44cMcacPwzfp08fI8kEBgaa4cOHm7lz55oDBw4UmGdJtmtAQIDp3LlzsbUVddqkpK9Jfh29evUqcOrAneVdqLDTSwMGDDBXXHGF83Fubq4JDg42w4YNc+kXHx9vHA6H2bt3rzHGmP379xtPT88Cp7+Sk5ONl5eXS3v+9k9ISLjoulyoNKdpevXqZbp06VKgPTo62mVd82VmZhpJZsqUKQWe8/HxMffee69bNQPF4TQNqo3c3Fx9+eWXGjJkiK644gpne1BQkEaMGKFvvvlGJ0+elCStXLlSkZGR6tSpk7Nf/fr1dccdd1RIrcOGDVO9evWcj3v37i1J2rt3b4nGT58+XatWrSow5R/mdzgc+uKLL/T444+rXr16evfddzVhwgSFhoZq2LBh+u2339yqt1atWm7dVZPPndck37hx4+Tp6en2sopSo0YN588ZGRk6fvy4+vTpo7179yojI0OS5OHhoTvuuEMff/yxy3q+88476tGjh1q0aCFJ+uijj5SXl6fbbrtNx48fd05NmjRRy5YttXbtWpdl+/r6asyYMWW2LsX55ZdfXPapfGfPni30iJ+fn5/z+QvVq1ev0CNvQGlxmgbVxrFjx3TmzJkC5/clqU2bNsrLy1NqaqratWunAwcOuNx5ku/CuxAyMjJc/lj7+Phc0nn9fM2bN3d5nP8m8uuvv5ZofIcOHQpcG3AhX19fPfLII3rkkUd05MgRrV+/XnPmzNF7770nb2/vYq8BudDp06fVuHHjEvfP585rki//jb+sfPvtt4qLi1NiYqLOnDnj8lxGRoYCAgIkSaNGjdJTTz2lpUuXatSoUdq5c6eSkpKUkJDg7L9r1y4ZY9SyZctCl3XhKbZmzZrJx8enTNenOMaYAm01atRQVlZWgfbff//d+Xxh83E4HGVfIKotwghwCSZOnKg333zT+bhPnz5uf/ZDYYr6z7+wN5OyEBQUpNtvv1233nqr2rVrp/fee09vvPFGia4lOXTokDIyMgoEtfJS2Jtjae3Zs0f9+vVT69atFR8fr5CQEPn4+Oizzz7T888/73Lbddu2bdWlSxctXLhQo0aN0sKFC+Xj46PbbrvN2ScvL08Oh0Off/55oa9h/nUy5bEuF9OgQYNCw2xQUJDWrl1bIGAcOXJEktS0adMCY3777Tc1bNiw/IpFtUMYQbXRqFEj+fv7a+fOnQWe27Fjhzw8PBQSEiJJCg0N1e7duwv0u7DtwQcf1J133ul8XNhh8MrE29tb4eHh2rVrl/P0wsW8/fbbkqQBAwa4vTx3XpPy8MknnygrK0sff/yxy9GoC0+n5Bs1apQmT56sI0eOaNGiRYqOjnZ5za+88koZY9SiRQtdddVV5VZ3abRu3VoffvhhgfZOnTrptdde008//aS2bds627///nvn8392+PBhZWdnF7jgFbgUXDOCasPT01P9+/fX8uXLXW7NTU9P16JFi9SrVy/VqVNH0vk31sTERJfbF0+cOKF33nnHZZ5t27ZVVFSUc8q/0+Byt2vXLh08eLBA+2+//abExETVq1dPjRo1uuh81qxZoxkzZqhFixalup7GndekPOQfvfjzEaeMjAwtWLCg0P7Dhw+Xw+HQxIkTtXfvXpcgKp2/a8jT01OPPvpogaNYxhj98ssvZbwGJRcZGalff/21wHVHt9xyi7y9vfXSSy8524wxSkhIULNmzdSjRw+X/klJSZJUoB24FBwZQZUzf/58rVy5skD7xIkT9fjjj2vVqlXq1auXxo8fLy8vL73yyivKysrS008/7ez74IMPauHChbrhhhv0t7/9zXlrb/PmzXXixIkSny/fvXu3Hn/88QLtnTt3VnR0dOlX8iK+/vpr5zn/PwsPD1d4eLj+9a9/acSIERo4cKB69+6t+vXr6/Dhw3rzzTf1888/a/bs2QVOM3z++efasWOHzp07p/T0dK1Zs0arVq1SaGioPv74Y+cFj+4q6WtSWqtXry50WwwZMkT9+/eXj4+PBg0apHvuuUenT5/WvHnz1LhxY+dpij9r1KiRbrzxRr3//vuqW7dugdfwyiuv1OOPP67Y2Fjt379fQ4YMUe3atbVv3z4tXbpUd999t/7+97+Xel3y96Xt27dLOn9U6ptvvpEkTZ06tdix0dHR8vLy0ldffaW7777b2R4cHKxJkybpmWeeUU5Ojrp166Zly5bp66+/1jvvvFNgP1i1apWaN2/Obb0oW7Zu4wHKWv6tn0VNqampxhhjtmzZYgYMGGBq1apl/P39zfXXX282btxYYH5bt241vXv3Nr6+viY4ONjMnDnTvPDCC0aSSUtLu2g9oaGhRdYyduxYY0zRt/YWdjuqJBMXF1fsMi92a2/++PT0dDNr1izTp08fExQUZLy8vEy9evVM3759zQcffFDsdvXx8TFNmjQxN9xwg5kzZ445efLkRbfFxdatJK+Ju5+wm7+8oqa3337bGGPMxx9/bMLDw42fn58JCwszTz31lJk/f36Rt3C/9957RpK5++67i1z2hx9+aHr16mVq1qxpatasaVq3bm0mTJhgdu7c6ezTp08f065duxKtS77i1qckBg8ebPr161egPTc31zz55JMmNDTU+Pj4mHbt2pmFCxcW2i8oKMhMnTrVrbqBi3EYU05XxAFV0KRJk/TKK6/o9OnTZXp7KSqP5cuXa8iQIdqwYYPzluvK4uuvv9Z1112nHTt2FHnHT3GWLVumESNGaM+ePQoKCiqHClFdEUaAIpw9e9blbodffvlFV111la6++mqtWrXKYmWw6eabb9ZPP/2k3bt3V8rbWwcOHKjg4GDNmzfP7bGRkZHq3bt3mZw+A/6Ma0aAIkRGRuq6665TmzZtlJ6ertdff10nT57UtGnTbJcGCxYvXqwff/xRK1as0Jw5cyplEJHOX/tTWqX5pmCgJDgyAhTh4Ycf1gcffKBDhw7J4XDo6quvVlxc3EU/TAxVk8PhUK1atTRs2DAlJCRc0vf5AHBFGAEAAFbxOSMAAMAqwggAALCqUpz0zMvL088//6zatWtX2ovGAACobowxOnXqlJo2bSoPj6KPf1SKMPLzzz+X6/dTAACA8pOamqrg4OAin68UYaR27dqSzq9MeX5PBQCUqcxMKf9bb3/+WapZ0249wIXOZUof/f8++tefJa+y3UdPnjypkJAQ5/t4USpFGMk/NVOnTh3CCIDK48+f0lunDmEEl59znpL///9cp06Zh5F8F7vEggtYAQCAVYQRAABgFWEEAABYVSmuGSmJ3Nxc5eTk2C6jSvH09JSXlxe3UwMAylWVCCOnT5/WoUOHxCfblz1/f38FBQXJx8fHdikAgCqq0oeR3NxcHTp0SP7+/mrUqBH/xZcRY4yys7N17Ngx7du3Ty1btiz2A2sAACitSh9GcnJyZIxRo0aNVKNGDdvlVCk1atSQt7e3Dhw4oOzsbPn5+dkuCQBQBVWZf3U5IlI+OBoCAChvvNMAAACrCCMAAMAqwggAALCKMGLZlClT5OvrqxEjRtguBQAAKwgjlsXGxuq5557Tu+++q927d9suBwCACkcYsSwgIEBjx46Vh4eHkpOTbZcDAECFq/SfM1IVnDt3Tv7+/kpJSdF//Md/2C7nshY2ZUWBtv2zoi1UYseF61+R616dtn1h63qhqrrugA1VL4wYI505Y2fZ/v5SKT7vZOrUqTp9+rRSUlLKoSgAAC5vVS+MnDkj1aplZ9mnT0s1a7o1JCkpSQkJCYqOji7zMLJmzRpt3bpV//u//1um8wUAoCxVvTBSieTl5emee+5RTEyMIiIidOeddyonJ0fe3t5lMv++ffuqb9++ZTIvAADKS9W7gNXf//wRChuTv79bpb744os6fvy4HnvsMXXo0EE5OTnasWOH8/mePXvq+++/lySNHTtWzz//vCRp8ODBmjhxoq655hq1atVKmzZt0i233KLQ0FC99NJLzvGDBw9WcnKybrrpJk2fPl09e/bUFVdcwekgAMBlpeqFEYfj/KkSG5Mb14scPnxY06ZN09y5c1WzZk21bNlSvr6+LkFh2rRpmjVrluLj4+Xh4aH7779fkpScnKzw8HB999136tevnx544AEtXLhQa9eu1YIFC5zjd+zYodatWyslJUXNmzfXt99+q/vuu0/Lly8vu+0NAMAlqnphpJK47777NHDgQEVHn78i38vLS23atHEJIzfeeKMOHjyoFStWOI94nDp1SsYYjR071mVetWvXljFGderUcfbz8/PT2bNn5XA4dNddd0k6/y3HdevWraC1BADg4ggjFnz66adas2aN5syZ49LeoUMHlzCyefNmnThxQgEBAc7rSLZv365u3bo5+yQnJysiIkKSlJKSog4dOjj7tWvXTikpKQX6t2vXrtzWDQAAd3EBqwU333yzfv311wLtb731lvPnw4cP66677tKaNWt06623KiUlRe3bt3eeosl36NAhBQcHSzofNPLDSP7PKSkp6tixo7P/n/sAAHA54MjIZejs2bMaOnSoXnzxRbVo0UKxsbGaMWOGJLmEkdTUVIWEhDjHXRhG2rdvr5SUFGf/c+fO6bffflODBg0qeI0AACgaR0YuQzVq1NDGjRudj4cOHaqhQ4dKkl544QVne0hIiDZs2OB8vGTJEufP+f0GDx7sbPPy8tK+ffvKrW4AAEqDIyMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIoxYNmXKFPn6+mrEiBG2SwEAwArCiGWxsbF67rnn9O6772r37t22ywEAoMIRRiwLCAjQ2LFj5eHhoeTkZNvlAABQ4Qgjl4Fz587J399fKSkptksBAKDCedkuoMwZI+WesbNsT3/J4XB72NSpU3X69GnCCACgWqp6YST3jPReLTvLvu205FXTrSFJSUlKSEhQdHQ0YQQAUC1xmsaivLw83XPPPYqJidGoUaO0a9cu5eTk2C4LAIAKVfWOjHj6nz9CYWvZbnjxxRd1/PhxPfbYYzp48KBycnK0Y8cOdejQQZLUs2dPxcfHKyIiQmPHjlX79u11//33a/DgwWrRooW+//57/frrr3r77bf1xBNPaNu2bXrooYc0fvx4SdLChQv1wgsv6OzZs2revLk++ugj9e3bt9B5AgBgS9U7MuJwnD9VYmNy43qRw4cPa9q0aZo7d65q1qypli1bytfX1+VUzbRp0zRr1izFx8fLw8PDGRqSk5MVHh6u7777Tv369dMDDzyghQsXau3atVqwYIFz/MCBA7Vp0yYlJyeradOmWrduXZHzBADAlqoXRiqJ++67TwMHDlR0dLQkycvLS23atHEJIzfeeKMOHjyoFStW6KWXXpIknTp1SsYYjR071mVetWvXljFGderUkSQZYzRv3jx169ZNHTt21Icffig/P79C5wkAgE2EEQs+/fRTrVmzRnPmzHFp79Chg0sY2bx5s06cOKGAgAB5e3tLkrZv365u3bo5+yQnJysiIkKSlJKS4jzF88Ybb2jHjh3asGGD/vWvf6levXpq27ZtofMEAMAmwogFN998s3799Vc1adLEpf2tt97S8uXLJZ0/jXPXXXdpzZo12r9/vzOk5J+iyXfo0CEFBwc7n8sPI9u3b1fPnj1Vo0YNzZ07V2fOnFF2dnah8wQAwCbCyGXo7NmzGjp0qF588UW1aNFCsbGxmjFjhiTXMJKamqqQkBDnuD+HkZEjR+rpp5/WNddco3379ql9+/ZFzhMAAJuq3t00VUCNGjW0ceNG5+OhQ4dq6NChkqQXXnjB2R4SEqINGzY4Hy9ZssT5c8eOHbVr164il/HneQIAYBNHRgAAgFWEEQAAYBVhBAAAWEUYAQAAVlWZMGKMsV1ClZSXl2e7BABAFVfp76bx9vaWw+HQsWPH1KhRIznc+Eh2FM0Yo+zsbB07dkweHh7y8fGxXRIAoIqq9GHE09NTwcHBOnTokPbv32+7nCrH399fzZs3l4dHlTmIBgC4zFT6MCJJtWrVUsuWLZWTk2O7lCrF09NTXl5eHG0CAJSrKhFGpPNvnJ6enrbLAAAAbuLYOwAAsKpUYWTu3LkKCwuTn5+fIiIitGnTpmL7z549W61atVKNGjUUEhKi+++/X7///nupCgYAAFWL22FkyZIlmjx5suLi4rRlyxZ17NhRAwYM0NGjRwvtv2jRIk2ZMkVxcXH66aef9Prrr2vJkiV6+OGHL7l4AABQ+bkdRuLj4zVu3DiNGTNGbdu2VUJCgvz9/TV//vxC+2/cuFE9e/bUiBEjFBYWpv79+2v48OEXPZoCAACqB7fCSHZ2tpKSkhQVFfXHDDw8FBUVpcTExELH9OjRQ0lJSc7wsXfvXn322We66aabilxOVlaWTp486TIBAICqya27aY4fP67c3FwFBga6tAcGBmrHjh2FjhkxYoSOHz+uXr16yRijc+fO6X/+53+KPU0zc+ZMPfroo+6UBgAAKqlyv5tm3bp1evLJJ/XSSy9py5Yt+uijj7RixQrNmDGjyDGxsbHKyMhwTqmpqeVdJgAAsMStIyMNGzaUp6en0tPTXdrT09PVpEmTQsdMmzZNI0eO1F133SVJ6tChgzIzM3X33XfrkUceKfSTPX19feXr6+tOaQAAoJJy68iIj4+PunTpotWrVzvb8vLytHr1akVGRhY65syZMwUCR/6Hk/HldgAAwO1PYJ08ebJGjx6trl27qnv37po9e7YyMzM1ZswYSdKoUaPUrFkzzZw5U5I0aNAgxcfHq3PnzoqIiNDu3bs1bdo0DRo0iE9MBQAA7oeRYcOG6dixY5o+fbrS0tLUqVMnrVy50nlR68GDB12OhEydOlUOh0NTp07V4cOH1ahRIw0aNEhPPPFE2a0FAACotEr13TQxMTGKiYkp9Ll169a5LsDLS3FxcYqLiyvNogAAQBXHd9MAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsMrLdgGovsKmrLhon/2zoiugkpIrq5oLm095rWtJai5MadejNPO9cD4l6VNWynMfazNtpX7688/xtxboU1771OX2uwMUhyMjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKtKFUbmzp2rsLAw+fn5KSIiQps2bSq2/2+//aYJEyYoKChIvr6+uuqqq/TZZ5+VqmAAAFC1eLk7YMmSJZo8ebISEhIUERGh2bNna8CAAdq5c6caN25coH92drZuuOEGNW7cWB988IGaNWumAwcOqG7dumVRPwAAqOTcDiPx8fEaN26cxowZI0lKSEjQihUrNH/+fE2ZMqVA//nz5+vEiRPauHGjvL29JUlhYWGXVjUAAKgy3DpNk52draSkJEVFRf0xAw8PRUVFKTExsdAxH3/8sSIjIzVhwgQFBgaqffv2evLJJ5Wbm1vkcrKysnTy5EmXCQAAVE1uhZHjx48rNzdXgYGBLu2BgYFKS0srdMzevXv1wQcfKDc3V5999pmmTZum5557To8//niRy5k5c6YCAgKcU0hIiDtlAgCASqTc76bJy8tT48aN9eqrr6pLly4aNmyYHnnkESUkJBQ5JjY2VhkZGc4pNTW1vMsEAACWuHXNSMOGDeXp6an09HSX9vT0dDVp0qTQMUFBQfL29panp6ezrU2bNkpLS1N2drZ8fHwKjPH19ZWvr687pQEAgErKrSMjPj4+6tKli1avXu1sy8vL0+rVqxUZGVnomJ49e2r37t3Ky8tztv373/9WUFBQoUEEAABUL26fppk8ebLmzZunN998Uz/99JPuvfdeZWZmOu+uGTVqlGJjY5397733Xp04cUITJ07Uv//9b61YsUJPPvmkJkyYUHZrAQAAKi23b+0dNmyYjh07punTpystLU2dOnXSypUrnRe1Hjx4UB4ef2SckJAQffHFF7r//vsVHh6uZs2aaeLEiXrooYfKbi0AAECl5XYYkaSYmBjFxMQU+ty6desKtEVGRuq7774rzaIAAEAVx3fTAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKzysl1AdRc2ZYXL4/2zoi1VUrgL6ytMYTVX5HqVpEbbSlNjZViv0ijJelXkupfVsgqbT40ymXPpFFbPhb+HJekDV2yz8sGREQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVpQojc+fOVVhYmPz8/BQREaFNmzaVaNzixYvlcDg0ZMiQ0iwWAABUQW6HkSVLlmjy5MmKi4vTli1b1LFjRw0YMEBHjx4tdtz+/fv197//Xb179y51sQAAoOpxO4zEx8dr3LhxGjNmjNq2bauEhAT5+/tr/vz5RY7Jzc3VHXfcoUcffVRXXHHFJRUMAACqFrfCSHZ2tpKSkhQVFfXHDDw8FBUVpcTExCLHPfbYY2rcuLHGjh1bouVkZWXp5MmTLhMAAKia3Aojx48fV25urgIDA13aAwMDlZaWVuiYb775Rq+//rrmzZtX4uXMnDlTAQEBzikkJMSdMgEAQCVSrnfTnDp1SiNHjtS8efPUsGHDEo+LjY1VRkaGc0pNTS3HKgEAgE1e7nRu2LChPD09lZ6e7tKenp6uJk2aFOi/Z88e7d+/X4MGDXK25eXlnV+wl5d27typK6+8ssA4X19f+fr6ulMaAACopNw6MuLj46MuXbpo9erVzra8vDytXr1akZGRBfq3bt1aycnJ2rZtm3MaPHiwrr/+em3bto3TLwAAwL0jI5I0efJkjR49Wl27dlX37t01e/ZsZWZmasyYMZKkUaNGqVmzZpo5c6b8/PzUvn17l/F169aVpALtAACgenI7jAwbNkzHjh3T9OnTlZaWpk6dOmnlypXOi1oPHjwoDw8+2BUAAJSM22FEkmJiYhQTE1Poc+vWrSt27BtvvFGaRQIAgCqKQxgAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAqwgjAADAKsIIAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAq7xsF2Bb2JQVpRq3f1b0RedzYZ+yqqew+ZZ2PcpCeS7b5nqVVmlrLs04tr09Ffl6Xe6/3yX5W1fav5FlNa40f4+rsvztU8Pxu37qYLkYcWQEAABYRhgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYFWpwsjcuXMVFhYmPz8/RUREaNOmTUX2nTdvnnr37q169eqpXr16ioqKKrY/AACoXtwOI0uWLNHkyZMVFxenLVu2qGPHjhowYICOHj1aaP9169Zp+PDhWrt2rRITExUSEqL+/fvr8OHDl1w8AACo/NwOI/Hx8Ro3bpzGjBmjtm3bKiEhQf7+/po/f36h/d955x2NHz9enTp1UuvWrfXaa68pLy9Pq1evvuTiAQBA5edWGMnOzlZSUpKioqL+mIGHh6KiopSYmFiieZw5c0Y5OTmqX79+kX2ysrJ08uRJlwkAAFRNboWR48ePKzc3V4GBgS7tgYGBSktLK9E8HnroITVt2tQl0Fxo5syZCggIcE4hISHulAkAACqRCr2bZtasWVq8eLGWLl0qPz+/IvvFxsYqIyPDOaWmplZglQAAoCJ5udO5YcOG8vT0VHp6ukt7enq6mjRpUuzYZ599VrNmzdJXX32l8PDwYvv6+vrK19fXndIAAEAl5daRER8fH3Xp0sXl4tP8i1EjIyOLHPf0009rxowZWrlypbp27Vr6agEAQJXj1pERSZo8ebJGjx6trl27qnv37po9e7YyMzM1ZswYSdKoUaPUrFkzzZw5U5L01FNPafr06Vq0aJHCwsKc15bUqlVLtWrVKsNVAQAAlZHbYWTYsGE6duyYpk+frrS0NHXq1EkrV650XtR68OBBeXj8ccDl5ZdfVnZ2tv7zP//TZT5xcXH6xz/+cWnVAwCASs/tMCJJMTExiomJKfS5devWuTzev39/aRYBAACqCb6bBgAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgFWEEAABYRRgBAABWEUYAAIBVhBEAAGAVYQQAAFhFGAEAAFYRRgAAgFWEEQAAYBVhBAAAWEUYAQAAVhFGAACAVYQRAABgVanCyNy5cxUWFiY/Pz9FRERo06ZNxfZ///331bp1a/n5+alDhw767LPPSlUsAACoetwOI0uWLNHkyZMVFxenLVu2qGPHjhowYICOHj1aaP+NGzdq+PDhGjt2rLZu3aohQ4ZoyJAhSklJueTiAQBA5ed2GImPj9e4ceM0ZswYtW3bVgkJCfL399f8+fML7T9nzhzdeOONeuCBB9SmTRvNmDFDV199tf75z39ecvEAAKDy83Knc3Z2tpKSkhQbG+ts8/DwUFRUlBITEwsdk5iYqMmTJ7u0DRgwQMuWLStyOVlZWcrKynI+zsjIkCSdPHnSnXJLJC/rTKnGXVhLYfMpSb2lWX5h8y3telSUylgzcKlys39X/p6fm3VGeSbPaj2l+btVkt/T0v6tq8hxZfX+Udp6Ljf565Hr+F0n81fp5EnJK7dMl5O/bYwxxXc0bjh8+LCRZDZu3OjS/sADD5ju3bsXOsbb29ssWrTIpW3u3LmmcePGRS4nLi7OSGJiYmJiYmKqAlNqamqx+cKtIyMVJTY21uVoSl5enk6cOKEGDRrI4XBYrKxyOHnypEJCQpSamqo6derYLqfSYLuVDtut9Nh2pcN2Kx0b280Yo1OnTqlp06bF9nMrjDRs2FCenp5KT093aU9PT1eTJk0KHdOkSRO3+kuSr6+vfH19Xdrq1q3rTqmQVKdOHX5RS4HtVjpst9Jj25UO2610Knq7BQQEXLSPWxew+vj4qEuXLlq9erWzLS8vT6tXr1ZkZGShYyIjI136S9KqVauK7A8AAKoXt0/TTJ48WaNHj1bXrl3VvXt3zZ49W5mZmRozZowkadSoUWrWrJlmzpwpSZo4caL69Omj5557TtHR0Vq8eLF++OEHvfrqq2W7JgAAoFJyO4wMGzZMx44d0/Tp05WWlqZOnTpp5cqVCgwMlCQdPHhQHh5/HHDp0aOHFi1apKlTp+rhhx9Wy5YttWzZMrVv377s1gIufH19FRcXV+BUF4rHdisdtlvpse1Kh+1WOpfzdnMYc7H7bQAAAMoP300DAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijFRCGzZs0KBBg9S0aVM5HI5iv3RQktatWyeHw1FgSktLq5iCLwMzZ85Ut27dVLt2bTVu3FhDhgzRzp07Lzru/fffV+vWreXn56cOHTros88+q4BqLx+l2W5vvPFGgX3Nz8+vgiq+fLz88ssKDw93ftplZGSkPv/882LHVPf9TXJ/u7G/FW7WrFlyOByaNGlSsf0ul32OMFIJZWZmqmPHjpo7d65b43bu3KkjR444p8aNG5dThZef9evXa8KECfruu++0atUq5eTkqH///srMzCxyzMaNGzV8+HCNHTtWW7du1ZAhQzRkyBClpKRUYOV2lWa7Sec/bvrP+9qBAwcqqOLLR3BwsGbNmqWkpCT98MMP6tu3r2655RZt37690P7sb+e5u90k9rcLbd68Wa+88orCw8OL7XdZ7XMl+bZeXL4kmaVLlxbbZ+3atUaS+fXXXyukpsrg6NGjRpJZv359kX1uu+02Ex0d7dIWERFh7rnnnvIu77JVku22YMECExAQUHFFVSL16tUzr732WqHPsb8Vrbjtxv7m6tSpU6Zly5Zm1apVpk+fPmbixIlF9r2c9jmOjFQjnTp1UlBQkG644QZ9++23tsuxKiMjQ5JUv379IvskJiYqKirKpW3AgAFKTEws19ouZyXZbpJ0+vRphYaGKiQk5KL/1VYHubm5Wrx4sTIzM4v8Xi72t4JKst0k9rc/mzBhgqKjowvsS4W5nPY5tz8OHpVPUFCQEhIS1LVrV2VlZem1117Tddddp++//15XX3217fIqXF5eniZNmqSePXsW+7UEaWlpzq85yBcYGFitrrX5s5Jut1atWmn+/PkKDw9XRkaGnn32WfXo0UPbt29XcHBwBVZsX3JysiIjI/X777+rVq1aWrp0qdq2bVtoX/a3P7iz3djf/rB48WJt2bJFmzdvLlH/y2mfI4xUA61atVKrVq2cj3v06KE9e/bo+eef19tvv22xMjsmTJiglJQUffPNN7ZLqVRKut0iIyNd/ovt0aOH2rRpo1deeUUzZswo7zIvK61atdK2bduUkZGhDz74QKNHj9b69euLfGPFee5sN/a381JTUzVx4kStWrWqUl7ASxipprp3714t34xjYmL06aefasOGDRf9r6lJkyZKT093aUtPT1eTJk3Ks8TLkjvb7ULe3t7q3Lmzdu/eXU7VXb58fHz0l7/8RZLUpUsXbd68WXPmzNErr7xSoC/72x/c2W4Xqq77W1JSko4ePepytDs3N1cbNmzQP//5T2VlZcnT09NlzOW0z3HNSDW1bds2BQUF2S6jwhhjFBMTo6VLl2rNmjVq0aLFRcdERkZq9erVLm2rVq0q9tx1VVOa7Xah3NxcJScnV6v9rSh5eXnKysoq9Dn2t6IVt90uVF33t379+ik5OVnbtm1zTl27dtUdd9yhbdu2FQgi0mW2z1X4JbO4ZKdOnTJbt241W7duNZJMfHy82bp1qzlw4IAxxpgpU6aYkSNHOvs///zzZtmyZWbXrl0mOTnZTJw40Xh4eJivvvrK1ipUuHvvvdcEBASYdevWmSNHjjinM2fOOPuMHDnSTJkyxfn422+/NV5eXubZZ581P/30k4mLizPe3t4mOTnZxipYUZrt9uijj5ovvvjC7NmzxyQlJZnbb7/d+Pn5me3bt9tYBWumTJli1q9fb/bt22d+/PFHM2XKFONwOMyXX35pjGF/K4q72439rWgX3k1zOe9zhJFKKP9W3Qun0aNHG2OMGT16tOnTp4+z/1NPPWWuvPJK4+fnZ+rXr2+uu+46s2bNGjvFW1LY9pJkFixY4OzTp08f5zbM995775mrrrrK+Pj4mHbt2pkVK1ZUbOGWlWa7TZo0yTRv3tz4+PiYwMBAc9NNN5ktW7ZUfPGW/fd//7cJDQ01Pj4+plGjRqZfv37ON1Rj2N+K4u52Y38r2oVh5HLe5xzGGFPRR2MAAADycc0IAACwijACAACsIowAAACrCCMAAMAqwggAALCKMAIAAKwijAAAAKsIIwAAwCrCCAAAsIowAgAArCKMAAAAq/4PMUNlQ7CDw08AAAAASUVORK5CYII=\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "WW analyze rows: 1\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - " layer_id name N M alpha rand_num_spikes detX_val status\n", - "0 1 0 672000 150 2.664018 0 167.990234 success" - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
layer_idnameNMalpharand_num_spikesdetX_valstatus
0106720001502.6640180167.990234success
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "summary": "{\n \"name\": \" print(' failed:', type(e)\",\n \"rows\": 1,\n \"fields\": [\n {\n \"column\": \"layer_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 1,\n \"max\": 1,\n \"num_unique_values\": 1,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"name\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"0\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"N\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 672000,\n \"max\": 672000,\n \"num_unique_values\": 1,\n \"samples\": [\n 672000\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"M\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 150,\n \"max\": 150,\n \"num_unique_values\": 1,\n \"samples\": [\n 150\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 2.6640179198766174,\n \"max\": 2.6640179198766174,\n \"num_unique_values\": 1,\n \"samples\": [\n 2.6640179198766174\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"detX_val\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 167.990234375,\n \"max\": 167.990234375,\n \"num_unique_values\": 1,\n \"samples\": [\n 167.990234375\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"status\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"success\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "alpha describe:\n", - "count 1.000000\n", - "mean 2.664018\n", - "std NaN\n", - "min 2.664018\n", - "25% 2.664018\n", - "50% 2.664018\n", - "75% 2.664018\n", - "max 2.664018\n", - "Name: alpha, dtype: float64\n", - "alpha NaN rows: 0\n", - "\n", - "Fallback convert smoke test: multiclass=avg\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "INFO:weightwatcher: __init__: Sequential(\n", - " (0): Linear(in_features=150, out_features=96000, bias=False)\n", - "), None\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - " success, rows= 0 alpha_non_nan= n/a\n", - "\n", - "Fallback convert smoke test: multiclass=per_class\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - " class_id rows alpha_non_nan\n", - "0 0 0 0\n", - "1 1 0 0\n", - "2 2 0 0\n", - "3 3 0 0\n", - "4 4 0 0\n", - "5 5 0 0\n", - "6 6 0 0" - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
class_idrowsalpha_non_nan
0000
1100
2200
3300
4400
5500
6600
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "summary": "{\n \"name\": \" print(' failed:', type(e)\",\n \"rows\": 7,\n \"fields\": [\n {\n \"column\": \"class_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 0,\n \"max\": 6,\n \"num_unique_values\": 7,\n \"samples\": [\n 0,\n 1,\n 5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rows\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha_non_nan\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {} - } + "output_type": "display_data", + "data": { + "text/plain": [ + " layer_id name N M alpha rand_num_spikes detX_val status\n", + "0 1 0 672000 150 2.664018 0 167.990234 success" ], - "source": [ - "# Debug one model end-to-end: train -> convert -> WeightWatcher (plot=True)\n", - "\n", - "DEBUG_TAG = 'U1' # quick presets below\n", - "DEBUG_MULTICLASS = 'stack' # try: 'stack', 'avg', 'per_class'\n", - "DEBUG_RETURN_TYPE = 'torch' # for stack/avg use 'torch'\n", - "DEBUG_PRESETS = {\n", - " 'U1': dict(max_depth=2, eta=0.3, num_boost_round=150, early_stopping_rounds=40, min_child_weight=20, gamma=5, subsample=0.6, colsample_bytree=0.6, reg_lambda=50, reg_alpha=0),\n", - " 'T1': dict(max_depth=8, eta=0.08, num_boost_round=1200, early_stopping_rounds=80, min_child_weight=2, gamma=0, subsample=0.8, colsample_bytree=0.8, reg_lambda=10, reg_alpha=0),\n", - " 'O1': dict(max_depth=12, eta=0.15, num_boost_round=1200, early_stopping_rounds=100, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.5, reg_alpha=0),\n", - "}\n", - "\n", - "assert DEBUG_TAG in DEBUG_PRESETS, f'{DEBUG_TAG} not in DEBUG_PRESETS'\n", - "debug_cfg = dict(DEBUG_PRESETS[DEBUG_TAG])\n", - "print('Debug config:', DEBUG_TAG, debug_cfg)\n", - "\n", - "# 1) Train a single model with deterministic split used above\n", - "dbg_params = dict(\n", - " objective='multi:softprob',\n", - " num_class=n_classes,\n", - " eval_metric=['mlogloss', 'merror'],\n", - " tree_method='hist',\n", - " seed=RNG,\n", - " verbosity=1,\n", - ")\n", - "dbg_params.update(debug_cfg)\n", - "num_boost_round = int(dbg_params.pop('num_boost_round', 200))\n", - "early_stopping_rounds = int(dbg_params.pop('early_stopping_rounds', 50))\n", - "\n", - "dtr = xgb.DMatrix(X_train[idx_tr], label=y_train[idx_tr])\n", - "dva = xgb.DMatrix(X_train[idx_val], label=y_train[idx_val])\n", - "dtest = xgb.DMatrix(X_test, label=y_test)\n", - "\n", - "dbg_evals_result = {}\n", - "dbg_booster = xgb.train(\n", - " params=dbg_params,\n", - " dtrain=dtr,\n", - " num_boost_round=num_boost_round,\n", - " evals=[(dtr, 'tr'), (dva, 'va')],\n", - " early_stopping_rounds=early_stopping_rounds,\n", - " evals_result=dbg_evals_result,\n", - " verbose_eval=False,\n", - ")\n", - "\n", - "best_iteration = int(getattr(dbg_booster, 'best_iteration', num_boost_round - 1))\n", - "print('best_iteration:', best_iteration, 'requested:', num_boost_round)\n", - "\n", - "# quick predictive sanity check\n", - "dbg_proba = dbg_booster.predict(dtest, iteration_range=(0, best_iteration + 1))\n", - "dbg_pred = np.argmax(dbg_proba, axis=1)\n", - "print('debug test_acc:', accuracy_score(y_test, dbg_pred))\n", - "print('debug test_mlogloss:', log_loss(y_test, dbg_proba, labels=np.arange(n_classes)))\n", - "\n", - "# 2) Convert with xgboost2ww and inspect converter output\n", - "print('Converting with multiclass=', DEBUG_MULTICLASS, 'return_type=', DEBUG_RETURN_TYPE)\n", - "try:\n", - " dbg_model_ww = convert(\n", - " dbg_booster,\n", - " X_train,\n", - " y_train,\n", - " multiclass=DEBUG_MULTICLASS,\n", - " return_type=DEBUG_RETURN_TYPE,\n", - " )\n", - " print('convert() success. type =', type(dbg_model_ww))\n", - "except Exception as e:\n", - " print('convert() failed:', type(e).__name__, e)\n", - " raise\n", - "\n", - "# Optional structural introspection to catch malformed converted layers\n", - "try:\n", - " if hasattr(dbg_model_ww, 'modules'):\n", - " layers = [m for m in dbg_model_ww.modules()]\n", - " print('torch module count:', len(layers))\n", - " linear_like = [m for m in layers if hasattr(m, 'weight')]\n", - " print('layers with weight attr:', len(linear_like))\n", - " for i, lyr in enumerate(linear_like[:10]):\n", - " w = getattr(lyr, 'weight', None)\n", - " if w is not None:\n", - " print(f' layer[{i}] weight shape:', tuple(w.shape))\n", - "except Exception as e:\n", - " print('Model structure introspection warning:', type(e).__name__, e)\n", - "\n", - "# 3) WeightWatcher with plot=True and extra debug flags\n", - "try:\n", - " dbg_watcher = ww.WeightWatcher(model=dbg_model_ww, log_level='INFO')\n", - " dbg_details = dbg_watcher.analyze(\n", - " randomize=True,\n", - " min_evals=10,\n", - " max_evals=200,\n", - " mp_fit=False,\n", - " plot=True,\n", - " savefig=False,\n", - " detX=True,\n", - " max_N=WW_MAX_N,\n", - " )\n", - " dbg_details = pd.DataFrame(dbg_details)\n", - " print('WW analyze rows:', len(dbg_details))\n", - " display_cols = [c for c in ['layer_id', 'name', 'N', 'M', 'alpha', 'rand_num_spikes', 'detX_val', 'status'] if c in dbg_details.columns]\n", - " display(dbg_details[display_cols] if display_cols else dbg_details.head())\n", - "\n", - " if 'alpha' in dbg_details:\n", - " print('alpha describe:')\n", - " print(dbg_details['alpha'].describe(include='all'))\n", - " print('alpha NaN rows:', int(dbg_details['alpha'].isna().sum()))\n", - "except Exception as e:\n", - " print('WeightWatcher analyze failed:', type(e).__name__, e)\n", - " raise\n", - "\n", - "# 4) If stack fails, quick fallback checks for convert-specific behavior\n", - "if DEBUG_MULTICLASS == 'stack':\n", - " print('\\nFallback convert smoke test: multiclass=avg')\n", - " try:\n", - " alt_model = convert(dbg_booster, X_train, y_train, multiclass='avg', return_type='torch')\n", - " alt_details = pd.DataFrame(\n", - " ww.WeightWatcher(model=alt_model, log_level='ERROR').analyze(\n", - " randomize=True,\n", - " min_evals=10,\n", - " max_evals=120,\n", - " mp_fit=False,\n", - " plot=True,\n", - " savefig=False,\n", - " max_N=WW_MAX_N,\n", - " )\n", - " )\n", - " print(' success, rows=', len(alt_details), 'alpha_non_nan=', int(alt_details['alpha'].notna().sum()) if 'alpha' in alt_details else 'n/a')\n", - " except Exception as e:\n", - " print(' failed:', type(e).__name__, e)\n", - "\n", - " print('\\nFallback convert smoke test: multiclass=per_class')\n", - " try:\n", - " alt_models = convert(dbg_booster, X_train, y_train, multiclass='per_class', return_type='numpy')\n", - " per_class_rows = []\n", - " for class_id, Wk in sorted(alt_models.items()):\n", - " class_model = to_linear_layer(Wk)\n", - " import torch\n", - " class_seq = torch.nn.Sequential(class_model)\n", - " class_details = pd.DataFrame(\n", - " ww.WeightWatcher(model=class_seq, log_level='ERROR').analyze(\n", - " randomize=True,\n", - " min_evals=10,\n", - " max_evals=120,\n", - " mp_fit=False,\n", - " plot=False,\n", - " savefig=False,\n", - " max_N=WW_MAX_N,\n", - " )\n", - " )\n", - " per_class_rows.append({\n", - " 'class_id': class_id,\n", - " 'rows': len(class_details),\n", - " 'alpha_non_nan': int(class_details['alpha'].notna().sum()) if 'alpha' in class_details else 0,\n", - " })\n", - " display(pd.DataFrame(per_class_rows))\n", - " except Exception as e:\n", - " print(' failed:', type(e).__name__, e)\n" + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
layer_idnameNMalpharand_num_spikesdetX_valstatus
0106720001502.6640180167.990234success
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" ], - "id": "sY-Hq3GkX3CQ" + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" print(' failed:', type(e)\",\n \"rows\": 1,\n \"fields\": [\n {\n \"column\": \"layer_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 1,\n \"max\": 1,\n \"num_unique_values\": 1,\n \"samples\": [\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"name\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"0\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"N\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 672000,\n \"max\": 672000,\n \"num_unique_values\": 1,\n \"samples\": [\n 672000\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"M\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 150,\n \"max\": 150,\n \"num_unique_values\": 1,\n \"samples\": [\n 150\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 2.6640179198766174,\n \"max\": 2.6640179198766174,\n \"num_unique_values\": 1,\n \"samples\": [\n 2.6640179198766174\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"detX_val\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": 167.990234375,\n \"max\": 167.990234375,\n \"num_unique_values\": 1,\n \"samples\": [\n 167.990234375\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"status\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"success\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} }, { - "cell_type": "markdown", - "metadata": { - "id": "6qrYqzUcX3CQ" - }, - "source": [ - "## Best model section (strong tuned candidate)\n" - ], - "id": "6qrYqzUcX3CQ" + "output_type": "stream", + "name": "stdout", + "text": [ + "alpha describe:\n", + "count 1.000000\n", + "mean 2.664018\n", + "std NaN\n", + "min 2.664018\n", + "25% 2.664018\n", + "50% 2.664018\n", + "75% 2.664018\n", + "max 2.664018\n", + "Name: alpha, dtype: float64\n", + "alpha NaN rows: 0\n", + "\n", + "Fallback convert smoke test: multiclass=avg\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "zs6oVWy6X3CQ", - "outputId": "81fd1c5b-aa1b-4553-a57f-132f006aa0ee", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 148 - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[BEST] requested=6000 best_iteration=1304 train_acc=0.9855 test_acc=0.9271 alpha=1.9214604016252392\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - " tag num_boost_round_requested best_iteration train_acc test_acc \\\n", - "0 BEST 6000 1304 0.985479 0.927125 \n", - "\n", - " train_bal_acc test_bal_acc test_macro_f1 train_mlogloss test_mlogloss \\\n", - "0 0.971639 0.870948 0.890698 0.063135 0.192197 \n", - "\n", - " ... hp_max_depth hp_eta hp_num_boost_round hp_early_stopping_rounds \\\n", - "0 ... 10 0.05 6000 150 \n", - "\n", - " hp_min_child_weight hp_gamma hp_subsample hp_colsample_bytree \\\n", - "0 1 0 0.9 0.9 \n", - "\n", - " hp_reg_lambda hp_reg_alpha \n", - "0 5 0.5 \n", - "\n", - "[1 rows x 25 columns]" - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tagnum_boost_round_requestedbest_iterationtrain_acctest_acctrain_bal_acctest_bal_acctest_macro_f1train_mloglosstest_mlogloss...hp_max_depthhp_etahp_num_boost_roundhp_early_stopping_roundshp_min_child_weighthp_gammahp_subsamplehp_colsample_bytreehp_reg_lambdahp_reg_alpha
0BEST600013040.9854790.9271250.9716390.8709480.8906980.0631350.192197...100.056000150100.90.950.5
\n", - "

1 rows × 25 columns

\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe" - } - }, - "metadata": {}, - "execution_count": 9 - } - ], - "source": [ - "best_cfg = dict(\n", - " max_depth=10,\n", - " eta=0.05,\n", - " num_boost_round=6000,\n", - " early_stopping_rounds=150,\n", - " min_child_weight=1,\n", - " gamma=0,\n", - " subsample=0.9,\n", - " colsample_bytree=0.9,\n", - " reg_lambda=5,\n", - " reg_alpha=0.5,\n", - ")\n", - "best_row, best_booster = fit_eval_config('BEST', best_cfg, t_points=T_POINTS_BEST, run_detx=True)\n", - "pd.DataFrame([best_row])\n" - ], - "id": "zs6oVWy6X3CQ" + "output_type": "stream", + "name": "stderr", + "text": [ + "INFO:weightwatcher: __init__: Sequential(\n", + " (0): Linear(in_features=150, out_features=96000, bias=False)\n", + "), None\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "z1qqZHkEX3CQ" - }, - "source": [ - "## Stage A: regime sweep seeds (includes required concrete configs)\n" - ], - "id": "z1qqZHkEX3CQ" + "output_type": "stream", + "name": "stdout", + "text": [ + " success, rows= 0 alpha_non_nan= n/a\n", + "\n", + "Fallback convert smoke test: multiclass=per_class\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "OzftMnpOX3CQ", - "outputId": "0f5af0b5-1f55-4ffe-865c-0bbda735394d", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 542 - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[U1] requested=150 best_iteration=147 train_acc=0.7519 test_acc=0.7439 alpha=2.6640179198766174\n", - "[U2] requested=300 best_iteration=296 train_acc=0.7946 test_acc=0.7812 alpha=2.717651438580225\n", - "[T1] requested=4000 best_iteration=1751 train_acc=0.9842 test_acc=0.9214 alpha=1.8277739874575372\n", - "[T2] requested=6000 best_iteration=1304 train_acc=0.9855 test_acc=0.9271 alpha=1.9214604016252392\n", - "[O1] requested=8000 best_iteration=347 train_acc=0.9867 test_acc=0.9321 alpha=2.4157331166759253\n", - "[O2] requested=6000 best_iteration=271 train_acc=0.9862 test_acc=0.9306 alpha=2.389654620960565\n", - "[U3] requested=250 best_iteration=237 train_acc=0.7537 test_acc=0.7481 alpha=1.9277020042007522\n", - "[T3] requested=3000 best_iteration=1869 train_acc=0.9001 test_acc=0.8687 alpha=1.670707759967076\n", - "[O3] requested=7000 best_iteration=374 train_acc=0.9864 test_acc=0.9317 alpha=1.7089374609846892\n", - "Saved: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_hyperparameter_sweep_results.csv\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - " tag test_acc train_acc alpha rand_num_spikes best_iteration \\\n", - "0 O1 0.932083 0.986667 2.415733 0.0 347 \n", - "1 O3 0.931750 0.986354 1.708937 3.0 374 \n", - "2 O2 0.930583 0.986219 2.389655 34.0 271 \n", - "3 BEST 0.927125 0.985479 1.921460 0.0 1304 \n", - "4 T2 0.927125 0.985479 1.921460 0.0 1304 \n", - "5 T1 0.921375 0.984229 1.827774 0.0 1751 \n", - "6 T3 0.868708 0.900073 1.670708 0.0 1869 \n", - "7 U2 0.781167 0.794625 2.717651 0.0 296 \n", - "8 U3 0.748125 0.753708 1.927702 0.0 237 \n", - "9 U1 0.743917 0.751885 2.664018 0.0 147 \n", - "\n", - " num_boost_round_requested ww_note \n", - "0 8000 \n", - "1 7000 \n", - "2 6000 \n", - "3 6000 \n", - "4 6000 \n", - "5 4000 \n", - "6 3000 \n", - "7 300 \n", - "8 250 \n", - "9 150 " - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tagtest_acctrain_accalpharand_num_spikesbest_iterationnum_boost_round_requestedww_note
0O10.9320830.9866672.4157330.03478000
1O30.9317500.9863541.7089373.03747000
2O20.9305830.9862192.38965534.02716000
3BEST0.9271250.9854791.9214600.013046000
4T20.9271250.9854791.9214600.013046000
5T10.9213750.9842291.8277740.017514000
6T30.8687080.9000731.6707080.018693000
7U20.7811670.7946252.7176510.0296300
8U30.7481250.7537081.9277020.0237250
9U10.7439170.7518852.6640180.0147150
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "summary": "{\n \"name\": \"results[['tag','test_acc','train_acc','alpha','rand_num_spikes','best_iteration','num_boost_round_requested','ww_note']]\",\n \"rows\": 10,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"U3\",\n \"O3\",\n \"T1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"test_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0810575356975784,\n \"min\": 0.7439166666666667,\n \"max\": 0.9320833333333334,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.748125,\n 0.93175,\n 0.8687083333333333\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"train_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.10394271540003114,\n \"min\": 0.7518854166666666,\n \"max\": 0.9866666666666667,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.7537083333333333,\n 0.9863541666666666,\n 0.9000729166666667\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.39232059688552195,\n \"min\": 1.670707759967076,\n \"max\": 2.717651438580225,\n \"num_unique_values\": 9,\n \"samples\": [\n 1.9277020042007522,\n 1.7089374609846892,\n 1.670707759967076\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 10.687999500997995,\n \"min\": 0.0,\n \"max\": 34.0,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.0,\n 3.0,\n 34.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"best_iteration\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 684,\n \"min\": 147,\n \"max\": 1869,\n \"num_unique_values\": 9,\n \"samples\": [\n 237,\n 374,\n 1869\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"num_boost_round_requested\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2991,\n \"min\": 150,\n \"max\": 8000,\n \"num_unique_values\": 8,\n \"samples\": [\n 7000,\n 300,\n 8000\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ww_note\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {}, - "execution_count": 10 - } + "output_type": "display_data", + "data": { + "text/plain": [ + " class_id rows alpha_non_nan\n", + "0 0 0 0\n", + "1 1 0 0\n", + "2 2 0 0\n", + "3 3 0 0\n", + "4 4 0 0\n", + "5 5 0 0\n", + "6 6 0 0" ], - "source": [ - "seed_configs = {\n", - " # Underfit\n", - " 'U1': dict(max_depth=2, eta=0.3, num_boost_round=150, early_stopping_rounds=40, min_child_weight=20, gamma=5, subsample=0.6, colsample_bytree=0.6, reg_lambda=50, reg_alpha=0),\n", - " 'U2': dict(max_depth=3, eta=0.2, num_boost_round=300, early_stopping_rounds=60, min_child_weight=15, gamma=2, subsample=0.7, colsample_bytree=0.7, reg_lambda=30, reg_alpha=0),\n", - " # Tuned\n", - " 'T1': dict(max_depth=8, eta=0.08, num_boost_round=4000, early_stopping_rounds=100, min_child_weight=2, gamma=0, subsample=0.8, colsample_bytree=0.8, reg_lambda=10, reg_alpha=0),\n", - " 'T2': dict(max_depth=10, eta=0.05, num_boost_round=6000, early_stopping_rounds=150, min_child_weight=1, gamma=0, subsample=0.9, colsample_bytree=0.9, reg_lambda=5, reg_alpha=0.5),\n", - " # Overfit-leaning\n", - " 'O1': dict(max_depth=14, eta=0.15, num_boost_round=8000, early_stopping_rounds=200, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.5, reg_alpha=0),\n", - " 'O2': dict(max_depth=12, eta=0.2, num_boost_round=6000, early_stopping_rounds=150, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0, reg_alpha=0),\n", - " # Additional coarse points\n", - " 'U3': dict(max_depth=4, eta=0.2, num_boost_round=250, early_stopping_rounds=50, min_child_weight=25, gamma=8, subsample=0.5, colsample_bytree=0.5, reg_lambda=80, reg_alpha=1),\n", - " 'T3': dict(max_depth=6, eta=0.1, num_boost_round=3000, early_stopping_rounds=100, min_child_weight=3, gamma=1, subsample=0.8, colsample_bytree=0.9, reg_lambda=12, reg_alpha=0.5),\n", - " 'O3': dict(max_depth=14, eta=0.2, num_boost_round=7000, early_stopping_rounds=200, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.1, reg_alpha=0),\n", - "}\n", - "\n", - "rows = [best_row]\n", - "boosters = {'BEST': best_booster}\n", - "for tag, cfg in seed_configs.items():\n", - " row, booster = fit_eval_config(tag, cfg, t_points=T_POINTS_SWEEP, run_detx=(tag in {'U1','T2','O1'}))\n", - " rows.append(row)\n", - " boosters[tag] = booster\n", - "\n", - "results = pd.DataFrame(rows).sort_values('test_acc', ascending=False).reset_index(drop=True)\n", - "results.to_csv(CHECKPOINT_RESULTS_CSV, index=False)\n", - "print('Saved:', CHECKPOINT_RESULTS_CSV)\n", - "results[['tag','test_acc','train_acc','alpha','rand_num_spikes','best_iteration','num_boost_round_requested','ww_note']]\n" + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
class_idrowsalpha_non_nan
0000
1100
2200
3300
4400
5500
6600
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" ], - "id": "OzftMnpOX3CQ" + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \" print(' failed:', type(e)\",\n \"rows\": 7,\n \"fields\": [\n {\n \"column\": \"class_id\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 0,\n \"max\": 6,\n \"num_unique_values\": 7,\n \"samples\": [\n 0,\n 1,\n 5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rows\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha_non_nan\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {} }, { - "cell_type": "markdown", - "metadata": { - "id": "_xdpH5YaX3CQ" - }, - "source": [ - "## Stage B: local refinement around top configs\n" - ], - "id": "_xdpH5YaX3CQ" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {} + } + ], + "source": [ + "# Debug one model end-to-end: train -> convert -> WeightWatcher (plot=True)\n", + "\n", + "DEBUG_TAG = 'U1' # quick presets below\n", + "DEBUG_MULTICLASS = 'stack' # try: 'stack', 'avg', 'per_class'\n", + "DEBUG_RETURN_TYPE = 'torch' # for stack/avg use 'torch'\n", + "DEBUG_PRESETS = {\n", + " 'U1': dict(max_depth=2, eta=0.3, num_boost_round=150, early_stopping_rounds=40, min_child_weight=20, gamma=5, subsample=0.6, colsample_bytree=0.6, reg_lambda=50, reg_alpha=0),\n", + " 'T1': dict(max_depth=8, eta=0.08, num_boost_round=1200, early_stopping_rounds=80, min_child_weight=2, gamma=0, subsample=0.8, colsample_bytree=0.8, reg_lambda=10, reg_alpha=0),\n", + " 'O1': dict(max_depth=12, eta=0.15, num_boost_round=1200, early_stopping_rounds=100, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.5, reg_alpha=0),\n", + "}\n", + "\n", + "assert DEBUG_TAG in DEBUG_PRESETS, f'{DEBUG_TAG} not in DEBUG_PRESETS'\n", + "debug_cfg = dict(DEBUG_PRESETS[DEBUG_TAG])\n", + "print('Debug config:', DEBUG_TAG, debug_cfg)\n", + "\n", + "# 1) Train a single model with deterministic split used above\n", + "dbg_params = dict(\n", + " objective='multi:softprob',\n", + " num_class=n_classes,\n", + " eval_metric=['mlogloss', 'merror'],\n", + " tree_method='hist',\n", + " seed=RNG,\n", + " verbosity=1,\n", + ")\n", + "dbg_params.update(debug_cfg)\n", + "num_boost_round = int(dbg_params.pop('num_boost_round', 200))\n", + "early_stopping_rounds = int(dbg_params.pop('early_stopping_rounds', 50))\n", + "\n", + "dtr = xgb.DMatrix(X_train[idx_tr], label=y_train[idx_tr])\n", + "dva = xgb.DMatrix(X_train[idx_val], label=y_train[idx_val])\n", + "dtest = xgb.DMatrix(X_test, label=y_test)\n", + "\n", + "dbg_evals_result = {}\n", + "dbg_booster = xgb.train(\n", + " params=dbg_params,\n", + " dtrain=dtr,\n", + " num_boost_round=num_boost_round,\n", + " evals=[(dtr, 'tr'), (dva, 'va')],\n", + " early_stopping_rounds=early_stopping_rounds,\n", + " evals_result=dbg_evals_result,\n", + " verbose_eval=False,\n", + ")\n", + "\n", + "best_iteration = int(getattr(dbg_booster, 'best_iteration', num_boost_round - 1))\n", + "print('best_iteration:', best_iteration, 'requested:', num_boost_round)\n", + "\n", + "# quick predictive sanity check\n", + "dbg_proba = dbg_booster.predict(dtest, iteration_range=(0, best_iteration + 1))\n", + "dbg_pred = np.argmax(dbg_proba, axis=1)\n", + "print('debug test_acc:', accuracy_score(y_test, dbg_pred))\n", + "print('debug test_mlogloss:', log_loss(y_test, dbg_proba, labels=np.arange(n_classes)))\n", + "\n", + "# 2) Convert with xgboost2ww and inspect converter output\n", + "print('Converting with multiclass=', DEBUG_MULTICLASS, 'return_type=', DEBUG_RETURN_TYPE)\n", + "try:\n", + " dbg_model_ww = convert(\n", + " dbg_booster,\n", + " X_train,\n", + " y_train,\n", + " multiclass=DEBUG_MULTICLASS,\n", + " return_type=DEBUG_RETURN_TYPE,\n", + " )\n", + " print('convert() success. type =', type(dbg_model_ww))\n", + "except Exception as e:\n", + " print('convert() failed:', type(e).__name__, e)\n", + " raise\n", + "\n", + "# Optional structural introspection to catch malformed converted layers\n", + "try:\n", + " if hasattr(dbg_model_ww, 'modules'):\n", + " layers = [m for m in dbg_model_ww.modules()]\n", + " print('torch module count:', len(layers))\n", + " linear_like = [m for m in layers if hasattr(m, 'weight')]\n", + " print('layers with weight attr:', len(linear_like))\n", + " for i, lyr in enumerate(linear_like[:10]):\n", + " w = getattr(lyr, 'weight', None)\n", + " if w is not None:\n", + " print(f' layer[{i}] weight shape:', tuple(w.shape))\n", + "except Exception as e:\n", + " print('Model structure introspection warning:', type(e).__name__, e)\n", + "\n", + "# 3) WeightWatcher with plot=True and extra debug flags\n", + "try:\n", + " dbg_watcher = ww.WeightWatcher(model=dbg_model_ww, log_level='INFO')\n", + " dbg_details = dbg_watcher.analyze(\n", + " randomize=True,\n", + " min_evals=10,\n", + " max_evals=200,\n", + " mp_fit=False,\n", + " plot=True,\n", + " savefig=False,\n", + " detX=True,\n", + " max_N=WW_MAX_N,\n", + " )\n", + " dbg_details = pd.DataFrame(dbg_details)\n", + " print('WW analyze rows:', len(dbg_details))\n", + " display_cols = [c for c in ['layer_id', 'name', 'N', 'M', 'alpha', 'rand_num_spikes', 'detX_val', 'status'] if c in dbg_details.columns]\n", + " display(dbg_details[display_cols] if display_cols else dbg_details.head())\n", + "\n", + " if 'alpha' in dbg_details:\n", + " print('alpha describe:')\n", + " print(dbg_details['alpha'].describe(include='all'))\n", + " print('alpha NaN rows:', int(dbg_details['alpha'].isna().sum()))\n", + "except Exception as e:\n", + " print('WeightWatcher analyze failed:', type(e).__name__, e)\n", + " raise\n", + "\n", + "# 4) If stack fails, quick fallback checks for convert-specific behavior\n", + "if DEBUG_MULTICLASS == 'stack':\n", + " print('\\nFallback convert smoke test: multiclass=avg')\n", + " try:\n", + " alt_model = convert(dbg_booster, X_train, y_train, multiclass='avg', return_type='torch')\n", + " alt_details = pd.DataFrame(\n", + " ww.WeightWatcher(model=alt_model, log_level='ERROR').analyze(\n", + " randomize=True,\n", + " min_evals=10,\n", + " max_evals=120,\n", + " mp_fit=False,\n", + " plot=True,\n", + " savefig=False,\n", + " max_N=WW_MAX_N,\n", + " )\n", + " )\n", + " print(' success, rows=', len(alt_details), 'alpha_non_nan=', int(alt_details['alpha'].notna().sum()) if 'alpha' in alt_details else 'n/a')\n", + " except Exception as e:\n", + " print(' failed:', type(e).__name__, e)\n", + "\n", + " print('\\nFallback convert smoke test: multiclass=per_class')\n", + " try:\n", + " alt_models = convert(dbg_booster, X_train, y_train, multiclass='per_class', return_type='numpy')\n", + " per_class_rows = []\n", + " for class_id, Wk in sorted(alt_models.items()):\n", + " class_model = to_linear_layer(Wk)\n", + " import torch\n", + " class_seq = torch.nn.Sequential(class_model)\n", + " class_details = pd.DataFrame(\n", + " ww.WeightWatcher(model=class_seq, log_level='ERROR').analyze(\n", + " randomize=True,\n", + " min_evals=10,\n", + " max_evals=120,\n", + " mp_fit=False,\n", + " plot=False,\n", + " savefig=False,\n", + " max_N=WW_MAX_N,\n", + " )\n", + " )\n", + " per_class_rows.append({\n", + " 'class_id': class_id,\n", + " 'rows': len(class_details),\n", + " 'alpha_non_nan': int(class_details['alpha'].notna().sum()) if 'alpha' in class_details else 0,\n", + " })\n", + " display(pd.DataFrame(per_class_rows))\n", + " except Exception as e:\n", + " print(' failed:', type(e).__name__, e)\n" + ], + "id": "sY-Hq3GkX3CQ" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6qrYqzUcX3CQ" + }, + "source": [ + "## Best model section (strong tuned candidate)\n" + ], + "id": "6qrYqzUcX3CQ" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zs6oVWy6X3CQ", + "outputId": "81fd1c5b-aa1b-4553-a57f-132f006aa0ee", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 148 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[BEST] requested=6000 best_iteration=1304 train_acc=0.9855 test_acc=0.9271 alpha=1.9214604016252392\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "5_nzDiSXX3CQ", - "outputId": "43ac6a08-20ba-4477-ce2f-81f305a84303", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 676 - } - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[R11_O1] requested=8000 best_iteration=430 train_acc=0.9867 test_acc=0.9326 alpha=1.7410022503807587\n", - "[R12_O1] requested=8000 best_iteration=414 train_acc=0.9866 test_acc=0.9308 alpha=1.6986392768578473\n", - "[R21_O3] requested=7000 best_iteration=284 train_acc=0.9863 test_acc=0.9313 alpha=2.4434917904587015\n", - "[R22_O3] requested=7000 best_iteration=322 train_acc=0.9865 test_acc=0.9314 alpha=2.4597379193177824\n", - "[R31_O2] requested=6000 best_iteration=324 train_acc=0.9861 test_acc=0.9307 alpha=2.603029458818721\n", - "[R32_O2] requested=6000 best_iteration=271 train_acc=0.9862 test_acc=0.9306 alpha=2.389654620960565\n", - "test accuracy spread: 18.87 percentage points\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - " tag test_acc train_acc alpha rand_num_spikes multiclass_mode \\\n", - "0 R11_O1 0.932625 0.986656 1.741002 0.0 stack \n", - "1 O1 0.932083 0.986667 2.415733 0.0 stack \n", - "2 O3 0.931750 0.986354 1.708937 3.0 stack \n", - "3 R22_O3 0.931375 0.986531 2.459738 9.0 stack \n", - "4 R21_O3 0.931292 0.986302 2.443492 54.0 stack \n", - "5 R12_O1 0.930792 0.986615 1.698639 0.0 stack \n", - "6 R31_O2 0.930667 0.986146 2.603029 43.0 stack \n", - "7 O2 0.930583 0.986219 2.389655 34.0 stack \n", - "8 R32_O2 0.930583 0.986219 2.389655 37.0 stack \n", - "9 BEST 0.927125 0.985479 1.921460 0.0 stack \n", - "10 T2 0.927125 0.985479 1.921460 0.0 stack \n", - "11 T1 0.921375 0.984229 1.827774 0.0 stack \n", - "12 T3 0.868708 0.900073 1.670708 0.0 stack \n", - "13 U2 0.781167 0.794625 2.717651 0.0 stack \n", - "14 U3 0.748125 0.753708 1.927702 0.0 stack \n", - "15 U1 0.743917 0.751885 2.664018 0.0 stack \n", - "\n", - " ww_note \n", - "0 \n", - "1 \n", - "2 \n", - "3 \n", - "4 \n", - "5 \n", - "6 \n", - "7 \n", - "8 \n", - "9 \n", - "10 \n", - "11 \n", - "12 \n", - "13 \n", - "14 \n", - "15 " - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tagtest_acctrain_accalpharand_num_spikesmulticlass_modeww_note
0R11_O10.9326250.9866561.7410020.0stack
1O10.9320830.9866672.4157330.0stack
2O30.9317500.9863541.7089373.0stack
3R22_O30.9313750.9865312.4597389.0stack
4R21_O30.9312920.9863022.44349254.0stack
5R12_O10.9307920.9866151.6986390.0stack
6R31_O20.9306670.9861462.60302943.0stack
7O20.9305830.9862192.38965534.0stack
8R32_O20.9305830.9862192.38965537.0stack
9BEST0.9271250.9854791.9214600.0stack
10T20.9271250.9854791.9214600.0stack
11T10.9213750.9842291.8277740.0stack
12T30.8687080.9000731.6707080.0stack
13U20.7811670.7946252.7176510.0stack
14U30.7481250.7537081.9277020.0stack
15U10.7439170.7518852.6640180.0stack
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "summary": "{\n \"name\": \"results[['tag','test_acc','train_acc','alpha','rand_num_spikes','multiclass_mode','ww_note']]\",\n \"rows\": 16,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 16,\n \"samples\": [\n \"R11_O1\",\n \"O1\",\n \"R12_O1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"test_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06959295586950659,\n \"min\": 0.7439166666666667,\n \"max\": 0.932625,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.921375,\n 0.7811666666666667,\n 0.932625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"train_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08880570824916605,\n \"min\": 0.7518854166666666,\n \"max\": 0.9866666666666667,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.9842291666666667,\n 0.794625,\n 0.98665625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.38397677093322224,\n \"min\": 1.670707759967076,\n \"max\": 2.717651438580225,\n \"num_unique_values\": 14,\n \"samples\": [\n 1.8277739874575372,\n 2.717651438580225,\n 1.7410022503807587\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 18.894443627691185,\n \"min\": 0.0,\n \"max\": 54.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.0,\n 3.0,\n 34.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"multiclass_mode\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"stack\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ww_note\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {}, - "execution_count": 11 - } + "output_type": "execute_result", + "data": { + "text/plain": [ + " tag num_boost_round_requested best_iteration train_acc test_acc \\\n", + "0 BEST 6000 1304 0.985479 0.927125 \n", + "\n", + " train_bal_acc test_bal_acc test_macro_f1 train_mlogloss test_mlogloss \\\n", + "0 0.971639 0.870948 0.890698 0.063135 0.192197 \n", + "\n", + " ... hp_max_depth hp_eta hp_num_boost_round hp_early_stopping_rounds \\\n", + "0 ... 10 0.05 6000 150 \n", + "\n", + " hp_min_child_weight hp_gamma hp_subsample hp_colsample_bytree \\\n", + "0 1 0 0.9 0.9 \n", + "\n", + " hp_reg_lambda hp_reg_alpha \n", + "0 5 0.5 \n", + "\n", + "[1 rows x 25 columns]" ], - "source": [ - "top_tags = results.head(3)['tag'].tolist()\n", - "refine_rows = []\n", - "for i, tag in enumerate(top_tags, 1):\n", - " base = {k.replace('hp_',''): results.loc[results['tag']==tag, k].iloc[0] for k in results.columns if k.startswith('hp_') and pd.notna(results.loc[results['tag']==tag, k].iloc[0])}\n", - " for j, (eta_mul, lam_mul, ss_delta) in enumerate([(0.9, 1.2, -0.05), (1.1, 0.8, 0.05)], 1):\n", - " cfg = dict(base)\n", - " cfg['eta'] = max(0.03, min(0.2, float(cfg['eta']) * eta_mul))\n", - " cfg['reg_lambda'] = max(0.0, float(cfg.get('reg_lambda', 1)) * lam_mul)\n", - " cfg['subsample'] = max(0.6, min(1.0, float(cfg.get('subsample', 0.9)) + ss_delta))\n", - " cfg['colsample_bytree'] = max(0.6, min(1.0, float(cfg.get('colsample_bytree', 0.9)) + ss_delta))\n", - " cfg['min_child_weight'] = max(1.0, float(cfg.get('min_child_weight', 1)))\n", - " rtag = f'R{i}{j}_{tag}'\n", - " row, booster = fit_eval_config(rtag, cfg, t_points=T_POINTS_SWEEP)\n", - " refine_rows.append(row)\n", - " boosters[rtag] = booster\n", - "\n", - "if refine_rows:\n", - " results = pd.concat([results, pd.DataFrame(refine_rows)], ignore_index=True)\n", - "\n", - "acc_span = 100 * (results['test_acc'].max() - results['test_acc'].min())\n", - "print(f'test accuracy spread: {acc_span:.2f} percentage points')\n", - "if acc_span < 8.0:\n", - " print('Spread too narrow; adding extreme guardrail configs...')\n", - " extreme_cfgs = {\n", - " 'U_extreme': dict(max_depth=2, eta=0.3, num_boost_round=80, early_stopping_rounds=20, min_child_weight=30, gamma=10, subsample=0.5, colsample_bytree=0.5, reg_lambda=100, reg_alpha=2),\n", - " 'O_extreme': dict(max_depth=14, eta=0.2, num_boost_round=8000, early_stopping_rounds=300, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.0, reg_alpha=0),\n", - " }\n", - " extra = []\n", - " for tag, cfg in extreme_cfgs.items():\n", - " row, booster = fit_eval_config(tag, cfg, t_points=T_POINTS_SWEEP)\n", - " boosters[tag] = booster\n", - " extra.append(row)\n", - " results = pd.concat([results, pd.DataFrame(extra)], ignore_index=True)\n", - "\n", - "results = results.sort_values('test_acc', ascending=False).reset_index(drop=True)\n", - "results.to_csv(CHECKPOINT_RESULTS_CSV, index=False)\n", - "results[['tag','test_acc','train_acc','alpha','rand_num_spikes','multiclass_mode','ww_note']].head(20)\n" + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tagnum_boost_round_requestedbest_iterationtrain_acctest_acctrain_bal_acctest_bal_acctest_macro_f1train_mloglosstest_mlogloss...hp_max_depthhp_etahp_num_boost_roundhp_early_stopping_roundshp_min_child_weighthp_gammahp_subsamplehp_colsample_bytreehp_reg_lambdahp_reg_alpha
0BEST600013040.9854790.9271250.9716390.8709480.8906980.0631350.192197...100.056000150100.90.950.5
\n", + "

1 rows × 25 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" ], - "id": "5_nzDiSXX3CQ" - }, + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe" + } + }, + "metadata": {}, + "execution_count": 9 + } + ], + "source": [ + "best_cfg = dict(\n", + " max_depth=10,\n", + " eta=0.05,\n", + " num_boost_round=6000,\n", + " early_stopping_rounds=150,\n", + " min_child_weight=1,\n", + " gamma=0,\n", + " subsample=0.9,\n", + " colsample_bytree=0.9,\n", + " reg_lambda=5,\n", + " reg_alpha=0.5,\n", + ")\n", + "best_row, best_booster = fit_eval_config('BEST', best_cfg, t_points=T_POINTS_BEST, run_detx=True)\n", + "pd.DataFrame([best_row])\n" + ], + "id": "zs6oVWy6X3CQ" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "z1qqZHkEX3CQ" + }, + "source": [ + "## Stage A: regime sweep seeds (includes required concrete configs)\n" + ], + "id": "z1qqZHkEX3CQ" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OzftMnpOX3CQ", + "outputId": "0f5af0b5-1f55-4ffe-865c-0bbda735394d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 542 + } + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "HqM6VUPNX3CQ" - }, - "source": [ - "## Optional per-class (`multiclass='per_class'`) analysis for representative configs\n" - ], - "id": "HqM6VUPNX3CQ" + "output_type": "stream", + "name": "stdout", + "text": [ + "[U1] requested=150 best_iteration=147 train_acc=0.7519 test_acc=0.7439 alpha=2.6640179198766174\n", + "[U2] requested=300 best_iteration=296 train_acc=0.7946 test_acc=0.7812 alpha=2.717651438580225\n", + "[T1] requested=4000 best_iteration=1751 train_acc=0.9842 test_acc=0.9214 alpha=1.8277739874575372\n", + "[T2] requested=6000 best_iteration=1304 train_acc=0.9855 test_acc=0.9271 alpha=1.9214604016252392\n", + "[O1] requested=8000 best_iteration=347 train_acc=0.9867 test_acc=0.9321 alpha=2.4157331166759253\n", + "[O2] requested=6000 best_iteration=271 train_acc=0.9862 test_acc=0.9306 alpha=2.389654620960565\n", + "[U3] requested=250 best_iteration=237 train_acc=0.7537 test_acc=0.7481 alpha=1.9277020042007522\n", + "[T3] requested=3000 best_iteration=1869 train_acc=0.9001 test_acc=0.8687 alpha=1.670707759967076\n", + "[O3] requested=7000 best_iteration=374 train_acc=0.9864 test_acc=0.9317 alpha=1.7089374609846892\n", + "Saved: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_hyperparameter_sweep_results.csv\n" + ] }, { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "FKjVjz38X3CQ", - "outputId": "68a544fe-910e-4825-aebe-d63f9f5a85cd", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 143 - } - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - " tag alpha_mean_per_class alpha_median_per_class layers_analyzed\n", - "0 U1 NaN NaN 0\n", - "1 T2 NaN NaN 0\n", - "2 O1 NaN NaN 0" - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tagalpha_mean_per_classalpha_median_per_classlayers_analyzed
0U1NaNNaN0
1T2NaNNaN0
2O1NaNNaN0
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "summary": "{\n \"name\": \"pd\",\n \"rows\": 3,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"U1\",\n \"T2\",\n \"O1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha_mean_per_class\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": null,\n \"max\": null,\n \"num_unique_values\": 0,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha_median_per_class\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": null,\n \"max\": null,\n \"num_unique_values\": 0,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"layers_analyzed\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {}, - "execution_count": 12 - } + "output_type": "execute_result", + "data": { + "text/plain": [ + " tag test_acc train_acc alpha rand_num_spikes best_iteration \\\n", + "0 O1 0.932083 0.986667 2.415733 0.0 347 \n", + "1 O3 0.931750 0.986354 1.708937 3.0 374 \n", + "2 O2 0.930583 0.986219 2.389655 34.0 271 \n", + "3 BEST 0.927125 0.985479 1.921460 0.0 1304 \n", + "4 T2 0.927125 0.985479 1.921460 0.0 1304 \n", + "5 T1 0.921375 0.984229 1.827774 0.0 1751 \n", + "6 T3 0.868708 0.900073 1.670708 0.0 1869 \n", + "7 U2 0.781167 0.794625 2.717651 0.0 296 \n", + "8 U3 0.748125 0.753708 1.927702 0.0 237 \n", + "9 U1 0.743917 0.751885 2.664018 0.0 147 \n", + "\n", + " num_boost_round_requested ww_note \n", + "0 8000 \n", + "1 7000 \n", + "2 6000 \n", + "3 6000 \n", + "4 6000 \n", + "5 4000 \n", + "6 3000 \n", + "7 300 \n", + "8 250 \n", + "9 150 " ], - "source": [ - "rep_tags = [t for t in ['U1','T2','O1'] if t in boosters]\n", - "per_class_summary = []\n", - "for tag in rep_tags:\n", - " try:\n", - " np_models = convert(boosters[tag], X_train, y_train, multiclass='per_class', return_type='numpy')\n", - " class_alphas = []\n", - " class_rows = 0\n", - " for class_id, Wk in sorted(np_models.items()):\n", - " class_model = to_linear_layer(Wk)\n", - " import torch\n", - " class_seq = torch.nn.Sequential(class_model)\n", - " ww_details = pd.DataFrame(\n", - " ww.WeightWatcher(model=class_seq, log_level='ERROR').analyze(\n", - " randomize=True,\n", - " min_evals=10,\n", - " max_evals=120,\n", - " mp_fit=False,\n", - " plot=False,\n", - " savefig=False,\n", - " max_N=WW_MAX_N,\n", - " )\n", - " )\n", - " class_rows += len(ww_details)\n", - " if 'alpha' in ww_details:\n", - " class_alphas.extend(ww_details['alpha'].dropna().tolist())\n", - "\n", - " alpha_mean = float(np.mean(class_alphas)) if class_alphas else np.nan\n", - " alpha_median = float(np.median(class_alphas)) if class_alphas else np.nan\n", - " per_class_summary.append({'tag': tag, 'alpha_mean_per_class': alpha_mean, 'alpha_median_per_class': alpha_median, 'layers_analyzed': class_rows})\n", - " except Exception as e:\n", - " per_class_summary.append({'tag': tag, 'alpha_mean_per_class': np.nan, 'alpha_median_per_class': np.nan, 'layers_analyzed': 0, 'note': str(e)})\n", - "\n", - "pd.DataFrame(per_class_summary)\n" + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tagtest_acctrain_accalpharand_num_spikesbest_iterationnum_boost_round_requestedww_note
0O10.9320830.9866672.4157330.03478000
1O30.9317500.9863541.7089373.03747000
2O20.9305830.9862192.38965534.02716000
3BEST0.9271250.9854791.9214600.013046000
4T20.9271250.9854791.9214600.013046000
5T10.9213750.9842291.8277740.017514000
6T30.8687080.9000731.6707080.018693000
7U20.7811670.7946252.7176510.0296300
8U30.7481250.7537081.9277020.0237250
9U10.7439170.7518852.6640180.0147150
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" ], - "id": "FKjVjz38X3CQ" + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"results[['tag','test_acc','train_acc','alpha','rand_num_spikes','best_iteration','num_boost_round_requested','ww_note']]\",\n \"rows\": 10,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 10,\n \"samples\": [\n \"U3\",\n \"O3\",\n \"T1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"test_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.0810575356975784,\n \"min\": 0.7439166666666667,\n \"max\": 0.9320833333333334,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.748125,\n 0.93175,\n 0.8687083333333333\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"train_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.10394271540003114,\n \"min\": 0.7518854166666666,\n \"max\": 0.9866666666666667,\n \"num_unique_values\": 9,\n \"samples\": [\n 0.7537083333333333,\n 0.9863541666666666,\n 0.9000729166666667\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.39232059688552195,\n \"min\": 1.670707759967076,\n \"max\": 2.717651438580225,\n \"num_unique_values\": 9,\n \"samples\": [\n 1.9277020042007522,\n 1.7089374609846892,\n 1.670707759967076\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 10.687999500997995,\n \"min\": 0.0,\n \"max\": 34.0,\n \"num_unique_values\": 3,\n \"samples\": [\n 0.0,\n 3.0,\n 34.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"best_iteration\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 684,\n \"min\": 147,\n \"max\": 1869,\n \"num_unique_values\": 9,\n \"samples\": [\n 237,\n 374,\n 1869\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"num_boost_round_requested\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2991,\n \"min\": 150,\n \"max\": 8000,\n \"num_unique_values\": 8,\n \"samples\": [\n 7000,\n 300,\n 8000\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ww_note\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 10 + } + ], + "source": [ + "seed_configs = {\n", + " # Underfit\n", + " 'U1': dict(max_depth=2, eta=0.3, num_boost_round=150, early_stopping_rounds=40, min_child_weight=20, gamma=5, subsample=0.6, colsample_bytree=0.6, reg_lambda=50, reg_alpha=0),\n", + " 'U2': dict(max_depth=3, eta=0.2, num_boost_round=300, early_stopping_rounds=60, min_child_weight=15, gamma=2, subsample=0.7, colsample_bytree=0.7, reg_lambda=30, reg_alpha=0),\n", + " # Tuned\n", + " 'T1': dict(max_depth=8, eta=0.08, num_boost_round=4000, early_stopping_rounds=100, min_child_weight=2, gamma=0, subsample=0.8, colsample_bytree=0.8, reg_lambda=10, reg_alpha=0),\n", + " 'T2': dict(max_depth=10, eta=0.05, num_boost_round=6000, early_stopping_rounds=150, min_child_weight=1, gamma=0, subsample=0.9, colsample_bytree=0.9, reg_lambda=5, reg_alpha=0.5),\n", + " # Overfit-leaning\n", + " 'O1': dict(max_depth=14, eta=0.15, num_boost_round=8000, early_stopping_rounds=200, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.5, reg_alpha=0),\n", + " 'O2': dict(max_depth=12, eta=0.2, num_boost_round=6000, early_stopping_rounds=150, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0, reg_alpha=0),\n", + " # Additional coarse points\n", + " 'U3': dict(max_depth=4, eta=0.2, num_boost_round=250, early_stopping_rounds=50, min_child_weight=25, gamma=8, subsample=0.5, colsample_bytree=0.5, reg_lambda=80, reg_alpha=1),\n", + " 'T3': dict(max_depth=6, eta=0.1, num_boost_round=3000, early_stopping_rounds=100, min_child_weight=3, gamma=1, subsample=0.8, colsample_bytree=0.9, reg_lambda=12, reg_alpha=0.5),\n", + " 'O3': dict(max_depth=14, eta=0.2, num_boost_round=7000, early_stopping_rounds=200, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.1, reg_alpha=0),\n", + "}\n", + "\n", + "rows = [best_row]\n", + "boosters = {'BEST': best_booster}\n", + "for tag, cfg in seed_configs.items():\n", + " row, booster = fit_eval_config(tag, cfg, t_points=T_POINTS_SWEEP, run_detx=(tag in {'U1','T2','O1'}))\n", + " rows.append(row)\n", + " boosters[tag] = booster\n", + "\n", + "results = pd.DataFrame(rows).sort_values('test_acc', ascending=False).reset_index(drop=True)\n", + "results.to_csv(CHECKPOINT_RESULTS_CSV, index=False)\n", + "print('Saved:', CHECKPOINT_RESULTS_CSV)\n", + "results[['tag','test_acc','test_acc_std','train_acc','train_acc_std','test_mlogloss','test_mlogloss_std','rep_split_seed','ww_note']]\n" + ], + "id": "OzftMnpOX3CQ" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_xdpH5YaX3CQ" + }, + "source": [ + "## Stage B: local refinement around top configs\n" + ], + "id": "_xdpH5YaX3CQ" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5_nzDiSXX3CQ", + "outputId": "43ac6a08-20ba-4477-ce2f-81f305a84303", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 676 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[R11_O1] requested=8000 best_iteration=430 train_acc=0.9867 test_acc=0.9326 alpha=1.7410022503807587\n", + "[R12_O1] requested=8000 best_iteration=414 train_acc=0.9866 test_acc=0.9308 alpha=1.6986392768578473\n", + "[R21_O3] requested=7000 best_iteration=284 train_acc=0.9863 test_acc=0.9313 alpha=2.4434917904587015\n", + "[R22_O3] requested=7000 best_iteration=322 train_acc=0.9865 test_acc=0.9314 alpha=2.4597379193177824\n", + "[R31_O2] requested=6000 best_iteration=324 train_acc=0.9861 test_acc=0.9307 alpha=2.603029458818721\n", + "[R32_O2] requested=6000 best_iteration=271 train_acc=0.9862 test_acc=0.9306 alpha=2.389654620960565\n", + "test accuracy spread: 18.87 percentage points\n" + ] }, { - "cell_type": "markdown", - "metadata": { - "id": "gFdoKDk6X3CQ" - }, - "source": [ - "## Labeled plots: every point identified\n" + "output_type": "execute_result", + "data": { + "text/plain": [ + " tag test_acc train_acc alpha rand_num_spikes multiclass_mode \\\n", + "0 R11_O1 0.932625 0.986656 1.741002 0.0 stack \n", + "1 O1 0.932083 0.986667 2.415733 0.0 stack \n", + "2 O3 0.931750 0.986354 1.708937 3.0 stack \n", + "3 R22_O3 0.931375 0.986531 2.459738 9.0 stack \n", + "4 R21_O3 0.931292 0.986302 2.443492 54.0 stack \n", + "5 R12_O1 0.930792 0.986615 1.698639 0.0 stack \n", + "6 R31_O2 0.930667 0.986146 2.603029 43.0 stack \n", + "7 O2 0.930583 0.986219 2.389655 34.0 stack \n", + "8 R32_O2 0.930583 0.986219 2.389655 37.0 stack \n", + "9 BEST 0.927125 0.985479 1.921460 0.0 stack \n", + "10 T2 0.927125 0.985479 1.921460 0.0 stack \n", + "11 T1 0.921375 0.984229 1.827774 0.0 stack \n", + "12 T3 0.868708 0.900073 1.670708 0.0 stack \n", + "13 U2 0.781167 0.794625 2.717651 0.0 stack \n", + "14 U3 0.748125 0.753708 1.927702 0.0 stack \n", + "15 U1 0.743917 0.751885 2.664018 0.0 stack \n", + "\n", + " ww_note \n", + "0 \n", + "1 \n", + "2 \n", + "3 \n", + "4 \n", + "5 \n", + "6 \n", + "7 \n", + "8 \n", + "9 \n", + "10 \n", + "11 \n", + "12 \n", + "13 \n", + "14 \n", + "15 " ], - "id": "gFdoKDk6X3CQ" - }, + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tagtest_acctrain_accalpharand_num_spikesmulticlass_modeww_note
0R11_O10.9326250.9866561.7410020.0stack
1O10.9320830.9866672.4157330.0stack
2O30.9317500.9863541.7089373.0stack
3R22_O30.9313750.9865312.4597389.0stack
4R21_O30.9312920.9863022.44349254.0stack
5R12_O10.9307920.9866151.6986390.0stack
6R31_O20.9306670.9861462.60302943.0stack
7O20.9305830.9862192.38965534.0stack
8R32_O20.9305830.9862192.38965537.0stack
9BEST0.9271250.9854791.9214600.0stack
10T20.9271250.9854791.9214600.0stack
11T10.9213750.9842291.8277740.0stack
12T30.8687080.9000731.6707080.0stack
13U20.7811670.7946252.7176510.0stack
14U30.7481250.7537081.9277020.0stack
15U10.7439170.7518852.6640180.0stack
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"results[['tag','test_acc','train_acc','alpha','rand_num_spikes','multiclass_mode','ww_note']]\",\n \"rows\": 16,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 16,\n \"samples\": [\n \"R11_O1\",\n \"O1\",\n \"R12_O1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"test_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06959295586950659,\n \"min\": 0.7439166666666667,\n \"max\": 0.932625,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.921375,\n 0.7811666666666667,\n 0.932625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"train_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08880570824916605,\n \"min\": 0.7518854166666666,\n \"max\": 0.9866666666666667,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.9842291666666667,\n 0.794625,\n 0.98665625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.38397677093322224,\n \"min\": 1.670707759967076,\n \"max\": 2.717651438580225,\n \"num_unique_values\": 14,\n \"samples\": [\n 1.8277739874575372,\n 2.717651438580225,\n 1.7410022503807587\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 18.894443627691185,\n \"min\": 0.0,\n \"max\": 54.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.0,\n 3.0,\n 34.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"multiclass_mode\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"stack\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ww_note\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 11 + } + ], + "source": [ + "top_tags = results.head(3)['tag'].tolist()\n", + "refine_rows = []\n", + "for i, tag in enumerate(top_tags, 1):\n", + " base = {k.replace('hp_',''): results.loc[results['tag']==tag, k].iloc[0] for k in results.columns if k.startswith('hp_') and pd.notna(results.loc[results['tag']==tag, k].iloc[0])}\n", + " for j, (eta_mul, lam_mul, ss_delta) in enumerate([(0.9, 1.2, -0.05), (1.1, 0.8, 0.05)], 1):\n", + " cfg = dict(base)\n", + " cfg['eta'] = max(0.03, min(0.2, float(cfg['eta']) * eta_mul))\n", + " cfg['reg_lambda'] = max(0.0, float(cfg.get('reg_lambda', 1)) * lam_mul)\n", + " cfg['subsample'] = max(0.6, min(1.0, float(cfg.get('subsample', 0.9)) + ss_delta))\n", + " cfg['colsample_bytree'] = max(0.6, min(1.0, float(cfg.get('colsample_bytree', 0.9)) + ss_delta))\n", + " cfg['min_child_weight'] = max(1.0, float(cfg.get('min_child_weight', 1)))\n", + " rtag = f'R{i}{j}_{tag}'\n", + " row, booster = fit_eval_config(rtag, cfg, t_points=T_POINTS_SWEEP)\n", + " refine_rows.append(row)\n", + " boosters[rtag] = booster\n", + "\n", + "if refine_rows:\n", + " results = pd.concat([results, pd.DataFrame(refine_rows)], ignore_index=True)\n", + "\n", + "acc_span = 100 * (results['test_acc'].max() - results['test_acc'].min())\n", + "print(f'test accuracy spread: {acc_span:.2f} percentage points')\n", + "if acc_span < 8.0:\n", + " print('Spread too narrow; adding extreme guardrail configs...')\n", + " extreme_cfgs = {\n", + " 'U_extreme': dict(max_depth=2, eta=0.3, num_boost_round=80, early_stopping_rounds=20, min_child_weight=30, gamma=10, subsample=0.5, colsample_bytree=0.5, reg_lambda=100, reg_alpha=2),\n", + " 'O_extreme': dict(max_depth=14, eta=0.2, num_boost_round=8000, early_stopping_rounds=300, min_child_weight=1, gamma=0, subsample=1.0, colsample_bytree=1.0, reg_lambda=0.0, reg_alpha=0),\n", + " }\n", + " extra = []\n", + " for tag, cfg in extreme_cfgs.items():\n", + " row, booster = fit_eval_config(tag, cfg, t_points=T_POINTS_SWEEP)\n", + " boosters[tag] = booster\n", + " extra.append(row)\n", + " results = pd.concat([results, pd.DataFrame(extra)], ignore_index=True)\n", + "\n", + "results = results.sort_values('test_acc', ascending=False).reset_index(drop=True)\n", + "results.to_csv(CHECKPOINT_RESULTS_CSV, index=False)\n", + "results[['tag','test_acc','test_acc_std','train_acc','train_acc_std','test_mlogloss','test_mlogloss_std','alpha','rand_num_spikes','multiclass_mode','ww_note']].head(20)\n" + ], + "id": "5_nzDiSXX3CQ" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HqM6VUPNX3CQ" + }, + "source": [ + "## Optional per-class (`multiclass='per_class'`) analysis for representative configs\n" + ], + "id": "HqM6VUPNX3CQ" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FKjVjz38X3CQ", + "outputId": "68a544fe-910e-4825-aebe-d63f9f5a85cd", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 143 + } + }, + "outputs": [ { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "7Mfjza-GX3CQ", - "outputId": "5ab3131a-1de1-419f-b99d-b348e8e8918a", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - } - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Saved plot: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_acc_vs_alpha.png\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Saved plot: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_test_vs_rand_num_spikes.png\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - " tag test_acc train_acc alpha rand_num_spikes multiclass_mode \\\n", - "0 R11_O1 0.932625 0.986656 1.741002 0.0 stack \n", - "1 O1 0.932083 0.986667 2.415733 0.0 stack \n", - "2 O3 0.931750 0.986354 1.708937 3.0 stack \n", - "3 R22_O3 0.931375 0.986531 2.459738 9.0 stack \n", - "4 R21_O3 0.931292 0.986302 2.443492 54.0 stack \n", - "5 R12_O1 0.930792 0.986615 1.698639 0.0 stack \n", - "6 R31_O2 0.930667 0.986146 2.603029 43.0 stack \n", - "7 O2 0.930583 0.986219 2.389655 34.0 stack \n", - "8 R32_O2 0.930583 0.986219 2.389655 37.0 stack \n", - "9 BEST 0.927125 0.985479 1.921460 0.0 stack \n", - "10 T2 0.927125 0.985479 1.921460 0.0 stack \n", - "11 T1 0.921375 0.984229 1.827774 0.0 stack \n", - "12 T3 0.868708 0.900073 1.670708 0.0 stack \n", - "13 U2 0.781167 0.794625 2.717651 0.0 stack \n", - "14 U3 0.748125 0.753708 1.927702 0.0 stack \n", - "15 U1 0.743917 0.751885 2.664018 0.0 stack \n", - "\n", - " ww_note \n", - "0 \n", - "1 \n", - "2 \n", - "3 \n", - "4 \n", - "5 \n", - "6 \n", - "7 \n", - "8 \n", - "9 \n", - "10 \n", - "11 \n", - "12 \n", - "13 \n", - "14 \n", - "15 " - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tagtest_acctrain_accalpharand_num_spikesmulticlass_modeww_note
0R11_O10.9326250.9866561.7410020.0stack
1O10.9320830.9866672.4157330.0stack
2O30.9317500.9863541.7089373.0stack
3R22_O30.9313750.9865312.4597389.0stack
4R21_O30.9312920.9863022.44349254.0stack
5R12_O10.9307920.9866151.6986390.0stack
6R31_O20.9306670.9861462.60302943.0stack
7O20.9305830.9862192.38965534.0stack
8R32_O20.9305830.9862192.38965537.0stack
9BEST0.9271250.9854791.9214600.0stack
10T20.9271250.9854791.9214600.0stack
11T10.9213750.9842291.8277740.0stack
12T30.8687080.9000731.6707080.0stack
13U20.7811670.7946252.7176510.0stack
14U30.7481250.7537081.9277020.0stack
15U10.7439170.7518852.6640180.0stack
\n", - "
\n", - "
\n", - "\n", - "
\n", - " \n", - "\n", - " \n", - "\n", - " \n", - "
\n", - "\n", - "\n", - "
\n", - "
\n" - ], - "application/vnd.google.colaboratory.intrinsic+json": { - "type": "dataframe", - "summary": "{\n \"name\": \"results[['tag','test_acc','train_acc','alpha','rand_num_spikes','multiclass_mode','ww_note']]\",\n \"rows\": 16,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 16,\n \"samples\": [\n \"R11_O1\",\n \"O1\",\n \"R12_O1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"test_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06959295586950659,\n \"min\": 0.7439166666666667,\n \"max\": 0.932625,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.921375,\n 0.7811666666666667,\n 0.932625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"train_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08880570824916605,\n \"min\": 0.7518854166666666,\n \"max\": 0.9866666666666667,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.9842291666666667,\n 0.794625,\n 0.98665625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.38397677093322224,\n \"min\": 1.670707759967076,\n \"max\": 2.717651438580225,\n \"num_unique_values\": 14,\n \"samples\": [\n 1.8277739874575372,\n 2.717651438580225,\n 1.7410022503807587\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 18.894443627691185,\n \"min\": 0.0,\n \"max\": 54.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.0,\n 3.0,\n 34.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"multiclass_mode\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"stack\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ww_note\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" - } - }, - "metadata": {}, - "execution_count": 13 - } + "output_type": "execute_result", + "data": { + "text/plain": [ + " tag alpha_mean_per_class alpha_median_per_class layers_analyzed\n", + "0 U1 NaN NaN 0\n", + "1 T2 NaN NaN 0\n", + "2 O1 NaN NaN 0" ], - "source": [ - "plot_df = results.dropna(subset=['alpha']).copy()\n", - "plot_df['alpha_line_side'] = np.where(plot_df['alpha'] < 2, 'alpha < 2', 'alpha ≥ 2')\n", - "\n", - "fig, ax = plt.subplots(1, 2, figsize=(16, 6), constrained_layout=True)\n", - "\n", - "ax[0].scatter(plot_df['alpha'], 100*plot_df['test_acc'], s=60)\n", - "ax[0].axvline(2.0, color='red', linestyle='--', linewidth=1.5, label='alpha = 2 reference')\n", - "for _, r in plot_df.iterrows():\n", - " ax[0].annotate(f\"{r['tag']} ({100*r['test_acc']:.1f}%, α={r['alpha']:.2f})\", (r['alpha'], 100*r['test_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", - "ax[0].set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Test Accuracy vs Alpha (sampled={USE_SAMPLING})')\n", - "ax[0].set_xlabel('WeightWatcher alpha (α)')\n", - "ax[0].set_ylabel('Test accuracy (%)')\n", - "ax[0].legend(loc='lower right')\n", - "\n", - "ax[1].scatter(plot_df['alpha'], 100*plot_df['train_acc'], s=60, color='tab:green')\n", - "ax[1].axvline(2.0, color='red', linestyle='--', linewidth=1.5, label='alpha = 2 reference')\n", - "for _, r in plot_df.iterrows():\n", - " ax[1].annotate(f\"{r['tag']} ({100*r['train_acc']:.1f}%, α={r['alpha']:.2f})\", (r['alpha'], 100*r['train_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", - "ax[1].set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Train Accuracy vs Alpha (sampled={USE_SAMPLING})')\n", - "ax[1].set_xlabel('WeightWatcher alpha (α)')\n", - "ax[1].set_ylabel('Training accuracy (%)')\n", - "ax[1].legend(loc='lower right')\n", - "\n", - "plot_path = CHECKPOINT_DIR / 'covertype_acc_vs_alpha.png'\n", - "plt.savefig(plot_path, dpi=150)\n", - "plt.show()\n", - "print('Saved plot:', plot_path)\n", - "\n", - "trap_fig, trap_ax = plt.subplots(figsize=(9, 6))\n", - "trap_ax.scatter(plot_df['rand_num_spikes'], 100*plot_df['test_acc'], s=60, color='tab:purple')\n", - "for _, r in plot_df.iterrows():\n", - " trap_ax.annotate(f\"{r['tag']} (α={r['alpha']:.2f})\", (r['rand_num_spikes'], 100*r['test_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", - "trap_ax.set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Test Accuracy vs rand_num_spikes')\n", - "trap_ax.set_xlabel('WeightWatcher rand_num_spikes (traps proxy)')\n", - "trap_ax.set_ylabel('Test accuracy (%)')\n", - "trap_path = CHECKPOINT_DIR / 'covertype_test_vs_rand_num_spikes.png'\n", - "plt.savefig(trap_path, dpi=150)\n", - "plt.show()\n", - "print('Saved plot:', trap_path)\n", - "\n", - "results[['tag','test_acc','train_acc','alpha','rand_num_spikes','multiclass_mode','ww_note']].sort_values('test_acc', ascending=False)\n" + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tagalpha_mean_per_classalpha_median_per_classlayers_analyzed
0U1NaNNaN0
1T2NaNNaN0
2O1NaNNaN0
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" ], - "id": "7Mfjza-GX3CQ" - }, + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"pd\",\n \"rows\": 3,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 3,\n \"samples\": [\n \"U1\",\n \"T2\",\n \"O1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha_mean_per_class\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": null,\n \"max\": null,\n \"num_unique_values\": 0,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha_median_per_class\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": null,\n \"min\": null,\n \"max\": null,\n \"num_unique_values\": 0,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"layers_analyzed\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 0,\n \"num_unique_values\": 1,\n \"samples\": [],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 12 + } + ], + "source": [ + "rep_tags = [t for t in ['U1','T2','O1'] if t in boosters]\n", + "per_class_summary = []\n", + "for tag in rep_tags:\n", + " try:\n", + " np_models = convert(boosters[tag], X_train, y_train, multiclass='per_class', return_type='numpy')\n", + " class_alphas = []\n", + " class_rows = 0\n", + " for class_id, Wk in sorted(np_models.items()):\n", + " class_model = to_linear_layer(Wk)\n", + " import torch\n", + " class_seq = torch.nn.Sequential(class_model)\n", + " ww_details = pd.DataFrame(\n", + " ww.WeightWatcher(model=class_seq, log_level='ERROR').analyze(\n", + " randomize=True,\n", + " min_evals=10,\n", + " max_evals=120,\n", + " mp_fit=False,\n", + " plot=False,\n", + " savefig=False,\n", + " max_N=WW_MAX_N,\n", + " )\n", + " )\n", + " class_rows += len(ww_details)\n", + " if 'alpha' in ww_details:\n", + " class_alphas.extend(ww_details['alpha'].dropna().tolist())\n", + "\n", + " alpha_mean = float(np.mean(class_alphas)) if class_alphas else np.nan\n", + " alpha_median = float(np.median(class_alphas)) if class_alphas else np.nan\n", + " per_class_summary.append({'tag': tag, 'alpha_mean_per_class': alpha_mean, 'alpha_median_per_class': alpha_median, 'layers_analyzed': class_rows})\n", + " except Exception as e:\n", + " per_class_summary.append({'tag': tag, 'alpha_mean_per_class': np.nan, 'alpha_median_per_class': np.nan, 'layers_analyzed': 0, 'note': str(e)})\n", + "\n", + "pd.DataFrame(per_class_summary)\n" + ], + "id": "FKjVjz38X3CQ" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gFdoKDk6X3CQ" + }, + "source": [ + "## Labeled plots: every point identified\n" + ], + "id": "gFdoKDk6X3CQ" + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7Mfjza-GX3CQ", + "outputId": "5ab3131a-1de1-419f-b99d-b348e8e8918a", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + } + }, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "yYU4nMaSX3CQ" - }, - "source": [ - "## Interpretation and takeaways\n", - "- Compare underfit/tuned/overfit tags (U*, T*, O*) to verify we captured a broad regime spread.\n", - "- Check if top-test-accuracy models cluster near alpha ~2 with fewer spikes versus overfit-leaning configurations.\n", - "- Use the saved CSV and PNGs in the checkpoint directory for offline comparison and reproducibility.\n", - "- If runtime is tight, keep `USE_SAMPLING=True`; for stronger final estimates, increase `SAMPLE_N` or disable sampling and rerun the best subset.\n" + "output_type": "display_data", + "data": { + "text/plain": [ + "
" ], - "id": "yYU4nMaSX3CQ" + "image/png": "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\n" + }, + "metadata": {} }, { - "cell_type": "code", - "source": [], - "metadata": { - "id": "dGuRQEVPZvLU" - }, - "id": "dGuRQEVPZvLU", - "execution_count": null, - "outputs": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "name": "python3" + "output_type": "stream", + "name": "stdout", + "text": [ + "Saved plot: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_acc_vs_alpha.png\n" + ] }, - "language_info": { - "name": "python", - "version": "3.10" + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} }, - "colab": { - "provenance": [], - "machine_shape": "hm", - "gpuType": "H100", - "include_colab_link": true + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Saved plot: /content/drive/MyDrive/xgboost2ww_checkpoints/covertype_hparam_sweep/covertype_test_vs_rand_num_spikes.png\n" + ] }, - "accelerator": "GPU" + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " tag test_acc train_acc alpha rand_num_spikes multiclass_mode \\\n", + "0 R11_O1 0.932625 0.986656 1.741002 0.0 stack \n", + "1 O1 0.932083 0.986667 2.415733 0.0 stack \n", + "2 O3 0.931750 0.986354 1.708937 3.0 stack \n", + "3 R22_O3 0.931375 0.986531 2.459738 9.0 stack \n", + "4 R21_O3 0.931292 0.986302 2.443492 54.0 stack \n", + "5 R12_O1 0.930792 0.986615 1.698639 0.0 stack \n", + "6 R31_O2 0.930667 0.986146 2.603029 43.0 stack \n", + "7 O2 0.930583 0.986219 2.389655 34.0 stack \n", + "8 R32_O2 0.930583 0.986219 2.389655 37.0 stack \n", + "9 BEST 0.927125 0.985479 1.921460 0.0 stack \n", + "10 T2 0.927125 0.985479 1.921460 0.0 stack \n", + "11 T1 0.921375 0.984229 1.827774 0.0 stack \n", + "12 T3 0.868708 0.900073 1.670708 0.0 stack \n", + "13 U2 0.781167 0.794625 2.717651 0.0 stack \n", + "14 U3 0.748125 0.753708 1.927702 0.0 stack \n", + "15 U1 0.743917 0.751885 2.664018 0.0 stack \n", + "\n", + " ww_note \n", + "0 \n", + "1 \n", + "2 \n", + "3 \n", + "4 \n", + "5 \n", + "6 \n", + "7 \n", + "8 \n", + "9 \n", + "10 \n", + "11 \n", + "12 \n", + "13 \n", + "14 \n", + "15 " + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tagtest_acctrain_accalpharand_num_spikesmulticlass_modeww_note
0R11_O10.9326250.9866561.7410020.0stack
1O10.9320830.9866672.4157330.0stack
2O30.9317500.9863541.7089373.0stack
3R22_O30.9313750.9865312.4597389.0stack
4R21_O30.9312920.9863022.44349254.0stack
5R12_O10.9307920.9866151.6986390.0stack
6R31_O20.9306670.9861462.60302943.0stack
7O20.9305830.9862192.38965534.0stack
8R32_O20.9305830.9862192.38965537.0stack
9BEST0.9271250.9854791.9214600.0stack
10T20.9271250.9854791.9214600.0stack
11T10.9213750.9842291.8277740.0stack
12T30.8687080.9000731.6707080.0stack
13U20.7811670.7946252.7176510.0stack
14U30.7481250.7537081.9277020.0stack
15U10.7439170.7518852.6640180.0stack
\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + "
\n" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "dataframe", + "summary": "{\n \"name\": \"results[['tag','test_acc','train_acc','alpha','rand_num_spikes','multiclass_mode','ww_note']]\",\n \"rows\": 16,\n \"fields\": [\n {\n \"column\": \"tag\",\n \"properties\": {\n \"dtype\": \"string\",\n \"num_unique_values\": 16,\n \"samples\": [\n \"R11_O1\",\n \"O1\",\n \"R12_O1\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"test_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.06959295586950659,\n \"min\": 0.7439166666666667,\n \"max\": 0.932625,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.921375,\n 0.7811666666666667,\n 0.932625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"train_acc\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.08880570824916605,\n \"min\": 0.7518854166666666,\n \"max\": 0.9866666666666667,\n \"num_unique_values\": 14,\n \"samples\": [\n 0.9842291666666667,\n 0.794625,\n 0.98665625\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"alpha\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.38397677093322224,\n \"min\": 1.670707759967076,\n \"max\": 2.717651438580225,\n \"num_unique_values\": 14,\n \"samples\": [\n 1.8277739874575372,\n 2.717651438580225,\n 1.7410022503807587\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"rand_num_spikes\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 18.894443627691185,\n \"min\": 0.0,\n \"max\": 54.0,\n \"num_unique_values\": 7,\n \"samples\": [\n 0.0,\n 3.0,\n 34.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"multiclass_mode\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"stack\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"ww_note\",\n \"properties\": {\n \"dtype\": \"object\",\n \"num_unique_values\": 1,\n \"samples\": [\n \"\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 13 + } + ], + "source": [ + "plot_df = results.dropna(subset=['alpha']).copy()\n", + "plot_df['alpha_line_side'] = np.where(plot_df['alpha'] < 2, 'alpha < 2', 'alpha ≥ 2')\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(16, 6), constrained_layout=True)\n", + "\n", + "ax[0].scatter(plot_df['alpha'], 100*plot_df['test_acc'], s=60)\n", + "ax[0].axvline(2.0, color='red', linestyle='--', linewidth=1.5, label='alpha = 2 reference')\n", + "for _, r in plot_df.iterrows():\n", + " ax[0].annotate(f\"{r['tag']} ({100*r['test_acc']:.1f}%, α={r['alpha']:.2f})\", (r['alpha'], 100*r['test_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", + "ax[0].set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Test Accuracy vs Alpha (sampled={USE_SAMPLING})')\n", + "ax[0].set_xlabel('WeightWatcher alpha (α)')\n", + "ax[0].set_ylabel('Test accuracy (%)')\n", + "ax[0].legend(loc='lower right')\n", + "\n", + "ax[1].scatter(plot_df['alpha'], 100*plot_df['train_acc'], s=60, color='tab:green')\n", + "ax[1].axvline(2.0, color='red', linestyle='--', linewidth=1.5, label='alpha = 2 reference')\n", + "for _, r in plot_df.iterrows():\n", + " ax[1].annotate(f\"{r['tag']} ({100*r['train_acc']:.1f}%, α={r['alpha']:.2f})\", (r['alpha'], 100*r['train_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", + "ax[1].set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Train Accuracy vs Alpha (sampled={USE_SAMPLING})')\n", + "ax[1].set_xlabel('WeightWatcher alpha (α)')\n", + "ax[1].set_ylabel('Training accuracy (%)')\n", + "ax[1].legend(loc='lower right')\n", + "\n", + "plot_path = CHECKPOINT_DIR / 'covertype_acc_vs_alpha.png'\n", + "plt.savefig(plot_path, dpi=150)\n", + "plt.show()\n", + "print('Saved plot:', plot_path)\n", + "\n", + "trap_fig, trap_ax = plt.subplots(figsize=(9, 6))\n", + "trap_ax.scatter(plot_df['rand_num_spikes'], 100*plot_df['test_acc'], s=60, color='tab:purple')\n", + "for _, r in plot_df.iterrows():\n", + " trap_ax.annotate(f\"{r['tag']} (α={r['alpha']:.2f})\", (r['rand_num_spikes'], 100*r['test_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", + "trap_ax.set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Test Accuracy vs rand_num_spikes')\n", + "trap_ax.set_xlabel('WeightWatcher rand_num_spikes (traps proxy)')\n", + "trap_ax.set_ylabel('Test accuracy (%)')\n", + "trap_path = CHECKPOINT_DIR / 'covertype_test_vs_rand_num_spikes.png'\n", + "plt.savefig(trap_path, dpi=150)\n", + "plt.show()\n", + "print('Saved plot:', trap_path)\n", + "\n", + "results[['tag','test_acc','train_acc','alpha','rand_num_spikes','multiclass_mode','ww_note']].sort_values('test_acc', ascending=False)\n" + ], + "id": "7Mfjza-GX3CQ" + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yYU4nMaSX3CQ" + }, + "source": [ + "## Interpretation and takeaways\n", + "- Compare underfit/tuned/overfit tags (U*, T*, O*) to verify we captured a broad regime spread.\n", + "- Check if top-test-accuracy models cluster near alpha ~2 with fewer spikes versus overfit-leaning configurations.\n", + "- Use the saved CSV and PNGs in the checkpoint directory for offline comparison and reproducibility.\n", + "- If runtime is tight, keep `USE_SAMPLING=True`; for stronger final estimates, increase `SAMPLE_N` or disable sampling and rerun the best subset.\n" + ], + "id": "yYU4nMaSX3CQ" + }, + { + "cell_type": "code", + "source": [ + "# Zoomed-in accuracy-vs-alpha plots (y-axis restricted to >= 90%)\n", + "plot_df_zoom = results.dropna(subset=['alpha']).copy()\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(16, 6), constrained_layout=True)\n", + "\n", + "ax[0].scatter(plot_df_zoom['alpha'], 100*plot_df_zoom['test_acc'], s=60)\n", + "ax[0].axvline(2.0, color='red', linestyle='--', linewidth=1.5, label='alpha = 2 reference')\n", + "for _, r in plot_df_zoom.iterrows():\n", + " ax[0].annotate(f\"{r['tag']} ({100*r['test_acc']:.1f}%, α={r['alpha']:.2f})\", (r['alpha'], 100*r['test_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", + "ax[0].set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Test Accuracy vs Alpha (sampled={USE_SAMPLING}, y >= 90%)')\n", + "ax[0].set_xlabel('WeightWatcher alpha (α)')\n", + "ax[0].set_ylabel('Test accuracy (%)')\n", + "ax[0].set_ylim(90, 100)\n", + "ax[0].legend(loc='lower right')\n", + "\n", + "ax[1].scatter(plot_df_zoom['alpha'], 100*plot_df_zoom['train_acc'], s=60, color='tab:green')\n", + "ax[1].axvline(2.0, color='red', linestyle='--', linewidth=1.5, label='alpha = 2 reference')\n", + "for _, r in plot_df_zoom.iterrows():\n", + " ax[1].annotate(f\"{r['tag']} ({100*r['train_acc']:.1f}%, α={r['alpha']:.2f})\", (r['alpha'], 100*r['train_acc']), textcoords='offset points', xytext=(5,5), fontsize=8)\n", + "ax[1].set_title(f'Covertype multiclass ({MULTICLASS_MODE_MAIN}) {W_MATRIX_NAME}: Train Accuracy vs Alpha (sampled={USE_SAMPLING}, y >= 90%)')\n", + "ax[1].set_xlabel('WeightWatcher alpha (α)')\n", + "ax[1].set_ylabel('Training accuracy (%)')\n", + "ax[1].set_ylim(90, 100)\n", + "ax[1].legend(loc='lower right')\n", + "\n", + "zoom_plot_path = CHECKPOINT_DIR / 'covertype_acc_vs_alpha_zoomed_y90.png'\n", + "plt.savefig(zoom_plot_path, dpi=150)\n", + "plt.show()\n", + "print('Saved plot:', zoom_plot_path)\n" + ], + "metadata": { + "id": "dGuRQEVPZvLU" + }, + "id": "dGuRQEVPZvLU", + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10" + }, + "colab": { + "provenance": [], + "machine_shape": "hm", + "gpuType": "H100", + "include_colab_link": true }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 5 +}