def VGG16_BN(input_tensor=None, input_shape=None, classes=10, conv_dropout=0.4, dropout=0.5, activation='relu'): """Instantiates the VGG16 architecture with Batch Normalization # Arguments input_tensor: Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. input_shape: shape tuple classes: optional number of classes to classify images # Returns A Keras model instance. """ img_input = Input(shape=input_shape) if input_tensor is None else ( Input(tensor=input_tensor, shape=input_shape) if not K.is_keras_tensor(input_tensor) else input_tensor ) # Block 1 x = conv_block(64, dropout=0.3, activation=activation, block=1, layer=1)(img_input) x = conv_block(64, dropout=0, activation=activation, block=1, layer=2)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) # Block 2 x = conv_block(128, dropout=conv_dropout, activation=activation, block=2, layer=1)(x) x = conv_block(128, dropout=0, activation=activation, block=2, layer=2)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) # Block 3 x = conv_block(256, dropout=conv_dropout, activation=activation, block=3, layer=1)(x) x = conv_block(256, dropout=conv_dropout, activation=activation, block=3, layer=2)(x) x = conv_block(256, dropout=0, activation=activation, block=3, layer=3)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) # Block 4 x = conv_block(512, dropout=conv_dropout, activation=activation, block=4, layer=1)(x) x = conv_block(512, dropout=conv_dropout, activation=activation, block=4, layer=2)(x) x = conv_block(512, dropout=0, activation=activation, block=4, layer=3)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x) # Block 5 x = conv_block(512, dropout=conv_dropout, activation=activation, block=5, layer=1)(x) x = conv_block(512, dropout=conv_dropout, activation=activation, block=5, layer=2)(x) x = conv_block(512, dropout=0, activation=activation, block=5, layer=3)(x) x = MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x) # Flatten x = GlobalAveragePooling2D()(x) # FC Layers x = dense_block(512, dropout=dropout, activation=activation, name='fc1')(x) x = dense_block(512, dropout=dropout, activation=activation, name='fc2')(x) # Classification block x = Dense(classes, activation='softmax', name='predictions')(x) # Ensure that the model takes into account any potential predecessors of `input_tensor`. inputs = get_source_inputs(input_tensor) if input_tensor is not None else img_input # Create model. return Model(inputs, x, name='vgg16_bn')
def SEDenseNet(input_shape=None, depth=40, nb_dense_block=3, growth_rate=12, nb_filter=-1, nb_layers_per_block=-1, bottleneck=False, reduction=0.0, dropout_rate=0.0, weight_decay=1e-4, subsample_initial_block=False, include_top=True, weights=None, input_tensor=None, classes=10, activation='softmax'): # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=32, min_size=8, data_format=K.image_data_format(), require_flatten=include_top) if input_tensor is None: img_input = Input(shape=input_shape) else: if not is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = __create_dense_net(classes, img_input, include_top, depth, nb_dense_block, growth_rate, nb_filter, nb_layers_per_block, bottleneck, reduction, dropout_rate, weight_decay, subsample_initial_block, activation) # 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 # Create model. model = Model(inputs, x, name='se-densenet') return model
def InceptionResNetV2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): #global backend, layers, models, keras_utils #backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=299, min_size=75, data_format=backend.image_data_format(), require_flatten=False, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor # Stem block: 35 x 35 x 192 x = conv2d_bn(img_input, 32, 3, strides=2, padding='valid') x = conv2d_bn(x, 32, 3, padding='valid') x = conv2d_bn(x, 64, 3) x = layers.MaxPooling2D(3, strides=2)(x) x = conv2d_bn(x, 80, 1, padding='valid') x = conv2d_bn(x, 192, 3, padding='valid') x = layers.MaxPooling2D(3, strides=2)(x) # Mixed 5b (Inception-A block): 35 x 35 x 320 branch_0 = conv2d_bn(x, 96, 1) branch_1 = conv2d_bn(x, 48, 1) branch_1 = conv2d_bn(branch_1, 64, 5) branch_2 = conv2d_bn(x, 64, 1) branch_2 = conv2d_bn(branch_2, 96, 3) branch_2 = conv2d_bn(branch_2, 96, 3) branch_pool = layers.AveragePooling2D(3, strides=1, padding='same')(x) branch_pool = conv2d_bn(branch_pool, 64, 1) branches = [branch_0, branch_1, branch_2, branch_pool] channel_axis = 1 if backend.image_data_format() == 'channels_first' else 3 x = layers.Concatenate(axis=channel_axis, name='mixed_5b')(branches) # 10x block35 (Inception-ResNet-A block): 35 x 35 x 320 for block_idx in range(1, 11): x = inception_resnet_block(x, scale=0.17, block_type='block35', block_idx=block_idx) # Mixed 6a (Reduction-A block): 17 x 17 x 1088 branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='valid') branch_1 = conv2d_bn(x, 256, 1) branch_1 = conv2d_bn(branch_1, 256, 3) branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='valid') branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x) branches = [branch_0, branch_1, branch_pool] x = layers.Concatenate(axis=channel_axis, name='mixed_6a')(branches) # 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088 for block_idx in range(1, 21): x = inception_resnet_block(x, scale=0.1, block_type='block17', block_idx=block_idx) # Mixed 7a (Reduction-B block): 8 x 8 x 2080 branch_0 = conv2d_bn(x, 256, 1) branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='valid') branch_1 = conv2d_bn(x, 256, 1) branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='valid') branch_2 = conv2d_bn(x, 256, 1) branch_2 = conv2d_bn(branch_2, 288, 3) branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='valid') branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x) branches = [branch_0, branch_1, branch_2, branch_pool] x = layers.Concatenate(axis=channel_axis, name='mixed_7a')(branches) # 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080 for block_idx in range(1, 10): x = inception_resnet_block(x, scale=0.2, block_type='block8', block_idx=block_idx) x = inception_resnet_block(x, scale=1., activation=None, block_type='block8', block_idx=10) # Final convolution block: 8 x 8 x 1536 x = conv2d_bn(x, 1536, 1, name='conv_7b') if include_top: # Classification block x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(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 # Create model. model = Model(inputs, x, name='inception_resnet_v2') return model
def MobileNetV2(input_shape=None, alpha=1.0, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000, **kwargs): """Instantiates the MobileNetV2 architecture. # Arguments input_shape: optional shape tuple, to be specified if you would like to use a model with an input img resolution that is not (224, 224, 3). It should have exactly 3 inputs channels (224, 224, 3). You can also omit this option if you would like to infer input_shape from an input_tensor. If you choose to include both input_tensor and input_shape then input_shape will be used if they match, if the shapes do not match then we will throw an error. E.g. `(160, 160, 3)` would be one valid value. alpha: controls the width of the network. This is known as the width multiplier in the MobileNetV2 paper, but the name is kept for consistency with MobileNetV1 in Keras. - 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. 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. 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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 or invalid alpha, rows when weights='imagenet' """ 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') # Determine proper input shape and default size. # If both input_shape and input_tensor are used, they should match if input_shape is not None and input_tensor is not None: try: is_input_t_tensor = backend.is_keras_tensor(input_tensor) except ValueError: try: is_input_t_tensor = backend.is_keras_tensor( keras_utils.get_source_inputs(input_tensor)) except ValueError: raise ValueError('input_tensor: ', input_tensor, 'is not type input_tensor') if is_input_t_tensor: if backend.image_data_format == 'channels_first': if backend.int_shape(input_tensor)[1] != input_shape[1]: raise ValueError( 'input_shape: ', input_shape, 'and input_tensor: ', input_tensor, 'do not meet the same shape requirements') else: if backend.int_shape(input_tensor)[2] != input_shape[1]: raise ValueError( 'input_shape: ', input_shape, 'and input_tensor: ', input_tensor, 'do not meet the same shape requirements') else: raise ValueError('input_tensor specified: ', input_tensor, 'is not a keras tensor') # If input_shape is None, infer shape from input_tensor if input_shape is None and input_tensor is not None: try: backend.is_keras_tensor(input_tensor) except ValueError: raise ValueError('input_tensor: ', input_tensor, 'is type: ', type(input_tensor), 'which is not a valid type') if input_shape is None and not backend.is_keras_tensor(input_tensor): default_size = 224 elif input_shape is None and backend.is_keras_tensor(input_tensor): if backend.image_data_format() == 'channels_first': rows = backend.int_shape(input_tensor)[2] cols = backend.int_shape(input_tensor)[3] else: rows = backend.int_shape(input_tensor)[1] cols = backend.int_shape(input_tensor)[2] if rows == cols and rows in [96, 128, 160, 192, 224]: default_size = rows else: default_size = 224 # If input_shape is None and no input_tensor elif input_shape is None: default_size = 224 # If input_shape is not None, assume default size else: 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 input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if backend.image_data_format() == 'channels_last': row_axis, col_axis = (0, 1) else: row_axis, col_axis = (1, 2) rows = input_shape[row_axis] cols = input_shape[col_axis] 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 warnings.warn('MobileNet shape is undefined.' ' Weights for input shape' '(224, 224) will be loaded.') if backend.image_data_format() != 'channels_last': warnings.warn('The MobileNet family of models 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.') backend.set_image_data_format('channels_last') old_data_format = 'channels_first' else: old_data_format = None if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor first_block_filters = _make_divisible(32 * alpha, 8) x = layers.ZeroPadding2D(padding=correct_pad(backend, img_input, 3), name='Conv1_pad')(img_input) x = layers.Conv2D(first_block_filters, kernel_size=3, strides=(2, 2), padding='valid', use_bias=False, name='Conv1')(x) x = layers.BatchNormalization(epsilon=1e-3, momentum=0.999, name='bn_Conv1')(x) x = layers.ReLU(6., name='Conv1_relu')(x) x = _inverted_res_block(x, filters=16, alpha=alpha, stride=1, expansion=1, block_id=0) x = _inverted_res_block(x, filters=24, alpha=alpha, stride=2, expansion=6, block_id=1) x = _inverted_res_block(x, filters=24, alpha=alpha, stride=1, expansion=6, block_id=2) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=2, expansion=6, block_id=3) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=4) x = _inverted_res_block(x, filters=32, alpha=alpha, stride=1, expansion=6, block_id=5) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=2, expansion=6, block_id=6) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, expansion=6, block_id=7) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, expansion=6, block_id=8) x = _inverted_res_block(x, filters=64, alpha=alpha, stride=1, expansion=6, block_id=9) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, expansion=6, block_id=10) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, expansion=6, block_id=11) x = _inverted_res_block(x, filters=96, alpha=alpha, stride=1, expansion=6, block_id=12) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=2, expansion=6, block_id=13) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, expansion=6, block_id=14) x = _inverted_res_block(x, filters=160, alpha=alpha, stride=1, expansion=6, block_id=15) x = _inverted_res_block(x, filters=320, alpha=alpha, stride=1, expansion=6, block_id=16) # no alpha applied to last conv as stated in the paper: # if the width multiplier is greater than 1 we # increase the number of output channels if alpha > 1.0: last_block_filters = _make_divisible(1280 * alpha, 8) else: last_block_filters = 1280 x = layers.Conv2D(last_block_filters, kernel_size=1, use_bias=False, name='Conv_1')(x) x = layers.BatchNormalization(epsilon=1e-3, momentum=0.999, name='Conv_1_bn')(x) x = layers.ReLU(6., name='out_relu')(x) if include_top: x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(classes, activation='softmax', use_bias=True, name='Logits')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='mobilenetv2_%0.2f_%s' % (alpha, rows)) # Load weights. if weights == 'imagenet': if backend.image_data_format() == 'channels_first': raise ValueError('Weights for "channels_first" format ' 'are not available.') if include_top: model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' + str(alpha) + '_' + str(rows) + '.h5') weigh_path = BASE_WEIGHT_PATH + model_name weights_path = keras_utils.get_file(model_name, weigh_path, cache_subdir='models') else: model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' + str(alpha) + '_' + str(rows) + '_no_top' + '.h5') weigh_path = BASE_WEIGHT_PATH + model_name weights_path = keras_utils.get_file(model_name, weigh_path, cache_subdir='models') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) if old_data_format: backend.set_image_data_format(old_data_format) return model
def ResNet(model_params, input_shape=None, input_tensor=None, include_top=True, classes=1000, weights='imagenet', create_encoder=False): """Instantiates the ResNet, SEResNet architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. Args: 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels. 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. """ if input_tensor is None: img_input = layers.Input(shape=input_shape, name='data') else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor # choose residual block type ResidualBlock = model_params.residual_block Attention = None # get out intermidiate scales scales = [] # get parameters for model layers no_scale_bn_params = get_bn_params(scale=False) bn_params = get_bn_params() conv_params = get_conv_params() init_filters = 64 # resnet bottom x = layers.BatchNormalization(name='bn_data', **no_scale_bn_params)(img_input) x = layers.ZeroPadding2D(padding=(3, 3))(x) x = layers.Conv2D(init_filters, (7, 7), strides=(2, 2), name='conv0', **conv_params)(x) x = layers.BatchNormalization(name='bn0', **bn_params)(x) x = layers.Activation('relu', name='relu0')(x) x = layers.ZeroPadding2D(padding=(1, 1))(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='valid', name='pooling0')(x) # resnet body for stage, rep in enumerate(model_params.repetitions): for block in range(rep): filters = init_filters * (2 ** stage) # first block of first stage without strides because we have maxpooling before if block == 0 and stage == 0: x = ResidualBlock(filters, stage, block, strides=(1, 1), cut='post', attention=Attention)(x) elif block == 0: x = ResidualBlock(filters, stage, block, strides=(2, 2), cut='post', attention=Attention)(x) else: x = ResidualBlock(filters, stage, block, strides=(1, 1), cut='pre', attention=Attention)(x) if block == rep - 1: scales.append(x) x = layers.BatchNormalization(name='bn1', **bn_params)(x) x = layers.Activation('relu', name='relu1')(x) # resnet top if include_top: x = layers.GlobalAveragePooling2D(name='pool1')(x) x = layers.Dense(classes, name='fc1')(x) x = layers.Activation('softmax', name='softmax')(x) # Ensure that the model takes into account any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. if not create_encoder: model = Model(inputs, x) return model else: return inputs, x, scales
def NASNet(input_shape=None, penultimate_filters=4032, num_blocks=6, stem_block_filters=96, skip_reduction=True, filter_multiplier=2, include_top=True, weights=None, input_tensor=None, pooling=None, classes=1000, default_size=None, **kwargs): '''Instantiates a NASNet model. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments input_shape: Optional shape tuple, the input shape is by default `(331, 331, 3)` for NASNetLarge and `(224, 224, 3)` for NASNetMobile. It should have exactly 3 input channels, and width and height should be no smaller than 32. E.g. `(224, 224, 3)` would be one valid value. penultimate_filters: Number of filters in the penultimate layer. NASNet models use the notation `NASNet (N @ P)`, where: - N is the number of blocks - P is the number of penultimate filters num_blocks: Number of repeated blocks of the NASNet model. NASNet models use the notation `NASNet (N @ P)`, where: - N is the number of blocks - P is the number of penultimate filters stem_block_filters: Number of filters in the initial stem block skip_reduction: Whether to skip the reduction step at the tail end of the network. filter_multiplier: Controls the width of the network. - If `filter_multiplier` < 1.0, proportionally decreases the number of filters in each layer. - If `filter_multiplier` > 1.0, proportionally increases the number of filters in each layer. - If `filter_multiplier` = 1, default number of filters from the paper are used at each layer. include_top: Whether to include the fully-connected layer at the top of the network. weights: `None` (random initialization) or `imagenet` (ImageNet weights) input_tensor: Optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. 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. default_size: Specifies the default image size of the model # Returns A Keras model instance. # Raises ValueError: In case of invalid argument for `weights`, invalid input shape or invalid `penultimate_filters` value. ''' # global backend, layers, models, keras_utils # backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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 (isinstance(input_shape, tuple) and None in input_shape and weights == 'imagenet'): raise ValueError('When specifying the input shape of a NASNet' ' and loading `ImageNet` weights, ' 'the input_shape argument must be static ' '(no None entries). Got: `input_shape=' + str(input_shape) + '`.') if default_size is None: default_size = 331 # Determine proper input shape and default size. input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if backend.image_data_format() != 'channels_last': warnings.warn('The NASNet family of models 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.') backend.set_image_data_format('channels_last') old_data_format = 'channels_first' else: old_data_format = None if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if penultimate_filters % 24 != 0: raise ValueError( 'For NASNet-A models, the value of `penultimate_filters` ' 'needs to be divisible by 24. Current value: %d' % penultimate_filters) channel_dim = 1 if backend.image_data_format() == 'channels_first' else -1 filters = penultimate_filters // 24 x = layers.Conv2D(stem_block_filters, (3, 3), strides=(2, 2), padding='same', use_bias=False, kernel_regularizer=l2(weight_decay), name='stem_conv1', kernel_initializer='he_normal')(img_input) if use_bn: x = layers.BatchNormalization(axis=channel_dim, momentum=bn_momentum, epsilon=1e-3, name='stem_bn1')(x) p = None x, p = _reduction_a_cell(x, p, filters // (filter_multiplier**2), block_id='stem_1') x, p = _reduction_a_cell(x, p, filters // filter_multiplier, block_id='stem_2') for i in range(num_blocks): x, p = _normal_a_cell(x, p, filters, block_id='%d' % (i)) x, p0 = _reduction_a_cell(x, p, filters * filter_multiplier, block_id='reduce_%d' % (num_blocks)) p = p0 if not skip_reduction else p for i in range(num_blocks): x, p = _normal_a_cell(x, p, filters * filter_multiplier, block_id='%d' % (num_blocks + i + 1)) x, p0 = _reduction_a_cell(x, p, filters * filter_multiplier**2, block_id='reduce_%d' % (2 * num_blocks)) p = p0 if not skip_reduction else p for i in range(num_blocks): x, p = _normal_a_cell(x, p, filters * filter_multiplier**2, block_id='%d' % (2 * num_blocks + i + 1)) x = layers.Activation('relu')(x) if include_top: x = layers.GlobalAveragePooling2D()(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input model = models.Model(inputs, x, name='NASNet') # Load weights. if weights == 'imagenet': if default_size == 224: # mobile version if include_top: weights_path = keras_utils.get_file( 'nasnet_mobile.h5', NASNET_MOBILE_WEIGHT_PATH, cache_subdir='models', file_hash='020fb642bf7360b370c678b08e0adf61') else: weights_path = keras_utils.get_file( 'nasnet_mobile_no_top.h5', NASNET_MOBILE_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='1ed92395b5b598bdda52abe5c0dbfd63') model.load_weights(weights_path) elif default_size == 331: # large version if include_top: weights_path = keras_utils.get_file( 'nasnet_large.h5', NASNET_LARGE_WEIGHT_PATH, cache_subdir='models', file_hash='11577c9a518f0070763c2b964a382f17') else: weights_path = keras_utils.get_file( 'nasnet_large_no_top.h5', NASNET_LARGE_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='d81d89dc07e6e56530c4e77faddd61b5') model.load_weights(weights_path) else: raise ValueError( 'ImageNet weights can only be loaded with NASNetLarge' ' or NASNetMobile') elif weights is not None: model.load_weights(weights) if old_data_format: backend.set_image_data_format(old_data_format) return model
def EfficientNet(input_shape, block_args_list: List[BlockArgs], width_coefficient: float, depth_coefficient: float, include_top=True, weights=None, input_tensor=None, pooling=None, classes=1000, dropout_rate=0., drop_connect_rate=0., batch_norm_momentum=0.99, batch_norm_epsilon=1e-3, depth_divisor=8, min_depth=None, data_format=None, default_size=None, **kwargs): if data_format is None: data_format = K.image_data_format() # if data_format == 'channels_first': # channel_axis = 1 # else: # channel_axis = -1 if default_size is None: default_size = 224 if block_args_list is None: block_args_list = get_default_block_list() # count number of strides to compute min size stride_count = 1 for block_args in block_args_list: if block_args.strides is not None and block_args.strides[0] > 1: stride_count += 1 min_size = int(2 ** stride_count) # Determine proper input shape and default size. input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=min_size, data_format=data_format, require_flatten=include_top, weights=weights) # Stem part if input_tensor is None: inputs = layers.Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): inputs = layers.Input(tensor=input_tensor, shape=input_shape) else: inputs = input_tensor x = inputs x = layers.Conv2D( filters=round_filters(32, width_coefficient, depth_divisor, min_depth), kernel_size=[3, 3], strides=[2, 2], kernel_initializer=EfficientNetConvInitializer(), padding='same', use_bias=False)(x) x = layers.BatchNormalization( axis=channel_axis, momentum=batch_norm_momentum, epsilon=batch_norm_epsilon)(x) x = Swish()(x) num_blocks = sum([block_args.num_repeat for block_args in block_args_list]) drop_connect_rate_per_block = drop_connect_rate / float(num_blocks) # Blocks part for block_idx, block_args in enumerate(block_args_list): assert block_args.num_repeat > 0 # Update block input and output filters based on depth multiplier. block_args.input_filters = round_filters(block_args.input_filters, width_coefficient, depth_divisor, min_depth) block_args.output_filters = round_filters(block_args.output_filters, width_coefficient, depth_divisor, min_depth) block_args.num_repeat = round_repeats(block_args.num_repeat, depth_coefficient) # The first block needs to take care of stride and filter size increase. x = MBConvBlock(block_args.input_filters, block_args.output_filters, block_args.kernel_size, block_args.strides, block_args.expand_ratio, block_args.se_ratio, block_args.identity_skip, drop_connect_rate_per_block * block_idx, batch_norm_momentum, batch_norm_epsilon, data_format)(x) if block_args.num_repeat > 1: block_args.input_filters = block_args.output_filters block_args.strides = [1, 1] for _ in range(block_args.num_repeat - 1): x = MBConvBlock(block_args.input_filters, block_args.output_filters, block_args.kernel_size, block_args.strides, block_args.expand_ratio, block_args.se_ratio, block_args.identity_skip, drop_connect_rate_per_block * block_idx, batch_norm_momentum, batch_norm_epsilon, data_format)(x) # Head part x = layers.Conv2D( filters=round_filters(1280, width_coefficient, depth_coefficient, min_depth), kernel_size=[1, 1], strides=[1, 1], kernel_initializer=EfficientNetConvInitializer(), padding='same', use_bias=False)(x) x = layers.BatchNormalization( axis=channel_axis, momentum=batch_norm_momentum, epsilon=batch_norm_epsilon)(x) x = Swish()(x) x = layers.GlobalAveragePooling2D(data_format=data_format)(x) if dropout_rate > 0: x = layers.Dropout(dropout_rate)(x) x = layers.Dense(classes, kernel_initializer=EfficientNetDenseInitializer())(x) x = layers.Activation('softmax')(x) outputs = 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) model = Model(inputs, outputs) # Load weights elif weights is not None: model.load_weights(weights)
def InceptionV31D(input_shape=None, weights=None, input_tensor=None, pooling=None, classes=2, dropout=0.0, top={ 'n_neurons': [], 'dropout': [], 'batch_norm': True }): """Instantiates the Inception v3 architecture. Optionally loads pre-trained weights. Note that the data format convention used by the model is the one specified in your Keras cfg_clb at `~/.keras/keras.json`. # Arguments input_shape: optional shape tuple, only to be specified if `top` is None (otherwise the input shape has to be `(...)` (with `channels_last` data format) or `(...)` (with `channels_first` data format). It should have exactly 3 input channel, and width and height should be no smaller than 75. E.g. `(150, 1)` would be one valid value. weights: one of `None` (random initialization) 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. 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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. include_top: whether to include the fully-connected layer at the top of the network. # Returns A Keras model instance. # Raises ValueError: in case of invalid argument for `weights`, or invalid input shape. """ if weights is not None and not os.path.exists(weights): raise ValueError('The `weights` argument should be either' '`None` (random initialization),' 'or the path to the weights file to be loaded.') if input_tensor is None: inp = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): inp = Input(tensor=input_tensor, shape=input_shape) else: inp = input_tensor if K.image_data_format() == 'channels_first': channel_axis = 1 else: channel_axis = -1 # Input layer inp = Input(shape=input_shape) x = conv1d_bn(inp, 32, 3, strides=2, padding='valid') x = conv1d_bn(x, 32, 3, padding='valid') x = conv1d_bn(x, 64, 3) x = MaxPooling1D(3, strides=2)(x) x = conv1d_bn(x, 80, 1, padding='valid') x = conv1d_bn(x, 192, 3, padding='valid') x = MaxPooling1D(3, strides=2)(x) # mixed 0: 35 x 35 x 256 x = inception_module(x, 64, 64, 96, 48, 64, 32, double=True, name='mixed0') # mixed 1: 35 x 35 x 288 x = inception_module(x, 64, 64, 96, 48, 64, 64, double=True, name='mixed1') # mixed 2: 35 x 35 x 288 x = inception_module(x, 64, 64, 96, 48, 64, 64, double=True, name='mixed2') # mixed 3: 17 x 17 x 768 conv3 = conv1d_bn(x, 384, 3, strides=2, padding='valid') conv3dbl = conv1d_bn(x, 64, 1) conv3dbl = conv1d_bn(conv3dbl, 96, 3) conv3dbl = conv1d_bn(conv3dbl, 96, 3, strides=2, padding='valid') pool = MaxPooling1D(3, strides=2)(x) x = concatenate([conv3, conv3dbl, pool], axis=channel_axis, name='mixed3') # mixed 4: 17 x 17 x 768 conv1 = conv1d_bn(x, 192, 1) conv7 = conv1d_bn(x, 128, 1) conv7 = conv1d_bn(conv7, 128, 7) conv7dbl = conv1d_bn(x, 128, 1) conv7dbl = conv1d_bn(conv7dbl, 128, 7) conv7dbl = conv1d_bn(conv7dbl, 128, 7) pool = AveragePooling1D(3, strides=1, padding='same')(x) pool = conv1d_bn(pool, 192, 1) x = concatenate([conv1, conv7, conv7dbl, pool], axis=channel_axis, name='mixed4') # mixed 5, 6: 17 x 17 x 768 for i in range(2): conv1 = conv1d_bn(x, 192, 1) conv7 = conv1d_bn(x, 160, 1) conv7 = conv1d_bn(conv7, 192, 7) conv7dbl = conv1d_bn(x, 160, 1) conv7dbl = conv1d_bn(conv7dbl, 160, 7) conv7dbl = conv1d_bn(conv7dbl, 192, 7) pool = AveragePooling1D(3, strides=1, padding='same')(x) pool = conv1d_bn(pool, 192, 1) x = concatenate([conv1, conv7, conv7dbl, pool], axis=channel_axis, name='mixed' + str(5 + i)) # mixed 7: 17 x 17 x 768 conv1 = conv1d_bn(x, 192, 1) conv7 = conv1d_bn(x, 192, 1) conv7 = conv1d_bn(conv7, 192, 7) conv7dbl = conv1d_bn(x, 192, 1) conv7dbl = conv1d_bn(conv7dbl, 192, 7) conv7dbl = conv1d_bn(conv7dbl, 192, 7) pool = AveragePooling1D(3, strides=1, padding='same')(x) pool = conv1d_bn(pool, 192, 1) x = concatenate([conv1, conv7, conv7dbl, pool], axis=channel_axis, name='mixed7') # mixed 8: 8 x 8 x 1280 conv3 = conv1d_bn(x, 192, 1) conv3 = conv1d_bn(conv3, 320, 3, strides=2, padding='valid') conv7 = conv1d_bn(x, 192, 1) conv7 = conv1d_bn(conv7, 192, 7) conv7 = conv1d_bn(conv7, 192, 3, strides=2, padding='valid') pool = MaxPooling1D(3, strides=2)(x) x = concatenate([conv3, conv7, pool], axis=channel_axis, name='mixed8') # mixed 9: 8 x 8 x 2048 for i in range(2): conv1 = conv1d_bn(x, 320, 1) conv3 = conv1d_bn(x, 384, 1) conv3 = conv1d_bn(conv3, 384, 3) conv3dbl = conv1d_bn(x, 448, 1) conv3dbl = conv1d_bn(conv3dbl, 384, 3) conv3dbl = conv1d_bn(conv3dbl, 384, 3) pool = AveragePooling1D(3, strides=1, padding='same')(x) pool = conv1d_bn(pool, 192, 1) x = concatenate([conv1, conv3, conv3dbl, pool], axis=channel_axis, name='mixed' + str(9 + i)) if top is None or top['n_neurons'] is None: if pooling == 'avg': x = GlobalAveragePooling1D()(x) elif pooling == 'max': x = GlobalMaxPooling1D()(x) else: # Include the fully-connected layer(s) at the top of the network # Classification/prediction block if classes == 2: n_pred_neurons = 1 last_activation = 'sigmoid' else: n_pred_neurons = classes last_activation = 'softmax' dense_layers = list(top['n_neurons']) dense_layers.append(n_pred_neurons) x = GlobalAveragePooling1D(name='avg_pool')(x) if dropout > 0: x = Dropout(dropout, name='dropout_{}'.format(dropout))(x) x = dense_block(x, dense_layers, flatten=False, last_activation=last_activation, batch_norm=top['batch_norm'], batch_norm_after_activation=True, dropout=top['dropout'], name='fc') # 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 = inp # Create model model = Model(inputs, x, name='inceptionV31D') # Load weights if weights is not None: model.load_weights(weights) # Return Keras model instance return model
def VGG16_fix(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the VGG16 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments include_top: whether to include the 3 fully-connected layers 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 input channels, and width and height should be no smaller than 32. E.g. `(200, 200, 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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. """ acf = 'relufix' acfpred = 'softmaxfix' #backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor # Block 1 x = layers.Conv2D(64, (3, 3), activation=acf, padding='same', name='block1_conv1')(img_input) x = layers.Conv2D(64, (3, 3), activation=acf, padding='same', name='block1_conv2')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block1_pool')(x) # Block 2 x = layers.Conv2D(128, (3, 3), activation=acf, padding='same', name='block2_conv1')(x) x = layers.Conv2D(128, (3, 3), activation=acf, padding='same', name='block2_conv2')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block2_pool')(x) # Block 3 x = layers.Conv2D(256, (3, 3), activation=acf, padding='same', name='block3_conv1')(x) x = layers.Conv2D(256, (3, 3), activation=acf, padding='same', name='block3_conv2')(x) x = layers.Conv2D(256, (3, 3), activation=acf, padding='same', name='block3_conv3')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) # Block 4 x = layers.Conv2D(512, (3, 3), activation=acf, padding='same', name='block4_conv1')(x) x = layers.Conv2D(512, (3, 3), activation=acf, padding='same', name='block4_conv2')(x) x = layers.Conv2D(512, (3, 3), activation=acf, padding='same', name='block4_conv3')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x) # Block 5 x = layers.Conv2D(512, (3, 3), activation=acf, padding='same', name='block5_conv1')(x) x = layers.Conv2D(512, (3, 3), activation=acf, padding='same', name='block5_conv2')(x) x = layers.Conv2D(512, (3, 3), activation=acf, padding='same', name='block5_conv3')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block5_pool')(x) if include_top: # Classification block x = layers.Flatten(name='flatten')(x) x = layers.Dense(4096, activation=acf, name='fc1')(x) x = layers.Dense(4096, activation=acf, name='fc2')(x) x = layers.Dense(classes, activation=acfpred, name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='vgg16') # Load weights. if weights == 'imagenet': if include_top: weights_path = keras_utils.get_file( 'vgg16_weights_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH, cache_subdir='models', file_hash='64373286793e3c8b2b4e3219cbf3544b') else: weights_path = keras_utils.get_file( 'vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5', WEIGHTS_PATH_NO_TOP, cache_subdir='models', file_hash='6d6bbae143d832006294945121d1f1fc') model.load_weights(weights_path) if backend.backend() == 'theano': keras_utils.convert_all_kernels_in_model(model) elif weights is not None: model.load_weights(weights) return model
def SEResNet(input_shape=None, initial_conv_filters=64, depth=[3, 4, 6, 3], filters=[64, 128, 256, 512], width=1, bottleneck=False, weight_decay=1e-4, include_top=True, weights=None, input_tensor=None, pooling=None, classes=1000): """ Instantiate the Squeeze and Excite ResNet architecture. Note that , when using TensorFlow for best performance you should set `image_data_format="channels_last"` in your Keras config at ~/.keras/keras.json. The model are compatible with both TensorFlow and Theano. The dimension ordering convention used by the model is the one specified in your Keras config file. # Arguments initial_conv_filters: number of features for the initial convolution depth: number or layers in the each block, defined as a list. ResNet-50 = [3, 4, 6, 3] ResNet-101 = [3, 6, 23, 3] ResNet-152 = [3, 8, 36, 3] filter: number of filters per block, defined as a list. filters = [64, 128, 256, 512 width: width multiplier for the network (for Wide ResNets) bottleneck: adds a bottleneck conv to reduce computation weight_decay: weight decay (l2 norm) include_top: whether to include the fully-connected layer at the top of the network. weights: `None` (random initialization) or `imagenet` (trained on ImageNet) 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 `(224, 224, 3)` (with `tf` dim ordering) or `(3, 224, 224)` (with `th` dim ordering). It should have exactly 3 inputs channels, and width and height should be no smaller than 8. E.g. `(200, 200, 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. """ if weights not in {'imagenet', None}: raise ValueError('The `weights` argument should be either ' '`None` (random initialization) or `imagenet` ' '(pre-training on ImageNet).') 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') assert len(depth) == len(filters), "The length of filter increment list must match the length " \ "of the depth list." # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=K.image_data_format(), require_flatten=False) if input_tensor is None: img_input = Input(shape=input_shape) else: if not is_keras_tensor(input_tensor): img_input = Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = _create_se_resnet(classes, img_input, include_top, initial_conv_filters, filters, depth, width, bottleneck, weight_decay, pooling) # pt_features = SEResNet50(input_shape, include_top=False) bn_features = BatchNormalization()(x) glb_max = GlobalMaxPooling2D()(bn_features) gap_dr = Dropout(0.25)(glb_max) dr_steps = Dropout(0.25)(Dense(512, activation='relu')(gap_dr)) dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps)) dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps)) dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps)) dr_steps = Dropout(0.25)(Dense(512, activation='relu')(dr_steps)) output = Dense(5, activation='softmax')(dr_steps) # 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 # Create model. model = Model(inputs, output, name='resnext') # load weights return model
def DenseNet(blocks, include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the DenseNet architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments blocks: numbers of building blocks for the four dense layers. 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 `(224, 224, 3)` (with `'channels_last'` data format) or `(3, 224, 224)` (with `'channels_first'` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(200, 200, 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. """ ## global backend, layers, models, keras_utils ## backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(img_input) x = layers.Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x) x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='conv1/bn')(x) x = layers.Activation('relu', name='conv1/relu')(x) x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x) x = layers.MaxPooling2D(3, strides=2, name='pool1')(x) x = dense_block(x, blocks[0], name='conv2') x = transition_block(x, 0.5, name='pool2') x = dense_block(x, blocks[1], name='conv3') x = transition_block(x, 0.5, name='pool3') x = dense_block(x, blocks[2], name='conv4') x = transition_block(x, 0.5, name='pool4') x = dense_block(x, blocks[3], name='conv5') x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='bn')(x) x = layers.Activation('relu', name='relu')(x) if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='fc1000')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D(name='max_pool')(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. if blocks == [6, 12, 24, 16]: model = models.Model(inputs, x, name='densenet121') elif blocks == [6, 12, 32, 32]: model = models.Model(inputs, x, name='densenet169') elif blocks == [6, 12, 48, 32]: model = models.Model(inputs, x, name='densenet201') else: model = models.Model(inputs, x, name='densenet') # Load weights. if weights == 'imagenet': if include_top: if blocks == [6, 12, 24, 16]: weights_path = keras_utils.get_file( 'densenet121_weights_tf_dim_ordering_tf_kernels.h5', DENSENET121_WEIGHT_PATH, cache_subdir='models', file_hash='9d60b8095a5708f2dcce2bca79d332c7') elif blocks == [6, 12, 32, 32]: weights_path = keras_utils.get_file( 'densenet169_weights_tf_dim_ordering_tf_kernels.h5', DENSENET169_WEIGHT_PATH, cache_subdir='models', file_hash='d699b8f76981ab1b30698df4c175e90b') elif blocks == [6, 12, 48, 32]: weights_path = keras_utils.get_file( 'densenet201_weights_tf_dim_ordering_tf_kernels.h5', DENSENET201_WEIGHT_PATH, cache_subdir='models', file_hash='1ceb130c1ea1b78c3bf6114dbdfd8807') else: if blocks == [6, 12, 24, 16]: weights_path = keras_utils.get_file( 'densenet121_weights_tf_dim_ordering_tf_kernels_notop.h5', DENSENET121_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='30ee3e1110167f948a6b9946edeeb738') elif blocks == [6, 12, 32, 32]: weights_path = keras_utils.get_file( 'densenet169_weights_tf_dim_ordering_tf_kernels_notop.h5', DENSENET169_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='b8c4d4c20dd625c148057b9ff1c1176b') elif blocks == [6, 12, 48, 32]: weights_path = keras_utils.get_file( 'densenet201_weights_tf_dim_ordering_tf_kernels_notop.h5', DENSENET201_WEIGHT_PATH_NO_TOP, cache_subdir='models', file_hash='c13680b51ded0fb44dff2d8f86ac8bb1') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
def ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, dataset="cifar10", **kwargs): """Instantiates the ResNet50 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(200, 200, 3)` would be one valid value. # Returns A Keras model instance. # Raises ValueError: in case of invalid argument for `weights`, or invalid input shape. """ #global backend, layers, models, keras_utils #backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) if dataset.casefold() == "cifar10": classes = 10 elif dataset.casefold() == "isic": classes = 8 elif dataset.casefold() == "imagenet": classes = 1000 else: print("Keras Resnet model: Please specify the name of your dataset") exit() 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.') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if backend.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 if dataset.casefold( ) == "cifar10": # input size 32x32, therefore we want a smaller conv kernel: x = layers.ZeroPadding2D(padding=(1, 1), name='conv1_pad')(img_input) x = layers.Conv2D(64, (3, 3), strides=(1, 1), padding='valid', kernel_initializer=custom_initialize, name='conv1')(x) else: x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input) x = layers.Conv2D(64, (7, 7), strides=(2, 2), padding='valid', kernel_initializer=custom_initialize, name='conv1')(x) x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x) x = layers.Activation('relu')(x) x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1)) x = identity_block(x, 3, [64, 64, 256], stage=2, block='b') x = identity_block(x, 3, [64, 64, 256], stage=2, block='c') x = conv_block(x, 3, [128, 128, 512], stage=3, block='a') x = identity_block(x, 3, [128, 128, 512], stage=3, block='b') x = identity_block(x, 3, [128, 128, 512], stage=3, block='c') x = identity_block(x, 3, [128, 128, 512], stage=3, block='d') x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f') x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c') #if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='fc1000')(x) #else: # if pooling == 'avg': # x = layers.GlobalAveragePooling2D()(x) # elif pooling == 'max': # x = layers.GlobalMaxPooling2D()(x) # else: # warnings.warn('The output shape of `ResNet50(include_top=False)` ' # 'has been changed since Keras 2.2.0.') # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='resnet50') # Load weights. #if weights == 'imagenet': # if include_top: # weights_path = keras_utils.get_file( # 'resnet50_weights_tf_dim_ordering_tf_kernels.h5', # WEIGHTS_PATH, # cache_subdir='models', # md5_hash='a7b3fe01876f51b976af0dea6bc144eb') # else: # weights_path = keras_utils.get_file( # 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5', # WEIGHTS_PATH_NO_TOP, # cache_subdir='models', # md5_hash='a268eb855778b3df3c7506639542a6af') # model.load_weights(weights_path) # if backend.backend() == 'theano': # keras_utils.convert_all_kernels_in_model(model) #elif weights is not None: # model.load_weights(weights) return model
def ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000): """Instantiates the ResNet50 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 197. E.g. `(200, 200, 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. """ 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') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if backend.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input) x = layers.Conv2D(64, (7, 7), strides=(2, 2), padding='valid', kernel_initializer='he_normal', name='conv1')(x) x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x) x = layers.Activation('relu')(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1)) x = identity_block(x, 3, [64, 64, 256], stage=2, block='b') x = identity_block(x, 3, [64, 64, 256], stage=2, block='c') x = conv_block(x, 3, [128, 128, 512], stage=3, block='a') x = identity_block(x, 3, [128, 128, 512], stage=3, block='b') x = identity_block(x, 3, [128, 128, 512], stage=3, block='c') x = identity_block(x, 3, [128, 128, 512], stage=3, block='d') x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f') x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c') if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='fc1000')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) else: warnings.warn('The output shape of `ResNet50(include_top=False)` ' 'has been changed since Keras 2.2.0.') # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='resnet50') # Load weights. if weights == 'imagenet': if include_top: weights_path = keras_utils.get_file( 'resnet50_weights_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH, cache_subdir='models', md5_hash='a7b3fe01876f51b976af0dea6bc144eb') else: weights_path = keras_utils.get_file( 'resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5', WEIGHTS_PATH_NO_TOP, cache_subdir='models', md5_hash='a268eb855778b3df3c7506639542a6af') model.load_weights(weights_path) if backend.backend() == 'theano': keras_utils.convert_all_kernels_in_model(model) elif weights is not None: model.load_weights(weights) return model
def ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the ResNet50 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(200, 200, 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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. """ if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if backend.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 x = layers.ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input) x = layers.Conv2D(64, (7, 7), strides=(2, 2), padding='valid', kernel_initializer='he_normal', name='conv1')(x) x = layers.BatchNormalization(axis=bn_axis, name='bn_conv1')(x) x = layers.Activation('relu')(x) x = layers.ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv_block(x, 3, [64, 64, 256], stage=2, block='a', strides=(1, 1)) x = identity_block(x, 3, [64, 64, 256], stage=2, block='b') x = identity_block(x, 3, [64, 64, 256], stage=2, block='c') x = conv_block(x, 3, [128, 128, 512], stage=3, block='a') x = identity_block(x, 3, [128, 128, 512], stage=3, block='b') x = identity_block(x, 3, [128, 128, 512], stage=3, block='c') x = identity_block(x, 3, [128, 128, 512], stage=3, block='d') x = conv_block(x, 3, [256, 256, 1024], stage=4, block='a') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='b') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='c') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='d') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='e') x = identity_block(x, 3, [256, 256, 1024], stage=4, block='f') x = conv_block(x, 3, [512, 512, 2048], stage=5, block='a') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='b') x = identity_block(x, 3, [512, 512, 2048], stage=5, block='c') if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='fc1000')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) else: warnings.warn('The output shape of `ResNet50(include_top=False)` ' 'has been changed since Keras 2.2.0.') # 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 # Create model. model = models.Model(inputs, x, name='resnet50') return model
def MobileNet(input_shape=None, alpha=1.0, depth_multiplier=1, dropout=1e-3, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000, **kwargs): """Instantiates the MobileNet architecture. # Arguments input_shape: optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(224, 224, 3)` (with `channels_last` data format) or (3, 224, 224) (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(200, 200, 3)` would be one valid value. alpha: controls the width of the network. This is known as the width multiplier in the MobileNet 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. depth_multiplier: depth multiplier for depthwise convolution. This is called the resolution multiplier in the MobileNet paper. dropout: dropout rate 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. 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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') # Determine proper input shape and default size. if input_shape is None: default_size = 224 else: 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 [128, 160, 192, 224]: default_size = rows else: default_size = 224 input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if backend.image_data_format() == 'channels_last': row_axis, col_axis = (0, 1) else: row_axis, col_axis = (1, 2) rows = input_shape[row_axis] cols = input_shape[col_axis] if weights == 'imagenet': if depth_multiplier != 1: raise ValueError('If imagenet weights are being loaded, ' 'depth multiplier must be 1') if alpha not in [0.25, 0.50, 0.75, 1.0]: raise ValueError('If imagenet weights are being loaded, ' 'alpha can be one of' '`0.25`, `0.50`, `0.75` or `1.0` only.') if rows != cols or rows not in [128, 160, 192, 224]: rows = 224 warnings.warn('MobileNet shape is undefined.' ' Weights for input shape ' '(224, 224) will be loaded.') if backend.image_data_format() != 'channels_last': warnings.warn('The MobileNet family of models 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.') backend.set_image_data_format('channels_last') old_data_format = 'channels_first' else: old_data_format = None if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = _conv_block(img_input, 32, alpha, strides=(2, 2)) x = _depthwise_conv_block(x, 64, alpha, depth_multiplier, block_id=1) x = _depthwise_conv_block(x, 128, alpha, depth_multiplier, strides=(2, 2), block_id=2) x = _depthwise_conv_block(x, 128, alpha, depth_multiplier, block_id=3) x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, strides=(2, 2), block_id=4) x = _depthwise_conv_block(x, 256, alpha, depth_multiplier, block_id=5) x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, strides=(2, 2), block_id=6) x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=7) x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=8) x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=9) x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=10) x = _depthwise_conv_block(x, 512, alpha, depth_multiplier, block_id=11) x = _depthwise_conv_block(x, 1024, alpha, depth_multiplier, strides=(2, 2), block_id=12) x = _depthwise_conv_block(x, 1024, alpha, depth_multiplier, block_id=13) if include_top: if backend.image_data_format() == 'channels_first': shape = (int(1024 * alpha), 1, 1) else: shape = (1, 1, int(1024 * alpha)) x = layers.GlobalAveragePooling2D()(x) x = layers.Reshape(shape, name='reshape_1')(x) x = layers.Dropout(dropout, name='dropout')(x) x = layers.Conv2D(classes, (1, 1), padding='same', name='conv_preds')(x) x = layers.Activation('softmax', name='act_softmax')(x) x = layers.Reshape((classes, ), name='reshape_2')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='mobilenet_%0.2f_%s' % (alpha, rows)) # Load weights. if weights == 'imagenet': if backend.image_data_format() == 'channels_first': raise ValueError('Weights for "channels_first" format ' 'are not available.') if alpha == 1.0: alpha_text = '1_0' elif alpha == 0.75: alpha_text = '7_5' elif alpha == 0.50: alpha_text = '5_0' else: alpha_text = '2_5' if include_top: model_name = 'mobilenet_%s_%d_tf.h5' % (alpha_text, rows) weight_path = BASE_WEIGHT_PATH + model_name weights_path = keras_utils.get_file(model_name, weight_path, cache_subdir='models') else: model_name = 'mobilenet_%s_%d_tf_no_top.h5' % (alpha_text, rows) weight_path = BASE_WEIGHT_PATH + model_name weights_path = keras_utils.get_file(model_name, weight_path, cache_subdir='models') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) if old_data_format: backend.set_image_data_format(old_data_format) return model
def ResNet50(input_tensor, input_shape, pooling=None): """Instantiates the ResNet50 architecture. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(200, 200, 3)` would be one valid value. pooling: Optional pooling mode for feature extraction. - `None` means that the output of the model will be the 4D tensor output of the last convolutional block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, and thus the output of the model will be a 2D tensor. - `max` means that global max pooling will be applied. # Returns A Keras model instance. """ 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 if K.image_data_format() == 'channels_last': bn_axis = 3 else: bn_axis = 1 # x = ZeroPadding2D(padding=(3, 3), name='conv1_pad')(img_input) # x = Conv2D(64, (7, 7), # strides=(2, 2), # padding='valid', # kernel_initializer='he_normal', # name='conv1')(x) # x = Activation('relu')(x) x = _vshifted_conv(img_input, 48, 'conv1a', activate=False) x = BatchNormalization(axis=bn_axis, name='bn_conv1a')(x) x = LeakyReLU(0.1)(x) # x = _vshifted_conv(x, 48, 'conv1b') # x = BatchNormalization(axis=bn_axis, name='bn_conv1b')(x) # x = LeakyReLU(0.1)(x) # x = ZeroPadding2D(padding=(1, 1), name='pool1_pad')(x) # x = MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv_block(x, [48, 48, 96], stage=2, block='a') x = identity_block(x, [48, 48, 96], stage=2, block='b') x = identity_block(x, [48, 48, 96], stage=2, block='c') x = conv_block(x, [96, 96, 192], stage=3, block='a') x = identity_block(x, [96, 96, 192], stage=3, block='b') x = identity_block(x, [96, 96, 192], stage=3, block='c') x = identity_block(x, [96, 96, 192], stage=3, block='d') x = conv_block(x, [96, 96, 192], stage=4, block='a') x = identity_block(x, [96, 96, 192], stage=4, block='b') x = identity_block(x, [96, 96, 192], stage=4, block='c') x = identity_block(x, [96, 96, 192], stage=4, block='d') x = identity_block(x, [96, 96, 192], stage=4, block='e') x = identity_block(x, [96, 96, 192], stage=4, block='f') x = conv_block(x, [192, 192, 384], stage=5, block='a') x = identity_block(x, [192, 192, 384], stage=5, block='b') x = identity_block(x, [192, 192, 384], stage=5, block='c') # final pad and crop for blind spot x = ZeroPadding2D([[1, 0], [0, 0]])(x) x = Cropping2D([[0, 1], [0, 0]])(x) if pooling is not None: if pooling == 'avg': x = GlobalAveragePooling2D()(x) elif pooling == 'max': x = GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. inputs = utils.get_source_inputs(input_tensor) # Create model model = Model(inputs, x, name='resnet50') return model
def OctaveResNet(layers, include_top=True, weights=None, input_tensor=None, input_shape=None, pooling=None, classes=1000, alpha=0.5, expansion=1, initial_filters=64, initial_strides=False, **kwargs): """ Instantiates a Octave ResNet architecture. # Arguments layers: list of integers defining the depth of the network and the number of octave conv blocks per level of the network. 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 `(224, 224, 3)` (with `'channels_last'` data format) or `(3, 224, 224)` (with `'channels_first'` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(200, 200, 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. alpha: float between [0, 1]. Defines the ratio of filters allocated to the high frequency and low frequency branches of the octave conv. expansion: int/float. Multiplicative factor to increase the number of filters in each octave block. initial_filters: number of filters in the first convolution layer. Determines how many parameters the network will have. initial_strides: bool to determine whether to apply a strided convolution and max pooling before any octave conv block. Set to True for ImageNet models and False for CIFAR models. # Returns A Keras model instance. # Raises ValueError: in case of invalid argument for `weights`, or invalid input shape. ` ValueError: If `alpha` is < 0 or > 1. ValueError: If `layers` is not a list or a tuple of integers. """ 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 alpha < 0. or alpha > 1.: raise ValueError('`alpha` must be between 0 and 1. Current alpha = ' '%f' % alpha) if type(layers) not in [list, tuple]: raise ValueError( '`layers` must be a list/tuple of integers. ' 'Current layers = ', layers) # Force convert all layer values to integers layers = [int(x) for x in layers] # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=K.image_data_format(), require_flatten=include_top, 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 if initial_strides: initial_strides = (2, 2) else: initial_strides = (1, 1) x = _conv_bn_relu(img_input, filters=64, kernel_size=(7, 7), strides=initial_strides) if initial_strides: x = MaxPool2D((3, 3), strides=(2, 2), padding='same')(x) num_filters = initial_filters num_blocks = len(layers) for i in range(num_blocks - 1): for j in range(layers[i]): if j == 0: strides = (2, 2) downsample_shortcut = True else: strides = (1, 1) downsample_shortcut = False # first block has no downsample, no shortcut if i == 0 and j == 0: first_block = True strides = (1, 1) downsample_shortcut = True else: first_block = False x = _octresnet_bottleneck_block(x, num_filters, alpha, strides, downsample_shortcut, first_block, expansion) # double number of filters per block num_filters *= 2 # final block for j in range(layers[-1]): if j == 0: strides = (2, 2) x = _octresnet_final_bottleneck_block(x, num_filters, alpha, strides, downsample_shortcut=True, expansion=expansion) else: strides = (1, 1) x = _bottleneck_original(x, num_filters, strides, expansion=expansion) if include_top: x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dense(classes, activation='softmax', name='fc')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = GlobalMaxPooling2D(name='max_pool')(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 model = Model(inputs, x, name='OctaveResNet') return model
def InceptionV3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the Inception v3 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # 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)` (with `channels_last` data format) or `(3, 299, 299)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 75. 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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. """ global backend, layers, models, keras_utils #backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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') # Determine proper input shape input_shape = _obtain_input_shape( input_shape, default_size=299, min_size=75, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor if backend.image_data_format() == 'channels_first': channel_axis = 1 else: channel_axis = 3 x = conv2d_bn(img_input, 32, 3, 3, strides=(2, 2), padding='valid') x = conv2d_bn(x, 32, 3, 3, padding='valid') x = conv2d_bn(x, 64, 3, 3) x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv2d_bn(x, 80, 1, 1, padding='valid') x = conv2d_bn(x, 192, 3, 3, padding='valid') x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) # mixed 0: 35 x 35 x 256 branch1x1 = conv2d_bn(x, 64, 1, 1) branch5x5 = conv2d_bn(x, 48, 1, 1) branch5x5 = conv2d_bn(branch5x5, 64, 5, 5) branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 32, 1, 1) x = layers.concatenate( [branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed0') # mixed 1: 35 x 35 x 288 branch1x1 = conv2d_bn(x, 64, 1, 1) branch5x5 = conv2d_bn(x, 48, 1, 1) branch5x5 = conv2d_bn(branch5x5, 64, 5, 5) branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 64, 1, 1) x = layers.concatenate( [branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed1') # mixed 2: 35 x 35 x 288 branch1x1 = conv2d_bn(x, 64, 1, 1) branch5x5 = conv2d_bn(x, 48, 1, 1) branch5x5 = conv2d_bn(branch5x5, 64, 5, 5) branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 64, 1, 1) x = layers.concatenate( [branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed2') # mixed 3: 17 x 17 x 768 branch3x3 = conv2d_bn(x, 384, 3, 3, strides=(2, 2), padding='valid') branch3x3dbl = conv2d_bn(x, 64, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3) branch3x3dbl = conv2d_bn( branch3x3dbl, 96, 3, 3, strides=(2, 2), padding='valid') branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = layers.concatenate( [branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed3') # mixed 4: 17 x 17 x 768 branch1x1 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(x, 128, 1, 1) branch7x7 = conv2d_bn(branch7x7, 128, 1, 7) branch7x7 = conv2d_bn(branch7x7, 192, 7, 1) branch7x7dbl = conv2d_bn(x, 128, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed4') # mixed 5, 6: 17 x 17 x 768 for i in range(2): branch1x1 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(x, 160, 1, 1) branch7x7 = conv2d_bn(branch7x7, 160, 1, 7) branch7x7 = conv2d_bn(branch7x7, 192, 7, 1) branch7x7dbl = conv2d_bn(x, 160, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch_pool = layers.AveragePooling2D( (3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed' + str(5 + i)) # mixed 7: 17 x 17 x 768 branch1x1 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(x, 192, 1, 1) branch7x7 = conv2d_bn(branch7x7, 192, 1, 7) branch7x7 = conv2d_bn(branch7x7, 192, 7, 1) branch7x7dbl = conv2d_bn(x, 192, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed7') # mixed 8: 8 x 8 x 1280 branch3x3 = conv2d_bn(x, 192, 1, 1) branch3x3 = conv2d_bn(branch3x3, 320, 3, 3, strides=(2, 2), padding='valid') branch7x7x3 = conv2d_bn(x, 192, 1, 1) branch7x7x3 = conv2d_bn(branch7x7x3, 192, 1, 7) branch7x7x3 = conv2d_bn(branch7x7x3, 192, 7, 1) branch7x7x3 = conv2d_bn( branch7x7x3, 192, 3, 3, strides=(2, 2), padding='valid') branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = layers.concatenate( [branch3x3, branch7x7x3, branch_pool], axis=channel_axis, name='mixed8') # mixed 9: 8 x 8 x 2048 for i in range(2): branch1x1 = conv2d_bn(x, 320, 1, 1) branch3x3 = conv2d_bn(x, 384, 1, 1) branch3x3_1 = conv2d_bn(branch3x3, 384, 1, 3) branch3x3_2 = conv2d_bn(branch3x3, 384, 3, 1) branch3x3 = layers.concatenate( [branch3x3_1, branch3x3_2], axis=channel_axis, name='mixed9_' + str(i)) branch3x3dbl = conv2d_bn(x, 448, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, 384, 3, 3) branch3x3dbl_1 = conv2d_bn(branch3x3dbl, 384, 1, 3) branch3x3dbl_2 = conv2d_bn(branch3x3dbl, 384, 3, 1) branch3x3dbl = layers.concatenate( [branch3x3dbl_1, branch3x3dbl_2], axis=channel_axis) branch_pool = layers.AveragePooling2D( (3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, 192, 1, 1) x = layers.concatenate( [branch1x1, branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed' + str(9 + i)) if include_top: # Classification block x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='inception_v3') # Load weights. if weights == 'imagenet': if include_top: weights_path = keras_utils.get_file( 'inception_v3_weights_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH, cache_subdir='models', file_hash='9a0d58056eeedaa3f26cb7ebd46da564') else: weights_path = keras_utils.get_file( 'inception_v3_weights_tf_dim_ordering_tf_kernels_notop.h5', WEIGHTS_PATH_NO_TOP, cache_subdir='models', file_hash='bcbd6486424b2319ff4ef7d526e38f63') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
def Xception(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, attention_module=None, **kwargs): """Instantiates the Xception architecture. Optionally loads weights pre-trained on ImageNet. This model can only be used with the 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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. """ # backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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 backend.image_data_format() != 'channels_last': warnings.warn('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.') backend.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=backend.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor x = layers.Conv2D(32, (3, 3), strides=(2, 2), use_bias=False, name='block1_conv1')(img_input) x = layers.BatchNormalization(name='block1_conv1_bn')(x) x = layers.Activation('relu', name='block1_conv1_act')(x) x = layers.Conv2D(64, (3, 3), use_bias=False, name='block1_conv2')(x) x = layers.BatchNormalization(name='block1_conv2_bn')(x) x = layers.Activation('relu', name='block1_conv2_act')(x) residual = layers.Conv2D(128, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = layers.BatchNormalization()(residual) x = layers.SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv1')(x) x = layers.BatchNormalization(name='block2_sepconv1_bn')(x) x = layers.Activation('relu', name='block2_sepconv2_act')(x) x = layers.SeparableConv2D(128, (3, 3), padding='same', use_bias=False, name='block2_sepconv2')(x) x = layers.BatchNormalization(name='block2_sepconv2_bn')(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block2_pool')(x) x = layers.add([x, residual]) residual = layers.Conv2D(256, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = layers.BatchNormalization()(residual) x = layers.Activation('relu', name='block3_sepconv1_act')(x) x = layers.SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv1')(x) x = layers.BatchNormalization(name='block3_sepconv1_bn')(x) x = layers.Activation('relu', name='block3_sepconv2_act')(x) x = layers.SeparableConv2D(256, (3, 3), padding='same', use_bias=False, name='block3_sepconv2')(x) x = layers.BatchNormalization(name='block3_sepconv2_bn')(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block3_pool')(x) x = layers.add([x, residual]) residual = layers.Conv2D(728, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = layers.BatchNormalization()(residual) x = layers.Activation('relu', name='block4_sepconv1_act')(x) x = layers.SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv1')(x) x = layers.BatchNormalization(name='block4_sepconv1_bn')(x) x = layers.Activation('relu', name='block4_sepconv2_act')(x) x = layers.SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block4_sepconv2')(x) x = layers.BatchNormalization(name='block4_sepconv2_bn')(x) x = layers.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 = layers.Activation('relu', name=prefix + '_sepconv1_act')(x) x = layers.SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv1')(x) x = layers.BatchNormalization(name=prefix + '_sepconv1_bn')(x) x = layers.Activation('relu', name=prefix + '_sepconv2_act')(x) x = layers.SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv2')(x) x = layers.BatchNormalization(name=prefix + '_sepconv2_bn')(x) x = layers.Activation('relu', name=prefix + '_sepconv3_act')(x) x = layers.SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name=prefix + '_sepconv3')(x) x = layers.BatchNormalization(name=prefix + '_sepconv3_bn')(x) # attention_module if attention_module is not None: x = attach_attention_module(x, attention_module) x = layers.add([x, residual]) residual = layers.Conv2D(1024, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = layers.BatchNormalization()(residual) x = layers.Activation('relu', name='block13_sepconv1_act')(x) x = layers.SeparableConv2D(728, (3, 3), padding='same', use_bias=False, name='block13_sepconv1')(x) x = layers.BatchNormalization(name='block13_sepconv1_bn')(x) x = layers.Activation('relu', name='block13_sepconv2_act')(x) x = layers.SeparableConv2D(1024, (3, 3), padding='same', use_bias=False, name='block13_sepconv2')(x) x = layers.BatchNormalization(name='block13_sepconv2_bn')(x) x = layers.MaxPooling2D((3, 3), strides=(2, 2), padding='same', name='block13_pool')(x) x = layers.add([x, residual]) x = layers.SeparableConv2D(1536, (3, 3), padding='same', use_bias=False, name='block14_sepconv1')(x) x = layers.BatchNormalization(name='block14_sepconv1_bn')(x) x = layers.Activation('relu', name='block14_sepconv1_act')(x) x = layers.SeparableConv2D(2048, (3, 3), padding='same', use_bias=False, name='block14_sepconv2')(x) x = layers.BatchNormalization(name='block14_sepconv2_bn')(x) x = layers.Activation('relu', name='block14_sepconv2_act')(x) if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='xception') # Load weights. if weights == 'imagenet': if include_top: weights_path = keras_utils.get_file( 'xception_weights_tf_dim_ordering_tf_kernels.h5', TF_WEIGHTS_PATH, cache_subdir='models', file_hash='0a58e3b7378bc2990ea3b43d5981f1f6') else: weights_path = keras_utils.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) if backend.backend() == 'theano': keras_utils.convert_all_kernels_in_model(model) elif weights is not None: model.load_weights(weights) if old_data_format: backend.set_image_data_format(old_data_format) return model
def EfficientNet(width_coefficient, depth_coefficient, default_resolution, dropout_rate=0.2, drop_connect_rate=0.2, depth_divisor=8, blocks_args=DEFAULT_BLOCKS_ARGS, model_name='efficientnet', include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, spatial_dropout=False, **kwargs): """Instantiates the EfficientNet architecture using given scaling coefficients. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments width_coefficient: float, scaling coefficient for network width. depth_coefficient: float, scaling coefficient for network depth. default_resolution: int, default input image size. dropout_rate: float, dropout rate before final classifier layer. drop_connect_rate: float, dropout rate at skip connections. depth_divisor: int. blocks_args: A list of BlockArgs to construct block modules. model_name: string, model name. 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. It should have exactly 3 inputs channels. 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. """ # global backend, layers, models, keras_utils # backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=default_resolution, min_size=32, data_format=backend.image_data_format(), require_flatten=include_top, weights=weights) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 activation = get_swish(**kwargs) # Build stem x = img_input x = layers.Conv2D(round_filters(32, width_coefficient, depth_divisor), 3, strides=(2, 2), padding='same', use_bias=False, kernel_initializer=CONV_KERNEL_INITIALIZER, name='stem_conv')(x) x = layers.BatchNormalization(axis=bn_axis, name='stem_bn')(x) x = layers.Activation(activation, name='stem_activation')(x) # Build blocks num_blocks_total = sum(block_args.num_repeat for block_args in blocks_args) block_num = 0 for idx, block_args in enumerate(blocks_args): assert block_args.num_repeat > 0 # Update block input and output filters based on depth multiplier. block_args = block_args._replace( input_filters=round_filters(block_args.input_filters, width_coefficient, depth_divisor), output_filters=round_filters(block_args.output_filters, width_coefficient, depth_divisor), num_repeat=round_repeats(block_args.num_repeat, depth_coefficient)) # The first block needs to take care of stride and filter size increase. drop_rate = drop_connect_rate * float(block_num) / num_blocks_total x = mb_conv_block(x, block_args, activation=activation, drop_rate=drop_rate, prefix='block{}a_'.format(idx + 1)) block_num += 1 if block_args.num_repeat > 1: # pylint: disable=protected-access block_args = block_args._replace( input_filters=block_args.output_filters, strides=[1, 1]) # pylint: enable=protected-access for bidx in xrange(block_args.num_repeat - 1): drop_rate = drop_connect_rate * float( block_num) / num_blocks_total block_prefix = 'block{}{}_'.format( idx + 1, string.ascii_lowercase[bidx + 1]) x = mb_conv_block(x, block_args, activation=activation, drop_rate=drop_rate, prefix=block_prefix) block_num += 1 # Build top x = layers.Conv2D(round_filters(1280, width_coefficient, depth_divisor), 1, padding='same', use_bias=False, kernel_initializer=CONV_KERNEL_INITIALIZER, name='top_conv')(x) x = layers.BatchNormalization(axis=bn_axis, name='top_bn')(x) x = layers.Activation(activation, name='top_activation')(x) if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) if dropout_rate and dropout_rate > 0: x = layers.Dropout(dropout_rate, name='top_dropout')(x) x = layers.Dense(classes, activation='softmax', kernel_initializer=DENSE_KERNEL_INITIALIZER, name='probs')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D(name='max_pool')(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name=model_name) # Load weights. if weights == 'imagenet': if include_top: file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_autoaugment.h5' file_hash = WEIGHTS_HASHES[model_name][0] else: file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_autoaugment_notop.h5' file_hash = WEIGHTS_HASHES[model_name][1] weights_path = keras_utils.get_file(file_name, BASE_WEIGHTS_PATH + file_name, cache_subdir='models', file_hash=file_hash) if not spatial_dropout: print("--------- No Sptial Dropout") model.load_weights(weights_path) else: print("######### Sptial Dropout") initial_model = EfficientNetB32( input_tensor=input_tensor, default_resolution=img_input.shape[1], weights='imagenet', include_top=False, input_shape=(img_input.shape[1], img_input.shape[1], 3)) count = 0 for id, layer in enumerate(initial_model.layers): print(layer.name, model.layers[count].name) if "spatial_dropout" in model.layers[count].name: count += 1 if "transformation" in model.layers[count].name: count += 1 if layer.name == model.layers[count].name: print("Igual", layer.name, model.layers[count].name) if len(layer.get_weights()) == len( model.layers[count].get_weights()): try: model.layers[count].set_weights( layer.get_weights()) except ValueError: print("Error jump") count += 1 elif weights is not None: model.load_weights(weights) return model
def InceptionResNetV2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the Inception-ResNet v2 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # 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)` (with `'channels_last'` data format) or `(3, 299, 299)` (with `'channels_first'` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 75. 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 block. - `'avg'` means that global average pooling will be applied to the output of the last convolutional block, 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. """ 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 input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor use_bn = kwargs['batch_n'] # Stem block: 35 x 35 x 192 x = conv2d_bn(img_input, 32, 3, strides=2, padding='valid', use_bn=use_bn) x = conv2d_bn(x, 32, 3, padding='valid', use_bn=use_bn) x = conv2d_bn(x, 64, 3, use_bn=use_bn) x = layers.MaxPooling2D(3, strides=2)(x) x = conv2d_bn(x, 80, 1, padding='valid', use_bn=use_bn) x = conv2d_bn(x, 192, 3, padding='valid', use_bn=use_bn) x = layers.MaxPooling2D(3, strides=2)(x) # Mixed 5b (Inception-A block): 35 x 35 x 320 branch_0 = conv2d_bn(x, 96, 1, use_bn=use_bn) branch_1 = conv2d_bn(x, 48, 1, use_bn=use_bn) branch_1 = conv2d_bn(branch_1, 64, 5, use_bn=use_bn) branch_2 = conv2d_bn(x, 64, 1, use_bn=use_bn) branch_2 = conv2d_bn(branch_2, 96, 3, use_bn=use_bn) branch_2 = conv2d_bn(branch_2, 96, 3, use_bn=use_bn) branch_pool = layers.AveragePooling2D(3, strides=1, padding='same')(x) branch_pool = conv2d_bn(branch_pool, 64, 1, use_bn=use_bn) branches = [branch_0, branch_1, branch_2, branch_pool] channel_axis = 1 if backend.image_data_format() == 'channels_first' else 3 x = layers.Concatenate(axis=channel_axis, name='mixed_5b')(branches) # 10x block35 (Inception-ResNet-A block): 35 x 35 x 320 for block_idx in range(1, 11): x = inception_resnet_block(x, scale=0.17, block_type='block35', block_idx=block_idx, use_bn=use_bn) x = layers.Dropout(0.1)(x, training=kwargs['training']) # Mixed 6a (Reduction-A block): 17 x 17 x 1088 branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='valid', use_bn=use_bn) branch_1 = conv2d_bn(x, 256, 1, use_bn=use_bn) branch_1 = conv2d_bn(branch_1, 256, 3, use_bn=use_bn) branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='valid', use_bn=use_bn) branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x) branches = [branch_0, branch_1, branch_pool] x = layers.Concatenate(axis=channel_axis, name='mixed_6a')(branches) # 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088 for block_idx in range(1, 21): x = inception_resnet_block(x, scale=0.1, block_type='block17', block_idx=block_idx, use_bn=use_bn) x = layers.Dropout(0.2)(x, training=kwargs['training']) # Mixed 7a (Reduction-B block): 8 x 8 x 2080 branch_0 = conv2d_bn(x, 256, 1, use_bn=use_bn) branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='valid', use_bn=use_bn) branch_1 = conv2d_bn(x, 256, 1, use_bn=use_bn) branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='valid', use_bn=use_bn) branch_2 = conv2d_bn(x, 256, 1, use_bn=use_bn) branch_2 = conv2d_bn(branch_2, 288, 3, use_bn=use_bn) branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='valid', use_bn=use_bn) branch_pool = layers.MaxPooling2D(3, strides=2, padding='valid')(x) branches = [branch_0, branch_1, branch_2, branch_pool] x = layers.Concatenate(axis=channel_axis, name='mixed_7a')(branches) # 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080 for block_idx in range(1, 10): x = inception_resnet_block(x, scale=0.2, block_type='block8', block_idx=block_idx, use_bn=use_bn) x = layers.Dropout(0.3)(x, training=kwargs['training']) x = inception_resnet_block(x, scale=1., activation=None, block_type='block8', block_idx=10, use_bn=use_bn) # Final convolution block: 8 x 8 x 1536 x = conv2d_bn(x, 1536, 1, name='conv_7b', use_bn=use_bn) last_tensor = None if include_top: # Classification block x = layers.GlobalAveragePooling2D(name='avg_pool')(x) last_tensor = x x = layers.Dense(classes, activation='softmax', name='predictions')(x) elif 'custom_top' in kwargs and kwargs['custom_top']: #Create a custom new classification here if needed x = layers.GlobalAveragePooling2D()(x) last_tensor = x x = layers.Dense(512)(x) x = layers.Activation('relu', name='class1_ac')(x) x = layers.Dropout(0.3)(x, training=kwargs['training']) x = layers.Dense(128)(x) x = layers.Activation('relu', name='class2_ac')(x) x = layers.Dropout(0.3)(x, training=kwargs['training']) x = layers.Dense(classes)(x) x = layers.Activation('softmax')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) last_tensor = x x = layers.Dense(classes, activation='softmax', name='predictions')(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='inception_resnet_v2') # Load weights. if 'preload' in kwargs and kwargs['preload']: if weights == 'imagenet': if include_top: fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5' weights_path = keras_utils.get_file( fname, BASE_WEIGHT_URL + fname, cache_subdir='models', file_hash='e693bd0210a403b3192acc6073ad2e96') else: fname = ('inception_resnet_v2_weights_' 'tf_dim_ordering_tf_kernels_notop.h5') weights_path = keras_utils.get_file( fname, BASE_WEIGHT_URL + fname, cache_subdir='models', file_hash='d19885ff4a710c122648d3b5c3b684e4') model.load_weights(weights_path, by_name=True) elif weights is not None: model.load_weights(weights, by_name=True) if 'feature' in kwargs and kwargs['feature']: return models.Model(inputs, last_tensor, name='inception_resnet_features') else: return model
def Cladoh(include_top=True, input_tensor=None, input_shape=None, pooling=None, classes=3): # include_top to be let as it is # weights to None for virgin network # input_tensor to None # input_shape I think is going to take (244,244,3) as default value # pooling need more information # classes is going to be 3 by default # with tf.name_scope('Pierre') as scope: # maybe this need to be changed if input_shape is None: input_shape = (224, 224, 3) # input preparation if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor # axis definition, it depends of the backend if backend.image_data_format() == 'channels_first': axis = 1 else: axis = 3 # from here is the layers definition # stem layer # print('+'*40, 'img_input_shape: ', img_input.shape) tensor = type0_layer(img_input, name='stem') # pair of inception and reduction layers: # inception layer # three passes tensor = type1_layer(tensor, 'inception1', axis) tensor = type1_layer(tensor, 'inception2', axis) tensor = type1_layer(tensor, 'inception3', axis) # reduction layer reduction_layer_width = 3 reduction_layer_rep_by_branch = [1, 3] reduction_layer_filter_list = [384, 64, 96, 96] reduction_layer_kernel_shape_list = [(3, 3), (1, 1), (3, 3), (3, 3)] reduction_layer_strides_list = [(2, 2), (1, 1), (1, 1), (2, 2)] reduction_layer_padding_list = ['valid', 'same', 'same', 'valid'] tensor = type1_layer(tensor, 'reduction1', axis, width=reduction_layer_width, inner_pooling='max', rep_by_branch=reduction_layer_rep_by_branch, filter_list=reduction_layer_filter_list, kernel_shape_list=reduction_layer_kernel_shape_list, strides_list=reduction_layer_strides_list, pooling_time=True, pooling_padding='valid', padding_list=reduction_layer_padding_list, use_cvbn_pooling=False, pooling_strides=(2, 2)) # TODO: maybe the change of dimension is to abrupt, something with a more # : nice slope ? # now last layers, there is an augmentation of dimension from now to # the output layer for i in range(2): """ augmentation_layer_width = 3 augmentation_layer_rep_by_branch = [] augmentation_layer_filter_list = [384, 64, 96, 96] augmentation_layer_kernel_shape_list = [(3, 3), (1, 1), (3, 3), (3, 3)] augmentation_layer_strides_list = [(2, 2), (1, 1), (1, 1), (2, 2)] augmentation_layer_padding_list = ['valid', 'same', 'same', 'valid'] """ # TODO: you need to define a type2 layer for this structure tensor_1x1 = cvbn(tensor, filters=320, kernel_shape=(1, 1)) tensor_3x3 = cvbn(tensor, filters=384, kernel_shape=(1, 1)) tensor_3x3_1 = cvbn(tensor_3x3, filters=384, kernel_shape=(1, 3)) tensor_3x3_2 = cvbn(tensor_3x3, filters=384, kernel_shape=(3, 1)) tensor_3x3 = layers.concatenate([tensor_3x3_1, tensor_3x3_2], axis=axis, name='augmentation' + str(i)) tensor_3x3dbl = cvbn(tensor, filters=448, kernel_shape=(1, 1)) tensor_3x3dbl = cvbn(tensor_3x3dbl, filters=384, kernel_shape=(3, 3)) tensor_3x3dbl_1 = cvbn(tensor_3x3dbl, filters=384, kernel_shape=(1, 3)) tensor_3x3dbl_2 = cvbn(tensor_3x3dbl, filters=384, kernel_shape=(3, 1)) tensor_3x3dbl = layers.concatenate([tensor_3x3dbl_1, tensor_3x3dbl_2], axis=axis) tensor_pooling = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(tensor) tensor_pooling = cvbn(tensor_pooling, filters=192, kernel_shape=(1, 1)) tensor = layers.concatenate( [tensor_1x1, tensor_3x3, tensor_3x3dbl, tensor_pooling], axis=axis, name='augmentation2' + str(9 + i)) # from here is the final setup and return # output layers if include_top: # Classification block tensor = layers.GlobalAveragePooling2D(name='avg_pool')(tensor) tensor = layers.Dense(classes, activation='softmax', name='predictions')(tensor) else: if pooling == 'avg': tensor = layers.GlobalAveragePooling2D()(tensor) elif pooling == 'max': tensor = layers.GlobalMaxPooling2D()(tensor) # print('+'*40, 'tensor_shape: ', tensor.shape) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # model creation and return model = models.Model(inputs, tensor, name='cladoh') return model
def InceptionV3(include_top=True, input_tensor=None, input_shape=None, pooling=None, classes=3, train_backbone=True, num_init_filters=8, **kwargs): """Instantiates the Inception v3 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # 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)` (with `channels_last` data format) or `(3, 299, 299)` (with `channels_first` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 75. 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 block. - `avg` means that global average pooling will be applied to the output of the last convolutional block, 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. """ # global backend, layers, models, keras_utils # backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) # if input_tensor is None: if input_tensor is None: img_input = Input(shape=input_shape) else: # if not backend.is_keras_tensor(input_tensor): # img_input = layers.Input(tensor=input_tensor, shape=input_shape) # else: img_input = input_tensor # if backend.image_data_format() == 'channels_first': # channel_axis = 1 # else: channel_axis = 3 x = conv2d_bn(img_input, num_init_filters, 3, 3, strides=(2, 2), padding='valid', trainable=train_backbone) x = conv2d_bn(x, num_init_filters, 3, 3, padding='valid', trainable=train_backbone) x = conv2d_bn(x, num_init_filters * 2, 3, 3) x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = conv2d_bn(x, int(num_init_filters * 2.5), 1, 1, padding='valid', trainable=train_backbone) x = conv2d_bn(x, num_init_filters * 6, 3, 3, padding='valid', trainable=train_backbone) x = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) # mixed 0: 35 x 35 x 256 branch1x1 = conv2d_bn(x, num_init_filters * 2, 1, 1) branch5x5 = conv2d_bn(x, int(num_init_filters * 1.5), 1, 1) branch5x5 = conv2d_bn(branch5x5, num_init_filters * 2, 5, 5) branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, num_init_filters, 1, 1) x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed0') # mixed 1: 35 x 35 x 288 branch1x1 = conv2d_bn(x, num_init_filters * 2, 1, 1) branch5x5 = conv2d_bn(x, int(num_init_filters * 1.5), 1, 1) branch5x5 = conv2d_bn(branch5x5, num_init_filters * 2, 5, 5) branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, num_init_filters * 2, 1, 1) x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed1') # mixed 2: 35 x 35 x 288 branch1x1 = conv2d_bn(x, num_init_filters * 2, 1, 1) branch5x5 = conv2d_bn(x, int(num_init_filters * 1.5), 1, 1) branch5x5 = conv2d_bn(branch5x5, num_init_filters * 2, 5, 5) branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, num_init_filters * 2, 1, 1) x = layers.concatenate([branch1x1, branch5x5, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed2') # mixed 3: 17 x 17 x 768 branch3x3 = conv2d_bn(x, num_init_filters * 12, 3, 3, strides=(2, 2), padding='valid', trainable=train_backbone) branch3x3dbl = conv2d_bn(x, num_init_filters * 2, 1, 1) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 3, 3, 3, strides=(2, 2), padding='valid', trainable=train_backbone) branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = layers.concatenate([branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed3') # mixed 4: 17 x 17 x 768 branch1x1 = conv2d_bn(x, num_init_filters * 6, 1, 1) branch7x7 = conv2d_bn(x, num_init_filters * 4, 1, 1) branch7x7 = conv2d_bn(branch7x7, num_init_filters * 4, 1, 7) branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 7, 1) branch7x7dbl = conv2d_bn(x, num_init_filters * 4, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 4, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 4, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 4, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, num_init_filters * 6, 1, 1) x = layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed4') # mixed 5, 6: 17 x 17 x 768 for i in range(2): branch1x1 = conv2d_bn(x, num_init_filters * 6, 1, 1) branch7x7 = conv2d_bn(x, num_init_filters * 5, 1, 1) branch7x7 = conv2d_bn(branch7x7, num_init_filters * 5, 1, 7) branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 7, 1) branch7x7dbl = conv2d_bn(x, num_init_filters * 5, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 5, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 5, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 5, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, num_init_filters * 6, 1, 1) x = layers.concatenate( [branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed' + str(5 + i)) # mixed 7: 17 x 17 x 768 branch1x1 = conv2d_bn(x, num_init_filters * 6, 1, 1) branch7x7 = conv2d_bn(x, num_init_filters * 6, 1, 1) branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 1, 7) branch7x7 = conv2d_bn(branch7x7, num_init_filters * 6, 7, 1) branch7x7dbl = conv2d_bn(x, num_init_filters * 6, 1, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 7, 1) branch7x7dbl = conv2d_bn(branch7x7dbl, num_init_filters * 6, 1, 7) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, num_init_filters * 6, 1, 1) x = layers.concatenate([branch1x1, branch7x7, branch7x7dbl, branch_pool], axis=channel_axis, name='mixed7') # mixed 8: 8 x 8 x 1280 branch3x3 = conv2d_bn(x, num_init_filters * 6, 1, 1, trainable=True) branch3x3 = conv2d_bn(branch3x3, num_init_filters * 10, 3, 3, strides=(2, 2), padding='valid', trainable=True) branch7x7x3 = conv2d_bn(x, num_init_filters * 6, 1, 1) branch7x7x3 = conv2d_bn(branch7x7x3, num_init_filters * 6, 1, 7) branch7x7x3 = conv2d_bn(branch7x7x3, num_init_filters * 6, 7, 1) branch7x7x3 = conv2d_bn(branch7x7x3, num_init_filters * 6, 3, 3, strides=(2, 2), padding='valid', trainable=True) branch_pool = layers.MaxPooling2D((3, 3), strides=(2, 2))(x) x = layers.concatenate([branch3x3, branch7x7x3, branch_pool], axis=channel_axis, name='mixed8') # mixed 9: 8 x 8 x 2048 for i in range(2): branch1x1 = conv2d_bn(x, num_init_filters * 10, 1, 1, trainable=True) branch3x3 = conv2d_bn(x, num_init_filters * 12, 1, 1, trainable=True) branch3x3_1 = conv2d_bn(branch3x3, num_init_filters * 12, 1, 3, trainable=True) branch3x3_2 = conv2d_bn(branch3x3, num_init_filters * 12, 3, 1, trainable=True) branch3x3 = layers.concatenate([branch3x3_1, branch3x3_2], axis=channel_axis, name='mixed9_' + str(i)) branch3x3dbl = conv2d_bn(x, num_init_filters * 14, 1, 1, trainable=True) branch3x3dbl = conv2d_bn(branch3x3dbl, num_init_filters * 12, 3, 3, trainable=True) branch3x3dbl_1 = conv2d_bn(branch3x3dbl, num_init_filters * 12, 1, 3, trainable=True) branch3x3dbl_2 = conv2d_bn(branch3x3dbl, num_init_filters * 12, 3, 1, trainable=True) branch3x3dbl = layers.concatenate([branch3x3dbl_1, branch3x3dbl_2], axis=channel_axis) branch_pool = layers.AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x) branch_pool = conv2d_bn(branch_pool, num_init_filters * 6, 1, 1, trainable=True) x = layers.concatenate( [branch1x1, branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed' + str(9 + i)) if include_top: # Classification block x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. # model = Model(inputs, x, name='inception_v3') return x
def build(self, input_shape=(224, 224, 3), num_classes=1000, model_type='large', pooling_type='avg', include_top=True, weights=None, input_tensor=None): self.model_type = model_type self.max_exp_lay_num = 14 if self.model_type is 'large' else 10 # ** input layer # inputs = Input(shape=input_shape) if input_tensor is None: inputs = Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): inputs = Input(tensor=input_tensor, shape=input_shape) else: inputs = input_tensor # ** feature extraction layers net = self.__conv2d_block(inputs, 16, kernel=(3, 3), strides=(2, 2), is_use_bias=False, padding='same', activation='HS', model_type=model_type) self.nlay += 1 if self.model_type == 'large': config_list = MobileNetV3.LARGE elif self.model_type == 'small': config_list = MobileNetV3.SMALL else: raise NotImplementedError for config in config_list: net = self.__bottleneck_block(net, *config) # ** final layers net = self.__conv2d_block(net, 960 if model_type is 'large' else 576, kernel=(1, 1), strides=(1, 1), is_use_bias=False, padding='same', activation='HS', model_type=model_type) if pooling_type == 'avg': net = GlobalAveragePooling2D()(net) elif pooling_type == 'depthwise': net = self.__global_depthwise_block(net) else: raise NotImplementedError pooled_shape = (1, 1, net._keras_shape[-1]) net = Reshape(pooled_shape)(net) net = Conv2D(1280 if model_type is 'large' else 1024, (1, 1), strides=(1, 1), padding='same', use_bias=True, name='conv_2')(net) net = Activation(self.Hswish, name='conv_2_activation')(net) if include_top: net = Conv2D(num_classes, (1, 1), strides=(1, 1), padding='same', use_bias=True, name='logits')(net) net = Flatten()(net) net = Softmax()(net) if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) model = Model(inputs=inputs, outputs=net) if weights: model.load_weights(weights) return model
def ResNet(stack_fn, preact, use_bias, model_name='resnet', include_top=True, weights=None, input_tensor=None, input_shape=None, pooling=None, nclass=1000, **kwargs): """Instantiates the ResNet, ResNetV2, and ResNeXt architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments stack_fn: a function that returns output tensor for the stacked residual blocks. preact: whether to use pre-activation or not (True for ResNetV2, False for ResNet and ResNeXt). use_bias: whether to use biases for convolutional layers or not (True for ResNet and ResNetV2, False for ResNeXt). model_name: string, model name. 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels. 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. """ # Determine proper input shape # input_shape = input_shape if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor bn_axis = 3 if backend.image_data_format() == 'channels_last' else 1 x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(img_input) x = layers.Conv2D(64, 7, strides=2, use_bias=use_bias, name='conv1_conv')(x) if preact is False: x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='conv1_bn')(x) x = layers.Activation('relu', name='conv1_relu')(x) x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x) x = layers.MaxPooling2D(3, strides=2, name='pool1_pool')(x) x = stack_fn(x) if preact is True: x = layers.BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='post_bn')(x) x = layers.Activation('relu', name='post_relu')(x) if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) x = layers.Dense(nclass, activation='softmax', name='probs')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D(name='max_pool')(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name=model_name) # Load weights. if weights is not None: model.load_weights(weights) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) return model
def EfficientNet(width_coefficient, depth_coefficient, default_size, dropout_rate=0.2, drop_connect_rate=0.2, depth_divisor=8, activation_fn=swish, blocks_args=DEFAULT_BLOCKS_ARGS, model_name='efficientnet', include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the EfficientNet architecture using given scaling coefficients. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments width_coefficient: float, scaling coefficient for network width. depth_coefficient: float, scaling coefficient for network depth. default_size: integer, default input image size. dropout_rate: float, dropout rate before final classifier layer. drop_connect_rate: float, dropout rate at skip connections. depth_divisor: integer, a unit of network width. activation_fn: activation function. blocks_args: list of dicts, parameters to construct block modules. model_name: string, model name. 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. It should have exactly 3 inputs channels. 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. """ #global backend, layers, models, keras_utils #backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=32, data_format=K.image_data_format(), require_flatten=include_top, 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 img_input = input_tensor bn_axis = 3 if K.image_data_format() == 'channels_last' else 1 def round_filters(filters, divisor=depth_divisor): """Round number of filters based on depth multiplier.""" filters *= width_coefficient new_filters = max(divisor, int(filters + divisor / 2) // divisor * divisor) # Make sure that round down does not go down by more than 10%. if new_filters < 0.9 * filters: new_filters += divisor return int(new_filters) def round_repeats(repeats): """Round number of repeats based on depth multiplier.""" return int(math.ceil(depth_coefficient * repeats)) # Build stem x = img_input x = ZeroPadding2D(padding=correct_pad(K, x, 3), name='stem_conv_pad')(x) x = Conv2D(round_filters(32), 3, strides=2, padding='valid', use_bias=False, kernel_initializer=CONV_KERNEL_INITIALIZER, name='stem_conv')(x) x = BatchNormalization(axis=bn_axis, name='stem_bn')(x) x = Activation(activation_fn, name='stem_activation')(x) # Build blocks from copy import deepcopy blocks_args = deepcopy(blocks_args) b = 0 blocks = float(sum(args['repeats'] for args in blocks_args)) for (i, args) in enumerate(blocks_args): assert args['repeats'] > 0 # Update block input and output filters based on depth multiplier. args['filters_in'] = round_filters(args['filters_in']) args['filters_out'] = round_filters(args['filters_out']) for j in range(round_repeats(args.pop('repeats'))): # The first block needs to take care of stride and filter size increase. if j > 0: args['strides'] = 1 args['filters_in'] = args['filters_out'] x = block(x, activation_fn, drop_connect_rate * b / blocks, name='block{}{}_'.format(i + 1, chr(j + 97)), **args) b += 1 # Build top x = Conv2D(round_filters(1280), 1, padding='same', use_bias=False, kernel_initializer=CONV_KERNEL_INITIALIZER, name='top_conv')(x) x = BatchNormalization(axis=bn_axis, name='top_bn')(x) x = Activation(activation_fn, name='top_activation')(x) if include_top: x = GlobalAveragePooling2D(name='avg_pool')(x) if dropout_rate > 0: x = Dropout(dropout_rate, name='top_dropout')(x) x = Dense(classes, activation='softmax', kernel_initializer=DENSE_KERNEL_INITIALIZER, name='probs')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = GlobalMaxPooling2D(name='max_pool')(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 # Create model. model = Model(inputs, x, name=model_name) # Load weights. if weights == 'imagenet': if include_top: file_suff = '_weights_tf_dim_ordering_tf_kernels_autoaugment.h5' file_hash = WEIGHTS_HASHES[model_name[-2:]][0] else: file_suff = '_weights_tf_dim_ordering_tf_kernels_autoaugment_notop.h5' file_hash = WEIGHTS_HASHES[model_name[-2:]][1] file_name = model_name + file_suff weights_path = get_file(file_name, BASE_WEIGHTS_PATH + file_name, cache_subdir='models', file_hash=file_hash) model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
def EfficientNet(input_shape, block_args_list: List[BlockArgs], width_coefficient: float, depth_coefficient: float, include_top=True, weights=None, input_tensor=None, pooling=None, classes=1000, dropout_rate=0., drop_connect_rate=0., batch_norm_momentum=0.99, batch_norm_epsilon=1e-3, depth_divisor=8, min_depth=None, data_format=None, default_size=None, **kwargs): """ Builder model for EfficientNets. # Arguments: input_shape: Optional shape tuple, the input shape depends on the configuration, with a minimum decided by the number of stride 2 operations. When None is provided, it defaults to 224. Considered the "Resolution" parameter from the paper (inherently Resolution coefficient). block_args_list: Optional List of BlockArgs, each of which detail the arguments of the MBConvBlock. If left as None, it defaults to the blocks from the paper. width_coefficient: Determines the number of channels available per layer. Compound Coefficient that needs to be found using grid search on a base configuration model. depth_coefficient: Determines the number of layers available to the model. Compound Coefficient that needs to be found using grid search on a base configuration model. include_top: Whether to include the fully-connected layer at the top of the network. weights: `None` (random initialization) or `imagenet` (ImageNet weights) input_tensor: Optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. 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. dropout_rate: Float, percentage of random dropout. drop_connect_rate: Float, percentage of random droped connections. batch_norm_momentum: Float, default batch normalization momentum. Obtained from the paper. batch_norm_epsilon: Float, default batch normalization epsilon. Obtained from the paper. depth_divisor: Optional. Used when rounding off the coefficient scaled channels and depth of the layers. min_depth: Optional. Minimum depth value in order to avoid blocks with 0 layers. data_format: "channels_first" or "channels_last". If left as None, defaults to the value set in ~/.keras. default_size: Specifies the default image size of the model # Raises: - ValueError: If weights are not in 'imagenet' or None. - ValueError: If weights are 'imagenet' and `classes` is not 1000. # Returns: A Keras Model. """ 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 data_format is None: data_format = K.image_data_format() if data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 if default_size is None: default_size = 224 if block_args_list is None: block_args_list = get_default_block_list() # count number of strides to compute min size stride_count = 1 for block_args in block_args_list: if block_args.strides is not None and block_args.strides[0] > 1: stride_count += 1 min_size = int(2**stride_count) # Determine proper input shape and default size. input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=min_size, data_format=data_format, require_flatten=include_top, weights=weights) # Stem part if input_tensor is None: inputs = layers.Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): inputs = layers.Input(tensor=input_tensor, shape=input_shape) else: inputs = input_tensor x = inputs x = layers.Conv2D(filters=round_filters(32, width_coefficient, depth_divisor, min_depth), kernel_size=[3, 3], strides=[2, 2], kernel_initializer=EfficientNetConvInitializer(), padding='same', use_bias=False)(x) x = layers.BatchNormalization(axis=channel_axis, momentum=batch_norm_momentum, epsilon=batch_norm_epsilon)(x) x = Swish()(x) num_blocks = sum([block_args.num_repeat for block_args in block_args_list]) drop_connect_rate_per_block = drop_connect_rate / float(num_blocks) # Blocks part for block_idx, block_args in enumerate(block_args_list): assert block_args.num_repeat > 0 # Update block input and output filters based on depth multiplier. block_args.input_filters = round_filters(block_args.input_filters, width_coefficient, depth_divisor, min_depth) block_args.output_filters = round_filters(block_args.output_filters, width_coefficient, depth_divisor, min_depth) block_args.num_repeat = round_repeats(block_args.num_repeat, depth_coefficient) # The first block needs to take care of stride and filter size increase. x = MBConvBlock(block_args.input_filters, block_args.output_filters, block_args.kernel_size, block_args.strides, block_args.expand_ratio, block_args.se_ratio, block_args.identity_skip, drop_connect_rate_per_block * block_idx, batch_norm_momentum, batch_norm_epsilon, data_format)(x) if block_args.num_repeat > 1: block_args.input_filters = block_args.output_filters block_args.strides = [1, 1] for _ in range(block_args.num_repeat - 1): x = MBConvBlock(block_args.input_filters, block_args.output_filters, block_args.kernel_size, block_args.strides, block_args.expand_ratio, block_args.se_ratio, block_args.identity_skip, drop_connect_rate_per_block * block_idx, batch_norm_momentum, batch_norm_epsilon, data_format)(x) # Head part x = layers.Conv2D(filters=round_filters(1280, width_coefficient, depth_coefficient, min_depth), kernel_size=[1, 1], strides=[1, 1], kernel_initializer=EfficientNetConvInitializer(), padding='same', use_bias=False)(x) x = layers.BatchNormalization(axis=channel_axis, momentum=batch_norm_momentum, epsilon=batch_norm_epsilon)(x) x = Swish()(x) if include_top: x = layers.GlobalAveragePooling2D(data_format=data_format)(x) if dropout_rate > 0: x = layers.Dropout(dropout_rate)(x) x = layers.Dense(classes, kernel_initializer=EfficientNetDenseInitializer())(x) x = layers.Activation('softmax')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) outputs = 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) model = Model(inputs, outputs) # Load weights if weights == 'imagenet': if default_size == 224: if include_top: weights_path = get_file( 'efficientnet-b0.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b0_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 240: if include_top: weights_path = get_file( 'efficientnet-b1.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b1_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 260: if include_top: weights_path = get_file( 'efficientnet-b2.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b2_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 300: if include_top: weights_path = get_file( 'efficientnet-b3.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b3_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 380: if include_top: weights_path = get_file( 'efficientnet-b4.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b4_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 456: if include_top: weights_path = get_file( 'efficientnet-b5.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b5_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5_notop.h5", cache_subdir='models') model.load_weights(weights_path) # TODO: When weights for efficientnet-b6 and efficientnet-b7 becomes available, uncomment this section and update # the ValueError message below (line 537: ValueError('ImageNet weights can only be loaded with EfficientNetB0-5')) # elif default_size == 528: # if include_top: # weights_path = get_file( # 'efficientnet-b6.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6.h5", # cache_subdir='models') # else: # weights_path = get_file( # 'efficientnet-b6_notop.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6_notop.h5", # cache_subdir='models') # model.load_weights(weights_path) # # elif default_size == 600: # if include_top: # weights_path = get_file( # 'efficientnet-b7.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7.h5", # cache_subdir='models') # else: # weights_path = get_file( # 'efficientnet-b7_notop.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7_notop.h5", # cache_subdir='models') # model.load_weights(weights_path) else: raise ValueError( 'ImageNet weights can only be loaded with EfficientNetB0-5') elif weights is not None: model.load_weights(weights) return model
def InceptionResNetV2R2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the Inception-ResNet v2 architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # 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)` (with `'channels_last'` data format) or `(3, 299, 299)` (with `'channels_first'` data format). It should have exactly 3 inputs channels, and width and height should be no smaller than 75. 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 block. - `'avg'` means that global average pooling will be applied to the output of the last convolutional block, 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. """ global backend, layers, models, keras_utils # backend, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) from keras import backend, layers, models from keras import utils as keras_utils 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') # Determine proper input shape # input_shape = _obtain_input_shape( # input_shape, # default_size=299, # min_size=75, # data_format=backend.image_data_format(), # require_flatten=include_top, # weights=weights) input_shape = input_shape #(96, 120, 86, 2) if input_tensor is None: img_input = layers.Input(shape=input_shape) else: if not backend.is_keras_tensor(input_tensor): img_input = layers.Input(tensor=input_tensor, shape=input_shape) else: img_input = input_tensor # Stem block output: 21 x 27 x 19 x 256 x = conv3d_bn(img_input, 48, 3, padding='valid') x = conv3d_bn(x, 64, 3) x1 = layers.MaxPooling3D(3, strides=2)(x) x2 = conv3d_bn(x, 64, 3, 2, padding='valid') channel_axis = 1 if backend.image_data_format() == 'channels_first' else 4 x = layers.Concatenate(axis=channel_axis)([x1, x2]) #nKernal = 128 x1 = conv3d_bn(x, 64, 1) x1 = conv3d_bn(x1, 96, 3, padding='valid') x2 = conv3d_bn(x, 64, 1) x2 = conv3d_bn(x2, 64, [1, 7, 1]) x2 = conv3d_bn(x2, 64, [1, 1, 7]) x2 = conv3d_bn(x2, 64, [7, 1, 1]) x2 = conv3d_bn(x2, 96, 3, padding='valid') x = layers.Concatenate(axis=channel_axis)([x1, x2]) #nKernal = 192 x1 = conv3d_bn(x, 128, 3, 2, padding='valid') x2 = layers.MaxPooling3D(3, strides=2, padding='valid', name='StemEnd')(x) x = layers.Concatenate(axis=channel_axis)([x1, x2]) #nKernal = 320 # 2x block35 (Inception-ResNet-A block) output: 21 x 27 x 19 x 320 for block_idx in range(1, 3): x = inception_resnet_block( x, scale=0.17, # scale=0.1, # reduce to 0.1 to avoid instability block_type='block35', block_idx=block_idx) # Mixed 6a (Reduction-A block) output: 10 x 13 x 9 x 640 branch_0 = conv3d_bn(x, 160, 3, strides=2, padding='valid') branch_1 = conv3d_bn(x, 128, 1) branch_1 = conv3d_bn(branch_1, 128, 3) branch_1 = conv3d_bn(branch_1, 160, 3, strides=2, padding='valid') branch_pool = layers.MaxPooling3D(3, strides=2, padding='valid')(x) branches = [branch_0, branch_1, branch_pool] channel_axis = 1 if backend.image_data_format() == 'channels_first' else 4 x = layers.Concatenate(axis=channel_axis, name='mixed_6a')(branches) # 4x block17 (Inception-ResNet-B block) output: 10 x 13 x 9 x 640 for block_idx in range(1, 5): x = inception_resnet_block(x, scale=0.1, block_type='block17', block_idx=block_idx) # Mixed 7a (Reduction-B block): 4 x 6 x 4 x 1408 branch_0 = conv3d_bn(x, 192, 1) branch_0 = conv3d_bn(branch_0, 224, 3, strides=2, padding='valid') branch_1 = conv3d_bn(x, 192, 1) branch_1 = conv3d_bn(branch_1, 288, 3, strides=2, padding='valid') branch_2 = conv3d_bn(x, 192, 1) branch_2 = conv3d_bn(branch_2, 224, 3) branch_2 = conv3d_bn(branch_2, 256, 3, strides=2, padding='valid') branch_pool = layers.MaxPooling3D(3, strides=2, padding='valid')(x) branches = [branch_0, branch_1, branch_2, branch_pool] x = layers.Concatenate(axis=channel_axis, name='mixed_7a')(branches) # 2x block8 (Inception-ResNet-C block): 4 x 6 x 4 x 1408 for block_idx in range(1, 2): x = inception_resnet_block( x, scale=0.2, # scale=0.1, # reduce to 0.1 to avoid instability block_type='block8', block_idx=block_idx) x = inception_resnet_block(x, scale=1., activation=None, block_type='block8', block_idx=5) # Final convolution block: 4 x 6 x 4 x 512 x = conv3d_bn(x, 512, 1, name='conv_7b') if include_top: # Classification block x = layers.GlobalAveragePooling3D(name='avg_pool')(x) x = layers.Dense(classes, activation='softmax', name='predictions')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling3D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling3D()(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = models.Model(inputs, x, name='inception_resnet_v2_3D') # Load weights. if weights == 'imagenet': if include_top: fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5' weights_path = keras_utils.get_file( fname, BASE_WEIGHT_URL + fname, cache_subdir='models', file_hash='e693bd0210a403b3192acc6073ad2e96') else: fname = ('inception_resnet_v2_weights_' 'tf_dim_ordering_tf_kernels_notop.h5') weights_path = keras_utils.get_file( fname, BASE_WEIGHT_URL + fname, cache_subdir='models', file_hash='d19885ff4a710c122648d3b5c3b684e4') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
def ResNet(stack_fn, preact, use_bias, model_name='resnet', include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the ResNet, ResNetV2, and ResNeXt architecture. Optionally loads weights pre-trained on ImageNet. Note that the data format convention used by the model is the one specified in your Keras config at `~/.keras/keras.json`. # Arguments stack_fn: a function that returns output tensor for the stacked residual blocks. preact: whether to use pre-activation or not (True for ResNetV2, False for ResNet and ResNeXt). use_bias: whether to use biases for convolutional layers or not (True for ResNet and ResNetV2, False for ResNeXt). model_name: string, model name. 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 `(224, 224, 3)` (with `channels_last` data format) or `(3, 224, 224)` (with `channels_first` data format). It should have exactly 3 inputs channels. 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. """ # global K, layers, models, keras_utils # K, layers, models, keras_utils = get_submodules_from_kwargs(kwargs) 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') # Determine proper input shape input_shape = _obtain_input_shape(input_shape, default_size=224, min_size=32, data_format=data_format, require_flatten=include_top, 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 bn_axis = 3 if data_format == 'channels_last' else 1 x = ZeroPadding2D(padding=((3, 3), (3, 3)), name='conv1_pad')(img_input) x = Conv2D(64, 7, strides=2, use_bias=use_bias, name='conv1_conv')(x) if preact is False: x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='conv1_bn')(x) x = Activation('relu', name='conv1_relu')(x) x = ZeroPadding2D(padding=((1, 1), (1, 1)), name='pool1_pad')(x) x = MaxPooling2D(3, strides=2, name='pool1_pool')(x) x = stack_fn(x) if preact is True: x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='post_bn')(x) x = Activation('relu', name='post_relu')(x) if include_top: x = GlobalAveragePooling2D(name='avg_pool')(x) x = Dense(classes, activation='softmax', name='probs')(x) else: if pooling == 'avg': x = GlobalAveragePooling2D(name='avg_pool')(x) elif pooling == 'max': x = GlobalMaxPooling2D(name='max_pool')(x) # Ensure that the model takes into account # any potential predecessors of `input_tensor`. if input_tensor is not None: inputs = keras_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = Model(inputs, x, name=model_name) # Load weights. if (weights == 'imagenet') and (model_name in WEIGHTS_HASHES): if include_top: file_name = model_name + '_weights_tf_dim_ordering_tf_kernels.h5' file_hash = WEIGHTS_HASHES[model_name][0] else: file_name = model_name + '_weights_tf_dim_ordering_tf_kernels_notop.h5' file_hash = WEIGHTS_HASHES[model_name][1] weights_path = keras_utils.get_file(file_name, BASE_WEIGHTS_PATH + file_name, cache_subdir='models', file_hash=file_hash) model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
def EfficientNet(input_shape, block_args_list: List[BlockArgs], width_coefficient: float, depth_coefficient: float, include_top=True, weights=None, input_tensor=None, pooling=None, classes=1000, dropout_rate=0., drop_connect_rate=0., batch_norm_momentum=0.99, batch_norm_epsilon=1e-3, depth_divisor=8, min_depth=None, data_format=None, default_size=None, **kwargs): 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 data_format is None: data_format = K.image_data_format() if data_format == 'channels_first': channel_axis = 1 else: channel_axis = -1 if default_size is None: default_size = 224 if block_args_list is None: block_args_list = get_default_block_list() # count number of strides to compute min size stride_count = 1 for block_args in block_args_list: if block_args.strides is not None and block_args.strides[0] > 1: stride_count += 1 min_size = int(2**stride_count) # Determine proper input shape and default size. input_shape = _obtain_input_shape(input_shape, default_size=default_size, min_size=min_size, data_format=data_format, require_flatten=include_top, weights=weights) # Stem part if input_tensor is None: inputs = layers.Input(shape=input_shape) else: if not K.is_keras_tensor(input_tensor): inputs = layers.Input(tensor=input_tensor, shape=input_shape) else: inputs = input_tensor x = inputs x = layers.Conv2D(filters=round_filters(32, width_coefficient, depth_divisor, min_depth), kernel_size=[3, 3], strides=[2, 2], kernel_initializer=EfficientNetConvInitializer(), padding='same', use_bias=False)(x) x = BatchNormalization(True, axis=channel_axis, momentum=batch_norm_momentum, epsilon=batch_norm_epsilon)(x) x = Swish(name='swish_0')(x) num_blocks = sum([block_args.num_repeat for block_args in block_args_list]) drop_connect_rate_per_block = drop_connect_rate / float(num_blocks) # Blocks part for block_idx, block_args in enumerate(block_args_list): assert block_args.num_repeat > 0 # Update block input and output filters based on depth multiplier. block_args.input_filters = round_filters(block_args.input_filters, width_coefficient, depth_divisor, min_depth) block_args.output_filters = round_filters(block_args.output_filters, width_coefficient, depth_divisor, min_depth) block_args.num_repeat = round_repeats(block_args.num_repeat, depth_coefficient) # The first block needs to take care of stride and filter size increase. x = MBConvBlock(block_args.input_filters, block_args.output_filters, block_args.kernel_size, block_args.strides, block_args.expand_ratio, block_args.se_ratio, block_args.identity_skip, drop_connect_rate_per_block * block_idx, str(block_idx) + '_i', batch_norm_momentum, batch_norm_epsilon, data_format)(x) if block_args.num_repeat > 1: block_args.input_filters = block_args.output_filters block_args.strides = [1, 1] for _ in range(block_args.num_repeat - 1): x = MBConvBlock(block_args.input_filters, block_args.output_filters, block_args.kernel_size, block_args.strides, block_args.expand_ratio, block_args.se_ratio, block_args.identity_skip, drop_connect_rate_per_block * block_idx, str(block_idx) + '_' + str(_), batch_norm_momentum, batch_norm_epsilon, data_format)(x) # Head part x = layers.Conv2D(filters=round_filters(1280, width_coefficient, depth_coefficient, min_depth), kernel_size=[1, 1], strides=[1, 1], kernel_initializer=EfficientNetConvInitializer(), padding='same', use_bias=False)(x) x = BatchNormalization(True, axis=channel_axis, momentum=batch_norm_momentum, epsilon=batch_norm_epsilon)(x) x = Swish(name='swish_last')(x) if include_top: x = layers.GlobalAveragePooling2D(data_format=data_format)(x) if dropout_rate > 0: x = layers.Dropout(dropout_rate)(x) x = layers.Dense(classes, kernel_initializer=EfficientNetDenseInitializer())(x) x = layers.Activation('softmax')(x) else: if pooling == 'avg': x = layers.GlobalAveragePooling2D()(x) elif pooling == 'max': x = layers.GlobalMaxPooling2D()(x) outputs = 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) model = Model(inputs, outputs) # Load weights if weights == 'imagenet': if default_size == 224: if include_top: weights_path = get_file( 'efficientnet-b0.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b0_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b0_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 240: if include_top: weights_path = get_file( 'efficientnet-b1.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b1_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b1_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 260: if include_top: weights_path = get_file( 'efficientnet-b2.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b2_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b2_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 300: if include_top: weights_path = get_file( 'efficientnet-b3.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b3_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b3_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 380: if include_top: weights_path = get_file( 'efficientnet-b4.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b4_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b4_notop.h5", cache_subdir='models') model.load_weights(weights_path) elif default_size == 456: if include_top: weights_path = get_file( 'efficientnet-b5.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5.h5", cache_subdir='models') else: weights_path = get_file( 'efficientnet-b5_notop.h5', "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b5_notop.h5", cache_subdir='models') model.load_weights(weights_path) # elif default_size == 528: # if include_top: # weights_path = get_file( # 'efficientnet-b6.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6.h5", # cache_subdir='models') # else: # weights_path = get_file( # 'efficientnet-b6_notop.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b6_notop.h5", # cache_subdir='models') # model.load_weights(weights_path) # # elif default_size == 600: # if include_top: # weights_path = get_file( # 'efficientnet-b7.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7.h5", # cache_subdir='models') # else: # weights_path = get_file( # 'efficientnet-b7_notop.h5', # "https://github.com/titu1994/keras-efficientnets/releases/download/v0.1/efficientnet-b7_notop.h5", # cache_subdir='models') # model.load_weights(weights_path) else: raise ValueError( 'ImageNet weights can only be loaded with EfficientNetB0-7') elif weights is not None: model.load_weights(weights) return model