Skip to content

Commit 98b114e

Browse files
bartzbeielsteinbartzbeielstein
committed
0.11.1
new function: get_tuned_hyperparameters
1 parent f232c94 commit 98b114e

6 files changed

Lines changed: 1224 additions & 93 deletions

File tree

‎notebooks/00_spotPython_tests.ipynb‎

Lines changed: 997 additions & 69 deletions
Large diffs are not rendered by default.

‎pyproject.toml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
77

88
[project]
99
name = "spotPython"
10-
version = "0.11.0"
10+
version = "0.11.1"
1111
authors = [
1212
{ name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
1313
]

‎src/spotPython/data/lightdatamodule.py‎

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -121,23 +121,23 @@ def setup(self, stage: Optional[str] = None) -> None:
121121
val_size = int(full_train_size * test_size / len(self.data_full))
122122
train_size = full_train_size - val_size
123123

124-
print(f"LightDataModule: setup(). stage: {stage}")
125-
print(f"LightDataModule setup(): full_train_size: {full_train_size}")
126-
print(f"LightDataModule setup(): val_size: {val_size}")
127-
print(f"LightDataModule setup(): train_size: {train_size}")
128-
print(f"LightDataModule setup(): test_size: {test_size}")
124+
print(f"LightDataModule.setup(): stage: {stage}")
125+
# print(f"LightDataModule setup(): full_train_size: {full_train_size}")
126+
# print(f"LightDataModule setup(): val_size: {val_size}")
127+
# print(f"LightDataModule setup(): train_size: {train_size}")
128+
# print(f"LightDataModule setup(): test_size: {test_size}")
129129

130130
# Assign train/val datasets for use in dataloaders
131131
if stage == "fit" or stage is None:
132-
print("LightDataModule: setup(). stage: fit")
132+
print(f"train_size: {train_size}, val_size: {val_size} used for train & val data.")
133133
generator_fit = torch.Generator().manual_seed(self.test_seed)
134134
self.data_train, self.data_val, _ = random_split(
135135
self.data_full, [train_size, val_size, test_size], generator=generator_fit
136136
)
137137

138138
# Assign test dataset for use in dataloader(s)
139139
if stage == "test" or stage is None:
140-
print("LightDataModule: setup(). stage: test")
140+
print(f"test_size: {test_size} used for test dataset.")
141141
# get test data set as test_abs percent of the full dataset
142142
generator_test = torch.Generator().manual_seed(self.test_seed)
143143
self.data_test, _ = random_split(self.data_full, [test_size, full_train_size], generator=generator_test)
@@ -153,7 +153,7 @@ def setup(self, stage: Optional[str] = None) -> None:
153153

154154
# Assign pred dataset for use in dataloader(s)
155155
if stage == "predict" or stage is None:
156-
print("LightDataModule: setup(). stage: predict")
156+
print(f"test_size: {test_size} used for predict dataset.")
157157
# get test data set as test_abs percent of the full dataset
158158
generator_predict = torch.Generator().manual_seed(self.test_seed)
159159
self.data_predict, _ = random_split(
@@ -179,9 +179,9 @@ def train_dataloader(self) -> DataLoader:
179179
Training set size: 3
180180
181181
"""
182-
print(f"LightDataModule: train_dataloader(). Training set size: {len(self.data_train)}")
183-
print(f"LightDataModule: train_dataloader(). batch_size: {self.batch_size}")
184-
print(f"LightDataModule: train_dataloader(). num_workers: {self.num_workers}")
182+
print(f"LightDataModule.train_dataloader(). data_train size: {len(self.data_train)}")
183+
# print(f"LightDataModule: train_dataloader(). batch_size: {self.batch_size}")
184+
# print(f"LightDataModule: train_dataloader(). num_workers: {self.num_workers}")
185185
return DataLoader(self.data_train, batch_size=self.batch_size, num_workers=self.num_workers)
186186

187187
def val_dataloader(self) -> DataLoader:
@@ -202,9 +202,9 @@ def val_dataloader(self) -> DataLoader:
202202
print(f"Training set size: {len(data_module.data_val)}")
203203
Training set size: 3
204204
"""
205-
print(f"LightDataModule: val_dataloader(). Validation set size: {len(self.data_val)}")
206-
print(f"LightDataModule: val_dataloader(). batch_size: {self.batch_size}")
207-
print(f"LightDataModule: val_dataloader(). num_workers: {self.num_workers}")
205+
print(f"LightDataModule.val_dataloader(). Val. set size: {len(self.data_val)}")
206+
# print(f"LightDataModule: val_dataloader(). batch_size: {self.batch_size}")
207+
# print(f"LightDataModule: val_dataloader(). num_workers: {self.num_workers}")
208208
return DataLoader(self.data_val, batch_size=self.batch_size, num_workers=self.num_workers)
209209

210210
def test_dataloader(self) -> DataLoader:
@@ -226,9 +226,9 @@ def test_dataloader(self) -> DataLoader:
226226
Test set size: 6
227227
228228
"""
229-
print(f"LightDataModule: test_dataloader(). Test set size: {len(self.data_test)}")
230-
print(f"LightDataModule: test_dataloader(). batch_size: {self.batch_size}")
231-
print(f"LightDataModule: test_dataloader(). num_workers: {self.num_workers}")
229+
print(f"LightDataModule.test_dataloader(). Test set size: {len(self.data_test)}")
230+
# print(f"LightDataModule: test_dataloader(). batch_size: {self.batch_size}")
231+
# print(f"LightDataModule: test_dataloader(). num_workers: {self.num_workers}")
232232
return DataLoader(self.data_test, batch_size=self.batch_size, num_workers=self.num_workers)
233233

234234
def predict_dataloader(self) -> DataLoader:
@@ -250,7 +250,7 @@ def predict_dataloader(self) -> DataLoader:
250250
Predict set size: 6
251251
252252
"""
253-
print(f"LightDataModule: predict_dataloader(). Predict set size: {len(self.data_predict)}")
254-
print(f"LightDataModule: predict_dataloader(). batch_size: {self.batch_size}")
255-
print(f"LightDataModule: predict_dataloader(). num_workers: {self.num_workers}")
253+
print(f"LightDataModule.predict_dataloader(). Predict set size: {len(self.data_predict)}")
254+
# print(f"LightDataModule: predict_dataloader(). batch_size: {self.batch_size}")
255+
# print(f"LightDataModule: predict_dataloader(). num_workers: {self.num_workers}")
256256
return DataLoader(self.data_predict, batch_size=len(self.data_predict), num_workers=self.num_workers)

‎src/spotPython/hyperparameters/values.py‎

Lines changed: 95 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1178,3 +1178,98 @@ def get_ith_hyperparameter_name_from_fun_control(fun_control, key, i):
11781178
if i < len(fun_control["core_model_hyper_dict"][key]["levels"]):
11791179
return fun_control["core_model_hyper_dict"][key]["levels"][i]
11801180
return None
1181+
1182+
1183+
def get_tuned_hyperparameters(spot_tuner):
1184+
"""
1185+
Get the tuned hyperparameters from the spot tuner.
1186+
This is just a wrapper function for the spot `get_tuned_hyperparameters` method.
1187+
1188+
Args:
1189+
spot_tuner (object):
1190+
spot tuner object.
1191+
1192+
Returns:
1193+
(dict):
1194+
dictionary containing the tuned hyperparameters.
1195+
1196+
Examples:
1197+
>>> from spotPython.utils.device import getDevice
1198+
from math import inf
1199+
from spotPython.utils.init import fun_control_init
1200+
import numpy as np
1201+
from spotPython.hyperparameters.values import set_control_key_value
1202+
from spotPython.data.diabetes import Diabetes
1203+
from spotPython.hyperparameters.values import get_tuned_hyperparameters
1204+
MAX_TIME = 1
1205+
FUN_EVALS = 10
1206+
INIT_SIZE = 5
1207+
WORKERS = 0
1208+
PREFIX="037"
1209+
DEVICE = getDevice()
1210+
DEVICES = 1
1211+
TEST_SIZE = 0.4
1212+
TORCH_METRIC = "mean_squared_error"
1213+
dataset = Diabetes()
1214+
fun_control = fun_control_init(
1215+
_L_in=10,
1216+
_L_out=1,
1217+
_torchmetric=TORCH_METRIC,
1218+
PREFIX=PREFIX,
1219+
TENSORBOARD_CLEAN=True,
1220+
data_set=dataset,
1221+
device=DEVICE,
1222+
enable_progress_bar=False,
1223+
fun_evals=FUN_EVALS,
1224+
log_level=50,
1225+
max_time=MAX_TIME,
1226+
num_workers=WORKERS,
1227+
show_progress=True,
1228+
test_size=TEST_SIZE,
1229+
tolerance_x=np.sqrt(np.spacing(1)),
1230+
)
1231+
from spotPython.light.regression.netlightregression import NetLightRegression
1232+
from spotPython.hyperdict.light_hyper_dict import LightHyperDict
1233+
from spotPython.hyperparameters.values import add_core_model_to_fun_control
1234+
add_core_model_to_fun_control(fun_control=fun_control,
1235+
core_model=NetLightRegression,
1236+
hyper_dict=LightHyperDict)
1237+
from spotPython.hyperparameters.values import set_control_hyperparameter_value
1238+
set_control_hyperparameter_value(fun_control, "l1", [7, 8])
1239+
set_control_hyperparameter_value(fun_control, "epochs", [3, 5])
1240+
set_control_hyperparameter_value(fun_control, "batch_size", [4, 5])
1241+
set_control_hyperparameter_value(fun_control, "optimizer", [
1242+
"Adam",
1243+
"RAdam",
1244+
])
1245+
set_control_hyperparameter_value(fun_control, "dropout_prob", [0.01, 0.1])
1246+
set_control_hyperparameter_value(fun_control, "lr_mult", [0.5, 5.0])
1247+
set_control_hyperparameter_value(fun_control, "patience", [2, 3])
1248+
set_control_hyperparameter_value(fun_control, "act_fn",[
1249+
"ReLU",
1250+
"LeakyReLU"
1251+
] )
1252+
from spotPython.utils.init import design_control_init, surrogate_control_init
1253+
design_control = design_control_init(init_size=INIT_SIZE)
1254+
surrogate_control = surrogate_control_init(noise=True,
1255+
n_theta=2)
1256+
from spotPython.fun.hyperlight import HyperLight
1257+
fun = HyperLight(log_level=50).fun
1258+
from spotPython.spot import spot
1259+
spot_tuner = spot.Spot(fun=fun,
1260+
fun_control=fun_control,
1261+
design_control=design_control,
1262+
surrogate_control=surrogate_control)
1263+
spot_tuner.run()
1264+
get_tuned_hyperparameters(spot_tuner)
1265+
{'l1': 7.0,
1266+
'epochs': 5.0,
1267+
'batch_size': 4.0,
1268+
'act_fn': 0.0,
1269+
'optimizer': 0.0,
1270+
'dropout_prob': 0.01,
1271+
'lr_mult': 5.0,
1272+
'patience': 3.0,
1273+
'initialization': 1.0}
1274+
"""
1275+
return spot_tuner.get_tuned_hyperparameters()

‎src/spotPython/light/trainmodel.py‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -92,9 +92,9 @@ def train_model(config: dict, fun_control: dict) -> float:
9292
test_seed=fun_control["test_seed"],
9393
)
9494
dm.setup()
95-
print(f"train_model(): Test set size: {len(dm.data_test)}")
96-
print(f"train_model(): Train set size: {len(dm.data_train)}")
97-
print(f"train_model(): Batch size: {config['batch_size']}")
95+
# print(f"train_model(): Test set size: {len(dm.data_test)}")
96+
# print(f"train_model(): Train set size: {len(dm.data_train)}")
97+
# print(f"train_model(): Batch size: {config['batch_size']}")
9898

9999
# Init trainer
100100
trainer = L.Trainer(

‎src/spotPython/spot/spot.py‎

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1322,6 +1322,114 @@ def print_results(self, print_screen=True, dict=None) -> list[str]:
13221322
output.append([var_name, res[0][i]])
13231323
return output
13241324

1325+
def get_tuned_hyperparameters(self, fun_control=None) -> dict:
1326+
"""Return the tuned hyperparameter values from the run.
1327+
If `noise == True`, the mean values are returned.
1328+
1329+
Returns:
1330+
(dict): dictionary of tuned hyperparameters.
1331+
1332+
Examples:
1333+
>>> from spotPython.utils.device import getDevice
1334+
from math import inf
1335+
from spotPython.utils.init import fun_control_init
1336+
import numpy as np
1337+
from spotPython.hyperparameters.values import set_control_key_value
1338+
from spotPython.data.diabetes import Diabetes
1339+
MAX_TIME = 1
1340+
FUN_EVALS = 10
1341+
INIT_SIZE = 5
1342+
WORKERS = 0
1343+
PREFIX="037"
1344+
DEVICE = getDevice()
1345+
DEVICES = 1
1346+
TEST_SIZE = 0.4
1347+
TORCH_METRIC = "mean_squared_error"
1348+
dataset = Diabetes()
1349+
fun_control = fun_control_init(
1350+
_L_in=10,
1351+
_L_out=1,
1352+
_torchmetric=TORCH_METRIC,
1353+
PREFIX=PREFIX,
1354+
TENSORBOARD_CLEAN=True,
1355+
data_set=dataset,
1356+
device=DEVICE,
1357+
enable_progress_bar=False,
1358+
fun_evals=FUN_EVALS,
1359+
log_level=50,
1360+
max_time=MAX_TIME,
1361+
num_workers=WORKERS,
1362+
show_progress=True,
1363+
test_size=TEST_SIZE,
1364+
tolerance_x=np.sqrt(np.spacing(1)),
1365+
)
1366+
from spotPython.light.regression.netlightregression import NetLightRegression
1367+
from spotPython.hyperdict.light_hyper_dict import LightHyperDict
1368+
from spotPython.hyperparameters.values import add_core_model_to_fun_control
1369+
add_core_model_to_fun_control(fun_control=fun_control,
1370+
core_model=NetLightRegression,
1371+
hyper_dict=LightHyperDict)
1372+
from spotPython.hyperparameters.values import set_control_hyperparameter_value
1373+
set_control_hyperparameter_value(fun_control, "l1", [7, 8])
1374+
set_control_hyperparameter_value(fun_control, "epochs", [3, 5])
1375+
set_control_hyperparameter_value(fun_control, "batch_size", [4, 5])
1376+
set_control_hyperparameter_value(fun_control, "optimizer", [
1377+
"Adam",
1378+
"RAdam",
1379+
])
1380+
set_control_hyperparameter_value(fun_control, "dropout_prob", [0.01, 0.1])
1381+
set_control_hyperparameter_value(fun_control, "lr_mult", [0.5, 5.0])
1382+
set_control_hyperparameter_value(fun_control, "patience", [2, 3])
1383+
set_control_hyperparameter_value(fun_control, "act_fn",[
1384+
"ReLU",
1385+
"LeakyReLU"
1386+
] )
1387+
from spotPython.utils.init import design_control_init, surrogate_control_init
1388+
design_control = design_control_init(init_size=INIT_SIZE)
1389+
surrogate_control = surrogate_control_init(noise=True,
1390+
n_theta=2)
1391+
from spotPython.fun.hyperlight import HyperLight
1392+
fun = HyperLight(log_level=50).fun
1393+
from spotPython.spot import spot
1394+
spot_tuner = spot.Spot(fun=fun,
1395+
fun_control=fun_control,
1396+
design_control=design_control,
1397+
surrogate_control=surrogate_control)
1398+
spot_tuner.run()
1399+
spot_tuner.get_tuned_hyperparameters()
1400+
{'l1': 7.0,
1401+
'epochs': 5.0,
1402+
'batch_size': 4.0,
1403+
'act_fn': 0.0,
1404+
'optimizer': 0.0,
1405+
'dropout_prob': 0.01,
1406+
'lr_mult': 5.0,
1407+
'patience': 3.0,
1408+
'initialization': 1.0}
1409+
1410+
"""
1411+
output = []
1412+
if self.noise:
1413+
res = self.to_all_dim(self.min_mean_X.reshape(1, -1))
1414+
else:
1415+
res = self.to_all_dim(self.min_X.reshape(1, -1))
1416+
for i in range(res.shape[1]):
1417+
if self.all_var_name is None:
1418+
var_name = "x" + str(i)
1419+
else:
1420+
var_name = self.all_var_name[i]
1421+
var_type = self.all_var_type[i]
1422+
if var_type == "factor" and fun_control is not None:
1423+
val = get_ith_hyperparameter_name_from_fun_control(
1424+
fun_control=fun_control, key=var_name, i=int(res[0][i])
1425+
)
1426+
else:
1427+
val = res[0][i]
1428+
output.append([var_name, val])
1429+
# convert list to a dictionary
1430+
output = dict(output)
1431+
return output
1432+
13251433
def chg(self, x, y, z0, i, j) -> list:
13261434
"""
13271435
Change the values of elements at indices `i` and `j` in the array `z0` to `x` and `y`, respectively.

0 commit comments

Comments
 (0)