def make_discriminator_model(): model = tf.keras.Sequential() model.add(layers.Input(shape=(1, 188))) # model.add(layers.Input(shape=(1, 187))) model.add(layers.Permute((2, 1))) model.add(layers.Conv1D(filters=32, kernel_size=16, strides=1, padding='same')) model.add(layers.LeakyReLU()) model.add(layers.Dropout(0.1)) # COMMENT OUT MAYBE model.add(layers.Conv1D(filters=64, kernel_size=16, strides=1, padding='same')) model.add(layers.LeakyReLU()) model.add(layers.MaxPool1D(pool_size=2)) model.add(layers.Conv1D(filters=128, kernel_size=16, strides=1, padding='same')) model.add(layers.LeakyReLU()) model.add(layers.Dropout(0.1)) # COMMENT OUT MAYBE model.add(layers.Conv1D(filters=256, kernel_size=16, strides=1, padding='same')) model.add(layers.LeakyReLU()) model.add(layers.MaxPool1D(pool_size=2)) model.add(layers.Flatten()) model.add(layers.Dense(1)) return model
def text_cnn(num_classes=10, max_features=20000, maxlen=50, embed_size=128, hid_dim_conv=64, pool_size=32, hid_dim_dense=50, dropout_rate=0.1, act='softmax'): input_tensor = L.Input(shape=(maxlen, ), dtype='int32') emb1 = L.Embedding(max_features, embed_size)(input_tensor) conv1 = L.Conv1D(filters=hid_dim_conv, kernel_size=1, padding='same')(emb1) pool1 = L.MaxPool1D(pool_size=pool_size)(conv1) conv2 = L.Conv1D(filters=hid_dim_conv, kernel_size=2, padding='same')(emb1) pool2 = L.MaxPool1D(pool_size=pool_size)(conv2) conv3 = L.Conv1D(filters=hid_dim_conv, kernel_size=3, padding='same')(emb1) pool3 = L.MaxPool1D(pool_size=pool_size)(conv3) conv4 = L.Conv1D(filters=hid_dim_conv, kernel_size=4, padding='same')(emb1) pool4 = L.MaxPool1D(pool_size=pool_size)(conv4) concat = L.concatenate([conv1, conv2, conv3, conv4], axis=-1) flat = L.Flatten()(concat) dense1 = L.Dense(hid_dim_dense, activation="relu")(flat) drop1 = L.Dropout(dropout_rate)(dense1) output = L.Dense(num_classes, activation=act)(drop1) return Model(inputs=input_tensor, outputs=output)
def cnn1d(shape, seed): np.random.seed(seed) if tf.__version__ == '1.14.0': tf.set_random_seed(seed) else: tf.random.set_seed(seed) inputs = layers.Input(shape) x = layers.Conv1D(64, 3, activation='relu')(inputs) x = layers.Conv1D(64, 3, activation='relu')(x) x = layers.MaxPool1D()(x) x = layers.Conv1D(64, 3, activation='relu')(x) x = layers.Conv1D(64, 3, activation='relu')(x) x = layers.MaxPool1D()(x) x = layers.Flatten()(x) x = layers.Dense(64, activation='relu')(x) x = layers.Dropout(0.2)(x) x = layers.Dense(64, activation='relu')(x) x = layers.Dropout(0.2)(x) x = layers.Dense(64, activation='relu')(x) x = layers.Dropout(0.2)(x) outputs = layers.Dense(10, activation='softmax')(x) model = keras.Model(inputs, outputs, name="fcnn") return model
def build_model(input_layer_shape, l1, l2, lr, embed_in_dim, embed_out_dim): """ We need three separate inputs, one for categorical data that gets an embedding, one for time since data start, and one for the numerical data. """ # Weekly timeseries input input_num = layers.Input(shape=(input_layer_shape, 1)) conv1 = layers.Conv1D(filters=5, kernel_size=7, padding='same', activation='relu')(input_num) pool1 = layers.MaxPool1D()(conv1) conv2 = layers.Conv1D(filters=1, kernel_size=4, padding='same', activation='relu')(pool1) pool2 = layers.MaxPool1D(12)(conv2) dropo = layers.Dropout(0.5)(pool2) feature_layer = layers.Flatten()(dropo) # Time since start input (for dealing with energy efficiency changes) input_time = layers.Input(shape=(1,)) # Region embbeding input input_cat = layers.Input(shape=(1,)) embed_layer = layers.Embedding(embed_in_dim, embed_out_dim)(input_cat) embed_layer = layers.Flatten()(embed_layer) merged_layer = layers.Concatenate()([feature_layer, input_time, embed_layer]) output = layers.Dense(l1, activation='relu')(merged_layer) output = layers.Dense(l2, activation='relu')(output) output = layers.Dense(1, bias_initializer=tf.keras.initializers.constant(4.0))(output) model = keras.models.Model(inputs=[input_num, input_time, input_cat], outputs=[output]) optimizer = tf.keras.optimizers.RMSprop(lr=lr) model.compile(loss='mean_squared_error', optimizer=optimizer, metrics=['mean_absolute_error', 'mean_squared_error']) return model
def baseline_model(): num_out = 6 model = keras.Sequential() model.add(layers.Conv1D(128, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Conv1D(128, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Conv1D(128, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Conv1D(128, 1, input_shape=(26, 1), activation='relu')) model.add(layers.MaxPool1D(2)) model.add(layers.Conv1D(96, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Conv1D(96, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Conv1D(96, 1, input_shape=(26, 1), activation='relu')) model.add(layers.MaxPool1D(2)) model.add(layers.Conv1D(64, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Conv1D(64, 1, input_shape=(26, 1), activation='relu')) model.add(layers.MaxPool1D(2)) model.add(layers.Conv1D(32, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Conv1D(32, 1, input_shape=(26, 1), activation='relu')) model.add(layers.Flatten()) model.add(layers.Dropout(0.2)) model.add(layers.Dense(60, activation='relu')) model.add(layers.Dense(30, activation='relu')) model.add(layers.Dense(16, activation='relu')) model.add(layers.Dense(num_out, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def cnn_base(): model = Sequential(layers=[ layers.Convolution1D(16, kernel_size=5, activation='relu', padding='valid', input_shape=(3000, 1)), layers.Convolution1D( 16, kernel_size=5, activation='relu', padding='valid'), layers.MaxPool1D(pool_size=2), layers.SpatialDropout1D(rate=0.01), layers.Convolution1D( 32, kernel_size=3, activation='relu', padding='valid'), layers.Convolution1D( 32, kernel_size=3, activation='relu', padding='valid'), layers.MaxPool1D(pool_size=2), layers.SpatialDropout1D(rate=0.01), layers.Convolution1D( 32, kernel_size=3, activation='relu', padding='valid'), layers.Convolution1D( 32, kernel_size=3, activation='relu', padding='valid'), layers.MaxPool1D(pool_size=2), layers.Convolution1D( 256, kernel_size=3, activation='relu', padding='valid'), layers.Convolution1D( 256, kernel_size=3, activation='relu', padding='valid'), layers.GlobalMaxPool1D(), layers.Dropout(rate=0.01), layers.Dense(64, activation='relu'), ]) model.compile(optimizer=optimizers.Adam(0.001), loss=losses.sparse_categorical_crossentropy, metrics=['acc']) #,class_model='categorical' return model
def create_cnn_model1(): model = Sequential() # model.add(layers.Flatten(input_shape=(3000, 1))) model.add(layers.Input(shape=(3000, 1))) model.add( layers.Convolution1D(16, kernel_size=5, activation=activations.relu, padding="valid")) model.add( layers.Convolution1D(16, kernel_size=5, activation=activations.relu, padding="valid")) model.add(layers.MaxPool1D(pool_size=2)) model.add( layers.Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")) model.add( layers.Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")) # model.add(layers.Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")) model.add(layers.MaxPool1D(pool_size=2)) model.add(layers.SpatialDropout1D(rate=0.01)) model.add( layers.Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")) model.add( layers.Convolution1D(32, kernel_size=3, activation=activations.relu, padding="valid")) model.add(layers.MaxPool1D(pool_size=2)) model.add(layers.SpatialDropout1D(rate=0.01)) model.add( layers.Convolution1D(256, kernel_size=3, activation=activations.relu, padding="valid")) model.add( layers.Convolution1D(256, kernel_size=3, activation=activations.relu, padding="valid")) model.add(layers.GlobalMaxPool1D()) # model.add(layers.Flatten()) model.add(Dense(64, activation='relu')) model.add(Dense(32, activation='relu')) model.add(Dense(5, activation=activations.softmax)) model.compile(optimizer=optimizers.Adam(0.001), loss=losses.sparse_categorical_crossentropy, metrics=['acc']) # model.summary() return model
def create_cnn_model(num_features, num_classes, loss_func, optimizer="adam", conv_layers=[64, 128], kernel_sizes=[7, 5], dense_layers=[64, 32], dropout=0.2): inp = Input(shape=(num_features, 1), name='input') c = layers.Conv1D(conv_layers[0], kernel_sizes[0], padding='same', activation='relu')(inp) c = layers.MaxPool1D(pool_size=2)(c) for conv_channels, kernel_size in zip(conv_layers[1:], kernel_sizes[1:]): c = layers.Conv1D(conv_channels, kernel_size, padding='same', activation='relu')(c) c = layers.MaxPool1D(pool_size=2)(c) c = layers.Flatten()(c) for hidden_units in dense_layers: c = layers.Dense(hidden_units)(c) if dropout: c = layers.Dropout(dropout)(c) c = layers.Dense(num_classes, activation="softmax", name="prediction")(c) model = Model(inp, c) model.compile(loss=loss_func, optimizer=optimizer, metrics=['accuracy']) return model
def CNN2_LSTM_ATT(in_shape=(200, 4), num_filters=32, batch_norm=True, activation='relu', lstm_units=128, heads=8, key_size=64, dense_units=512, num_out=12): inputs = Input(shape=in_shape) nn = layers.Conv1D(filters=num_filters, kernel_size=19, use_bias=False, padding='same')(inputs) if batch_norm: nn = layers.BatchNormalization()(nn) nn = layers.Activation(activation, name='conv_activation')(nn) nn = layers.MaxPool1D(pool_size=4)(nn) nn = layers.Dropout(0.1)(nn) nn = layers.Conv1D(filters=num_filters, kernel_size=7, use_bias=False, padding='same')(nn) nn = layers.BatchNormalization()(nn) nn = layers.Activation('relu')(nn) nn = layers.MaxPool1D(pool_size=6)(nn) nn = layers.Dropout(0.1)(nn) forward = layers.LSTM(lstm_units//2, return_sequences=True) backward = layers.LSTM(lstm_units//2, activation='relu', return_sequences=True, go_backwards=True) nn = layers.Bidirectional(forward, backward_layer=backward)(nn) nn = layers.Dropout(0.1)(nn) nn, w = MultiHeadAttention(num_heads=heads, d_model=key_size)(nn, nn, nn) nn = layers.Dropout(0.1)(nn) nn = layers.Flatten()(nn) nn = layers.Dense(dense_units, use_bias=False)(nn) nn = layers.BatchNormalization()(nn) nn = layers.Activation('relu')(nn) nn = layers.Dropout(0.5)(nn) outputs = layers.Dense(num_out, activation='sigmoid')(nn) return Model(inputs=inputs, outputs=outputs)
def __init__(self, input_shape, **kwargs): super(MLP, self).__init__(**kwargs) # Add input layer self.input_layer = klayers.Input(input_shape) self.embedding = klayers.Embedding(10000, 7, input_length=200) self.conv_1 = klayers.Conv1D(16, kernel_size=5, name="conv_1", activation="relu") self.pool_1 = klayers.MaxPool1D() self.conv_2 = klayers.Conv1D(128, kernel_size=2, name="conv_2", activation="relu") self.pool_2 = klayers.MaxPool1D( ) # In order to show the second pool output_shape, define it again with different name. self.flatten = klayers.Flatten() self.dense = klayers.Dense(1, activation="sigmoid") # Get output layer with `call` method self.out = self.call(self.input_layer) # Reinitial super(MLP, self).__init__(inputs=self.input_layer, outputs=self.out, **kwargs)
def CNN2(in_shape=(200, 4), num_filters=32, batch_norm=True, activation='relu', heads=8, key_size=64, dense_units=512, num_out=12): inputs = Input(shape=in_shape) nn = layers.Conv1D(filters=num_filters, kernel_size=19, use_bias=False, padding='same')(inputs) if batch_norm: nn = layers.BatchNormalization()(nn) nn = layers.Activation(activation, name='conv_activation')(nn) nn = layers.MaxPool1D(pool_size=4)(nn) nn = layers.Dropout(0.1)(nn) nn = layers.Conv1D(filters=num_filters, kernel_size=7, use_bias=False, padding='same')(nn) nn = layers.BatchNormalization()(nn) nn = layers.Activation('relu')(nn) nn = layers.MaxPool1D(pool_size=6)(nn) nn = layers.Dropout(0.1)(nn) nn = layers.Flatten()(nn) nn = layers.Dense(dense_units, use_bias=False)(nn) nn = layers.BatchNormalization()(nn) nn = layers.Activation('relu')(nn) nn = layers.Dropout(0.5)(nn) outputs = layers.Dense(num_out, activation='sigmoid')(nn) return Model(inputs=inputs, outputs=outputs)
def build_model(hparams): """Convolutional neural network architecture.""" l2_reg = tf.keras.regularizers.l2 return tf.keras.models.Sequential([ # Two convolution + maxpooling blocks layers.Conv1D(filters=16, kernel_size=5, activation=tf.nn.relu, kernel_regularizer=l2_reg(hparams.l2)), layers.MaxPool1D(pool_size=3, strides=1), layers.Conv1D(filters=16, kernel_size=3, activation=tf.nn.relu, kernel_regularizer=l2_reg(hparams.l2)), layers.MaxPool1D(pool_size=3, strides=1), # Flatten the input volume layers.Flatten(), # Two fully connected layers, each followed by a dropout layer layers.Dense(units=16, activation=tf.nn.relu, kernel_regularizer=l2_reg(hparams.l2)), layers.Dropout(rate=0.3), layers.Dense(units=16, activation=tf.nn.relu, kernel_regularizer=l2_reg(hparams.l2)), layers.Dropout(rate=0.3), # Output layer with softmax activation layers.Dense(units=len(_ALLOWED_BASES), activation='softmax') ])
def call(self, inputs, pos_inputs, training): word_embed = tf.nn.embedding_lookup(self.embeddings, inputs) pos_embed = tf.nn.embedding_lookup(self.embeddings, pos_inputs) tokens_mask = tf.cast(inputs != 0, tf.float32) x = tf.concat([word_embed, pos_embed], axis=2) x = self.drop(x) # print(inputs.shape) out1 = tf.nn.tanh( self.conv1(x)) # bsz x (filter_size - seq_len + 1) x n_filters out2 = tf.nn.tanh(self.conv2(x)) out3 = tf.nn.tanh(self.conv3(x)) # bsz x 1 x n_filters - before squeeze # bsz x n_filters - after squeeze pool1 = tf.squeeze(layers.MaxPool1D(out1.shape[1])(out1)) pool2 = tf.squeeze(layers.MaxPool1D(out2.shape[1])(out2)) pool3 = tf.squeeze(layers.MaxPool1D(out3.shape[1])(out3)) # bsz x n_filters * (number of different conv2d layers) x = tf.concat([pool1, pool2, pool3], axis=1) x = self.dropout(x) x = self.linear(x) return {'logits': x}
def __init__(self): super(EventDetector, self).__init__() self.conv1 = layers.Conv1D( 64, 3, activation='relu', kernel_regularizer=keras.regularizers.L2(0.1)) self.bn1 = layers.BatchNormalization() self.mp1 = layers.MaxPool1D(3) self.conv2 = layers.Conv1D( 128, 3, activation='relu', kernel_regularizer=keras.regularizers.L2(0.1)) self.bn2 = layers.BatchNormalization() self.mp2 = layers.MaxPool1D(3) self.flatten = layers.Flatten() self.dropout = layers.Dropout(0.15) self.d1 = layers.Dense(64, activation='relu', kernel_regularizer=keras.regularizers.L2(0.1)) self.d2 = layers.Dense(32, activation='relu', kernel_regularizer=keras.regularizers.L2(0.1)) self.d3 = layers.Dense(3, activation='relu', kernel_regularizer=keras.regularizers.L2(0.1)) self.softmax = layers.Softmax()
def DeepAnt_Model(): model_m = keras.Sequential([ layers.Input(shape=(X.shape[1], X.shape[2])), #layers.BatchNormalization(), layers.Conv1D(filters=32, kernel_size=7, padding="same", strides=1, activation="relu"), #layers.Dropout(rate=0.2), layers.MaxPool1D(pool_size=2), layers.Conv1D(filters=32, kernel_size=7, padding="same", strides=1, activation="relu"), layers.MaxPool1D(pool_size=2), layers.Flatten(), layers.Dropout(rate=0.25), layers.Dense(128, activation='relu'), layers.Dropout(rate=0.45), layers.Dense(window_size - 2 * margin, activation='relu'), ]) model_m.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0005), loss="mse") model_m.summary() return model_m
def __init__(self, hparams): super(AttentionNET, self).__init__() self.downres0 = DownResLayer( channels_out=6, dropout_rate=0.2, kernel_size=6, first_layer=True, regularization=tf.keras.regularizers.l2(0.0005)) self.max_pool0 = layers.MaxPool1D(pool_size=2, strides=2) self.attention_layer = AttentionLayer( channels_out=6, filters_per_head=4, num_attention_heads=1, use_positional_encoding=False, regularization=tf.keras.regularizers.l2(0.0005), kernel_size=6, ) self.max_pool1 = layers.MaxPool1D(pool_size=2, strides=2) self.downres1 = DownResLayer( channels_out=8, dropout_rate=0.2, kernel_size=6, regularization=tf.keras.regularizers.l2(0.0005)) self.final_pool = layers.MaxPool1D(pool_size=2, strides=2) self.dense_dropout = layers.Dropout(0.5) self.dense_output = layers.Dense(2, activation="softmax")
def build(self, input_shape): self.conv1 = layers.Conv1D(filters=8, kernel_size=3, padding='same', activation='relu') self.conv2 = layers.Conv1D(filters=16, kernel_size=3, padding='same', activation='relu') self.conv3 = layers.Conv1D(filters=32, kernel_size=3, padding='same', activation='relu') self.conv4 = layers.Conv1D(filters=64, kernel_size=3, padding='same', activation='relu') self.pool1 = layers.MaxPool1D(pool_size=2, strides=2) self.pool2 = layers.MaxPool1D(pool_size=2, strides=2) self.pool3 = layers.MaxPool1D(pool_size=2, strides=2) self.pool4 = layers.MaxPool1D(pool_size=2, strides=2) self.global_avg = layers.GlobalAveragePooling1D() self.dense1 = layers.Dense(32, activation='relu') self.dropout = layers.Dropout(self.rate) self.dense2 = layers.Dense(1, activation='linear')
def conv_net(self, word_pos): sent_len = word_pos.shape[1] conv_output = self.conv1layer(word_pos) conv_output2 = self.conv2layer(word_pos) pool_output = layers.MaxPool1D(pool_size=sent_len - 1)(conv_output) pool_output2 = layers.MaxPool1D(pool_size=sent_len - 2)(conv_output2) pool_concat = tf.concat([pool_output, pool_output2], axis=2) flatten_output = self.flatten(pool_concat) return flatten_output
def build(self,input_shape): self.embedding = layers.Embedding(MAX_WORDS,7,input_length=MAX_LEN) self.conv_1 = layers.Conv1D(16,kernel_size=5,name="conv_1",activation="relu") self.pool_1 = layers.MaxPool1D(name="pool_1") self.conv_2 = layers.Conv1D(128,kernel_size=2,name="conv_2",activation="relu") self.pool_2 = layers.MaxPool1D(name="pool_2") self.flatten = layers.Flatten() self.dense = layers.Dense(1,activation="sigmoid") super(CnnModel, self).build(input_shape)
def create_model(): model = models.Sequential() model.add(layers.Embedding(MAX_WORDS, 7, input_length=MAX_LEN)) model.add(layers.Conv1D(filters=64, kernel_size=5, activation="relu")) model.add(layers.MaxPool1D(2)) model.add(layers.Conv1D(filters=32, kernel_size=3, activation="relu")) model.add(layers.MaxPool1D(2)) model.add(layers.Flatten()) model.add(layers.Dense(CAT_NUM, activation="softmax")) return model
def CNN1D(classes): input = layers.Input(shape=(250, 1)) x = layers.Conv1D(128, 13, padding='same', activation='relu')(input) x = layers.BatchNormalization()(x) x = layers.Conv1D(128, 13, padding='same', activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.MaxPool1D(pool_size=2)(x) x = layers.Conv1D(256, 7, padding='same', activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Conv1D(256, 7, padding='same', activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.MaxPool1D(pool_size=2)(x) x = layers.Conv1D(512, 5, padding='same', activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Conv1D(512, 5, padding='same', activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Conv1D(512, 5, padding='same', activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.Conv1D(512, 5, padding='same', activation='relu')(x) x = layers.BatchNormalization()(x) x = layers.MaxPool1D(pool_size=2)(x) # x = layers.Conv1D(256,1,padding='same',activation='relu')(x) # x = layers.Conv1D(512,3,padding='same',activation='relu')(x) # x = layers.BatchNormalization()(x) # x = layers.Conv1D(512,3,padding='same',activation='relu')(x) # x = layers.BatchNormalization()(x) # x = layers.MaxPool1D(pool_size=2)(x) # x = layers.Conv1D(512,3,padding='same',activation='relu')(x) # x = layers.BatchNormalization()(x) # x = layers.Conv1D(512,3,padding='same',activation='relu')(x) # x = layers.BatchNormalization()(x) # x = layers.MaxPool1D(pool_size=2)(x) # x = layers.Conv1D(512,3,padding='same',activation='relu')(x) # x = layers.BatchNormalization()(x) # x = layers.Conv1D(512,3,padding='same',activation='relu')(x) # x = layers.BatchNormalization()(x) # x = layers.MaxPool1D(pool_size=2)(x) x = layers.Flatten()(x) x = layers.Dense(units=128)(x) x = layers.Dropout(0.5)(x) x = layers.Dense(units=64)(x) x = layers.Dropout(0.5)(x) output = layers.Dense(units=classes, activation='softmax')(x) CNN = tf.keras.Model(input, output, name='CNN1D') return CNN
def hist_encoder(conv_input): conv = layers.Reshape((n_steps_in, 1))(conv_input) conv = layers.Conv1D(4, [3], activation=activation, padding='same')(conv) conv = layers.MaxPool1D(pool_size=2)(conv) conv = layers.Conv1D(1, [7], activation=activation, padding='same')(conv) conv = layers.MaxPool1D(pool_size=2)(conv) conv = layers.Flatten()(conv) conv = layers.Dense(n_steps_out)(conv) conv = layers.Reshape((n_steps_out, 1))(conv) return conv
def make_conv_layers(name: str): """Input -> Conv -> MaxPool -> Conv -> MaxPool -> Flatten""" model = models.Sequential(name=name) model.add(layers.Embedding(voc_size, dim, input_length=maxlen)) model.add(layers.Conv1D(dim * 2, kernel_size, activation='relu')) model.add(layers.MaxPool1D(2)) model.add(layers.Conv1D(dim * 2, 2, activation='relu')) model.add(layers.MaxPool1D(feature_size)) model.add(layers.Flatten()) model.add(layers.GaussianNoise(0.1 / dim)) model.add(layers.Dropout(0.5)) model.add(layers.Dense(dim)) return model
def create_convolution_model( input_size: Tuple[int, ...] ) -> Tuple[Union[tf.Tensor, List[tf.Tensor]], tf.Tensor]: """ Creates a convolutional neural network with kernel size 3 and max pooling after every convolution. The output layer and activation are omitted, as they are added by the wrapper function. """ input_cont = keras.Input((2, )) input_conv = keras.Input(input_size) conv1 = layers.Conv1D(128, kernel_size=10, strides=10, activation='relu')(input_conv) pool1 = layers.MaxPool1D(2)(conv1) bn1 = layers.BatchNormalization()(pool1) conv2 = layers.Conv1D(256, kernel_size=3, activation='relu', padding='same')(bn1) pool2 = layers.MaxPool1D(2)(conv2) bn2 = layers.BatchNormalization()(pool2) conv3 = layers.Conv1D(512, kernel_size=3, activation='relu', padding='same')(bn2) pool3 = layers.MaxPool1D(2)(conv3) bn3 = layers.BatchNormalization()(pool3) conv4 = layers.Conv1D(1024, kernel_size=3, activation='relu', padding='same')(bn3) pool4 = layers.MaxPool1D(2)(conv4) bn4 = layers.BatchNormalization()(pool4) flatten = layers.Flatten()(bn4) conc = layers.Concatenate()([input_cont, flatten]) dense1 = layers.Dense(1024, activation='relu')(conc) drop1 = layers.Dropout(0.2)(dense1) dense2 = layers.Dense(1024, activation='relu')(drop1) drop2 = layers.Dropout(0.2)(dense2) out = layers.Dense(512, activation='relu')(drop2) # Omit final layer as it is added by the wrapper function # out = layers.Dense(1, activation='sigmoid')(dense4) return [input_cont, input_conv], out
def build_model(hp): model = keras.Sequential() model.add(layers.Conv1D(filters=hp.Int('units_1', min_value=32, max_value=512, step=32), kernel_size=hp.Int('kernel_1',min_value=2,max_value=3), input_shape=input_shape, padding='same')) model.add(layers.Conv1D(filters=hp.Int('units_2', min_value=32, max_value=512, step=32), kernel_size=hp.Int('kernel_2',min_value=2,max_value=3), activation='relu', padding='same')) model.add(layers.MaxPool1D(hp.Int('pool_1',min_value=2,max_value=3))) model.add(layers.Dropout(0.3)) model.add(layers.Conv1D(filters=hp.Int('units_3', min_value=32, max_value=512, step=32), kernel_size=hp.Int('kernel_3',min_value=2,max_value=3), activation='relu', padding='same')) model.add(layers.MaxPool1D(hp.Int('pool_2',min_value=2,max_value=3))) model.add(layers.Dropout(0.5)) model.add(layers.Flatten()) model.add(layers.Dense(units=hp.Int('units_4', min_value=32, max_value=512, step=32), activation='relu')) model.add(layers.Dense(units=hp.Int('units_5', min_value=32, max_value=512, step=32), activation='relu')) model.add(layers.Dense(units=hp.Int('units_6', min_value=32, max_value=512, step=32), activation='relu')) model.add(layers.Dense(1, activation='sigmoid')) model.compile( optimizer=keras.optimizers.Adam( hp.Choice('learning_rate', values=[1e-2, 1e-3, 1e-4])), loss='binary_crossentropy', metrics=['acc']) return model
def build(self, input_shape): self.embedding = layers.Embedding(MAX_WORDS, 7, input_length=MAX_LEN) self.conv1 = layers.Conv1D(16, kernel_size=5, name='conv_1', activation='relu') self.pool1 = layers.MaxPool1D(name='maxpool_1') self.conv2 = layers.Conv1D(128, kernel_size=2, name='conv_2', activation='relu') self.pool2 = layers.MaxPool1D(name='maxpool_2') self.flatten = layers.Flatten() self.dense = layers.Dense(1, activation='sigmoid') super(CnnModel, self).build(input_shape)
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 __init__(self, hparams): super(BaseNET2, self).__init__() self.expand = layers.Conv1D( filters=4, kernel_size=5, padding="same" ) self.downres0 = DownResLayer( channels_out=6, dropout_rate=0.0, kernel_size=6, first_layer=False, regularization=tf.keras.regularizers.l2(0.0005) ) self.conv3 = layers.Conv1D( filters=8, kernel_size=6, strides=1, padding="same", activation="relu", kernel_regularizer=tf.keras.regularizers.l2(0.0005) ) self.maxp = layers.MaxPool1D(2,2) self.flat = layers.Flatten() self.drop1 = layers.Dropout(0.5) self.dense_out = layers.Dense(2, activation="softmax")
def Conv1D(): channels = None input_shape = spectrogram_dim model = keras.models.Sequential([ layers.Conv1D(256, 3, activation="relu"), layers.MaxPool1D(2), layers.Conv1D(256, 3, activation="relu"), layers.MaxPool1D(2), layers.Conv1D(256, 3, activation="relu"), layers.MaxPool1D(2), layers.Conv1D(256, 3, activation="relu"), layers.Flatten(), layers.Dense(len(birdcodes.bird_code), activation="sigmoid") ]) return model, input_shape, channels
def get_hotel_model(): embedding_dim = 16 units = 76 vocab_size = 49536 input_length = 350 model = tf.keras.Sequential([ layers.Embedding(vocab_size, embedding_dim, input_length=input_length), layers.Bidirectional(layers.LSTM(units, return_sequences=True)), # L.LSTM(units,return_sequences=True), layers.Conv1D(64, 3), layers.MaxPool1D(), layers.Flatten(), layers.Dropout(0.5), layers.Dense(128, activation="relu"), layers.Dropout(0.5), layers.Dense(64, activation="relu"), layers.Dropout(0.5), layers.Dense(5, activation="softmax"), ]) model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) # model.summary() return model