Fixing quantum notebook

%% Cell type:markdown id: tags:

Setting up imports

%% Cell type:code id: tags:

``` python

%load_ext autoreload

%autoreload 2

%pdb off

"""

Not Currently Working

"""

from __future__ import print_function

from __future__ import division

from __future__ import unicode_literals

__author__ = "Joseph Gomes"

__author__ = "Joseph Gomes and Bharath Ramsundar"

__copyright__ = "Copyright 2016, Stanford University"

__license__ = "LGPL"

import os

import unittest

import tempfile

import shutil

import numpy as np

import deepchem as dc

import numpy.random

from deepchem import metrics

from deepchem.data.datasets import Dataset

from deepchem.featurizers.featurize import DataFeaturizer

from deepchem.featurizers.featurize import FeaturizedSamples

from deepchem.hyperparameters import HyperparamOpt

from deepchem.metrics import Metric

from deepchem.models import Model

from deepchem.models.sklearn_models import SklearnModel

from deepchem.transformers import NormalizationTransformer

from deepchem.utils.evaluate import Evaluator

from sklearn.ensemble import RandomForestRegressor

from sklearn.kernel_ridge import KernelRidge

```

%% Output

    The autoreload extension is already loaded. To reload it, use:

      %reload_ext autoreload

    Automatic pdb calling has been turned OFF

    ---------------------------------------------------------------------------

    ImportError                               Traceback (most recent call last)

    <ipython-input-2-a6ac7c9c202f> in <module>()

         20 from deepchem import metrics

         21 from deepchem.data.datasets import Dataset

    ---> 22 from deepchem.featurizers.featurize import DataFeaturizer

         23 from deepchem.featurizers.featurize import FeaturizedSamples

         24 from deepchem.hyperparameters import HyperparamOpt

    ImportError: No module named featurizers.featurize

%% Cell type:markdown id: tags:

Creating temporary directories

%% Cell type:code id: tags:

``` python

feature_dir = tempfile.mkdtemp()

samples_dir = tempfile.mkdtemp()

train_dir = tempfile.mkdtemp()

valid_dir = tempfile.mkdtemp()

test_dir = tempfile.mkdtemp()

model_dir = tempfile.mkdtemp()

```

%% Cell type:markdown id: tags:

Setting up model variables

%% Cell type:code id: tags:

``` python

from deepchem.featurizers.coulomb_matrices import CoulombMatrixEig

compound_featurizers = [CoulombMatrixEig(23, remove_hydrogens=False)]

complex_featurizers = []

featurizer = dc.feat.CoulombMatrixEig(23, remove_hydrogens=False)

tasks = ["atomization_energy"]

task_type = "regression"

task_types = {task: task_type for task in tasks}

input_file = "../datasets/gdb1k.sdf"

dataset_file = "../../datasets/gdb1k.sdf"

smiles_field = "smiles"

mol_field = "mol"

```

%% Cell type:markdown id: tags:

Load featurized data

%% Cell type:code id: tags:

``` python

featurizers = compound_featurizers + complex_featurizers

featurizer = DataFeaturizer(tasks=tasks,

                            smiles_field=smiles_field,

                            mol_field=mol_field,

                            compound_featurizers=compound_featurizers,

                            complex_featurizers=complex_featurizers, verbosity="high")

```

%% Cell type:code id: tags:

``` python

featurized_samples = featurizer.featurize(input_file, feature_dir, samples_dir)

loader = dc.data.SDFLoader(

      tasks=["atomization_energy"], smiles_field="smiles",

      featurizer=featurizer,

      mol_field="mol")

dataset = loader.featurize(dataset_file)

```

%% Cell type:markdown id: tags:

Perform Train, Validation, and Testing Split

%% Cell type:code id: tags:

``` python

from deepchem.splits import RandomSplitter

random_splitter = RandomSplitter()

train_samples, valid_samples, test_samples = random_splitter.train_valid_test_split(featurized_samples,

    train_dir, valid_dir, test_dir)

```

%% Cell type:markdown id: tags:

Creating datasets

%% Cell type:code id: tags:

``` python

train_dataset = Dataset(data_dir=train_dir, samples=train_samples,

                        featurizers=featurizers, tasks=tasks)

valid_dataset = Dataset(data_dir=valid_dir, samples=valid_samples,

                        featurizers=featurizers, tasks=tasks)

test_dataset = Dataset(data_dir=test_dir, samples=test_samples,

                       featurizers=featurizers, tasks=tasks)

random_splitter = dc.splits.RandomSplitter()

train_dataset, valid_dataset, test_dataset = random_splitter.train_valid_test_split(dataset)

```

%% Cell type:markdown id: tags:

Transforming datasets

%% Cell type:code id: tags:

``` python

input_transformers = [NormalizationTransformer(transform_X=True, dataset=train_dataset)]

output_transformers = [NormalizationTransformer(transform_y=True, dataset=train_dataset)]

transformers = input_transformers + output_transformers

for transformer in transformers:

    transformer.transform(train_dataset)

for transformer in transformers:

    transformer.transform(valid_dataset)

for transformer in transformers:

    transformer.transform(test_dataset)

transformers = [

    dc.trans.NormalizationTransformer(transform_X=True, dataset=train_dataset),

    dc.trans.NormalizationTransformer(transform_y=True, dataset=train_dataset)]

for dataset in [train_dataset, valid_dataset, test_dataset]:

  for transformer in transformers:

      dataset = transformer.transform(dataset)

```

%% Cell type:markdown id: tags:

Fit Random Forest with hyperparameter search

%% Cell type:code id: tags:

``` python

def rf_model_builder(tasks, task_types, params_dict, model_dir, verbosity=None):

    """Builds random forests given hyperparameters.

    """

    n_estimators = params_dict["n_estimators"]

    max_features = params_dict["max_features"]

    return SklearnModel(

        tasks, task_types, params_dict, model_dir,

        mode="regression",

        model_instance=RandomForestRegressor(n_estimators=n_estimators,

                                             max_features=max_features))

def rf_model_builder(model_params, model_dir):

  sklearn_model = RandomForestRegressor(**model_params)

  return dc.models.SklearnModel(sklearn_model, model_dir)

params_dict = {

    "n_estimators": [10, 100],

    "data_shape": [train_dataset.get_data_shape()],

    "max_features": ["auto"],

    }

    "max_features": ["auto", "sqrt", "log2", None],

}

metric = Metric(metrics.mean_absolute_error)

optimizer = HyperparamOpt(rf_model_builder, tasks, task_types, verbosity="low")

best_model, best_hyperparams, all_results = optimizer.hyperparam_search(

    params_dict, train_dataset, valid_dataset, output_transformers,

    metric, use_max="False", logdir=None)

metric = dc.metrics.Metric(dc.metrics.mean_absolute_error)

optimizer = dc.hyper.HyperparamOpt(rf_model_builder)

best_rf, best_rf_hyperparams, all_rf_results = optimizer.hyperparam_search(

    params_dict, train_dataset, valid_dataset, transformers,

    metric=metric)

```

%% Cell type:code id: tags:

``` python

def kr_model_builder(tasks, task_types, params_dict, model_dir, verbosity=None):

    """Builds random forests given hyperparameters.

    """

    kernel = params_dict["kernel"]

    alpha = params_dict["alpha"]

    gamma = params_dict["gamma"]

    return SklearnModel(

        tasks, task_types, params_dict, model_dir,

        mode="regression",

        model_instance=KernelRidge(alpha=alpha,kernel=kernel,gamma=gamma))

def krr_model_builder(model_params, model_dir):

  sklearn_model = KernelRidge(**model_params)

  return dc.models.SklearnModel(sklearn_model, model_dir)

params_dict = {

    "kernel": ["laplacian"],

    "alpha": [0.0001],

    "gamma": [0.0001]

    }

metric = Metric(metrics.mean_absolute_error)

optimizer = HyperparamOpt(kr_model_builder, tasks, task_types, verbosity="low")

best_model, best_hyperparams, all_results = optimizer.hyperparam_search(

    params_dict, train_dataset, valid_dataset, output_transformers,

    metric, use_max="False", logdir=None)

```

%% Cell type:code id: tags:

}

``` python

metric = dc.metrics.Metric(dc.metrics.mean_absolute_error)

optimizer = dc.hyper.HyperparamOpt(krr_model_builder)

best_krr, best_krr_hyperparams, all_krr_results = optimizer.hyperparam_search(

    params_dict, train_dataset, valid_dataset, transformers,

    metric=metric)

```

def test_solubility():

  nb, errors = _notebook_read("solubility.ipynb")

  assert errors == []

def test_quantum():

  nb, errors = _notebook_read("quantum_machine_gdb1k.ipynb")

  assert errors == []