Nosetests now passing for new transforms

- conda install -c omnia keras

- conda install seaborn

- conda install six

- pip install --user git+https://github.com/uqfoundation/pathos

- conda install dill

- conda install runipy

- python setup.py install

script:

- nosetests -v deepchem

from deepchem.featurizers.nnscore import NNScoreComplexFeaturizer

import multiprocessing as mp

from functools import partial

import multiprocess

import dill

def generate_scaffold(smiles, include_chirality=False):

      shard_df[task_names] = y

      shard_df[pred_task_names] = y_pred

      shard_df[w_task_names] = w

      # TODO(rbharath): This feels like a total hack. Is there a structured way

      # to deal with this instead?

      shard_df["y_means"] = list(dataset.get_label_means())[0] * np.ones(np.shape(y))

      shard_df["y_stds"] = list(dataset.get_label_stds())[0]  * np.ones(np.shape(y))

      pred_y_df = pd.concat([pred_y_df, shard_df])

    return pred_y_df

from __future__ import print_function

from __future__ import division

from __future__ import unicode_literals

import os

import numpy as np

import warnings

from functools import partial

from deepchem.utils.save import save_to_disk

from deepchem.utils.save import load_from_disk

# TODO(rbharath): The handling of X/y transforms in the same class is

# awkward. Is there a better way to handle this work. 

    self.dataset = dataset

    self.transform_X = transform_X

    self.transform_y = transform_y

    # One, but not both, transform_X or tranform_y is true

    assert transform_X or transform_y

    assert not (transform_X and transform_y)

  def transform_row(self, i, df):

    """

    raise NotImplementedError(

      "Each Transformer is responsible for its own tranform_row method.")

  def untransform(self, z, X_transform=False, y_transform=True):

  def untransform(self, z):

    """Reverses stored transformation on provided data."""

    raise NotImplementedError(

      "Each Transformer is responsible for its own untransfomr method.")

    Adds X-transform, y-transform columns to metadata.

    """

    self._transform(dataset, parallel=parallel)

    df = dataset.metadata_df

    indices = range(0, df.shape[0])

    transform_row_partial = partial(_transform_row, df=df, transformer=self)

  """

  transformer.transform_row(i, df)

class NormalizeTransformer(Transformer):

class NormalizationTransformer(Transformer):

  def __init__(self, i, df, X_means, X_stds, y_means, y_stds):

  def __init__(self, transform_X=False, transform_y=False, dataset=None):

    """Initialize clipping transformation."""

    super(ClippingTransformer, self).__init__(i, df)

    super(NormalizationTransformer, self).__init__(transform_X=transform_X,

                                                   transform_y=transform_y,

                                                   dataset=dataset)

    X_means, X_stds, y_means, y_stds = dataset.compute_statistics()

    self.X_means = X_means 

    self.X_stds = X_stds

    self.y_means = y_means 

      y = np.nan_to_num((y - self.y_means) / self.y_stds)

      save_to_disk(y, row['y-transformed'])

  def untransform(z, X_transform=False, y_transform=True):

  def untransform(self, z):

    """

    Undo transformation on provided data.

    """

    if X_transform:

      return z * self.X_stds + X_means

    elif y_transform:

      return z * self.y_stds + y_means

    if self.transform_X:

      print("z.shape")

      print(z.shape)

      print("self.X_stds.shape")

      print(self.X_stds.shape)

      print("self.X_means.shape")

      print(self.X_means.shape)

      print("self.y_means.shape")

      print(self.y_means.shape)

      print("self.y_stds.shape")

      print(self.y_stds.shape)

      return z * self.X_stds + self.X_means

    elif self.transform_y:

      return z * self.y_stds + self.y_means

class ClippingTransformer(Transformer):

  def __init__(self, i, df, max_val):

  def __init__(self, transform_X=False, transform_y=False, dataset=None,

               max_val=5.):

    """Initialize clipping transformation."""

    super(ClippingTransformer, self).__init__(i, df)

    super(ClippingTransformer, self).__init__(transform_X=transform_X,

                                              transform_y=transform_y,

                                              dataset=dataset)

    self.max_val = max_val

  def transform_row(self, i, df):

    """

    row = df.iloc[i]

    if self.transform_X:

      X = load_from_disk(row['X'])

      X[X > self.max_val] = self.max_val

      X[X < (-1.0*self.max_val)] = -1.0 * self.max_val

      save_to_disk(X, row['X-transformed'])

    if self.transform_y:

      y = load_from_disk(row['y'])

      y[y > trunc] = trunc

      y[y < (-1.0*trunc)] = -1.0 * trunc

      save_to_disk(y, row['y-transformed'])

  def untransform(z, X_transform=False, y_transform=True):

    raise NotImplementedError("Clipping cannot be undone.")

  def untransform(self, z):

    warnings.warn("Clipping cannot be undone.")

    return z

class LogTransformer(Transformer):

      y = np.log(y)

      save_to_disk(y, row['y-transformed'])

  def untransform(z, X_transform=False, y_transform=True):

  def untransform(self, z):

    """Undoes the logarithmic transformation."""

    return np.exp(z)

                   'w',

                   'X_sums', 'X_sum_squares', 'X_n',

                   'y_sums', 'y_sum_squares', 'y_n'))

      self.save()

      self.save_to_disk()

      #save_to_disk(

      #    self.metadata_df, self._get_metadata_filename())

      ## input/output transforms not specified yet, so

      else:

        raise ValueError("No metadata found.")

  def save_to_disk():

  def save_to_disk(self):

    """Save dataset to disk."""

    save_to_disk(

        self.metadata_df, self._get_metadata_filename())

      ids = load_from_disk(row['ids'])

      yield (X, y, w, ids)

  def get_label_means(self):

    """Return pandas series of label means."""

    return self.metadata_df["y_means"]

    """Return pandas series of label stds."""

    return self.metadata_df["y_stds"]

  def get_input_transforms(self):

    """Returns stored input transforms."""

    (input_transforms, _) = self.transforms

    return input_transforms

  def get_output_transforms(self):

    """Returns stored output transforms."""

    (_, output_transforms) = self.transforms

    return output_transforms

  def compute_statistics(self):

    """Computes statistics of this dataset"""

    df = self.metadata_df

  save_to_disk(X, out_X)

  save_to_disk(y, out_y)

  # Write X, y as transformed versions

  save_to_disk(X, out_X_transformed)

  save_to_disk(y, out_y_transformed)

  save_to_disk(w, out_w)

  save_to_disk(ids, out_ids)

  # TODO(rbharath): Should X be saved to out_X_transformed as well? Since