def cnn(train_x, train_y): # prepare data # define parameters epochs, batch_size, patience = 10, 64, 1500 n_timesteps, n_features, n_outputs = train_x.shape[1], train_x.shape[ 2], train_y.shape[1] # define model model = Sequential() model.add( Conv1D(filters=32, kernel_size=2, activation='relu', strides=2, input_shape=(n_timesteps, n_features))) model.add(Conv1D(filters=64, kernel_size=2, activation='relu', strides=2)) model.add(Conv1D(filters=128, kernel_size=2, activation='relu', strides=2)) model.add(Flatten()) model.add(Dense(128, activation='relu')) model.add(Reshape([8, 16])) model.add(UpSampling1D(2)) model.add(Conv1D(filters=8, kernel_size=1, activation='relu', strides=1)) model.add(UpSampling1D(2)) model.add(Conv1D(filters=1, kernel_size=9, activation='relu', strides=1)) model.add(Reshape([24, 1])) # model.add(Dense(n_outputs)) model.compile(loss='mse', optimizer='adam') model.summary() # fit network # early_stopping = tf.keras.callbacks.EarlyStopping(patience=patience, mode='min', restore_best_weights= True) model.fit(train_x, train_y, epochs=epochs, batch_size=batch_size) return model
def __call__(self, input_tensor, units=64, kernel_size=2, predict_seq_length=1): out_0, out_1, out_2, x = input_tensor x = UpSampling1D(4)(x) x = Concatenate()([x, out_2]) x = conv_br(x, units * 3, kernel_size, 1, 1) x = UpSampling1D(2)(x) x = Concatenate()([x, out_1]) x = conv_br(x, units * 2, kernel_size, 1, 1) x = UpSampling1D(2)(x) x = Concatenate()([x, out_0]) x = conv_br(x, units, kernel_size, 1, 1) # regression x = Conv1D(1, kernel_size=kernel_size, strides=1, padding="same")(x) out = Activation("sigmoid")(x) out = Lambda(lambda x: 12 * x)(out) out = AveragePooling1D(strides=4)( out ) # Todo: just a tricky way to change the batch*input_seq*1 -> batch_out_seq*1, need a more general way return out
def _decoder(self): feature_maps = [16, 1] kernel_size = [3, 2] encoded_window = Input(shape=(120, 1)) x = Conv1D(feature_maps[1], kernel_size[0], padding="same")(encoded_window) x = LeakyReLU(alpha=0.2)(x) x = UpSampling1D(2)(x) x = Conv1D(feature_maps[0], kernel_size[1], padding="same")(x) x = LeakyReLU(alpha=0.2)(x) x = UpSampling1D(2)(x) x = Conv1D(feature_maps[1], kernel_size[0], padding="same")(x) # "decoded" is the lossy reconstruction of the input decoded = LeakyReLU(alpha=0.2)(x) # create the decoder model decoder = Model(inputs=encoded_window, outputs=decoded) decoder.summary() #decoder.compile(optimizer = 'adam', loss = 'mse', metrics = ["accuracy"]) self.decoder = decoder return decoder
def make_decoder(self, latent_input, n_deconv = 4): ''' Helper function to instatiate the decoder model. Parameters ---------- latent_input : Tensorflow symbolic tensor The symbolic tensor which represents the latent input. n_deconv : int, optional The number of upsampling and convolution layers applied. Returns: -------- Keras model The created encoder model. ''' x = latent_input #x = Dense(self.latent_dim * 2, activation = 'relu') (x) x = Dense(4 * 128, activation = 'relu') (x) x = Reshape((4, 128)) (x) for _ in range(n_deconv - 1): x = UpSampling1D(2) (x) x = Conv1D(64 * 2 ** i, 3, activation = 'relu', padding = 'same') (x) x = UpSampling1D(2) (x) x = Conv1D(22, 5, activation = 'relu', padding = 'same') (x) decoder = Model(latent_input, x, name='decoder') if self.debug: decoder.summary() return decoder
def create_conv_max_pool_autoencoder( input_dimension, optimizer='adam', loss='binary_crossentropy', ) -> Model: input_layer = Input(shape=(input_dimension, 1)) layer = Conv1D(32, 5, activation='relu', padding='same')(input_layer) layer = MaxPooling1D(2, padding='same')(layer) layer = Conv1D(16, 5, activation='relu', padding='same')(layer) layer = MaxPooling1D(2, padding='same')(layer) #encoder = Model(input_layer, layer) layer = UpSampling1D(2)(layer) layer = Conv1D(16, 5, activation='relu', padding='same')(layer) layer = UpSampling1D(2)(layer) layer = Conv1D(32, 5, activation='relu', padding='same')(layer) decoded = Conv1D(1, 1, activation='sigmoid', padding='same')(layer) model = Model(input_layer, decoded) model.compile(optimizer=optimizer, loss=loss) return model
def _build_encoder(self): x = Input(shape=(self.step, self.feature_sz + 1)) # Encoder h = Conv1D(256, 16, padding='same', activation='relu')(x) h = MaxPool1D(5, padding='same')(h) h = Conv1D(128, 8, padding='same', activation='relu')(h) h = MaxPool1D(2, padding='same')(h) h = Flatten()(h) # None, 128 _sz = h.shape[1] h = Dense(self.z_sz)(h) # Decoder out = h out = Dense(_sz, activation='relu')(out) out = Reshape((-1, 128))(out) # Be careful with the shape out = Conv1D(128, 4, padding='same', activation='relu')(out) out = UpSampling1D(2)(out) out = Conv1D(self.feature_sz + 1, 16, padding='same')(out) out = UpSampling1D(5)(out) ae = Model(x, out) encoder = Model(x, h) return ae, encoder
def __init__(self, ch): super(cnn_decoder, self).__init__() self.output_ch = ch self.up = UpSampling1D() self.up_mask = UpSampling1D() self.c1 = Conv1D(32, 3, strides=1, padding='valid') self.c2 = Conv1D(32, 3, strides=1, padding='valid') self.d1 = Dense(ch)
def decoder_skip(iot=False): encoded_shape = (63 + 32, 1) inputs_combined = Input(shape=encoded_shape, name='encoder_input_combined') encoded32_input = Lambda(lambda y: y[:, 32:63 + 32, ])(inputs_combined) encoded64_input = Lambda(lambda y: y[:, 0:32, ])(inputs_combined) AE_encoder_output_32CG = Conv1D(filters=8, kernel_size=3, activation='swish', padding='same')(encoded32_input) AE_encoder_output_32CG = Conv1D(filters=16, kernel_size=3, activation='swish', padding='same')(AE_encoder_output_32CG) AE_encoder_output_32CG_32filters = UpSampling1D(size=2)( AE_encoder_output_32CG) # [118X16] AE_encoder_output_32CG_32filters = Conv1D( filters=16, kernel_size=3, activation='swish', padding='same')(AE_encoder_output_32CG_32filters) # [63X32] AE_encoder_output_32CG_32filters = Conv1D( filters=32, kernel_size=3, activation='swish', padding='valid')(AE_encoder_output_32CG_32filters) # [124X32] encoded64_input = Conv1D(filters=16, kernel_size=7, activation='swish', padding='same')(encoded64_input) encoded64_input = Conv1D(filters=32, kernel_size=3, activation='swish', padding='same')(encoded64_input) encoded64_input = UpSampling1D(size=2)(encoded64_input) # [64X32] encoded64_input = Conv1D(filters=32, kernel_size=3, activation='swish', padding='valid')(encoded64_input) encoded64_output = UpSampling1D(size=2)(encoded64_input) # [124X32] if iot: decoder_shared = Decoder_shared_iot(True, name='decoder_32_64_shared_iot') else: pass # decoder_shared = Decoder_16_32_shared(True, name='decoder_32_64_shared') decoded_shared_32 = decoder_shared(AE_encoder_output_32CG_32filters) decoded_shared_64 = decoder_shared(encoded64_output) Decoder_16_32_skip = Model(inputs_combined, [decoded_shared_32 + decoded_shared_64], name='decoder') return Decoder_16_32_skip
def get_generator(): model = Sequential() model.add(Dense(4*4*16*64, activation='relu', input_dim=LATENT_DIM)) model.add(Reshape((2**10,2**4))) model.add(BatchNormalization(momentum=0.8)) # output (2**11, 2**4) model.add(UpSampling1D()) model.add(Conv1D(2**6, kernel_size=25,strides=4,activation="relu",padding="same")) model.add(BatchNormalization(momentum=0.8)) # model.add(UpSampling1D()) model.add(Conv1D(2**8, kernel_size=25,strides=4,activation="relu",padding="same")) model.add(BatchNormalization(momentum=0.8)) # model.add(UpSampling1D()) model.add(Conv1D(2**7, kernel_size=25,strides=1,activation="relu",padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling1D()) # model.add(UpSampling1D()) model.add(Conv1D(2**6, kernel_size=25,strides=1,activation="relu",padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling1D()) # model.add(UpSampling1D()) model.add(Conv1D(1, kernel_size=25,strides=1,activation="relu",padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling1D()) # model.add(Activation("tanh")) model.summary() return model
def autoencoder(data_in): # Encoder: x = Conv1D(128, kernel_size=3, padding='same', activation='relu')(data_in) x = MaxPooling1D(pool_size=2, padding='same')(x) x = Conv1D(64, kernel_size=3, padding='same', activation='relu')(x) x = MaxPooling1D(pool_size=2, padding='same')(x) x = Conv1D(32, kernel_size=3, padding='same', activation='relu')(x) # Decoder: x = Conv1D(32, kernel_size=3, padding='same', activation='relu')(x) x = UpSampling1D(2)(x) x = Conv1D(64, kernel_size=3, padding='same', activation='relu')(x) x = UpSampling1D(2)(x) data_out = Conv1D(1, kernel_size=2, padding='valid', activation='tanh')(x) return data_out
def autoencoder_model(timesteps, input_dim): inputs = Input(shape=(timesteps, input_dim), name='input') # (,7813,6) activation = 'sigmoid' # sigmoid activation_last = 'sigmoid' # relu maxpoolsize = 2 latent_dim = input_dim # 没有意义,和xyz轴已经不对应了 kernelsize = 8 x = Conv1D(16, kernelsize, activation=activation, padding='same', use_bias=True)(inputs) x = BatchNormalization(axis=-1)(x) x = MaxPooling1D(maxpoolsize, padding='same')(x) x = Conv1D(8, kernelsize, activation=activation, padding='same', use_bias=True, input_shape=(timesteps, input_dim))(x) x = BatchNormalization(axis=-1)(x) x = MaxPooling1D(maxpoolsize, padding='same')(x) x = Conv1D(latent_dim, kernelsize, activation=activation_last, padding='same', use_bias=True, input_shape=(timesteps, input_dim))(x) x = BatchNormalization(axis=-1)(x) encoded = MaxPooling1D(2, padding='same')(x) # (,977,2) x = Conv1D(latent_dim, kernelsize, activation=activation, padding='same', use_bias=True, input_shape=(timesteps, input_dim))(encoded) x = BatchNormalization(axis=-1)(x) x = UpSampling1D(maxpoolsize)(x) x = Conv1D(8, kernelsize, activation=activation, padding='same', use_bias=True, input_shape=(timesteps, input_dim))(x) x = BatchNormalization(axis=-1)(x) x = UpSampling1D(maxpoolsize)(x) x = Conv1D(16, kernelsize, activation=activation, padding='same', use_bias=True, input_shape=(timesteps, input_dim))( x) x = BatchNormalization(axis=-1)(x) x = UpSampling1D(maxpoolsize)(x) # print('AE timesteps', timesteps) # print('AE x.shape', x.shape) n_crop = int(x.shape[1] - timesteps) x = Cropping1D(cropping=(0, n_crop))(x) decoded = Conv1D(input_dim, kernelsize, activation='linear', padding='same', use_bias=False, input_shape=(timesteps, input_dim), name='autoencoderl')(x) autoencoder = Model(inputs, decoded) # autoencoder.compile(optimizer='Adam', loss='mse') # mine # autoencoder.compile(optimizer='rmsprop', loss='mse') # autoencoder.summary() encoder = Model(inputs, encoded, name='encoded_layer') return autoencoder, encoder
def cnn_encoder(n_timesteps, n_features): drop = 0 input_ = Input((n_timesteps, 12)) x = AveragePooling1D(4)(input_) x = Conv1D(32, 3, padding='same', activation='relu', name='encoder1')(x) x = AveragePooling1D(2)(x) x = Conv1D(64, 3, padding='same', activation='relu', name='encoder2')(x) x = AveragePooling1D(2)(x) x = Conv1D(64, 3, padding='same', activation='relu', name='encoder3')(x) x = AveragePooling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='encoder4')(x) x = AveragePooling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='encoder5')(x) x = AveragePooling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='encoder6')(x) x = AveragePooling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='encoder7')(x) # x = AveragePooling1D(2)(x) # x = Conv1D(128, 3, padding = 'same', activation = 'relu', name = 'encoder8')(x) # x = AveragePooling1D(2)(x) # x = Conv1D(128, 3, padding = 'same', activation = 'relu', name = 'encoder9')(x) x = AveragePooling1D(2, name='encoded')(x) # x = Conv1D(128, 3, padding = 'same', activation = 'relu', name = 'decoder10')(x) # x = UpSampling1D(2)(x) # x = Conv1D(128, 3, padding = 'same', activation = 'relu', name = 'decoder9')(x) # x = UpSampling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='decoder8')(x) x = UpSampling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='decoder7')(x) x = UpSampling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='decoder6')(x) x = UpSampling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='decoder5')(x) x = UpSampling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='decoder4')(x) x = UpSampling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='decoder3')(x) x = UpSampling1D(2)(x) x = Conv1D(128, 3, padding='same', activation='relu', name='decoder2')(x) x = UpSampling1D(2)(x) x = Conv1D(64, 3, padding='same', activation='relu', name='decoder1')(x) x = UpSampling1D(2)(x) x = Conv1D(64, 3, padding='same', activation='relu', name='decoder0')(x) x = UpSampling1D(2)(x) x = Conv1D(64, 3, padding='same', name='decoder-1')(x) x = Conv1D(12, 3, activation='sigmoid', padding='same', name='recover')(x) x = Flatten()(x) model = Model(inputs=input_, outputs=x) return model
def network_decoder_v2(x, code_size, sound_shape): n_upsamplings = 3 u_best, f_best, smallest_overshoot = get_smaller_overshoot( code_size, sound_shape[0], n_upsamplings) x = ExpandDims(2)(x) for _ in range(n_upsamplings): x = keras.layers.Conv1D(filters=32, kernel_size=3, strides=1, padding='same', activation='linear')(x) x = keras.layers.BatchNormalization()(x) x = UpSampling1D(size=u_best)(x) x = keras.layers.LeakyReLU()(x) x = keras.layers.Conv1D(filters=f_best, kernel_size=3, strides=1, padding='same', activation='linear')(x) x = keras.layers.Flatten()(x) x = Slice(axis=1, initial=smallest_overshoot, final=None)(x) x = ExpandDims(2)(x) return x
def apply_upsampling(layer, N): n = layer.shape[1] factor = int(N//n) if(factor > 0): return UpSampling1D(factor)(layer) else: return layer
def __init__(self, num_filter, size_filter, sampling_stride, use_regular_uppsampling = False, size = 2, rate = 0.1, l1 = 0.01, l2 = 0.01, use_max_pool = False): super(UpsampleMod_s_res, self).__init__() self.use_max_pool = use_max_pool self.bn1 = LayerNormalization() self.bn2 = LayerNormalization() self.bn3 = LayerNormalization() self.bn4 = LayerNormalization() self.reg1 = L1L2(l1=l1, l2=l2) self.reg2 = L1L2(l1=l1, l2=l2) self.reg3 = L1L2(l1=l1, l2=l2) self.reg4 = L1L2(l1=l1, l2=l2) self.add = Add() self.concat = Concatenate(axis=2) self.act = LeakyReLU() self.conv1 = Conv1D(num_filter, size_filter, padding='same', kernel_regularizer = self.reg1, use_bias=False) self.conv2 = Conv1D(num_filter, size_filter, padding='same', kernel_regularizer = self.reg2, use_bias=False) self.conv3 = Conv1D(num_filter, size_filter, padding='same', kernel_regularizer = self.reg3, use_bias=False) if not self.use_max_pool: self.u_sample = Conv1DTranspose(num_filter, size_filter, strides = sampling_stride, kernel_regularizer = self.reg4, use_bias=False) else: self.u_sample = UpSampling1D(size = size) self.dOut = Dropout(rate)
def upsample_1D(inputs, residual, filters, kernel_size=3): conv = Conv1D(filters, (kernel_size), padding='same')(inputs) residual = Conv1D(filters, (1))(residual) conv = Add()([conv,residual]) conv = Activation('relu')(conv) conv = UpSampling1D()(conv) return conv
def _upsampler(dimension, pool_x, pool_y, pool_z): if dimension == 4: return UpSampling3D(size=(pool_x, pool_y, pool_z)) elif dimension == 3: return UpSampling2D(size=(pool_x, pool_y)) elif dimension == 2: return UpSampling1D(size=pool_x)
def __init__(self, num_layers=4, c1=128, c2=192, c3=256, drop_rate=0.1, num_heads=8): super().__init__() self.input_dense = Dense(c1) self.sigma_ffn = ff_network(c1//4, 2048) self.enc1 = ConvSubLayer(c1, [1, 2]) self.enc2 = ConvSubLayer(c2, [1, 2]) self.enc3 = DecoderLayer(c2, 3, drop_rate, pos_factor=4) self.enc4 = ConvSubLayer(c3, [1, 2]) self.enc5 = DecoderLayer(c3, 4, drop_rate, pos_factor=2) self.pool = AveragePooling1D(2) self.upsample = UpSampling1D(2) self.skip_conv1 = Conv1D(c2, 3, padding='same') self.skip_conv2 = Conv1D(c3, 3, padding='same') self.skip_conv3 = Conv1D(c2*2, 3, padding='same') self.text_style_encoder = Text_Style_Encoder(c2*2, c2*4) self.att_dense = Dense(c2*2) self.att_layers = [DecoderLayer(c2*2, 6, drop_rate) for i in range(num_layers)] self.dec3 = ConvSubLayer(c3, [1, 2]) self.dec2 = ConvSubLayer(c2, [1, 1]) self.dec1 = ConvSubLayer(c1, [1, 1]) self.output_dense = Dense(2) self.pen_lifts_dense = Dense(1, activation='sigmoid')
def build_decoder(self, latent_dim, block_size, k_size): model = Sequential() model.add(Input(shape=(latent_dim, ))) model.add(Dense(units=latent_dim * 2, activation='relu')) model.add(Reshape(target_shape=(latent_dim, latent_dim))) current_len = model.layers[-1].output_shape[1] filters = 256 while current_len < block_size: model.add( Conv1DTranspose(filters, strides=1, kernel_size=k_size, padding='same')) model.add(UpSampling1D(size=2)) model.add(Activation('relu')) filters = filters // 2 current_len = model.layers[-1].output_shape[1] model.add( Conv1DTranspose(1, kernel_size=k_size, padding='same', activation=None)) return model
def auto_encoder_text2(vocab_size=None, filters=None, latentDim=None): input_layer = Input(shape=(vocab_size, 1)) x = input_layer for f in filters: x = Conv1D(f, (3), activation='relu', padding='same')(x) x = MaxPool1D((2), padding='same')(x) volumeSize = K.int_shape(x) x = Flatten(name="bottleneck")(x) latent = Dense(latentDim, activation='tanh', name='encoded')(x) x = Dense(np.prod(volumeSize[1:]))(latent) x = Reshape((volumeSize[1], volumeSize[2]))(x) # decoding architecture for f in filters[::-1]: x = Conv1D(f, (3), activation='relu', padding='causal')(x) x = UpSampling1D((2))(x) output_layer = Conv1D(1, (3), padding='same', activation='sigmoid')(x) # compile the model model = Model(input_layer, output_layer) model.compile(optimizer='adam', loss='mse') return model
def auto_encoder(): data, labs = data_generator_multiple(ndat, nL, sd) data = data.reshape((ndat, nL,1)) print(data[:n_train].shape) #labs = np_utils.to_categorical(labs, 2) #create model input = Input(shape = (nL,1)) x = Conv1D(filters = 2, kernel_size=4, activation='relu', padding = 'same')(input) encoded = MaxPooling1D(pool_size = 2, strides = 2, padding = 'same')(x) # stride is compression ratio x = Conv1D(filters = 2, kernel_size=4, activation='relu', padding = 'same')(encoded) x = UpSampling1D(size = 2)(x) decoded = Conv1D(filters = 1, kernel_size=4, activation='linear', padding = 'same')(x) model = Model(input, decoded) model.compile(optimizer='adam', loss='mse', metrics=['accuracy']) model.fit(data[:n_train], data[:n_train], batch_size = 32,epochs=30) score = model.evaluate(data[n_train:], data[n_train:], verbose=0) print('Test accuracy:', score[1]) layer_outputs = [layer.output for layer in model.layers] activation_model = models.Model(inputs = model.input, outputs = layer_outputs) return model, activation_model
def __init__(self, frame_length, **kwargs): super(Decoder, self).__init__(**kwargs) self.frame_length = frame_length self.upsampling = UpSampling1D(size=frame_length // 64) self.dense1 = Dense(128, activation='softplus') self.dense2 = Dense(64, activation='softplus') self.dense3 = Dense(64, activation='softplus') self.dense4 = Dense(128, activation='relu') self.convtranspose1 = Conv1DTranspose(1, 128, padding='same')
def __init__(self, norm_output, **kwargs): super(Decoder_shared_iot, self).__init__(**kwargs) self.norm_output = norm_output self.upsam1 = UpSampling1D(size=2) self.zeroPadding = ZeroPadding1D(padding=(1, 1)) self.conv3 = Conv1D(filters=64, kernel_size=7, activation='swish', padding='same') self.conv4 = Conv1D(filters=128, kernel_size=7, activation='swish', padding='same') # 20 self.upsam2 = UpSampling1D(size=2) self.conv5 = Conv1D(filters=16, kernel_size=3, activation='swish', padding='same') self.conv6 = Conv1D(filters=32, kernel_size=5, activation='swish', padding='same') self.upsam3 = UpSampling1D(size=2) self.conv7 = Conv1D(filters=32, kernel_size=3, activation='swish', padding='same') # 25 # self.upsam4 = UpSampling1D(size=2) self.conv8 = Conv1D(filters=8, kernel_size=3, activation='swish', padding='same') self.conv9 = Conv1D(filters=2, kernel_size=3, activation='swish', padding='same') self.flatten = Flatten() self.Dense = Dense(2000, name='outputs_decoder')
def HealpyUpSample(self, current_nside, current_indices, p): """ :param p: Boost factor >=1 of the nside -> number of nodes increases by 4^p, note that the layer only checks if the dimensionality of the input is evenly divisible by 4^p and not if the ordering is correct (should be nested ordering) """ layer = UpSampling1D(4**p) new_nside = int(current_nside * 2**p) self.current_indices = self._transform_indices(nside_in=current_nside, nside_out=new_nside, indices=current_indices) self.current_nside = new_nside return layer
def segnet(input_shape, n_classes, width=16, n_filters=16, dropout_rate=0.01, input_dropout_rate=0.01, pool_size=4, l2_lambda=1e-30, n_blocks=5, batch_normalization=False, crf=None, smooth=False, tanh=False): # starting input and dropout X_input=Input(shape=input_shape) X=Dropout(input_dropout_rate)(X_input) # down layers pools=[] for i in range(n_blocks): # double convolutional block for each step for j in range(2 + int(i>1)): # Defaults are activation=None and stride=1 X=Conv1D(filters=n_filters*(2**i), kernel_size=width, padding='same', kernel_initializer='he_normal', activity_regularizer=regularizers.l2(l2_lambda), name='conv'+str(i+1)+'_down'+str(j+1))(X) # optional batchnorm, then ReLU activation and Dropout if batch_normalization: X=BatchNormalization(center=False)(X) X=Activation('tanh' if tanh else 'relu')(X) X=Dropout(dropout_rate)(X) # scrunch down, save layer X=MaxPooling1D(pool_size=pool_size, name='pool'+str(i))(X) pools.append(X) # up layers for i in reversed(range(n_blocks)): # link up with previous filters, expand back up X=concatenate([pools[i], X], axis = -1) X=UpSampling1D(size=pool_size, name='up'+str(i))(X) for j in range(2 + int(i>1)): X=Conv1D(filters=n_filters*(2**i), kernel_size=width, padding='same', kernel_initializer='he_normal', activity_regularizer=regularizers.l2(l2_lambda), name='conv'+str(i)+'_up'+str(j))(X) if batch_normalization: X=BatchNormalization(center=False)(X) X=Activation('tanh' if tanh else 'relu')(X) X=Dropout(dropout_rate)(X) # output layer if crf is not None: # this is a passed tf2CRF object # - must have loss=crf.loss, metrics=[crf.accuracy] (or similar) # at compile-time (train.py or sandbox.ipynb) Y=CRF(n_classes, learn_mode='marginal', test_mode='marginal', activation='softmax')(X) elif smooth: Y=Conv1D(filters=n_classes, kernel_size=256, padding='same', activation='softmax', name='output_layer')(X) else: Y=Dense(n_classes, activation='softmax', name='output_layer')(X) # done! return Model(inputs=X_input, outputs=Y, name='segnet')
def Attention_3(X, filters, base): F1, F2, F3 = filters name_base = base X = res_identity(X, filters, name_base + '/Pre_Residual_id') X_Trunk = Trunk_block(X, filters, name_base + '/Trunk') X = MaxPooling1D(3, strides=2, padding='same', name=name_base + '/Mask/pool_1')(X) X = res_identity(X, filters, name_base + '/Mask/Residual_id_1_Down') X = res_identity(X, filters, name_base + '/Mask/Residual_id_1_Up') temp_name2 = name_base + "/Mask/Interpool_1" # X = Lambda(interpolation, arguments={'ref_tensor': X_Trunk, 'name': temp_name2})(X) X = UpSampling1D(size=X_Trunk.shape[1] // X.shape[1], name=temp_name2)(X) X = BatchNormalization(name=name_base + '/Mask/Interpool_2/bn_1')(X) X = Activation('relu', name=name_base + '/Mask/Interpool_2/relu_1')(X) X = Conv1D(F3, kernel_size=1, strides=1, padding='same', name=name_base + '/Mask/Interpool_2/conv_1', kernel_initializer=glorot_uniform(seed=0))(X) X = BatchNormalization(name=name_base + '/Mask/Interpool_2/bn_2')(X) X = Activation('relu', name=name_base + '/Mask/Interpool_2/relu_2')(X) X = Conv1D(F3, kernel_size=1, strides=1, padding='same', name=name_base + '/Mask/Interpool_2/conv_2', kernel_initializer=glorot_uniform(seed=0))(X) X = Activation('sigmoid', name=name_base + '/Mask/sigmoid')(X) X = Multiply(name=name_base + '/Mutiply')([X_Trunk, X]) X = Add(name=name_base + '/Add')([X_Trunk, X]) X = res_identity(X, filters, name_base + '/Post_Residual_id') return X
def pool(self, tensor): tensor = Conv1D(self.filters, 1, 1, padding="same", activation=self.activation, kernel_regularizer=l2(0.00))(tensor) shape = tensor.shape.as_list() # [batch,lenth,channels] scaler = AveragePooling1D(tensor.shape.as_list()[1])( tensor) # [batch,channels] scaler = UpSampling1D(shape[1])(scaler) return scaler
def get_model(): layers = 4 units = 6 force_trainable = False x = Input(shape=(num_samples, 1)) y = x def block(y, i, s, trainable): s += str(i) u = 2**(units + i) trainable = (trainable or force_trainable) y = Conv1D(u, 15, padding='same', activation='relu', name=s + '_conv1d_1', trainable=trainable)(y) y = BatchNormalization(name=s + '_norm1', trainable=trainable)(y) y = Conv1D(u, 15, padding='same', activation='relu', name=s + '_conv1d_2', trainable=trainable)(y) y = BatchNormalization(name=s + '_norm2', trainable=trainable)(y) return Dropout(0.1)(y) # Encoder for i in range(layers): y = block(y, i, 'enc', i == layers - 1) y = MaxPooling1D(4)(y) y = block(y, layers, 'enc' + str(layers + 100) + '_', True) # Decoder for i in reversed(range(layers)): y = UpSampling1D(4)(y) y = block(y, i, 'dec', i == layers - 1) trainable = (layers == 1 or force_trainable) y = Dense(256, activation='relu', name='final_relu1', trainable=trainable)(y) y = Dense(256, activation='relu', name='final_relu2', trainable=trainable)(y) y = Dense(256, activation='softmax', dtype='float32', name='softmax_final', trainable=trainable)(y) return Model(inputs=x, outputs=y)
def build_model(acti, opti, lr): #2. 모델 inputs = Input(shape=(6, 1), name='input') x = Conv1D(filters=50, kernel_size=4, padding='same', strides=2, activation=acti)(inputs) x = Dropout(0.2)(x) # x = MaxPooling1D(pool_size=2)(x) x = Conv1D(filters=150, kernel_size=2, padding='same', strides=2, activation=acti)(x) x = Dropout(0.3)(x) # x = MaxPooling1D(pool_size=2)(x) x = Conv1D(filters=150, kernel_size=2, padding='same', strides=2, activation=acti)(x) x = Dropout(0.3)(x) x = UpSampling1D(size=2)(x) x = Conv1D(filters=50, kernel_size=2, padding='same', strides=2, activation=acti)(x) x = Dropout(0.2)(x) x = UpSampling1D(size=2)(x) x = Flatten()(x) outputs = Dense(1)(x) model = Model(inputs=inputs, outputs=outputs) model.compile(loss='mse', optimizer=opti(learning_rate=lr), metrics=['mae']) return model
def upsample(filters, apply_dropout=False): initializer = tf.random_normal_initializer(0., 0.02) result = tf.keras.Sequential() result.add(UpSampling1D()) result.add(tf.keras.layers.Conv1D(filters, kernel_size=25,strides=1,padding='same')) result.add(tf.keras.layers.BatchNormalization()) if apply_dropout: result.add(tf.keras.layers.Dropout(0.5)) result.add(tf.keras.layers.ReLU()) return result