#Welcome to the deepchem tutorial. In this iPython Notebook, one can follow along with the code below to learn how to fit machine learning models with rich predictive power on chemical datasets.
%% Cell type:markdown id: tags:
Overview:
In this tutorial, you will trace an arc from loading a raw dataset to fitting a cutting edge ML technique for predicting binding affinities. This will be accomplished by writing simple commands to access the deepchem Python API, encompassing the following broad steps:
1. Loading a chemical dataset, consisting of a series of protein-ligand complexes.
2. Featurizing each protein-ligand complexes with various featurization schemes.
3. Fitting a series of models with these featurized protein-ligand complexes.
4. Visualizing the results.
%% Cell type:markdown id: tags:
First, let's point to a "dataset" file. This can come in the format of a CSV file or Pandas DataFrame. Regardless
of file format, it must be columnar data, where each row is a molecular system, and each column represents
a different piece of information about that system. For instance, in this example, every row reflects a
protein-ligand complex, and the following columns are present: a unique complex identifier; the SMILES string
of the ligand; the binding affinity (Ki) of the ligand to the protein in the complex; a Python `list` of all lines
in a PDB file for the protein alone; and a Python `list` of all lines in a ligand file for the ligand alone.
This should become clearer with the example.
%% Cell type:code id: tags:
``` python
dataset_file="../datasets/pdbbind_core_df.pkl.gz"
fromdeepchem.utils.saveimportload_from_disk
dataset=load_from_disk(dataset_file)
```
%% Cell type:markdown id: tags:
Let's see what `dataset` looks like:
%% Cell type:code id: tags:
``` python
print("Type of dataset is: %s"%str(type(dataset)))
print("Columns of dataset are: %s"%str(dataset.columns.values))
print("Shape of dataset is: %s"%str(dataset.shape))
```
%% Output
Type of dataset is: <class 'pandas.core.frame.DataFrame'>
Columns of dataset are: ['pdb_id' 'smiles' 'complex_id' 'protein_pdb' 'ligand_pdb' 'ligand_mol2'
'label']
Shape of dataset is: (193, 7)
%% Cell type:markdown id: tags:
So, let's take a quick look at the first molecule. The first complex contains a protein with a PDB ID of:
%% Cell type:code id: tags:
``` python
complex_1=dataset.iterrows().next()[1]
complex_1["pdb_id"]
```
%% Output
'2d3u'
%% Cell type:markdown id: tags:
, and contains a ligand with a SMILES string of:
%% Cell type:code id: tags:
``` python
complex_1["smiles"]
```
%% Output
'CC1CCCCC1S(O)(O)NC1CC(C2CCC(CN)CC2)SC1C(O)O'
%% Cell type:markdown id: tags:
This complex has a `Ki` of:
%% Cell type:code id: tags:
``` python
complex_1['label']
```
%% Output
'6.92'
%% Cell type:markdown id: tags:
Now that we're oriented, let's use ML to do some chemistry.
So, step (2) will entail featurizing the dataset.
The available featurizations that come standard with deepchem are ECFP4 fingerprints, RDKit descriptors, and NNScore binding pocket descriptors.
Note how we separate our featurizers into those that featurize individual chemical compounds, compound_featurizers, and those that featurize molecular complexes, complex_featurizers.
Now, let's perform the actual featurization. Calling ```featurizer.featurize()``` will return an instance of class ```FeaturizedSamples```. Internally, ```featurizer.featurize()``` (a) computes the user-specified features on the data, (b) transforms the inputs into X and y NumPy arrays suitable for ML algorithms, and (c) constructs a ```FeaturizedSamples()``` instance that has useful methods, such as an iterator, over the featurized data.
%% Cell type:code id: tags:
``` python
#Make a directory in which to store the featurized complexes.
Now, we conduct a train-test split. If you'd like, you can choose `splittype="scaffold"` instead to perform a train-test split based on Bemis-Murcko scaffolds.
We generate separate instances of the Dataset() object to hermetically seal the train dataset from the test dataset. This style lends itself easily to validation-set type hyperparameter searches, which we will illustate in a separate tutorial.
Now, we're ready to do some learning! To set up a model, we will need: (a) a dictionary ```task_types``` that maps a task, in this case ```label```, i.e. the Ki, to the type of the task, in this case ```regression```. For the multitask use case, one will have a series of keys, each of which is a different task (Ki, solubility, renal half-life, etc.) that maps to a different task type (regression or classification).
To fit a deepchem model, first we instantiate one of the provided (or user-written) model classes. In this case, we have a created a convenience class to wrap around any ML model available in Sci-Kit Learn that can in turn be used to interoperate with deepchem. To instantiate an ```SklearnModel```, you will need (a) task_types, (b) model_params, another ```dict``` as illustrated below, and (c) a ```model_instance``` defining the type of model you would like to fit, in this case a ```RandomForestRegressor```.
Saving predictions to <open file '<fdopen>', mode 'w+b' at 0x7f9aeae9ac00>
Saving model performance scores to <open file '<fdopen>', mode 'w+b' at 0x7f9aeae9ab70>
%% Cell type:code id: tags:
``` python
r2score
```
%% Output
task_name r2_score rms_error
0 label 0.826262 0.939944
%% Cell type:markdown id: tags:
While we have computed three separate featurizations -- ECFP4, RDKitDescriptors, and NNScore -- in this example we choose to use the RDKitDescriptors featurization. This will serve as a baseline as you apply more advanced featurization schemes.
%% Cell type:markdown id: tags:
It is essential for many ML methods, depending on the data type, to perform preprocessing in order to attain optimal performance. Here, we choose to normalize and truncate the inputs (X, the featurized complexes) while normalizing the output (y, the binding affinities):
%% Cell type:markdown id: tags:
To recap, the initial dataset has now been featurized, split into train and test sets, and transformed. We are now ready to learn some chemistry! To warm up, let's apply a more traditional but quite robust statistical learning technique: random forests.
%% Cell type:markdown id: tags:
Now that we've fit an Random Forest Regressor on the data, let's evaluate its performance:
%% Cell type:markdown id: tags:
Let's compare this to performance with a deep neural network.
