{ "cells": [ { "cell_type": "markdown", "id": "14c8221b", "metadata": {}, "source": [ "# Multi-Metric Hyperparameter Search on Iris\n", "\n", "This notebook keeps the original objective of the Iris multi-metric tutorial: show how `GASearchCV` can optimize with multiple scorers and refit the final estimator using one selected metric.\n", "\n", "## Menu\n", "\n", "1. [Problem Setup](#problem-setup)\n", "2. [Define Multiple Metrics](#define-multiple-metrics)\n", "3. [Configure GASearchCV](#configure-gasearchcv)\n", "4. [Inspect Best Parameters and Test Metrics](#inspect-best-parameters-and-test-metrics)\n", "5. [Explore Multi-Metric cv_results_](#explore-multi-metric-cv-results)\n", "6. [Read Optimizer Telemetry](#read-optimizer-telemetry)\n", "7. [Change the Refit Metric](#change-the-refit-metric)\n", "8. [Practical Notes](#practical-notes)" ] }, { "cell_type": "markdown", "id": "e236187d", "metadata": {}, "source": [ "## Problem Setup\n", "\n", "Iris is a compact multi-class classification dataset. The small size keeps this notebook fast, while still making it useful for demonstrating multi-metric evaluation.\n", "\n", "We use a `Pipeline` with scaling plus multinomial logistic regression. The genetic search tunes regularization and solver-related settings." ] }, { "cell_type": "code", "execution_count": null, "id": "919a94ea", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:04.089875Z", "iopub.status.busy": "2026-06-20T05:29:04.089581Z", "iopub.status.idle": "2026-06-20T05:29:11.126986Z", "shell.execute_reply": "2026-06-20T05:29:11.125579Z" } }, "outputs": [], "source": [ "import warnings\n", "from pprint import pprint\n", "\n", "import pandas as pd\n", "from sklearn.datasets import load_iris\n", "from sklearn.linear_model import LogisticRegression\n", "from sklearn.metrics import accuracy_score, balanced_accuracy_score, f1_score, make_scorer\n", "from sklearn.model_selection import StratifiedKFold, train_test_split\n", "from sklearn.pipeline import Pipeline\n", "from sklearn.preprocessing import StandardScaler\n", "\n", "from sklearn_genetic import (\n", " EvolutionConfig,\n", " GASearchCV,\n", " OptimizationConfig,\n", " PopulationConfig,\n", " RuntimeConfig,\n", ")\n", "from sklearn_genetic.callbacks import ConsecutiveStopping, DeltaThreshold, TimerStopping\n", "from sklearn_genetic.schedules import ExponentialAdapter, InverseAdapter\n", "from sklearn_genetic.space import Categorical, Continuous, Integer\n", "\n", "warnings.filterwarnings(\"ignore\", category=UserWarning)\n", "\n", "RANDOM_STATE = 42" ] }, { "cell_type": "code", "execution_count": 2, "id": "69e43c70", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:11.130860Z", "iopub.status.busy": "2026-06-20T05:29:11.130171Z", "iopub.status.idle": "2026-06-20T05:29:11.171379Z", "shell.execute_reply": "2026-06-20T05:29:11.170121Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Training shape: (105, 4)\n", "Test shape: (45, 4)\n", "Classes: ['setosa', 'versicolor', 'virginica']\n" ] } ], "source": [ "iris = load_iris(as_frame=True)\n", "X = iris.data\n", "y = iris.target\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(\n", " X,\n", " y,\n", " test_size=0.30,\n", " stratify=y,\n", " random_state=RANDOM_STATE,\n", ")\n", "\n", "cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=RANDOM_STATE)\n", "\n", "print(f\"Training shape: {X_train.shape}\")\n", "print(f\"Test shape: {X_test.shape}\")\n", "print(f\"Classes: {iris.target_names.tolist()}\")" ] }, { "cell_type": "markdown", "id": "c08a5ea5", "metadata": {}, "source": [ "## Define Multiple Metrics\n", "\n", "A multi-metric search receives a dictionary of scorers. The `refit` parameter decides which metric is used to choose `best_params_` and refit `best_estimator_`.\n", "\n", "Here we track three metrics:\n", "\n", "- `accuracy`: overall correctness.\n", "- `balanced_accuracy`: average recall across classes.\n", "- `f1_macro`: macro-averaged F1, useful when classes should contribute equally.\n", "\n", "We set `refit=\"balanced_accuracy\"` so the final model is selected by class-balanced behavior." ] }, { "cell_type": "code", "execution_count": 3, "id": "b910b087", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:11.175153Z", "iopub.status.busy": "2026-06-20T05:29:11.174645Z", "iopub.status.idle": "2026-06-20T05:29:11.179911Z", "shell.execute_reply": "2026-06-20T05:29:11.178783Z" } }, "outputs": [], "source": [ "scoring = {\n", " \"accuracy\": \"accuracy\",\n", " \"balanced_accuracy\": make_scorer(balanced_accuracy_score),\n", " \"f1_macro\": make_scorer(f1_score, average=\"macro\"),\n", "}" ] }, { "cell_type": "markdown", "id": "7ae80f40", "metadata": {}, "source": [ "## Configure GASearchCV\n", "\n", "This example uses optimizer controls while keeping the search small enough for a notebook.\n", "\n", "`PopulationConfig(initializer=\"smart\")` improves the first generation. `warm_start_configs` includes a sensible logistic-regression configuration. Diversity control, fitness sharing, and local search help balance exploration and exploitation." ] }, { "cell_type": "code", "execution_count": null, "id": "ada06bf1", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:11.182519Z", "iopub.status.busy": "2026-06-20T05:29:11.182169Z", "iopub.status.idle": "2026-06-20T05:29:19.982267Z", "shell.execute_reply": "2026-06-20T05:29:19.981215Z" } }, "outputs": [], "source": [ "model = Pipeline(\n", " [\n", " (\"scaler\", StandardScaler()),\n", " (\n", " \"logistic\",\n", " LogisticRegression(\n", " solver=\"saga\",\n", " max_iter=1200,\n", " random_state=RANDOM_STATE,\n", " ),\n", " ),\n", " ]\n", ")\n", "\n", "param_grid = {\n", " \"logistic__C\": Continuous(1e-3, 30.0, distribution=\"log-uniform\"),\n", " \"logistic__l1_ratio\": Continuous(0.0, 1.0),\n", " \"logistic__class_weight\": Categorical([None, \"balanced\"]),\n", " \"logistic__max_iter\": Integer(1000, 1500),\n", "}\n", "\n", "search = GASearchCV(\n", " estimator=model,\n", " param_grid=param_grid,\n", " scoring=scoring,\n", " refit=\"balanced_accuracy\",\n", " cv=cv,\n", " evolution_config=EvolutionConfig(\n", " population_size=12,\n", " generations=10,\n", " crossover_probability=ExponentialAdapter(initial_value=0.8, end_value=0.4, adaptive_rate=0.15),\n", " mutation_probability=InverseAdapter(initial_value=0.25, end_value=0.08, adaptive_rate=0.25),\n", " tournament_size=3,\n", " elitism=True,\n", " keep_top_k=3,\n", " ),\n", " population_config=PopulationConfig(\n", " initializer=\"smart\",\n", " warm_start_configs=[\n", " {\n", " \"logistic__C\": 1.0,\n", " \"logistic__l1_ratio\": 0.0,\n", " \"logistic__class_weight\": None,\n", " \"logistic__max_iter\": 1200,\n", " }\n", " ],\n", " ),\n", " runtime_config=RuntimeConfig(n_jobs=-1, parallel_backend=\"auto\", use_cache=True, verbose=True),\n", " optimization_config=OptimizationConfig(\n", " local_search=True,\n", " local_search_top_k=2,\n", " local_search_steps=1,\n", " local_search_radius=0.20,\n", " diversity_control=True,\n", " diversity_threshold=0.30,\n", " diversity_stagnation_generations=3,\n", " diversity_mutation_boost=1.8,\n", " random_immigrants_fraction=0.10,\n", " fitness_sharing=True,\n", " sharing_radius=0.40,\n", " ),\n", ")\n", "\n", "callbacks = [\n", " DeltaThreshold(threshold=0.001, generations=5, metric=\"fitness_best\"),\n", " ConsecutiveStopping(generations=7, metric=\"fitness_best\"),\n", " TimerStopping(total_seconds=90),\n", "]\n", "\n", "search.fit(X_train, y_train, callbacks=callbacks)\n" ] }, { "cell_type": "markdown", "id": "8eac76cd", "metadata": {}, "source": [ "## Inspect Best Parameters and Test Metrics\n", "\n", "Because `refit=\"balanced_accuracy\"`, the best parameters and final estimator are selected by the cross-validation rank of `balanced_accuracy`." ] }, { "cell_type": "code", "execution_count": 5, "id": "9704d9ca", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:19.984857Z", "iopub.status.busy": "2026-06-20T05:29:19.984520Z", "iopub.status.idle": "2026-06-20T05:29:19.989037Z", "shell.execute_reply": "2026-06-20T05:29:19.988015Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Refit metric: balanced_accuracy\n", "Best balanced-accuracy CV score: 0.9798\n", "Best parameters:\n", "{'logistic__C': 1.0,\n", " 'logistic__class_weight': None,\n", " 'logistic__l1_ratio': 0.0,\n", " 'logistic__max_iter': 1200}\n" ] } ], "source": [ "print(\"Refit metric:\", search.refit_metric)\n", "print(\"Best balanced-accuracy CV score:\", round(search.best_score_, 4))\n", "print(\"Best parameters:\")\n", "pprint(search.best_params_)" ] }, { "cell_type": "code", "execution_count": 6, "id": "a2f3b847", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:19.991726Z", "iopub.status.busy": "2026-06-20T05:29:19.991379Z", "iopub.status.idle": "2026-06-20T05:29:20.004974Z", "shell.execute_reply": "2026-06-20T05:29:20.003852Z" } }, "outputs": [ { "data": { "text/plain": [ "{'accuracy': 0.9111111111111111,\n", " 'balanced_accuracy': 0.9111111111111111,\n", " 'f1_macro': 0.9107142857142857}" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "predictions = search.predict(X_test)\n", "test_metrics = {\n", " \"accuracy\": accuracy_score(y_test, predictions),\n", " \"balanced_accuracy\": balanced_accuracy_score(y_test, predictions),\n", " \"f1_macro\": f1_score(y_test, predictions, average=\"macro\"),\n", "}\n", "test_metrics" ] }, { "cell_type": "markdown", "id": "0a5fe975", "metadata": {}, "source": [ "## Explore Multi-Metric cv_results_\n", "\n", "For multi-metric searches, `cv_results_` includes one set of columns for each metric. The most useful columns usually start with `mean_test_`, `std_test_`, or `rank_test_`." ] }, { "cell_type": "code", "execution_count": 7, "id": "510af77e", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:20.007706Z", "iopub.status.busy": "2026-06-20T05:29:20.007339Z", "iopub.status.idle": "2026-06-20T05:29:20.075469Z", "shell.execute_reply": "2026-06-20T05:29:20.074259Z" } }, "outputs": [ { "data": { "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", "
mean_test_accuracyrank_test_accuracymean_test_balanced_accuracyrank_test_balanced_accuracymean_test_f1_macrorank_test_f1_macroparam_logistic__Cparam_logistic__l1_ratioparam_logistic__class_weightparam_logistic__max_iter
00.98095210.97979810.98052911.0000000.000000None1200
10.98095210.97979810.98052912.1111630.031362None1185
30.98095210.97979810.98052914.6804470.521491None1102
40.98095210.97979810.98052910.6874060.391485balanced1258
120.98095210.97979810.98052911.0000000.000000None1119
\n", "
" ], "text/plain": [ " mean_test_accuracy rank_test_accuracy mean_test_balanced_accuracy \\\n", "0 0.980952 1 0.979798 \n", "1 0.980952 1 0.979798 \n", "3 0.980952 1 0.979798 \n", "4 0.980952 1 0.979798 \n", "12 0.980952 1 0.979798 \n", "\n", " rank_test_balanced_accuracy mean_test_f1_macro rank_test_f1_macro \\\n", "0 1 0.980529 1 \n", "1 1 0.980529 1 \n", "3 1 0.980529 1 \n", "4 1 0.980529 1 \n", "12 1 0.980529 1 \n", "\n", " param_logistic__C param_logistic__l1_ratio param_logistic__class_weight \\\n", "0 1.000000 0.000000 None \n", "1 2.111163 0.031362 None \n", "3 4.680447 0.521491 None \n", "4 0.687406 0.391485 balanced \n", "12 1.000000 0.000000 None \n", "\n", " param_logistic__max_iter \n", "0 1200 \n", "1 1185 \n", "3 1102 \n", "4 1258 \n", "12 1119 " ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "results = pd.DataFrame(search.cv_results_)\n", "metric_columns = [\n", " \"mean_test_accuracy\",\n", " \"rank_test_accuracy\",\n", " \"mean_test_balanced_accuracy\",\n", " \"rank_test_balanced_accuracy\",\n", " \"mean_test_f1_macro\",\n", " \"rank_test_f1_macro\",\n", "]\n", "parameter_columns = [column for column in results.columns if column.startswith(\"param_\")]\n", "\n", "results[metric_columns + parameter_columns].sort_values(\"rank_test_balanced_accuracy\").head()" ] }, { "cell_type": "markdown", "id": "7b655d7f", "metadata": {}, "source": [ "## Read Optimizer Telemetry\n", "\n", "The multi-metric result still has a single scalar fitness during optimization: the selected `refit` metric. Telemetry helps explain how the optimizer moved through the space while optimizing that metric." ] }, { "cell_type": "code", "execution_count": 8, "id": "1000a4f6", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:20.078069Z", "iopub.status.busy": "2026-06-20T05:29:20.077817Z", "iopub.status.idle": "2026-06-20T05:29:20.082916Z", "shell.execute_reply": "2026-06-20T05:29:20.081978Z" } }, "outputs": [ { "data": { "text/plain": [ "{'evaluated_candidates': 110,\n", " 'unique_candidates': 101,\n", " 'cross_validate_calls': 101,\n", " 'cache_hits': 9,\n", " 'duplicate_candidates': 0,\n", " 'skipped_invalid_candidates': 0,\n", " 'population_parallel_batches': 6,\n", " 'population_serial_batches': 0,\n", " 'random_immigrants': 6,\n", " 'local_refinement_candidates': 2}" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "search.fit_stats_" ] }, { "cell_type": "code", "execution_count": 9, "id": "29697fc0", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:20.085531Z", "iopub.status.busy": "2026-06-20T05:29:20.085217Z", "iopub.status.idle": "2026-06-20T05:29:20.096585Z", "shell.execute_reply": "2026-06-20T05:29:20.095536Z" } }, "outputs": [ { "data": { "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", "
genfitnessfitness_maxfitness_stdunique_individual_ratiogenotype_diversitystagnation_generationsbest_generation
000.7519640.9797980.2970051.0000000.77272700
110.9543350.9797980.0329810.7500000.47727310
220.9386920.9797980.0354030.6666670.29545520
330.9470400.9797980.0376540.7500000.45454530
440.9713100.9797980.0079820.9166670.47727350
\n", "
" ], "text/plain": [ " gen fitness fitness_max fitness_std unique_individual_ratio \\\n", "0 0 0.751964 0.979798 0.297005 1.000000 \n", "1 1 0.954335 0.979798 0.032981 0.750000 \n", "2 2 0.938692 0.979798 0.035403 0.666667 \n", "3 3 0.947040 0.979798 0.037654 0.750000 \n", "4 4 0.971310 0.979798 0.007982 0.916667 \n", "\n", " genotype_diversity stagnation_generations best_generation \n", "0 0.772727 0 0 \n", "1 0.477273 1 0 \n", "2 0.295455 2 0 \n", "3 0.454545 3 0 \n", "4 0.477273 5 0 " ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "history = pd.DataFrame(search.history)\n", "telemetry_columns = [\n", " \"gen\",\n", " \"fitness\",\n", " \"fitness_max\",\n", " \"fitness_std\",\n", " \"unique_individual_ratio\",\n", " \"genotype_diversity\",\n", " \"stagnation_generations\",\n", " \"best_generation\",\n", "]\n", "history[[column for column in telemetry_columns if column in history.columns]].tail()" ] }, { "cell_type": "code", "execution_count": 10, "id": "6e41843d", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:20.098825Z", "iopub.status.busy": "2026-06-20T05:29:20.098533Z", "iopub.status.idle": "2026-06-20T05:29:21.250502Z", "shell.execute_reply": "2026-06-20T05:29:21.249357Z" } }, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Balanced accuracy')" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ax = history.plot(x=\"gen\", y=[\"fitness_best\", \"fitness_max\", \"fitness\"], marker=\"o\", figsize=(8, 4))\n", "ax.set_title(\"Balanced-accuracy fitness over generations\")\n", "ax.set_xlabel(\"Generation\")\n", "ax.set_ylabel(\"Balanced accuracy\")" ] }, { "cell_type": "markdown", "id": "78893a76", "metadata": {}, "source": [ "## Change the Refit Metric\n", "\n", "The same `cv_results_` can point to different candidate rankings. The example below shows the best row for each metric without rerunning the search. In a real workflow, choose `refit` before fitting based on the metric that best matches the product or scientific goal." ] }, { "cell_type": "code", "execution_count": 11, "id": "a5e76bd0", "metadata": { "execution": { "iopub.execute_input": "2026-06-20T05:29:21.253936Z", "iopub.status.busy": "2026-06-20T05:29:21.253552Z", "iopub.status.idle": "2026-06-20T05:29:21.268298Z", "shell.execute_reply": "2026-06-20T05:29:21.267090Z" } }, "outputs": [ { "data": { "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", "
metricmean_test_scorerankCl1_ratioclass_weight
0accuracy0.98095211.00.0None
1balanced_accuracy0.97979811.00.0None
2f1_macro0.98052911.00.0None
\n", "
" ], "text/plain": [ " metric mean_test_score rank C l1_ratio class_weight\n", "0 accuracy 0.980952 1 1.0 0.0 None\n", "1 balanced_accuracy 0.979798 1 1.0 0.0 None\n", "2 f1_macro 0.980529 1 1.0 0.0 None" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "best_rows = []\n", "for metric_name in [\"accuracy\", \"balanced_accuracy\", \"f1_macro\"]:\n", " row = results.sort_values(f\"rank_test_{metric_name}\").iloc[0]\n", " best_rows.append(\n", " {\n", " \"metric\": metric_name,\n", " \"mean_test_score\": row[f\"mean_test_{metric_name}\"],\n", " \"rank\": row[f\"rank_test_{metric_name}\"],\n", " \"C\": row[\"param_logistic__C\"],\n", " \"l1_ratio\": row[\"param_logistic__l1_ratio\"],\n", " \"class_weight\": row[\"param_logistic__class_weight\"],\n", " }\n", " )\n", "\n", "pd.DataFrame(best_rows)" ] }, { "cell_type": "markdown", "id": "8156a660", "metadata": {}, "source": [ "## Practical Notes\n", "\n", "- With multi-metric scoring, set `refit` to the metric that should define the final model.\n", "- `best_score_`, `best_params_`, and `best_estimator_` follow the `refit` metric, not every metric at once.\n", "- Use `cv_results_` to inspect tradeoffs between metrics after fitting.\n", "- Use `fit_stats_` and `history` to understand optimizer cost, duplicate candidates, diversity, stagnation, and convergence behavior." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.14" } }, "nbformat": 4, "nbformat_minor": 5 }