diff --git a/MLP_feature_cleaning.ipynb b/MLP_feature_cleaning.ipynb index e409881..af296e0 100644 --- a/MLP_feature_cleaning.ipynb +++ b/MLP_feature_cleaning.ipynb @@ -47,23 +47,879 @@ "name": "stderr", "output_type": "stream", "text": [ - " 0%| | 0/200 [00:00 best_val_f1:\n", - " best_val_f1 = val_f1\n", - " patience_counter = 0\n", - " else:\n", - " patience_counter += 1\n", + "# # Early stopping check\n", + "# if val_f1 > best_val_f1:\n", + "# best_val_f1 = val_f1\n", + "# patience_counter = 0\n", + "# else:\n", + "# patience_counter += 1\n", " \n", - " # Stop if plateau\n", - " if patience_counter >= patience:\n", - " break\n", + "# # Stop if plateau\n", + "# if patience_counter >= patience:\n", + "# break\n", " \n", - " # Handle pruning based on intermediate value\n", - " if trial.should_prune():\n", - " raise optuna.TrialPruned()\n", + "# # Handle pruning based on intermediate value\n", + "# if trial.should_prune():\n", + "# raise optuna.TrialPruned()\n", " \n", - " return best_val_f1\n", + "# return best_val_f1\n", "\n", "\n", - "# Create study with pruning\n", - "study = optuna.create_study(\n", - " direction='maximize',\n", - " pruner=optuna.pruners.MedianPruner(n_startup_trials=5, n_warmup_steps=5)\n", - ")\n", + "# # Create study with pruning\n", + "# study = optuna.create_study(\n", + "# direction='maximize',\n", + "# pruner=optuna.pruners.MedianPruner(n_startup_trials=5, n_warmup_steps=5)\n", + "# )\n", "\n", - "# Run optimization with progress bar\n", - "print(\"\\nStarting optimization...\")\n", - "print(\"This will take approximately 15-20 minutes.\\n\")\n", + "# # Run optimization with progress bar\n", + "# print(\"\\nStarting optimization...\")\n", + "# print(\"This will take approximately 15-20 minutes.\\n\")\n", "\n", - "# Progress bar for trials showing X% out of 100\n", - "n_trials = 20\n", - "progress_bar = tqdm(total=100, desc=\"Optimization Progress\", unit=\"%\", bar_format='{l_bar}{bar}| {n:.0f}% done')\n", + "# # Progress bar for trials showing X% out of 100\n", + "# n_trials = 20\n", + "# progress_bar = tqdm(total=100, desc=\"Optimization Progress\", unit=\"%\", bar_format='{l_bar}{bar}| {n:.0f}% done')\n", "\n", - "completed_trials = 0\n", + "# completed_trials = 0\n", "\n", - "def update_progress(study, trial):\n", - " global completed_trials\n", - " completed_trials += 1\n", - " # Update progress bar (each trial = 5% of 100)\n", - " progress_increment = 100 / n_trials\n", - " progress_bar.update(progress_increment)\n", - " progress_bar.set_postfix({\n", - " 'trial': f'{completed_trials}/{n_trials}',\n", - " 'best_f1': f'{study.best_value:.4f}' if study.best_value else 'N/A'\n", - " })\n", + "# def update_progress(study, trial):\n", + "# global completed_trials\n", + "# completed_trials += 1\n", + "# # Update progress bar (each trial = 5% of 100)\n", + "# progress_increment = 100 / n_trials\n", + "# progress_bar.update(progress_increment)\n", + "# progress_bar.set_postfix({\n", + "# 'trial': f'{completed_trials}/{n_trials}',\n", + "# 'best_f1': f'{study.best_value:.4f}' if study.best_value else 'N/A'\n", + "# })\n", "\n", - "study.optimize(objective, n_trials=n_trials, callbacks=[update_progress])\n", - "progress_bar.close()\n", + "# study.optimize(objective, n_trials=n_trials, callbacks=[update_progress])\n", + "# progress_bar.close()\n", "\n", - "# Display results\n", - "print(\"\\n\" + \"=\"*70)\n", - "print(\"OPTIMIZATION COMPLETE\")\n", - "print(\"=\"*70)\n", - "print(f\"Best trial: {study.best_trial.number}\")\n", - "print(f\"Best validation F1 score: {study.best_value:.4f}\")\n", + "# # Display results\n", + "# print(\"\\n\" + \"=\"*70)\n", + "# print(\"OPTIMIZATION COMPLETE\")\n", + "# print(\"=\"*70)\n", + "# print(f\"Best trial: {study.best_trial.number}\")\n", + "# print(f\"Best validation F1 score: {study.best_value:.4f}\")\n", "\n", - "# Compute actual hidden2 from the best trial's parameters\n", - "best_params = study.best_params.copy()\n", - "hidden1_best = best_params['hidden1']\n", - "hidden2_raw_best = best_params['hidden2_raw']\n", + "# # Compute actual hidden2 from the best trial's parameters\n", + "# best_params = study.best_params.copy()\n", + "# hidden1_best = best_params['hidden1']\n", + "# hidden2_raw_best = best_params['hidden2_raw']\n", "\n", - "all_sizes = [32, 64, 128, 192, 250]\n", - "valid_sizes = [s for s in all_sizes if s <= hidden1_best]\n", - "hidden2_best = valid_sizes[hidden2_raw_best % len(valid_sizes)]\n", + "# all_sizes = [32, 64, 128, 192, 250]\n", + "# valid_sizes = [s for s in all_sizes if s <= hidden1_best]\n", + "# hidden2_best = valid_sizes[hidden2_raw_best % len(valid_sizes)]\n", "\n", - "# Add computed hidden2 to best_params and remove hidden2_raw\n", - "best_params['hidden2'] = hidden2_best\n", - "del best_params['hidden2_raw']\n", - "best_params['best_val_f1'] = study.best_value\n", + "# # Add computed hidden2 to best_params and remove hidden2_raw\n", + "# best_params['hidden2'] = hidden2_best\n", + "# del best_params['hidden2_raw']\n", + "# best_params['best_val_f1'] = study.best_value\n", "\n", - "print(f\"\\nBest hyperparameters:\")\n", - "for key, value in best_params.items():\n", - " if key != 'best_val_f1':\n", - " print(f\" {key:15s}: {value}\")\n", - "print(f\" {'best_val_f1':15s}: {best_params['best_val_f1']:.4f}\")\n", - "print(\"=\"*70)\n", + "# print(f\"\\nBest hyperparameters:\")\n", + "# for key, value in best_params.items():\n", + "# if key != 'best_val_f1':\n", + "# print(f\" {key:15s}: {value}\")\n", + "# print(f\" {'best_val_f1':15s}: {best_params['best_val_f1']:.4f}\")\n", + "# print(\"=\"*70)\n", "\n", - "# Save to JSON\n", - "import json\n", - "with open('outputs/best_hyperparameters.json', 'w') as f:\n", - " json.dump(best_params, f, indent=4)\n", + "# # Save to JSON\n", + "# import json\n", + "# with open('outputs/best_hyperparameters.json', 'w') as f:\n", + "# json.dump(best_params, f, indent=4)\n", "\n", - "# Save to shell script format\n", - "with open('outputs/model_config.sh', 'w') as f:\n", - " f.write(f\"#!/bin/bash\\n\")\n", - " f.write(f\"# Best hyperparameters from Optuna optimization\\n\")\n", - " f.write(f\"# Generated: {pd.Timestamp.now()}\\n\\n\")\n", - " f.write(f\"export HIDDEN1={best_params['hidden1']}\\n\")\n", - " f.write(f\"export HIDDEN2={best_params['hidden2']}\\n\")\n", - " f.write(f\"export DROPOUT_RATE={best_params['dropout_rate']}\\n\")\n", - " f.write(f\"export LEARNING_RATE={best_params['lr']}\\n\")\n", - " f.write(f\"export BATCH_SIZE={best_params['batch_size']}\\n\")\n", - " f.write(f\"export WEIGHT_DECAY={best_params['weight_decay']}\\n\")\n", - " f.write(f\"export BEST_VAL_F1={study.best_value}\\n\")\n", + "# # Save to shell script format\n", + "# with open('outputs/model_config.sh', 'w') as f:\n", + "# f.write(f\"#!/bin/bash\\n\")\n", + "# f.write(f\"# Best hyperparameters from Optuna optimization\\n\")\n", + "# f.write(f\"# Generated: {pd.Timestamp.now()}\\n\\n\")\n", + "# f.write(f\"export HIDDEN1={best_params['hidden1']}\\n\")\n", + "# f.write(f\"export HIDDEN2={best_params['hidden2']}\\n\")\n", + "# f.write(f\"export DROPOUT_RATE={best_params['dropout_rate']}\\n\")\n", + "# f.write(f\"export LEARNING_RATE={best_params['lr']}\\n\")\n", + "# f.write(f\"export BATCH_SIZE={best_params['batch_size']}\\n\")\n", + "# f.write(f\"export WEIGHT_DECAY={best_params['weight_decay']}\\n\")\n", + "# f.write(f\"export BEST_VAL_F1={study.best_value}\\n\")\n", "\n", - "print(\"\\n✓ Saved hyperparameters to outputs/best_hyperparameters.json\")\n", - "print(\"✓ Saved hyperparameters to outputs/model_config.sh\")" + "# print(\"\\n✓ Saved hyperparameters to outputs/best_hyperparameters.json\")\n", + "# print(\"✓ Saved hyperparameters to outputs/model_config.sh\")" ] }, { @@ -244031,7 +244531,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "5b33848f", "metadata": {}, "outputs": [ @@ -244065,50 +244565,50 @@ } ], "source": [ - "import json\n", + "# import json\n", "\n", - "# Save hyperparameters to JSON (easier for Makefile to read)\n", - "hyperparams_json = {\n", - " 'hidden1': best_params['hidden1'],\n", - " 'hidden2': best_params['hidden2'],\n", - " 'dropout_rate': float(best_params['dropout_rate']),\n", - " 'lr': float(best_params['lr']),\n", - " 'weight_decay': float(best_params['weight_decay']),\n", - " 'batch_size': best_params['batch_size'],\n", - " 'best_val_f1': float(best_val_f1),\n", - " 'num_features': int(X_train.shape[1]),\n", - " 'num_classes': len(le.classes_),\n", - " 'epochs_trained': len(train_losses_tuned),\n", - " 'optuna_study_name': study.study_name,\n", - " 'optuna_trials': len(study.trials)\n", - "}\n", + "# # Save hyperparameters to JSON (easier for Makefile to read)\n", + "# hyperparams_json = {\n", + "# 'hidden1': best_params['hidden1'],\n", + "# 'hidden2': best_params['hidden2'],\n", + "# 'dropout_rate': float(best_params['dropout_rate']),\n", + "# 'lr': float(best_params['lr']),\n", + "# 'weight_decay': float(best_params['weight_decay']),\n", + "# 'batch_size': best_params['batch_size'],\n", + "# 'best_val_f1': float(best_val_f1),\n", + "# 'num_features': int(X_train.shape[1]),\n", + "# 'num_classes': len(le.classes_),\n", + "# 'epochs_trained': len(train_losses_tuned),\n", + "# 'optuna_study_name': study.study_name,\n", + "# 'optuna_trials': len(study.trials)\n", + "# }\n", "\n", - "# Save to JSON\n", - "with open('outputs/best_hyperparameters.json', 'w') as f:\n", - " json.dump(hyperparams_json, f, indent=2)\n", + "# # Save to JSON\n", + "# with open('outputs/best_hyperparameters.json', 'w') as f:\n", + "# json.dump(hyperparams_json, f, indent=2)\n", "\n", - "print(\"✓ Saved hyperparameters to JSON: outputs/best_hyperparameters.json\")\n", - "print(\"\\nHyperparameters:\")\n", - "print(json.dumps(hyperparams_json, indent=2))\n", + "# print(\"✓ Saved hyperparameters to JSON: outputs/best_hyperparameters.json\")\n", + "# print(\"\\nHyperparameters:\")\n", + "# print(json.dumps(hyperparams_json, indent=2))\n", "\n", - "# Also create a simple config file for shell scripts\n", - "with open('outputs/model_config.sh', 'w') as f:\n", - " f.write(\"#!/bin/bash\\n\")\n", - " f.write(\"# Model hyperparameters (auto-generated from Optuna optimization)\\n\\n\")\n", - " for key, value in hyperparams_json.items():\n", - " # Convert Python variable names to uppercase shell variables\n", - " shell_var = key.upper()\n", - " f.write(f'export {shell_var}=\"{value}\"\\n')\n", + "# # Also create a simple config file for shell scripts\n", + "# with open('outputs/model_config.sh', 'w') as f:\n", + "# f.write(\"#!/bin/bash\\n\")\n", + "# f.write(\"# Model hyperparameters (auto-generated from Optuna optimization)\\n\\n\")\n", + "# for key, value in hyperparams_json.items():\n", + "# # Convert Python variable names to uppercase shell variables\n", + "# shell_var = key.upper()\n", + "# f.write(f'export {shell_var}=\"{value}\"\\n')\n", "\n", - "print(\"✓ Saved shell config: outputs/model_config.sh\")\n", - "print(\"\\nYour Makefile can now:\")\n", - "print(\" 1. Load JSON: jq .hidden1 outputs/best_hyperparameters.json\")\n", - "print(\" 2. Source shell: source outputs/model_config.sh && echo $HIDDEN1\")" + "# print(\"✓ Saved shell config: outputs/model_config.sh\")\n", + "# print(\"\\nYour Makefile can now:\")\n", + "# print(\" 1. Load JSON: jq .hidden1 outputs/best_hyperparameters.json\")\n", + "# print(\" 2. Source shell: source outputs/model_config.sh && echo $HIDDEN1\")" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "id": "c775f867", "metadata": {}, "outputs": [ @@ -244146,138 +244646,138 @@ } ], "source": [ - "import matplotlib.pyplot as plt\n", + "# import matplotlib.pyplot as plt\n", "\n", - "fig, axes = plt.subplots(2, 3, figsize=(18, 10))\n", + "# fig, axes = plt.subplots(2, 3, figsize=(18, 10))\n", "\n", - "# 1. Optimization History\n", - "ax = axes[0, 0]\n", - "trial_numbers = [t.number for t in study.trials if t.value is not None]\n", - "trial_values = [t.value for t in study.trials if t.value is not None]\n", - "ax.plot(trial_numbers, trial_values, 'o-', alpha=0.6, linewidth=2)\n", - "ax.axhline(y=study.best_value, color='r', linestyle='--', linewidth=2, label=f'Best: {study.best_value:.4f}')\n", - "ax.set_xlabel('Trial Number', fontsize=12)\n", - "ax.set_ylabel('Validation F1 Score', fontsize=12)\n", - "ax.set_title('Optimization History', fontsize=14, fontweight='bold')\n", - "ax.legend(fontsize=11)\n", - "ax.grid(True, alpha=0.3)\n", + "# # 1. Optimization History\n", + "# ax = axes[0, 0]\n", + "# trial_numbers = [t.number for t in study.trials if t.value is not None]\n", + "# trial_values = [t.value for t in study.trials if t.value is not None]\n", + "# ax.plot(trial_numbers, trial_values, 'o-', alpha=0.6, linewidth=2)\n", + "# ax.axhline(y=study.best_value, color='r', linestyle='--', linewidth=2, label=f'Best: {study.best_value:.4f}')\n", + "# ax.set_xlabel('Trial Number', fontsize=12)\n", + "# ax.set_ylabel('Validation F1 Score', fontsize=12)\n", + "# ax.set_title('Optimization History', fontsize=14, fontweight='bold')\n", + "# ax.legend(fontsize=11)\n", + "# ax.grid(True, alpha=0.3)\n", "\n", - "# 2. Learning Rate vs F1\n", - "ax = axes[0, 1]\n", - "lrs = [t.params['lr'] for t in study.trials if t.value is not None]\n", - "f1_scores = [t.value for t in study.trials if t.value is not None]\n", - "scatter = ax.scatter(lrs, f1_scores, c=f1_scores, cmap='viridis', s=100, alpha=0.7, edgecolors='black')\n", - "ax.set_xscale('log')\n", - "ax.set_xlabel('Learning Rate', fontsize=12)\n", - "ax.set_ylabel('Validation F1 Score', fontsize=12)\n", - "ax.set_title('Learning Rate vs F1 Score', fontsize=14, fontweight='bold')\n", - "ax.grid(True, alpha=0.3)\n", - "plt.colorbar(scatter, ax=ax, label='F1 Score')\n", + "# # 2. Learning Rate vs F1\n", + "# ax = axes[0, 1]\n", + "# lrs = [t.params['lr'] for t in study.trials if t.value is not None]\n", + "# f1_scores = [t.value for t in study.trials if t.value is not None]\n", + "# scatter = ax.scatter(lrs, f1_scores, c=f1_scores, cmap='viridis', s=100, alpha=0.7, edgecolors='black')\n", + "# ax.set_xscale('log')\n", + "# ax.set_xlabel('Learning Rate', fontsize=12)\n", + "# ax.set_ylabel('Validation F1 Score', fontsize=12)\n", + "# ax.set_title('Learning Rate vs F1 Score', fontsize=14, fontweight='bold')\n", + "# ax.grid(True, alpha=0.3)\n", + "# plt.colorbar(scatter, ax=ax, label='F1 Score')\n", "\n", - "# 3. Architecture Performance\n", - "ax = axes[0, 2]\n", - "# Compute hidden2 for each trial (same logic as in objective function)\n", - "all_sizes = [32, 64, 128, 192, 250]\n", - "architectures = []\n", - "for t in study.trials:\n", - " if t.value is not None:\n", - " hidden1 = t.params['hidden1']\n", - " hidden2_raw = t.params['hidden2_raw']\n", - " valid_sizes = [s for s in all_sizes if s <= hidden1]\n", - " hidden2 = valid_sizes[hidden2_raw % len(valid_sizes)]\n", - " architectures.append((hidden1, hidden2))\n", + "# # 3. Architecture Performance\n", + "# ax = axes[0, 2]\n", + "# # Compute hidden2 for each trial (same logic as in objective function)\n", + "# all_sizes = [32, 64, 128, 192, 250]\n", + "# architectures = []\n", + "# for t in study.trials:\n", + "# if t.value is not None:\n", + "# hidden1 = t.params['hidden1']\n", + "# hidden2_raw = t.params['hidden2_raw']\n", + "# valid_sizes = [s for s in all_sizes if s <= hidden1]\n", + "# hidden2 = valid_sizes[hidden2_raw % len(valid_sizes)]\n", + "# architectures.append((hidden1, hidden2))\n", "\n", - "arch_f1s = {}\n", - "for arch, f1 in zip(architectures, f1_scores):\n", - " arch_str = f\"{arch[0]}-{arch[1]}\"\n", - " if arch_str not in arch_f1s:\n", - " arch_f1s[arch_str] = []\n", - " arch_f1s[arch_str].append(f1)\n", + "# arch_f1s = {}\n", + "# for arch, f1 in zip(architectures, f1_scores):\n", + "# arch_str = f\"{arch[0]}-{arch[1]}\"\n", + "# if arch_str not in arch_f1s:\n", + "# arch_f1s[arch_str] = []\n", + "# arch_f1s[arch_str].append(f1)\n", "\n", - "arch_labels = sorted(arch_f1s.keys())\n", - "arch_means = [np.mean(arch_f1s[arch]) for arch in arch_labels]\n", - "arch_stds = [np.std(arch_f1s[arch]) if len(arch_f1s[arch]) > 1 else 0 for arch in arch_labels]\n", + "# arch_labels = sorted(arch_f1s.keys())\n", + "# arch_means = [np.mean(arch_f1s[arch]) for arch in arch_labels]\n", + "# arch_stds = [np.std(arch_f1s[arch]) if len(arch_f1s[arch]) > 1 else 0 for arch in arch_labels]\n", "\n", - "bars = ax.barh(arch_labels, arch_means, xerr=arch_stds, alpha=0.7, capsize=5)\n", - "ax.set_xlabel('Mean F1 Score', fontsize=12)\n", - "ax.set_ylabel('Architecture (hidden1-hidden2)', fontsize=12)\n", - "ax.set_title('Architecture Performance', fontsize=14, fontweight='bold')\n", - "ax.grid(True, alpha=0.3, axis='x')\n", + "# bars = ax.barh(arch_labels, arch_means, xerr=arch_stds, alpha=0.7, capsize=5)\n", + "# ax.set_xlabel('Mean F1 Score', fontsize=12)\n", + "# ax.set_ylabel('Architecture (hidden1-hidden2)', fontsize=12)\n", + "# ax.set_title('Architecture Performance', fontsize=14, fontweight='bold')\n", + "# ax.grid(True, alpha=0.3, axis='x')\n", "\n", - "# Highlight best architecture (compute from best_params which now has hidden2)\n", - "hidden1_best = study.best_params['hidden1']\n", - "hidden2_raw_best = study.best_params['hidden2_raw']\n", - "valid_sizes_best = [s for s in all_sizes if s <= hidden1_best]\n", - "hidden2_best = valid_sizes_best[hidden2_raw_best % len(valid_sizes_best)]\n", - "best_arch = f\"{hidden1_best}-{hidden2_best}\"\n", - "for i, label in enumerate(arch_labels):\n", - " if label == best_arch:\n", - " bars[i].set_color('red')\n", - " bars[i].set_alpha(0.9)\n", + "# # Highlight best architecture (compute from best_params which now has hidden2)\n", + "# hidden1_best = study.best_params['hidden1']\n", + "# hidden2_raw_best = study.best_params['hidden2_raw']\n", + "# valid_sizes_best = [s for s in all_sizes if s <= hidden1_best]\n", + "# hidden2_best = valid_sizes_best[hidden2_raw_best % len(valid_sizes_best)]\n", + "# best_arch = f\"{hidden1_best}-{hidden2_best}\"\n", + "# for i, label in enumerate(arch_labels):\n", + "# if label == best_arch:\n", + "# bars[i].set_color('red')\n", + "# bars[i].set_alpha(0.9)\n", "\n", - "# 4. Batch Size Performance\n", - "ax = axes[1, 0]\n", - "batch_sizes = [t.params['batch_size'] for t in study.trials if t.value is not None]\n", - "batch_f1s = {}\n", - "for bs, f1 in zip(batch_sizes, f1_scores):\n", - " if bs not in batch_f1s:\n", - " batch_f1s[bs] = []\n", - " batch_f1s[bs].append(f1)\n", + "# # 4. Batch Size Performance\n", + "# ax = axes[1, 0]\n", + "# batch_sizes = [t.params['batch_size'] for t in study.trials if t.value is not None]\n", + "# batch_f1s = {}\n", + "# for bs, f1 in zip(batch_sizes, f1_scores):\n", + "# if bs not in batch_f1s:\n", + "# batch_f1s[bs] = []\n", + "# batch_f1s[bs].append(f1)\n", "\n", - "batch_labels = [str(bs) for bs in sorted(batch_f1s.keys())]\n", - "batch_means = [np.mean(batch_f1s[int(bs)]) for bs in batch_labels]\n", - "batch_stds = [np.std(batch_f1s[int(bs)]) if len(batch_f1s[int(bs)]) > 1 else 0 for bs in batch_labels]\n", + "# batch_labels = [str(bs) for bs in sorted(batch_f1s.keys())]\n", + "# batch_means = [np.mean(batch_f1s[int(bs)]) for bs in batch_labels]\n", + "# batch_stds = [np.std(batch_f1s[int(bs)]) if len(batch_f1s[int(bs)]) > 1 else 0 for bs in batch_labels]\n", "\n", - "ax.bar(batch_labels, batch_means, yerr=batch_stds, alpha=0.7, capsize=5, color='skyblue', edgecolor='black')\n", - "ax.set_xlabel('Batch Size', fontsize=12)\n", - "ax.set_ylabel('Mean F1 Score', fontsize=12)\n", - "ax.set_title('Batch Size Performance', fontsize=14, fontweight='bold')\n", - "ax.grid(True, alpha=0.3, axis='y')\n", + "# ax.bar(batch_labels, batch_means, yerr=batch_stds, alpha=0.7, capsize=5, color='skyblue', edgecolor='black')\n", + "# ax.set_xlabel('Batch Size', fontsize=12)\n", + "# ax.set_ylabel('Mean F1 Score', fontsize=12)\n", + "# ax.set_title('Batch Size Performance', fontsize=14, fontweight='bold')\n", + "# ax.grid(True, alpha=0.3, axis='y')\n", "\n", - "# 5. Dropout Rate vs F1\n", - "ax = axes[1, 1]\n", - "dropouts = [t.params['dropout_rate'] for t in study.trials if t.value is not None]\n", - "scatter = ax.scatter(dropouts, f1_scores, c=f1_scores, cmap='plasma', s=100, alpha=0.7, edgecolors='black')\n", - "ax.set_xlabel('Dropout Rate', fontsize=12)\n", - "ax.set_ylabel('Validation F1 Score', fontsize=12)\n", - "ax.set_title('Dropout Rate vs F1 Score', fontsize=14, fontweight='bold')\n", - "ax.grid(True, alpha=0.3)\n", - "plt.colorbar(scatter, ax=ax, label='F1 Score')\n", + "# # 5. Dropout Rate vs F1\n", + "# ax = axes[1, 1]\n", + "# dropouts = [t.params['dropout_rate'] for t in study.trials if t.value is not None]\n", + "# scatter = ax.scatter(dropouts, f1_scores, c=f1_scores, cmap='plasma', s=100, alpha=0.7, edgecolors='black')\n", + "# ax.set_xlabel('Dropout Rate', fontsize=12)\n", + "# ax.set_ylabel('Validation F1 Score', fontsize=12)\n", + "# ax.set_title('Dropout Rate vs F1 Score', fontsize=14, fontweight='bold')\n", + "# ax.grid(True, alpha=0.3)\n", + "# plt.colorbar(scatter, ax=ax, label='F1 Score')\n", "\n", - "# 6. Weight Decay vs F1\n", - "ax = axes[1, 2]\n", - "weight_decays = [t.params['weight_decay'] for t in study.trials if t.value is not None]\n", - "scatter = ax.scatter(weight_decays, f1_scores, c=f1_scores, cmap='coolwarm', s=100, alpha=0.7, edgecolors='black')\n", - "ax.set_xscale('log')\n", - "ax.set_xlabel('Weight Decay', fontsize=12)\n", - "ax.set_ylabel('Validation F1 Score', fontsize=12)\n", - "ax.set_title('Weight Decay vs F1 Score', fontsize=14, fontweight='bold')\n", - "ax.grid(True, alpha=0.3)\n", - "plt.colorbar(scatter, ax=ax, label='F1 Score')\n", + "# # 6. Weight Decay vs F1\n", + "# ax = axes[1, 2]\n", + "# weight_decays = [t.params['weight_decay'] for t in study.trials if t.value is not None]\n", + "# scatter = ax.scatter(weight_decays, f1_scores, c=f1_scores, cmap='coolwarm', s=100, alpha=0.7, edgecolors='black')\n", + "# ax.set_xscale('log')\n", + "# ax.set_xlabel('Weight Decay', fontsize=12)\n", + "# ax.set_ylabel('Validation F1 Score', fontsize=12)\n", + "# ax.set_title('Weight Decay vs F1 Score', fontsize=14, fontweight='bold')\n", + "# ax.grid(True, alpha=0.3)\n", + "# plt.colorbar(scatter, ax=ax, label='F1 Score')\n", "\n", - "plt.tight_layout()\n", - "plt.savefig('outputs/optuna_optimization_results.png', dpi=300, bbox_inches='tight')\n", - "plt.show()\n", + "# plt.tight_layout()\n", + "# plt.savefig('outputs/optuna_optimization_results.png', dpi=300, bbox_inches='tight')\n", + "# plt.show()\n", "\n", - "print(\"\\n\" + \"=\"*70)\n", - "print(\"OPTIMIZATION SUMMARY\")\n", - "print(\"=\"*70)\n", - "print(f\"Total trials completed: {len([t for t in study.trials if t.value is not None])}\")\n", - "print(f\"Best F1 score: {study.best_value:.4f}\")\n", - "print(f\"\\nBest hyperparameters:\")\n", - "# Compute hidden2 for display (using same logic as before)\n", - "all_sizes = [32, 64, 128, 192, 250]\n", - "hidden1_best = study.best_params['hidden1']\n", - "hidden2_raw_best = study.best_params['hidden2_raw']\n", - "valid_sizes_best = [s for s in all_sizes if s <= hidden1_best]\n", - "hidden2_best = valid_sizes_best[hidden2_raw_best % len(valid_sizes_best)]\n", - "print(f\" Architecture: {hidden1_best}-{hidden2_best}\")\n", - "print(f\" Learning rate: {study.best_params['lr']:.6f}\")\n", - "print(f\" Batch size: {study.best_params['batch_size']}\")\n", - "print(f\" Dropout: {study.best_params['dropout_rate']:.3f}\")\n", - "print(f\" Weight decay: {study.best_params['weight_decay']:.6f}\")\n", - "print(\"=\"*70)\n", - "print(\"\\n✓ Visualization saved to: outputs/optuna_optimization_results.png\")" + "# print(\"\\n\" + \"=\"*70)\n", + "# print(\"OPTIMIZATION SUMMARY\")\n", + "# print(\"=\"*70)\n", + "# print(f\"Total trials completed: {len([t for t in study.trials if t.value is not None])}\")\n", + "# print(f\"Best F1 score: {study.best_value:.4f}\")\n", + "# print(f\"\\nBest hyperparameters:\")\n", + "# # Compute hidden2 for display (using same logic as before)\n", + "# all_sizes = [32, 64, 128, 192, 250]\n", + "# hidden1_best = study.best_params['hidden1']\n", + "# hidden2_raw_best = study.best_params['hidden2_raw']\n", + "# valid_sizes_best = [s for s in all_sizes if s <= hidden1_best]\n", + "# hidden2_best = valid_sizes_best[hidden2_raw_best % len(valid_sizes_best)]\n", + "# print(f\" Architecture: {hidden1_best}-{hidden2_best}\")\n", + "# print(f\" Learning rate: {study.best_params['lr']:.6f}\")\n", + "# print(f\" Batch size: {study.best_params['batch_size']}\")\n", + "# print(f\" Dropout: {study.best_params['dropout_rate']:.3f}\")\n", + "# print(f\" Weight decay: {study.best_params['weight_decay']:.6f}\")\n", + "# print(\"=\"*70)\n", + "# print(\"\\n✓ Visualization saved to: outputs/optuna_optimization_results.png\")" ] }, { @@ -244290,7 +244790,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 11, "id": "9614360d", "metadata": {}, "outputs": [ @@ -244321,13 +244821,17 @@ "\n", "Training for up to 100 epochs with patience=10...\n", "This may take 5-10 minutes...\n", + "\n", + "\n", + "Training for up to 100 epochs with patience=10...\n", + "This may take 5-10 minutes...\n", "\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "850390b73e3e4866a1c85a7a878e928e", + "model_id": "b4a805f5d1074915bb162ae9e5ccd284", "version_major": 2, "version_minor": 0 }, @@ -244343,14 +244847,14 @@ "output_type": "stream", "text": [ "\n", - "Early stopping at epoch 70\n", + "Early stopping at epoch 78\n", "\n", "======================================================================\n", "FINAL MODEL TRAINING COMPLETE\n", "======================================================================\n", - "Best validation F1 score: 0.8536\n", - "Final validation accuracy: 0.8570\n", - "Total epochs trained: 70\n", + "Best validation F1 score: 0.8570\n", + "Final validation accuracy: 0.8596\n", + "Total epochs trained: 78\n", "======================================================================\n", "\n", "======================================================================\n", @@ -244364,7 +244868,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -244382,9 +244886,9 @@ "======================================================================\n", "\n", "Overall Accuracy Metrics:\n", - " Top-1 Accuracy: 0.8570 (49422/57671 pitches)\n", - " Top-3 Accuracy: 0.9736 (56150/57671 pitches)\n", - " Top-5 Accuracy: 0.9909 (57149/57671 pitches)\n", + " Top-1 Accuracy: 0.8596 (49575/57671 pitches)\n", + " Top-3 Accuracy: 0.9744 (56195/57671 pitches)\n", + " Top-5 Accuracy: 0.9905 (57126/57671 pitches)\n", "\n", "======================================================================\n", "PER-PITCHER ACCURACY\n", @@ -244395,34 +244899,34 @@ "----------------------------------------------------------------------\n", "1 Lodolo, Nick 510 510 1.0000 \n", "2 Sears, JP 500 500 1.0000 \n", - "3 Hendricks, Kyle 514 515 0.9981 \n", - "4 Verlander, Justin 535 537 0.9963 \n", - "5 Peralta, Freddy 613 617 0.9935 \n", - "6 Rodriguez, Eduardo 525 533 0.9850 \n", - "7 Heaney, Andrew 409 416 0.9832 \n", - "8 Ryan, Joe 559 570 0.9807 \n", - "9 Sale, Chris 395 406 0.9729 \n", - "10 Littell, Zack 532 547 0.9726 \n", + "3 Peralta, Freddy 615 617 0.9968 \n", + "4 Verlander, Justin 534 537 0.9944 \n", + "5 Heaney, Andrew 413 416 0.9928 \n", + "6 Falter, Bailey 410 415 0.9880 \n", + "7 Liberatore, Matthew 491 497 0.9879 \n", + "8 Littell, Zack 538 547 0.9835 \n", + "9 Hendricks, Kyle 506 515 0.9825 \n", + "10 Rodriguez, Eduardo 522 533 0.9794 \n", "\n", "Bottom 10 Least Accurate Pitchers:\n", "Rank Pitcher Name Correct Total Accuracy \n", "----------------------------------------------------------------------\n", - "1 Irvin, Jake 426 607 0.7018 \n", - "2 Giolito, Lucas 299 474 0.6308 \n", - "3 Cecconi, Slade 259 413 0.6271 \n", - "4 Lorenzen, Michael 298 491 0.6069 \n", - "5 Pfaadt, Brandon 368 611 0.6023 \n", - "6 Severino, Luis 327 546 0.5989 \n", - "7 Senzatela, Antonio 289 491 0.5886 \n", - "8 Smith, Shane 267 475 0.5621 \n", - "9 Martin, Davis 260 473 0.5497 \n", - "10 Vásquez, Randy 225 430 0.5233 \n", + "1 Keller, Mitch 403 574 0.7021 \n", + "2 May, Dustin 290 447 0.6488 \n", + "3 Senzatela, Antonio 316 491 0.6436 \n", + "4 Martin, Davis 299 473 0.6321 \n", + "5 Cecconi, Slade 260 413 0.6295 \n", + "6 Severino, Luis 341 546 0.6245 \n", + "7 Smith, Shane 281 475 0.5916 \n", + "8 Pfaadt, Brandon 350 611 0.5728 \n", + "9 Lorenzen, Michael 265 491 0.5397 \n", + "10 Vásquez, Randy 213 430 0.4953 \n", "\n", "Per-Pitcher Accuracy Statistics:\n", - " Mean: 0.8534\n", - " Median: 0.8746\n", - " Std: 0.1091\n", - " Min: 0.5233\n", + " Mean: 0.8547\n", + " Median: 0.8721\n", + " Std: 0.1118\n", + " Min: 0.4953\n", " Max: 1.0000\n", "\n", "✓ Saved per-pitcher accuracy to: outputs/per_pitcher_accuracy.txt\n", @@ -244430,7 +244934,7 @@ "\n", "✓ Saved tuned model to: outputs/model_tuned.pt\n", "✓ Saved best hyperparameters to: outputs/best_hyperparameters.pkl\n", - "✓ Saved Optuna study to: outputs/optuna_study.pkl\n", + "ℹ Skipping Optuna study save (using pre-saved hyperparameters)\n", "✓ Saved training history to: outputs/training_history.pkl\n", "✓ Saved scaler to: outputs/scaler.pkl\n", "✓ Saved label encoder to: outputs/label_encoder.pkl\n", @@ -244441,9 +244945,9 @@ "======================================================================\n", "\n", "Overall Accuracy Metrics:\n", - " Top-1 Accuracy: 0.8570 (49422/57671 pitches)\n", - " Top-3 Accuracy: 0.9736 (56150/57671 pitches)\n", - " Top-5 Accuracy: 0.9909 (57149/57671 pitches)\n", + " Top-1 Accuracy: 0.8596 (49575/57671 pitches)\n", + " Top-3 Accuracy: 0.9744 (56195/57671 pitches)\n", + " Top-5 Accuracy: 0.9905 (57126/57671 pitches)\n", "\n", "======================================================================\n", "PER-PITCHER ACCURACY\n", @@ -244454,34 +244958,34 @@ "----------------------------------------------------------------------\n", "1 Lodolo, Nick 510 510 1.0000 \n", "2 Sears, JP 500 500 1.0000 \n", - "3 Hendricks, Kyle 514 515 0.9981 \n", - "4 Verlander, Justin 535 537 0.9963 \n", - "5 Peralta, Freddy 613 617 0.9935 \n", - "6 Rodriguez, Eduardo 525 533 0.9850 \n", - "7 Heaney, Andrew 409 416 0.9832 \n", - "8 Ryan, Joe 559 570 0.9807 \n", - "9 Sale, Chris 395 406 0.9729 \n", - "10 Littell, Zack 532 547 0.9726 \n", + "3 Peralta, Freddy 615 617 0.9968 \n", + "4 Verlander, Justin 534 537 0.9944 \n", + "5 Heaney, Andrew 413 416 0.9928 \n", + "6 Falter, Bailey 410 415 0.9880 \n", + "7 Liberatore, Matthew 491 497 0.9879 \n", + "8 Littell, Zack 538 547 0.9835 \n", + "9 Hendricks, Kyle 506 515 0.9825 \n", + "10 Rodriguez, Eduardo 522 533 0.9794 \n", "\n", "Bottom 10 Least Accurate Pitchers:\n", "Rank Pitcher Name Correct Total Accuracy \n", "----------------------------------------------------------------------\n", - "1 Irvin, Jake 426 607 0.7018 \n", - "2 Giolito, Lucas 299 474 0.6308 \n", - "3 Cecconi, Slade 259 413 0.6271 \n", - "4 Lorenzen, Michael 298 491 0.6069 \n", - "5 Pfaadt, Brandon 368 611 0.6023 \n", - "6 Severino, Luis 327 546 0.5989 \n", - "7 Senzatela, Antonio 289 491 0.5886 \n", - "8 Smith, Shane 267 475 0.5621 \n", - "9 Martin, Davis 260 473 0.5497 \n", - "10 Vásquez, Randy 225 430 0.5233 \n", + "1 Keller, Mitch 403 574 0.7021 \n", + "2 May, Dustin 290 447 0.6488 \n", + "3 Senzatela, Antonio 316 491 0.6436 \n", + "4 Martin, Davis 299 473 0.6321 \n", + "5 Cecconi, Slade 260 413 0.6295 \n", + "6 Severino, Luis 341 546 0.6245 \n", + "7 Smith, Shane 281 475 0.5916 \n", + "8 Pfaadt, Brandon 350 611 0.5728 \n", + "9 Lorenzen, Michael 265 491 0.5397 \n", + "10 Vásquez, Randy 213 430 0.4953 \n", "\n", "Per-Pitcher Accuracy Statistics:\n", - " Mean: 0.8534\n", - " Median: 0.8746\n", - " Std: 0.1091\n", - " Min: 0.5233\n", + " Mean: 0.8547\n", + " Median: 0.8721\n", + " Std: 0.1118\n", + " Min: 0.4953\n", " Max: 1.0000\n", "\n", "✓ Saved per-pitcher accuracy to: outputs/per_pitcher_accuracy.txt\n", @@ -244489,7 +244993,7 @@ "\n", "✓ Saved tuned model to: outputs/model_tuned.pt\n", "✓ Saved best hyperparameters to: outputs/best_hyperparameters.pkl\n", - "✓ Saved Optuna study to: outputs/optuna_study.pkl\n", + "ℹ Skipping Optuna study save (using pre-saved hyperparameters)\n", "✓ Saved training history to: outputs/training_history.pkl\n", "✓ Saved scaler to: outputs/scaler.pkl\n", "✓ Saved label encoder to: outputs/label_encoder.pkl\n", @@ -244888,7 +245392,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 12, "id": "e5380749", "metadata": {}, "outputs": [ @@ -244939,7 +245443,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 13, "id": "cef111b8", "metadata": {}, "outputs": [ diff --git a/README.md b/README.md index ca097c1..ed6a381 100644 --- a/README.md +++ b/README.md @@ -20,7 +20,7 @@ We are building a model that, given a single pitch based on Statcast features an ### How We Achieved These Goals **Goal 1 - Pitcher Classification:** -We trained a Multi-Layer Perceptron (MLP) neural network on 293,185 pitches from 110 qualified MLB pitchers. The model achieved 83% top-1 accuracy and 96% top-3 accuracy. The key to success was careful feature engineering, particularly normalizing handedness to prevent the model from using left vs right as a shortcut instead of learning pitcher-specific characteristics. +We trained a Multi-Layer Perceptron (MLP) neural network on 293,185 pitches from 110 qualified MLB pitchers. The model achieved 85% top-1 accuracy, 97% top-3 accuracy, and 99% top-5 accuracy. The key to success was careful feature engineering, particularly normalizing handedness to prevent the model from using left vs right as a shortcut instead of learning pitcher-specific characteristics. **Goal 2 - Similarity Analysis:** Rather than just averaging pitch features, we leveraged the trained classifier's confusion patterns. When the model consistently confuses pitcher A for pitcher B, it reveals they have similar pitch profiles. We developed a confusion-based similarity metric that normalizes by each pitcher's total confusion mass, creating comparable scores even between highly distinctive and generic pitchers. This approach captures which pitchers the model actually struggles to distinguish in practice, revealing similarities that simple feature averaging would miss.