def __init__(self, num_outputs=None, feedback_dim=None, **kwargs): super(LookupFeedback, self).__init__(**kwargs) update_instance(self, locals()) self.lookup = LookupTable(num_outputs, feedback_dim, kwargs.get("weights_init")) self.children = [self.lookup]
def __init__(self, aggregation_scheme, initialization_updates=None, accumulation_updates=None, readout_expression=None): if initialization_updates is None: initialization_updates = [] if accumulation_updates is None: accumulation_updates = [] update_instance(self, locals())
def __init__(self, state_names, state_dims, sequence_dim, match_dim, state_transformer=None, sequence_transformer=None, energy_computer=None, weights_init=None, biases_init=None, **kwargs): super(SequenceContentAttention, self).__init__(**kwargs) update_instance(self, locals()) self.state_transformers = Parallel(state_names, self.state_transformer, name="state_trans") if not self.sequence_transformer: self.sequence_transformer = MLP([Identity()], name="seq_trans") if not self.energy_computer: self.energy_computer = MLP([Identity()], name="energy_comp") self.children = [ self.state_transformers, self.sequence_transformer, self.energy_computer ]
def __init__(self, readout_dim, source_names, weights_init, biases_init, **kwargs): super(LinearReadout, self).__init__(readout_dim, **kwargs) update_instance(self, locals()) self.projectors = [MLP(name="project_{}".format(name), activations=[Identity()]) for name in self.source_names] self.children.extend(self.projectors)
def __init__(self, transition, **kwargs): super(FakeAttentionTransition, self).__init__(**kwargs) update_instance(self, locals()) self.state_names = transition.apply.states self.context_names = transition.apply.contexts self.glimpse_names = [] self.children = [self.transition]
def __init__(self, readout, transition, fork=None, weights_init=None, biases_init=None, **kwargs): super(BaseSequenceGenerator, self).__init__(**kwargs) update_instance(self, locals()) self.state_names = transition.compute_states.outputs self.context_names = transition.apply.contexts self.glimpse_names = transition.take_look.outputs self.children = [self.readout, self.fork, self.transition]
def __init__(self, input_dim, output_dim, weights_init, biases_init=None, use_bias=True, **kwargs): super(Linear, self).__init__(**kwargs) update_instance(self, locals())
def __init__(self, readout_dim=None, emitter=None, feedbacker=None, **kwargs): super(Readout, self).__init__(**kwargs) if not emitter: emitter = TrivialEmitter(readout_dim) if not feedbacker: feedbacker = TrivialFeedback(readout_dim) update_instance(self, locals()) self.children = [self.emitter, self.feedbacker]
def __init__(self, activation, gate_activation, dim, weights_init, use_update_gate=True, use_reset_gate=True, **kwargs): super(GatedRecurrent, self).__init__(**kwargs) if not activation: activation = Identity() if not gate_activation: gate_activation = Sigmoid() update_instance(self, locals()) self.children = [activation, gate_activation]
def __init__(self, activations, dims, weights_init, biases_init=None, use_bias=True, **kwargs): super(MLP, self).__init__(**kwargs) self.linear_transformations = [Linear(name='linear_{}'.format(i)) for i in range(len(activations))] self.children = (self.linear_transformations + [activation for activation in activations if activation is not None]) if not dims: dims = [None] * (len(activations) + 1) update_instance(self, locals())
def __init__(self, activations, dims, **kwargs): update_instance(self, locals()) self.linear_transformations = [Linear(name='linear_{}'.format(i)) for i in range(len(activations))] # Interleave the transformations and activations children = [child for child in list(chain(*zip( self.linear_transformations, activations))) if child is not None] if not dims: dims = [None] * (len(activations) + 1) self.dims = dims super(MLP, self).__init__(children, **kwargs)
def __init__(self, channel_names, input_dims, output_dims, prototype=None, **kwargs): super(Parallel, self).__init__(**kwargs) update_instance(self, locals()) if not self.prototype: self.prototype = MLP([Identity()], use_bias=False) self.transforms = [] for name in self.channel_names: self.transforms.append(copy.deepcopy(self.prototype)) self.transforms[-1].name = "transform_{}".format(name) self.children = self.transforms
def __init__(self, input_dim, output_dim, num_pieces, **kwargs): super(LinearMaxout, self).__init__(**kwargs) update_instance(self, locals()) self.linear_transformation = Linear(name='linear_to_maxout', input_dim=input_dim, output_dim=output_dim * num_pieces, weights_init=self.weights_init, biases_init=self.biases_init, use_bias=self.use_bias) self.maxout_transformation = Maxout(name='maxout', num_pieces=num_pieces) self.children = [self.linear_transformation, self.maxout_transformation]
def __init__(self, transition, num_params, params_name, weights_init, biases_init, **kwargs): super(AddParameters, self).__init__(**kwargs) update_instance(self, locals()) self.input_names = [name for name in transition.apply.sequences if name != 'mask'] self.state_name = transition.apply.states[0] assert len(transition.apply.states) == 1 self.fork = Fork(self.input_names) # Could be also several init bricks, one for each of the states self.init = MLP([Identity()], name="init") self.children = [self.transition, self.fork, self.init]
def __init__(self, state_names, state_dims, sequence_dim, match_dim, state_transformer=None, sequence_transformer=None, energy_computer=None, weights_init=None, biases_init=None, **kwargs): super(SequenceContentAttention, self).__init__(**kwargs) update_instance(self, locals()) self.state_transformers = Parallel(state_names, self.state_transformer, name="state_trans") if not self.sequence_transformer: self.sequence_transformer = MLP([Identity()], name="seq_trans") if not self.energy_computer: self.energy_computer = MLP([Identity()], name="energy_comp") self.children = [self.state_transformers, self.sequence_transformer, self.energy_computer]
def __init__(self, activations, dims, weights_init, biases_init=None, use_bias=True, **kwargs): super(MLP, self).__init__(**kwargs) self.linear_transformations = [ Linear(name='linear_{}'.format(i)) for i in range(len(activations)) ] self.children = (self.linear_transformations + [ activation for activation in activations if activation is not None ]) if not dims: dims = [None] * (len(activations) + 1) update_instance(self, locals())
def __init__(self, transition, attention, mixer, attended_name=None, attended_mask_name=None, **kwargs): super(AttentionTransition, self).__init__(**kwargs) update_instance(self, locals()) self.sequence_names = self.transition.apply.sequences self.state_names = self.transition.apply.states self.context_names = self.transition.apply.contexts if not self.attended_name: self.attended_name = self.context_names[0] if not self.attended_mask_name: self.attended_mask_name = self.context_names[1] self.preprocessed_attended_name = "preprocessed_" + self.attended_name self.glimpse_names = self.attention.take_look.outputs # We need to determine which glimpses are fed back. # Currently we extract it from `take_look` signature. self.previous_glimpses_needed = [ name for name in self.glimpse_names if name in self.attention.take_look.inputs] self.children = [self.transition, self.attention, self.mixer]
def __init__(self, data_stream, request_iterator=None, as_dict=False): update_instance(self, locals())
def __init__(self, length, dim, weights_init, **kwargs): super(LookupTable, self).__init__(**kwargs) update_instance(self, locals())
def __init__(self, num_init, weights_init, sparse_init=None): if sparse_init is None: sparse_init = Constant(0.) update_instance(self, locals())
def __init__(self, input_dim, output_dim, **kwargs): super(Linear, self).__init__(**kwargs) update_instance(self, locals())
def __init__(self, rng, func, seq_len, batch_size): update_instance(self, locals()) self.num_params = len(inspect.getargspec(self.func).args) - 1
def __init__(self, dim, weights_init, activation=None, **kwargs): super(Recurrent, self).__init__(**kwargs) if activation is None: activation = Identity() update_instance(self, locals()) self.children = [activation]
def __init__(self, variable): update_instance(self, locals())
def __init__(self, rng, seq_len): update_instance(self, locals())
def __init__(self, rng, seq_len, batch_size): update_instance(self, locals()) logger.debug("Markov chain entropy: {}".format(self.entropy)) logger.debug("Expected min error: {}".format( -self.entropy * self.seq_len * self.batch_size))
def __init__(self, rng=None, theano_rng=None, **kwargs): super(DefaultRNG, self).__init__(**kwargs) update_instance(self, locals())
def __init__(self, theano_rng=None, **kwargs): super(Random, self).__init__(**kwargs) update_instance(self, locals())
def __init__(self, prototype, weights_init, **kwargs): super(Bidirectional, self).__init__(**kwargs) update_instance(self, locals()) self.children = [copy.deepcopy(prototype) for i in range(2)] self.children[0].name = 'forward' self.children[1].name = 'backward'