update irv

from deepchem.utils.save import log

from deepchem.models.tensorgraph.tensor_graph import TensorGraph

from deepchem.models.tensorgraph.layers import Layer, SigmoidCrossEntropy, \

    Sigmoid, Feature, Label, Weights, Concat, WeightedError

    Sigmoid, Feature, Label, Weights, Concat, WeightedError, Stack

from deepchem.models.tensorgraph.layers import convert_to_layers

from deepchem.trans import undo_transforms

       https://www.ncbi.nlm.nih.gov/pmc/articles/PMC2750043/

    """

    self.mol_features = Feature(shape=(None, self.n_features))

    self._labels = Label(shape=(None, self.n_tasks))

    self._weights = Weights(shape=(None, self.n_tasks))

    predictions = IRVLayer(self.n_tasks, self.K, in_layers=[self.mol_features])

    costs = []

    self.labels_fd = []

    outputs = []

    for task in range(self.n_tasks):

      task_output = Slice(task, 1, in_layers=[predictions])

      sigmoid = Sigmoid(in_layers=[task_output])

      self.add_output(sigmoid)

      outputs.append(sigmoid)

      label = Label(shape=(None, 1))

      self.labels_fd.append(label)

      label = Slice(task, axis=1, in_layers=[self._labels])

      cost = SigmoidCrossEntropy(in_layers=[label, task_output])

      costs.append(cost)

    all_cost = Concat(in_layers=costs, axis=1)

    self.weights = Weights(shape=(None, self.n_tasks))

    loss = WeightedError(in_layers=[all_cost, self.weights]) + \

    loss = WeightedError(in_layers=[all_cost, self._weights]) + \

        IRVRegularize(predictions, self.penalty, in_layers=[predictions])

    self.set_loss(loss)

  def default_generator(self,

                        dataset,

                        epochs=1,

                        predict=False,

                        deterministic=True,

                        pad_batches=True):

    """TensorGraph style implementation """

    for epoch in range(epochs):

      if not predict:

        logger.info('Starting epoch %i' % epoch)

      for (X_b, y_b, w_b, ids_b) in dataset.iterbatches(

          batch_size=self.batch_size,

          deterministic=deterministic,

          pad_batches=pad_batches):

        feed_dict = dict()

        if y_b is not None:

          for index, label in enumerate(self.labels_fd):

            feed_dict[label] = y_b[:, index:index + 1]

        if w_b is not None:

          feed_dict[self.weights] = w_b

        feed_dict[self.mol_features] = X_b

        yield feed_dict

    outputs = Stack(axis=1, in_layers=outputs)

    self.add_output(outputs)

  def predict(self, dataset, transformers=[], outputs=None):

    out = super(TensorflowMultiTaskIRVClassifier, self).predict(

        dataset, transformers=transformers, outputs=outputs)

    out = np.concatenate(out, axis=1)

    out = np.round(out).astype(int)

    return out

  def predict_proba(self, dataset, transformers=[], outputs=None):

    out = super(TensorflowMultiTaskIRVClassifier, self).predict_proba(

        dataset, transformers=transformers, outputs=outputs)

    out = np.concatenate(out, axis=1)

    out = np.stack([1 - out, out], axis=2)

    return out

    return np.concatenate([1 - out, out], axis=2)

from deepchem.models.tensorgraph.tensor_graph import TensorGraph, TFWrapper

from deepchem.models.tensorgraph.layers import Layer, Feature, Label, Weights, \

    WeightedError, Dense, Dropout, WeightDecay, Reshape, SparseSoftMaxCrossEntropy, \

    L2Loss, ReduceSum, Concat, Stack, TensorWrapper, ReLU, Squeeze, SoftMax

    L2Loss, ReduceSum, Concat, Stack, TensorWrapper, ReLU, Squeeze, SoftMax, Cast

from deepchem.models.tensorgraph.IRV import Slice

class ProgressiveMultitaskRegressor(TensorGraph):

    # Add the input features.

    self.mol_features = Feature(shape=(None, n_features))

    self.labels = Label(shape=(None, n_tasks))

    self.weights = Weights(shape=(None, n_tasks))

    self._task_labels = Label(shape=(None, n_tasks))

    self._task_weights = Weights(shape=(None, n_tasks))

    all_layers = {}

    outputs = []

        layer = layer + lateral_contrib

      output_layer = self.create_output(layer)

      outputs.append(output_layer)

      self.add_output(output_layer)

      label = Slice(task, axis=1, in_layers=[self.labels])

      weight = Slice(task, axis=1, in_layers=[self.weights])

      label = Slice(task, axis=1, in_layers=[self._task_labels])

      weight = Slice(task, axis=1, in_layers=[self._task_weights])

      task_loss = self.create_loss(layer, label, weight)

      self.create_submodel(layers=task_layers, loss=task_loss, optimizer=None)

    outputs = Stack(axis=1, in_layers=outputs)

    self.add_output(outputs)

    # Weight decay not activated

    """

    if weight_decay_penalty != 0.0:

    """

  def create_loss(self, layer, label, weight):

    weighted_loss = ReduceSum(

        L2Loss(in_layers=[label, layer, weight]))

    weighted_loss = ReduceSum(L2Loss(in_layers=[label, layer, weight]))

    return weighted_loss

  def create_output(self, layer):

    self.fit_generator(generator, max_checkpoints_to_keep, checkpoint_interval,

                       restore, self.submodels[submodel])

  def predict_proba(self, dataset, transformers=[], outputs=None):

    return self.predict(dataset, transformers=transformers, outputs=outputs)

  def predict(self, dataset, transformers=[], outputs=None):

    retval = super(ProgressiveMultitaskRegressor, self).predict(

        dataset, transformers, outputs)

    # Results is of shape (n_samples, n_tasks, n_outputs)

    out = np.stack(retval, axis=1)

    return out

class ProgressiveMultitaskClassifier(ProgressiveMultitaskRegressor):

  """Implements a progressive multitask neural network for classification.

  def create_loss(self, layer, label, weight):

    task_label = Squeeze(squeeze_dims=1, in_layers=[label])

    task_label = Cast(dtype=tf.int32, in_layers=[task_label])

    task_weight = Squeeze(squeeze_dims=1, in_layers=[weight])

    loss = SparseSoftMaxCrossEntropy(in_layers=[task_label, layer])

    results = estimator.evaluate(input_fn=lambda: input_fn(1))

    assert results['loss'] < 1e-2

    assert results['error'] < 0.1

  def test_irv(self):

    """Test creating an Estimator from a IRVClassifier."""

    n_samples = 50

    n_features = 3

    n_tasks = 2

    # Create a dataset and an input function for processing it.

    np.random.seed(123)

    X = np.random.rand(n_samples, n_features)

    y = np.zeros((n_samples, n_tasks))

    dataset = dc.data.NumpyDataset(X, y)

    transformers = [dc.trans.IRVTransformer(10, n_tasks, dataset)]

    for transformer in transformers:

      dataset = transformer.transform(dataset)

    def input_fn(epochs):

      x, y, weights = dataset.make_iterator(

          batch_size=n_samples, epochs=epochs).get_next()

      return {'x': x, 'weights': weights}, y

    # Create a TensorGraph model.

    model = dc.models.TensorflowMultiTaskIRVClassifier(

        n_tasks, K=10, learning_rate=0.001, penalty=0.05, batch_size=50)

    model.build()

    # Create an estimator from it.

    x_col = tf.feature_column.numeric_column('x', shape=(2 * 10 * n_tasks,))

    weight_col = tf.feature_column.numeric_column('weights', shape=(n_tasks,))

    def accuracy(labels, predictions, weights):

      return tf.metrics.accuracy(labels, tf.round(predictions), weights)

    metrics = {'accuracy': accuracy}

    estimator = model.make_estimator(

        feature_columns=[x_col], weight_column=weight_col, metrics=metrics)

    # Train the model.

    estimator.train(input_fn=lambda: input_fn(500))

    # Evaluate the model.

    results = estimator.evaluate(input_fn=lambda: input_fn(1))

    assert results['accuracy'] > 0.9