Models:
Catherine Stones
cathy-stones/
DUCK-Net
0
Downloads: 0
[541a77]: / CustomLayers / ConvBlock2D.py

Download this file

126 lines (80 with data), 4.3 kB 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
from keras.layers import BatchNormalizationV2, add

from keras.layers import Conv2D



kernel_initializer = 'he_uniform'





def conv_block_2D(x, filters, block_type, repeat=1, dilation_rate=1, size=3, padding='same'):

    result = x



    for i in range(0, repeat):



        if block_type == 'separated':

            result = separated_conv2D_block(result, filters, size=size, padding=padding)

        elif block_type == 'duckv2':

            result = duckv2_conv2D_block(result, filters, size=size)

        elif block_type == 'midscope':

            result = midscope_conv2D_block(result, filters)

        elif block_type == 'widescope':

            result = widescope_conv2D_block(result, filters)

        elif block_type == 'resnet':

            result = resnet_conv2D_block(result, filters, dilation_rate)

        elif block_type == 'conv':

            result = Conv2D(filters, (size, size),

                            activation='relu', kernel_initializer=kernel_initializer, padding=padding)(result)

        elif block_type == 'double_convolution':

            result = double_convolution_with_batch_normalization(result, filters, dilation_rate)



        else:

            return None



    return result





def duckv2_conv2D_block(x, filters, size):

    x = BatchNormalizationV2(axis=-1)(x)

    x1 = widescope_conv2D_block(x, filters)



    x2 = midscope_conv2D_block(x, filters)



    x3 = conv_block_2D(x, filters, 'resnet', repeat=1)



    x4 = conv_block_2D(x, filters, 'resnet', repeat=2)



    x5 = conv_block_2D(x, filters, 'resnet', repeat=3)



    x6 = separated_conv2D_block(x, filters, size=6, padding='same')



    x = add([x1, x2, x3, x4, x5, x6])



    x = BatchNormalizationV2(axis=-1)(x)



    return x





def separated_conv2D_block(x, filters, size=3, padding='same'):

    x = Conv2D(filters, (1, size), activation='relu', kernel_initializer=kernel_initializer, padding=padding)(x)



    x = BatchNormalizationV2(axis=-1)(x)



    x = Conv2D(filters, (size, 1), activation='relu', kernel_initializer=kernel_initializer, padding=padding)(x)



    x = BatchNormalizationV2(axis=-1)(x)



    return x





def midscope_conv2D_block(x, filters):

    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=1)(x)



    x = BatchNormalizationV2(axis=-1)(x)



    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=2)(x)



    x = BatchNormalizationV2(axis=-1)(x)



    return x





def widescope_conv2D_block(x, filters):

    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=1)(x)



    x = BatchNormalizationV2(axis=-1)(x)



    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=2)(x)



    x = BatchNormalizationV2(axis=-1)(x)



    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=3)(x)



    x = BatchNormalizationV2(axis=-1)(x)



    return x





def resnet_conv2D_block(x, filters, dilation_rate=1):

    x1 = Conv2D(filters, (1, 1), activation='relu', kernel_initializer=kernel_initializer, padding='same',

                dilation_rate=dilation_rate)(x)



    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=dilation_rate)(x)

    x = BatchNormalizationV2(axis=-1)(x)

    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=dilation_rate)(x)

    x = BatchNormalizationV2(axis=-1)(x)

    x_final = add([x, x1])



    x_final = BatchNormalizationV2(axis=-1)(x_final)



    return x_final





def double_convolution_with_batch_normalization(x, filters, dilation_rate=1):

    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=dilation_rate)(x)

    x = BatchNormalizationV2(axis=-1)(x)

    x = Conv2D(filters, (3, 3), activation='relu', kernel_initializer=kernel_initializer, padding='same',

               dilation_rate=dilation_rate)(x)

    x = BatchNormalizationV2(axis=-1)(x)



    return x