def train_made_cond(n_hiddens, act_fun, mode):
assert is_data_loaded(), 'Dataset hasn\'t been loaded'
model = mades.ConditionalGaussianMade(data.n_labels,
data.n_dims,
n_hiddens,
act_fun,
mode=mode)
train_cond(model, a_made)
save_model(model, 'made_cond', mode, n_hiddens, act_fun, None, False)
def __init__(self, n_inputs, n_outputs, n_hiddens, act_fun, n_mades, batch_norm=True, output_order='sequential', mode='sequential', input=None, output=None, rng=np.random):
"""
Constructor.
:param n_inputs: number of (conditional) inputs
:param n_outputs: number of outputs
:param n_hiddens: list with number of hidden units for each hidden layer
:param act_fun: name of activation function
:param n_mades: number of mades in the flow
:param batch_norm: whether to use batch normalization between mades in the flow
:param output_order: order of outputs of last made
:param mode: strategy for assigning degrees to hidden nodes: can be 'random' or 'sequential'
:param input: theano variable to serve as input; if None, a new variable is created
:param output: theano variable to serve as output; if None, a new variable is created
"""
# save input arguments
self.n_inputs = n_inputs
self.n_outputs = n_outputs
self.n_hiddens = n_hiddens
self.act_fun = act_fun
self.n_mades = n_mades
self.batch_norm = batch_norm
self.mode = mode
self.input = tt.matrix('x', dtype=dtype) if input is None else input
self.y = tt.matrix('y', dtype=dtype) if output is None else output
self.parms = []
self.mades = []
self.bns = []
self.u = self.y
self.logdet_dudy = 0.0
for i in xrange(n_mades):
# create a new made
made = mades.ConditionalGaussianMade(n_inputs, n_outputs, n_hiddens, act_fun, output_order, mode, self.input, self.u, rng)
self.mades.append(made)
self.parms += made.parms
output_order = output_order if output_order == 'random' else made.output_order[::-1]
# inverse autoregressive transform
self.u = made.u
self.logdet_dudy += 0.5 * tt.sum(made.logp, axis=1)
# batch normalization
if batch_norm:
bn = layers.BatchNorm(self.u, n_outputs)
self.u = bn.y
self.parms += bn.parms
self.logdet_dudy += tt.sum(bn.log_gamma) - 0.5 * tt.sum(tt.log(bn.v))
self.bns.append(bn)
self.output_order = self.mades[0].output_order
# log likelihoods
self.L = -0.5 * n_inputs * np.log(2 * np.pi) - 0.5 * tt.sum(self.u ** 2, axis=1) + self.logdet_dudy
self.L.name = 'L'
# train objective
self.trn_loss = -tt.mean(self.L)
self.trn_loss.name = 'trn_loss'
# theano evaluation functions, will be compiled when first needed
self.eval_lprob_f = None
self.eval_grad_f = None
self.eval_score_f = None
self.eval_us_f = None