workbench 0.8.202__py3-none-any.whl → 0.8.220__py3-none-any.whl

workbench/repl/workbench_shell.py

@@ -302,11 +302,6 @@ class WorkbenchShell:
             self.commands["PandasToView"] = importlib.import_module("workbench.core.views.pandas_to_view").PandasToView
             self.commands["Pipeline"] = importlib.import_module("workbench.api.pipeline").Pipeline
 
-            # Algorithms
-            self.commands["FSP"] = importlib.import_module(
-                "workbench.algorithms.dataframe.feature_space_proximity"
-            ).FeatureSpaceProximity
-
             # These are 'nice to have' imports
             self.commands["pd"] = importlib.import_module("pandas")
             self.commands["wr"] = importlib.import_module("awswrangler")

workbench/resources/open_source_api.key

@@ -1 +1 @@
-eyJsaWNlbnNlX2lkIjogIk9wZW5fU291cmNlX0xpY2Vuc2UiLCAiY29tcGFueSI6ICIiLCAiYXdzX2FjY291bnRfaWQiOiAiIiwgInRpZXIiOiAiRW50ZXJwcmlzZSBQcm8iLCAiZmVhdHVyZXMiOiBbInBsdWdpbnMiLCAicGFnZXMiLCAidGhlbWVzIiwgInBpcGVsaW5lcyIsICJicmFuZGluZyJdLCAiZXhwaXJlcyI6ICIyMDI2LTAxLTE0In02zCDRy41wKRViRnGmodczFWexLyfXYrJWSuVQQbhbWeRttQRv6zpo9x4O2yBjdRfhb9E7mFUppNiOS_ZGK-bL71nGHt_Mc8niG8jkpvKX9qZ6BqkXF_vzDIOcI8iGiwB3wikeVO4zRLD1AI0U3cgYmIyGXI9QKJ9L7IHyQ0TWqw==
+eyJsaWNlbnNlX2lkIjogIk9wZW5fU291cmNlX0xpY2Vuc2UiLCAiY29tcGFueSI6ICIiLCAiYXdzX2FjY291bnRfaWQiOiAiIiwgInRpZXIiOiAiRW50ZXJwcmlzZSBQcm8iLCAiZmVhdHVyZXMiOiBbInBsdWdpbnMiLCAicGFnZXMiLCAidGhlbWVzIiwgInBpcGVsaW5lcyIsICJicmFuZGluZyJdLCAiZXhwaXJlcyI6ICIyMDI2LTEyLTA1In1IsmpkuybFALADkRj_RfmkQ0LAIsQeXRE7Uoc3DL1UrDr-rSnwu-PDqsKBUkX6jPRFZV3DLxNjBapxPeEIFhfvxvjzz_sc6CwtxNpZ3bPmxSPs2W-j3xZS4-XyEqIilcwSkWh-NU1u27gCuuivn5eiUmIYJGAp0wdVkeE6_Z9dlg==

workbench/scripts/endpoint_test.py

@@ -5,7 +5,7 @@ Usage:
     python model_script_harness.py <local_script.py> <model_name>
 
 Example:
-    python model_script_harness.py pytorch.py aqsol-pytorch-reg
+    python model_script_harness.py pytorch.py aqsol-reg-pytorch
 
 This allows you to test LOCAL changes to a model script against deployed model artifacts.
 Evaluation data is automatically pulled from the FeatureSet (training = FALSE rows).
@@ -72,7 +72,7 @@ def main():
         print("Usage: python model_script_harness.py <local_script.py> <model_name>")
         print("\nArguments:")
         print("  local_script.py  - Path to your LOCAL model script to test")
-        print("  model_name       - Workbench model name (e.g., aqsol-pytorch-reg)")
+        print("  model_name       - Workbench model name (e.g., aqsol-reg-pytorch)")
         print("\nOptional: testing/env.json with additional environment variables")
         sys.exit(1)
 

workbench/scripts/meta_model_sim.py

@@ -0,0 +1,35 @@
+"""MetaModelSimulator: Simulate and analyze ensemble model performance.
+
+This class helps evaluate whether a meta model (ensemble) would outperform
+individual child models by analyzing endpoint inference predictions.
+"""
+
+import argparse
+from workbench.utils.meta_model_simulator import MetaModelSimulator
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Simulate and analyze ensemble model performance using MetaModelSimulator."
+    )
+    parser.add_argument(
+        "models",
+        nargs="+",
+        help="List of model endpoint names to include in the ensemble simulation.",
+    )
+    parser.add_argument(
+        "--id-column",
+        default="molecule_name",
+        help="Name of the ID column (default: molecule_name)",
+    )
+    args = parser.parse_args()
+    models = args.models
+    id_column = args.id_column
+
+    # Create MetaModelSimulator instance and generate report
+    sim = MetaModelSimulator(models, id_column=id_column)
+    sim.report()
+
+
+if __name__ == "__main__":
+    main()

workbench/scripts/training_test.py

@@ -0,0 +1,85 @@
+"""
+Local test harness for SageMaker training scripts.
+
+Usage:
+    python training_test.py <model_script.py> <featureset_name>
+
+Example:
+    python training_test.py ../model_scripts/pytorch_model/generated_model_script.py caco2-class-features
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+import pandas as pd
+
+from workbench.api import FeatureSet
+
+
+def get_training_data(featureset_name: str) -> pd.DataFrame:
+    """Get training data from the FeatureSet."""
+    fs = FeatureSet(featureset_name)
+    return fs.pull_dataframe()
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: python training_test.py <model_script.py> <featureset_name>")
+        sys.exit(1)
+
+    script_path = sys.argv[1]
+    featureset_name = sys.argv[2]
+
+    if not os.path.exists(script_path):
+        print(f"Error: Script not found: {script_path}")
+        sys.exit(1)
+
+    # Create temp directories
+    model_dir = tempfile.mkdtemp(prefix="training_model_")
+    train_dir = tempfile.mkdtemp(prefix="training_data_")
+    output_dir = tempfile.mkdtemp(prefix="training_output_")
+
+    print(f"Model dir: {model_dir}")
+    print(f"Train dir: {train_dir}")
+
+    try:
+        # Get training data and save to CSV
+        print(f"Loading FeatureSet: {featureset_name}")
+        df = get_training_data(featureset_name)
+        print(f"Data shape: {df.shape}")
+
+        train_file = os.path.join(train_dir, "training_data.csv")
+        df.to_csv(train_file, index=False)
+
+        # Set up environment
+        env = os.environ.copy()
+        env["SM_MODEL_DIR"] = model_dir
+        env["SM_CHANNEL_TRAIN"] = train_dir
+        env["SM_OUTPUT_DATA_DIR"] = output_dir
+
+        print("\n" + "=" * 60)
+        print("Starting training...")
+        print("=" * 60 + "\n")
+
+        # Run the script
+        cmd = [sys.executable, script_path, "--model-dir", model_dir, "--train", train_dir]
+        result = subprocess.run(cmd, env=env)
+
+        print("\n" + "=" * 60)
+        if result.returncode == 0:
+            print("Training completed successfully!")
+        else:
+            print(f"Training failed with return code: {result.returncode}")
+        print("=" * 60)
+
+    finally:
+        shutil.rmtree(model_dir, ignore_errors=True)
+        shutil.rmtree(train_dir, ignore_errors=True)
+        shutil.rmtree(output_dir, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()

workbench/utils/chem_utils/fingerprints.py

@@ -1,31 +1,48 @@
-"""Molecular fingerprint computation utilities"""
+"""Molecular fingerprint computation utilities for ADMET modeling.
+
+This module provides Morgan count fingerprints, the standard for ADMET prediction.
+Count fingerprints outperform binary fingerprints for molecular property prediction.
+
+References:
+    - Count vs Binary: https://pubs.acs.org/doi/10.1021/acs.est.3c02198
+    - ECFP/Morgan: https://pubs.acs.org/doi/10.1021/ci100050t
+"""
 
 import logging
-import pandas as pd
 
-# Molecular Descriptor Imports
-from rdkit import Chem
-from rdkit.Chem import rdFingerprintGenerator
+import numpy as np
+import pandas as pd
+from rdkit import Chem, RDLogger
+from rdkit.Chem import AllChem
 from rdkit.Chem.MolStandardize import rdMolStandardize
 
+# Suppress RDKit warnings (e.g., "not removing hydrogen atom without neighbors")
+# Keep errors enabled so we see actual problems
+RDLogger.DisableLog("rdApp.warning")
+
 # Set up the logger
 log = logging.getLogger("workbench")
 
 
-def compute_morgan_fingerprints(df: pd.DataFrame, radius=2, n_bits=2048, counts=True) -> pd.DataFrame:
-    """Compute and add Morgan fingerprints to the DataFrame.
+def compute_morgan_fingerprints(df: pd.DataFrame, radius: int = 2, n_bits: int = 2048) -> pd.DataFrame:
+    """Compute Morgan count fingerprints for ADMET modeling.
+
+    Generates true count fingerprints where each bit position contains the
+    number of times that substructure appears in the molecule (clamped to 0-255).
+    This is the recommended approach for ADMET prediction per 2025 research.
 
     Args:
-        df (pd.DataFrame): Input DataFrame containing SMILES strings.
-        radius (int): Radius for the Morgan fingerprint.
-        n_bits (int): Number of bits for the fingerprint.
-        counts (bool): Count simulation for the fingerprint.
+        df: Input DataFrame containing SMILES strings.
+        radius: Radius for the Morgan fingerprint (default 2 = ECFP4 equivalent).
+        n_bits: Number of bits for the fingerprint (default 2048).
 
     Returns:
-        pd.DataFrame: The input DataFrame with the Morgan fingerprints added as bit strings.
+        pd.DataFrame: Input DataFrame with 'fingerprint' column added.
+                      Values are comma-separated uint8 counts.
 
     Note:
-        See: https://greglandrum.github.io/rdkit-blog/posts/2021-07-06-simulating-counts.html
+        Count fingerprints outperform binary for ADMET prediction.
+        See: https://pubs.acs.org/doi/10.1021/acs.est.3c02198
     """
     delete_mol_column = False
 
@@ -39,7 +56,7 @@ def compute_morgan_fingerprints(df: pd.DataFrame, radius=2, n_bits=2048, counts=
         log.warning("Detected serialized molecules in 'molecule' column. Removing...")
         del df["molecule"]
 
-    # Convert SMILES to RDKit molecule objects (vectorized)
+    # Convert SMILES to RDKit molecule objects
     if "molecule" not in df.columns:
         log.info("Converting SMILES to RDKit Molecules...")
         delete_mol_column = True
@@ -47,23 +64,32 @@ def compute_morgan_fingerprints(df: pd.DataFrame, radius=2, n_bits=2048, counts=
         # Make sure our molecules are not None
         failed_smiles = df[df["molecule"].isnull()][smiles_column].tolist()
         if failed_smiles:
-            log.error(f"Failed to convert the following SMILES to molecules: {failed_smiles}")
-        df = df.dropna(subset=["molecule"])
+            log.warning(f"Failed to convert {len(failed_smiles)} SMILES to molecules ({failed_smiles})")
+        df = df.dropna(subset=["molecule"]).copy()
 
     # If we have fragments in our compounds, get the largest fragment before computing fingerprints
     largest_frags = df["molecule"].apply(
         lambda mol: rdMolStandardize.LargestFragmentChooser().choose(mol) if mol else None
     )
 
-    # Create a Morgan fingerprint generator
-    if counts:
-        n_bits *= 4  # Multiply by 4 to simulate counts
-    morgan_generator = rdFingerprintGenerator.GetMorganGenerator(radius=radius, fpSize=n_bits, countSimulation=counts)
+    def mol_to_count_string(mol):
+        """Convert molecule to comma-separated count fingerprint string."""
+        if mol is None:
+            return pd.NA
 
-    # Compute Morgan fingerprints (vectorized)
-    fingerprints = largest_frags.apply(
-        lambda mol: (morgan_generator.GetFingerprint(mol).ToBitString() if mol else pd.NA)
-    )
+        # Get hashed Morgan fingerprint with counts
+        fp = AllChem.GetHashedMorganFingerprint(mol, radius, nBits=n_bits)
+
+        # Initialize array and populate with counts (clamped to uint8 range)
+        counts = np.zeros(n_bits, dtype=np.uint8)
+        for idx, count in fp.GetNonzeroElements().items():
+            counts[idx] = min(count, 255)
+
+        # Return as comma-separated string
+        return ",".join(map(str, counts))
+
+    # Compute Morgan count fingerprints
+    fingerprints = largest_frags.apply(mol_to_count_string)
 
     # Add the fingerprints to the DataFrame
     df["fingerprint"] = fingerprints
@@ -71,59 +97,62 @@ def compute_morgan_fingerprints(df: pd.DataFrame, radius=2, n_bits=2048, counts=
     # Drop the intermediate 'molecule' column if it was added
     if delete_mol_column:
         del df["molecule"]
+
     return df
 
 
 if __name__ == "__main__":
-    print("Running molecular fingerprint tests...")
-    print("Note: This requires molecular_screening module to be available")
+    print("Running Morgan count fingerprint tests...")
 
     # Test molecules
     test_molecules = {
         "aspirin": "CC(=O)OC1=CC=CC=C1C(=O)O",
         "caffeine": "CN1C=NC2=C1C(=O)N(C(=O)N2C)C",
         "glucose": "C([C@@H]1[C@H]([C@@H]([C@H](C(O1)O)O)O)O)O",  # With stereochemistry
-        "sodium_acetate": "CC(=O)[O-].[Na+]",  # Salt
+        "sodium_acetate": "CC(=O)[O-].[Na+]",  # Salt (largest fragment used)
         "benzene": "c1ccccc1",
         "butene_e": "C/C=C/C",  # E-butene
         "butene_z": "C/C=C\\C",  # Z-butene
     }
 
-    # Test 1: Morgan Fingerprints
-    print("\n1. Testing Morgan fingerprint generation...")
+    # Test 1: Morgan Count Fingerprints (default parameters)
+    print("\n1. Testing Morgan fingerprint generation (radius=2, n_bits=2048)...")
 
     test_df = pd.DataFrame({"SMILES": list(test_molecules.values()), "name": list(test_molecules.keys())})
-
-    fp_df = compute_morgan_fingerprints(test_df.copy(), radius=2, n_bits=512, counts=False)
+    fp_df = compute_morgan_fingerprints(test_df.copy())
 
     print("   Fingerprint generation results:")
     for _, row in fp_df.iterrows():
         fp = row.get("fingerprint", "N/A")
-        fp_len = len(fp) if fp != "N/A" else 0
-        print(f"   {row['name']:15} → {fp_len} bits")
+        if pd.notna(fp):
+            counts = [int(x) for x in fp.split(",")]
+            non_zero = sum(1 for c in counts if c > 0)
+            max_count = max(counts)
+            print(f"   {row['name']:15} → {len(counts)} features, {non_zero} non-zero, max={max_count}")
+        else:
+            print(f"   {row['name']:15} → N/A")
 
-    # Test 2: Different fingerprint parameters
-    print("\n2. Testing different fingerprint parameters...")
+    # Test 2: Different parameters
+    print("\n2. Testing with different parameters (radius=3, n_bits=1024)...")
 
-    # Test with counts enabled
-    fp_counts_df = compute_morgan_fingerprints(test_df.copy(), radius=3, n_bits=256, counts=True)
+    fp_df_custom = compute_morgan_fingerprints(test_df.copy(), radius=3, n_bits=1024)
 
-    print("   With count simulation (256 bits * 4):")
-    for _, row in fp_counts_df.iterrows():
+    for _, row in fp_df_custom.iterrows():
         fp = row.get("fingerprint", "N/A")
-        fp_len = len(fp) if fp != "N/A" else 0
-        print(f"   {row['name']:15} → {fp_len} bits")
+        if pd.notna(fp):
+            counts = [int(x) for x in fp.split(",")]
+            non_zero = sum(1 for c in counts if c > 0)
+            print(f"   {row['name']:15} → {len(counts)} features, {non_zero} non-zero")
+        else:
+            print(f"   {row['name']:15} → N/A")
 
     # Test 3: Edge cases
     print("\n3. Testing edge cases...")
 
     # Invalid SMILES
     invalid_df = pd.DataFrame({"SMILES": ["INVALID", ""]})
-    try:
-        fp_invalid = compute_morgan_fingerprints(invalid_df.copy())
-        print(f"   ✓ Invalid SMILES handled: {len(fp_invalid)} valid molecules")
-    except Exception as e:
-        print(f"   ✓ Invalid SMILES properly raised error: {type(e).__name__}")
+    fp_invalid = compute_morgan_fingerprints(invalid_df.copy())
+    print(f"   ✓ Invalid SMILES handled: {len(fp_invalid)} rows returned")
 
     # Test with pre-existing molecule column
     mol_df = test_df.copy()
@@ -131,4 +160,16 @@ if __name__ == "__main__":
     fp_with_mol = compute_morgan_fingerprints(mol_df)
     print(f"   ✓ Pre-existing molecule column handled: {len(fp_with_mol)} fingerprints generated")
 
+    # Test 4: Verify count values are reasonable
+    print("\n4. Verifying count distribution...")
+    all_counts = []
+    for _, row in fp_df.iterrows():
+        fp = row.get("fingerprint", "N/A")
+        if pd.notna(fp):
+            counts = [int(x) for x in fp.split(",")]
+            all_counts.extend([c for c in counts if c > 0])
+
+    if all_counts:
+        print(f"   Non-zero counts: min={min(all_counts)}, max={max(all_counts)}, mean={np.mean(all_counts):.2f}")
+
     print("\n✅ All fingerprint tests completed!")

workbench/utils/chem_utils/projections.py

@@ -17,18 +17,28 @@ log = logging.getLogger("workbench")
 
 def fingerprints_to_matrix(fingerprints, dtype=np.uint8):
     """
-    Convert bitstring fingerprints to numpy matrix.
+    Convert fingerprints to numpy matrix.
+
+    Supports two formats (auto-detected):
+        - Bitstrings: "10110010..." → matrix of 0s and 1s
+        - Count vectors: "0,3,0,1,5,..." → matrix of counts (or binary if dtype=np.bool_)
 
     Args:
-        fingerprints: pandas Series or list of bitstring fingerprints
-        dtype: numpy data type (uint8 is default: np.bool_ is good for Jaccard computations
+        fingerprints: pandas Series or list of fingerprints
+        dtype: numpy data type (uint8 is default; np.bool_ for Jaccard computations)
 
     Returns:
         dense numpy array of shape (n_molecules, n_bits)
     """
-
-    # Dense matrix representation (we might support sparse in the future)
-    return np.array([list(fp) for fp in fingerprints], dtype=dtype)
+    # Auto-detect format based on first fingerprint
+    sample = str(fingerprints.iloc[0] if hasattr(fingerprints, "iloc") else fingerprints[0])
+    if "," in sample:
+        # Count vector format: comma-separated integers
+        matrix = np.array([list(map(int, fp.split(","))) for fp in fingerprints], dtype=dtype)
+    else:
+        # Bitstring format: each character is a bit
+        matrix = np.array([list(fp) for fp in fingerprints], dtype=dtype)
+    return matrix
 
 
 def project_fingerprints(df: pd.DataFrame, projection: str = "UMAP") -> pd.DataFrame: