workbench 0.8.224__py3-none-any.whl → 0.8.234__py3-none-any.whl

workbench/__init__.py

@@ -29,6 +29,7 @@ Workbench Main Classes
      |      json_to_data.set_output_tags(["abalone", "json", "whatever"])
      |      json_to_data.transform()
 """
+
 import os
 from importlib.metadata import version
 

workbench/algorithms/dataframe/__init__.py

@@ -9,10 +9,12 @@ from .proximity import Proximity
 from .feature_space_proximity import FeatureSpaceProximity
 from .fingerprint_proximity import FingerprintProximity
 from .projection_2d import Projection2D
+from .smart_aggregator import smart_aggregator
 
 __all__ = [
     "Proximity",
     "FeatureSpaceProximity",
     "FingerprintProximity",
     "Projection2D",
+    "smart_aggregator",
 ]

workbench/algorithms/dataframe/smart_aggregator.py

@@ -0,0 +1,161 @@
+"""SmartSample: Intelligently reduce DataFrame rows by aggregating similar rows together."""
+
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+from sklearn.cluster import MiniBatchKMeans
+import logging
+
+# Set up logging
+log = logging.getLogger("workbench")
+
+
+def smart_aggregator(df: pd.DataFrame, target_rows: int = 1000, outlier_column: str = "residual") -> pd.DataFrame:
+    """
+    Reduce DataFrame rows by aggregating similar rows based on numeric column similarity.
+
+    This is a performant (2-pass) algorithm:
+    1. Pass 1: Normalize numeric columns and cluster similar rows using MiniBatchKMeans
+    2. Pass 2: Aggregate each cluster (mean for numeric, first for non-numeric)
+
+    Args:
+        df: Input DataFrame.
+        target_rows: Target number of rows in output (default: 1000).
+        outlier_column: Column where high values should resist aggregation (default: "residual").
+                       Rows with high values in this column will be kept separate while rows
+                       with low values cluster together. Set to None to disable.
+
+    Returns:
+        Reduced DataFrame with 'aggregation_count' column showing how many rows were combined.
+    """
+    if df is None or df.empty:
+        return df
+
+    n_rows = len(df)
+
+    # Preserve original column order
+    original_columns = df.columns.tolist()
+
+    # If already at or below target, just add the count column and return
+    if n_rows <= target_rows:
+        result = df.copy()
+        result["aggregation_count"] = 1
+        return result
+
+    log.info(f"smart_aggregator: Reducing {n_rows} rows to ~{target_rows} rows")
+
+    # Identify columns by type
+    df = df.copy()
+    numeric_cols = df.select_dtypes(include=["number"]).columns.tolist()
+    non_numeric_cols = [c for c in df.columns if c not in numeric_cols]
+
+    if not numeric_cols:
+        log.warning("smart_aggregator: No numeric columns for clustering, falling back to random sample")
+        result = df.sample(n=target_rows)
+        result["aggregation_count"] = 1
+        return result.reset_index(drop=True)
+
+    # Handle NaN values - fill with column median
+    df_for_clustering = df[numeric_cols].fillna(df[numeric_cols].median())
+
+    # Normalize and cluster
+    X = StandardScaler().fit_transform(df_for_clustering)
+    df["_cluster"] = MiniBatchKMeans(
+        n_clusters=min(target_rows, n_rows), random_state=42, batch_size=min(1024, n_rows), n_init=3
+    ).fit_predict(X)
+
+    # Post-process: give high-outlier rows their own unique clusters so they don't get aggregated
+    if outlier_column and outlier_column in df.columns:
+        # Top 10% of outlier values get their own clusters, capped at 200
+        n_to_isolate = min(int(n_rows * 0.1), 200)
+        threshold = df[outlier_column].nlargest(n_to_isolate).min()
+        high_outlier_mask = df[outlier_column] >= threshold
+        n_high_outliers = high_outlier_mask.sum()
+        # Assign unique cluster IDs starting after the max existing cluster
+        max_cluster = df["_cluster"].max()
+        df.loc[high_outlier_mask, "_cluster"] = range(max_cluster + 1, max_cluster + 1 + n_high_outliers)
+        log.info(f"smart_aggregator: Isolated {n_high_outliers} high-outlier rows (>= {threshold:.3f})")
+    elif outlier_column:
+        log.warning(f"smart_aggregator: outlier_column '{outlier_column}' not found in columns")
+
+    # Aggregate each cluster (mean for numeric, first for non-numeric)
+    agg_dict = {col: "mean" for col in numeric_cols} | {col: "first" for col in non_numeric_cols}
+    grouped = df.groupby("_cluster")
+    result = grouped.agg(agg_dict).reset_index(drop=True)
+    result["aggregation_count"] = grouped.size().values
+
+    # Restore original column order, with aggregation_count at the end
+    result = result[original_columns + ["aggregation_count"]]
+
+    log.info(f"smart_aggregator: Reduced to {len(result)} rows")
+    return result
+
+
+# Testing
+if __name__ == "__main__":
+    pd.set_option("display.max_columns", None)
+    pd.set_option("display.width", 1000)
+
+    # Create test data with clusters
+    np.random.seed(42)
+    n_samples = 10000
+
+    # Create 3 distinct clusters
+    cluster_1 = np.random.randn(n_samples // 3, 3) + np.array([0, 0, 0])
+    cluster_2 = np.random.randn(n_samples // 3, 3) + np.array([5, 5, 5])
+    cluster_3 = np.random.randn(n_samples // 3, 3) + np.array([10, 0, 5])
+
+    features = np.vstack([cluster_1, cluster_2, cluster_3])
+
+    # Create target and prediction columns, then compute residuals
+    target = features[:, 0] + features[:, 1] * 0.5 + np.random.randn(len(features)) * 0.1
+    prediction = target + np.random.randn(len(features)) * 0.5  # Add noise for residuals
+    residuals = np.abs(target - prediction)
+
+    data = {
+        "id": [f"id_{i}" for i in range(len(features))],
+        "A": features[:, 0],
+        "B": features[:, 1],
+        "C": features[:, 2],
+        "category": np.random.choice(["cat1", "cat2", "cat3"], len(features)),
+        "target": target,
+        "prediction": prediction,
+        "residual": residuals,
+    }
+    df = pd.DataFrame(data)
+
+    print(f"Original DataFrame: {len(df)} rows")
+    print(df.head())
+    print()
+
+    # Test smart_aggregator with residuals preservation
+    result = smart_aggregator(df, target_rows=500)
+    print(f"smart_aggregator result: {len(result)} rows")
+    print(result.head(20))
+    print()
+    print("Aggregation count stats:")
+    print(result["aggregation_count"].describe())
+    print()
+    # Show that high-residual points have lower aggregation counts
+    print("Aggregation count by residual quartile:")
+    result["residual_quartile"] = pd.qcut(result["residual"], 4, labels=["Q1 (low)", "Q2", "Q3", "Q4 (high)"])
+    print(result.groupby("residual_quartile")["aggregation_count"].mean())
+
+    # Test with real Workbench data
+    print("\n" + "=" * 80)
+    print("Testing with Workbench data...")
+    print("=" * 80)
+
+    from workbench.api import Model
+
+    model = Model("abalone-regression")
+    df = model.get_inference_predictions()
+    if df is not None:
+        print(f"\nOriginal DataFrame: {len(df)} rows")
+        print(df.head())
+
+        result = smart_aggregator(df, target_rows=500)
+        print(f"\nsmart_aggregator result: {len(result)} rows")
+        print(result.head())
+        print("\nAggregation count stats:")
+        print(result["aggregation_count"].describe())

workbench/algorithms/sql/column_stats.py

@@ -6,7 +6,6 @@ import pandas as pd
 # Workbench Imports
 from workbench.core.artifacts.data_source_abstract import DataSourceAbstract
 
-
 # Workbench Logger
 log = logging.getLogger("workbench")
 

workbench/algorithms/sql/correlations.py

@@ -7,7 +7,6 @@ from collections import defaultdict
 # Workbench Imports
 from workbench.core.artifacts.data_source_abstract import DataSourceAbstract
 
-
 # Workbench Logger
 log = logging.getLogger("workbench")
 

workbench/algorithms/sql/descriptive_stats.py

@@ -7,7 +7,6 @@ from collections import defaultdict
 # Workbench Imports
 from workbench.core.artifacts.data_source_abstract import DataSourceAbstract
 
-
 # Workbench Logger
 log = logging.getLogger("workbench")
 

workbench/api/meta.py

@@ -6,7 +6,6 @@ such as Data Sources, Feature Sets, Models, and Endpoints.
 from typing import Union
 import pandas as pd
 
-
 # Workbench Imports
 from workbench.core.cloud_platform.cloud_meta import CloudMeta
 

workbench/cached/cached_meta.py

@@ -6,7 +6,6 @@ import pandas as pd
 from functools import wraps
 from concurrent.futures import ThreadPoolExecutor
 
-
 # Workbench Imports
 from workbench.core.cloud_platform.cloud_meta import CloudMeta
 from workbench.utils.workbench_cache import WorkbenchCache

workbench/cached/cached_model.py

@@ -4,8 +4,9 @@ from typing import Union
 import pandas as pd
 
 # Workbench Imports
-from workbench.core.artifacts.model_core import ModelCore
+from workbench.core.artifacts.model_core import ModelCore, ModelType
 from workbench.core.artifacts.cached_artifact_mixin import CachedArtifactMixin
+from workbench.algorithms.dataframe import smart_aggregator
 
 
 class CachedModel(CachedArtifactMixin, ModelCore):
@@ -84,20 +85,49 @@ class CachedModel(CachedArtifactMixin, ModelCore):
         return super().get_inference_metrics(capture_name=capture_name)
 
     @CachedArtifactMixin.cache_result
-    def get_inference_predictions(self, capture_name: str = "auto_inference") -> Union[pd.DataFrame, None]:
+    def get_inference_predictions(
+        self, capture_name: str = "full_cross_fold", target_rows: int = 1000
+    ) -> Union[pd.DataFrame, None]:
         """Retrieve the captured prediction results for this model
 
         Args:
-            capture_name (str, optional): Specific capture_name (default: training_holdout)
+            capture_name (str, optional): Specific capture_name (default: full_cross_fold)
+            target_rows (int, optional): Target number of rows to return (default: 1000)
 
         Returns:
             pd.DataFrame: DataFrame of the Captured Predictions (might be None)
         """
-        # Note: This method can generate larger dataframes, so we'll sample if needed
         df = super().get_inference_predictions(capture_name=capture_name)
-        if df is not None and len(df) > 5000:
-            self.log.warning(f"{self.name}:{capture_name} Sampling Inference Predictions to 5000 rows")
-            return df.sample(5000)
+        if df is None:
+            return None
+
+        # Compute residual based on model type
+        is_regressor = self.model_type in [ModelType.REGRESSOR, ModelType.UQ_REGRESSOR, ModelType.ENSEMBLE_REGRESSOR]
+        is_classifier = self.model_type == ModelType.CLASSIFIER
+
+        if is_regressor:
+            target = self.target()
+            if target and "prediction" in df.columns and target in df.columns:
+                df["residual"] = abs(df["prediction"] - df[target])
+
+        elif is_classifier:
+            target = self.target()
+            class_labels = self.class_labels()
+            if target and "prediction" in df.columns and target in df.columns and class_labels:
+                # Create a mapping from label to ordinal index
+                label_to_idx = {label: idx for idx, label in enumerate(class_labels)}
+                # Compute residual as distance between predicted and actual class
+                df["residual"] = abs(
+                    df["prediction"].map(label_to_idx).fillna(-1) - df[target].map(label_to_idx).fillna(-1)
+                )
+
+        # Use smart_aggregator to aggregate similar rows if we have too many
+        if len(df) > target_rows:
+            self.log.info(
+                f"{self.name}:{capture_name} Using smart_aggregator to reduce {len(df)} rows to ~{target_rows}"
+            )
+            df = smart_aggregator(df, target_rows=target_rows)
+
         return df
 
     @CachedArtifactMixin.cache_result

workbench/core/artifacts/endpoint_core.py

@@ -546,7 +546,14 @@ class EndpointCore(Artifact):
         target_list = targets if isinstance(targets, list) else [targets]
         primary_target = target_list[0]
 
-        # Collect UQ columns (q_*, confidence) for additional tracking
+        # If we don't have a smiles column, try to merge it from the FeatureSet
+        if "smiles" not in out_of_fold_df.columns:
+            fs_df = fs.query(f'SELECT {fs.id_column}, "smiles" FROM "{fs.athena_table}"')
+            if "smiles" in fs_df.columns:
+                self.log.info("Merging 'smiles' column from FeatureSet into out-of-fold predictions.")
+                out_of_fold_df = out_of_fold_df.merge(fs_df, on=fs.id_column, how="left")
+
+        # Collect UQ columns (q_*, confidence) for additional tracking (used for hashing)
         additional_columns = [col for col in out_of_fold_df.columns if col.startswith("q_") or col == "confidence"]
         if additional_columns:
             self.log.info(f"UQ columns from training: {', '.join(additional_columns)}")
@@ -559,7 +566,6 @@ class EndpointCore(Artifact):
         # For single-target models (99% of cases), just save as "full_cross_fold"
         # For multi-target models, save each as cv_{target} plus primary as "full_cross_fold"
         is_multi_target = len(target_list) > 1
-
         for target in target_list:
             # Drop rows with NaN target values for metrics/plots
             target_df = out_of_fold_df.dropna(subset=[target])
@@ -899,6 +905,10 @@ class EndpointCore(Artifact):
         # Add UQ columns (q_*, confidence) and proba columns
         output_columns += [c for c in cols if c.startswith("q_") or c == "confidence" or c.endswith("_proba")]
 
+        # Add smiles column if present
+        if "smiles" in cols:
+            output_columns.append("smiles")
+
         # Write the predictions to S3
         output_file = f"{inference_capture_path}/inference_predictions.csv"
         self.log.info(f"Writing predictions to {output_file}")

workbench/core/artifacts/feature_set_core.py

@@ -554,12 +554,29 @@ class FeatureSetCore(Artifact):
         aws_cols = ["write_time", "api_invocation_time", "is_deleted", "event_time"]
         source_columns = get_column_list(self.data_source, self.table)
         column_list = [col for col in source_columns if col not in aws_cols]
-        sql_columns = ", ".join([f'"{column}"' for column in column_list])
 
-        # Build inner query with both columns
+        # Build the training column CASE statement
         training_case = self._build_holdout_case(holdout_ids)
-        weight_case = self._build_weight_case(weight_dict, default_weight)
-        inner_sql = f"SELECT {sql_columns}, {training_case}, {weight_case} FROM {self.table}"
+
+        # For large weight_dict, use supplemental table + JOIN
+        if len(weight_dict) >= 100:
+            self.log.info("Using supplemental table approach for large weight_dict")
+            weights_table = self._create_weights_table(weight_dict)
+
+            # Build column selection with table alias
+            sql_columns = ", ".join([f't."{col}"' for col in column_list])
+
+            # Build JOIN query with training CASE and weight from joined table
+            training_case_aliased = training_case.replace(f"WHEN {self.id_column} IN", f"WHEN t.{self.id_column} IN")
+            inner_sql = f"""SELECT {sql_columns}, {training_case_aliased},
+                COALESCE(w.sample_weight, {default_weight}) AS sample_weight
+                FROM {self.table} t
+                LEFT JOIN {weights_table} w ON t.{self.id_column} = w.{self.id_column}"""
+        else:
+            # For small weight_dict, use CASE statement
+            sql_columns = ", ".join([f'"{column}"' for column in column_list])
+            weight_case = self._build_weight_case(weight_dict, default_weight)
+            inner_sql = f"SELECT {sql_columns}, {training_case}, {weight_case} FROM {self.table}"
 
         # Optionally filter out zero weights
         if exclude_zero_weights:
@@ -608,6 +625,10 @@ class FeatureSetCore(Artifact):
             }
             fs.set_sample_weights(weights)  # zeros automatically excluded
             fs.set_sample_weights(weights, exclude_zero_weights=False)  # keep zeros
+
+        Note:
+            For large weight_dict (100+ entries), weights are stored as a supplemental
+            table and joined to avoid Athena query size limits.
         """
         from workbench.core.views import TrainingView
 
@@ -618,14 +639,25 @@ class FeatureSetCore(Artifact):
 
         self.log.important(f"Setting sample weights for {len(weight_dict)} IDs")
 
-        # Build inner query with sample weights
-        weight_case = self._build_weight_case(weight_dict, default_weight)
-        inner_sql = f"SELECT *, {weight_case} FROM {self.table}"
+        # For large weight_dict, use supplemental table + JOIN to avoid query size limits
+        if len(weight_dict) >= 100:
+            self.log.info("Using supplemental table approach for large weight_dict")
+            weights_table = self._create_weights_table(weight_dict)
+
+            # Build JOIN query with COALESCE for default weight
+            inner_sql = f"""SELECT t.*, COALESCE(w.sample_weight, {default_weight}) AS sample_weight
+                FROM {self.table} t
+                LEFT JOIN {weights_table} w ON t.{self.id_column} = w.{self.id_column}"""
+        else:
+            # For small weight_dict, use CASE statement (simpler, no extra table)
+            weight_case = self._build_weight_case(weight_dict, default_weight)
+            inner_sql = f"SELECT *, {weight_case} FROM {self.table}"
 
         # Optionally filter out zero weights
         if exclude_zero_weights:
             zero_count = sum(1 for w in weight_dict.values() if w == 0.0)
-            self.log.important(f"Filtering out {zero_count} rows with sample_weight = 0")
+            if zero_count:
+                self.log.important(f"Filtering out {zero_count} rows with sample_weight = 0")
             sql_query = f"SELECT * FROM ({inner_sql}) WHERE sample_weight > 0"
         else:
             sql_query = inner_sql
@@ -667,6 +699,32 @@ class FeatureSetCore(Artifact):
         create_view_query = f"CREATE OR REPLACE VIEW {view_table} AS\n{sql_query}"
         self.data_source.execute_statement(create_view_query)
 
+    def _create_weights_table(self, weight_dict: Dict[Union[str, int], float]) -> str:
+        """Store sample weights as a supplemental data table.
+
+        Args:
+            weight_dict: Mapping of ID to sample weight
+
+        Returns:
+            str: The name of the created supplemental table
+        """
+        from workbench.core.views.view_utils import dataframe_to_table
+
+        # Create DataFrame from weight_dict
+        df = pd.DataFrame(
+            [(id_val, weight) for id_val, weight in weight_dict.items()],
+            columns=[self.id_column, "sample_weight"],
+        )
+
+        # Supplemental table name follows convention: _{base_table}___sample_weights
+        weights_table = f"_{self.table}___sample_weights"
+
+        # Store as supplemental data table
+        self.log.info(f"Creating supplemental weights table: {weights_table}")
+        dataframe_to_table(self.data_source, df, weights_table)
+
+        return weights_table
+
     @classmethod
     def delete_views(cls, table: str, database: str):
         """Delete any views associated with this FeatureSet

workbench/core/cloud_platform/cloud_meta.py

@@ -7,7 +7,6 @@ import logging
 from typing import Union
 import pandas as pd
 
-
 # Workbench Imports
 from workbench.core.cloud_platform.aws.aws_meta import AWSMeta
 

workbench/model_script_utils/model_script_utils.py

@@ -249,6 +249,36 @@ def output_fn(output_df: pd.DataFrame, accept_type: str) -> tuple[str, str]:
         raise RuntimeError(f"{accept_type} accept type is not supported by this script.")
 
 
+def cap_std_outliers(std_array: np.ndarray) -> np.ndarray:
+    """Cap extreme outliers in prediction_std using IQR method.
+
+    Uses the standard IQR fence (Q3 + 1.5*IQR) to cap extreme values.
+    This prevents unreasonably large std values while preserving the
+    relative ordering and keeping meaningful high-uncertainty signals.
+
+    Args:
+        std_array: Array of standard deviations (n_samples,) or (n_samples, n_targets)
+
+    Returns:
+        Array with outliers capped at the upper fence
+    """
+    if std_array.ndim == 1:
+        std_array = std_array.reshape(-1, 1)
+        squeeze = True
+    else:
+        squeeze = False
+
+    capped = std_array.copy()
+    for col in range(capped.shape[1]):
+        col_data = capped[:, col]
+        q1, q3 = np.percentile(col_data, [25, 75])
+        iqr = q3 - q1
+        upper_bound = q3 + 1.5 * iqr
+        capped[:, col] = np.minimum(col_data, upper_bound)
+
+    return capped.squeeze() if squeeze else capped
+
+
 def compute_regression_metrics(y_true: np.ndarray, y_pred: np.ndarray) -> dict[str, float]:
     """Compute standard regression metrics.
 

workbench/model_script_utils/uq_harness.py

@@ -22,7 +22,6 @@ import joblib
 from lightgbm import LGBMRegressor
 from mapie.regression import ConformalizedQuantileRegressor
 
-
 # Default confidence levels for prediction intervals
 DEFAULT_CONFIDENCE_LEVELS = [0.50, 0.68, 0.80, 0.90, 0.95]
 

workbench/model_scripts/chemprop/chemprop.template

@@ -20,6 +20,7 @@ import torch
 from chemprop import data, models
 
 from model_script_utils import (
+    cap_std_outliers,
     expand_proba_column,
     input_fn,
     output_fn,
@@ -245,6 +246,7 @@ def predict_fn(df: pd.DataFrame, model_dict: dict) -> pd.DataFrame:
     preds_std = np.std(np.stack(all_preds), axis=0)
     if preds.ndim == 1:
         preds, preds_std = preds.reshape(-1, 1), preds_std.reshape(-1, 1)
+    preds_std = cap_std_outliers(preds_std)
 
     print(f"Inference complete: {preds.shape[0]} predictions")
 
@@ -701,6 +703,7 @@ if __name__ == "__main__":
             preds_std = np.std(np.stack(all_ens_preds), axis=0)
             if preds_std.ndim == 1:
                 preds_std = preds_std.reshape(-1, 1)
+            preds_std = cap_std_outliers(preds_std)
 
         print("\n--- Per-target metrics ---")
         for t_idx, t_name in enumerate(target_columns):

workbench/model_scripts/chemprop/generated_model_script.py

@@ -58,11 +58,11 @@ DEFAULT_HYPERPARAMETERS = {
 # Template parameters (filled in by Workbench)
 TEMPLATE_PARAMS = {
     "model_type": "uq_regressor",
-    "targets": ['udm_asy_res_free_percent'],
+    "targets": ['udm_asy_res_value'],
     "feature_list": ['smiles'],
     "id_column": "udm_mol_bat_id",
-    "model_metrics_s3_path": "s3://ideaya-sageworks-bucket/models/ppb-human-free-reg-chemprop-foundation-1-dt/training",
-    "hyperparameters": {'from_foundation': 'CheMeleon', 'freeze_mpnn_epochs': 10, 'n_folds': 5, 'max_epochs': 100, 'patience': 20, 'ffn_hidden_dim': 512, 'dropout': 0.15},
+    "model_metrics_s3_path": "s3://ideaya-sageworks-bucket/models/logd-value-reg-chemprop-1-dt/training",
+    "hyperparameters": {},
 }
 
 

workbench/model_scripts/chemprop/model_script_utils.py

@@ -249,6 +249,36 @@ def output_fn(output_df: pd.DataFrame, accept_type: str) -> tuple[str, str]:
         raise RuntimeError(f"{accept_type} accept type is not supported by this script.")
 
 
+def cap_std_outliers(std_array: np.ndarray) -> np.ndarray:
+    """Cap extreme outliers in prediction_std using IQR method.
+
+    Uses the standard IQR fence (Q3 + 1.5*IQR) to cap extreme values.
+    This prevents unreasonably large std values while preserving the
+    relative ordering and keeping meaningful high-uncertainty signals.
+
+    Args:
+        std_array: Array of standard deviations (n_samples,) or (n_samples, n_targets)
+
+    Returns:
+        Array with outliers capped at the upper fence
+    """
+    if std_array.ndim == 1:
+        std_array = std_array.reshape(-1, 1)
+        squeeze = True
+    else:
+        squeeze = False
+
+    capped = std_array.copy()
+    for col in range(capped.shape[1]):
+        col_data = capped[:, col]
+        q1, q3 = np.percentile(col_data, [25, 75])
+        iqr = q3 - q1
+        upper_bound = q3 + 1.5 * iqr
+        capped[:, col] = np.minimum(col_data, upper_bound)
+
+    return capped.squeeze() if squeeze else capped
+
+
 def compute_regression_metrics(y_true: np.ndarray, y_pred: np.ndarray) -> dict[str, float]:
     """Compute standard regression metrics.
 

workbench/model_scripts/custom_models/chem_info/mol_descriptors.py

@@ -99,7 +99,6 @@ from rdkit.ML.Descriptors import MoleculeDescriptors
 from mordred import Calculator as MordredCalculator
 from mordred import AcidBase, Aromatic, Constitutional, Chi, CarbonTypes
 
-
 logger = logging.getLogger("workbench")
 logger.setLevel(logging.DEBUG)
 

workbench/model_scripts/custom_models/chem_info/molecular_descriptors.py

@@ -15,7 +15,6 @@ import json
 from mol_standardize import standardize
 from mol_descriptors import compute_descriptors
 
-
 # TRAINING SECTION
 #
 # This section (__main__) is where SageMaker will execute the training job

workbench/model_scripts/custom_models/chem_info/morgan_fingerprints.py

@@ -17,7 +17,6 @@ import json
 # Local imports
 from fingerprints import compute_morgan_fingerprints
 
-
 # TRAINING SECTION
 #
 # This section (__main__) is where SageMaker will execute the training job