示例#1
0
    def __init__(self,
                 channels,
                 init_block_channels,
                 bottleneck,
                 in_channels=3,
                 in_size=(224, 224),
                 classes=1000,
                 data_format="channels_last",
                 **kwargs):
        super(CbamResNet, self).__init__(**kwargs)
        self.in_size = in_size
        self.classes = classes
        self.data_format = data_format

        self.features = tf.keras.Sequential(name="features")
        self.features.add(
            ResInitBlock(in_channels=in_channels,
                         out_channels=init_block_channels,
                         data_format=data_format,
                         name="init_block"))
        in_channels = init_block_channels
        for i, channels_per_stage in enumerate(channels):
            stage = tf.keras.Sequential(name="stage{}".format(i + 1))
            for j, out_channels in enumerate(channels_per_stage):
                strides = 2 if (j == 0) and (i != 0) else 1
                stage.add(
                    CbamResUnit(in_channels=in_channels,
                                out_channels=out_channels,
                                strides=strides,
                                bottleneck=bottleneck,
                                data_format=data_format,
                                name="unit{}".format(j + 1)))
                in_channels = out_channels
            self.features.add(stage)
        self.features.add(
            nn.AveragePooling2D(pool_size=7,
                                strides=1,
                                data_format=data_format,
                                name="final_pool"))

        self.output1 = nn.Dense(units=classes,
                                input_dim=in_channels,
                                name="output1")
示例#2
0
def trans_block(x, reduction):
    """ Construct a Transition Block
        x        : input layer
        reduction: percentage of reduction of feature maps
    """

    # Reduce (compress) the number of feature maps (DenseNet-C)
    # shape[n] returns a class object. We use int() to cast it into the dimension size
    n_filters = int( int(x.shape[3]) * reduction)
    
    # BN-LI-Conv pre-activation form of convolutions

    x = layers.BatchNormalization()(x)
    # Use 1x1 linear projection convolution
    x = layers.Conv2D(n_filters, (1, 1), strides=(1, 1), use_bias=False)(x)

    # Use mean value (average) instead of max value sampling when pooling reduce by 75%
    x = layers.AveragePooling2D((2, 2), strides=(2, 2))(x)
    return x
def InceptionV3_top30(inputs, classes=1000, pooling='avg'):
    global backend

    x = inputs

    if backend.image_data_format() == 'channels_first':
        channel_axis = 1
    else:
        channel_axis = 3

    # mixed 10: 8 x 8 x 2048
    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(1))

    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(10))

    x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
    x = layers.Dense(classes,
                     activation='softmax',
                     name='predictions',
                     kernel_regularizer=regularization)(x)

    model = keras.Model(inputs, x, name='inception_v3_top30')
    return model
示例#4
0
def Conv2DBlockRegu(_input,
                    n_kerns=4, kern_space=1, kern_length=64,
                    kern_regu_scale=0.0, l1=0.000, l2=0.000,
                    n_pool=4,
                    dropout_rate=0.25, dropout_type='Dropout',
                    activation='elu',
                    return_model=None):
    if dropout_type == 'SpatialDropout2D':
        dropout_type = layers.SpatialDropout2D
    elif dropout_type == 'Dropout':
        dropout_type = layers.Dropout
    else:
        raise ValueError('dropoutType must be one of SpatialDropout2D '
                         'or Dropout, passed as a string.')

    num_chans = _input.shape.as_list()[0]

    if kern_regu_scale:
        kern_regu = KernelLengthRegularizer((1, kern_length),
                                            window_func='poly',
                                            window_scale=kern_regu_scale,
                                            poly_exp=2, threshold=0.0015)
    elif l1 > 0 or l2 > 0:
        kern_regu = tf.keras.regularizers.l1_l2(l1=l1, l2=l2)
    else:
        kern_regu = None

    # Temporal-filter-like
    _y = layers.Conv2D(n_kerns, (kern_space, kern_length),
                       padding='same',
                       kernel_regularizer=kern_regu,
                       use_bias=False)(_input)
    _y = layers.BatchNormalization()(_y)
    _y = layers.Activation(activation)(_y)
    if n_pool > 1:
        _y = layers.AveragePooling2D((1, n_pool))(_y)
    _y = dropout_type(dropout_rate)(_y)

    if return_model is False:
        return _y
    else:
        return models.Model(inputs=input, outputs=_y)
示例#5
0
def build_model(hp):
    """Function that build a TF model based on hyperparameters values.

    Args:
        hp (HyperParameter): hyperparameters values

    Returns:
        Model: Compiled model
    """

    num_layers = hp.Int('num_layers', 2, 8, default=6)
    lr = hp.Choice('learning_rate', [1e-3, 5e-4])

    inputs = layers.Input(shape=(28, 28, 1))
    x = inputs

    for idx in range(num_layers):
        idx = str(idx)

        filters = hp.Int('filters_' + idx, 32, 256, step=32, default=64)
        x = layers.Conv2D(filters=filters,
                          kernel_size=3,
                          padding='same',
                          activation='relu')(x)

        # add a pooling layers if needed
        if x.shape[1] >= 8:
            pool_type = hp.Choice('pool_' + idx, values=['max', 'avg'])
            if pool_type == 'max':
                x = layers.MaxPooling2D(2)(x)
            elif pool_type == 'avg':
                x = layers.AveragePooling2D(2)(x)

    x = layers.Flatten()(x)
    outputs = layers.Dense(10, activation='softmax')(x)

    # Build model
    model = keras.Model(inputs, outputs)
    model.compile(optimizer=Adam(lr),
                  loss='categorical_crossentropy',
                  metrics=['accuracy'])
    return model
示例#6
0
def inception_v4_c(input_tensor):
    """
    block c of inception v4
    Args:
        input_tensor (keras tensor): input tensor
    Returns: keras tensor
    """
    avgpool = layers.AveragePooling2D(padding='same', strides=1)(input_tensor)
    conv_pool = layers.Conv2D(256, 1, 1, padding='same')(avgpool)
    conv_pool = layers.BatchNormalization()(conv_pool)
    conv_pool = layers.ReLU()(conv_pool)
    conv1 = layers.Conv2D(256, 1, 1, padding='same')(input_tensor)
    conv1 = layers.BatchNormalization()(conv1)
    conv1 = layers.ReLU()(conv1)
    conv2 = layers.Conv2D(384, 1, 1, padding='same')(input_tensor)
    conv2 = layers.BatchNormalization()(conv2)
    conv2 = layers.ReLU()(conv2)
    conv21 = layers.Conv2D(256, (1, 3), 1, padding='same')(conv2)
    conv21 = layers.BatchNormalization()(conv21)
    conv21 = layers.ReLU()(conv21)
    conv22 = layers.Conv2D(256, (3, 1), 1, padding='same')(conv2)
    conv22 = layers.BatchNormalization()(conv22)
    conv22 = layers.ReLU()(conv22)
    conv3 = layers.Conv2D(384, 1, 1, padding='same')(input_tensor)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    conv3 = layers.Conv2D(448, (1, 3), 1, padding='same')(conv3)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    conv3 = layers.Conv2D(512, (3, 1), 1, padding='same')(conv3)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    conv31 = layers.Conv2D(256, (3, 1), 1, padding='same')(conv3)
    conv31 = layers.BatchNormalization()(conv31)
    conv31 = layers.ReLU()(conv31)
    conv32 = layers.Conv2D(256, (1, 3), 1, padding='same')(conv3)
    conv32 = layers.BatchNormalization()(conv32)
    conv32 = layers.ReLU()(conv32)
    x = layers.Concatenate()(
        [conv_pool, conv1, conv21, conv22, conv31, conv32])

    return x
示例#7
0
    def get_model():
        """
        Lenet5 expects 32 x 32 image size.

        Model taken from https://engmrk.com/lenet-5-a-classic-cnn-architecture/
        """
        import tensorflow as tf
        from tensorflow.keras import layers

        model = tf.keras.Sequential()

        model.add(tf.keras.Input(shape=(
            32,
            32,
            3,
        )))

        model.add(
            layers.Conv2D(filters=6,
                          kernel_size=(5, 5),
                          strides=(1, 1),
                          activation="relu"))

        model.add(layers.AveragePooling2D(pool_size=(2, 2), ))

        model.add(
            layers.Conv2D(filters=16,
                          kernel_size=(5, 5),
                          strides=(1, 1),
                          activation="relu"))

        model.add(
            layers.Conv2D(filters=6,
                          kernel_size=(2, 2),
                          strides=(2, 2),
                          activation="relu"))

        model.add(layers.Flatten())
        model.add(layers.Dense(units=120))
        model.add(layers.Dense(units=84))
        model.add(layers.Dense(units=10))
        return model
示例#8
0
def _mixed(x, filters, name=None):
    """Utility function to implement the mixed (inception mobilenet) block.

    # Arguments
        x: input tensor.
        filters: a list of filter sizes.
        name: name of the ops

    # Returns
        Output tensor after applying the mixed block.
    """
    if len(filters) != 4:
        raise ValueError('filters should have 4 components')

    name1 = name + '_1x1' if name else None
    branch1x1 = _conv2d_bn(x, filters[0], kernel_size=(1, 1), name=name1)

    name1 = name + '_3x3' if name else None
    branch3x3 = _depthwise_conv2d_bn(x,
                                     filters[1],
                                     kernel_size=(3, 3),
                                     name=name1)

    name1 = name + '_5x5' if name else None
    branch5x5 = _depthwise_conv2d_bn(x,
                                     filters[2],
                                     kernel_size=(5, 5),
                                     name=name1)

    name1 = name + '_pool_1' if name else None
    name2 = name + '_pool_2' if name else None
    branchpool = layers.AveragePooling2D(pool_size=(3, 3),
                                         strides=(1, 1),
                                         padding='same',
                                         name=name1)(x)
    branchpool = _conv2d_bn(branchpool, filters[3], (1, 1), name=name2)

    concat_axis = 1 if backend.image_data_format() == 'channels_first' else 3
    x = layers.concatenate([branch1x1, branch3x3, branch5x5, branchpool],
                           axis=concat_axis,
                           name=name)
    return x
示例#9
0
def HIDRA(temporal_encoders='HIDRA', probabilistic=True, num_predictions=72, name='HIDRA'):
    """Build the HIDRA model.

    Args:
        temporal_encoders (str, optional): Which temporal encoders to use (One of: 'HIDRA', 'LSTM', 'TCN'). Defaults to 'HIDRA'.
        probabilistic (bool, optional): Model outputs as probability distributions. Defaults to True.
        num_predictions (int, optional): Number of predicted times.
    """
    # Time invariant atmospheric spatial encoder
    weather_cnn = tf.keras.Sequential([
        SpatialEncoding(),
        ResNet_v2(num_res_blocks=2, reduce_fn=L.AveragePooling2D((2,2))),
    ])

    # Add spatial attention and ReLU
    weather_cnn_full = tf.keras.Sequential([
        TimeInvariant(weather_cnn),
        FlattenSpatial(),
        TemporalLinearCombination(combination_axis=2, temporal_axis=1),
        L.ReLU()
    ])

    # Regression network
    regression = RegressionNetwork(
        num_predictions=num_predictions,
        units=[256, 256, 256],
        dropout_rate=0.5,
        probabilistic=probabilistic)

    # Temporal encoders
    if temporal_encoders == 'HIDRA':
        weather_pr = LinearCombination(axis=1)
        ssh_pr = L.Flatten()
    elif temporal_encoders == 'LSTM':
        weather_pr = LSTMStack([128,128,128])
        ssh_pr = LSTMStack([32,32,32])
    elif temporal_encoders == 'TCN':
        weather_pr = TCN([128,128,128])
        ssh_pr = TCN([32,32,32])

    model = HIDRABase(weather_cnn_full, weather_pr, ssh_pr, regression, name=name)
    return model
示例#10
0
    def __init__(self,
                 in_channels,
                 out_channels,
                 pool_out_size,
                 upscale_out_size,
                 data_format="channels_last",
                 **kwargs):
        super(PyramidPoolingBranch, self).__init__(**kwargs)
        self.upscale_out_size = upscale_out_size
        self.data_format = data_format

        self.pool = nn.AveragePooling2D(
            pool_size=pool_out_size,
            data_format=data_format,
            name="pool")
        self.conv = conv1x1_block(
            in_channels=in_channels,
            out_channels=out_channels,
            data_format=data_format,
            name="conv")
def trans_block(x, reduce_by):
    """ Construct a Transition Block
        x        : input layer
        reduce_by: percentage of reduction of feature maps
    """

    # Reduce (compression) the number of feature maps (DenseNet-C)
    # shape[n] returns a class object. We use int() to cast it into the dimension
    # size
    nb_filters = int(int(x.shape[3]) * reduce_by)

    # Bottleneck convolution
    x = layers.Conv2D(nb_filters, (1, 1), strides=(1, 1))(x)
    x = layers.BatchNormalization()(x)
    x = layers.ReLU()(x)

    # Use mean value (average) instead of max value sampling when pooling
    # reduce by 75%
    x = layers.AveragePooling2D((2, 2), strides=(2, 2))(x)
    return x
示例#12
0
def define_model_bins(nchan, L, Fs):
    model = tf.keras.Sequential()
    model.add(layers.InputLayer((L, nchan), batch_size=1))
    model.add(
        MorletConv([L, nchan],
                   Fs,
                   input_shape=[L, nchan, 1],
                   etas=25,
                   wtime=0.04))
    model.add(
        layers.Conv2D(filters=25, kernel_size=[1, nchan], activation='elu'))
    model.add(layers.Permute((3, 1, 2)))
    model.add(layers.AveragePooling2D(pool_size=(1, 10), strides=(1, 5)))
    #model.add(layers.Dropout(0.75))
    model.add(layers.Flatten())
    model.add(layers.Dense(1, activation='sigmoid'))
    model.compile(loss=losses.BinaryCrossentropy(),
                  optimizer=optimizers.Adam(),
                  metrics=['accuracy'])
    return model
示例#13
0
def build_model():
    model = models.Sequential([
        layers.Conv2D(8, (25, 22),
                      activation='relu',
                      name='Conv2D_1',
                      input_shape=(353, 22, 1)),
        layers.Dropout(0.25),
        layers.AveragePooling2D((10, 1), name='AveragePooling2D_2'),
        #layers.Conv2D(8, (5, 1), activation='relu', name='Conv2D_3'),
        layers.Dropout(0.25),
        #layers.MaxPooling2D((10, 1),name='MaxPooling2D_4'),
        #layers.Conv2D(64, (3, 1), activation='relu', name='Conv2D_5'),
        layers.Flatten(),
        layers.Dense(4, activation='relu', name='Dense_6'),
        layers.Dropout(0.25),
        layers.Dense(1, activation='relu', name='Output_8')
    ])
    optimizer = tf.keras.optimizers.Adam()
    model.compile(loss='mse', optimizer=optimizer, metrics=['mae', 'mse'])
    return model
示例#14
0
def gen_avgpool2d_test(name, input_shape, kernels, strides, padding):
    # Create model.
    inp = layers.Input(name='input',
                       batch_size=input_shape[0],
                       shape=input_shape[1:])
    out = layers.AveragePooling2D(pool_size=kernels,
                                  strides=strides,
                                  padding=padding)(inp)
    model = Model(inputs=[inp], outputs=[out])
    # Create data.
    np.random.seed(0)
    inp_tensor = np.random.rand(*input_shape).astype(np.float32)
    out_tensor = model.predict(inp_tensor)
    # Save model.
    save_model(model, name)
    # Save data.
    save_tensor(inp_tensor, name + '.inp0')
    save_tensor(out_tensor, name + '.out0')
    # Clear session.
    keras_backend.clear_session()
示例#15
0
def transition_block(x, reduction, name):
    """A transition block.
    # Arguments
        x: input tensor.
        reduction: float, compression rate at transition layers.
        name: string, block label.
    # Returns
        output tensor for the block.
    """
    bn_axis = 3 if K.image_data_format() == 'channels_last' else 1
    x = layers.BatchNormalization(axis=bn_axis,
                                  epsilon=1.001e-5,
                                  name=name + '_bn')(x)
    x = layers.Activation('relu', name=name + '_relu')(x)
    x = layers.Conv2D(int(K.int_shape(x)[bn_axis] * reduction),
                      1,
                      use_bias=False,
                      name=name + '_conv')(x)
    x = layers.AveragePooling2D(2, strides=2, name=name + '_pool')(x)
    return x
示例#16
0
    def __init__(self,
                 pool_shape,
                 pool_type='max',
                 use_tf_crop_and_resize=True,
                 **kwargs):
        '''
        Implements ROI Pooling on multiple levels of the feature pyramid.

        Attributes
        ---
            pool_shape: (height, width) of the output pooled regions.
                Example: (7, 7)
        '''
        super(PyramidROIAlign, self).__init__(**kwargs)
        self.pre_pool_shape = tuple([2 * x for x in pool_shape])
        if pool_type == 'max':
            self._pool = layers.MaxPool2D(padding='same')
        elif pool_type == 'avg':
            self._pool = layers.AveragePooling2D(padding='same')
        self.use_tf_crop_and_resize = use_tf_crop_and_resize
示例#17
0
 def __init__(self):
     super(MobileNetV2, self).__init__()
     self.conv1 = layers.Conv2D(32, 3, 2, "same")
     self.bottleneck_1 = build_bottleneck(t=1,
                                          in_channel_num=32,
                                          out_channel_num=64,
                                          n=1,
                                          s=1)
     self.bottleneck_2 = build_bottleneck(6, 16, 24, 2, 2)
     self.bottleneck_3 = build_bottleneck(t=6,
                                          in_channel_num=24,
                                          out_channel_num=32,
                                          n=3,
                                          s=2)
     self.bottleneck_4 = build_bottleneck(t=6,
                                          in_channel_num=32,
                                          out_channel_num=64,
                                          n=4,
                                          s=2)
     self.bottleneck_5 = build_bottleneck(t=6,
                                          in_channel_num=64,
                                          out_channel_num=96,
                                          n=3,
                                          s=1)
     self.bottleneck_6 = build_bottleneck(t=6,
                                          in_channel_num=96,
                                          out_channel_num=160,
                                          n=3,
                                          s=2)
     self.bottleneck_7 = build_bottleneck(t=6,
                                          in_channel_num=160,
                                          out_channel_num=320,
                                          n=1,
                                          s=1)
     self.conv2 = layers.Conv2D(1280, 1, 1, "same")
     self.avgpool = layers.AveragePooling2D((7, 7))
     self.conv3 = layers.Conv2D(NUM_CLASSES,
                                1,
                                1,
                                "same",
                                activation=tf.keras.activations.softmax)
示例#18
0
    def __init__(self,
                 dropout_rate=0.0,
                 in_channels=3,
                 in_size=(299, 299),
                 classes=1000,
                 data_format="channels_last",
                 **kwargs):
        super(InceptionV4, self).__init__(**kwargs)
        self.in_size = in_size
        self.classes = classes
        self.data_format = data_format
        layers = [4, 8, 4]
        normal_units = [InceptionAUnit, InceptionBUnit, InceptionCUnit]
        reduction_units = [ReductionAUnit, ReductionBUnit]

        self.features = tf.keras.Sequential(name="features")
        self.features.add(
            InceptInitBlock(in_channels=in_channels,
                            data_format=data_format,
                            name="init_block"))

        for i, layers_per_stage in enumerate(layers):
            stage = tf.keras.Sequential(name="stage{}".format(i + 1))
            for j in range(layers_per_stage):
                if (j == 0) and (i != 0):
                    unit = reduction_units[i - 1]
                else:
                    unit = normal_units[i]
                stage.add(
                    unit(data_format=data_format, name="unit{}".format(j + 1)))
            self.features.add(stage)
        self.features.add(
            nn.AveragePooling2D(pool_size=8,
                                strides=1,
                                data_format=data_format,
                                name="final_pool"))

        self.output1 = tf.keras.Sequential(name="output1")
        if dropout_rate > 0.0:
            self.output1.add(nn.Dropout(rate=dropout_rate, name="dropout"))
        self.output1.add(nn.Dense(units=classes, input_dim=1536, name="fc"))
示例#19
0
    def __init__(self, classes, width_multiplier=1):
        super(MobileNetV2, self).__init__()
        a = width_multiplier
        self.classes = classes
        self.m_layers = LayerList()

        # convolucion inicial
        l = basic_conv_block(int(a * 32), (3, 3),
                             stride=2,
                             dropout=0.25,
                             activation="ReLU6",
                             name="layer_0")
        self.m_layers.add(l)

        # los bloques de bottleneck intermedios
        self.crearBloques(32, 1, a * 16, 1, 1)
        self.crearBloques(16, 6, a * 24, 2, 2)
        self.crearBloques(24, 6, a * 32, 3, 2)
        self.crearBloques(32, 6, a * 64, 4, 2)
        self.crearBloques(69, 6, a * 96, 3, 1)
        self.crearBloques(96, 6, a * 160, 3, 2)
        self.crearBloques(160, 6, a * 320, 1, 1)

        # ultima convolucion
        l = pwise_conv_block(int(a * 1280),
                             dropout=0.25,
                             activation="ReLU6",
                             name="layer_{}_conv1x1".format(len(
                                 self.m_layers)))
        self.m_layers.add(l)

        # Average Pooling y Fully Connected
        self.m_layers.add(layers.AveragePooling2D(pool_size=(7, 7),
                                                  strides=(1, 1)),
                          training_arg=False)
        self.m_layers.add(layers.Flatten(), training_arg=False)
        self.m_layers.add(layers.Dense(1280))
        self.m_layers.add(layers.Dropout(0.5, name="dropout"),
                          only_training=True)
        self.m_layers.add(layers.Dense(classes))
        self.m_layers.add(layers.Activation("softmax"))
示例#20
0
    def __init__(self,
                 filters,
                 kernel_size,
                 strides,
                 pool_size=(2, 2),
                 activation='relu',
                 *args,
                 **kwargs
                 ):
        super(ConvLayer, self).__init__(*args, **kwargs)

        self.batch_norm = layers.BatchNormalization()

        self.conv_1 = layers.Conv2D(
            filters=filters,
            kernel_size=kernel_size,
            strides=strides,
            activation=activation,
            padding='same',
        )

        self.conv_2 = layers.Conv2D(
            filters=filters,
            kernel_size=kernel_size,
            strides=strides,
            activation=activation,
            padding='same',
        )

        self.conv_3 = layers.Conv2D(
            filters=filters,
            kernel_size=kernel_size,
            strides=strides,
            activation='relu',
            padding='same',
        )

        self.avg_pool = layers.AveragePooling2D(
            pool_size=pool_size,
            padding='same',
        )
示例#21
0
def inception_v4_b(input_tensor):
    """
    b block for inception v4
    Args:
        input_tensor (keras tensor): input tensor
    Returns: keras tensor
    """
    avgpool = layers.AveragePooling2D(strides=1, padding='same')(input_tensor)
    conv_pool = layers.Conv2D(128, 1, 1, padding='same')(avgpool)
    conv_pool = layers.BatchNormalization()(conv_pool)
    conv_pool = layers.ReLU()(conv_pool)
    conv1 = layers.Conv2D(384, 1, 1, padding='same')(input_tensor)
    conv1 = layers.BatchNormalization()(conv1)
    conv1 = layers.ReLU()(conv1)
    conv2 = layers.Conv2D(192, 1, 1, padding='same')(input_tensor)
    conv2 = layers.BatchNormalization()(conv2)
    conv2 = layers.ReLU()(conv2)
    conv2 = layers.Conv2D(224, (1, 7), 1, padding='same')(conv2)
    conv2 = layers.BatchNormalization()(conv2)
    conv2 = layers.ReLU()(conv2)
    conv2 = layers.Conv2D(256, (1, 7), 1, padding='same')(conv2)
    conv2 = layers.BatchNormalization()(conv2)
    conv2 = layers.ReLU()(conv2)
    conv3 = layers.Conv2D(192, 1, 1, padding='same')(input_tensor)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    conv3 = layers.Conv2D(192, (1, 7), 1, padding='same')(conv3)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    conv3 = layers.Conv2D(224, (7, 1), 1, padding='same')(conv3)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    conv3 = layers.Conv2D(224, (1, 7), 1, padding='same')(conv3)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    conv3 = layers.Conv2D(256, (7, 1), 1, padding='same')(conv3)
    conv3 = layers.BatchNormalization()(conv3)
    conv3 = layers.ReLU()(conv3)
    concat = layers.Concatenate()([conv_pool, conv1, conv2, conv3])

    return concat
def pyramidnet_cifar(inputs_shape,
                     depth,
                     alpha,
                     num_classes,
                     bottleneck=False):
    if bottleneck:
        n = int((depth - 2) / 9)
        block = bottle_neck
    else:
        n = int((depth - 2) / 6)
        block = basic_block
    addrate = alpha / 3 / n
    inputs = layers.Input(shape=inputs_shape)
    x = layers.Conv2D(filters=16,
                      kernel_size=3,
                      padding="same",
                      use_bias=False)(inputs)
    x = layers.BatchNormalization()(x)
    x, featuremap_dim = make_group(x,
                                   16,
                                   addrate=addrate,
                                   block=block,
                                   block_depth=n)
    x, featuremap_dim = make_group(x,
                                   featuremap_dim,
                                   addrate=addrate,
                                   block=block,
                                   block_depth=n,
                                   stride=2)
    x, featuremap_dim = make_group(x,
                                   featuremap_dim,
                                   addrate=addrate,
                                   block=block,
                                   block_depth=n,
                                   stride=2)
    x = layers.BatchNormalization()(x)
    x = layers.ReLU()(x)
    x = layers.AveragePooling2D(8)(x)
    x = layers.Flatten()(x)
    x = layers.Dense(num_classes)(x)
    return tf.keras.Model(inputs=inputs, outputs=x)
示例#23
0
def resnet(input_shape, depth):

    num_classes = 2
    if (depth - 2) % 6 != 0:
        raise ValueError('depth should be 6n+2 (eg 20, 32, 44 in [a])')

    num_filters = 16
    num_res_blocks = int((depth - 2) / 6)

    inputs = layers.Input(shape=input_shape)
    x = resnet_layer(inputs=inputs)
    for stack in range(3):
        for res_block in range(num_res_blocks):
            strides = 1
            if stack > 0 and res_block == 0:
                strides = 2
            y = resnet_layer(inputs=x,
                             num_filters=num_filters,
                             strides=strides)
            y = resnet_layer(inputs=y,
                             num_filters=num_filters,
                             activation=None)
            if stack > 0 and res_block == 0:
                x = resnet_layer(inputs=x,
                                 num_filters=num_filters,
                                 kernel_size=1,
                                 strides=strides,
                                 activation=None,
                                 batch_normalization=False)
            x = layers.add([x, y])
            x = layers.Activation('relu')(x)
        num_filters *= 2

    x = layers.AveragePooling2D(pool_size=8)(x)
    y = layers.Flatten()(x)
    outputs = layers.Dense(num_classes,
                           activation='softmax',
                           kernel_initializer='he_normal')(y)

    model = models.Model(inputs=inputs, outputs=outputs)
    return model
示例#24
0
    def inception_c(self, x):
        branch1 = layers.AveragePooling2D(pool_size=(3, 3),
                                          strides=1,
                                          padding='same')(x)

        branch2 = self.conv2d_bn(x, 256, (1, 1))

        branch3 = self.conv2d_bn(x, 384, (1, 1))
        branch31 = self.conv2d_bn(branch3, 256, (1, 3))
        branch32 = self.conv2d_bn(branch3, 256, (3, 1))
        branch3 = layers.concatenate([branch31, branch32], axis=3)

        branch4 = self.conv2d_bn(x, 384, 1)
        branch4 = self.conv2d_bn(branch4, 448, (1, 3))
        branch4 = self.conv2d_bn(branch4, 512, (3, 1))
        branch41 = self.conv2d_bn(branch4, 256, (3, 1))
        branch42 = self.conv2d_bn(branch4, 256, (1, 3))
        branch4 = layers.concatenate([branch41, branch42], axis=3)

        x = layers.concatenate([branch1, branch2, branch3, branch4], axis=3)
        return x
示例#25
0
def conv2d_stats_block(input_layer, cropping, stats_block):
    x = layers.Cropping2D(cropping, name='crop_' + stats_block)(input_layer)
    x = layers.Conv2D(8, (5, 5), (2, 2), name='conv2d_' + stats_block)(x)
    x = layers.BatchNormalization(name='batchnorm_' + stats_block)(x)
    x = layers.MaxPool2D((2, 2))(x)

    x = convolutional_block(x, 3, [8, 8, 16], 2, stats_block + '_a', s=1)
    x = identity_block(x, 3, [8, 8, 16], 2, stats_block + '_b')
    x = identity_block(x, 3, [8, 8, 16], 2, stats_block + '_c')

    x = convolutional_block(x, 3, [16, 16, 32], 3, stats_block + '_a', s=2)
    x = identity_block(x, 3, [16, 16, 32], 3, stats_block + '_b')
    x = identity_block(x, 3, [16, 16, 32], 3, stats_block + '_c')
    x = identity_block(x, 3, [16, 16, 32], 3, stats_block + '_d')

    x = convolutional_block(x, 3, [32, 32, 64], 4, stats_block + '_a', s=2)
    x = identity_block(x, 3, [32, 32, 64], 4, stats_block + '_b')
    x = identity_block(x, 3, [32, 32, 64], 4, stats_block + '_c')
    x = identity_block(x, 3, [32, 32, 64], 4, stats_block + '_d')

    return layers.AveragePooling2D((3, 3))(x)
示例#26
0
def build_D(fade_in_alpha, mbstd_group_size=4, initial_resolution=2, target_resolution=10, num_channels=3):
    model_list = list()
    disc_block_list = list()
    for res in range(initial_resolution, target_resolution + 1):
        x0 = layers.Input(shape=(2**res, 2**res, num_channels))
        curr_from_rgb = fromrgb(res, num_channels)
        curr_D_block = block_D(res, initial_resolution, mbstd_group_size)
        x = curr_from_rgb(x0)
        x = curr_D_block(x)
        if res > initial_resolution:
            x_ds = layers.AveragePooling2D(name="downsample_%dx%d" % (2**res, 2**res))(x0)
            x_ds = prev_from_rgb(x_ds)
            x = FadeIn(fade_in_alpha=fade_in_alpha, name="fade_in_%dx%d" % (2**res, 2**res))([x_ds, x])
            for prev_d in disc_block_list[::-1]:
                x = prev_d(x)
        disc_block_list.append(curr_D_block)
        prev_from_rgb = curr_from_rgb
        mdl = Model(inputs=x0, outputs=x)
        model_list.append(mdl)

    return model_list
示例#27
0
def d_block(x, n_filters, pool=True, use_bias=True, bn=L.Layer, act=L.ReLU):

    skip = L.Conv2D(n_filters, kernel_size=1, use_bias=use_bias, **common)(x)
    skip = bn()(skip)

    x = L.Conv2D(n_filters, kernel_size=3, use_bias=use_bias, **common)(x)
    x = bn()(x)
    x = act()(x)
    x = L.Conv2D(n_filters, kernel_size=3, use_bias=use_bias, **common)(x)
    x = bn()(x)
    x = act()(x)
    x = L.Conv2D(n_filters, kernel_size=1, **common)(x)

    x = L.Add()([x, skip])
    x = bn()(x)
    x = act()(x)

    if pool:
        x = L.AveragePooling2D()(x)

    return x
示例#28
0
def google_net(width, height):
    normalizationEpsilon = 1e-6
    input = layers.Input(shape=(width, height, 3))
    conv_7x7_2_1 = layers.Conv2D(64, (7, 7),
                                 activation='relu',
                                 strides=2,
                                 padding='same')(input)
    max_3x3_2_1 = layers.MaxPooling2D((3, 3), strides=2,
                                      padding='same')(conv_7x7_2_1)
    norm_1 = layers.LayerNormalization(
        epsilon=normalizationEpsilon)(max_3x3_2_1)
    conv_1x1_1_2 = layers.Conv2D(64, (1, 1), activation='relu')(norm_1)
    conv_3x3_1_2 = layers.Conv2D(192, (3, 3),
                                 activation='relu',
                                 padding='same')(conv_1x1_1_2)
    norm_2 = layers.LayerNormalization(
        epsilon=normalizationEpsilon)(conv_3x3_1_2)
    max_3x3_2_2 = layers.MaxPooling2D((3, 3), strides=2,
                                      padding='same')(norm_2)
    inc_3a = getInception(64, 96, 128, 16, 32, 32, max_3x3_2_2)
    inc_3b = getInception(128, 128, 192, 32, 96, 64, inc_3a)
    max_3x3_2_3 = layers.MaxPooling2D((3, 3), strides=2,
                                      padding='same')(inc_3b)
    inc_4a = getInception(192, 96, 208, 16, 48, 64, max_3x3_2_3)
    inc_4b = getInception(160, 112, 224, 24, 64, 64, inc_4a)
    inc_4c = getInception(128, 128, 256, 24, 64, 64, inc_4b)
    inc_4d = getInception(112, 144, 288, 32, 64, 64, inc_4c)
    inc_4e = getInception(256, 160, 320, 32, 128, 128, inc_4d)
    max_3x3_2_4 = layers.MaxPooling2D((3, 3), strides=2,
                                      padding='same')(inc_4e)
    inc_5a = getInception(256, 160, 320, 32, 128, 128, max_3x3_2_4)
    inc_5b = getInception(384, 192, 384, 48, 128, 128, inc_5a)
    avg_6 = layers.AveragePooling2D((7, 7), padding='same')(inc_5b)
    dropout_6 = layers.Dropout(0.4)(max_3x3_2_1)
    flatten = layers.Flatten()(dropout_6)
    fc_6 = layers.Dense(1000, activation='relu')(flatten)
    dropout_7 = layers.Dropout(0.4)(fc_6)
    fc_7 = layers.Dense(10, activation='softmax')(dropout_7)
    model = tf.keras.Model(inputs=input, outputs=fc_7, name='google_net')
    return model
示例#29
0
    def __init__(self, nc):
        super(Inception, self).__init__()
        self.conv7x7 = layers.Conv2D(64,
                                     kernel_size=7,
                                     strides=2,
                                     padding="same",
                                     activation="relu")
        self.maxPooling3x3 = layers.MaxPool2D(pool_size=3,
                                              strides=2,
                                              padding="same")
        self.batchNormal1 = layers.BatchNormalization()
        self.conv1x1 = layers.Conv2D(64,
                                     kernel_size=1,
                                     strides=1,
                                     padding="same",
                                     activation="relu")
        self.conv3x3 = layers.Conv2D(192,
                                     kernel_size=3,
                                     strides=1,
                                     padding="same",
                                     activation="relu")
        self.batchNormal2 = layers.BatchNormalization()

        self.inception3a = InceptionBlock([64, 96, 128, 16, 32, 32])
        self.inception3b = InceptionBlock([128, 128, 192, 32, 96, 64])

        self.inception4a = InceptionBlock([192, 96, 208, 16, 48, 64])
        self.inception4b = InceptionBlock([160, 112, 224, 24, 64, 64])
        self.inception4c = InceptionBlock([128, 128, 256, 24, 64, 64])
        self.inception4d = InceptionBlock([112, 144, 288, 32, 64, 64])
        self.inception4e = InceptionBlock([256, 160, 320, 32, 128, 128])

        self.inception5a = InceptionBlock([256, 160, 320, 32, 128, 128])
        self.inception5b = InceptionBlock([384, 192, 384, 48, 128, 128])

        self.averagePooling = layers.AveragePooling2D(pool_size=7, strides=1)
        self.fc = layers.Dense(nc)

        self.classifier1 = Classifier(nc)
        self.classifier2 = Classifier(nc)
示例#30
0
 def __init__(self):
     super(InceptionBlockB, self).__init__()
     self.b1_pool = layers.AveragePooling2D((3, 3), 1, "same")
     self.b1_conv = BasicConv2D(128, (1, 1), 1, "same")
     self.b2_conv = BasicConv2D(filters=384,
                                kernel_size=(1, 1),
                                strides=1,
                                padding="same")
     self.b3_conv1 = BasicConv2D(filters=192,
                                 kernel_size=(1, 1),
                                 strides=1,
                                 padding="same")
     self.b3_conv2 = BasicConv2D(filters=224,
                                 kernel_size=(1, 7),
                                 strides=1,
                                 padding="same")
     self.b3_conv3 = BasicConv2D(filters=256,
                                 kernel_size=(1, 7),
                                 strides=1,
                                 padding="same")
     self.b4_conv1 = BasicConv2D(filters=192,
                                 kernel_size=(1, 1),
                                 strides=1,
                                 padding="same")
     self.b4_conv2 = BasicConv2D(filters=192,
                                 kernel_size=(1, 7),
                                 strides=1,
                                 padding="same")
     self.b4_conv3 = BasicConv2D(filters=224,
                                 kernel_size=(7, 1),
                                 strides=1,
                                 padding="same")
     self.b4_conv4 = BasicConv2D(filters=224,
                                 kernel_size=(1, 7),
                                 strides=1,
                                 padding="same")
     self.b4_conv5 = BasicConv2D(filters=256,
                                 kernel_size=(7, 1),
                                 strides=1,
                                 padding="same")