def build_classifier(dsvdd): filter_size = 3 n_filters_factor = 2 dsvdd.trainable = False c_x = keras.Input(shape=dsvdd.input.shape[1:], name='c_x') y = dsvdd(c_x) y = layers.Lambda(lambda x: keras.backend.expand_dims(x, -1))(y) y = layers.Conv1D(4 * n_filters_factor, filter_size, padding='same')(y) y = layers.LeakyReLU(.3)(y) y = layers.AveragePooling1D(padding='same')(y) y = layers.Conv1D(8 * n_filters_factor, filter_size, padding='same')(y) y = layers.LeakyReLU(.3)(y) y = layers.AveragePooling1D(padding='same')(y) y = layers.Conv1D(12 * n_filters_factor, filter_size, padding='same')(y) y = layers.LeakyReLU(.3)(y) y = layers.AveragePooling1D(padding='same')(y) y = layers.Conv1D(24 * n_filters_factor, filter_size, padding='same')(y) y = layers.LeakyReLU(.3)(y) y = layers.AveragePooling1D(padding='same')(y) y = layers.Conv1D(24 * n_filters_factor, filter_size, padding='same')(y) y = layers.LeakyReLU(.3)(y) y = layers.AveragePooling1D(padding='same')(y) y = layers.Flatten()(y) y = layers.Dense(1)(y) # relu? y = layers.Activation(keras.activations.sigmoid)(y) cls = keras.Model(inputs=c_x, outputs=y, name='cls') return cls
def __init__(self, num_classes): """ Initializes TimeCNNBlock :param num_classes: number of classes in input """ super(TimeCNNBlock, self).__init__() self.conv1_valid = layers.Conv1D(filters=6, kernel_size=7, padding='valid', activation='sigmoid') self.conv1_same = layers.Conv1D(filters=6, kernel_size=7, padding='same', activation='sigmoid') self.AvePool1 = layers.AveragePooling1D(pool_size=3) self.conv2_valid = layers.Conv1D(filters=12, kernel_size=7, padding='valid', activation='sigmoid') self.conv2_same = layers.Conv1D(filters=12, kernel_size=7, padding='same', activation='sigmoid') self.AvePool2 = layers.AveragePooling1D(pool_size=3) self.flatten = layers.Flatten() self.out = layers.Dense(units=num_classes, activation='sigmoid')
def define_1DCNN(nchan, L, Fs): model = tf.keras.Sequential() model.add(layers.InputLayer((L, nchan), batch_size=None)) model.add(layers.Conv1D(filters=30, kernel_size=64, padding="causal")) model.add(layers.LayerNormalization()) model.add(layers.Activation('elu')) model.add(layers.AveragePooling1D(pool_size=(2))) model.add(layers.Dropout(0.2)) model.add(layers.Conv1D(filters=15, kernel_size=32, padding="causal")) model.add(layers.LayerNormalization()) model.add(layers.Activation('elu')) model.add(layers.AveragePooling1D(pool_size=(2))) model.add(layers.Dropout(0.3)) model.add(layers.Conv1D(filters=10, kernel_size=16, padding="causal")) model.add(layers.LayerNormalization()) model.add(layers.Activation('elu')) model.add(layers.AveragePooling1D(pool_size=(2))) model.add(layers.Dropout(0.4)) model.add(layers.Flatten()) model.add(layers.Dense(15, activation="tanh")) model.add(layers.LayerNormalization()) model.add(layers.Dense(3)) model.add(layers.Activation('softmax')) model.compile(loss=losses.CategoricalCrossentropy(), optimizer=optimizers.Adam(), metrics=['accuracy'], run_eagerly=False) return model
def create_discriminator(input_shape): inp = keras.Input(input_shape) out_map1 = discriminator_block(inp) pool1 = layers.AveragePooling1D()(inp) out_map2 = discriminator_block(pool1) pool2 = layers.AveragePooling1D()(pool1) out_map3 = discriminator_block(pool2) return keras.Model(inp, [out_map1, out_map2, out_map3])
def __init__(self, channels, kernel_size, initial_activation=None, normalization=None, downsample_rate=2, regularization=None): super(DownResBlock, self).__init__() self.out_channels = channels self.in_act = initial_activation self.norm0 = None self.norm1 = None if normalization is "layer": self.norm0 = layers.LayerNormalization(axis=[2]) self.norm1 = layers.LayerNormalization(axis=[2]) elif normalization is "batch": self.norm0 = layers.BatchNormalization() self.norm1 = layers.BatchNormalization() self.conv1 = layers.Conv1D(filters=channels, kernel_size=kernel_size, padding="same", kernel_regularizer=regularization) self.conv1act = layers.LeakyReLU() self.conv2 = layers.Conv1D(filters=channels, kernel_size=kernel_size, padding="same", strides=downsample_rate, kernel_regularizer=regularization) #self.pool = layers.AveragePooling1D(pool_size=downsample_rate, strides=downsample_rate, padding="same") self.shortcut_conv = layers.Conv1D(filters=channels, kernel_size=1, padding="same", kernel_regularizer=regularization) self.shortcut_pool = layers.AveragePooling1D(pool_size=downsample_rate, strides=downsample_rate, padding="same")
def __init__( self, **kwargs ): #vocab_size,embed_dim,context_size,stride,drop_rate,fc_dim,num_class,embedding_path=None): super(swem_hier, self).__init__() if kwargs["embedding_path"] is None: embedding_initializer = "uniform" elif type(kwargs["embedding_path"]) == str: embedding_initializer = np.load(embedding_path).astype(np.float32) embedding_initializer = tf.keras.initializers.Constant( embedding_initializer) print("Initialize from", embedding_path) elif type(kwargs["embedding_path"]) == np.ndarray: embedding_initializer = tf.keras.initializers.Constant( kwargs["embedding_path"]) print("Initialize from a numpy array") if kwargs["is_mlp"]: self.embedding = keras.Sequential([ layers.Embedding(kwargs["vocab_size"], kwargs["embed_dim"], embedding_initializer, mask_zero=True), layers.Dense(kwargs["embed_dim"], "relu") ]) else: self.embedding = layers.Embedding(kwargs["vocab_size"], kwargs["embed_dim"], embedding_initializer, mask_zero=True) self.hier = layers.AveragePooling1D(pool_size=kwargs["context_size"], strides=kwargs["stride"]) self.drop = layers.Dropout(kwargs["drop_rate"]) self.fc = layers.Dense(kwargs["fc_dim"], "relu") self.drop2 = layers.Dropout(kwargs["drop_rate"]) self.classifier = layers.Dense(kwargs["num_class"])
def build_model_2(time_steps): # 卷积层过多的激活函数效果反而一般 model = tf.keras.models.Sequential() # 每次输入一个月的数据量 # 输入数据5个通道是指四个价格,加一个交易量 # 时间步数太短,卷积核尺寸开始小,然后增大,不能一直用1,否则卷积无法查看相邻的关系 # model.add(layers.Conv1D(16, 2, padding='same', activation='tanh', strides=1, input_shape=(time_steps, 5))) # model.add(layers.Conv1D(32, 2, padding='same', activation='tanh', strides=1)) model.add( layers.Conv1D(64, 2, padding='same', activation='tanh', strides=1)) model.add( layers.Conv1D(128, 2, padding='same', activation='tanh', strides=1)) model.add(layers.AveragePooling1D(2)) # 卷积核数量作为需要标准化的轴,每个卷积核使用不用beta和gamma # 在这里用BN层效果一般,可能是股价的均值,方差不稳定 # model.add(layers.BatchNormalization(axis=2)) # activation = 'relu' CuDNNGRU,CuDNNLSTM的激活函数貌似是内定的 # 单次直接输入多个日期,貌似不需要时间记忆,先去掉,把神经网络加深。。。。 # return_sequences 决定返回单个 hidden state值还是返回全部time steps 的 hidden state值 # 这里第一个不加return sequence ,不能连7续用两个gru,输出没有time steps形状不匹配 model.add(CuDNNGRU(128, return_sequences=True)) # model.add(CuDNNGRU(256, return_sequences=True)) model.add(layers.Flatten()) model.add(layers.Dropout(0.4)) model.add(layers.Dense(128, activation='relu')) model.add(layers.Dense(5, activation='tanh')) # 最终输出层用tanh收敛好于relu,并且预测效果远好于relu,可能是输出-1,1,对应输入范围广的原因 model.compile(optimizer='adam', loss='mse') return model
def __init__(self, kernel: tuple, stride=2, padding=0, scope='APOOL'): super(AvgPool, self).__init__(scope) dim = len(kernel) is_global = True if kernel[-1]<0 else False if is_global: assert padding == 0 if dim == 1: if is_global: self.pool = _AP(1) else: self.pool = layers.AveragePooling1D(kernel, stride) pad_fn = layers.ZeroPadding1D elif dim == 2: if is_global: self.pool = _AP(2) else: self.pool = layers.AveragePooling2D(kernel, stride) pad_fn = layers.ZeroPadding2D elif dim == 3: if is_global: self.pool = _AP(3) else: self.pool = layers.AveragePooling3D(kernel, stride) pad_fn = layers.ZeroPadding3D else: raise Exception('NEBULAE ERROR ⨷ %d-d pooling is not supported.' % dim) if isinstance(padding, int): padding = dim * [[padding, padding]] elif isinstance(padding, (list, tuple)): padding = [(padding[2*d], padding[2*d+1]) for d in range(dim-1, -1, -1)] self.pad = pad_fn(padding)
def build_model_3(time_steps): model = tf.keras.models.Sequential() model.add( layers.Conv1D(64, 2, padding='same', strides=1, activation='relu', kernel_initializer='uniform', input_shape=(time_steps, 5))) # model.add(layers.Conv1D(32, 2, padding='same', strides=1,activation='relu',kernel_initializer='uniform')) # model.add(layers.Conv1D(64, 2, padding='same', strides=1,activation='relu',kernel_initializer='uniform')) model.add( layers.Conv1D(128, 2, padding='same', strides=1, activation='relu', kernel_initializer='uniform')) model.add(layers.AveragePooling1D(2)) model.add(CuDNNGRU(128, return_sequences=True)) model.add(layers.Flatten()) model.add(layers.Dropout(0.4)) model.add(layers.Dense(128, activation='relu')) model.add(layers.Dense(128, activation='relu')) model.add(layers.Dense(5, activation='tanh')) # 优化算法使用adam,短周期收敛较慢 model.compile(optimizer='adam', loss='mse') return model
def fit_model(trainX, trainy, epochs=50, batch_size=32, verbose=1): n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[ 2], trainy.shape[1] norm_layer = layers.experimental.preprocessing.Normalization() norm_layer.adapt(trainX) model = models.Sequential([ layers.Input(shape=(n_timesteps, n_features)), norm_layer, layers.AveragePooling1D(), layers.Conv1D(filters=3, kernel_size=200, activation='relu'), layers.MaxPooling1D(), layers.Conv1D(filters=6, kernel_size=200, activation='relu'), layers.GlobalMaxPooling1D(), layers.Dense(n_outputs, activation='softmax'), ]) model.summary() opt = tf.keras.optimizers.Adam(learning_rate=0.001) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) # fit network callback = tf.keras.callbacks.LearningRateScheduler(scheduler) model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose, callbacks=[callback]) return model
def __init__(self, name="discrete_10000_ec_0"): super(discrete_10000_ec_0, self).__init__(name=name) self.decider = keras.Sequential() self.decider.add(layers.Conv1D(6, 2, strides=1, padding='same')) self.decider.add(layers.LeakyReLU()) self.decider.add(layers.Conv1D(7, 4, strides=1, padding='same')) self.decider.add(layers.LeakyReLU()) self.decider.add(layers.Conv1D(8, 6, strides=1, padding='same')) self.counters = [] for i in range(1, 8): model = keras.Sequential() model.add(layers.Conv1D(8, 2**i, 2**(i - 1), padding='same')) model.add(layers.LeakyReLU()) pool_size = (10000 + 2**(i - 1) - 1) // 2**(i - 1) model.add(layers.AveragePooling1D(pool_size=pool_size)) model.add(layers.LeakyReLU()) self.counters.append(model) self.conv_down = layers.Dense(1) self.weighters = keras.Sequential() self.weighters.add(layers.BatchNormalization()) self.weighters.add(layers.Dense(21)) self.weighters.add(layers.Activation(layers.LeakyReLU())) self.weighters.add(layers.Dense(14)) self.weighters.add(layers.Activation(layers.LeakyReLU())) self.weighters.add(layers.Dense(7)) self.weighters.add(layers.Activation('softmax')) self.out_layer = layers.Dense(1)
def build(self, input_shape): assert len(input_shape) == 2 assert len(input_shape[0]) == 3 and len(input_shape[1]) == 3 # Assertion for high inputs assert input_shape[0][1] >= self.mor_kernel_size # Assertion for low inputs assert input_shape[0][1] // input_shape[1][1] == self.beta # channel last for Tensorflow assert K.image_data_format() == 'channels_last' self.conv_high_high = NCausalConv1D( filters=self.high_channels, kernel_size=self.mor_kernel_size, dilation_rate=self.mor_dilation, activation=tf.nn.leaky_relu, ) self.conv_low_high = NCausalConv1D( filters=self.high_channels, kernel_size=self.rhy_kernel_size, dilation_rate=self.rhy_dilation, activation=tf.nn.leaky_relu, ) self.conv_high_low = NCausalConv1D( filters=self.low_channels, kernel_size=self.mor_kernel_size, dilation_rate=self.mor_dilation, activation=tf.nn.leaky_relu, ) self.conv_low_low = NCausalConv1D( filters=self.low_channels, kernel_size=self.rhy_kernel_size, dilation_rate=self.rhy_dilation, activation=tf.nn.leaky_relu, ) # self.bi_gru = BiGRUCell(rnn_size=self.filters, # dropout=self.dropout) self.high_cross = layers.Conv1D(self.filters, 1, padding='same') self.low_cross = layers.Conv1D(self.filters, 1, padding='same') self.upsampling1d = layers.UpSampling1D(size=self.beta) self.averagepooling1d = layers.AveragePooling1D(pool_size=self.beta) self.batch_norm1 = layers.BatchNormalization() self.batch_norm2 = layers.BatchNormalization() self.batch_norm3 = layers.BatchNormalization() self.batch_norm4 = layers.BatchNormalization() self.dropout_high = layers.Dropout( self.dropout, [tf.constant(1), tf.constant(1), tf.constant(self.high_channels)]) self.dropout_low = layers.Dropout( self.dropout, [tf.constant(1), tf.constant(1), tf.constant(self.low_channels)]) super().build(input_shape)
def createModel(self, learningRate: float): # Should go over minutes, not seconds input_layer = layers.Input(shape=(self._MINUTES, 4)) layer = layers.Conv1D(filters=16, kernel_size=16, activation='relu', input_shape=(self._MINUTES, 4))(input_layer) layer = layers.AveragePooling1D(pool_size=2)(layer) layer = layers.Conv1D(filters=8, kernel_size=8, activation='relu', input_shape=(self._MINUTES, 4))(layer) layer = layers.AveragePooling1D(pool_size=2)(layer) layer = tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(self._MINUTES, input_shape=layer.shape))(layer) layer = layers.Dense(5, activation='relu')(layer) layer = layers.Dense(2, activation='relu')(layer) layer = tf.keras.layers.Dropout(0.1)(layer) layer = layers.Dense(1, activation='sigmoid')(layer) self.model = tf.keras.Model(input_layer, layer) self.model.compile(loss='binary_crossentropy', optimizer=tf.keras.optimizers.RMSprop(lr=learningRate), metrics=self._metrics) tf.keras.utils.plot_model(self.model, "crypto_model.png", show_shapes=True)
def create_vgg_2d(input_shape=(80, 3), num_classes=3, activation="softmax"): """2次元データのVGGっぽいの""" inputs = layers.Input(input_shape) x = inputs for ch in [64, 128, 256]: x = layers.Conv1D(ch, 3, padding='same')(x) x = layers.BatchNormalization()(x) x = layers.ReLU()(x) if ch != 256: x = layers.AveragePooling1D(2)(x) x = layers.GlobalAveragePooling1D()(x) x = layers.Dense(num_classes, activation=activation)(x) return tf.keras.models.Model(inputs, x)
def __init__(self, output_channels, downsample_factor): """Initilizer for the unconditional DBlock of the GAN-TTS discriminator. Paramaters: output_channels: The number of output channels from the DBlock. downsample_factor: The downsampling factor of the DBlock. """ super(DBlock, self).__init__() self.stack = keras.Sequential([ layers.AveragePooling1D(pool_size=downsample_factor, strides=downsample_factor), layers.ReLU(), layers.Conv1D(filters=output_channels, kernel_size=3, strides=1, dilation_rate=1, padding='same'), layers.ReLU(), layers.Conv1D(filters=output_channels, kernel_size=3, strides=1, dilation_rate=2, padding='same') ]) self.residual = keras.Sequential([ layers.Conv1D(filters=output_channels, kernel_size=3, strides=1, dilation_rate=1, padding='same'), layers.AveragePooling1D(pool_size=downsample_factor, strides=downsample_factor) ])
def __init__(self, params): name = params['model_name'] super(discrete_10000_ec_4, self).__init__(name=name) # float dropout_rate = params['dropout_rate'] # list with 2 element: start and end # [0:1] = V # [1:2] = W # [0:2] = V and W self.pchoice = params['pchoice'] self.d = layers.Conv1D(1, 2, strides=1, padding='same') self.d2 = layers.Conv1D(1, 3, strides=1, padding='same') self.semilocal = layers.Conv1D(1, 16, strides=1, padding='same') self.decider = keras.Sequential() self.decider.add(layers.Conv1D(6, 2, strides=1, padding='same')) self.decider.add(layers.ELU()) self.decider.add(layers.Dropout(rate=dropout_rate)) self.decider.add(layers.Conv1D(7, 4, strides=1, padding='same')) self.decider.add(layers.LeakyReLU()) self.decider.add(layers.Dropout(rate=dropout_rate)) self.decider.add(layers.Conv1D(8, 6, strides=1, padding='same')) self.counters = [] for i in range(1, 8): model = keras.Sequential() model.add(layers.Conv1D(8, 2**i, 2**(i - 1), padding='same')) model.add(layers.ELU()) model.add(layers.Dropout(rate=dropout_rate)) pool_size = (10000 + 2**(i - 1) - 1) // 2**(i - 1) model.add(layers.AveragePooling1D(pool_size=pool_size)) model.add(layers.LeakyReLU()) self.counters.append(model) self.conv_down = layers.Dense(1) self.weighters = keras.Sequential() self.weighters.add(layers.BatchNormalization()) self.weighters.add(layers.Dense(21)) self.weighters.add(layers.ELU()) self.weighters.add(layers.Dropout(rate=dropout_rate)) self.weighters.add(layers.Dense(14)) self.weighters.add(layers.LeakyReLU()) self.weighters.add(layers.Dropout(rate=dropout_rate)) self.weighters.add(layers.Dense(7)) self.weighters.add(layers.Activation('softmax')) self.out_layer = layers.Dense(1)
def __call__(self, x): """ x: input tensor. returns: output tensor for the block. """ x = layers.BatchNormalization(epsilon=1.001e-5, name=self.name + "_bn")(x) x = layers.Activation('relu', name=self.name + "_relu")(x) x = layers.Conv1D(int(x.shape[-1] * self.reduction), 1, use_bias=False, name=self.name + "_conv")(x) x = layers.AveragePooling1D(2, strides=2, name=self.name + "_pool")(x) return x
def build_model_resnet(h): try: callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0.0001, patience=10) inputs = layers.Input(shape=(h.get('len_slice'), 2)) t = layers.BatchNormalization()(inputs) t = layers.GaussianNoise(0.1)(t) t = layers.Conv1D(kernel_size=h.Int('kernel_1', 2, 20, 1, default=7), filters=h.Int('filters_1', 10, 200, 10, default=64), activation=h.Choice( 'activation_1', values=['relu', 'tanh', 'sigmoid'], default='relu'))(t) t = layers.MaxPool1D(2)(t) f_b_1 = h.Int('filters_block_1', 10, 200, 10, default=64) t = proj_block(t, f_b_1) for i in range(h.Int('nb_id_1', 1, 5, 1, default=2)): t = id_block(t, f_b_1) f_b_2 = h.Int('filters_block_2', 10, 200, 10, default=128) t = proj_block(t, f_b_2) for j in range(h.Int('nb_id_2', 1, 5, 1, default=3)): t = id_block(t, f_b_2) t = layers.AveragePooling1D(2)(t) t = layers.Flatten()(t) outputs = layers.Dense(3, activation='softmax')(t) model = tf.keras.models.Model(inputs, outputs) model.compile(optimizer=optimizers.Adam(learning_rate=0.0001), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy']) except: model = models.Sequential() model.add( layers.BatchNormalization(input_shape=(h.get('len_slice'), 2))) model.add(layers.Flatten()) model.add(layers.Dense(3, activation='softmax')) model.compile(optimizer=optimizers.Adam(learning_rate=0.0001), loss=tf.keras.losses.categorical_crossentropy, metrics=['accuracy']) return model
def __init__(self, encoder_blocks, encoder_layers, encoder_channels, kernel_size, encoder_pool, **kwargs): super().__init__(**kwargs) self.encoder_blocks = encoder_blocks self.encoder_layers = encoder_layers self.encoder_channels = encoder_channels self.kernel_size = kernel_size self.encoder_pool = encoder_pool dilated_layers = [] for _ in range(self.encoder_blocks): for i in range(self.encoder_layers): dilation = 2 ** i dilated_layers.append(DilatedResConv(channels=self.encoder_channels, kernel_size=self.kernel_size, dilation=dilation)) self.dilated_convs = Sequential(layers=dilated_layers) self.start = layers.Conv1D(self.encoder_channels, self.kernel_size) # default padding is 'valid', for Non-Causal Convulution self.conv_1x1 = layers.Conv1D(self.encoder_channels, kernel_size = 1) self.pool = layers.AveragePooling1D(self.encoder_pool, padding='same')
def create_multiview_model_old(base_model, multiviews_num, input_shape, output_size, use_lstm): assert base_model == "voxnet" or base_model == "pointnet" if base_model == "voxnet": base_model = create_voxnet_model_homepage(input_shape, output_size) elif base_model == "pointnet": base_model = create_point_net(input_shape, output_size) model = models.Sequential() model.add(layers.TimeDistributed(base_model, input_shape=(multiviews_num,) + input_shape)) if use_lstm is True: model.add(layers.LSTM(8, activation="relu")) else: model.add(layers.AveragePooling1D(multiviews_num)) model.add(layers.Flatten()) model.add(layers.Dense(output_size)) return model
def build_model(self): ECG = layers.Input(shape=self.input_shape, name='ECG') x = kanres_init(ECG, 64, 32, 8, 3, 1) x = layers.AveragePooling1D(pool_size=2, data_format='channels_last')(x) x = kanres_module(x, 64, 32, 50, 50, 1) x = kanres_module(x, 64, 32, 50, 50, 1) x = kanres_module(x, 64, 32, 50, 50, 1) x = kanres_module(x, 64, 32, 50, 50, 1) x = kanres_module(x, 64, 32, 50, 50, 1) x = kanres_module(x, 64, 32, 50, 50, 1) x = kanres_module(x, 64, 32, 50, 50, 1) x = kanres_module(x, 64, 32, 50, 50, 1) x = layers.GlobalAveragePooling1D()(x) output = layers.Dense(self.output_size)(x) model = Model(inputs=ECG, outputs=output) self.model = model
def transition_block(x, reduction, reg, name): """A transition block. # Arguments x: input tensor. reduction: float, compression rate at transition layers. name: string, block label. # Returns output tensor for the block. """ bn_axis = 2 x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name=name + '_bn')(x) x = layers.Activation('relu', name=name + '_relu')(x) x = layers.Conv1D(int(backend.int_shape(x)[bn_axis] * reduction), 1, use_bias=False, kernel_regularizer=reg, name=name + '_conv')(x) x = layers.AveragePooling1D(2, strides=2, name=name + '_pool')(x) return x
def build_discriminator(self): dropout_rate = 0.0 activation = "relu" D = Models.Sequential(name="Discriminator") D.add(Layers.Input(shape=self.output_timesteps)) D.add(Layers.Reshape(target_shape=(self.output_timesteps, 1))) D.add(Layers.Conv1D(filters=64, kernel_size=2, activation=activation)) D.add(Layers.Conv1D(filters=64, kernel_size=2, activation=activation)) D.add(Layers.AveragePooling1D(pool_size=2)) D.add(Layers.Dropout(rate=dropout_rate)) D.add(Layers.Flatten()) D.add(Layers.Dense(units=200, activation="relu")) D.add(Layers.Dense(units=20, activation="relu")) D.add(Layers.Dense(1, activation="sigmoid")) D.summary() return D
def build_model( self, optimizer="adam", dropout_rate=0.005, neurons=50, kernel_size=3, pool_size=2, activation="relu", conv_stacks=3, ): model = M.Sequential() model.add(L.Input(shape=(self.input_timesteps, self.input_features))) for _ in range(conv_stacks): model.add( L.Conv1D( filters=neurons, kernel_size=kernel_size, activation=activation ) ) model.add( L.Conv1D( filters=neurons, kernel_size=kernel_size, activation=activation ) ) model.add(L.AveragePooling1D(pool_size=pool_size)) model.add(L.Dropout(rate=dropout_rate)) model.add(L.LSTM(units=20, return_sequences=True)) model.add(L.Dropout(rate=dropout_rate)) model.add(L.LSTM(units=5, return_sequences=True)) model.add(L.Dropout(rate=dropout_rate)) model.add(L.Flatten()) model.add(L.Dense(units=neurons)) model.add(L.Dense(units=self.output_timesteps, activation="linear")) mape = "mean_absolute_percentage_error" model.compile(loss=mape, optimizer=optimizer, metrics=[mape]) return model
def build_model_1(time_steps): model = tf.keras.models.Sequential() # 时间步数太短,卷积核尺寸开始小,然后增大,不能一直用1,否则卷积无法查看相邻的关系 model.add( layers.Conv1D(16, 2, padding='same', strides=1, input_shape=(time_steps, 5))) model.add(layers.Conv1D(32, 2, padding='same', strides=1)) model.add(layers.Conv1D(64, 2, padding='same', strides=1)) # 注意这里第二次卷积核为2的卷积实际上就已经跨过三天的k线,所以没必要用太多 model.add(layers.Conv1D(128, 2, padding='same', strides=1)) model.add(layers.AveragePooling1D(2)) model.add(CuDNNGRU(128, return_sequences=True)) model.add(layers.Flatten()) model.add(layers.Dropout(0.4)) model.add(layers.Dense(128, activation='relu')) # model.add(layers.Dense(128, activation='relu')) model.add(layers.Dense(5, activation='tanh')) # 优化算法使用adam,短周期收敛较慢 model.compile(optimizer='adam', loss='mse') return model
def doublePool(x, pool_size=2, strides=None): return layers.concatenate([ layers.MaxPooling1D(pool_size, strides)(x), layers.AveragePooling1D(pool_size, strides)(x) ])
def build_dense_net(blocks, output_dim, input_shape=None, growth_rate=32, lr=0.01, dpt=0.5, mid_dpt=0.0, cvf=128, cvs=7, mid_cvs=3, use_l2=1, l2_val=0.001): # In 2D convolution with keras, we pass # the channels axis here. The equivalent # axis for us is the second one, which # is the number of features describing each # time step bn_axis = 2 # If we want to use an l2 penalty, reg is # initialized to the usual keras l2 regularizer. # If not, we use a lambda function that always # returns 0 (no penalty) if use_l2 == 1: reg = regularizers.l2(l2_val) else: reg = lambda weight_matrix: 0.0 input_tensor = layers.Input(shape=input_shape) x = layers.Conv1D(cvf, cvs, strides=1, use_bias=False, kernel_regularizer=reg, padding="same", name='conv1/conv')(input_tensor) x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='conv1/bn')(x) x = layers.Activation('relu', name='conv1/relu')(x) x = layers.AveragePooling1D(3, name='pool1')(x) for i, val in enumerate(blocks): x = dense_block(x, val, growth_rate, mid_dpt, mid_cvs, reg, name=f'dense_block_{i}') x = transition_block(x, 0.5, reg, name=f'transition_block_{i}') x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='bn')(x) x = layers.Dropout(dpt)(x) x = layers.Activation('relu', name='relu')(x) x = layers.GlobalAveragePooling1D(name='avg_pool')(x) if output_dim > 1: x = layers.Dense(output_dim, activation='softmax', name='fc1000')(x) else: x = layers.Dense(output_dim, activation='sigmoid', name='fc1000')(x) model = models.Model(input_tensor, x, name="densenet") return model
'Mangrove Warbler': 261, 'Myrtle Warbler': 262, 'Yellow-throated Vireo': 263 } INV_BIRD_CODE = {v: k for k, v in BIRD_CODE.items()} SAMPLE_RATE = 32000 NUM_CLASSES_SOUND = 264 PERIOD = 5 base_model = ResNet50(include_top=False, weights=None) x = base_model.output x = tf.reduce_mean(x, axis=2) x1 = L.MaxPooling1D(pool_size=3, strides=1, padding='same')(x) x2 = L.AveragePooling1D(pool_size=3, strides=1, padding='same')(x) x = x1 + x2 x = L.Dropout(0.5)(x) x = L.Dense(1024, activation='relu')(x) x = L.Dropout(0.5)(x) norm_att = L.Conv1D(filters=NUM_CLASSES_SOUND, kernel_size=1, padding='same')(x) norm_att = tf.keras.activations.tanh(norm_att / 10) * 10 norm_att = tf.keras.activations.softmax(norm_att, axis=-2) segmentwise_output = L.Conv1D(filters=NUM_CLASSES_SOUND, kernel_size=1, padding='same', activation='sigmoid', name='segmentwise_output')(x) clipwise_output = tf.math.reduce_sum(norm_att * segmentwise_output, axis=1)
train_x = tf.convert_to_tensor( data.get_description('..\\track1_round1_train_20210222.csv')) train_y = tf.convert_to_tensor( data.get_label('..\\track1_round1_train_20210222.csv')) print(train_x.shape) test_x, test_y = data.get_test('..\\track1_round1_train_20210222.csv') rnn_units = 32 input_layer = keras.Input(shape=(104, 1)) # x = layers.Embedding(input_dim=859, output_dim=10)(input_layer) x = layers.Conv1D(filters=rnn_units, kernel_size=4, padding='valid')(input_layer) x = layers.Conv1D(filters=rnn_units, kernel_size=4, padding='valid')(x) x = layers.AveragePooling1D()(x) # attention attention_pre = layers.Dense(32, name='attention_vec')(x) # [b_size,maxlen,64] attention_probs = layers.Softmax()(attention_pre) # [b_size,maxlen,64] attention_mul = layers.Lambda(lambda x: x[0] * x[1])([attention_probs, x]) y = layers.Dense(32, name='attention_vec1')(attention_mul) y = layers.Softmax()(y) attention_mul = layers.Lambda(lambda x: x[0] * x[1])([y, attention_mul]) y = layers.Dense(32, name='attention_vec2')(attention_mul) y = layers.Softmax()(y) attention_mul = layers.Lambda(lambda x: x[0] * x[1])([y, attention_mul]) y = layers.Dense(32, name='attention_vec3')(attention_mul)
def InceptionV3(include_top=True, weights='hasc', input_shape=None, pooling=None, classes=6, classifier_activation='softmax'): if input_shape is None: input_shape = (256*3, 1) if weights in ['hasc', 'HASC'] and include_top and classes != 6: raise ValueError('If using `weights` as `"hasc"` with `include_top`' ' as true, `classes` should be 6') inputs = layers.Input(shape=input_shape) x = Conv1DBN(32, 3, strides=2, padding='valid')(inputs) x = Conv1DBN(32, 3, padding='valid')(x) x = Conv1DBN(64, 3)(x) x = layers.MaxPooling1D(3, strides=2)(x) x = Conv1DBN(80, 1, padding='valid')(x) x = Conv1DBN(192, 3, padding='valid')(x) x = layers.MaxPooling1D(3, strides=2)(x) # mixed 0 branch1x1 = Conv1DBN(64, 1)(x) branch5x5 = Conv1DBN(48, 1)(x) branch5x5 = Conv1DBN(64, 5)(branch5x5) branch3x3dbl = Conv1DBN(64, 1)(x) branch3x3dbl = Conv1DBN(96, 3)(branch3x3dbl) branch3x3dbl = Conv1DBN(96, 3)(branch3x3dbl) branch_pool = layers.AveragePooling1D(3, strides=1, padding='same')(x) branch_pool = Conv1DBN(32, 1)(branch_pool) x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool], name='mixed0') # mixed 1 branch1x1 = Conv1DBN(64, 1)(x) branch5x5 = Conv1DBN(48, 1)(x) branch5x5 = Conv1DBN(64, 5)(branch5x5) branch3x3dbl = Conv1DBN(64, 1)(x) branch3x3dbl = Conv1DBN(96, 3)(branch3x3dbl) branch3x3dbl = Conv1DBN(96, 3)(branch3x3dbl) branch_pool = layers.AveragePooling1D(3, strides=1, padding='same')(x) branch_pool = Conv1DBN(64, 1)(branch_pool) x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool], name='mixed1') # mixed 2 branch1x1 = Conv1DBN(64, 1)(x) branch5x5 = Conv1DBN(48, 1)(x) branch5x5 = Conv1DBN(64, 5)(branch5x5) branch3x3dbl = Conv1DBN(64, 1)(x) branch3x3dbl = Conv1DBN(96, 3)(branch3x3dbl) branch3x3dbl = Conv1DBN(96, 3)(branch3x3dbl) branch_pool = layers.AveragePooling1D(3, strides=1, padding='same')(x) branch_pool = Conv1DBN(64, 1)(branch_pool) x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool], name='mixed2') # mixed 3 branch3x3 = Conv1DBN(384, 3, strides=2, padding='valid')(x) branch3x3dbl = Conv1DBN(64, 1)(x) branch3x3dbl = Conv1DBN(96, 3)(branch3x3dbl) branch3x3dbl = Conv1DBN(96, 3, strides=2, padding='valid')(branch3x3dbl) branch_pool = layers.MaxPooling1D(3, strides=2)(x) x = layers.concatenate([branch3x3, branch3x3dbl, branch_pool], name='mixed3') # mixed 4 branch1x1 = Conv1DBN(192, 1)(x) branch7x7 = Conv1DBN(128, 1)(x) branch7x7 = Conv1DBN(128, 1)(branch7x7) branch7x7 = Conv1DBN(128, 7)(branch7x7) branch7x7dbl = Conv1DBN(128, 1)(x) branch7x7dbl = Conv1DBN(128, 7)(branch7x7dbl) branch7x7dbl = Conv1DBN(128, 1)(branch7x7dbl) branch7x7dbl = Conv1DBN(128, 7)(branch7x7dbl) branch7x7dbl = Conv1DBN(128, 1)(branch7x7dbl) branch_pool = layers.AveragePooling1D(3, strides=1, padding='same')(x) branch_pool = Conv1DBN(192, 1)(branch_pool) x = layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool], name='mixed4') # mixed 5, 6 for i in range(2): branch1x1 = Conv1DBN(192, 1)(x) branch7x7 = Conv1DBN(160, 1)(x) branch7x7 = Conv1DBN(160, 1)(branch7x7) branch7x7 = Conv1DBN(192, 7)(branch7x7) branch7x7dbl = Conv1DBN(160, 1)(x) branch7x7dbl = Conv1DBN(160, 7)(branch7x7dbl) branch7x7dbl = Conv1DBN(160, 1)(branch7x7dbl) branch7x7dbl = Conv1DBN(160, 7)(branch7x7dbl) branch7x7dbl = Conv1DBN(192, 1)(branch7x7dbl) branch_pool = layers.AveragePooling1D(3, strides=1, padding='same')(x) branch_pool = Conv1DBN(192, 1)(branch_pool) x = layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool], name='mixed' + str(5 + i)) # mixed 7 branch1x1 = Conv1DBN(192, 1)(x) branch7x7 = Conv1DBN(192, 1)(x) branch7x7 = Conv1DBN(192, 1)(branch7x7) branch7x7 = Conv1DBN(192, 7)(branch7x7) branch7x7dbl = Conv1DBN(192, 1)(x) branch7x7dbl = Conv1DBN(192, 7)(branch7x7dbl) branch7x7dbl = Conv1DBN(192, 1)(branch7x7dbl) branch7x7dbl = Conv1DBN(192, 7)(branch7x7dbl) branch7x7dbl = Conv1DBN(192, 1)(branch7x7dbl) branch_pool = layers.AveragePooling1D(3, strides=1, padding='same')(x) branch_pool = Conv1DBN(192, 1)(branch_pool) x = layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool], name='mixed7') # mixed 8 branch3x3 = Conv1DBN(192, 1)(x) branch3x3 = Conv1DBN(320, 3, strides=2, padding='valid')(branch3x3) branch7x7x3 = Conv1DBN(192, 1)(x) branch7x7x3 = Conv1DBN(192, 1)(branch7x7x3) branch7x7x3 = Conv1DBN(192, 7)(branch7x7x3) branch7x7x3 = Conv1DBN(192, 3, strides=2, padding='valid')(branch7x7x3) branch_pool = layers.MaxPooling1D(3, strides=2)(x) x = layers.concatenate([branch3x3, branch7x7x3, branch_pool], name='mixed8') # mixed 9, 10 for i in range(2): branch1x1 = Conv1DBN(320, 1)(x) branch3x3 = Conv1DBN(384, 1)(x) branch3x3_1 = Conv1DBN(384, 1)(branch3x3) branch3x3_2 = Conv1DBN(384, 3)(branch3x3) branch3x3 = layers.concatenate([branch3x3_1, branch3x3_2], name='mixed9_' + str(i)) branch3x3dbl = Conv1DBN(448, 1)(x) branch3x3dbl = Conv1DBN(384, 3)(branch3x3dbl) branch3x3dbl_1 = Conv1DBN(384, 1)(branch3x3dbl) branch3x3dbl_2 = Conv1DBN(384, 3)(branch3x3dbl) branch3x3dbl = layers.concatenate([branch3x3dbl_1, branch3x3dbl_2]) branch_pool = layers.AveragePooling1D(3, strides=1, padding='same')(x) branch_pool = Conv1DBN(192, 1)(branch_pool) x = layers.concatenate([branch1x1, branch3x3, branch3x3dbl, branch_pool], name='mixed' + str(9 + i)) # Classification block x = layers.GlobalAveragePooling1D(name='avg_pool')(x) y = layers.Dense(classes, activation=classifier_activation, name='predictions')(x) model = Model(inputs, y) if weights is not None: if weights in ['hasc', "HASC"]: weights = 'weights/inceptionv3/inceptionv3_hasc_weights_{}_{}.hdf5'.format(int(input_shape[0]), int(input_shape[1])) # hasc or weights fileで初期化 if os.path.exists(weights): print("Load weights from {}".format(weights)) model.load_weights(weights) else: print("Not exist weights: {}".format(weights)) # topを含まないとき if not include_top: if pooling is None: # topを削除する model = Model(inputs=model.input, outputs=model.layers[-3].output) elif pooling == 'avg': y = layers.GlobalAveragePooling1D()(model.layers[-3].output) model = Model(inputs=model.input, outputs=y) elif pooling == 'max': y = layers.GlobalMaxPooling1D()(model.layers[-3].output) model = Model(inputs=model.input, outputs=y) else: print("Not exist pooling option: {}".format(pooling)) model = Model(inputs=model.input, outputs=model.layers[-3].output) return model