def __init__(self,
dilation_rate,
nb_filters,
kernel_size,
padding,
dropout_rate=0.0,
conv_regularization=0.08):
"""
Defines the residual block for TCN
:param x: The previous layer in the model
:param dilation_rate: The dilation rate for this residual block
:param nb_filters: The number of convolutional filters to use in this block
:param kernel_size: The size of the convolutional kernel
:param padding: The padding used in the convolutional layers, 'same' or 'causal'.
:param dropout_rate: Float between 0 and 1. Fraction of the input units to drop.
:param conv_regularization: L2 regularization coefficient.
:return: A tuple where the first element is the residual model layer, and the second is the skip connection.
"""
super(ResidualBlock, self).__init__()
self.dilation_rate = dilation_rate
self.nb_filters = nb_filters
self.kernel_size = kernel_size
self.padding = padding
self.dropout_rate = dropout_rate
self.conv_regularization = conv_regularization
self.con1 = layers.SeparableConv1D(
filters=self.nb_filters,
kernel_size=self.kernel_size,
dilation_rate=self.dilation_rate,
padding=self.padding,
kernel_regularizer=regularizers.l2(conv_regularization),
kernel_initializer=initializers.RandomNormal(mean=0.0,
stddev=0.01))
self.dropout1 = layers.SpatialDropout1D(self.dropout_rate)
self.con2 = layers.SeparableConv1D(
filters=self.nb_filters,
kernel_size=self.kernel_size,
dilation_rate=self.dilation_rate,
padding=self.padding,
kernel_regularizer=regularizers.l2(conv_regularization),
kernel_initializer=initializers.RandomNormal(mean=0.0,
stddev=0.01))
self.dropout2 = layers.SpatialDropout1D(self.dropout_rate)
self.conv_matching = layers.Conv1D(
filters=nb_filters,
kernel_size=1,
padding='same',
kernel_initializer=initializers.RandomNormal(mean=0.0,
stddev=0.01))
def create_channel(self, x, kernel_size, feature_map):
"""
Creates a layer, working channel wise
Arguments:
x : Input for convolutional channel
kernel_size : Kernel size for creating Conv1D
feature_map : Feature map
Returns:
x : Channel including (Conv1D + {GlobalMaxPooling & GlobalAveragePooling} + Dense [+ Dropout])
"""
x = layers.SeparableConv1D(feature_map,
kernel_size=kernel_size,
activation='relu',
strides=1,
padding='valid',
depth_multiplier=4)(x)
x1 = layers.GlobalMaxPooling1D()(x)
x2 = layers.GlobalAveragePooling1D()(x)
x = layers.concatenate([x1, x2])
x = layers.Dense(self.hidden_units)(x)
if self.dropout_rate:
x = layers.Dropout(self.dropout_rate)(x)
return x
def __init__(self, out_width, bottleneck=4, stride=2):
"""
Constructs a downsample block with the final number of output
feature maps given by `out_width`. Stride of the spatial convolution
layer is given by `stride`. Take care to increase width appropriately
for a given spatial downsample.
The first two convolutions are bottlenecked according to `bottleneck`.
Arguments:
out_width: Positive integer, number of output feature maps.
bottleneck: Positive integer, factor by which to bottleneck
relative to `out_width`. Default 4.
stride: Positive integer or tuple of positive integers giving
the stride of the depthwise separable convolution layer.
If a single value, row and col stride will be
set to the given value. If a tuple, assign row and
col stride from the tuple as (row, col). Default 2.
"""
super().__init__()
# 1x1 convolution, enter the bottleneck
self.channel_conv_1 = layers.Conv1D(
filters=out_width // bottleneck,
name='Downsample_enter',
kernel_size=1,
strides=1,
use_bias=False,
activation=None,
)
self.bn1 = layers.BatchNormalization()
self.relu1 = layers.ReLU()
# 3x3 depthwise separable spatial convolution
self.spatial_conv = layers.SeparableConv1D(filters=out_width,
name='Downsample_conv',
kernel_size=3,
strides=stride,
use_bias=False,
activation=None,
padding='same')
self.bn2 = layers.BatchNormalization()
self.relu2 = layers.ReLU()
# 3x3/2 convolution along main path
self.main = layers.Conv1D(filters=out_width,
name='Downsample_main',
kernel_size=3,
strides=stride,
use_bias=False,
activation=None,
padding='same')
self.bn_main = layers.BatchNormalization()
self.relu_main = layers.ReLU()
# Merge operation to join residual + main paths
self.merge = layers.Add()
def testHugeEnclave(self):
model = Sequential([
layers.SeparableConv1D(64,
10,
input_shape=(500, 64),
padding='same')
])
common_test_basis(model, True)
def sep_conv(x, num_filters, kernel_size=3, activation='relu'):
if activation == 'selu':
x = layers.SeparableConv1D(num_filters,
kernel_size,
activation='selu',
padding='same',
kernel_initializer='lecun_normal')(x)
elif activation == 'relu':
x = layers.SeparableConv1D(num_filters,
kernel_size,
padding='same',
use_bias=False)(x)
x = layers.BatchNormalization()(x)
x = layers.Activation('relu')(x)
else:
ValueError('Unknown activation function: %s' % (activation, ))
return x
def __init__(self, kernel_size, filters, residual=False):
super(Small_block, self).__init__(name='small_block')
self.conv = layers.SeparableConv1D(filters,
kernel_size,
padding='same',
use_bias=False)
self.bn = layers.BatchNormalization(momentum=0.9)
self.residual = residual
self.relu = layers.ReLU()
self.kernel_size = kernel_size
self.filters = filters
def __call__(self, x):
shortcut = x
prefix = 'expanded_conv/'
infilters = x.shape[-1]
if self.block_id:
# Expand
prefix = 'expanded_conv_{}/'.format(self.block_id)
x = layers.Conv1D(_depth(infilters * self.expansion),
kernel_size=1,
padding='same',
use_bias=False,
name=prefix + 'expand')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + 'expand/BatchNorm')(x)
x = self.activation(x)
if self.stride == 2:
x = layers.ZeroPadding1D(padding=1,
name=prefix + 'depthwise/pad')(x)
x = layers.SeparableConv1D(
int(x.shape[-1]),
self.kernel_size,
strides=self.stride,
padding='same' if self.stride == 1 else 'valid',
use_bias=False,
name=prefix + 'depthwise')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + "depthwise/BatchNorm")(x)
x = self.activation(x)
if self.se_ratio:
x = SEBlock(_depth(infilters * self.expansion), self.se_ratio,
prefix)(x)
x = layers.Conv1D(self.filters,
kernel_size=1,
padding='same',
use_bias=False,
name=prefix + 'project')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + "project/BatchNorm")(x)
if self.stride == 1 and infilters == self.filters:
x = layers.Add(name=prefix + 'Add')([shortcut, x])
return x
def __call__(self, x):
x = layers.SeparableConv1D(self.pointwise_conv_filters,
kernel_size=3,
padding='same',
depth_multiplier=self.depth_multiplier,
strides=self.strides,
use_bias=False,
name="Conv_sep")(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name='Conv_sep_bn')(x)
x = layers.ReLU(6., name='Conv_sep_relu')(x)
return x
def __call__(self, ip):
with backend.name_scope('separable_conv_block_%s' % self.block_id):
x = layers.Activation('relu')(ip)
if self.strides == 2:
x = layers.ZeroPadding1D(padding=self.kernel_size,
name='separable_conv_1_pad_%s' %
self.block_id)(x)
conv_pad = 'valid'
else:
conv_pad = 'same'
x = layers.SeparableConv1D(self.filters,
self.kernel_size,
strides=self.strides,
name='separable_conv_1_%s' %
self.block_id,
padding=conv_pad,
use_bias=False,
kernel_initializer='he_normal')(x)
x = layers.BatchNormalization(momentum=0.9997,
epsilon=1e-3,
name='separable_conv_1_bn_%s' %
self.block_id)(x)
x = layers.Activation('relu')(x)
x = layers.SeparableConv1D(self.filters,
self.kernel_size,
name='separable_conv_2_%s' %
self.block_id,
padding='same',
use_bias=False,
kernel_initializer='he_normal')(x)
x = layers.BatchNormalization(momentum=0.9997,
epsilon=1e-3,
name='separable_conv_2_bn_%s' %
self.block_id)(x)
return x
def __call__(self, x):
in_channels = x.shape[-1]
pointwise_conv_filters = int(self.filters * self.alpha)
pointwise_filters = _make_divisible(pointwise_conv_filters, 8)
inputs = x
prefix = 'block_{}_'.format(self.block_id)
if self.block_id:
x = layers.Conv1D(self.expansion * in_channels,
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + "expand")(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + "expand_bn")(x)
x = layers.ReLU(6., name=prefix + "expand_relu")(x)
else:
prefix = 'expanded_conv_'
x = layers.SeparableConv1D(int(x.shape[-1]),
kernel_size=self.kernel,
strides=self.stride,
activation=None,
use_bias=False,
padding='same',
name=prefix + 'depthwise')(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + 'depthwise_bn')(x)
x = layers.ReLU(6., name=prefix + 'depthwise_relu')(x)
x = layers.Conv1D(pointwise_filters,
kernel_size=1,
padding='same',
use_bias=False,
activation=None,
name=prefix + "project")(x)
x = layers.BatchNormalization(epsilon=1e-3,
momentum=0.999,
name=prefix + 'project_bn')(x)
if in_channels == pointwise_filters and self.stride == 1:
x = layers.Add(name=prefix + 'add')([inputs, x])
return x
def __init__(self, out_width, bottleneck=4):
"""
Constructs a bottleneck block with the final number of output
feature maps given by `out_width`. Bottlenecked layers will have
output feature map count given by `out_width // bottleneck`.
Arguments:
out_width: Positive integer, number of output feature maps.
bottleneck: Positive integer, factor by which to bottleneck
relative to `out_width`. Default 4.
"""
super().__init__()
# 1x1 depthwise convolution, enter the bottleneck
self.channel_conv_1 = layers.Conv1D(
filters=out_width // bottleneck,
name='Bottleneck_enter',
kernel_size=1,
strides=1,
use_bias=False,
activation=None,
)
self.bn1 = layers.BatchNormalization()
self.relu1 = layers.ReLU()
# 3x3 depthwise separable convolution
self.spatial_conv = layers.SeparableConv1D(filters=out_width,
name='Bottleneck_conv',
kernel_size=3,
strides=1,
use_bias=False,
activation=None,
padding='same')
self.bn2 = layers.BatchNormalization()
self.relu2 = layers.ReLU()
# Merge operation to join residual + main paths
self.merge = layers.Add()
def __init__(self,
kernel_size,
filters,
layer_name,
residual=False,
use_biases=False,
use_batchnorms=True):
super(Small_block, self).__init__(name=layer_name)
self.conv = layers.SeparableConv1D(filters,
kernel_size,
padding='same',
use_bias=use_biases,
bias_initializer='zeros',
name='sepconv')
if use_batchnorms: self.bn = layers.BatchNormalization(momentum=0.9)
else: self.bn = None
self.residual = residual
self.relu = layers.ReLU()
self.kernel_size = kernel_size
self.filters = filters
self.layer_name = layer_name
self.use_biases = use_biases
self.use_batchnorms = use_batchnorms
def testMediumNative(self):
model = Sequential([
layers.SeparableConv1D(3, 3, input_shape=(10, 5), padding='same')
])
common_test_basis(model, False)
def testLargeEnclave(self):
model = Sequential([
layers.SeparableConv1D(10, 5, input_shape=(100, 5), padding='same')
])
common_test_basis(model, True)
sig_freq_30, sig_freq_31, sig_freq_32, sig_freq_33, sig_freq_34,
sig_freq_35, sig_freq_36, sig_freq_37, sig_freq_38, sig_freq_39,
sig_freq_40, sig_freq_41, sig_freq_42, sig_freq_43, sig_freq_44,
sig_freq_45, sig_freq_46, sig_freq_47, sig_freq_48, sig_freq_49,
sig_freq_50, sig_freq_51, sig_freq_52, sig_freq_53, sig_freq_54,
sig_freq_55, sig_freq_56, sig_freq_57, sig_freq_58, sig_freq_59,
sig_freq_60, sig_freq_61, sig_freq_62
]))
sig_freq_abs_transpose = tf.transpose(sig_freq_abs, perm=(1, 0, 2))
print("DFT Stack Complete")
dropout0 = layers.Dropout(0.5)(sig_freq_abs_transpose)
norm0 = layers.BatchNormalization(axis=1)(dropout0)
conv1 = layers.SeparableConv1D(512, kernel_size=(4),
activation='relu')(norm0)
maxpool1 = layers.MaxPooling1D(4)(conv1)
dropout1 = layers.Dropout(0.3)(maxpool1)
norm1 = layers.BatchNormalization(axis=1)(dropout1)
conv2 = layers.SeparableConv1D(512, kernel_size=(4),
activation='relu')(norm1)
maxpool2 = layers.MaxPooling1D(2)(conv2)
dropout2 = layers.Dropout(0.3)(maxpool2)
norm2 = layers.BatchNormalization(axis=1)(dropout2)
conv3 = layers.SeparableConv1D(256, kernel_size=(4),
activation='relu')(norm2)
maxpool3 = layers.MaxPooling1D(2)(conv3)
dropout3 = layers.Dropout(0.3)(maxpool3)
norm3 = layers.BatchNormalization(axis=1)(dropout3)
def generate_sep_conv1(test_name="small",
steps=3,
channels=3,
filters=3,
kernel_size=3,
mode='full'):
declarations = [
parameter_template.render(name='steps', value=steps),
parameter_template.render(name='channels', value=channels),
parameter_template.render(name='filters', value=filters),
parameter_template.render(name='kernel_size', value=kernel_size)
]
inputs = rng.uniform(-1, 1, (1, steps, channels))
if mode == 'zeros':
layer = tf_layers.SeparableConv1D(filters,
kernel_size,
strides=1,
input_shape=inputs.shape,
padding='same',
use_bias=True,
bias_initializer='zeros',
depthwise_initializer='zeros',
pointwise_initializer='zeros')
elif mode == 'ones':
inputs = np.ones((1, steps, channels))
layer = tf_layers.SeparableConv1D(filters,
kernel_size,
strides=1,
input_shape=inputs.shape,
padding='same',
use_bias=True,
bias_initializer='zeros',
depthwise_initializer='ones',
pointwise_initializer='ones')
elif mode == 'sequential':
inputs = np.arange(steps * channels, dtype=np.float).reshape(
(1, steps, channels))
layer = tf_layers.SeparableConv1D(filters,
kernel_size,
strides=1,
input_shape=inputs.shape,
padding='same',
use_bias=True,
bias_initializer='zeros',
depthwise_initializer='ones',
pointwise_initializer='ones')
elif mode == 'no_bias':
layer = tf_layers.SeparableConv1D(
filters,
kernel_size,
strides=1,
input_shape=inputs.shape,
padding='same',
use_bias=True,
bias_initializer='zeros',
depthwise_initializer='glorot_uniform',
pointwise_initializer='glorot_uniform')
elif mode == 'full':
layer = tf_layers.SeparableConv1D(
filters,
kernel_size,
strides=1,
input_shape=inputs.shape,
padding='same',
use_bias=True,
bias_initializer='glorot_uniform',
depthwise_initializer='glorot_uniform',
pointwise_initializer='glorot_uniform')
else:
raise NotImplementedError("Unknown tests mode")
declarations.append(generate_array('inputs', inputs))
results = layer(inputs).numpy()
params = layer.get_weights()
depth_kernels = params[0]
declarations.append(generate_array('depth_kernels', depth_kernels))
point_kernels = params[1]
declarations.append(generate_array('point_kernels', point_kernels))
biases = params[2]
declarations.append(generate_array('biases', biases))
declarations.append(generate_array('expected', results))
declarations.append(ret_template.render(size=steps * filters))
operator = "sep_conv1(inputs, steps, channels, filters, depth_kernels, point_kernels, kernel_size, biases, ret);"
return {
'suite': 'sep_conv1',
'name': test_name,
'declarations': declarations,
'operator': operator
}
def get_quartznet(input_dim,
output_dim,
is_mixed_precision=False,
fixed_sequence_size=None,
num_b_block_repeats=3,
b_block_kernel_sizes=(33, 39, 51, 63, 75),
b_block_num_channels=(256, 256, 512, 512, 512),
num_small_blocks=5,
use_biases=False,
use_batchnorms=True,
use_mask=False,
fixed_batch_size=None,
random_state=1) -> keras.Model:
"""
Parameters
----------
input_dim: input feature length
output_dim: output feature length
is_mixed_precision: if mixed precision model is needed
fixed_sequence_size: int, default None. If the length of sequence has to be fixed.
num_b_block_repeats: 1 is 5x5 quartznet, 2 is 10x5, 3 is 15x5
b_block_kernel_sizes: iterable, kernel size of each b block
b_block_num_channels: iterable, number of channels of each b block
num_small_blocks: int, number of conv blocks inside 1 residual block
use_biases: if biases are used with convolutions
use_batchnorms: if batchnorms are inserted after each residual block
use_mask: if mask layer is used
fixed_batch_size: int, default None. If the model will have fixed batch size
random_state: int, state used for weight initialization
"""
assert len(b_block_kernel_sizes) == len(b_block_num_channels), \
"Number of kernel sizes not equal the number of channel sizes"
max_seq_length = None
if tflite_version:
max_seq_length = 5
if is_mixed_precision:
policy = mixed_precision.Policy('mixed_float16')
mixed_precision.set_policy(policy)
np.random.seed(random_state)
tf.random.set_seed(random_state)
with tf.device('/cpu:0'):
input_tensor = layers.Input([fixed_sequence_size, input_dim],
name='X',
batch_size=fixed_batch_size)
x = tf.identity(input_tensor)
if use_mask: x = layers.Masking()(x)
# First encoder layer
x = layers.SeparableConv1D(256,
33,
padding='same',
strides=2,
name='conv_1',
use_bias=use_biases,
bias_initializer='zeros')(x)
if use_batchnorms:
x = layers.BatchNormalization(name='BN-1', momentum=0.9)(x)
x = layers.ReLU(name='RELU-1')(x)
block_idx = 1
for kernel_size, n_channels in zip(b_block_kernel_sizes,
b_block_num_channels):
for bk in range(num_b_block_repeats):
x = B_block(kernel_size,
n_channels,
num_small_blocks,
f'B-{block_idx}',
use_biases=use_biases,
use_batchnorms=use_batchnorms)(x)
block_idx += 1
# First final layer
x = layers.SeparableConv1D(512,
87,
padding='same',
name='conv_2',
dilation_rate=2,
use_bias=use_biases,
bias_initializer='zeros')(x)
if use_batchnorms:
x = layers.BatchNormalization(name='BN-2', momentum=0.9)(x)
x = layers.ReLU(name='RELU-2')(x)
# Second final layer
x = layers.Conv1D(1024,
1,
padding='same',
name='conv_3',
use_bias=use_biases,
bias_initializer='zeros')(x)
if use_batchnorms:
x = layers.BatchNormalization(name='BN-3', momentum=0.9)(x)
x = layers.ReLU(name='RELU-3')(x)
# Third final layer
x = layers.Conv1D(output_dim,
1,
padding='same',
dilation_rate=1,
name='conv_4')(x)
model = keras.Model([input_tensor], x, name='QuartzNet')
if is_mixed_precision:
policy = mixed_precision.Policy('float32')
mixed_precision.set_policy(policy)
return model
def testSmallEnclave(self):
model = Sequential(
[layers.SeparableConv1D(3, 3, input_shape=(5, 3), padding='same')])
common_test_basis(model, True)
def Xception(include_top=True, weights='hasc', input_shape=None, pooling=None, classes=6, classifier_activation='softmax'):
if input_shape is None:
input_shape = (256*3, 1)
if weights in ['hasc', 'HASC'] and include_top and classes != 6:
raise ValueError('If using `weights` as `"hasc"` with `include_top`'
' as true, `classes` should be 6')
inputs = layers.Input(shape=input_shape)
x = layers.Conv1D(32, 3, strides=2, use_bias=False, name='block1_conv1')(inputs)
x = layers.BatchNormalization(name='block1_conv1_bn')(x)
x = layers.Activation('relu', name='block1_conv1_act')(x)
x = layers.Conv1D(64, 3, use_bias=False, name='block1_conv2')(x)
x = layers.BatchNormalization(name='block1_conv2_bn')(x)
x = layers.Activation('relu', name='block1_conv2_act')(x)
residual = layers.Conv1D(
128, 1, strides=2, padding='same', use_bias=False
)(x)
residual = layers.BatchNormalization()(residual)
x = layers.SeparableConv1D(128, 3, padding='same', use_bias=False, name='block2_sepconv1')(x)
x = layers.BatchNormalization(name='block2_sepconv1_bn')(x)
x = layers.Activation('relu', name='block2_sepconv2_act')(x)
x = layers.SeparableConv1D(128, 3, padding='same', use_bias=False, name='block2_sepconv2')(x)
x = layers.BatchNormalization(name='block2_sepconv2_bn')(x)
x = layers.MaxPooling1D(3, strides=2, padding='same', name='block2_pool')(x)
x = layers.add([x, residual])
residual = layers.Conv1D(
256, 1, strides=2, padding='same', use_bias=False
)(x)
residual = layers.BatchNormalization()(residual)
x = layers.Activation('relu', name='block3_sepconv1_act')(x)
x = layers.SeparableConv1D(256, 3, padding='same', use_bias=False, name='block3_sepconv1')(x)
x = layers.BatchNormalization(name='block3_sepconv1_bn')(x)
x = layers.Activation('relu', name='block3_sepconv2_act')(x)
x = layers.SeparableConv1D(256, 3, padding='same', use_bias=False, name='block3_sepconv2')(x)
x = layers.BatchNormalization(name='block3_sepconv2_bn')(x)
x = layers.MaxPooling1D(3, strides=2, padding='same', name='block3_pool')(x)
x = layers.add([x, residual])
residual = layers.Conv1D(728, 1, strides=2, padding='same', use_bias=False)(x)
residual = layers.BatchNormalization()(residual)
x = layers.Activation('relu', name='block4_sepconv1_act')(x)
x = layers.SeparableConv1D(728, 3, padding='same', use_bias=False, name='block4_sepconv1')(x)
x = layers.BatchNormalization(name='block4_sepconv1_bn')(x)
x = layers.Activation('relu', name='block4_sepconv2_act')(x)
x = layers.SeparableConv1D(728, 3, padding='same', use_bias=False, name='block4_sepconv2')(x)
x = layers.BatchNormalization(name='block4_sepconv2_bn')(x)
x = layers.MaxPooling1D(3, strides=2, padding='same', name='block4_pool')(x)
x = layers.add([x, residual])
for i in range(8):
residual = x
prefix = 'block' + str(i + 5)
x = layers.Activation('relu', name=prefix + "_sepconv1_act")(x)
x = layers.SeparableConv1D(728, 3, padding='same', use_bias=False, name=prefix + "_sepconv1")(x)
x = layers.BatchNormalization(name=prefix + "_sepconv1_bn")(x)
x = layers.Activation('relu', name=prefix + "_sepconv2_act")(x)
x = layers.SeparableConv1D(728, 3, padding='same', use_bias=False, name=prefix + "_sepconv2")(x)
x = layers.BatchNormalization(name=prefix + "_sepconv2_bn")(x)
x = layers.Activation('relu', name=prefix + "_sepconv3_act")(x)
x = layers.SeparableConv1D(728, 3, padding='same', use_bias=False, name=prefix + "_sepconv3")(x)
x = layers.add([x, residual])
residual = layers.Conv1D(1024, 1, strides=2, padding='same', use_bias=False)(x)
residual = layers.BatchNormalization()(residual)
x = layers.Activation('relu', name='block13_sepconv1_act')(x)
x = layers.SeparableConv1D(728, 3, padding='same', use_bias=False, name='block13_sepconv1')(x)
x = layers.BatchNormalization(name='block13_sepconv1_bn')(x)
x = layers.Activation('relu', name='block13_speconv2_act')(x)
x = layers.SeparableConv1D(1024, 3, padding='same', use_bias=False, name='block13_sepconv2')(x)
x = layers.BatchNormalization(name='block13_sepconv2_bn')(x)
x = layers.MaxPooling1D(3, strides=2, padding='same')(x)
x = layers.add([x, residual])
x = layers.SeparableConv1D(1536, 3, padding='same', use_bias=False, name='block14_sepconv1')(x)
x = layers.BatchNormalization(name='block14_sepconv1_bn')(x)
x = layers.Activation('relu', name='block14_sepconv1_act')(x)
x = layers.SeparableConv1D(2048, 3, padding='same', use_bias=False, name='block14_sepconv2')(x)
x = layers.BatchNormalization(name='block14_sepconv2_bn')(x)
x = layers.Activation('relu', name='block14_sepconv2_act')(x)
x = layers.GlobalAveragePooling1D(name='avg_pool')(x)
y = layers.Dense(classes, activation=classifier_activation,
name='predictions')(x)
model = Model(inputs, y)
if weights is not None:
if weights in ['hasc', "HASC"]:
weights = 'weights/xception/xception_hasc_weights_{}_{}.hdf5'.format(int(input_shape[0]),
int(input_shape[1]))
# hasc or weights fileで初期化
if os.path.exists(weights):
print("Load weights from {}".format(weights))
model.load_weights(weights)
else:
print("Not exist weights: {}".format(weights))
# topを含まないとき
if not include_top:
if pooling is None:
# topを削除する
model = Model(inputs=model.input, outputs=model.layers[-3].output)
elif pooling == 'avg':
y = layers.GlobalAveragePooling1D()(model.layers[-3].output)
model = Model(inputs=model.input, outputs=y)
elif pooling == 'max':
y = layers.GlobalMaxPooling1D()(model.layers[-3].output)
model = Model(inputs=model.input, outputs=y)
else:
print("Not exist pooling option: {}".format(pooling))
model = Model(inputs=model.input, outputs=model.layers[-3].output)
return model
def get_quartznet(input_dim,
output_dim,
is_mixed_precision=False,
tflite_version=False,
num_b_block_repeats=3,
b_block_kernel_sizes=(33, 39, 51, 63, 75),
b_block_num_channels=(256, 256, 512, 512, 512),
num_small_blocks=5,
random_state=1) -> keras.Model:
"""
Parameters
----------
input_dim: input feature length
output_dim: output feature length
is_mixed_precision: if mixed precision model is needed
tflite_version: if export to tflite is needed
num_b_block_repeats: 1 is 5x5 quartznet, 2 is 10x5, 3 is 15x5
b_block_kernel_sizes: iterable, kernel size of each b block
b_block_num_channels: iterable, number of channels of each b block
"""
assert len(b_block_kernel_sizes) == len(b_block_num_channels), \
"Number of kernel sizes not equal the number of channel sizes"
max_seq_length = None
if tflite_version:
max_seq_length = 5
if is_mixed_precision:
policy = mixed_precision.Policy('mixed_float16')
mixed_precision.set_policy(policy)
np.random.seed(random_state)
tf.random.set_seed(random_state)
with tf.device('/cpu:0'):
input_tensor = layers.Input([max_seq_length, input_dim], name='X')
x = layers.Masking()(input_tensor)
# First encoder layer
x = layers.SeparableConv1D(256,
33,
padding='same',
strides=2,
name='conv_1',
use_bias=False)(x)
x = layers.BatchNormalization(name='BN-1', momentum=0.9)(x)
x = layers.ReLU(name='RELU-1')(x)
block_idx = 1
for kernel_size, n_channels in zip(b_block_kernel_sizes,
b_block_num_channels):
for bk in range(num_b_block_repeats):
x = B_block(kernel_size, n_channels, num_small_blocks,
f'B-{block_idx}')(x)
block_idx += 1
# First final layer
x = layers.SeparableConv1D(512,
87,
padding='same',
name='conv_2',
dilation_rate=2,
use_bias=False)(x)
x = layers.BatchNormalization(name='BN-2', momentum=0.9)(x)
x = layers.ReLU(name='RELU-2')(x)
# Second final layer
x = layers.Conv1D(1024,
1,
padding='same',
name='conv_3',
use_bias=False)(x)
x = layers.BatchNormalization(name='BN-3', momentum=0.9)(x)
x = layers.ReLU(name='RELU-3')(x)
# Third final layer
x = layers.Conv1D(output_dim,
1,
padding='same',
dilation_rate=1,
name='conv_4')(x)
model = keras.Model([input_tensor], x, name='QuartzNet')
if is_mixed_precision:
policy = mixed_precision.Policy('float32')
mixed_precision.set_policy(policy)
return model
