def build(self, input_shape): self.kernel = [] if self.conn_type == "S": # scale-only parameter self.kernel.append( self.add_weight("CrowdLayer", (1, self.num_annotators), initializer=Ones(), trainable=True)) elif self.conn_type == "B": # bias-only parameter self.kernel.append( self.add_weight("CrowdLayer", (1, self.num_annotators), initializer=Zeros(), trainable=True)) elif self.conn_type == "S+B" or self.conn_type == "B+S": # scale and bias parameters self.kernel.append( self.add_weight("CrowdLayer", (1, self.num_annotators), initializer=Ones(), trainable=True)) self.kernel.append( self.add_weight("CrowdLayer", (1, self.num_annotators), initializer=Zeros(), trainable=True)) else: raise Exception( "Unknown connection type for CrowdsRegression layer!") super(CrowdsRegression, self).build(input_shape) # Be sure to call this somewhere!
def get_generator_unet(n_block=3): input = Input(shape=(image_size, image_size, input_channel)) # encoder e0 = Conv2D(64, kernel_size=4, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(input) # use reflection padding instead e0 = BatchNormalization()(e0) e0 = Activation('relu')(e0) e1 = conv_block(e0, 128, downsample=True, dropout=False) # 1/2 e2 = conv_block(e1, 256, downsample=True, dropout=False) # 1/4 e3 = conv_block(e2, 512, downsample=True, dropout=False) # 1/8 e4 = conv_block(e3, 512, downsample=True, dropout=False) # 1/16 e5 = conv_block(e4, 512, downsample=True, dropout=False) # 1/32 e6 = conv_block(e5, 512, downsample=True, dropout=False) # 1/64 e7 = conv_block(e6, 512, downsample=True, dropout=False) # 1/128 # decoder d0 = conv_block(e7, 512, downsample=False, dropout=True) # 1/64 d1 = Concatenate(axis=-1)([d0, e6]) d1 = conv_block(d1, 512, downsample=False, dropout=True) # 1/32 d2 = Concatenate(axis=-1)([d1, e5]) d2 = conv_block(d2, 512, downsample=False, dropout=True) # 1/16 d3 = Concatenate(axis=-1)([d2, e4]) d3 = conv_block(d3, 512, downsample=False, dropout=True) # 1/8 d4 = Concatenate(axis=-1)([d3, e3]) d4 = conv_block(d4, 256, downsample=False, dropout=True) # 1/4 d5 = Concatenate(axis=-1)([d4, e2]) d5 = conv_block(d5, 128, downsample=False, dropout=True) # 1/2 d6 = Concatenate(axis=-1)([d5, e1]) d6 = conv_block(d6, 64, downsample=False, dropout=True) # 1 # out x = Conv2D(output_channel, kernel_size=3, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(d6) # use reflection padding instead x = BatchNormalization()(x) x = Activation('tanh')(x) generator = Model(inputs=input, outputs=x) return generator
def __init__(self, embed_dim, num_heads, ff_dim, dropout=0.1, prenorm=False, approximate_gelu=False): super(TransformerBlock, self).__init__() self.att = MultiHeadSelfAttention(embed_dim, num_heads) self.ffn = tf.keras.Sequential([ Dense(ff_dim, kernel_initializer=TruncatedNormal(mean=0., stddev=TRUNC_STD), bias_initializer=Zeros()), tfa.layers.GELU(approximate=approximate_gelu), Dense(embed_dim, kernel_initializer=TruncatedNormal(mean=0., stddev=TRUNC_STD), bias_initializer=Zeros()), ]) self.layernorm1 = LayerNormalization(epsilon=1e-6) self.layernorm2 = LayerNormalization(epsilon=1e-6) self.dropout1 = Dropout(dropout) self.dropout2 = Dropout(dropout) self.prenorm = prenorm
def get_generator(n_block=3): input = Input(shape=(image_size, image_size, input_channel)) x = Conv2D(64, kernel_size=7, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(input) # use reflection padding instead x = BatchNormalization()(x) x = Activation('relu')(x) # downsample x = Conv2D(128, kernel_size=3, strides=2, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) x = BatchNormalization()(x) x = Activation('relu')(x) # downsample x = Conv2D(256, kernel_size=3, strides=2, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) x = BatchNormalization()(x) x = Activation('relu')(x) for i in range(n_block): x = residual_block(x) # upsample x = Conv2DTranspose(128, kernel_size=3, strides=2, padding='same', kernel_initializer=RandomNormal(mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) x = BatchNormalization()(x) x = Activation('relu')(x) # upsample x = Conv2DTranspose(64, kernel_size=3, strides=2, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) x = BatchNormalization()(x) x = Activation('relu')(x) # out x = Conv2D(output_channel, kernel_size=7, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) # use reflection padding instead x = BatchNormalization()(x) x = Activation('tanh')(x) generator = Model(inputs=input, outputs=x) return generator
def conv_block(feature, out_channel, downsample=True, dropout=False): if downsample: x = Conv2D(out_channel, kernel_size=4, strides=2, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(feature) else: x = Conv2DTranspose(out_channel, kernel_size=4, strides=2, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(feature) x = BatchNormalization()(x) x = Activation('relu')(x) if dropout: x = Dropout(0.5)(x) return x
def residual_block(feature, dropout=False): x = Conv2D(256, kernel_size=3, strides=1, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(feature) x = BatchNormalization()(x) x = Activation('relu')(x) if dropout: x = Dropout(0.5)(x) x = Conv2D(256, kernel_size=3, strides=1, padding='same', kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) x = BatchNormalization()(x) x = Activation('relu')(x) return Add()([feature, x])
def build(self, input_shape): input_size = input_shape[-1] hidden_units = [int(input_size)] + list(self.hidden_units) self.kernels = [ self.add_weight(name='kernel' + str(i), shape=(hidden_units[i], hidden_units[i + 1]), initializer=glorot_normal(seed=self.seed), regularizer=l2(self.l2_reg), trainable=True) for i in range(len(self.hidden_units)) ] self.bias = [ self.add_weight(name='bias' + str(i), shape=(self.hidden_units[i], ), initializer=Zeros(), trainable=True) for i in range(len(self.hidden_units)) ] if self.use_bn: self.bn_layers = [ tf.keras.layers.BatchNormalization() for _ in range(len(self.hidden_units)) ] self.dropout_layers = [ tf.keras.layers.Dropout(self.dropout_rate, seed=self.seed + i) for i in range(len(self.hidden_units)) ] self.activation_layers = [ activation_layer(self.activation) for _ in range(len(self.hidden_units)) ] super(DNN, self).build(input_shape) # Be sure to call this somewhere!
def __init__( self, n_feat, n_hidden, out=1, name_idx=0, hidden_activation="sigmoid", output_activation="sigmoid", feat_weight_trainable=True, kernel_initializer=VarianceScaling(), bias_initializer=Zeros(), width=1., #Width of Softmin layer **kwargs): self.n_feat = n_feat self.n_hidden = n_hidden self.out = out self.name_idx = name_idx self.kernel_initializer = kernel_initializer self.bias_initializer = bias_initializer self.feat_weight_trainable = feat_weight_trainable self.hidden_activation = activations.get(hidden_activation) self.output_activation = activations.get(output_activation) self.width = width self.min_layer = Softmin(width=self.width) super(DenseAttentionwFeatWeights, self).__init__(**kwargs)
def score_block(inputs, conv_type, num_classes, name, l2_reg=0.): """ 1x1 Convolution applied in FCN8 to compute class scores at different levels of the network. Parameters: inputs: Input tensor conv_type: 'ds' for depthwise separable convolutions, in other case standard convolution operation num_classes: Number of classes to classify name: Name of the layer. 'score32' or 'score16' or 'score8' l2_reg: l2 regularizer value """ #He initialization if name == 'score32': in_channels = inputs.get_shape().as_list()[-1] stddev = (2 / in_channels)**.5 elif name == 'score16': stddev = 0.01 elif name == 'score8': stddev = .001 #w_initializer = TruncatedNormal(stddev=stddev) w_initializer = tf.keras.initializers.he_normal() b_initializer = Zeros() if conv_type == 'ds': x = SeparableConv2D(num_classes, 1, padding='same', strides=1, name=name, depthwise_initializer=w_initializer,\ pointwise_initializer=w_initializer, bias_initializer=b_initializer,\ pointwise_regularizer=l2(l2_reg), depthwise_regularizer=l2(l2_reg))(inputs) else: x = Conv2D(num_classes, (1,1), padding='same', strides = (1,1), name=name,\ kernel_initializer=w_initializer, bias_initializer=b_initializer, kernel_regularizer=l2(l2_reg))(inputs) return x
def build(self, input_shape): if not isinstance(input_shape, list) or len(input_shape) != 2: raise ValueError('A `LocalActivationUnit` layer should be called ' 'on a list of 2 inputs') if len(input_shape[0]) != 3 or len(input_shape[1]) != 3: raise ValueError("Unexpected inputs dimensions %d and %d, expect to be 3 dimensions" % ( len(input_shape[0]), len(input_shape[1]))) if input_shape[0][-1] != input_shape[1][-1] or input_shape[0][1] != 1: raise ValueError('A `LocalActivationUnit` layer requires ' 'inputs of a two inputs with shape (None,1,embedding_size) and (None,T,embedding_size)' 'Got different shapes: %s,%s' % (input_shape)) size = 4 * \ int(input_shape[0][-1] ) if len(self.hidden_units) == 0 else self.hidden_units[-1] self.kernel = self.add_weight(shape=(size, 1), initializer=glorot_normal( seed=self.seed), name="kernel") self.bias = self.add_weight( shape=(1,), initializer=Zeros(), name="bias") #self.dnn = DNN(self.hidden_units, self.activation, self.l2_reg, # self.dropout_rate, self.use_bn, seed=self.seed) super(LocalActivationUnit, self).build( input_shape) # Be sure to call this somewhere!
def _deconv(self, feature_map, f, k, s): """ The deconvolution operation to upsample the average feature map downstream f = # of filters from previous leaky layer (int) k = size of kernel from previous leaky layer s = amount of stride from previous leaky layer """ x = Input(shape=(None, None, 1)) y = Conv2DTranspose( filters=1, kernel_size=(3, 3), strides=(2, 2), padding='same', kernel_initializer=Ones(), # set all weights to 1 bias_initializer=Zeros() # set all biases to 0 )(x) deconv_model = Model(inputs=[x], outputs=[y]) inps = [deconv_model.input, K.learning_phase()] # input placeholder outs = [deconv_model.layers[-1].output] # output placeholder deconv_func = K.function(inps, outs) # evaluation function return deconv_func([feature_map, 0])[0]
def build(self, input_shape): super().build(input_shape) if self.use_bias: self.global_bias = self.add_weight( shape=(self.num_class,) if self.task == "multiclass" else (1,), initializer=Zeros(), name="global_bias")
def __init__(self, embed_dim, num_heads=8): super(MultiHeadSelfAttention, self).__init__() self.embed_dim = embed_dim self.num_heads = num_heads if embed_dim % num_heads != 0: raise ValueError( f"embedding dimension = {embed_dim} should be divisible by number of heads = {num_heads}" ) self.projection_dim = embed_dim // num_heads self.query_dense = Dense(embed_dim, kernel_initializer=TruncatedNormal( mean=0., stddev=TRUNC_STD), use_bias=False) self.key_dense = Dense(embed_dim, kernel_initializer=TruncatedNormal( mean=0., stddev=TRUNC_STD), use_bias=False) self.value_dense = Dense(embed_dim, kernel_initializer=TruncatedNormal( mean=0., stddev=TRUNC_STD), use_bias=False) self.combine_heads = Dense(embed_dim, kernel_initializer=TruncatedNormal( mean=0., stddev=TRUNC_STD), bias_initializer=Zeros())
def build(self, input_shape): if self.conn_type == "MW": # matrix of weights per annotator self.kernel = self.add_weight( "CrowdLayer", (self.output_dim, self.output_dim, self.num_annotators), initializer=init_identities, trainable=True) elif self.conn_type == "VW": # vector of weights (one scale per class) per annotator self.kernel = self.add_weight( "CrowdLayer", (self.output_dim, self.num_annotators), initializer=Ones(), trainable=True) elif self.conn_type == "VB": # two vectors of weights (one scale and one bias per class) per annotator self.kernel = [] self.kernel.append( self.add_weight("CrowdLayer", (self.output_dim, self.num_annotators), initializer=Zeros(), trainable=True)) elif self.conn_type == "VW+B": # two vectors of weights (one scale and one bias per class) per annotator self.kernel = [] self.kernel.append( self.add_weight("CrowdLayer", (self.output_dim, self.num_annotators), initializer=Ones(), trainable=True)) self.kernel.append( self.add_weight("CrowdLayer", (self.output_dim, self.num_annotators), initializer=Zeros(), trainable=True)) elif self.conn_type == "SW": # single weight value per annotator self.kernel = self.add_weight("CrowdLayer", (self.num_annotators, 1), initializer=Ones(), trainable=True) else: raise Exception( "Unknown connection type for CrowdsClassification layer!") super(CrowdsClassification, self).build(input_shape) # Be sure to call this somewhere!
def __init__(self, n_attention, n_attention_hidden, n_attention_out, n_feat, n_hidden, activation="sigmoid", concat_activity_regularizer=None, kernel_initializer=VarianceScaling(distribution="uniform"), kernel_regularizer='l1', bias_initializer=Zeros(), bias_regularizer='l1', attention_initializer=VarianceScaling(distribution="uniform"), attention_hidden_activation="sigmoid", attention_output_activation="sigmoid", attention_trainable=True, batch_norm_kwargs={}, **kwargs): self.n_attention = n_attention self.n_attention_hidden = n_attention_hidden self.n_attention_out = n_attention_out self.n_feat = n_feat self.n_hidden = n_hidden self.activation = activations.get(activation) self.concat_activity_regularizer = concat_activity_regularizer self.kernel_initializer = kernel_initializer self.kernel_regularizer = kernel_regularizer self.bias_initializer = bias_initializer self.bias_regularizer = bias_regularizer self.attention_initializer = attention_initializer self.attention_hidden_activation = attention_hidden_activation self.attention_output_activation = attention_output_activation self.attention_trainable = attention_trainable self.batch_norm_kwargs = batch_norm_kwargs self.attention_layers = [] for i in range(self.n_attention): attention_layer = DenseAttention( n_feat=self.n_feat, n_hidden=self.n_attention_hidden, out=self.n_attention_out, hidden_activation=self.attention_hidden_activation, output_activation=self.attention_output_activation, kernel_initializer=self.attention_initializer, trainable=self.attention_trainable) self.attention_layers.append(attention_layer) self.concat_layer = Concatenate( activity_regularizer=self.concat_activity_regularizer) #Current (v3): Use Dense layer and batch normalization self.dense_layer = Dense( self.n_hidden, activation=None, #Batch normalization before activation kernel_initializer=self.kernel_initializer, bias_initializer=self.bias_initializer, kernel_regularizer=self.kernel_regularizer, bias_regularizer=self.bias_regularizer, ) self.batch_norm_layer = BatchNormalization(**batch_norm_kwargs) super(ConcatAttentions, self).__init__(**kwargs)
def build(self, input_shape): if self.use_bias: self.global_bias = self.add_weight( shape=(1,), initializer=Zeros(), name="global_bias") # Be sure to call this somewhere! super(PredictionLayer, self).build(input_shape)
def build(self, input_shape): self._g = self.add_weight(name='gain', shape=(input_shape[-1], ), initializer=Ones(), trainable=True) self._b = self.add_weight(name='bias', shape=(input_shape[-1], ), initializer=Zeros(), trainable=True)
def __init__(self): """ Initialize multi-layer neural network """ self.model = Sequential() self.loss = None self.metric = [] self.optimizer = None self.initilizer = Zeros()
def build(self, input_shape): self.gamma = self.add_weight(name='gamma', shape=input_shape[-1:], initializer=Ones(), trainable=True) self.beta = self.add_weight(name='beta', shape=input_shape[-1:], initializer=Zeros(), trainable=True) super().build(input_shape)
def build(self, input_shape): self.gamma = self.add_weight( name="gamma", shape=input_shape[-1:], initializer=Ones(), trainable=True ) self.beta = self.add_weight( name="beta", shape=input_shape[-1:], initializer=Zeros(), trainable=True ) super(LayerNormalization, self).build(input_shape)
def get_discriminator(n_layers=4, use_sigmoid=True): input = Input(shape=(image_size, image_size, input_channel + output_channel)) x = Conv2D(64, kernel_size=4, padding='same', strides=2, kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(input) x = LeakyReLU(alpha=0.2)(x) for i in range(1, n_layers): x = Conv2D(64 * 2 ** i, kernel_size=4, padding='same', strides=2, kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2D(64 * 2 ** n_layers, kernel_size=4, padding='same', strides=1, kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) x = BatchNormalization()(x) x = LeakyReLU(alpha=0.2)(x) x = Conv2D(1, kernel_size=4, padding='same', strides=1, kernel_initializer=RandomNormal( mean=0.0, stddev=0.02), bias_initializer=Zeros())(x) if use_sigmoid: x = Activation('sigmoid')(x) discriminator = Model(inputs=input, outputs=x) return discriminator
def build(self, input_shape): self.bn = tf.keras.layers.BatchNormalization(axis=self.axis, epsilon=self.epsilon, center=False, scale=False) self.alphas = self.add_weight( shape=(input_shape[-1], ), initializer=Zeros(), dtype=tf.float32, name='dice_alpha') # name='alpha_'+self.name super(Dice, self).build(input_shape) # Be sure to call this somewhere! self.uses_learning_phase = True
def __init__(self, num_classes, from_logits=True, name='miou', dtype=tf.int32, **kwargs): super().__init__(name=name, dtype=dtype, **kwargs) self.num_classes = num_classes self.from_logits = from_logits self.total_cm = self.add_weight('total_confusion_matrix', shape=(num_classes, num_classes), initializer=Zeros(), dtype=self.dtype)
def create_model_categorical(self, input_shape, output_dim): self.model.add(LSTM(50, input_shape=input_shape, kernel_initializer=RandomUniform(seed=SEED_VALUE), bias_initializer=Zeros(), return_sequences=True, activation='relu')) self.model.add(LSTM(50, kernel_initializer=RandomUniform(seed=SEED_VALUE), bias_initializer=Zeros(), # return_sequences=True, activation='relu')) # self.model.add(Dense(20, # kernel_initializer=RandomUniform(seed=SEED_VALUE), # bias_initializer=Zeros(), # activation='relu')) self.model.add(Dense(output_dim, kernel_initializer=RandomUniform(seed=SEED_VALUE), bias_initializer=Zeros(), activation='softmax')) print(colored('Model RNN', 'green')) self.model.summary()
def __init__(self, xdim, ydim, adim): super().__init__() self.input_output_layer = xdim + ydim + adim self.hidden_layer = 128 self.shapes = [ self.input_output_layer, self.hidden_layer, self.input_output_layer ] self.zeros = Zeros() self.ones = Ones() self.is_built = False
def create_model(self, input_shape, output_dim): self.model.add(SimpleRNN(50, input_shape=input_shape, kernel_initializer=RandomUniform(seed=SEED_VALUE), bias_initializer=Zeros(), return_sequences=True, activation='relu')) self.model.add(SimpleRNN(50, kernel_initializer=RandomUniform(seed=SEED_VALUE), bias_initializer=Zeros(), activation='relu', )) # self.model.add(Dense(10, # kernel_initializer=RandomUniform(seed=SEED_VALUE), # bias_initializer=Zeros(), # activation='relu')) self.model.add(Dense(output_dim, kernel_initializer=RandomUniform(seed=SEED_VALUE), bias_initializer=Zeros(), # use_bias=False, activation='relu')) print(colored('Model RNN', 'green')) self.model.summary()
def build_fcn16s(nb_classes, target_size=(None, None)): inputs = Input(shape=(*target_size, 3)) vgg = VGG16(weights='imagenet', include_top=False, input_tensor=inputs, input_shape=(*target_size, 3)) x = Conv2D(4096, (7, 7), activation='relu', padding='same')(vgg.output) x = Dropout(0.5)(x) x = Conv2D(4096, (1, 1), activation='relu', padding='same')(x) x = Dropout(0.5)(x) x = Conv2D(nb_classes, (1, 1), padding='same', kernel_initializer='he_normal')(x) x = Conv2DTranspose(nb_classes, (4, 4), strides=(2, 2), use_bias=False, padding='same', activation='relu', name='fcn16s-transpose-first')(x) skip_con = Conv2D(nb_classes, (1, 1), strides=(1, 1), padding='same', bias_initializer=Zeros(), kernel_initializer=Zeros(), name='fcn16s-skip-con')( vgg.get_layer(name="block4_pool").output) x = Add()([x, skip_con]) x = Conv2DTranspose(nb_classes, (32, 32), strides=(16, 16), use_bias=False, padding='same', activation='softmax', name='fcn16s-transpose-second')(x) model = Model(inputs=inputs, outputs=x) return model
def __init__(self, n_attention, n_attention_hidden, n_attention_out, n_feat, n_hidden, activation="sigmoid", concat_activity_regularizer=None, kernel_initializer=VarianceScaling(distribution="uniform"), kernel_regularizer='l1', bias_initializer=Zeros(), bias_regularizer='l1', attention_initializer=VarianceScaling(distribution="uniform"), attention_hidden_activation="sigmoid", attention_output_activation="sigmoid", attention_trainable=True, attention_feat_weight_trainable=True, **kwargs): self.n_attention = n_attention self.n_attention_hidden = n_attention_hidden self.n_attention_out = n_attention_out self.n_feat = n_feat self.n_hidden = n_hidden self.activation = activations.get(activation) self.concat_activity_regularizer = concat_activity_regularizer self.kernel_initializer = kernel_initializer self.kernel_regularizer = kernel_regularizer self.bias_initializer = bias_initializer self.bias_regularizer = bias_regularizer self.attention_initializer = attention_initializer self.attention_hidden_activation = attention_hidden_activation self.attention_output_activation = attention_output_activation self.attention_trainable = attention_trainable self.attention_feat_weight_trainable = attention_feat_weight_trainable self.concat_layer = Concatenate( activity_regularizer=self.concat_activity_regularizer) self.attention_layers = [] for i in range(self.n_attention): attention_layer = DenseAttentionwFeatWeights( n_feat=self.n_feat, n_hidden=self.n_attention_hidden, out=self.n_attention_out, hidden_activation=self.attention_hidden_activation, output_activation=self.attention_output_activation, feat_weight_trainable=self.attention_feat_weight_trainable, initializer=self.attention_initializer, trainable=self.attention_trainable) self.attention_layers.append(attention_layer) super(ConcatAttentionswFeatWeights, self).__init__(**kwargs)
def build(self, input_shapes): self.neigh_weights = self.add_weight( shape=(self.input_dim, self.units), initializer=glorot_uniform(seed=self.seed), regularizer=l2(self.l2_reg), name="neigh_weights") if self.use_bias: self.bias = self.add_weight(shape=self.units, initializer=Zeros(), name='bias_weight') self.dropout = Dropout(self.dropout_rate) self.built = True
def __init__(self, num_classes, in_channels, feat_channels=256, stacked_convs=4, norm='bn', strides=(8, 16, 32, 64, 128), reg_max=16, reg_topk=4, reg_channels=64): super().__init__(1, num_classes, in_channels, feat_channels, stacked_convs, centerness=False, bbox_out_channels=4 * (reg_max + 1), concat=False, norm=norm, num_levels=len(strides)) self.strides = strides self.reg_max = reg_max self.reg_topk = reg_topk self.reg_channels = reg_channels self.reg_conf = Sequential([ Linear(4 * (reg_topk + 1), reg_channels, act='relu', kernel_init=RandomNormal(stddev=0.01), bias_init=Zeros()), Linear(reg_channels, 1, act='sigmoid', kernel_init=RandomNormal(stddev=0.01), bias_init=Zeros()), ])