workbench 0.8.160__tar.gz → 0.8.162__tar.gz

{workbench-0.8.160 → workbench-0.8.162}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workbench
-Version: 0.8.160
+Version: 0.8.162
 Summary: Workbench: A Dashboard and Python API for creating and deploying AWS SageMaker Model Pipelines
 Author-email: SuperCowPowers LLC <support@supercowpowers.com>
 License-Expression: MIT

{workbench-0.8.160 → workbench-0.8.162}/aws_setup/workbench_core/workbench_core/workbench_core_stack.py

@@ -727,6 +727,7 @@ class WorkbenchCoreStack(Stack):
             self.glue_databases_read(),
             self.athena_read(),
             self.cloudwatch_logs(),
+            self.parameter_store_discover(),
             self.parameter_store_read(),
         ]
 
@@ -746,6 +747,7 @@ class WorkbenchCoreStack(Stack):
             self.glue_databases_full(),
             self.athena_read(),
             self.cloudwatch_logs(),
+            self.parameter_store_discover(),
             self.parameter_store_full(),
         ]
 
@@ -766,7 +768,8 @@ class WorkbenchCoreStack(Stack):
             self.featurestore_discovery(),
             self.featurestore_full(),
             self.cloudwatch_logs(),
-            self.parameter_store_full(),
+            self.parameter_store_discover(),
+            self.parameter_store_read(),
         ]
         return iam.ManagedPolicy(
             self,
@@ -785,6 +788,7 @@ class WorkbenchCoreStack(Stack):
             self.featurestore_discovery(),
             self.featurestore_full(),
             self.cloudwatch_logs(),
+            self.parameter_store_discover(),
             self.parameter_store_full(),
         ]
         return iam.ManagedPolicy(
@@ -823,6 +827,7 @@ class WorkbenchCoreStack(Stack):
             self.models_discovery(),
             self.models_read(),
             self.cloudwatch_logs(),
+            self.parameter_store_discover(),
             self.parameter_store_read(),
         ]
         return iam.ManagedPolicy(
@@ -843,6 +848,7 @@ class WorkbenchCoreStack(Stack):
             self.cloudwatch_metrics(),
             self.cloudwatch_logs(),
             self.sagemaker_pass_role_policy(),
+            self.parameter_store_discover(),
             self.parameter_store_full(),
         ]
         return iam.ManagedPolicy(
@@ -859,6 +865,7 @@ class WorkbenchCoreStack(Stack):
             self.endpoint_read(),
             self.endpoint_monitoring_discovery(),
             self.cloudwatch_logs(),
+            self.parameter_store_discover(),
             self.parameter_store_read(),
         ]
         return iam.ManagedPolicy(
@@ -878,6 +885,7 @@ class WorkbenchCoreStack(Stack):
             self.endpoint_monitoring_schedules(),
             self.cloudwatch_metrics(),
             self.cloudwatch_logs(),
+            self.parameter_store_discover(),
             self.parameter_store_full(),
         ]
         return iam.ManagedPolicy(

{workbench-0.8.160 → workbench-0.8.162}/examples/models/pytorch.py

@@ -7,7 +7,7 @@ feature_list = model.features()
 target = model.target()
 
 # Recreate Flag in case you want to recreate the artifacts
-recreate = False
+recreate = True
 
 # PyTorch Regression Model
 if recreate or not Model("aqsol-pytorch-reg").exists():
@@ -20,6 +20,7 @@ if recreate or not Model("aqsol-pytorch-reg").exists():
         target_column=target,
         description="PyTorch Regression Model for AQSol",
         tags=["pytorch", "molecular descriptors"],
+        hyperparameters={"training_config": {"max_epochs": 150}, "model_config": {"layers": "128-64-32"}},
     )
     m.set_owner("BW")
 
@@ -43,6 +44,7 @@ if recreate or not Model("aqsol-pytorch-class").exists():
         target_column="solubility_class",
         description="PyTorch Classification Model for AQSol",
         tags=["pytorch", "molecular descriptors"],
+        hyperparameters={"training_config": {"max_epochs": 150}, "model_config": {"layers": "256-128-64"}},
     )
     m.set_owner("BW")
     m.set_class_labels(["low", "medium", "high"])

{workbench-0.8.160 → workbench-0.8.162}/experiments/pytorch_model.py

@@ -61,6 +61,17 @@ TEMPLATE_PARAMS = {
     "compressed_features": [],
     "model_metrics_s3_path": "s3://sandbox-sageworks-artifacts/models/aqsol-pytorch-reg/training",
     "train_all_data": False,
+    "hyperparameters": {
+        "learning_rate": 0.001,
+        "batch_size": 64,
+        "max_epochs": 100,
+        "early_stopping_patience": 10,
+        "layers": "512-256",
+        "activation": "ReLU",
+        "dropout": 0.1,
+        "use_batch_norm": True,
+        "initialization": "kaiming",
+    },
 }
 
 
@@ -342,6 +353,7 @@ if __name__ == "__main__":
     model_type = TEMPLATE_PARAMS["model_type"]
     model_metrics_s3_path = TEMPLATE_PARAMS["model_metrics_s3_path"]
     train_all_data = TEMPLATE_PARAMS["train_all_data"]
+    hyperparameters = TEMPLATE_PARAMS["hyperparameters"]
     validation_split = 0.2
 
     # Script arguments for input/output directories
@@ -402,21 +414,7 @@ if __name__ == "__main__":
         categorical_cols=categorical_cols,
     )
 
-    trainer_config = TrainerConfig(
-        auto_lr_find=True,
-        batch_size=min(1024, len(df_train) // 4),
-        max_epochs=100,
-        early_stopping="valid_loss",
-        early_stopping_patience=15,
-        checkpoints="valid_loss",
-        accelerator="auto",
-        progress_bar="none",
-        gradient_clip_val=1.0,
-    )
-
-    optimizer_config = OptimizerConfig()
-
-    # Choose model configuration based on model type
+    # Choose the 'task' based on model type also set up the label encoder if needed
     if model_type == "classifier":
         task = "classification"
         # Encode the target column
@@ -427,26 +425,50 @@ if __name__ == "__main__":
         task = "regression"
         label_encoder = None
 
+    # Use any hyperparameters to set up both the trainer and model configurations
+    print(f"Hyperparameters: {hyperparameters}")
+
+    # Set up PyTorch Tabular configuration with defaults
+    trainer_defaults = {
+        "auto_lr_find": True,
+        "batch_size": min(1024, max(32, len(df_train) // 4)),
+        "max_epochs": 100,
+        "early_stopping": "valid_loss",
+        "early_stopping_patience": 15,
+        "checkpoints": "valid_loss",
+        "accelerator": "auto",
+        "progress_bar": "none",
+        "gradient_clip_val": 1.0,
+    }
+
+    # Override defaults with any provided hyperparameters for trainer
+    trainer_params = {**trainer_defaults, **{k: v for k, v in hyperparameters.items() if k in trainer_defaults}}
+    trainer_config = TrainerConfig(**trainer_params)
+
+    # Model config defaults
+    model_defaults = {
+        "layers": "1024-512-512",
+        "activation": "ReLU",
+        "learning_rate": 1e-3,
+        "dropout": 0.1,
+        "use_batch_norm": True,
+        "initialization": "kaiming",
+    }
+    # Override defaults with any provided hyperparameters for model
+    model_params = {**model_defaults, **{k: v for k, v in hyperparameters.items() if k in model_defaults}}
     # Use CategoryEmbedding for both regression and classification tasks
-    model_config = CategoryEmbeddingModelConfig(
-        task=task,
-        layers="1024-512-512",
-        activation="ReLU",
-        learning_rate=1e-3,
-        dropout=0.1,
-        use_batch_norm=True,
-        initialization="kaiming",
-    )
+    model_config = CategoryEmbeddingModelConfig(task=task, **model_params)
+    optimizer_config = OptimizerConfig()
 
-    # Create and train the TabularModel
+    #####################################
+    # Create and train the TabularModel #
+    #####################################
     tabular_model = TabularModel(
         data_config=data_config,
         model_config=model_config,
         optimizer_config=optimizer_config,
         trainer_config=trainer_config,
     )
-
-    # Train the model
     tabular_model.fit(train=df_train, validation=df_val)
 
     # Make Predictions on the Validation Set

{workbench-0.8.160 → workbench-0.8.162}/src/workbench/api/feature_set.py

@@ -108,6 +108,7 @@ class FeatureSet(FeatureSetCore):
             training_image (str, optional): The training image to use (default: "xgb_training")
             inference_image (str, optional): The inference image to use (default: "xgb_inference")
             inference_arch (str, optional): The architecture to use for inference (default: "x86_64")
+            kwargs (dict, optional): Additional keyword arguments to pass to the model
 
         Returns:
             Model: The Model created from the FeatureSet (or None if the Model could not be created)

{workbench-0.8.160 → workbench-0.8.162}/src/workbench/api/parameter_store.py

@@ -133,3 +133,8 @@ if __name__ == "__main__":
     # Out of scope tests
     param_store.upsert("test", "value")
     param_store.delete("test")
+
+    # Recursive delete test
+    param_store.upsert("/workbench/test/test1", "value1")
+    param_store.upsert("/workbench/test/test2", "value2")
+    param_store.delete_recursive("workbench/test/")

{workbench-0.8.160 → workbench-0.8.162}/src/workbench/core/artifacts/model_core.py

@@ -926,15 +926,15 @@ class ModelCore(Artifact):
         wr.s3.delete_objects(s3_delete_path, boto3_session=cls.boto3_session)
 
         # Delete any dataframes that were stored in the Dataframe Cache
-        cls.log.info("Deleting Dataframe Cache...")
+        cls.log.info("Deleting Dataframe Cache Entries...")
         cls.df_cache.delete_recursive(model_group_name)
 
         # Delete any dataframes that were stored in the Dataframe Store
-        cls.log.info("Deleting Dataframe Store...")
+        cls.log.info("Deleting Dataframe Store Entries...")
         cls.df_store.delete_recursive(f"workbench/models/{model_group_name}")
 
         # Delete anything we might have stored in the Parameter Store
-        cls.log.info("Deleting Parameter Store...")
+        cls.log.info("Deleting Parameter Store Entries...")
         cls.param_store.delete_recursive(f"workbench/models/{model_group_name}")
 
     def _set_model_type(self, model_type: ModelType):

{workbench-0.8.160 → workbench-0.8.162}/src/workbench/core/transforms/features_to_model/features_to_model.py

@@ -164,6 +164,7 @@ class FeaturesToModel(Transform):
             "model_metrics_s3_path": self.model_training_root,
             "train_all_data": train_all_data,
             "id_column": feature_set.id_column,
+            "hyperparameters": kwargs.get("hyperparameters", {}),
         }
 
         # Custom Script
@@ -280,11 +281,12 @@ class FeaturesToModel(Transform):
         # Call the Model onboard method
         output_model.onboard_with_args(self.model_type, self.target_column, self.model_feature_list)
 
-    def create_and_register_model(self, aws_region=None):
+    def create_and_register_model(self, aws_region=None, **kwargs):
         """Create and Register the Model
 
         Args:
             aws_region (str, optional): AWS Region to use (default None)
+            **kwargs: Additional keyword arguments to pass to the model registration
         """
 
         # Get the metadata/tags to push into AWS

{workbench-0.8.160 → workbench-0.8.162}/src/workbench/model_scripts/pytorch_model/generated_model_script.py

@@ -8,7 +8,7 @@ import numpy as np
 os.environ["TORCH_FORCE_NO_WEIGHTS_ONLY_LOAD"] = "1"
 from pytorch_tabular import TabularModel
 from pytorch_tabular.config import DataConfig, OptimizerConfig, TrainerConfig
-from pytorch_tabular.models import CategoryEmbeddingModelConfig, TabNetModelConfig
+from pytorch_tabular.models import CategoryEmbeddingModelConfig
 
 # Model Performance Scores
 from sklearn.metrics import (
@@ -40,7 +40,8 @@ TEMPLATE_PARAMS = {
     "features": ['molwt', 'mollogp', 'molmr', 'heavyatomcount', 'numhacceptors', 'numhdonors', 'numheteroatoms', 'numrotatablebonds', 'numvalenceelectrons', 'numaromaticrings', 'numsaturatedrings', 'numaliphaticrings', 'ringcount', 'tpsa', 'labuteasa', 'balabanj', 'bertzct'],
     "compressed_features": [],
     "model_metrics_s3_path": "s3://sandbox-sageworks-artifacts/models/aqsol-pytorch-class/training",
-    "train_all_data": False
+    "train_all_data": False,
+    "hyperparameters": {'training_config': {'max_epochs': 150}, 'model_config': {'layers': '256-128-64'}}
 }
 
 
@@ -203,15 +204,6 @@ def decompress_features(
     return df, decompressed_features
 
 
-def model_fn(model_dir):
-    """Deserialize and return fitted PyTorch Tabular model"""
-    #
-    os.environ['TEMP'] = '/tmp'
-    model_path = os.path.join(model_dir, "tabular_model")
-    model = TabularModel.load_model(model_path)
-    return model
-
-
 def model_fn(model_dir):
 
     # Save current working directory
@@ -343,6 +335,7 @@ if __name__ == "__main__":
     model_type = TEMPLATE_PARAMS["model_type"]
     model_metrics_s3_path = TEMPLATE_PARAMS["model_metrics_s3_path"]
     train_all_data = TEMPLATE_PARAMS["train_all_data"]
+    hyperparameters = TEMPLATE_PARAMS["hyperparameters"]
     validation_split = 0.2
 
     # Script arguments for input/output directories
@@ -412,21 +405,7 @@ if __name__ == "__main__":
         categorical_cols=categorical_cols,
     )
 
-    trainer_config = TrainerConfig(
-        auto_lr_find=True,
-        batch_size=min(1024, len(df_train) // 4),
-        max_epochs=100,
-        early_stopping="valid_loss",
-        early_stopping_patience=15,
-        checkpoints="valid_loss",
-        accelerator="auto",
-        progress_bar="none",
-        gradient_clip_val=1.0,
-    )
-
-    optimizer_config = OptimizerConfig()
-
-    # Choose model configuration based on model type
+    # Choose the 'task' based on model type also set up the label encoder if needed
     if model_type == "classifier":
         task = "classification"
         # Encode the target column
@@ -437,30 +416,70 @@ if __name__ == "__main__":
         task = "regression"
         label_encoder = None
 
-    # Use CategoryEmbedding for both regression and classification tasks
+    # Use any hyperparameters to set up both the trainer and model configurations
+    print(f"Hyperparameters: {hyperparameters}")
+
+    # Set up PyTorch Tabular configuration with defaults
+    trainer_defaults = {
+        "auto_lr_find": True,
+        "batch_size": min(1024, max(32, len(df_train) // 4)),
+        "max_epochs": 100,
+        "early_stopping": "valid_loss",
+        "early_stopping_patience": 15,
+        "checkpoints": "valid_loss",
+        "accelerator": "auto",
+        "progress_bar": "none",
+        "gradient_clip_val": 1.0,
+    }
+
+    # Override defaults with training_config if present
+    training_overrides = {k: v for k, v in hyperparameters.get('training_config', {}).items()
+                          if k in trainer_defaults}
+    # Print overwrites
+    for key, value in training_overrides.items():
+        print(f"TRAINING CONFIG Override: {key}: {trainer_defaults[key]} → {value}")
+    trainer_params = {**trainer_defaults, **training_overrides}
+    trainer_config = TrainerConfig(**trainer_params)
+
+    # Model config defaults
+    model_defaults = {
+        "layers": "1024-512-512",
+        "activation": "ReLU",
+        "learning_rate": 1e-3,
+        "dropout": 0.1,
+        "use_batch_norm": True,
+        "initialization": "kaiming",
+    }
+    # Override defaults with model_config if present
+    model_overrides = {k: v for k, v in hyperparameters.get('model_config', {}).items()
+                          if k in model_defaults}
+    # Print overwrites
+    for key, value in model_overrides.items():
+        print(f"MODEL CONFIG Override: {key}: {model_defaults[key]} → {value}")
+    model_params = {**model_defaults, **model_overrides}
+
+    # Use CategoryEmbedding model configuration for general-purpose tabular modeling.
+    # Works effectively for both regression and classification as the foundational
+    # architecture in PyTorch Tabular
     model_config = CategoryEmbeddingModelConfig(
         task=task,
-        layers="1024-512-512",
-        activation="ReLU",
-        learning_rate=1e-3,
-        dropout=0.1,
-        use_batch_norm=True,
-        initialization="kaiming",
+        **model_params
     )
+    optimizer_config = OptimizerConfig()
 
-    # Create and train the TabularModel
+    #####################################
+    # Create and train the TabularModel #
+    #####################################
     tabular_model = TabularModel(
         data_config=data_config,
         model_config=model_config,
         optimizer_config=optimizer_config,
         trainer_config=trainer_config,
     )
-
-    # Train the model
     tabular_model.fit(train=df_train, validation=df_val)
 
     # Make Predictions on the Validation Set
-    print(f"Making Predictions on Validation Set...")
+    print("Making Predictions on Validation Set...")
     result = tabular_model.predict(df_val, include_input_features=False)
 
     # pytorch-tabular returns predictions using f"{target}_prediction" column
@@ -554,4 +573,4 @@ if __name__ == "__main__":
 
     # Save the category mappings
     with open(os.path.join(args.model_dir, "category_mappings.json"), "w") as fp:
-        json.dump(category_mappings, fp)
+        json.dump(category_mappings, fp)

{workbench-0.8.160 → workbench-0.8.162}/src/workbench/model_scripts/pytorch_model/pytorch.template

@@ -40,7 +40,8 @@ TEMPLATE_PARAMS = {
     "features": "{{feature_list}}",
     "compressed_features": "{{compressed_features}}",
     "model_metrics_s3_path": "{{model_metrics_s3_path}}",
-    "train_all_data": "{{train_all_data}}"
+    "train_all_data": "{{train_all_data}}",
+    "hyperparameters": "{{hyperparameters}}"
 }
 
 
@@ -334,6 +335,7 @@ if __name__ == "__main__":
     model_type = TEMPLATE_PARAMS["model_type"]
     model_metrics_s3_path = TEMPLATE_PARAMS["model_metrics_s3_path"]
     train_all_data = TEMPLATE_PARAMS["train_all_data"]
+    hyperparameters = TEMPLATE_PARAMS["hyperparameters"]
     validation_split = 0.2
 
     # Script arguments for input/output directories
@@ -403,21 +405,7 @@ if __name__ == "__main__":
         categorical_cols=categorical_cols,
     )
 
-    trainer_config = TrainerConfig(
-        auto_lr_find=True,
-        batch_size=min(1024, len(df_train) // 4),
-        max_epochs=100,
-        early_stopping="valid_loss",
-        early_stopping_patience=15,
-        checkpoints="valid_loss",
-        accelerator="auto",
-        progress_bar="none",
-        gradient_clip_val=1.0,
-    )
-
-    optimizer_config = OptimizerConfig()
-
-    # Choose model configuration based on model type
+    # Choose the 'task' based on model type also set up the label encoder if needed
     if model_type == "classifier":
         task = "classification"
         # Encode the target column
@@ -428,26 +416,66 @@ if __name__ == "__main__":
         task = "regression"
         label_encoder = None
 
-    # Use CategoryEmbedding for both regression and classification tasks
+    # Use any hyperparameters to set up both the trainer and model configurations
+    print(f"Hyperparameters: {hyperparameters}")
+
+    # Set up PyTorch Tabular configuration with defaults
+    trainer_defaults = {
+        "auto_lr_find": True,
+        "batch_size": min(1024, max(32, len(df_train) // 4)),
+        "max_epochs": 100,
+        "early_stopping": "valid_loss",
+        "early_stopping_patience": 15,
+        "checkpoints": "valid_loss",
+        "accelerator": "auto",
+        "progress_bar": "none",
+        "gradient_clip_val": 1.0,
+    }
+
+    # Override defaults with training_config if present
+    training_overrides = {k: v for k, v in hyperparameters.get('training_config', {}).items()
+                          if k in trainer_defaults}
+    # Print overwrites
+    for key, value in training_overrides.items():
+        print(f"TRAINING CONFIG Override: {key}: {trainer_defaults[key]} → {value}")
+    trainer_params = {**trainer_defaults, **training_overrides}
+    trainer_config = TrainerConfig(**trainer_params)
+
+    # Model config defaults
+    model_defaults = {
+        "layers": "1024-512-512",
+        "activation": "ReLU",
+        "learning_rate": 1e-3,
+        "dropout": 0.1,
+        "use_batch_norm": True,
+        "initialization": "kaiming",
+    }
+    # Override defaults with model_config if present
+    model_overrides = {k: v for k, v in hyperparameters.get('model_config', {}).items()
+                          if k in model_defaults}
+    # Print overwrites
+    for key, value in model_overrides.items():
+        print(f"MODEL CONFIG Override: {key}: {model_defaults[key]} → {value}")
+    model_params = {**model_defaults, **model_overrides}
+
+    # Use CategoryEmbedding model configuration for general-purpose tabular modeling.
+    # Works effectively for both regression and classification as the foundational
+    # architecture in PyTorch Tabular
     model_config = CategoryEmbeddingModelConfig(
         task=task,
-        layers="1024-512-512",
-        activation="ReLU",
-        learning_rate=1e-3,
-        dropout=0.1,
-        use_batch_norm=True,
-        initialization="kaiming",
+        **model_params
     )
+    optimizer_config = OptimizerConfig()
 
-    # Create and train the TabularModel
+    #####################################
+    # Create and train the TabularModel #
+    #####################################
     tabular_model = TabularModel(
         data_config=data_config,
         model_config=model_config,
         optimizer_config=optimizer_config,
         trainer_config=trainer_config,
     )
-
-    # Train the model
     tabular_model.fit(train=df_train, validation=df_val)
 
     # Make Predictions on the Validation Set

{workbench-0.8.160 → workbench-0.8.162}/src/workbench/model_scripts/script_generation.py

@@ -68,7 +68,7 @@ def fill_template(template_path: str, params: dict, output_script: str) -> str:
         template = template.replace(placeholder, str(value))
 
     # Sanity check to ensure all placeholders were replaced
-    if "{{" in template or "}}" in template:
+    if "{{" in template and "}}" in template:
         msg = "Not all template placeholders were replaced. Please check your params."
         log.critical(msg)
         raise ValueError(msg)
@@ -93,6 +93,7 @@ def generate_model_script(template_params: dict) -> str:
             - feature_list (list[str]): A list of columns for the features
             - model_metrics_s3_path (str): The S3 path to store the model metrics
             - train_all_data (bool): Whether to train on all (100%) of the data
+            - hyperparameters (dict, optional): Hyperparameters for the model (default: None)
 
     Returns:
         str: The name of the generated model script

{workbench-0.8.160 → workbench-0.8.162}/src/workbench.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workbench
-Version: 0.8.160
+Version: 0.8.162
 Summary: Workbench: A Dashboard and Python API for creating and deploying AWS SageMaker Model Pipelines
 Author-email: SuperCowPowers LLC <support@supercowpowers.com>
 License-Expression: MIT

{workbench-0.8.160 → workbench-0.8.162}/tests/artifacts/featureset_ingest_boundaries.py

@@ -70,6 +70,9 @@ def test_underflow():
     rejected_ids = original_ids - ingested_ids
     print(f"Rejected IDs (due to underflow or ingest errors): {rejected_ids}")
 
+    # Delete the FeatureSet after testing
+    fs.delete()
+
 
 @pytest.mark.long
 def test_overflow_nan_inf():
@@ -115,6 +118,9 @@ def test_overflow_nan_inf():
     rejected_ids = original_ids - ingested_ids
     print(f"Rejected IDs (due to overflow, NaN, or INF): {rejected_ids}")
 
+    # Delete the FeatureSet after testing
+    fs.delete()
+
 
 if __name__ == "__main__":
     test_underflow()