workbench 0.8.214__tar.gz → 0.8.218__tar.gz

{workbench-0.8.214 → workbench-0.8.218}/PKG-INFO

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

{workbench-0.8.214 → workbench-0.8.218}/docs/api_classes/endpoint.md

@@ -28,7 +28,7 @@ results_df = endpoint.inference(df)
 results_df = endpoint.inference(df, capture=True)
 
 # Run inference/predictions using the FeatureSet evaluation data
-results_df = endpoint.auto_inference(capture=True)
+results_df = endpoint.auto_inference()
 ```
 
 **Output**

{workbench-0.8.214 → workbench-0.8.218}/docs/core_classes/transforms/features_to_model.md

@@ -116,7 +116,7 @@ model = Model("my-custom-model")
 end = model.to_endpoint()   # Note: This takes a while
 
 # Now run inference on my custom model :)
-end.auto_inference(capture=True)
+end.auto_inference()
 
 # Run inference with my own dataframe
 df = fs.pull_dataframe()  # Or whatever dataframe

{workbench-0.8.214 → workbench-0.8.218}/examples/endpoint/endpoint_inference.py

@@ -15,4 +15,4 @@ results_df = endpoint.inference(df)
 results_df = endpoint.inference(df, capture_name="test_inference")
 
 # Run inference/predictions using the FeatureSet evaluation data
-results_df = endpoint.auto_inference(capture=True)
+results_df = endpoint.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/ml_pipelines/wine_classifier.py

@@ -37,5 +37,5 @@ if __name__ == "__main__":
     end = m.to_endpoint("wine-classification", tags=["wine", "classification"])
 
     # Run inference on the endpoint
-    end.auto_inference(capture=True)
+    end.auto_inference()
     end.set_owner("test")

workbench-0.8.218/examples/models/chemprop.py

@@ -0,0 +1,140 @@
+from workbench.api import FeatureSet, Model, ModelType, ModelFramework, Endpoint
+
+# Recreate Flag in case you want to recreate the artifacts
+recreate = False
+
+# =============================================================================
+# Single-Target Chemprop Regression Model
+# =============================================================================
+if recreate or not Model("open-admet-chemprop-logd").exists():
+    feature_set = FeatureSet("open_admet_all")
+    m = feature_set.to_model(
+        name="open-admet-chemprop-logd",
+        model_type=ModelType.UQ_REGRESSOR,
+        model_framework=ModelFramework.CHEMPROP,
+        target_column="logd",  # Single target (string)
+        feature_list=["smiles"],
+        description="Single-target Chemprop Regression Model for LogD",
+        tags=["chemprop", "open_admet"],
+    )
+    m.set_owner("BW")
+
+# Create an Endpoint for the Regression Model
+if recreate or not Endpoint("open-admet-chemprop-logd").exists():
+    m = Model("open-admet-chemprop-logd")
+    end = m.to_endpoint(tags=["chemprop", "open_admet"])
+    end.set_owner("BW")
+    end.auto_inference()
+    end.cross_fold_inference()
+
+# =============================================================================
+# Hybrid ChemProp Model (SMILES + Molecular Descriptors)
+# =============================================================================
+# This example shows how to combine ChemProp's learned molecular representations
+# with pre-computed molecular descriptors (RDKit/Mordred features).
+# The extra features are concatenated with the MPNN output before the FFN.
+
+# Top 10 SHAP features from LogD XGBoost model (provides complementary information to MPNN)
+TOP_LOGD_SHAP_FEATURES = [
+    "mollogp",
+    "fr_halogen",
+    "peoe_vsa6",
+    "nbase",
+    "peoe_vsa7",
+    "peoe_vsa9",
+    "peoe_vsa1",
+    "mi",
+    "bcut2d_mrlow",
+    "slogp_vsa1",
+]
+
+if recreate or not Model("open-admet-chemprop-logd-hybrid").exists():
+    feature_set = FeatureSet("open_admet_logd")
+
+    # Hybrid mode: SMILES + top molecular descriptors
+    # The template auto-detects extra features beyond the SMILES column
+    hybrid_features = ["smiles"] + TOP_LOGD_SHAP_FEATURES
+
+    m = feature_set.to_model(
+        name="open-admet-chemprop-logd-hybrid",
+        model_type=ModelType.UQ_REGRESSOR,
+        model_framework=ModelFramework.CHEMPROP,
+        target_column="logd",
+        feature_list=hybrid_features,
+        description="Hybrid ChemProp model combining D-MPNN with top SHAP molecular descriptors",
+        tags=["chemprop", "open_admet", "hybrid"],
+    )
+    m.set_owner("BW")
+
+# Create an Endpoint for the Hybrid Model
+if recreate or not Endpoint("open-admet-chemprop-logd-hybrid").exists():
+    m = Model("open-admet-chemprop-logd-hybrid")
+    end = m.to_endpoint(tags=["chemprop", "open_admet", "hybrid"])
+    end.set_owner("BW")
+    end.auto_inference()
+    end.cross_fold_inference()
+
+# =============================================================================
+# Chemprop Classification Model
+# =============================================================================
+if recreate or not Model("aqsol-class-chemprop").exists():
+    feature_set = FeatureSet("aqsol_features")
+    m = feature_set.to_model(
+        name="aqsol-class-chemprop",
+        model_type=ModelType.CLASSIFIER,
+        model_framework=ModelFramework.CHEMPROP,
+        target_column="solubility_class",
+        feature_list=["smiles"],
+        description="Classification ChemProp model AQSol solubility classes",
+        tags=["chemprop", "aqsol", "class"],
+    )
+    m.set_owner("BW")
+    m.set_class_labels(["low", "medium", "high"])
+
+# Create an Endpoint for the Multi-Task Regression Model
+if recreate or not Endpoint("aqsol-class-chemprop").exists():
+    m = Model("aqsol-class-chemprop")
+    end = m.to_endpoint(tags=["chemprop", "aqsol", "class"])
+    end.set_owner("BW")
+    end.auto_inference()
+    end.cross_fold_inference()
+
+# =============================================================================
+# Multi-Target Chemprop Regression Model (Open ADMET)
+# =============================================================================
+# This example shows how to train a multi-task model predicting all 9 ADMET endpoints
+# from the Open ADMET challenge: logd, ksol, hlm_clint, mlm_clint, caco_2_papp_a_b,
+# caco_2_efflux, mppb, mbpb, mgmb
+
+ADMET_TARGETS = [
+    "logd",
+    "ksol",
+    "hlm_clint",
+    "mlm_clint",
+    "caco_2_papp_a_b",
+    "caco_2_efflux",
+    "mppb",
+    "mbpb",
+    "mgmb",
+]
+
+if recreate or not Model("open-admet-chemprop-mt").exists():
+    feature_set = FeatureSet("open_admet_all")
+    m = feature_set.to_model(
+        name="open-admet-chemprop-mt",
+        model_type=ModelType.REGRESSOR,
+        model_framework=ModelFramework.CHEMPROP,
+        target_column=ADMET_TARGETS,  # Multi-task: list of 9 targets
+        feature_list=["smiles"],
+        description="Multi-task ChemProp model for 9 ADMET endpoints",
+        tags=["chemprop", "open_admet", "multitask"],
+    )
+    m.set_owner("BW")
+
+# Create an Endpoint for the Multi-Task Regression Model
+if recreate or not Endpoint("open-admet-chemprop-mt").exists():
+    m = Model("open-admet-chemprop-mt")
+    end = m.to_endpoint(tags=["chemprop", "open_admet", "multitask"])
+    end.set_owner("BW")
+    end.auto_inference()
+    end.cross_fold_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/custom_model.py

@@ -21,4 +21,4 @@ my_model = Model("smiles-to-taut-md-stereo-v0")
 endpoint = my_model.to_endpoint(name="smiles-to-taut-md-stereo-v0", tags=["smiles", "molecular descriptors"])
 
 # Run auto-inference on the Endpoint
-endpoint.auto_inference(capture=True)
+endpoint.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/dbscan.py

@@ -24,4 +24,4 @@ my_model = Model("abalone-clusters")
 endpoint = my_model.to_endpoint(name="abalone-clusters", tags=["abalone", "clusters"])
 
 # Run auto-inference on the Endpoint
-endpoint.auto_inference(capture=True)
+endpoint.auto_inference()

workbench-0.8.218/examples/models/meta_model.py

@@ -0,0 +1,34 @@
+from workbench.api import MetaModel, Endpoint
+
+# Recreate Flag in case you want to recreate the artifacts
+recreate = True
+
+# =============================================================================
+# Meta Model: Ensemble of XGBoost, PyTorch, and ChemProp for LogD
+# =============================================================================
+# This meta model aggregates predictions from different model architectures,
+# using model-weighted voting to combine their outputs.
+
+# Child endpoints that this meta model will call
+CHILD_ENDPOINTS = [
+    "logd-reg-pytorch",
+    "logd-reg-chemprop",
+]
+
+if recreate or not MetaModel("logd-meta").exists():
+    m = MetaModel.create(
+        name="logd-meta",
+        child_endpoints=CHILD_ENDPOINTS,
+        target_column="logd",
+        description="Meta model combining XGBoost, PyTorch, and ChemProp for LogD prediction",
+        tags=["meta", "open_admet", "logd"],
+    )
+    m.set_owner("BW")
+
+# Create an Endpoint for the Meta Model
+if recreate or not Endpoint("logd-meta").exists():
+    m = MetaModel("logd-meta")
+    end = m.to_endpoint(tags=["meta", "open_admet", "logd"])
+    end.set_owner("BW")
+    end.auto_inference()
+    end.full_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/pytorch.py

@@ -10,10 +10,10 @@ target = model.target()
 recreate = False
 
 # PyTorch Regression Model
-if recreate or not Model("aqsol-pytorch-reg").exists():
+if recreate or not Model("aqsol-reg-pytorch").exists():
     feature_set = FeatureSet("aqsol_features")
     m = feature_set.to_model(
-        name="aqsol-pytorch-reg",
+        name="aqsol-reg-pytorch",
         model_type=ModelType.UQ_REGRESSOR,
         model_framework=ModelFramework.PYTORCH,
         feature_list=feature_list,
@@ -25,19 +25,19 @@ if recreate or not Model("aqsol-pytorch-reg").exists():
     m.set_owner("BW")
 
 # Create an Endpoint for the Regression Model
-if recreate or not Endpoint("aqsol-pytorch-reg").exists():
-    m = Model("aqsol-pytorch-reg")
+if recreate or not Endpoint("aqsol-reg-pytorch").exists():
+    m = Model("aqsol-reg-pytorch")
     end = m.to_endpoint(tags=["pytorch", "molecular descriptors"])
     end.set_owner("BW")
 
     # Run inference on the endpoint
-    end.auto_inference(capture=True)
+    end.auto_inference()
 
 # Pytorch Classification Model
-if recreate or not Model("aqsol-pytorch-class").exists():
+if recreate or not Model("aqsol-class-pytorch").exists():
     feature_set = FeatureSet("aqsol_features")
     m = feature_set.to_model(
-        name="aqsol-pytorch-class",
+        name="aqsol-class-pytorch",
         model_type=ModelType.CLASSIFIER,
         model_framework=ModelFramework.PYTORCH,
         feature_list=feature_list,
@@ -49,10 +49,10 @@ if recreate or not Model("aqsol-pytorch-class").exists():
     m.set_class_labels(["low", "medium", "high"])
 
 # Create an Endpoint for the Classification Model
-if recreate or not Endpoint("aqsol-pytorch-class").exists():
-    m = Model("aqsol-pytorch-class")
+if recreate or not Endpoint("aqsol-class-pytorch").exists():
+    m = Model("aqsol-class-pytorch")
     end = m.to_endpoint(tags=["pytorch", "molecular descriptors"])
     end.set_owner("BW")
 
     # Run inference on the endpoint
-    end.auto_inference(capture=True)
+    end.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/smiles_to_md_v1.py

@@ -24,4 +24,4 @@ model = feature_set.to_model(
 end = model.to_endpoint(tags=tags, mem_size=4096, max_concurrency=10)
 
 # Run inference on the endpoint
-end.auto_inference(capture=True)
+end.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/uq/bayesian_ridge.py

@@ -28,4 +28,4 @@ my_model = fs.to_model(
 end = my_model.to_endpoint(tags=["aqsol", "bayesian"])
 
 # Run auto-inference on the Endpoint
-end.auto_inference(capture=True)
+end.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/uq/ensemble_xgb.py

@@ -28,4 +28,4 @@ my_model = fs.to_model(
 end = my_model.to_endpoint(tags=["aqsol", "ensemble", "uq"])
 
 # Run auto-inference on the AQSol Ensemble/UQ Endpoint
-end.auto_inference(capture=True)
+end.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/uq/gaussian_process.py

@@ -35,4 +35,4 @@ my_model = Model("aqsol-gaussian-reg")
 endpoint = my_model.to_endpoint(tags=["aqsol", "gaussian"])
 
 # Run auto-inference on the Endpoint
-endpoint.auto_inference(capture=True)
+endpoint.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/uq/meta_uq.py

@@ -36,4 +36,4 @@ my_model = Model("aqsol-meta-uq")
 endpoint = my_model.to_endpoint(tags=["aqsol", "meta-uq"])
 
 # Run auto-inference on the Endpoint
-endpoint.auto_inference(capture=True)
+endpoint.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/uq/ngboost.py

@@ -35,4 +35,4 @@ my_model = Model("aqsol-ngboost-reg")
 endpoint = my_model.to_endpoint(tags=["aqsol", "ngboost"])
 
 # Run auto-inference on the Endpoint
-endpoint.auto_inference(capture=True)
+endpoint.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/uq/quant_xgb.py

@@ -23,4 +23,4 @@ my_model = fs.to_model(
 end = my_model.to_endpoint(tags=["aqsol", "quantiles"])
 
 # Run auto-inference on the AQSol Quantile Regression Endpoint
-end.auto_inference(capture=True)
+end.auto_inference()

{workbench-0.8.214 → workbench-0.8.218}/examples/models/xgb_model.py

@@ -48,7 +48,7 @@ if recreate or not Endpoint("aqsol-regression").exists():
     end.set_owner("BW")
 
     # Run inference on the endpoint
-    end.auto_inference(capture=True)
+    end.auto_inference()
     end.cross_fold_inference()
 
 # XGBoost Classification Model
@@ -72,5 +72,5 @@ if recreate or not Endpoint("aqsol-class").exists():
     end.set_owner("BW")
 
     # Run inference on the endpoint
-    end.auto_inference(capture=True)
+    end.auto_inference()
     end.cross_fold_inference()

workbench-0.8.218/experiments/cleanlab_bug_report.py

@@ -0,0 +1,17 @@
+"""Minimal reproduction of cleanlab Datalab regression bug."""
+
+import sys
+from cleanlab import Datalab
+import cleanlab
+import datasets
+
+print(f"Python: {sys.version}")
+print(f"cleanlab: {cleanlab.__version__}")
+print(f"datasets: {datasets.__version__}")
+
+print("\n" + "=" * 60)
+print("Attempting to create Datalab with task='regression'...")
+print("=" * 60)
+
+data = {"X": [0, 1, 2], "y": [0.1, 0.5, 0.9]}
+lab = Datalab(data, label_name="y", task="regression")

{workbench-0.8.214 → workbench-0.8.218}/experiments/sol_pipeline.py

@@ -116,4 +116,4 @@ if __name__ == "__main__":
         m = Model(model_name)
         m.to_endpoint(name=endpoint_name, tags=endpoint_tags)
         end = Endpoint(endpoint_name)
-        end.auto_inference(capture=True)
+        end.auto_inference()

workbench-0.8.218/feature_endpoints/model_scripts/rdkit_mordred_model_script.py

@@ -0,0 +1,90 @@
+# Model: rdkit_mordred_model_script (
+#
+# Description: The molecular_descriptors model uses RDKit and Mordred to compute a wide array of
+#     molecular descriptors from SMILES strings. These descriptors quantify various chemical properties
+#     and structural features, providing critical insights for cheminformatics applications such as
+#     QSAR modeling and drug discovery.
+#
+import argparse
+import os
+from io import StringIO
+import pandas as pd
+import json
+
+# Local imports
+from molecular_utils.mol_standardize import standardize
+from molecular_utils.mol_descriptors import compute_descriptors
+
+
+# TRAINING SECTION
+#
+# This section (__main__) is where SageMaker will execute the training job
+# and save the model artifacts to the model directory.
+#
+if __name__ == "__main__":
+    # Script arguments for input/output directories
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR", "/opt/ml/model"))
+    parser.add_argument(
+        "--train",
+        type=str,
+        default=os.environ.get("SM_CHANNEL_TRAIN", "/opt/ml/input/data/train"),
+    )
+    parser.add_argument(
+        "--output-data-dir",
+        type=str,
+        default=os.environ.get("SM_OUTPUT_DATA_DIR", "/opt/ml/output/data"),
+    )
+    args = parser.parse_args()
+
+    # This model doesn't get trained, it just a feature creation 'model'
+    # So we don't need to do anything here
+
+
+# Model loading and prediction functions
+def model_fn(model_dir):
+    return None
+
+
+def input_fn(input_data, content_type):
+    """Parse input data and return a DataFrame."""
+    if not input_data:
+        raise ValueError("Empty input data is not supported!")
+
+    # Decode bytes to string if necessary
+    if isinstance(input_data, bytes):
+        input_data = input_data.decode("utf-8")
+
+    if "text/csv" in content_type:
+        return pd.read_csv(StringIO(input_data))
+    elif "application/json" in content_type:
+        return pd.DataFrame(json.loads(input_data))  # Assumes JSON array of records
+    else:
+        raise ValueError(f"{content_type} not supported!")
+
+
+def output_fn(output_df, accept_type):
+    """Supports both CSV and JSON output formats."""
+    use_explicit_na = False
+    if "text/csv" in accept_type:
+        if use_explicit_na:
+            csv_output = output_df.fillna("N/A").to_csv(index=False)  # CSV with N/A for missing values
+        else:
+            csv_output = output_df.to_csv(index=False)
+        return csv_output, "text/csv"
+    elif "application/json" in accept_type:
+        return (
+            output_df.to_json(orient="records"),
+            "application/json",
+        )  # JSON array of records (NaNs -> null)
+    else:
+        raise RuntimeError(f"{accept_type} accept type is not supported by this script.")
+
+
+# Prediction function
+def predict_fn(df, model):
+
+    # Standardize the molecule (extract salts) and then compute descriptors
+    df = standardize(df, extract_salts=True)
+    df = compute_descriptors(df)
+    return df

workbench-0.8.218/feature_endpoints/model_scripts/rdkit_mordred_model_script_keep_salts.py

@@ -0,0 +1,90 @@
+# Model: molecular_descriptors
+#
+# Description: The molecular_descriptors model uses RDKit and Mordred to compute a wide array of
+#     molecular descriptors from SMILES strings. These descriptors quantify various chemical properties
+#     and structural features, providing critical insights for cheminformatics applications such as
+#     QSAR modeling and drug discovery.
+#
+import argparse
+import os
+from io import StringIO
+import pandas as pd
+import json
+
+# Local imports
+from molecular_utils.mol_standardize import standardize
+from molecular_utils.mol_descriptors import compute_descriptors
+
+
+# TRAINING SECTION
+#
+# This section (__main__) is where SageMaker will execute the training job
+# and save the model artifacts to the model directory.
+#
+if __name__ == "__main__":
+    # Script arguments for input/output directories
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-dir", type=str, default=os.environ.get("SM_MODEL_DIR", "/opt/ml/model"))
+    parser.add_argument(
+        "--train",
+        type=str,
+        default=os.environ.get("SM_CHANNEL_TRAIN", "/opt/ml/input/data/train"),
+    )
+    parser.add_argument(
+        "--output-data-dir",
+        type=str,
+        default=os.environ.get("SM_OUTPUT_DATA_DIR", "/opt/ml/output/data"),
+    )
+    args = parser.parse_args()
+
+    # This model doesn't get trained, it just a feature creation 'model'
+    # So we don't need to do anything here
+
+
+# Model loading and prediction functions
+def model_fn(model_dir):
+    return None
+
+
+def input_fn(input_data, content_type):
+    """Parse input data and return a DataFrame."""
+    if not input_data:
+        raise ValueError("Empty input data is not supported!")
+
+    # Decode bytes to string if necessary
+    if isinstance(input_data, bytes):
+        input_data = input_data.decode("utf-8")
+
+    if "text/csv" in content_type:
+        return pd.read_csv(StringIO(input_data))
+    elif "application/json" in content_type:
+        return pd.DataFrame(json.loads(input_data))  # Assumes JSON array of records
+    else:
+        raise ValueError(f"{content_type} not supported!")
+
+
+def output_fn(output_df, accept_type):
+    """Supports both CSV and JSON output formats."""
+    use_explicit_na = False
+    if "text/csv" in accept_type:
+        if use_explicit_na:
+            csv_output = output_df.fillna("N/A").to_csv(index=False)  # CSV with N/A for missing values
+        else:
+            csv_output = output_df.to_csv(index=False)
+        return csv_output, "text/csv"
+    elif "application/json" in accept_type:
+        return (
+            output_df.to_json(orient="records"),
+            "application/json",
+        )  # JSON array of records (NaNs -> null)
+    else:
+        raise RuntimeError(f"{accept_type} accept type is not supported by this script.")
+
+
+# Prediction function
+def predict_fn(df, model):
+
+    # Standardize the molecule (DON'T extract salts) and then compute descriptors
+    df = standardize(df, extract_salts=False)
+    df = compute_descriptors(df)
+    return df

workbench-0.8.218/feature_endpoints/model_scripts/requirements.txt

@@ -0,0 +1,2 @@
+rdkit==2025.3.6
+mordredcommunity>=2.0.6

workbench-0.8.218/feature_endpoints/rdkit_mordred_keep_salts_v1.py

@@ -0,0 +1,66 @@
+"""Create the SMILES to Standardize/Tautomer + RDKIT + Mordred Model + Endpoint
+   Note: This version KEEPS salts in the molecules.
+
+Description:
+   Feature Endpoint that takes a SMILES string and
+   computes RDKIT + Mordred Molecular Descriptors
+
+Created Artifacts:
+
+    Models:
+        - smiles-to-taut-md-stereo-v1-keep-salts
+
+    Endpoints:
+        - smiles-to-taut-md-stereo-v1-keep-salts
+"""
+
+import os
+import awswrangler as wr
+
+# Workbench Imports
+from workbench.api import FeatureSet, ModelType
+from workbench.core.transforms.pandas_transforms import PandasToFeatures
+
+
+if __name__ == "__main__":
+
+    # Serverless and Instance types
+    serverless = os.environ.get("SERVERLESS", "True").lower() == "true"
+
+    # Pull in the custom script path
+    script_path = "model_scripts/rdkit_mordred_model_script_keep_salts.py"
+
+    # Check if we have an existing FeatureSet, if not create one
+    if not FeatureSet("feature_endpoint_fs").exists():
+        s3_path = "s3://workbench-public-data/comp_chem/aqsol_public_data.csv"
+        aqsol_data = wr.s3.read_csv(s3_path)
+        aqsol_data.columns = aqsol_data.columns.str.lower()
+
+        to_features = PandasToFeatures("feature_endpoint_fs")
+        to_features.set_input(aqsol_data, id_column="id")
+        to_features.set_output_tags(["aqsol", "public"])
+        to_features.transform()
+        fs = FeatureSet("feature_endpoint_fs")
+        fs.set_owner("FeatureEndpoint")
+
+    # Grab our FeatureSet
+    feature_set = FeatureSet("feature_endpoint_fs")
+    tags = ["smiles", "molecular descriptors", "tautomerized", "stereo"]
+    model = feature_set.to_model(
+        name="smiles-to-taut-md-stereo-v1-keep-salts",
+        model_type=ModelType.TRANSFORMER,
+        feature_list=["smiles"],
+        description="Smiles to Molecular Descriptors",
+        tags=tags,
+        custom_script=script_path,
+    )
+    model.set_owner("BW")
+
+    # Create the endpoint for the model
+    if serverless:
+        end = model.to_endpoint(tags=tags, serverless=True, mem_size=4096, max_concurrency=5)
+    else:
+        end = model.to_endpoint(tags=tags, serverless=False, instance="ml.c7i.large")
+
+    # Run inference on the endpoint
+    end.inference(feature_set.pull_dataframe()[:100])