RuleOfThreeFilter#

class skfp.filters.RuleOfThreeFilter(extended: bool = False, allow_one_violation: bool = False, return_type: str = 'mol', n_jobs: int | None = None, batch_size: int | None = None, verbose: int | dict = 0)#

Rule of three (Ro3).

Rule optimized to search for fragment-based lead-like compounds with desired properties. It was described in [1].

Molecule must fulfill conditions:

molecular weight <= 300
HBA <= 3
HBD <= 3
logP <= 3

Additionally, an extended version of this rule has been proposed, which adds two conditions:

number of rotatable bonds <= 3
TPSA <= 60

Parameters:

extended (bool, default=False) – Whether to use an extended version of this rule, additionally including TPSA and rotatable bonds conditions.
allow_one_violation (bool, default=False) – Whether to allow violating one of the rules for a molecule. This makes the filter less restrictive.
return_type ({"mol", "indicators", "condition_indicators"}, default="mol") –
What values to return as the filtering result.
- "mol" - return a list of molecules remaining in the dataset after filtering
- "indicators" - return a binary vector with indicators which molecules pass the filter (1) and which would be removed (0)
- "condition_indicators" - return a Pandas DataFrame with molecules in rows, filter conditions in columns, and 0/1 indicators whether a given condition was fulfilled by a given molecule
n_jobs (int, default=None) – The number of jobs to run in parallel. transform_x_y() and transform() are parallelized over the input molecules. None means 1 unless in a joblib.parallel_backend context. -1 means using all processors. See scikit-learn documentation on n_jobs for more details.
batch_size (int, default=None) – Number of inputs processed in each batch. None divides input data into equal-sized parts, as many as n_jobs.
verbose (int or dict, default=0) – Controls the verbosity when filtering molecules. If a dictionary is passed, it is treated as kwargs for tqdm(), and can be used to control the progress bar.

References

Examples

>>> from skfp.filters import RuleOfThreeFilter
>>> smiles = ['C=CCNC(=S)NCc1ccccc1OC', 'C=CCOc1ccc(Br)cc1/C=N/O', 'C=CCNc1ncnc2ccccc12']
>>> filt = RuleOfThreeFilter()
>>> filt
RuleOfThreeFilter()
>>> filtered_mols = filt.transform(smiles)
>>> filtered_mols
['C=CCNC(=S)NCc1ccccc1OC', 'C=CCOc1ccc(Br)cc1/C=N/O', 'C=CCNc1ncnc2ccccc12']
>>> filt = RuleOfThreeFilter(extended=True)
>>> filtered_mols = filt.transform(smiles)
>>> filtered_mols
['C=CCNc1ncnc2ccccc12']

Methods

`fit`(X[, y])	Unused, kept for scikit-learn compatibility.
`fit_transform`(X[, y])	The same as `.transform()` method, kept for scikit-learn compatibility.
`get_feature_names_out`([input_features])	Get filter condition names.
`get_metadata_routing`()	Get metadata routing of this object.
`get_params`([deep])	Get parameters for this estimator.
`set_output`(*[, transform])	Set output container.
`set_params`(**params)	Set the parameters of this estimator.
`set_transform_request`(*[, copy])	Configure whether metadata should be requested to be passed to the `transform` method.
`transform`(X[, copy])	Apply a filter to input molecules.
`transform_x_y`(X, y[, copy])	Apply a filter to input molecules.

fit(X: Sequence[str | Mol], y: ndarray | None = None)#

Unused, kept for scikit-learn compatibility.

Parameters:

X (any) – Unused, kept for scikit-learn compatibility.
y (any) – Unused, kept for scikit-learn compatibility.

Return type:

self

fit_transform(X: Sequence[str | Mol], y: ndarray | None = None, **fit_params)#

The same as .transform() method, kept for scikit-learn compatibility.

Parameters:

X (any) – See .transform() method.
y (any) – See .transform() method.
**fit_params (dict) – Unused, kept for scikit-learn compatibility.

Returns:

X_new – See .transform() method.

Return type:

any

get_feature_names_out(input_features=None) → ndarray#

Get filter condition names. They correspond to molecular descriptors (for physicochemical filters) or SMARTS patterns (for substructural filters).

Parameters:: input_features (array-like of str or None, default=None) – Unused, kept for scikit-learn compatibility.
Returns:: feature_names_out – Filter condition names.
Return type:: ndarray of str objects

get_metadata_routing()#

Get metadata routing of this object.

Please check User Guide on how the routing mechanism works.

Returns:: routing – A MetadataRequest encapsulating routing information.
Return type:: MetadataRequest

get_params(deep=True)#

Get parameters for this estimator.

Parameters:: deep (bool, default=True) – If True, will return the parameters for this estimator and contained subobjects that are estimators.
Returns:: params – Parameter names mapped to their values.
Return type:: dict

set_output(*, transform=None)#

Set output container.

See Introducing the set_output API for an example on how to use the API.

Parameters:

transform ({"default", "pandas", "polars"}, default=None) –

Configure output of transform and fit_transform.

”default”: Default output format of a transformer
”pandas”: DataFrame output
”polars”: Polars output
None: Transform configuration is unchanged

Added in version 1.4: “polars” option was added.

Returns:

self – Estimator instance.

Return type:

estimator instance

set_params(**params)#

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as Pipeline). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Parameters:: **params (dict) – Estimator parameters.
Returns:: self – Estimator instance.
Return type:: estimator instance

set_transform_request(*, copy: bool | None | str = '$UNCHANGED$') → RuleOfThreeFilter#

Configure whether metadata should be requested to be passed to the transform method.

Note that this method is only relevant when this estimator is used as a sub-estimator within a meta-estimator and metadata routing is enabled with enable_metadata_routing=True (see sklearn.set_config()). Please check the User Guide on how the routing mechanism works.

The options for each parameter are:

True: metadata is requested, and passed to transform if provided. The request is ignored if metadata is not provided.
False: metadata is not requested and the meta-estimator will not pass it to transform.
None: metadata is not requested, and the meta-estimator will raise an error if the user provides it.
str: metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default (sklearn.utils.metadata_routing.UNCHANGED) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Parameters:: copy (str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED) – Metadata routing for copy parameter in transform.
Returns:: self – The updated object.
Return type:: object

transform(X: Sequence[str | Mol], copy: bool = False) → list[str | Mol] | ndarray#

Apply a filter to input molecules. Output depends on return_type attribute.

Parameters:

X ({sequence of str or Mol}) – Sequence containing SMILES strings or RDKit Mol objects.
copy (bool, default=False) – Copy the input X or not.

Returns:

X – or array of shape (n_samples, n_conditions) List with filtered molecules or indicators.

Return type:

list of shape (n_samples,) or array of shape (n_samples,)

transform_x_y(X: Sequence[str | Mol], y: ndarray, copy: bool = False) → tuple[list[str | Mol], ndarray] | tuple[ndarray, ndarray]#

Apply a filter to input molecules. Output depends on return_type attribute.

Parameters:

X ({sequence of str or Mol}) – Sequence containing SMILES strings or RDKit Mol objects.
y (array-like of shape (n_samples,)) – Array with labels for molecules.
copy (bool, default=False) – Copy the input X or not.

Returns:

X (list of shape (n_samples,) or array of shape (n_samples,)) – or array of shape (n_samples, n_conditions) List with filtered molecules or indicators.
y (np.ndarray of shape (n_samples,)) – Array with labels for molecules.