Module keras.api.keras.applications
Public API for tf.keras.applications namespace.
Expand source code
# This file is MACHINE GENERATED! Do not edit.
# Generated by: tensorflow/python/tools/api/generator/create_python_api.py script.
"""Public API for tf.keras.applications namespace.
"""
from __future__ import print_function as _print_function
import sys as _sys
from keras.api.keras.applications import densenet
from keras.api.keras.applications import efficientnet
from keras.api.keras.applications import imagenet_utils
from keras.api.keras.applications import inception_resnet_v2
from keras.api.keras.applications import inception_v3
from keras.api.keras.applications import mobilenet
from keras.api.keras.applications import mobilenet_v2
from keras.api.keras.applications import mobilenet_v3
from keras.api.keras.applications import nasnet
from keras.api.keras.applications import resnet
from keras.api.keras.applications import resnet50
from keras.api.keras.applications import resnet_v2
from keras.api.keras.applications import vgg16
from keras.api.keras.applications import vgg19
from keras.api.keras.applications import xception
from keras.applications.densenet import DenseNet121
from keras.applications.densenet import DenseNet169
from keras.applications.densenet import DenseNet201
from keras.applications.efficientnet import EfficientNetB0
from keras.applications.efficientnet import EfficientNetB1
from keras.applications.efficientnet import EfficientNetB2
from keras.applications.efficientnet import EfficientNetB3
from keras.applications.efficientnet import EfficientNetB4
from keras.applications.efficientnet import EfficientNetB5
from keras.applications.efficientnet import EfficientNetB6
from keras.applications.efficientnet import EfficientNetB7
from keras.applications.inception_resnet_v2 import InceptionResNetV2
from keras.applications.inception_v3 import InceptionV3
from keras.applications.mobilenet import MobileNet
from keras.applications.mobilenet_v2 import MobileNetV2
from keras.applications.mobilenet_v3 import MobileNetV3Large
from keras.applications.mobilenet_v3 import MobileNetV3Small
from keras.applications.nasnet import NASNetLarge
from keras.applications.nasnet import NASNetMobile
from keras.applications.resnet import ResNet101
from keras.applications.resnet import ResNet152
from keras.applications.resnet import ResNet50
from keras.applications.resnet_v2 import ResNet101V2
from keras.applications.resnet_v2 import ResNet152V2
from keras.applications.resnet_v2 import ResNet50V2
from keras.applications.vgg16 import VGG16
from keras.applications.vgg19 import VGG19
from keras.applications.xception import Xception
del _print_function
from tensorflow.python.util import module_wrapper as _module_wrapper
if not isinstance(_sys.modules[__name__], _module_wrapper.TFModuleWrapper):
_sys.modules[__name__] = _module_wrapper.TFModuleWrapper(
_sys.modules[__name__], "keras.applications", public_apis=None, deprecation=True,
has_lite=False)
Sub-modules
keras.api.keras.applications.densenet
-
Public API for tf.keras.applications.densenet namespace.
keras.api.keras.applications.efficientnet
-
Public API for tf.keras.applications.efficientnet namespace.
keras.api.keras.applications.imagenet_utils
-
Public API for tf.keras.applications.imagenet_utils namespace.
keras.api.keras.applications.inception_resnet_v2
-
Public API for tf.keras.applications.inception_resnet_v2 namespace.
keras.api.keras.applications.inception_v3
-
Public API for tf.keras.applications.inception_v3 namespace.
keras.api.keras.applications.mobilenet
-
Public API for tf.keras.applications.mobilenet namespace.
keras.api.keras.applications.mobilenet_v2
-
Public API for tf.keras.applications.mobilenet_v2 namespace.
keras.api.keras.applications.mobilenet_v3
-
Public API for tf.keras.applications.mobilenet_v3 namespace.
keras.api.keras.applications.nasnet
-
Public API for tf.keras.applications.nasnet namespace.
keras.api.keras.applications.resnet
-
Public API for tf.keras.applications.resnet namespace.
keras.api.keras.applications.resnet50
-
Public API for tf.keras.applications.resnet50 namespace.
keras.api.keras.applications.resnet_v2
-
Public API for tf.keras.applications.resnet_v2 namespace.
keras.api.keras.applications.vgg16
-
Public API for tf.keras.applications.vgg16 namespace.
keras.api.keras.applications.vgg19
-
Public API for tf.keras.applications.vgg19 namespace.
keras.api.keras.applications.xception
-
Public API for tf.keras.applications.xception namespace.
Functions
def DenseNet121(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
-
Instantiates the Densenet121 architecture.
Reference: - Densely Connected Convolutional Networks (CVPR 2017)
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
.Note: each Keras Application expects a specific kind of input preprocessing. For DenseNet, call
tf.keras.applications.densenet.preprocess_input
on your inputs before passing them to the model.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, 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
isFalse
. -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 noweights
argument is specified.
Returns
A Keras model instance.
Expand source code
@keras_export('keras.applications.densenet.DenseNet121', 'keras.applications.DenseNet121') def DenseNet121(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000): """Instantiates the Densenet121 architecture.""" return DenseNet([6, 12, 24, 16], include_top, weights, input_tensor, input_shape, pooling, classes)
def DenseNet169(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
-
Instantiates the Densenet169 architecture.
Reference: - Densely Connected Convolutional Networks (CVPR 2017)
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
.Note: each Keras Application expects a specific kind of input preprocessing. For DenseNet, call
tf.keras.applications.densenet.preprocess_input
on your inputs before passing them to the model.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, 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
isFalse
. -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 noweights
argument is specified.
Returns
A Keras model instance.
Expand source code
@keras_export('keras.applications.densenet.DenseNet169', 'keras.applications.DenseNet169') def DenseNet169(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000): """Instantiates the Densenet169 architecture.""" return DenseNet([6, 12, 32, 32], include_top, weights, input_tensor, input_shape, pooling, classes)
def DenseNet201(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
-
Instantiates the Densenet201 architecture.
Reference: - Densely Connected Convolutional Networks (CVPR 2017)
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
.Note: each Keras Application expects a specific kind of input preprocessing. For DenseNet, call
tf.keras.applications.densenet.preprocess_input
on your inputs before passing them to the model.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, 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
isFalse
. -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 noweights
argument is specified.
Returns
A Keras model instance.
Expand source code
@keras_export('keras.applications.densenet.DenseNet201', 'keras.applications.DenseNet201') def DenseNet201(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000): """Instantiates the Densenet201 architecture.""" return DenseNet([6, 12, 48, 32], include_top, weights, input_tensor, input_shape, pooling, classes)
def EfficientNetB0(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB0 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB0', 'keras.applications.EfficientNetB0') def EfficientNetB0(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 1.0, 1.0, 224, 0.2, model_name='efficientnetb0', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def EfficientNetB1(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB1 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB1', 'keras.applications.EfficientNetB1') def EfficientNetB1(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 1.0, 1.1, 240, 0.2, model_name='efficientnetb1', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def EfficientNetB2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB2 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB2', 'keras.applications.EfficientNetB2') def EfficientNetB2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 1.1, 1.2, 260, 0.3, model_name='efficientnetb2', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def EfficientNetB3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB3 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB3', 'keras.applications.EfficientNetB3') def EfficientNetB3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 1.2, 1.4, 300, 0.3, model_name='efficientnetb3', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def EfficientNetB4(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB4 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB4', 'keras.applications.EfficientNetB4') def EfficientNetB4(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 1.4, 1.8, 380, 0.4, model_name='efficientnetb4', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def EfficientNetB5(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB5 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB5', 'keras.applications.EfficientNetB5') def EfficientNetB5(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 1.6, 2.2, 456, 0.4, model_name='efficientnetb5', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def EfficientNetB6(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB6 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB6', 'keras.applications.EfficientNetB6') def EfficientNetB6(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 1.8, 2.6, 528, 0.5, model_name='efficientnetb6', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def EfficientNetB7(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the EfficientNetB7 architecture.
Reference: - EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks (ICML 2019)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For EfficientNet, input preprocessing is included as part of the model (as a
Rescaling
layer), and thustf.keras.applications.efficientnet.preprocess_input
is actually a pass-through function. EfficientNet models expect their inputs to be float tensors of pixels with values in the [0-255] range.Args
include_top
- Whether to include the fully-connected layer at the top of the network. Defaults to True.
weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Defaults to '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. It should have exactly 3 inputs channels. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. Defaults to None. -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 noweights
argument is specified. Defaults to 1000 (number of ImageNet classes). classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. Defaults to 'softmax'. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.efficientnet.EfficientNetB7', 'keras.applications.EfficientNetB7') def EfficientNetB7(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): return EfficientNet( 2.0, 3.1, 600, 0.5, model_name='efficientnetb7', include_top=include_top, weights=weights, input_tensor=input_tensor, input_shape=input_shape, pooling=pooling, classes=classes, classifier_activation=classifier_activation, **kwargs)
def InceptionResNetV2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the Inception-ResNet v2 architecture.
Reference: - Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning (AAAI 2017)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For InceptionResNetV2, call
tf.keras.applications.inception_resnet_v2.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.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
isFalse
(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
isFalse
. -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
isTrue
, and if noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
. **kwargs
- For backwards compatibility only.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.inception_resnet_v2.InceptionResNetV2', 'keras.applications.InceptionResNetV2') def InceptionResNetV2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): """Instantiates the Inception-ResNet v2 architecture. Reference: - [Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning](https://arxiv.org/abs/1602.07261) (AAAI 2017) This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet. For image classification use cases, see [this page for detailed examples]( https://keras.io/api/applications/#usage-examples-for-image-classification-models). For transfer learning use cases, make sure to read the [guide to transfer learning & fine-tuning]( https://keras.io/guides/transfer_learning/). Note: each Keras Application expects a specific kind of input preprocessing. For InceptionResNetV2, call `tf.keras.applications.inception_resnet_v2.preprocess_input` on your inputs before passing them to the model. `inception_resnet_v2.preprocess_input` will scale input pixels between -1 and 1. 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 `(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. classifier_activation: A `str` or callable. The activation function to use on the "top" layer. Ignored unless `include_top=True`. Set `classifier_activation=None` to return the logits of the "top" layer. When loading pretrained weights, `classifier_activation` can only be `None` or `"softmax"`. **kwargs: For backwards compatibility only. Returns: A `keras.Model` instance. """ global layers if 'layers' in kwargs: layers = kwargs.pop('layers') else: layers = VersionAwareLayers() if kwargs: raise ValueError('Unknown argument(s): %s' % (kwargs,)) if not (weights in {'imagenet', None} or tf.io.gfile.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 = imagenet_utils.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 # 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) imagenet_utils.validate_activation(classifier_activation, weights) x = layers.Dense(classes, activation=classifier_activation, 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 = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = training.Model(inputs, x, name='inception_resnet_v2') # Load weights. if weights == 'imagenet': if include_top: fname = 'inception_resnet_v2_weights_tf_dim_ordering_tf_kernels.h5' weights_path = data_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 = data_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 InceptionV3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax')
-
Instantiates the Inception v3 architecture.
Reference: - Rethinking the Inception Architecture for Computer Vision (CVPR 2016)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For
InceptionV3()
, calltf.keras.applications.inception_v3.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.Args
include_top
- Boolean, whether to include the fully-connected
layer at the top, as the last layer of the network. Default to
True
. weights
- One of
None
(random initialization),imagenet
(pre-training on ImageNet), or the path to the weights file to be loaded. Default toimagenet
. input_tensor
- Optional Keras tensor (i.e. output of
layers.Input()
) to use as image input for the model.input_tensor
is useful for sharing inputs between multiple different networks. Default to None. input_shape
- Optional shape tuple, only to be specified
if
include_top
is False (otherwise the input shape has to be(299, 299, 3)
(withchannels_last
data format) or(3, 299, 299)
(withchannels_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.input_shape
will be ignored if theinput_tensor
is provided. pooling
- Optional pooling mode for feature extraction
when
include_top
isFalse
. -None
(default) 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 noweights
argument is specified. Default to 1000. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.inception_v3.InceptionV3', 'keras.applications.InceptionV3') def InceptionV3( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax'): """Instantiates the Inception v3 architecture. Reference: - [Rethinking the Inception Architecture for Computer Vision]( http://arxiv.org/abs/1512.00567) (CVPR 2016) This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet. For image classification use cases, see [this page for detailed examples]( https://keras.io/api/applications/#usage-examples-for-image-classification-models). For transfer learning use cases, make sure to read the [guide to transfer learning & fine-tuning]( https://keras.io/guides/transfer_learning/). Note: each Keras Application expects a specific kind of input preprocessing. For `InceptionV3`, call `tf.keras.applications.inception_v3.preprocess_input` on your inputs before passing them to the model. `inception_v3.preprocess_input` will scale input pixels between -1 and 1. Args: include_top: Boolean, whether to include the fully-connected layer at the top, as the last layer of the network. Default to `True`. weights: One of `None` (random initialization), `imagenet` (pre-training on ImageNet), or the path to the weights file to be loaded. Default to `imagenet`. input_tensor: Optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. `input_tensor` is useful for sharing inputs between multiple different networks. Default to None. 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. `input_shape` will be ignored if the `input_tensor` is provided. pooling: Optional pooling mode for feature extraction when `include_top` is `False`. - `None` (default) 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. Default to 1000. classifier_activation: A `str` or callable. The activation function to use on the "top" layer. Ignored unless `include_top=True`. Set `classifier_activation=None` to return the logits of the "top" layer. When loading pretrained weights, `classifier_activation` can only be `None` or `"softmax"`. Returns: A `keras.Model` instance. """ if not (weights in {'imagenet', None} or tf.io.gfile.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 = imagenet_utils.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) imagenet_utils.validate_activation(classifier_activation, weights) x = layers.Dense(classes, activation=classifier_activation, 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 = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = training.Model(inputs, x, name='inception_v3') # Load weights. if weights == 'imagenet': if include_top: weights_path = data_utils.get_file( 'inception_v3_weights_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH, cache_subdir='models', file_hash='9a0d58056eeedaa3f26cb7ebd46da564') else: weights_path = data_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 MobileNet(input_shape=None, alpha=1.0, depth_multiplier=1, dropout=0.001, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the MobileNet architecture.
Reference: - MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For MobileNet, call
tf.keras.applications.mobilenet.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.Args
input_shape
- Optional shape tuple, only to be specified if
include_top
is False (otherwise the input shape has to be(224, 224, 3)
(withchannels_last
data format) or (3, 224, 224) (withchannels_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. Default toNone
.input_shape
will be ignored if theinput_tensor
is provided. 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. - Ifalpha
> 1.0, proportionally increases the number of filters in each layer. - Ifalpha
= 1, default number of filters from the paper are used at each layer. Default to 1.0. depth_multiplier
- Depth multiplier for depthwise convolution. This is called the resolution multiplier in the MobileNet paper. Default to 1.0.
dropout
- Dropout rate. Default to 0.001.
include_top
- Boolean, whether to include the fully-connected layer at the
top of the network. Default to
True
. weights
- One of
None
(random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Default toimagenet
. input_tensor
- Optional Keras tensor (i.e. output of
layers.Input()
) to use as image input for the model.input_tensor
is useful for sharing inputs between multiple different networks. Default to None. pooling
- Optional pooling mode for feature extraction when
include_top
isFalse
. -None
(default) 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 noweights
argument is specified. Defaults to 1000. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
. **kwargs
- For backwards compatibility only.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.mobilenet.MobileNet', 'keras.applications.MobileNet') 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, classifier_activation='softmax', **kwargs): """Instantiates the MobileNet architecture. Reference: - [MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications]( https://arxiv.org/abs/1704.04861) This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet. For image classification use cases, see [this page for detailed examples]( https://keras.io/api/applications/#usage-examples-for-image-classification-models). For transfer learning use cases, make sure to read the [guide to transfer learning & fine-tuning]( https://keras.io/guides/transfer_learning/). Note: each Keras Application expects a specific kind of input preprocessing. For MobileNet, call `tf.keras.applications.mobilenet.preprocess_input` on your inputs before passing them to the model. `mobilenet.preprocess_input` will scale input pixels between -1 and 1. Args: 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. Default to `None`. `input_shape` will be ignored if the `input_tensor` is provided. 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. Default to 1.0. depth_multiplier: Depth multiplier for depthwise convolution. This is called the resolution multiplier in the MobileNet paper. Default to 1.0. dropout: Dropout rate. Default to 0.001. include_top: Boolean, whether to include the fully-connected layer at the top of the network. Default to `True`. weights: One of `None` (random initialization), 'imagenet' (pre-training on ImageNet), or the path to the weights file to be loaded. Default to `imagenet`. input_tensor: Optional Keras tensor (i.e. output of `layers.Input()`) to use as image input for the model. `input_tensor` is useful for sharing inputs between multiple different networks. Default to None. pooling: Optional pooling mode for feature extraction when `include_top` is `False`. - `None` (default) 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. Defaults to 1000. classifier_activation: A `str` or callable. The activation function to use on the "top" layer. Ignored unless `include_top=True`. Set `classifier_activation=None` to return the logits of the "top" layer. When loading pretrained weights, `classifier_activation` can only be `None` or `"softmax"`. **kwargs: For backwards compatibility only. Returns: A `keras.Model` instance. """ global layers if 'layers' in kwargs: layers = kwargs.pop('layers') else: layers = VersionAwareLayers() if kwargs: raise ValueError('Unknown argument(s): %s' % (kwargs,)) if not (weights in {'imagenet', None} or tf.io.gfile.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 = imagenet_utils.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 logging.warning('`input_shape` is undefined or non-square, ' 'or `rows` is not in [128, 160, 192, 224]. ' 'Weights for input shape (224, 224) will be' ' loaded as the default.') 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.Reshape((classes,), name='reshape_2')(x) imagenet_utils.validate_activation(classifier_activation, weights) x = layers.Activation(activation=classifier_activation, 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 = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = training.Model(inputs, x, name='mobilenet_%0.2f_%s' % (alpha, rows)) # Load weights. if weights == 'imagenet': 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 = data_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 = data_utils.get_file( model_name, weight_path, cache_subdir='models') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
def MobileNetV2(input_shape=None, alpha=1.0, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs)
-
Instantiates the MobileNetV2 architecture.
MobileNetV2 is very similar to the original MobileNet, except that it uses inverted residual blocks with bottlenecking features. It has a drastically lower parameter count than the original MobileNet. MobileNets support any input size greater than 32 x 32, with larger image sizes offering better performance.
Reference: - MobileNetV2: Inverted Residuals and Linear Bottlenecks (CVPR 2018)
This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet.
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For MobileNetV2, call
tf.keras.applications.mobilenet_v2.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.Args
input_shape
- Optional shape tuple, to be specified if you would
like to use a model with an input image 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
- Float between 0 and 1. 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
applications.MobileNetV1
model in Keras. - Ifalpha
< 1.0, proportionally decreases the number of filters in each layer. - Ifalpha
> 1.0, proportionally increases the number of filters in each layer. - Ifalpha
= 1.0, default number of filters from the paper are used at each layer. include_top
- Boolean, whether to include the fully-connected
layer at the top of the network. Defaults to
True
. weights
- String, 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
- String, optional pooling mode for feature extraction
when
include_top
isFalse
. -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
- Integer, optional number of classes to classify images
into, only to be specified if
include_top
is True, and if noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
. **kwargs
- For backwards compatibility only.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.mobilenet_v2.MobileNetV2', 'keras.applications.MobileNetV2') def MobileNetV2(input_shape=None, alpha=1.0, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000, classifier_activation='softmax', **kwargs): """Instantiates the MobileNetV2 architecture. MobileNetV2 is very similar to the original MobileNet, except that it uses inverted residual blocks with bottlenecking features. It has a drastically lower parameter count than the original MobileNet. MobileNets support any input size greater than 32 x 32, with larger image sizes offering better performance. Reference: - [MobileNetV2: Inverted Residuals and Linear Bottlenecks]( https://arxiv.org/abs/1801.04381) (CVPR 2018) This function returns a Keras image classification model, optionally loaded with weights pre-trained on ImageNet. For image classification use cases, see [this page for detailed examples]( https://keras.io/api/applications/#usage-examples-for-image-classification-models). For transfer learning use cases, make sure to read the [guide to transfer learning & fine-tuning]( https://keras.io/guides/transfer_learning/). Note: each Keras Application expects a specific kind of input preprocessing. For MobileNetV2, call `tf.keras.applications.mobilenet_v2.preprocess_input` on your inputs before passing them to the model. `mobilenet_v2.preprocess_input` will scale input pixels between -1 and 1. Args: input_shape: Optional shape tuple, to be specified if you would like to use a model with an input image 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: Float between 0 and 1. 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 `applications.MobileNetV1` model 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.0, default number of filters from the paper are used at each layer. include_top: Boolean, whether to include the fully-connected layer at the top of the network. Defaults to `True`. weights: String, 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: String, 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: Integer, optional number of classes to classify images into, only to be specified if `include_top` is True, and if no `weights` argument is specified. classifier_activation: A `str` or callable. The activation function to use on the "top" layer. Ignored unless `include_top=True`. Set `classifier_activation=None` to return the logits of the "top" layer. When loading pretrained weights, `classifier_activation` can only be `None` or `"softmax"`. **kwargs: For backwards compatibility only. Returns: A `keras.Model` instance. """ global layers if 'layers' in kwargs: layers = kwargs.pop('layers') else: layers = VersionAwareLayers() if kwargs: raise ValueError('Unknown argument(s): %s' % (kwargs,)) if not (weights in {'imagenet', None} or tf.io.gfile.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( layer_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 = imagenet_utils.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 logging.warning('`input_shape` is undefined or non-square, ' 'or `rows` is not in [96, 128, 160, 192, 224].' ' Weights for input shape (224, 224) will be' ' loaded as the default.') 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 channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1 first_block_filters = _make_divisible(32 * alpha, 8) x = layers.Conv2D( first_block_filters, kernel_size=3, strides=(2, 2), padding='same', use_bias=False, name='Conv1')(img_input) x = layers.BatchNormalization( axis=channel_axis, 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( axis=channel_axis, 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) imagenet_utils.validate_activation(classifier_activation, weights) x = layers.Dense(classes, activation=classifier_activation, 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 = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = training.Model(inputs, x, name='mobilenetv2_%0.2f_%s' % (alpha, rows)) # Load weights. if weights == 'imagenet': if include_top: model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' + str(float(alpha)) + '_' + str(rows) + '.h5') weight_path = BASE_WEIGHT_PATH + model_name weights_path = data_utils.get_file( model_name, weight_path, cache_subdir='models') else: model_name = ('mobilenet_v2_weights_tf_dim_ordering_tf_kernels_' + str(float(alpha)) + '_' + str(rows) + '_no_top' + '.h5') weight_path = BASE_WEIGHT_PATH + model_name weights_path = data_utils.get_file( model_name, weight_path, cache_subdir='models') model.load_weights(weights_path) elif weights is not None: model.load_weights(weights) return model
def MobileNetV3Large(input_shape=None, alpha=1.0, minimalistic=False, include_top=True, weights='imagenet', input_tensor=None, classes=1000, pooling=None, dropout_rate=0.2, classifier_activation='softmax', include_preprocessing=True)
-
Instantiates the MobileNetV3Large architecture.
Reference: - Searching for MobileNetV3 (ICCV 2019)
The following table describes the performance of MobileNets v3:
MACs stands for Multiply Adds
Classification Checkpoint MACs(M) Parameters(M) Top1 Accuracy Pixel1 CPU(ms) mobilenet_v3_large_1.0_224 217 5.4 75.6 51.2 mobilenet_v3_large_0.75_224 155 4.0 73.3 39.8 mobilenet_v3_large_minimalistic_1.0_224 209 3.9 72.3 44.1 mobilenet_v3_small_1.0_224 66 2.9 68.1 15.8 mobilenet_v3_small_0.75_224 44 2.4 65.4 12.8 mobilenet_v3_small_minimalistic_1.0_224 65 2.0 61.9 12.2 For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ModelNetV3, by default input preprocessing is included as a part of the model (as a
Rescaling
layer), and thustf.keras.applications.mobilenet_v3.preprocess_input
is actually a pass-through function. In this use case, ModelNetV3 models expect their inputs to be float tensors of pixels with values in the [0-255] range. At the same time, preprocessing as a part of the model (i.e.Rescaling
layer) can be disabled by settinginclude_preprocessing
argument to False. With preprocessing disabled ModelNetV3 models expect their inputs to be float tensors of pixels with values in the [-1, 1] range.Args
input_shape
- Optional shape tuple, to be specified if you would
like to use a model with an input image 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
depth multiplier in the MobileNetV3 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. - Ifalpha
> 1.0, proportionally increases the number of filters in each layer. - Ifalpha
= 1, default number of filters from the paper are used at each layer. minimalistic
- In addition to large and small models this module also contains so-called minimalistic models, these models have the same per-layer dimensions characteristic as MobilenetV3 however, they don't utilize any of the advanced blocks (squeeze-and-excite units, hard-swish, and 5x5 convolutions). While these models are less efficient on CPU, they are much more performant on GPU/DSP.
include_top
- Boolean, whether to include the fully-connected
layer at the top of the network. Defaults to
True
. weights
- String, 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
- String, optional pooling mode for feature extraction
when
include_top
isFalse
. -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
- Integer, optional number of classes to classify images
into, only to be specified if
include_top
is True, and if noweights
argument is specified. dropout_rate
- fraction of the input units to drop on the last layer.
classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
. include_preprocessing
- Boolean, whether to include the preprocessing
layer (
Rescaling
) at the bottom of the network. Defaults toTrue
.
Call arguments: inputs: A floating point
numpy.array
or atf.Tensor
, 4D with 3 color channels, with values in the range [0, 255] ifinclude_preprocessing
is True and in the range [-1, 1] otherwise.Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.MobileNetV3Large') def MobileNetV3Large(input_shape=None, alpha=1.0, minimalistic=False, include_top=True, weights='imagenet', input_tensor=None, classes=1000, pooling=None, dropout_rate=0.2, classifier_activation='softmax', include_preprocessing=True): def stack_fn(x, kernel, activation, se_ratio): def depth(d): return _depth(d * alpha) x = _inverted_res_block(x, 1, depth(16), 3, 1, None, relu, 0) x = _inverted_res_block(x, 4, depth(24), 3, 2, None, relu, 1) x = _inverted_res_block(x, 3, depth(24), 3, 1, None, relu, 2) x = _inverted_res_block(x, 3, depth(40), kernel, 2, se_ratio, relu, 3) x = _inverted_res_block(x, 3, depth(40), kernel, 1, se_ratio, relu, 4) x = _inverted_res_block(x, 3, depth(40), kernel, 1, se_ratio, relu, 5) x = _inverted_res_block(x, 6, depth(80), 3, 2, None, activation, 6) x = _inverted_res_block(x, 2.5, depth(80), 3, 1, None, activation, 7) x = _inverted_res_block(x, 2.3, depth(80), 3, 1, None, activation, 8) x = _inverted_res_block(x, 2.3, depth(80), 3, 1, None, activation, 9) x = _inverted_res_block(x, 6, depth(112), 3, 1, se_ratio, activation, 10) x = _inverted_res_block(x, 6, depth(112), 3, 1, se_ratio, activation, 11) x = _inverted_res_block(x, 6, depth(160), kernel, 2, se_ratio, activation, 12) x = _inverted_res_block(x, 6, depth(160), kernel, 1, se_ratio, activation, 13) x = _inverted_res_block(x, 6, depth(160), kernel, 1, se_ratio, activation, 14) return x return MobileNetV3(stack_fn, 1280, input_shape, alpha, 'large', minimalistic, include_top, weights, input_tensor, classes, pooling, dropout_rate, classifier_activation, include_preprocessing)
def MobileNetV3Small(input_shape=None, alpha=1.0, minimalistic=False, include_top=True, weights='imagenet', input_tensor=None, classes=1000, pooling=None, dropout_rate=0.2, classifier_activation='softmax', include_preprocessing=True)
-
Instantiates the MobileNetV3Small architecture.
Reference: - Searching for MobileNetV3 (ICCV 2019)
The following table describes the performance of MobileNets v3:
MACs stands for Multiply Adds
Classification Checkpoint MACs(M) Parameters(M) Top1 Accuracy Pixel1 CPU(ms) mobilenet_v3_large_1.0_224 217 5.4 75.6 51.2 mobilenet_v3_large_0.75_224 155 4.0 73.3 39.8 mobilenet_v3_large_minimalistic_1.0_224 209 3.9 72.3 44.1 mobilenet_v3_small_1.0_224 66 2.9 68.1 15.8 mobilenet_v3_small_0.75_224 44 2.4 65.4 12.8 mobilenet_v3_small_minimalistic_1.0_224 65 2.0 61.9 12.2 For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ModelNetV3, by default input preprocessing is included as a part of the model (as a
Rescaling
layer), and thustf.keras.applications.mobilenet_v3.preprocess_input
is actually a pass-through function. In this use case, ModelNetV3 models expect their inputs to be float tensors of pixels with values in the [0-255] range. At the same time, preprocessing as a part of the model (i.e.Rescaling
layer) can be disabled by settinginclude_preprocessing
argument to False. With preprocessing disabled ModelNetV3 models expect their inputs to be float tensors of pixels with values in the [-1, 1] range.Args
input_shape
- Optional shape tuple, to be specified if you would
like to use a model with an input image 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
depth multiplier in the MobileNetV3 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. - Ifalpha
> 1.0, proportionally increases the number of filters in each layer. - Ifalpha
= 1, default number of filters from the paper are used at each layer. minimalistic
- In addition to large and small models this module also contains so-called minimalistic models, these models have the same per-layer dimensions characteristic as MobilenetV3 however, they don't utilize any of the advanced blocks (squeeze-and-excite units, hard-swish, and 5x5 convolutions). While these models are less efficient on CPU, they are much more performant on GPU/DSP.
include_top
- Boolean, whether to include the fully-connected
layer at the top of the network. Defaults to
True
. weights
- String, 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
- String, optional pooling mode for feature extraction
when
include_top
isFalse
. -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
- Integer, optional number of classes to classify images
into, only to be specified if
include_top
is True, and if noweights
argument is specified. dropout_rate
- fraction of the input units to drop on the last layer.
classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
. include_preprocessing
- Boolean, whether to include the preprocessing
layer (
Rescaling
) at the bottom of the network. Defaults toTrue
.
Call arguments: inputs: A floating point
numpy.array
or atf.Tensor
, 4D with 3 color channels, with values in the range [0, 255] ifinclude_preprocessing
is True and in the range [-1, 1] otherwise.Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.MobileNetV3Small') def MobileNetV3Small(input_shape=None, alpha=1.0, minimalistic=False, include_top=True, weights='imagenet', input_tensor=None, classes=1000, pooling=None, dropout_rate=0.2, classifier_activation='softmax', include_preprocessing=True): def stack_fn(x, kernel, activation, se_ratio): def depth(d): return _depth(d * alpha) x = _inverted_res_block(x, 1, depth(16), 3, 2, se_ratio, relu, 0) x = _inverted_res_block(x, 72. / 16, depth(24), 3, 2, None, relu, 1) x = _inverted_res_block(x, 88. / 24, depth(24), 3, 1, None, relu, 2) x = _inverted_res_block(x, 4, depth(40), kernel, 2, se_ratio, activation, 3) x = _inverted_res_block(x, 6, depth(40), kernel, 1, se_ratio, activation, 4) x = _inverted_res_block(x, 6, depth(40), kernel, 1, se_ratio, activation, 5) x = _inverted_res_block(x, 3, depth(48), kernel, 1, se_ratio, activation, 6) x = _inverted_res_block(x, 3, depth(48), kernel, 1, se_ratio, activation, 7) x = _inverted_res_block(x, 6, depth(96), kernel, 2, se_ratio, activation, 8) x = _inverted_res_block(x, 6, depth(96), kernel, 1, se_ratio, activation, 9) x = _inverted_res_block(x, 6, depth(96), kernel, 1, se_ratio, activation, 10) return x return MobileNetV3(stack_fn, 1024, input_shape, alpha, 'small', minimalistic, include_top, weights, input_tensor, classes, pooling, dropout_rate, classifier_activation, include_preprocessing)
def NASNetLarge(input_shape=None, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000)
-
Instantiates a NASNet model in ImageNet mode.
Reference: - Learning Transferable Architectures for Scalable Image Recognition (CVPR 2018)
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
.Note: each Keras Application expects a specific kind of input preprocessing. For NASNet, call
tf.keras.applications.nasnet.preprocess_input
on your inputs before passing them to the model.Args
input_shape
- Optional shape tuple, only to be specified
if
include_top
is False (otherwise the input shape has to be(331, 331, 3)
for NASNetLarge. It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g.(224, 224, 3)
would be one valid value. include_top
- Whether to include the fully-connected layer at the top of the network.
weights
None
(random initialization) orimagenet
(ImageNet weights) For loadingimagenet
weights,input_shape
should be (331, 331, 3)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
isFalse
. -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 noweights
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.
Expand source code
@keras_export('keras.applications.nasnet.NASNetLarge', 'keras.applications.NASNetLarge') def NASNetLarge(input_shape=None, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000): """Instantiates a NASNet model in ImageNet mode. Reference: - [Learning Transferable Architectures for Scalable Image Recognition]( https://arxiv.org/abs/1707.07012) (CVPR 2018) 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`. Note: each Keras Application expects a specific kind of input preprocessing. For NASNet, call `tf.keras.applications.nasnet.preprocess_input` on your inputs before passing them to the model. Args: input_shape: Optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(331, 331, 3)` for NASNetLarge. It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(224, 224, 3)` would be one valid value. include_top: Whether to include the fully-connected layer at the top of the network. weights: `None` (random initialization) or `imagenet` (ImageNet weights) For loading `imagenet` weights, `input_shape` should be (331, 331, 3) 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. 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. """ return NASNet( input_shape, penultimate_filters=4032, num_blocks=6, stem_block_filters=96, skip_reduction=True, filter_multiplier=2, include_top=include_top, weights=weights, input_tensor=input_tensor, pooling=pooling, classes=classes, default_size=331)
def NASNetMobile(input_shape=None, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000)
-
Instantiates a Mobile NASNet model in ImageNet mode.
Reference: - Learning Transferable Architectures for Scalable Image Recognition (CVPR 2018)
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
.Note: each Keras Application expects a specific kind of input preprocessing. For NASNet, call
tf.keras.applications.nasnet.preprocess_input
on your inputs before passing them to the model.Args
input_shape
- Optional shape tuple, only to be specified
if
include_top
is False (otherwise the input shape has to be(224, 224, 3)
for NASNetMobile It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g.(224, 224, 3)
would be one valid value. include_top
- Whether to include the fully-connected layer at the top of the network.
weights
None
(random initialization) orimagenet
(ImageNet weights) For loadingimagenet
weights,input_shape
should be (224, 224, 3)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
isFalse
. -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 noweights
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.
Expand source code
@keras_export('keras.applications.nasnet.NASNetMobile', 'keras.applications.NASNetMobile') def NASNetMobile(input_shape=None, include_top=True, weights='imagenet', input_tensor=None, pooling=None, classes=1000): """Instantiates a Mobile NASNet model in ImageNet mode. Reference: - [Learning Transferable Architectures for Scalable Image Recognition]( https://arxiv.org/abs/1707.07012) (CVPR 2018) 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`. Note: each Keras Application expects a specific kind of input preprocessing. For NASNet, call `tf.keras.applications.nasnet.preprocess_input` on your inputs before passing them to the model. Args: input_shape: Optional shape tuple, only to be specified if `include_top` is False (otherwise the input shape has to be `(224, 224, 3)` for NASNetMobile It should have exactly 3 inputs channels, and width and height should be no smaller than 32. E.g. `(224, 224, 3)` would be one valid value. include_top: Whether to include the fully-connected layer at the top of the network. weights: `None` (random initialization) or `imagenet` (ImageNet weights) For loading `imagenet` weights, `input_shape` should be (224, 224, 3) 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. 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. """ return NASNet( input_shape, penultimate_filters=1056, num_blocks=4, stem_block_filters=32, skip_reduction=False, filter_multiplier=2, include_top=include_top, weights=weights, input_tensor=input_tensor, pooling=pooling, classes=classes, default_size=224)
def ResNet101(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs)
-
Instantiates the ResNet101 architecture.
Reference: - Deep Residual Learning for Image Recognition (CVPR 2015)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ResNet, call
tf.keras.applications.resnet.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will convert the input images from RGB to BGR, then will zero-center each color channel with respect to the ImageNet dataset, without scaling.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, 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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A Keras model instance.
Expand source code
@keras_export('keras.applications.resnet.ResNet101', 'keras.applications.ResNet101') def ResNet101(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the ResNet101 architecture.""" def stack_fn(x): x = stack1(x, 64, 3, stride1=1, name='conv2') x = stack1(x, 128, 4, name='conv3') x = stack1(x, 256, 23, name='conv4') return stack1(x, 512, 3, name='conv5') return ResNet(stack_fn, False, True, 'resnet101', include_top, weights, input_tensor, input_shape, pooling, classes, **kwargs)
def ResNet101V2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax')
-
Instantiates the ResNet101V2 architecture.
Reference: - [Identity Mappings in Deep Residual Networks] (https://arxiv.org/abs/1603.05027) (CVPR 2016)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ResNetV2, call
tf.keras.applications.resnet_v2.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.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, 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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.resnet_v2.ResNet101V2', 'keras.applications.ResNet101V2') def ResNet101V2( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax'): """Instantiates the ResNet101V2 architecture.""" def stack_fn(x): x = resnet.stack2(x, 64, 3, name='conv2') x = resnet.stack2(x, 128, 4, name='conv3') x = resnet.stack2(x, 256, 23, name='conv4') return resnet.stack2(x, 512, 3, stride1=1, name='conv5') return resnet.ResNet( stack_fn, True, True, 'resnet101v2', include_top, weights, input_tensor, input_shape, pooling, classes, classifier_activation=classifier_activation)
def ResNet152(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs)
-
Instantiates the ResNet152 architecture.
Reference: - Deep Residual Learning for Image Recognition (CVPR 2015)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ResNet, call
tf.keras.applications.resnet.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will convert the input images from RGB to BGR, then will zero-center each color channel with respect to the ImageNet dataset, without scaling.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, 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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A Keras model instance.
Expand source code
@keras_export('keras.applications.resnet.ResNet152', 'keras.applications.ResNet152') def ResNet152(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the ResNet152 architecture.""" def stack_fn(x): x = stack1(x, 64, 3, stride1=1, name='conv2') x = stack1(x, 128, 8, name='conv3') x = stack1(x, 256, 36, name='conv4') return stack1(x, 512, 3, name='conv5') return ResNet(stack_fn, False, True, 'resnet152', include_top, weights, input_tensor, input_shape, pooling, classes, **kwargs)
def ResNet152V2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax')
-
Instantiates the ResNet152V2 architecture.
Reference: - [Identity Mappings in Deep Residual Networks] (https://arxiv.org/abs/1603.05027) (CVPR 2016)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ResNetV2, call
tf.keras.applications.resnet_v2.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.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, 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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.resnet_v2.ResNet152V2', 'keras.applications.ResNet152V2') def ResNet152V2( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax'): """Instantiates the ResNet152V2 architecture.""" def stack_fn(x): x = resnet.stack2(x, 64, 3, name='conv2') x = resnet.stack2(x, 128, 8, name='conv3') x = resnet.stack2(x, 256, 36, name='conv4') return resnet.stack2(x, 512, 3, stride1=1, name='conv5') return resnet.ResNet( stack_fn, True, True, 'resnet152v2', include_top, weights, input_tensor, input_shape, pooling, classes, classifier_activation=classifier_activation)
def ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs)
-
Instantiates the ResNet50 architecture.
Reference: - Deep Residual Learning for Image Recognition (CVPR 2015)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ResNet, call
tf.keras.applications.resnet.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will convert the input images from RGB to BGR, then will zero-center each color channel with respect to the ImageNet dataset, without scaling.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, 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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A Keras model instance.
Expand source code
@keras_export('keras.applications.resnet50.ResNet50', 'keras.applications.resnet.ResNet50', 'keras.applications.ResNet50') def ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, **kwargs): """Instantiates the ResNet50 architecture.""" def stack_fn(x): x = stack1(x, 64, 3, stride1=1, name='conv2') x = stack1(x, 128, 4, name='conv3') x = stack1(x, 256, 6, name='conv4') return stack1(x, 512, 3, name='conv5') return ResNet(stack_fn, False, True, 'resnet50', include_top, weights, input_tensor, input_shape, pooling, classes, **kwargs)
def ResNet50V2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax')
-
Instantiates the ResNet50V2 architecture.
Reference: - [Identity Mappings in Deep Residual Networks] (https://arxiv.org/abs/1603.05027) (CVPR 2016)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
Note: each Keras Application expects a specific kind of input preprocessing. For ResNetV2, call
tf.keras.applications.resnet_v2.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.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, 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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.resnet_v2.ResNet50V2', 'keras.applications.ResNet50V2') def ResNet50V2( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax'): """Instantiates the ResNet50V2 architecture.""" def stack_fn(x): x = resnet.stack2(x, 64, 3, name='conv2') x = resnet.stack2(x, 128, 4, name='conv3') x = resnet.stack2(x, 256, 6, name='conv4') return resnet.stack2(x, 512, 3, stride1=1, name='conv5') return resnet.ResNet( stack_fn, True, True, 'resnet50v2', include_top, weights, input_tensor, input_shape, pooling, classes, classifier_activation=classifier_activation)
def VGG16(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax')
-
Instantiates the VGG16 model.
Reference: - Very Deep Convolutional Networks for Large-Scale Image Recognition (ICLR 2015)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
The default input size for this model is 224x224.
Note: each Keras Application expects a specific kind of input preprocessing. For VGG16, call
tf.keras.applications.vgg16.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will convert the input images from RGB to BGR, then will zero-center each color channel with respect to the ImageNet dataset, without scaling.Args
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)
(withchannels_last
data format) or(3, 224, 224)
(withchannels_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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.vgg16.VGG16', 'keras.applications.VGG16') def VGG16( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax'): """Instantiates the VGG16 model. Reference: - [Very Deep Convolutional Networks for Large-Scale Image Recognition]( https://arxiv.org/abs/1409.1556) (ICLR 2015) For image classification use cases, see [this page for detailed examples]( https://keras.io/api/applications/#usage-examples-for-image-classification-models). For transfer learning use cases, make sure to read the [guide to transfer learning & fine-tuning]( https://keras.io/guides/transfer_learning/). The default input size for this model is 224x224. Note: each Keras Application expects a specific kind of input preprocessing. For VGG16, call `tf.keras.applications.vgg16.preprocess_input` on your inputs before passing them to the model. `vgg16.preprocess_input` will convert the input images from RGB to BGR, then will zero-center each color channel with respect to the ImageNet dataset, without scaling. Args: 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. classifier_activation: A `str` or callable. The activation function to use on the "top" layer. Ignored unless `include_top=True`. Set `classifier_activation=None` to return the logits of the "top" layer. When loading pretrained weights, `classifier_activation` can only be `None` or `"softmax"`. Returns: A `keras.Model` instance. """ if not (weights in {'imagenet', None} or tf.io.gfile.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 = imagenet_utils.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='relu', padding='same', name='block1_conv1')( img_input) x = layers.Conv2D( 64, (3, 3), activation='relu', 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='relu', padding='same', name='block2_conv1')(x) x = layers.Conv2D( 128, (3, 3), activation='relu', 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='relu', padding='same', name='block3_conv1')(x) x = layers.Conv2D( 256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x) x = layers.Conv2D( 256, (3, 3), activation='relu', 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='relu', padding='same', name='block4_conv1')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', 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='relu', padding='same', name='block5_conv1')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', 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='relu', name='fc1')(x) x = layers.Dense(4096, activation='relu', name='fc2')(x) imagenet_utils.validate_activation(classifier_activation, weights) x = layers.Dense(classes, activation=classifier_activation, 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 = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = training.Model(inputs, x, name='vgg16') # Load weights. if weights == 'imagenet': if include_top: weights_path = data_utils.get_file( 'vgg16_weights_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH, cache_subdir='models', file_hash='64373286793e3c8b2b4e3219cbf3544b') else: weights_path = data_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) elif weights is not None: model.load_weights(weights) return model
def VGG19(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax')
-
Instantiates the VGG19 architecture.
Reference: - Very Deep Convolutional Networks for Large-Scale Image Recognition (ICLR 2015)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
The default input size for this model is 224x224.
Note: each Keras Application expects a specific kind of input preprocessing. For VGG19, call
tf.keras.applications.vgg19.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will convert the input images from RGB to BGR, then will zero-center each color channel with respect to the ImageNet dataset, without scaling.Args
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)
(withchannels_last
data format) or(3, 224, 224)
(withchannels_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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.vgg19.VGG19', 'keras.applications.VGG19') def VGG19( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax'): """Instantiates the VGG19 architecture. Reference: - [Very Deep Convolutional Networks for Large-Scale Image Recognition]( https://arxiv.org/abs/1409.1556) (ICLR 2015) For image classification use cases, see [this page for detailed examples]( https://keras.io/api/applications/#usage-examples-for-image-classification-models). For transfer learning use cases, make sure to read the [guide to transfer learning & fine-tuning]( https://keras.io/guides/transfer_learning/). The default input size for this model is 224x224. Note: each Keras Application expects a specific kind of input preprocessing. For VGG19, call `tf.keras.applications.vgg19.preprocess_input` on your inputs before passing them to the model. `vgg19.preprocess_input` will convert the input images from RGB to BGR, then will zero-center each color channel with respect to the ImageNet dataset, without scaling. Args: 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 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. classifier_activation: A `str` or callable. The activation function to use on the "top" layer. Ignored unless `include_top=True`. Set `classifier_activation=None` to return the logits of the "top" layer. When loading pretrained weights, `classifier_activation` can only be `None` or `"softmax"`. Returns: A `keras.Model` instance. """ if not (weights in {'imagenet', None} or tf.io.gfile.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 = imagenet_utils.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='relu', padding='same', name='block1_conv1')( img_input) x = layers.Conv2D( 64, (3, 3), activation='relu', 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='relu', padding='same', name='block2_conv1')(x) x = layers.Conv2D( 128, (3, 3), activation='relu', 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='relu', padding='same', name='block3_conv1')(x) x = layers.Conv2D( 256, (3, 3), activation='relu', padding='same', name='block3_conv2')(x) x = layers.Conv2D( 256, (3, 3), activation='relu', padding='same', name='block3_conv3')(x) x = layers.Conv2D( 256, (3, 3), activation='relu', padding='same', name='block3_conv4')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block3_pool')(x) # Block 4 x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block4_conv1')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block4_conv2')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block4_conv3')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block4_conv4')(x) x = layers.MaxPooling2D((2, 2), strides=(2, 2), name='block4_pool')(x) # Block 5 x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block5_conv1')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block5_conv2')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block5_conv3')(x) x = layers.Conv2D( 512, (3, 3), activation='relu', padding='same', name='block5_conv4')(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='relu', name='fc1')(x) x = layers.Dense(4096, activation='relu', name='fc2')(x) imagenet_utils.validate_activation(classifier_activation, weights) x = layers.Dense(classes, activation=classifier_activation, 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 = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = training.Model(inputs, x, name='vgg19') # Load weights. if weights == 'imagenet': if include_top: weights_path = data_utils.get_file( 'vgg19_weights_tf_dim_ordering_tf_kernels.h5', WEIGHTS_PATH, cache_subdir='models', file_hash='cbe5617147190e668d6c5d5026f83318') else: weights_path = data_utils.get_file( 'vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5', WEIGHTS_PATH_NO_TOP, cache_subdir='models', file_hash='253f8cb515780f3b799900260a226db6') 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, classifier_activation='softmax')
-
Instantiates the Xception architecture.
Reference: - Xception: Deep Learning with Depthwise Separable Convolutions (CVPR 2017)
For image classification use cases, see this page for detailed examples.
For transfer learning use cases, make sure to read the guide to transfer learning & fine-tuning.
The default input image size for this model is 299x299.
Note: each Keras Application expects a specific kind of input preprocessing. For Xception, call
tf.keras.applications.xception.preprocess_input
on your inputs before passing them to the model.preprocess_input()
will scale input pixels between -1 and 1.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(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
isFalse
. -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 noweights
argument is specified. classifier_activation
- A
str
or callable. The activation function to use on the "top" layer. Ignored unlessinclude_top=True
. Setclassifier_activation=None
to return the logits of the "top" layer. When loading pretrained weights,classifier_activation
can only beNone
or"softmax"
.
Returns
A
keras.Model
instance.Expand source code
@keras_export('keras.applications.xception.Xception', 'keras.applications.Xception') def Xception( include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000, classifier_activation='softmax'): """Instantiates the Xception architecture. Reference: - [Xception: Deep Learning with Depthwise Separable Convolutions]( https://arxiv.org/abs/1610.02357) (CVPR 2017) For image classification use cases, see [this page for detailed examples]( https://keras.io/api/applications/#usage-examples-for-image-classification-models). For transfer learning use cases, make sure to read the [guide to transfer learning & fine-tuning]( https://keras.io/guides/transfer_learning/). The default input image size for this model is 299x299. Note: each Keras Application expects a specific kind of input preprocessing. For Xception, call `tf.keras.applications.xception.preprocess_input` on your inputs before passing them to the model. `xception.preprocess_input` will scale input pixels between -1 and 1. 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 `(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. classifier_activation: A `str` or callable. The activation function to use on the "top" layer. Ignored unless `include_top=True`. Set `classifier_activation=None` to return the logits of the "top" layer. When loading pretrained weights, `classifier_activation` can only be `None` or `"softmax"`. Returns: A `keras.Model` instance. """ if not (weights in {'imagenet', None} or tf.io.gfile.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 = imagenet_utils.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 channel_axis = 1 if backend.image_data_format() == 'channels_first' else -1 x = layers.Conv2D( 32, (3, 3), strides=(2, 2), use_bias=False, name='block1_conv1')(img_input) x = layers.BatchNormalization(axis=channel_axis, 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(axis=channel_axis, 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(axis=channel_axis)(residual) x = layers.SeparableConv2D( 128, (3, 3), padding='same', use_bias=False, name='block2_sepconv1')(x) x = layers.BatchNormalization(axis=channel_axis, 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(axis=channel_axis, 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(axis=channel_axis)(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(axis=channel_axis, 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(axis=channel_axis, 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(axis=channel_axis)(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(axis=channel_axis, 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(axis=channel_axis, 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( axis=channel_axis, 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( axis=channel_axis, 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( axis=channel_axis, name=prefix + '_sepconv3_bn')(x) x = layers.add([x, residual]) residual = layers.Conv2D( 1024, (1, 1), strides=(2, 2), padding='same', use_bias=False)(x) residual = layers.BatchNormalization(axis=channel_axis)(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( axis=channel_axis, 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( axis=channel_axis, 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( axis=channel_axis, 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( axis=channel_axis, name='block14_sepconv2_bn')(x) x = layers.Activation('relu', name='block14_sepconv2_act')(x) if include_top: x = layers.GlobalAveragePooling2D(name='avg_pool')(x) imagenet_utils.validate_activation(classifier_activation, weights) x = layers.Dense(classes, activation=classifier_activation, 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 = layer_utils.get_source_inputs(input_tensor) else: inputs = img_input # Create model. model = training.Model(inputs, x, name='xception') # Load weights. if weights == 'imagenet': if include_top: weights_path = data_utils.get_file( 'xception_weights_tf_dim_ordering_tf_kernels.h5', TF_WEIGHTS_PATH, cache_subdir='models', file_hash='0a58e3b7378bc2990ea3b43d5981f1f6') else: weights_path = data_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) elif weights is not None: model.load_weights(weights) return model