workbench 0.8.210__tar.gz → 0.8.214__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workbench
-Version: 0.8.210
+Version: 0.8.214
 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
@@ -47,6 +47,7 @@ Requires-Dist: cryptography>=44.0.2
 Requires-Dist: ipython>=8.37.0
 Requires-Dist: pyreadline3; sys_platform == "win32"
 Requires-Dist: scikit-learn>=1.5.2
+Requires-Dist: umap-learn>=0.5.8
 Requires-Dist: xgboost>=3.0.3
 Requires-Dist: joblib>=1.3.2
 Requires-Dist: requests>=2.26.0
@@ -55,7 +56,7 @@ Requires-Dist: mordredcommunity>=2.0.6
 Requires-Dist: workbench-bridges>=0.1.16
 Provides-Extra: ui
 Requires-Dist: plotly>=6.0.0; extra == "ui"
-Requires-Dist: dash>3.0.0; extra == "ui"
+Requires-Dist: dash>=3.0.0; extra == "ui"
 Requires-Dist: dash-bootstrap-components>=1.6.0; extra == "ui"
 Requires-Dist: dash-bootstrap-templates>=1.3.0; extra == "ui"
 Requires-Dist: dash_ag_grid; extra == "ui"
@@ -70,8 +71,8 @@ Requires-Dist: flake8; extra == "dev"
 Requires-Dist: black; extra == "dev"
 Provides-Extra: all
 Requires-Dist: networkx>=3.2; extra == "all"
-Requires-Dist: plotly>=5.18.0; extra == "all"
-Requires-Dist: dash<3.0.0,>=2.16.1; extra == "all"
+Requires-Dist: plotly>=6.0.0; extra == "all"
+Requires-Dist: dash>=3.0.0; extra == "all"
 Requires-Dist: dash-bootstrap-components>=1.6.0; extra == "all"
 Requires-Dist: dash-bootstrap-templates>=1.3.0; extra == "all"
 Requires-Dist: dash_ag_grid; extra == "all"

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

@@ -15,7 +15,7 @@ if recreate or not Model("aqsol-pytorch-reg").exists():
     m = feature_set.to_model(
         name="aqsol-pytorch-reg",
         model_type=ModelType.UQ_REGRESSOR,
-        model_framework=ModelFramework.PYTORCH_TABULAR,
+        model_framework=ModelFramework.PYTORCH,
         feature_list=feature_list,
         target_column=target,
         description="PyTorch Regression Model for AQSol",
@@ -39,12 +39,11 @@ if recreate or not Model("aqsol-pytorch-class").exists():
     m = feature_set.to_model(
         name="aqsol-pytorch-class",
         model_type=ModelType.CLASSIFIER,
-        model_framework=ModelFramework.PYTORCH_TABULAR,
+        model_framework=ModelFramework.PYTORCH,
         feature_list=feature_list,
         target_column="solubility_class",
         description="PyTorch Classification Model for AQSol",
         tags=["pytorch", "molecular descriptors"],
-        hyperparameters={"max_epochs": 150, "layers": "256-128-64"},
     )
     m.set_owner("BW")
     m.set_class_labels(["low", "medium", "high"])

workbench-0.8.214/experiments/chem_info/knn_sims.py

@@ -0,0 +1,22 @@
+# Workbench Imports
+from workbench.api.df_store import DFStore
+from workbench.algorithms.dataframe.fingerprint_proximity import FingerprintProximity
+
+# Grab tox21 dataset (only 10)
+tox_df = DFStore().get("/datasets/chem_info/tox21_10")
+# tox_df = tox_df.sample(100)
+
+# Compute FingerprintProximity (auto-computes fingerprints from SMILES)
+prox = FingerprintProximity(tox_df, id_column="id")
+
+# Get all neighbors for the first 3 compounds
+all_ids = prox.df["id"].tolist()[:3]
+neighbors_df = prox.neighbors(all_ids, n_neighbors=5)
+print("\nNeighbors for first 3 compounds:")
+print(neighbors_df.head(20))
+
+# Query for neighbors for a specific compound
+query_id = prox.df["id"].iloc[1]
+query_neighbors_df = prox.neighbors(query_id, n_neighbors=5)
+print(f"\nKNN: Neighbors for query ID {query_id}:")
+print(query_neighbors_df)

{workbench-0.8.210 → workbench-0.8.214}/model_docker_images/inference/Dockerfile

@@ -5,9 +5,6 @@ COPY requirements.txt /tmp/
 # Install dependencies
 RUN pip install --no-cache-dir -r /tmp/requirements.txt
 
-# MAPIE complains about Python 3.12, install with ignore flag
-RUN pip install --no-cache-dir --ignore-requires-python mapie
-
 FROM python:3.12-slim
 
 # Copy installed packages from builder

{workbench-0.8.210 → workbench-0.8.214}/model_docker_images/inference/requirements.txt

@@ -1,9 +1,10 @@
-fastapi==0.121.0       # FastAPI for serving the model
-uvicorn==0.34.0        # ASGI server for running FastAPI
 scikit-learn==1.7.2
 xgboost==3.1.1
 lightgbm==4.6.0
+mapie==1.2.0
 ngboost==0.5.6
 pandas==2.3.3
 awswrangler==3.14.0
-joblib==1.5.2
+joblib==1.5.2
+fastapi==0.121.0       # FastAPI for serving the model
+uvicorn==0.34.0        # ASGI server for running FastAPI

{workbench-0.8.210 → workbench-0.8.214}/model_docker_images/ml_pipelines/requirements.txt

@@ -4,8 +4,6 @@
 pandas==2.3.3
 awswrangler==3.14.0
 torch==2.9.1
-pytorch-tabular==1.1.1
-requests==2.32.5
 joblib==1.5.2
 boto3==1.40.72
 botocore==1.40.72

{workbench-0.8.210 → workbench-0.8.214}/model_docker_images/pytorch_inference/requirements.txt

@@ -5,10 +5,10 @@
 torch==2.9.1
 pandas==2.3.3
 awswrangler==3.14.0
-pytorch-tabular==1.1.1
-requests==2.32.5  # Needed by PyTorch-Tabular
-joblib==1.5.2
-fastapi==0.122.0  # FastAPI for serving the model
-uvicorn==0.38.0   # ASGI server for running FastAPI
+lightgbm==4.6.0
+mapie==1.2.0
+joblib==1.5.3
 chemprop==2.2.1   # Message Passing Neural Networks for molecular property prediction
-rdkit==2025.9.1   # Cheminformatics toolkit for SMILES processing
+rdkit==2025.9.3   # Cheminformatics toolkit for SMILES processing
+fastapi==0.126.0  # FastAPI for serving the model
+uvicorn==0.38.0   # ASGI server for running FastAPI

{workbench-0.8.210 → workbench-0.8.214}/model_docker_images/pytorch_training/requirements.txt

@@ -5,8 +5,8 @@
 torch==2.9.1
 pandas==2.3.3
 awswrangler==3.14.0
-pytorch-tabular==1.1.1
-requests==2.32.5  # Needed by PyTorch-Tabular
-joblib==1.5.2
+lightgbm==4.6.0
+mapie==1.2.0
+joblib==1.5.3
 chemprop==2.2.1   # Message Passing Neural Networks for molecular property prediction
-rdkit==2025.9.1   # Cheminformatics toolkit for SMILES processing
+rdkit==2025.9.3   # Cheminformatics toolkit for SMILES processing

{workbench-0.8.210 → workbench-0.8.214}/model_docker_images/training/Dockerfile

@@ -13,9 +13,6 @@ COPY requirements.txt /tmp/
 # Install dependencies
 RUN pip install --no-cache-dir -r /tmp/requirements.txt
 
-# MAPIE complains about Python 3.12, install with ignore flag
-RUN pip install --no-cache-dir --ignore-requires-python mapie
-
 # Copy the SageMaker entrypoint script
 COPY sagemaker_entrypoint.py /opt/program/
 WORKDIR /opt/program

{workbench-0.8.210 → workbench-0.8.214}/model_docker_images/training/requirements.txt

@@ -1,6 +1,7 @@
 scikit-learn==1.7.2
 xgboost==3.1.1
 lightgbm==4.6.0
+mapie==1.2.0
 ngboost==0.5.6
 pandas==2.3.3
 awswrangler==3.14.0

{workbench-0.8.210 → workbench-0.8.214}/open_admet/all_models.py

@@ -106,7 +106,7 @@ def create_models_for_featureset(fs_name: str, rdkit_features: list[str]):
         pytorch_model = fs.to_model(
             name=pytorch_model_name,
             model_type=ModelType.UQ_REGRESSOR,
-            model_framework=ModelFramework.PYTORCH_TABULAR,
+            model_framework=ModelFramework.PYTORCH,
             target_column=target,
             feature_list=non_zero_shap,
             description=f"PyTorch Tabular model for {base_name} prediction",

{workbench-0.8.210 → workbench-0.8.214}/pyproject.toml

@@ -36,6 +36,7 @@ dependencies = [
     "ipython >=8.37.0",
     "pyreadline3; sys_platform == 'win32'",
     "scikit-learn >=1.5.2",
+    "umap-learn >=0.5.8",
     "xgboost >=3.0.3",
     "joblib >= 1.3.2",
     "requests >= 2.26.0",
@@ -47,7 +48,7 @@ dependencies = [
 [project.optional-dependencies]
 ui = [
     "plotly>=6.0.0",
-    "dash>3.0.0",
+    "dash>=3.0.0",
     "dash-bootstrap-components>=1.6.0",
     "dash-bootstrap-templates>=1.3.0",
     "dash_ag_grid",
@@ -57,8 +58,8 @@ ui = [
 dev = ["pytest", "pytest-sugar", "coverage", "pytest-cov", "flake8", "black"]
 all = [
     "networkx>=3.2",
-    "plotly>=5.18.0",
-    "dash>=2.16.1,<3.0.0",
+    "plotly>=6.0.0",
+    "dash>=3.0.0",
     "dash-bootstrap-components>=1.6.0",
     "dash-bootstrap-templates>=1.3.0",
     "dash_ag_grid",
@@ -95,6 +96,7 @@ ml_pipeline_batch = "workbench.scripts.ml_pipeline_batch:main"
 ml_pipeline_sqs = "workbench.scripts.ml_pipeline_sqs:main"
 lambda_test = "workbench.scripts.lambda_test:main"
 endpoint_test = "workbench.scripts.endpoint_test:main"
+training_test = "workbench.scripts.training_test:main"
 
 [tool.pytest.ini_options]
 addopts = "-v --cov-report term-missing"

workbench-0.8.214/src/workbench/algorithms/dataframe/feature_space_proximity.py

@@ -0,0 +1,180 @@
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import StandardScaler
+from sklearn.neighbors import NearestNeighbors
+from typing import List, Optional
+import logging
+
+# Workbench Imports
+from workbench.algorithms.dataframe.proximity import Proximity
+from workbench.algorithms.dataframe.projection_2d import Projection2D
+
+# Set up logging
+log = logging.getLogger("workbench")
+
+
+class FeatureSpaceProximity(Proximity):
+    """Proximity computations for numeric feature spaces using Euclidean distance."""
+
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        id_column: str,
+        features: List[str],
+        target: Optional[str] = None,
+        track_columns: Optional[List[str]] = None,
+    ):
+        """
+        Initialize the FeatureSpaceProximity class.
+
+        Args:
+            df: DataFrame containing data for neighbor computations.
+            id_column: Name of the column used as the identifier.
+            features: List of feature column names to be used for neighbor computations.
+            target: Name of the target column. Defaults to None.
+            track_columns: Additional columns to track in results. Defaults to None.
+        """
+        # Validate and filter features before calling parent init
+        self._raw_features = features
+        super().__init__(df, id_column=id_column, features=features, target=target, track_columns=track_columns)
+
+    def _prepare_data(self) -> None:
+        """Filter out non-numeric features and drop NaN rows."""
+        # Validate features
+        self.features = self._validate_features(self.df, self._raw_features)
+
+        # Drop NaN rows for the features we're using
+        self.df = self.df.dropna(subset=self.features).copy()
+
+    def _validate_features(self, df: pd.DataFrame, features: List[str]) -> List[str]:
+        """Remove non-numeric features and log warnings."""
+        non_numeric = [f for f in features if f not in df.select_dtypes(include=["number"]).columns]
+        if non_numeric:
+            log.warning(f"Non-numeric features {non_numeric} aren't currently supported, excluding them")
+        return [f for f in features if f not in non_numeric]
+
+    def _build_model(self) -> None:
+        """Standardize features and fit Nearest Neighbors model."""
+        self.scaler = StandardScaler()
+        X = self.scaler.fit_transform(self.df[self.features])
+        self.nn = NearestNeighbors().fit(X)
+
+    def _transform_features(self, df: pd.DataFrame) -> np.ndarray:
+        """Transform features using the fitted scaler."""
+        return self.scaler.transform(df[self.features])
+
+    def _project_2d(self) -> None:
+        """Project the numeric features to 2D for visualization."""
+        if len(self.features) >= 2:
+            self.df = Projection2D().fit_transform(self.df, features=self.features)
+
+
+# Testing the FeatureSpaceProximity class
+if __name__ == "__main__":
+
+    pd.set_option("display.max_columns", None)
+    pd.set_option("display.width", 1000)
+
+    # Create a sample DataFrame
+    data = {
+        "ID": [1, 2, 3, 4, 5],
+        "Feature1": [0.1, 0.2, 0.3, 0.4, 0.5],
+        "Feature2": [0.5, 0.4, 0.3, 0.2, 0.1],
+        "Feature3": [2.5, 2.4, 2.3, 2.3, np.nan],
+    }
+    df = pd.DataFrame(data)
+
+    # Test the FeatureSpaceProximity class
+    features = ["Feature1", "Feature2", "Feature3"]
+    prox = FeatureSpaceProximity(df, id_column="ID", features=features)
+    print(prox.neighbors(1, n_neighbors=2))
+
+    # Test the neighbors method with radius
+    print(prox.neighbors(1, radius=2.0))
+
+    # Test with Features list
+    prox = FeatureSpaceProximity(df, id_column="ID", features=["Feature1"])
+    print(prox.neighbors(1))
+
+    # Create a sample DataFrame
+    data = {
+        "foo_id": ["a", "b", "c", "d", "e"],  # Testing string IDs
+        "Feature1": [0.1, 0.2, 0.3, 0.4, 0.5],
+        "Feature2": [0.5, 0.4, 0.3, 0.2, 0.1],
+        "target": [1, 0, 1, 0, 5],
+    }
+    df = pd.DataFrame(data)
+
+    # Test with String Ids
+    prox = FeatureSpaceProximity(
+        df,
+        id_column="foo_id",
+        features=["Feature1", "Feature2"],
+        target="target",
+        track_columns=["Feature1", "Feature2"],
+    )
+    print(prox.neighbors(["a", "b"]))
+
+    # Test duplicate IDs
+    data = {
+        "foo_id": ["a", "b", "c", "d", "d"],  # Duplicate ID (d)
+        "Feature1": [0.1, 0.2, 0.3, 0.4, 0.5],
+        "Feature2": [0.5, 0.4, 0.3, 0.2, 0.1],
+        "target": [1, 0, 1, 0, 5],
+    }
+    df = pd.DataFrame(data)
+    prox = FeatureSpaceProximity(df, id_column="foo_id", features=["Feature1", "Feature2"], target="target")
+    print(df.equals(prox.df))
+
+    # Test on real data from Workbench
+    from workbench.api import FeatureSet, Model
+
+    fs = FeatureSet("aqsol_features")
+    model = Model("aqsol-regression")
+    features = model.features()
+    df = fs.pull_dataframe()
+    prox = FeatureSpaceProximity(
+        df, id_column=fs.id_column, features=model.features(), target=model.target(), track_columns=features
+    )
+    print(prox.neighbors(df[fs.id_column].tolist()[:3]))
+
+    print("\n" + "=" * 80)
+    print("Testing isolated_compounds...")
+    print("=" * 80)
+
+    # Test isolated data in the top 1%
+    isolated_1pct = prox.isolated(top_percent=1.0)
+    print(f"\nTop 1% most isolated compounds (n={len(isolated_1pct)}):")
+    print(isolated_1pct[[fs.id_column, "nn_distance", "nn_id"]].head(10))
+
+    # Test isolated data in the top 5%
+    isolated_5pct = prox.isolated(top_percent=5.0)
+    print(f"\nTop 5% most isolated compounds (n={len(isolated_5pct)}):")
+    print(isolated_5pct[[fs.id_column, "nn_distance", "nn_id"]].head(10))
+
+    print("\n" + "=" * 80)
+    print("Testing target_gradients...")
+    print("=" * 80)
+
+    # Test with different parameters
+    gradients_1pct = prox.target_gradients(top_percent=1.0, min_delta=1.0)
+    print(f"\nTop 1% target gradients (min_delta=5.0) (n={len(gradients_1pct)}):")
+    print(
+        gradients_1pct[[fs.id_column, model.target(), "neighbor_median", "neighbor_median_diff", "gradient"]].head(10)
+    )
+
+    gradients_5pct = prox.target_gradients(top_percent=5.0, min_delta=5.0)
+    print(f"\nTop 5% target gradients (min_delta=5.0) (n={len(gradients_5pct)}):")
+    print(
+        gradients_5pct[[fs.id_column, model.target(), "neighbor_median", "neighbor_median_diff", "gradient"]].head(10)
+    )
+
+    # Visualize the 2D projection
+    print("\n" + "=" * 80)
+    print("Visualizing 2D Projection...")
+    print("=" * 80)
+    from workbench.web_interface.components.plugin_unit_test import PluginUnitTest
+    from workbench.web_interface.components.plugins.scatter_plot import ScatterPlot
+
+    unit_test = PluginUnitTest(ScatterPlot, input_data=prox.df[:1000], x="x", y="y")
+    unit_test.run()

workbench-0.8.214/src/workbench/algorithms/dataframe/fingerprint_proximity.py

@@ -0,0 +1,252 @@
+import pandas as pd
+import numpy as np
+from sklearn.neighbors import NearestNeighbors
+from typing import Union, List, Optional
+import logging
+
+# Workbench Imports
+from workbench.algorithms.dataframe.proximity import Proximity
+from workbench.algorithms.dataframe.projection_2d import Projection2D
+from workbench.utils.chem_utils.fingerprints import compute_morgan_fingerprints
+
+# Set up logging
+log = logging.getLogger("workbench")
+
+
+class FingerprintProximity(Proximity):
+    """Proximity computations for binary fingerprints using Jaccard/Tanimoto similarity."""
+
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        id_column: str,
+        fingerprint_column: Optional[str] = None,
+        target: Optional[str] = None,
+        track_columns: Optional[List[str]] = None,
+        radius: int = 2,
+        n_bits: int = 1024,
+        counts: bool = False,
+    ) -> None:
+        """
+        Initialize the FingerprintProximity class for binary fingerprint similarity.
+
+        Args:
+            df: DataFrame containing fingerprints or SMILES.
+            id_column: Name of the column used as an identifier.
+            fingerprint_column: Name of the column containing fingerprints (bit strings).
+                If None, looks for existing "fingerprint" column or computes from SMILES.
+            target: Name of the target column. Defaults to None.
+            track_columns: Additional columns to track in results. Defaults to None.
+            radius: Radius for Morgan fingerprint computation (default: 2).
+            n_bits: Number of bits for fingerprint (default: 1024).
+            counts: Whether to use count simulation (default: False).
+        """
+        # Store fingerprint computation parameters
+        self._fp_radius = radius
+        self._fp_n_bits = n_bits
+        self._fp_counts = counts
+
+        # Store the requested fingerprint column (may be None)
+        self._fingerprint_column_arg = fingerprint_column
+
+        # Determine fingerprint column name (but don't compute yet - that happens in _prepare_data)
+        self.fingerprint_column = self._resolve_fingerprint_column_name(df, fingerprint_column)
+
+        # Call parent constructor with fingerprint_column as the only "feature"
+        super().__init__(
+            df,
+            id_column=id_column,
+            features=[self.fingerprint_column],
+            target=target,
+            track_columns=track_columns,
+        )
+
+    @staticmethod
+    def _resolve_fingerprint_column_name(df: pd.DataFrame, fingerprint_column: Optional[str]) -> str:
+        """
+        Determine the fingerprint column name, validating it exists or can be computed.
+
+        Args:
+            df: Input DataFrame.
+            fingerprint_column: Explicitly specified fingerprint column, or None.
+
+        Returns:
+            Name of the fingerprint column to use.
+
+        Raises:
+            ValueError: If no fingerprint column exists and no SMILES column found.
+        """
+        # If explicitly provided, validate it exists
+        if fingerprint_column is not None:
+            if fingerprint_column not in df.columns:
+                raise ValueError(f"Fingerprint column '{fingerprint_column}' not found in DataFrame")
+            return fingerprint_column
+
+        # Check for existing "fingerprint" column
+        if "fingerprint" in df.columns:
+            log.info("Using existing 'fingerprint' column")
+            return "fingerprint"
+
+        # Will need to compute from SMILES - validate SMILES column exists
+        smiles_column = next((col for col in df.columns if col.lower() == "smiles"), None)
+        if smiles_column is None:
+            raise ValueError(
+                "No fingerprint column provided and no SMILES column found. "
+                "Either provide a fingerprint_column or include a 'smiles' column in the DataFrame."
+            )
+
+        # Fingerprints will be computed in _prepare_data
+        return "fingerprint"
+
+    def _prepare_data(self) -> None:
+        """Compute fingerprints from SMILES if needed."""
+        # If fingerprint column doesn't exist yet, compute it
+        if self.fingerprint_column not in self.df.columns:
+            log.info(f"Computing Morgan fingerprints (radius={self._fp_radius}, n_bits={self._fp_n_bits})...")
+            self.df = compute_morgan_fingerprints(
+                self.df, radius=self._fp_radius, n_bits=self._fp_n_bits, counts=self._fp_counts
+            )
+
+    def _build_model(self) -> None:
+        """
+        Build the fingerprint proximity model using Jaccard metric.
+        Converts fingerprint strings to binary arrays and initializes NearestNeighbors.
+        """
+        log.info("Converting fingerprints to binary feature matrix...")
+
+        # Convert fingerprint strings to binary arrays and store for later use
+        self.X = self._fingerprints_to_matrix(self.df)
+
+        # Use Jaccard distance for binary fingerprints (1 - Tanimoto similarity)
+        # Using BallTree algorithm for better performance with high-dimensional binary data
+        log.info("Computing NearestNeighbors with Jaccard metric (BallTree)...")
+        self.nn = NearestNeighbors(metric="jaccard", algorithm="ball_tree").fit(self.X)
+
+    def _transform_features(self, df: pd.DataFrame) -> np.ndarray:
+        """
+        Transform fingerprints to binary matrix for querying.
+
+        Args:
+            df: DataFrame containing fingerprints to transform.
+
+        Returns:
+            Binary feature matrix for the fingerprints.
+        """
+        return self._fingerprints_to_matrix(df)
+
+    def _fingerprints_to_matrix(self, df: pd.DataFrame) -> np.ndarray:
+        """
+        Convert fingerprint strings to a binary numpy matrix.
+
+        Args:
+            df: DataFrame containing fingerprint column.
+
+        Returns:
+            2D numpy array of binary fingerprint bits.
+        """
+        fingerprint_bits = df[self.fingerprint_column].apply(
+            lambda fp: np.array([int(bit) for bit in fp], dtype=np.bool_)
+        )
+        return np.vstack(fingerprint_bits)
+
+    def _project_2d(self) -> None:
+        """Project the fingerprint matrix to 2D for visualization using UMAP with Jaccard metric."""
+        self.df = Projection2D().fit_transform(self.df, feature_matrix=self.X, metric="jaccard")
+
+    def neighbors(
+        self,
+        id_or_ids: Union[str, int, List[Union[str, int]]],
+        n_neighbors: Optional[int] = 5,
+        min_similarity: Optional[float] = None,
+        include_self: bool = True,
+    ) -> pd.DataFrame:
+        """
+        Return neighbors for ID(s) from the existing dataset.
+
+        Args:
+            id_or_ids: Single ID or list of IDs to look up
+            n_neighbors: Number of neighbors to return (default: 5, ignored if min_similarity is set)
+            min_similarity: If provided, find all neighbors with similarity >= this value (0-1)
+            include_self: Whether to include self in results (default: True)
+
+        Returns:
+            DataFrame containing neighbors with similarity scores (1 - Jaccard distance)
+        """
+        # Convert min_similarity to radius (Jaccard distance)
+        radius = 1 - min_similarity if min_similarity is not None else None
+
+        # Call parent method
+        neighbors_df = super().neighbors(
+            id_or_ids=id_or_ids,
+            n_neighbors=n_neighbors,
+            radius=radius,
+            include_self=include_self,
+        )
+
+        # Convert distance to similarity for fingerprints
+        neighbors_df["similarity"] = 1 - neighbors_df["distance"]
+        neighbors_df.drop(columns=["distance"], inplace=True)
+
+        return neighbors_df
+
+
+# Testing the FingerprintProximity class
+if __name__ == "__main__":
+    pd.set_option("display.max_columns", None)
+    pd.set_option("display.width", 1000)
+
+    # Create an Example DataFrame
+    data = {
+        "id": ["a", "b", "c", "d", "e"],
+        "fingerprint": ["101010", "111010", "101110", "011100", "000111"],
+        "Feature1": [0.1, 0.2, 0.3, 0.4, 0.5],
+        "Feature2": [0.5, 0.4, 0.3, 0.2, 0.1],
+        "target": [1, 0, 1, 0, 5],
+    }
+    df = pd.DataFrame(data)
+
+    # Initialize the FingerprintProximity class
+    proximity = FingerprintProximity(df, fingerprint_column="fingerprint", id_column="id", target="target")
+
+    # Test 1: Neighbors for a single ID
+    print("\n--- Test 1: Neighbors for ID 'a' ---")
+    neighbors_df = proximity.neighbors("a")
+    print(neighbors_df)
+
+    # Test 2: Neighbors for multiple IDs
+    print("\n--- Test 2: Neighbors for IDs ['a', 'b'] ---")
+    neighbors_df = proximity.neighbors(["a", "b"])
+    print(neighbors_df)
+
+    # Test 3: Neighbors with similarity threshold
+    print("\n--- Test 3: Neighbors with min_similarity=0.5 ---")
+    neighbors_df = proximity.neighbors("a", min_similarity=0.5)
+    print(neighbors_df)
+
+    # Test 4: Isolated compounds
+    print("\n--- Test 4: Isolated compounds (top 50%) ---")
+    isolated_df = proximity.isolated(top_percent=50.0)
+    print(isolated_df[["id", "nn_distance", "nn_id"]])
+
+    # Test 5: Target gradients
+    print("\n--- Test 5: Target gradients ---")
+    gradients_df = proximity.target_gradients(top_percent=50.0, min_delta=0.1)
+    print(gradients_df)
+
+    # Test on real data from Workbench
+    from workbench.api import FeatureSet, Model
+
+    fs = FeatureSet("aqsol_features")
+    model = Model("aqsol-regression")
+    features = model.features()
+    df = fs.pull_dataframe()
+    prox = FingerprintProximity(df, id_column=fs.id_column, target=model.target())
+    print(prox.neighbors(df[fs.id_column].tolist()[:3]))
+
+    # Test 6: Visualize the 2D projection
+    print("\n--- Test 6: 2D Projection Scatter Plot ---")
+    from workbench.web_interface.components.plugin_unit_test import PluginUnitTest
+    from workbench.web_interface.components.plugins.scatter_plot import ScatterPlot
+
+    unit_test = PluginUnitTest(ScatterPlot, input_data=prox.df[:1000], x="x", y="y")
+    unit_test.run()