Merge pull request #751 from peastman/fc

import numpy as np

import tensorflow as tf

import threading

import collections

import deepchem as dc

from deepchem.nn import model_ops

               n_tasks,

               n_features,

               layer_sizes=[1000],

               weight_init_stddevs=[0.02],

               bias_init_consts=[1.0],

               weight_init_stddevs=0.02,

               bias_init_consts=1.0,

               weight_decay_penalty=0.0,

               weight_decay_penalty_type="l2",

               dropouts=[0.5],

               dropouts=0.5,

               activation_fns=tf.nn.relu,

               n_classes=2,

               **kwargs):

    """Create a TensorGraphMultiTaskClassifier.

      number of features

    layer_sizes: list

      the size of each dense layer in the network.  The length of this list determines the number of layers.

    weight_init_stddevs: list

    weight_init_stddevs: list or float

      the standard deviation of the distribution to use for weight initialization of each layer.  The length

      of this list should equal len(layer_sizes).

    bias_init_consts: list

      of this list should equal len(layer_sizes).  Alternatively this may be a single value instead of a list,

      in which case the same value is used for every layer.

    bias_init_consts: list or loat

      the value to initialize the biases in each layer to.  The length of this list should equal len(layer_sizes).

      Alternatively this may be a single value instead of a list, in which case the same value is used for every layer.

    weight_decay_penalty: float

      the magnitude of the weight decay penalty to use

    weight_decay_penalty_type: str

      the type of penalty to use for weight decay, either 'l1' or 'l2'

    dropouts: list

    dropouts: list or float

      the dropout probablity to use for each layer.  The length of this list should equal len(layer_sizes).

      Alternatively this may be a single value instead of a list, in which case the same value is used for every layer.

    activation_fns: list or object

      the Tensorflow activation function to apply to each layer.  The length of this list should equal

      len(layer_sizes).  Alternatively this may be a single value instead of a list, in which case the

      same value is used for every layer.

    n_classes: int

      the number of classes

    """

    self.n_tasks = n_tasks

    self.n_features = n_features

    self.n_classes = n_classes

    n_layers = len(layer_sizes)

    if not isinstance(weight_init_stddevs, collections.Sequence):

      weight_init_stddevs = [weight_init_stddevs] * n_layers

    if not isinstance(bias_init_consts, collections.Sequence):

      bias_init_consts = [bias_init_consts] * n_layers

    if not isinstance(dropouts, collections.Sequence):

      dropouts = [dropouts] * n_layers

    if not isinstance(activation_fns, collections.Sequence):

      activation_fns = [activation_fns] * n_layers

    # Add the input features.

    # Add the dense layers

    for size, weight_stddev, bias_const, dropout in zip(

        layer_sizes, weight_init_stddevs, bias_init_consts, dropouts):

    for size, weight_stddev, bias_const, dropout, activation_fn in zip(

        layer_sizes, weight_init_stddevs, bias_init_consts, dropouts,

        activation_fns):

      layer = Dense(

          in_layers=[prev_layer],

          out_channels=size,

          activation_fn=tf.nn.relu,

          activation_fn=activation_fn,

          weights_initializer=TFWrapper(

              tf.truncated_normal_initializer, stddev=weight_stddev),

          biases_initializer=TFWrapper(

          pad_batches=pad_batches):

        feed_dict = dict()

        if y_b is not None and not predict:

          feed_dict[self.labels[0]] = to_one_hot(

              y_b.flatten(), self.n_classes).reshape(-1, self.n_tasks,

          feed_dict[self.labels[0]] = to_one_hot(y_b.flatten(),

                                                 self.n_classes).reshape(

                                                     -1, self.n_tasks,

                                                     self.n_classes)

        if X_b is not None:

          feed_dict[self.features[0]] = X_b

               n_tasks,

               n_features,

               layer_sizes=[1000],

               weight_init_stddevs=[0.02, 0.02],

               bias_init_consts=[1.0, 1.0],

               weight_init_stddevs=0.02,

               bias_init_consts=1.0,

               weight_decay_penalty=0.0,

               weight_decay_penalty_type="l2",

               dropouts=[0.5],

               dropouts=0.5,

               activation_fns=tf.nn.relu,

               **kwargs):

    """Create a TensorGraphMultiTaskRegressor.

      number of features

    layer_sizes: list

      the size of each dense layer in the network.  The length of this list determines the number of layers.

    weight_init_stddevs: list

    weight_init_stddevs: list or float

      the standard deviation of the distribution to use for weight initialization of each layer.  The length

      of this list should equal len(layer_sizes)+1.  The final element corresponds to the output layer.

    bias_init_consts: list

      Alternatively this may be a single value instead of a list, in which case the same value is used for every layer.

    bias_init_consts: list or float

      the value to initialize the biases in each layer to.  The length of this list should equal len(layer_sizes)+1.

      The final element corresponds to the output layer.

      The final element corresponds to the output layer.  Alternatively this may be a single value instead of a list,

      in which case the same value is used for every layer.

    weight_decay_penalty: float

      the magnitude of the weight decay penalty to use

    weight_decay_penalty_type: str

      the type of penalty to use for weight decay, either 'l1' or 'l2'

    dropouts: list

    dropouts: list or float

      the dropout probablity to use for each layer.  The length of this list should equal len(layer_sizes).

      Alternatively this may be a single value instead of a list, in which case the same value is used for every layer.

    activation_fns: list or object

      the Tensorflow activation function to apply to each layer.  The length of this list should equal

      len(layer_sizes).  Alternatively this may be a single value instead of a list, in which case the

      same value is used for every layer.

    """

    super(TensorGraphMultiTaskRegressor, self).__init__(

        mode='regression', **kwargs)

    self.n_tasks = n_tasks

    self.n_features = n_features

    n_layers = len(layer_sizes)

    if not isinstance(weight_init_stddevs, collections.Sequence):

      weight_init_stddevs = [weight_init_stddevs] * (n_layers + 1)

    if not isinstance(bias_init_consts, collections.Sequence):

      bias_init_consts = [bias_init_consts] * (n_layers + 1)

    if not isinstance(dropouts, collections.Sequence):

      dropouts = [dropouts] * n_layers

    if not isinstance(activation_fns, collections.Sequence):

      activation_fns = [activation_fns] * n_layers

    # Add the input features.

    # Add the dense layers

    for size, weight_stddev, bias_const, dropout in zip(

        layer_sizes, weight_init_stddevs, bias_init_consts, dropouts):

    for size, weight_stddev, bias_const, dropout, activation_fn in zip(

        layer_sizes, weight_init_stddevs, bias_init_consts, dropouts,

        activation_fns):

      layer = Dense(

          in_layers=[prev_layer],

          out_channels=size,

          activation_fn=tf.nn.relu,

          activation_fn=activation_fn,

          weights_initializer=TFWrapper(

              tf.truncated_normal_initializer, stddev=weight_stddev),

          biases_initializer=TFWrapper(

      mol_features: Molecule descriptor (e.g. fingerprint) tensor with shape

        batch_size x n_features.

    """

    placeholder_scope = TensorflowGraph.get_placeholder_scope(graph,

                                                              name_scopes)

    placeholder_scope = TensorflowGraph.get_placeholder_scope(

        graph, name_scopes)

    n_features = self.n_features

    with graph.as_default():

      with placeholder_scope:

      assert n_layers > 0, 'Must have some layers defined.'

      label_placeholders = self.add_label_placeholders(graph, name_scopes)

      weight_placeholders = self.add_example_weight_placeholders(graph,

                                                                 name_scopes)

      weight_placeholders = self.add_example_weight_placeholders(

          graph, name_scopes)

      if training:

        graph.queue = tf.FIFOQueue(

            capacity=5,

        batch_size x n_features.

    """

    n_features = self.n_features

    placeholder_scope = TensorflowGraph.get_placeholder_scope(graph,

                                                              name_scopes)

    placeholder_scope = TensorflowGraph.get_placeholder_scope(

        graph, name_scopes)

    with graph.as_default():

      with placeholder_scope:

        mol_features = tf.placeholder(

      assert n_layers > 0, 'Must have some layers defined.'

      label_placeholders = self.add_label_placeholders(graph, name_scopes)

      weight_placeholders = self.add_example_weight_placeholders(graph,

                                                                 name_scopes)

      weight_placeholders = self.add_example_weight_placeholders(

          graph, name_scopes)

      if training:

        graph.queue = tf.FIFOQueue(

            capacity=5,