Python keras.layers.Concatenate() Examples
The following are 30
code examples of keras.layers.Concatenate().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
keras.layers
, or try the search function
.

Example #1
Source Project: Pix2Pix-Keras Author: wmylxmj File: model.py License: MIT License | 7 votes |
def creat_discriminator(self): # layer 0 image_A = Input(shape=self.image_shape) image_B = Input(shape=self.image_shape) combined_images = Concatenate(axis=-1)([image_A, image_B]) # layer 1 d1 = Conv2D(filters=64, kernel_size=4, strides=2, padding='same')(combined_images) d1 = LeakyReLU(alpha=0.2)(d1) # layer 2 d2 = Conv2D(filters=128, kernel_size=4, strides=2, padding='same')(d1) d2 = LeakyReLU(alpha=0.2)(d2) d2 = BatchNormalization(momentum=0.8)(d2) # layer 3 d3 = Conv2D(filters=128, kernel_size=4, strides=2, padding='same')(d2) d3 = LeakyReLU(alpha=0.2)(d3) d3 = BatchNormalization(momentum=0.8)(d3) # layer 4 d4 = Conv2D(filters=128, kernel_size=4, strides=2, padding='same')(d3) d4 = LeakyReLU(alpha=0.2)(d4) d4 = BatchNormalization(momentum=0.8)(d4) validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4) return Model([image_A, image_B], validity)
Example #2
Source Project: Keras-GAN Author: eriklindernoren File: pix2pix.py License: MIT License | 6 votes |
def build_discriminator(self): def d_layer(layer_input, filters, f_size=4, bn=True): """Discriminator layer""" d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) d = LeakyReLU(alpha=0.2)(d) if bn: d = BatchNormalization(momentum=0.8)(d) return d img_A = Input(shape=self.img_shape) img_B = Input(shape=self.img_shape) # Concatenate image and conditioning image by channels to produce input combined_imgs = Concatenate(axis=-1)([img_A, img_B]) d1 = d_layer(combined_imgs, self.df, bn=False) d2 = d_layer(d1, self.df*2) d3 = d_layer(d2, self.df*4) d4 = d_layer(d3, self.df*8) validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4) return Model([img_A, img_B], validity)
Example #3
Source Project: MesoNet Author: DariusAf File: classifiers.py License: Apache License 2.0 | 6 votes |
def InceptionLayer(self, a, b, c, d): def func(x): x1 = Conv2D(a, (1, 1), padding='same', activation='relu')(x) x2 = Conv2D(b, (1, 1), padding='same', activation='relu')(x) x2 = Conv2D(b, (3, 3), padding='same', activation='relu')(x2) x3 = Conv2D(c, (1, 1), padding='same', activation='relu')(x) x3 = Conv2D(c, (3, 3), dilation_rate = 2, strides = 1, padding='same', activation='relu')(x3) x4 = Conv2D(d, (1, 1), padding='same', activation='relu')(x) x4 = Conv2D(d, (3, 3), dilation_rate = 3, strides = 1, padding='same', activation='relu')(x4) y = Concatenate(axis = -1)([x1, x2, x3, x4]) return y return func
Example #4
Source Project: n2n-watermark-remove Author: zxq2233 File: model.py License: MIT License | 6 votes |
def get_unet_model(input_channel_num=3, out_ch=3, start_ch=64, depth=4, inc_rate=2., activation='relu', dropout=0.5, batchnorm=False, maxpool=True, upconv=True, residual=False): def _conv_block(m, dim, acti, bn, res, do=0): n = Conv2D(dim, 3, activation=acti, padding='same')(m) n = BatchNormalization()(n) if bn else n n = Dropout(do)(n) if do else n n = Conv2D(dim, 3, activation=acti, padding='same')(n) n = BatchNormalization()(n) if bn else n return Concatenate()([m, n]) if res else n def _level_block(m, dim, depth, inc, acti, do, bn, mp, up, res): if depth > 0: n = _conv_block(m, dim, acti, bn, res) m = MaxPooling2D()(n) if mp else Conv2D(dim, 3, strides=2, padding='same')(n) m = _level_block(m, int(inc * dim), depth - 1, inc, acti, do, bn, mp, up, res) if up: m = UpSampling2D()(m) m = Conv2D(dim, 2, activation=acti, padding='same')(m) else: m = Conv2DTranspose(dim, 3, strides=2, activation=acti, padding='same')(m) n = Concatenate()([n, m]) m = _conv_block(n, dim, acti, bn, res) else: m = _conv_block(m, dim, acti, bn, res, do) return m i = Input(shape=(None, None, input_channel_num)) o = _level_block(i, start_ch, depth, inc_rate, activation, dropout, batchnorm, maxpool, upconv, residual) o = Conv2D(out_ch, 1)(o) model = Model(inputs=i, outputs=o) return model
Example #5
Source Project: keras-yolo3 Author: bing0037 File: model.py License: MIT License | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #6
Source Project: multi-object-tracking Author: jguoaj File: model.py License: GNU General Public License v3.0 | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #7
Source Project: vision-web-service Author: sherlockchou86 File: model.py License: MIT License | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #8
Source Project: PIEPredict Author: aras62 File: pie_predict.py License: Apache License 2.0 | 6 votes |
def get_data_helper(self, data, data_type): """ A helper function for data generation that combines different data types into a single representation :param data: A dictionary of different data types :param data_type: The data types defined for encoder and decoder input/output :return: A unified data representation as a list """ if not data_type: return [] d = [] for dt in data_type: if dt == 'image': continue d.append(np.array(data[dt])) # Concatenate different data points into a single representation if len(d) > 1: return np.concatenate(d, axis=2) else: return d[0]
Example #9
Source Project: MBLLEN Author: Lvfeifan File: Network.py License: Apache License 2.0 | 6 votes |
def build_mbllen(input_shape): def EM(input, kernal_size, channel): conv_1 = Conv2D(channel, (3, 3), activation='relu', padding='same', data_format='channels_last')(input) conv_2 = Conv2D(channel, (kernal_size, kernal_size), activation='relu', padding='valid', data_format='channels_last')(conv_1) conv_3 = Conv2D(channel*2, (kernal_size, kernal_size), activation='relu', padding='valid', data_format='channels_last')(conv_2) conv_4 = Conv2D(channel*4, (kernal_size, kernal_size), activation='relu', padding='valid', data_format='channels_last')(conv_3) conv_5 = Conv2DTranspose(channel*2, (kernal_size, kernal_size), activation='relu', padding='valid', data_format='channels_last')(conv_4) conv_6 = Conv2DTranspose(channel, (kernal_size, kernal_size), activation='relu', padding='valid', data_format='channels_last')(conv_5) res = Conv2DTranspose(3, (kernal_size, kernal_size), activation='relu', padding='valid', data_format='channels_last')(conv_6) return res inputs = Input(shape=input_shape) FEM = Conv2D(32, (3, 3), activation='relu', padding='same', data_format='channels_last')(inputs) EM_com = EM(FEM, 5, 8) for j in range(3): for i in range(0, 3): FEM = Conv2D(32, (3, 3), activation='relu', padding='same', data_format='channels_last')(FEM) EM1 = EM(FEM, 5, 8) EM_com = Concatenate(axis=3)([EM_com, EM1]) outputs = Conv2D(3, (1, 1), activation='relu', padding='same', data_format='channels_last')(EM_com) return Model(inputs, outputs)
Example #10
Source Project: SeqGAN Author: tyo-yo File: models.py License: MIT License | 6 votes |
def VariousConv1D(x, filter_sizes, num_filters, name_prefix=''): ''' Layer wrapper function for various filter sizes Conv1Ds # Arguments: x: tensor, shape = (B, T, E) filter_sizes: list of int, list of each Conv1D filter sizes num_filters: list of int, list of each Conv1D num of filters name_prefix: str, layer name prefix # Returns: out: tensor, shape = (B, sum(num_filters)) ''' conv_outputs = [] for filter_size, n_filter in zip(filter_sizes, num_filters): conv_name = '{}VariousConv1D/Conv1D/filter_size_{}'.format(name_prefix, filter_size) pooling_name = '{}VariousConv1D/MaxPooling/filter_size_{}'.format(name_prefix, filter_size) conv_out = Conv1D(n_filter, filter_size, name=conv_name)(x) # (B, time_steps, n_filter) conv_out = GlobalMaxPooling1D(name=pooling_name)(conv_out) # (B, n_filter) conv_outputs.append(conv_out) concatenate_name = '{}VariousConv1D/Concatenate'.format(name_prefix) out = Concatenate(name=concatenate_name)(conv_outputs) return out
Example #11
Source Project: YOLO-3D-Box Author: scutan90 File: model.py License: MIT License | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #12
Source Project: deep_sort_yolov3 Author: Qidian213 File: model.py License: GNU General Public License v3.0 | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #13
Source Project: Generative-Adversarial-Networks-Cookbook Author: PacktPublishing File: discriminator.py License: MIT License | 6 votes |
def model(self): input_A = Input(shape=self.SHAPE) input_B = Input(shape=self.SHAPE) input_layer = Concatenate(axis=-1)([input_A, input_B]) up_layer_1 = Convolution2D(self.FS, kernel_size=4, strides=2, padding='same',activation=LeakyReLU(alpha=0.2))(input_layer) up_layer_2 = Convolution2D(self.FS*2, kernel_size=4, strides=2, padding='same',activation=LeakyReLU(alpha=0.2))(up_layer_1) leaky_layer_2 = BatchNormalization(momentum=0.8)(up_layer_2) up_layer_3 = Convolution2D(self.FS*4, kernel_size=4, strides=2, padding='same',activation=LeakyReLU(alpha=0.2))(leaky_layer_2) leaky_layer_3 = BatchNormalization(momentum=0.8)(up_layer_3) up_layer_4 = Convolution2D(self.FS*8, kernel_size=4, strides=2, padding='same',activation=LeakyReLU(alpha=0.2))(leaky_layer_3) leaky_layer_4 = BatchNormalization(momentum=0.8)(up_layer_4) output_layer = Convolution2D(1, kernel_size=4, strides=1, padding='same')(leaky_layer_4) return Model([input_A, input_B],output_layer)
Example #14
Source Project: keras-yolo3-master Author: lijialinneu File: model.py License: MIT License | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #15
Source Project: perceptron-benchmark Author: advboxes File: model.py License: Apache License 2.0 | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers( darknet.output, 512, num_anchors * (num_classes + 5)) x = compose( DarknetConv2D_BN_Leaky(256, (1, 1)), UpSampling2D(2))(x) x = Concatenate()([x, darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors * (num_classes + 5)) x = compose( DarknetConv2D_BN_Leaky(128, (1, 1)), UpSampling2D(2))(x) x = Concatenate()([x, darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors * (num_classes + 5)) return Model(inputs, [y1, y2, y3])
Example #16
Source Project: ImageAI Author: OlafenwaMoses File: models.py License: MIT License | 6 votes |
def yolo_main(input, num_anchors, num_classes): darknet_network = Model(input, darknet(input)) network, network_1 = last_layers(darknet_network.output, 512, num_anchors * (num_classes + 5), layer_name="last1") network = NetworkConv2D_BN_Leaky( input=network, channels=256, kernel_size=(1,1)) network = UpSampling2D(2)(network) network = Concatenate()([network, darknet_network.layers[152].output]) network, network_2 = last_layers(network, 256, num_anchors * (num_classes + 5), layer_name="last2") network = NetworkConv2D_BN_Leaky(input=network, channels=128, kernel_size=(1, 1)) network = UpSampling2D(2)(network) network = Concatenate()([network, darknet_network.layers[92].output]) network, network_3 = last_layers(network, 128, num_anchors * (num_classes + 5), layer_name="last3") return Model(input, [network_1, network_2, network_3])
Example #17
Source Project: Vehicle-Detection-and-Tracking-Usig-YOLO-and-Deep-Sort-with-Keras-and-Tensorflow Author: Akhtar303 File: model.py License: MIT License | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #18
Source Project: dts Author: albertogaspar File: FFNN.py License: MIT License | 6 votes |
def model_inputs(self, input_shape, conditions_shape=None): """ :param input_shape: np.array (window_size, n_features) :param conditions_shape: np.array (horizon, n_features) :return: a tuple containing: - a list containing all the Input Layers needed by the model - the tensor that has to be feeded to the subsequent layers of the archotecture """ inputs = Input(shape=input_shape, name='input') if conditions_shape is not None: conditions = Input(shape=conditions_shape, name='exogenous') # pass through different filters in order for them to have = no. channels out = Concatenate(axis=1)( [Dense(units=128, activation='sigmoid')(inputs), Dense(units=128, activation='tanh')(conditions)] ) # concatenate over temporal axis return [inputs, conditions], out return inputs, inputs
Example #19
Source Project: keras-yolov3-KF-objectTracking Author: mattzheng File: model.py License: MIT License | 6 votes |
def yolo_body(inputs, num_anchors, num_classes): """Create YOLO_V3 model CNN body in Keras.""" darknet = Model(inputs, darknet_body(inputs)) x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(256, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[152].output]) x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5)) x = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x) x = Concatenate()([x,darknet.layers[92].output]) x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5)) return Model(inputs, [y1,y2,y3])
Example #20
Source Project: Kaggler Author: jeongyoonlee File: categorical.py License: MIT License | 5 votes |
def _get_model(X, cat_cols, num_cols, n_uniq, n_emb, output_activation): inputs = [] num_inputs = [] embeddings = [] for i, col in enumerate(cat_cols): if not n_uniq[i]: n_uniq[i] = X[col].nunique() if not n_emb[i]: n_emb[i] = max(MIN_EMBEDDING, 2 * int(np.log2(n_uniq[i]))) _input = Input(shape=(1,), name=col) _embed = Embedding(input_dim=n_uniq[i], output_dim=n_emb[i], name=col + EMBEDDING_SUFFIX)(_input) _embed = Dropout(.2)(_embed) _embed = Reshape((n_emb[i],))(_embed) inputs.append(_input) embeddings.append(_embed) if num_cols: num_inputs = Input(shape=(len(num_cols),), name='num_inputs') merged_input = Concatenate(axis=1)(embeddings + [num_inputs]) inputs = inputs + [num_inputs] else: merged_input = Concatenate(axis=1)(embeddings) x = BatchNormalization()(merged_input) x = Dense(128, activation='relu')(x) x = Dropout(.5)(x) x = BatchNormalization()(x) x = Dense(64, activation='relu')(x) x = Dropout(.5)(x) x = BatchNormalization()(x) output = Dense(1, activation=output_activation)(x) model = Model(inputs=inputs, outputs=output) return model, n_emb, n_uniq
Example #21
Source Project: keras-utility-layer-collection Author: zimmerrol File: attention.py License: MIT License | 5 votes |
def build(self, input_shape): self._validate_input_shape(input_shape) d_k = self._d_k if self._d_k else input_shape[1][-1] d_model = self._d_model if self._d_model else input_shape[1][-1] d_v = self._d_v if type(d_k) == tf.Dimension: d_k = d_k.value if type(d_model) == tf.Dimension: d_model = d_model.value self._q_layers = [] self._k_layers = [] self._v_layers = [] self._sdp_layer = ScaledDotProductAttention(return_attention=self._return_attention) for _ in range(self._h): self._q_layers.append( TimeDistributed( Dense(d_k, activation=self._activation, use_bias=False) ) ) self._k_layers.append( TimeDistributed( Dense(d_k, activation=self._activation, use_bias=False) ) ) self._v_layers.append( TimeDistributed( Dense(d_v, activation=self._activation, use_bias=False) ) ) self._output = TimeDistributed(Dense(d_model)) #if self._return_attention: # self._output = Concatenate()
Example #22
Source Project: keras-utility-layer-collection Author: zimmerrol File: attention.py License: MIT License | 5 votes |
def __call__(self, x, mask=None): if isinstance(x, (list, tuple)): self.build([it.shape for it in x]) else: self.build(x.shape) q, k, v = x outputs = [] attentions = [] for i in range(self._h): qi = self._q_layers[i](q) ki = self._k_layers[i](k) vi = self._v_layers[i](v) if self._return_attention: output, attention = self._sdp_layer([qi, ki, vi], mask=mask) outputs.append(output) attentions.append(attention) else: output = self._sdp_layer([qi, ki, vi], mask=mask) outputs.append(output) concatenated_outputs = Concatenate()(outputs) output = self._output(concatenated_outputs) if self._return_attention: attention = Concatenate()(attentions) # print("attention", attention, attention.shape) if self._return_attention: return [output, attention] else: return output # https://wanasit.github.io/attention-based-sequence-to-sequence-in-keras.html # https://arxiv.org/pdf/1508.04025.pdf
Example #23
Source Project: Keras-GAN Author: eriklindernoren File: ccgan.py License: MIT License | 5 votes |
def build_generator(self): """U-Net Generator""" def conv2d(layer_input, filters, f_size=4, bn=True): """Layers used during downsampling""" d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) d = LeakyReLU(alpha=0.2)(d) if bn: d = BatchNormalization(momentum=0.8)(d) return d def deconv2d(layer_input, skip_input, filters, f_size=4, dropout_rate=0): """Layers used during upsampling""" u = UpSampling2D(size=2)(layer_input) u = Conv2D(filters, kernel_size=f_size, strides=1, padding='same', activation='relu')(u) if dropout_rate: u = Dropout(dropout_rate)(u) u = BatchNormalization(momentum=0.8)(u) u = Concatenate()([u, skip_input]) return u img = Input(shape=self.img_shape) # Downsampling d1 = conv2d(img, self.gf, bn=False) d2 = conv2d(d1, self.gf*2) d3 = conv2d(d2, self.gf*4) d4 = conv2d(d3, self.gf*8) # Upsampling u1 = deconv2d(d4, d3, self.gf*4) u2 = deconv2d(u1, d2, self.gf*2) u3 = deconv2d(u2, d1, self.gf) u4 = UpSampling2D(size=2)(u3) output_img = Conv2D(self.channels, kernel_size=4, strides=1, padding='same', activation='tanh')(u4) return Model(img, output_img)
Example #24
Source Project: Keras-GAN Author: eriklindernoren File: cyclegan.py License: MIT License | 5 votes |
def build_generator(self): """U-Net Generator""" def conv2d(layer_input, filters, f_size=4): """Layers used during downsampling""" d = Conv2D(filters, kernel_size=f_size, strides=2, padding='same')(layer_input) d = LeakyReLU(alpha=0.2)(d) d = InstanceNormalization()(d) return d def deconv2d(layer_input, skip_input, filters, f_size=4, dropout_rate=0): """Layers used during upsampling""" u = UpSampling2D(size=2)(layer_input) u = Conv2D(filters, kernel_size=f_size, strides=1, padding='same', activation='relu')(u) if dropout_rate: u = Dropout(dropout_rate)(u) u = InstanceNormalization()(u) u = Concatenate()([u, skip_input]) return u # Image input d0 = Input(shape=self.img_shape) # Downsampling d1 = conv2d(d0, self.gf) d2 = conv2d(d1, self.gf*2) d3 = conv2d(d2, self.gf*4) d4 = conv2d(d3, self.gf*8) # Upsampling u1 = deconv2d(d4, d3, self.gf*4) u2 = deconv2d(u1, d2, self.gf*2) u3 = deconv2d(u2, d1, self.gf) u4 = UpSampling2D(size=2)(u3) output_img = Conv2D(self.channels, kernel_size=4, strides=1, padding='same', activation='tanh')(u4) return Model(d0, output_img)
Example #25
Source Project: View-Adaptive-Neural-Networks-for-Skeleton-based-Human-Action-Recognition Author: microsoft File: va-rnn.py License: MIT License | 5 votes |
def creat_model(input_shape, num_class): init = initializers.Orthogonal(gain=args.norm) sequence_input =Input(shape=input_shape) mask = Masking(mask_value=0.)(sequence_input) if args.aug: mask = augmentaion()(mask) X = Noise(0.075)(mask) if args.model[0:2]=='VA': # VA trans = LSTM(args.nhid,recurrent_activation='sigmoid',return_sequences=True,implementation=2,recurrent_initializer=init)(X) trans = Dropout(0.5)(trans) trans = TimeDistributed(Dense(3,kernel_initializer='zeros'))(trans) rot = LSTM(args.nhid,recurrent_activation='sigmoid',return_sequences=True,implementation=2,recurrent_initializer=init)(X) rot = Dropout(0.5)(rot) rot = TimeDistributed(Dense(3,kernel_initializer='zeros'))(rot) transform = Concatenate()([rot,trans]) X = VA()([mask,transform]) X = LSTM(args.nhid,recurrent_activation='sigmoid',return_sequences=True,implementation=2,recurrent_initializer=init)(X) X = Dropout(0.5)(X) X = LSTM(args.nhid,recurrent_activation='sigmoid',return_sequences=True,implementation=2,recurrent_initializer=init)(X) X = Dropout(0.5)(X) X = LSTM(args.nhid,recurrent_activation='sigmoid',return_sequences=True,implementation=2,recurrent_initializer=init)(X) X = Dropout(0.5)(X) X = TimeDistributed(Dense(num_class))(X) X = MeanOverTime()(X) X = Activation('softmax')(X) model=Model(sequence_input,X) return model
Example #26
Source Project: keras-yolo3 Author: bing0037 File: model.py License: MIT License | 5 votes |
def tiny_yolo_body(inputs, num_anchors, num_classes): '''Create Tiny YOLO_v3 model CNN body in keras.''' x1 = compose( DarknetConv2D_BN_Leaky(16, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(32, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(64, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(128, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(256, (3,3)))(inputs) x2 = compose( MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(512, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(1,1), padding='same'), DarknetConv2D_BN_Leaky(1024, (3,3)), DarknetConv2D_BN_Leaky(256, (1,1)))(x1) y1 = compose( DarknetConv2D_BN_Leaky(512, (3,3)), DarknetConv2D(num_anchors*(num_classes+5), (1,1)))(x2) x2 = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x2) y2 = compose( Concatenate(), DarknetConv2D_BN_Leaky(256, (3,3)), DarknetConv2D(num_anchors*(num_classes+5), (1,1)))([x2,x1]) return Model(inputs, [y1,y2])
Example #27
Source Project: keras-ctpn Author: yizt File: models.py License: Apache License 2.0 | 5 votes |
def ctpn(base_features, num_anchors, rnn_units=128, fc_units=512): """ ctpn网络 :param base_features: (B,H,W,C) :param num_anchors: anchors个数 :param rnn_units: :param fc_units: :return: """ x = layers.Conv2D(512, kernel_size=(3, 3), padding='same', name='pre_fc')(base_features) # [B,H,W,512] # 沿着宽度方式做rnn rnn_forward = layers.TimeDistributed(layers.GRU(rnn_units, return_sequences=True, kernel_initializer='he_normal'), name='gru_forward')(x) rnn_backward = layers.TimeDistributed( layers.GRU(rnn_units, return_sequences=True, kernel_initializer='he_normal', go_backwards=True), name='gru_backward')(x) rnn_output = layers.Concatenate(name='gru_concat')([rnn_forward, rnn_backward]) # (B,H,W,256) # conv实现fc fc_output = layers.Conv2D(fc_units, kernel_size=(1, 1), activation='relu', name='fc_output')( rnn_output) # (B,H,W,512) # 分类 class_logits = layers.Conv2D(2 * num_anchors, kernel_size=(1, 1), name='cls')(fc_output) class_logits = layers.Reshape(target_shape=(-1, 2), name='cls_reshape')(class_logits) # 中心点垂直坐标和高度回归 predict_deltas = layers.Conv2D(2 * num_anchors, kernel_size=(1, 1), name='deltas')(fc_output) predict_deltas = layers.Reshape(target_shape=(-1, 2), name='deltas_reshape')(predict_deltas) # 侧边精调(只需要预测x偏移即可) predict_side_deltas = layers.Conv2D(num_anchors, kernel_size=(1, 1), name='side_deltas')(fc_output) predict_side_deltas = layers.Reshape(target_shape=(-1, 1), name='side_deltas_reshape')( predict_side_deltas) return class_logits, predict_deltas, predict_side_deltas
Example #28
Source Project: deep-smoke-machine Author: CMU-CREATE-Lab File: timeception.py License: BSD 3-Clause "New" or "Revised" License | 5 votes |
def __temporal_convolutional_block(tensor, n_channels_per_branch, kernel_sizes, dilation_rates, layer_num, group_num): """ Define 5 branches of convolutions that operate of channels of each group. """ # branch 1: dimension reduction only and no temporal conv t_1 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b1_g%d_tc%d' % (group_num, layer_num))(tensor) t_1 = BatchNormalization(name='bn_b1_g%d_tc%d' % (group_num, layer_num))(t_1) # branch 2: dimension reduction followed by depth-wise temp conv (kernel-size 3) t_2 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b2_g%d_tc%d' % (group_num, layer_num))(tensor) t_2 = DepthwiseConv1DLayer(kernel_sizes[0], dilation_rates[0], padding='same', name='convdw_b2_g%d_tc%d' % (group_num, layer_num))(t_2) t_2 = BatchNormalization(name='bn_b2_g%d_tc%d' % (group_num, layer_num))(t_2) # branch 3: dimension reduction followed by depth-wise temp conv (kernel-size 5) t_3 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b3_g%d_tc%d' % (group_num, layer_num))(tensor) t_3 = DepthwiseConv1DLayer(kernel_sizes[1], dilation_rates[1], padding='same', name='convdw_b3_g%d_tc%d' % (group_num, layer_num))(t_3) t_3 = BatchNormalization(name='bn_b3_g%d_tc%d' % (group_num, layer_num))(t_3) # branch 4: dimension reduction followed by depth-wise temp conv (kernel-size 7) t_4 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b4_g%d_tc%d' % (group_num, layer_num))(tensor) t_4 = DepthwiseConv1DLayer(kernel_sizes[2], dilation_rates[2], padding='same', name='convdw_b4_g%d_tc%d' % (group_num, layer_num))(t_4) t_4 = BatchNormalization(name='bn_b4_g%d_tc%d' % (group_num, layer_num))(t_4) # branch 5: dimension reduction followed by temporal max pooling t_5 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b5_g%d_tc%d' % (group_num, layer_num))(tensor) t_5 = MaxPooling3D(pool_size=(2, 1, 1), strides=(1, 1, 1), padding='same', name='maxpool_b5_g%d_tc%d' % (group_num, layer_num))(t_5) t_5 = BatchNormalization(name='bn_b5_g%d_tc%d' % (group_num, layer_num))(t_5) # concatenate channels of branches tensor = Concatenate(axis=4, name='concat_g%d_tc%d' % (group_num, layer_num))([t_1, t_2, t_3, t_4, t_5]) return tensor
Example #29
Source Project: timeception Author: noureldien File: timeception.py License: GNU General Public License v3.0 | 5 votes |
def __temporal_convolutional_block(tensor, n_channels_per_branch, kernel_sizes, dilation_rates, layer_num, group_num): """ Define 5 branches of convolutions that operate of channels of each group. """ # branch 1: dimension reduction only and no temporal conv t_1 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b1_g%d_tc%d' % (group_num, layer_num))(tensor) t_1 = BatchNormalization(name='bn_b1_g%d_tc%d' % (group_num, layer_num))(t_1) # branch 2: dimension reduction followed by depth-wise temp conv (kernel-size 3) t_2 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b2_g%d_tc%d' % (group_num, layer_num))(tensor) t_2 = DepthwiseConv1DLayer(kernel_sizes[0], dilation_rates[0], padding='same', name='convdw_b2_g%d_tc%d' % (group_num, layer_num))(t_2) t_2 = BatchNormalization(name='bn_b2_g%d_tc%d' % (group_num, layer_num))(t_2) # branch 3: dimension reduction followed by depth-wise temp conv (kernel-size 5) t_3 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b3_g%d_tc%d' % (group_num, layer_num))(tensor) t_3 = DepthwiseConv1DLayer(kernel_sizes[1], dilation_rates[1], padding='same', name='convdw_b3_g%d_tc%d' % (group_num, layer_num))(t_3) t_3 = BatchNormalization(name='bn_b3_g%d_tc%d' % (group_num, layer_num))(t_3) # branch 4: dimension reduction followed by depth-wise temp conv (kernel-size 7) t_4 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b4_g%d_tc%d' % (group_num, layer_num))(tensor) t_4 = DepthwiseConv1DLayer(kernel_sizes[2], dilation_rates[2], padding='same', name='convdw_b4_g%d_tc%d' % (group_num, layer_num))(t_4) t_4 = BatchNormalization(name='bn_b4_g%d_tc%d' % (group_num, layer_num))(t_4) # branch 5: dimension reduction followed by temporal max pooling t_5 = Conv3D(n_channels_per_branch, kernel_size=(1, 1, 1), padding='same', name='conv_b5_g%d_tc%d' % (group_num, layer_num))(tensor) t_5 = MaxPooling3D(pool_size=(2, 1, 1), strides=(1, 1, 1), padding='same', name='maxpool_b5_g%d_tc%d' % (group_num, layer_num))(t_5) t_5 = BatchNormalization(name='bn_b5_g%d_tc%d' % (group_num, layer_num))(t_5) # concatenate channels of branches tensor = Concatenate(axis=4, name='concat_g%d_tc%d' % (group_num, layer_num))([t_1, t_2, t_3, t_4, t_5]) return tensor
Example #30
Source Project: vision-web-service Author: sherlockchou86 File: model.py License: MIT License | 5 votes |
def tiny_yolo_body(inputs, num_anchors, num_classes): '''Create Tiny YOLO_v3 model CNN body in keras.''' x1 = compose( DarknetConv2D_BN_Leaky(16, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(32, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(64, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(128, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(256, (3,3)))(inputs) x2 = compose( MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'), DarknetConv2D_BN_Leaky(512, (3,3)), MaxPooling2D(pool_size=(2,2), strides=(1,1), padding='same'), DarknetConv2D_BN_Leaky(1024, (3,3)), DarknetConv2D_BN_Leaky(256, (1,1)))(x1) y1 = compose( DarknetConv2D_BN_Leaky(512, (3,3)), DarknetConv2D(num_anchors*(num_classes+5), (1,1)))(x2) x2 = compose( DarknetConv2D_BN_Leaky(128, (1,1)), UpSampling2D(2))(x2) y2 = compose( Concatenate(), DarknetConv2D_BN_Leaky(256, (3,3)), DarknetConv2D(num_anchors*(num_classes+5), (1,1)))([x2,x1]) return Model(inputs, [y1,y2])