def do_theano(self):
""" Compiles all theano functions needed to use the model"""
init_names = dir(self)
###### All fields you don't want to get pickled (e.g., theano functions) should be created below this line
# SAMPLING: NEGATIVE PHASE
neg_updates = self.neg_sampling_updates(n_steps=self.neg_sample_steps,
use_pcd=True)
self.sample_func = theano.function([], [], updates=neg_updates)
##
# BUILD COST OBJECTS
##
lcost = self.ml_cost(pos_v=self.input, neg_v=neg_updates[self.neg_v])
spcost = self.get_sparsity_cost()
regcost = self.get_reg_cost(self.l2, self.l1)
##
# COMPUTE GRADIENTS WRT. COSTS
##
main_cost = [lcost, spcost, regcost]
learning_grads = costmod.compute_gradients(self.lr, self.lr_mults,
*main_cost)
##
# BUILD UPDATES DICTIONARY FROM GRADIENTS
##
learning_updates = costmod.get_updates(learning_grads)
learning_updates.update(neg_updates)
learning_updates.update({self.iter: self.iter + 1})
# build theano function to train on a single minibatch
self.batch_train_func = function([self.input], [],
updates=learning_updates,
name='train_rbm_func')
#######################
# CONSTRAINT FUNCTION #
#######################
# enforce constraints function
constraint_updates = self.get_constraint_updates()
self.enforce_constraints = theano.function([], [],
updates=constraint_updates)
###### All fields you don't want to get pickled should be created above this line
final_names = dir(self)
self.register_names_to_del(
[name for name in (final_names) if name not in init_names])
# Before we start learning, make sure constraints are enforced
self.enforce_constraints()
def do_theano(self):
""" Compiles all theano functions needed to use the model"""
init_names = dir(self)
###### All fields you don't want to get pickled (e.g., theano functions) should be created below this line
# SAMPLING: NEGATIVE PHASE
neg_updates = self.neg_sampling_updates(n_steps=self.neg_sample_steps, use_pcd=True)
self.sample_func = theano.function([], [], updates=neg_updates)
##
# HELPER FUNCTIONS
##
self.fe_v_func = theano.function([self.input], self.free_energy_v(self.input))
self.fe_h_func = theano.function([self.input], self.free_energy_h(self.input))
self.post_func = theano.function([self.input], self.h_given_v(self.input))
self.v_given_h_func = theano.function([self.input], self.v_given_h(self.input))
self.h_given_v_func = theano.function([self.input], self.h_given_v(self.input))
self.sample_v_given_h_func = theano.function([self.input], self.sample_v_given_h(self.input))
self.sample_h_given_v_func = theano.function([self.input], self.sample_h_given_v(self.input))
## CAST FUNCTIONS
beta = T.vector('beta')
self.logp_given_beta_func = theano.function(
[self.input, beta],
-self.free_energy_v(self.input, beta=beta))
##
# BUILD COST OBJECTS
##
lcost = self.ml_cost(pos_v = self.input, neg_v = self.neg_v)
spcost = self.get_sparsity_cost()
regcost = self.get_reg_cost(self.l2, self.l1)
##
# COMPUTE GRADIENTS WRT. COSTS
##
main_cost = [lcost, spcost, regcost]
learning_grads = costmod.compute_gradients(self.lr, self.lr_mults, *main_cost)
##
# BUILD UPDATES DICTIONARY FROM GRADIENTS
##
learning_updates = costmod.get_updates(learning_grads)
learning_updates.update({
self.iter: self.iter+1,
self.logz: 0.0,
})
# build theano function to train on a single minibatch
self.batch_train_func = function([self.input], [],
updates=learning_updates,
name='train_rbm_func')
#######################
# CONSTRAINT FUNCTION #
#######################
# enforce constraints function
constraint_updates = self.get_constraint_updates()
self.enforce_constraints = theano.function([],[], updates=constraint_updates)
###### All fields you don't want to get pickled should be created above this line
final_names = dir(self)
self.register_names_to_del( [ name for name in (final_names) if name not in init_names ])
# Before we start learning, make sure constraints are enforced
self.enforce_constraints()
def do_theano(self):
""" Compiles all theano functions needed to use the model"""
init_names = dir(self)
###### All fields you don't want to get pickled (e.g., theano functions) should be created below this line
# SAMPLING: NEGATIVE PHASE
neg_updates = self.neg_sampling_updates(
n_steps=self.neg_sample_steps, use_pcd=not self.flags['use_cd'])
self.sample_func = theano.function([], [], updates=neg_updates)
# determing maximum likelihood cost
if self.flags.get('use_energy', False):
pos_h = self.h_given_v(self.input)
pos_s = self.s_given_hv(pos_h, self.input)
ml_cost = self.ml_cost_energy(pos_h=pos_h,
pos_s=pos_s,
pos_v=self.input,
neg_h=neg_updates[self.neg_h],
neg_s=neg_updates[self.neg_s],
neg_v=neg_updates[self.neg_v])
else:
ml_cost = self.ml_cost_free_energy(pos_v=self.input,
neg_v=neg_updates[self.neg_v])
main_cost = [
ml_cost,
self.get_sparsity_cost(),
self.get_reg_cost(self.l2, self.l1)
]
if self.orth_lambda:
main_cost += [self.orthogonality_cost(self.orth_lambda)]
##
# COMPUTE GRADIENTS WRT. TO ALL COSTS
##
learning_grads = utils_cost.compute_gradients(*main_cost)
##
# BUILD UPDATES DICTIONARY
##
learning_updates = utils_cost.get_updates(
learning_grads, self.lr, multipliers=self.lr_mults_shrd)
learning_updates.update(neg_updates)
learning_updates.update({self.iter: self.iter + 1})
# build theano function to train on a single minibatch
self.batch_train_func = function([self.input], [],
updates=learning_updates,
name='train_rbm_func')
# enforce constraints function
constraint_updates = OrderedDict()
constraint_updates[self.wv_norms] = T.maximum(1.0, self.wv_norms)
## clip parameters to maximum values (if applicable)
for (k, v) in self.clip_max.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(param, param, v)
## clip parameters to minimum values (if applicable)
for (k, v) in self.clip_min.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(
constraint_updates.get(param, param), v, param)
# constraint filters to have unit norm
if self.flags.get('weight_norm', None):
wv = constraint_updates.get(self.Wv, self.Wv)
wv_norm = T.sqrt(T.sum(wv**2, axis=0))
if self.flags['weight_norm'] == 'unit':
constraint_updates[self.Wv] = wv / wv_norm
elif self.flags['weight_norm'] == 'max_unit':
constraint_updates[self.Wv] = wv / wv_norm * T.minimum(
wv_norm, 1.0)
if self.scalar_b:
beta = constraint_updates.get(self.beta, self.beta)
constraint_updates[self.beta] = T.mean(beta) * T.ones_like(beta)
self.enforce_constraints = theano.function([], [],
updates=constraint_updates)
###### All fields you don't want to get pickled should be created above this line
final_names = dir(self)
self.register_names_to_del(
[name for name in (final_names) if name not in init_names])
# Before we start learning, make sure constraints are enforced
self.enforce_constraints()
def do_theano(self):
""" Compiles all theano functions needed to use the model"""
init_names = dir(self)
###### All fields you don't want to get pickled (e.g., theano functions) should be created below this line
# SAMPLING: NEGATIVE PHASE
neg_updates = self.neg_sampling_updates(
n_steps=self.neg_sample_steps,
use_pcd=not self.flags['use_cd'])
# determing maximum likelihood cost
ml_cost = self.ml_cost(pos_v = self.input, neg_v = neg_updates[self.neg_v])
main_cost = [ml_cost,
self.get_sparsity_cost(),
self.get_reg_cost(self.l2, self.l1)]
##
# COMPUTE GRADIENTS WRT. TO ALL COSTS
##
learning_grads = utils_cost.compute_gradients(*main_cost)
##
# BUILD UPDATES DICTIONARY
##
learning_updates = utils_cost.get_updates(
learning_grads,
self.lr,
multipliers = self.lr_mults_shrd)
learning_updates.update(neg_updates)
learning_updates.update({self.iter: self.iter+1})
# build theano function to train on a single minibatch
self.batch_train_func = function([self.input], [],
updates=learning_updates, name='train_rbm_func')
# enforce constraints function
constraint_updates = {}
## clip parameters to maximum values (if applicable)
for (k,v) in self.clip_max.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(param, param, v)
## clip parameters to minimum values (if applicable)
for (k,v) in self.clip_min.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(constraint_updates.get(param, param), v, param)
# constraint filters to have unit norm
if self.flags.get('weight_norm', None):
wv = constraint_updates.get(self.Wv, self.Wv)
wv_norm = T.sqrt(T.sum(wv**2, axis=0))
if self.flags['weight_norm'] == 'unit':
constraint_updates[self.Wv] = wv / wv_norm
elif self.flags['weight_norm'] == 'max_unit':
constraint_updates[self.Wv] = wv / wv_norm * T.minimum(wv_norm, 1.0)
self.enforce_constraints = theano.function([],[], updates=constraint_updates)
###### All fields you don't want to get pickled should be created above this line
final_names = dir(self)
self.register_names_to_del( [ name for name in (final_names) if name not in init_names ])
# Before we start learning, make sure constraints are enforced
self.enforce_constraints()
def do_theano(self):
""" Compiles all theano functions needed to use the model"""
init_names = dir(self)
###### All fields you don't want to get pickled (e.g., theano functions) should be created below this line
# SAMPLING: NEGATIVE PHASE
neg_updates = self.neg_sampling_updates(n_steps=self.neg_sample_steps)
self.sample_neg_func = function([], [], updates=neg_updates, name='sample_neg_func')
pos_updates = {}
# determing maximum likelihood cost
main_cost = [self.ml_cost(),
self.get_sparsity_cost(),
self.get_reg_cost(self.l2, self.l1)]
##
# COMPUTE GRADIENTS WRT. TO ALL COSTS
##
learning_grads = utils_cost.compute_gradients(*main_cost)
##
# BUILD UPDATES DICTIONARY
##
learning_updates = utils_cost.get_updates(
learning_grads,
self.lr_shrd,
multipliers = self.lr_mults_shrd)
if self.learn_h_weights:
learning_updates[self.Wh] *= self.sparse_hmask.mask
learning_updates.update(pos_updates)
# build theano function to train on a single minibatch
self.batch_train_func = function([self.input], [],
updates=learning_updates, name='train_rbm_func')
# enforce constraints function
constraint_updates = {}
## clip parameters to maximum values (if applicable)
for (k,v) in self.clip_max.iteritems():
assert k in [param.name for param in self.params]
param = getattr(self, k)
constraint_updates[param] = T.clip(param, param, v)
## clip parameters to minimum values (if applicable)
for (k,v) in self.clip_min.iteritems():
assert k in [param.name for param in self.params]
param = getattr(self, k)
constraint_updates[param] = T.clip(constraint_updates.get(param, param), v, param)
## Residual variance on beta is scalar valued
if self.scalar_b:
beta = constraint_updates.get(self.beta, self.beta)
constraint_updates[self.beta] = T.mean(beta) * T.ones_like(beta)
# constraint filters to have unit norm
if self.unit_norm_filters:
Wv = constraint_updates.get(self.Wv, self.Wv)
constraint_updates[self.Wv] = Wv / T.sqrt(T.sum(Wv**2, axis=0))
self.enforce_constraints = theano.function([],[], updates=constraint_updates)
###### All fields you don't want to get pickled should be created above this line
final_names = dir(self)
self.register_names_to_del( [ name for name in (final_names) if name not in init_names ])
# Before we start learning, make sure constraints are enforced
self.enforce_constraints()
def do_theano(self):
""" Compiles all theano functions needed to use the model"""
init_names = dir(self)
###### All fields you don't want to get pickled (e.g., theano functions) should be created below this line
# SAMPLING: NEGATIVE PHASE
neg_updates = self.neg_sampling_updates(n_steps=self.neg_sample_steps,
use_pcd=True)
self.sample_func = theano.function([], [], updates=neg_updates)
##
# BUILD COST OBJECTS
##
lcost = self.ml_cost(pos_v=self.input, neg_v=neg_updates[self.neg_v])
spcost = self.get_sparsity_cost()
regcost = self.get_reg_cost(self.l2, self.l1)
##
# COMPUTE GRADIENTS WRT. COSTS
##
main_cost = [lcost, spcost, regcost]
learning_grads = costmod.compute_gradients(self.lr, self.lr_mults,
*main_cost)
##
# BUILD UPDATES DICTIONARY FROM GRADIENTS
##
learning_updates = costmod.get_updates(learning_grads)
learning_updates.update(neg_updates)
learning_updates.update({self.iter: self.iter + 1})
# build theano function to train on a single minibatch
self.batch_train_func = function([self.input], [],
updates=learning_updates,
name='train_rbm_func')
#######################
# CONSTRAINT FUNCTION #
#######################
# enforce constraints function
constraint_updates = OrderedDict()
## clip parameters to maximum values (if applicable)
for (k, v) in self.clip_max.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(param, param, v)
## clip parameters to minimum values (if applicable)
for (k, v) in self.clip_min.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(
constraint_updates.get(param, param), v, param)
## constrain lambd to be a scalar
if self.flags['scalar_lambd']:
lambd = constraint_updates.get(self.lambd, self.lambd)
constraint_updates[self.lambd] = T.mean(lambd) * T.ones_like(lambd)
self.enforce_constraints = theano.function([], [],
updates=constraint_updates)
###### All fields you don't want to get pickled should be created above this line
final_names = dir(self)
self.register_names_to_del(
[name for name in (final_names) if name not in init_names])
# Before we start learning, make sure constraints are enforced
self.enforce_constraints()
def do_theano(self):
""" Compiles all theano functions needed to use the model"""
init_names = dir(self)
###### All fields you don't want to get pickled (e.g., theano functions) should be created below this line
# SAMPLING: NEGATIVE PHASE
neg_updates = self.neg_sampling_updates(n_steps=self.neg_sample_steps, use_pcd=True)
self.sample_func = theano.function([], [], updates=neg_updates)
##
# BUILD COST OBJECTS
##
lcost = self.ml_cost(pos_v = self.input, neg_v = neg_updates[self.neg_v])
spcost = self.get_sparsity_cost()
regcost = self.get_reg_cost(self.l2, self.l1)
##
# COMPUTE GRADIENTS WRT. COSTS
##
main_cost = [lcost, spcost, regcost]
learning_grads = costmod.compute_gradients(self.lr, self.lr_mults, *main_cost)
##
# BUILD UPDATES DICTIONARY FROM GRADIENTS
##
learning_updates = costmod.get_updates(learning_grads)
learning_updates.update(neg_updates)
learning_updates.update({self.iter: self.iter+1})
# build theano function to train on a single minibatch
self.batch_train_func = function([self.input], [],
updates=learning_updates,
name='train_rbm_func')
#######################
# CONSTRAINT FUNCTION #
#######################
# enforce constraints function
constraint_updates = OrderedDict()
## clip parameters to maximum values (if applicable)
for (k,v) in self.clip_max.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(param, param, v)
## clip parameters to minimum values (if applicable)
for (k,v) in self.clip_min.iteritems():
assert k in [param.name for param in self.params()]
param = getattr(self, k)
constraint_updates[param] = T.clip(constraint_updates.get(param, param), v, param)
## constrain lambd to be a scalar
if self.flags['scalar_lambd']:
lambd = constraint_updates.get(self.lambd, self.lambd)
constraint_updates[self.lambd] = T.mean(lambd) * T.ones_like(lambd)
self.enforce_constraints = theano.function([],[], updates=constraint_updates)
###### All fields you don't want to get pickled should be created above this line
final_names = dir(self)
self.register_names_to_del( [ name for name in (final_names) if name not in init_names ])
# Before we start learning, make sure constraints are enforced
self.enforce_constraints()