'Compiles the theano functions needed for the train method.
Parameters
model : a Model instance
dataset : Dataset'

def setup(self, model, dataset):

    self.i = 0
    if (self.cost is None):
        self.cost = model.get_default_cost()
    inf_params = [param for param in model.get_params() if np.any(np.isinf(param.get_value()))]
    if (len(inf_params) > 0):
        raise ValueError(('These    params    are    Inf:    ' + str(inf_params)))
    if any([np.any(np.isnan(param.get_value())) for param in model.get_params()]):
        nan_params = [param for param in model.get_params() if np.any(np.isnan(param.get_value()))]
        raise ValueError(('These    params    are    NaN:    ' + str(nan_params)))
    self.model = model
    self._synchronize_batch_size(model)
    model._test_batch_size = self.batch_size
    self.monitor = Monitor.get_monitor(model)
    self.monitor._sanity_check()
    if (getattr(model, 'force_batch_size', False) and any((((dataset.get_design_matrix().shape[0] % self.batch_size) != 0) for dataset in self.monitoring_dataset.values())) and (not has_uniform_batch_size(self.monitor_iteration_mode))):
        raise ValueError('Dataset    size    is    not    a    multiple    of    batch    size.You    should    set    monitor_iteration_mode    to    even_sequential,    even_shuffled_sequential    or    even_batchwise_shuffled_sequential')
    data_specs = self.cost.get_data_specs(self.model)
    mapping = DataSpecsMapping(data_specs)
    space_tuple = mapping.flatten(data_specs[0], return_tuple=True)
    source_tuple = mapping.flatten(data_specs[1], return_tuple=True)
    theano_args = []
    for (space, source) in safe_zip(space_tuple, source_tuple):
        name = ('%s[%s]' % (self.__class__.__name__, source))
        arg = space.make_theano_batch(name=name, batch_size=self.batch_size)
        theano_args.append(arg)
    theano_args = tuple(theano_args)
    nested_args = mapping.nest(theano_args)
    fixed_var_descr = self.cost.get_fixed_var_descr(model, nested_args)
    self.on_load_batch = fixed_var_descr.on_load_batch
    cost_value = self.cost.expr(model, nested_args, **fixed_var_descr.fixed_vars)
    if ((cost_value is not None) and (cost_value.name is None)):
        cost_value.name = 'objective'
    learning_rate = self.learning_rate
    if (self.monitoring_dataset is not None):
        if ((self.monitoring_batch_size is None) and (self.monitoring_batches is None)):
            self.monitoring_batch_size = self.batch_size
            self.monitoring_batches = self.batches_per_iter
        self.monitor.setup(dataset=self.monitoring_dataset, cost=self.cost, batch_size=self.monitoring_batch_size, num_batches=self.monitoring_batches, extra_costs=self.monitoring_costs, mode=self.monitor_iteration_mode)
        dataset_name = self.monitoring_dataset.keys()[0]
        monitoring_dataset = self.monitoring_dataset[dataset_name]
        self.monitor.add_channel(name='learning_rate', ipt=None, val=learning_rate, data_specs=(NullSpace(), ''), dataset=monitoring_dataset)
        if self.learning_rule:
            self.learning_rule.add_channels_to_monitor(self.monitor, monitoring_dataset)
    params = list(model.get_params())
    assert (len(params) > 0)
    for (i, param) in enumerate(params):
        if (param.name is None):
            param.name = ('sgd_params[%d]' % i)
    self.params = params
    (grads, updates) = self.cost.get_gradients(model, nested_args, **fixed_var_descr.fixed_vars)
    if (not isinstance(grads, OrderedDict)):
        raise TypeError((((((str(type(self.cost)) + '.get_gradients    returned    ') + 'something    with') + str(type(grads))) + 'as    its    ') + 'first    member.    Expected    OrderedDict.'))
    for param in grads:
        assert (param in params)
    for param in params:
        assert (param in grads)
    lr_scalers = model.get_lr_scalers()
    for key in lr_scalers:
        if (key not in params):
            raise ValueError((('Tried    to    scale    the    learning    rate    on    ' + str(key)) + '    which    is    not    an    optimization    parameter.'))
    assert (len(updates.keys()) == 0)
    def get_func(learn_discriminator, learn_generator):
        updates = OrderedDict()
        assert ((learn_discriminator or learn_generator) and (not (learn_discriminator and learn_generator)))
        if learn_discriminator:
            cur_params = model.discriminator.get_params()
        else:
            cur_params = model.generator.get_params()
        cur_grads = OrderedDict()
        for param in cur_params:
            cur_grads[param] = grads[param]
        for param in grads:
            if ((grads[param].name is None) and (cost_value is not None)):
                grads[param].name = ('grad(%(costname)s,    %(paramname)s)' % {'costname': cost_value.name, 'paramname': param.name})
            assert (grads[param].dtype == param.dtype)
        cur_lr_scalers = OrderedDict()
        for param in cur_params:
            if (param in lr_scalers):
                lr_scaler = lr_scalers[param]
                cur_lr_scalers[param] = lr_scaler
        log.info('Parameter    and    initial    learning    rate    summary:')
        for param in cur_params:
            param_name = param.name
            if (param_name is None):
                param_name = 'anon_param'
            lr = (learning_rate.get_value() * cur_lr_scalers.get(param, 1.0))
            log.info((((' DCTB ' + param_name) + ':    ') + str(lr)))
        if self.learning_rule:
            updates.update(self.learning_rule.get_updates(learning_rate, cur_grads, cur_lr_scalers))
        else:
            updates.update(dict(safe_zip(params, [(param - ((learning_rate * lr_scalers.get(param, 1.0)) * grads[param])) for param in params])))
        for param in cur_params:
            if (updates[param].name is None):
                updates[param].name = (('sgd_update(' + param.name) + ')')
        model.modify_updates(updates)
        for param in cur_params:
            update = updates[param]
            if (update.name is None):
                update.name = (('censor(sgd_update(' + param.name) + '))')
            for update_val in get_debug_values(update):
                if np.any(np.isinf(update_val)):
                    raise ValueError(('debug    value    of    %s    contains    infs' % update.name))
                if np.any(np.isnan(update_val)):
                    raise ValueError(('debug    value    of    %s    contains    nans' % update.name))
        with log_timing(log, 'Compiling    sgd_update'):
            return function(theano_args, updates=updates, name='sgd_update', on_unused_input='ignore', mode=self.theano_function_mode)
    self.d_func = get_func(1, 0)
    self.g_func = get_func(0, 1)
