def downsample(self, inputs, pool_type: str = 'max',
sorted: bool = True, stage: int = 1): # noqa: A002
layers_pool = []
if pool_type == 'max':
layers_pool.append(
L.MaxPooling1D(pool_size=3,
strides=2,
padding='same',
name=f'pool_{stage}'))
elif pool_type == 'k_max':
k = int(inputs.shape[1].value / 2)
layers_pool.append(
KMaxPoolingLayer(k=k,
sorted=sorted,
name=f'pool_{stage}'))
elif pool_type == 'conv':
layers_pool.append(
L.Conv1D(filters=inputs.shape[-1].value,
kernel_size=3,
strides=2,
padding='same',
name=f'pool_{stage}'))
layers_pool.append(
L.BatchNormalization())
elif pool_type is None:
layers_pool = []
else:
raise ValueError(f'unsupported pooling type `{pool_type}`!')
tensor_out = inputs
for layer in layers_pool:
tensor_out = layer(tensor_out)
return tensor_out
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_blstm = L.Bidirectional(L.LSTM(**config['layer_blstm']),
name='layer_blstm')
layer_dense = L.Dense(**config['layer_dense'], name='layer_dense')
layer_crf_dense = L.Dense(output_dim, name='layer_crf_dense')
layer_crf = CRF(output_dim, name='layer_crf')
layer_dropout = L.Dropout(**config['layer_dropout'],
name='layer_dropout')
tensor = layer_blstm(embed_model.output)
tensor = layer_dense(tensor)
tensor = layer_dropout(tensor)
tensor = layer_crf_dense(tensor)
output_tensor = layer_crf(tensor)
self.layer_crf = layer_crf
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
# layer_blstm = L.Bidirectional(L.LSTM(**config['layer_blstm']),
# name='layer_blstm')
layer_conv = L.Conv1D(**config['layer_conv'], name='layer_conv')
layer_position = Position_layer(name='layer_position')
layer_blstm = L.Bidirectional(L.CuDNNLSTM(**config['layer_blstm']),
name='layer_blstm')
layer_dense = L.Dense(**config['layer_dense'], name='layer_dense')
layer_crf_dense = L.Dense(output_dim, name='layer_crf_dense')
layer_crf = CRF(output_dim, name='layer_crf') #全局定制类
tensor = layer_conv(embed_model.output)
tensor = layer_position(tensor)
tensor = layer_blstm(tensor)
tensor = layer_dense(tensor)
tensor = layer_crf_dense(tensor)
output_tensor = layer_crf(tensor)
self.layer_crf = layer_crf
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layers_rcnn_seq = []
layers_rcnn_seq.append(L.SpatialDropout1D(**config['spatial_dropout']))
layers_rcnn_seq.append(L.Bidirectional(L.GRU(**config['rnn_0'])))
layers_rcnn_seq.append(L.Conv1D(**config['conv_0']))
layers_sensor = []
layers_sensor.append(L.GlobalMaxPooling1D())
layers_sensor.append(AttentionWeightedAverageLayer())
layers_sensor.append(L.GlobalAveragePooling1D())
layer_concat = L.Concatenate(**config['concat'])
layers_full_connect = []
layers_full_connect.append(L.Dropout(**config['dropout']))
layers_full_connect.append(L.Dense(**config['dense']))
layers_full_connect.append(
L.Dense(output_dim, **config['activation_layer']))
tensor = embed_model.output
for layer in layers_rcnn_seq:
tensor = layer(tensor)
tensors_sensor = [layer(tensor) for layer in layers_sensor]
tensor_output = layer_concat(tensors_sensor)
# tensor_output = L.concatenate(tensor_sensors, **config['concat'])
for layer in layers_full_connect:
tensor_output = layer(tensor_output)
self.tf_model = tf.keras.Model(embed_model.inputs, tensor_output)
def model(self):
x1 = L.Input(shape=(None, ))
x2 = L.Input(shape=(self.hidden_size, ))
x3 = L.Input(shape=(self.hidden_size, ))
return tf.keras.Model(inputs=[x1, x2, x3],
outputs=self.call(x1, x2, x3),
name='AttGRUDecoder')
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_blstm = L.Bidirectional(L.LSTM(**config['layer_blstm']),
name='layer_blstm')
layer_dense = L.Dense(**config['layer_dense'], name='layer_dense')
layer_crf_dense = L.Dense(output_dim, name='layer_crf_dense')
layer_crf = CRF(output_dim, name='layer_crf')
if isinstance(embed_model, keras.Model):
first_layer_output = embed_model.output
first_layer_input = embed_model.inputs
else:
first_layer_output = embed_model
first_layer_input = embed_model
tensor = layer_blstm(first_layer_output)
tensor = layer_dense(tensor)
tensor = layer_crf_dense(tensor)
output_tensor = layer_crf(tensor)
self.layer_crf = layer_crf
self.tf_model = keras.Model(first_layer_input, output_tensor)
def conv_block(self,
inputs,
filters: int,
kernel_size: int = 3,
activation: str = 'linear',
shortcut: bool = True):
layers_conv_unit = []
layers_conv_unit.append(L.BatchNormalization())
layers_conv_unit.append(L.PReLU())
layers_conv_unit.append(
L.Conv1D(filters=filters,
kernel_size=kernel_size,
strides=1,
padding='same',
activation=activation))
layers_conv_block = layers_conv_unit * 2
tensor_out = inputs
for layer in layers_conv_block:
tensor_out = layer(tensor_out)
if shortcut:
tensor_out = L.Add()([inputs, tensor_out])
return tensor_out
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_blstm = L.Bidirectional(L.LSTM(**config['layer_blstm']),
name='layer_blstm')
layer_LSTMDecoder = LSTMDecoder(**config['layer_LSTMDecoder'],
name='layer_LSTMDecoder')
layer_dense = L.Dense(**config['layer_dense'], name='layer_dense')
layer_decoder_dense = L.Dense(output_dim, name='layer_decoder_dense')
softmax_layer = L.Activation(tf.nn.softmax, name="softmax_layer")
tensor = layer_blstm(embed_model.output)
tensor = layer_LSTMDecoder(tensor)
tensor = layer_dense(tensor)
tensor = layer_decoder_dense(tensor)
output_tensor = softmax_layer(tensor)
self.layer_LSTMDecoder = layer_LSTMDecoder
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
output_dim = self.processor.output_dim
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_bi_lstm = L.Bidirectional(L.LSTM(**config['layer_bi_lstm']))
layer_dense = L.Dense(output_dim, **config['layer_dense'])
tensor = layer_bi_lstm(embed_model.output)
output_tensor = layer_dense(tensor)
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_bi_gru = L.Bidirectional(L.GRU(**config['layer_bi_gru']))
layer_dense = L.Dense(output_dim, **config['layer_dense'])
tensor = layer_bi_gru(embed_model.output)
output_tensor = layer_dense(tensor)
self.tf_model = tf.keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layers_region = [
L.Conv1D(**config['region_embedding']),
L.BatchNormalization(),
L.PReLU(),
L.Dropout(**config['region_dropout'])
]
layers_main = [
L.GlobalMaxPooling1D(),
L.Dense(**config['dense']),
L.BatchNormalization(),
L.PReLU(),
L.Dropout(**config['dropout']),
L.Dense(output_dim, **config['activation'])
]
if isinstance(embed_model, keras.Model):
first_layer_output = embed_model.output
first_layer_input = embed_model.inputs
else:
first_layer_output = embed_model
first_layer_input = embed_model
tensor_out = first_layer_output
# build region tensors
for layer in layers_region:
tensor_out = layer(tensor_out)
# build the base pyramid layer
tensor_out = self.conv_block(tensor_out, **config['conv_block'])
# build the above pyramid layers while `steps > 2`
seq_len = tensor_out.shape[1].value
if seq_len is None:
raise ValueError('`sequence_length` should be explicitly assigned, but it is `None`.')
for i in range(floor(log2(seq_len)) - 2):
tensor_out = self.resnet_block(tensor_out, stage=i + 1,
**config['resnet_block'])
for layer in layers_main:
tensor_out = layer(tensor_out)
self.tf_model = tf.keras.Model(first_layer_input, tensor_out)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layers_seq = []
layers_seq.append(L.Conv1D(**config['conv_layer']))
layers_seq.append(L.MaxPooling1D(**config['max_pool_layer']))
layers_seq.append(L.GRU(**config['gru_layer']))
layers_seq.append(L.Dense(output_dim, **config['activation_layer']))
tensor = embed_model.output
for layer in layers_seq:
tensor = layer(tensor)
self.tf_model = tf.keras.Model(embed_model.inputs, tensor)
def build_model_arc(self) -> None:
output_dim = self.label_processor.vocab_size
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_stack = [
L.Bidirectional(L.GRU(**config['layer_bi_gru'])),
L.Dense(output_dim, **config['layer_output']),
self._activation_layer()
]
tensor = embed_model.output
for layer in layer_stack:
tensor = layer(tensor)
self.tf_model = keras.Model(embed_model.inputs, tensor)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_embed_dropout = L.SpatialDropout1D(**config['spatial_dropout'])
layers_conv = [L.Conv1D(**config[f'conv_{i}']) for i in range(4)]
layers_sensor = [KMaxPoolingLayer(**config['maxpool_i4']), L.Flatten()]
layer_concat = L.Concatenate(**config['merged_tensor'])
layers_seq = []
layers_seq.append(L.Dropout(**config['dropout']))
layers_seq.append(L.Dense(**config['dense']))
layers_seq.append(L.Dense(output_dim, **config['activation_layer']))
embed_tensor = layer_embed_dropout(embed_model.output)
tensors_conv = [layer_conv(embed_tensor) for layer_conv in layers_conv]
tensors_sensor = []
for tensor_conv in tensors_conv:
tensor_sensor = tensor_conv
for layer_sensor in layers_sensor:
tensor_sensor = layer_sensor(tensor_sensor)
tensors_sensor.append(tensor_sensor)
tensor = layer_concat(tensors_sensor)
# tensor = L.concatenate(tensors_sensor, **config['merged_tensor'])
for layer in layers_seq:
tensor = layer(tensor)
self.tf_model = tf.keras.Model(embed_model.inputs, tensor)
def build_model_arc(self) -> None:
output_dim = self.label_processor.vocab_size
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_stack = [
L.Bidirectional(L.LSTM(**config['layer_blstm']),
name='layer_blstm'),
L.Dropout(**config['layer_dropout'], name='layer_dropout'),
L.Dense(output_dim, **config['layer_time_distributed']),
L.Activation(**config['layer_activation'])
]
tensor = embed_model.output
for layer in layer_stack:
tensor = layer(tensor)
self.tf_model = keras.Model(embed_model.inputs, tensor)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_bi_gru = L.Bidirectional(L.GRU(**config['layer_bi_gru']))
layer_dense = L.Dense(output_dim, **config['layer_dense'])
if isinstance(embed_model, keras.Model):
first_layer_output = embed_model.output
first_layer_input = embed_model.inputs
else:
first_layer_output = embed_model
first_layer_input = embed_model
tensor = layer_bi_gru(first_layer_output)
output_tensor = layer_dense(tensor)
self.tf_model = tf.keras.Model(first_layer_input, output_tensor)
def build_model_arc(self):
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_bi_lstm = L.Bidirectional(L.LSTM(**config['layer_bi_lstm']),
name='layer_bi_lstm')
layer_output_1 = L.Dense(3,
activation='sigmoid',
name='layer_output_1')
layer_output_2 = L.Dense(3,
activation='sigmoid',
name='layer_output_2')
tensor = layer_bi_lstm(embed_model.output)
output_tensor_1 = layer_output_1(tensor)
output_tensor_2 = layer_output_2(tensor)
self.tf_model = tf.keras.Model(embed_model.inputs,
[output_tensor_1, output_tensor_2])
def build_model_arc(self) -> None:
output_dim = self.label_processor.vocab_size
config = self.hyper_parameters
embed_model = self.embedding.embed_model
# build model structure in sequent way
layer_stack = [
L.Conv1D(**config['conv1d_layer']),
L.MaxPooling1D(**config['max_pool_layer']),
L.LSTM(**config['lstm_layer']),
L.Dense(output_dim, **config['layer_output']),
self._activation_layer()
]
tensor = embed_model.output
for layer in layer_stack:
tensor = layer(tensor)
self.tf_model = keras.Model(embed_model.inputs, tensor)
def build_model_arc(self) -> None:
output_dim = self.label_processor.vocab_size
config = self.hyper_parameters
embed_model = self.embedding.embed_model
crf = KConditionalRandomField()
layer_stack = [
L.Bidirectional(L.GRU(**config['layer_bgru']), name='layer_bgru'),
L.Dropout(**config['layer_dropout'], name='layer_dropout'),
L.Dense(output_dim, **config['layer_time_distributed']), crf
]
tensor = embed_model.output
for layer in layer_stack:
tensor = layer(tensor)
self.tf_model = keras.Model(embed_model.inputs, tensor)
self.crf_layer = crf
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_blstm = L.Bidirectional(L.LSTM(**config['layer_blstm']),
name='layer_blstm')
layer_self_attention = SeqSelfAttention(**
config['layer_self_attention'],
name='layer_self_attention')
layer_dropout = L.Dropout(**config['layer_dropout'],
name='layer_dropout')
layer_time_distributed = L.TimeDistributed(
L.Dense(output_dim, **config['layer_time_distributed']),
name='layer_time_distributed')
layer_activation = L.Activation(**config['layer_activation'])
tensor = layer_blstm(embed_model.output)
tensor = layer_self_attention(tensor)
tensor = layer_dropout(tensor)
tensor = layer_time_distributed(tensor)
output_tensor = layer_activation(tensor)
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_bert = bert_attention(name='layer_bert')
layer_position = Position_attention_layer(name='layer_position')
layer_blstm = L.Bidirectional(L.CuDNNLSTM(**config['layer_blstm']),
name='layer_blstm')
layer_LSTMDecoder = LSTMDecoder(**config['layer_LSTMDecoder'],
name='layer_LSTMDecoder')
layer_attention = Attention(name='layer_attention')
layer_Activation = L.Activation("tanh", name="layer_Activation")
layer_dense1 = L.Dense(**config['layer_dense1'], name='layer_dense1')
layer_dense2 = L.Dense(**config['layer_dense2'], name='layer_dense2')
layer_crf_dense = L.Dense(output_dim, name='layer_crf_dense')
layer_crf = CRF(output_dim, name='layer_crf') #全局定制类
tensor = layer_bert(embed_model.output)
tensor = layer_position(tensor)
tensor = layer_blstm(tensor)
tensor = layer_LSTMDecoder(tensor)
tensor = layer_attention(tensor)
tensor = layer_Activation(tensor)
tensor = layer_dense1(tensor)
tensor = layer_dense2(tensor)
tensor = layer_crf_dense(tensor)
output_tensor = layer_crf(tensor)
self.layer_crf = layer_crf
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_conv = L.Conv1D(**config['layer_conv'], name='layer_conv')
layer_blstm = L.Bidirectional(L.CuDNNLSTM(**config['layer_blstm']),
name='layer_blstm')
layer_dense = L.Dense(**config['layer_dense'], name='layer_dense')
layer_crf_dense1 = L.Dense(output_dim, name='layer_crf_dense')
layer_crf1 = CRF(output_dim, name='layer_crf1') #全局定制类
layer_crf_dense2 = L.Dense(output_dim, name='layer_crf_dense2')
layer_crf2 = CRF(output_dim, name='layer_crf2')
tensor = layer_conv(embed_model.output)
tensor1 = layer_crf_dense1(tensor)
output_tensor1 = layer_crf1(tensor1)
tensor = layer_blstm(tensor)
tensor = layer_dense(tensor)
tensor2 = layer_crf_dense2(tensor)
output_tensor2 = layer_crf2(tensor2)
self.layer_crf1 = layer_crf1
self.layer_crf2 = layer_crf2
self.tf_model = keras.Model(inputs=embed_model.inputs,
outputs=[output_tensor2, output_tensor1])
def build_model_arc(self):
output_dim = len(self.processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
# Define your layers
layer_blstm1 = L.Bidirectional(L.LSTM(**config['layer_blstm1']),
name='layer_blstm1')
layer_blstm2 = L.Bidirectional(L.LSTM(**config['layer_blstm2']),
name='layer_blstm2')
layer_blstm3 = L.Bidirectional(L.LSTM(**config['layer_blstm3']),
name='layer_blstm3')
layer_dropout1 = L.Dropout(**config['layer_dropout1'],
name='layer_dropout1')
layer_dropout2 = L.Dropout(**config['layer_dropout2'],
name='layer_dropout2')
layer_dropout3 = L.Dropout(**config['layer_dropout3'],
name='layer_dropout3')
#layer_flatten = L.Flatten(**config['layer_flatten'])
#layer_activation = L.Activation(**config['layer_activation'])
layer_dense = L.Dense(output_dim, **config['layer_dense'])
# Define tensor flow
tensor = layer_dropout1(embed_model.output)
tensor = layer_blstm1(tensor)
tensor = layer_dropout2(tensor)
tensor = layer_blstm2(tensor)
#tensor = layer_dropout3(tensor)
#tensor = layer_blstm3(tensor)
output_tensor = layer_dense(tensor)
# Init model
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layer_embed_dropout = L.SpatialDropout1D(**config['spatial_dropout'])
layers_conv = [L.Conv1D(**config[f'conv_{i}']) for i in range(4)]
layers_sensor = []
layers_sensor.append(L.GlobalMaxPooling1D())
layers_sensor.append(AttentionWeightedAverageLayer())
layers_sensor.append(L.GlobalAveragePooling1D())
layer_view = L.Concatenate(**config['v_col3'])
layer_allviews = L.Concatenate(**config['merged_tensor'])
layers_seq = []
layers_seq.append(L.Dropout(**config['dropout']))
layers_seq.append(L.Dense(**config['dense']))
layers_seq.append(L.Dense(output_dim, **config['activation_layer']))
embed_tensor = layer_embed_dropout(embed_model.output)
tensors_conv = [layer_conv(embed_tensor) for layer_conv in layers_conv]
tensors_matrix_sensor = []
for tensor_conv in tensors_conv:
tensor_sensors = []
tensor_sensors = [
layer_sensor(tensor_conv) for layer_sensor in layers_sensor
]
# tensor_sensors.append(L.GlobalMaxPooling1D()(tensor_conv))
# tensor_sensors.append(AttentionWeightedAverageLayer()(tensor_conv))
# tensor_sensors.append(L.GlobalAveragePooling1D()(tensor_conv))
tensors_matrix_sensor.append(tensor_sensors)
tensors_views = [
layer_view(list(tensors))
for tensors in zip(*tensors_matrix_sensor)
]
tensor = layer_allviews(tensors_views)
# tensors_v_cols = [L.concatenate(tensors, **config['v_col3']) for tensors
# in zip(*tensors_matrix_sensor)]
# tensor = L.concatenate(tensors_v_cols, **config['merged_tensor'])
for layer in layers_seq:
tensor = layer(tensor)
self.tf_model = tf.keras.Model(embed_model.inputs, tensor)
def __init__(self,
embedding: ABCEmbedding,
vocab_size: int,
hidden_size: int = 1024):
super(AttGRUDecoder, self).__init__()
self.embedding = embedding
self.hidden_size = hidden_size
self.gru = tf.keras.layers.GRU(hidden_size,
return_sequences=True,
return_state=True,
recurrent_initializer='glorot_uniform')
self.fc = tf.keras.layers.Dense(vocab_size)
# 用于注意力
self.attention = L.BahdanauAttention(hidden_size)
def _build_model(self, **kwargs):
if self.embed_model is None and all(embed.embed_model is not None
for embed in self.embeddings):
layer_concatenate = L.Concatenate(name='layer_concatenate')
inputs = []
for embed in self.embeddings:
inputs += embed.embed_model.inputs
# inputs = [embed.embed_model.inputs for embed in self.embeddings]
outputs = layer_concatenate(
[embed.embed_model.output for embed in self.embeddings])
self.embed_model = tf.keras.Model(inputs, outputs)
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
# build model structure in sequent way
layers_seq = []
layers_seq.append(L.Conv1D(**config['conv1d_layer']))
layers_seq.append(L.GlobalMaxPooling1D(**config['max_pool_layer']))
layers_seq.append(L.Dense(**config['dense_layer']))
layers_seq.append(L.Dense(output_dim, **config['activation_layer']))
if isinstance(embed_model, keras.Model):
first_layer_output = embed_model.output
first_layer_input = embed_model.inputs
else:
first_layer_output = embed_model
first_layer_input = embed_model
tensor = first_layer_output
for layer in layers_seq:
tensor = layer(tensor)
self.tf_model = tf.keras.Model(first_layer_input, tensor)
def build_model_arc(self) -> None:
config = self.hyper_parameters
output_dim = self.label_processor.vocab_size
embed_model = self.embedding.embed_model
# 定义模型架构
self.tf_model = keras.Sequential([
embed_model,
L.Bidirectional(L.LSTM(**config['layer_lstm1'])),
L.Bidirectional(L.LSTM(**config['layer_lstm2'])),
L.Dropout(**config['layer_dropout']),
L.Dense(output_dim, **config['layer_output']),
self._activation_layer()
])
def build_model_arc(self):
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
layers_rnn = []
layers_rnn.append(L.SpatialDropout1D(**config['spatial_dropout']))
layers_rnn.append(L.Bidirectional(L.GRU(**config['rnn_0'])))
layers_rnn.append(L.SpatialDropout1D(**config['rnn_dropout']))
layers_rnn.append(L.Bidirectional(L.GRU(**config['rnn_1'])))
layers_sensor = []
layers_sensor.append(L.Lambda(lambda t: t[:, -1], name='last'))
layers_sensor.append(L.GlobalMaxPooling1D())
layers_sensor.append(AttentionWeightedAverageLayer())
layers_sensor.append(L.GlobalAveragePooling1D())
layer_allviews = L.Concatenate(**config['all_views'])
layers_full_connect = []
layers_full_connect.append(L.Dropout(**config['dropout_0']))
layers_full_connect.append(L.Dense(**config['dense']))
layers_full_connect.append(L.Dropout(**config['dropout_1']))
layers_full_connect.append(
L.Dense(output_dim, **config['activation_layer']))
tensor_rnn = embed_model.output
for layer in layers_rnn:
tensor_rnn = layer(tensor_rnn)
tensor_sensors = [layer(tensor_rnn) for layer in layers_sensor]
tensor_output = layer_allviews(tensor_sensors)
for layer in layers_full_connect:
tensor_output = layer(tensor_output)
self.tf_model = tf.keras.Model(embed_model.inputs, tensor_output)
def build_model_arc(self):
"""
build model architectural
"""
output_dim = len(self.pre_processor.label2idx)
config = self.hyper_parameters
embed_model = self.embedding.embed_model
# layer_blstm = L.Bidirectional(L.LSTM(**config['layer_blstm']),
# name='layer_blstm')
layer_conv2 = L.Conv1D(**config['layer_conv2'],
name='layer_conv2',
kernel_regularizer=regularizers.l2(0.01))
layer_conv3 = L.Conv1D(**config['layer_conv3'],
name='layer_conv3',
kernel_regularizer=regularizers.l2(0.02))
layer_conv4 = L.Conv1D(**config['layer_conv4'],
name='layer_conv4',
kernel_regularizer=regularizers.l2(0.03))
layer_conv5 = L.Conv1D(**config['layer_conv5'],
name='layer_conv5',
kernel_regularizer=regularizers.l2(0.04))
layer_conv6 = L.Conv1D(**config['layer_conv6'],
name='layer_conv6',
kernel_regularizer=regularizers.l2(0.05))
layer_conv7 = L.Conv1D(**config['layer_conv7'],
name='layer_conv7',
kernel_regularizer=regularizers.l2(0.06))
layer_conv8 = L.Conv1D(**config['layer_conv8'],
name='layer_conv8',
kernel_regularizer=regularizers.l2(0.07))
layer_conv9 = L.Conv1D(**config['layer_conv9'],
name='layer_conv9',
kernel_regularizer=regularizers.l2(0.08))
layer_conv10 = L.Conv1D(**config['layer_conv10'],
name='layer_conv10',
kernel_regularizer=regularizers.l2(0.09))
layer_blstm = L.Bidirectional(L.CuDNNLSTM(**config['layer_blstm']),
name='layer_blstm')
layer_dense = L.Dense(**config['layer_dense'], name='layer_dense')
layer_crf_dense = L.Dense(output_dim, name='layer_crf_dense')
layer_crf = CRF(output_dim, name='layer_crf') #全局定制类
tensor2 = layer_conv2(embed_model.output)
tensor3 = layer_conv3(embed_model.output)
tensor4 = layer_conv4(embed_model.output)
tensor5 = layer_conv5(embed_model.output)
tensor6 = layer_conv6(embed_model.output)
tensor7 = layer_conv7(embed_model.output)
tensor8 = layer_conv8(embed_model.output)
tensor9 = layer_conv9(embed_model.output)
tensor10 = layer_conv10(embed_model.output)
tensor = keras.layers.concatenate([
tensor2, tensor3, tensor4, tensor5, tensor6, tensor7, tensor8,
tensor9, tensor10
], 2)
tensor = layer_blstm(tensor)
tensor = layer_dense(tensor)
tensor = layer_crf_dense(tensor)
output_tensor = layer_crf(tensor)
self.layer_crf = layer_crf
self.tf_model = keras.Model(embed_model.inputs, output_tensor)
