def __init__(
self,
rank,
filters,
kernel_size,
strides=1,
padding="valid",
data_format=None,
dilation_rate=1,
activation=None,
use_bias=True,
normalize_weight=False,
kernel_initializer="complex",
bias_initializer="zeros",
gamma_diag_initializer=sqrt_init,
gamma_off_initializer="zeros",
kernel_regularizer=None,
bias_regularizer=None,
gamma_diag_regularizer=None,
gamma_off_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
gamma_diag_constraint=None,
gamma_off_constraint=None,
init_criterion="he",
seed=None,
spectral_parametrization=False,
transposed=False,
epsilon=1e-7,
**kwargs):
super(ComplexConv, self).__init__(**kwargs)
self.rank = rank
self.filters = filters
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 = "channels_last" \
if rank == 1 else 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.normalize_weight = normalize_weight
self.init_criterion = init_criterion
self.spectral_parametrization = spectral_parametrization
self.transposed = transposed
self.epsilon = epsilon
self.kernel_initializer = sanitizedInitGet(kernel_initializer)
self.bias_initializer = sanitizedInitGet(bias_initializer)
self.gamma_diag_initializer = sanitizedInitGet(gamma_diag_initializer)
self.gamma_off_initializer = sanitizedInitGet(gamma_off_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.gamma_diag_regularizer = regularizers.get(gamma_diag_regularizer)
self.gamma_off_regularizer = regularizers.get(gamma_off_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.gamma_diag_constraint = constraints.get(gamma_diag_constraint)
self.gamma_off_constraint = constraints.get(gamma_off_constraint)
if seed is None:
self.seed = np.random.randint(1, 10e6)
else:
self.seed = seed
self.input_spec = InputSpec(ndim=self.rank + 2)
# The following are initialized later
self.kernel_shape = None
self.kernel = None
self.gamma_rr = None
self.gamma_ii = None
self.gamma_ri = None
self.bias = None
def __init__(self, scale = 1, **kwargs):
self.scale = scale
self.input_spec = [InputSpec(ndim=4)]
super(Upsampling, self).__init__(**kwargs)
def build(self, input_shape):
input_shapes = input_shape
assert (input_shapes[0] == input_shapes[1])
input_shape = input_shapes[0]
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) + '.')
self.input_spec = InputSpec(ndim=len(input_shape),
axes={self.axis: dim})
shape = (dim, ) # 用于对实数的初始化
if self.scale:
self.gamma_rr = self.add_weight(
shape=shape,
name='gamma_rr',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint)
self.gamma_rr = self.add_weight(
shape=shape,
name='gamma_ii',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint)
self.gamma_ri = self.add_weight(
shape=shape,
name='gamma_ri',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint)
self.moving_Vrr = self.add_weight(
shape=shape,
initializer=self.moving_variance_initializer,
name='moving_Vrr',
trainable=False)
self.moving_Vii = self.add_weight(
shape=shape,
initializer=self.moving_variance_initializer,
name='moving_Vii',
trainable=False)
self.moving_Vri = self.add_weight(
shape=shape,
initializer=self.moving_covariance_initializer,
name='moving_Vri',
trainable=False)
else:
self.gamma_rr = None
self.gamma_ii = None
self.gamma_ri = None
self.moving_Vrr = None
self.moving_Vii = None
self.moving_Vri = None
if self.center:
self.beta_real = self.add_weight(shape=shape,
name='beta_real',
initializer=self.beta_initializer,
regularizer=self.beta_regularizer,
constraint=self.beta_constraint)
self.beta_image = self.add_weight(
shape=shape,
name='beta_image',
initializer=self.beta_initializer,
regularizer=self.beta_regularizer,
constraint=self.beta_constraint)
self.moving_mean_real = self.add_weight(
shape=shape,
initializer=self.moving_mean_initializer,
name='moving_mean_real',
trainable=False)
self.moving_mean_image = self.add_weight(
shape=shape,
initializer=self.moving_mean_initializer,
name='moving_mean_image',
trainable=False)
else:
self.beta_real = None
self.beta_image = None
self.moving_mean_real = None
self.moving_mean_image = None
self.built = True
def __init__(self,
rank,
filters,
kernel_size,
strides=1,
padding='valid',
data_format=None,
dilation_rate=1,
activation=None,
use_bias=True,
normalize_weight=False,
kernel_initializer='complex',
bias_initializer='zeros',
gamma_diag_initializer=sqrt_init,
gamma_off_initializer='zeros',
kernel_regularizer=None,
bias_regularizer=None,
gamma_diag_regularizer=None,
gamma_off_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
bias_constraint=None,
gamma_diag_constraint=None,
gamma_off_constraint=None,
init_criterion='he',
seed=None,
spectral_parametrization=False,
epsilon=1e-7,
**kwargs):
super(ComplexConv, self).__init__(**kwargs)
self.rank = rank
self.filters = filters
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 = 'channels_last' if rank == 1 else conv_utils.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.normalize_weight = normalize_weight
self.init_criterion = init_criterion
self.spectral_parametrization = spectral_parametrization
self.epsilon = epsilon
self.kernel_initializer = sanitizedInitGet(kernel_initializer)
self.bias_initializer = sanitizedInitGet(bias_initializer)
self.gamma_diag_initializer = sanitizedInitGet(gamma_diag_initializer)
self.gamma_off_initializer = sanitizedInitGet(gamma_off_initializer)
self.kernel_regularizer = regularizers.get(kernel_regularizer)
self.bias_regularizer = regularizers.get(bias_regularizer)
self.gamma_diag_regularizer = regularizers.get(gamma_diag_regularizer)
self.gamma_off_regularizer = regularizers.get(gamma_off_regularizer)
self.activity_regularizer = regularizers.get(activity_regularizer)
self.kernel_constraint = constraints.get(kernel_constraint)
self.bias_constraint = constraints.get(bias_constraint)
self.gamma_diag_constraint = constraints.get(gamma_diag_constraint)
self.gamma_off_constraint = constraints.get(gamma_off_constraint)
if seed is None:
self.seed = np.random.randint(1, 10e6)
else:
self.seed = seed
self.input_spec = InputSpec(ndim=self.rank + 2)
def __init__(self, **kwargs):
super(_GlobalSumPooling1D, self).__init__(**kwargs)
self.input_spec = [InputSpec(ndim=3)]
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
self.states = [None, None]
self.trainable_weights = []
self.W_a = Convolution2D(self.nb_filters_att,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.init)
self.U_a = Convolution2D(self.nb_filters_att,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.init)
self.V_a = Convolution2D(1,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=False,
init=self.attentive_init)
self.W_a.build((input_shape[0], self.nb_filters_att, input_shape[3],
input_shape[4]))
self.U_a.build((input_shape[0], self.nb_filters_in, input_shape[3],
input_shape[4]))
self.V_a.build((input_shape[0], self.nb_filters_att, input_shape[3],
input_shape[4]))
self.W_a.built = True
self.U_a.built = True
self.V_a.built = True
self.W_i = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.init)
self.U_i = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.inner_init)
self.W_i.build((input_shape[0], self.nb_filters_in, input_shape[3],
input_shape[4]))
self.U_i.build((input_shape[0], self.nb_filters_out, input_shape[3],
input_shape[4]))
self.W_i.built = True
self.U_i.built = True
self.W_f = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.init)
self.U_f = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.inner_init)
self.W_f.build((input_shape[0], self.nb_filters_in, input_shape[3],
input_shape[4]))
self.U_f.build((input_shape[0], self.nb_filters_out, input_shape[3],
input_shape[4]))
self.W_f.built = True
self.U_f.built = True
self.W_c = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.init)
self.U_c = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.inner_init)
self.W_c.build((input_shape[0], self.nb_filters_in, input_shape[3],
input_shape[4]))
self.U_c.build((input_shape[0], self.nb_filters_out, input_shape[3],
input_shape[4]))
self.W_c.built = True
self.U_c.built = True
self.W_o = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.init)
self.U_o = Convolution2D(self.nb_filters_out,
self.nb_rows,
self.nb_cols,
border_mode='same',
bias=True,
init=self.inner_init)
self.W_o.build((input_shape[0], self.nb_filters_in, input_shape[3],
input_shape[4]))
self.U_o.build((input_shape[0], self.nb_filters_out, input_shape[3],
input_shape[4]))
self.W_o.built = True
self.U_o.built = True
self.trainable_weights = []
self.trainable_weights.extend(self.W_a.trainable_weights)
self.trainable_weights.extend(self.U_a.trainable_weights)
self.trainable_weights.extend(self.V_a.trainable_weights)
self.trainable_weights.extend(self.W_i.trainable_weights)
self.trainable_weights.extend(self.U_i.trainable_weights)
self.trainable_weights.extend(self.W_f.trainable_weights)
self.trainable_weights.extend(self.U_f.trainable_weights)
self.trainable_weights.extend(self.W_c.trainable_weights)
self.trainable_weights.extend(self.U_c.trainable_weights)
self.trainable_weights.extend(self.W_o.trainable_weights)
self.trainable_weights.extend(self.U_o.trainable_weights)
def __init__(self, data_format=None, **kwargs):
super(NoisyAndPooling2D, self).__init__(**kwargs)
self.data_format = K.normalize_data_format(data_format)
self.input_spec = InputSpec(ndim=4)
self.initializer = initializers.get('zeros')
self.a = 10
def build(self, input_shape):
if self.data_format == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
if input_shape[channel_axis] is None:
raise ValueError('The channel dimension of the inputs '
'should be defined. Found `None`.')
input_dim = input_shape[channel_axis] // 4
self.kernel_shape = self.kernel_size + (input_dim , self.filters)
if self.kernel_initializer in {'quaternion', 'quaternion_independent'}:
kls = {'quaternion': QuaternionInit,
'quaternion_independent': QuaternionIndependentFilters}[self.kernel_initializer]
kern_init = kls(
kernel_size=self.kernel_size,
input_dim=input_dim,
weight_dim=self.rank,
nb_filters=self.filters,
criterion=self.init_criterion
)
else:
kern_init = self.kernel_initializer
self.kernel = self.add_weight(
self.kernel_shape,
initializer=kern_init,
name='kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint
)
if self.normalize_weight:
gamma_shape = (input_dim * self.filters,)
self.gamma_rr = self.add_weight(
shape=gamma_shape,
name='gamma_rr',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint
)
self.gamma_ri = self.add_weight(
shape=gamma_shape,
name='gamma_ri',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint
)
self.gamma_rj = self.add_weight(
shape=gamma_shape,
name='gamma_rj',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint
)
self.gamma_rk = self.add_weight(
shape=gamma_shape,
name='gamma_rk',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint
)
self.gamma_ii = self.add_weight(
shape=gamma_shape,
name='gamma_ii',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint
)
self.gamma_ij = self.add_weight(
shape=gamma_shape,
name='gamma_ij',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint
)
self.gamma_ik = self.add_weight(
shape=gamma_shape,
name='gamma_ik',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint
)
self.gamma_jj = self.add_weight(
shape=gamma_shape,
name='gamma_jj',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint
)
self.gamma_jk = self.add_weight(
shape=gamma_shape,
name='gamma_jk',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint
)
self.gamma_kk = self.add_weight(
shape=gamma_shape,
name='gamma_kk',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint
)
else:
self.gamma_rr = None
self.gamma_ri = None
self.gamma_rj = None
self.gamma_rk = None
self.gamma_ii = None
self.gamma_ij = None
self.gamma_ik = None
self.gamma_jj = None
self.gamma_jk = None
self.gamma_kk = None
if self.use_bias:
bias_shape = (4 * self.filters,)
self.bias = self.add_weight(
bias_shape,
initializer=self.bias_initializer,
name='bias',
regularizer=self.bias_regularizer,
constraint=self.bias_constraint
)
else:
self.bias = None
# Set input spec.
self.input_spec = InputSpec(ndim=self.rank + 2,
axes={channel_axis: input_dim * 4})
self.built = True
def __init__(self, **kwargs):
super(FlattenCaps, self).__init__(**kwargs)
self.input_spec = InputSpec(min_ndim=4)
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
shape = (input_shape[self.axis], )
init_gamma = self.scale * np.ones(shape)
self.gamma = K.variable(init_gamma, name='{}_gamma'.format(self.name))
self.trainable_weights = [self.gamma]
def __init__(self, padding=(1, 1), **kwargs):
if type(padding) == int:
padding = (padding, padding)
self.padding = padding
self.input_spec = [InputSpec(ndim=4)]
super(ReflectionPadding2D, self).__init__(**kwargs)
def __init__(self, **kwargs):
super(LocalPooling1D, self).__init__(**kwargs)
self.supports_masking = True
self.input_spec = [InputSpec(ndim=3), InputSpec(ndim=2)]
def __init__(self, n, **kwargs):
self.n = n
self.input_spec = [InputSpec(ndim=3)]
super(RepeatVector4D, self).__init__(**kwargs)
def build(self, input_shape):
if self.verbose:
print('Build started')
if type(input_shape) == list:
self.input_spec = [
InputSpec(shape=input_shape[0]),
InputSpec(shape=(input_shape[1]))
]
else:
self.input_spec = [InputSpec(shape=input_shape)]
input_shape = [input_shape, None]
input_dim = input_shape[0][1]
def combine_nodes(left, right):
parent_node = Node()
parent_node.left = left
parent_node.right = right
parent_node.code = left.code + right.code
parent_node.frequency = left.frequency + right.frequency
return parent_node
# Generate leaves of Huffman tree.
leaves = [
Lambda(lambda x: K.cast(x * 0 + i, dtype='int32'))
for i in range(self.nb_classes)
]
# Set attribs for leaves
for l in range(len(leaves)):
leaf = leaves[l]
leaf.built = True
leaf.code = [l]
leaf.frequency = self.frequency_table[l]
# Build Huffman tree.
if self.verbose:
print('Building huffman tree...')
un_merged_nodes = leaves[:]
self.nodes = []
frequencies = [l.frequency for l in leaves]
# We keep merging 2 least frequency nodes, until only the root node remains. Classic Huffman tree, nothing fancy.
prev_p = 0
while len(un_merged_nodes) > 1:
p = int(100. * (self.nb_classes - len(un_merged_nodes) + 1) /
self.nb_classes)
if self.verbose:
if p > prev_p:
sys.stdout.write('\r' + str(p) + ' %')
prev_p = p
min_frequency_node = np.argmin(frequencies)
left = un_merged_nodes.pop(min_frequency_node)
frequencies.pop(min_frequency_node)
min_frequency_node = np.argmin(frequencies)
right = un_merged_nodes.pop(min_frequency_node)
frequencies.pop(min_frequency_node)
parent_node = combine_nodes(left, right)
self.nodes += [parent_node]
un_merged_nodes += [parent_node]
frequencies += [parent_node.frequency]
if self.verbose:
sys.stdout.write('\r100 %')
print('Huffman tree build complete')
self.root_node = un_merged_nodes[0]
self.nodes += [self.root_node]
self.node_indices = {self.nodes[i]: i for i in range(len(self.nodes))}
self.node_indices.update({leaves[i]: i for i in range(len(leaves))})
self.leaves = leaves
# Set paths and huffman codes
self.paths = []
self.huffman_codes = []
self.one_hot_huffman_codes = []
for i in range(self.nb_classes):
path, huffman_code = self._traverse_huffman_tree(i)
self.paths += [path]
self.huffman_codes += [huffman_code]
one_hot_huffman_code = [([1, 0] if c == 0 else [0, 1])
for c in huffman_code]
self.one_hot_huffman_codes += [one_hot_huffman_code]
self.max_tree_depth = max(map(len, self.huffman_codes))
for huffman_code in self.huffman_codes:
huffman_code += [0] * (self.max_tree_depth - len(huffman_code))
self.padded_one_hot_huffman_codes = self.one_hot_huffman_codes[:]
for one_hot_huffman_code in self.padded_one_hot_huffman_codes:
one_hot_huffman_code += [[1, 1]] * (self.max_tree_depth -
len(one_hot_huffman_code))
if self.verbose:
print('Setting weights...')
self.W = self.init((len(self.nodes), input_dim, 1))
if self.bias:
self.b = K.zeros((len(self.nodes), 1))
self.trainable_weights = [self.W, self.b]
else:
self.trainable_weights = [self.W]
self.regularizers = []
if self.W_regularizer:
self.W_regularizer.set_param(self.W)
self.regularizers.append(self.W_regularizer)
if self.bias and self.b_regularizer:
self.b_regularizer.set_param(self.b)
self.regularizers.append(self.b_regularizer)
if self.activity_regularizer:
self.activity_regularizer.set_layer(self)
self.regularizers.append(self.activity_regularizer)
self.constraints = {}
if self.W_constraint:
self.constraints[self.W] = self.W_constraint
if self.bias and self.b_constraint:
self.constraints[self.b] = self.b_constraint
if hasattr(self, 'initial_weights') and self.initial_weights:
self.set_weights(self.initial_weights)
del self.initial_weights
# Class -> path map
self.class_path_map = K.variable(np.array([[
self.node_indices[node] for node in path + [self.root_node] *
(self.max_tree_depth - len(path))
] for path in self.paths]),
dtype='int32')
super(Huffmax, self).build(input_shape)
if self.verbose:
print('Done.')
def build(self, input_shape):
"""build"""
if self.data_format == "channels_first":
channel_axis = 1
else:
channel_axis = -1
if input_shape[channel_axis] is None:
raise ValueError(
"The channel dimension of the inputs "
"should be defined. Found `None`."
)
input_dim = input_shape[channel_axis] // 2
if False and self.transposed:
self.kernel_shape = self.kernel_size + (self.filters, input_dim)
else:
self.kernel_shape = self.kernel_size + (input_dim, self.filters)
# The kernel shape here is a complex kernel shape:
# nb of complex feature maps = input_dim;
# nb of output complex feature maps = self.filters;
# imaginary kernel size = real kernel size
# = self.kernel_size
# = complex kernel size
if self.kernel_initializer in {"complex", "complex_independent"}:
kls = {
"complex": ComplexInit,
"complex_independent": ComplexIndependentFilters,
}[
self.kernel_initializer
]
kern_init = kls(
kernel_size=self.kernel_size,
input_dim=input_dim,
weight_dim=self.rank,
nb_filters=self.filters,
criterion=self.init_criterion,
)
else:
kern_init = self.kernel_initializer
self.kernel = self.add_weight(
"kernel",
self.kernel_shape,
initializer=kern_init,
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint,
)
if self.normalize_weight:
gamma_shape = (input_dim * self.filters,)
self.gamma_rr = self.add_weight(
shape=gamma_shape,
name="gamma_rr",
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint,
)
self.gamma_ii = self.add_weight(
shape=gamma_shape,
name="gamma_ii",
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint,
)
self.gamma_ri = self.add_weight(
shape=gamma_shape,
name="gamma_ri",
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint,
)
else:
self.gamma_rr = None
self.gamma_ii = None
self.gamma_ri = None
if self.use_bias:
bias_shape = (2 * self.filters,)
self.bias = self.add_weight(
"bias",
bias_shape,
initializer=self.bias_initializer,
regularizer=self.bias_regularizer,
constraint=self.bias_constraint,
)
else:
self.bias = None
# Set input spec.
self.input_spec = InputSpec(
ndim=self.rank + 2, axes={channel_axis: input_dim * 2}
)
self.built = True
def __init__(self, **kwargs):
super(CapsToScalars, self).__init__(**kwargs)
self.input_spec = InputSpec(min_ndim=3)
def __init__(self, k=1, **kwargs):
super().__init__(**kwargs)
self.input_spec = InputSpec(ndim=3)
self.k = k
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
super(DecodeDetectionsFast, self).build(input_shape)
def __init__(self, rate, **kwargs):
super(TimestepDropout, self).__init__(rate, **kwargs)
self.input_spec = InputSpec(ndim=3)
def build(self, input_shape):
ndim = len(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) + '.')
self.input_spec = InputSpec(ndim=len(input_shape),
axes={self.axis: dim})
param_shape = (input_shape[self.axis] // 2, )
if self.scale:
self.gamma_rr = self.add_weight(
shape=param_shape,
name='gamma_rr',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint)
self.gamma_ii = self.add_weight(
shape=param_shape,
name='gamma_ii',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint)
self.gamma_ri = self.add_weight(
shape=param_shape,
name='gamma_ri',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint)
self.moving_Vrr = self.add_weight(
shape=param_shape,
initializer=self.moving_variance_initializer,
name='moving_Vrr',
trainable=False)
self.moving_Vii = self.add_weight(
shape=param_shape,
initializer=self.moving_variance_initializer,
name='moving_Vii',
trainable=False)
self.moving_Vri = self.add_weight(
shape=param_shape,
initializer=self.moving_covariance_initializer,
name='moving_Vri',
trainable=False)
else:
self.gamma_rr = None
self.gamma_ii = None
self.gamma_ri = None
self.moving_Vrr = None
self.moving_Vii = None
self.moving_Vri = None
if self.center:
self.beta = self.add_weight(shape=(input_shape[self.axis], ),
name='beta',
initializer=self.beta_initializer,
regularizer=self.beta_regularizer,
constraint=self.beta_constraint)
self.moving_mean = self.add_weight(
shape=(input_shape[self.axis], ),
initializer=self.moving_mean_initializer,
name='moving_mean',
trainable=False)
else:
self.beta = None
self.moving_mean = None
self.built = True
def build(self, input_shape):
assert len(input_shape) == 2
assert input_shape[-1] % 4 == 0
input_dim = input_shape[-1] // 4
data_format = K.image_data_format()
kernel_shape = (input_dim, self.units)
fan_in, fan_out = initializers._compute_fans(kernel_shape,
data_format=data_format)
if self.init_criterion == 'he':
s = tf.sqrt(tf.cast(1. / fan_in, tf.float32))
elif self.init_criterion == 'glorot':
s = tf.sqrt(tf.cast(1. / (fan_in + fan_out), tf.float32))
# Equivalent initialization using amplitude phase representation:
"""modulus = rng.rayleigh(scale=s, size=kernel_shape)
phase = rng.uniform(low=-np.pi, high=np.pi, size=kernel_shape)
def init_w_real(shape, dtype=None):
return modulus * K.cos(phase)
def init_w_imag(shape, dtype=None):
return modulus * K.sin(phase)"""
# Initialization using euclidean representation:
def init_w_r(shape, dtype=None):
return K.random_normal_variable(kernel_shape,
mean=0,
scale=s,
dtype=tf.float32,
seed=self.seed)
def init_w_i(shape, dtype=None):
return K.random_normal_variable(kernel_shape,
mean=0,
scale=s,
dtype=tf.float32,
seed=self.seed)
def init_w_j(shape, dtype=None):
return K.random_normal_variable(kernel_shape,
mean=0,
scale=s,
dtype=tf.float32,
seed=self.seed)
def init_w_k(shape, dtype=None):
return K.random_normal_variable(kernel_shape,
mean=0,
scale=s,
dtype=tf.float32,
seed=self.seed)
if self.kernel_initializer in {'quaternion'}:
r_init = init_w_r
i_init = init_w_i
j_init = init_w_j
k_init = init_w_k
else:
r_init = self.kernel_initializer
i_init = self.kernel_initializer
j_init = self.kernel_initializer
k_init = self.kernel_initializer
self.r_kernel = self.add_weight(shape=kernel_shape,
initializer=r_init,
name='r_kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.i_kernel = self.add_weight(shape=kernel_shape,
initializer=i_init,
name='i_kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.j_kernel = self.add_weight(shape=kernel_shape,
initializer=j_init,
name='j_kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.k_kernel = self.add_weight(shape=kernel_shape,
initializer=k_init,
name='k_kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
if self.use_bias:
self.bias = self.add_weight(shape=(4 * self.units, ),
initializer=self.bias_initializer,
name='bias',
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
self.input_spec = InputSpec(ndim=2, axes={-1: 4 * input_dim})
self.built = True
def __init__(self, padding=(1, 1), **kwargs):
self.padding = tuple(padding)
self.input_spec = [InputSpec(ndim=4)]
super(ReflectionPadding2D, self).__init__(**kwargs)
def build(self, input_shape):
if self.data_format == 'channels_first':
channel_axis = 1
else:
channel_axis = -1
if input_shape[channel_axis] is None:
raise ValueError('The channel dimension of the inputs '
'should be defined. Found `None`.')
input_dim = input_shape[channel_axis] // 2
self.kernel_shape = self.kernel_size + (input_dim, self.filters)
# The kernel shape here is a complex kernel shape:
# nb of complex feature maps = input_dim;
# nb of output complex feature maps = self.filters;
# imaginary kernel size = real kernel size
# = self.kernel_size
# = complex kernel size
if self.kernel_initializer in {'complex', 'complex_independent'}:
kls = {
'complex': ComplexInit,
'complex_independent': ComplexIndependentFilters
}[self.kernel_initializer]
kern_init = kls(kernel_size=self.kernel_size,
input_dim=input_dim,
weight_dim=self.rank,
nb_filters=self.filters,
criterion=self.init_criterion)
else:
kern_init = self.kernel_initializer
self.kernel = self.add_weight(self.kernel_shape,
initializer=kern_init,
name='kernel',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
if self.normalize_weight:
gamma_shape = (input_dim * self.filters, )
self.gamma_rr = self.add_weight(
shape=gamma_shape,
name='gamma_rr',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint)
self.gamma_ii = self.add_weight(
shape=gamma_shape,
name='gamma_ii',
initializer=self.gamma_diag_initializer,
regularizer=self.gamma_diag_regularizer,
constraint=self.gamma_diag_constraint)
self.gamma_ri = self.add_weight(
shape=gamma_shape,
name='gamma_ri',
initializer=self.gamma_off_initializer,
regularizer=self.gamma_off_regularizer,
constraint=self.gamma_off_constraint)
else:
self.gamma_rr = None
self.gamma_ii = None
self.gamma_ri = None
if self.use_bias:
bias_shape = (2 * self.filters, )
self.bias = self.add_weight(bias_shape,
initializer=self.bias_initializer,
name='bias',
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
# Set input spec.
self.input_spec = InputSpec(ndim=self.rank + 2,
axes={channel_axis: input_dim * 2})
self.built = True
def build(self, input_shape):
assert len(input_shape) == 2
assert input_shape[-1] % 2 == 0
input_dim = input_shape[-1] // 4
data_format = K.image_data_format()
kernel_shape = (input_dim, self.units)
fan_in, fan_out = initializers._compute_fans(kernel_shape,
data_format=data_format)
if self.init_criterion == 'he':
s = 1. / np.sqrt(2 * fan_in)
elif self.init_criterion == 'glorot':
s = 1. / np.sqrt(2 * (fan_in + fan_out))
rng = RandomStreams(seed=self.seed)
# Equivalent initialization using amplitude phase representation:
"""modulus = rng.rayleigh(scale=s, size=kernel_shape)
phase = rng.uniform(low=-np.pi, high=np.pi, size=kernel_shape)
def init_w_real(shape, dtype=None):
return modulus * K.cos(phase)
def init_w_imag(shape, dtype=None):
return modulus * K.sin(phase)"""
# Initialization using euclidean representation:
def init_w_real(shape, dtype=None):
return rng.normal(size=kernel_shape, avg=0, std=s, dtype=dtype)
def init_w_imag(shape, dtype=None):
return rng.normal(size=kernel_shape, avg=0, std=s, dtype=dtype)
if self.kernel_initializer in {'complex'}:
real_init = init_w_real
imag_init = init_w_imag
else:
real_init = self.kernel_initializer
imag_init = self.kernel_initializer
self.r = self.add_weight(shape=kernel_shape,
initializer=real_init,
name='r',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.i = self.add_weight(shape=kernel_shape,
initializer=imag_init,
name='i',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.j = self.add_weight(shape=kernel_shape,
initializer=imag_init,
name='j',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
self.k = self.add_weight(shape=kernel_shape,
initializer=imag_init,
name='k',
regularizer=self.kernel_regularizer,
constraint=self.kernel_constraint)
if self.use_bias:
self.bias = self.add_weight(shape=(4 * self.units, ),
initializer=self.bias_initializer,
name='bias',
regularizer=self.bias_regularizer,
constraint=self.bias_constraint)
else:
self.bias = None
self.input_spec = InputSpec(ndim=2, axes={-1: 4 * input_dim})
self.built = True
def build(self, input_shape):
self.input_spec = [InputSpec(shape=input_shape)]
super(RNNCell, self).build(input_shape)
def build(self, input_shape):
self.beta = self.add_weight(shape=[1],
name='beta',
initializer=self.beta_initializer)
self.input_spec = InputSpec(ndim=len(input_shape))
self.built = True
