From 493d11ec22c134d297e24c21a73333a038c65751 Mon Sep 17 00:00:00 2001 From: Lu Zhu Date: Tue, 7 May 2024 20:06:32 -0400 Subject: [PATCH] Enhancement (#2) * dev refactor * fix test * fix tests * remove unused code * refactor repo name * Reviewed @zhu0619's changes. Switched to jinja2 for HTML broadcaster * Fixed bug in LoggerBroadcaster * Fixed release CICD * Fix CICD --------- Co-authored-by: cwognum --- .github/ISSUE_TEMPLATE/bug-report.yml | 10 +- .github/workflows/doc.yml | 6 +- .github/workflows/release.yml | 6 +- .github/workflows/test.yml | 9 +- README.md | 6 +- alchemy/report/__init__.py | 3 - alchemy/report/broadcaster/_base.py | 67 ------- alchemy/report/broadcaster/_html.py | 70 -------- alchemy/visualization/__init__.py | 8 - alchemy/visualization/_distribution.py | 166 ------------------ {alchemy => auroris}/__init__.py | 0 {alchemy => auroris}/_version.py | 0 {alchemy => auroris}/cli.py | 4 +- {alchemy => auroris}/curation/__init__.py | 0 {alchemy => auroris}/curation/_curator.py | 14 +- .../curation/actions/__init__.py | 2 + .../curation/actions/_ac_stereoisomer.py | 61 ++++--- .../curation/actions/_base.py | 8 +- .../curation/actions/_deduplicate.py | 6 +- .../curation/actions/_discretize.py | 22 ++- auroris/curation/actions/_distribution.py | 35 ++++ {alchemy => auroris}/curation/actions/_mol.py | 39 ++-- .../curation/actions/_outlier.py | 12 +- {alchemy => auroris}/curation/functional.py | 0 auroris/report/__init__.py | 3 + {alchemy => auroris}/report/_report.py | 41 +++-- .../report/broadcaster/__init__.py | 0 auroris/report/broadcaster/_base.py | 17 ++ auroris/report/broadcaster/_html.py | 83 +++++++++ .../report/broadcaster/_logger.py | 20 ++- .../broadcaster/templates/report.html.jinja | 95 ++++++++++ {alchemy => auroris}/types.py | 0 {alchemy => auroris}/utils.py | 14 +- auroris/visualization/__init__.py | 8 + .../visualization/_chemspace.py | 2 +- auroris/visualization/_distribution.py | 110 ++++++++++++ {alchemy => auroris}/visualization/utils.py | 0 docs/api/actions/deduplication.md | 2 +- docs/api/actions/discretization.md | 2 +- docs/api/actions/mol.md | 2 +- docs/api/actions/outlier_detection.md | 2 +- docs/api/actions/stereo_ac.md | 2 +- docs/api/curator.md | 2 +- docs/api/functional.md | 2 +- docs/api/types.md | 2 +- docs/api/visualization.md | 2 +- docs/index.md | 2 +- docs/tutorials/getting_started.ipynb | 107 ++++++----- env.yml | 4 + mkdocs.yml | 16 +- pyproject.toml | 20 +-- tests/test_curator.py | 16 +- tests/test_deduplication.py | 2 +- tests/test_discretization.py | 2 +- tests/test_mol_curation.py | 4 +- tests/test_outlier_detection.py | 4 +- tests/test_stereoisomer_ac.py | 4 +- 57 files changed, 639 insertions(+), 507 deletions(-) delete mode 100644 alchemy/report/__init__.py delete mode 100644 alchemy/report/broadcaster/_base.py delete mode 100644 alchemy/report/broadcaster/_html.py delete mode 100644 alchemy/visualization/__init__.py delete mode 100644 alchemy/visualization/_distribution.py rename {alchemy => auroris}/__init__.py (100%) rename {alchemy => auroris}/_version.py (100%) rename {alchemy => auroris}/cli.py (88%) rename {alchemy => auroris}/curation/__init__.py (100%) rename {alchemy => auroris}/curation/_curator.py (88%) rename {alchemy => auroris}/curation/actions/__init__.py (78%) rename {alchemy => auroris}/curation/actions/_ac_stereoisomer.py (53%) rename {alchemy => auroris}/curation/actions/_base.py (84%) rename {alchemy => auroris}/curation/actions/_deduplicate.py (94%) rename {alchemy => auroris}/curation/actions/_discretize.py (84%) create mode 100644 auroris/curation/actions/_distribution.py rename {alchemy => auroris}/curation/actions/_mol.py (87%) rename {alchemy => auroris}/curation/actions/_outlier.py (94%) rename {alchemy => auroris}/curation/functional.py (100%) create mode 100644 auroris/report/__init__.py rename {alchemy => auroris}/report/_report.py (64%) rename {alchemy => auroris}/report/broadcaster/__init__.py (100%) create mode 100644 auroris/report/broadcaster/_base.py create mode 100644 auroris/report/broadcaster/_html.py rename {alchemy => auroris}/report/broadcaster/_logger.py (72%) create mode 100644 auroris/report/broadcaster/templates/report.html.jinja rename {alchemy => auroris}/types.py (100%) rename {alchemy => auroris}/utils.py (69%) create mode 100644 auroris/visualization/__init__.py rename {alchemy => auroris}/visualization/_chemspace.py (97%) create mode 100644 auroris/visualization/_distribution.py rename {alchemy => auroris}/visualization/utils.py (100%) diff --git a/.github/ISSUE_TEMPLATE/bug-report.yml b/.github/ISSUE_TEMPLATE/bug-report.yml index ba89630..d70c26e 100644 --- a/.github/ISSUE_TEMPLATE/bug-report.yml +++ b/.github/ISSUE_TEMPLATE/bug-report.yml @@ -7,10 +7,10 @@ body: value: | Please provide the following information. - type: input - id: alchemy-version + id: auroris-version attributes: - label: Alchemy version - description: Value of ``alchemy.__version__`` + label: Auroris version + description: Value of ``auroris.__version__`` placeholder: 0.2.5, 0.3.0, 0.3.1, etc. validations: required: true @@ -34,7 +34,7 @@ body: id: installation attributes: label: Installation - description: How was Alchemy installed? + description: How was Auroris installed? placeholder: e.g., "using pip into virtual environment", or "using conda" validations: required: true @@ -56,4 +56,4 @@ body: id: additional-output attributes: label: Additional output - description: If you think it might be relevant, please provide the output from ``pip freeze`` or ``conda env export`` depending on which was used to install Alchemy. \ No newline at end of file + description: If you think it might be relevant, please provide the output from ``pip freeze`` or ``conda env export`` depending on which was used to install Auroris. \ No newline at end of file diff --git a/.github/workflows/doc.yml b/.github/workflows/doc.yml index edaf5c9..d56c181 100644 --- a/.github/workflows/doc.yml +++ b/.github/workflows/doc.yml @@ -31,7 +31,11 @@ jobs: cache-downloads: true - name: Install library - run: python -m pip install --no-deps . + run: | + python -m pip install --no-deps . + # Note: Temporarily upgrade mkdocs-jupyter through PyPi + # See https://github.com/conda-forge/mkdocs-jupyter-feedstock/pull/30 + python -m pip install mkdocs-jupyter -U --force-reinstall - name: Configure git run: | diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 06dd20d..646f6bb 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -100,7 +100,11 @@ jobs: git push origin "${{ inputs.release-version }}" - name: Install library - run: python -m pip install --no-deps . + run: | + python -m pip install --no-deps . + # Note: Temporarily upgrade mkdocs-jupyter through PyPi + # See https://github.com/conda-forge/mkdocs-jupyter-feedstock/pull/29 + python -m pip install mkdocs-jupyter -U --force-reinstall - name: Build the wheel and sdist run: python -m build --no-isolation diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 447f45a..cb8ea74 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -43,7 +43,12 @@ jobs: python=${{ matrix.python-version }} - name: Install library - run: python -m pip install --no-deps -e . # -e (editable is needed for code coverage) + run: | + python -m pip install --no-deps . + # Note: Temporarily upgrade mkdocs-jupyter through PyPi + # See https://github.com/conda-forge/mkdocs-jupyter-feedstock/pull/30 + python -m pip install mkdocs-jupyter -U --force-reinstall + - name: Install UMAP run: python -m pip install umap-learn # Optional dependency @@ -52,7 +57,7 @@ jobs: run: pytest - name: Test CLI - run: alchemy --help + run: auroris --help - name: Test building the doc run: mkdocs build diff --git a/README.md b/README.md index c716b4a..86ac292 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Alchemy +# Auroris Tools for data curation in the Polaris ecosystem. @@ -6,8 +6,8 @@ Tools for data curation in the Polaris ecosystem. ### Getting started ```python -from alchemy.curation import Curator -from alchemy.curation.actions import MoleculeCuration, OutlierDetection, Discretization +from auroris.curation import Curator +from auroris.curation.actions import MoleculeCuration, OutlierDetection, Discretization # Define the curation workflow curator = Curator( diff --git a/alchemy/report/__init__.py b/alchemy/report/__init__.py deleted file mode 100644 index 264b42a..0000000 --- a/alchemy/report/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from ._report import CurationReport, Section - -__all__ = ["CurationReport", "Section"] diff --git a/alchemy/report/broadcaster/_base.py b/alchemy/report/broadcaster/_base.py deleted file mode 100644 index 835f805..0000000 --- a/alchemy/report/broadcaster/_base.py +++ /dev/null @@ -1,67 +0,0 @@ -import abc - -from PIL.Image import Image as ImageType - -from alchemy.report import CurationReport, Section - - -class ReportBroadcaster(abc.ABC): - """ - Creates a specific view of the report. - Implements the Template Method Design Pattern. - """ - - def __init__(self, report: CurationReport): - self._report = report - - def broadcast(self): - self.on_report_start(self._report) - for section in self._report.sections: - self.on_section_start(section) - - if len(section.logs) > 0: - self.on_logs_start() - for log in section.logs: - self.render_log(log) - self.on_logs_end() - - if len(section.images) > 0: - self.on_images_start() - for image in section.images: - self.render_image(image) - self.on_images_end() - - self.on_section_end(section) - self.on_report_end(self._report) - - @abc.abstractmethod - def render_log(self, message: str): - raise NotImplementedError - - @abc.abstractmethod - def render_image(self, image: ImageType): - raise NotImplementedError - - def on_section_start(self, section: Section): - pass - - def on_section_end(self, section: Section): - pass - - def on_logs_start(self): - pass - - def on_logs_end(self): - pass - - def on_images_start(self): - pass - - def on_images_end(self): - pass - - def on_report_start(self, report: CurationReport): - pass - - def on_report_end(self, section: CurationReport): - pass diff --git a/alchemy/report/broadcaster/_html.py b/alchemy/report/broadcaster/_html.py deleted file mode 100644 index 0cdc002..0000000 --- a/alchemy/report/broadcaster/_html.py +++ /dev/null @@ -1,70 +0,0 @@ -import datamol as dm -import fsspec -from PIL.Image import Image as ImageType - -from alchemy.report import CurationReport, Section - -from ._base import ReportBroadcaster - - -class HTMLBroadcaster(ReportBroadcaster): - """Render a simple HTML page""" - - def __init__(self, report: CurationReport, destination: str): - super().__init__(report) - - # Create destination dir. - self._destination = destination - dm.fs.mkdir(self._destination, exist_ok=True) - - # Create the directory for images - self._image_dir = dm.fs.join(self._destination, "images") - dm.fs.mkdir(self._image_dir, exist_ok=True) - - # Open the file - path = dm.fs.join(self._destination, "report.html") - self._file_descriptor = fsspec.open(path, "w") - self._file = self._file_descriptor.__enter__() - - # Count the images - self._image_count = 0 - - def on_logs_start(self): - # Start an unordered list - self._file.write("

Logs

") - self._file.write("") - - def on_images_start(self): - self._file.write("

Images

") - - def render_log(self, message: str): - # Write the log to the HTML - self._file.write(f"
  • {message}
    • ") - - def render_image(self, image: ImageType): - # Save the image to the disk - path = dm.fs.join(self._image_dir, f"image_{self._image_count}.png") - image.save(path) - - # Write the image to the HTML - self._file.write(f'') - - # Increase counter - self._image_count += 1 - - def on_report_start(self, report: CurationReport): - self._file.write("") - self._file.write("

    Curation Report

    ") - self._file.write(f"

    Time: {report.time_stamp.strftime('%Y-%m-%d %H:%M:%S')}

    ") - self._file.write(f"

    Version: {report.alchemy_version}

    ") - - def on_section_start(self, section: Section): - self._file.write(f"

    {section.title}

    ") - - def on_report_end(self, report: CurationReport): - self._file.write("") - self._file_descriptor.__exit__() diff --git a/alchemy/visualization/__init__.py b/alchemy/visualization/__init__.py deleted file mode 100644 index 6248c94..0000000 --- a/alchemy/visualization/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -from ._chemspace import visualize_chemspace -from ._distribution import detailed_distributions_plots, visualize_distribution_with_outliers - -__all__ = [ - "visualize_chemspace", - "detailed_distributions_plots", - "visualize_distribution_with_outliers", -] diff --git a/alchemy/visualization/_distribution.py b/alchemy/visualization/_distribution.py deleted file mode 100644 index a29e376..0000000 --- a/alchemy/visualization/_distribution.py +++ /dev/null @@ -1,166 +0,0 @@ -from typing import Callable, Dict, List, Optional, Tuple - -import numpy as np -import pandas as pd -import seaborn as sns -from loguru import logger -from scipy import stats - -from alchemy.visualization.utils import create_figure - - -def detailed_distributions_plots( - df: pd.DataFrame, - thresholds: Dict[str, Tuple[int, Callable]] = None, - label_names: List[str] = None, - log_scale_mapping: Dict[str, bool] = None, - positive_color: str = "#3db371", - negative_color: str = "#a9a9a9", - n_cols: int = 3, - fig_base_size: float = 8, - w_h_ratio: float = 0.5, - legend_fontsize: int = 18, - ticks_fontsize: int = 18, - title_fontsize: int = 18, - gridsize: int = 1000, - dpi: int = 150, - seaborn_theme: Optional[str] = "whitegrid", -): - """Plot the detailed distribution of the columns in `df`. Also, color the part of the - "positive" distribution using `thresholds`. - - Args: - df: A dataframe with binarized readouts only. NaN are allowed. - thresholds: A dict mapping of the `df` column. Value is a tuple where the first - element is the threshold value and the second element is a callable deciding wether - a datapoint meets the criterai or not (something like `np.less` or np.greater`). - label_names: Name of the labels (same order as the columns in `df`). If not set - the name of the columns are used. - log_scale_mapping: A dict mapping of the `df` column. If True, - the plot for this readout will be log scaled. - positive_color: Color for `True` or `1`. - negative_color: Color for `False` or `0`. - n_cols: Number of columns in the subplots. - fig_base_size: Base size of the plots. - w_h_ratio: Width/height ratio. - legend_fontsize: Font size of the legend. - ticks_fontsize: Font size of the x ticks and x label. - title_fontsize: Font size of the title. - gridsize: Gridsize for the kernel density estimate (KDE). - dpi: DPI value of the figure. - seaborn_theme: Seaborn theme. - """ - - # NOTE: the `thresholds` API is not super nice, consider an alternative. - # NOTE: we could eventually add support for multiclass here if we need it. - if thresholds is None: - thresholds = {} - - if log_scale_mapping is None: - log_scale_mapping = {} - - if label_names is None: - label_names = df.columns.tolist() - - # Check all columns are numeric - numerics = df.apply(lambda x: x.dtype.kind in "biufc") - if not numerics.all(): - raise ValueError(f"Not all columns are numeric: {numerics[~numerics].to_dict()}") - - n_plots = len(df.columns) - - # Create the figure - with create_figure( - n_plots=n_plots, - n_cols=n_cols, - dpi=dpi, - fig_base_size=fig_base_size, - w_h_ratio=w_h_ratio, - seaborn_theme=seaborn_theme, - ) as (fig, axes): - for ax, readout, label_name in zip(axes, df.columns, label_names): - values = df[readout].dropna() - - # Get threshold value and function - threshold_value, threshold_fn = None, None - threshold = thresholds.get(readout, None) - if threshold is not None: - threshold_value, threshold_fn = threshold - - # Whether to log scale - log_scale = log_scale_mapping.get(readout, False) - - # Draw distribution and kde plot - kde_kws = {} - kde_kws["clip"] = values.min(), values.max() - kde_kws["gridsize"] = gridsize - kplot = sns.histplot( - values, - kde=True, - ax=ax, - color=negative_color, - kde_kws=kde_kws, - log_scale=log_scale, - ) - - # Label - ax.set_title(label_name, fontsize=title_fontsize) - ax.set_xlabel(None) - ax.set_ylabel("Count", fontsize=ticks_fontsize) - - ax.xaxis.set_tick_params(labelsize=ticks_fontsize) - ax.yaxis.set_tick_params(labelsize=ticks_fontsize) - - if threshold_value is not None and threshold_fn is not None: - # Fill between on active values - x, y = kplot.get_lines()[0].get_data() - ax.fill_between( - x, - y, - where=threshold_fn(x, threshold_value), - facecolor=positive_color, - alpha=0.8, - ) - - # Active ratio text box - positive_ratio = threshold_fn(values, threshold_value).sum() / len(values) * 100 - ax.text( - 0.85, - 0.95, - f"{positive_ratio:.1f} %", - transform=ax.transAxes, - fontsize=legend_fontsize, - verticalalignment="top", - bbox=dict(boxstyle="round", facecolor="wheat", alpha=0.5), - ) - else: - logger.warning(f"Threshold not available for readout '{readout}'") - - return fig - - -def visualize_distribution_with_outliers( - values: np.ndarray, - is_outlier: Optional[List[bool]] = None, -): - """Visualize the distribution of the data and highlight the potential outliers.""" - - values = np.sort(values) - - if is_outlier is None: - # Import here to prevent ciruclar imports - from alchemy.curation.functional import detect_outliers - - is_outlier = detect_outliers(values) - - with create_figure(n_plots=2) as (fig, axes): - sns.scatterplot( - x=np.arange(len(values)), - y=values, - hue=is_outlier, - palette={1.0: "red", 0.0: "navy", 0.5: "grey"}, - ax=axes[0], - ) - stats.probplot(values, dist="norm", plot=axes[1]) - - return fig diff --git a/alchemy/__init__.py b/auroris/__init__.py similarity index 100% rename from alchemy/__init__.py rename to auroris/__init__.py diff --git a/alchemy/_version.py b/auroris/_version.py similarity index 100% rename from alchemy/_version.py rename to auroris/_version.py diff --git a/alchemy/cli.py b/auroris/cli.py similarity index 88% rename from alchemy/cli.py rename to auroris/cli.py index a42551f..0bbcb89 100644 --- a/alchemy/cli.py +++ b/auroris/cli.py @@ -2,8 +2,8 @@ import pandas as pd import typer -from alchemy.curation import Curator -from alchemy.report.broadcaster import HTMLBroadcaster +from auroris.curation import Curator +from auroris.report.broadcaster import HTMLBroadcaster app = typer.Typer() diff --git a/alchemy/curation/__init__.py b/auroris/curation/__init__.py similarity index 100% rename from alchemy/curation/__init__.py rename to auroris/curation/__init__.py diff --git a/alchemy/curation/_curator.py b/auroris/curation/_curator.py similarity index 88% rename from alchemy/curation/_curator.py rename to auroris/curation/_curator.py index ab94d2a..57025a8 100644 --- a/alchemy/curation/_curator.py +++ b/auroris/curation/_curator.py @@ -3,11 +3,12 @@ import fsspec import pandas as pd +from loguru import logger from pydantic import BaseModel, Field, field_serializer, field_validator -from alchemy.curation.actions._base import ACTION_REGISTRY -from alchemy.report import CurationReport -from alchemy.types import VerbosityLevel +from auroris.curation.actions._base import ACTION_REGISTRY, BaseAction +from auroris.report import CurationReport +from auroris.types import VerbosityLevel class Curator(BaseModel): @@ -37,9 +38,12 @@ def _serialize_verbosity(self, value: VerbosityLevel): def transform(self, dataset: pd.DataFrame) -> Tuple[pd.DataFrame, CurationReport]: report = CurationReport() - dataset = dataset.copy(deep=True) + + action: BaseAction for action in self.steps: + logger.info(f"Performing step: {action.name}") + with report.section(action.name): dataset = action.transform( dataset, @@ -47,6 +51,7 @@ def transform(self, dataset: pd.DataFrame) -> Tuple[pd.DataFrame, CurationReport verbosity=self.verbosity, parallelized_kwargs=self.parallelized_kwargs, ) + return dataset, report def __call__(self, dataset): @@ -71,3 +76,4 @@ def to_json(self, path: str): """ with fsspec.open(path, "w") as f: json.dump(self.model_dump(), f) + return path diff --git a/alchemy/curation/actions/__init__.py b/auroris/curation/actions/__init__.py similarity index 78% rename from alchemy/curation/actions/__init__.py rename to auroris/curation/actions/__init__.py index aafffff..caf0d7d 100644 --- a/alchemy/curation/actions/__init__.py +++ b/auroris/curation/actions/__init__.py @@ -2,6 +2,7 @@ from ._base import BaseAction from ._deduplicate import Deduplication from ._discretize import Discretization +from ._distribution import ContinuousDistributionVisualization from ._mol import MoleculeCuration from ._outlier import OutlierDetection @@ -12,4 +13,5 @@ "Deduplication", "Discretization", "StereoIsomerACDetection", + "ContinuousDistributionVisualization", ] diff --git a/alchemy/curation/actions/_ac_stereoisomer.py b/auroris/curation/actions/_ac_stereoisomer.py similarity index 53% rename from alchemy/curation/actions/_ac_stereoisomer.py rename to auroris/curation/actions/_ac_stereoisomer.py index f815bea..10357c3 100644 --- a/alchemy/curation/actions/_ac_stereoisomer.py +++ b/auroris/curation/actions/_ac_stereoisomer.py @@ -4,11 +4,11 @@ import numpy as np import pandas as pd -from alchemy.curation.actions._base import BaseAction -from alchemy.curation.actions._outlier import modified_zscore -from alchemy.report import CurationReport -from alchemy.types import VerbosityLevel -from alchemy.utils import is_regression +from auroris.curation.actions._base import BaseAction +from auroris.curation.actions._outlier import modified_zscore +from auroris.report import CurationReport +from auroris.types import VerbosityLevel +from auroris.utils import is_regression def detect_streoisomer_activity_cliff( @@ -18,29 +18,35 @@ def detect_streoisomer_activity_cliff( threshold: float = 1.0, prefix: str = "AC_", ): - groups = [] + dataset_ori = dataset.copy(deep=True) ac_cols = {y_col: [] for y_col in y_cols} - - dataset = dataset.reset_index(drop=True) - - for _, group in dataset.groupby(stereoisomer_id_col): - for y_col in y_cols: - if is_regression(group[y_col].values): - # In regression, we use the difference between the z-scores - zscores = modified_zscore(dataset[y_col].values)[group.index] - ac = (zscores.max() - zscores.min()) > threshold + group_index_list = np.array( + [group.index.values for _, group in dataset.groupby(stereoisomer_id_col, sort=False)] + ) + for y_col in y_cols: + is_reg = is_regression(dataset[y_col].dropna().values) + if is_reg: + y_zscores = modified_zscore(dataset[y_col].values) + + for group_index in group_index_list: + group = dataset.iloc[group_index, :] + if len(group) == 1: + ac = None else: - # For classification, we use the number of unique classes - ac = len(np.unique(group[y_col].values)) > 1 + if is_reg: + # In regression, we use the difference between the z-scores + zscores = y_zscores[group.index] + ac = (np.nanmax(zscores) - np.nanmin(zscores)) > threshold + else: + # For classification, we use the number of unique classes + ac = len(np.unique(group[y_col].values)) > 1 ac_cols[y_col].extend([ac] * len(group)) - groups.append(group) - - dataset = pd.concat(groups) for y_col in y_cols: - dataset[f"{prefix}{y_col}"] = ac_cols[y_col] + rows = group_index_list.flatten() + dataset_ori.loc[rows, f"{prefix}{y_col}"] = np.array(ac_cols[y_col]).astype(bool) - return dataset.sort_index() + return dataset_ori class StereoIsomerACDetection(BaseAction): @@ -52,6 +58,7 @@ class StereoIsomerACDetection(BaseAction): y_cols: List[str] threshold: float = 2.0 prefix: str = "AC_" + mol_col: str = "MOL_smiles" def transform( self, @@ -62,7 +69,7 @@ def transform( ): dataset = detect_streoisomer_activity_cliff( dataset=dataset, - stereo_column=self.stereo_column, + stereoisomer_id_col=self.stereoisomer_id_col, y_cols=self.y_cols, threshold=self.threshold, prefix=self.prefix, @@ -79,11 +86,10 @@ def transform( if num_cliff > 0: report.log( f"Found {num_cliff} activity cliffs among stereoisomers " - "with respect to the {col} column." + f"with respect to the {col} column." ) - - to_plot = dataset.loc[has_cliff, "smiles"] - legends = dataset.loc[has_cliff, col_with_prefix] + to_plot = dataset.loc[has_cliff, self.mol_col] + legends = (col + dataset.loc[has_cliff, col].astype(str)).tolist() image = dm.to_image([dm.to_mol(s) for s in to_plot], legends=legends, use_svg=False) report.log_image(image) @@ -92,3 +98,4 @@ def transform( report.log( "Found no activity cliffs among stereoisomers with respect to the {col} column." ) + return dataset diff --git a/alchemy/curation/actions/_base.py b/auroris/curation/actions/_base.py similarity index 84% rename from alchemy/curation/actions/_base.py rename to auroris/curation/actions/_base.py index a132eb8..589e211 100644 --- a/alchemy/curation/actions/_base.py +++ b/auroris/curation/actions/_base.py @@ -4,10 +4,10 @@ import pandas as pd from pydantic import BaseModel, model_validator -from alchemy.types import VerbosityLevel +from auroris.types import VerbosityLevel if TYPE_CHECKING: - from alchemy.report import CurationReport + from auroris.report import CurationReport ACTION_REGISTRY = [] @@ -19,6 +19,8 @@ class BaseAction(BaseModel, abc.ABC): Args: prefix: If the action adds columns, use this prefix. + completed: If the action has completed. + dep_action: Name of dependent action. """ prefix: str = None @@ -32,7 +34,7 @@ def name(self) -> str: @classmethod def _validate_model(cls, m: "BaseAction"): if m.prefix is None: - m = m.name.upper() + "_" + m.prefix = m.name.upper() + "_" return m def get_column_name(self, column: str): diff --git a/alchemy/curation/actions/_deduplicate.py b/auroris/curation/actions/_deduplicate.py similarity index 94% rename from alchemy/curation/actions/_deduplicate.py rename to auroris/curation/actions/_deduplicate.py index a13240c..30cb7aa 100644 --- a/alchemy/curation/actions/_deduplicate.py +++ b/auroris/curation/actions/_deduplicate.py @@ -2,9 +2,9 @@ import pandas as pd -from alchemy.curation.actions._base import BaseAction -from alchemy.report import CurationReport -from alchemy.types import VerbosityLevel +from auroris.curation.actions._base import BaseAction +from auroris.report import CurationReport +from auroris.types import VerbosityLevel def deduplicate( diff --git a/alchemy/curation/actions/_discretize.py b/auroris/curation/actions/_discretize.py similarity index 84% rename from alchemy/curation/actions/_discretize.py rename to auroris/curation/actions/_discretize.py index ca43456..d9be8f9 100644 --- a/alchemy/curation/actions/_discretize.py +++ b/auroris/curation/actions/_discretize.py @@ -1,12 +1,13 @@ -from typing import Dict, Literal, Optional, Union +from typing import Dict, List, Literal, Optional, Union import numpy as np import pandas as pd from sklearn.base import check_array -from alchemy.curation.actions._base import BaseAction -from alchemy.report import CurationReport -from alchemy.types import VerbosityLevel +from auroris.curation.actions._base import BaseAction +from auroris.report import CurationReport +from auroris.types import VerbosityLevel +from auroris.visualization import visualize_continuous_distribution def discretize( @@ -23,8 +24,7 @@ def discretize( scipy.sparse matrices should be in CSR or CSC format to avoid an un-necessary copy. - thresholds: Feature values below or equal to this are replaced by 0, above it by 1. - Threshold may not be less than 0 for operations on sparse matrices. + thresholds: Interval boundaries that include the right bin edge. inplace: Set to True to perform inplace discretization and avoid a copy (if the input is already a numpy array or a scipy.sparse CSR / CSC @@ -78,10 +78,11 @@ def discretize( class Discretization(BaseAction): input_column: str prefix: str = "CLS_" - thresholds: list + thresholds: List[float] inplace: bool = False allow_nan: bool = True label_order: Literal["ascending", "descending"] = "ascending" + log_scale: bool = True def transform( self, @@ -99,6 +100,13 @@ def transform( label_order=self.label_order, ) + fig = visualize_continuous_distribution( + data=dataset[self.input_column].values, + log_scale=self.log_scale, + bins=self.thresholds, + ) + report.log_image(fig, title=self.input_column) + column_name = self.get_column_name(self.input_column) dataset[column_name] = X diff --git a/auroris/curation/actions/_distribution.py b/auroris/curation/actions/_distribution.py new file mode 100644 index 0000000..97f225b --- /dev/null +++ b/auroris/curation/actions/_distribution.py @@ -0,0 +1,35 @@ +from typing import Dict, List, Optional + +import pandas as pd +from pydantic import Field + +from auroris.curation.actions._base import BaseAction +from auroris.report import CurationReport +from auroris.types import VerbosityLevel +from auroris.visualization import visualize_continuous_distribution + + +class ContinuousDistributionVisualization(BaseAction): + """ + Visualize a continuous distribution + """ + + y_cols: Optional[List[str]] = None + log_scale: bool = False + kwargs: Dict = Field(default_factory=dict) + + def transform( + self, + dataset: pd.DataFrame, + report: Optional[CurationReport] = None, + verbosity: VerbosityLevel = VerbosityLevel.NORMAL, + parallelized_kwargs: Optional[Dict] = None, + ): + if report is not None: + for y_col in self.y_cols: + fig = visualize_continuous_distribution( + data=dataset[y_col], label_name=y_col, log_scale=self.log_scale + ) + report.log_image(fig, title=f"Data distribution - {y_col}") + + return dataset diff --git a/alchemy/curation/actions/_mol.py b/auroris/curation/actions/_mol.py similarity index 87% rename from alchemy/curation/actions/_mol.py rename to auroris/curation/actions/_mol.py index 1fc1681..dcff30c 100644 --- a/alchemy/curation/actions/_mol.py +++ b/auroris/curation/actions/_mol.py @@ -6,10 +6,10 @@ import pandas as pd from rdkit.Chem import FindMolChiralCenters -from alchemy.curation.actions._base import BaseAction -from alchemy.report import CurationReport -from alchemy.types import VerbosityLevel -from alchemy.visualization import visualize_chemspace +from auroris.curation.actions._base import BaseAction +from auroris.report import CurationReport +from auroris.types import VerbosityLevel +from auroris.visualization import visualize_chemspace def curate_molecules( @@ -269,7 +269,7 @@ def transform( X = np.array([dm.to_fp(smi) for smi in smiles]) fig = visualize_chemspace(X=X) - report.log_image(fig) + report.log_image(fig, "Distribution in Chemical Space") if self.count_stereocenters: # Plot all compounds with undefined stereocenters for visual inspection @@ -277,15 +277,24 @@ def transform( undefined_col = self.get_column_name("num_undefined_stereo_center") defined_col = self.get_column_name("num_defined_stereo_center") - to_plot = dataset[dataset[[undefined_col, defined_col]].notna().any(axis=1)] - - legends = [] - for _, row in to_plot.iterrows(): - undefined = row[undefined_col] - defined = row[defined_col] - legends.append(f"Undefined:{undefined}\n Definded:{defined}") - - image = dm.to_image(to_plot[smiles_col].tolist(), legends=legends, use_svg=False) - report.log_image(image) + to_plot = dataset.query(f"{undefined_col} > 0 ") + num_mol_undefined = to_plot.shape[0] + report.log(f"Molecules with undefined stereocenter detected: {num_mol_undefined}.") + + if num_mol_undefined > 0: + legends = [] + for _, row in to_plot.iterrows(): + undefined = row[undefined_col] + defined = row[defined_col] + legends.append(f"Undefined:{undefined}\n Definded:{defined}") + + image = dm.to_image(to_plot[smiles_col].tolist(), legends=legends, use_svg=False) + report.log_image( + image, + title="Molecules with undefined stereocenters", + description=f"There are {num_mol_undefined} molecules with undefined stereocenter(s)." + f"It's recommanded to use and" + f"check the stereoisomers and activity cliffs in the dataset.", + ) return dataset diff --git a/alchemy/curation/actions/_outlier.py b/auroris/curation/actions/_outlier.py similarity index 94% rename from alchemy/curation/actions/_outlier.py rename to auroris/curation/actions/_outlier.py index b6d759d..5731bb3 100644 --- a/alchemy/curation/actions/_outlier.py +++ b/auroris/curation/actions/_outlier.py @@ -10,10 +10,10 @@ from sklearn.neighbors import LocalOutlierFactor from sklearn.svm import OneClassSVM -from alchemy.curation.actions._base import BaseAction -from alchemy.report import CurationReport -from alchemy.types import VerbosityLevel -from alchemy.visualization import visualize_distribution_with_outliers +from auroris.curation.actions._base import BaseAction +from auroris.report import CurationReport +from auroris.types import VerbosityLevel +from auroris.visualization import visualize_distribution_with_outliers OutlierDetectionMethod: TypeAlias = Literal["iso", "lof", "svm", "ee", "zscore"] @@ -37,10 +37,10 @@ def detect_outliers(X: np.ndarray, method: OutlierDetectionMethod = "zscore", ** in_ = X[indices].reshape(-1, 1) out_ = detector.fit_predict(in_) - is_inlier = np.zeros_like(X, dtype=int) + is_inlier = np.full_like(X, np.nan) is_inlier[indices] = out_.flatten() - is_outlier = 1 - ((is_inlier + 1) / 2) + is_outlier = is_inlier == -1 return is_outlier diff --git a/alchemy/curation/functional.py b/auroris/curation/functional.py similarity index 100% rename from alchemy/curation/functional.py rename to auroris/curation/functional.py diff --git a/auroris/report/__init__.py b/auroris/report/__init__.py new file mode 100644 index 0000000..fa3578f --- /dev/null +++ b/auroris/report/__init__.py @@ -0,0 +1,3 @@ +from ._report import AnnotatedImage, CurationReport, Section + +__all__ = ["CurationReport", "Section", "AnnotatedImage"] diff --git a/alchemy/report/_report.py b/auroris/report/_report.py similarity index 64% rename from alchemy/report/_report.py rename to auroris/report/_report.py index 4d33ca7..bd00929 100644 --- a/alchemy/report/_report.py +++ b/auroris/report/_report.py @@ -1,14 +1,26 @@ from contextlib import contextmanager from datetime import datetime -from typing import List, Optional, Union +from typing import ByteString, List, Optional, Union from matplotlib import pyplot as plt from matplotlib.figure import Figure from PIL.Image import Image as ImageType from pydantic import BaseModel, ConfigDict, Field, PrivateAttr -from alchemy import __version__ -from alchemy.utils import fig2img +from auroris import __version__ +from auroris.utils import fig2img + + +class AnnotatedImage(BaseModel): + """ + Image data, potentially with a title and / or description. + """ + + image: ImageType + title: Optional[str] = "" + description: Optional[str] = "" + + model_config = ConfigDict(arbitrary_types_allowed=True) class Section(BaseModel): @@ -18,9 +30,7 @@ class Section(BaseModel): title: str logs: List[str] = Field(default_factory=list) - images: List[ImageType] = Field(default_factory=list) - - model_config = ConfigDict(arbitrary_types_allowed=True) + images: List[AnnotatedImage] = Field(default_factory=list) class CurationReport(BaseModel): @@ -28,8 +38,9 @@ class CurationReport(BaseModel): A report that summarizes the changes of the curation process. """ + title: str = "Curation Report" sections: List[Section] = Field(default_factory=list) - alchemy_version: str = Field(default=__version__) + auroris_version: str = Field(default=__version__) time_stamp: datetime = Field(default_factory=datetime.now) _active_section: Optional[Section] = PrivateAttr(None) @@ -51,20 +62,30 @@ def section(self, name: str): def log(self, message: str): """Log a message to the report""" + self._check_active_section() self._active_section.logs.append(message) def log_new_column(self, name: str): """Log that a new column has been added to the dataset""" self.log(f"New column added: {name}") - def log_image(self, image_or_figure: Union[ImageType, Figure]): + def log_image( + self, + image_or_figure: Union[ImageType, Figure, ByteString], + title: Optional[str] = None, + description: Optional[str] = None, + ): """Logs an image. Also accepts Matplotlib figures, which will be converted to images.""" - + self._check_active_section() if isinstance(image_or_figure, Figure): image = fig2img(image_or_figure) plt.close(image_or_figure) - else: image = image_or_figure + image = AnnotatedImage(image=image, title=title, description=description) self._active_section.images.append(image) + + def _check_active_section(self): + if self._active_section is None: + raise RuntimeError("No active section. Use `with report.section(name):`") diff --git a/alchemy/report/broadcaster/__init__.py b/auroris/report/broadcaster/__init__.py similarity index 100% rename from alchemy/report/broadcaster/__init__.py rename to auroris/report/broadcaster/__init__.py diff --git a/auroris/report/broadcaster/_base.py b/auroris/report/broadcaster/_base.py new file mode 100644 index 0000000..00bb64b --- /dev/null +++ b/auroris/report/broadcaster/_base.py @@ -0,0 +1,17 @@ +import abc + +from auroris.report import CurationReport + + +class ReportBroadcaster(abc.ABC): + """ + Creates a specific view of the report. + Implements the Template Method Design Pattern. + """ + + def __init__(self, report: CurationReport): + self._report = report + + @abc.abstractmethod + def broadcast(self): + raise NotImplementedError diff --git a/auroris/report/broadcaster/_html.py b/auroris/report/broadcaster/_html.py new file mode 100644 index 0000000..a855d65 --- /dev/null +++ b/auroris/report/broadcaster/_html.py @@ -0,0 +1,83 @@ +import base64 +import os +import pathlib +from copy import deepcopy +from importlib import resources + +import datamol as dm +import fsspec + +from auroris.report import CurationReport +from auroris.utils import img2bytes + +from ._base import ReportBroadcaster + +try: + import jinja2 +except ImportError: + jinja2 = None + + +class HTMLBroadcaster(ReportBroadcaster): + """Render a simple HTML page""" + + def __init__( + self, + report: CurationReport, + destination: str, + embed_images: bool = False, + ): + super().__init__(report) + + if jinja2 is None: + raise ImportError( + f"Jinja2 is required to use {self.__class__.__name__}. Install it with `pip install Jinja2`." + ) + + self._destination = destination + self._image_dir = dm.fs.join(self._destination, "images") + self._embed_images = embed_images + + def broadcast(self): + report = deepcopy(self._report) + + # Create destination dir. + dm.fs.mkdir(self._destination, exist_ok=True) + + # Create the directory for images + if not self._embed_images: + dm.fs.mkdir(self._image_dir, exist_ok=True) + + pathlib.Path(__file__).parent.resolve() / "templates" + + # Save all images + image_counter = 0 + for section in report.sections: + for image in section.images: + if self._embed_images: + # Encode directly into the HTML + image_data = img2bytes(image.image) + image_data = base64.b64encode(image_data).decode("utf-8") + src = f"data:image/png;base64,{image_data}" + else: + # Save as separate file + path = dm.fs.join(self._image_dir, f"{image_counter}.png") + image.image.save(path) + src = os.path.relpath(path, self._destination) + + image.image = src + image_counter += 1 + + # Get HTML template file + path = resources.files("auroris.report.broadcaster.templates") + path = path.joinpath("report.html.jinja") + + # Render the HTML + with path.open() as template_file: + template = jinja2.Template(template_file.read()) + html = template.render(report=report) + + # Write the HTML + path = dm.fs.join(self._destination, "index.html") + with fsspec.open(path, "w") as fd: + fd.write(html) diff --git a/alchemy/report/broadcaster/_logger.py b/auroris/report/broadcaster/_logger.py similarity index 72% rename from alchemy/report/broadcaster/_logger.py rename to auroris/report/broadcaster/_logger.py index 4a8570f..b6daa9a 100644 --- a/alchemy/report/broadcaster/_logger.py +++ b/auroris/report/broadcaster/_logger.py @@ -1,9 +1,7 @@ import logging import sys -from PIL.Image import Image as ImageType - -from alchemy.report import CurationReport, Section +from auroris.report import AnnotatedImage, CurationReport, Section from ._base import ReportBroadcaster @@ -45,11 +43,21 @@ def __init__(self, report: CurationReport): self.logger.removeHandler(handler) self.logger.addHandler(handler) + def broadcast(self): + self.on_report_start(self._report) + for section in self._report.sections: + self.on_section_start(section) + for log in section.logs: + self.render_log(log) + for image in section.images: + self.render_image(image) + def render_log(self, message: str): self.logger.debug(f"[LOG]: {message}") - def render_image(self, image: ImageType): - self.logger.debug(f"[IMG]: Dimensions {image.width} x {image.height}") + def render_image(self, image: AnnotatedImage): + width, height = image.image.size + self.logger.debug(f"[IMG]: Dimensions {width} x {height}") def on_section_start(self, section: Section): self.logger.info(f"===== {section.title} =====") @@ -57,4 +65,4 @@ def on_section_start(self, section: Section): def on_report_start(self, report: CurationReport): self.logger.critical("===== Curation Report =====") self.logger.debug(f"Time: {report.time_stamp.strftime('%Y-%m-%d %H:%M:%S')}") - self.logger.debug(f"Version: {report.alchemy_version}") + self.logger.debug(f"Version: {report.auroris_version}") diff --git a/auroris/report/broadcaster/templates/report.html.jinja b/auroris/report/broadcaster/templates/report.html.jinja new file mode 100644 index 0000000..c295986 --- /dev/null +++ b/auroris/report/broadcaster/templates/report.html.jinja @@ -0,0 +1,95 @@ + + + + + {{ report.title }} + + + +
    +
    +

    {{ report.title|e }}

    +

    Time: {{ report.time_stamp.strftime('%Y-%m-%d %H:%M:%S') }}

    +

    Version: {{ report.auroris_version }}

    +
    + + {% for section in report.sections %} +

    {{ section.title|e }}

    + + + {% if section.logs|count > 0 %} +

    Logs

    +
      + {% for log in section.logs %} +
    • {{ log|e }}
      • + {% endfor %} +
    + {% endif %} + + + {% if section.images|count > 0 %} +

    Images

    + {% for img in section.images %} + {% if img.title %} +

    {{img.title}}

    + {% endif %} + + {% if img.description %} +

    {{img.description}}

    + {% endif %} + {% endfor %} + {% endif %} + + {% endfor %} +
    +

    Generated by Auroris Data Curation

    +
    +
    + + \ No newline at end of file diff --git a/alchemy/types.py b/auroris/types.py similarity index 100% rename from alchemy/types.py rename to auroris/types.py diff --git a/alchemy/utils.py b/auroris/utils.py similarity index 69% rename from alchemy/utils.py rename to auroris/utils.py index 467cc6c..fb59f38 100644 --- a/alchemy/utils.py +++ b/auroris/utils.py @@ -1,3 +1,5 @@ +from io import BytesIO + import numpy as np from matplotlib.figure import Figure from PIL import Image @@ -19,7 +21,15 @@ def fig2img(fig: Figure) -> ImageType: """Convert a Matplotlib figure to a PIL Image""" fig.canvas.draw() return Image.frombytes( - "RGB", + "RGBA", fig.canvas.get_width_height(), - fig.canvas.tostring_rgb(), + fig.canvas.buffer_rgba(), ) + + +def img2bytes(image: ImageType): + """Convert png image to bytes""" + image_bytes = BytesIO() + image.save(image_bytes, format="PNG") + image_bytes = image_bytes.getvalue() + return image_bytes diff --git a/auroris/visualization/__init__.py b/auroris/visualization/__init__.py new file mode 100644 index 0000000..13da1fd --- /dev/null +++ b/auroris/visualization/__init__.py @@ -0,0 +1,8 @@ +from ._chemspace import visualize_chemspace +from ._distribution import visualize_continuous_distribution, visualize_distribution_with_outliers + +__all__ = [ + "visualize_chemspace", + "visualize_continuous_distribution", + "visualize_distribution_with_outliers", +] diff --git a/alchemy/visualization/_chemspace.py b/auroris/visualization/_chemspace.py similarity index 97% rename from alchemy/visualization/_chemspace.py rename to auroris/visualization/_chemspace.py index 9bc7eaf..16d6246 100644 --- a/alchemy/visualization/_chemspace.py +++ b/auroris/visualization/_chemspace.py @@ -3,7 +3,7 @@ import numpy as np import seaborn as sns -from alchemy.visualization.utils import create_figure +from auroris.visualization.utils import create_figure try: import umap # type: ignore diff --git a/auroris/visualization/_distribution.py b/auroris/visualization/_distribution.py new file mode 100644 index 0000000..8bd47c6 --- /dev/null +++ b/auroris/visualization/_distribution.py @@ -0,0 +1,110 @@ +from typing import List, Optional, Sequence + +import numpy as np +import seaborn as sns +from scipy import stats + +from auroris.visualization.utils import create_figure + + +def visualize_continuous_distribution( + data: np.ndarray, log_scale: bool = False, bins: Optional[Sequence[float]] = None +): + """ + KDE plot the distribution of the column in `data` with colored sections under the KDE curve. + + Args: + data: A 1D numpy array with the values to plot the distribution for. + log_scale: Whether to plot the x-axis in log scale. + bins: The bin boundaries to color the area under the KDE curve. + """ + # Create a KDE plot without filling + with create_figure(n_plots=1) as (fig, axs): + ax = sns.kdeplot(data, ax=axs[0], log_scale=log_scale, color="black", linewidth=1.5) + + if bins is None: + return fig + + # Get the xy coordinates of the plotted KDE line + coords = ax.get_lines()[0].get_data() + xs = coords[0] + ys = coords[1] + + # Setup the bins + bins = np.sort(bins) + bins = np.append(bins, np.inf) + lower = -np.inf + + ylim = ax.get_ylim() + + # Color the area under the KDE curve in accordance with the bins + # Also added a vertical dashed line for each bin boundary + for threshold in bins: + if log_scale and lower != -np.inf: + lower = np.log(lower) + if log_scale and threshold != np.inf: + threshold = np.log(threshold) + + mask = (xs > lower) & (xs <= threshold) + lower = threshold + + # Update xs to make sure they cover the range even if the + # coordinates don't fully cover it + masked_xs = xs[mask] + + if len(masked_xs) == 0: + continue + + masked_xs[0] = max(lower, np.min(xs)) + masked_xs[-1] = threshold + + pct_mask = (data > lower) & (data <= threshold) + pct = np.sum(pct_mask) / len(data) + + def _format(val): + if val == -np.inf: + return "-∞" + elif val == np.inf: + return "∞" + else: + return f"{val:.2f}" + + label = f"{_format(lower)}, {_format(threshold)}" + label = f"({label})" if threshold == np.inf else f"({label}]" + label += f" - {pct:.2%}" + + ax.fill_between(masked_xs, ys[mask], alpha=0.5, label=label) + ax.plot([threshold, threshold], [ylim[0], ys[mask][-1]], "k--") + + ax.legend() + return fig + + +def visualize_distribution_with_outliers( + values: np.ndarray, + is_outlier: Optional[List[bool]] = None, +): + """Visualize the distribution of the data and highlight the potential outliers.""" + + if is_outlier is None: + # Import here to prevent ciruclar imports + from auroris.curation.functional import detect_outliers + + is_outlier = detect_outliers(values) + + # sort both value and outlier indicator + sorted_ind = np.argsort(values) + values = values[sorted_ind] + is_outlier = is_outlier[sorted_ind] + + with create_figure(n_plots=2) as (fig, axes): + sns.scatterplot( + x=np.arange(len(values)), + y=values, + hue=is_outlier, + palette={1.0: "red", 0.0: "navy", 0.5: "grey"}, + ax=axes[0], + ) + stats.probplot(values, dist="norm", plot=axes[1]) + + return fig diff --git a/alchemy/visualization/utils.py b/auroris/visualization/utils.py similarity index 100% rename from alchemy/visualization/utils.py rename to auroris/visualization/utils.py diff --git a/docs/api/actions/deduplication.md b/docs/api/actions/deduplication.md index 8fc6d7d..1e6a0a5 100644 --- a/docs/api/actions/deduplication.md +++ b/docs/api/actions/deduplication.md @@ -1,4 +1,4 @@ -::: alchemy.curation.actions.Deduplication +::: auroris.curation.actions.Deduplication options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/discretization.md b/docs/api/actions/discretization.md index 4fc025f..3de0d20 100644 --- a/docs/api/actions/discretization.md +++ b/docs/api/actions/discretization.md @@ -1,4 +1,4 @@ -::: alchemy.curation.actions.Discretization +::: auroris.curation.actions.Discretization options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/mol.md b/docs/api/actions/mol.md index 548ffa8..8d95039 100644 --- a/docs/api/actions/mol.md +++ b/docs/api/actions/mol.md @@ -1,4 +1,4 @@ -::: alchemy.curation.actions.MoleculeCuration +::: auroris.curation.actions.MoleculeCuration options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/outlier_detection.md b/docs/api/actions/outlier_detection.md index ab7c1ab..5a7b0b3 100644 --- a/docs/api/actions/outlier_detection.md +++ b/docs/api/actions/outlier_detection.md @@ -1,4 +1,4 @@ -::: alchemy.curation.actions.OutlierDetection +::: auroris.curation.actions.OutlierDetection options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/actions/stereo_ac.md b/docs/api/actions/stereo_ac.md index 4cd6cc2..97f93a1 100644 --- a/docs/api/actions/stereo_ac.md +++ b/docs/api/actions/stereo_ac.md @@ -1,4 +1,4 @@ -::: alchemy.curation.actions.StereoIsomerACDetection +::: auroris.curation.actions.StereoIsomerACDetection options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/curator.md b/docs/api/curator.md index e1f72a2..7878383 100644 --- a/docs/api/curator.md +++ b/docs/api/curator.md @@ -1,4 +1,4 @@ -::: alchemy.curation.Curator +::: auroris.curation.Curator options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/functional.md b/docs/api/functional.md index 7cc1028..3518fa4 100644 --- a/docs/api/functional.md +++ b/docs/api/functional.md @@ -1,4 +1,4 @@ -::: alchemy.curation.functional +::: auroris.curation.functional options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/types.md b/docs/api/types.md index 0ef9592..b722399 100644 --- a/docs/api/types.md +++ b/docs/api/types.md @@ -1,3 +1,3 @@ -::: alchemy.types +::: auroris.types options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/api/visualization.md b/docs/api/visualization.md index c4c7c66..7dafb14 100644 --- a/docs/api/visualization.md +++ b/docs/api/visualization.md @@ -1,3 +1,3 @@ -::: alchemy.visualization +::: auroris.visualization options: filters: ["!^_"] \ No newline at end of file diff --git a/docs/index.md b/docs/index.md index 4162166..e80fbeb 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,4 +1,4 @@ # Introduction -Welcome to the Alchemy documentation! +Welcome to the Auroris documentation! diff --git a/docs/tutorials/getting_started.ipynb b/docs/tutorials/getting_started.ipynb index 3950fec..4a03831 100644 --- a/docs/tutorials/getting_started.ipynb +++ b/docs/tutorials/getting_started.ipynb @@ -54,12 +54,12 @@ "source": [ "
    \n", "

    In short

    \n", - "

    This tutorial gives an overview of the basic concepts in the `alchemy` library.

    \n", + "

    This tutorial gives an overview of the basic concepts in the `auroris` library.

    \n", "
    \n", "\n", "
    \n", "

    On the nuances of curation

    \n", - "

    How to best curate a dataset is highly situation-dependent. The `alchemy` library includes some useful tools, but blindly applying them won't necessarily lead to good datasets. To learn more, visit the Polaris Hub for extensive resources and documentation on dataset curation and more.

    \n", + "

    How to best curate a dataset is highly situation-dependent. The `auroris` library includes some useful tools, but blindly applying them won't necessarily lead to good datasets. To learn more, visit the Polaris Hub for extensive resources and documentation on dataset curation and more.

    \n", "
    \n", "\n", "Data curation is concerned with analyzing and processing an existing dataset to maximize its quality. Within drug discovery, this can imply many things, such as filtering out outliers or flagging activity-cliffs. High-quality, well-curated datasets are the foundation upon which we can build realistic, impactful benchmarks for drug discovery. This notebook demonstrates how to curate your dataset with the Polaris data curation API for small molecules." @@ -78,7 +78,7 @@ "source": [ "## Curating a toy dataset\n", "\n", - "Let's learn about the basic concepts of the `alchemy` library by curating a toy dataset. For the sake of simplicity, we will use the solubility dataset from Datamol. It is worth noting that this dataset is only meant to be used as a toy dataset for pedagogic and testing purposes. It is not a dataset for benchmarking, analysis or model training. Curation can only take us so far. For impactful benchmarks, we rely on high-quality data sources to begin with." + "Let's learn about the basic concepts of the `auroris` library by curating a toy dataset. For the sake of simplicity, we will use the solubility dataset from Datamol. It is worth noting that this dataset is only meant to be used as a toy dataset for pedagogic and testing purposes. It is not a dataset for benchmarking, analysis or model training. Curation can only take us so far. For impactful benchmarks, we rely on high-quality data sources to begin with." ] }, { @@ -142,7 +142,7 @@ " \n", " \n", " 0\n", - " <rdkit.Chem.rdchem.Mol object at 0x75d39fd10510>\n", + " <rdkit.Chem.rdchem.Mol object at 0x1570f9d90>\n", " 1\n", " n-pentane\n", " -3.18\n", @@ -152,7 +152,7 @@ " \n", " \n", " 1\n", - " <rdkit.Chem.rdchem.Mol object at 0x75d39fd10660>\n", + " <rdkit.Chem.rdchem.Mol object at 0x1570f9ee0>\n", " 2\n", " cyclopentane\n", " -2.64\n", @@ -162,7 +162,7 @@ " \n", " \n", " 2\n", - " <rdkit.Chem.rdchem.Mol object at 0x75d39fd106d0>\n", + " <rdkit.Chem.rdchem.Mol object at 0x1570f9f50>\n", " 3\n", " n-hexane\n", " -3.84\n", @@ -172,7 +172,7 @@ " \n", " \n", " 3\n", - " <rdkit.Chem.rdchem.Mol object at 0x75d39fd10740>\n", + " <rdkit.Chem.rdchem.Mol object at 0x1570f9fc0>\n", " 4\n", " 2-methylpentane\n", " -3.74\n", @@ -182,7 +182,7 @@ " \n", " \n", " 4\n", - " <rdkit.Chem.rdchem.Mol object at 0x75d39fd107b0>\n", + " <rdkit.Chem.rdchem.Mol object at 0x1570fa030>\n", " 6\n", " 2,2-dimethylbutane\n", " -3.55\n", @@ -195,12 +195,12 @@ "" ], "text/plain": [ - " mol ID NAME \\\n", - "0 1 n-pentane \n", - "1 2 cyclopentane \n", - "2 3 n-hexane \n", - "3 4 2-methylpentane \n", - "4 6 2,2-dimethylbutane \n", + " mol ID NAME \\\n", + "0 1 n-pentane \n", + "1 2 cyclopentane \n", + "2 3 n-hexane \n", + "3 4 2-methylpentane \n", + "4 6 2,2-dimethylbutane \n", "\n", " SOL SOL_classification smiles split \n", "0 -3.18 (A) low CCCCC train \n", @@ -230,7 +230,7 @@ "## Using the `Curator` API\n", "The recommended way to specify curation workflows is through the `Curator` API:\n", "- A `Curator` object defines a number of curation steps.\n", - "- Each step should inherit from `alchemy.curation.actions.BaseAction`.\n", + "- Each step should inherit from `auroris.curation.actions.BaseAction`.\n", "- The `Curator` object is serializable. You can thus easily save and load it from JSON, which makes it easy to reproduce a curation workflow.\n", "- Finally, the `Curator` produces a `CurationReport` which summarizes the changes made to a dataset.\n", "\n", @@ -247,8 +247,8 @@ "metadata": {}, "outputs": [], "source": [ - "from alchemy.curation import Curator\n", - "from alchemy.curation.actions import MoleculeCuration, OutlierDetection, Discretization\n", + "from auroris.curation import Curator\n", + "from auroris.curation.actions import MoleculeCuration, OutlierDetection, Discretization\n", "\n", "# Define the curation workflow\n", "curator = Curator(\n", @@ -283,7 +283,7 @@ "output_type": "stream", "text": [ "\u001b[31;1m===== Curation Report =====\u001b[0m\n", - "\u001b[38;20mTime: 2024-04-26 12:55:14\u001b[0m\n", + "\u001b[38;20mTime: 2024-05-02 13:20:55\u001b[0m\n", "\u001b[38;20mVersion: dev\u001b[0m\n", "\u001b[34;1m===== MoleculeCuration =====\u001b[0m\n", "\u001b[38;20m[LOG]: Couldn't preprocess 18 / 1282 molecules.\u001b[0m\n", @@ -298,6 +298,7 @@ "\u001b[38;20m[LOG]: New column added: MOL_undefined_E_D\u001b[0m\n", "\u001b[38;20m[LOG]: New column added: MOL_undefined_E/Z\u001b[0m\n", "\u001b[38;20m[IMG]: Dimensions 1200 x 600\u001b[0m\n", + "\u001b[38;20m[IMG]: Dimensions None x None\u001b[0m\n", "\u001b[34;1m===== OutlierDetection =====\u001b[0m\n", "\u001b[38;20m[LOG]: New column added: OUTLIER_SOL\u001b[0m\n", "\u001b[38;20m[IMG]: Dimensions 2400 x 600\u001b[0m\n", @@ -307,7 +308,7 @@ } ], "source": [ - "from alchemy.report.broadcaster import LoggerBroadcaster\n", + "from auroris.report.broadcaster import LoggerBroadcaster\n", "\n", "broadcaster = LoggerBroadcaster(report)\n", "broadcaster.broadcast()" @@ -323,22 +324,14 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "9b896b12-fbae-4b7b-b62a-f2d2d15075c1", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[38;20mopen file: /home/cas/Desktop/report_html/report.html\u001b[0m\n" - ] - } - ], + "outputs": [], "source": [ - "from alchemy.report.broadcaster import HTMLBroadcaster\n", + "from auroris.report.broadcaster import HTMLBroadcaster\n", "\n", - "broadcaster = HTMLBroadcaster(report, \"/path/to/destination/\")\n", + "broadcaster = HTMLBroadcaster(report, \"/path/to/broadcaster\")\n", "broadcaster.broadcast()" ] }, @@ -359,25 +352,25 @@ { "data": { "text/plain": [ - "mol \n", - "ID 1\n", - "NAME n-pentane\n", - "SOL -3.18\n", - "SOL_classification (A) low\n", - "smiles CCCCC\n", - "split train\n", - "MOL_smiles CCCCC\n", - "MOL_molhash_id 3cb2e0cf1b50d8f954891abc5dcce90d543cd3d7\n", - "MOL_molhash_id_no_stereo 36551d628217a351e720cdbe676fca3067730a91\n", - "MOL_num_stereoisomers 1.0\n", - "MOL_num_undefined_stereoisomers 1.0\n", - "MOL_num_defined_stereo_center 0.0\n", - "MOL_num_undefined_stereo_center 0.0\n", - "MOL_num_stereo_center 0.0\n", - "MOL_undefined_E_D False\n", - "MOL_undefined_E/Z 0\n", - "OUTLIER_SOL 0.0\n", - "CLS_SOL 0.0\n", + "mol \n", + "ID 1\n", + "NAME n-pentane\n", + "SOL -3.18\n", + "SOL_classification (A) low\n", + "smiles CCCCC\n", + "split train\n", + "MOL_smiles CCCCC\n", + "MOL_molhash_id 3cb2e0cf1b50d8f954891abc5dcce90d543cd3d7\n", + "MOL_molhash_id_no_stereo 36551d628217a351e720cdbe676fca3067730a91\n", + "MOL_num_stereoisomers 1.0\n", + "MOL_num_undefined_stereoisomers 1.0\n", + "MOL_num_defined_stereo_center 0.0\n", + "MOL_num_undefined_stereo_center 0.0\n", + "MOL_num_stereo_center 0.0\n", + "MOL_undefined_E_D False\n", + "MOL_undefined_E/Z 0\n", + "OUTLIER_SOL 0.0\n", + "CLS_SOL 0.0\n", "Name: 0, dtype: object" ] }, @@ -402,7 +395,7 @@ }, "source": [ "### Using the functional API\n", - "`alchemy` provides a functional API to easily and quickly run some curation steps. Let's look at an oulier detection example." + "`auroris` provides a functional API to easily and quickly run some curation steps. Let's look at an oulier detection example." ] }, { @@ -419,7 +412,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
    " ] @@ -429,8 +422,8 @@ } ], "source": [ - "from alchemy.curation.functional import detect_outliers\n", - "from alchemy.visualization import visualize_distribution_with_outliers\n", + "from auroris.curation.functional import detect_outliers\n", + "from auroris.visualization import visualize_distribution_with_outliers\n", "\n", "y = dataset[\"SOL\"].values\n", "is_outlier = detect_outliers(y)\n", @@ -444,6 +437,12 @@ "source": [ "The End. " ] + }, + { + "cell_type": "markdown", + "id": "e5b79da1", + "metadata": {}, + "source": [] } ], "metadata": { diff --git a/env.yml b/env.yml index 162b3a3..841c1c9 100644 --- a/env.yml +++ b/env.yml @@ -21,6 +21,10 @@ dependencies: # Chemistry - datamol >=0.12.1 + # Visualization + - umap-learn + # - tmap + # Optional - gcsfs diff --git a/mkdocs.yml b/mkdocs.yml index 75c0737..ee47e12 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,8 +1,8 @@ -site_name: "Alchemy" +site_name: "Auroris" site_description: "Tools for data curation for drug discovery datasets." -site_url: "https://github.com/polaris-hub/alchemy" -repo_url: "https://github.com/polaris-hub/alchemy" -repo_name: "polaris-hub/alchemy" +site_url: "https://github.com/polaris-hub/auroris" +repo_url: "https://github.com/polaris-hub/auroris" +repo_name: "polaris-hub/auroris" copyright: Copyright 2023 - 2024 Polaris remote_branch: "gh-pages" @@ -14,7 +14,7 @@ strict: true nav: - Getting started: - - Alchemy: index.md + - Auroris: index.md - Tutorials: - Getting Started: tutorials/getting_started.ipynb - API Reference: @@ -50,7 +50,7 @@ theme: logo: images/logo-white.svg extra_css: - - assets/css/custom-alchemy.css + - assets/css/custom-auroris.css extra_javascript: - https://polyfill.io/v3/polyfill.min.js?features=es6 @@ -78,7 +78,7 @@ markdown_extensions: pygments_lang_class: true watch: - - alchemy/ + - auroris/ plugins: - search @@ -89,7 +89,7 @@ plugins: setup_commands: - import sys - sys.path.append("docs") - - sys.path.append("alchemy") + - sys.path.append("auroris") options: show_root_heading: yes heading_level: 3 diff --git a/pyproject.toml b/pyproject.toml index 19c6a55..0bfc7ab 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -3,7 +3,7 @@ requires = ["setuptools", "setuptools-scm"] build-backend = "setuptools.build_meta" [project] -name = "alchemy-lib" +name = "auroris" description = "Data Curation in Polaris" dynamic = ["version"] authors = [ @@ -66,13 +66,13 @@ doc = [ ] [project.scripts] -alchemy = "alchemy.cli:app" +auroris = "auroris.cli:app" [project.urls] Website = "https://polarishub.io/" -"Source Code" = "https://github.com/polaris-hub/alchemy" -"Bug Tracker" = "https://github.com/polaris-hub/alchemy/issues" -Documentation = "https://polaris-hub.github.io/alchemy/" +"Source Code" = "https://github.com/polaris-hub/auroris" +"Bug Tracker" = "https://github.com/polaris-hub/auroris/issues" +Documentation = "https://polaris-hub.github.io/auroris/" [tool.setuptools] include-package-data = true @@ -82,26 +82,26 @@ fallback_version = "dev" [tool.setuptools.packages.find] where = ["."] -include = ["alchemy", "alchemy.*"] +include = ["auroris", "auroris.*"] exclude = [] namespaces = false [tool.pytest.ini_options] minversion = "7.0" -addopts = "--verbose --durations=10 -n auto --cov=alchemy --cov-fail-under=75 --cov-report xml --cov-report term" +addopts = "--verbose --durations=10 -n auto --cov=auroris --cov-fail-under=75 --cov-report xml --cov-report term" testpaths = ["tests"] pythonpath = "." filterwarnings = ["ignore::DeprecationWarning:jupyter_client.connect.*:"] [tool.coverage.run] -source = ["alchemy/"] +source = ["auroris/"] disable_warnings = ["no-data-collected"] data_file = ".coverage/coverage" [tool.coverage.report] omit = [ - "alchemy/__init__.py", - "alchemy/_version.py", + "auroris/__init__.py", + "auroris/_version.py", ] [tool.coverage.xml] diff --git a/tests/test_curator.py b/tests/test_curator.py index cfb9b6c..221b934 100644 --- a/tests/test_curator.py +++ b/tests/test_curator.py @@ -1,8 +1,13 @@ import os -from alchemy.curation import Curator -from alchemy.curation.actions import Discretization, MoleculeCuration, OutlierDetection -from alchemy.report.broadcaster import HTMLBroadcaster, LoggerBroadcaster +from auroris.curation import Curator +from auroris.curation.actions import Discretization, MoleculeCuration, OutlierDetection +from auroris.report.broadcaster import HTMLBroadcaster, LoggerBroadcaster + +try: + import jinja2 +except ImportError: + jinja2 = None def test_curator_save_load(tmpdir): @@ -35,5 +40,6 @@ def test_curator_integration(dataset, tmpdir): broadcaster = LoggerBroadcaster(report) broadcaster.broadcast() - broadcaster = HTMLBroadcaster(report, tmpdir) - broadcaster.broadcast() + if jinja2: + broadcaster = HTMLBroadcaster(report, tmpdir) + broadcaster.broadcast() diff --git a/tests/test_deduplication.py b/tests/test_deduplication.py index 6008d13..ce082fb 100644 --- a/tests/test_deduplication.py +++ b/tests/test_deduplication.py @@ -1,7 +1,7 @@ import numpy as np import pandas as pd -from alchemy.curation.functional import deduplicate +from auroris.curation.functional import deduplicate def test_deduplicate(): diff --git a/tests/test_discretization.py b/tests/test_discretization.py index df00bed..0324e2d 100644 --- a/tests/test_discretization.py +++ b/tests/test_discretization.py @@ -1,7 +1,7 @@ import numpy as np import pytest -from alchemy.curation.functional import discretize +from auroris.curation.functional import discretize def test_discretizer(): diff --git a/tests/test_mol_curation.py b/tests/test_mol_curation.py index f396347..4735995 100644 --- a/tests/test_mol_curation.py +++ b/tests/test_mol_curation.py @@ -1,7 +1,7 @@ import datamol as dm -from alchemy.curation.actions._mol import _num_stereo_centers -from alchemy.curation.functional import curate_molecules +from auroris.curation.actions._mol import _num_stereo_centers +from auroris.curation.functional import curate_molecules def test_run_chemistry_curation(): diff --git a/tests/test_outlier_detection.py b/tests/test_outlier_detection.py index 4d1f622..4169d63 100644 --- a/tests/test_outlier_detection.py +++ b/tests/test_outlier_detection.py @@ -2,8 +2,8 @@ import pandas as pd import pytest -from alchemy.curation.actions import OutlierDetection -from alchemy.curation.functional import detect_outliers +from auroris.curation.actions import OutlierDetection +from auroris.curation.functional import detect_outliers @pytest.mark.parametrize("method", ["iso", "lof", "svm", "ee", "zscore"]) diff --git a/tests/test_stereoisomer_ac.py b/tests/test_stereoisomer_ac.py index 30c92ba..db2f09a 100644 --- a/tests/test_stereoisomer_ac.py +++ b/tests/test_stereoisomer_ac.py @@ -1,7 +1,7 @@ import numpy as np import pandas as pd -from alchemy.curation.functional import detect_streoisomer_activity_cliff +from auroris.curation.functional import detect_streoisomer_activity_cliff def test_identify_stereoisomers_with_activity_cliff(): @@ -15,7 +15,7 @@ def test_identify_stereoisomers_with_activity_cliff(): df = detect_streoisomer_activity_cliff( dataset=data, stereoisomer_id_col="groupby_col", - threshold=1.0, + threshold=3, y_cols=["data_col"], ) # check if identifed ids are correct