def create_dlinknet(): inputs = Input(shape=INPUT_SHAPE) inputs_ = Conv2D(64, kernel_size=(3, 3), padding='same')(inputs) inputs_ = BatchNormalization()(inputs_) inputs_ = Activation('relu')(inputs_) max_pool_inputs = MaxPooling2D((2, 2), strides=(2, 2))(inputs_) encoded_1, encoded_pool_1 = encoder_block(max_pool_inputs, num_filters=64, num_res_blocks=3) encoded_2, encoded_pool_2 = encoder_block(encoded_pool_1, num_filters=128, num_res_blocks=4) encoded_3, encoded_pool_3 = encoder_block(encoded_pool_2, num_filters=256, num_res_blocks=6) encoded_4, encoded_pool_4 = encoder_block(encoded_pool_3, num_filters=512, num_res_blocks=3) center = dilated_center_block(encoded_4, 512) decoded_1 = Add()([decoder_block(center, 256), encoded_3]) decoded_2 = Add()([decoder_block(decoded_1, 128), encoded_2]) decoded_3 = Add()([decoder_block(decoded_2, 64), encoded_1]) decoded_4 = decoder_block(decoded_3, 64) final = Conv2DTranspose(32, kernel_size=(3, 3), padding='same')(decoded_4) outputs = Conv2D(1, (1, 1), activation='sigmoid')(final) model_i = Model(inputs=[inputs], outputs=[outputs]) model_i.compile(optimizer='adam', loss=combined_loss, metrics=[dice_coeff]) model_i.summary() # model_i.load_weights(save_model_path) return model_i
def up_projection(lt_, nf, s, block): with tf.name_scope('up_' + str(block)): if s == 2: ht = Conv2DTranspose(nf, 2, strides=2)(lt_) ht = PReLU()(ht) lt = ZeroPadding2D(2)(ht) lt = Conv2D(nf, 6, 2)(lt) lt = PReLU()(lt) et = Subtract()([lt, lt_]) ht1 = Conv2DTranspose(nf, 2, strides=2)(et) ht1 = PReLU()(ht1) ht1 = Add()([ht, ht1]) return (ht1) if s == 4: ht = Conv2DTranspose(nf, 4, strides=4)(lt_) ht = PReLU()(ht) lt = ZeroPadding2D(2)(ht) lt = Conv2D(nf, 8, strides=4)(lt) lt = PReLU()(lt) et = Subtract()([lt, lt_]) ht1 = Conv2DTranspose(nf, 4, strides=4)(et) ht1 = PReLU()(ht1) ht1 = Add()([ht, ht1]) return (ht1) if s == 8: ht = Conv2DTranspose(nf, 8, strides=8)(lt_) ht = PReLU()(ht) lt = ZeroPadding2D(2)(ht) lt = Conv2D(nf, 12, strides=8)(lt) lt = PReLU()(lt) et = Subtract()([lt, lt_]) ht1 = Conv2DTranspose(nf, 8, strides=8)(et) ht1 = PReLU()(ht1) ht1 = Add()([ht, ht1]) return (ht1)
def phase_residual_block_2(X): X_main = Conv2D(16, (1, 1), strides=(2, 2), padding='same', kernel_initializer='he_normal')(X) X_main = BatchNormalization()(X_main) X_main = Conv2D(16, (3, 3), padding='same', kernel_initializer='he_normal')(X_main) X_main = BatchNormalization()(X_main) X_main = Lambda(crelu)(X_main) X_main = Conv2D(48, (1, 1), padding='same', kernel_initializer='he_normal')(X_main) X_main = BatchNormalization()(X_main) X_res_branch = Conv2D(48, (1, 1), strides=(2, 2), padding='same', kernel_initializer='he_normal')(X) X_res_branch = BatchNormalization()(X_res_branch) X_combined = Add()([X_main, X_res_branch]) X_main = Conv2D(16, (1, 1), padding='same', kernel_initializer='he_normal')(X_combined) X_main = BatchNormalization()(X_main) X_main = Conv2D(16, (3, 3), padding='same', kernel_initializer='he_normal')(X_main) X_main = BatchNormalization()(X_main) X_main = Lambda(crelu)(X_main) X_main = Conv2D(48, (1, 1), padding='same', kernel_initializer='he_normal')(X_main) X_main = BatchNormalization()(X_main) X_combined = Add()([X_main, X_combined]) return X_combined
def _create_decoder(input_shape, encode_block): conv3 = encode_block.get_layer('conv3').output x = Input(shape=input_shape, name='decoder_input') net = Add()([x, conv3]) conv2 = encode_block.get_layer('conv2').output net = Conv2DTranspose(filters=64, kernel_size=3, strides=2, name='dconv1')(x) net = Add()([net, conv2]) net = BatchNormalization()(net) net = Conv2DTranspose(filters=32, kernel_size=3, strides=2, name='dconv2')(net) net = BatchNormalization()(net) encoder_input = encode_block.get_layer('encoder_input').output net = Conv2DTranspose(filters=1, kernel_size=3, strides=2, name='dconv3')(net) net = Add()([net, encoder_input]) net = BatchNormalization()(net) net = Model(inputs=[x, encode_block.input], outputs=net, name='decoder') return net
def resdual_net(x, num_filters, num_blocks, name=None): x = Lambda(padding)(x) x = Conv2D(filters=num_filters, kernel_size=3, strides=2, padding='VALID', use_bias=False)(x) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.1)(x) for i in range(num_blocks): y = Conv2D(filters=num_filters // 2, kernel_size=1, strides=1, padding='VALID', use_bias=False)(x) y = BatchNormalization()(y) y = LeakyReLU(alpha=0.1)(y) y = Lambda(padding)(y) y = Conv2D(filters=num_filters, kernel_size=3, strides=1, padding='VALID', use_bias=False)(y) y = BatchNormalization()(y) y = LeakyReLU(alpha=0.1)(y) if i == num_blocks - 1: x = Add(name=name)([x, y]) else: x = Add()([x, y]) return x
def edsr(scale, num_filters=64, num_res_blocks=8, res_block_scaling=None): x_in = Input(shape=(None, None, 3)) # print(tf.keras.backend.shape(x_in)) x = Lambda(normalize)(x_in) # print(tf.keras.backend.shape(x)) x = b = Conv2D(num_filters, 3, padding='same')(x) # print(tf.keras.backend.shape(x)) for i in range(num_res_blocks): b = res_block(b, num_filters, res_block_scaling) print(tf.keras.backend.shape(b)) if i == 8: b = Add()([x, b]) b = cpy = upsample(b, 2, num_filters, 'upscale_1') b = srcnn(b) # if i == 15: # b = upsample(b, 2, num_filters, 'upscale_2') b = Conv2D(num_filters, 3, padding='same')(b) # print(tf.keras.backend.shape(b)) # x = Add()([x, b]) # print(tf.keras.backend.shape(b)) b = Add()([b, cpy]) x = upsample(b, 2, num_filters, 'upscale_2') x = srcnn(x) # x = upsample(x, 4, num_filters, 'upscale_3') # print(tf.keras.backend.shape(b)) x = Conv2D(3, 3, padding='same')(x) # print(tf.keras.backend.shape(b)) x = Lambda(denormalize)(x) # print(tf.keras.backend.shape(b)) # print("Done") return Model(x_in, x, name="edsr")
def stresnet(c_conf=(3, 2, 32, 32), p_conf=(3, 2, 32, 32), t_conf=(3, 2, 32, 32), external_dim=8, nb_residual_unit=3, CF=64): ''' C - Temporal Closeness P - Period T - Trend conf = (len_seq, nb_flow, map_height, map_width) external_dim ''' # main input main_inputs = [] outputs = [] for conf in [c_conf, p_conf, t_conf]: if conf is not None: len_seq, nb_flow, map_height, map_width = conf input = Input(shape=(nb_flow * len_seq, map_height, map_width)) main_inputs.append(input) # Conv1 conv1 = Convolution2D( filters=CF, kernel_size=(3, 3), padding="same")(input) # [nb_residual_unit] Residual Units residual_output = ResUnits(_residual_unit, nb_filter=CF, repetations=nb_residual_unit)(conv1) # Conv2 activation = Activation('relu')(residual_output) conv2 = Convolution2D( filters=nb_flow, kernel_size=(3, 3), padding="same")(activation) outputs.append(conv2) # parameter-matrix-based fusion if len(outputs) == 1: main_output = outputs[0] else: from BikeNYC.DST_network.ilayer import iLayer new_outputs = [] for output in outputs: new_outputs.append(iLayer()(output)) main_output = Add()(new_outputs) # fusing with external component if external_dim != None and external_dim > 0: # external input external_input = Input(shape=(external_dim,)) main_inputs.append(external_input) embedding = Dense(units=10)(external_input) embedding = Activation('relu')(embedding) h1 = Dense(units=nb_flow * map_height * map_width)(embedding) activation = Activation('relu')(h1) external_output = Reshape((nb_flow, map_height, map_width))(activation) main_output = Add()([main_output, external_output]) else: print('external_dim:', external_dim) main_output = Activation('tanh')(main_output) model = Model(input=main_inputs, output=main_output) return model
def add_model(self, input_data, target_data=None): """Implements core of model that transforms input_data into predictions. The core transformation for this model which transforms a batch of input data into a batch of predictions. Args: input_data: A tensor of shape (batch_size, num_steps, time_stamps). target_data: A tensor of shape (batch_size, num_steps, time_stamps). Returns: predict: A tensor of shape (batch_size, num_steps, time_stamps) """ # Consider signal matrix as an image with channels. height = self.config.num_steps width = self.config.time_stamps channels = self.config.channels batch_size = self.config.batch_size # input_data: (-1, height, width, channels) input_data = tf.reshape(input_data, [-1, channels, height, width]) input_data = tf.transpose(input_data, perm=[0, 2, 3, 1]) x0 = Convolution2D(64, (3, 3), activation='relu', padding='same', name='sr_res_conv1')(input_data) x1 = Convolution2D(64, (3, 3), activation='relu', padding='same', strides=(2, 2), name='sr_res_conv2')(x0) x2 = Convolution2D(64, (3, 3), activation='relu', padding='same', strides=(2, 2), name='sr_res_conv3')(x1) x = self._residual_block(x2, 1) for i in range(self.config.nb_residual): x = self._residual_block(x, i + 2) x = Add()([x, x2]) x = self._upscale_block(x, 1) x = Add()([x, x1]) x = self._upscale_block(x, 2) x = Add()([x, x0]) output = Convolution2D(self.config.channels, (3, 3), activation="linear", padding='same', name='sr_res_conv_final')(x) prediction = tf.transpose(output, perm=[0, 3, 1, 2]) prediction = tf.reshape(prediction, [batch_size, height, width]) return prediction
def backbone(input_shape=(512, 512, 3)): image = Input(shape=input_shape, name="image") base_model = ResNet50(input_tensor=image, include_top=False, weights=None) x = base_model.get_layer(name="activation_48").output x = _deconv_block(x, 1024) x = Add()([x, base_model.get_layer(name="activation_39").output]) x = _deconv_block(x, 512) x = Add()([x, base_model.get_layer(name="activation_21").output]) model = Model(image, x) return model, 8
def relation_attention_module(glob_fts, fts): attention_weights = [] for i in range(len(fts)): fts[i] = Concatenate()([fts[i], glob_fts]) weight = attention_extractor(fts[i]) fts[i] = Multiply()([fts[i], weight]) attention_weights.append(weight) total_weights = Add()(attention_weights) numerator = Add()( fts) # numerator of fraction in definition of P_ran (see paper) final_representation = Lambda(lambda_divide)([numerator, total_weights]) return final_representation
def self_attention_module(crops, CNN): attention_weights = [] for i in range(len(crops)): crops[i] = CNN(crops[i]) weight = attention_extractor(crops[i]) crops[i] = Multiply()([crops[i], weight]) attention_weights.append(weight) total_weights = Add()(attention_weights) numerator = Add()( crops) # numerator of fraction in definition of F_m (see paper) global_feature_representation = Lambda(lambda_divide)( [numerator, total_weights]) return global_feature_representation
def UNet3D_Isensee(input_shape=(4, 128, 128, 128), nchannels=(16, 32, 64, 128, 256), n_labels=3, activation='sigmoid', n_segmentation_level=3): inputs = Input(input_shape) current_layer = inputs downsample_level = [] segmentation_level = [] for idx, filters in enumerate(nchannels): if idx == 0: in_conv = convolution_module(current_layer, filters, activation=LeakyReLU, instance_norm=True) else: in_conv = convolution_module(current_layer, filters, activation=LeakyReLU, strides=(2, 2, 2), instance_norm=True) context_layer = context_module(in_conv, filters, dropout=0.3) add_layer = Add()([in_conv, context_layer]) downsample_level.append(add_layer) current_layer = add_layer for idx, filters in reversed(list(enumerate(nchannels[:-1:]))): upsample_conv = upsampling_module(current_layer, filters) current_layer = concatenate([upsample_conv, downsample_level[idx]], axis=1) localization = localization_module(current_layer, filters) current_layer = localization if idx < n_segmentation_level: layer = Conv3D(n_labels, kernel_size=(1, 1, 1), data_format='channels_first')(localization) segmentation_level.append(layer) output_layer = None for idx in range(len(segmentation_level)): if output_layer is None: output_layer = segmentation_level[idx] else: output_layer = Add()([output_layer, segmentation_level[idx]]) if idx != len(segmentation_level) - 1: output_layer = UpSampling3D( size=(2, 2, 2), data_format='channels_first')(output_layer) act = Activation(activation)(output_layer) model = Model(inputs=inputs, outputs=act) return model
def backbone(input_shape=(512, 512, 3)): image = Input(shape=input_shape, name="image") base_model = MobileNet(input_tensor=image, include_top=False, weights="imagenet") x = base_model.output x = _deconv_block(x, 512, kernel_size=3) y = base_model.layers[81].output x = Add()([x, y]) x = _deconv_block(x, 256, kernel_size=3) y = base_model.layers[39].output x = Add()([x, y]) model = Model(image, x) return model, 8
def build_model(): input = Input(shape=(257, 1091, 1)) [x, weight] = attentionModule(input) x = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) #block 1 residual = x x = _bn_relu(x) x = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) x = _bn_relu(x) x = Conv2D(16, kernel_size=(3, 3), strides=(1,1), padding="same", kernel_initializer="glorot_normal")(x) x = Add()([x, residual]) #x += residual x = MaxPooling2D(pool_size=(1, 2))(x) x = Conv2D(32, kernel_size=(3, 3), dilation_rate=(2,2), kernel_initializer="glorot_normal")(x) x = ZeroPadding2D()(x) x = residualBlock(pool_size=(1,2), dilation_rate=(4,4))(x) x = residualBlock(pool_size=(2,2), dilation_rate=(4,4))(x) x = residualBlock(pool_size=(2,2), dilation_rate=(8,8))(x) x = residualBlock(pool_size=(2,2), dilation_rate=(8,8))(x) x = Flatten()(x) x = Dense(32, kernel_initializer="glorot_normal")(x) residual = x x = _bn_relu_dense(x) x = Dense(32, kernel_initializer="glorot_normal")(x) x = _bn_relu_dense(x) x = Dense(32, kernel_initializer="glorot_normal")(x) x = Add()([x, residual]) #x += residual ### residual = x x = _bn_relu_dense(x) x = Dense(32, kernel_initializer="glorot_normal")(x) x = _bn_relu_dense(x) x = Dense(32, kernel_initializer="glorot_normal")(x) x = Add()([x, residual]) #x += residual ### x = _bn_relu_dense(x) dense = Dense(1, kernel_initializer="glorot_normal", activation="sigmoid")(x) model = Model(inputs=input, outputs=dense) weight_model = Model(inputs=input, outputs=weight) return model, weight_model
def channel_attention_m(x, residual=False, stream=False): if not stream: # dims: BxHxWxCxM (M streams) if isinstance(x, list): x = Lambda(lambda var: K.stack(var, axis=4))(x) y = GlobalMaxPooling3D()(x) y = Lambda(lambda var: K.expand_dims( K.expand_dims(K.expand_dims(var, axis=1), axis=2), axis=3))(y) y = Conv3D(filters=int(K.int_shape(x)[-1] / 2), kernel_size=1, strides=1)(y) y = Activation("relu")(y) y = Conv3D(filters=K.int_shape(x)[-1], kernel_size=1, strides=1)(y) y = Activation("softmax")(y) y = Lambda(lambda var: tf.multiply(*var))([x, y]) if residual: y = Add()([y, x]) else: # dims: BxHxWxCxM (M streams) y = GlobalMaxPooling3D()(x) y = Lambda(lambda var: K.expand_dims( K.expand_dims(K.expand_dims(var, axis=1), axis=2), axis=3))(y) y = Conv3D(filters=int(K.int_shape(x)[-1] / 2), kernel_size=1, strides=1)(y) y = Activation("relu")(y) y = Conv3D(filters=2, kernel_size=1, strides=1)(y) y = Activation("sigmoid")(y) y_l = [] c = int(x.get_shape().as_list()[-1] / 2) for i in range(2): ind_st = i * c ind_end = (i + 1) * c x_sub = Lambda(slicing, arguments={ 'index': ind_st, 'index_end': ind_end })(x) y_sub = Lambda(slicing, arguments={ 'index': i, 'index_end': i + 1 })(y) y = Lambda(lambda var: tf.multiply(*var))([x_sub, y_sub]) if residual: y = Add()([y, x_sub]) y_l.append(y) y = concatenate(y_l) return y
def compile_dueling_deep_q_network(): he = variance_scaling_initializer() model_input = Input(shape=(STATE_SHAPE, )) x = Dense(DENSE_LAYER_DIMS, input_shape=(STATE_SHAPE, ), kernel_initializer=he, activation=ACTIVATION_FUNCTION)(model_input) # x = Dense(DENSE_LAYER_DIMS, kernel_initializer=he, activation=ACTIVATION_FUNCTION)(x) # val_stream, adv_stream = Lambda(lambda w: tf.split(w, 2, 3))(x) val_stream, adv_stream = Lambda(lambda w: tf.split(w, 2, 1))(x) val_stream = Flatten()(val_stream) val = Dense(1, kernel_initializer=he)(val_stream) adv_stream = Flatten()(adv_stream) adv = Dense(NUMBER_OF_ACTIONS, kernel_initializer=he)(adv_stream) # Combine streams into Q-Values reduce_mean = Lambda(lambda w: tf.reduce_mean(w, axis=1, keepdims=True) ) # custom layer for reduce mean q_vals = Add()([val, Subtract()([adv, reduce_mean(adv)])]) # Build model model = Model(model_input, q_vals) model.compile(Adam(LEARNING_RATE), loss=LOSS_FUNCTION) return model
def create_pyramid_level(backbone_input, upsamplelike_input=None, addition_input=None, level=5, ndim=2, feature_size=256): """Create a pyramid layer from a particular backbone input layer. Args: backbone_input (layer): Backbone layer to use to create they pyramid layer upsamplelike_input ([type], optional): Defaults to None. Input to use as a template for shape to upsample to addition_input (layer, optional): Defaults to None. Layer to add to pyramid layer after conv and upsample level (int, optional): Defaults to 5. Level to use in layer names feature_size (int, optional): Defaults to 256. Number of filters for convolutional layer ndim: The spatial dimensions of the input data. Default is 2, but it also works with 3 Returns: (pyramid final, pyramid upsample): Pyramid layer after processing, upsampled pyramid layer """ acceptable_ndims = {2, 3} if ndim not in acceptable_ndims: raise ValueError('Only 2 and 3 dimensional networks are supported') reduced_name = 'C%s_reduced' % level upsample_name = 'P%s_upsampled' % level addition_name = 'P%s_merged' % level final_name = 'P%s' % level # Apply 1x1 conv to backbone layer if ndim == 2: pyramid = Conv2D(feature_size, (1, 1), strides=(1, 1), padding='same', name=reduced_name)(backbone_input) else: pyramid = Conv3D(feature_size, (1, 1, 1), strides=(1, 1, 1), padding='same', name=reduced_name)(backbone_input) # Upsample pyramid input if upsamplelike_input is not None: pyramid_upsample = UpsampleLike(name=upsample_name)( [pyramid, upsamplelike_input]) else: pyramid_upsample = None # Add and then 3x3 conv if addition_input is not None: pyramid = Add(name=addition_name)([pyramid, addition_input]) if ndim == 2: pyramid_final = Conv2D(feature_size, (3, 3), strides=(1, 1), padding='same', name=final_name)(pyramid) else: pyramid_final = Conv3D(feature_size, (3, 3, 3), strides=(1, 1, 1), padding='same', name=final_name)(pyramid) return pyramid_final, pyramid_upsample
def init_model(self): x = Input(shape=(11, 11, N_FEATURES)) layer = Conv2D(128, 3, padding="same", activation="relu")(x) for _ in range(2): res = layer layer = Conv2D(128, 3, padding="same", activation="relu")(layer) layer = Conv2D(128, 3, padding="same", activation="relu")(layer) layer = Conv2D(128, 3, padding="same")(layer) layer = Add()([layer, res]) layer = Activation("relu")(layer) y = Conv2D(64, 1, padding="same", activation="relu")(layer) y = Flatten()(y) y = Dense(64, activation="relu")(y) y = Dense(16, activation="relu")(y) y = Dense(N_ACTIONS, activation='softmax', name="y")(y) message = Conv2D(64, 1, padding="same", activation="relu")(layer) message = Flatten()(message) message = Dense(64, activation="relu")(message) message = Dense(16, activation="relu")(message) message = Dense(N_MESSAGE_BITS, name="message")(message) model = tf.keras.models.Model(inputs=x, outputs=[y, message]) model.compile(loss='sparse_categorical_crossentropy', optimizer=tf.keras.optimizers.Adam(lr=LR), metrics=['accuracy'], loss_weights=[1., 0.]) self.model = model
def residual_block(input, input_channels=None, output_channels=None, kernel_size=(3, 3), stride=1): """ full pre-activation residual block https://arxiv.org/pdf/1603.05027.pdf """ if output_channels is None: output_channels = input.get_shape()[-1].value if input_channels is None: input_channels = output_channels // 4 strides = (stride, stride) x = BatchNormalization()(input) x = Activation('relu')(x) x = Conv2D(input_channels, (1, 1))(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2D(input_channels, kernel_size, padding='same', strides=stride)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2D(output_channels, (1, 1), padding='same')(x) if input_channels != output_channels or stride != 1: input = Conv2D(output_channels, (1, 1), padding='same', strides=strides)(input) x = Add()([x, input]) return x
def sr_resnet(num_filters=64, num_res_blocks=16): lr_input = Input(shape=(24, 24, 3)) x_start = Conv2D(64, kernel_size=3, strides=1, padding='same')(lr_input) x_start = LeakyReLU(0.2)(x_start) x = RRDB(x_start) x = Conv2D(64, kernel_size=3, strides=1, padding='same')(x) x = Lambda(lambda x: x * 0.2)(x) x = Add()([x, x_start]) x = upsample(x, 1) if upscaling_factor > 2: x = upsample(x, 2) if upscaling_factor > 4: x = upsample(x, 3) x = Conv2D(64, kernel_size=3, strides=1, padding='same')(x) x = LeakyReLU(0.2)(x) hr_output = Conv2D(channels, kernel_size=3, strides=1, padding='same', activation='tanh')(x) model = Model(inputs=lr_input, outputs=hr_output) return model
def wdsr(scale, num_filters, num_res_blocks, res_block_expansion, res_block_scaling, res_block): x_in = Input(shape=(None, None, 3)) x = Lambda(normalize)(x_in) # main branch m = conv2d_weightnorm(num_filters, 3, padding='same')(x) for i in range(num_res_blocks): m = res_block(m, num_filters, res_block_expansion, kernel_size=3, scaling=res_block_scaling) m = conv2d_weightnorm(3 * scale**2, 3, padding='same', name=f'conv2d_main_scale_{scale}')(m) m = Lambda(subpixel_conv2d(scale))(m) # skip branch s = conv2d_weightnorm(3 * scale**2, 5, padding='same', name=f'conv2d_skip_scale_{scale}')(x) s = Lambda(subpixel_conv2d(scale))(s) x = Add()([m, s]) x = Lambda(denormalize)(x) return Model(x_in, x, name="wdsr")
def build_model(self, vocab_size: int, vector_dim: int): """ Builds the Keras model. :param vocab_size: The number of distinct words. :param vector_dim: The vector dimension of each word. :return: the Keras GloVe model. """ input_target = Input((1, ), name="central_word_id") input_context = Input((1, ), name="context_word_id") central_embedding = Embedding(vocab_size, vector_dim, input_length=1, name=CNTRL_EMB)(input_target) central_bias = Embedding(vocab_size, 1, input_length=1, name=CNTRL_BS)(input_target) context_embedding = Embedding(vocab_size, vector_dim, input_length=1, name=CTX_EMB)(input_context) context_bias = Embedding(vocab_size, 1, input_length=1, name=CTX_BS)(input_context) dot_product = Dot(axes=-1)([central_embedding, context_embedding]) dot_product = Reshape((1, ))(dot_product) bias_target = Reshape((1, ))(central_bias) bias_context = Reshape((1, ))(context_bias) prediction = Add()([dot_product, bias_target, bias_context]) model = Model(inputs=[input_target, input_context], outputs=prediction) model.compile(loss=self.custom_loss, optimizer=Adagrad(lr=self.lr)) print(model.summary()) return model
def RRDB(input): x = dense_block(input) x = dense_block(x) x = dense_block(x) x = Lambda(lambda x: x * 0.2)(x) out = Add()([x, input]) return out
def _residual_block(self, ip, id): mode = True if self.config.mode == 'train' else False channel_axis = 1 if K.image_data_format() == 'channels_first' else -1 init = ip x = Convolution2D(self.config.n, (3, 3), activation='linear', padding='same', name='sr_res_conv_' + str(id) + '_1')(ip) x = BatchNormalization(axis=channel_axis, name="sr_res_batchnorm_" + str(id) + "_1")( x, training=mode) x = Activation('relu', name="sr_res_activation_" + str(id) + "_1")(x) x = Convolution2D(64, (3, 3), activation='linear', padding='same', name='sr_res_conv_' + str(id) + '_2')(x) x = BatchNormalization(axis=channel_axis, name="sr_res_batchnorm_" + str(id) + "_2")( x, training=mode) m = Add(name="sr_res_merge_" + str(id))([x, init]) return m
def build_model(self): input_state = keras.layers.Input(shape=self.state_shape, name='state_input') input_action = keras.layers.Input(shape=(self.action_size, ), name='action_input') input_size = self.get_input_size(self.state_shape) out = Reshape((input_size, ))(input_state) with tf.variable_scope(self.scope): for i in range(self.act_insert_block): out = dense_block(out, self.hiddens[i], self.activations[i], self.layer_norm, self.noisy_layer) val = out adv = Concatenate(axis=1)([out, input_action]) for i in range(self.act_insert_block, len(self.hiddens)): val = dense_block(val, self.hiddens[i], self.activations[i], self.layer_norm, self.noisy_layer) adv = dense_block(adv, self.hiddens[i], self.activations[i], self.layer_norm, self.noisy_layer) val = Dense(1, self.out_activation, kernel_initializer=RandomUniform(-3e-3, 3e-3), bias_initializer=RandomUniform(-3e-3, 3e-3))(val) adv = Dense(1, self.out_activation, kernel_initializer=RandomUniform(-3e-3, 3e-3), bias_initializer=RandomUniform(-3e-3, 3e-3))(adv) out = Add()([val, adv]) model = keras.models.Model(inputs=[input_state, input_action], outputs=out) return model
def wdsr(scale, num_filters, num_res_blocks, res_block_expansion, res_block_scaling, res_block): """ WDSR model edited to be single channel uint16 """ x_in = Input(shape=(None, None, 1)) x = Lambda(normalize)(x_in) # main branch # m = conv2d_weightnorm(num_filters, 3, padding='same')(x) m = conv2d_weightnorm(num_filters, 1, padding='same')(x) for i in range(num_res_blocks): m = res_block(m, num_filters, res_block_expansion, kernel_size=3, scaling=res_block_scaling) m = conv2d_weightnorm(1 * scale**2, 3, padding='same', name=f'conv2d_main_scale_{scale}')(m) m = Lambda(pixel_shuffle(scale))(m) # skip branch s = conv2d_weightnorm(1 * scale**2, 5, padding='same', name=f'conv2d_skip_scale_{scale}')(x) s = Lambda(pixel_shuffle(scale))(s) x = Add()([m, s]) x = Lambda(denormalize)(x) return Model(x_in, x, name="wdsr")
def build_model(seq_len: int, word_embedding_dim: int, vocab_size: int, hidden_state_dim: int, learning_rate: float): sequence_input = Input(shape=(seq_len, ), dtype='int32') embeddings = Embedding(vocab_size, word_embedding_dim, input_length=seq_len)(sequence_input) lstm = Bidirectional( LSTM(hidden_state_dim, return_sequences=True, return_state=True, dropout=.5, recurrent_dropout=.4))(embeddings) lstm, forward_h, forward_c, backward_h, backward_c = Bidirectional( LSTM(hidden_state_dim, return_sequences=True, return_state=True, dropout=0.5, recurrent_dropout=.4))(lstm) state_h = Add()([forward_h, backward_h]) attention = Attention(hidden_state_dim) context_vector, attention_weights = attention(lstm, state_h) dense = Dense(100, activation='relu')(context_vector) dropout = Dropout(rate=.3)(dense) output = Dense(1, activation='sigmoid')(dropout) model = Model(inputs=sequence_input, outputs=output, name="TweetsModel") print(model.summary()) model.compile(optimizer=Nadam(lr=learning_rate), loss='binary_crossentropy', metrics=['accuracy']) return model
def res_block(x_in, filters, scaling): x = Conv2D(filters, 3, padding='same', activation='relu')(x_in) x = Conv2D(filters, 3, padding='same')(x) if scaling: x = Lambda(lambda t: t * scaling)(x) x = Add()([x_in, x]) return x
def _inverted_res_block(inputs, expansion, stride, alpha, filters, block_id, skip_connection, rate=1): in_channels = inputs.shape[-1].value # inputs._keras_shape[-1] pointwise_conv_filters = int(filters * alpha) pointwise_filters = _make_divisible(pointwise_conv_filters, 8) x = inputs prefix = 'expanded_conv_{}_'.format(block_id) if block_id: # Expand x = Conv2D(expansion * in_channels, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'expand')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'expand_BN')(x) x = Activation(tf.nn.relu6, name=prefix + 'expand_relu')(x) else: prefix = 'expanded_conv_' # Depthwise x = DepthwiseConv2D(kernel_size=3, strides=stride, activation=None, use_bias=False, padding='same', dilation_rate=(rate, rate), name=prefix + 'depthwise')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'depthwise_BN')(x) x = Activation(tf.nn.relu6, name=prefix + 'depthwise_relu')(x) # Project x = Conv2D(pointwise_filters, kernel_size=1, padding='same', use_bias=False, activation=None, name=prefix + 'project')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name=prefix + 'project_BN')(x) if skip_connection: return Add(name=prefix + 'add')([inputs, x]) # if in_channels == pointwise_filters and stride == 1: # return Add(name='res_connect_' + str(block_id))([inputs, x]) return x
def dilated_center_block(input_tensor, num_filters): dilation_1 = Conv2D(num_filters, kernel_size=(3, 3), dilation_rate=(1, 1), padding='same')(input_tensor) dilation_1 = Activation('relu')(dilation_1) dilation_2 = Conv2D(num_filters, kernel_size=(3, 3), dilation_rate=(2, 2), padding='same')(dilation_1) dilation_2 = Activation('relu')(dilation_2) dilation_4 = Conv2D(num_filters, kernel_size=(3, 3), dilation_rate=(4, 4), padding='same')(dilation_2) dilation_4 = Activation('relu')(dilation_4) dilation_8 = Conv2D(num_filters, kernel_size=(3, 3), dilation_rate=(8, 8), padding='same')(dilation_4) dilation_8 = Activation('relu')(dilation_8) final_diliation = Add()( [input_tensor, dilation_1, dilation_2, dilation_4, dilation_8]) return final_diliation