0.10.27

Documentation

Author: bartzbeielstein

gui/spotGUI.py

@@ -0,0 +1,55 @@
+import tkinter as tk
+from spotPython.hyperparameters.values import get_default_values
+
+def create_gui(elements):
+    # Create a tkinter window
+    root = tk.Tk()
+
+    # Loop over the dictionary and create labels and entries for each key-value pair
+    for i, (key, value) in enumerate(elements.items()):
+        # Create a label with the key as text
+        label = tk.Label(root, text=key)
+        label.grid(row=i, column=0, sticky="W")
+
+        # Create an entry with the value as the default text
+        entry = tk.Entry(root)
+        entry.insert(0, value)
+        entry.grid(row=i, column=1, sticky="W")
+
+    # Run the tkinter main loop
+    root.mainloop()
+
+# Create a dictionary with keys and default values
+# elements = {"A": "1", "B": "2", "C": "3"}
+d = {"core_model_hyper_dict":{
+    "leaf_prediction": {
+        "levels": ["mean", "model", "adaptive"],
+        "type": "factor",
+        "default": "mean",
+        "core_model_parameter_type": "str"},
+    "leaf_model": {
+        "levels": ["linear_model.LinearRegression", "linear_model.PARegressor", "linear_model.Perceptron"],
+        "type": "factor",
+        "default": "LinearRegression",
+        "core_model_parameter_type": "instance"},
+    "splitter": {
+        "levels": ["EBSTSplitter", "TEBSTSplitter", "QOSplitter"],
+        "type": "factor",
+        "default": "EBSTSplitter",
+        "core_model_parameter_type": "instance()"},
+    "binary_split": {
+        "levels": [0, 1],
+        "type": "factor",
+        "default": 0,
+        "core_model_parameter_type": "bool"},
+    "stop_mem_management": {
+        "levels": [0, 1],
+        "type": "factor",
+        "default": 0,
+        "core_model_parameter_type": "bool"}}}
+elements = get_default_values(d)
+
+
+
+# Call the function to create the GUI
+create_gui(elements)

gui/spotGUI_0.py

@@ -0,0 +1,43 @@
+import tkinter as tk
+import json
+
+def get_default_values(elements):
+    pass
+
+def get_bound_values(elements):
+    pass
+
+def create_gui(dict_file):
+    # Load the dictionary from the file
+    with open(dict_file, 'r') as f:
+        elements = json.load(f)
+
+    # Apply the functions to the dictionary
+    default_values = get_default_values(elements)
+    bound_values = get_bound_values(elements)
+
+    # Create a tkinter window
+    root = tk.Tk()
+
+    # Loop over the dictionary and create labels and entries for each key-value pair
+    for i, (key, value) in enumerate(default_values.items()):
+        # Create a label with the key as text
+        label = tk.Label(root, text=key)
+        label.grid(row=i, column=0, sticky="W")
+
+        # Create an entry with the default value as the default text
+        default_entry = tk.Entry(root)
+        default_entry.insert(0, value)
+        default_entry.grid(row=i, column=1, sticky="W")
+
+        # Create an entry with the bound value as the default text
+        bound_entry = tk.Entry(root)
+        bound_entry.insert(0, bound_values[key])
+        bound_entry.grid(row=i, column=2, sticky="W")
+
+    # Run the tkinter main loop
+    root.mainloop()
+
+# Call the function to create the GUI
+create_gui("elements.json")
+

gui/spotGUI_1.py

@@ -0,0 +1,44 @@
+import tkinter as tk
+import json
+from spotPython.hyperparameters.values import get_default_values, get_bound_values
+
+def get_default_values(elements):
+    pass
+
+def get_bound_values(elements):
+    pass
+
+def create_gui(dict_file):
+    # Load the dictionary from the file
+    with open(dict_file, 'r') as f:
+        elements = json.load(f)
+
+    # Apply the functions to the dictionary
+    default_values = get_default_values(elements)
+    bound_values = get_bound_values(elements)
+
+    # Create a tkinter window
+    root = tk.Tk()
+
+    # Loop over the dictionary and create labels and entries for each key-value pair
+    for i, (key, value) in enumerate(default_values.items()):
+        # Create a label with the key as text
+        label = tk.Label(root, text=key)
+        label.grid(row=i, column=0, sticky="W")
+
+        # Create an entry with the default value as the default text
+        default_entry = tk.Entry(root)
+        default_entry.insert(0, value)
+        default_entry.grid(row=i, column=1, sticky="W")
+
+        # Create an entry with the bound value as the default text
+        bound_entry = tk.Entry(root)
+        bound_entry.insert(0, bound_values[key])
+        bound_entry.grid(row=i, column=2, sticky="W")
+
+    # Run the tkinter main loop
+    root.mainloop()
+
+# Call the function to create the GUI
+create_gui("elements.json")
+

notebooks/00_spotPython_tests.ipynb

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

pyproject.toml

@@ -16,7 +16,11 @@ class LightDataModule(L.LightningDataModule):
             It  must implement three functions: __init__, __len__, and __getitem__.
             Required.
         test_size (float):
-            The test size. Required.
+            The test size. if test_size is float, then train_size is 1 - test_size.
+            If test_size is int, then train_size is len(data_full) - test_size.
+            Train size will be split into train and validation sets.
+            So if test size is 0.7, the 0.7 train size will be split into 0.7 * 0.7 = 0.49 train set
+            amd 0.7 * 0.3 = 0.21 validation set.
         test_seed (int):
             The test seed. Defaults to 42.
         num_workers (int):
@@ -47,13 +51,21 @@ class LightDataModule(L.LightningDataModule):
     Examples:
         >>> from spotPython.data.lightdatamodule import LightDataModule
             from spotPython.data.csvdataset import CSVDataset
-            from spotPython.data.pkldataset import PKLDataset
             import torch
+            # data.csv is simple csv file with 11 samples
             dataset = CSVDataset(csv_file='data.csv', target_column='prognosis', feature_type=torch.long)
             data_module = LightDataModule(dataset=dataset, batch_size=5, test_size=0.5)
             data_module.setup()
             print(f"Training set size: {len(data_module.data_train)}")
+            print(f"Validation set size: {len(data_module.data_val)}")
+            print(f"Test set size: {len(data_module.data_test)}")
+            full_train_size: 0.5
+            val_size: 0.25
+            train_size: 0.25
+            test_size: 0.5
             Training set size: 3
+            Validation set size: 3
+            Test set size: 6
 
     References:
         See https://lightning.ai/docs/pytorch/stable/data/datamodule.html
@@ -109,17 +121,20 @@ def setup(self, stage: Optional[str] = None) -> None:
             val_size = int(full_train_size * test_size / len(self.data_full))
             train_size = full_train_size - val_size
 
-        print(f"full_train_size: {full_train_size}")
-        print(f"val_size: {val_size}")
-        print(f"train_size: {train_size}")
-        print(f"test_size: {test_size}")
+        print(f"LightDataModule: setup(). stage: {stage}")
+        print(f"LightDataModule setup(): full_train_size: {full_train_size}")
+        print(f"LightDataModule setup(): val_size: {val_size}")
+        print(f"LightDataModule setup(): train_size: {train_size}")
+        print(f"LightDataModule setup(): test_size: {test_size}")
 
         # Assign train/val datasets for use in dataloaders
         if stage == "fit" or stage is None:
+            print("LightDataModule: setup(). stage: fit")
             self.data_train, self.data_val, _ = random_split(self.data_full, [train_size, val_size, test_size])
 
         # Assign test dataset for use in dataloader(s)
         if stage == "test" or stage is None:
+            print("LightDataModule: setup(). stage: test")
             # get test data aset as test_abs percent of the full dataset
             generator_test = torch.Generator().manual_seed(self.test_seed)
             self.data_test, _ = random_split(self.data_full, [test_size, full_train_size], generator=generator_test)
@@ -135,6 +150,7 @@ def setup(self, stage: Optional[str] = None) -> None:
 
         # Assign pred dataset for use in dataloader(s)
         if stage == "predict" or stage is None:
+            print("LightDataModule: setup(). stage: predict")
             # get test data aset as test_abs percent of the full dataset
             generator_predict = torch.Generator().manual_seed(self.test_seed)
             self.data_predict, _ = random_split(
@@ -152,7 +168,6 @@ def train_dataloader(self) -> DataLoader:
         Examples:
             >>> from spotPython.data.lightdatamodule import LightDataModule
                 from spotPython.data.csvdataset import CSVDataset
-                from spotPython.data.pkldataset import PKLDataset
                 import torch
                 dataset = CSVDataset(csv_file='data.csv', target_column='prognosis', feature_type=torch.long)
                 data_module = LightDataModule(dataset=dataset, batch_size=5, test_size=0.5)
@@ -177,15 +192,16 @@ def val_dataloader(self) -> DataLoader:
         Examples:
             >>> from spotPython.data.lightdatamodule import LightDataModule
                 from spotPython.data.csvdataset import CSVDataset
-                from spotPython.data.pkldataset import PKLDataset
                 import torch
                 dataset = CSVDataset(csv_file='data.csv', target_column='prognosis', feature_type=torch.long)
                 data_module = LightDataModule(dataset=dataset, batch_size=5, test_size=0.5)
                 data_module.setup()
                 print(f"Training set size: {len(data_module.data_val)}")
                 Training set size: 3
-
         """
+        print(f"LightDataModule: val_dataloader(). Training set size: {len(self.data_val)}")
+        print(f"LightDataModule: val_dataloader(). batch_size: {self.batch_size}")
+        print(f"LightDataModule: val_dataloader(). num_workers: {self.num_workers}")
         return DataLoader(self.data_val, batch_size=self.batch_size, num_workers=self.num_workers)
 
     def test_dataloader(self) -> DataLoader:
@@ -199,7 +215,6 @@ def test_dataloader(self) -> DataLoader:
         Examples:
             >>> from spotPython.data.lightdatamodule import LightDataModule
                 from spotPython.data.csvdataset import CSVDataset
-                from spotPython.data.pkldataset import PKLDataset
                 import torch
                 dataset = CSVDataset(csv_file='data.csv', target_column='prognosis', feature_type=torch.long)
                 data_module = LightDataModule(dataset=dataset, batch_size=5, test_size=0.5)
@@ -214,6 +229,24 @@ def test_dataloader(self) -> DataLoader:
         return DataLoader(self.data_test, batch_size=self.batch_size, num_workers=self.num_workers)
 
     def predict_dataloader(self) -> DataLoader:
+        """
+        Returns the predict dataloader, i.e., a pytorch DataLoader instance
+        using the predict dataset.
+
+        Returns:
+            DataLoader: The predict dataloader.
+
+        Examples:
+            >>> from spotPython.data.lightdatamodule import LightDataModule
+                from spotPython.data.csvdataset import CSVDataset
+                import torch
+                dataset = CSVDataset(csv_file='data.csv', target_column='prognosis', feature_type=torch.long)
+                data_module = LightDataModule(dataset=dataset, batch_size=5, test_size=0.5)
+                data_module.setup()
+                print(f"Predict set size: {len(data_module.data_predict)}")
+                Predict set size: 6
+
+        """
         print(f"LightDataModule: predict_dataloader(). Predict set size: {len(self.data_predict)}")
         print(f"LightDataModule: predict_dataloader(). batch_size: {self.batch_size}")
         print(f"LightDataModule: predict_dataloader(). num_workers: {self.num_workers}")

src/spotPython/data/lightdatamodule.py

@@ -31,5 +31,17 @@ def test_light_data_module_test_size():
     # Test the length of val and train: should be equal, because test_size=0.5
     assert len(data_module.data_test) ==  7
 
+def test_light_data_module_sizes():
+    # data.csv is simple csv file with 11 samples
+    dataset = CSVDataset(csv_file='data.csv', target_column='prognosis', feature_type=torch.long)
+    data_module = LightDataModule(dataset=dataset, batch_size=5, test_size=0.5)
+    data_module.setup()
+    print(f"Training set size: {len(data_module.data_train)}")
+    print(f"Validation set size: {len(data_module.data_val)}")
+    print(f"Test set size: {len(data_module.data_test)}")
+    assert len(data_module.data_train) == 3
+    assert len(data_module.data_val) == 3
+    assert len(data_module.data_test) == 6
+
 if __name__ == "__main__":
     pytest.main(["-v", __file__])