def get_aggregator(self):
initialized = shared_like(0.)
numerator_acc = shared_like(self.numerator)
denominator_acc = shared_like(self.denominator)
# Dummy default expression to use as the previously-aggregated
# value, that has the same shape as the new result
numerator_zeros = tensor.as_tensor(self.numerator).zeros_like()
denominator_zeros = tensor.as_tensor(self.denominator).zeros_like()
conditional_update_num = self.numerator + ifelse(initialized,
numerator_acc,
numerator_zeros)
conditional_update_den = self.denominator + ifelse(initialized,
denominator_acc,
denominator_zeros)
initialization_updates = [(numerator_acc,
tensor.zeros_like(numerator_acc)),
(denominator_acc,
tensor.zeros_like(denominator_acc)),
(initialized, 0.)]
accumulation_updates = [(numerator_acc,
conditional_update_num),
(denominator_acc,
conditional_update_den),
(initialized, 1.)]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(numerator_acc /
denominator_acc))
return aggregator
def get_aggregator(self):
initialized = shared_like(0.)
numerator_acc = shared_like(self.numerator)
denominator_acc = shared_like(self.denominator)
# Dummy default expression to use as the previously-aggregated
# value, that has the same shape as the new result
numerator_zeros = tensor.as_tensor(self.numerator).zeros_like()
denominator_zeros = tensor.as_tensor(self.denominator).zeros_like()
conditional_update_num = self.numerator + ifelse(
initialized, numerator_acc, numerator_zeros)
conditional_update_den = self.denominator + ifelse(
initialized, denominator_acc, denominator_zeros)
initialization_updates = [
(numerator_acc, tensor.zeros_like(numerator_acc)),
(denominator_acc, tensor.zeros_like(denominator_acc)),
(initialized, tensor.zeros_like(initialized))
]
accumulation_updates = [(numerator_acc, conditional_update_num),
(denominator_acc, conditional_update_den),
(initialized, tensor.ones_like(initialized))]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(numerator_acc /
denominator_acc))
return aggregator
def get_aggregator(self):
initialized = shared_like(0.)
numerator_acc = shared_like(self.numerator)
denominator_acc = shared_like(self.denominator)
conditional_update_num = ifelse(initialized,
self.numerator + numerator_acc,
self.numerator)
conditional_update_den = ifelse(initialized,
self.denominator + denominator_acc,
self.denominator)
initialization_updates = [(numerator_acc,
tensor.zeros_like(numerator_acc)),
(denominator_acc,
tensor.zeros_like(denominator_acc)),
(initialized, 0.)]
accumulation_updates = [(numerator_acc,
conditional_update_num),
(denominator_acc,
conditional_update_den),
(initialized, 1.)]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(numerator_acc /
denominator_acc))
return aggregator
def get_aggregator(self):
initialized = shared_like(0.)
total_acc = shared_like(self.variable)
total_zeros = tensor.as_tensor(self.variable).zeros_like()
conditional_update_num = self.variable + ifelse(initialized,
total_acc,
total_zeros)
initialization_updates = [(total_acc,
tensor.zeros_like(total_acc)),
(initialized,
tensor.zeros_like(initialized))]
accumulation_updates = [(total_acc,
conditional_update_num),
(initialized, tensor.ones_like(initialized))]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(total_acc))
return aggregator
def get_aggregator(self):
initialized = shared_like(0.)
total_acc = shared_like(self.variable)
empty_init = tensor.zeros((0, ) * self.variable.ndim,
dtype=self.variable.dtype)
empty_shape = tuple([
0 if d is 0 else self.variable.shape[d]
for d in range(self.variable.ndim)
])
conditional_update_num = tensor.concatenate([
ifelse(initialized, total_acc, empty_init.reshape(empty_shape)),
self.variable
])
initialization_updates = [(total_acc, empty_init),
(initialized, tensor.zeros_like(initialized))
]
accumulation_updates = [(total_acc, conditional_update_num),
(initialized, tensor.ones_like(initialized))]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(total_acc))
return aggregator
def get_aggregator(self):
initialized = shared_like(0.)
total_acc = shared_like(self.variable)
empty_init = tensor.zeros(
(0,) * self.variable.ndim, dtype=self.variable.dtype)
empty_shape = tuple([
0 if d is 0
else self.variable.shape[d]
for d in range(self.variable.ndim)])
conditional_update_num = tensor.concatenate([
ifelse(initialized, total_acc, empty_init.reshape(empty_shape)),
self.variable])
initialization_updates = [(total_acc, empty_init),
(initialized, tensor.zeros_like(initialized))]
accumulation_updates = [(total_acc, conditional_update_num),
(initialized, tensor.ones_like(initialized))]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(total_acc))
return aggregator
def get_aggregator(self):
numerator_acc = shared_like(self.numerator)
denominator_acc = shared_like(self.denominator)
initialization_updates = [(numerator_acc, 0.0), (denominator_acc, 0.0)]
accumulation_updates = [
(numerator_acc, numerator_acc + self.numerator),
(denominator_acc, denominator_acc + self.denominator)
]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(numerator_acc /
denominator_acc))
return aggregator
def get_aggregator(self):
numerator_acc = shared_like(self.numerator)
denominator_acc = shared_like(self.denominator)
initialization_updates = [(numerator_acc, 0.0),
(denominator_acc, 0.0)]
accumulation_updates = [(numerator_acc,
numerator_acc + self.numerator),
(denominator_acc,
denominator_acc + self.denominator)]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(numerator_acc /
denominator_acc))
return aggregator
def get_aggregator(self):
self.storage = shared_like(self.variable)
return Aggregator(aggregation_scheme=self,
initialization_updates=[
(self.storage, tensor.zeros_like(self.storage))],
accumulation_updates=[(self.storage, self.variable)],
readout_variable=self.storage)
def get_aggregator(self):
self.storage = shared_like(self.variable)
return Aggregator(aggregation_scheme=self,
initialization_updates=[
(self.storage, tensor.zeros_like(self.storage))],
accumulation_updates=[(self.storage, self.variable)],
readout_variable=self.storage)
def get_snapshot(self, data):
"""Evaluate all role-carrying Theano variables on given data.
Parameters
----------
data : dict of (data source, data) pairs
Data for input variables. The sources should match with the
names of the input variables.
Returns
-------
Dictionary of (variable, variable value on given data) pairs.
"""
role_variables = [
var for var in self.variables
if hasattr(var.tag, "roles") and not is_shared_variable(var)
]
value_holders = [shared_like(var) for var in role_variables]
function = self.get_theano_function(
equizip(value_holders, role_variables))
function(*(data[input_.name] for input_ in self.inputs))
return OrderedDict([
(var, value_holder.get_value(borrow=True))
for var, value_holder in equizip(role_variables, value_holders)
])
def __init__(self, gradient_norm, clipping_rule,
initial_threshold, burnin_period=100, decay_rate=0.99):
self.gradient_norm = gradient_norm
self.clipping_rule = clipping_rule
self.initial_threshold = initial_threshold
self.burnin_period = burnin_period
self.decay_rate = decay_rate
self.mean_gradient_norm = self.mean_gradient_norm2 = .0
self._gradient_norm_receiver = shared_like(self.gradient_norm)
def get_aggregator(self):
initialized = shared_like(0.)
numerator_acc = shared_like(self.numerator)
denominator_acc = shared_like(self.denominator)
squared_num_acc = shared_like(self.squared_num)
conditional_update_num = ifelse(initialized,
self.numerator + numerator_acc,
self.numerator)
conditional_update_den = ifelse(initialized,
self.denominator + denominator_acc,
self.denominator)
conditional_update_sqn = ifelse(initialized,
self.squared_num + squared_num_acc,
self.squared_num)
initialization_updates = [(numerator_acc,
tensor.zeros_like(numerator_acc)),
(denominator_acc,
tensor.zeros_like(denominator_acc)),
(squared_num_acc,
tensor.zeros_like(squared_num_acc)),
(initialized, 0.)]
accumulation_updates = [(numerator_acc,
conditional_update_num),
(denominator_acc,
conditional_update_den),
(squared_num_acc,
conditional_update_sqn),
(initialized, 1.)]
readout_variable = tensor.stacklists([(numerator_acc /
denominator_acc),
((squared_num_acc /
denominator_acc) -
(numerator_acc /
denominator_acc)**2)])
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable = readout_variable)
return aggregator
def get_aggregator(self):
initialized = shared_like(0.)
expression_acc = shared_like(self.expression)
# Dummy default expression to use as the previously-accumulated
# value, that has the same shape as the new result
expression_zeros = tensor.as_tensor(self.expression).zeros_like()
conditional_update_expr = self.expression + ifelse(
initialized, expression_acc, expression_zeros)
initialization_updates = [(expression_acc,
tensor.zeros_like(expression_acc)),
(initialized, 0.)]
accumulation_updates = [(expression_acc, conditional_update_expr),
(initialized, 1.)]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(expression_acc))
return aggregator
def _build_aggregator(self, accumulate_update):
initialized = shared_like(0.)
accumulate = ifelse(initialized, accumulate_update, self.variable)
return Aggregator(aggregation_scheme=self,
initialization_updates=[
(self.storage, tensor.zeros_like(self.storage)),
(initialized, tensor.zeros_like(initialized))
],
accumulation_updates=[
(self.storage, accumulate),
(initialized, tensor.ones_like(initialized))
],
readout_variable=self.storage)
def get_aggregator(self):
initialized = shared_like(0.)
total_acc = shared_like(self.variable)
total_zeros = tensor.as_tensor(self.variable).zeros_like()
conditional_update_num = self.variable + ifelse(
initialized, total_acc, total_zeros)
initialization_updates = [(total_acc, tensor.zeros_like(total_acc)),
(initialized, tensor.zeros_like(initialized))
]
accumulation_updates = [(total_acc, conditional_update_num),
(initialized, tensor.ones_like(initialized))]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(total_acc))
return aggregator
def _build_aggregator(self, accumulate_update):
initialized = shared_like(0.)
accumulate = ifelse(initialized, accumulate_update, self.variable)
return Aggregator(aggregation_scheme=self,
initialization_updates=[
(self.storage, tensor.zeros_like(self.storage)),
(initialized, tensor.zeros_like(initialized))
],
accumulation_updates=[
(self.storage, accumulate),
(initialized, tensor.ones_like(initialized))
],
readout_variable=self.storage)
def get_aggregator(self):
initialized = shared_like(0.)
expression_acc = shared_like(self.expression)
# Dummy default expression to use as the previously-accumulated
# value, that has the same shape as the new result
expression_zeros = tensor.as_tensor(self.expression).zeros_like()
conditional_update_expr = self.expression + ifelse(initialized,
expression_acc,
expression_zeros)
initialization_updates = [(expression_acc,
tensor.zeros_like(expression_acc)),
(initialized, 0.)]
accumulation_updates = [(expression_acc,
conditional_update_expr),
(initialized, 1.)]
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=(expression_acc))
return aggregator
def get_aggregator(self):
initialized = shared_like(0.)
numerator_acc = shared_like(self.numerator)
denominator_acc = shared_like(self.denominator)
squared_num_acc = shared_like(self.squared_num)
conditional_update_num = ifelse(initialized,
self.numerator + numerator_acc,
self.numerator)
conditional_update_den = ifelse(initialized,
self.denominator + denominator_acc,
self.denominator)
conditional_update_sqn = ifelse(initialized,
self.squared_num + squared_num_acc,
self.squared_num)
initialization_updates = [
(numerator_acc, tensor.zeros_like(numerator_acc)),
(denominator_acc, tensor.zeros_like(denominator_acc)),
(squared_num_acc, tensor.zeros_like(squared_num_acc)),
(initialized, 0.)
]
accumulation_updates = [(numerator_acc, conditional_update_num),
(denominator_acc, conditional_update_den),
(squared_num_acc, conditional_update_sqn),
(initialized, 1.)]
readout_variable = tensor.stacklists([
(numerator_acc / denominator_acc),
((squared_num_acc / denominator_acc) -
(numerator_acc / denominator_acc)**2)
])
aggregator = Aggregator(aggregation_scheme=self,
initialization_updates=initialization_updates,
accumulation_updates=accumulation_updates,
readout_variable=readout_variable)
return aggregator
def get_snapshot(self, data):
"""Evaluate all role-carrying Theano variables on given data.
Parameters
----------
data : dict of (data source, data) pairs
Data for input variables. The sources should match with the
names of the input variables.
Returns
-------
Dictionary of (variable, variable value on given data) pairs.
"""
role_variables = [var for var in self.variables if hasattr(var.tag, "roles") and not is_shared_variable(var)]
value_holders = [shared_like(var) for var in role_variables]
function = self.get_theano_function(equizip(value_holders, role_variables))
function(*(data[input_.name] for input_ in self.inputs))
return OrderedDict(
[(var, value_holder.get_value(borrow=True)) for var, value_holder in equizip(role_variables, value_holders)]
)
def get_aggregator(self):
self.storage = shared_like(self.variable)
return self._build_aggregator(
tensor.concatenate([self.storage, self.variable]))
def get_aggregator(self):
self.storage = shared_like(self.variable)
return self._build_aggregator(
tensor.maximum(self.storage, self.variable))
def get_aggregator(self):
self.storage = shared_like(self.variable)
return self._build_aggregator(tensor.concatenate([self.storage,
self.variable]))
(discriminator_grad_norm, discriminator_descent.total_gradient_norm)])
generator_descent.add_updates([
(generator_cost, ComputationGraph(cost_generator).outputs[0]),
(generator_step_norm, generator_descent.total_step_norm),
(generator_grad_norm, generator_descent.total_gradient_norm)])
observables = []
observables.append(generator_cost)
observables.append(discriminator_cost)
observables.append(generator_step_norm)
observables.append(generator_grad_norm)
observables.append(discriminator_step_norm)
observables.append(discriminator_grad_norm)
g_out = shared_like(generator_cg.outputs[0],
name='generator_' + generator_cg.outputs[0].name)
d_out = shared_like(discriminator_cg.outputs[0],
name='discriminator_' + discriminator_cg.outputs[0].name)
false_generated = theano.shared(value=np.array(0., dtype=np.float32),
name='false_generated')
false_dataset = theano.shared(np.array(0., dtype='float32'),
name='false_dataset')
gen_errors = theano.shared(np.array(0., dtype='float32'),
name='generator_errors')
discriminator_descent.add_updates([(false_generated, false_generated +
(discriminator_cg.outputs[0] > 0.5)[:m].sum().astype('float32')),
def get_aggregator(self):
self.storage = shared_like(self.variable)
return self._build_aggregator(tensor.maximum(self.storage,
self.variable))
