def _squeezenet1d(flat_input, keep_prob, n_classes): w_ini, b_ini, r_ini = initializers() x_multichannel = tf.reshape(flat_input, [-1, conf.seq_lngth, conf.num_ch]) net = conv1d(x_multichannel, filters=96, kernel_size=7, name='conv1', kernel_initializer=w_ini, bias_initializer=b_ini, kernel_regularizer=r_ini) net = max_pooling1d(net, pool_size=3, strides=2, name='maxpool1') net = fire_module1d(net, 16, 64, name='fire2') net = fire_module1d(net, 16, 64, name='fire3') net = fire_module1d(net, 32, 128, name='fire4') net = max_pooling1d(net, pool_size=3, strides=2, name='maxpool4') net = fire_module1d(net, 32, 128, name='fire5') net = fire_module1d(net, 48, 192, name='fire6') net = fire_module1d(net, 48, 192, name='fire7') net = fire_module1d(net, 64, 256, name='fire8') net = max_pooling1d(net, pool_size=3, strides=2, name='maxpool8') net = fire_module1d(net, 64, 256, name='fire9') net = tf.nn.dropout(net, keep_prob=keep_prob, name='dropout9') net = conv1d(net, n_classes, 1, 1, name='conv10', kernel_initializer=w_ini, bias_initializer=b_ini, kernel_regularizer=r_ini) logits = tf.reduce_mean( net, axis=1, name='global_avgpool10') # global average pooling return logits
def res_block_1d(x, kernel_size, activation, training, batch_norm=True): assert len(x.shape) == 3, "Input tensor must be 3-dimensional." activation = activation.lower() filters = int(x.shape[2]) y = ly.conv1d(inputs=x, filters=filters, kernel_size=kernel_size, strides=1, padding='same') if batch_norm: y = ly.batch_normalization(y, training=training) y = nonlinear[activation](y) y = ly.conv1d(inputs=y, filters=filters, kernel_size=kernel_size, strides=1, padding='same') if batch_norm: y = ly.batch_normalization(y, training=training) return tf.add(x, y)
def misconception_model(inputs, filters_list, kernel_size, strides_list, training, objective_functions, sub_filters=128, sub_layers=2, dropout_rate=0.5, virtual_batch_size=None, feature_means=None, feature_stds=None): """ A misconception tower. Args: input: a tensor of size [batch_size, 1, width, depth]. window_size: the width of the conv and pooling filters to apply. depth: the depth of the output tensor. levels: the height of the tower in misconception layers. objective_functions: a list of objective functions to add to the top of the network. is_training: whether the network is training. Returns: a tensor of size [batch_size, num_classes]. """ layers = [] net = inputs if feature_means is not None: net = net - tf.constant(feature_means)[None, None, :] if feature_stds is not None: net = net / (tf.constant(feature_stds) + 1e-6) layers.append(net) for filters, strides in zip(filters_list, strides_list): net = misconception_with_bypass(net, filters, kernel_size, strides, training, virtual_batch_size=virtual_batch_size) layers.append(net) outputs = [] for ofunc in objective_functions: onet = net for _ in range(sub_layers - 1): onet = ly.conv1d(onet, sub_filters, 1, activation=None, use_bias=False) onet = ly.batch_normalization( onet, training=training, virtual_batch_size=virtual_batch_size) onet = tf.nn.relu(onet) onet = ly.conv1d(onet, sub_filters, 1, activation=tf.nn.relu) onet = ly.flatten(onet) # onet = ly.dropout(onet, training=training, rate=dropout_rate) outputs.append(ofunc.build(onet)) return outputs, layers
def misconception_fishing(inputs, filters_list, kernel_size, strides_list, objective_function, training, pre_filters=128, post_filters=128, post_layers=1, dropout_rate=0.5, internal_dropout_rate=0.5, other_objectives=(), feature_means=None, feature_stds=None): _, layers = misconception_model(inputs, filters_list, kernel_size, strides_list, training, other_objectives, sub_filters=post_filters, sub_layers=2, dropout_rate=internal_dropout_rate, feature_means=feature_means, feature_stds=feature_stds) expanded_layers = [] for i, lyr in enumerate(layers): lyr = ly.conv1d(lyr, pre_filters, 1, activation=None) lyr = ly.batch_normalization(lyr, training=training) lyr = tf.nn.relu(lyr) expanded_layers.append(repeat_tensor(lyr, 2**i)) embedding = tf.add_n(expanded_layers) for _ in range(post_layers - 1): embedding = ly.conv1d(embedding, post_filters, 1, activation=None, use_bias=False) embedding = ly.batch_normalization(embedding, training=training) embedding = tf.nn.relu(embedding) embedding = ly.conv1d(embedding, post_filters, 1, activation=tf.nn.relu) embedding = ly.dropout(embedding, training=training, rate=dropout_rate) fishing_outputs = ly.conv1d(embedding, 1, 1, activation=None) return objective_function.build(fishing_outputs)
def shake2_with_thru_max(inputs, filters, kernel_size, stride, training, scope=None): with tf.name_scope(scope): ss = shake2(inputs, filters, kernel_size, stride, training) mp = tf.layers.max_pooling1d(inputs, kernel_size, strides=stride, padding="valid") concat = tf.concat([ss, mp], 2) y = ly.conv1d(concat, filters, 1, activation=None, use_bias=False) residual = ly.batch_normalization(y, training=training) # crop = (kernel_size - stride // 2) // 2 # TODO: work this out more generally / cleanly crop = kernel_size // 2 thru = inputs if crop: thru = inputs[:, crop:-crop] thru = thru[:, ::stride] # if stride > 1: # thru = tf.layers.max_pooling1d( # thru, kernel_size, strides=stride, padding="valid") thru = zero_pad_features(thru, filters) return thru + residual
def misconception_layer(inputs, filters, kernel_size, strides, training, scope=None, virtual_batch_size=None): """ A single layer of the misconception convolutional network. Args: input: a tensor of size [batch_size, 1, width, depth] window_size: the width of the conv and pooling filters to apply. stride: the downsampling to apply when filtering. depth: the depth of the output tensor. Returns: a tensor of size [batch_size, 1, width/stride, depth]. """ with tf.name_scope(scope): extra = kernel_size - strides p0 = extra // 2 p1 = extra - p0 padded = tf.pad(inputs, [[0, 0], [p0, p1], [0, 0]]) stage_conv = ly.conv1d(padded, filters, kernel_size, strides=strides, padding="valid", activation=None, use_bias=False) stage_conv = ly.batch_normalization( stage_conv, training=training, virtual_batch_size=virtual_batch_size) stage_conv = tf.nn.relu(stage_conv) stage_max_pool_reduce = tf.layers.max_pooling1d(padded, kernel_size, strides=strides, padding="valid") concat = tf.concat([stage_conv, stage_max_pool_reduce], 2) total = ly.conv1d(concat, filters, 1, activation=None, use_bias=False) total = ly.batch_normalization(total, training=training, virtual_batch_size=virtual_batch_size) total = tf.nn.relu(total) return total
def shakeout(inputs, filters, kernel_size, stride, training, scope=None): with tf.name_scope(scope): y = tf.nn.relu(inputs) y1, y2 = shake_out(y, training) y1 = ly.conv1d(y1, filters, kernel_size, activation=None, use_bias=False, strides=stride, padding="valid") y1 = ly.batch_normalization(y1, training=training) y1 = tf.nn.relu(y1) y1 = ly.conv1d(y1, filters, 1, activation=None, use_bias=False, padding="valid") y1 = ly.batch_normalization(y1, training=training) y2 = ly.conv1d(y, filters, kernel_size, activation=None, use_bias=False, strides=stride, padding="valid") y2 = ly.batch_normalization(y2, training=training) y2 = tf.nn.relu(y2) y2 = ly.conv1d(y2, filters, 1, activation=None, use_bias=False, padding="valid") y2 = ly.batch_normalization(y2, training=training) return y1 + y2
def _squeeze1d(inputs, n_outputs): w_ini, b_ini, r_ini = initializers() return conv1d(inputs=inputs, filters=n_outputs, kernel_size=1, strides=1, name='squeeze', activation=tf.nn.relu, kernel_initializer=w_ini, bias_initializer=b_ini, kernel_regularizer=r_ini)
def _conv1d(inputs, n_filters, size, name, padding='VALID'): """wrapper function for 1D convolutional layer""" w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str) return conv1d(inputs, n_filters, size, padding=padding, activation=tf.nn.relu, bias_initializer=b_ini, kernel_initializer=w_ini, kernel_regularizer=r_ini, name=name)
def conv1d_layer(x, n_out, kernel_size, stride=1, activation=ACTIVATION, regularize=True, use_bias=True, drop_rate=0.0, batch_norm=BATCH_NORM, training=True, name=None, reuse=None): if batch_norm: if name: x = batch_norm_layer(x, training, name=name + '_bn', reuse=reuse) else: x = batch_norm_layer(x, training, name=name, reuse=reuse) #wt_init = tf.truncated_normal_initializer(stddev=0.2) #bi_init = tf.truncated_normal_initializer(mean=BIAS_SHIFT,stddev=0.01) wt_init = None bi_init = None if regularize: wt_reg = WT_REG bi_reg = BI_REG else: wt_reg = None bi_reg = None y = layers.conv1d(x, n_out, kernel_size, strides=stride, padding='same', data_format='channels_last', dilation_rate=1, activation=activation, use_bias=use_bias, kernel_initializer=wt_init, bias_initializer=bi_init, kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, trainable=True, name=None, reuse=None) y = layers.dropout(y, rate=drop_rate, training=training) return y
def _expand1d(inputs, n_outputs): w_ini, b_ini, r_ini = initializers() with tf.variable_scope('expand'): e1x1 = conv1d(inputs=inputs, filters=n_outputs, kernel_size=1, strides=1, name='1x1', activation=tf.nn.relu, kernel_initializer=w_ini, bias_initializer=b_ini, kernel_regularizer=r_ini) e3x3 = conv1d(inputs=inputs, filters=n_outputs, padding='SAME', kernel_size=3, strides=1, name='3x3', activation=tf.nn.relu, kernel_initializer=w_ini, bias_initializer=b_ini, kernel_regularizer=r_ini) return tf.concat([e1x1, e3x3], -1)
def shake2_with_max(inputs, filters, kernel_size, stride, training, scope=None): with tf.name_scope(scope): ss = shake2(inputs, filters, kernel_size, stride, training) mp = tf.layers.max_pooling1d(inputs, kernel_size, strides=stride, padding="valid") concat = tf.concat([ss, mp], 2) y = ly.conv1d(concat, filters, 1, activation=None, use_bias=False) y = ly.batch_normalization(y, training=training) return y
def conv_block_1d(x, kernel_size, filters, strides, activation, training, batch_norm=True): activation = activation.lower() y = ly.conv1d(inputs=x, filters=filters, kernel_size=kernel_size, strides=strides, padding='same') y = nonlinear[activation](y) if batch_norm: y = ly.batch_normalization(y, training=training) return y
test_set.append( test_tss_b[:, int(r - 2 * stop_time - inp_size // 2):int(r - 2 * stop_time + inp_size // 2)].transpose()) continue for i in np.arange(max(0, r - 1000), min(stop_time * 2, r + 1000)): tss_mask[0, int(i)] = 1 #normal(i,std=400) test_set = np.stack(test_set) tss_mask = tss_mask / np.max(tss_mask) tss_mask = amp.reshape(1, -1) / np.max(amp) x = tf.placeholder(tf.float32, [None, inp_size, 255]) y = tf.placeholder(tf.float32, [None, 1, 1]) relu = tf.nn.relu x1 = relu(layers.conv1d(x, 250, [10], padding='valid')) x1 = layers.max_pooling1d(x1, 100, strides=1, padding='valid') x1 = relu(layers.conv1d(x1, 250, [10], padding='valid')) x1 = layers.max_pooling1d(x1, 100, strides=1, padding='valid') x1 = relu(layers.conv1d(x1, 250, [10], padding='valid')) x1 = layers.max_pooling1d(x1, 100, strides=1, padding='valid') x1 = relu(layers.conv1d(x1, 250, [10], padding='valid')) x1 = layers.max_pooling1d(x1, 100, strides=1, padding='valid') x1 = relu(layers.conv1d(x1, 250, [10], padding='valid')) x1 = layers.max_pooling1d(x1, 100, strides=1, padding='valid') x1 = relu(layers.conv1d(x1, 250, [10], padding='valid')) x1 = layers.max_pooling1d(x1, 100, strides=1, padding='valid') x1 = layers.conv1d(x1, 1, [10], padding='valid') x1_prob = tf.nn.sigmoid(x1) # loss = tf.reduce_mean(tf.nn.weighted_cross_entropy_with_logits(y,x1,pos_weight)) loss = tf.reduce_mean(tf.square(y - x1) * (y * pos_weight + 1))
def network(self, x, is_training): # Embedding Lookup 16 with tf.device('/cpu:0'), tf.name_scope("embedding"): # use_he_uniform: self.embedding_W = tf.get_variable( name='lookup_W', shape=[self.char_dict_size, self.embedding_size], # TODO bigger embedding? initializer=tf.keras.initializers.he_uniform()) self.embedded_characters = tf.nn.embedding_lookup( params=self.embedding_W, ids=x, name='embed_lu') print("-" * 20) print("Embedded Lookup:", self.embedded_characters.get_shape()) print("-" * 20) # Temp(First) Conv Layer with tf.variable_scope("temp_conv"): print("-" * 20) print("Convolutional Block 1") print("-" * 20) he_std = np.sqrt(2 / (1 * 64)) conv1 = conv1d( inputs=self.embedded_characters, filters=128, padding='valid', kernel_size=3, strides=2, activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(stddev=he_std)) #conv1 = dropout(conv1, rate=0.5, training=is_training) conv1 = tf.layers.batch_normalization(inputs=conv1, momentum=0.997, epsilon=1e-5, center=True, scale=True, training=is_training) print("Conv 1", conv1.get_shape()) print("-" * 20) print("Convolutional Block 2") print("-" * 20) conv2 = conv1d( inputs=conv1, filters=128, padding='valid', kernel_size=3, activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(stddev=he_std)) conv2 = tf.layers.batch_normalization(inputs=conv2, momentum=0.997, epsilon=1e-5, center=True, scale=True, training=is_training) print("Conv 2", conv2.get_shape()) print("-" * 20) print("Convolutional Block 3") print("-" * 20) conv3 = conv1d( inputs=conv2, filters=128, padding='valid', kernel_size=3, activation=tf.nn.relu, kernel_initializer=tf.random_normal_initializer(stddev=he_std)) conv3 = tf.layers.batch_normalization(inputs=conv3, momentum=0.997, epsilon=1e-5, center=True, scale=True, training=is_training) print("Conv 3", conv3.get_shape()) flatten1 = tf.contrib.layers.flatten(conv3) print("-" * 20) print("Dense1") print("-" * 20) print("flatten", flatten1.get_shape()) dense1 = dense(flatten1, 512, activation=tf.nn.relu, name='dense1') print("dense1", dense1.get_shape()) dense2 = dense(dense1, self.output_embedding_size, activation=tf.nn.log_softmax, name='dense2') # print("dense2", dense2.get_shape()) return dense2
def vgg_1d(input_tensor, initializer=tf.initializers.he_normal(), reuse=None): """ :param initializer: :param input_tensor: [batch_size, M, H] :return: """ net = layers.conv1d(input_tensor, config.spectral_hidden_dimension, kernel_size=7, strides=2, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv11", reuse=reuse) net = layers.conv1d(net, config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv12", reuse=reuse) net = layers.conv1d(net, config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv13", reuse=reuse) if (not reuse) and config.histo_summary_flag: tf.summary.histogram("output_conv13", net) # [2000 64] net = layers.conv1d(net, 2 * config.spectral_hidden_dimension, kernel_size=3, strides=2, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv21", reuse=reuse) net = layers.conv1d(net, 2 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv22", reuse=reuse) net = layers.conv1d(net, 2 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv23", reuse=reuse) if (not reuse) and config.histo_summary_flag: tf.summary.histogram("output_conv23", net) # [1000, 128], 0.15 params net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=2, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv31", reuse=reuse) net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv32", reuse=reuse) net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv33", reuse=reuse) if (not reuse) and config.histo_summary_flag: tf.summary.histogram("output_conv33", net) # [500, 256], 0.6M params net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=2, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv41", reuse=reuse) net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv42", reuse=reuse) net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv43", reuse=reuse) if (not reuse) and config.histo_summary_flag: tf.summary.histogram("output_conv43", net) # [250, 256], 0.6M net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=2, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv51", reuse=reuse) net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv52", reuse=reuse) net = layers.conv1d(net, 4 * config.spectral_hidden_dimension, kernel_size=3, strides=1, padding='same', kernel_initializer=initializer, activation=activation_func, kernel_regularizer=kernel_regularizer, name="conv53", reuse=reuse) if (not reuse) and config.histo_summary_flag: tf.summary.histogram("output_conv53", net) # [125, 256], 0.6M # finally a fully connected layer k_size = net.get_shape()[1] net = layers.conv1d(net, 1, kernel_size=(k_size, ), strides=1, padding='valid', kernel_initializer=initializer, activation=None, kernel_regularizer=kernel_regularizer, name="conv_final", reuse=reuse) logits = tf.squeeze(net, axis=[1, 2]) return logits
def misconception_model_2(inputs, filters_list, kernel_size, strides_list, training, objective_functions, sub_filters=128, sub_layers=2, dropout_rate=0.5): """ A misconception tower. Args: input: a tensor of size [batch_size, 1, width, depth]. window_size: the width of the conv and pooling filters to apply. depth: the depth of the output tensor. levels: the height of the tower in misconception layers. objective_functions: a list of objective functions to add to the top of the network. is_training: whether the network is training. Returns: a tensor of size [batch_size, num_classes]. """ layers = [] net = inputs layers.append(net) for filters, strides in zip(filters_list, strides_list): net = misconception_with_bypass(net, filters, kernel_size, strides, training) layers.append(net) onet = net for _ in range(sub_layers - 1): onet = ly.conv1d(onet, sub_filters, 1, activation=None, use_bias=False) onet = ly.batch_normalization(onet, training=training) onet = tf.nn.relu(onet) onet = ly.conv1d(onet, sub_filters, 1, activation=tf.nn.relu) snet = ly.conv1d(onet, 1, 1, activation=tf.nn.relu)[:, :, 0] selector = tf.expand_dims(tf.nn.softmax(snet), 2) outputs = [] for ofunc in objective_functions: onet = net for _ in range(sub_layers - 1): onet = ly.conv1d(onet, sub_filters, 1, activation=None, use_bias=False) onet = ly.batch_normalization(onet, training=training) onet = tf.nn.relu(onet) onet = ly.conv1d(onet, sub_filters, 1, activation=tf.nn.relu) onet = onet * selector n = int(onet.get_shape().dims[1]) onet = ly.average_pooling1d(onet, n, n) onet = ly.flatten(onet) # onet = ly.dropout(onet, training=training, rate=dropout_rate) outputs.append(ofunc.build(onet)) return outputs, layers
def deepLoco_decoder(x, img_channels=1): ''' :param inputs: input tensor, shape [?,nx,ny,img_channels] ''' nx = tf.shape(x)[1] ny = tf.shape(x)[2] inputs = tf.reshape(x, tf.stack([-1,nx,ny,img_channels])) batch_size = tf.shape(inputs)[0] print("input shape:",tf.shape(x)) conv1 = conv2d(inputs=x, filters=16, kernel_size=5, activation = tf.nn.relu, padding = 'same') # print ("conv1 shape:",conv1.shape) conv1 = conv2d(inputs=conv1, filters=16, kernel_size=5, activation = tf.nn.relu, padding = 'same') # print ("conv1 shape:",conv1.shape) conv1 = conv2d(inputs=conv1, filters=64, kernel_size=5, activation = tf.nn.relu, strides= 2, padding = 'same') print ("conv1 shape:",tf.shape(conv1)) conv2 = conv2d(inputs=conv1, filters=64, kernel_size=5, activation = tf.nn.relu, padding = 'same') # print ("conv2 shape:",conv2.shape) conv2 = conv2d(inputs=conv2, filters=64, kernel_size=5, activation = tf.nn.relu, padding = 'same') # print ("conv2 shape:",conv2.shape) conv2 = conv2d(inputs=conv2, filters=256, kernel_size=3, activation = tf.nn.relu, strides=2, padding = 'same') print ("conv2 shape:",tf.shape(conv2)) conv3 = conv2d(inputs=conv2, filters=256, kernel_size=3, activation = tf.nn.relu, padding = 'same') # print ("conv3 shape:",conv3.shape) conv3 = conv2d(inputs=conv3, filters=256, kernel_size=3, activation = tf.nn.relu, padding = 'same') # print ("conv3 shape:",conv3.shape) conv3 = conv2d(inputs=conv3, filters=256, kernel_size=3, activation = tf.nn.relu, strides=4, padding = 'same') print ("conv3 shape:",tf.shape(conv3)) # flat1 = tf.layers.flatten(inputs=conv3) tensor_shape = conv3.get_shape() print(tensor_shape) flat1 = tf.reshape(conv3, shape=[-1, tensor_shape[1]*tensor_shape[2]*tensor_shape[3]]) print("flat ", flat1.get_shape()) dense1 = tf.layers.dense(inputs=flat1, units=2048, activation=tf.nn.relu) print("dense1 ",dense1.get_shape()) reshape1 = tf.reshape(dense1, shape = [-1, 2048, 1]) # print("reshape1", reshape1.shape) shortcut = reshape1 # res1 = build_resnet(reshape1, basic_block, [2]) res1 = conv1d(inputs=reshape1, filters=1, kernel_size=3, strides=1, padding='same') # print("res1 ", res1.shape) res1 = LeakyReLU()(res1) res1 = batch_normalization(inputs=res1) # res1 = add_common_layers(res1) add1 = tf.add(shortcut,res1) # print("add1 ",add1.shape) add1 = LeakyReLU()(add1) add1 = batch_normalization(inputs=add1) shortcut = add1 res2 = conv1d(inputs=add1, filters=1, kernel_size=3, strides=1, padding='same') res2 = LeakyReLU()(res2) res2 = batch_normalization(inputs=res2) # res2 = add_common_layers(res2) # print("res2 ",res2.shape) add2 = tf.add(shortcut,res2) # print("add2 ",add2.shape) add2 = LeakyReLU()(add2) add2 = batch_normalization(inputs=add2) weights = conv1d(inputs=add2, filters=1, kernel_size=3, strides=8, padding='same', activation=tf.nn.relu) print("weights ", weights.get_shape()) positions = conv1d(inputs=add2, filters=2, kernel_size=3, strides=8, padding='same', activation=tf.nn.sigmoid) print("positions ",positions.get_shape()) output = tf.concat([weights,positions], 2) print(output.get_shape()) # return [weights, positions] return output