Removed use of ModelConfig class

      with tf.name_scope(self.placeholder_root) as scope:

        self.placeholder_scope = scope

        self.valid = tf.placeholder(tf.bool,

                                    shape=[model_params.batch_size],

                                    shape=[model_params["batch_size"]],

                                    name='valid')

    num_classification_tasks = model_params.GetOptionalParam(

        'num_classification_tasks', 0)

    num_regression_tasks = model_params.GetOptionalParam('num_regression_tasks', 0)

    if "num_classification_tasks" in model_params:

      num_classification_tasks = model_params["num_classification_tasks"]

    else:

      num_classification_tasks = 0

    if "num_regression_tasks" in model_params:

      num_regression_tasks = model_params["num_regression_tasks"]

    else:

      num_regression_tasks = 0

    if num_classification_tasks and num_regression_tasks:

      raise AssertionError(

          'Dual classification/regression models are not supported.')

    for task in xrange(self.num_tasks):

      with tf.name_scope(self.placeholder_scope):

        weights.append(tf.identity(

            tf.placeholder(tf.float32, shape=[self.model_params.batch_size],

            tf.placeholder(tf.float32, shape=[self.model_params["batch_size"]],

                           name='weights_%d' % task)))

    self.weights = weights

            # tf.reduce_mean (which can put ops on the CPU) we explicitly

            # calculate with div/sum so it stays on the GPU.

            gradient_cost = tf.div(tf.reduce_sum(weighted_cost),

                                   model_params.batch_size)

                                   model_params["batch_size"])

            tf.scalar_summary('cost' + task_str,

                              model_ops.MovingAverage(gradient_cost,

                                                      self.global_step))

          old_loss = tf.add_n(old_costs)

        # weight decay

        if model_params.penalty != 0.0:

        if model_params["penalty"] != 0.0:

          penalty = WeightDecay(model_params)

          loss += penalty

          old_loss += penalty

      saver = tf.train.Saver(max_to_keep=max_checkpoints_to_keep)

      # Save an initial checkpoint.

      saver.save(sess, self._save_path, global_step=self.global_step)

      for (X_b, y_b, w_b, ids_b) in dataset.iterbatches(self.model_params.batch_size):

      for (X_b, y_b, w_b, ids_b) in dataset.iterbatches(self.model_params["batch_size"]):

        # Run training op and compute summaries.

        feed_dict = self.construct_feed_dict(X_b, y_b, w_b, ids_b)

        secs_since_summary = time.time() - last_summary_time

    weighted_costs = super(TensorflowClassifier, self).training_cost()  # calculate loss

    epsilon = 1e-3  # small float to avoid dividing by zero

    model_params = self.model_params

    num_tasks = model_params.num_classification_tasks

    num_tasks = model_params["num_classification_tasks"]

    cond_costs = collections.defaultdict(list)

    with self._shared_name_scope('costs'):

          with tf.name_scope('conditional'):

            # pos/neg costs: mean over pos/neg examples

            for name, label in [('neg', 0), ('pos', 1)]:

              cond_weights = self.labels[task][:model_params.batch_size, label]

              cond_weights = self.labels[task][:model_params["batch_size"], label]

              cond_cost = tf.div(

                  tf.reduce_sum(tf.mul(weighted_costs[task], cond_weights)),

                  tf.reduce_sum(cond_weights) + epsilon)

        with tf.device(num_pos.device):

          tf.get_default_graph().add_to_collection(

              'updates', num_pos.assign_add(

                  tf.reduce_sum(self.labels[task][:model_params.batch_size, 1])))

                  tf.reduce_sum(self.labels[task][:model_params["batch_size"], 1])))

        tf.scalar_summary(num_pos.name, num_pos)

    return weighted_costs

    feeding and fetching the same tensor.

    """

    model_params = self.model_params

    batch_size = model_params.batch_size

    num_classes = model_params.num_classes

    batch_size = model_params["batch_size"]

    num_classes = model_params["num_classes"]

    labels = []

    for task in xrange(self.num_tasks):

      with tf.name_scope(self.placeholder_scope):

        task.

    """

    y_true, y_pred = [], []

    for task in xrange(self.model_params.num_classification_tasks):

    for task in xrange(self.model_params["num_classification_tasks"]):

      # mask examples with zero weight

      mask = weights[:, task] > 0

      # get true class labels

    Placeholders are wrapped in identity ops to avoid the error caused by

    feeding and fetching the same tensor.

    """

    batch_size = self.model_params.batch_size

    batch_size = self.model_params["batch_size"]

    labels = []

    for task in xrange(self.num_tasks):

      with tf.name_scope(self.placeholder_scope):

    """

    # build arrays of true and predicted values for R-squared calculation

    y_true, y_pred = [], []

    for task in xrange(self.model_params.num_regression_tasks):

    for task in xrange(self.model_params["num_regression_tasks"]):

      mask = weights[:, task] > 0  # ignore examples with zero weight

      y_true.append(labels[mask, task])

      y_pred.append(output[mask, task])

    NotImplementedError: If an unsupported optimizer is requested.

  """

  # TODO(user): gradient clipping (see Minimize)

  if model_params.optimizer == 'adagrad':

    train_op = tf.train.AdagradOptimizer(model_params.learning_rate)

  elif model_params.optimizer == 'adam':

    train_op = tf.train.AdamOptimizer(model_params.learning_rate)

  elif model_params.optimizer == 'momentum':

    train_op = tf.train.MomentumOptimizer(model_params.learning_rate,

                                          model_params.memory)

  elif model_params.optimizer == 'rmsprop':

    train_op = tf.train.RMSPropOptimizer(model_params.learning_rate,

                                         model_params.memory)

  elif model_params.optimizer == 'sgd':

    train_op = tf.train.GradientDescentOptimizer(model_params.learning_rate)

  if model_params["optimizer"] == 'adagrad':

    train_op = tf.train.AdagradOptimizer(model_params["learning_rate"])

  elif model_params["optimizer"] == 'adam':

    train_op = tf.train.AdamOptimizer(model_params["learning_rate"])

  elif model_params["optimizer"] == 'momentum':

    train_op = tf.train.MomentumOptimizer(model_params["learning_rate"],

                                          model_params["memory"])

  elif model_params["optimizer"] == 'rmsprop':

    train_op = tf.train.RMSPropOptimizer(model_params["learning_rate"],

                                         model_params["memory"])

  elif model_params["optimizer"] == 'sgd':

    train_op = tf.train.GradientDescentOptimizer(model_params["learning_rate"])

  else:

    raise NotImplementedError('Unsupported optimizer %s' % model_params.optimizer)

    raise NotImplementedError('Unsupported optimizer %s' % model_params["optimizer"])

  return train_op

      variables.append(v)

  with tf.name_scope('weight_decay'):

    if model_params.penalty_type == 'l1':

    if model_params["penalty_type"] == 'l1':

      cost = tf.add_n([tf.reduce_sum(tf.Abs(v)) for v in variables])

    elif model_params.penalty_type == 'l2':

    elif model_params["penalty_type"] == 'l2':

      cost = tf.add_n([tf.nn.l2_loss(v) for v in variables])

    else:

      raise NotImplementedError('Unsupported penalty_type %s' %

                                model_params.penalty_type)

    cost *= model_params.penalty

                                model_params["penalty_type"])

    cost *= model_params["penalty"]

    tf.scalar_summary('Weight Decay Cost', cost)

  return cost

    with tf.name_scope(self.placeholder_scope):

      self.mol_features = tf.placeholder(

          tf.float32,

          shape=[self.model_params.batch_size, self.model_params.num_features],

          shape=[self.model_params["batch_size"],

                 self.model_params["num_features"]],

          name='mol_features')

    layer_sizes = self.model_params.layer_sizes

    weight_init_stddevs = self.model_params.weight_init_stddevs

    bias_init_consts = self.model_params.bias_init_consts

    dropouts = self.model_params.dropouts

    layer_sizes = self.model_params["layer_sizes"]

    weight_init_stddevs = self.model_params["weight_init_stddevs"]

    bias_init_consts = self.model_params["bias_init_consts"]

    dropouts = self.model_params["dropouts"]

    lengths_set = {

        len(layer_sizes),

        len(weight_init_stddevs),

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

    prev_layer = self.mol_features

    prev_layer_size = self.model_params.num_features

    prev_layer_size = self.model_params["num_features"]

    for i in xrange(num_layers):

      layer = tf.nn.relu(model_ops.FullyConnectedLayer(

          tensor=prev_layer,

      prev_layer_size = layer_sizes[i]

    self.output = model_ops.MultitaskLogits(

        layer, self.model_params.num_classification_tasks)

        layer, self.model_params["num_classification_tasks"])

  # TODO(rbharath): Copying this out for now. Ensure this isn't harmful

  #def add_labels_and_weights(self):

      randomize = False

      num_iterations = 1

    num_tasks = self.model_params.num_classification_tasks

    tasks_in_input = self.model_params.tasks_in_input

    num_tasks = self.model_params["num_classification_tasks"]

    tasks_in_input = self.model_params["tasks_in_input"]

    if input_data_types is None:

      input_data_types = ([legacy_types_pb2.DF_FLOAT] +

                          [legacy_types_pb2.DF_LABEL_PROTO] * tasks_in_input)

    features, labels = input_ops.InputExampleInputReader(

        input_pattern=input_pattern,

        batch_size=self.model_params.batch_size,

        batch_size=self.model_params["batch_size"],

        num_tasks=num_tasks,

        input_data_types=input_data_types,

        num_features=self.model_params.num_features,

        num_features=self.model_params["num_features"],

        randomize=randomize,

        shuffling=randomize,

        num_iterations=num_iterations)

    """Runs inference on the provided batch of input.

    Args:

      input_batch: iterator of input with len self.model_params.batch_size.

      input_batch: iterator of input with len self.model_params["batch_size"].

    Returns:

      Tuple of three numpy arrays with shape num_examples x num_tasks (x ...):

    Args:

      serialized_batch: List of tuples: (_, value) where value is

          a serialized InputExample proto. Must have self.model_params.batch_size

          a serialized InputExample proto. Must have self.model_params["batch_size"]

          length or smaller. If smaller, we'll pad up to batch_size

          and mark the padding as invalid so it's ignored in eval metrics.

    Yields:

    Raises:

      ValueError: If the batch is larger than the batch_size.

    """

    if len(serialized_batch) > self.model_params.batch_size:

    if len(serialized_batch) > self.model_params["batch_size"]:

      raise ValueError(

          'serialized_batch length {} must be <= batch_size {}'.format(

              len(serialized_batch), self.model_params.batch_size))

    for _ in xrange(self.model_params.batch_size - len(serialized_batch)):

              len(serialized_batch), self.model_params["batch_size"]))

    for _ in xrange(self.model_params["batch_size"] - len(serialized_batch)):

      serialized_batch.append((None, ''))

    features = []

        features.append([f for f in input_example.endpoint[0].float_value])

        label_protos = [endpoint.label

                        for endpoint in input_example.endpoint[1:]]

        assert len(label_protos) == self.model_params.num_classification_tasks

        assert len(label_protos) == self.model_params["num_classification_tasks"]

        labels.append([l.SerializeToString() for l in label_protos])

      else:

        # This was a padded value to reach the batch size.

        features.append([0.0 for _ in xrange(self.model_params.num_features)])

        features.append([0.0 for _ in xrange(self.model_params["num_features"])])

        labels.append(

            ['' for _ in xrange(self.model_params.num_classification_tasks)])

            ['' for _ in xrange(self.model_params["num_classification_tasks"])])

    valid = np.asarray([(np.sum(f) > 0) for f in features])

    assert len(features) == self.model_params.batch_size

    assert len(labels) == self.model_params.batch_size

    assert len(valid) == self.model_params.batch_size

    assert len(features) == self.model_params["batch_size"]

    assert len(labels) == self.model_params["batch_size"]

    assert len(valid) == self.model_params["batch_size"]

    yield self._GetFeedDict({

        'mol_features': features,

        'labels': labels,

        'bias_init_consts': [0.5],

        'dropouts': [0.0],

    })

    model_params.ReadFromFile(FLAGS.config,

                              overwrite='required')

    #model_params.ReadFromFile(FLAGS.config,

    #                          overwrite='required')

    if FLAGS.replica_id == 0:

      gfile.MakeDirs(FLAGS.logdir)

      model_params.WriteToFile(os.path.join(FLAGS.logdir, 'config.pbtxt'))

      #model_params.WriteToFile(os.path.join(FLAGS.logdir, 'config.pbtxt'))

#    model = icml_models.IcmlModel(config,

#                                  train=True,

    complex_featurizers = []

    #model_params = {}

    task_types = {"outcome": "classification"}

    input_file = "example_classification.csv"

    input_transformers = []

        splittype, compound_featurizers, 

        complex_featurizers, input_transformers,

        output_transformers, input_file, task_types.keys())

    #model_params["data_shape"] = train_dataset.get_data_shape()

    model_params = ModelConfig()

    model_params.AddParam("batch_size", 4, "allowed")

    model_params.AddParam("num_classification_tasks", 1, "allowed")

    model_params.AddParam("num_features", 1024, "allowed")

    model_params.AddParam("layer_sizes", [1024], "allowed")

    model_params.AddParam("weight_init_stddevs", [1.], "allowed")

    model_params.AddParam("bias_init_consts", [0.], "allowed")

    model_params.AddParam("dropouts", [.5], "allowed")

    model_params.AddParam("num_classes", 2, "allowed")

    model_params.AddParam("penalty", 0.0, "allowed")

    model_params.AddParam("optimizer", "adam", "allowed")

    model_params.AddParam("learning_rate", .001, "allowed")

    model_params = {

      "batch_size": 4,

      "num_classification_tasks": 1,

      "num_features": 1024,

      "layer_sizes": [1024],

      "weight_init_stddevs": [1.],

      "bias_init_consts": [0.],

      "dropouts": [.5],

      "num_classes": 2,

      "penalty": 0.0,

      "optimizer": "adam",

      "learning_rate": .001,

      "data_shape": train_dataset.get_data_shape()

    }

    train = True

    logdir = self.model_dir

    model = TensorflowMultiTaskClassifier(