BACE models

  def get_statistics(self):

    """Computes and returns statistics of this dataset"""

    if len(self) == 0:

      return None, None, None, None

    self.update_moments()

    df = self.metadata_df

    X_means, X_stds, y_means, y_stds = compute_mean_and_std(df)

from deepchem.metrics import Metric

from deepchem.utils.evaluate import Evaluator

def load_bace(mode="regression", transform=True):

def load_bace(mode="regression", transform=True, split="20-80"):

  """Load BACE-1 dataset as regression/classification problem."""

  reload = True

  verbosity = "high"

  assert split in ["20-80", "80-20"]

  current_dir = os.path.dirname(os.path.realpath(__file__))

  if split == "20-80":

    dataset_file = os.path.join(

        current_dir, "../../datasets/desc_canvas_aug30.csv")

  elif split == "80-20":

    dataset_file = os.path.join(

        current_dir, "../../datasets/rev8020split_desc.csv")

  print("dataset_file")

  print(dataset_file)

  dataset = load_from_disk(dataset_file)

  train_samples, valid_samples, test_samples = splitter.train_valid_test_split(

      featurized_samples, train_dir, valid_dir, test_dir,

      reload=reload)

  ######################## DEBUG

  print("bace_datasets")

  print("len(train_samples), len(valid_samples), len(test_samples)")

  print(len(train_samples), len(valid_samples), len(test_samples))

  ######################## DEBUG

  #NOTE THE RENAMING:

  if split == "20-80":

    valid_samples, test_samples = test_samples, valid_samples

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

        ClippingTransformer(transform_X=True, dataset=train_dataset)]

    output_transformers = []

    if mode == "regression":

      output_transformers = [

        NormalizationTransformer(transform_y=True, dataset=train_dataset)]

      ######## DEBUG (TURN ME BACK ON!)

      #output_transformers = [

      #  NormalizationTransformer(transform_y=True, dataset=train_dataset)]

      ######## DEBUG (TURN ME BACK ON!)

      output_transformers = []

    else:

      output_transformers = []

  else:

      transformer.transform(valid_dataset)

  for transformer in transformers:

      transformer.transform(test_dataset)

  for transformer in transformers:

      transformer.transform(crystal_dataset)

  #for transformer in transformers:

  #    transformer.transform(crystal_dataset)

  return (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset, transformers)

  #return (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset, transformers)

  return (bace_tasks, train_dataset, valid_dataset, test_dataset, crystal_dataset, output_transformers)

#def load_classification_bace():

#  """Load BACE-1 dataset as classification problem."""

    if self.threshold is not None:

      y_pred = np.greater(y_pred, threshold)

    ######### DEBUG (TURN ME BACK ON!)

    try:

      #print("np.amax(y_true), np.amin(y_true)")

      #print(np.amax(y_true), np.amin(y_true))

      #print("np.amax(y_pred), np.amin(y_pred)")

      #print(np.amax(y_pred), np.amin(y_pred))

      metric_value = self.metric(y_true, y_pred)

    except (AssertionError, ValueError) as e:

      warnings.warn("Error calculating metric %s: %s"

                    % (self.name, e))

      metric_value = np.nan

    ######### DEBUG (TURN ME BACK ON!)

    return metric_value 

import joblib

import os

import tempfile

import sklearn

from deepchem.datasets import Dataset

from deepchem.transformers import undo_transforms

from deepchem.utils.save import load_from_disk

from deepchem.utils.save import save_to_disk

from deepchem.utils.save import log

import sklearn

def undo_transforms(y, transformers):

  """Undoes all transformations applied."""

  # Note that transformers have to be undone in reversed order

  for transformer in reversed(transformers):

    if transformer.transform_y:

      y = transformer.untransform(y)

  return y

class Model(object):

  """

      y_preds.append(y_pred_batch)

    y_pred = np.vstack(y_preds)

    ################ DEBUG

    y_plain = []

    for (X_batch, y_batch, w_batch, ids_batch) in dataset.iterbatches(batch_size):

      y_pred_batch = np.reshape(self.predict_on_batch(X_batch), y_batch.shape)

      y_plain.append(y_pred_batch)

    y_plain_pred = np.vstack(y_plain)

    y = dataset.get_labels()

    import sklearn

    print("sklearn.metrics.r2_score(y, y_plain_pred)")

    print(sklearn.metrics.r2_score(y, y_plain_pred))

    ################ DEBUG

    # The iterbatches does padding with zero-weight examples on the last batch.

    # Remove padded examples.

    n_samples, n_tasks = len(dataset), len(self.tasks)

from deepchem import metrics

from deepchem.utils.evaluate import Evaluator

from deepchem.models.multitask import SingletaskToMultitask

from deepchem.transformers import NormalizationTransformer

from deepchem.transformers import ClippingTransformer

class TestGeneralization(TestAPI):

  """

    assert scores[regression_metric.name] > .5

  def test_sklearn_transformed_regression(self):

    """Test that sklearn models can learn on simple transformed regression datasets."""

    np.random.seed(123)

    dataset = sklearn.datasets.load_diabetes()

    X, y = dataset.data, dataset.target

    frac_train = .7

    n_samples = len(X)

    X_train, y_train = X[:frac_train*n_samples], y[:frac_train*n_samples]

    X_test, y_test = X[frac_train*n_samples:], y[frac_train*n_samples:]

    train_dataset = Dataset.from_numpy(self.train_dir, X_train, y_train)

    test_dataset = Dataset.from_numpy(self.test_dir, X_test, y_test)

    # Eval model on train

    input_transformers = [

        NormalizationTransformer(transform_X=True, dataset=train_dataset),

        ClippingTransformer(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(test_dataset)

    tasks = train_dataset.get_task_names()

    task_types = {task: "regression" for task in tasks}

    model_params = {

      "batch_size": None,

      "data_shape": train_dataset.get_data_shape()

    }

    verbosity = "high"

    regression_metric = Metric(metrics.r2_score, verbosity=verbosity)

    model = SklearnModel(tasks, task_types, model_params, self.model_dir,

                         mode="regression",

                         model_instance=LinearRegression())

    # Fit trained model

    model.fit(train_dataset)

    model.save()

    train_evaluator = Evaluator(model, train_dataset, transformers, verbosity=verbosity)

    train_scores = train_evaluator.compute_model_performance([regression_metric])

    print("train_scores")

    print(train_scores)

    assert train_scores[regression_metric.name] > .5

    # Eval model on test

    transformers = []

    evaluator = Evaluator(model, test_dataset, transformers, verbosity=verbosity)

    scores = evaluator.compute_model_performance([regression_metric])

    print("scores")

    print(scores)

    assert scores[regression_metric.name] > .5

  def test_sklearn_multitask_regression(self):

    """Test that sklearn models can learn on simple multitask regression."""

    np.random.seed(123)