def build(self, input_shape):
assert isinstance(input_shape, list)
self.batch_size, self.time_step, self.input_dim = input_shape[1]
self.batch_size_e, self.time_step_e, self.input_dim_e = input_shape[0]
"""
Matrices for cx (context) gate
"""
self.C_cx = self.add_weight(shape=(self.atten_units, ),
name='C_cx',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.W_cx = self.add_weight(shape=(self.input_dim_e + self.units,
self.atten_units),
name='W_cx',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.b_cx = self.add_weight(shape=(self.atten_units, ),
name='b_cx',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for i (input) gate
"""
self.V_i = self.add_weight(shape=(self.input_dim, self.units),
name='V_i',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.W_i = self.add_weight(shape=(self.input_dim_e, self.units),
name='W_i',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.U_i = self.add_weight(shape=(self.units, self.units),
name='U_i',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_i = self.add_weight(shape=(self.units, ),
name='b_i',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for f (forget) gate
"""
self.V_f = self.add_weight(shape=(self.input_dim, self.units),
name='V_f',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.W_f = self.add_weight(shape=(self.input_dim_e, self.units),
name='W_f',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.U_f = self.add_weight(shape=(self.units, self.units),
name='U_f',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_f = self.add_weight(shape=(self.units, ),
name='b_f',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for o (output) gate
"""
self.V_o = self.add_weight(shape=(self.input_dim, self.units),
name='V_o',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.W_o = self.add_weight(shape=(self.input_dim_e, self.units),
name='W_o',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.U_o = self.add_weight(shape=(self.units, self.units),
name='U_o',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_o = self.add_weight(shape=(self.units, ),
name='b_o',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for c (candidate)
"""
self.V_c = self.add_weight(shape=(self.input_dim, self.units),
name='V_c',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.W_c = self.add_weight(shape=(self.input_dim_e, self.units),
name='W_c',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.U_c = self.add_weight(shape=(self.units, self.units),
name='U_c',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_c = self.add_weight(shape=(self.units, ),
name='b_c',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for mmaxout
"""
self.U_p = self.add_weight(shape=(self.units, self.units),
name='U_p',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
"""
Matrices for making the final prediction vector
"""
self.M_p = self.add_weight(shape=(self.gmax, self.output_dim),
name='M_p',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.b_p = self.add_weight(shape=(self.output_dim, ),
name='b_p',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
# For creating the initial state:
self.W_sc = self.add_weight(shape=(self.input_dim, self.units),
name='W_sc',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_sc = self.add_weight(shape=(self.units, ),
name='b_sc',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
self.W_sy = self.add_weight(shape=(self.input_dim, self.units),
name='W_sy',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_sy = self.add_weight(shape=(self.units, ),
name='b_sy',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
self.trainable_weights = [
self.C_cx, self.W_cx, self.b_cx, self.V_i, self.W_i, self.U_i,
self.b_i, self.V_f, self.W_f, self.U_f, self.b_f, self.V_o,
self.W_o, self.U_o, self.b_o, self.V_c, self.W_c, self.U_c,
self.b_c, self.M_p, self.U_p, self.b_p, self.W_sc, self.W_sy,
self.b_sc, self.b_sy
]
self.input_spec = [
InputSpec(shape=(self.batch_size_e, self.time_step_e,
self.input_dim_e)),
InputSpec(shape=(self.batch_size, self.time_step, self.input_dim))
]
self.built = True
super(attention_LSTM, self).build(input_shape)
def build(self, input_shape):
assert isinstance(input_shape, list) or isinstance(input_shape, tuple)
if isinstance(input_shape, tuple):
main_input_shape = input_shape
else:
main_input_shape = input_shape[0]
batch_size = main_input_shape[0] if self.stateful else None
if self.semantic_condition and self.condition_on_ptm1 and self.generation_only:
#takes orig_input while training and dialogue act for conditioning
assert len(input_shape) == 2
self.input_dim = main_input_shape[2]
elif not self.generation_only and self.semantic_condition and self.condition_on_ptm1:
#takes the aux the orig input -1 and the dialogue act while training, while testing the o-1 is replaced by ptm1
assert len(input_shape) == 3
self.input_dim = 2 * main_input_shape[2]
elif not self.generation_only and not self.semantic_condition and self.condition_on_ptm1:
#takes aux, orig-1 while training and aus, aus while testing
assert len(input_shape) == 2
self.input_dim = 2 * main_input_shape[2]
elif not self.generation_only and not self.semantic_condition and not self.condition_on_ptm1:
#takes aux input for train and testing (vanille lstm)
self.input_dim = main_input_shape[2]
elif not self.generation_only and not self.semantic_condition and self.condition_on_ptm1:
self.input_dim = main_input_shape[2]
else:
assert len(input_shape) == 2
self.input_dim = main_input_shape[2]
if self.semantic_condition:
diact_shape = input_shape[-1]
self.dialogue_act_dim = diact_shape[-1]
self.input_spec[0] = InputSpec(shape=(batch_size, None,
main_input_shape[2]))
#h,c
self.states = [None, None]
if self.stateful:
self.reset_states()
self.kernel = self.add_weight(shape=(self.input_dim, self.units * 4),
name='kernel',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.recurrent_kernel = self.add_weight(
shape=(self.units, self.units * 4),
name='recurrent_kernel',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
if self.semantic_condition:
self.kernel_d = self.add_weight(
shape=(self.dialogue_act_dim, self.units),
name='diag_kernel',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.kernel_r = self.add_weight(
shape=(self.input_dim, self.dialogue_act_dim),
name='kernel_r',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.recurrent_kernel_r = self.add_weight(
shape=(self.units, self.dialogue_act_dim),
name='recurrent_kernel_r',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.kernel_constraint)
self.out_kernel = self.add_weight(
shape=(self.units, self.out_units),
name='out_kernel',
initializer=self.out_kernel_initializer,
regularizer=self.out_kernel_regularizer,
constraint=self.out_kernel_constraint)
if self.use_bias:
if self.unit_forget_bias:
def bias_initializer(shape, *args, **kwargs):
return K.concatenate([
self.bias_initializer((self.units, ), *args, **kwargs),
initializers.Ones()((self.units, ), *args, **kwargs),
self.bias_initializer((self.units * 2, ), *args,
**kwargs),
])
else:
bias_initializer = self.bias_initializer
self.bias = self.add_weight(shape=(self.units * 4, ),
name='bias',
initializer=bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
self.kernel_i = self.kernel[:, :self.units]
self.kernel_f = self.kernel[:, self.units * 1:self.units * 2]
self.kernel_c = self.kernel[:, self.units * 2:self.units * 3]
self.kernel_o = self.kernel[:, self.units * 3:]
self.recurrent_kernel_i = self.recurrent_kernel[:, :self.units]
self.recurrent_kernel_f = self.recurrent_kernel[:,
self.units:self.units *
2]
self.recurrent_kernel_c = self.recurrent_kernel[:, self.units *
2:self.units * 3]
self.recurrent_kernel_o = self.recurrent_kernel[:, self.units * 3:]
if self.use_bias:
self.bias_i = self.bias[:self.units]
self.bias_f = self.bias[self.units:self.units * 2]
self.bias_c = self.bias[self.units * 2:self.units * 3]
self.bias_o = self.bias[self.units * 3:]
if self.semantic_condition:
self.bias_r = self.add_weight(
shape=(self.dialogue_act_dim, ),
name='bias_r',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias_i = None
self.bias_f = None
self.bias_c = None
self.bias_o = None
self.bias_r = None
self.built = True
def __init__(self,
eps=1e-5,
cov_mode='channel',
activation='linear',
normalization='mean',
cov_regularizer=None,
cov_alpha=0.01,
cov_beta=0.3,
use_kernel=False,
kernel_initializer='ones',
kernel_regularizer=None,
kernel_constraint='NonNeg',
alpha_initializer='ones',
alpha_constraint=None,
dim_ordering='default',
robust=False,
**kwargs):
if dim_ordering == 'default':
dim_ordering = K.image_dim_ordering()
if dim_ordering == 'th':
self.axis_filter = 1
self.axis_row = 2
self.axis_col = 3
else:
self.axis_filter = 3
self.axis_row = 1
self.axis_col = 2
if cov_mode not in ['channel', 'feature', 'mean', 'pmean']:
raise ValueError('only support cov_mode across channel and features and mean, given {}'.format(cov_mode))
self.cov_mode = cov_mode
if normalization not in ['mean', None]:
raise ValueError('Only support normalization in mean or None, given {}'.format(normalization))
self.normalization = normalization
# input parameter preset
self.nb_filter = 0
self.cols = 0
self.rows = 0
self.nb_samples = 0
self.eps = eps
self.activation = activations.get(activation)
self.use_kernel = use_kernel
self.kernel_initializer = initializers.get(kernel_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.alpha_initializer = initializers.get(alpha_initializer)
self.alpha_constraint = constraints.get(alpha_constraint)
## Add the fob regularizer.
self.cov_regulairzer = cov_regularizer
self.cov_alpha = cov_alpha
self.cov_beta = cov_beta
self.robust = robust
self.dim_ordering = dim_ordering
self.input_spec = [InputSpec(ndim=4)]
super(SecondaryStatistic, self).__init__(**kwargs)
if self.use_kernel:
self.name += '-para'
def build(self, input_shape):
if isinstance(input_shape, list):
input_shape = input_shape[0]
batch_size = input_shape[0] if self.stateful else None
self.timestep_dim = input_shape[1]
self.input_dim = input_shape[2]
self.input_spec[0] = InputSpec(shape=(batch_size, None, self.input_dim))
self.states = [None, None]
if self.stateful:
self.reset_states()
self.kernel = self.add_weight(shape=(self.input_dim, self.units * 4),
name='kernel',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.recurrent_kernel = self.add_weight(
shape=(self.units, self.units * 4),
name='recurrent_kernel',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
# add attention kernel
self.attention_kernel = self.add_weight(
shape=(self.input_dim, self.units * 4),
name='attention_kernel',
initializer=self.attention_initializer,
regularizer=self.attention_regularizer,
constraint=self.attention_constraint)
# add attention weights
# weights for attention model
self.attention_weights = self.add_weight(shape=(self.input_dim, self.units),
name='attention_W',
initializer=self.attention_initializer,
regularizer=self.attention_regularizer,
constraint=self.attention_constraint)
self.attention_recurrent_weights = self.add_weight(shape=(self.units, self.units),
name='attention_U',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
if self.use_bias:
if self.unit_forget_bias:
def bias_initializer(shape, *args, **kwargs):
return K.concatenate([
self.bias_initializer((self.units,), *args, **kwargs),
initializers.Ones()((self.units,), *args, **kwargs),
self.bias_initializer((self.units * 2,), *args, **kwargs),
])
else:
bias_initializer = self.bias_initializer
self.bias = self.add_weight(shape=(self.units * 4,),
name='bias',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
self.attention_bias = self.add_weight(shape=(self.units,),
name='attention_b',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
self.attention_recurrent_bias = self.add_weight(shape=(self.units, 1),
name='attention_v',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
self.attention_bias = None
self.attention_recurrent_bias = None
self.kernel_i = self.kernel[:, :self.units]
self.kernel_f = self.kernel[:, self.units: self.units * 2]
self.kernel_c = self.kernel[:, self.units * 2: self.units * 3]
self.kernel_o = self.kernel[:, self.units * 3:]
self.recurrent_kernel_i = self.recurrent_kernel[:, :self.units]
self.recurrent_kernel_f = self.recurrent_kernel[:, self.units: self.units * 2]
self.recurrent_kernel_c = self.recurrent_kernel[:, self.units * 2: self.units * 3]
self.recurrent_kernel_o = self.recurrent_kernel[:, self.units * 3:]
self.attention_i = self.attention_kernel[:, :self.units]
self.attention_f = self.attention_kernel[:, self.units: self.units * 2]
self.attention_c = self.attention_kernel[:, self.units * 2: self.units * 3]
self.attention_o = self.attention_kernel[:, self.units * 3:]
if self.use_bias:
self.bias_i = self.bias[:self.units]
self.bias_f = self.bias[self.units: self.units * 2]
self.bias_c = self.bias[self.units * 2: self.units * 3]
self.bias_o = self.bias[self.units * 3:]
else:
self.bias_i = None
self.bias_f = None
self.bias_c = None
self.bias_o = None
self.built = True
def build(self, input_shape):
"""
See Appendix 2 of Bahdanau 2014, arXiv:1409.0473
for model details that correspond to the matrices here.
"""
self.batch_size, self.timesteps, self.input_dim = input_shape
if self.stateful:
super(AttentionDecoder, self).reset_states()
self.states = [None, None] # y, s
"""
Matrices for creating the context vector
"""
self.V_a = self.add_weight(shape=(self.units, ),
name='V_a',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.W_a = self.add_weight(shape=(self.units, self.units),
name='W_a',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.U_a = self.add_weight(shape=(self.input_dim, self.units),
name='U_a',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.b_a = self.add_weight(shape=(self.units, ),
name='b_a',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for the r (reset) gate
"""
self.C_r = self.add_weight(shape=(self.input_dim, self.units),
name='C_r',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.U_r = self.add_weight(shape=(self.units, self.units),
name='U_r',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.W_r = self.add_weight(shape=(self.output_dim, self.units),
name='W_r',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_r = self.add_weight(shape=(self.units, ),
name='b_r',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for the z (update) gate
"""
self.C_z = self.add_weight(shape=(self.input_dim, self.units),
name='C_z',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.U_z = self.add_weight(shape=(self.units, self.units),
name='U_z',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.W_z = self.add_weight(shape=(self.output_dim, self.units),
name='W_z',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_z = self.add_weight(shape=(self.units, ),
name='b_z',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for the proposal
"""
self.C_p = self.add_weight(shape=(self.input_dim, self.units),
name='C_p',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.U_p = self.add_weight(shape=(self.units, self.units),
name='U_p',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.W_p = self.add_weight(shape=(self.output_dim, self.units),
name='W_p',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_p = self.add_weight(shape=(self.units, ),
name='b_p',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
"""
Matrices for making the final prediction vector
"""
self.C_o = self.add_weight(shape=(self.input_dim, self.output_dim),
name='C_o',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.U_o = self.add_weight(shape=(self.units, self.output_dim),
name='U_o',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.W_o = self.add_weight(shape=(self.output_dim, self.output_dim),
name='W_o',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.b_o = self.add_weight(shape=(self.output_dim, ),
name='b_o',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
# For creating the initial state:
self.W_s = self.add_weight(shape=(self.input_dim, self.units),
name='W_s',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
self.input_spec = [
InputSpec(shape=(self.batch_size, self.timesteps, self.input_dim))
]
self.built = True
def __init__(self, size=(2, 2), data_format=None, **kwargs):
super(BilinearUpSampling2D, self).__init__(**kwargs)
self.data_format = conv_utils.normalize_data_format(data_format)
self.size = conv_utils.normalize_tuple(size, 2, 'size')
self.input_spec = InputSpec(ndim=4)
def __init__(self,
units,
activation='tanh',
recurrent_activation='hard_sigmoid',
attention_activation='tanh',
use_bias=True,
kernel_initializer='glorot_uniform',
recurrent_initializer='orthogonal',
attention_initializer='orthogonal',
bias_initializer='zeros',
unit_forget_bias=True,
kernel_regularizer=None,
recurrent_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
attention_regularizer=None,
kernel_constraint=None,
recurrent_constraint=None,
bias_constraint=None,
attention_constraint=None,
dropout=0.,
recurrent_dropout=0.,
return_attention=False,
implementation=1,
**kwargs):
super(AttentionLSTMCell, self).__init__(**kwargs)
self.input_spec = [InputSpec(ndim=3)]
self.units = units
self.activation = activations.get(activation)
self.recurrent_activation = activations.get(recurrent_activation)
self.attention_activation = activations.get(attention_activation)
self.use_bias = use_bias
self.kernel_initializer = initializers.get(kernel_initializer)
self.recurrent_initializer = initializers.get(recurrent_initializer)
self.attention_initializer = initializers.get(attention_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.unit_forget_bias = unit_forget_bias
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.recurrent_regularizer = regularizers.get(recurrent_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.attention_regularizer = regularizers.get(attention_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.recurrent_constraint = constraints.get(recurrent_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.attention_constraint = constraints.get(attention_constraint)
self.dropout = min(1., max(0., dropout))
self.recurrent_dropout = min(1., max(0., recurrent_dropout))
self.return_attention = return_attention
self._dropout_mask = None
self._recurrent_dropout_mask = None
self.implementation = implementation
self.state_spec = [
InputSpec(shape=(None, self.units)),
InputSpec(shape=(None, self.units))
]
self.state_size = (self.units, self.units)
def __init__(self, n_shapelets, **kwargs):
self.n_shapelets = n_shapelets
super(LocalSquaredDistanceLayer, self).__init__(**kwargs)
self.input_spec = InputSpec(ndim=3)
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
self.input_dim = 10
if self.stateful:
self.reset_states()
else:
# initial states: all-zero tensor of shape (output_dim)
self.states = [None]
self.W_z = self.add_weight((self.input_dim, self.output_dim),
initializer=self.init,
name='{}_W_z'.format(self.name),
regularizer=self.W_regularizer)
self.U_z = self.add_weight((self.output_dim, self.output_dim),
initializer=self.init,
name='{}_U_z'.format(self.name),
regularizer=self.W_regularizer)
self.b_z = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_b_z'.format(self.name),
regularizer=self.b_regularizer)
self.W_r = self.add_weight((self.input_dim, self.output_dim),
initializer=self.init,
name='{}_W_r'.format(self.name),
regularizer=self.W_regularizer)
self.U_r = self.add_weight((self.output_dim, self.output_dim),
initializer=self.init,
name='{}_U_r'.format(self.name),
regularizer=self.W_regularizer)
self.b_r = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_b_r'.format(self.name),
regularizer=self.b_regularizer)
self.W_h = self.add_weight((self.input_dim, self.output_dim),
initializer=self.init,
name='{}_W_h'.format(self.name),
regularizer=self.W_regularizer)
self.U_h = self.add_weight((self.output_dim, self.output_dim),
initializer=self.init,
name='{}_U_h'.format(self.name),
regularizer=self.W_regularizer)
self.b_h = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_b_h'.format(self.name),
regularizer=self.b_regularizer)
self.A_h = self.add_weight((self.output_dim, self.output_dim),
initializer=self.init,
name='{}_A_h'.format(self.name),
regularizer=self.W_regularizer)
self.A_u = self.add_weight((self.output_dim, self.output_dim),
initializer=self.init,
name='{}_A_u'.format(self.name),
regularizer=self.W_regularizer)
self.b_a_h = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_b_a_h'.format(self.name),
regularizer=self.b_regularizer)
self.b_a_u = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_b_a_u'.format(self.name),
regularizer=self.b_regularizer)
self.W_t = self.add_weight((self.input_dim, self.output_dim),
initializer=self.init,
name='{}_W_t'.format(self.name),
regularizer=self.W_regularizer)
self.U_t = self.add_weight((1, self.output_dim),
initializer=self.init,
name='{}_U_t'.format(self.name),
regularizer=self.W_regularizer)
self.b_t = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_b_t'.format(self.name),
regularizer=self.b_regularizer)
self.W_g = self.add_weight((self.input_dim, self.output_dim),
initializer=self.init,
name='{}_W_g'.format(self.name),
regularizer=self.W_regularizer)
self.U_g = self.add_weight((1, self.output_dim),
initializer=self.init,
name='{}_U_g'.format(self.name),
regularizer=self.W_regularizer)
self.b_g = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_b_g'.format(self.name),
regularizer=self.b_regularizer)
if self.initial_weights is not None:
self.set_weights(self.initial_weights)
del self.initial_weights
self.built = True
def __init__(self, padding, **kwargs):
self.padding = tuple(padding)
self.input_spec = [InputSpec(ndim=4)]
super(ReflectionPadding2D, self).__init__(**kwargs)
def __init__(self, **kwargs):
super(GlobalMinPooling1D, self).__init__(**kwargs)
self.input_spec = InputSpec(ndim=3)
def __init__(self, padding=1, data_format=None, **kwargs):
super(ChannelPadding, self).__init__(**kwargs)
self.padding = conv_utils.normalize_tuple(padding, 2, 'padding')
self.data_format = normalize_data_format(data_format)
self.input_spec = InputSpec(ndim=4)
def __init__(self, k=1, **kwargs):
super().__init__(**kwargs)
self.input_spec = InputSpec(ndim=3)
self.k = k
def __init__(self,
filters,
kernel_size,
input_components=None,
output_components=None,
strides=(1, 1),
padding='valid',
data_format=None,
dilation_rate=(1, 1),
activation=None,
use_bias=True,
pre_kernel_initializer='glorot_uniform',
kernel_initializer='glorot_uniform',
post_kernel_initializer='glorot_uniform',
bias_initializer='zeros',
pre_kernel_regularizer=None,
kernel_regularizer=None,
post_kernel_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
pre_kernel_constraint=None,
kernel_constraint=None,
post_kernel_constraint=None,
bias_constraint=None,
**kwargs):
super(FactorizedConv2DTucker, self).__init__(**kwargs)
rank = 2
self.rank = rank
self.input_components = input_components
self.output_components = output_components
self.filters = filters
self.output_components = output_components
self.kernel_size = conv_utils.normalize_tuple(kernel_size, rank,
'kernel_size')
self.strides = conv_utils.normalize_tuple(strides, rank, 'strides')
self.padding = conv_utils.normalize_padding(padding)
self.data_format = K.normalize_data_format(data_format)
self.dilation_rate = conv_utils.normalize_tuple(
dilation_rate, rank, 'dilation_rate')
self.activation = activations.get(activation)
self.use_bias = use_bias
self.pre_kernel_initializer = initializers.get(pre_kernel_initializer)
self.kernel_initializer = initializers.get(kernel_initializer)
self.post_kernel_initializer = initializers.get(
post_kernel_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.pre_kernel_regularizer = regularizers.get(pre_kernel_regularizer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.post_kernel_regularizer = regularizers.get(
post_kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.pre_kernel_constraint = constraints.get(pre_kernel_constraint)
self.kernel_constraint = constraints.get(kernel_constraint)
self.post_kernel_constraint = constraints.get(post_kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.input_spec = InputSpec(ndim=rank + 2) # batch, H, W, C
def __init__(self,
stack_sizes,
R_stack_sizes,
A_filt_sizes,
Ahat_filt_sizes,
R_filt_sizes,
pixel_max=1.,
error_activation='relu',
A_activation='relu',
LSTM_activation='tanh',
LSTM_inner_activation='hard_sigmoid',
output_mode='error',
extrap_start_time=None,
data_format=K.image_data_format(),
**kwargs):
self.stack_sizes = stack_sizes
self.nb_layers = len(stack_sizes)
assert len(
R_stack_sizes
) == self.nb_layers, 'len(R_stack_sizes) must equal len(stack_sizes)'
self.R_stack_sizes = R_stack_sizes
assert len(A_filt_sizes) == (
self.nb_layers -
1), 'len(A_filt_sizes) must equal len(stack_sizes) - 1'
self.A_filt_sizes = A_filt_sizes
assert len(
Ahat_filt_sizes
) == self.nb_layers, 'len(Ahat_filt_sizes) must equal len(stack_sizes)'
self.Ahat_filt_sizes = Ahat_filt_sizes
assert len(R_filt_sizes) == (
self.nb_layers), 'len(R_filt_sizes) must equal len(stack_sizes)'
self.R_filt_sizes = R_filt_sizes
self.pixel_max = pixel_max
self.error_activation = activations.get(error_activation)
self.A_activation = activations.get(A_activation)
self.LSTM_activation = activations.get(LSTM_activation)
self.LSTM_inner_activation = activations.get(LSTM_inner_activation)
default_output_modes = ['prediction', 'error', 'all']
layer_output_modes = [
layer + str(n) for n in range(self.nb_layers)
for layer in ['R', 'E', 'A', 'Ahat']
]
assert output_mode in default_output_modes + layer_output_modes, 'Invalid output_mode: ' + str(
output_mode)
self.output_mode = output_mode
if self.output_mode in layer_output_modes:
self.output_layer_type = self.output_mode[:-1]
self.output_layer_num = int(self.output_mode[-1])
else:
self.output_layer_type = None
self.output_layer_num = None
self.extrap_start_time = extrap_start_time
assert data_format in {
'channels_last', 'channels_first'
}, 'data_format must be in {channels_last, channels_first}'
self.data_format = data_format
self.channel_axis = -3 if data_format == 'channels_first' else -1
self.row_axis = -2 if data_format == 'channels_first' else -3
self.column_axis = -1 if data_format == 'channels_first' else -2
super(Argc_PredNet, self).__init__(**kwargs)
self.input_spec = [InputSpec(ndim=5)]
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
if self.stateful:
self.reset_states()
else:
# initial states: all-zero tensor of shape (output_dim)
self.states = [None]
input_dim = input_shape[2]
self.input_dim = input_dim
if self.flag_return_all_hidden:
output_dim_h0 = self.K_layers*self.output_dim
else:
output_dim_h0 = self.output_dim
if self.flag_nonnegative:
self.log_h0 = self.add_weight((self.output_dim,),
initializer='uniform',
name='{}_log_h0'.format(self.name))
self.h0_last = K.softplus(self.log_h0)
else:
self.h0_last = self.add_weight((self.output_dim,),
initializer='zero',
name='{}_h0'.format(self.name))
if self.flag_return_all_hidden:
self.h0 = K.tile(self.h0_last, [self.K_layers,])
else:
self.h0 = self.h0_last
for key in self.alt_params:
param=self.alt_params[key]
if key in self.keys_trainable:
flag_trainable=True
else:
flag_trainable=False
pcur = self.add_weight(param.shape,
initializer='zero',
trainable=flag_trainable,
name=('{}_%s' % key).format(self.name))
pcur.set_value(param)
#setattr(self, key, pcur)
self.alt_params[key]=pcur
self.Wk=[]
self.Uk=[]
self.bk=[]
self.Sk=[]
for k in range(self.K_layers):
if ('W' in self.maps_from_alt):
if isinstance(self.maps_from_alt['W'],list):
map_cur=self.maps_from_alt['W'][k]
else:
map_cur=self.maps_from_alt['W']
Wcur = map_cur(self.alt_params)
else:
Wcur = self.add_weight((input_dim, self.output_dim),
initializer=self.init,
name=('{}_W_%d' % k).format(self.name),
regularizer=self.W_regularizer)
if ('U' in self.maps_from_alt):
if isinstance(self.maps_from_alt['U'],list):
map_cur=self.maps_from_alt['U'][k]
else:
map_cur=self.maps_from_alt['U']
Ucur = map_cur(self.alt_params)
else:
Ucur = self.add_weight((self.output_dim, self.output_dim),
initializer=self.inner_init,
name=('{}_U_%d' % k).format(self.name),
regularizer=self.U_regularizer)
if ('b' in self.maps_from_alt):
if isinstance(self.maps_from_alt['b'],list):
map_cur=self.maps_from_alt['b'][k]
else:
map_cur=self.maps_from_alt['b']
bcur = map_cur(self.alt_params)
else:
bcur = self.add_weight((self.output_dim,),
initializer='zero',
name=('{}_b_%d' % k).format(self.name),
regularizer=self.b_regularizer)
self.Wk.append(Wcur)
self.Uk.append(Ucur)
self.bk.append(bcur)
if k>0:
if ('S' in self.maps_from_alt):
if isinstance(self.maps_from_alt['S'],list):
map_cur=self.maps_from_alt['S'][k-1]
else:
map_cur=self.maps_from_alt['S']
Scur = map_cur(self.alt_params)
else:
Scur = self.add_weight((self.output_dim, self.output_dim),
initializer=self.inner_init,
name=('{}_S_%dto%d' % (k-1,k)).format(self.name))
self.Sk.append(Scur)
"""
if self.initial_weights is not None:
self.set_weights(self.initial_weights)
del self.initial_weights
"""
self.built = True
def __init__(self, data_format=None, **kwargs):
super(Maxima2D, self).__init__(**kwargs)
self.data_format = conv_utils.normalize_data_format(data_format)
self.input_spec = InputSpec(ndim=4)
def build(self, input_shape):
self.batch_size, self.timesteps, self.input_dim = input_shape
if self.stateful:
super(AttentionDecoder, self).reset_states()
self.states = [None, None]
self.V_a = self.add_weight(shape=(self.units, ),
name="V_a",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.W_a = self.add_weight(shape=(self.units, self.units),
name="W_a",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.U_a = self.add_weight(shape=(self.input_dim, self.units),
name="U_a",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.b_a = self.add_weight(shape=(self.units),
name="b_a",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.C_r = self.add_weight(shape=(self.input_dim, self.units),
name="C_r",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.U_r = self.add_weight(shape=(self.units, self.units),
name="U_r",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.W_r = self.add_weight(shape=(self.output_dim, self.units),
name="W_r",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.b_r = self.add_weight(shape=(self.units),
name="b_r",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.C_z = self.add_weight(shape=(self.input_dim, self.units),
name="C_z",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.U_z = self.add_weight(shape=(self.units, self.units),
name="U_z",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.W_z = self.add_weight(shape=(self.ouput_dim, self.units),
name="W_z",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.b_z = self.add_weight(shape=(self.units),
name="b_z",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.C_p = self.add_weight(shape=(self.input_dim, self.units),
name="C_p",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.U_p = self.add_weight(shape=(self.units, self.units),
name="U_p",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.W_p = self.add_weight(shape=(self.ouput_dim, self.units),
name="W_p",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.b_p = self.add_weight(shape=(self.units),
name="b_p",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.C_o = self.add_weight(shape=(self.input_dim, self.output_dim),
name="C_o",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.U_o = self.add_weight(shape=(self.units, self.ouput_dim),
name="U_o",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.W_o = self.add_weight(shape=(self.ouput_dim, self.output_dim),
name="W_o",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.b_o = self.add_weight(shape=(self.output_dim, ),
name="b_o",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.W_s = self.add_weight(shape=(self.input_dim, self.units),
name="W_s",
initializer=self.kernel_initializer,
regularizer=self.kernel_regulaizer,
constraint=self.kernel_constraint)
self.input_spec = [
InputSpec(shape=(self.batch_size, self.timesteps, self.input_dim))
]
self.built = True
def build(self, input_shape):
if isinstance(input_shape, list):
input_shape = input_shape[0]
batch_size = input_shape[0] if self.stateful else None
self.input_dim = input_shape[2]
self.input_spec[0] = InputSpec(
shape=(batch_size, None,
self.input_dim)) # (timesteps, batchsize, inputdim)
self.states = [None, None]
if self.stateful:
self.reset_states()
if self.project_input:
self.kernel_dim = 4
elif self.input_dim != self.units:
self.kernel_dim = 4
else:
self.kernel_dim = 3
self.kernel = self.add_weight(shape=(self.input_dim,
self.units * self.kernel_dim),
name='kernel',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
if self.use_bias:
if self.unit_forget_bias:
def bias_initializer(shape, *args, **kwargs):
return K.concatenate([
self.bias_initializer((self.units, ), *args, **kwargs),
initializers.Ones()((self.units, ), *args, **kwargs),
])
else:
bias_initializer = self.bias_initializer
self.bias = self.add_weight(shape=(self.units * 2, ),
name='bias',
initializer=bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
self.kernel_w = self.kernel[:, :self.units]
self.kernel_f = self.kernel[:, self.units:self.units * 2]
self.kernel_r = self.kernel[:, self.units * 2:self.units * 3]
if self.kernel_dim == 4:
self.kernel_p = self.kernel[:, self.units * 3:self.units * 4]
else:
self.kernel_p = None
if self.use_bias:
self.bias_f = self.bias[:self.units]
self.bias_r = self.bias[self.units:self.units * 2]
else:
self.bias_f = None
self.bias_r = None
self.built = True
def build(self, input_shape):
if isinstance(input_shape, list):
input_shape = input_shape[0]
batch_size = input_shape[0] if self.stateful else None
self.input_dim = input_shape[2]
self.input_spec = InputSpec(shape=(batch_size, None, self.input_dim))
self.state_spec = [
InputSpec(shape=(batch_size, self.units)),
InputSpec(shape=(batch_size, self.units))
]
self.states = [None, None, None]
if self.stateful:
self.reset_states()
self.kernel = self.add_weight((self.input_dim, self.units * 4),
name='kernel',
initializer=self.kernel_initializer,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.recurrent_kernel = self.add_weight(
(self.units, self.units * 4),
name='recurrent_kernel',
initializer=self.recurrent_initializer,
regularizer=self.recurrent_regularizer,
constraint=self.recurrent_constraint)
if self.use_bias:
self.bias = self.add_weight((self.units * 4, ),
name='bias',
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
if self.unit_forget_bias:
bias_value = np.zeros((self.units * 4, ))
bias_value[self.units:self.units * 2] = 1.
K.set_value(self.bias, bias_value)
else:
self.bias = None
self.kernel_i = self.kernel[:, :self.units]
self.kernel_f = self.kernel[:, self.units:self.units * 2]
self.kernel_c = self.kernel[:, self.units * 2:self.units * 3]
self.kernel_o = self.kernel[:, self.units * 3:]
self.recurrent_kernel_i = self.recurrent_kernel[:, :self.units]
self.recurrent_kernel_f = self.recurrent_kernel[:,
self.units:self.units *
2]
self.recurrent_kernel_c = self.recurrent_kernel[:, self.units *
2:self.units * 3]
self.recurrent_kernel_o = self.recurrent_kernel[:, self.units * 3:]
if self.use_bias:
self.bias_i = self.bias[:self.units]
self.bias_f = self.bias[self.units:self.units * 2]
self.bias_c = self.bias[self.units * 2:self.units * 3]
self.bias_o = self.bias[self.units * 3:]
else:
self.bias_i = None
self.bias_f = None
self.bias_c = None
self.bias_o = None
# time-gate
self.timegate_kernel = self.add_weight(
(3, self.units),
name='timegate_kernel',
initializer=self.timegate_initializer,
regularizer=self.timegate_regularizer,
constraint=self.timegate_constraint)
self.built = True
def __init__(self, *args, n_channels=3, mono=False, **kwargs):
super().__init__(*args, **kwargs)
self.input_spec = [InputSpec(ndim=4), InputSpec(ndim=4)]
def __init__(self, k=1, sorted=True, **kwargs):
super().__init__(**kwargs)
self.input_spec = InputSpec(ndim=3)
self.k = k
self.sorted = sorted
def build(self, input_shape):
dim = input_shape[self.axis]
if dim is None:
raise ValueError('Axis ' + str(self.axis) + ' of '
'input tensor should have a defined dimension '
'but the layer received an input with shape ' +
str(input_shape) + '.')
if dim < self.groups:
raise ValueError('Number of groups (' + str(self.groups) + ') cannot be '
'more than the number of channels (' +
str(dim) + ').')
if dim % self.groups != 0:
raise ValueError('Number of groups (' + str(self.groups) + ') must be a '
'multiple of the number of channels (' +
str(dim) + ').')
self.input_spec = InputSpec(ndim=len(input_shape),
axes={self.axis: dim})
shape_ = (1, dim, 1, 1)
shape = (self.groups,)
broadcast_shape = [-1, self.groups, 1, 1, 1]
if self.scale:
self.gamma = self.add_weight(shape=shape_,
name='gamma',
initializer=self.gamma_initializer,
regularizer=self.gamma_regularizer,
constraint=self.gamma_constraint)
else:
self.gamma = None
if self.center:
self.beta = self.add_weight(shape=shape_,
name='beta',
initializer=self.beta_initializer,
regularizer=self.beta_regularizer,
constraint=self.beta_constraint)
else:
self.beta = None
self.moving_mean = self.add_weight(
shape=shape,
name="moving_mean",
initializer=self.moving_mean_initializer,
trainable=False)
self.moving_mean = K.reshape(self.moving_mean, broadcast_shape)
self.moving_mean = K.variable(value=self.moving_mean)
self.moving_variance = self.add_weight(
shape=shape,
name="moving_variance",
initializer=self.moving_variance_initializer,
trainable=False)
self.moving_variance = K.reshape(self.moving_variance, broadcast_shape)
self.moving_variance = K.variable(value=self.moving_variance)
self.built = True
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
self.input_dim = input_shape[2]
if self.stateful:
self.reset_states()
else:
# initial states: 2 all-zero tensors of shape (output_dim)
self.states = [None, None]
if self.consume_less == 'gpu':
self.W = self.init((self.input_dim, 4 * self.output_dim),
name='{}_W'.format(self.name))
self.U = self.inner_init((self.output_dim, 4 * self.output_dim),
name='{}_U'.format(self.name))
self.b = K.variable(np.hstack(
(np.zeros(self.output_dim),
K.get_value(self.forget_bias_init(self.output_dim)),
np.zeros(self.output_dim), np.zeros(self.output_dim))),
name='{}_b'.format(self.name))
self.trainable_weights = [self.W, self.U, self.b]
else:
self.W_i = self.init((self.input_dim, self.output_dim),
name='{}_W_i'.format(self.name))
self.U_i = self.inner_init((self.output_dim, self.output_dim),
name='{}_U_i'.format(self.name))
self.b_i = K.zeros((self.output_dim, ),
name='{}_b_i'.format(self.name))
self.W_f = self.init((self.input_dim, self.output_dim),
name='{}_W_f'.format(self.name))
self.U_f = self.inner_init((self.output_dim, self.output_dim),
name='{}_U_f'.format(self.name))
self.b_f = self.forget_bias_init((self.output_dim, ),
name='{}_b_f'.format(self.name))
self.W_c = self.init((self.input_dim, self.output_dim),
name='{}_W_c'.format(self.name))
self.U_c = self.inner_init((self.output_dim, self.output_dim),
name='{}_U_c'.format(self.name))
self.b_c = K.zeros((self.output_dim, ),
name='{}_b_c'.format(self.name))
self.W_o = self.init((self.input_dim, self.output_dim),
name='{}_W_o'.format(self.name))
self.U_o = self.inner_init((self.output_dim, self.output_dim),
name='{}_U_o'.format(self.name))
self.b_o = K.zeros((self.output_dim, ),
name='{}_b_o'.format(self.name))
self.trainable_weights = [
self.W_i, self.U_i, self.b_i, self.W_c, self.U_c, self.b_c,
self.W_f, self.U_f, self.b_f, self.W_o, self.U_o, self.b_o
]
self.W = K.concatenate([self.W_i, self.W_f, self.W_c, self.W_o])
self.U = K.concatenate([self.U_i, self.U_f, self.U_c, self.U_o])
self.b = K.concatenate([self.b_i, self.b_f, self.b_c, self.b_o])
self.regularizers = []
if self.W_regularizer:
self.W_regularizer.set_param(self.W)
self.regularizers.append(self.W_regularizer)
if self.U_regularizer:
self.U_regularizer.set_param(self.U)
self.regularizers.append(self.U_regularizer)
if self.b_regularizer:
self.b_regularizer.set_param(self.b)
self.regularizers.append(self.b_regularizer)
if self.initial_weights is not None:
self.set_weights(self.initial_weights)
del self.initial_weights
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
input_dim = input_shape[2]
self.input_dim = input_dim
if self.stateful:
self.reset_states()
else:
self.states = [None, None, None]
self.states_dim = [self.hidden_recurrent_dim, self.input_dim, self.hidden_dim]
if(not self.finetune):
self.output_dim = self.input_dim
else:
self.output_dim = self.hidden_dim
if(not hasattr(self, 'W')):
self.W = self.add_weight((input_dim, self.hidden_recurrent_dim),
initializer=self.init,
name='{}_W'.format(self.name),
regularizer=self.W_regularizer)
self.U = self.add_weight((self.hidden_recurrent_dim, self.hidden_recurrent_dim),
initializer=self.inner_init,
name='{}_U'.format(self.name),
regularizer=self.U_regularizer)
self.b = self.add_weight((self.hidden_recurrent_dim,),
initializer='zero',
name='{}_b'.format(self.name),
regularizer=self.b_regularizer)
if self.initial_weights is not None:
self.set_weights(self.initial_weights)
del self.initial_weights
if(self.rbm):
self.Wrbm = self.rbm.Wrbm
self.bv = self.rbm.bx
self.bh = self.rbm.bh
else:
self.Wrbm = self.add_weight((input_dim, self.hidden_dim),
initializer=self.init_rbm,
name='{}_Wrbm'.format(self.name),
regularizer=self.Wrbm_regularizer)
self.bv = self.add_weight((self.input_dim,),
initializer='zero',
name='{}_bv'.format(self.name),
regularizer=None)
self.bh = self.add_weight((self.hidden_dim,),
initializer='zero',
name='{}_bh'.format(self.name),
regularizer=None)
self.Wuv = self.add_weight((self.hidden_recurrent_dim, input_dim),
initializer=self.init,
name='{}_Wuv'.format(self.name),
regularizer=None)
self.Wuh = self.add_weight((self.hidden_recurrent_dim, self.hidden_dim),
initializer=self.init,
name='{}_Wuh'.format(self.name),
regularizer=None)
self.trainable_weights = [self.W, self.U, self.b, self.Wrbm, self.Wuh, self.bh]
if(not self.finetune):
self.trainable_weights.append(self.Wuv)
self.trainable_weights.append(self.bv)
self.built = True
def build(self, input_shape):
# pylint: disable=attribute-defined-outside-init,redefined-variable-type
# Defining two classes of parameters:
# 1) predicate, one argument composition (*2_*)
# 2) predicate, two arguments composition (*3_*)
#
# The naming scheme is an extension of the one used
# in the LSTM code of Keras. W is a weight and b is a bias
# *_i: input gate parameters
# *_fp: predicate forget gate parameters
# *_fa: argument forget gate parameters (one-arg only)
# *_fa1: argument-1 forget gate parameters (two-arg only)
# *_fa2: argument-2 forget gate parameters (two-arg only)
# *_u: update gate parameters
# *_o: output gate parameters
#
# Predicate, argument composition:
# W2_i, W2_fp, W2_fa, W2_o, W2_u
# U2_i, U2_fp, U2_fa, U2_o, U2_u
# b2_i, b2_fp, b2_fa, b2_o, b2_u
#
# Predicate, two argument composition:
# W3_i, W3_fp, W3_fa1, W3_fa2, W3_o, W3_u
# U3_i, U3_fp, U3_fa1, U3_fa2, U3_o, U3_u
# V3_i, V3_fp, V3_fa1, V3_fa2, V3_o, V3_u
# b3_i, b3_fp, b3_fa1, b3_fa2, b3_o, b3_u
self.input_spec = [InputSpec(shape=input_shape)]
self.input_dim = input_shape[2]
# initial states: buffer and stack. buffer has shape (samples, buff_limit, output_dim);
# stack has shape (samples, stack_limit, 2*output_dim)
self.states = [None, None]
# The first dims in all weight matrices are k * output_dim because of the recursive nature
# of treeLSTM
if self.implementation == 1:
# Input dimensionality for all W2s is output_dim, and there are 5 W2s: i, fp, fa, u, o
self.W2 = self.add_weight((self.output_dim, 5 * self.output_dim),
name='{}_W2'.format(self.name),
initializer=self.initializer)
# Input dimensionality for all U2s is output_dim, and there are 5 U2s: i, fp, fa, u, o
self.U2 = self.add_weight((self.output_dim, 5 * self.output_dim),
name='{}_U2'.format(self.name),
initializer=self.initializer)
# Input dimensionality for all W3s is output_dim, and there are 6 W2s: i, fp, fa1, fa2, u, o
self.W3 = self.add_weight((self.output_dim, 6 * self.output_dim),
name='{}_W3'.format(self.name),
initializer=self.initializer)
# Input dimensionality for all U3s is output_dim, and there are 6 U3s: i, fp, fa1, fa2, u, o
self.U3 = self.add_weight((self.output_dim, 6 * self.output_dim),
name='{}_U3'.format(self.name),
initializer=self.initializer)
# Input dimensionality for all V3s is output_dim, and there are 6 V3s: i, fp, fa1, fa2, u, o
self.V3 = self.add_weight((self.output_dim, 6 * self.output_dim),
name='{}_V3'.format(self.name),
initializer=self.initializer)
self.b2 = K.variable(np.hstack(
(np.zeros(self.output_dim),
K.get_value(
self.add_weight(
self.output_dim,
initializer=self.forget_bias_initializer)),
K.get_value(
self.add_weight(
self.output_dim,
initializer=self.forget_bias_initializer)),
np.zeros(self.output_dim), np.zeros(self.output_dim))),
name='{}_b2'.format(self.name))
self.b3 = K.variable(np.hstack(
(np.zeros(self.output_dim),
K.get_value(
self.add_weight(
self.output_dim,
initializer=self.forget_bias_initializer)),
K.get_value(
self.add_weight(
self.output_dim,
initializer=self.forget_bias_initializer)),
K.get_value(
self.add_weight(
self.output_dim,
initializer=self.forget_bias_initializer)),
np.zeros(self.output_dim), np.zeros(self.output_dim))),
name='{}_b3'.format(self.name))
self.trainable_weights = [
self.W2, self.U2, self.W3, self.U3, self.V3, self.b2, self.b3
]
else:
self.W2_i = self.add_weight((self.output_dim, self.output_dim),
name='{}_W2_i'.format(self.name),
initializer=self.initializer)
self.U2_i = self.add_weight((self.output_dim, self.output_dim),
name='{}_U2_i'.format(self.name),
initializer=self.initializer)
self.W3_i = self.add_weight((self.output_dim, self.output_dim),
name='{}_W3_i'.format(self.name),
initializer=self.initializer)
self.U3_i = self.add_weight((self.output_dim, self.output_dim),
name='{}_U3_i'.format(self.name),
initializer=self.initializer)
self.V3_i = self.add_weight((self.output_dim, self.output_dim),
name='{}_V3_i'.format(self.name),
initializer=self.initializer)
self.b2_i = K.zeros((self.output_dim, ),
name='{}_b2_i'.format(self.name))
self.b3_i = K.zeros((self.output_dim, ),
name='{}_b3_i'.format(self.name))
self.W2_fp = self.add_weight((self.output_dim, self.output_dim),
name='{}_W2_fp'.format(self.name),
initializer=self.initializer)
self.U2_fp = self.add_weight((self.output_dim, self.output_dim),
name='{}_U2_fp'.format(self.name),
initializer=self.initializer)
self.W2_fa = self.add_weight((self.output_dim, self.output_dim),
name='{}_W2_fa'.format(self.name),
initializer=self.initializer)
self.U2_fa = self.add_weight((self.output_dim, self.output_dim),
name='{}_U2_fa'.format(self.name),
initializer=self.initializer)
self.W3_fp = self.add_weight((self.output_dim, self.output_dim),
name='{}_W3_fp'.format(self.name),
initializer=self.initializer)
self.U3_fp = self.add_weight((self.output_dim, self.output_dim),
name='{}_U3_fp'.format(self.name),
initializer=self.initializer)
self.V3_fp = self.add_weight((self.output_dim, self.output_dim),
name='{}_V3_fp'.format(self.name),
initializer=self.initializer)
self.W3_fa1 = self.add_weight((self.output_dim, self.output_dim),
name='{}_W3_fa1'.format(self.name),
initializer=self.initializer)
self.U3_fa1 = self.add_weight((self.output_dim, self.output_dim),
name='{}_U3_fa1'.format(self.name),
initializer=self.initializer)
self.V3_fa1 = self.add_weight((self.output_dim, self.output_dim),
name='{}_V3_fa1'.format(self.name),
initializer=self.initializer)
self.W3_fa2 = self.add_weight((self.output_dim, self.output_dim),
name='{}_W3_fa2'.format(self.name),
initializer=self.initializer)
self.U3_fa2 = self.add_weight((self.output_dim, self.output_dim),
name='{}_U3_fa2'.format(self.name),
initializer=self.initializer)
self.V3_fa2 = self.add_weight((self.output_dim, self.output_dim),
name='{}_V3_fa2'.format(self.name),
initializer=self.initializer)
self.b2_fp = self.add_weight(
(self.output_dim, ),
name='{}_b2_fp'.format(self.name),
initializer=self.forget_bias_initializer)
self.b2_fa = self.add_weight(
(self.output_dim, ),
name='{}_b2_fa'.format(self.name),
initializer=self.forget_bias_initializer)
self.b3_fp = self.add_weight(
(self.output_dim, ),
name='{}_b3_fp'.format(self.name),
initializer=self.forget_bias_initializer)
self.b3_fa1 = self.add_weight(
(self.output_dim, ),
name='{}_b3_fa1'.format(self.name),
initializer=self.forget_bias_initializer)
self.b3_fa2 = self.add_weight(
(self.output_dim, ),
name='{}_b3_fa2'.format(self.name),
initializer=self.forget_bias_initializer)
self.W2_u = self.add_weight((self.output_dim, self.output_dim),
name='{}_W2_u'.format(self.name),
initializer=self.initializer)
self.U2_u = self.add_weight((self.output_dim, self.output_dim),
name='{}_U2_u'.format(self.name),
initializer=self.initializer)
self.W3_u = self.add_weight((self.output_dim, self.output_dim),
name='{}_W3_u'.format(self.name),
initializer=self.initializer)
self.U3_u = self.add_weight((self.output_dim, self.output_dim),
name='{}_U3_u'.format(self.name),
initializer=self.initializer)
self.V3_u = self.add_weight((self.output_dim, self.output_dim),
name='{}_V3_u'.format(self.name),
initializer=self.initializer)
self.b2_u = K.zeros((self.output_dim, ),
name='{}_b2_u'.format(self.name))
self.b3_u = K.zeros((self.output_dim, ),
name='{}_b3_u'.format(self.name))
self.W2_o = self.add_weight((self.output_dim, self.output_dim),
name='{}_W2_o'.format(self.name),
initializer=self.initializer)
self.U2_o = self.add_weight((self.output_dim, self.output_dim),
name='{}_U2_o'.format(self.name),
initializer=self.initializer)
self.W3_o = self.add_weight((self.output_dim, self.output_dim),
name='{}_W3_o'.format(self.name),
initializer=self.initializer)
self.U3_o = self.add_weight((self.output_dim, self.output_dim),
name='{}_U3_o'.format(self.name),
initializer=self.initializer)
self.V3_o = self.add_weight((self.output_dim, self.output_dim),
name='{}_V3_o'.format(self.name),
initializer=self.initializer)
self.b2_o = K.zeros((self.output_dim, ),
name='{}_b2_o'.format(self.name))
self.b3_o = K.zeros((self.output_dim, ),
name='{}_b3_o'.format(self.name))
self.W2 = K.concatenate(
[self.W2_i, self.W2_fp, self.W2_fa, self.W2_u, self.W2_o])
self.U2 = K.concatenate(
[self.U2_i, self.U2_fp, self.U2_fa, self.U2_u, self.U2_o])
self.W3 = K.concatenate([
self.W3_i, self.W3_fp, self.W3_fa1, self.W3_fa2, self.W3_u,
self.W3_o
])
self.U3 = K.concatenate([
self.U3_i, self.U3_fp, self.U3_fa1, self.U3_fa2, self.U3_u,
self.U3_o
])
self.V3 = K.concatenate([
self.V3_i, self.V3_fp, self.V3_fa1, self.V3_fa2, self.V3_u,
self.V3_o
])
self.b2 = K.concatenate(
[self.b2_i, self.b2_fp, self.b2_fa, self.b2_u, self.b2_o])
self.b3 = K.concatenate([
self.b3_i, self.b3_fp, self.b3_fa1, self.b3_fa2, self.b3_u,
self.b3_o
])
self.regularizers = []
if self.W_regularizers:
self.W_regularizers[0].set_param(self.W2)
self.W_regularizers[1].set_param(self.W3)
self.regularizers.extend(self.W_regularizers)
if self.U_regularizers:
self.U_regularizers[0].set_param(self.U2)
self.U_regularizers[1].set_param(self.U3)
self.regularizers.extend(self.U_regularizers)
if self.V_regularizer:
self.V_regularizer.set_param(self.V3)
self.regularizers.append(self.V_regularizer)
if self.b_regularizers:
self.b_regularizers[0].set_param(self.b2)
self.b_regularizers[1].set_param(self.b3)
self.regularizers.extend(self.b_regularizers)
self.built = True
def __init__(self,
units,
out_units,
alpha=0.2,
softmax_temperature=None,
return_da=True,
generation_only=False,
condition_on_ptm1=True,
semantic_condition=True,
activation='tanh',
recurrent_activation='hard_sigmoid',
use_bias=True,
kernel_initializer='glorot_uniform',
out_kernel_initializer='glorot_uniform',
recurrent_initializer='orthogonal',
bias_initializer='zeros',
unit_forget_bias=True,
kernel_regularizer=None,
out_kernel_regularizer=None,
recurrent_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
out_kernel_constraint=None,
recurrent_constraint=None,
bias_constraint=None,
dropout=0.,
recurrent_dropout=0.,
sc_dropout=0.,
**kwargs):
super(SC_LSTM, self).__init__(**kwargs)
self.units = units
self.alpha = alpha
self.out_units = out_units
self.activation = activations.get(activation)
self.recurrent_activation = activations.get(recurrent_activation)
self.use_bias = use_bias
self.semantic_condition = semantic_condition
self.generation_only = generation_only
self.return_da = return_da
self.softmax_temperature = softmax_temperature
#different behaviour while training than from inefrence time
self.train_phase = True
self.condition_on_ptm1 = condition_on_ptm1
if self.semantic_condition and self.condition_on_ptm1 and self.generation_only:
#takes orig_input while training and dialogue act for conditioning
self.input_spec = [InputSpec(ndim=3), InputSpec(ndim=2)]
elif not self.generation_only and self.semantic_condition and self.condition_on_ptm1:
#takes the aux the orig input -1 and the dialogue act while training, while testing the o-1 is replaced by ptm1
self.input_spec = [
InputSpec(ndim=3),
InputSpec(ndim=3),
InputSpec(ndim=2)
]
elif not self.generation_only and not self.semantic_condition and self.condition_on_ptm1:
#takes aux, orig-1 while training and aus, aus while testing
self.input_spec = [InputSpec(ndim=3), InputSpec(ndim=3)]
elif not self.generation_only and not self.semantic_condition and not self.condition_on_ptm1:
#takes aux input for train and testing (vanille lstm)
self.input_spec = [InputSpec(ndim=3)]
elif not self.generation_only and not self.condition_on_ptm1 and self.semantic_condition:
self.input_spec = [InputSpec(ndim=3), InputSpec(ndim=2)]
else:
self.input_spec = [InputSpec(ndim=3), InputSpec(ndim=3)]
self.kernel_initializer = initializers.get(kernel_initializer)
self.out_kernel_initializer = initializers.get(out_kernel_initializer)
self.recurrent_initializer = initializers.get(recurrent_initializer)
self.bias_initializer = initializers.get(bias_initializer)
self.unit_forget_bias = unit_forget_bias
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.out_kernel_regularizer = regularizers.get(out_kernel_regularizer)
self.recurrent_regularizer = regularizers.get(recurrent_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.out_kernel_constraint = constraints.get(out_kernel_constraint)
self.recurrent_constraint = constraints.get(recurrent_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.dropout = min(1., max(0., dropout))
self.recurrent_dropout = min(1., max(0., recurrent_dropout))
self.sc_dropout = min(1., max(0., sc_dropout))
self.state_spec = [
InputSpec(shape=(None, self.units)),
InputSpec(shape=(None, self.units))
]
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
self.conv_layers = {c: [] for c in ['i', 'f', 'c', 'a', 'ahat']}
for l in range(self.nb_layers):
for c in ['i', 'f', 'c']:
act = self.LSTM_activation if c == 'c' else self.LSTM_inner_activation
self.conv_layers[c].append(
Conv2D(self.R_stack_sizes[l],
self.R_filt_sizes[l],
padding='same',
activation=act,
data_format=self.data_format))
act = 'relu' if l == 0 else self.A_activation
self.conv_layers['ahat'].append(
Conv2D(self.stack_sizes[l],
self.Ahat_filt_sizes[l],
padding='same',
activation=act,
data_format=self.data_format))
if l < self.nb_layers - 1:
self.conv_layers['a'].append(
Conv2D(self.stack_sizes[l + 1],
self.A_filt_sizes[l],
padding='same',
activation=self.A_activation,
data_format=self.data_format))
self.upsample = UpSampling2D(data_format=self.data_format)
self.pool = MaxPooling2D(data_format=self.data_format)
self.trainable_weights = []
nb_row, nb_col = (
input_shape[-2],
input_shape[-1]) if self.data_format == 'channels_first' else (
input_shape[-3], input_shape[-2])
for c in sorted(self.conv_layers.keys()):
for l in range(len(self.conv_layers[c])):
ds_factor = 2**l
if c == 'ahat':
nb_channels = self.R_stack_sizes[l]
elif c == 'a':
nb_channels = 2 * self.stack_sizes[l]
else:
nb_channels = self.stack_sizes[l] * 2 + self.R_stack_sizes[
l]
if l < self.nb_layers - 1:
nb_channels += self.R_stack_sizes[l + 1]
in_shape = (input_shape[0], nb_channels, nb_row // ds_factor,
nb_col // ds_factor)
if self.data_format == 'channels_last':
in_shape = (in_shape[0], in_shape[2], in_shape[3],
in_shape[1])
with K.name_scope('layer_' + c + '_' + str(l)):
self.conv_layers[c][l].build(in_shape)
self.trainable_weights += self.conv_layers[c][
l].trainable_weights
self.states = [None] * self.nb_layers * 3
if self.extrap_start_time is not None:
self.t_extrap = K.variable(
self.extrap_start_time,
int if K.backend() != 'tensorflow' else 'int32')
self.states += [None] * 2
def build(self, input_shape):
super(PointerLSTM, self).build(input_shape)
self.input_spec = [InputSpec(shape=input_shape)]
def __init__(self, upsampling=(2, 2), data_format=None, **kwargs):
super(BilinearUpsampling, self).__init__(**kwargs)
self.data_format = normalize_data_format(data_format)
self.upsampling = conv_utils.normalize_tuple(upsampling, 2, 'size')
self.input_spec = InputSpec(ndim=4)
