Merge pull request #249 from peastman/atomicnet

import os

import tempfile

import sklearn

from deepchem.datasets import Dataset

from deepchem.datasets import Dataset, pad_features

from deepchem.transformers import undo_transforms

from deepchem.transformers import undo_grad_transforms

from deepchem.utils.save import load_from_disk

    y_preds = []

    n_tasks = self.get_num_tasks()

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

        batch_size, deterministic=True, pad_batches=pad_batches):

        batch_size, deterministic=True):

      n_samples = len(X_batch)

      if pad_batches:

        X_batch = pad_features(batch_size, X_batch)

      y_pred_batch = self.predict_on_batch(X_batch)

      if pad_batches:

        y_pred_batch = y_pred_batch[:n_samples]

      y_pred_batch = np.reshape(y_pred_batch, (n_samples, n_tasks))

      y_pred_batch = undo_transforms(y_pred_batch, transformers)

      y_preds.append(y_pred_batch)

            log("About to shuffle dataset before epoch start.", self.verbosity)

            dataset.shuffle()

          for ind, (X_b, y_b, w_b, ids_b) in enumerate(

              dataset.iterbatches(batch_size, pad_batches=pad_batches)):

              dataset.iterbatches(batch_size, pad_batches=True)): # hardcode pad_batches=True to work around limitations in Tensorflow

            if ind % log_every_N_batches == 0:

              log("On batch %d" % ind, self.verbosity)

            # Run training op.

    """

    self.model_instance.fit(dataset, **kwargs)

  def predict(self, dataset, transformers=[], batch_size=None,

              pad_batches=False):

    """

    Uses self to make predictions on provided Dataset object.

    This is overridden to make sure the batch size is always valid for Tensorflow.

    Returns:

      y_pred: numpy ndarray of shape (n_samples,)

    """

    return Model.predict(self, dataset, transformers, self.model_instance.batch_size, True)

  def predict_on_batch(self, X):

    """

    Makes predictions on batch of data.

    """

    return self.model_instance.predict_on_batch(X)

    len_unpadded = len(X)

    Xpad = pad_features(self.model_instance.batch_size, X)

    return self.model_instance.predict_on_batch(Xpad)[:len_unpadded]

  def predict_grad_on_batch(self, X):

    """