PharmacophoreFingerprint#

class skfp.fingerprints.PharmacophoreFingerprint(variant: str = 'raw_bits', min_points: int = 2, max_points: int = 3, fp_size: int = 2048, use_3D: bool = False, count: bool = False, sparse: bool = False, n_jobs: int | None = None, batch_size: int | None = None, verbose: int | dict = 0)#

Pharmacophore fingerprint.

The implementation uses RDKit. This is a hashed fingerprint, where fragments are computed based on N-point tuples, using pharmacophoric points.

An N-point pharmacophoric structure encodes N pharmacophoric points and pairwise distances between them, e.g. 3-point pharmacophore uses 6-element tuples (P1 D12 P2 D23 P3 D13). P is a pharmacophoric point, atom or subgraph, of a particular type (see below), and Dij is a topological distance (shortest path) between points i and j. Distance values are limited to 8 (higher values are capped at 8).

Pharmacophoric point types are (based on SMARTS patterns definitions from [1]): - hydrophobic atom - hydrogen bond donor - hydrogen bond acceptor - aromatic attachment - aliphatic attachment - “unusual” atom (not H, C, N, O, F, S, Cl, Br, I) - basic group - acidic group

By default, 2-point and 3-point pharmacophores are used, resulting in 39972-element vector. Alternatively, folding can be applied. Note that due to RDKit limitations, only 2-point and 3-point variants are available.

Note that this is by far the slowest fingerprint, particularly for larger molecules. This is due to the 3-point pharmacophore calculation. Consider filtering out large (heavy) molecules or setting max_points=2 if it takes too long.

Parameters:

  • variant ({"raw_bits", "folded"} = "raw_bits") – Whether to return raw bit values, or to fold them. Length of raw bits variant depends on used N-points, see n_features_out attribute.

  • min_points (int, default=2) – Lower bound of N-point pharmacophore. Must be 2 or 3, and less or equal to max_points.

  • max_points (int, default=3) – Upper bound of N-point pharmacophore. Must be 2 or 3, and greater or equal to min_points.

  • fp_size (int, default=2048) – Size of output vectors, i.e. number of bits for each fingerprint. Only used for “folded” variant. Must be positive.

  • use_3D (bool, default=False) – Whether to use 3D Euclidean distance matrix, instead of topological distance. Binning is used to discretize values into values 0-8.

  • count (bool, default=False) – Whether to return binary (bit) features, or their counts.

  • sparse (bool, default=False) – Whether to return dense NumPy array, or sparse SciPy CSR array.

  • n_jobs (int, default=None) – The number of jobs to run in parallel. transform() is 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 computing fingerprints. If a dictionary is passed, it is treated as kwargs for tqdm(), and can be used to control the progress bar.

n_features_out#

Number of output features, size of fingerprints. For "folded" variant, it is equal to fp_size. For "raw_bits" variant, it depends on min_points and max_points: 252 for (2,2), 39720 for (3,3), and 39972 for (2,3).

Type:

int, default=39972

requires_conformers#

Whether the fingerprint is 3D-based and requires molecules with conformers as inputs, with conf_id integer property set. This depends on the use_3D parameter, and has the same value.

Type:

bool

References

Examples

>>> from skfp.fingerprints import PharmacophoreFingerprint
>>> smiles = ["O", "CC", "[C-]#N", "CC=O"]
>>> fp = PharmacophoreFingerprint()
>>> fp
PharmacophoreFingerprint()

>>> fp.transform(smiles)
array([[0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0]], shape=(4, 39972), dtype=uint8)

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 output feature names for transformation.

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])

Compute MACCS fingerprints.
fit(X: Sequence[str | Mol], y: Any | None = None, **fit_params)#

Unused, kept for scikit-learn compatibility.

Parameters:

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

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

  • **fit_params (dict) – Unused, kept for scikit-learn compatibility.

Return type:

self

fit_transform(X: Sequence[str | Mol], y: Any | 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)#

Get output feature names for transformation.

The feature names out will prefixed by the lowercased class name. For example, if the transformer outputs 3 features, then the feature names out are: [“class_name0”, “class_name1”, “class_name2”].

Parameters:

input_features (array-like of str or None, default=None) – Only used to validate feature names with the names seen in fit.

Returns:

feature_names_out – Transformed feature 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$') → PharmacophoreFingerprint#

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) → ndarray | csr_array#

Compute MACCS fingerprints. Output shape depends on min_points and max_points parameters.

Parameters:

  • X ({sequence, array-like} of shape (n_samples,)) – Sequence containing SMILES strings or RDKit Mol objects.

  • copy (bool, default=False) – Copy the input X or not.

Returns:

X – Array with fingerprints.

Return type:

{ndarray, sparse matrix} of shape (n_samples, self.n_features_out)