def combined_model(dense_layers, output_dim): conv_base = VGG16(weights='imagenet', include_top=False, input_shape=(128, 128, 3)) image_model = models.Sequential() image_model.add(conv_base) image_model.add(layers.Flatten()) image_model.add(layers.Dense(2048, activation='relu')) image_model.add(layers.Dropout(0.5)) image_model.add(layers.Dense(1024, activation='relu')) image_model.add(layers.Dropout(0.5)) image_model.add(layers.Dense(512, activation='relu')) text_model = models.Sequential() text_model.add(layers.Embedding(UNK_WORD + 1, 100, input_length=20)) text_model.add(layers.Convolution1D(256, 3, padding='same')) text_model.add(layers.MaxPool1D(3, 3, padding='same')) text_model.add(layers.Convolution1D(128, 3, padding='same')) text_model.add(layers.MaxPool1D(3, 3, padding='same')) text_model.add(layers.Convolution1D(64, 3, padding='same')) text_model.add(layers.Flatten()) model = models.Sequential() model.add(Merge([image_model, text_model], mode='concat')) model.add(layers.BatchNormalization()) for item in dense_layers: model.add(layers.Dense(item, activation='relu')) model.add(layers.Dropout(0.5)) model.add(layers.Dense(output_dim, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def base_multi_channel_net__runable(vocabulary_size): """ 可执行的多路一维卷积 :param vocabulary_size: :return: """ text_input = Input(shape=(32, ), dtype='int32', name='text') embedded_text = layers.Embedding(vocabulary_size, 64)(text_input) # kernel_size = 3 channel1 = layers.Conv1D(64, 3, padding="same", activation='relu')(embedded_text) channel1 = layers.MaxPool1D(4)(channel1) channel2 = layers.Conv1D(64, 4, padding="same", activation='relu')(embedded_text) channel2 = layers.MaxPool1D(4)(channel2) channel3 = layers.Conv1D(64, 5, padding="same", activation='relu')(embedded_text) channel3 = layers.MaxPool1D(4)(channel3) concatenated = layers.concatenate([channel1, channel2, channel3], axis=-1) concatenated = layers.LSTM(64)(concatenated) output = layers.Dense(64, activation='relu')(concatenated) output = layers.Dense(1, activation='sigmoid')(output) model = Model(text_input, output) return model
def model(self, embedding_matrix): inputs = layers.Input(shape=(self.nn_param.max_words,), dtype='float32') embedding = layers.Embedding(input_dim=self.nn_param.vocab_size + 1, output_dim=self.nn_param.embedding_dim, input_length=self.nn_param.max_words, trainable=False, weights=[embedding_matrix]) embed = embedding(inputs) cnn1 = layers.Conv1D(256, 3, padding='same', strides=1, activation='relu')(embed) cnn1 = layers.MaxPool1D(pool_size=48)(cnn1) cnn2 = layers.Conv1D(256, 4, padding='same', strides=1, activation='relu')(embed) cnn2 = layers.MaxPool1D(pool_size=47)(cnn2) cnn3 = layers.Conv1D(256, 5, padding='same', strides=1, activation='relu')(embed) cnn3 = layers.MaxPool1D(pool_size=46)(cnn3) cnn = layers.concatenate(inputs=[cnn1, cnn2, cnn3], axis=1) flat = layers.Flatten()(cnn) drop = layers.Dropout(0.2)(flat) if self.nn_param.class_num == 2: output = layers.Dense(1, activation='sigmoid')(drop) else: output = layers.Dense(self.nn_param.class_num, activation='sigmoid')(drop) model = models.Model(inputs=inputs, outputs=output) print(model.summary()) return model
def cnn_model_simple(self, kernel_sizes_cnn: List[int], filters_cnn: int, dense_size: int, coef_reg_cnn: float = 0., coef_reg_den: float = 0., dropout_rate: float = 0., input_projection_size: Optional[int] = None, **kwargs) -> Model: inp = Input(shape=(self.opt['text_size'], self.opt['embedding_size'])) output = inp if input_projection_size is not None: output = Dense(input_projection_size, activation='relu')(output) output = layers.Conv1D(filters=64, kernel_size=3, activation='relu')(output) output = layers.Conv1D(filters=64, kernel_size=3, activation='relu')(output) output = layers.MaxPool1D(2, strides=2)(output) output = layers.BatchNormalization()(output) output = layers.Conv1D(filters=128, kernel_size=3, activation='relu')(output) output = layers.Conv1D(filters=128, kernel_size=3, activation='relu')(output) output = layers.MaxPool1D(2, strides=2)(output) output = layers.BatchNormalization()(output) output = layers.Flatten()(output) output = layers.Dense(dense_size, activation='relu')(output) output = layers.Dense(self.n_classes, activation='softmax', use_bias=False)(output) model = Model([inp], [output]) return model
def conv_lstm(x): x = KL.Conv1D(filters=40, kernel_size=5, strides=1)(x) x = KL.MaxPool1D(pool_size=2, strides=2)(x) x = KL.Conv1D(filters=32, kernel_size=3, strides=1)(x) x = KL.MaxPool1D(pool_size=2, strides=2)(x) x = KL.LSTM(units=32, recurrent_dropout=0.25, dropout=0.5, return_sequences=True)(x) x = KL.LSTM(units=16, recurrent_dropout=0.25, return_sequences=True)(x) x = KL.LSTM(units=4, return_sequences=False)(x) x = KL.Dense(units=conf.num_class, activation='softmax')(x) return x
def text_cnn(token_per_text, embedding_dim): i_emb = layers.Input(shape=(token_per_text, embedding_dim)) conv5_1 = layers.Conv1D(128, 5, padding='same', activation='relu')(i_emb) pool5_1 = layers.MaxPool1D(5, padding='same')(conv5_1) conv5_2 = layers.Conv1D(64, 5, padding='same', activation='relu')(pool5_1) pool5_2 = layers.MaxPool1D(5, padding='same')(conv5_2) conv5_3 = layers.Conv1D(32, 5, padding='same', activation='relu')(pool5_2) pool5_3 = layers.MaxPool1D(5, padding='same')(conv5_3) flat5 = layers.Flatten()(pool5_3) conv3_1 = layers.Conv1D(128, 3, padding='same', activation='relu')(i_emb) pool3_1 = layers.MaxPool1D(3, padding='same')(conv3_1) conv3_2 = layers.Conv1D(64, 3, padding='same', activation='relu')(pool3_1) pool3_2 = layers.MaxPool1D(3, padding='same')(conv3_2) conv3_3 = layers.Conv1D(32, 4, padding='same', activation='relu')(pool3_2) pool3_3 = layers.MaxPool1D(13, padding='same')(conv3_3) flat3 = layers.Flatten()(pool3_3) conv1_1 = layers.Conv1D(128, 1, padding='same', activation='relu')(i_emb) pool1_1 = layers.MaxPool1D(1, padding='same')(conv1_1) conv1_2 = layers.Conv1D(64, 1, padding='same', activation='relu')(pool1_1) pool1_2 = layers.MaxPool1D(1, padding='same')(conv1_2) conv1_3 = layers.Conv1D(32, 1, padding='same', activation='relu')(pool1_2) pool1_3 = layers.MaxPool1D(150, padding='same')(conv1_3) flat1 = layers.Flatten()(pool1_3) o = layers.Concatenate()([flat5, flat3, flat1]) return Model(i_emb, o)
def model_twitter_convnet_lstm(embedding_matrix, maxlen): input_twitter = layers.Input(shape=(maxlen, ), dtype='int32', name='input_twitter') x = layers.Embedding(embedding_matrix.shape[0], embedding_matrix.shape[1], input_length=maxlen, trainable=True, weights=[embedding_matrix], mask_zero=False, name='embedded')(input_twitter) x = layers.Conv1D(32, (5), padding='same', kernel_initializer='orthogonal', name='conv1d_1')(x) x = layers.Activation('elu', name='act_elu_1')(x) x = layers.MaxPool1D(3, name='maxpool_1')(x) x = layers.Dropout(0.25, name='dropout_1')(x) x = layers.Conv1D(32, (5), padding='same', kernel_initializer='orthogonal', name='conv1d_2')(x) x = layers.Activation('elu', name='act_elu_2')(x) x = layers.MaxPool1D(3, name='maxpool_2')(x) x = layers.Dropout(0.25, name='dropout_2')(x) x = layers.Bidirectional( layers.LSTM(32, return_sequences=True, kernel_initializer='orthogonal', name='lstm_1'))(x) x = layers.Activation('elu', name='act_elu_3')(x) x = layers.Bidirectional( layers.LSTM(64, return_sequences=False, kernel_initializer='orthogonal', name='lstm_2'))(x) x = layers.Activation('elu', name='act_elu_4')(x) x = layers.Dense(1, name='dense_final', activation='sigmoid')(x) model = Model(input_twitter, x) model.compile(optimizer=Adam(lr=0.0001, decay=1e-6), loss='binary_crossentropy', metrics=['acc']) print(model.summary()) return model
def get_baseline_convolutional_encoder(filters, embedding_dimension, input_shape=None, dropout=0.05): encoder = Sequential() # Initial conv if input_shape is None: # In this case we are using the encoder as part of a siamese network and the input shape will be determined # automatically based on the input shape of the siamese network encoder.add( layers.Conv1D(filters, 32, padding='same', activation='relu')) else: # In this case we are using the encoder to build a classifier network and the input shape must be defined encoder.add( layers.Conv1D(filters, 32, padding='same', activation='relu', input_shape=input_shape)) encoder.add(layers.BatchNormalization()) encoder.add(layers.SpatialDropout1D(dropout)) encoder.add(layers.MaxPool1D(4, 4)) # Further convs encoder.add( layers.Conv1D(2 * filters, 3, padding='same', activation='relu')) encoder.add(layers.BatchNormalization()) encoder.add(layers.SpatialDropout1D(dropout)) encoder.add(layers.MaxPool1D()) encoder.add( layers.Conv1D(3 * filters, 3, padding='same', activation='relu')) encoder.add(layers.BatchNormalization()) encoder.add(layers.SpatialDropout1D(dropout)) encoder.add(layers.MaxPool1D()) encoder.add( layers.Conv1D(4 * filters, 3, padding='same', activation='relu')) encoder.add(layers.BatchNormalization()) encoder.add(layers.SpatialDropout1D(dropout)) encoder.add(layers.MaxPool1D()) encoder.add(layers.GlobalMaxPool1D()) encoder.add(layers.Dense(embedding_dimension)) return encoder
def base_multi_channel_net(vocabulary_size, time_steps=32): """ 多通道卷积 :param vocabulary_size: :param time_steps: :return: """ text_input = Input(shape=(time_steps, ), dtype='int32', name='text') embedded_text = layers.Embedding(vocabulary_size, 128)(text_input) channels = [] for kernel_size in range(3, 7): channel = layers.Conv1D(16, kernel_size, activation='relu')(embedded_text) channel = layers.MaxPool1D(time_steps - kernel_size + 1)(channel) channels.append(channel) concatenated = layers.concatenate(channels, axis=-1) concatenated = layers.Flatten()(concatenated) # concatenated = layers.LSTM(64)(concatenated) output = layers.Dense( 64, activation='relu', kernel_regularizer=regularizers.l2(0.001))(concatenated) output = layers.Dense(1, activation='sigmoid')(output) model = Model(text_input, output) return model
def __call__(self, inp): # Conv-layers x = inp for i, (n_filter, n_col) in enumerate(zip(self.filters, self.conv_widths)): if i == 0: # if first layer, specify input shape to enable auto build x = kl.Conv1D(filters=n_filter, kernel_size=n_col, kernel_initializer='he_normal')(x) else: x = kl.Conv1D(filters=n_filter, kernel_size=n_col, kernel_initializer='he_normal')(x) x = kl.BatchNormalization()(x) x = kl.Activation(self.activation_func)(x) if i in self.pool_layers_indices: # Add pool layers where appropriate x = kl.MaxPool1D(pool_size=self.pool_widths[ self.pool_layers_indices.index(i)], strides=self.pool_strides[ self.pool_layers_indices.index(i)])(x) seq_preds = kl.Flatten()(x) # fully connected for drop_rate, fc_layer_size in zip(self.dropout, self.hidden): seq_preds = kl.Dropout(drop_rate)(seq_preds) seq_preds = kl.Dense(fc_layer_size)(seq_preds) if self.batchnorm: seq_preds = kl.BatchNormalization()(seq_preds) seq_preds = kl.Activation('relu')(seq_preds) seq_preds = kl.Dropout(self.final_dropout)(seq_preds) return seq_preds
def get_predefined_model(): # input shape: window_size x len(x_cols) x = layers.Input((33, 91), name='input_62') y = layers.Conv1D(filters=126, kernel_size=2, padding='causal', name='conv1d_154')(x) #y = layers.BatchNormalization(name='batch_normalization_118')(y) y = layers.Activation('relu', name='activation_118')(y) y = layers.Conv1D(filters=126, kernel_size=2, padding='causal', dilation_rate=2, name='conv1d_155')(y) #y = layers.BatchNormalization(name='batch_normalization_119')(y) y = layers.Activation('relu', name='activation_119')(y) shortcut = layers.Conv1D(filters=126, kernel_size=1, padding='causal', dilation_rate=2, name='conv1d_156')(x) y = layers.add([shortcut, y], name='add_37') y = layers.MaxPool1D(pool_size=33, name='global_max_pooling1d_62')(y) y = layers.Flatten()(y) y = layers.Dense(units=len(cfg.data_cfg['Target_param_names']), name='dense_62')(y) model = models.Model(inputs=x, outputs=y) model.compile(optimizer=opts.Adam(lr=1e-9), loss='mse') return model
def cnn_module(self, tra_charas, tes_charas, tra_y, tes_y, out_len): self.model.add(layers.Conv1D(32, 4, activation='relu', input_shape=(20, 128))) # 125 self.model.add(layers.MaxPool1D(2)) # 63 self.model.add(layers.Conv1D(64, 4, activation='relu')) # 60 self.model.add(layers.MaxPool1D(2)) # 30 self.model.add(layers.Conv1D(64, 4, activation='relu')) # 27 self.model.add(layers.MaxPool1D(2)) # 14 self.model.add(layers.Flatten()) self.model.add(layers.Dense(128, activation='relu')) self.model.add(layers.Dense(out_len, activation='softmax')) self.model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) self.model.fit(tra_charas, tra_y, epochs=5, batch_size=64) test_loss, test_acc = self.model.evaluate(tes_charas, tes_y) print("test loss is : ", test_loss) print("test accuracy is : ", test_acc) return test_acc
def _build_model(self): # Neural Net for Deep-Q learning Model inp = KL.Input(shape=(self.state_size)) x = inp x = KL.Conv1D(64,72,strides=8,activation='relu')(x) x = KL.Conv1D(64,12,strides=4,activation='relu')(x) x = KL.Conv1D(128,7,strides=3,activation='relu')(x) x = KL.Conv1D(128,3,strides=3,activation='relu')(x) x = KL.Conv1D(256,3,activation='relu')(x) x = KL.MaxPool1D(3)(x) x = KL.Flatten()(x) x = KL.Dropout(0.3)(x) x = KL.Dense(64,activation='relu')(x) inp_R = KL.Input(shape=(self.statement_size,1)) R = inp_R R = KL.Masking()(R) R = KL.GRU(64)(R) out = KL.Add()([x,R]) out = KL.Dense(128,activation='relu')(out) out = KL.Dense(self.action_size)(out) model = Model([inp,inp_R],out) model.compile(loss=self._huber_loss, optimizer=Adam(lr=self.learning_rate)) return model
def _build_model(self): """ 论文中的模型结构 :return: """ model = Sequential() # 词嵌入 model.add( layers.Embedding(self.alphabet_size + 1, 128, input_length=self.input_size) ) # 卷积层 for cl in self.conv_layers: model.add(layers.Conv1D(filters=cl[0], kernel_size=cl[1])) model.add(layers.ThresholdedReLU(self.threshold)) if cl[-1] is not None: model.add(layers.MaxPool1D(pool_size=cl[-1])) model.add(layers.Flatten()) # 全连接层 for fl in self.fully_layers: # model.add(layers.Dense(fl, activity_regularizer=regularizers.l2(0.01))) model.add(layers.Dense(fl)) model.add(layers.ThresholdedReLU(self.threshold)) model.add(layers.Dropout(self.dropout_p)) # 输出层 model.add(layers.Dense(self.num_of_classes, activation="softmax")) model.compile(optimizer=self.optimizer, loss=self.loss, metrics=["accuracy"]) print("CharCNN model built success") model.summary() return model
def generate_convnet_model(maxwords, vocabsize, units, layercnt, conv_layercnt, embedding_units, conv_filters, conv_window, pool_size, flatten_after_conv, dropout, conv_activation, activation, final_activation, optimizer, loss, metrics): model = models.Sequential() model.add( layers.Embedding(vocabsize, embedding_units, input_length=maxwords)) for i in range(conv_layercnt): model.add( layers.Conv1D(conv_filters, conv_window, activation=conv_activation)) if i < conv_layercnt - 1: # Max pooling until last layer model.add(layers.MaxPool1D(pool_size)) else: # Layer after last conv layer prepares output for dense layers if flatten_after_conv: model.add(layers.Flatten()) else: model.add(layers.GlobalMaxPool1D()) for i in range(layercnt): if dropout is not None: model.add(layers.Dropout(dropout)) model.add(layers.Dense(units, activation=activation)) if dropout is not None: model.add(layers.Dropout(dropout)) model.add(layers.Dense(1, activation=final_activation)) model.compile(optimizer=optimizer, loss=loss, metrics=metrics) return model
def __init__(self, n_classes: int, hparams: Dict): cfg: Big01Cfg = Big01Cfg.scheme(hparams) input = layers.Input(shape=(None, 1)) net = layers.BatchNormalization()(input) for i in range(cfg.num_blocks): channels = 2**i * cfg.block_init_channels net = layers.Conv1D(channels, cfg.receptive_width, padding="same", bias_regularizer=regularizers.l1(0.1))(net) with tf.name_scope(f"block_{i}"): for _ in range(cfg.block_elem): x = net net = layers.Conv1D(channels, cfg.receptive_width, padding='same')(net) net = layers.BatchNormalization()(net) net = layers.Activation('relu')(net) net = layers.Conv1D(channels, cfg.receptive_width, padding='same')(net) net = layers.BatchNormalization()(net) net = layers.Activation('relu')(net) net = ConstMultiplierLayer()(net) net = layers.add([x, net]) net = layers.MaxPool1D(padding='same', pool_size=2)(net) net = layers.Conv1D(n_classes, cfg.receptive_width, padding="same")(net) self.forward_model = models.Model(inputs=[input], outputs=[net]) self.ratio = 2**cfg.num_blocks
def _foraward_model(n_classes, cfg: FunnyFermatCfg) -> models.Model: input = layers.Input(shape=(None, 1)) net = input net = layers.BatchNormalization()(net) for i in range(cfg.num_blocks): channels = cfg.block_init_channels * 2**i net = layers.Conv1D(channels, cfg.receptive_width, padding='same')(net) with K.name_scope(f"block_{i}"): for _ in range(cfg.block_elem): x = net net = layers.Conv1D(channels, cfg.receptive_width, padding='same')(net) net = layers.BatchNormalization()(net) net = layers.Activation('relu')(net) net = layers.Conv1D(channels, cfg.receptive_width, padding='same')(net) net = layers.BatchNormalization()(net) net = layers.Activation('relu')(net) net = ConstMultiplierLayer()(net) net = layers.add([x, net]) net = layers.MaxPool1D(padding="same", pool_size=2)(net) net = layers.Conv1D(n_classes, cfg.receptive_width, padding="same")(net) return models.Model(inputs=[input], outputs=[net])
def test_conv_sequence(): (x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_feature) x_train = sequence.pad_sequences(x_train, maxlen=max_len) x_test = sequence.pad_sequences(x_test, maxlen=max_len) model = Sequential() model.add(layers.Embedding(max_feature, 128, input_length=max_len)) model.add(layers.Conv1D(32, 7, activation='relu')) model.add(layers.MaxPool1D(5)) model.add(layers.Conv1D(32, 7, activation='relu')) model.add(layers.GlobalMaxPool1D()) model.add(layers.Dense(1)) model.summary() model.compile(optimizer=RMSprop(lr=1e-4), loss='binary_crossentropy', metrics=['acc']) history = model.fit(x_train, y_train, epochs=5, batch_size=128, validation_split=0.2) model_plot(history)
def convNetLSTM(dimFeature): # Convnet model filters = 16 kernel_size = 16 """" model = kmodels.Sequential(( # The first conv layer learns `nb_filter` filters (aka kernels), each of size ``(filter_length, nb_input_series)``. # Its output will have shape (None, window_size - filter_length + 1, nb_filter), i.e., for each position in # the input timeseries, the activation of each filter at that position. klayers.Convolution1D(nb_filter=nb_filter, filter_length=filter_length, activation='relu', input_shape=(a, b)), klayers.MaxPooling1D(), # Downsample the output of convolution by 2X. #klayers.Convolution1D(nb_filter=nb_filter, filter_length=filter_length, activation='relu'), #klayers.MaxPooling1D(), klayers.Flatten(), klayers.Dense(1, activation='linear'), # For binary classification, change the activation to 'sigmoid' )) """ model = kmodels.Sequential() #model.add(klayers.Conv1D(filters=filters, kernel_size=kernel_size, activation='relu', input_shape=(1, trainFeatures.shape[2]), data_format="channels_first")) model.add( klayers.Conv1D(filters=filters, kernel_size=kernel_size, activation='relu', input_shape=(1, dimFeature), data_format="channels_first")) model.add(klayers.MaxPool1D()) #model.add(klayers.LSTM(10, dropout=0.25, recurrent_dropout=0.25)) model.add(klayers.LSTM(50, dropout=0.25, recurrent_dropout=0.25)) model.add(klayers.Dense(16, activation="relu")) model.add(klayers.Dense(1, activation="sigmoid")) return model
def pixel_branch(input_tensor): filters = [8, 16, 32, 64, 96, 128] conv0 = L.Conv1D(filters[3], 11, padding='valid')(input_tensor) conv0_a = attention_block_3(conv0, 170, 64) conv0 = L.concatenate([conv0, conv0_a]) conv0 = L.BatchNormalization(axis=-1)(conv0) conv0 = L.advanced_activations.LeakyReLU(alpha=0.2)(conv0) conv3 = L.Conv1D(filters[5], 3, padding='valid')(conv0) conv3 = L.advanced_activations.LeakyReLU(alpha=0.2)(conv3) conv3 = L.MaxPool1D(pool_size=2, padding='valid')(conv3) conv3 = L.Conv1D(filters[5], 3, padding='valid')(conv3) conv3 = L.advanced_activations.LeakyReLU(alpha=0.2)(conv3) conv3 = L.MaxPool1D(pool_size=2, padding='valid')(conv3) conv3 = L.Conv1D(filters[5], 3, padding='valid')(conv3) conv3 = L.advanced_activations.LeakyReLU(alpha=0.2)(conv3) conv3 = L.MaxPool1D(pool_size=2, padding='valid')(conv3) conv3 = L.Flatten()(conv3) return conv3
def mount_conv_model(vb_size, emb_dim, *, max_len=100, num_classes=3, act='relu', weights=None): """ :param max_len: :param weights: :param vb_size: :param emb_dim: :param num_classes: :param act: :return: """ print('cls', num_classes) model = Sequential([ layers.Embedding(vb_size, emb_dim, input_length=max_len), layers.Dropout(0.2), layers.Conv1D(32, 5, activation=act), layers.MaxPool1D(3), layers.Conv1D(32, 5, activation=act), layers.MaxPool1D(3), layers.Conv1D(32, 5, activation=act), # layers.GlobalAveragePooling1D(), # layers.Bidirectional(layers.GRU(16, dropout=0.1, recurrent_dropout=0.5)), # layers.Bidirectional(layers.GRU(16, dropout=0.1, recurrent_dropout=0.5)), # layers.Bidirectional(layers.GRU(16, dropout=0.1, recurrent_dropout=0.5, return_sequences=True)), layers.Flatten(), layers.Dense(32), layers.Dense(num_classes, activation='softmax'), ]) # If any pre-trained weights (glove/w2v), use em if weights is not None: model.layers[0].set_weights([weights]) model.layers[0].trainable = False return model
def __init__(self, strategy): NUM_CLASS = variables.NUM_CLASS ksize = variables.ksize hchn = variables.hchn filters = [32, 64, 128, 256, 512] dilations = [1, 3, 5, 7] self.input_hsi2D = L.Input((ksize, ksize, hchn)) getindicelayer = Lambda( lambda x: x[:, variables.r, variables.r, :, np.newaxis]) self.input_hsi1D = getindicelayer(self.input_hsi2D) # self.first=L.initializers.RandomNormal(mean=0.0,stddev=0.05,seed=None) self.conv0_0 = L.Conv2D(64, (3, 3), padding='same')(self.input_hsi2D) self.conv0_1 = L.BatchNormalization(axis=-1)(self.conv0_0) self.conv0_2 = L.advanced_activations.LeakyReLU(alpha=0.2)( self.conv0_1) self.conv0_3 = L.Conv2D(128, (1, 1), padding='same')(self.conv0_2) self.conv0_4 = L.advanced_activations.LeakyReLU(alpha=0.2)( self.conv0_3) self.conv0_5 = L.MaxPool2D(pool_size=(2, 2), padding='same')(self.conv0_4) self.conv0_6 = L.Flatten()(self.conv0_5) self.conv1_0 = L.Conv1D(64, 3, padding='valid')(self.input_hsi1D) self.conv1_1 = L.BatchNormalization(axis=-1)(self.conv1_0) self.conv1_2 = L.advanced_activations.LeakyReLU(alpha=0.2)( self.conv1_1) self.conv1_3 = L.Conv1D(128, 3, padding='valid')(self.conv1_2) self.conv1_4 = L.advanced_activations.LeakyReLU(alpha=0.2)( self.conv1_3) self.conv1_5 = L.MaxPool1D(pool_size=2, padding='same')(self.conv1_4) self.conv1_6 = L.Flatten()(self.conv1_5) self.conv7 = L.concatenate([self.conv0_6, self.conv1_6]) # self.conv7=self.conv0_6 self.conv8 = L.Dropout(0.5)(self.conv7) self.conv9 = L.Dense(NUM_CLASS, activation='linear', kernel_regularizer=regularizers.l2(0.5))( self.conv8) # activation='softmax')(self.conv8) self.model = K.models.Model([self.input_hsi2D], self.conv9) if strategy == 'Adam': opti = K.optimizers.Adam(lr=0.001) if strategy == 'SGD_005_1e-6_0': opti = K.optimizers.SGD(lr=0.005, momentum=1e-6) if strategy == 'SGD_001_95_1e-5': opti = K.optimizers.SGD(lr=0.001, momentum=0.95, decay=1e-5) if strategy == 'SGD_001_99_1e-3': opti = K.optimizers.SGD(lr=0.001, momentum=0.99, decay=1e-3) kwargs = K.backend.moving_averages self.model.compile( optimizer=opti, loss='categorical_squared_hinge', #'mean_squared_error', # loss='categorical_crossentropy', metrics=['acc'])
def _network4(): optimizer = optimizers.Adadelta(lr=2) model = Sequential() # output 44,6 model.add( layers.Conv1D(filters=30, kernel_size=70, strides=2, activation='relu')) # output 11, 3 if NO_FEATURES == 308: model.add(layers.MaxPool1D(120, 2)) if NO_FEATURES == 300: model.add(layers.MaxPool1D(116, 2)) model.add(layers.Dense(units=3, activation='softmax')) model.add(layers.Dropout(0.5)) model.add(layers.Dense(units=3, activation='relu')) model.add(layers.Softmax()) model.compile(loss=losses.categorical_crossentropy, optimizer=optimizer, metrics=['accuracy']) [favorites_dataset, retweets_dl] = _transform_to_dataloader() x_train, y_train = favorites_dataset[0] x_validation, y_validation = favorites_dataset[1] x_train = np.expand_dims(x_train, axis=2) y_train = np.expand_dims(to_categorical(y_train, num_classes=3), axis=1) x_validation = np.expand_dims(x_validation, axis=2) y_validation = np.expand_dims(to_categorical(y_validation, num_classes=3), axis=1) x = model.fit(x_train, y_train, validation_split=0.3, epochs=EPOCHS, batch_size=BATCH_SIZE, verbose=1, shuffle=True, callbacks=[es])
def build_model(embedding_layer): #model = bidirectional_attention.BidirectionalAttentionFlow(params=params.Params()) # train a 1D convnet with global maxpooling question_input = layers.Input( shape=(MAX_SEQUENCE_LENGTH, ), dtype='int32') # * 2 since doubling the question and passage answer_input = layers.Input( shape=(MAX_SEQUENCE_LENGTH, ), dtype='int32') # * 2 since doubling the question and passage question_embedding = embedding_layer(question_input) answer_embedding = embedding_layer(answer_input) question = layers.Conv1D( filters=200, kernel_size=10, activation='relu', name="question", kernel_regularizer=l2(0.0001), kernel_initializer='he_uniform')(question_embedding) answer = layers.Conv1D(filters=200, kernel_size=10, activation='relu', name="answer", kernel_regularizer=l2(0.0001), kernel_initializer='he_uniform')(answer_embedding) question = layers.MaxPool1D(pool_size=5)(question) answer = layers.MaxPool1D(pool_size=5)(answer) question = layers.Flatten()(question) answer = layers.Flatten()(answer) question = layers.Dropout(0.1)(question) answer = layers.Dropout(0.1)(answer) merged = layers.concatenate([question, answer]) preds = layers.Dense(1, activation='sigmoid', name="activation")(merged) model = models.Model(inputs=[question_input, answer_input], outputs=preds) return model
def Conv_model(train_gen, val_gen, val_steps, float_data_shape): model = Sequential() model.add( layers.Conv1D(32, 5, activation='relu', input_shape=(None, float_data_shape[-1]))) model.add(layers.MaxPool1D(3)) model.add(layers.Conv1D(32, 5, activation='relu')) model.add(layers.MaxPool1D(3)) model.add(layers.Conv1D(32, 5, activation='relu')) model.add(layers.GlobalMaxPool1D()) model.add(layers.Dense(1)) model.compile(optimizer=RMSprop(), loss='mae') history = model.fit_generator(train_gen, steps_per_epoch=500, epochs=5, validation_data=val_gen, validation_steps=val_steps) return history
def pixel_branch(input_tensor): filters = [8, 16, 32, 64, 96, 128] # input_tensor=L.Permute((2,1))(input_tensor) conv0 = L.Conv1D(filters[3], 11, padding='valid')(input_tensor) conv0 = L.BatchNormalization(axis=-1)(conv0) conv0 = L.advanced_activations.LeakyReLU(alpha=0.2)(conv0) conv3 = L.Conv1D(filters[5], 3, padding='valid')(conv0) conv3 = L.advanced_activations.LeakyReLU(alpha=0.2)(conv3) conv3 = L.MaxPool1D(pool_size=2, padding='valid')(conv3) conv3 = L.Flatten()(conv3) # conv3 = L.Dense(192)(conv3) return conv3
def build_M(self): inp = KL.Input(shape=(self.len_data, self.len_segment, 1)) x = inp x = KL.Reshape((self.len_segment, 1))(x) x = KL.Conv1D(128, 17, strides=1, padding='same', name='conv1')(x) x = KL.BatchNormalization(name='bn1')(x) x = KL.LeakyReLU(0.2)(x) x = KL.MaxPool1D(16, name='pool1')(x) x = KL.Conv1D(128, 17, strides=1, padding='same', name='conv2')(x) x = KL.BatchNormalization(name='bn2')(x) x = KL.LeakyReLU(0.2)(x) x = KL.MaxPool1D(16, name='pool2')(x) x = KL.Conv1D(128, 3, padding='same', name='conv3')(x) x = KL.BatchNormalization(name='bn3')(x) x = KL.LeakyReLU(0.2)(x) x = KL.MaxPool1D(2, name='pool3')(x) x = KL.Flatten()(x) out = x # out_deconv = y return Model([inp], [out])
def CreateCONVGRUModel(): model = models.Sequential() model.add(layers.Conv1D(32,5,activation='relu',input_shape=(None, float_data.shape[-1]))) model.add(layers.MaxPool1D(3)) model.add(layers.Conv1D(32,5,activation='relu')) model.add(layers.GRU(32,dropout=0.1,recurrent_dropout=0.5)) model.add(layers.Dense(1)) print(model.summary()) plot_model(model=model, to_file='{}/{}.png'.format(res_path,'conv_gru_model'), show_shapes=True) model.compile(optimizer=optimizers.RMSprop(), loss='mae') return model
def model_1(self): inputs = layers.Input(shape=(self.max_words,), dtype='float32') embedding = layers.Embedding(input_dim=self.vocab_size + 1, output_dim=self.embedding_dim, input_length=self.max_words) embed = embedding(inputs) # 907*100 - 907*256 - cnn1 = layers.Conv1D(256, 3, padding='same', strides=1, activation='relu')(embed) cnn1 = layers.MaxPool1D(pool_size=48)(cnn1) cnn2 = layers.Conv1D(256, 4, padding='same', strides=1, activation='relu')(embed) cnn2 = layers.MaxPool1D(pool_size=47)(cnn2) cnn3 = layers.Conv1D(256, 5, padding='same', strides=1, activation='relu')(embed) cnn3 = layers.MaxPool1D(pool_size=46)(cnn3) cnn_con = layers.concatenate(inputs=[cnn1, cnn2, cnn3], axis=1) flat = layers.Flatten()(cnn_con) drop = layers.Dropout(0.5)(flat) output = layers.Dense(self.class_num, activation='softmax')(drop) model = models.Model(inputs=inputs, outputs=output) print(model.summary()) return model
def muti_output(): vocabulary_size = 50000 num_income_groups=10 posts_input = Input(shape=(None,),dtype='int32',name='posts') embedded_posts = layers.Embedding(256,vocabulary_size)(posts_input) x = layers.Conv1D(128,5,activation='relu')(embedded_posts) x = layers.MaxPool1D(5)(x) x = layers.Conv1D(256,5,activation='relu')(x) x = layers.Conv1D(256,5,activation='relu')(x) x = layers.MaxPool1D(5)(x) x = layers.Conv1D(256,5,activation='relu')(x) x = layers.Conv1D(256,5,activation='relu')(x) x = layers.MaxPool1D(5)(x) x = layers.Dense(128,activation='relu')(x) age_prediction = layers.Dense(1,name='age')(x) income_prediction = layers.Dense(num_income_groups,activation='softmax',name='income')(x) gender_prediction = layers.Dense(1,activation='sigmoid') model = Model(posts_input,[age_prediction,income_prediction,gender_prediction]) model.compile(optimizer='rmsprop',loss=['mse','categorical_crossentropy','binary_crossentropy'],loss_weights=[0.25,1.,10.])#损失加权