def model(reader): inshape = (reader.max_len, ) known_in = L.Input(shape=inshape, dtype='int32') unknown_in = L.Input(shape=inshape, dtype='int32') embedding = L.Embedding(len(reader.vocabulary_above_cutoff) + 2, 5) known_emb = embedding(known_in) unknown_emb = embedding(unknown_in) lstm = L.Bidirectional(L.LSTM(100, return_sequences=True)) char_features_known = lstm(known_emb) char_features_unknown = lstm(unknown_emb) features_known = L.GlobalAveragePooling1D()(char_features_known) features_unknown = L.GlobalAveragePooling1D()(char_features_unknown) cos_distance = L.merge([features_known, features_unknown], mode='cos', dot_axes=1) cos_distance = L.Reshape((1, ))(cos_distance) cos_similarity = L.Lambda(lambda x: 1 - x)(cos_distance) model = Model(inputs=[known_in, unknown_in], outputs=cos_similarity) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) return model
def build_model(embedding_matrix, word_index, max_len, lstm_units, verbose = False, compile = True, multi=True, gpu_num=4): #logger.info('Build model') sequence_input = L.Input(shape=(max_len,), dtype='int32') embedding_layer = L.Embedding(*embedding_matrix.shape, weights=[embedding_matrix], trainable=False) x = embedding_layer(sequence_input) x = L.SpatialDropout1D(0.3)(x) x = L.Bidirectional(L.CuDNNLSTM(lstm_units, return_sequences=True))(x) x = L.Bidirectional(L.CuDNNLSTM(lstm_units, return_sequences=True))(x) att = Attention(max_len)(x) avg_pool1 = L.GlobalAveragePooling1D()(x) max_pool1 = L.GlobalMaxPooling1D()(x) x = L.concatenate([att,avg_pool1, max_pool1]) preds = L.Dense(1, activation='sigmoid')(x) model = Model(sequence_input, preds) if multi: print('use multi gpus') model = ModelMGPU(model, gpus=gpu_num) if verbose: model.summary() if compile: model.compile(loss='binary_crossentropy',optimizer=Adam(0.005),metrics=['acc']) return model
def littlesmartcnn(): inp = kl.Input((1024, 1)) x = kl.Conv1D(128, 7)(inp) x = kl.BatchNormalization()(x) x = kl.LeakyReLU()(x) x = littelsmartblock(x, 128) x = kl.MaxPooling1D()(x) x = kl.Conv1D(256, 3, padding='same')(x) x = kl.BatchNormalization()(x) x = kl.LeakyReLU()(x) x = littelsmartblock(x, 256) x = kl.MaxPooling1D()(x) x = kl.Conv1D(512, 3, padding='same')(x) x = kl.BatchNormalization()(x) x = kl.LeakyReLU()(x) x = littelsmartblock(x, 512) x = littelsmartblock(x, 512) x = littelsmartblock(x, 512) x = kl.MaxPooling1D()(x) x = kl.Conv1D(1024, 3, padding='same')(x) x = kl.BatchNormalization()(x) x = kl.LeakyReLU()(x) x = littelsmartblock(x, 1024) x = kl.GlobalAveragePooling1D()(x) x = kl.Dense(1)(x) return km.Model(inp, x)
def __call__(self, inputs): x = inputs[0] kernel_regularizer = kr.L1L2(l1=self.l1_decay, l2=self.l2_decay) x = kl.Conv1D(128, 11, name='conv1', kernel_initializer=self.init, kernel_regularizer=kernel_regularizer)(x) x = kl.BatchNormalization(name='bn1')(x) x = kl.Activation('relu', name='act1')(x) x = kl.MaxPooling1D(2, name='pool1')(x) # 124 x = self._res_unit(x, [32, 32, 128], stage=1, block=1, stride=2) x = self._res_unit(x, [32, 32, 128], stage=1, block=2) x = self._res_unit(x, [32, 32, 128], stage=1, block=3) # 64 x = self._res_unit(x, [64, 64, 256], stage=2, block=1, stride=2) x = self._res_unit(x, [64, 64, 256], stage=2, block=2) x = self._res_unit(x, [64, 64, 256], stage=2, block=3) # 32 x = self._res_unit(x, [128, 128, 512], stage=3, block=1, stride=2) x = self._res_unit(x, [128, 128, 512], stage=3, block=2) x = self._res_unit(x, [128, 128, 512], stage=3, block=3) # 16 x = self._res_unit(x, [256, 256, 1024], stage=4, block=1, stride=2) x = kl.GlobalAveragePooling1D()(x) x = kl.Dropout(self.dropout)(x) return self._build(inputs, x)
def model(embedding_size,vocab_size,encoded_image,words_input,masks,positional_encoding,bottleneck_units=512): emb = kl.Embedding(vocab_size+1 , embedding_size , mask_zero=False , name='w2v_emb')(words_input) emb = kl.Dense(name='c1' ,units=bottleneck_units ,activation=activation ,use_bias=True)(emb) sa_input = kl.Add()([emb,positional_encoding]) # ---- decoder block 1 ---- dec_1 = decoder_block(sa_input=sa_input ,masks=masks ,encoder_output=encoded_image ,heads=8 ,layer_number=1) # ---- decoder block 2 ---- dec_2 = decoder_block(sa_input=dec_1 ,masks=masks ,encoder_output=encoded_image ,heads=8 ,layer_number=2) gap = kl.GlobalAveragePooling1D()(dec_2) gap = kl.Dense(1024 ,activation=activation)(gap) target = kl.Dense(vocab_size+1)(gap) return target
def build_model(verbose = False, compile = True): sequence_input = L.Input(shape=(maxlen,), dtype='int32') embedding_layer = L.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], input_length=maxlen, trainable=False) x = embedding_layer(sequence_input) x = L.SpatialDropout1D(0.2)(x) x = L.Bidirectional(L.CuDNNLSTM(64, return_sequences=True))(x) att = Attention(maxlen)(x) avg_pool1 = L.GlobalAveragePooling1D()(x) max_pool1 = L.GlobalMaxPooling1D()(x) x = L.concatenate([att,avg_pool1, max_pool1]) preds = L.Dense(1, activation='sigmoid')(x) model = Model(sequence_input, preds) if verbose: model.summary() if compile: model.compile(loss='binary_crossentropy',optimizer=Adam(0.005),metrics=['acc']) return model
def make_model(input_shape): nn = models.Sequential() nn.add( layers.SeparableConv1D(64, 7, activation='relu', input_shape=(None, input_shape[-1]))) nn.add(layers.BatchNormalization()) nn.add(layers.SeparableConv1D(64, 7, activation='relu')) nn.add(layers.BatchNormalization()) nn.add(layers.MaxPooling1D(5)) nn.add(layers.Dropout(0.3)) nn.add(layers.SeparableConv1D(128, 7, activation='relu')) nn.add(layers.BatchNormalization()) nn.add(layers.SeparableConv1D(128, 7, activation='relu')) nn.add(layers.BatchNormalization()) nn.add(layers.MaxPooling1D(5)) nn.add(layers.Dropout(0.3)) nn.add(layers.SeparableConv1D(512, 7, activation='relu')) nn.add(layers.BatchNormalization()) nn.add(layers.SeparableConv1D(512, 7, activation='relu')) nn.add(layers.BatchNormalization()) nn.add(layers.GlobalAveragePooling1D()) nn.add(layers.Dense(41, activation='softmax')) return nn
def basic_model(self, input_shape, num_classes): model = models.Sequential() model.add( layers.Conv1D(128, 5, padding='same', input_shape=input_shape)) model.add(layers.Activation('relu')) model.add(layers.MaxPooling1D()) model.add(layers.Dropout(0.4)) for i in range(6): model.add( layers.Conv1D( int(128 / (i + 1)), 5 + (2 * i), padding='same', )) model.add(layers.Activation('relu')) model.add(layers.MaxPooling1D()) model.add(layers.Dropout(0.4)) model.add(layers.GlobalAveragePooling1D()) model.add(layers.Dense(256)) model.add(layers.Activation('relu')) model.add(layers.Dropout(0.3)) model.add(layers.Dense(128)) model.add(layers.Activation('relu')) model.add(layers.Dropout(0.3)) model.add(layers.Dense(64)) model.add(layers.Activation('relu')) model.add(layers.Dropout(0.3)) model.add(layers.Dense(num_classes)) model.add(layers.Activation('softmax')) return model
def __call__(self, inputs): x = inputs[0] w_reg = kr.WeightRegularizer(l1=self.l1_decay, l2=self.l2_decay) x = kl.Conv1D(128, 11, name='conv1', init=self.init, W_regularizer=w_reg)(x) x = kl.Activation('relu', name='act1')(x) x = kl.MaxPooling1D(2, name='pool1')(x) # 124 x = self._res_unit(x, [32, 32, 128], stage=1, block=1, stride=2) x = self._res_unit(x, [32, 32, 128], atrous=2, stage=1, block=2) x = self._res_unit(x, [32, 32, 128], atrous=4, stage=1, block=3) # 64 x = self._res_unit(x, [64, 64, 256], stage=2, block=1, stride=2) x = self._res_unit(x, [64, 64, 256], atrous=2, stage=2, block=2) x = self._res_unit(x, [64, 64, 256], atrous=4, stage=2, block=3) # 32 x = self._res_unit(x, [128, 128, 512], stage=3, block=1, stride=2) x = self._res_unit(x, [128, 128, 512], atrous=2, stage=3, block=2) x = self._res_unit(x, [128, 128, 512], atrous=4, stage=3, block=3) # 16 x = self._res_unit(x, [256, 256, 1024], stage=4, block=1, stride=2) x = kl.GlobalAveragePooling1D()(x) x = kl.Dropout(self.dropout)(x) return self._build(inputs, x)
def __call__(self, inputs): x = inputs[0] w_reg = kr.WeightRegularizer(l1=self.l1_decay, l2=self.l2_decay) x = kl.Conv1D(128, 11, name='conv1', init=self.init, W_regularizer=w_reg)(x) x = kl.BatchNormalization(name='bn1')(x) x = kl.Activation('relu', name='act1')(x) x = kl.MaxPooling1D(2, name='pool1')(x) # 124 x = self._res_unit(x, 128, stage=1, block=1, stride=2) x = self._res_unit(x, 128, stage=1, block=2) # 64 x = self._res_unit(x, 256, stage=2, block=1, stride=2) # 32 x = self._res_unit(x, 256, stage=3, block=1, stride=2) # 32 x = self._res_unit(x, 512, stage=4, block=1, stride=2) x = kl.GlobalAveragePooling1D()(x) x = kl.Dropout(self.dropout)(x) return self._build(inputs, x)
def build(txt_shape, img_shape, act_1=None, act_2=None, loss_function=mAP.my_loss): K.clear_session() word_index, embedding_matrix = loading() input_text = layers.Input(shape=(None, ), dtype='int32') input_image = layers.Input(shape=(img_shape, )) embeddings = layers.Embedding(len(word_index) + 1, 128, weights=[embedding_matrix], input_length=400, trainable=True)(input_text) embeddings = Position_Embedding()(embeddings) O_seq = Attention(8, 16)([embeddings, embeddings, embeddings]) O_seq = layers.GlobalAveragePooling1D()(O_seq) text_embedding = layers.Dropout(0.5)(O_seq) text_dense = layers.Dense(512, activation=act_1)(text_embedding) image_dense = layers.Dense(512, activation=act_1)(input_image) mul = layers.Multiply()([text_dense, image_dense]) pred = layers.Dense(1, activation=act_2)(mul) model = Model(inputs=[input_text, input_image], outputs=pred) model.compile(loss=loss_function, optimizer='adam', metrics=[mAP.auc]) model.summary() return model
def model_3(self): embedding_matrix = self.build_myself_embedding_matrix() input = layers.Input(shape=(self.max_words,)) embedding = layers.Embedding(input_dim=embedding_matrix.shape[0], output_dim=embedding_matrix.shape[1], input_length=self.max_words, weights=[embedding_matrix]) x = layers.SpatialDropout1D(0.2)(embedding(input)) x = layers.Bidirectional(layers.GRU(400, return_sequences=True))(x) x = layers.Bidirectional(layers.GRU(400, return_sequences=True))(x) avg_pool = layers.GlobalAveragePooling1D()(x) max_pool = layers.GlobalMaxPool1D()(x) concat = layers.concatenate([avg_pool, max_pool]) x = layers.Dense(1024)(concat) x = layers.BatchNormalization()(x) x = layers.Activation(activation='relu')(x) x = layers.Dropout(0.2)(x) x = layers.Dense(512)(x) x = layers.BatchNormalization()(x) x = layers.Activation(activation='relu')(x) x = layers.Dropout(0.2)(x) output = layers.Dense(self.class_num, activation='softmax')(x) model = models.Model(input=input, output=output) print(model.summary()) return model
def build(self, input_shape): if len(input_shape) != 4 and len(input_shape) != 3: raise ValueError( 'expected 3D or 4D input, got shape {}'.format(input_shape)) super(AttentiveNormalization, self).build(input_shape) dim = input_shape[self.axis] shape = (self.n_mixture, dim) # K x C self.FC = layers.Dense(self.n_mixture, activation="sigmoid") self.FC.build(input_shape) # (N, C) if len(input_shape) == 4: self.GlobalAvgPooling = layers.GlobalAveragePooling2D( self.data_format) else: self.GlobalAvgPooling = layers.GlobalAveragePooling1D( self.data_format) self.GlobalAvgPooling.build(input_shape) self._trainable_weights = self.FC.trainable_weights self.learnable_weights = self.add_weight(name='gamma2', shape=shape, initializer=ANInitializer( scale=0.1, bias=1.), trainable=True) self.learnable_bias = self.add_weight(name='bias2', shape=shape, initializer=ANInitializer( scale=0.1, bias=0.), trainable=True)
def mini_resnet(input_x): # head x = KL.Conv1D(filters=64, kernel_size=size, padding='same')(input_x) x = KL.BatchNormalization()(x) x = KL.Activation(activation='relu')(x) # block 1 x = conv_unit(x, filters=[16, 16], block=1, unit=1, trainable=True) x = conv_unit(x, filters=[16, 16], block=2, unit=2, trainable=True) # block 3 x = conv_unit(x, filters=[32, 32], block=3, unit=1, trainable=True) x = conv_unit(x, filters=[32, 32], block=4, unit=2, trainable=True) # block 5 x = conv_unit(x, filters=[64, 64], block=5, unit=1, trainable=True) x = conv_unit(x, filters=[64, 64], block=6, unit=2, trainable=True) # block 6 x = conv_unit(x, filters=[128, 128], block=7, unit=1, trainable=True) x = conv_unit(x, filters=[128, 128], block=8, unit=2, trainable=True) # block 7 # x = conv_unit(x, filters=[512, 512], block=7, unit=1, trainable=True) # x = conv_unit(x, filters=[512, 512], block=8, unit=2, trainable=True) # tail x = KL.BatchNormalization(name='out_bn')(x, training=True) x = KL.Activation(activation='relu', name='out_relu')(x) # x = KL.Flatten(name='out_flatten')(x) x = KL.GlobalAveragePooling1D()(x) if not conf.use_tradition_feature: x = KL.Dense(units=conf.num_class, name='dense_soft_out', activation='softmax')(x) return x
def create_channel(self, x, kernel_size, feature_map): """ Creates a layer, working channel wise Arguments: x : Input for convoltuional 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 self_Att_channel(x,x_att,r = 16,name = '1'): ''' advanced Hu, Jie, Li Shen, and Gang Sun."Squeeze-and-excitation networks." arXiv preprintarXiv:1709.01507 (2017). :param x: :param r: :return: ''' x_self = x chanel = K.int_shape(x)[-1] L = K.int_shape(x)[-2] x_att = layers.GlobalAveragePooling1D(name='self_avg_pool' + name )(x_att) # x_att = layers.Conv2D(chanel, # (H,W), # padding='valid', # use_bias=None, # name='FCN' + name)(x_att) x_att = layers.Dense(int(chanel / r),activation='relu')(x_att) x_att = layers.Dense(chanel, activation='sigmoid')(x_att) x = layers.Multiply()([x_self,x_att]) return x
def create_keras_classifier_model(number_of_words: int, input_length: int, output_neurons: int = 1) -> Model: """ :param number_of_words : int :param input_length : int :param output_neurons : int -> the number of output neurons. this must match the labels. :return Model """ raise Exception("Deprecated, please use bucket_classification.py instead") model = Sequential() model.add( layers.Embedding(number_of_words, EMBEDDING_SIZE, input_length=input_length)) model.add(layers.GlobalAveragePooling1D()) model.add(layers.Dense(64, activation="relu")) model.add(layers.Dropout(0.25)) model.add(layers.Dense(64, activation="relu")) model.add(layers.Dropout(0.1)) activation = "sigmoid" if output_neurons == 1 else "softmax" model.add(layers.Dense(output_neurons, activation=activation)) # todo - include other metrics such as auc, roc in the future # see https://stackoverflow.com/questions/41032551/how-to-compute-receiving-operating-characteristic-roc-and-auc-in-keras model.compile(optimizer=optimizers.Adam(), loss="binary_crossentropy", metrics=["accuracy"]) model.summary() return model
def SwishNet(input_shape, classes, width_multiply=1): _x_in = layers.Input(shape=input_shape) # 1 block _x_up = __causal_gated_conv1D(filters=16 * width_multiply, length=3)(_x_in) _x_down = __causal_gated_conv1D(filters=16 * width_multiply, length=6)(_x_in) _x = layers.Concatenate()([_x_up, _x_down]) # 2 block _x_up = __causal_gated_conv1D(filters=8 * width_multiply, length=3)(_x) _x_down = __causal_gated_conv1D(filters=8 * width_multiply, length=6)(_x) _x = layers.Concatenate()([_x_up, _x_down]) # 3 block _x_up = __causal_gated_conv1D(filters=8 * width_multiply, length=3)(_x) _x_down = __causal_gated_conv1D(filters=8 * width_multiply, length=6)(_x) _x_concat = layers.Concatenate()([_x_up, _x_down]) _x = layers.Add()([_x, _x_concat]) # 4 block _x_loop1 = __causal_gated_conv1D(filters=16 * width_multiply, length=3, strides=3)(_x) _x = layers.Add()([_x, _x_loop1]) # 5 block _x_loop2 = __causal_gated_conv1D(filters=16 * width_multiply, length=3, strides=2)(_x) _x = layers.Add()([_x, _x_loop2]) # 6 block _x_loop3 = __causal_gated_conv1D(filters=16 * width_multiply, length=3, strides=2)(_x) _x = layers.Add()([_x, _x_loop3]) # 7 block _x_forward = __causal_gated_conv1D(filters=16 * width_multiply, length=3, strides=2)(_x) # 8 block _x_loop4 = __causal_gated_conv1D(filters=32 * width_multiply, length=3, strides=2)(_x) # output _x = layers.Concatenate()([_x_loop2, _x_loop3, _x_forward, _x_loop4]) _x = layers.Conv1D(filters=classes, kernel_size=1)(_x) _x = layers.GlobalAveragePooling1D()(_x) _x = layers.Activation("softmax")(_x) model = Model(inputs=_x_in, outputs=_x) return model
def build_transformer(max_words=20000, maxlen=200, embedding_dim=400, classification_type=2): S_inputs = layers.Input(shape=(None,), dtype='int32') embeddings = layers.Embedding(max_words, embedding_dim, input_length=maxlen)(S_inputs) embeddings = Position_Embedding()(embeddings) # 增加Position_Embedding能轻微提高准确率 O_seq = Attention(8, 16)([embeddings, embeddings, embeddings]) O_seq = layers.GlobalAveragePooling1D()(O_seq) O_seq = layers.Dropout(0.5)(O_seq) outputs = layers.Dense(classification_type, activation='softmax')(O_seq) model = models.Model(inputs=S_inputs, outputs=outputs) return model
def build_model(max_words, embedding_dim, sequence_length): print('Build model...') model = models.Sequential() model.add( layers.Embedding(max_words, embedding_dim, input_length=sequence_length)) model.add(layers.GlobalAveragePooling1D()) return model.input, model.output
def __call__(self, inputs): x = self._merge_inputs(inputs) shape = getattr(x, '_keras_shape') replicate_model = self._replicate_model(kl.Input(shape=shape[2:])) x = kl.TimeDistributed(replicate_model)(x) x = kl.GlobalAveragePooling1D()(x) x = kl.Dropout(self.dropout)(x) return self._build(inputs, x)
def build_model(emb_cid, emb_advid): inp1 = layers.Input(shape=(max_len, )) inp2 = layers.Input(shape=(max_len, )) emb1 = layers.Embedding(input_dim=emb_cid.shape[0], output_dim=emb_cid.shape[1], input_length=max_len, weights=[emb_cid], trainable=False)(inp1) emb2 = layers.Embedding(input_dim=emb_advid.shape[0], output_dim=emb_advid.shape[1], input_length=max_len, weights=[emb_advid], trainable=False)(inp2) sdrop = layers.SpatialDropout1D(rate=0.2) emb1 = sdrop(emb1) emb2 = sdrop(emb2) content = layers.Concatenate()([emb1, emb2]) mha = MultiHeadAttention(head_num=16)(content) mha = layers.Dropout(0.01)(mha) mha = layers.Add()([content, mha]) mha = LayerNormalization()(mha) mha = layers.Dropout(0.01)(mha) mha_ff = FeedForward(256)(mha) mha_out = layers.Add()([mha, mha_ff]) mha_out = LayerNormalization()(mha_out) lstm = layers.Bidirectional(layers.LSTM(128, return_sequences=True))(mha_out) avg_pool = layers.GlobalAveragePooling1D()(lstm) max_pool = layers.GlobalMaxPool1D()(lstm) x = layers.Concatenate()([avg_pool, max_pool]) x = layers.Dense(128, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Dense(64, activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Dropout(0.1)(x) out = layers.Dense(10, activation='softmax')(x) model = keras.Model(inputs=[inp1, inp2], outputs=out) model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(1e-3), metrics=['accuracy']) return model
def test_globalpooling_1d_supports_masking(): # Test GlobalAveragePooling1D supports masking model = Sequential() model.add(layers.Masking(mask_value=0., input_shape=(3, 4))) model.add(layers.GlobalAveragePooling1D()) model.compile(loss='mae', optimizer='adam') model_input = np.random.randint(low=1, high=5, size=(2, 3, 4)) model_input[0, 1:, :] = 0 output = model.predict(model_input) assert np.array_equal(output[0], model_input[0, 0, :])
def FastText(param): inp = layers.Input(shape=(param['sentence_len'], )) x = layers.Embedding(param['vocab_size'], param['embed_size'])(inp) x = layers.SpatialDropout1D(rate=0.1)(x) x = layers.GlobalAveragePooling1D()(x) outp = layers.Dense(param['num_class'], activation='sigmoid')(x) model = Model(inputs=inp, outputs=outp) optimizer = optimizers.Adam(lr=0.01) model.compile(loss='binary_crossentropy', optimizer=optimizer) return model
def TimeAvgLSTM_embedding(input_shape, dropW=0.2, dropU=0.2, lstm_dims=128, embedding=None): model = Sequential() model.add(layers.InputLayer(input_shape=(input_shape, ))) model.add(embedding) model.add(layers.LSTM(lstm_dims, dropout_W=dropW, dropout_U=dropU)) model.add(layers.GlobalAveragePooling1D()) return model
def build_model(max_words, embedding_dim, output_dim, sequence_length): print('Build model...') model = models.Sequential() model.add( layers.Embedding(max_words, embedding_dim, input_length=sequence_length)) # 我们增加 GlobalAveragePooling1D, 这将平均计算文档中所有词汇的的词嵌入 model.add(layers.GlobalAveragePooling1D()) model.add(layers.Dense(output_dim, activation='sigmoid')) model.add(layers.Activation('softmax')) return model
def build_Model(self, input_tensor, reshape_dimension): x = lpk.ContextGating()(input_tensor) x = layers.Reshape((100, reshape_dimension))(x) x = lpk.NetVLAD(feature_size = reshape_dimension, max_samples = 100, cluster_size = 32, output_dim =3*16)(x) x = layers.Reshape((3,16))(x) x = layers.GlobalAveragePooling1D()(x) x = layers.Dense(24, activation = 'relu')(x) x = layers.Dense(3, activation = 'sigmoid')(x) return x
def make_model(filters=CHANNELS): """Создает сеть на основе сгенеренных признаков.""" backend.clear_session() y = x = layers.Input(shape=(None, 4)) y = conv1d.make_net(y, BLOCKS, LINK, CHANNELS, LAYERS_TYPE, se=SE) y = layers.GlobalAveragePooling1D()(y) y = layers.Dense(units=filters // 2, activation="relu")(y) y = layers.Dense(units=4, activation=None)(y) model = models.Model(inputs=x, outputs=y) model.summary() return model
def model(self, embedding_matrix): model = models.Sequential() model.add(layers.Embedding(self.nn_param.vocab_size + 1, self.nn_param.embedding_dim, input_length=self.nn_param.max_words)) # input_length=self.nn_param.max_words, weights=[embedding_matrix])) model.add(layers.GlobalAveragePooling1D()) if self.nn_param.class_num == 2: model.add(layers.Dense(1, activation='sigmoid')) model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy']) else: model.add(layers.Dense(self.nn_param.class_num, activation='softmax')) model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) print(model.summary()) return model
def new_model(): model = keras.Sequential() model.add(layers.GaussianNoise(0.5, input_shape=(None, FEATURE_SIZE))) model.add(layers.Conv1D(128, 5, activation="relu")) model.add(layers.MaxPooling1D(5)) model.add(layers.Conv1D(256, 5, activation="relu")) model.add(layers.GlobalAveragePooling1D()) model.add(layers.Dense(500, activation="relu")) model.add(layers.Dropout(0.5)) model.add(layers.Dense(500, activation="relu")) model.add(layers.Dropout(0.5)) model.add( layers.Dense(max(allophone_mapping.values()) + 1, activation="softmax")) return model