Commit 633e03f1 authored by Bharath Ramsundar's avatar Bharath Ramsundar
Browse files

First steps in debuggin

parent b955f6be

deepchem/datasets/__init__.py

+6 −4
Original line number Diff line number Diff line
@@ -182,12 +182,14 @@ class Dataset(object): 
    """

    Returns minibatches from dataset.

    """

    if batch_size == None:

      batch_size = len(self)

    for i, (X, y, w, ids) in enumerate(self.itershards()):

      nb_sample = np.shape(X)[0]

      if batch_size is None:

        shard_batch_size = nb_sample

      else:

        shard_batch_size = batch_size 

      interval_points = np.linspace(

          0, nb_sample, np.ceil(float(nb_sample)/batch_size)+1, dtype=int)

          0, nb_sample, np.ceil(float(nb_sample)/shard_batch_size)+1, dtype=int)

      for j in range(len(interval_points)-1):

        indices = range(interval_points[j], interval_points[j+1])

        X_batch = X[indices, :]
@@ -195,7 +197,7 @@ class Dataset(object): 
        w_batch = w[indices]

        ids_batch = ids[indices]

        (X_batch, y_batch, w_batch, ids_batch) = self._pad_batch(

            X_batch, y_batch, w_batch, ids_batch, batch_size)

            X_batch, y_batch, w_batch, ids_batch, shard_batch_size)

        yield (X_batch, y_batch, w_batch, ids_batch)



  @staticmethod

deepchem/hyperparameters/tests/test_hyperparam_opt.py

+23 −5
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ from deepchem.metrics import Metric 
from deepchem.models.multitask import SingletaskToMultitask 

from sklearn.linear_model import LogisticRegression

from sklearn.ensemble import RandomForestRegressor 

from deepchem.datasets import Dataset



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

    """Builds random forests given hyperparameters.
@@ -33,6 +34,7 @@ def rf_model_builder(tasks, task_types, params_dict, model_dir, verbosity=None): 
    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))
@@ -79,11 +81,26 @@ class TestHyperparamOptAPI(TestAPI): 
             "task13", "task14", "task15", "task16"]

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

    input_file = "multitask_example.csv"

    train_dataset, valid_dataset, _, output_transformers, = \

        self._featurize_train_test_split(

            splittype, compound_featurizers, 

            complex_featurizers, input_transformer_classes,

            output_transformer_classes, input_file, tasks)

      

    n_features = 10

    n_tasks = len(tasks)

    # Define train dataset

    n_train = 100

    X_train = np.random.rand(n_train, n_features)

    y_train = np.random.randint(2, size=(n_train, n_tasks))

    w_train = np.ones_like(y_train)

    ids_train = ["C"] * n_train

    train_dataset = Dataset.from_numpy(self.train_dir, tasks,

                                       X_train, y_train, w_train, ids_train)



    # Define validation dataset

    n_valid = 10

    X_valid = np.random.rand(n_valid, n_features)

    y_valid = np.random.randint(2, size=(n_valid, n_tasks))

    w_valid = np.ones_like(y_valid)

    ids_valid = ["C"] * n_valid

    valid_dataset = Dataset.from_numpy(self.valid_dir, tasks,

                                       X_valid, y_valid, w_valid, ids_valid)

    params_dict = {

        "batch_size": [32],

        "data_shape": [train_dataset.get_data_shape()],
@@ -97,6 +114,7 @@ class TestHyperparamOptAPI(TestAPI): 
                                verbosity=None):

      return SingletaskToMultitask(tasks, task_types, params_dict,

                                   self.model_dir, model_builder)

    output_transformers = []

    self._hyperparam_opt(multitask_model_builder, params_dict, train_dataset,

                         valid_dataset, output_transformers, tasks, task_types,

                         classification_metric)

deepchem/metrics/__init__.py

+2 −0
Original line number Diff line number Diff line
@@ -141,6 +141,8 @@ class Metric(object): 
        metric_value = np.nan

      computed_metrics.append(metric_value)

    log("computed_metrics: %s" % str(computed_metrics), self.verbosity)

    if num_tasks == 1:

      computed_metrics = computed_metrics[0]

    if not self.is_multitask:

      return computed_metrics

    else:

deepchem/models/__init__.py

+23 −19
Original line number Diff line number Diff line
@@ -146,28 +146,32 @@ class Model(object): 
    Uses self to make predictions on provided Dataset object.

    """

    X, y, w, ids = dataset.to_numpy()

    print("X.shape, y.shape, w.shape, ids.shape")

    print(X.shape, y.shape, w.shape, ids.shape)

    

    #X = X[w.flatten() != 0, :]

    num_tasks = y.shape[1]



    y_pred = self.predict_on_batch(X)



    print("Model.predict()")

    for task in xrange(num_tasks):

      y_task, w_task, y_pred_task = y[:, task], w[:, task], y_pred[:, task]

      y_task = y_task[w_task.flatten() != 0]

      y_task = to_one_hot(y_task)

      y_pred_task = y_pred_task[w_task.flatten() != 0][:, np.newaxis]

      #y_pred_d = y_pred[w_task.flatten() != 0][:, np.newaxis]

    #y_pred = np.reshape(self.predict_on_batch(X), y.shape)

    #y_pred = undo_transforms(y_pred, transformers)



      print("task %d" % task)

      print("sklearn.metrics.roc_auc_score(y_task, y_pred_d)")

    batch_size = self.model_params["batch_size"]

    y_preds = []

    print("predict()")

    print("len(dataset)")

    print(len(dataset))

    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_pred_batch = undo_transforms(y_pred_batch, transformers)

      y_preds.append(y_pred_batch)

      print("X_batch.shape, y_batch.shape, y_pred_batch.shape")

      print(X_batch.shape, y_batch.shape, y_pred_batch.shape)

    y_pred = np.vstack(y_preds)

  

      print("y_task.shape, w_task.shape, y_pred_task.shape")

      print(y_task.shape, w_task.shape, y_pred_task.shape)

      print(sklearn.metrics.roc_auc_score(y_task, y_pred_task))

    #X = X[w.flatten() != 0, :]

    #print("Model.predict()")

    #print("y.shape, w.shape, y_pred.shape")

    #print(y.shape, w.shape, y_pred.shape)

    #for task in xrange(num_tasks):

    #  y_task, w_task, y_pred_task = y[:, task], w[:, task], y_pred[:, task]

    #  y_task = y_task[w_task.flatten() != 0]

    #  y_task = to_one_hot(y_task)

    #  y_pred_task = y_pred_task[w_task.flatten() != 0][:, np.newaxis]



    return y_pred

deepchem/models/sklearn_models/__init__.py

+7 −2
Original line number Diff line number Diff line
@@ -19,7 +19,8 @@ class SklearnModel(Model): 
  Abstract base class for different ML models.

  """

  def __init__(self, tasks, task_types, model_params, model_dir, fit_transformers=None,

               model_instance=None, initialize_raw_model=True, verbosity=None):

               model_instance=None, initialize_raw_model=True, verbosity=None,

               mode="classification"):

    super(SklearnModel, self).__init__(

        tasks, task_types, model_params, model_dir,

        fit_transformers=fit_transformers,
@@ -29,6 +30,8 @@ class SklearnModel(Model): 
    self.model_params = model_params

    self.raw_model = model_instance

    self.verbosity = verbosity

    assert mode in ["classification", "regression"]

    self.mode = mode



  # TODO(rbharath): This does not work with very large datasets! sklearn does

  # support partial_fit, but only for some models. Might make sense to make
@@ -52,8 +55,10 @@ class SklearnModel(Model): 
    """

    Makes predictions on batch of data.

    """

    #return self.raw_model.predict(X)

    if self.mode == "classification":

      return self.raw_model.predict_proba(X)

    else:

      return self.raw_model.predict(X)



  def predict(self, X, transformers):

    """

CRA Git | Maintained and supported by SUSTech CRA and CCSE