Skip to content

taps.apps.docking.train

Protein docking model training.

Module adapted from ParslDock.

MorganFingerprintTransformer 

MorganFingerprintTransformer(
    length: int = 256, radius: int = 4
)

Bases: BaseEstimator, TransformerMixin

Class that converts SMILES strings to fingerprint vectors.

Source code in taps/apps/docking/train.py 
61
62
63
def __init__(self, length: int = 256, radius: int = 4):
    self.length = length
    self.radius = radius

fit 

fit(
    X: list[str], y: NDArray[bool] | None = None
) -> MorganFingerprintTransformer

Train model.

Parameters:

  • X (list[str]) –

    List of SMILES strings.

  • y (NDArray[bool] | None, default: None ) –

    Array of true fingerprints.

Returns:

Source code in taps/apps/docking/train.py 
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
def fit(
    self,
    X: list[str],  # noqa: N803
    y: NDArray[numpy.bool] | None = None,
) -> MorganFingerprintTransformer:
    """Train model.

    Args:
        X: List of SMILES strings.
        y: Array of true fingerprints.

    Returns:
        The trained model.
    """
    return self  # Don't need to do anything

transform 

transform(
    X: list[str], y: NDArray[bool] | None = None
) -> list[NDArray[bool]]

Compute the fingerprints.

Parameters:

  • X (list[str]) –

    List of SMILES strings.

  • y (NDArray[bool] | None, default: None ) –

    Array of true fingerprints.

Returns:

Source code in taps/apps/docking/train.py 
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
def transform(
    self,
    X: list[str],  # noqa: N803
    y: NDArray[numpy.bool] | None = None,
) -> list[NDArray[numpy.bool]]:
    """Compute the fingerprints.

    Args:
        X: List of SMILES strings.
        y: Array of true fingerprints.

    Returns:
        Array of predicted fingerprints.
    """
    fps = []
    for x in X:
        fp = compute_morgan_fingerprints(x, self.length, self.radius)
        fps.append(fp)

    return fps

compute_morgan_fingerprints 

compute_morgan_fingerprints(
    smiles: str,
    fingerprint_length: int,
    fingerprint_radius: int,
) -> NDArray[bool]

Get Morgan Fingerprint of a specific SMILES string.

Adapted from: https://github.com/google-research/google-research/blob/> dfac417/mol_dqn/chemgraph/dqn/deep_q_networks.py#L750

Parameters:

  • smiles (str) –

    The molecule as a SMILES string.

  • fingerprint_length (int) –

    Bit-length of fingerprint.

  • fingerprint_radius (int) –

    Radius used to compute fingerprint.

Returns:

  • NDArray[bool] –

    Array containing the Morgan fingerprint with shape

  • NDArray[bool] –

    [hparams, fingerprint_length].

Source code in taps/apps/docking/train.py 
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
def compute_morgan_fingerprints(
    smiles: str,
    fingerprint_length: int,
    fingerprint_radius: int,
) -> NDArray[numpy.bool]:
    """Get Morgan Fingerprint of a specific SMILES string.

    Adapted from: https://github.com/google-research/google-research/blob/>
    dfac4178ccf521e8d6eae45f7b0a33a6a5b691ee/mol_dqn/chemgraph/dqn/deep_q_networks.py#L750

    Args:
        smiles: The molecule as a SMILES string.
        fingerprint_length: Bit-length of fingerprint.
        fingerprint_radius: Radius used to compute fingerprint.

    Returns:
        Array containing the Morgan fingerprint with shape
        `[hparams, fingerprint_length]`.
    """
    from rdkit import Chem
    from rdkit import DataStructs
    from rdkit.Chem import rdFingerprintGenerator

    # Parse the molecule
    molecule = Chem.MolFromSmiles(smiles)

    # Compute the fingerprint
    mfpgen = rdFingerprintGenerator.GetMorganGenerator(
        radius=fingerprint_radius,
        fpSize=fingerprint_length,
    )
    fingerprint = mfpgen.GetFingerprint(
        molecule,
    )
    arr = numpy.zeros((1,), dtype=bool)

    # ConvertToNumpyArray takes ~ 0.19 ms, while
    # numpy.asarray takes ~ 4.69 ms
    DataStructs.ConvertToNumpyArray(fingerprint, arr)
    return arr

train_model 

train_model(training_data: DataFrame) -> Pipeline

Train a machine learning model using Morgan Fingerprints.

Parameters:

  • training_data (DataFrame) –

    Dataframe with a 'smiles' and 'score' column that contains molecule structure and docking score, respectfully.

Returns:

  • Pipeline –

    A trained model.

Source code in taps/apps/docking/train.py 
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
def train_model(training_data: pandas.DataFrame) -> Pipeline:
    """Train a machine learning model using Morgan Fingerprints.

    Args:
        training_data: Dataframe with a 'smiles' and 'score' column
            that contains molecule structure and docking score, respectfully.

    Returns:
        A trained model.
    """
    from sklearn.neighbors import KNeighborsRegressor
    from sklearn.pipeline import Pipeline

    model = Pipeline(
        [
            ('fingerprint', MorganFingerprintTransformer()),
            (
                'knn',
                KNeighborsRegressor(
                    n_neighbors=4,
                    weights='distance',
                    metric='jaccard',
                    n_jobs=-1,
                ),
            ),
        ],
    )

    return model.fit(training_data['smiles'], training_data['score'])

run_model 

run_model(model: Pipeline, smiles: list[str]) -> DataFrame

Run a model on a list of smiles strings.

Parameters:

  • model (Pipeline) –

    Trained model that takes SMILES strings as inputs.

  • smiles (list[str]) –

    List of molecules to evaluate.

Returns:

  • DataFrame –

    A dataframe with the molecules and their predicted outputs

Source code in taps/apps/docking/train.py 
134
135
136
137
138
139
140
141
142
143
144
145
146
147
def run_model(model: Pipeline, smiles: list[str]) -> pandas.DataFrame:
    """Run a model on a list of smiles strings.

    Args:
        model: Trained model that takes SMILES strings as inputs.
        smiles: List of molecules to evaluate.

    Returns:
        A dataframe with the molecules and their predicted outputs
    """
    import pandas

    pred_y = model.predict(smiles)
    return pandas.DataFrame({'smiles': smiles, 'score': pred_y})