Cleanup of code. Some tests still broken

      model.save()

      evaluator = Evaluator(model, valid_dataset, output_transformers)

      #df, scores_df, multitask_scores = evaluator.compute_model_performance(

      #    [metric], valid_csv_out, valid_stats_out)

      multitask_scores = evaluator.compute_model_performance(

          [metric], valid_csv_out, valid_stats_out)

      #if not metric.is_multitask:

      #  valid_score = scores_df.iloc[0][metric.name]

      #else:

      #  valid_score = multitask_scores[metric.name]

      valid_score = multitask_scores[metric.name]

      all_scores[hyperparameter_tuple] = valid_score

    train_csv_out = tempfile.NamedTemporaryFile()

    train_stats_out = tempfile.NamedTemporaryFile()

    train_evaluator = Evaluator(best_model, train_dataset, output_transformers)

    #train_df, train_score, multitask_scores = train_evaluator.compute_model_performance(

    #    [metric], train_csv_out, train_stats_out)

    multitask_scores = train_evaluator.compute_model_performance(

        [metric], train_csv_out, train_stats_out)

    #if not metric.is_multitask:

    #  train_score = train_score.iloc[0][metric.name]

    #else:

    #  train_score = multitask_scores[metric.name]

    train_score = multitask_scores[metric.name]

    log("Best hyperparameters: %s" % str(best_hyperparams),

        self.verbosity, "low")

from sklearn.metrics import mean_squared_error

from sklearn.metrics import mean_absolute_error

# DEBUG

def to_one_hot(y):

  """Transforms label vector into one-hot encoding.

      y_hot[index] = np.array([0, 1])

  return y_hot

def from_one_hot(y, axis=1):

  """Transorms label vector from one-hot encoding.

  y: np.ndarray

    A vector of shape [n_samples, num_classes]

  """

  return np.argmax(y, axis=axis)

def compute_roc_auc_scores(y, y_pred):

  """Transforms the results dict into roc-auc-scores and prints scores.

    Returns:

      A numpy array containing metric values for each task.

    """

    print("y_true.shape, y_pred.shape, w.shape")

    print(y_true.shape, y_pred.shape, w.shape)

    assert y_true.shape[0] == y_pred.shape[0] == w.shape[0]

    num_tasks = y_true.shape[1] 

    computed_metrics = []

      w_task = w[:, task]

      try:

        import sklearn

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

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

        metric_value = self.compute_singletask_metric(

            y_task, y_pred_task, w_task)

      except (AssertionError, ValueError) as e:

    Raises:

      NotImplementedError: If metric_str is not in METRICS.

    """

    #print("compute_singletask_metric()")

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

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

    y_true = y_true[w != 0]

    y_pred = y_pred[w != 0]

    if self.mode == "classification":

      y_pred = y_pred[:, np.newaxis]

    if self.threshold is not None:

      y_pred = np.greater(y_pred, threshold)

    print("y_true.shape, y_pred.shape")

    print(y_true.shape, y_pred.shape)

    import sklearn

    print("compute_singletask_metric()")

    print("sklearn.metrics.roc_auc_score(y_true, y_pred)")

    print(sklearn.metrics.roc_auc_score(y_true, y_pred))

    try:

      metric_value = self.metric(y_true, y_pred)

    except (AssertionError, ValueError) as e:

import sklearn

# DEBUG COPY!

def to_one_hot(y):

  """Transforms label vector into one-hot encoding.

  Turns y into vector of shape [n_samples, 2] (assuming binary labels).

  y: np.ndarray

    A vector of shape [n_samples, 1]

  """

  n_samples = np.shape(y)[0]

  y_hot = np.zeros((n_samples, 2))

  for index, val in enumerate(y):

    if val == 0:

      y_hot[index] = np.array([1, 0])

    elif val == 1:

      y_hot[index] = np.array([0, 1])

  return y_hot

def undo_transforms(y, transformers):

  """Undoes all transformations applied."""

  # Note that transformers have to be undone in reversed order

    return X, y, w

  # TODO(rbharath): The structure of the produced df might be

  # complicated. Better way to model?

  def predict(self, dataset, transformers):

    """

    Uses self to make predictions on provided Dataset object.

    """

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

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

    #y_pred = undo_transforms(y_pred, transformers)

    batch_size = self.model_params["batch_size"]

    # Have to include ys/ws since we might pad batches

    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)

      #ys.append(y_batch)

      #w_preds.append(w_batch)

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

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

    #y = np.vstack(ys)

    y_pred = np.vstack(y_preds)

    #w_pred = np.vstack(w_preds)

    #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]

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

    # Remove padded examples.

    return y_pred

    #task_names = dataset.get_task_names()

    #pred_task_names = ["%s_pred" % task_name for task_name in task_names]

    #w_task_names = ["%s_weight" % task_name for task_name in task_names]

    #raw_task_names = [task_name+"_raw" for task_name in task_names]

    #raw_pred_task_names = [pred_task_name+"_raw" for pred_task_name in pred_task_names]

    #column_names = (['ids'] + raw_task_names + task_names

    #                + raw_pred_task_names + pred_task_names + w_task_names

    #                + ["y_means", "y_stds"])

    #pred_y_df = pd.DataFrame(columns=column_names)

    #batch_size = self.model_params["batch_size"]

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

    #  # HACK(JG): This was a hack to perform n-fold averaging of y_pred on

    #  # a given X_batch.  If fit_transformers exist, we will apply them to

    #  # X_batch 1 times and average the resulting y_pred before we undo 

    #  # transforms on y_pred and y.  In the future the averaging will be

    #  # performed n_sample times, where n_sample can be user-specified.

    #  if self.fit_transformers:

    #    y_preds = []

    #    for i in xrange(1):

    #      X_b, y_b, w_b = self.transform_on_batch(X_batch, y_batch, w_batch)

    #      y_pred = self.predict_on_batch(X_b)

    #      y_pred = np.reshape(y_pred, np.shape(y_b))

    #      y_preds.append(y_pred)

    #    y_pred = np.array(y_preds).mean(axis=0)

    #  else:

    #    # DEBUG

    #    X_batch = X_batch[w_batch.flatten() != 0, :]

    #    y_batch = y_batch[w_batch.flatten() != 0]

    #    y_pred = self.predict_on_batch(X_batch)

    #    y_pred = np.reshape(y_pred, np.shape(y_batch))

    #    # DEBUG:

    #    print("y_batch.shape, y_pred.shape")

    #    print(y_batch.shape, y_pred.shape)

    #    #y_batch_d = y_batch[w_batch != 0]

    #    #y_pred_d = y_pred[w_batch != 0]

    #    #print("y_batch_d.shape, y_pred_d.shape")

    #    #print(y_batch_d.shape, y_pred_d.shape)

    #    if np.count_nonzero(y_batch) > 0:

    #      print("sklearn.metrics.roc_auc_score(y_batch, y_pred)")

    #      print(sklearn.metrics.roc_auc_score(y_batch, y_pred))

    #  # Now undo transformations on y, y_pred

    #  y_raw, y_pred_raw = y_batch, y_pred

    #  y_batch = undo_transforms(y_batch, transformers)

    #  y_pred = undo_transforms(y_pred, transformers)

    #  batch_df = pd.DataFrame(columns=column_names)

    #  #batch_df['ids'] = ids_batch

    #  #batch_df[raw_task_names] = y_raw

    #  #batch_df[task_names] = y_batch

    #  #batch_df[raw_pred_task_names] = y_pred_raw

    #  #batch_df[pred_task_names] = y_pred

    #  #batch_df[w_task_names] = w_batch

    #  pred_y_df = pd.concat([pred_y_df, batch_df])

    #return pred_y_df

  def get_task_type(self):

    """

    Currently models can only be classifiers or regressors.

from keras.layers.normalization import BatchNormalization 

from keras.optimizers import SGD

from deepchem.models.keras_models import KerasModel

from deepchem.utils.evaluate import to_one_hot

from deepchem.metrics import to_one_hot

class MultiTaskDNN(KerasModel):

  """

      log("Fitting model for task %s" % task, self.verbosity, "high")

      y_task = y[:, ind]

      w_task = w[:, ind]

      # DEBUG

      X_task = X[w_task != 0, :]

      y_task = y_task[w_task != 0]

      #self.models[task].raw_model.fit(X, y_task, w_task)

      self.models[task].raw_model.fit(X_task, y_task)

      y_pred_task = self.models[task].raw_model.predict(X_task)

      print("Train ROC-AUC for %s: %f"

            % (task, sklearn.metrics.roc_auc_score(y_task.astype(int),

                                                   y_pred_task)))

  def predict_on_batch(self, X):

    """

    Concatenates results from all singletask models.

    N_samples = X.shape[0]

    y_pred = np.zeros((N_samples, N_tasks))

    for ind, task in enumerate(self.tasks):

      # DEBUG: ONLY FOR DEBUGGING

      #print("ind, task")

      #print(ind, task)

      #print("self.models[task]")

      #print(self.models[task])

      #print("type(self.models[task].predict_on_batch(X))")

      #print(type(self.models[task].predict_on_batch(X)))

      y_pred[:, ind] = self.models[task].predict_on_batch(X)[:, 0]

      #return self.models[task].predict_on_batch(X)[:, 0]

      #y_pred[task] = self.models[task].predict_on_batch(X)

    return y_pred

  def save(self):