testmodel, trainmodel. cvmodel, loadmodel

Author: bartzbeielstein

notebooks/00_spotPython_tests.ipynb

@@ -686,12 +686,12 @@
       "metadata": {},
       "outputs": [],
       "source": [
-        "from spotPython.light.netlightbase import NetLightBase\n",
+        "from spotPython.light.netlightregressione import NetLightRegression\n",
         "from spotPython.utils.init import fun_control_init\n",
         "from spotPython.hyperdict.light_hyper_dict import LightHyperDict\n",
         "from spotPython.hyperparameters.values import add_core_model_to_fun_control\n",
         "fun_control = fun_control_init()\n",
-        "add_core_model_to_fun_control(core_model=NetLightBase,\n",
+        "add_core_model_to_fun_control(core_model=NetLightRegression,\n",
         "                              fun_control=fun_control,\n",
         "                              hyper_dict=LightHyperDict)\n",
         "fun_control[\"core_model\"].__name__"

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotPython"
-version = "0.6.58"
+version = "0.6.60"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

src/spotPython/data/csvdataset.py

@@ -3,7 +3,6 @@
 from torch.utils.data import Dataset
 from sklearn.preprocessing import LabelEncoder
 import pathlib
-from typing import Any
 
 
 class CSVDataset(Dataset):

src/spotPython/fun/hyperlight.py

@@ -1,7 +1,7 @@
 import logging
 import numpy as np
 from numpy.random import default_rng
-from spotPython.light.traintest import train_model
+from spotPython.light.trainmodel import train_model
 from spotPython.hyperparameters.values import assign_values, generate_one_config_from_var_dict, get_var_name
 
 logger = logging.getLogger(__name__)

src/spotPython/fun/hyperlightning.py

@@ -677,16 +677,16 @@ def add_core_model_to_fun_control(core_model, fun_control, hyper_dict=None, file
             The updated fun_control dictionary.
 
     Examples:
-        >>> from spotPython.light.netlightbase import NetLightBase
+        >>> from spotPython.light.netlightregressione import NetLightRegression
             from spotPython.hyperdict.light_hyper_dict import LightHyperDict
             from spotPython.hyperparameters.values import add_core_model_to_fun_control
-            add_core_model_to_fun_control(core_model=NetLightBase,
+            add_core_model_to_fun_control(core_model=NetLightRegression,
                               fun_control=fun_control,
                               hyper_dict=LightHyperDict)
         # or, if a user wants to use a custom hyper_dict:
-        >>> from spotPython.light.netlightbase import NetLightBase
+        >>> from spotPython.light.netlightregression import NetLightRegression
             from spotPython.hyperparameters.values import add_core_model_to_fun_control
-            add_core_model_to_fun_control(core_model=NetLightBase,
+            add_core_model_to_fun_control(core_model=NetLightRegression,
                                         fun_control=fun_control,
                                         filename="./hyperdict/user_hyper_dict.json")
 

src/spotPython/hyperparameters/values.py

@@ -1,7 +1,6 @@
 from types import SimpleNamespace
 import torch.nn as nn
 from spotPython.light.cnn.inceptionblock import InceptionBlock
-from typing import Any
 
 
 class GoogleNet(nn.Module):

src/spotPython/light/cnn/googlenet.py

@@ -27,7 +27,7 @@ class InceptionBlock(nn.Module):
             Dictionary with keys "1x1", "3x3", "5x5", and "max"
         act_fn (nn.Module):
             Activation class constructor (e.g. nn.ReLU)
-            
+
 
     Examples:
         >>> from spotPython.light.cnn.googlenet import InceptionBlock
@@ -43,6 +43,7 @@ class InceptionBlock(nn.Module):
             torch.Size([1, 64, 32, 32])
 
     """
+
     def __init__(self, c_in, c_red: dict, c_out: dict, act_fn):
         super().__init__()
 
@@ -79,7 +80,7 @@ def __init__(self, c_in, c_red: dict, c_out: dict, act_fn):
             act_fn(),
         )
 
-    def forward(self, x)->torch.Tensor:
+    def forward(self, x) -> torch.Tensor:
         x_1x1 = self.conv_1x1(x)
         x_3x3 = self.conv_3x3(x)
         x_5x5 = self.conv_5x5(x)

src/spotPython/light/cnn/inceptionblock.py

@@ -0,0 +1,105 @@
+import lightning as L
+from spotPython.data.lightcrossvalidationdatamodule import LightCrossValidationDataModule
+from spotPython.utils.eda import generate_config_id
+from pytorch_lightning.loggers import TensorBoardLogger
+from lightning.pytorch.callbacks.early_stopping import EarlyStopping
+from spotPython.torch.initialization import kaiming_init, xavier_init
+import os
+
+
+def cv_model(config: dict, fun_control: dict) -> float:
+    """
+    Performs k-fold cross-validation on a model using the given configuration and function control parameters.
+
+    Args:
+        config (dict): A dictionary containing the configuration parameters for the model.
+        fun_control (dict): A dictionary containing the function control parameters.
+
+    Returns:
+        (float): The mean average precision at k (MAP@k) score of the model.
+
+    Examples:
+        >>> config = {
+        ...     "initialization": "Xavier",
+        ...     "batch_size": 32,
+        ...     "patience": 10,
+        ... }
+        >>> fun_control = {
+        ...     "_L_in": 10,
+        ...     "_L_out": 1,
+        ...     "enable_progress_bar": True,
+        ...     "core_model": MyModel,
+        ...     "num_workers": 4,
+        ...     "DATASET_PATH": "./data",
+        ...     "CHECKPOINT_PATH": "./checkpoints",
+        ...     "TENSORBOARD_PATH": "./tensorboard",
+        ...     "k_folds": 5,
+        ... }
+        >>> mapk_score = cv_model(config, fun_control)
+    """
+    _L_in = fun_control["_L_in"]
+    _L_out = fun_control["_L_out"]
+    if fun_control["enable_progress_bar"] is None:
+        enable_progress_bar = False
+    else:
+        enable_progress_bar = fun_control["enable_progress_bar"]
+    # Add "CV" postfix to config_id
+    config_id = generate_config_id(config) + "_CV"
+    results = []
+    num_folds = fun_control["k_folds"]
+    split_seed = 12345
+
+    for k in range(num_folds):
+        print("k:", k)
+
+        model = fun_control["core_model"](**config, _L_in=_L_in, _L_out=_L_out)
+        initialization = config["initialization"]
+        if initialization == "Xavier":
+            xavier_init(model)
+        elif initialization == "Kaiming":
+            kaiming_init(model)
+        else:
+            pass
+        # print(f"model: {model}")
+
+        dm = LightCrossValidationDataModule(
+            k=k,
+            num_splits=num_folds,
+            split_seed=split_seed,
+            dataset=fun_control["data_set"],
+            num_workers=fun_control["num_workers"],
+            batch_size=config["batch_size"],
+            data_dir=fun_control["DATASET_PATH"],
+        )
+        dm.prepare_data()
+        dm.setup()
+
+        # Init trainer
+        trainer = L.Trainer(
+            # Where to save models
+            default_root_dir=os.path.join(fun_control["CHECKPOINT_PATH"], config_id),
+            max_epochs=model.hparams.epochs,
+            accelerator="auto",
+            devices=1,
+            logger=TensorBoardLogger(
+                save_dir=fun_control["TENSORBOARD_PATH"], version=config_id, default_hp_metric=True, log_graph=True
+            ),
+            callbacks=[
+                EarlyStopping(monitor="val_loss", patience=config["patience"], mode="min", strict=False, verbose=False)
+            ],
+            enable_progress_bar=enable_progress_bar,
+        )
+        # Pass the datamodule as arg to trainer.fit to override model hooks :)
+        trainer.fit(model=model, datamodule=dm)
+        # Test best model on validation and test set
+        # result = trainer.validate(model=model, datamodule=dm, ckpt_path="last")
+        score = trainer.validate(model=model, datamodule=dm)
+        # unlist the result (from a list of one dict)
+        score = score[0]
+        print(f"train_model result: {score}")
+
+        results.append(score["val_loss"])
+
+    score = sum(results) / num_folds
+    # print(f"cv_model mapk result: {mapk_score}")
+    return score