EVOLUTION-MANAGER

Edit File: _1d.py

# -*- coding: utf-8 -*-

"""
keras_resnet.models._1d
~~~~~~~~~~~~~~~~~~~~~~~

This module implements popular one-dimensional residual models.
"""

import keras.backend
import keras.layers
import keras.models
import keras.regularizers

import keras_resnet.blocks
import keras_resnet.layers

class ResNet1D(keras.Model):
    """
    Constructs a `keras.models.Model` object using the given block count.

:param inputs: input tensor (e.g. an instance of `keras.layers.Input`)

:param blocks: the network’s residual architecture

:param block: a residual block (e.g. an instance of `keras_resnet.blocks.basic_1d`)

:param include_top: if true, includes classification layers

:param classes: number of classes to classify (include_top must be true)

:param freeze_bn: if true, freezes BatchNormalization layers (ie. no updates are done in these layers)

:param numerical_names: list of bool, same size as blocks, used to indicate whether names of layers should include numbers or letters

:return model: ResNet model with encoding output (if `include_top=False`) or classification output (if `include_top=True`)

Usage:

>>> import keras_resnet.blocks
        >>> import keras_resnet.models

>>> shape, classes = (224, 224, 3), 1000

>>> x = keras.layers.Input(shape)

>>> blocks = [2, 2, 2, 2]

>>> block = keras_resnet.blocks.basic_1d

>>> model = keras_resnet.models.ResNet(x, classes, blocks, block, classes=classes)

>>> model.compile("adam", "categorical_crossentropy", ["accuracy"])
    """
    def __init__(
        self,
        inputs,
        blocks,
        block,
        include_top=True,
        classes=1000,
        freeze_bn=True,
        numerical_names=None,
        *args,
        **kwargs
    ):
        if keras.backend.image_data_format() == "channels_last":
            axis = 3
        else:
            axis = 1

if numerical_names is None:
            numerical_names = [True] * len(blocks)

x = keras.layers.ZeroPadding1D(padding=3, name="padding_conv1")(inputs)
        x = keras.layers.Conv1D(64, (7, 7), strides=(2, 2), use_bias=False, name="conv1")(x)
        x = keras_resnet.layers.BatchNormalization(axis=axis, epsilon=1e-5, freeze=freeze_bn, name="bn_conv1")(x)
        x = keras.layers.Activation("relu", name="conv1_relu")(x)
        x = keras.layers.MaxPooling1D((3, 3), strides=(2, 2), padding="same", name="pool1")(x)

features = 64

outputs = []

for stage_id, iterations in enumerate(blocks):
            for block_id in range(iterations):
                x = block(
                    features,
                    stage_id,
                    block_id,
                    numerical_name=(block_id > 0 and numerical_names[stage_id]),
                    freeze_bn=freeze_bn
                )(x)

features *= 2

outputs.append(x)

if include_top:
            assert classes > 0

x = keras.layers.GlobalAveragePooling1D(name="pool5")(x)
            x = keras.layers.Dense(classes, activation="softmax", name="fc1000")(x)

super(ResNet1D, self).__init__(inputs=inputs, outputs=x, *args, **kwargs)
        else:
            # Else output each stages features
            super(ResNet1D, self).__init__(inputs=inputs, outputs=outputs, *args, **kwargs)

class ResNet1D18(ResNet1D):
    """
    Constructs a `keras.models.Model` according to the ResNet18 specifications.

:param inputs: input tensor (e.g. an instance of `keras.layers.Input`)

:param blocks: the network’s residual architecture

:param include_top: if true, includes classification layers

:param classes: number of classes to classify (include_top must be true)

:param freeze_bn: if true, freezes BatchNormalization layers (ie. no updates are done in these layers)

:return model: ResNet model with encoding output (if `include_top=False`) or classification output (if `include_top=True`)

Usage:

>>> import keras_resnet.models

>>> shape, classes = (224, 224, 3), 1000

>>> x = keras.layers.Input(shape)

>>> model = keras_resnet.models.ResNet18(x, classes=classes)

>>> model.compile("adam", "categorical_crossentropy", ["accuracy"])
    """
    def __init__(self, inputs, blocks=None, include_top=True, classes=1000, freeze_bn=False, *args, **kwargs):
        if blocks is None:
            blocks = [2, 2, 2, 2]

super(ResNet1D18, self).__init__(
            inputs,
            blocks,
            block=keras_resnet.blocks.basic_1d,
            include_top=include_top,
            classes=classes,
            freeze_bn=freeze_bn,
            *args,
            **kwargs
        )

class ResNet1D34(ResNet1D):
    """
    Constructs a `keras.models.Model` according to the ResNet34 specifications.

:param inputs: input tensor (e.g. an instance of `keras.layers.Input`)

:param blocks: the network’s residual architecture

:param include_top: if true, includes classification layers

:param classes: number of classes to classify (include_top must be true)

:param freeze_bn: if true, freezes BatchNormalization layers (ie. no updates are done in these layers)

:return model: ResNet model with encoding output (if `include_top=False`) or classification output (if `include_top=True`)

Usage:

>>> import keras_resnet.models

>>> shape, classes = (224, 224, 3), 1000

>>> x = keras.layers.Input(shape)

>>> model = keras_resnet.models.ResNet34(x, classes=classes)

super(ResNet1D34, self).__init__(
            inputs,
            blocks,
            block=keras_resnet.blocks.basic_1d,
            include_top=include_top,
            classes=classes,
            freeze_bn=freeze_bn,
            *args,
            **kwargs
        )

class ResNet1D50(ResNet1D):
    """
    Constructs a `keras.models.Model` according to the ResNet50 specifications.

:param inputs: input tensor (e.g. an instance of `keras.layers.Input`)

:param blocks: the network’s residual architecture

:param include_top: if true, includes classification layers

:param classes: number of classes to classify (include_top must be true)

:param freeze_bn: if true, freezes BatchNormalization layers (ie. no updates are done in these layers)

:return model: ResNet model with encoding output (if `include_top=False`) or classification output (if `include_top=True`)

Usage:

>>> import keras_resnet.models

>>> shape, classes = (224, 224, 3), 1000

>>> x = keras.layers.Input(shape)

>>> model = keras_resnet.models.ResNet50(x)

numerical_names = [False, False, False, False]

super(ResNet1D50, self).__init__(
            inputs,
            blocks,
            numerical_names=numerical_names,
            block=keras_resnet.blocks.bottleneck_1d,
            include_top=include_top,
            classes=classes,
            freeze_bn=freeze_bn,
            *args,
            **kwargs
        )

class ResNet1D101(ResNet1D):
    """
    Constructs a `keras.models.Model` according to the ResNet101 specifications.

:param inputs: input tensor (e.g. an instance of `keras.layers.Input`)

:param blocks: the network’s residual architecture

:param include_top: if true, includes classification layers

:param classes: number of classes to classify (include_top must be true)

:param freeze_bn: if true, freezes BatchNormalization layers (ie. no updates are done in these layers)

:return model: ResNet model with encoding output (if `include_top=False`) or classification output (if `include_top=True`)

Usage:

>>> import keras_resnet.models

>>> shape, classes = (224, 224, 3), 1000

>>> x = keras.layers.Input(shape)

>>> model = keras_resnet.models.ResNet101(x, classes=classes)

numerical_names = [False, True, True, False]

super(ResNet1D101, self).__init__(
            inputs,
            blocks,
            numerical_names=numerical_names,
            block=keras_resnet.blocks.bottleneck_1d,
            include_top=include_top,
            classes=classes,
            freeze_bn=freeze_bn,
            *args,
            **kwargs
        )

class ResNet1D152(ResNet1D):
    """
    Constructs a `keras.models.Model` according to the ResNet152 specifications.

:param inputs: input tensor (e.g. an instance of `keras.layers.Input`)

:param blocks: the network’s residual architecture

:param include_top: if true, includes classification layers

:param classes: number of classes to classify (include_top must be true)

:param freeze_bn: if true, freezes BatchNormalization layers (ie. no updates are done in these layers)

:return model: ResNet model with encoding output (if `include_top=False`) or classification output (if `include_top=True`)

Usage:

>>> import keras_resnet.models

>>> shape, classes = (224, 224, 3), 1000

>>> x = keras.layers.Input(shape)

>>> model = keras_resnet.models.ResNet152(x, classes=classes)

numerical_names = [False, True, True, False]

super(ResNet1D152, self).__init__(
            inputs,
            blocks,
            numerical_names=numerical_names,
            block=keras_resnet.blocks.bottleneck_1d,
            include_top=include_top,
            classes=classes,
            freeze_bn=freeze_bn,
            *args,
            **kwargs
        )

class ResNet1D200(ResNet1D):
    """
    Constructs a `keras.models.Model` according to the ResNet200 specifications.

:param inputs: input tensor (e.g. an instance of `keras.layers.Input`)

:param blocks: the network’s residual architecture

:param include_top: if true, includes classification layers

:param classes: number of classes to classify (include_top must be true)

:param freeze_bn: if true, freezes BatchNormalization layers (ie. no updates are done in these layers)

:return model: ResNet model with encoding output (if `include_top=False`) or classification output (if `include_top=True`)

Usage:

>>> import keras_resnet.models

>>> shape, classes = (224, 224, 3), 1000

>>> x = keras.layers.Input(shape)

>>> model = keras_resnet.models.ResNet200(x, classes=classes)

numerical_names = [False, True, True, False]

super(ResNet1D200, self).__init__(
            inputs,
            blocks,
            numerical_names=numerical_names,
            block=keras_resnet.blocks.bottleneck_1d,
            include_top=include_top,
            classes=classes,
            freeze_bn=freeze_bn,
            *args,
            **kwargs
        )