'Builds a trainer to minimize the cross entropy cost function.
Args:
task_context: file path from which to read the task context
batch_size: batch size to request from reader op
learning_rate: initial value of the learning rate
decay_steps: decay learning rate by 0.96 every this many steps
momentum: momentum parameter used when training with momentum
corpus_name: name of the task input to read parses from
Returns:
Dictionary of named training nodes.'

def AddTraining(self, task_context, batch_size, learning_rate=0.1, decay_steps=4000, momentum=0.9, corpus_name='documents'):

    with tf.name_scope('training'):
        nodes = self.training
        nodes.update(self._AddGoldReader(task_context, batch_size, corpus_name))
        nodes.update(self._BuildNetwork(nodes['feature_endpoints'], return_average=False))
        nodes.update(self._AddCostFunction(batch_size, nodes['gold_actions'], nodes['logits']))
        if self._only_train:
            trainable_params = [v for (k, v) in self.params.iteritems() if (k in self._only_train)]
        else:
            trainable_params = self.params.values()
        lr = self._AddLearningRate(learning_rate, decay_steps)
        optimizer = tf.train.MomentumOptimizer(lr, momentum, use_locking=self._use_locking)
        train_op = optimizer.minimize(nodes['cost'], var_list=trainable_params)
        for param in trainable_params:
            slot = optimizer.get_slot(param, 'momentum')
            self.inits[slot.name] = state_ops.init_variable(slot, tf.zeros_initializer())
            self.variables[slot.name] = slot
        numerical_checks = [tf.check_numerics(param, message='Parameter    is    not    finite.') for param in trainable_params if (param.dtype.base_dtype in [tf.float32, tf.float64])]
        check_op = tf.group(*numerical_checks)
        avg_update_op = tf.group(*self._averaging.values())
        train_ops = [train_op]
        if self._check_parameters:
            train_ops.append(check_op)
        if self._use_averaging:
            train_ops.append(avg_update_op)
        nodes['train_op'] = tf.group(name='train_op', *train_ops)
    return nodes
