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)