def residual_block(x, **metaparameters): """ Construct a Residual Block x : input to the block n_filters: number of filters in convolution layer in residual block """ if 'n_filters' in metaparameters: n_filters = metaparameters['n_filters'] del metaparameters['n_filters'] else: n_filters = DenseNet.n_filters # Remember input tensor into residual block shortcut = x # BN-RE-Conv pre-activation form of convolutions # Dimensionality expansion, expand filters by 4 (DenseNet-B) x = BatchNormalization()(x) x = Composable.ReLU(x) x = Composable.Conv2D(x, 4 * n_filters, (1, 1), strides=(1, 1), use_bias=False, **metaparameters) # Bottleneck convolution # 3x3 convolution with padding=same to preserve same shape of feature maps x = BatchNormalization()(x) x = Composable.ReLU(x) x = Composable.Conv2D(x, n_filters, (3, 3), strides=(1, 1), padding='same', use_bias=False, **metaparameters) # Concatenate the input (identity) with the output of the residual block # Concatenation (vs. merging) provides Feature Reuse between layers x = Concatenate()([shortcut, x]) return x
def __init__(self, groups=None , input_shape=(32, 32, 3), include_top=True, **hyperparameters): """ Construct a Wids Residual (Convolutional Neural) Network groups : metaparameter for group configuration input_shape : input shape include_top : include the reconstruction component initializer : kernel initialization regularizer : kernel regularization relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether use bias in conjunction with batch norm """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) if groups is None: groups = self.groups # The input tensor inputs = Input(input_shape) # The stem convolutional group x = self.stem(inputs) # The learner outputs = self.learner(x, groups) # The reconstruction if include_top: outputs = self.decoder(outputs) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, input_shape=(32, 32, 3), include_top=True, f1 = 9, f2=1, f3=5, **hyperparameters): """ Construct a Wids Residual (Convolutional Neural) Network f1, f2, f3 : number of filters for convolutional layers n1, n2 and n3 input_shape : input shape include_top : include the reconstruction component initializer : kernel initialization regularizer : kernel regularization relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether use bias in conjunction with batch norm """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # The input tensor inputs = Input(input_shape) # The stem convolutional group x = self.stem(inputs, f1) # The encoder outputs = self.encoder(x, f2) # The reconstruction if include_top: outputs = self.reconstruction(outputs, f3) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, dropout=0.4, input_shape=(229, 229, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct an Inception V3 convolutional neural network dropout : percentage of dropout rate input_shape : the input to the model n_classes : number of output classes include_top : whether to include the classifier initializer : kernel initiaklizer regularizer : kernel regularizer relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to use bias """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # The input tensor (299x299 in V3 vs 224x224 in V1/V2) inputs = Input(shape=input_shape) # The stem convolutional group x = self.stem(inputs) # The learner outputs, aux = self.learner(x, n_classes) # The classifier if include_top: outputs = self.classifier(outputs, n_classes, dropout) # Instantiate the Model self._model = Model(inputs, [outputs] + aux)
def decoder(x, init_weights=None, **metaparameters): ''' Construct the Decoder x : input to the decoder layers: number of filters per layer reg : kernel regularizer ''' layers = metaparameters['layers'] if 'reg' in metaparameters: reg = metaparameters['reg'] else: reg = AutoEncoder.reg if 'init_weights' in metaparameters: init_weights = metaparameters['init_weights'] else: init_weights = AutoEncoder.init_weights # Progressive Feature Unpooling for _ in range(len(layers)-1, 0, -1): n_filters = layers[_]['n_filters'] x = Conv2DTranspose(n_filters, (3, 3), strides=2, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(x) x = BatchNormalization()(x) x = Composable.ReLU(x) # Last unpooling and match shape to input x = Conv2DTranspose(3, (3, 3), strides=2, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(x) x = BatchNormalization()(x) x = Composable.ReLU(x) # The decoded image return x
def __init__(self, layers=None, input_shape=(32, 32, 3), **hyperparameters): ''' Construct an AutoEncoder input_shape : input shape to the autoencoder layers : the number of filters per layer initializer : kernel initializer regularizer : kernel regularizer relu_clip : clip value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to use bias ''' # Configure base (super) class Composable.__init__(self, input_shape, None, self.hyperparameters, **hyperparameters) if layers is None: layers = self.layers # remember the layers self.layers = layers # remember the input shape self.input_shape = input_shape inputs = Input(input_shape) encoder = self.encoder(inputs, layers=layers) outputs = self.decoder(encoder, layers=layers) self._model = Model(inputs, outputs)
def depthwise_block(x, strides, **metaparameters): """ Construct a Depthwise Separable Convolution block x : input to the block strides : strides n_filters : number of filters alpha : width multiplier """ n_filters = metaparameters['n_filters'] alpha = metaparameters['alpha'] del metaparameters['n_filters'] # Apply the width filter to the number of feature maps filters = int(n_filters * alpha) # Strided convolution to match number of filters if strides == (2, 2): x = ZeroPadding2D(padding=((0, 1), (0, 1)))(x) padding = 'valid' else: padding = 'same' # Depthwise Convolution x = Composable.DepthwiseConv2D(x, (3, 3), strides, padding=padding, use_bias=False, **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) # Pointwise Convolution x = Composable.Conv2D(x, filters, (1, 1), strides=(1, 1), padding='same', use_bias=False, **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) return x
def projection_block(x, **metaparameters): """ Create a residual block using Depthwise Separable Convolutions with Projection shortcut x : input into residual block n_filters: number of filters """ n_filters = metaparameters['n_filters'] del metaparameters['n_filters'] # Remember the input shortcut = x # Strided convolution to double number of filters in identity link to # match output of residual block for the add operation (projection shortcut) shortcut = Composable.Conv2D(x, n_filters, (1, 1), strides=(2, 2), padding='same', **metaparameters) shortcut = BatchNormalization()(shortcut) # First Depthwise Separable Convolution x = Composable.SeparableConv2D(x, n_filters, (3, 3), padding='same', **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) # Second depthwise Separable Convolution x = Composable.SeparableConv2D(x, n_filters, (3, 3), padding='same', **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) # Create pooled feature maps, reduce size by 75% x = MaxPooling2D((3, 3), strides=(2, 2), padding='same')(x) # Add the projection shortcut to the output of the block x = Add()([x, shortcut]) return x
def __init__(self, groups=None, dropout=0.5, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): ''' Construct a SqueezeNet Complex Bypass Convolution Neural Network groups : number of blocks/filters per group dropout : percent of dropoput input_shape : input shape to model n_classes : number of output classes include_top : whether to include classifier init_weights: kernel initializer reg : kernel regularizer relu : max value for ReLU bias : whether to use bias in conjunction with batch norm ''' Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) if groups is None: groups = list(SqueezeNetComplex.groups) # The input shape inputs = Input(shape=input_shape) # The Stem Group x = self.stem(inputs) # The Learner outputs = self.learner(x, groups=groups, dropout=dropout) # The Classifier if include_top: outputs = self.classifier(outputs, n_classes) self._model = Model(inputs, outputs)
def fire_block(x, **metaparameters): ''' Construct a Fire Block with complex bypass x : input to the block n_filters: number of filters in block reg : kernel regularizer ''' n_filters = metaparameters['n_filters'] if 'reg' in metaparameters: reg = metaparameters['reg'] else: reg = SqueezeNetComplex.reg if 'init_weights' in metaparameters: init_weights = metaparameters['init_weights'] else: init_weights = SqueezeNetComplex.init_weights # remember the input (identity) shortcut = x # if the number of input filters does not equal the number of output filters, then use # a transition convolution to match the number of filters in identify link to output if shortcut.shape[3] != 8 * n_filters: shortcut = Conv2D(n_filters * 8, (1, 1), strides=1, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(shortcut) shortcut = Composable.ReLU(shortcut) # squeeze layer squeeze = Conv2D(n_filters, (1, 1), strides=1, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(x) squeeze = Composable.ReLU(squeeze) # branch the squeeze layer into a 1x1 and 3x3 convolution and double the number # of filters expand1x1 = Conv2D(n_filters * 4, (1, 1), strides=1, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(squeeze) expand1x1 = Composable.ReLU(expand1x1) expand3x3 = Conv2D(n_filters * 4, (3, 3), strides=1, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(squeeze) expand3x3 = Composable.ReLU(expand3x3) # concatenate the feature maps from the 1x1 and 3x3 branches x = Concatenate()([expand1x1, expand3x3]) # if identity link, add (matrix addition) input filters to output filters if shortcut is not None: x = Add()([x, shortcut]) return x
def strided_shuffle_block(x, **metaparameters): ''' Construct a Strided Shuffle Block x : input to the block n_partitions: number of groups to partition feature maps (channels) into. n_filters : number of filters reduction : dimensionality reduction factor (e.g, 0.25) ''' n_partitions = metaparameters['n_partitions'] n_filters = metaparameters['n_filters'] reduction = metaparameters['reduction'] del metaparameters['n_filters'] del metaparameters['n_partitions'] if 'reg' in metaparameters: reg = metaparameters['reg'] else: reg = ShuffleNet.reg if 'init_weights' in metaparameters: init_weights = metaparameters['init_weights'] else: init_weights = ShuffleNet.init_weights # projection shortcut shortcut = x shortcut = AveragePooling2D((3, 3), strides=2, padding='same')(shortcut) # On entry block, we need to adjust the number of output filters # of the entry pointwise group convolution to match the exit # pointwise group convolution, by subtracting the number of input filters n_filters -= int(x.shape[3]) # pointwise group convolution, with dimensionality reduction x = ShuffleNet.pw_group_conv(x, n_partitions, int(reduction * n_filters), **metaparameters) x = Composable.ReLU(x) # channel shuffle layer x = ShuffleNet.channel_shuffle(x, n_partitions) # Depthwise 3x3 Strided Convolution x = DepthwiseConv2D((3, 3), strides=2, padding='same', use_bias=False, kernel_initializer=init_weights, kernel_regularizer=reg)(x) x = BatchNormalization()(x) # pointwise group convolution, with dimensionality restoration x = ShuffleNet.pw_group_conv(x, n_partitions, n_filters, **metaparameters) # Concatenate the projection shortcut to the output x = Concatenate()([shortcut, x]) x = Composable.ReLU(x) return x
def __init__(self, groups=None, alpha=1, pho=1, dropout=0.5, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Mobile Convolution Neural Network alpha : width multipler pho : resolution multiplier input_shape : the input shape n_classes : number of output classes include_top : whether to include classifier initializer : kernel initializer regularizer : kernel regularizer relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to include bias """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) if groups is None: groups = list(self.groups) if alpha < 0 or alpha > 1: raise Exception("MobileNet: alpha out of range") if pho < 0 or pho > 1: raise Exception("MobileNet: pho out of range") if dropout < 0 or dropout > 1: raise Exception("MobileNet: alpha out of range") inputs = Input(shape=(int(input_shape[0] * pho), int(input_shape[1] * pho), 3)) # The Stem Group x = self.stem(inputs, alpha=alpha) # The Learner outputs = self.learner(x, groups=groups, alpha=alpha) # The Classifier if include_top: outputs = self.classifier(outputs, n_classes, alpha=alpha, dropout=dropout) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, n_layers, cardinality=32, ratio=16, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Residual Next Convolution Neural Network n_layers : number of layers cardinality : width of group convolution ratio : amount of filter reduction in squeeze operation input_shape : the input shape n_classes : number of output classes include_top : whether to include classifier initializer : kernel initializer regularizer : kernel regularization relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to use bias with batchnorm """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # predefined if isinstance(n_layers, int): if n_layers not in [50, 101, 152]: raise Exception("SE-ResNeXt: Invalid value for n_layers") groups = list(self.groups[n_layers]) # user defined else: groups = n_layers # The input tensor inputs = Input(shape=input_shape) # The Stem Group x = self.stem(inputs) # The Learner outputs = self.learner(x, groups=groups, cardinality=cardinality, ratio=ratio) # The Classifier if include_top: # Add hidden dropout outputs = self.classifier(outputs, n_classes, dropout=0.0) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, n_layers, n_filters=32, reduction=0.5, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Densely Connected Convolution Neural Network n_layers : number of layers n_filters : number of filters (growth rate) reduction : anount to reduce feature maps by (compression factor) input_shape : input shape n_classes : number of output classes include_top : whether to include the classifier regularizer : kernel regularizer initializer : kernel initializer relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to use bias """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # predefined if isinstance(n_layers, int): if n_layers not in [121, 169, 201]: raise Exception("DenseNet: Invalid value for n_layers") groups = list(self.groups[n_layers]) # user defined else: groups = n_layers # The input vector inputs = Input(shape=input_shape) # The Stem Convolution Group x = self.stem(inputs, n_filters) # The Learner outputs = self.learner(x, n_filters=n_filters, reduction=reduction, groups=groups) # The Classifier if include_top: # Add hidden dropout layer outputs = self.classifier(outputs, n_classes, dropout=0.1) # Instantiate the model self._model = Model(inputs, outputs)
def fire_block(x, **metaparameters): ''' Construct a Fire Block x : input to the block n_filters: number of filters in the block bypass : whether block has an identity shortcut reg : kernel regularizer ''' n_filters = metaparameters['n_filters'] bypass = metaparameters['bypass'] if 'reg' in metaparameters: reg = metaparameters['reg'] else: reg = SqueezeNetBypass.reg if 'init_weights' in metaparameters: init_weights = metaparameters['init_weights'] else: init_weights = SqueezeNetBypass.init_weights # remember the input shortcut = x # squeeze layer squeeze = Conv2D(n_filters, (1, 1), strides=1, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(x) squeeze = Composable.ReLU(squeeze) # branch the squeeze layer into a 1x1 and 3x3 convolution and double the number # of filters expand1x1 = Conv2D(n_filters * 4, (1, 1), strides=1, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(squeeze) expand1x1 = Composable.ReLU(expand1x1) expand3x3 = Conv2D(n_filters * 4, (3, 3), strides=1, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(squeeze) expand3x3 = Composable.ReLU(expand3x3) # concatenate the feature maps from the 1x1 and 3x3 branches x = Concatenate()([expand1x1, expand3x3]) # if identity link, add (matrix addition) input filters to output filters if bypass: x = Add()([x, shortcut]) return x
def __init__(self, n_layers, stem={ 'n_filters': [32, 64], 'pooling': 'feature' }, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Jump Convolutional Neural Network n_layers : number of layers stem : number of filters in the stem convolutional stack input_shape : input shape n_classes : number of output classes include_top : whether to include classifier regulalizer : kernel regularizer relu_clip : max value for ReLU initializer : kernel initializer bn_epsilon : epsilon for batch norm use_bias : whether to use bias with batchnorm """ # Configure the base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # predefined if isinstance(n_layers, int): if n_layers not in [50, 101, 152]: raise Exception("JumpNet: Invalid value for n_layers") groups = list(self.groups[n_layers]) # user defined else: groups = n_layers # The input tensor inputs = Input(input_shape) # The stem convolutional group x = self.stem(inputs, stem=stem) # The learner outputs = self.learner(x, groups=groups) # The classifier # Add hidden dropout for training-time regularization if include_top: outputs = self.classifier(outputs, n_classes) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, groups=None, filters=None, n_partitions=2, reduction=0.25, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): ''' Construct a Shuffle Convolution Neural Network groups : number of shuffle blocks per shuffle group filters : filters per group based on partitions n_partitions: number of groups to partition the filters (channels) reduction : dimensionality reduction on entry to a shuffle block input_shape : the input shape to the model n_classes : number of output classes include_top : whether to include classifier initializer : kernel initializer regularizer : kernel regularizer relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to use bias in conjunction with batch norm ''' Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) if groups is None: groups = list(ShuffleNet.groups) if filters is None: filters = self.filters[n_partitions] # input tensor inputs = Input(shape=input_shape) # The Stem convolution group (referred to as Stage 1) x = self.stem(inputs) # The Learner outputs = self.learner(x, groups=groups, n_partitions=n_partitions, filters=filters, reduction=reduction) # The Classifier if include_top: # Add hidden dropout to classifier outputs = self.classifier(outputs, n_classes, dropout=0.0) self._model = Model(inputs, outputs)
def shuffle_block(x, **metaparameters): ''' Construct a shuffle Shuffle block x : input to the block n_partitions: number of groups to partition feature maps (channels) into. n_filters : number of filters reduction : dimensionality reduction factor (e.g, 0.25) reg : kernel regularizer ''' n_partitions = metaparameters['n_partitions'] n_filters = metaparameters['n_filters'] reduction = metaparameters['reduction'] del metaparameters['n_filters'] del metaparameters['n_partitions'] if 'reg' in metaparameters: reg = metaparameters['reg'] else: reg = ShuffleNet.reg if 'init_weights' in metaparameters: init_weights = metaparameters['init_weights'] else: init_weights = ShuffleNet.init_weights # identity shortcut shortcut = x # pointwise group convolution, with dimensionality reduction x = ShuffleNet.pw_group_conv(x, n_partitions, int(reduction * n_filters), **metaparameters) x = Composable.ReLU(x) # channel shuffle layer x = ShuffleNet.channel_shuffle(x, n_partitions) # Depthwise 3x3 Convolution x = Composable.DepthwiseConv2D(x, (3, 3), strides=1, padding='same', use_bias=False, **metaparameters) x = BatchNormalization()(x) # pointwise group convolution, with dimensionality restoration x = ShuffleNet.pw_group_conv(x, n_partitions, n_filters, **metaparameters) # Add the identity shortcut (input added to output) x = Add()([shortcut, x]) x = Composable.ReLU(x) return x
def auxiliary(x, n_classes, **metaparameters): """ Construct the auxiliary classier x : input to the auxiliary classifier n_classes: number of output classes """ x = AveragePooling2D((5, 5), strides=(3, 3))(x) x = Composable.Conv2D(x, 128, (1, 1), strides=(1, 1), padding='same', use_bias=False, **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) x = Flatten()(x) x = Composable.Dense(x, 1024, activation=Composable.ReLU, **metaparameters) x = Dropout(0.7)(x) output = Composable.Dense(x, n_classes, activation='softmax', **metaparameters) return output
def trans_block(x, **metaparameters): """ Construct a Transition Block x : input layer reduction: percentage of reduction of feature maps """ if 'reduction' in metaparameters: reduction = metaparameters['reduction'] else: reduction = DenseNet.reduction del metaparameters['n_filters'] # 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 # Use 1x1 linear projection convolution x = BatchNormalization()(x) x = Composable.Conv2D(x, n_filters, (1, 1), strides=(1, 1), use_bias=False, **metaparameters) # Use mean value (average) instead of max value sampling when pooling reduce by 75% x = AveragePooling2D((2, 2), strides=(2, 2))(x) return x
def stem(inputs): """ Create the stem entry into the neural network inputs : input tensor to neural network """ # Strided convolution - dimensionality reduction # Reduce feature maps by 75% x = Composable.Conv2D(inputs, 32, (3, 3), strides=(2, 2), **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) # Convolution - dimensionality expansion # Double the number of filters x = Composable.Conv2D(x, 64, (3, 3), strides=(1, 1), **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) return x
def classifier(self, x, n_classes): ''' Construct the Classifier x : input to the classifier n_classes: number of output classes ''' # Save the encoding layer self.encoding = x # set the number of filters equal to number of classes x = Conv2D(n_classes, (1, 1), strides=1, padding='same', kernel_initializer=self.init_weights, kernel_regularizer=self.reg)(x) x = Composable.ReLU(x) # reduce each filter (class) to a single value x = GlobalAveragePooling2D()(x) # Save the pre-activation probabilities layer self.probabilities = x outputs = Activation('softmax')(x) # Save the post-activation probabilities layer self.softmax = outputs return outputs
def stem(self, inputs): """ Construct the Stem Convolutional Group inputs : the input vector """ # The 224x224 images are zero padded (black - no signal) to be 230x230 images prior to the first convolution x = ZeroPadding2D(padding=(3, 3))(inputs) # First Convolutional layer which uses a large (coarse) filter x = self.Conv2D(x, 64, (7, 7), strides=(2, 2), padding='valid', use_bias=False) x = BatchNormalization()(x) x = self.ReLU(x) # Pooled feature maps will be reduced by 75% x = ZeroPadding2D(padding=(1, 1))(x) x = MaxPooling2D((3, 3), strides=(2, 2))(x) # Second Convolutional layer which uses a mid-size filter x = self.Conv2D(x, 64, (1, 1), strides=(1, 1), padding='same', use_bias=False) x = BatchNormalization()(x) x = Composable.ReLU(x) x = ZeroPadding2D(padding=(1, 1))(x) x = self.Conv2D(x, 192, (3, 3), strides=(1, 1), padding='valid', use_bias=False) x = BatchNormalization()(x) x = self.ReLU(x) # Pooled feature maps will be reduced by 75% x = ZeroPadding2D(padding=(1, 1))(x) x = MaxPooling2D((3, 3), strides=(2, 2))(x) return x
def encoder(x, init_weights=None, **metaparameters): ''' Construct the Encoder x : input to the encoder layers: number of filters per layer reg : kernel regularizer ''' layers = metaparameters['layers'] if 'reg' in metaparameters: reg = metaparameters['reg'] else: reg = AutoEncoder.reg if 'init_weights' in metaparameters: init_weights = metaparameters['init_weights'] else: init_weights = AutoEncoder.init_weights # Progressive Feature Pooling for layer in layers: n_filters = layer['n_filters'] x = Conv2D(n_filters, (3, 3), strides=2, padding='same', kernel_initializer=init_weights, kernel_regularizer=reg)(x) x = BatchNormalization()(x) x = Composable.ReLU(x) # The Encoding return x
def __init__(self, groups, alpha=1, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Mobile Convolution Neural Network V3 groups : number of filters and blocks per group alpha : width multiplier input_shape : the input shape n_classes : number of output classes include_top : whether to include classifier regularizer : kernel regularizer initializer : kernel initializer relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to use bias """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # Variable Binding self.GROUPS() # predefined if isinstance(groups, str): if groups not in ['large', 'small']: raise Exception("MobileNetV3: Invalid value for groups") groups = list(self.groups[groups]) inputs = Input(shape=input_shape) # The Stem Group x = self.stem(inputs, alpha=alpha) # The Learner outputs = self.learner(x, groups=groups, alpha=alpha) # The Classifier if include_top: outputs = self.classifier(outputs, n_classes) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, n_layers, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Residual Convolutional Neural Network V2 n_layers : number of layers input_shape : input shape n_classes : number of output classes include_top : whether to include classifier regularizer : kernel regularizer initializer : kernel initializer relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to include a bias with batchnorm """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # predefined if isinstance(n_layers, int): if n_layers not in [50, 101, 152]: raise Exception("ResNet: Invalid value for n_layers") groups = self.groups[n_layers] # user defined else: groups = n_layers # The input tensor inputs = Input(input_shape) # The stem convolutional group x = self.stem(inputs) # The learner outputs = self.learner(x, groups=groups) # The classifier if include_top: # Add hidden dropout for training-time regularization outputs = self.classifier(outputs, n_classes, dropout=0.0) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, groups=None, alpha=1, expansion=6, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Mobile Convolution Neural Network V2 groups : number of filters and blocks per group alpha : width multiplier expansion : multiplier to expand the number of filters input_shape : the input shape n_classes : number of output classes include_top : whether to include classifier regularizer : kernel regularizer initializer : kernel initializer relu_clip : max value for ReLU bn_epsilon : epsilon for batch norm use_bias : whether to use a bias """ # Configure base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) if groups is None: groups = list(self.groups) inputs = Input(shape=input_shape) # The Stem Group x = self.stem(inputs, alpha=alpha) # The Learner outputs = self.learner(x, groups=groups, alpha=alpha, expansion=expansion) # The Classifier # Add hidden dropout layer if include_top: outputs = self.classifier(outputs, n_classes, dropout=0.0) # Instantiate the Model self._model = Model(inputs, outputs)
def projection_block(x, **metaparameters): """ Construct a B(3,3) style block x : input into the block n_filters: number of filters k : width factor strides : whether the projection shortcut is strided """ n_filters = metaparameters['n_filters'] strides = metaparameters['strides'] k = metaparameters['k'] del metaparameters['n_filters'] del metaparameters['strides'] # Save input vector (feature maps) for the identity link shortcut = BatchNormalization()(x) shortcut = Composable.Conv2D(shortcut, n_filters * k, (3, 3), strides=strides, padding='same', use_bias=False, **metaparameters) ## Construct the 3x3, 3x3 convolution block x = BatchNormalization()(x) x = Composable.ReLU(x) x = Composable.Conv2D(x, n_filters * k, (3, 3), strides=strides, padding='same', use_bias=False, **metaparameters) x = BatchNormalization()(x) x = Composable.ReLU(x) x = Composable.Conv2D(x, n_filters * k, (3, 3), strides=(1, 1), padding='same', use_bias=False, **metaparameters) # Add the identity link (input) to the output of the residual block x = Add()([shortcut, x]) return x
def __init__(self, n_layers, ratio=16, input_shape=(224, 224, 3), n_classes=1000, include_top=True, **hyperparameters): """ Construct a Residual Convolutional Neural Network V1 n_layers : number of layers input_shape : input shape n_classes : number of output classes include_top : whether to include classifier reg : kernel regularizer init_weights: kernel initializer relu : max value for ReLU bias : whether to use bias for batchnorm """ Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # predefined if isinstance(n_layers, int): if n_layers not in [50, 101, 152]: raise Exception("SE-ResNet: Invalid value for n_layers") groups = list(self.groups[n_layers]) # user defined else: groups = n_layers # The input tensor inputs = Input(shape=input_shape) # The Stem Group x = self.stem(inputs) # The Learner outputs = self.learner(x, groups=groups, ratio=ratio) # The Classifier if include_top: # Add hidden dropout outputs = self.classifier(outputs, n_classes, dropout=0.0) # Instantiate the Model self._model = Model(inputs, outputs)
def __init__(self, n_layers, input_shape=(32, 32, 3), n_classes=10, include_top=True, **hyperparameters): """ Construct a Residual Convolutional Neural Network V1 n_layers : number of layers input_shape : input shape n_classes : number of output classes include_top : whether to include classifier regularizer : kernel regularizer relu_clip : max value for ReLU initializer : kernel initializer bn_epsilon : epsilon for batch norm use_bias : whether to use bias with batchnorm """ # Configure the base (super) class Composable.__init__(self, input_shape, include_top, self.hyperparameters, **hyperparameters) # depth if isinstance(n_layers, int): if n_layers not in [20, 32, 44, 56, 110, 164]: raise Exception("ResNet CIFAR: invalid value for n_layers") groups = list(self.groups[n_layers]) else: groups = n_layers # The input tensor inputs = Input(input_shape) # The stem convolutional group x = self.stem(inputs) # The learner outputs = self.learner(x, groups=groups) # The classifier if include_top: outputs = self.classifier(outputs, n_classes) # Instantiate the Model self._model = Model(inputs, outputs)