diff --git a/examples/tutorials/try_optuna.ipynb b/examples/tutorials/try_optuna.ipynb
new file mode 100644
index 000000000..1a10ceb0f
--- /dev/null
+++ b/examples/tutorials/try_optuna.ipynb
@@ -0,0 +1,1159 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "c25b63fd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# --- Setup: Logging and Display Configuration ---\n",
+ "# Configure logging to see training progress and plotly to render as PNG for VS Code compatibility\n",
+ "import logging\n",
+ "import pandas as pd\n",
+ "import plotly.io as pio\n",
+ "\n",
+ "pd.options.plotting.backend = \"plotly\"\n",
+ "pio.renderers.default = \"png\" # Use PNG for VS Code notebook compatibility\n",
+ "\n",
+ "logging.basicConfig(level=logging.INFO, format=\"[%(asctime)s][%(levelname)s] %(message)s\")\n",
+ "logger = logging.getLogger(__name__)\n",
+ "logging.getLogger(\"choreographer\").setLevel(logging.ERROR)\n",
+ "logging.getLogger(\"kaleido\").setLevel(logging.ERROR)\n",
+ "logging.getLogger(\"choreographer\").disabled = True\n",
+ "logging.getLogger(\"kaleido\").disabled = True"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "84299333",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/fleur.petit/projects/openstef/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning:\n",
+ "\n",
+ "IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+ "\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Downloading load_measurements/mv_feeder/OS Gorredijk.parquet...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/fleur.petit/projects/openstef/.venv/lib/python3.12/site-packages/huggingface_hub/utils/_validators.py:202: UserWarning:\n",
+ "\n",
+ "The `local_dir_use_symlinks` argument is deprecated and ignored in `hf_hub_download`. Downloading to a local directory does not use symlinks anymore.\n",
+ "\n",
+ "[2026-03-26 11:11:52,083][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/load_measurements/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n",
+ "[2026-03-26 11:11:52,244][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/weather_forecasts_versioned/mv_feeder/OS%20Gorredijk.parquet \"HTTP/1.1 302 Found\"\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "✓ load_measurements/mv_feeder/OS Gorredijk.parquet downloaded\n",
+ "Downloading weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet...\n",
+ "✓ weather_forecasts_versioned/mv_feeder/OS Gorredijk.parquet downloaded\n",
+ "Downloading EPEX.parquet...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2026-03-26 11:11:52,424][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/EPEX.parquet \"HTTP/1.1 302 Found\"\n",
+ "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
+ "[2026-03-26 11:11:52,425][WARNING] Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n",
+ "[2026-03-26 11:11:52,607][INFO] HTTP Request: HEAD https://huggingface.co/datasets/OpenSTEF/liander2024-energy-forecasting-benchmark/resolve/main/profiles.parquet \"HTTP/1.1 302 Found\"\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "✓ EPEX.parquet downloaded\n",
+ "Downloading profiles.parquet...\n",
+ "✓ profiles.parquet downloaded\n",
+ "\n",
+ "✅ All files downloaded successfully!\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Download dataset from HuggingFace Hub\n",
+ "# The dataset is stored as parquet files for efficient loading\n",
+ "from huggingface_hub import hf_hub_download # pyright: ignore[reportUnknownVariableType]\n",
+ "from openstef_core.base_model import Path\n",
+ "\n",
+ "repo_id = \"OpenSTEF/liander2024-energy-forecasting-benchmark\" # Public benchmark dataset\n",
+ "local_dir = Path(\"./liander_dataset\")\n",
+ "target = \"mv_feeder/OS Gorredijk\" # Specific installation to focus on\n",
+ "\n",
+ "# Download required files: load measurements, weather, prices, and profiles\n",
+ "files_to_download = [\n",
+ " f\"load_measurements/{target}.parquet\", # Energy consumption data\n",
+ " f\"weather_forecasts_versioned/{target}.parquet\", # Weather features\n",
+ " \"EPEX.parquet\", # Electricity prices (optional feature)\n",
+ " \"profiles.parquet\" # Standard load profiles (optional feature)\n",
+ "]\n",
+ "\n",
+ "for filename in files_to_download:\n",
+ " print(f\"Downloading {filename}...\")\n",
+ " hf_hub_download(repo_id=repo_id, filename=filename, repo_type=\"dataset\",\n",
+ " local_dir=local_dir, local_dir_use_symlinks=False) # pyright: ignore[reportCallIssue]\n",
+ " print(f\"✓ {filename} downloaded\")\n",
+ "\n",
+ "print(\"\\n✅ All files downloaded successfully!\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "524f65a1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "[2026-03-26 11:11:54,019][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-26 11:11:54,040][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-26 11:11:54,065][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n",
+ "[2026-03-26 11:11:54,075][WARNING] Parquet file does not contain 'sample_interval' attribute. Using default value of 15 minutes.\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Dataset shape: (35136, 28)\n",
+ "Date range: 2024-01-01 00:00:00+00:00 to 2024-12-31 23:45:00+00:00\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.microsoft.datawrangler.viewer.v0+json": {
+ "columns": [
+ {
+ "name": "timestamp",
+ "rawType": "datetime64[ns, UTC]",
+ "type": "unknown"
+ },
+ {
+ "name": "load",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "temperature_2m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "relative_humidity_2m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "surface_pressure",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "cloud_cover",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_speed_10m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_speed_80m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "wind_direction_10m",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "shortwave_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "direct_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "diffuse_radiation",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "direct_normal_irradiance",
+ "rawType": "float32",
+ "type": "float"
+ },
+ {
+ "name": "EPEX_NL",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1A_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1A_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1B_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1B_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1C_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E1C_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2A_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2A_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2B_AZI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E2B_AMI_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3A_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3B_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3C_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E3D_A",
+ "rawType": "float64",
+ "type": "float"
+ },
+ {
+ "name": "E4A_A",
+ "rawType": "float64",
+ "type": "float"
+ }
+ ],
+ "ref": "eb7e1c92-b6c6-4dfc-8d57-1c88f21fdea1",
+ "rows": [
+ [
+ "2024-01-01 00:00:00+00:00",
+ "423333.3333333333",
+ "7.2435",
+ "85.02532",
+ "994.23645",
+ "100.0",
+ "28.185953",
+ "43.832863",
+ "204.92845",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.97e-05",
+ "4.031e-05",
+ "6.206e-05",
+ "7.815e-05",
+ "5.683e-05",
+ "6.431e-05",
+ "2.42e-05",
+ "3.404e-05",
+ "5.292e-05",
+ "6.425e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "5.839e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:15:00+00:00",
+ "436666.6666666666",
+ "7.281",
+ "84.80853",
+ "994.1865",
+ "100.0",
+ "28.75338",
+ "44.97622",
+ "206.93102",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.91e-05",
+ "3.866e-05",
+ "6.079e-05",
+ "7.537e-05",
+ "5.572e-05",
+ "6.058e-05",
+ "2.395e-05",
+ "3.352e-05",
+ "5.236e-05",
+ "6.326e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "5.826e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:30:00+00:00",
+ "410000.0",
+ "7.3185005",
+ "84.59174",
+ "994.1366",
+ "100.0",
+ "29.320807",
+ "46.11957",
+ "208.93356",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.794e-05",
+ "3.771e-05",
+ "5.799e-05",
+ "7.33e-05",
+ "5.451e-05",
+ "5.967e-05",
+ "2.338e-05",
+ "3.312e-05",
+ "5.113e-05",
+ "6.252e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "5.782e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 00:45:00+00:00",
+ "403333.3333333333",
+ "7.3560004",
+ "84.374954",
+ "994.08673",
+ "100.0",
+ "29.888233",
+ "47.262924",
+ "210.93613",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.01",
+ "2.712e-05",
+ "3.649e-05",
+ "5.659e-05",
+ "7.12e-05",
+ "5.211e-05",
+ "5.708e-05",
+ "2.325e-05",
+ "3.219e-05",
+ "5.083e-05",
+ "6.076e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "5.89e-05",
+ "7.931e-05"
+ ],
+ [
+ "2024-01-01 01:00:00+00:00",
+ "420000.0",
+ "7.3935003",
+ "84.158165",
+ "994.0368",
+ "100.0",
+ "30.45566",
+ "48.40628",
+ "212.93869",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "0.0",
+ "2.714e-05",
+ "3.44e-05",
+ "5.728e-05",
+ "6.668e-05",
+ "5.045e-05",
+ "5.493e-05",
+ "2.359e-05",
+ "3.198e-05",
+ "5.158e-05",
+ "6.036e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "5.726e-05",
+ "7.931e-05"
+ ]
+ ],
+ "shape": {
+ "columns": 28,
+ "rows": 5
+ }
+ },
+ "text/html": [
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " load | \n",
+ " temperature_2m | \n",
+ " relative_humidity_2m | \n",
+ " surface_pressure | \n",
+ " cloud_cover | \n",
+ " wind_speed_10m | \n",
+ " wind_speed_80m | \n",
+ " wind_direction_10m | \n",
+ " shortwave_radiation | \n",
+ " direct_radiation | \n",
+ " ... | \n",
+ " E1C_AMI_A | \n",
+ " E2A_AZI_A | \n",
+ " E2A_AMI_A | \n",
+ " E2B_AZI_A | \n",
+ " E2B_AMI_A | \n",
+ " E3A_A | \n",
+ " E3B_A | \n",
+ " E3C_A | \n",
+ " E3D_A | \n",
+ " E4A_A | \n",
+ "
\n",
+ " \n",
+ " | timestamp | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 2024-01-01 00:00:00+00:00 | \n",
+ " 423333.333333 | \n",
+ " 7.243500 | \n",
+ " 85.025322 | \n",
+ " 994.236450 | \n",
+ " 100.0 | \n",
+ " 28.185953 | \n",
+ " 43.832863 | \n",
+ " 204.928452 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000064 | \n",
+ " 0.000024 | \n",
+ " 0.000034 | \n",
+ " 0.000053 | \n",
+ " 0.000064 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:15:00+00:00 | \n",
+ " 436666.666667 | \n",
+ " 7.281000 | \n",
+ " 84.808533 | \n",
+ " 994.186523 | \n",
+ " 100.0 | \n",
+ " 28.753380 | \n",
+ " 44.976219 | \n",
+ " 206.931015 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000061 | \n",
+ " 0.000024 | \n",
+ " 0.000034 | \n",
+ " 0.000052 | \n",
+ " 0.000063 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:30:00+00:00 | \n",
+ " 410000.000000 | \n",
+ " 7.318501 | \n",
+ " 84.591743 | \n",
+ " 994.136597 | \n",
+ " 100.0 | \n",
+ " 29.320807 | \n",
+ " 46.119572 | \n",
+ " 208.933563 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000060 | \n",
+ " 0.000023 | \n",
+ " 0.000033 | \n",
+ " 0.000051 | \n",
+ " 0.000063 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000058 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 00:45:00+00:00 | \n",
+ " 403333.333333 | \n",
+ " 7.356000 | \n",
+ " 84.374954 | \n",
+ " 994.086731 | \n",
+ " 100.0 | \n",
+ " 29.888233 | \n",
+ " 47.262924 | \n",
+ " 210.936127 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000057 | \n",
+ " 0.000023 | \n",
+ " 0.000032 | \n",
+ " 0.000051 | \n",
+ " 0.000061 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000059 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ " | 2024-01-01 01:00:00+00:00 | \n",
+ " 420000.000000 | \n",
+ " 7.393500 | \n",
+ " 84.158165 | \n",
+ " 994.036804 | \n",
+ " 100.0 | \n",
+ " 30.455660 | \n",
+ " 48.406281 | \n",
+ " 212.938690 | \n",
+ " 0.0 | \n",
+ " 0.0 | \n",
+ " ... | \n",
+ " 0.000055 | \n",
+ " 0.000024 | \n",
+ " 0.000032 | \n",
+ " 0.000052 | \n",
+ " 0.000060 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000057 | \n",
+ " 0.000079 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
5 rows × 28 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " load temperature_2m \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 423333.333333 7.243500 \n",
+ "2024-01-01 00:15:00+00:00 436666.666667 7.281000 \n",
+ "2024-01-01 00:30:00+00:00 410000.000000 7.318501 \n",
+ "2024-01-01 00:45:00+00:00 403333.333333 7.356000 \n",
+ "2024-01-01 01:00:00+00:00 420000.000000 7.393500 \n",
+ "\n",
+ " relative_humidity_2m surface_pressure \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 85.025322 994.236450 \n",
+ "2024-01-01 00:15:00+00:00 84.808533 994.186523 \n",
+ "2024-01-01 00:30:00+00:00 84.591743 994.136597 \n",
+ "2024-01-01 00:45:00+00:00 84.374954 994.086731 \n",
+ "2024-01-01 01:00:00+00:00 84.158165 994.036804 \n",
+ "\n",
+ " cloud_cover wind_speed_10m wind_speed_80m \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 100.0 28.185953 43.832863 \n",
+ "2024-01-01 00:15:00+00:00 100.0 28.753380 44.976219 \n",
+ "2024-01-01 00:30:00+00:00 100.0 29.320807 46.119572 \n",
+ "2024-01-01 00:45:00+00:00 100.0 29.888233 47.262924 \n",
+ "2024-01-01 01:00:00+00:00 100.0 30.455660 48.406281 \n",
+ "\n",
+ " wind_direction_10m shortwave_radiation \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 204.928452 0.0 \n",
+ "2024-01-01 00:15:00+00:00 206.931015 0.0 \n",
+ "2024-01-01 00:30:00+00:00 208.933563 0.0 \n",
+ "2024-01-01 00:45:00+00:00 210.936127 0.0 \n",
+ "2024-01-01 01:00:00+00:00 212.938690 0.0 \n",
+ "\n",
+ " direct_radiation ... E1C_AMI_A E2A_AZI_A \\\n",
+ "timestamp ... \n",
+ "2024-01-01 00:00:00+00:00 0.0 ... 0.000064 0.000024 \n",
+ "2024-01-01 00:15:00+00:00 0.0 ... 0.000061 0.000024 \n",
+ "2024-01-01 00:30:00+00:00 0.0 ... 0.000060 0.000023 \n",
+ "2024-01-01 00:45:00+00:00 0.0 ... 0.000057 0.000023 \n",
+ "2024-01-01 01:00:00+00:00 0.0 ... 0.000055 0.000024 \n",
+ "\n",
+ " E2A_AMI_A E2B_AZI_A E2B_AMI_A E3A_A \\\n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 0.000034 0.000053 0.000064 0.000058 \n",
+ "2024-01-01 00:15:00+00:00 0.000034 0.000052 0.000063 0.000058 \n",
+ "2024-01-01 00:30:00+00:00 0.000033 0.000051 0.000063 0.000058 \n",
+ "2024-01-01 00:45:00+00:00 0.000032 0.000051 0.000061 0.000059 \n",
+ "2024-01-01 01:00:00+00:00 0.000032 0.000052 0.000060 0.000057 \n",
+ "\n",
+ " E3B_A E3C_A E3D_A E4A_A \n",
+ "timestamp \n",
+ "2024-01-01 00:00:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:15:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:30:00+00:00 0.000058 0.000058 0.000058 0.000079 \n",
+ "2024-01-01 00:45:00+00:00 0.000059 0.000059 0.000059 0.000079 \n",
+ "2024-01-01 01:00:00+00:00 0.000057 0.000057 0.000057 0.000079 \n",
+ "\n",
+ "[5 rows x 28 columns]"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "# Load datasets using OpenSTEF's VersionedTimeSeriesDataset\n",
+ "# This class handles versioned data where each value has an \"available_at\" timestamp\n",
+ "from openstef_core.datasets import VersionedTimeSeriesDataset\n",
+ "\n",
+ "# Load each data source from parquet files\n",
+ "load_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
+ " local_dir / f\"load_measurements/{target}.parquet\"\n",
+ ")\n",
+ "weather_dataset = VersionedTimeSeriesDataset.read_parquet(\n",
+ " local_dir / f\"weather_forecasts_versioned/{target}.parquet\"\n",
+ ")\n",
+ "epex_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"EPEX.parquet\")\n",
+ "profiles_dataset = VersionedTimeSeriesDataset.read_parquet(local_dir / \"profiles.parquet\")\n",
+ "\n",
+ "# Combine all datasets using left join (keep all load timestamps, match features where available)\n",
+ "# select_version() materializes the lazy dataset into a concrete TimeSeriesDataset\n",
+ "dataset = VersionedTimeSeriesDataset.concat(\n",
+ " [load_dataset, weather_dataset, epex_dataset, profiles_dataset], \n",
+ " mode=\"left\" # Left join keeps all timestamps from the first dataset\n",
+ ").select_version()\n",
+ "\n",
+ "# Preview the combined dataset\n",
+ "print(f\"Dataset shape: {dataset.data.shape}\")\n",
+ "print(f\"Date range: {dataset.data.index.min()} to {dataset.data.index.max()}\")\n",
+ "dataset.data.head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "2a64bbb5",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "📈 Training period: 2024-03-01 to 2024-05-30 (8640 samples)\n",
+ "🔮 Forecast period: 2024-05-30 to 2024-06-13 (1344 samples)\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Define training and forecast time periods\n",
+ "from datetime import datetime, timedelta\n",
+ "\n",
+ "# Training period: 90 days of historical data\n",
+ "train_start = datetime.fromisoformat(\"2024-03-01T00:00:00Z\")\n",
+ "train_end = train_start + timedelta(days=90)\n",
+ "\n",
+ "# Forecast period: 14 days after training (this is where we'll predict)\n",
+ "forecast_start = train_end\n",
+ "forecast_end = forecast_start + timedelta(days=14)\n",
+ "\n",
+ "# Split the dataset using time-based filtering\n",
+ "train_dataset = dataset.filter_by_range(start=train_start, end=train_end)\n",
+ "forecast_dataset = dataset.filter_by_range(start=forecast_start, end=forecast_end)\n",
+ "\n",
+ "print(f\"📈 Training period: {train_start.date()} to {train_end.date()} ({len(train_dataset.data)} samples)\")\n",
+ "print(f\"🔮 Forecast period: {forecast_start.date()} to {forecast_end.date()} ({len(forecast_dataset.data)} samples)\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "bfe2a41f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "# Visualize the training data\n",
+ "# The plot shows the 'load' column (energy consumption in MW) over time\n",
+ "fig = train_dataset.data[[\"load\"]].plot(title=\"Training Data: Energy Load over Time\")\n",
+ "fig.update_layout(yaxis_title=\"Load (MW)\", xaxis_title=\"Time\")\n",
+ "fig.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "12d8302c",
+ "metadata": {},
+ "source": [
+ "## Define a base config with inline search space\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a001a0f0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/fleur.petit/projects/openstef/.venv/lib/python3.12/site-packages/mlflow/__init__.py:41: UserWarning:\n",
+ "\n",
+ "Versions of mlflow (3.9.0) and child packages mlflow-skinny (3.6.0) are different. This may lead to unexpected behavior. Please install the same version of all MLflow packages.\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "from openstef_core.types import LeadTime, Q\n",
+ "from openstef_models.models.forecasting.xgboost_forecaster import XGBoostHyperParams\n",
+ "from openstef_models.presets import ForecastingWorkflowConfig, fit_with_tuning\n",
+ "from openstef_models.presets.forecasting_workflow import create_forecasting_workflow\n",
+ "from openstef_models.utils.tuning import FloatRange, IntRange\n",
+ "\n",
+ "config = ForecastingWorkflowConfig(\n",
+ " model_id=\"xgboost_optuna_demo\",\n",
+ " model=\"xgboost\",\n",
+ "\n",
+ " horizons=[LeadTime.from_string(\"PT36H\")],\n",
+ " quantiles=[Q(0.5), Q(0.1), Q(0.9)],\n",
+ "\n",
+ " target_column=\"load\",\n",
+ " temperature_column=\"temperature_2m\",\n",
+ " relative_humidity_column=\"relative_humidity_2m\",\n",
+ " wind_speed_column=\"wind_speed_10m\",\n",
+ " radiation_column=\"shortwave_radiation\",\n",
+ " pressure_column=\"surface_pressure\",\n",
+ "\n",
+ " # Pass TuningRange objects directly as field values — tune=True marks them for Optuna.\n",
+ " # None values for low/high fall back to the class-level defaults in XGBoostHyperParams.\n",
+ " xgboost_hyperparams=XGBoostHyperParams(\n",
+ " n_estimators=200,\n",
+ " learning_rate=FloatRange(None, None, log=True, tune=True), # class default range: 0.01 to 0.5\n",
+ " max_depth=IntRange(5, 15, tune=True),\n",
+ " min_child_weight=FloatRange(None, None, tune=True), # class default range: 1.0 to 10.0\n",
+ " reg_alpha=FloatRange(None, None, log=True, tune=True), # class default range: 1e-8 to 10.0\n",
+ " reg_lambda=FloatRange(None, None, log=True, tune=True), # class default range: 1e-8 to 10.0\n",
+ " ),\n",
+ " optuna_n_trials=20,\n",
+ " optuna_seed=42,\n",
+ "\n",
+ " mlflow_storage=None, # Disable MLflow during tuning\n",
+ " verbosity=0,\n",
+ ")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "9b47824a",
+ "metadata": {},
+ "source": [
+ "## Inspect the resolved search space\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "65a76a06",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Resolved search space:\n",
+ " learning_rate : FloatRange [0.01 — 0.5] [log]\n",
+ " max_depth : IntRange [5 — 15]\n",
+ " min_child_weight : FloatRange [1.0 — 10.0]\n",
+ " reg_alpha : FloatRange [1e-08 — 10.0] [log]\n",
+ " reg_lambda : FloatRange [1e-08 — 10.0] [log]\n"
+ ]
+ }
+ ],
+ "source": [
+ "from openstef_models.utils.tuning import FloatRange, IntRange, get_search_space\n",
+ "\n",
+ "# Merge custom annotated hyperparams with class-level annotated defaults (filling in any None bounds).\n",
+ "resolved_space = get_search_space(config.xgboost_hyperparams)\n",
+ "\n",
+ "print(\"Resolved search space:\")\n",
+ "for name, param in resolved_space.items():\n",
+ " if isinstance(param, (FloatRange, IntRange)):\n",
+ " scale = \" [log]\" if param.log else \"\"\n",
+ " print(f\" {name:25s}: {type(param).__name__} [{param.low} — {param.high}]{scale}\")\n",
+ " else:\n",
+ " print(f\" {name:25s}: CategoricalRange {param.choices}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08768e60",
+ "metadata": {},
+ "source": [
+ "## Run the Optuna study with `fit_with_tuning`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8601c179",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ " 0%| | 0/20 [00:00, ?it/s]"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Best trial: 12. Best value: 0.8388: 100%|██████████| 20/20 [02:16<00:00, 6.83s/it]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Study complete: 20 trials\n",
+ "Best R²: 0.8388\n",
+ "Best hyperparameters:\n",
+ " learning_rate : 0.1661524390633895\n",
+ " max_depth : 12\n",
+ " min_child_weight : 6.81957188819057\n",
+ " reg_alpha : 0.04112476622444426\n",
+ " reg_lambda : 0.0022086692193693247\n"
+ ]
+ }
+ ],
+ "source": [
+ "import optuna\n",
+ "optuna.logging.set_verbosity(optuna.logging.WARNING) # Suppress per-trial logs\n",
+ "\n",
+ "tuning_result = fit_with_tuning(config, train_dataset, create_forecasting_workflow)\n",
+ "\n",
+ "print(f\"Study complete: {len(tuning_result.study.trials)} trials\")\n",
+ "print(f\"Best R²: {tuning_result.study.best_value:.4f}\")\n",
+ "print(\"Best hyperparameters:\")\n",
+ "for k, v in tuning_result.study.best_params.items():\n",
+ " print(f\" {k:25s}: {v}\")\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "096af1c0",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Final XGBoost hyperparameters (tuned values marked):\n",
+ " n_estimators : 200\n",
+ " learning_rate : 0.1661524390633895 <- tuned\n",
+ " max_depth : 12 <- tuned\n",
+ " min_child_weight : 6.81957188819057 <- tuned\n",
+ " gamma : 0\n",
+ " objective : pinball_loss\n",
+ " evaluation_metric : mean_pinball_loss\n",
+ " reg_alpha : 0.04112476622444426 <- tuned\n",
+ " reg_lambda : 0.0022086692193693247 <- tuned\n",
+ " max_delta_step : 0\n",
+ " max_leaves : 0\n",
+ " grow_policy : depthwise\n",
+ " max_bin : 256\n",
+ " num_parallel_trees : 1\n",
+ " subsample : 1.0\n",
+ " colsample_bytree : 1.0\n",
+ " colsample_bylevel : 1.0\n",
+ " colsample_bynode : 1.0\n",
+ " tree_method : auto\n",
+ " random_state : 42\n",
+ " early_stopping_rounds : None\n",
+ " use_target_scaling : True\n"
+ ]
+ }
+ ],
+ "source": [
+ "# The best config is already applied inside fit_with_tuning.\n",
+ "# Here we inspect which hyperparameters were tuned vs kept at their default.\n",
+ "print(\"Final XGBoost hyperparameters (tuned values marked):\")\n",
+ "final_hp = tuning_result.workflow.model.forecaster.hyperparams\n",
+ "baseline_hp = config.xgboost_hyperparams\n",
+ "best_params = tuning_result.study.best_params\n",
+ "\n",
+ "for field in type(final_hp).model_fields:\n",
+ " value = getattr(final_hp, field)\n",
+ " baseline = getattr(baseline_hp, field)\n",
+ " marker = \" <- tuned\" if field in best_params else \"\"\n",
+ " print(f\" {field:25s}: {value}{marker}\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d86e3cbc",
+ "metadata": {},
+ "source": [
+ "## Full-set training metrics\n",
+ "\n",
+ "`fit_with_tuning` trains the final model on the full training set with the best\n",
+ "hyperparameters. The fit result is available as `tuning_result.fit_result`.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "5be7e4a8",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Final model already trained by fit_with_tuning!\n",
+ "Full-set metrics (tuned model):\n",
+ " quantile R2 observed_probability\n",
+ "0 0.5 0.978403 0.503819\n",
+ "1 0.1 0.968634 0.263426\n",
+ "2 0.9 0.955630 0.743750\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Final model already trained by fit_with_tuning!\")\n",
+ "print(\"Full-set metrics (tuned model):\")\n",
+ "print(tuning_result.fit_result.metrics_full.to_dataframe())\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3fc5f542",
+ "metadata": {},
+ "source": [
+ "## Inspect the study and forecast\n",
+ "\n",
+ "1. How did $R^2$ improved over trials?\n",
+ "2. Which parameters had the most impact?\n",
+ "3. Final tuned model predictions on the held-out forecast window.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "c29a1423",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from optuna.visualization import plot_optimization_history, plot_param_importances\n",
+ "\n",
+ "study = tuning_result.study\n",
+ "\n",
+ "# How the best score evolved over trials\n",
+ "fig = plot_optimization_history(study)\n",
+ "fig.update_layout(title=\"Optimization History: R² over Trials\")\n",
+ "fig.show()\n",
+ "\n",
+ "# Which hyperparameters mattered most (requires ≥ ~20 trials for reliable ranking)\n",
+ "fig2 = plot_param_importances(study)\n",
+ "fig2.update_layout(title=\"Hyperparameter Importances\")\n",
+ "fig2.show()\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "571d30d9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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"
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from openstef_beam.analysis.plots import ForecastTimeSeriesPlotter\n",
+ "\n",
+ "forecast = tuning_result.workflow.predict(forecast_dataset)\n",
+ "\n",
+ "fig = (\n",
+ " ForecastTimeSeriesPlotter()\n",
+ " .add_measurements(measurements=forecast_dataset.data[\"load\"])\n",
+ " .add_model(\n",
+ " model_name=\"XGBoost (tuned)\",\n",
+ " forecast=forecast.median_series,\n",
+ " quantiles=forecast.quantiles_data,\n",
+ " )\n",
+ " .plot()\n",
+ ")\n",
+ "fig.update_layout(\n",
+ " title=\"Tuned XGBoost Forecast vs Actual\",\n",
+ " yaxis_title=\"Load (MW)\",\n",
+ " xaxis_title=\"Time\",\n",
+ " height=500,\n",
+ ")\n",
+ "fig.show()\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "openstef (3.12.10)",
+ "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.12.10"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py b/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py
index 176cd26e4..9e4ed604c 100644
--- a/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py
+++ b/packages/openstef-meta/src/openstef_meta/presets/forecasting_workflow.py
@@ -65,6 +65,7 @@
)
from openstef_models.utils.data_split import DataSplitter
from openstef_models.utils.feature_selection import Exclude, FeatureSelection, Include
+from openstef_models.utils.tuning import TuningConfigMixin
from openstef_models.workflows.custom_forecasting_workflow import (
CustomForecastingWorkflow,
ForecastingCallback,
@@ -74,7 +75,7 @@
from openstef_core.datasets import ForecastDataset
-class EnsembleForecastingWorkflowConfig(BaseConfig):
+class EnsembleForecastingWorkflowConfig(TuningConfigMixin, BaseConfig):
"""Configuration for ensemble forecasting workflows."""
kind: Literal["ensemble"] = Field(default="ensemble", description="Discriminator tag for config type.")
@@ -279,6 +280,15 @@ class EnsembleForecastingWorkflowConfig(BaseConfig):
default_factory=dict,
description="Optional metadata tags for experiment tracking.",
)
+ # Hyperparameter tuning (Optuna)
+ optuna_n_trials: int = Field(
+ default=50,
+ description="Number of Optuna trials to run during hyperparameter tuning.",
+ )
+ optuna_seed: int | None = Field(
+ default=None,
+ description="Random seed for Optuna sampler reproducibility. None disables seeding.",
+ )
def _checks(config: EnsembleForecastingWorkflowConfig) -> list[Transform[TimeSeriesDataset, TimeSeriesDataset]]:
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
index b181b7bd5..ad20bbd39 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/gblinear_forecaster.py
@@ -11,7 +11,7 @@
to predict values outside the range of the training data.
"""
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
import numpy as np
import pandas as pd
@@ -22,7 +22,6 @@
from openstef_core.datasets.mixins import LeadTime
from openstef_core.datasets.validated_datasets import ForecastDataset, ForecastInputDataset
from openstef_core.exceptions import InputValidationError, MissingExtraError, NotFittedError
-from openstef_core.mixins.predictor import HyperParams
from openstef_core.utils.pandas import normalize_to_unit_sum
from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
from openstef_models.models.forecasting.forecaster import Forecaster
@@ -32,6 +31,7 @@
get_objective_function,
xgb_prepare_target_for_objective,
)
+from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange, TunableHyperParams
try:
import xgboost as xgb
@@ -39,19 +39,19 @@
raise MissingExtraError("xgboost", "openstef-models") from e
-class GBLinearHyperParams(HyperParams):
+class GBLinearHyperParams(TunableHyperParams):
"""Hyperparameter configuration for GBLinear forecaster."""
# Learning Parameters
- n_steps: int = Field(
+ n_steps: Annotated[int, IntRange(50, 1000)] = Field(
default=500,
description="Number for steps (boosting rounds) to train the GBLinear model.",
)
- updater: str = Field(
+ updater: Annotated[str, CategoricalRange(("shotgun", "coord_descent"))] = Field(
default="shotgun",
description="The updater to use for the GBLinear booster.",
)
- learning_rate: float = Field(
+ learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
default=0.15,
description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require more boosting "
"rounds.",
@@ -68,15 +68,15 @@ class GBLinearHyperParams(HyperParams):
)
# Regularization
- reg_alpha: float = Field(
+ reg_alpha: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
default=0.0001, description="L1 regularization on weights. Higher values increase regularization. Range: [0,∞]"
)
- reg_lambda: float = Field(
+ reg_lambda: Annotated[float, FloatRange(1e-8, 1.0, log=True)] = Field(
default=0.1, description="L2 regularization on weights. Higher values increase regularization. Range: [0,∞]"
)
# Feature selection
- feature_selector: str = Field(
+ feature_selector: Annotated[str, CategoricalRange(("cyclic", "shuffle", "random", "greedy", "thrifty"))] = Field(
default="shuffle",
description="Feature selection method.",
)
diff --git a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
index 87a956378..8717db795 100644
--- a/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
+++ b/packages/openstef-models/src/openstef_models/models/forecasting/xgboost_forecaster.py
@@ -9,7 +9,7 @@
comprehensive hyperparameter control for production forecasting workflows.
"""
-from typing import ClassVar, Literal, override
+from typing import Annotated, ClassVar, Literal, override
import numpy as np
import pandas as pd
@@ -18,7 +18,6 @@
from openstef_core.datasets import ForecastDataset, ForecastInputDataset, TimeSeriesDataset
from openstef_core.exceptions import MissingExtraError, NotFittedError
-from openstef_core.mixins import HyperParams
from openstef_core.utils.pandas import normalize_to_unit_sum
from openstef_models.explainability.mixins import ContributionsMixin, ExplainableForecaster
from openstef_models.models.forecasting.forecaster import Forecaster
@@ -28,6 +27,7 @@
get_objective_function,
xgb_prepare_target_for_objective,
)
+from openstef_models.utils.tuning import CategoricalRange, FloatRange, IntRange, TunableHyperParams
try:
import xgboost as xgb
@@ -35,7 +35,7 @@
raise MissingExtraError("xgboost", "openstef-models") from e
-class XGBoostHyperParams(HyperParams):
+class XGBoostHyperParams(TunableHyperParams):
"""XGBoost hyperparameters for gradient boosting tree models.
Configures tree-specific parameters for XGBoost gbtree booster. Provides
@@ -65,28 +65,28 @@ class XGBoostHyperParams(HyperParams):
"""
# Core Tree Boosting Parameters
- n_estimators: int = Field(
+ n_estimators: Annotated[int, IntRange(50, 500)] = Field(
default=100,
description="Number of boosting rounds/trees to fit. Higher values may improve performance but "
"increase training time and risk overfitting.",
)
- learning_rate: float = Field(
+ learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = Field(
default=0.3,
alias="eta",
description="Step size shrinkage used to prevent overfitting. Range: [0,1]. Lower values require "
"more boosting rounds.",
)
- max_depth: int = Field(
+ max_depth: Annotated[int, IntRange(1, 15)] = Field(
default=6,
description="Maximum depth of trees. Higher values capture more complex patterns but risk "
"overfitting. Range: [1,∞]",
)
- min_child_weight: float = Field(
+ min_child_weight: Annotated[float, FloatRange(1.0, 10.0)] = Field(
default=1,
description="Minimum sum of instance weight (hessian) needed in a child. Higher values prevent "
"overfitting. Range: [0,∞]",
)
- gamma: float = Field(
+ gamma: Annotated[float, FloatRange(0.0, 5.0)] = Field(
default=0,
alias="min_split_loss",
description="Minimum loss reduction required to make a split. Higher values make algorithm more "
@@ -103,10 +103,10 @@ class XGBoostHyperParams(HyperParams):
)
# Regularization
- reg_alpha: float = Field(
+ reg_alpha: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
default=0, description="L1 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
)
- reg_lambda: float = Field(
+ reg_lambda: Annotated[float, FloatRange(1e-8, 10.0, log=True)] = Field(
default=1, description="L2 regularization on leaf weights. Higher values increase regularization. Range: [0,∞]"
)
max_delta_step: float = Field(
@@ -119,7 +119,7 @@ class XGBoostHyperParams(HyperParams):
max_leaves: int = Field(
default=0, description="Maximum number of leaves. 0 means no limit. Only relevant when grow_policy='lossguide'."
)
- grow_policy: Literal["depthwise", "lossguide"] = Field(
+ grow_policy: Annotated[Literal["depthwise", "lossguide"], CategoricalRange(("depthwise", "lossguide"))] = Field(
default="depthwise",
description="Controls how new nodes are added. 'depthwise' grows level by level, 'lossguide' adds leaves "
"with highest loss reduction.",
@@ -136,11 +136,11 @@ class XGBoostHyperParams(HyperParams):
)
# Subsampling Parameters
- subsample: float = Field(
+ subsample: Annotated[float, FloatRange(0.5, 1.0)] = Field(
default=1.0,
description="Fraction of training samples used for each tree. Lower values prevent overfitting. Range: (0,1]",
)
- colsample_bytree: float = Field(
+ colsample_bytree: Annotated[float, FloatRange(0.5, 1.0)] = Field(
default=1.0, description="Fraction of features used when constructing each tree. Range: (0,1]"
)
colsample_bylevel: float = Field(
@@ -151,7 +151,10 @@ class XGBoostHyperParams(HyperParams):
)
# Tree Construction Method
- tree_method: Literal["auto", "exact", "hist", "approx", "gpu_hist"] = Field(
+ tree_method: Annotated[
+ Literal["auto", "exact", "hist", "approx", "gpu_hist"],
+ CategoricalRange(("auto", "hist", "approx")),
+ ] = Field(
default="auto",
description="Tree construction algorithm. 'hist' is fastest for large datasets, 'exact' for small "
"datasets, 'approx' is deprecated.",
diff --git a/packages/openstef-models/src/openstef_models/presets/__init__.py b/packages/openstef-models/src/openstef_models/presets/__init__.py
index 0615a0ea4..9e75c4bb9 100644
--- a/packages/openstef-models/src/openstef_models/presets/__init__.py
+++ b/packages/openstef-models/src/openstef_models/presets/__init__.py
@@ -7,9 +7,17 @@
Provides configurations and utilities for setting up forecasting workflows.
"""
-from .forecasting_workflow import ForecastingWorkflowConfig, create_forecasting_workflow
+from openstef_models.utils.tuning import TuningResult, fit_with_tuning, tune
+
+from .forecasting_workflow import (
+ ForecastingWorkflowConfig,
+ create_forecasting_workflow,
+)
__all__ = [
"ForecastingWorkflowConfig",
+ "TuningResult",
"create_forecasting_workflow",
+ "fit_with_tuning",
+ "tune",
]
diff --git a/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py b/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
index 028302c1b..e51653b83 100644
--- a/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
+++ b/packages/openstef-models/src/openstef_models/presets/forecasting_workflow.py
@@ -63,6 +63,7 @@
)
from openstef_models.utils.data_split import DataSplitter
from openstef_models.utils.feature_selection import Exclude, FeatureSelection, Include
+from openstef_models.utils.tuning import TuningConfigMixin
from openstef_models.workflows.custom_forecasting_workflow import (
CustomForecastingWorkflow,
ForecastingCallback,
@@ -100,7 +101,7 @@ def tags(self) -> dict[str, str]:
}
-class ForecastingWorkflowConfig(BaseConfig): # PredictionJob
+class ForecastingWorkflowConfig(TuningConfigMixin, BaseConfig): # PredictionJob
"""Configuration for forecasting workflows.
Defines all parameters needed to set up a forecasting model, including model type,
@@ -278,6 +279,16 @@ class ForecastingWorkflowConfig(BaseConfig): # PredictionJob
default=0, description="Verbosity level. 0=silent, 1=warning, 2=info, 3=debug"
)
+ # Hyperparameter tuning (Optuna)
+ optuna_n_trials: int = Field(
+ default=20,
+ description="Number of Optuna trials to run when any search-space field has tune=True.",
+ )
+ optuna_seed: int | None = Field(
+ default=42,
+ description="Random seed for the Optuna TPE sampler. Set to None to disable seeding.",
+ )
+
# Metadata
tags: dict[str, str] = Field(
default_factory=dict,
diff --git a/packages/openstef-models/src/openstef_models/utils/tuning.py b/packages/openstef-models/src/openstef_models/utils/tuning.py
new file mode 100644
index 000000000..22baf54ac
--- /dev/null
+++ b/packages/openstef-models/src/openstef_models/utils/tuning.py
@@ -0,0 +1,665 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project
+#
+# SPDX-License-Identifier: MPL-2.0
+"""Hyperparameter tuning utilities for OpenSTEF models.
+
+Provides dataclasses for describing hyperparameter search spaces, helper functions to
+extract and merge search spaces from annotated HyperParams classes, and a thin wrapper
+around Optuna for running Bayesian hyperparameter optimisation studies.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple, Protocol, Self, cast, runtime_checkable
+
+import optuna
+from pydantic import BaseModel, PrivateAttr, model_validator
+
+from openstef_core.mixins import HyperParams
+
+if TYPE_CHECKING:
+ from collections.abc import Callable
+
+ from pydantic.fields import FieldInfo
+
+ from openstef_core.datasets import TimeSeriesDataset
+ from openstef_core.types import QuantileOrGlobal
+ from openstef_models.mixins.model_serializer import ModelIdentifier
+ from openstef_models.models.forecasting_model import ModelFitResult
+ from openstef_models.workflows.custom_forecasting_workflow import CustomForecastingWorkflow
+
+
+@dataclass(frozen=True)
+class FloatRange:
+ """Search space metadata for continuous float hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to declare the
+ range that a hyperparameter tuner should explore.
+
+ Args:
+ low: Lower bound of the search interval (inclusive).
+ high: Upper bound of the search interval (inclusive).
+ log: When ``True`` the sampler draws on a log scale, which is
+ recommended for parameters like learning rates and
+ regularisation coefficients.
+
+ Example:
+ >>> learning_rate: Annotated[float, FloatRange(0.01, 0.5, log=True)] = 0.3
+ """
+
+ low: float | None
+ high: float | None
+ log: bool = False
+ tune: bool = False
+
+
+@dataclass(frozen=True)
+class IntRange:
+ """Search space metadata for discrete integer hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to declare the
+ integer range that a hyperparameter tuner should explore.
+
+ Args:
+ low: Minimum integer value (inclusive).
+ high: Maximum integer value (inclusive).
+ log: When ``True`` the sampler draws on a log scale.
+
+ Example:
+ >>> n_estimators: Annotated[int, IntRange(50, 500)] = 100
+ """
+
+ low: int | None
+ high: int | None
+ log: bool = False
+ tune: bool = False
+
+
+@dataclass(frozen=True)
+class CategoricalRange:
+ """Search space metadata for categorical hyperparameters.
+
+ Attach to a ``HyperParams`` field via ``Annotated`` to list the
+ discrete choices that a hyperparameter tuner should explore.
+
+ Args:
+ choices: Tuple of allowed values for the parameter.
+
+ Example:
+ >>> tree_method: Annotated[str, CategoricalRange(("hist", "approx"))] = "hist"
+ """
+
+ choices: tuple[Any, ...] | None
+ tune: bool = False
+
+
+#: Union alias for any single-parameter search space descriptor.
+TuningRange = FloatRange | IntRange | CategoricalRange
+
+
+class TunableHyperParams(HyperParams):
+ """HyperParams subclass that accepts ``TuningRange`` objects as field values.
+
+ Pass a :class:`FloatRange`, :class:`IntRange`, or :class:`CategoricalRange` as the
+ value for any field during construction. The range is stored in the private
+ ``_instance_ranges`` attribute and the field itself keeps its declared default value.
+ ``None`` for ``low`` / ``high`` / ``choices`` falls back to the class-level
+ ``Annotated`` metadata when the search space is resolved.
+
+ This means the tuning search space lives **on the HyperParams instance itself** — no
+ separate dict is needed.
+
+ Example::
+
+ hp = XGBoostHyperParams(
+ n_estimators=IntRange(100, 800, tune=True),
+ learning_rate=FloatRange(None, None, log=True, tune=True), # → class default [0.01, 0.5]
+ )
+ # hp.n_estimators == 100 (the class default; the IntRange was extracted)
+ # get_search_space(hp) → {'n_estimators': IntRange(100, 800), 'learning_rate': FloatRange(0.01, 0.5)}
+ """
+
+ _instance_ranges: dict[str, TuningRange] = PrivateAttr( # pyright: ignore[reportUnknownVariableType]
+ default_factory=dict
+ )
+
+ @property
+ def instance_ranges(self) -> dict[str, TuningRange]:
+ """Public view of the per-instance tuning ranges extracted at construction."""
+ return self._instance_ranges
+
+ @model_validator(mode="wrap")
+ @classmethod
+ def _extract_tuning_ranges(
+ cls,
+ data: dict[str, object] | object,
+ handler: Callable[[dict[str, object] | object], TunableHyperParams],
+ ) -> TunableHyperParams:
+ """Strip TuningRange values from the input dict and store them as instance metadata.
+
+ Returns:
+ A new :class:`TunableHyperParams` instance with TuningRange values removed
+ from the fields and stored in the private ``_instance_ranges`` attribute.
+ """
+ instance_ranges: dict[str, TuningRange] = {}
+ if isinstance(data, dict):
+ cleaned: dict[str, Any] = {}
+ for key, value in cast("dict[str, object]", data).items():
+ if isinstance(value, (FloatRange, IntRange, CategoricalRange)):
+ instance_ranges[key] = value
+ # Keep the key absent: Pydantic uses the declared field default
+ else:
+ cleaned[key] = value
+ data = cleaned
+ result: TunableHyperParams = handler(data)
+ if instance_ranges and result.__pydantic_private__ is not None:
+ result._instance_ranges = instance_ranges
+ return result
+
+
+@dataclass(frozen=True)
+class ModelTuningInfo:
+ """Dataclass for model specific hyperparameter info.
+
+ Ensures that search_space cannot be empty.
+
+ Attributes:
+ model_hyperparams_field_name: Name of the field on the config object
+ (e.g. ``"xgboost_hyperparams"``).
+ tunable_hyperparams: The ``TunableHyperParams`` instance to update with
+ trial suggestions.
+ search_space: Pre-computed, non-empty mapping of
+ parameter name → :class:`TuningRange`.
+ """
+
+ model_hyperparams_field_name: str
+ tunable_hyperparams: TunableHyperParams
+ search_space: dict[str, TuningRange]
+
+ def __post_init__(self) -> None:
+ """Validate that search_space is non-empty.
+
+ Raises:
+ ValueError: If ``search_space`` is empty.
+ """
+ if not self.search_space:
+ msg = (
+ f"search_space for '{self.model_hyperparams_field_name}' must not be empty. "
+ "Pass TuningRange(tune=True) objects in the HyperParams constructor."
+ )
+ raise ValueError(msg)
+
+
+@runtime_checkable
+class TunableWorkflowConfig(Protocol):
+ """Structural requirements for workflow configs for tuning.
+
+ This protocol is used for type checking of different configs cross-package, for example
+ ForecastingWorkflowConfig and EnsembleForecastingWorkflowConfig.
+ """
+
+ model_id: ModelIdentifier
+ optuna_n_trials: int
+ optuna_seed: int | None
+
+ @property
+ def model_selection_metric(self) -> tuple[QuantileOrGlobal, str, Any]:
+ """Metric used to select the best trial: (quantile, metric_name, direction)."""
+ ...
+
+ def get_model_tuning_info(self) -> list[ModelTuningInfo]:
+ """Return TunableField with model_hyperparams_field_name, hyperparams_instance and search_space for tuning.
+
+ Can be inherited from TuningConfigMixin.
+ """
+ ...
+
+ def model_copy(self, *, update: dict[str, Any]) -> Self:
+ """Return a copy of the config with the given fields updated."""
+ ...
+
+
+def _get_class_range(field_info: FieldInfo) -> TuningRange | None:
+ """Return the first TuningRange found in a Pydantic FieldInfo's metadata."""
+ for meta in field_info.metadata:
+ if isinstance(meta, (FloatRange, IntRange, CategoricalRange)):
+ return meta
+ return None
+
+
+def _merge_numerical_range[T: (FloatRange, IntRange)](override: T, class_range: TuningRange | None) -> T:
+ """Merge a FloatRange or IntRange override with the class-level default.
+
+ Returns:
+ A new instance of the same type as *override* with ``None`` bounds filled
+ from *class_range*.
+ """
+ cr = class_range if isinstance(class_range, type(override)) else None
+ low = override.low if override.low is not None else (cr.low if cr is not None else None)
+ high = override.high if override.high is not None else (cr.high if cr is not None else None)
+ return replace(override, low=low, high=high)
+
+
+def _merge_categorical_range(override: CategoricalRange, class_range: TuningRange | None) -> CategoricalRange:
+ """Merge a CategoricalRange override with the class-level CategoricalRange default.
+
+ Returns:
+ A new :class:`CategoricalRange` with ``None`` choices filled from *class_range*.
+ """
+ cr = class_range if isinstance(class_range, CategoricalRange) else None
+ cr_choices = cr.choices if cr is not None else None
+ choices = override.choices if override.choices is not None else cr_choices
+ return CategoricalRange(choices=choices, tune=override.tune)
+
+
+def _merge_range(override: TuningRange, class_range: TuningRange | None) -> TuningRange:
+ """Merge *override* with *class_range*, filling ``None`` from the class defaults.
+
+ For ``FloatRange`` / ``IntRange``, ``None`` values for ``low`` or ``high`` are filled
+ in from *class_range*. For ``CategoricalRange``, ``None`` for ``choices`` falls back
+ to *class_range*. The ``tune`` flag always comes from *override*.
+
+ Returns:
+ A new :class:`TuningRange` with ``None`` bounds merged from *class_range*.
+ """
+ if isinstance(override, FloatRange):
+ return _merge_numerical_range(override, class_range)
+ if isinstance(override, IntRange):
+ return _merge_numerical_range(override, class_range)
+ return _merge_categorical_range(override, class_range)
+
+
+def get_search_space(
+ hyperparams: BaseModel,
+ include: set[str] | None = None,
+) -> dict[str, TuningRange]:
+ """Extract the effective tunable search space from a *HyperParams* instance.
+
+ Reads per-instance ``TuningRange`` objects stored in ``_instance_ranges``
+ (set by passing ranges directly in the constructor of a
+ :class:`TunableHyperParams` subclass) and merges them with the class-level
+ ``Annotated`` metadata. ``None`` bounds fall back to the class-level defaults.
+ Only fields where the resulting ``tune`` flag is ``True`` are included.
+
+ Args:
+ hyperparams: A :class:`TunableHyperParams` (or plain ``HyperParams``) instance.
+ include: If given, restrict the output to exactly these field names. A
+ ``KeyError`` is raised immediately for any name that is absent or has no
+ ``tune=True`` annotation (catches typos early).
+
+ Returns:
+ Mapping of hyperparam field-name → effective :class:`TuningRange` for all tunable fields.
+
+ Raises:
+ KeyError: If ``include`` is specified and any requested field name is not
+ present in the tunable search space.
+
+ Example::
+
+ hp = XGBoostHyperParams(
+ n_estimators=IntRange(100, 800, tune=True),
+ learning_rate=FloatRange(None, None, log=True, tune=True),
+ )
+ space = get_search_space(hp)
+ # {'n_estimators': IntRange(100, 800), 'learning_rate': FloatRange(0.01, 0.5, log=True)}
+ """
+ # Per-instance ranges take precedence over class-level annotations
+ instance_ranges: dict[str, TuningRange] = {}
+ if isinstance(hyperparams, TunableHyperParams):
+ instance_ranges = hyperparams.instance_ranges
+
+ result: dict[str, TuningRange] = {}
+ for hyperparam_name, field_info in type(hyperparams).model_fields.items():
+ class_range = _get_class_range(field_info)
+ override = instance_ranges.get(hyperparam_name)
+
+ if override is not None:
+ if not override.tune:
+ continue
+ result[hyperparam_name] = _merge_range(override, class_range)
+ elif class_range is not None and class_range.tune:
+ result[hyperparam_name] = class_range
+
+ if include is not None:
+ missing = include - result.keys()
+ if missing:
+ msg = (
+ f"Fields {sorted(missing)!r} not found in the tunable search space. "
+ "Check that they exist on the HyperParams class and were passed as "
+ "TuningRange(tune=True) in the constructor."
+ )
+ raise KeyError(msg)
+ result = {k: result[k] for k in include}
+
+ return result
+
+
+def apply_trial_suggestions[HP: BaseModel](
+ trial: optuna.Trial,
+ space: dict[str, TuningRange],
+ current: HP,
+) -> HP:
+ """Create an updated *HyperParams* using Optuna trial suggestions.
+
+ Args:
+ trial: Optuna trial object for suggesting values.
+ space: Search space returned by :func:`get_search_space`.
+ current: Current ``HyperParams`` instance to copy-and-update.
+
+ Returns:
+ A new ``HyperParams`` instance with the suggested values applied.
+ """
+ updates: dict[str, Any] = {}
+ for hyperparam_name, tuning_range in space.items():
+ value = _suggest_hyperparam_value(trial, hyperparam_name, tuning_range)
+ if value is not None:
+ updates[hyperparam_name] = value
+ return current.model_copy(update=updates)
+
+
+def run_optuna_study(
+ objective: Callable[[optuna.Trial], float],
+ n_trials: int,
+ seed: int | None = 42,
+ direction: Literal["maximize", "minimize"] = "maximize",
+ study_name: str = "hyperparameter_tuning",
+) -> optuna.Study:
+ """Run a Bayesian hyperparameter optimisation study using Optuna.
+
+ Args:
+ objective: Callable that receives an :class:`optuna.Trial` and returns a
+ ``float`` score to optimise.
+ n_trials: Number of trials to evaluate.
+ seed: Random seed for the TPE sampler (``None`` disables seeding).
+ direction: ``"maximize"`` or ``"minimize"``.
+ study_name: Human-readable label for the study.
+
+ Returns:
+ Completed :class:`optuna.Study` with all trial results.
+ """
+ study = optuna.create_study(
+ direction=direction,
+ sampler=optuna.samplers.TPESampler(seed=seed),
+ pruner=optuna.pruners.MedianPruner(n_startup_trials=5),
+ study_name=study_name,
+ )
+ study.optimize(objective, n_trials=n_trials, show_progress_bar=True)
+ return study
+
+
+class TuningConfigMixin:
+ """Mixin for get_model_tuning_info for workflow configs.
+
+ Discovers tunable fields by reflecting over model_fields and returning a TunableField for every field whose value
+ is a TunableHyperParams instance with a non-empty search space.
+ """
+
+ def get_model_tuning_info(self) -> list[ModelTuningInfo]:
+ """Return one ModelTuningInfo per active tunable hyperparameter group for a model."""
+ result: list[ModelTuningInfo] = []
+ model_fields: dict[str, Any] = cast(dict[str, Any], getattr(type(self), "model_fields", {}))
+ for field_name in model_fields:
+ value = getattr(self, field_name)
+ if isinstance(value, TunableHyperParams): # checks if the config field contains tunable hyperparams
+ space = get_search_space(value)
+ if space:
+ result.append(
+ ModelTuningInfo(
+ model_hyperparams_field_name=field_name,
+ tunable_hyperparams=value,
+ search_space=space,
+ )
+ )
+ return result
+
+
+@dataclass(repr=False)
+class TuningResult:
+ """Result of a :func:`fit_with_tuning` call.
+
+ Attributes:
+ workflow: The fitted :class:`CustomForecastingWorkflow`.
+ fit_result: The :class:`ModelFitResult` from the final training run, or
+ ``None`` if fitting was skipped (e.g. by an MLflow callback).
+ study: The completed :class:`optuna.Study`. Raw best parameter values
+ are available via ``study.best_params``.
+ best_config: The workflow config updated with the best hyperparameters
+ found during tuning.
+ """
+
+ workflow: CustomForecastingWorkflow
+ fit_result: ModelFitResult | None
+ study: optuna.Study
+ best_config: TunableWorkflowConfig
+
+ def __repr__(self) -> str:
+ """Return a string representation of the TuningResult."""
+ n = len(self.study.best_params)
+ return f"TuningResult({n} params tuned)" if n else "TuningResult(no tuning)"
+
+
+class _TrialEntry(NamedTuple):
+ """One entry in the combined search space, keyed by Optuna trial-key.
+
+ Attributes:
+ model_hyperparams_field_name: Field on the config holding the hyperparams
+ group for a specific model, e.g. ``"xgboost_hyperparams"``.
+ hyperparam_name: Individual parameter within that group, e.g. ``"n_estimators"``.
+ tuning_range: Defines the search space for this parameter.
+ """
+
+ model_hyperparams_field_name: str
+ hyperparam_name: str
+ tuning_range: TuningRange
+
+
+def _suggest_hyperparam_value(
+ trial: optuna.Trial,
+ trial_key: str,
+ tuning_range: TuningRange,
+) -> bool | int | float | str | None:
+ """Suggest a value for *trial_key* using the appropriate Optuna API.
+
+ Returns ``None`` when the range is incomplete (missing bounds or choices)
+ so the caller can skip updating that parameter.
+
+ Returns:
+ The suggested value, or ``None`` if the range has no usable bounds.
+ """
+ if isinstance(tuning_range, FloatRange) and tuning_range.low is not None and tuning_range.high is not None:
+ return trial.suggest_float(trial_key, tuning_range.low, tuning_range.high, log=tuning_range.log)
+ if isinstance(tuning_range, IntRange) and tuning_range.low is not None and tuning_range.high is not None:
+ return trial.suggest_int(trial_key, tuning_range.low, tuning_range.high, log=tuning_range.log)
+ if isinstance(tuning_range, CategoricalRange) and tuning_range.choices is not None:
+ return trial.suggest_categorical(trial_key, list(tuning_range.choices))
+ return None
+
+
+def _build_hp_updates(
+ model_tuning_info: list[ModelTuningInfo],
+ per_field: dict[str, dict[str, Any]],
+) -> dict[str, Any]:
+ """Build a config-level update dict by applying *per_field* values to each HP group.
+
+ Returns:
+ Mapping of config field name → updated :class:`TunableHyperParams` instance.
+ """
+ return {
+ tf.model_hyperparams_field_name: tf.tunable_hyperparams.model_copy(
+ update=per_field[tf.model_hyperparams_field_name]
+ )
+ for tf in model_tuning_info
+ if tf.model_hyperparams_field_name in per_field
+ }
+
+
+class _TuningObjective:
+ """Callable Optuna objective that encapsulates the context for a tuning run."""
+
+ def __init__(
+ self,
+ combined_space: dict[str, _TrialEntry],
+ model_tuning_info: list[ModelTuningInfo],
+ config: TunableWorkflowConfig,
+ train_dataset: TimeSeriesDataset,
+ create_workflow: Callable[..., CustomForecastingWorkflow],
+ target_quantile: QuantileOrGlobal,
+ metric_name: str,
+ ) -> None:
+ """Store the tuning context."""
+ self._combined_space = combined_space
+ self._model_tuning_info = model_tuning_info
+ self._config = config
+ self._train_dataset = train_dataset
+ self._create_workflow = create_workflow
+ self._target_quantile: QuantileOrGlobal = target_quantile
+ self._metric_name = metric_name
+
+ def __call__(self, trial: optuna.Trial) -> float:
+ """Evaluate a single Optuna trial.
+
+ Returns:
+ Score to maximise, or ``-inf`` on failure.
+ """
+ per_field: dict[str, dict[str, Any]] = {}
+ for trial_key, trial_entry in self._combined_space.items():
+ value = _suggest_hyperparam_value(trial, trial_key, trial_entry.tuning_range)
+ if value is not None:
+ per_field.setdefault(trial_entry.model_hyperparams_field_name, {})[trial_entry.hyperparam_name] = value
+
+ tuned_config = self._config.model_copy(update=_build_hp_updates(self._model_tuning_info, per_field))
+
+ trial_workflow = self._create_workflow(tuned_config)
+ trial_result = trial_workflow.fit(self._train_dataset)
+ if trial_result is None:
+ return float("-inf")
+ metrics = trial_result.metrics_val if trial_result.metrics_val is not None else trial_result.metrics_train
+ score = metrics.get_metric(quantile=self._target_quantile, metric_name=self._metric_name)
+ return float(score) if score is not None else float("-inf")
+
+
+def tune[ConfigT: TunableWorkflowConfig](
+ config: ConfigT,
+ train_dataset: TimeSeriesDataset,
+ create_workflow: Callable[[ConfigT], CustomForecastingWorkflow],
+) -> tuple[ConfigT, optuna.Study, dict[str, Any]]:
+ """Generic hyperparameter tuning for any TunableWorkflowConfig.
+
+ Args:
+ config: Any config implementing TunableWorkflowConfig.
+ train_dataset: Dataset used for all trial fit calls.
+ create_workflow: Factory that builds a CustomForecastingWorkflow from config.
+
+ Returns:
+ (best_config, study, best_params)
+
+ Raises:
+ ValueError: If no hyperparameter field has tune=True ranges.
+ """
+ model_tuning_info = config.get_model_tuning_info()
+ if not model_tuning_info:
+ msg = (
+ f"No tunable hyperparameters found on config '{config.model_id}'. "
+ "Pass TuningRange(tune=True) objects as field values in the hyperparams constructor."
+ )
+ raise ValueError(msg)
+
+ target_quantile, metric_name, _ = config.model_selection_metric
+
+ # Aggregate search spaces across tunable hyperparam fields.
+ # Use prefixes to avoid collisions.
+ multi = len(model_tuning_info) > 1
+ combined_space: dict[
+ str, _TrialEntry
+ ] = {} # trial_key -> (model_hyperparams_field_name, hyperparam_name, tuning_range)
+ for tf in model_tuning_info:
+ for hyperparam_name, tuning_range in tf.search_space.items():
+ trial_key = f"{tf.model_hyperparams_field_name}.{hyperparam_name}" if multi else hyperparam_name
+ combined_space[trial_key] = _TrialEntry(tf.model_hyperparams_field_name, hyperparam_name, tuning_range)
+
+ # Build and run the Optuna study
+ objective = _TuningObjective(
+ combined_space=combined_space,
+ model_tuning_info=model_tuning_info,
+ config=config,
+ train_dataset=train_dataset,
+ create_workflow=create_workflow,
+ target_quantile=target_quantile,
+ metric_name=metric_name,
+ )
+ study = run_optuna_study(
+ objective=objective,
+ n_trials=config.optuna_n_trials,
+ seed=config.optuna_seed,
+ study_name=f"tuning_{config.model_id}",
+ )
+
+ # Reconstruct the best config by applying the best parameters per field
+ best_config = _reconstruct_best_config(config, model_tuning_info, study)
+ return best_config, study, study.best_params
+
+
+def _reconstruct_best_config[ConfigT: TunableWorkflowConfig](
+ config: ConfigT,
+ model_tuning_info_list: list[ModelTuningInfo],
+ study: optuna.Study,
+) -> ConfigT:
+ """Returns the best config using the optuna study results for all tunable fields.
+
+ Args:
+ config: Any config implementing TunableWorkflowConfig.
+ model_tuning_info_list: list of :class: ModelTuningInfo per model,
+ study: :class:`optuna.Study` completed with trial results
+
+ Returns:
+ :class:`TunableWorkflowConfig` with the best best hyperparameter values.
+ """
+ multi = len(model_tuning_info_list) > 1
+ per_field_best: dict[str, dict[str, Any]] = {}
+ for trial_key, value in study.best_params.items():
+ if multi and "." in trial_key:
+ model_hyperparams_field_name, hyperparam_name = trial_key.split(".", 1)
+ else:
+ model_hyperparams_field_name = model_tuning_info_list[0].model_hyperparams_field_name
+ hyperparam_name = trial_key
+ per_field_best.setdefault(model_hyperparams_field_name, {})[hyperparam_name] = value
+
+ return config.model_copy(update=_build_hp_updates(model_tuning_info_list, per_field_best))
+
+
+def fit_with_tuning[ConfigT: TunableWorkflowConfig](
+ config: ConfigT, train_dataset: TimeSeriesDataset, create_workflow: Callable[[ConfigT], CustomForecastingWorkflow]
+) -> TuningResult:
+ """Create, tune and fit.
+
+ Args:
+ config: Any config implementing TunableWorkflowConfig.
+ train_dataset: Dataset used for fit.
+ create_workflow: Factory that builds a CustomForecastingWorkflow from config.
+
+ Returns:
+ :class:`TuningResult` with the fitted workflow, completed study, and best config.
+ """
+ best_config, study, _ = tune(config, train_dataset, create_workflow)
+ workflow = create_workflow(best_config)
+ result = workflow.fit(train_dataset)
+ return TuningResult(workflow=workflow, fit_result=result, study=study, best_config=best_config)
+
+
+__all__ = [
+ "CategoricalRange",
+ "FloatRange",
+ "IntRange",
+ "ModelTuningInfo",
+ "TunableHyperParams",
+ "TunableWorkflowConfig",
+ "TuningConfigMixin",
+ "TuningRange",
+ "TuningResult",
+ "apply_trial_suggestions",
+ "fit_with_tuning",
+ "get_search_space",
+ "run_optuna_study",
+ "tune",
+]
diff --git a/packages/openstef-models/tests/unit/utils/test_tuning.py b/packages/openstef-models/tests/unit/utils/test_tuning.py
new file mode 100644
index 000000000..291569208
--- /dev/null
+++ b/packages/openstef-models/tests/unit/utils/test_tuning.py
@@ -0,0 +1,477 @@
+# SPDX-FileCopyrightText: 2025 Contributors to the OpenSTEF project
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""Unit tests for the hyperparameter tuning utilities."""
+
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import MagicMock
+
+import optuna
+import pytest
+
+from openstef_models.models.forecasting.xgboost_forecaster import XGBoostHyperParams
+from openstef_models.presets.forecasting_workflow import ForecastingWorkflowConfig
+from openstef_models.utils.tuning import (
+ CategoricalRange,
+ FloatRange,
+ IntRange,
+ ModelTuningInfo,
+ TuningResult,
+ _merge_range, # noqa: PLC2701
+ _reconstruct_best_config, # noqa: PLC2701
+ _suggest_hyperparam_value, # noqa: PLC2701
+ apply_trial_suggestions,
+ fit_with_tuning,
+ get_search_space,
+ run_optuna_study,
+ tune,
+)
+
+# Suppress Optuna progress output during tests
+optuna.logging.set_verbosity(optuna.logging.WARNING)
+
+
+def _config(**kwargs: Any) -> ForecastingWorkflowConfig:
+ """Minimal ForecastingWorkflowConfig for tuning tests."""
+ return ForecastingWorkflowConfig(
+ model_id="test",
+ model="xgboost",
+ optuna_n_trials=2,
+ optuna_seed=0,
+ **kwargs,
+ )
+
+
+# Helper
+
+
+def _make_mock_workflow(score: float = 0.8) -> MagicMock:
+ """Return a mock workflow whose fit() reports a fixed metric score."""
+ mock_metrics = MagicMock()
+ mock_metrics.get_metric.return_value = score
+ mock_fit_result = MagicMock()
+ mock_fit_result.metrics_val = mock_metrics
+ mock_workflow = MagicMock()
+ mock_workflow.fit.return_value = mock_fit_result
+ return mock_workflow
+
+
+# TunableHyperParams
+
+
+def test_tunable_hyperparams__range_extracted_and_field_keeps_default() -> None:
+ """A TuningRange passed at construction is stored in instance_ranges; the field keeps its default."""
+ hp = XGBoostHyperParams(n_estimators=IntRange(100, 800, tune=True))
+
+ assert hp.instance_ranges["n_estimators"] == IntRange(100, 800, tune=True)
+ assert hp.n_estimators == 100 # default preserved
+
+
+def test_tunable_hyperparams__multiple_ranges_all_extracted() -> None:
+ """All TuningRange values passed at construction appear in instance_ranges."""
+ hp = XGBoostHyperParams(
+ n_estimators=IntRange(100, 800, tune=True),
+ learning_rate=FloatRange(0.01, 0.5, log=True, tune=True),
+ grow_policy=CategoricalRange(("depthwise",), tune=True),
+ )
+
+ assert set(hp.instance_ranges.keys()) == {"n_estimators", "learning_rate", "grow_policy"}
+
+
+def test_tunable_hyperparams__scalar_values_not_extracted() -> None:
+ """Scalar field values are stored normally and never appear in instance_ranges."""
+ hp = XGBoostHyperParams(n_estimators=200)
+
+ assert hp.n_estimators == 200
+ assert hp.instance_ranges == {}
+
+
+# ModelTuningInfo
+
+
+def test_model_tuning_info__raises_on_empty_search_space() -> None:
+ """ModelTuningInfo raises ValueError when search_space is empty."""
+ with pytest.raises(ValueError, match=r"search_space.*must not be empty"):
+ ModelTuningInfo(
+ model_hyperparams_field_name="xgboost_hyperparams",
+ tunable_hyperparams=XGBoostHyperParams(),
+ search_space={},
+ )
+
+
+# _merge_range
+
+
+@pytest.mark.parametrize(
+ ("override", "class_range", "expected"),
+ [
+ pytest.param(
+ FloatRange(None, None, tune=True),
+ FloatRange(0.01, 0.5, log=True),
+ FloatRange(0.01, 0.5, log=False, tune=True),
+ id="float-none-bounds-fallback",
+ ),
+ pytest.param(
+ FloatRange(0.2, 0.8, tune=True),
+ FloatRange(0.01, 0.5),
+ FloatRange(0.2, 0.8, log=False, tune=True),
+ id="float-override-bounds-preserved",
+ ),
+ pytest.param(
+ FloatRange(None, 0.8, tune=True),
+ None,
+ FloatRange(None, 0.8, log=False, tune=True),
+ id="float-none-stays-without-class-range",
+ ),
+ pytest.param(
+ IntRange(None, None, tune=True),
+ IntRange(10, 100),
+ IntRange(10, 100, log=False, tune=True),
+ id="int-none-bounds-fallback",
+ ),
+ pytest.param(
+ IntRange(20, 80, tune=True),
+ IntRange(10, 100),
+ IntRange(20, 80, log=False, tune=True),
+ id="int-override-bounds-preserved",
+ ),
+ pytest.param(
+ CategoricalRange(None, tune=True),
+ CategoricalRange(("x", "y")),
+ CategoricalRange(("x", "y"), tune=True),
+ id="categorical-none-choices-fallback",
+ ),
+ pytest.param(
+ CategoricalRange(("a",), tune=True),
+ CategoricalRange(("x", "y")),
+ CategoricalRange(("a",), tune=True),
+ id="categorical-override-choices-preserved",
+ ),
+ ],
+)
+def test_merge_range__fills_none_bounds_from_class_range(
+ override: FloatRange | IntRange | CategoricalRange,
+ class_range: FloatRange | IntRange | CategoricalRange | None,
+ expected: FloatRange | IntRange | CategoricalRange,
+) -> None:
+ """_merge_range fills None bounds/choices from class_range; tune always comes from override."""
+ assert _merge_range(override, class_range) == expected
+
+
+# ===========================================================================
+# get_search_space
+# ===========================================================================
+
+
+def test_get_search_space__returns_instance_ranges_with_tune_true() -> None:
+ """get_search_space includes instance ranges where tune=True."""
+ space = get_search_space(XGBoostHyperParams(n_estimators=IntRange(100, 800, tune=True)))
+
+ assert space["n_estimators"] == IntRange(100, 800, tune=True)
+
+
+def test_get_search_space__excludes_instance_ranges_with_tune_false() -> None:
+ """get_search_space excludes instance ranges where tune=False."""
+ assert "n_estimators" not in get_search_space(XGBoostHyperParams(n_estimators=IntRange(100, 800, tune=False)))
+
+
+def test_get_search_space__returns_empty_when_no_tune_true_annotations() -> None:
+ """get_search_space returns empty dict when no field has tune=True (XGBoostHyperParams class defaults)."""
+ assert get_search_space(XGBoostHyperParams()) == {}
+
+
+def test_get_search_space__merges_none_bounds_from_class_annotation() -> None:
+ """Instance ranges with None bounds are filled from the class-level Annotated defaults."""
+ # XGBoostHyperParams.learning_rate has FloatRange(0.01, 0.5, log=True) as its class annotation
+ space = get_search_space(XGBoostHyperParams(learning_rate=FloatRange(None, None, log=True, tune=True)))
+
+ result = space["learning_rate"]
+ assert isinstance(result, FloatRange)
+ assert result.low == pytest.approx(0.01)
+ assert result.high == pytest.approx(0.5)
+ assert result.log is True
+
+
+def test_get_search_space__include_restricts_to_requested_fields() -> None:
+ """get_search_space with include returns only the requested field names."""
+ hp = XGBoostHyperParams(n_estimators=IntRange(100, 800, tune=True), max_depth=IntRange(1, 10, tune=True))
+ assert set(get_search_space(hp, include={"n_estimators"}).keys()) == {"n_estimators"}
+
+
+@pytest.mark.parametrize(
+ "bad_include",
+ [
+ pytest.param({"nonexistent"}, id="field-missing-from-class"),
+ pytest.param({"objective"}, id="field-has-no-tune-annotation"),
+ ],
+)
+def test_get_search_space__raises_key_error_for_invalid_include(bad_include: set[str]) -> None:
+ """get_search_space raises KeyError when include contains an absent or non-tunable field."""
+ with pytest.raises(KeyError):
+ get_search_space(XGBoostHyperParams(n_estimators=IntRange(100, 800, tune=True)), include=bad_include)
+
+
+# _suggest_hyperparam_value
+
+
+@pytest.mark.parametrize(
+ ("tuning_range", "suggest_method", "call_args", "call_kwargs"),
+ [
+ (FloatRange(0.1, 0.9), "suggest_float", ("param", 0.1, 0.9), {"log": False}),
+ (FloatRange(0.01, 0.5, log=True), "suggest_float", ("param", 0.01, 0.5), {"log": True}),
+ (IntRange(10, 100), "suggest_int", ("param", 10, 100), {"log": False}),
+ (CategoricalRange(("a", "b")), "suggest_categorical", ("param", ["a", "b"]), {}),
+ ],
+)
+def test_suggest_hyperparam_value__calls_correct_optuna_api(
+ tuning_range: FloatRange | IntRange | CategoricalRange,
+ suggest_method: str,
+ call_args: tuple[object, ...],
+ call_kwargs: dict[str, object],
+) -> None:
+ """_suggest_hyperparam_value calls the correct optuna.Trial method for each TuningRange type."""
+ # Arrange
+ trial = MagicMock(spec=optuna.Trial)
+ getattr(trial, suggest_method).return_value = 0.5
+
+ # Act
+ _suggest_hyperparam_value(trial, "param", tuning_range)
+
+ # Assert
+ getattr(trial, suggest_method).assert_called_once_with(*call_args, **call_kwargs)
+
+
+@pytest.mark.parametrize(
+ "incomplete_range",
+ [
+ FloatRange(None, 0.9),
+ FloatRange(0.1, None),
+ IntRange(None, 100),
+ CategoricalRange(None),
+ ],
+)
+def test_suggest_hyperparam_value__returns_none_for_incomplete_range(
+ incomplete_range: FloatRange | IntRange | CategoricalRange,
+) -> None:
+ """_suggest_hyperparam_value returns None when bounds or choices are missing."""
+ # Arrange
+ trial = MagicMock(spec=optuna.Trial)
+
+ # Act
+ result = _suggest_hyperparam_value(trial, "param", incomplete_range)
+
+ # Assert
+ assert result is None
+ trial.suggest_float.assert_not_called()
+ trial.suggest_int.assert_not_called()
+ trial.suggest_categorical.assert_not_called()
+
+
+# apply_trial_suggestions
+
+
+def test_apply_trial_suggestions__updates_all_fields_from_trial() -> None:
+ """apply_trial_suggestions applies all trial suggestions and returns an updated HyperParams."""
+ # Arrange
+ hp = XGBoostHyperParams()
+ trial = MagicMock(spec=optuna.Trial)
+ trial.suggest_float.return_value = 0.1
+ trial.suggest_int.return_value = 200
+ trial.suggest_categorical.return_value = "lossguide"
+ space: dict[str, Any] = {
+ "learning_rate": FloatRange(0.01, 0.5, log=True),
+ "n_estimators": IntRange(50, 500),
+ "grow_policy": CategoricalRange(("depthwise", "lossguide")),
+ }
+
+ # Act
+ result = apply_trial_suggestions(trial, space, hp)
+
+ # Assert
+ assert result.learning_rate == pytest.approx(0.1)
+ assert result.n_estimators == 200
+ assert result.grow_policy == "lossguide"
+ trial.suggest_float.assert_called_once_with("learning_rate", 0.01, 0.5, log=True)
+ trial.suggest_int.assert_called_once_with("n_estimators", 50, 500, log=False)
+ trial.suggest_categorical.assert_called_once_with("grow_policy", ["depthwise", "lossguide"])
+
+
+def test_apply_trial_suggestions__skips_fields_with_none_bounds() -> None:
+ """apply_trial_suggestions leaves fields unchanged when their range has None bounds."""
+ hp = XGBoostHyperParams()
+ trial = MagicMock(spec=optuna.Trial)
+
+ result = apply_trial_suggestions(trial, {"n_estimators": IntRange(None, None)}, hp)
+
+ assert result.n_estimators == hp.n_estimators
+ trial.suggest_int.assert_not_called()
+
+
+# TuningConfigMixin
+
+
+def test_tuning_config_mixin__discovers_all_tunable_fields() -> None:
+ """get_model_tuning_info returns one ModelTuningInfo per TunableHyperParams field with a non-empty search space."""
+ config = _config(xgboost_hyperparams=XGBoostHyperParams(n_estimators=IntRange(50, 500, tune=True)))
+ tunable = config.get_model_tuning_info()
+
+ assert len(tunable) == 1
+ assert tunable[0].model_hyperparams_field_name == "xgboost_hyperparams"
+ assert "n_estimators" in tunable[0].search_space
+
+
+def test_tuning_config_mixin__returns_empty_when_no_tunable_ranges() -> None:
+ """get_model_tuning_info returns an empty list when no TunableHyperParams field has tune=True."""
+ assert _config().get_model_tuning_info() == []
+
+
+# TuningResult
+
+
+@pytest.mark.parametrize(
+ ("best_params", "expected_repr"),
+ [
+ ({"alpha": 0.5, "n_iter": 42}, "TuningResult(2 params tuned)"),
+ ({}, "TuningResult(no tuning)"),
+ ],
+)
+def test_tuning_result__repr_reflects_param_count(best_params: dict[str, Any], expected_repr: str) -> None:
+ """TuningResult.__repr__ summarises the count of tuned parameters."""
+ # Arrange
+ study = MagicMock(spec=optuna.Study)
+ study.best_params = best_params
+ result = TuningResult(
+ workflow=MagicMock(),
+ fit_result=None,
+ study=study,
+ best_config=MagicMock(),
+ )
+
+ # Act & Assert
+ assert repr(result) == expected_repr
+
+
+# run_optuna_study
+
+
+@pytest.mark.parametrize("n_trials", [1, 3])
+def test_run_optuna_study__runs_exactly_n_trials(n_trials: int) -> None:
+ """run_optuna_study produces a study containing exactly n_trials completed trials."""
+
+ # Arrange
+ def objective(trial: optuna.Trial) -> float:
+ return trial.suggest_float("x", 0.0, 1.0)
+
+ # Act
+ study = run_optuna_study(objective, n_trials=n_trials, seed=0)
+
+ # Assert
+ assert isinstance(study, optuna.Study)
+ assert len(study.trials) == n_trials
+
+
+@pytest.mark.parametrize(
+ ("direction", "expected_direction_name"),
+ [
+ ("maximize", "MAXIMIZE"),
+ ("minimize", "MINIMIZE"),
+ ],
+)
+def test_run_optuna_study__respects_direction(direction: str, expected_direction_name: str) -> None:
+ """run_optuna_study creates a study with the specified optimisation direction."""
+
+ # Arrange
+ def objective(trial: optuna.Trial) -> float:
+ return trial.suggest_float("x", 0.0, 1.0)
+
+ # Act
+ study = run_optuna_study(objective, n_trials=1, seed=0, direction=direction) # type: ignore[arg-type]
+
+ # Assert
+ assert study.direction.name == expected_direction_name
+
+
+# _reconstruct_best_config
+
+
+def test_reconstruct_best_config__single_model_applies_best_params() -> None:
+ """_reconstruct_best_config updates the single hyperparams field with best_params values."""
+ config = _config()
+ info = ModelTuningInfo(
+ model_hyperparams_field_name="xgboost_hyperparams",
+ tunable_hyperparams=config.xgboost_hyperparams,
+ search_space={"n_estimators": IntRange(50, 500, tune=True)},
+ )
+ study = MagicMock(spec=optuna.Study)
+ study.best_params = {"n_estimators": 300}
+
+ best_config = _reconstruct_best_config(config, [info], study)
+
+ assert best_config.xgboost_hyperparams.n_estimators == 300
+ assert best_config.xgboost_hyperparams.max_depth == config.xgboost_hyperparams.max_depth # unchanged
+
+
+def test_reconstruct_best_config__multi_model_parses_dotted_trial_keys() -> None:
+ """_reconstruct_best_config routes 'field.param' keys to the correct HP group."""
+ config = _config()
+ info_xgb = ModelTuningInfo(
+ model_hyperparams_field_name="xgboost_hyperparams",
+ tunable_hyperparams=config.xgboost_hyperparams,
+ search_space={"n_estimators": IntRange(50, 500, tune=True)},
+ )
+ info_gblinear = ModelTuningInfo(
+ model_hyperparams_field_name="gblinear_hyperparams",
+ tunable_hyperparams=config.gblinear_hyperparams,
+ search_space={"n_estimators": IntRange(50, 500, tune=True)},
+ )
+ study = MagicMock(spec=optuna.Study)
+ study.best_params = {"xgboost_hyperparams.n_estimators": 300, "gblinear_hyperparams.n_estimators": 150}
+
+ best_config = _reconstruct_best_config(config, [info_xgb, info_gblinear], study)
+
+ assert best_config.xgboost_hyperparams.n_estimators == 300
+ assert best_config.gblinear_hyperparams.n_estimators == 150
+
+
+# tune
+
+
+def test_tune__raises_when_no_tunable_hyperparams() -> None:
+ """tune raises ValueError when the config exposes no tune=True hyperparameter ranges."""
+ with pytest.raises(ValueError, match="No tunable hyperparameters"):
+ tune(_config(), MagicMock(), MagicMock())
+
+
+def test_tune__returns_best_config_study_and_params() -> None:
+ """tune returns a best_config, completed study, and best_params dict after n_trials trials."""
+ config = _config(xgboost_hyperparams=XGBoostHyperParams(n_estimators=IntRange(50, 500, tune=True)))
+ create_workflow = MagicMock(return_value=_make_mock_workflow())
+
+ best_config, study, best_params = tune(config, MagicMock(), create_workflow)
+
+ assert isinstance(best_config, ForecastingWorkflowConfig)
+ assert isinstance(study, optuna.Study)
+ assert len(study.trials) == 2
+ assert "n_estimators" in best_params
+ assert 50 <= best_params["n_estimators"] <= 500
+
+
+# fit_with_tuning
+
+
+def test_fit_with_tuning__returns_tuning_result_with_best_config_and_study() -> None:
+ """fit_with_tuning returns a TuningResult holding the best config, study, and fitted workflow."""
+ config = _config(xgboost_hyperparams=XGBoostHyperParams(n_estimators=IntRange(50, 500, tune=True)))
+ create_workflow = MagicMock(return_value=_make_mock_workflow())
+
+ result = fit_with_tuning(config, MagicMock(), create_workflow)
+
+ assert isinstance(result, TuningResult)
+ assert isinstance(result.study, optuna.Study)
+ assert isinstance(result.best_config, ForecastingWorkflowConfig)
+ assert result.workflow is not None
+ # n_trials training runs during tuning + 1 final fit with the best config
+ assert create_workflow.call_count == 2 + 1
diff --git a/pyproject.toml b/pyproject.toml
index 15a43c8cc..b50e3d487 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,6 +29,7 @@ classifiers = [
dependencies = [
"openstef-core",
"openstef-models[xgb-cpu]",
+ "optuna>=4.7",
]
optional-dependencies.all = [
diff --git a/uv.lock b/uv.lock
index d6360eecc..a8c24e62d 100644
--- a/uv.lock
+++ b/uv.lock
@@ -172,6 +172,20 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" },
]
+[[package]]
+name = "alembic"
+version = "1.18.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mako" },
+ { name = "sqlalchemy" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/79/41/ab8f624929847b49f84955c594b165855efd829b0c271e1a8cac694138e5/alembic-1.18.3.tar.gz", hash = "sha256:1212aa3778626f2b0f0aa6dd4e99a5f99b94bd25a0c1ac0bba3be65e081e50b0", size = 2052564, upload-time = "2026-01-29T20:24:15.124Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/45/8e/d79281f323e7469b060f15bd229e48d7cdd219559e67e71c013720a88340/alembic-1.18.3-py3-none-any.whl", hash = "sha256:12a0359bfc068a4ecbb9b3b02cf77856033abfdb59e4a5aca08b7eacd7b74ddd", size = 262282, upload-time = "2026-01-29T20:24:17.488Z" },
+]
+
[[package]]
name = "annotated-doc"
version = "0.0.4"
@@ -632,6 +646,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
]
+[[package]]
+name = "colorlog"
+version = "6.10.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/61/f083b5ac52e505dfc1c624eafbf8c7589a0d7f32daa398d2e7590efa5fda/colorlog-6.10.1.tar.gz", hash = "sha256:eb4ae5cb65fe7fec7773c2306061a8e63e02efc2c72eba9d27b0fa23c94f1321", size = 17162, upload-time = "2025-10-16T16:14:11.978Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6d/c1/e419ef3723a074172b68aaa89c9f3de486ed4c2399e2dbd8113a4fdcaf9e/colorlog-6.10.1-py3-none-any.whl", hash = "sha256:2d7e8348291948af66122cff006c9f8da6255d224e7cf8e37d8de2df3bad8c9c", size = 11743, upload-time = "2025-10-16T16:14:10.512Z" },
+]
+
[[package]]
name = "comm"
version = "0.2.3"
@@ -1236,6 +1262,45 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0a/14/933037032608787fb92e365883ad6a741c235e0ff992865ec5d904a38f1e/graphql_core-3.2.7-py3-none-any.whl", hash = "sha256:17fc8f3ca4a42913d8e24d9ac9f08deddf0a0b2483076575757f6c412ead2ec0", size = 207262, upload-time = "2025-11-01T22:30:38.912Z" },
]
+[[package]]
+name = "greenlet"
+version = "3.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8a/99/1cd3411c56a410994669062bd73dd58270c00cc074cac15f385a1fd91f8a/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98", size = 184690, upload-time = "2026-01-23T15:31:02.076Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f9/c8/9d76a66421d1ae24340dfae7e79c313957f6e3195c144d2c73333b5bfe34/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975", size = 276443, upload-time = "2026-01-23T15:30:10.066Z" },
+ { url = "https://files.pythonhosted.org/packages/81/99/401ff34bb3c032d1f10477d199724f5e5f6fbfb59816ad1455c79c1eb8e7/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36", size = 597359, upload-time = "2026-01-23T16:00:57.394Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/bc/4dcc0871ed557792d304f50be0f7487a14e017952ec689effe2180a6ff35/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba", size = 607805, upload-time = "2026-01-23T16:05:28.068Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/05/821587cf19e2ce1f2b24945d890b164401e5085f9d09cbd969b0c193cd20/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336", size = 609947, upload-time = "2026-01-23T15:32:51.004Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/52/ee8c46ed9f8babaa93a19e577f26e3d28a519feac6350ed6f25f1afee7e9/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1", size = 1567487, upload-time = "2026-01-23T16:04:22.125Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/7c/456a74f07029597626f3a6db71b273a3632aecb9afafeeca452cfa633197/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149", size = 1636087, upload-time = "2026-01-23T15:33:47.486Z" },
+ { url = "https://files.pythonhosted.org/packages/34/2f/5e0e41f33c69655300a5e54aeb637cf8ff57f1786a3aba374eacc0228c1d/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a", size = 227156, upload-time = "2026-01-23T15:34:34.808Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/ab/717c58343cf02c5265b531384b248787e04d8160b8afe53d9eec053d7b44/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1", size = 226403, upload-time = "2026-01-23T15:31:39.372Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/ab/d26750f2b7242c2b90ea2ad71de70cfcd73a948a49513188a0fc0d6fc15a/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3", size = 275205, upload-time = "2026-01-23T15:30:24.556Z" },
+ { url = "https://files.pythonhosted.org/packages/10/d3/be7d19e8fad7c5a78eeefb2d896a08cd4643e1e90c605c4be3b46264998f/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac", size = 599284, upload-time = "2026-01-23T16:00:58.584Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/21/fe703aaa056fdb0f17e5afd4b5c80195bbdab701208918938bd15b00d39b/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd", size = 610274, upload-time = "2026-01-23T16:05:29.312Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/86/5c6ab23bb3c28c21ed6bebad006515cfe08b04613eb105ca0041fecca852/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3", size = 612904, upload-time = "2026-01-23T15:32:52.317Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/f3/7949994264e22639e40718c2daf6f6df5169bf48fb038c008a489ec53a50/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951", size = 1567316, upload-time = "2026-01-23T16:04:23.316Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/6e/d73c94d13b6465e9f7cd6231c68abde838bb22408596c05d9059830b7872/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2", size = 1636549, upload-time = "2026-01-23T15:33:48.643Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/b3/c9c23a6478b3bcc91f979ce4ca50879e4d0b2bd7b9a53d8ecded719b92e2/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946", size = 227042, upload-time = "2026-01-23T15:33:58.216Z" },
+ { url = "https://files.pythonhosted.org/packages/90/e7/824beda656097edee36ab15809fd063447b200cc03a7f6a24c34d520bc88/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d", size = 226294, upload-time = "2026-01-23T15:30:52.73Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/fb/011c7c717213182caf78084a9bea51c8590b0afda98001f69d9f853a495b/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5", size = 275737, upload-time = "2026-01-23T15:32:16.889Z" },
+ { url = "https://files.pythonhosted.org/packages/41/2e/a3a417d620363fdbb08a48b1dd582956a46a61bf8fd27ee8164f9dfe87c2/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b", size = 646422, upload-time = "2026-01-23T16:01:00.354Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/09/c6c4a0db47defafd2d6bab8ddfe47ad19963b4e30f5bed84d75328059f8c/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e", size = 658219, upload-time = "2026-01-23T16:05:30.956Z" },
+ { url = "https://files.pythonhosted.org/packages/80/38/9d42d60dffb04b45f03dbab9430898352dba277758640751dc5cc316c521/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f", size = 660237, upload-time = "2026-01-23T15:32:53.967Z" },
+ { url = "https://files.pythonhosted.org/packages/96/61/373c30b7197f9e756e4c81ae90a8d55dc3598c17673f91f4d31c3c689c3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683", size = 1615261, upload-time = "2026-01-23T16:04:25.066Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/d3/ca534310343f5945316f9451e953dcd89b36fe7a19de652a1dc5a0eeef3f/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1", size = 1683719, upload-time = "2026-01-23T15:33:50.61Z" },
+ { url = "https://files.pythonhosted.org/packages/52/cb/c21a3fd5d2c9c8b622e7bede6d6d00e00551a5ee474ea6d831b5f567a8b4/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a", size = 228125, upload-time = "2026-01-23T15:32:45.265Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/8e/8a2db6d11491837af1de64b8aff23707c6e85241be13c60ed399a72e2ef8/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79", size = 227519, upload-time = "2026-01-23T15:31:47.284Z" },
+ { url = "https://files.pythonhosted.org/packages/28/24/cbbec49bacdcc9ec652a81d3efef7b59f326697e7edf6ed775a5e08e54c2/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242", size = 282706, upload-time = "2026-01-23T15:33:05.525Z" },
+ { url = "https://files.pythonhosted.org/packages/86/2e/4f2b9323c144c4fe8842a4e0d92121465485c3c2c5b9e9b30a52e80f523f/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774", size = 651209, upload-time = "2026-01-23T16:01:01.517Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/87/50ca60e515f5bb55a2fbc5f0c9b5b156de7d2fc51a0a69abc9d23914a237/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97", size = 654300, upload-time = "2026-01-23T16:05:32.199Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/94/74310866dfa2b73dd08659a3d18762f83985ad3281901ba0ee9a815194fb/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2", size = 653842, upload-time = "2026-01-23T15:32:55.671Z" },
+ { url = "https://files.pythonhosted.org/packages/97/43/8bf0ffa3d498eeee4c58c212a3905dd6146c01c8dc0b0a046481ca29b18c/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53", size = 1614917, upload-time = "2026-01-23T16:04:26.276Z" },
+ { url = "https://files.pythonhosted.org/packages/89/90/a3be7a5f378fc6e84abe4dcfb2ba32b07786861172e502388b4c90000d1b/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249", size = 1676092, upload-time = "2026-01-23T15:33:52.176Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/2b/98c7f93e6db9977aaee07eb1e51ca63bd5f779b900d362791d3252e60558/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451", size = 233181, upload-time = "2026-01-23T15:33:00.29Z" },
+]
+
[[package]]
name = "h11"
version = "0.16.0"
@@ -2055,6 +2120,18 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
]
+[[package]]
+name = "mako"
+version = "1.3.10"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/38/bd5b78a920a64d708fe6bc8e0a2c075e1389d53bef8413725c63ba041535/mako-1.3.10.tar.gz", hash = "sha256:99579a6f39583fa7e5630a28c3c1f440e4e97a414b80372649c0ce338da2ea28", size = 392474, upload-time = "2025-04-10T12:44:31.16Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/87/fb/99f81ac72ae23375f22b7afdb7642aba97c00a713c217124420147681a2f/mako-1.3.10-py3-none-any.whl", hash = "sha256:baef24a52fc4fc514a0887ac600f9f1cff3d82c61d4d700a1fa84d597b88db59", size = 78509, upload-time = "2025-04-10T12:50:53.297Z" },
+]
+
[[package]]
name = "markdown"
version = "3.10"
@@ -2685,6 +2762,7 @@ source = { editable = "." }
dependencies = [
{ name = "openstef-core" },
{ name = "openstef-models", extra = ["xgb-cpu"] },
+ { name = "optuna" },
]
[package.optional-dependencies]
@@ -2739,6 +2817,7 @@ requires-dist = [
{ name = "openstef-models", extras = ["xgb-cpu"], editable = "packages/openstef-models" },
{ name = "openstef-models", extras = ["xgb-cpu"], marker = "extra == 'all'", editable = "packages/openstef-models" },
{ name = "openstef-models", extras = ["xgb-cpu"], marker = "extra == 'models'", editable = "packages/openstef-models" },
+ { name = "optuna", specifier = ">=4.7.0" },
]
provides-extras = ["all", "beam", "meta", "models"]
@@ -3010,6 +3089,24 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/24/7d/c88d7b15ba8fe5c6b8f93be50fc11795e9fc05386c44afaf6b76fe191f9b/opentelemetry_semantic_conventions-0.59b0-py3-none-any.whl", hash = "sha256:35d3b8833ef97d614136e253c1da9342b4c3c083bbaf29ce31d572a1c3825eed", size = 207954, upload-time = "2025-10-16T08:35:48.054Z" },
]
+[[package]]
+name = "optuna"
+version = "4.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "alembic" },
+ { name = "colorlog" },
+ { name = "numpy" },
+ { name = "packaging" },
+ { name = "pyyaml" },
+ { name = "sqlalchemy" },
+ { name = "tqdm" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/b2/b5e12de7b4486556fe2257611b55dbabf30d0300bdb031831aa943ad20e4/optuna-4.7.0.tar.gz", hash = "sha256:d91817e2079825557bd2e97de2e8c9ae260bfc99b32712502aef8a5095b2d2c0", size = 479740, upload-time = "2026-01-19T05:45:52.604Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/75/d1/6c8a4fbb38a9e3565f5c36b871262a85ecab3da48120af036b1e4937a15c/optuna-4.7.0-py3-none-any.whl", hash = "sha256:e41ec84018cecc10eabf28143573b1f0bde0ba56dba8151631a590ecbebc1186", size = 413894, upload-time = "2026-01-19T05:45:50.815Z" },
+]
+
[[package]]
name = "optype"
version = "0.14.0"
@@ -4774,6 +4871,48 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" },
]
+[[package]]
+name = "sqlalchemy"
+version = "2.0.46"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/aa/9ce0f3e7a9829ead5c8ce549392f33a12c4555a6c0609bb27d882e9c7ddf/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7", size = 9865393, upload-time = "2026-01-21T18:03:45.119Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b6/35/d16bfa235c8b7caba3730bba43e20b1e376d2224f407c178fbf59559f23e/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c", size = 2153405, upload-time = "2026-01-21T19:05:54.143Z" },
+ { url = "https://files.pythonhosted.org/packages/06/6c/3192e24486749862f495ddc6584ed730c0c994a67550ec395d872a2ad650/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9", size = 3334702, upload-time = "2026-01-21T18:46:45.384Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/a2/b9f33c8d68a3747d972a0bb758c6b63691f8fb8a49014bc3379ba15d4274/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b", size = 3347664, upload-time = "2026-01-21T18:40:09.979Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/d2/3e59e2a91eaec9db7e8dc6b37b91489b5caeb054f670f32c95bcba98940f/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53", size = 3277372, upload-time = "2026-01-21T18:46:47.168Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/dd/67bc2e368b524e2192c3927b423798deda72c003e73a1e94c21e74b20a85/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e", size = 3312425, upload-time = "2026-01-21T18:40:11.548Z" },
+ { url = "https://files.pythonhosted.org/packages/43/82/0ecd68e172bfe62247e96cb47867c2d68752566811a4e8c9d8f6e7c38a65/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb", size = 2113155, upload-time = "2026-01-21T18:42:49.748Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/2a/2821a45742073fc0331dc132552b30de68ba9563230853437cac54b2b53e/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff", size = 2140078, upload-time = "2026-01-21T18:42:51.197Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/4b/fa7838fe20bb752810feed60e45625a9a8b0102c0c09971e2d1d95362992/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00", size = 2150268, upload-time = "2026-01-21T19:05:56.621Z" },
+ { url = "https://files.pythonhosted.org/packages/46/c1/b34dccd712e8ea846edf396e00973dda82d598cb93762e55e43e6835eba9/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2", size = 3276511, upload-time = "2026-01-21T18:46:49.022Z" },
+ { url = "https://files.pythonhosted.org/packages/96/48/a04d9c94753e5d5d096c628c82a98c4793b9c08ca0e7155c3eb7d7db9f24/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee", size = 3292881, upload-time = "2026-01-21T18:40:13.089Z" },
+ { url = "https://files.pythonhosted.org/packages/be/f4/06eda6e91476f90a7d8058f74311cb65a2fb68d988171aced81707189131/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad", size = 3224559, upload-time = "2026-01-21T18:46:50.974Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/a2/d2af04095412ca6345ac22b33b89fe8d6f32a481e613ffcb2377d931d8d0/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e", size = 3262728, upload-time = "2026-01-21T18:40:14.883Z" },
+ { url = "https://files.pythonhosted.org/packages/31/48/1980c7caa5978a3b8225b4d230e69a2a6538a3562b8b31cea679b6933c83/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f", size = 2111295, upload-time = "2026-01-21T18:42:52.366Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/54/f8d65bbde3d877617c4720f3c9f60e99bb7266df0d5d78b6e25e7c149f35/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef", size = 2137076, upload-time = "2026-01-21T18:42:53.924Z" },
+ { url = "https://files.pythonhosted.org/packages/56/ba/9be4f97c7eb2b9d5544f2624adfc2853e796ed51d2bb8aec90bc94b7137e/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10", size = 3556533, upload-time = "2026-01-21T18:33:06.636Z" },
+ { url = "https://files.pythonhosted.org/packages/20/a6/b1fc6634564dbb4415b7ed6419cdfeaadefd2c39cdab1e3aa07a5f2474c2/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764", size = 3523208, upload-time = "2026-01-21T18:45:08.436Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/d8/41e0bdfc0f930ff236f86fccd12962d8fa03713f17ed57332d38af6a3782/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b", size = 3464292, upload-time = "2026-01-21T18:33:08.208Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/8b/9dcbec62d95bea85f5ecad9b8d65b78cc30fb0ffceeb3597961f3712549b/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447", size = 3473497, upload-time = "2026-01-21T18:45:10.552Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/f8/5ecdfc73383ec496de038ed1614de9e740a82db9ad67e6e4514ebc0708a3/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada", size = 2152079, upload-time = "2026-01-21T19:05:58.477Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/bf/eba3036be7663ce4d9c050bc3d63794dc29fbe01691f2bf5ccb64e048d20/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366", size = 3272216, upload-time = "2026-01-21T18:46:52.634Z" },
+ { url = "https://files.pythonhosted.org/packages/05/45/1256fb597bb83b58a01ddb600c59fe6fdf0e5afe333f0456ed75c0f8d7bd/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d", size = 3277208, upload-time = "2026-01-21T18:40:16.38Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/a0/2053b39e4e63b5d7ceb3372cface0859a067c1ddbd575ea7e9985716f771/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e", size = 3221994, upload-time = "2026-01-21T18:46:54.622Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/87/97713497d9502553c68f105a1cb62786ba1ee91dea3852ae4067ed956a50/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf", size = 3243990, upload-time = "2026-01-21T18:40:18.253Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/87/5d1b23548f420ff823c236f8bea36b1a997250fd2f892e44a3838ca424f4/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908", size = 2114215, upload-time = "2026-01-21T18:42:55.232Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/20/555f39cbcf0c10cf452988b6a93c2a12495035f68b3dbd1a408531049d31/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b", size = 2139867, upload-time = "2026-01-21T18:42:56.474Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/f0/f96c8057c982d9d8a7a68f45d69c674bc6f78cad401099692fe16521640a/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa", size = 3561202, upload-time = "2026-01-21T18:33:10.337Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/53/3b37dda0a5b137f21ef608d8dfc77b08477bab0fe2ac9d3e0a66eaeab6fc/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863", size = 3526296, upload-time = "2026-01-21T18:45:12.657Z" },
+ { url = "https://files.pythonhosted.org/packages/33/75/f28622ba6dde79cd545055ea7bd4062dc934e0621f7b3be2891f8563f8de/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede", size = 3470008, upload-time = "2026-01-21T18:33:11.725Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/42/4afecbbc38d5e99b18acef446453c76eec6fbd03db0a457a12a056836e22/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330", size = 3476137, upload-time = "2026-01-21T18:45:15.001Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/a1/9c4efa03300926601c19c18582531b45aededfb961ab3c3585f1e24f120b/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e", size = 1937882, upload-time = "2026-01-21T18:22:10.456Z" },
+]
+
[[package]]
name = "sqlparse"
version = "0.5.3"