def bn_feature_net_2D(receptive_field=61, input_shape=(256, 256, 1), n_features=3, n_channels=1, reg=1e-5, n_conv_filters=64, n_dense_filters=200, VGG_mode=False, init='he_normal', norm_method='std', location=False, dilated=False, padding=False, padding_mode='reflect', multires=False, include_top=True): # Create layers list (x) to store all of the layers. # We need to use the functional API to enable the multiresolution mode x = [] win = (receptive_field - 1) // 2 if dilated: padding = True if K.image_data_format() == 'channels_first': channel_axis = 1 row_axis = 2 col_axis = 3 if not dilated: input_shape = (n_channels, receptive_field, receptive_field) else: row_axis = 1 col_axis = 2 channel_axis = -1 if not dilated: input_shape = (receptive_field, receptive_field, n_channels) x.append(Input(shape=input_shape)) x.append(ImageNormalization2D(norm_method=norm_method, filter_size=receptive_field)(x[-1])) if padding: if padding_mode == 'reflect': x.append(ReflectionPadding2D(padding=(win, win))(x[-1])) elif padding_mode == 'zero': x.append(ZeroPadding2D(padding=(win, win))(x[-1])) if location: x.append(Location2D(in_shape=tuple(x[-1].shape.as_list()[1:]))(x[-1])) x.append(Concatenate(axis=channel_axis)([x[-2], x[-1]])) if multires: layers_to_concat = [] rf_counter = receptive_field block_counter = 0 d = 1 while rf_counter > 4: filter_size = 3 if rf_counter % 2 == 0 else 4 x.append(Conv2D(n_conv_filters, (filter_size, filter_size), dilation_rate=d, kernel_initializer=init, padding='valid', kernel_regularizer=l2(reg))(x[-1])) x.append(BatchNormalization(axis=channel_axis)(x[-1])) x.append(Activation('relu')(x[-1])) block_counter += 1 rf_counter -= filter_size - 1 if block_counter % 2 == 0: if dilated: x.append(DilatedMaxPool2D(dilation_rate=d, pool_size=(2, 2))(x[-1])) d *= 2 else: x.append(MaxPool2D(pool_size=(2, 2))(x[-1])) if VGG_mode: n_conv_filters *= 2 rf_counter = rf_counter // 2 if multires: layers_to_concat.append(len(x) - 1) if multires: c = [] for l in layers_to_concat: output_shape = x[l].get_shape().as_list() target_shape = x[-1].get_shape().as_list() row_crop = int(output_shape[row_axis] - target_shape[row_axis]) if row_crop % 2 == 0: row_crop = (row_crop // 2, row_crop // 2) else: row_crop = (row_crop // 2, row_crop // 2 + 1) col_crop = int(output_shape[col_axis] - target_shape[col_axis]) if col_crop % 2 == 0: col_crop = (col_crop // 2, col_crop // 2) else: col_crop = (col_crop // 2, col_crop // 2 + 1) cropping = (row_crop, col_crop) c.append(Cropping2D(cropping=cropping)(x[l])) x.append(Concatenate(axis=channel_axis)(c)) x.append(Conv2D(n_dense_filters, (rf_counter, rf_counter), dilation_rate=d, kernel_initializer=init, padding='valid', kernel_regularizer=l2(reg))(x[-1])) x.append(BatchNormalization(axis=channel_axis)(x[-1])) x.append(Activation('relu')(x[-1])) x.append(TensorProduct(n_dense_filters, kernel_initializer=init, kernel_regularizer=l2(reg))(x[-1])) x.append(BatchNormalization(axis=channel_axis)(x[-1])) x.append(Activation('relu')(x[-1])) x.append(TensorProduct(n_features, kernel_initializer=init, kernel_regularizer=l2(reg))(x[-1])) if not dilated: x.append(Flatten()(x[-1])) if include_top: x.append(Softmax(axis=channel_axis)(x[-1])) model = Model(inputs=x[0], outputs=x[-1]) return model
x_batch = [] y_batch = [] end = min(start + val_batch_size, len(ids)) i_val_batch = ids[start:end] for i in i_val_batch: x_batch.append(process_wav_file(valid_df.wav_file.values[i])) y_batch.append(valid_df.label_id.values[i]) x_batch = np.array(x_batch) y_batch = to_categorical(y_batch, num_classes = len(POSSIBLE_LABELS)) yield x_batch, y_batch x_in = Input(shape = (257,98,2)) x = BatchNormalization()(x_in) for i in range(4): x = Conv2D(16*(2 ** i), (3,3))(x) x = Activation('elu')(x) x = BatchNormalization()(x) x = MaxPooling2D((2,2))(x) x = Conv2D(128, (1,1))(x) x_branch_1 = GlobalAveragePooling2D()(x) x_branch_2 = GlobalMaxPool2D()(x) x = concatenate([x_branch_1, x_branch_2]) x = Dense(256, activation = 'relu')(x) x = Dropout(0.5)(x) x = Dense(len(POSSIBLE_LABELS), activation = 'softmax')(x) model = Model(inputs = x_in, outputs = x) model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) model.summary() callbacks = [LoggingCallback(logging.info),
def Deeplabv3(weights='pascal_voc', input_tensor=None, input_shape=(512, 512, 3), classes=21, backbone='mobilenetv2', OS=16, alpha=1., activation=None): """ Instantiates the Deeplabv3+ architecture Optionally loads weights pre-trained on PASCAL VOC or Cityscapes. This model is available for TensorFlow only. # Arguments weights: one of 'pascal_voc' (pre-trained on pascal voc), 'cityscapes' (pre-trained on cityscape) or None (random initialization) input_tensor: optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. input_shape: shape of input image. format HxWxC PASCAL VOC model was trained on (512,512,3) images. None is allowed as shape/width classes: number of desired classes. PASCAL VOC has 21 classes, Cityscapes has 19 classes. If number of classes not aligned with the weights used, last layer is initialized randomly backbone: backbone to use. one of {'xception','mobilenetv2'} activation: optional activation to add to the top of the network. One of 'softmax', 'sigmoid' or None OS: determines input_shape/feature_extractor_output ratio. One of {8,16}. Used only for xception backbone. alpha: controls the width of the MobileNetV2 network. This is known as the width multiplier in the MobileNetV2 paper. - If `alpha` < 1.0, proportionally decreases the number of filters in each layer. - If `alpha` > 1.0, proportionally increases the number of filters in each layer. - If `alpha` = 1, default number of filters from the paper are used at each layer. Used only for mobilenetv2 backbone. Pretrained is only available for alpha=1. # Returns A Keras model instance. # Raises RuntimeError: If attempting to run this model with a backend that does not support separable convolutions. ValueError: in case of invalid argument for `weights` or `backbone` """ if not (weights in {'pascal_voc', 'cityscapes', None}): raise ValueError( 'The `weights` argument should be either ' '`None` (random initialization), `pascal_voc`, or `cityscapes` ' '(pre-trained on PASCAL VOC)') if not (backbone in {'xception', 'mobilenetv2'}): raise ValueError('The `backbone` argument should be either ' '`xception` or `mobilenetv2` ') if input_tensor is None: img_input = Input(shape=input_shape) else: img_input = input_tensor if backbone == 'xception': if OS == 8: entry_block3_stride = 1 middle_block_rate = 2 # ! Not mentioned in paper, but required exit_block_rates = (2, 4) atrous_rates = (12, 24, 36) else: entry_block3_stride = 2 middle_block_rate = 1 exit_block_rates = (1, 2) atrous_rates = (6, 12, 18) x = Conv2D(32, (3, 3), strides=(2, 2), name='entry_flow_conv1_1', use_bias=False, padding='same')(img_input) x = BatchNormalization(name='entry_flow_conv1_1_BN')(x) x = Activation(tf.nn.relu)(x) x = _conv2d_same(x, 64, 'entry_flow_conv1_2', kernel_size=3, stride=1) x = BatchNormalization(name='entry_flow_conv1_2_BN')(x) x = Activation(tf.nn.relu)(x) x = _xception_block(x, [128, 128, 128], 'entry_flow_block1', skip_connection_type='conv', stride=2, depth_activation=False) x, skip1 = _xception_block(x, [256, 256, 256], 'entry_flow_block2', skip_connection_type='conv', stride=2, depth_activation=False, return_skip=True) x = _xception_block(x, [728, 728, 728], 'entry_flow_block3', skip_connection_type='conv', stride=entry_block3_stride, depth_activation=False) for i in range(16): x = _xception_block(x, [728, 728, 728], 'middle_flow_unit_{}'.format(i + 1), skip_connection_type='sum', stride=1, rate=middle_block_rate, depth_activation=False) x = _xception_block(x, [728, 1024, 1024], 'exit_flow_block1', skip_connection_type='conv', stride=1, rate=exit_block_rates[0], depth_activation=False) x = _xception_block(x, [1536, 1536, 2048], 'exit_flow_block2', skip_connection_type='none', stride=1, rate=exit_block_rates[1], depth_activation=True) else: OS = 8 first_block_filters = _make_divisible(32 * alpha, 8) x = Conv2D(first_block_filters, kernel_size=3, strides=(2, 2), padding='same', use_bias=False, name='Conv')(img_input) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name='Conv_BN')(x) x = Activation(tf.nn.relu6, name='Conv_Relu6')(x) x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1, expansion=1, block_id=0, skip_connection=False) x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2, expansion=6, block_id=1, skip_connection=False) x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1, expansion=6, block_id=2, skip_connection=True) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2, expansion=6, block_id=3, skip_connection=False) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=4, skip_connection=True) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=5, skip_connection=True) # stride in block 6 changed from 2 -> 1, so we need to use rate = 2 x = _inverted_res_block( x, filters=64, alpha=alpha, stride=1, # 1! expansion=6, block_id=6, skip_connection=False) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2, expansion=6, block_id=7, skip_connection=True) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2, expansion=6, block_id=8, skip_connection=True) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2, expansion=6, block_id=9, skip_connection=True) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2, expansion=6, block_id=10, skip_connection=False) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2, expansion=6, block_id=11, skip_connection=True) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2, expansion=6, block_id=12, skip_connection=True) x = _inverted_res_block( x, filters=160, alpha=alpha, stride=1, rate=2, # 1! expansion=6, block_id=13, skip_connection=False) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4, expansion=6, block_id=14, skip_connection=True) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4, expansion=6, block_id=15, skip_connection=True) x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, rate=4, expansion=6, block_id=16, skip_connection=False) # end of feature extractor # branching for Atrous Spatial Pyramid Pooling # Image Feature branch shape_before = tf.shape(x) b4 = GlobalAveragePooling2D()(x) # from (b_size, channels)->(b_size, 1, 1, channels) b4 = Lambda(lambda x: K.expand_dims(x, 1))(b4) b4 = Lambda(lambda x: K.expand_dims(x, 1))(b4) b4 = Conv2D(256, (1, 1), padding='same', use_bias=False, name='image_pooling')(b4) b4 = BatchNormalization(name='image_pooling_BN', epsilon=1e-5)(b4) b4 = Activation(tf.nn.relu)(b4) # upsample. have to use compat because of the option align_corners size_before = tf.keras.backend.int_shape(x) b4 = Lambda(lambda x: tf.compat.v1.image.resize( x, size_before[1:3], method='bilinear', align_corners=True))(b4) # simple 1x1 b0 = Conv2D(256, (1, 1), padding='same', use_bias=False, name='aspp0')(x) b0 = BatchNormalization(name='aspp0_BN', epsilon=1e-5)(b0) b0 = Activation(tf.nn.relu, name='aspp0_activation')(b0) # there are only 2 branches in mobilenetV2. not sure why if backbone == 'xception': # rate = 6 (12) b1 = SepConv_BN(x, 256, 'aspp1', rate=atrous_rates[0], depth_activation=True, epsilon=1e-5) # rate = 12 (24) b2 = SepConv_BN(x, 256, 'aspp2', rate=atrous_rates[1], depth_activation=True, epsilon=1e-5) # rate = 18 (36) b3 = SepConv_BN(x, 256, 'aspp3', rate=atrous_rates[2], depth_activation=True, epsilon=1e-5) # concatenate ASPP branches & project x = Concatenate()([b4, b0, b1, b2, b3]) else: x = Concatenate()([b4, b0]) x = Conv2D(256, (1, 1), padding='same', use_bias=False, name='concat_projection')(x) x = BatchNormalization(name='concat_projection_BN', epsilon=1e-5)(x) x = Activation(tf.nn.relu)(x) x = Dropout(0.1)(x) # DeepLab v.3+ decoder if backbone == 'xception': # Feature projection # x4 (x2) block skip_size = tf.keras.backend.int_shape(skip1) x = Lambda(lambda xx: tf.compat.v1.image.resize( xx, skip_size[1:3], method='bilinear', align_corners=True))(x) dec_skip1 = Conv2D(48, (1, 1), padding='same', use_bias=False, name='feature_projection0')(skip1) dec_skip1 = BatchNormalization(name='feature_projection0_BN', epsilon=1e-5)(dec_skip1) dec_skip1 = Activation(tf.nn.relu)(dec_skip1) x = Concatenate()([x, dec_skip1]) x = SepConv_BN(x, 256, 'decoder_conv0', depth_activation=True, epsilon=1e-5) x = SepConv_BN(x, 256, 'decoder_conv1', depth_activation=True, epsilon=1e-5) # you can use it with arbitary number of classes if (weights == 'pascal_voc' and classes == 21) or (weights == 'cityscapes' and classes == 19): last_layer_name = 'logits_semantic' else: last_layer_name = 'custom_logits_semantic' x = Conv2D(classes, (1, 1), padding='same', name=last_layer_name)(x) size_before3 = tf.keras.backend.int_shape(img_input) x = Lambda(lambda xx: tf.compat.v1.image.resize( xx, size_before3[1:3], method='bilinear', align_corners=True))(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = get_source_inputs(input_tensor) else: inputs = img_input if activation in {'softmax', 'sigmoid'}: x = tf.keras.layers.Activation(activation)(x) model = Model(inputs, x, name='deeplabv3plus') # load weights if weights == 'pascal_voc': if backbone == 'xception': weights_path = get_file( 'deeplabv3_xception_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH_X, cache_subdir='models') else: weights_path = get_file( 'deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH_MOBILE, cache_subdir='models') model.load_weights(weights_path, by_name=True) elif weights == 'cityscapes': if backbone == 'xception': weights_path = get_file( 'deeplabv3_xception_tf_dim_ordering_tf_kernels_cityscapes.h5', WEIGHTS_PATH_X_CS, cache_subdir='models') else: weights_path = get_file( 'deeplabv3_mobilenetv2_tf_dim_ordering_tf_kernels_cityscapes.h5', WEIGHTS_PATH_MOBILE_CS, cache_subdir='models') model.load_weights(weights_path, by_name=True) return model
def create_vgg_like_model(input_shape=(40, 256, 1), output_dim=256, filters=64, pool_shape=(1, 2), max_pool=True, filter_shapes=[(1, 5), (1, 3)], dropout=0.3): model_name = 'vgg_like_in={}_out={}_filters={}_pool_shape={}_max={}_filter_shapes={}_dropout={}'\ .format(input_shape, output_dim, filters, pool_shape, max_pool, filter_shapes, dropout)\ .replace(',', '_').replace(' ', '_') visible = Input(shape=(input_shape[0], None, input_shape[2])) x = visible x = Conv2D(filters * 2**0, filter_shapes[0], padding='same', activation='relu', name='Conv0')(x) x = BatchNormalization(name='BN0')(x) x = Conv2D(filters * 2**0, filter_shapes[1], padding='same', activation='relu', name='Conv1')(x) x = BatchNormalization(name='BN1')(x) x = possible_pool(1, input_shape, pool_shape, max_pool, x) x = Dropout(dropout)(x) x = Conv2D(filters * 2**1, filter_shapes[0], padding='same', activation='relu', name='Conv2')(x) x = BatchNormalization(name='BN2')(x) x = Conv2D(filters * 2**1, filter_shapes[1], padding='same', activation='relu', name='Conv3')(x) x = BatchNormalization(name='BN3')(x) x = possible_pool(2, input_shape, pool_shape, max_pool, x) x = Dropout(dropout)(x) x = Conv2D(filters * 2**2, filter_shapes[0], padding='same', activation='relu', name='Conv4')(x) x = BatchNormalization(name='BN4')(x) x = Conv2D(filters * 2**2, filter_shapes[1], padding='same', activation='relu', name='Conv5')(x) x = BatchNormalization(name='BN5')(x) x = possible_pool(3, input_shape, pool_shape, max_pool, x) x = Dropout(dropout)(x) x = Conv2D(filters * 2**2, filter_shapes[0], padding='same', activation='relu', name='Conv6')(x) x = BatchNormalization(name='BN6')(x) x = Conv2D(filters * 2**2, filter_shapes[1], padding='same', activation='relu', name='Conv7')(x) x = BatchNormalization(name='BN7')(x) x = possible_pool(4, input_shape, pool_shape, max_pool, x) x = Dropout(dropout)(x) x = Conv2D(filters * 2**3, filter_shapes[0], padding='same', activation='relu', name='Conv8')(x) x = BatchNormalization(name='BN8')(x) x = Conv2D(filters * 2**3, filter_shapes[1], padding='same', activation='relu', name='Conv9')(x) x = BatchNormalization(name='BN9')(x) x = possible_pool(5, input_shape, pool_shape, max_pool, x) x = Dropout(dropout)(x) x = Conv2D(filters * 2**3, filter_shapes[0], padding='same', activation='relu', name='Conv10')(x) x = BatchNormalization(name='BN10')(x) x = Conv2D(filters * 2**3, filter_shapes[1], padding='same', activation='relu', name='Conv11')(x) x = BatchNormalization(name='BN11')(x) x = possible_pool(6, input_shape, pool_shape, max_pool, x) x = Dropout(dropout)(x) x = Conv2D(output_dim, (1, 1), padding='same', activation='relu', name='1x1')(x) x = GlobalAveragePooling2D()(x) x = Activation('softmax')(x) return Model(inputs=visible, outputs=x, name=model_name)
def test_tf_keras_mnist_cnn(): """ This is the basic mnist cnn example from keras. """ try: import tensorflow as tf from tensorflow.python import keras from tensorflow.python.keras.models import Sequential from tensorflow.python.keras.layers import Dense, Dropout, Flatten, Activation from tensorflow.python.keras.layers import Conv2D, MaxPooling2D from tensorflow.python.keras import backend as K except Exception as e: print("Skipping test_tf_keras_mnist_cnn!") return import shap batch_size = 128 num_classes = 10 epochs = 1 # input image dimensions img_rows, img_cols = 28, 28 # the data, split between train and test sets (x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data() if K.image_data_format() == 'channels_first': x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols) input_shape = (1, img_rows, img_cols) else: x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) input_shape = (img_rows, img_cols, 1) x_train = x_train.astype('float32') x_test = x_test.astype('float32') x_train /= 255 x_test /= 255 # convert class vectors to binary class matrices y_train = keras.utils.to_categorical(y_train, num_classes) y_test = keras.utils.to_categorical(y_test, num_classes) model = Sequential() model.add( Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape)) model.add(Conv2D(64, (3, 3), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(32, activation='relu')) # 128 model.add(Dropout(0.5)) model.add(Dense(num_classes)) model.add(Activation('softmax')) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy']) model.fit(x_train[:1000, :], y_train[:1000, :], batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test[:1000, :], y_test[:1000, :])) # explain by passing the tensorflow inputs and outputs np.random.seed(0) inds = np.random.choice(x_train.shape[0], 10, replace=False) e = shap.DeepExplainer((model.layers[0].input, model.layers[-1].input), x_train[inds, :, :]) shap_values = e.shap_values(x_test[:1]) sess = tf.keras.backend.get_session() diff = sess.run(model.layers[-1].input, feed_dict={model.layers[0].input: x_test[:1]}) - \ sess.run(model.layers[-1].input, feed_dict={model.layers[0].input: x_train[inds,:,:]}).mean(0) sums = np.array([shap_values[i].sum() for i in range(len(shap_values))]) d = np.abs(sums - diff).sum() assert d / np.abs(diff).sum( ) < 0.001, "Sum of SHAP values does not match difference! %f" % d
y = Input(shape=(None, ), dtype='int32') y_in = Lambda(lambda x: x[:, :-1])(y) y_out = Lambda(lambda x: x[:, 1:])(y) # 誤差関数のマスク mask = Lambda(lambda x: K.cast(K.not_equal(x, w2i['<pad>']), 'float32'))( y_out) # 層の定義 embedding = Embedding(vocab_size, emb_dim) lstm = LSTM(hid_dim, activation='tanh', return_sequences=True, return_state=True) dense = Dense(vocab_size) softmax = Activation('softmax') # 順伝播 y_emb = embedding(y_in) h, _, _ = lstm(y_emb, initial_state=[h_0, c_0]) # 第2,3戻り値(最終ステップのh, c)は無視 h = dense(h) y_pred = softmax(h) def masked_cross_entropy(y_true, y_pred): return -K.mean( K.sum(K.sum(y_true * K.log(K.clip(y_pred, 1e-10, 1)), axis=-1) * mask, axis=1)) model = Model([x, y], y_pred) model.compile(loss=masked_cross_entropy, optimizer='rmsprop')
def __create_pyramid_features(backbone_dict, ndim=2, feature_size=256, include_final_layers=True): """Creates the FPN layers on top of the backbone features. Args: backbone_dict (dictionary): A dictionary of the backbone layers, with the names as keys, e.g. {'C0': C0, 'C1': C1, 'C2': C2, ...} feature_size (int, optional): Defaults to 256. The feature size to use for the resulting feature levels. include_final_layers: Defaults to True. Option to add two coarser pyramid levels ndim: The spatial dimensions of the input data. Default is 2, but it also works with 3 Returns: A dictionary with the feature pyramid names and levels, e.g. {'P3': P3, 'P4': P4, ...} Each backbone layer gets a pyramid level, and two additional levels are added, e.g. [C3, C4, C5] --> [P3, P4, P5, P6, P7] """ acceptable_ndims = [2, 3] if ndim not in acceptable_ndims: raise ValueError('Only 2 and 3 dimensional networks are supported') # Get names of the backbone levels and place in ascending order backbone_names = get_sorted_keys(backbone_dict) backbone_features = [backbone_dict[name] for name in backbone_names] pyramid_names = [] pyramid_finals = [] pyramid_upsamples = [] # Reverse lists backbone_names.reverse() backbone_features.reverse() for i in range(len(backbone_names)): N = backbone_names[i] level = int(re.findall(r'\d+', N)[0]) p_name = 'P' + str(level) pyramid_names.append(p_name) backbone_input = backbone_features[i] # Don't add for the bottom of the pyramid if i == 0: if len(backbone_features) > 1: upsamplelike_input = backbone_features[i + 1] else: upsamplelike_input = None addition_input = None # Don't upsample for the top of the pyramid elif i == len(backbone_names) - 1: upsamplelike_input = None addition_input = pyramid_upsamples[-1] # Otherwise, add and upsample else: upsamplelike_input = backbone_features[i + 1] addition_input = pyramid_upsamples[-1] pf, pu = create_pyramid_level(backbone_input, upsamplelike_input=upsamplelike_input, addition_input=addition_input, level=level) pyramid_finals.append(pf) pyramid_upsamples.append(pu) # Add the final two pyramid layers if include_final_layers: # "Second to last pyramid layer is obtained via a # 3x3 stride-2 conv on the coarsest backbone" N = backbone_names[0] F = backbone_features[0] level = int(re.findall(r'\d+', N)[0]) + 1 P_minus_2_name = 'P%s' % level if ndim == 2: P_minus_2 = Conv2D(feature_size, kernel_size=(3, 3), strides=(2, 2), padding='same', name=P_minus_2_name)(F) else: P_minus_2 = Conv3D(feature_size, kernel_size=(3, 3, 3), strides=(2, 2, 2), padding='same', name=P_minus_2_name)(F) pyramid_names.insert(0, P_minus_2_name) pyramid_finals.insert(0, P_minus_2) # "Last pyramid layer is computed by applying ReLU # followed by a 3x3 stride-2 conv on second to last layer" level = int(re.findall(r'\d+', N)[0]) + 2 P_minus_1_name = 'P' + str(level) P_minus_1 = Activation('relu', name=N + '_relu')(P_minus_2) if ndim == 2: P_minus_1 = Conv2D(feature_size, kernel_size=(3, 3), strides=(2, 2), padding='same', name=P_minus_1_name)(P_minus_1) else: P_minus_1 = Conv3D(feature_size, kernel_size=(3, 3, 3), strides=(2, 2, 2), padding='same', name=P_minus_1_name)(P_minus_1) pyramid_names.insert(0, P_minus_1_name) pyramid_finals.insert(0, P_minus_1) pyramid_names.reverse() pyramid_finals.reverse() # Reverse lists backbone_names.reverse() backbone_features.reverse() pyramid_dict = {} for name, feature in zip(pyramid_names, pyramid_finals): pyramid_dict[name] = feature return pyramid_dict
def MobileNetV2(classes=1000, input_tensor=None, input_shape=(512, 512, 3), weights_info=None, OS=16, alpha=1., include_top=True): """ Instantiates the Deeplabv3+ architecture Optionally loads weights pre-trained on PASCAL VOC or Cityscapes. This model is available for TensorFlow only. # Arguments classes: Integer, optional number of classes to classify images into, only to be specified if `include_top` is True, and if no `weights` argument is specified. input_tensor: optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. input_shape: shape of input image. format HxWxC PASCAL VOC model was trained on (512,512,3) images. None is allowed as shape/width weights_info: this dict is consisted of `classes` and `weghts`. `classes` is number of `weights` output units. `weights` is one of 'imagenet' (pre-training on ImageNet), 'pascal_voc', 'cityscapes', original weights path (pre-training on original data) or None (random initialization) OS: determines input_shape/feature_extractor_output ratio. One of {8,16}. Used only for xception backbone. alpha: controls the width of the MobileNetV2 network. This is known as the width multiplier in the MobileNetV2 paper. - If `alpha` < 1.0, proportionally decreases the number of filters in each layer. - If `alpha` > 1.0, proportionally increases the number of filters in each layer. - If `alpha` = 1, default number of filters from the paper are used at each layer. Used only for mobilenetv2 backbone. Pretrained is only available for alpha=1. include_top: Boolean, whether to include the fully-connected layer at the top of the network. Defaults to `True`. # Returns A Keras model instance. """ if weights_info is not None: if weights_info.get("weights") is None: weights = None elif weights_info["weights"] in { 'imagenet', 'pascal_voc', 'cityscapes', None }: weights = weights_info["weights"] elif os.path.exists(weights_info["weights"]) and weights_info.get( "classes") is not None: classes = int(weights_info["classes"]) weights = weights_info["weights"] else: raise ValueError( 'The `weights` should be either ' '`None` (random initialization), `imagenet`, `pascal_voc`, `cityscapes`, ' 'original weights path (pre-training on original data), ' 'or the path to the weights file to be loaded and' '`classes` should be number of original weights output units') else: weights = None if classes is None: raise ValueError('`classes` should be any number') if input_tensor is None: img_input = Input(shape=input_shape) else: img_input = input_tensor # If input_shape is None, infer shape from input_tensor if backend.image_data_format() == 'channels_first': rows = input_shape[1] cols = input_shape[2] else: rows = input_shape[0] cols = input_shape[1] if rows == cols and rows in [96, 128, 160, 192, 224]: default_size = rows else: default_size = 224 if weights == 'imagenet': if alpha not in [0.35, 0.50, 0.75, 1.0, 1.3, 1.4]: raise ValueError('If imagenet weights are being loaded, ' 'alpha can be one of `0.35`, `0.50`, `0.75`, ' '`1.0`, `1.3` or `1.4` only.') if rows != cols or rows not in [96, 128, 160, 192, 224]: rows = 224 OS = 8 first_block_filters = _make_divisible(32 * alpha, 8) x = Conv2D(first_block_filters, kernel_size=3, strides=(2, 2), padding='same', use_bias=False, name='Conv')(img_input) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name='Conv_BN')(x) x = Activation(relu6, name='Conv_Relu6')(x) x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1, expansion=1, block_id=0, skip_connection=False) x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2, expansion=6, block_id=1, skip_connection=False) x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1, expansion=6, block_id=2, skip_connection=True) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2, expansion=6, block_id=3, skip_connection=False) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=4, skip_connection=True) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=5, skip_connection=True) # stride in block 6 changed from 2 -> 1, so we need to use rate = 2 x = _inverted_res_block( x, filters=64, alpha=alpha, stride=1, # 1! expansion=6, block_id=6, skip_connection=False) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2, expansion=6, block_id=7, skip_connection=True) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2, expansion=6, block_id=8, skip_connection=True) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, rate=2, expansion=6, block_id=9, skip_connection=True) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2, expansion=6, block_id=10, skip_connection=False) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2, expansion=6, block_id=11, skip_connection=True) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, rate=2, expansion=6, block_id=12, skip_connection=True) x = _inverted_res_block( x, filters=160, alpha=alpha, stride=1, rate=2, # 1! expansion=6, block_id=13, skip_connection=False) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4, expansion=6, block_id=14, skip_connection=True) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, rate=4, expansion=6, block_id=15, skip_connection=True) x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, rate=4, expansion=6, block_id=16, skip_connection=False) if alpha > 1.0: last_block_filters = _make_divisible(1280 * alpha, 8) else: last_block_filters = 1280 x = Conv2D(last_block_filters, kernel_size=1, use_bias=False, name='Conv_1')(x) x = BatchNormalization(epsilon=1e-3, momentum=0.999, name='Conv_1_bn')(x) x = Activation(relu6, name='out_relu')(x) x = GlobalAveragePooling2D()(x) x = Dense(classes, activation='softmax')(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='mobilenetv2') # Load weights. if weights == 'imagenet': print("movilenetv2 load model imagenet") model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' + str(alpha) + '_' + str(rows) + '.h5') weight_path = BASE_WEIGHT_PATH + model_name weights_path = data_utils.get_file(model_name, weight_path, cache_subdir='models') model.load_weights(weights_path) elif not (weights in {'pascal_voc', 'cityscapes', None}): model.load_weights(weights) if include_top: return model else: # get last _inverted_res_block layer no_top_model = Model(inputs=model.input, outputs=model.get_layer(index=-6).output) return no_top_model
def inception_resnet_block(x, scale, block_type, block_idx, activation='relu'): """Adds a Inception-ResNet block. This function builds 3 types of Inception-ResNet blocks mentioned in the paper, controlled by the `block_type` argument (which is the block name used in the official TF-slim implementation): - Inception-ResNet-A: `block_type='block35'` - Inception-ResNet-B: `block_type='block17'` - Inception-ResNet-C: `block_type='block8'` # Arguments x: input tensor. scale: scaling factor to scale the residuals (i.e., the output of passing `x` through an inception module) before adding them to the shortcut branch. Let `r` be the output from the residual branch, the output of this block will be `x + scale * r`. block_type: `'block35'`, `'block17'` or `'block8'`, determines the network structure in the residual branch. block_idx: an `int` used for generating layer names. The Inception-ResNet blocks are repeated many times in this network. We use `block_idx` to identify each of the repetitions. For example, the first Inception-ResNet-A block will have `block_type='block35', block_idx=0`, ane the layer names will have a common prefix `'block35_0'`. activation: activation function to use at the end of the block (see [activations](../activations.md)). When `activation=None`, no activation is applied (i.e., "linear" activation: `a(x) = x`). # Returns Output tensor for the block. # Raises ValueError: if `block_type` is not one of `'block35'`, `'block17'` or `'block8'`. """ if block_type == 'block35': branch_0 = conv2d_bn(x, 32, 1) branch_1 = conv2d_bn(x, 32, 1) branch_1 = conv2d_bn(branch_1, 32, 3) branch_2 = conv2d_bn(x, 32, 1) branch_2 = conv2d_bn(branch_2, 48, 3) branch_2 = conv2d_bn(branch_2, 64, 3) branches = [branch_0, branch_1, branch_2] elif block_type == 'block17': branch_0 = conv2d_bn(x, 192, 1) branch_1 = conv2d_bn(x, 128, 1) branch_1 = conv2d_bn(branch_1, 160, [1, 7]) branch_1 = conv2d_bn(branch_1, 192, [7, 1]) branches = [branch_0, branch_1] elif block_type == 'block8': branch_0 = conv2d_bn(x, 192, 1) branch_1 = conv2d_bn(x, 192, 1) branch_1 = conv2d_bn(branch_1, 224, [1, 3]) branch_1 = conv2d_bn(branch_1, 256, [3, 1]) branches = [branch_0, branch_1] else: raise ValueError('Unknown Inception-ResNet block type. ' 'Expects "block35", "block17" or "block8", ' 'but got: ' + str(block_type)) block_name = block_type + '_' + str(block_idx) channel_axis = 1 if K.image_data_format() == 'channels_first' else 3 mixed = Concatenate(axis=channel_axis, name=block_name + '_mixed')(branches) up = conv2d_bn(mixed, K.int_shape(x)[channel_axis], 1, activation=None, use_bias=True, name=block_name + '_conv') x = Lambda( lambda inputs, scale: inputs[0] + inputs[1] * scale, # output_shape=K.int_shape(x)[1:], arguments={'scale': scale}, name=block_name)([x, up]) if activation is not None: x = Activation(activation, name=block_name + '_ac')(x) return x
batch_size=16, class_mode='categorical') test_gen = datagen.flow_from_directory(test_dir, target_size=(sz, sz), batch_size=16, class_mode='categorical') label_map = train_gen.class_indices print(label_map) label_map1 = test_gen.class_indices print(label_map1) model = Sequential() model.add(Conv2D(64, (3, 3), input_shape=input_shape)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) # model.add(Dense(64)) # model.add(Activation('softmax')) # model.add(Dropout(0.5)) model.add(Dense(46))
def get_test_model_full(): """Returns a maximally complex test model, using all supported layer types with different parameter combination. """ input_shapes = [ (26, 28, 3), (4, 4, 3), (4, 4, 3), (4, ), (2, 3), (27, 29, 1), (17, 1), (17, 4), ] inputs = [Input(shape=s) for s in input_shapes] outputs = [] for inp in inputs[6:8]: for padding in ['valid', 'same']: for s in range(1, 6): for out_channels in [1, 2]: for d in range(1, 4): outputs.append( Conv1D(out_channels, s, padding=padding, dilation_rate=d)(inp)) for padding_size in range(0, 5): outputs.append(ZeroPadding1D(padding_size)(inp)) for crop_left in range(0, 2): for crop_right in range(0, 2): outputs.append(Cropping1D((crop_left, crop_right))(inp)) for upsampling_factor in range(1, 5): outputs.append(UpSampling1D(upsampling_factor)(inp)) for padding in ['valid', 'same']: for pool_factor in range(1, 6): for s in range(1, 4): outputs.append( MaxPooling1D(pool_factor, strides=s, padding=padding)(inp)) outputs.append( AveragePooling1D(pool_factor, strides=s, padding=padding)(inp)) outputs.append(GlobalMaxPooling1D()(inp)) outputs.append(GlobalAveragePooling1D()(inp)) for inp in [inputs[0], inputs[5]]: for padding in ['valid', 'same']: for h in range(1, 6): for out_channels in [1, 2]: for d in range(1, 4): outputs.append( Conv2D(out_channels, (h, 1), padding=padding, dilation_rate=(d, 1))(inp)) outputs.append( SeparableConv2D(out_channels, (h, 1), padding=padding, dilation_rate=(d, 1))(inp)) for sy in range(1, 4): outputs.append( Conv2D(out_channels, (h, 1), strides=(1, sy), padding=padding)(inp)) outputs.append( SeparableConv2D(out_channels, (h, 1), strides=(sy, sy), padding=padding)(inp)) for sy in range(1, 4): outputs.append( MaxPooling2D((h, 1), strides=(1, sy), padding=padding)(inp)) for w in range(1, 6): for out_channels in [1, 2]: for d in range(1, 4) if sy == 1 else [1]: outputs.append( Conv2D(out_channels, (1, w), padding=padding, dilation_rate=(1, d))(inp)) outputs.append( SeparableConv2D(out_channels, (1, w), padding=padding, dilation_rate=(1, d))(inp)) for sx in range(1, 4): outputs.append( Conv2D(out_channels, (1, w), strides=(sx, 1), padding=padding)(inp)) outputs.append( SeparableConv2D(out_channels, (1, w), strides=(sx, sx), padding=padding)(inp)) for sx in range(1, 4): outputs.append( MaxPooling2D((1, w), strides=(1, sx), padding=padding)(inp)) outputs.append(ZeroPadding2D(2)(inputs[0])) outputs.append(ZeroPadding2D((2, 3))(inputs[0])) outputs.append(ZeroPadding2D(((1, 2), (3, 4)))(inputs[0])) outputs.append(Cropping2D(2)(inputs[0])) outputs.append(Cropping2D((2, 3))(inputs[0])) outputs.append(Cropping2D(((1, 2), (3, 4)))(inputs[0])) for y in range(1, 3): for x in range(1, 3): outputs.append(UpSampling2D(size=(y, x))(inputs[0])) outputs.append(GlobalAveragePooling2D()(inputs[0])) outputs.append(GlobalMaxPooling2D()(inputs[0])) outputs.append(AveragePooling2D((2, 2))(inputs[0])) outputs.append(MaxPooling2D((2, 2))(inputs[0])) outputs.append(UpSampling2D((2, 2))(inputs[0])) outputs.append(keras.layers.concatenate([inputs[0], inputs[0]])) outputs.append(Dropout(0.5)(inputs[0])) outputs.append(BatchNormalization()(inputs[0])) outputs.append(BatchNormalization(center=False)(inputs[0])) outputs.append(BatchNormalization(scale=False)(inputs[0])) outputs.append(Conv2D(2, (3, 3), use_bias=True)(inputs[0])) outputs.append(Conv2D(2, (3, 3), use_bias=False)(inputs[0])) outputs.append(SeparableConv2D(2, (3, 3), use_bias=True)(inputs[0])) outputs.append(SeparableConv2D(2, (3, 3), use_bias=False)(inputs[0])) outputs.append(Dense(2, use_bias=True)(inputs[3])) outputs.append(Dense(2, use_bias=False)(inputs[3])) shared_conv = Conv2D(1, (1, 1), padding='valid', name='shared_conv', activation='relu') up_scale_2 = UpSampling2D((2, 2)) x1 = shared_conv(up_scale_2(inputs[1])) # (1, 8, 8) x2 = shared_conv(up_scale_2(inputs[2])) # (1, 8, 8) x3 = Conv2D(1, (1, 1), padding='valid')(up_scale_2(inputs[2])) # (1, 8, 8) x = keras.layers.concatenate([x1, x2, x3]) # (3, 8, 8) outputs.append(x) x = Conv2D(3, (1, 1), padding='same', use_bias=False)(x) # (3, 8, 8) outputs.append(x) x = Dropout(0.5)(x) outputs.append(x) x = keras.layers.concatenate( [MaxPooling2D((2, 2))(x), AveragePooling2D((2, 2))(x)]) # (6, 4, 4) outputs.append(x) x = Flatten()(x) # (1, 1, 96) x = Dense(4, use_bias=False)(x) outputs.append(x) x = Dense(3)(x) # (1, 1, 3) outputs.append(x) intermediate_input_shape = (3, ) intermediate_in = Input(intermediate_input_shape) intermediate_x = intermediate_in intermediate_x = Dense(8)(intermediate_x) intermediate_x = Dense(5)(intermediate_x) intermediate_model = Model(inputs=[intermediate_in], outputs=[intermediate_x], name='intermediate_model') intermediate_model.compile(loss='mse', optimizer='nadam') x = intermediate_model(x) # (1, 1, 5) intermediate_model_2 = Sequential() intermediate_model_2.add(Dense(7, input_shape=(5, ))) intermediate_model_2.add(Dense(5)) intermediate_model_2.compile(optimizer='rmsprop', loss='categorical_crossentropy') x = intermediate_model_2(x) # (1, 1, 5) x = Dense(3)(x) # (1, 1, 3) shared_activation = Activation('tanh') outputs = outputs + [ Activation('tanh')(inputs[3]), Activation('hard_sigmoid')(inputs[3]), Activation('selu')(inputs[3]), Activation('sigmoid')(inputs[3]), Activation('softplus')(inputs[3]), Activation('softmax')(inputs[3]), Activation('relu')(inputs[3]), LeakyReLU()(inputs[3]), ELU()(inputs[3]), shared_activation(inputs[3]), inputs[4], inputs[1], x, shared_activation(x), ] print('Model has {} outputs.'.format(len(outputs))) model = Model(inputs=inputs, outputs=outputs, name='test_model_full') model.compile(loss='mse', optimizer='nadam') # fit to dummy data training_data_size = 1 batch_size = 1 epochs = 10 data_in = generate_input_data(training_data_size, input_shapes) data_out = generate_output_data(training_data_size, outputs) model.fit(data_in, data_out, epochs=epochs, batch_size=batch_size) return model
def cifar100_student_strong(n_classes: int, input_shape=None, input_tensor=None, weights_path: Union[None, str] = None) -> Model: """ Defines a cifar100 strong student network. :param n_classes: the number of classes. :param input_shape: the input shape of the network. Can be omitted if input_tensor is used. :param input_tensor: the input tensor of the network. Can be omitted if input_shape is used. :param weights_path: a path to a trained cifar10 tiny network's weights. :return: Keras functional Model. """ inputs = create_inputs(input_shape, input_tensor) # Define a weight decay for the regularisation. weight_decay = 1e-4 # Block1. x = Conv2D(32, (3, 3), padding='same', activation='elu', name='block1_conv1', kernel_regularizer=l2(weight_decay))(inputs) x = BatchNormalization(name='block1_batch-norm1')(x) x = Conv2D(64, (3, 3), padding='same', activation='elu', name='block1_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block1_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block1_pool')(x) x = Dropout(0.2, name='block1_dropout', seed=0)(x) # Block2. x = Conv2D(128, (3, 3), padding='same', activation='elu', name='block2_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm1')(x) x = Conv2D(128, (3, 3), padding='same', activation='elu', name='block2_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block2_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block2_pool')(x) x = Dropout(0.3, name='block2_dropout', seed=0)(x) # Block3. x = Conv2D(256, (3, 3), padding='same', activation='elu', name='block3_conv1', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block3_batch-norm1')(x) x = Conv2D(256, (3, 3), padding='same', activation='elu', name='block3_conv2', kernel_regularizer=l2(weight_decay))(x) x = BatchNormalization(name='block3_batch-norm2')(x) x = MaxPooling2D(pool_size=(2, 2), name='block3_pool')(x) x = Dropout(0.4, name='block3_dropout', seed=0)(x) # Add top layers. x = Flatten()(x) x = Dense(n_classes)(x) outputs = Activation('softmax', name='softmax')(x) # Create model. model = Model(inputs, outputs, name='cifar100_student_strong') # Load weights, if they exist. load_weights(weights_path, model) return model
def build_model(): inputs = Input(shape=(NORM_H, NORM_W, 3)) # Block 1__ x = Conv2D( 64, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block1_conv1", )(inputs) x = Activation("relu")(x) x = Conv2D( 64, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block1_conv2", )(x) x = Activation("relu")(x) x = MaxPooling2D(strides=(2, 2), name="block1_pool")(x) # Block 2 x = Conv2D( 128, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block2_conv1", )(x) x = Activation("relu")(x) x = Conv2D( 128, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block2_conv2", )(x) x = Activation("relu")(x) x = MaxPooling2D(strides=(2, 2), name="block2_pool")(x) # Block 3 x = Conv2D( 256, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block3_conv1", )(x) x = Activation("relu")(x) x = Conv2D( 256, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block3_conv2", )(x) x = Activation("relu")(x) x = Conv2D( 256, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block3_conv3", )(x) x = Activation("relu")(x) x = MaxPooling2D(strides=(2, 2), name="block3_pool")(x) # Block 4 x = Conv2D( 512, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block4_conv1", )(x) x = Activation("relu")(x) x = Conv2D( 512, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block4_conv2", )(x) x = Activation("relu")(x) x = Conv2D( 512, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block4_conv3", )(x) x = Activation("relu")(x) x = MaxPooling2D(strides=(2, 2), name="block4_pool")(x) # Block 5 x = Conv2D( 512, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block5_conv1", )(x) x = Activation("relu")(x) x = Conv2D( 512, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block5_conv2", )(x) x = Activation("relu")(x) x = Conv2D( 512, (3, 3), padding="same", kernel_initializer="he_normal", kernel_regularizer=l2(1e-4), name="block5_conv3", )(x) x = Activation("relu")(x) x = MaxPooling2D(strides=(2, 2), name="block5_pool")(x) # Flatten x = Flatten(name="Flatten")(x) # Dimensions branch dimensions = Dense(512, name="d_fc_1")(x) dimensions = LeakyReLU(alpha=0.1)(dimensions) dimensions = Dropout(0.5)(dimensions) dimensions = Dense(3, name="d_fc_2")(dimensions) dimensions = LeakyReLU(alpha=0.1, name="dimensions")(dimensions) # Orientation branch orientation = Dense(256, name="o_fc_1")(x) orientation = LeakyReLU(alpha=0.1)(orientation) orientation = Dropout(0.5)(orientation) orientation = Dense(BIN * 2, name="o_fc_2")(orientation) orientation = LeakyReLU(alpha=0.1)(orientation) orientation = Reshape((BIN, -1))(orientation) orientation = Lambda(VGG16.l2_normalize, name="orientation")(orientation) # Confidence branch confidence = Dense(256, name="c_fc_1")(x) confidence = LeakyReLU(alpha=0.1)(confidence) confidence = Dropout(0.5)(confidence) confidence = Dense(BIN, activation="softmax", name="confidence")(confidence) # Build model return tf.keras.Model(inputs, [dimensions, orientation, confidence])
y_test = to_categorical(y_test, 6) # input = Input(shape=(128, 128, 3)) # model = VGG16(weights=None, include_top=False, input_tensor=input, pooling='None') # x = model.output # x = Flatten()(x) # x = Dense(4096, activation='relu')(x) # x = Dense(4096, activation='relu')(x) # predictions = Dense(6, activation='softmax')(x) # model = tf.keras.Model(inputs=model.input, outputs=predictions) k_size = (3,3) input = Input(shape=(128, 128, 3)) x = Conv2D(32, k_size, padding='same', strides=2)(input) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2D(64, k_size, padding='same', strides=1)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = MaxPool2D((2,2))(x) x = Conv2D(128, k_size, padding='same', strides=2)(x) x = BatchNormalization()(x) x = Activation('relu')(x) x = Conv2D(256, k_size, padding='same', strides=2)(x) x = BatchNormalization()(x) x = Activation('relu')(x)
def Xception(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000): """Instantiates the Xception architecture. Optionally loads weights pre-trained on ImageNet. This model is available for TensorFlow only, and can only be used with inputs following the TensorFlow data format `(width, height, channels)`. You should set `image_data_format='channels_last'` in your Keras config located at ~/.keras/keras.json. Note that the default input image size for this model is 299x299. Arguments: include_top: whether to include the fully-connected layer at the top of the network. weights: one of `None` (random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. input_tensor: optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. input_shape: optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(299, 299, 3)`. It should have exactly 3 inputs channels, and width and height should be no smaller than 71. E.g. `(150, 150, 3)` would be one valid value. pooling: Optional pooling mode for feature extraction when `include_top` is `False`. - `None` means that the output of the model will be the 4D tensor output of the last convolutional layer. - `avg` means that global average pooling will be applied to the output of the last convolutional layer, and thus the output of the model will be a 2D tensor. - `max` means that global max pooling will be applied. classes: optional number of classes to classify images into, only to be specified if `include_top` is True, and if no `weights` argument is specified. Returns: A Keras model instance. Raises: ValueError: in case of invalid argument for `weights`, or invalid input shape. RuntimeError: If attempting to run this model with a backend that does not support separable convolutions. """ if not (weights in {'imagenet', None} or os.path.exists(weights)): raise ValueError('The `weights` argument should be either ' '`None` (random initialization), `imagenet` ' '(pre-training on ImageNet), ' 'or the path to the weights file to be loaded.') if weights == 'imagenet' and include_top and classes != 1000: raise ValueError('If using `weights` as imagenet with `include_top`' ' as true, `classes` should be 1000') if K.image_data_format() != 'channels_last': logging.warning( 'The Xception model is only available for the ' 'input data format "channels_last" ' '(width, height, channels). ' 'However your settings specify the default ' 'data format "channels_first" (channels, width, height). ' 'You should set `image_data_format="channels_last"` in your Keras ' 'config located at ~/.keras/keras.json. ' 'The model being returned right now will expect inputs ' 'to follow the "channels_last" data format.') K.set_image_data_format('channels_last') old_data_format = 'channels_first' else: old_data_format = None # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=299, min_size=71, data_format=K.image_data_format(), require_flatten=False, weights=weights) if input_tensor is None: img_input = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False, name='block1_conv1')(img_input) x = BatchNormalization(name='block1_conv1_bn')(x) x = Activation('relu', name='block1_conv1_act')(x) x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x) x = BatchNormalization(name='block1_conv2_bn')(x) x = Activation('relu', name='block1_conv2_act')(x) residual = Conv2D(128, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv1')(x) x = BatchNormalization(name='block2_sepconv1_bn')(x) x = Activation('relu', name='block2_sepconv2_act')(x) x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv2')(x) x = BatchNormalization(name='block2_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block2_pool')(x) x = layers.add([x, residual]) residual = Conv2D(256, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) x = Activation('relu', name='block3_sepconv1_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv1')(x) x = BatchNormalization(name='block3_sepconv1_bn')(x) x = Activation('relu', name='block3_sepconv2_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv2')(x) x = BatchNormalization(name='block3_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block3_pool')(x) x = layers.add([x, residual]) residual = Conv2D(728, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) x = Activation('relu', name='block4_sepconv1_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv1')(x) x = BatchNormalization(name='block4_sepconv1_bn')(x) x = Activation('relu', name='block4_sepconv2_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv2')(x) x = BatchNormalization(name='block4_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block4_pool')(x) x = layers.add([x, residual]) for i in range(8): residual = x prefix = 'block' + str(i + 5) x = Activation('relu', name=prefix + '_sepconv1_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv1')(x) x = BatchNormalization(name=prefix + '_sepconv1_bn')(x) x = Activation('relu', name=prefix + '_sepconv2_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv2')(x) x = BatchNormalization(name=prefix + '_sepconv2_bn')(x) x = Activation('relu', name=prefix + '_sepconv3_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv3')(x) x = BatchNormalization(name=prefix + '_sepconv3_bn')(x) x = layers.add([x, residual]) residual = Conv2D(1024, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization()(residual) x = Activation('relu', name='block13_sepconv1_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block13_sepconv1')(x) x = BatchNormalization(name='block13_sepconv1_bn')(x) x = Activation('relu', name='block13_sepconv2_act')(x) x = SeparableConv2D(1024, (3, 3), padding='same', use_bias=False, name='block13_sepconv2')(x) x = BatchNormalization(name='block13_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block13_pool')(x) x = layers.add([x, residual]) x = SeparableConv2D(1536, (3, 3), padding='same', use_bias=False, name='block14_sepconv1')(x) x = BatchNormalization(name='block14_sepconv1_bn')(x) x = Activation('relu', name='block14_sepconv1_act')(x) x = SeparableConv2D(2048, (3, 3), padding='same', use_bias=False, name='block14_sepconv2')(x) x = BatchNormalization(name='block14_sepconv2_bn')(x) x = Activation('relu', name='block14_sepconv2_act')(x) if include_top: x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) x = Flatten(name='custom')(x) ##DB # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name='xception') # load weights if weights == 'imagenet': if include_top: weights_path = get_file( 'xception_weights_tf_dim_ordering_tf_kernels.h5', TF_WEIGHTS_PATH, cache_subdir='models', file_hash='0a58e3b7378bc2990ea3b43d5981f1f6') else: weights_path = get_file( 'xception_weights_tf_dim_ordering_tf_kernels_notop.h5', TF_WEIGHTS_PATH_NO_TOP, cache_subdir='models', file_hash='b0042744bf5b25fce3cb969f33bebb97') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) if old_data_format: K.set_image_data_format(old_data_format) return model
def act_blend(self, linear_input): full_conv_relu = Activation('relu')(linear_input) return full_conv_relu full_conv_sigmoid = Activation('sigmoid')(linear_input) full_conv = concatenate([full_conv_relu, full_conv_sigmoid], axis=1) return full_conv
model.add( LSTM(128, return_sequences=True, dropout=0.2, recurrent_dropout=0.2, activation='relu', input_shape=(99 * 3, 52))) model.add( LSTM(128, name='dense_3', return_sequences=True, dropout=0.2, recurrent_dropout=0.2, activation='relu')) model.add(TimeDistributed(Dense(2))) model.add(Activation('sigmoid')) time_distributed_merge_layer = tf.keras.layers.Lambda( function=lambda x: tf.keras.backend.mean(x, axis=1)) model.add(time_distributed_merge_layer) model.compile(optimizer="Adam", loss="categorical_crossentropy", metrics=['accuracy']) print(y_train) print(y_test) model.fit(x=X_train, y=y_train, epochs=5,
def __merge_temporal_features(feature, mode='conv', feature_size=256, frames_per_batch=1): """ Merges feature with its temporal residual through addition. Input feature (x) --> Temporal convolution* --> Residual feature (x') *Type of temporal convolution specified by "mode" argument Output: y = x + x' Args: feature (tensorflow.keras.layers.Layer): Input layer mode (str, optional): Mode of temporal convolution. Choose from {'conv','lstm','gru', None}. Defaults to 'conv'. feature_size (int, optional): Defaults to 256. frames_per_batch (int, optional): Defaults to 1. Raises: ValueError: Mode not 'conv', 'lstm', 'gru' or None Returns: tensorflow.keras.layers.Layer: Input feature merged with its residual from a temporal convolution. If mode is None, the output is exactly the input. """ # Check inputs to mode acceptable_modes = {'conv', 'lstm', 'gru', None} if mode is not None: mode = str(mode).lower() if mode not in acceptable_modes: raise ValueError('Mode {} not supported. Please choose ' 'from {}.'.format(mode, str(acceptable_modes))) f_name = str(feature.name)[:2] if mode == 'conv': x = Conv3D( feature_size, (frames_per_batch, 3, 3), strides=(1, 1, 1), padding='same', name='conv3D_mtf_{}'.format(f_name), )(feature) x = BatchNormalization(axis=-1, name='bnorm_mtf_{}'.format(f_name))(x) x = Activation('relu', name='acti_mtf_{}'.format(f_name))(x) elif mode == 'lstm': x = ConvLSTM2D(feature_size, (3, 3), padding='same', activation='relu', return_sequences=True, name='convLSTM_mtf_{}'.format(f_name))(feature) elif mode == 'gru': x = ConvGRU2D(feature_size, (3, 3), padding='same', activation='relu', return_sequences=True, name='convGRU_mtf_{}'.format(f_name))(feature) else: x = feature temporal_feature = x return temporal_feature
name = 'SKIP-GRAM_example' layers = [{ 'Size': 100, 'Activation': 'relu' }, { 'Size': 75, 'Activation': 'relu' }, { 'Size': len(word_bank), 'Activation': 'softmax' }] #Build model ---------------------------------> model = Sequential() model.add(Flatten()) #Must flatten layer if going from 2D to 1D (dense) model.add(Dense(layers[0]['Size'], input_shape=data['context'].shape[1:])) model.add(Activation(layers[0]['Activation'])) for l in layers[1:]: model.add(Dropout(0.5)) model.add(Dense(l['Size'])) model.add(Activation(l['Activation'])) #Train model ---------------------------------> model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) model.fit(X, y, epochs=100, validation_split=0.3, callbacks=[tensorboard]) #Save & log new model ------------------------> if os.path.exists('{}/logs/models.csv'.format(locations['main'])): data = load.readData('{}/logs/models.csv'.format(locations['main'])) else: data = pd.DataFrame()
def __create_pyramid_features(C3, C4, C5, feature_size=256): """Creates the FPN layers on top of the backbone features. Args: C3: Feature stage C3 from the backbone. C4: Feature stage C4 from the backbone. C5: Feature stage C5 from the backbone. feature_size: The feature size to use for the resulting feature levels. Returns: A list of feature levels [P3, P4, P5, P6, P7]. """ # upsample C5 to get P5 from the FPN paper P5 = Conv3D(feature_size, kernel_size=1, strides=1, padding='same', name='C5_reduced')(C5) P5_upsampled = UpsampleLike3D(name='P5_upsampled')([P5, C4]) P5 = Conv3D(feature_size, kernel_size=3, strides=1, padding='same', name='P5')(P5) # add P5 elementwise to C4 P4 = Conv3D(feature_size, kernel_size=1, strides=1, padding='same', name='C4_reduced')(C4) P4 = Add(name='P4_merged')([P5_upsampled, P4]) P4_upsampled = UpsampleLike3D(name='P4_upsampled')([P4, C3]) P4 = Conv3D(feature_size, kernel_size=3, strides=1, padding='same', name='P4')(P4) # add P4 elementwise to C3 P3 = Conv3D(feature_size, kernel_size=1, strides=1, padding='same', name='C3_reduced')(C3) P3 = Add(name='P3_merged')([P4_upsampled, P3]) P3 = Conv3D(feature_size, kernel_size=3, strides=1, padding='same', name='P3')(P3) # "P6 is obtained via a 3x3 stride-2 conv on C5" P6 = Conv3D(feature_size, kernel_size=3, strides=2, padding='same', name='P6')(C5) # "P7 is computed by applying ReLU followed by a 3x3 stride-2 conv on P6" P7 = Activation('relu', name='C6_relu')(P6) P7 = Conv3D(feature_size, kernel_size=3, strides=2, padding='same', name='P7')(P7) return [P3, P4, P5, P6, P7]
print(np.shape(train)) print(np.shape(test)) # In[3]: fitur ektraksi train_input = train[:, :-10] train_labels = train[:, -10:] # In[3]: fitur ektraksi test_input = test[:, :-10] test_labels = test[:, -10:] # In[3]: fitur ektraksi print(np.shape(train_input)) print(np.shape(train_labels)) # In[3]: membuat seq NN, layer pertama dense dari 100 neurons, no 7 model = Sequential([ Dense(100, input_dim=np.shape(train_input)[1]), Activation('relu'), Dense(10), Activation('softmax'), ]) # In[3]: fitur ektraksi no 8 model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) print(model.summary()) # In[3]: fitur ektraksi, no 9 model.fit(train_input, train_labels, epochs=10, batch_size=32, validation_split=0.2) # In[3]: fitur ektraksi no 10
gen.add(BatchNormalization(momentum=0.9)) gen.add(LeakyReLU(alpha=0.2)) gen.add(UpSampling2D()) gen.add(Conv2DTranspose(int(channel_depth / 8), 5, padding='same')) gen.add(BatchNormalization(momentum=0.9)) gen.add(LeakyReLU(alpha=0.2)) ''' gen.add(Conv2DTranspose(int(channel_depth / 8), 5, padding='same')) gen.add(BatchNormalization(momentum=0.9)) gen.add(Activation('relu')) ''' # Out: 28 x 28 x 1 gen.add(Conv2DTranspose(1, 5, padding='same')) gen.add(Activation('tanh')) # now the discriminator channel_depth = 8 dropout = 0.4 D = Sequential() D.add(InputLayer(input_shape=(img_size_flat, ))) D.add(Reshape(img_size_full)) D.add(Conv2D(channel_depth * 1, 5, strides=2, padding='same')) D.add(BatchNormalization(momentum=0.9)) D.add(LeakyReLU(alpha=0.2)) D.add(Dropout(dropout)) D.add(Conv2D(channel_depth * 2, 5, strides=2, padding='same'))
def create_model_v1(): """ description: Defining the Model with keras backend output: 1. The Model """ model = Sequential() # 1st Convolutional Layer model.add(Conv2D(filters=96, input_shape=(img_rows, img_cols, color_type), kernel_size=(11,11),strides=(4,4), padding='valid')) model.add(Activation('relu')) # Pooling model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='valid')) # Batch Normalisation before passing it to the next layer model.add(BatchNormalization()) # 2nd Convolutional Layer model.add(Conv2D(filters=256, kernel_size=(11,11), strides=(1,1), padding='valid')) model.add(Activation('relu')) # Pooling model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='valid')) # Batch Normalisation model.add(BatchNormalization()) # 3rd Convolutional Layer model.add(Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), padding='valid')) model.add(Activation('relu')) # Batch Normalisation model.add(BatchNormalization()) # 4th Convolutional Layer model.add(Conv2D(filters=384, kernel_size=(3,3), strides=(1,1), padding='valid')) model.add(Activation('relu')) # Batch Normalisation model.add(BatchNormalization()) # 5th Convolutional Layer model.add(Conv2D(filters=256, kernel_size=(3,3), strides=(1,1), padding='valid')) model.add(Activation('relu')) # Pooling model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='valid')) # Batch Normalisation model.add(BatchNormalization()) # Passing it to a dense layer model.add(Flatten()) # 1st Dense Layer model.add(Dense(4096, input_shape=(224*224*3,))) model.add(Activation('relu')) # Add Dropout to prevent overfitting model.add(Dropout(0.4)) # Batch Normalisation model.add(BatchNormalization()) # 2nd Dense Layer model.add(Dense(4096)) model.add(Activation('relu')) # Add Dropout model.add(Dropout(0.4)) # Batch Normalisation model.add(BatchNormalization()) # 3rd Dense Layer model.add(Dense(1000)) model.add(Activation('relu')) # Add Dropout model.add(Dropout(0.4)) # Batch Normalisation model.add(BatchNormalization()) # Output Layer model.add(Dense(10)) model.add(Activation('softmax')) return model
def generator(batch_size, gf_dim, ch, rows, cols): """ Generator model. Generates image from compressed image representation (vector Z). Input: Z (compressed image representation) Output: generated image """ model = Sequential() # Input layer. model.add( Dense(gf_dim * 8 * rows[0] * cols[0], name="g_h0_lin", batch_input_shape=(batch_size, z_dim), kernel_initializer=initializers.random_normal(stddev=.02))) model.add(Reshape((rows[0], cols[0], gf_dim * 8))) model.add( BN(axis=3, name="g_bn0", epsilon=1e-5, gamma_initializer=initializers.random_normal(mean=1., stddev=.02))) model.add(Activation("relu")) # Layer 1. model.add( Conv2DTranspose( gf_dim * 4, kernel_size=(5, 5), strides=(2, 2), padding="same", name="g_h1", kernel_initializer=initializers.random_normal(stddev=.02))) model.add( BN(axis=3, name="g_bn1", epsilon=1e-5, gamma_initializer=initializers.random_normal(mean=1., stddev=.02))) model.add(Activation("relu")) # Layer 2. model.add( Conv2DTranspose( gf_dim * 2, kernel_size=(5, 5), strides=(2, 2), padding="same", name="g_h2", kernel_initializer=initializers.random_normal(stddev=.02))) model.add( BN(axis=3, name="g_bn2", epsilon=1e-5, gamma_initializer=initializers.random_normal(mean=1., stddev=.02))) model.add(Activation("relu")) # Layer 3. model.add( Conv2DTranspose( gf_dim, kernel_size=(5, 5), strides=(2, 2), padding="same", name="g_h3", kernel_initializer=initializers.random_normal(stddev=.02))) model.add( BN(axis=3, name="g_bn3", epsilon=1e-5, gamma_initializer=initializers.random_normal(mean=1., stddev=.02))) model.add(Activation("relu")) # Output layer. model.add( Conv2DTranspose( ch, kernel_size=(5, 5), strides=(2, 2), padding="same", name="g_h4", kernel_initializer=initializers.random_normal(stddev=.02))) model.add(Activation("tanh")) return model
def build(input_shape=None, classes=3): img_input = Input(shape=input_shape) channel_axis = 1 if image_data_format() == 'channels_first' else -1 x = Conv2D(32, (3, 3), strides=(2, 2), use_bias=False, name='block1_conv1')(img_input) x = BatchNormalization(axis=channel_axis, name='block1_conv1_bn')(x) x = Activation('relu', name='block1_conv1_act')(x) x = Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x) x = BatchNormalization(axis=channel_axis, name='block1_conv2_bn')(x) x = Activation('relu', name='block1_conv2_act')(x) residual = Conv2D(128, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization(axis=channel_axis)(residual) x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv1')(x) x = BatchNormalization(axis=channel_axis, name='block2_sepconv1_bn')(x) x = Activation('relu', name='block2_sepconv2_act')(x) x = SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv2')(x) x = BatchNormalization(axis=channel_axis, name='block2_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block2_pool')(x) x = add([x, residual]) residual = Conv2D(256, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization(axis=channel_axis)(residual) x = Activation('relu', name='block3_sepconv1_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv1')(x) x = BatchNormalization(axis=channel_axis, name='block3_sepconv1_bn')(x) x = Activation('relu', name='block3_sepconv2_act')(x) x = SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv2')(x) x = BatchNormalization(axis=channel_axis, name='block3_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block3_pool')(x) x = add([x, residual]) residual = Conv2D(728, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization(axis=channel_axis)(residual) x = Activation('relu', name='block4_sepconv1_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv1')(x) x = BatchNormalization(axis=channel_axis, name='block4_sepconv1_bn')(x) x = Activation('relu', name='block4_sepconv2_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv2')(x) x = BatchNormalization(axis=channel_axis, name='block4_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block4_pool')(x) x = add([x, residual]) for i in range(8): residual = x prefix = 'block' + str(i + 5) x = Activation('relu', name=prefix + '_sepconv1_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv1')(x) x = BatchNormalization(axis=channel_axis, name=prefix + '_sepconv1_bn')(x) x = Activation('relu', name=prefix + '_sepconv2_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv2')(x) x = BatchNormalization(axis=channel_axis, name=prefix + '_sepconv2_bn')(x) x = Activation('relu', name=prefix + '_sepconv3_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv3')(x) x = BatchNormalization(axis=channel_axis, name=prefix + '_sepconv3_bn')(x) x = add([x, residual]) residual = Conv2D(1024, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = BatchNormalization(axis=channel_axis)(residual) x = Activation('relu', name='block13_sepconv1_act')(x) x = SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block13_sepconv1')(x) x = BatchNormalization(axis=channel_axis, name='block13_sepconv1_bn')(x) x = Activation('relu', name='block13_sepconv2_act')(x) x = SeparableConv2D(1024, (3, 3), padding='same', use_bias=False, name='block13_sepconv2')(x) x = BatchNormalization(axis=channel_axis, name='block13_sepconv2_bn')(x) x = MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block13_pool')(x) x = add([x, residual]) x = SeparableConv2D(1536, (3, 3), padding='same', use_bias=False, name='block14_sepconv1')(x) x = BatchNormalization(axis=channel_axis, name='block14_sepconv1_bn')(x) x = Activation('relu', name='block14_sepconv1_act')(x) x = SeparableConv2D(2048, (3, 3), padding='same', use_bias=False, name='block14_sepconv2')(x) x = BatchNormalization(axis=channel_axis, name='block14_sepconv2_bn')(x) x = Activation('relu', name='block14_sepconv2_act')(x) x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dropout(0.25)(x) # softmax classifier x = Flatten()(x) x = Dense(classes)(x) x = Activation("softmax")(x) inputs = img_input # Create model. return Model(inputs, x, name='xception')
def build_3d_cnn(w, h, d, s, num_outputs): #Credit: https://github.com/jessecha/DNRacing/blob/master/3D_CNN_Model/model.py ''' w : width h : height d : depth s : n_stacked ''' input_shape=(s, h, w, d) model = Sequential() #First layer #model.add(Cropping3D(cropping=((0,0), (50,10), (0,0)), input_shape=input_shape) ) #trim pixels off top # Second layer model.add(Conv3D( filters=16, kernel_size=(3,3,3), strides=(1,3,3), data_format='channels_last', padding='same', input_shape=input_shape) ) model.add(Activation('relu')) model.add(MaxPooling3D( pool_size=(1,2,2), strides=(1,2,2), padding='valid', data_format=None) ) # Third layer model.add(Conv3D( filters=32, kernel_size=(3,3,3), strides=(1,1,1), data_format='channels_last', padding='same') ) model.add(Activation('relu')) model.add(MaxPooling3D( pool_size=(1, 2, 2), strides=(1,2,2), padding='valid', data_format=None) ) # Fourth layer model.add(Conv3D( filters=64, kernel_size=(3,3,3), strides=(1,1,1), data_format='channels_last', padding='same') ) model.add(Activation('relu')) model.add(MaxPooling3D( pool_size=(1,2,2), strides=(1,2,2), padding='valid', data_format=None) ) # Fifth layer model.add(Conv3D( filters=128, kernel_size=(3,3,3), strides=(1,1,1), data_format='channels_last', padding='same') ) model.add(Activation('relu')) model.add(MaxPooling3D( pool_size=(1,2,2), strides=(1,2,2), padding='valid', data_format=None) ) # Fully connected layer model.add(Flatten()) model.add(Dense(256)) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(256)) model.add(BatchNormalization()) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(num_outputs)) #model.add(Activation('tanh')) return model
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] in_channels = inputs.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 SqueezeNet(include_top=True, weights="imagenet", model_input=None, non_top_pooling=None, num_classes=1000, model_path="", initial_num_classes=None, transfer_with_full_training=True): if (weights == "imagenet" and num_classes != 1000): raise ValueError( "You must parse in SqueezeNet model trained on the 1000 class ImageNet" ) image_input = model_input network = Conv2D(64, (3, 3), strides=(2, 2), padding="valid")(image_input) network = Activation("relu")(network) network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network) network = squeezenet_fire_module(input=network, input_channel_small=16, input_channel_large=64) network = squeezenet_fire_module(input=network, input_channel_small=16, input_channel_large=64) network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network) network = squeezenet_fire_module(input=network, input_channel_small=32, input_channel_large=128) network = squeezenet_fire_module(input=network, input_channel_small=32, input_channel_large=128) network = MaxPool2D(pool_size=(3, 3), strides=(2, 2))(network) network = squeezenet_fire_module(input=network, input_channel_small=48, input_channel_large=192) network = squeezenet_fire_module(input=network, input_channel_small=48, input_channel_large=192) network = squeezenet_fire_module(input=network, input_channel_small=64, input_channel_large=256) network = squeezenet_fire_module(input=network, input_channel_small=64, input_channel_large=256) if (include_top): network = Dropout(0.5)(network) if (initial_num_classes != None): network = Conv2D(initial_num_classes, kernel_size=(1, 1), padding="valid", name="last_conv")(network) else: network = Conv2D(num_classes, kernel_size=(1, 1), padding="valid", name="last_conv")(network) network = Activation("relu")(network) network = GlobalAvgPool2D()(network) network = Activation("softmax")(network) else: if (non_top_pooling == "Average"): network = GlobalAvgPool2D()(network) elif (non_top_pooling == "Maximum"): network = GlobalMaxPool2D()(network) elif (non_top_pooling == None): pass input_image = image_input model = Model(inputs=input_image, outputs=network) if (weights == "imagenet"): weights_path = model_path model.load_weights(weights_path) return model elif (weights == "trained"): weights_path = model_path model.load_weights(weights_path) return model elif (weights == "continued"): weights_path = model_path model.load_weights(weights_path) return model elif (weights == "transfer"): weights_path = model_path model.load_weights(weights_path) if (transfer_with_full_training == False): for eachlayer in model.layers: eachlayer.trainable = False print("Training with top layers of the Model") else: print("Training with all layers of the Model") network2 = model.layers[-5].output network2 = Conv2D(num_classes, kernel_size=(1, 1), padding="valid", name="last_conv")(network2) network2 = Activation("relu")(network2) network2 = GlobalAvgPool2D()(network2) network2 = Activation("softmax")(network2) new_model = Model(inputs=model.input, outputs=network2) return new_model elif (weights == "custom"): return model
def __init__(self, data_format='channels_first', domain_a_image_channels=3, domain_b_image_channels=1): # Encoding layers self.g_en_conv0_a = tf.make_template('conv0_a', LeakyReLUBNNSConv2d(n_filters=64, kernel_size=(5, 5), stride=(2, 2), padding='same', data_format=data_format)) self.g_en_conv0_b = tf.make_template('conv0_b', LeakyReLUBNNSConv2d(n_filters=64, kernel_size=(5, 5), stride=(2, 2), padding='same', data_format=data_format)) self.g_en_conv1 = tf.make_template('conv1', LeakyReLUBNNSConv2d(n_filters=128, kernel_size=(5, 5), stride=(2, 2), padding='same', data_format=data_format)) self.g_en_conv2 = tf.make_template('conv2', LeakyReLUBNNSConv2d(n_filters=256, kernel_size=(8, 8), stride=(1, 1), padding='valid', data_format=data_format)) self.g_en_conv3 = tf.make_template('conv3', LeakyReLUBNNSConv2d(n_filters=512, kernel_size=(1, 1), stride=(1, 1), padding='valid', data_format=data_format)) # Layer to generate the latent variables self.g_vae = tf.make_template('vae', GaussianVAE2D(n_filters=512, kernel_size=(1, 1), stride=(1, 1), padding='valid', data_format=data_format)) # Decoding layers # We will reconstruct the images using transposed convolutional layers followed by a tanh activation function # because the input image has been normalized such that the value of any pixel is between -1 and 1. self.g_de_conv0 = tf.make_template('de_conv0', LeakyReLUBNNSConvTranspose2d(n_filters=512, kernel_size=(4, 4), stride=(2, 2), padding='valid', data_format=data_format)) self.g_de_conv1 = tf.make_template('de_conv1', LeakyReLUBNNSConvTranspose2d(n_filters=256, kernel_size=(4, 4), stride=(2, 2), padding='same', data_format=data_format)) self.g_de_conv2 = tf.make_template('de_conv2', LeakyReLUBNNSConvTranspose2d(n_filters=128, kernel_size=(4, 4), stride=(2, 2), padding='same', data_format=data_format)) self.g_de_conv3_a = tf.make_template('de_conv3_a', LeakyReLUBNNSConvTranspose2d(n_filters=64, kernel_size=(4, 4), stride=(2, 2), padding='same', data_format=data_format)) self.g_de_conv3_b = tf.make_template('de_conv3_b', LeakyReLUBNNSConvTranspose2d(n_filters=64, kernel_size=(4, 4), stride=(2, 2), padding='same', data_format=data_format)) self.de_conv4_a = tf.make_template('de_conv4_a', Conv2DTranspose(filters=domain_a_image_channels, kernel_size=(1, 1), strides=(1, 1), padding='valid', data_format=data_format)) self.de_conv4_b = tf.make_template('de_conv4_b', Conv2DTranspose(filters=domain_b_image_channels, kernel_size=(1, 1), strides=(1, 1), padding='valid', data_format=data_format)) self.tanh_a = tf.make_template('tanh_a', Activation('tanh')) self.tanh_b = tf.make_template('tanh_b', Activation('tanh'))
def siamese_model(input_shape=None, track_length=1, features=None, neighborhood_scale_size=10, reg=1e-5, init='he_normal', softmax=True, norm_method='std', filter_size=61): def compute_input_shape(feature): if feature == 'appearance': return input_shape elif feature == 'distance': return (None, 2) elif feature == 'neighborhood': return (None, 2 * neighborhood_scale_size + 1, 2 * neighborhood_scale_size + 1, 1) elif feature == 'regionprop': return (None, 3) else: raise ValueError('siamese_model.compute_input_shape: ' 'Unknown feature `{}`'.format(feature)) def compute_reshape(feature): if feature == 'appearance': return (64,) elif feature == 'distance': return (2,) elif feature == 'neighborhood': return (64,) elif feature == 'regionprop': return (3,) else: raise ValueError('siamese_model.compute_output_shape: ' 'Unknown feature `{}`'.format(feature)) def compute_feature_extractor(feature, shape): if feature == 'appearance': # This should not stay: channels_first/last should be used to # dictate size (1 works for either right now) N_layers = np.int(np.floor(np.log2(input_shape[1]))) feature_extractor = Sequential() feature_extractor.add(InputLayer(input_shape=shape)) # feature_extractor.add(ImageNormalization2D(norm_method='std', filter_size=32)) for layer in range(N_layers): feature_extractor.add(Conv3D(64, (1, 3, 3), kernel_initializer=init, padding='same', kernel_regularizer=l2(reg))) feature_extractor.add(BatchNormalization(axis=channel_axis)) feature_extractor.add(Activation('relu')) feature_extractor.add(MaxPool3D(pool_size=(1, 2, 2))) feature_extractor.add(Reshape((-1, 64))) return feature_extractor elif feature == 'distance': return None elif feature == 'neighborhood': N_layers_og = np.int(np.floor(np.log2(2 * neighborhood_scale_size + 1))) feature_extractor_neighborhood = Sequential() feature_extractor_neighborhood.add( InputLayer(input_shape=(None, 2 * neighborhood_scale_size + 1, 2 * neighborhood_scale_size + 1, 1)) ) for layer in range(N_layers_og): feature_extractor_neighborhood.add(Conv3D(64, (1, 3, 3), kernel_initializer=init, padding='same', kernel_regularizer=l2(reg))) feature_extractor_neighborhood.add(BatchNormalization(axis=channel_axis)) feature_extractor_neighborhood.add(Activation('relu')) feature_extractor_neighborhood.add(MaxPool3D(pool_size=(1, 2, 2))) feature_extractor_neighborhood.add(Reshape((-1, 64))) return feature_extractor_neighborhood elif feature == 'regionprop': return None else: raise ValueError('siamese_model.compute_feature_extractor: ' 'Unknown feature `{}`'.format(feature)) if features is None: raise ValueError('siamese_model: No features specified.') if K.image_data_format() == 'channels_first': channel_axis = 1 input_shape = (input_shape[0], None, *input_shape[1:]) else: channel_axis = -1 input_shape = (None, *input_shape) features = sorted(features) inputs = [] outputs = [] for feature in features: in_shape = compute_input_shape(feature) re_shape = compute_reshape(feature) feature_extractor = compute_feature_extractor(feature, in_shape) layer_1 = Input(shape=in_shape) layer_2 = Input(shape=in_shape) inputs.extend([layer_1, layer_2]) # apply feature_extractor if it exists if feature_extractor is not None: layer_1 = feature_extractor(layer_1) layer_2 = feature_extractor(layer_2) # LSTM on 'left' side of network since that side takes in stacks of features layer_1 = LSTM(64)(layer_1) layer_2 = Reshape(re_shape)(layer_2) outputs.append([layer_1, layer_2]) dense_merged = [] for layer_1, layer_2 in outputs: merge = Concatenate(axis=channel_axis)([layer_1, layer_2]) dense_merge = Dense(128)(merge) bn_merge = BatchNormalization(axis=channel_axis)(dense_merge) dense_relu = Activation('relu')(bn_merge) dense_merged.append(dense_relu) # Concatenate outputs from both instances merged_outputs = Concatenate(axis=channel_axis)(dense_merged) # Add dense layers dense1 = Dense(128)(merged_outputs) bn1 = BatchNormalization(axis=channel_axis)(dense1) relu1 = Activation('relu')(bn1) dense2 = Dense(128)(relu1) bn2 = BatchNormalization(axis=channel_axis)(dense2) relu2 = Activation('relu')(bn2) dense3 = Dense(3, activation='softmax')(relu2) # Instantiate model final_layer = dense3 model = Model(inputs=inputs, outputs=final_layer) return model