def __init__(self, layers=16, use_bn=False, num_classes=1000): super(VGG, self).__init__() self.layers = layers self.use_bn = use_bn supported_layers = [16, 19] assert layers in supported_layers if layers == 16: depth = [2, 2, 3, 3, 3] elif layers == 19: depth = [2, 2, 4, 4, 4] num_channels = [3, 64, 128, 256, 512] num_filters = [64, 128, 256, 512, 512] self.layer1 = fluid.dygraph.Sequential(*self.make_layer(num_channels[0], num_filters[0], depth[0], use_bn, name='layer1')) self.layer2 = fluid.dygraph.Sequential(*self.make_layer(num_channels[1], num_filters[1], depth[1], use_bn, name='layer2')) self.layer3 = fluid.dygraph.Sequential(*self.make_layer(num_channels[2], num_filters[2], depth[2], use_bn, name='layer3')) self.layer4 = fluid.dygraph.Sequential(*self.make_layer(num_channels[3], num_filters[3], depth[3], use_bn, name='layer4')) self.layer5 = fluid.dygraph.Sequential(*self.make_layer(num_channels[4], num_filters[4], depth[4], use_bn, name='layer5')) self.classifier = fluid.dygraph.Sequential( Linear(input_dim=512 * 7 * 7, output_dim=4096, act='relu'), Dropout(), Linear(input_dim=4096, output_dim=4096, act='relu'), Dropout(), Linear(input_dim=4096, output_dim=num_classes)) self.out_dim = 512 * 7 * 7
def __init__(self, num_classes=59, backbone='resnet50'): super(PSPNet, self).__init__() res = ResNet50(pretrained=False) # stem: res.conv, res.pool2d_max self.layer0 = fluid.dygraph.Sequential( res.conv, res.pool2d_max ) self.layer1 = res.layer1 self.layer2 = res.layer2 self.layer3 = res.layer3 self.layer4 = res.layer4 num_channels = 2048 # psp: 2048 -> 2048*2 self.pspmodule = PSPModule(num_channels, [1, 2, 3, 6]) num_channels *= 2 # cls: 2048*2 -> 512 -> num_classes self.classifier = fluid.dygraph.Sequential( Conv2D(num_channels, num_filters=512, filter_size=3, padding=1), BatchNorm(512, act='relu'), Dropout(0.1), Conv2D(512, num_classes, filter_size=1) )
def __init__(self, num_classes=1): super(CNN_AllTricks, self).__init__() self.conv1 = Conv2D(3, 64, 3, padding=1, stride=1, act='leaky_relu') self.bn1 = BatchNorm(64) self.conv2 = Conv2D(64, 128, 3, padding=1, stride=1, act='leaky_relu') self.bn2 = BatchNorm(128) self.conv3 = Conv2D(128, 256, 3, padding=1, stride=1, act='leaky_relu') self.bn3 = BatchNorm(256) self.conv4 = Conv2D(256, 512, 3, padding=1, stride=1, act='leaky_relu') self.bn4 = BatchNorm(512) self.block5 = ConcatConv((512, 384), (384, 256), (256, 256), 128, act_fun='leaky_relu') self.bn5 = BatchNorm(1024) self.block6 = ConcatConv((1024, 384), (384, 256), (256, 256), 128, act_fun='leaky_relu') self.bn6 = BatchNorm(1024) self.pool_global = Pool2D(pool_stride=1, global_pooling=True, pool_type='avg') self.fc = Linear(input_dim=1024, output_dim=num_classes) self.pool_down = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.dropout = Dropout(p=0.5)
def __init__(self, block=BasicBlock, layers=50, inp=3, num_classes=400, input_size=112, dropout=0.5): self.inplanes = 64 self.inp = inp super(ResNet, self).__init__() self.conv1 = Conv2D(inp, 64, filter_size=7, stride=2, padding=3, bias_attr=False) self.bn1 = BatchNorm(64) self.relu = fluid.layers.relu #nn.ReLU(inplace=True) self.maxpool = Pool2D( pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') #nn.MaxPool2d(kernel_size=3, stride=2, padding=1) self.layer1 = self._make_layer(block, 64, layers[0]) self.layer2 = self._make_layer(block, 128, layers[1], stride=2) self.rep_of_rep = repofrep("flowofflow") self.layer3 = self._make_layer(block, 256, layers[2], stride=2) self.layer4 = self._make_layer(block, 512, layers[3], stride=2) # probably need to adjust this based on input spatial size size = int(math.ceil(input_size / 32)) self.avgpool = Pool2D(pool_size=size, pool_stride=1, pool_padding=0, pool_type='avg') #nn.AvgPool2d(size, stride=1) self.dropout = Dropout(dropout) #nn.Dropout(p=dropout) self.fc = Linear(512 * block.expansion, num_classes)
def __init__(self, num_classes=1): super(AlexNet, self).__init__() self.conv1 = Conv2D(num_channels=3, num_filters=96, filter_size=11, stride=4, padding=2, act='relu') self.pool1 = Pool2D(pool_size=3, pool_stride=2, pool_type='max') self.conv2 = Conv2D(num_channels=96, num_filters=256, filter_size=5, stride=1, padding=2, act='relu') self.pool2 = Pool2D(pool_size=3, pool_stride=2, pool_type='max') self.conv3 = Conv2D(num_channels=256, num_filters=384, filter_size=3, stride=1, padding=1, act='relu') self.conv4 = Conv2D(num_channels=384, num_filters=384, filter_size=3, stride=1, padding=1, act='relu') self.conv5 = Conv2D(num_channels=384, num_filters=256, filter_size=3, stride=1, padding=1, act='relu') self.pool5 = Pool2D(pool_size=3, pool_stride=2, pool_type='max') self.fc1 = Linear(256 * 6 * 6, 4096, act='relu') self.drop_out1 = Dropout(p=0.5) self.fc2 = Linear(4096, 4096, act='relu') self.drop_out2 = Dropout(p=0.5) self.fc3 = Linear(4096, num_classes, act='relu')
def _prepare_tsn(self, num_class): feature_dim = getattr(self.base_model, self.base_model.last_layer_name).weight.shape[0] setattr(self.base_model, self.base_model.last_layer_name, Dropout(p=self.dropout)) self.new_fc = Linear(feature_dim, num_class, act='softmax', param_attr=fluid.ParamAttr(learning_rate=1.0), bias_attr=fluid.ParamAttr(learning_rate=2.0))
def __init__(self, hidden_unit_num, image_size, in_channel, patch_num, dropout): super(ResNet24, self).__init__() self.patch_size = image_size // patch_num self.patch_num = patch_num n_patch_size = (image_size // patch_num) * (image_size // patch_num) self.position_embedding = fluid.layers.create_parameter( (1, n_patch_size + 1, hidden_unit_num), dtype='float32', is_bias=True) self.cls_token = fluid.layers.create_parameter((1, 1, hidden_unit_num), is_bias=False, dtype='float32') self.dropout = Dropout(dropout) self.layer1_1 = BasicBlock(num_channels=in_channel, num_filters=24, stride=1, shortcut=False) self.layer1_2 = BasicBlock(num_channels=24, num_filters=48, stride=2, shortcut=False) self.layer2_1 = BasicBlock(num_channels=48, num_filters=48, stride=1, shortcut=False) self.layer2_2 = BasicBlock(num_channels=48, num_filters=48, stride=2, shortcut=False) self.layer3_1 = BasicBlock(num_channels=48, num_filters=128, stride=1, shortcut=False) self.layer3_2 = BasicBlock(num_channels=128, num_filters=256, stride=2, shortcut=False) self.layer4_1 = BasicBlock(num_channels=256, num_filters=256, stride=1, shortcut=False) self.layer4_2 = BasicBlock(num_channels=256, num_filters=256, stride=1, shortcut=False) self.layer5_1 = BasicBlock(num_channels=256, num_filters=512, stride=1, shortcut=False) self.layer5_2 = BasicBlock(num_channels=512, num_filters=hidden_unit_num, stride=2, shortcut=False)
def __init__(self, num_classes=59): super(FCN8s, self).__init__() backbone = VGG16BN(pretrained=False) self.layer1 = backbone.layer1 self.layer1[0].conv._padding = [100, 100] self.pool1 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True) self.layer2 = backbone.layer2 self.pool2 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True) self.layer3 = backbone.layer3 self.pool3 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True) self.layer4 = backbone.layer4 self.pool4 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True) self.layer5 = backbone.layer5 self.pool5 = Pool2D(pool_size=2, pool_stride=2, ceil_mode=True) self.fc6 = Conv2D(512, 4096, 7, act='relu') self.fc7 = Conv2D(4096, 4096, 1, act='relu') self.drop6 = Dropout() self.drop7 = Dropout() self.score = Conv2D(4096, num_classes, 1) self.score_pool3 = Conv2D(256, num_classes, 1) self.score_pool4 = Conv2D(512, num_classes, 1) self.up_output = Conv2DTranspose(num_channels=num_classes, num_filters=num_classes, filter_size=4, stride=2, bias_attr=False) self.up_pool4 = Conv2DTranspose(num_channels=num_classes, num_filters=num_classes, filter_size=4, stride=2, bias_attr=False) self.up_final = Conv2DTranspose(num_channels=num_classes, num_filters=num_classes, filter_size=16, stride=8, bias_attr=False)
def __init__(self, name_scope, out_chs=20, in_chs=1024, inter_chs=512): super(DANet, self).__init__(name_scope) name_scope = self.full_name() self.in_chs = in_chs self.out_chs = out_chs self.inter_chs = inter_chs if inter_chs else in_chs self.backbone = ResNet(50) self.conv5p = Sequential( Conv2D(self.in_chs, self.inter_chs, 3, padding=1), BatchNorm(self.inter_chs, act='relu'), ) self.conv5c = Sequential( Conv2D(self.in_chs, self.inter_chs, 3, padding=1), BatchNorm(self.inter_chs, act='relu'), ) self.sp = PAM_module(self.inter_chs) self.sc = CAM_module(self.inter_chs) self.conv6p = Sequential( Conv2D(self.inter_chs, self.inter_chs, 3, padding=1), BatchNorm(self.inter_chs, act='relu'), ) self.conv6c = Sequential( Conv2D(self.inter_chs, self.inter_chs, 3, padding=1), BatchNorm(self.inter_chs, act='relu'), ) self.conv7p = Sequential( Dropout(0.1), Conv2D(self.inter_chs, self.out_chs, 1), ) self.conv7c = Sequential( Dropout(0.1), Conv2D(self.inter_chs, self.out_chs, 1), ) self.conv7pc = Sequential( Dropout(0.1), Conv2D(self.inter_chs, self.out_chs, 1), )
def __init__(self,num_classes=59): super(FCN8s,self).__init__() vgg16bn = VGG16BN() self.layer1 = vgg16bn.layer1 self.layer1[0].conv._padding = [100,100] self.layer2 = vgg16bn.layer2 self.layer3 = vgg16bn.layer3 self.layer4 = vgg16bn.layer4 self.layer5 = vgg16bn.layer5 # self.conv1_1 = Conv2D(3,64,3,padding=1) # self.conv1_2 = Conv2D(64,64,3,padding=1) self.pool1 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True) # self.conv2_1 = Conv2D(64,128,3,padding=1) # self.conv2_2 = Conv2D(128,128,3,padding=1) self.pool2 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True) # self.conv3_1 = Conv2D(128,256,3,padding=1) # self.conv3_2 = Conv2D(256,256,3,padding=1) # self.conv3_3 = Conv2D(256,256,3,padding=1) self.pool3 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True) # self.conv4_1 = Conv2D(256,512,3,padding=1) # self.conv4_2 = Conv2D(512,512,3,padding=1) # self.conv4_3 = Conv2D(512,512,3,padding=1) self.pool4 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True) # self.conv5_1 = Conv2D(512,512,3,padding=1) # self.conv5_2 = Conv2D(512,512,3,padding=1) # self.conv5_3 = Conv2D(512,512,3,padding=1) self.pool5 = Pool2D(pool_size=2,pool_stride=2,ceil_mode=True) self.conv6 = Conv2D(512,4096,1,act='relu') self.conv7 = Conv2D(4096,4096,1,act='relu') self.drop6 = Dropout() self.drop7 = Dropout() self.score = Conv2D(4096,num_classes,1) self.score_pool3 = Conv2D(256,num_classes,1) self.score_pool4 = Conv2D(512,num_classes,1,) self.upsample1 = Conv2DTranspose(num_classes,num_classes,filter_size=4,stride=2,padding=2,bias_attr=False) self.upsample2 = Conv2DTranspose(num_classes,num_classes,filter_size=4,stride=2,padding=2,bias_attr=False) self.upsample3 = Conv2DTranspose(num_classes,num_classes,filter_size=16,stride=8,padding=1,bias_attr=False)
def __init__(self, num_classes=1): super(GoogLeNet_BN, self).__init__() self.bn64 = BatchNorm(64) self.bn192 = BatchNorm(192) self.bn256 = BatchNorm(256) self.bn480 = BatchNorm(480) self.bn512 = BatchNorm(512) self.bn528 = BatchNorm(528) self.bn832 = BatchNorm(832) self.bn1024 = BatchNorm(1024) self.conv1 = Conv2D(3, 64, 7, padding=3, stride=2, act='relu') self.pool1 = Pool2D(pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') self.conv2_1 = Conv2D(64, 64, 1, act='relu') self.conv2_2 = Conv2D(64, 192, 3, padding=1, act='relu') self.pool2 = Pool2D(pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') self.block3_a = Inception((192, 64), (96, 128), (16, 32), 32) self.block3_b = Inception((256, 128), (128, 192), (32, 96), 64) self.pool3 = Pool2D(pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') self.block4_a = Inception((480, 192), (96, 208), (16, 48), 64) self.block4_b = Inception((512, 160), (112, 224), (24, 64), 64) self.block4_c = Inception((512, 128), (128, 256), (24, 64), 64) self.block4_d = Inception((512, 112), (144, 288), (32, 64), 64) self.block4_e = Inception((528, 256), (160, 320), (32, 128), 128) self.pool4 = Pool2D(pool_size=3, pool_stride=2, pool_padding=1, pool_type='max') self.block5_a = Inception((832, 256), (160, 320), (32, 128), 128) self.block5_b = Inception((832, 384), (192, 384), (48, 128), 128) self.pool5 = Pool2D(pool_size=7, pool_stride=1, global_pooling=True, pool_type='avg') self.drop = Dropout(p=0.4) self.fc = Linear(1024, num_classes)
def __init__(self, num_classes=1): super(CNN_ConcatConv, self).__init__() self.conv1 = Conv2D(3, 64, 5, padding=2, stride=1, act='sigmoid') self.bn1 = BatchNorm(64) self.conv2 = Conv2D(64, 128, 5, padding=2, stride=1, act='sigmoid') self.bn2 = BatchNorm(128) self.conv3 = Conv2D(128, 256, 5, padding=2, stride=1, act='sigmoid') self.bn3 = BatchNorm(256) self.conv4 = Conv2D(256, 512, 5, padding=2, stride=1, act='sigmoid') self.bn4 = BatchNorm(512) self.block5 = ConcatConv(self.full_name(), (512, 384), (384, 256), (256, 256), 128) self.bn5 = BatchNorm(1024) self.conv6 = Conv2D(1024, 1024, 5, padding=2, stride=1, act='sigmoid') self.bn6 = BatchNorm(1024) self.fc1 = Linear(1024 * 7 * 7, 1024, act='sigmoid') self.fc2 = Linear(1024, num_classes) self.pool_down = Pool2D(pool_size=2, pool_stride=2, pool_type='max') self.dropout = Dropout(p=0.5)
def __init__(self, num_classes=1): super(CNN_DropOut, self).__init__() self.conv1 = Conv2D(3, 64, 5, padding=2, stride=1, act='sigmoid') self.bn1 = BatchNorm(64) self.conv2 = Conv2D(64, 128, 5, padding=2, stride=1, act='sigmoid') self.bn2 = BatchNorm(128) self.conv3 = Conv2D(128, 256, 5, padding=2, stride=1, act='sigmoid') self.bn3 = BatchNorm(256) self.conv4 = Conv2D(256, 512, 5, padding=2, stride=1, act='sigmoid') self.bn4 = BatchNorm(512) self.conv5 = Conv2D(512, 1024, 5, padding=2, stride=1, act='sigmoid') self.bn5 = BatchNorm(1024) self.conv6 = Conv2D(1024, 1024, 5, padding=2, stride=1, act='sigmoid') self.bn6 = BatchNorm(1024) self.fc1 = Linear(1024 * 7 * 7, 1024, act='sigmoid') self.fc2 = Linear(1024, num_classes) self.pool_down = Pool2D(pool_size=2, pool_stride=2, pool_type='max') # 按照50%的比例随机丢弃部分神经元 self.dropout = Dropout(p=0.5)
def __init__(self, in_planes): super(BasicLiner, self).__init__() self.fc = linear(in_planes, in_planes) self.bn = norm_layer(in_planes) self.act = act_layer self.dp = Dropout()
def __init__(self, num_classes=1): super(VGG13, self).__init__() self.drop_out = Dropout(p=0.5) self.pool = Pool2D(pool_size=3, pool_stride=2, pool_type='max') self.conv1 = Conv2D(num_channels=3, num_filters=64, filter_size=3, stride=1, padding=1, act='relu') self.conv2 = Conv2D(num_channels=64, num_filters=128, filter_size=3, stride=1, padding=1, act='relu') self.conv3 = Conv2D(num_channels=128, num_filters=256, filter_size=3, stride=1, padding=1, act='relu') self.conv4 = Conv2D(num_channels=256, num_filters=256, filter_size=3, stride=1, padding=1, act='relu') self.conv5 = Conv2D(num_channels=256, num_filters=512, filter_size=3, stride=1, padding=1, act='relu') self.conv6 = Conv2D(num_channels=512, num_filters=512, filter_size=3, stride=1, padding=1, act='relu') self.conv7 = Conv2D(num_channels=512, num_filters=512, filter_size=3, stride=1, padding=1, act='relu') self.conv8 = Conv2D(num_channels=512, num_filters=512, filter_size=3, stride=1, padding=1, act='relu') self.fc1 = Linear(512 * 6 * 6, 4096, act='relu') self.fc2 = Linear(4096, 4096, act='relu') self.fc3 = Linear(4096, num_classes, act='relu')
def build_dropout(attr, channels=None, conv_bias=False): return Dropout(p=attr['dropout_ratio']), channels
def __init__(self, batch_size, block_fn, layers, num_classes, data_format='channels_last', non_local=[], rep_flow=[], size=112, dropout_keep_prob=0.5): """Generator for ResNet v1 models. Args: block_fn: `function` for the block to use within the model. Either `residual_block` or `bottleneck_block`. layers: list of 4 `int`s denoting the number of blocks to include in each of the 4 block groups. Each group consists of blocks that take inputs of the same resolution. num_classes: `int` number of possible classes for image classification. data_format: `str` either "channels_first" for `[batch, channels, height, width]` or "channels_last for `[batch, height, width, channels]`. Returns: Model `function` that takes in `inputs` and `is_training` and returns the output `Tensor` of the ResNet model. """ super(ResNet3D, self).__init__() is_training = False self.stem = Conv2D( 3, 64, filter_size=7, bias_attr=fluid.ParamAttr(trainable=False), stride=2, padding=3, param_attr=fluid.initializer.MSRAInitializer(uniform=False)) self.bn1 = BatchNorm(64, act='relu') self.num_classes = num_classes self.rep_flow = rf.FlowLayer(batch_size, block_fn.expansion * 128, bn=False) self.flow_conv = Conv2D(512, 512, filter_size=3, stride=1, padding=1) self.rep_flow2 = rf.FlowLayer(batch_size, 512) # res 2 inputs = 64 self.res2 = Block3D(block_ind=1, inputs=inputs, filters=64, block_fn=block_fn, blocks=layers[0], strides=1, is_training=is_training, name='block_group1', data_format=data_format, non_local=non_local[0]) # res 3 inputs = 64 * block_fn.expansion self.res3 = Block3D(block_ind=2, inputs=inputs, filters=128, block_fn=block_fn, blocks=layers[1], strides=2, is_training=is_training, name='block_group2', data_format=data_format, non_local=non_local[1]) # res 4 inputs = 128 * block_fn.expansion self.res4 = Block3D(block_ind=3, inputs=inputs, filters=256, block_fn=block_fn, blocks=layers[2], strides=2, is_training=is_training, name='block_group3', data_format=data_format, non_local=non_local[2]) # res 5 inputs = 256 * block_fn.expansion self.res5 = Block3D(block_ind=4, inputs=inputs, filters=512, block_fn=block_fn, blocks=layers[3], strides=2, is_training=is_training, name='block_group4', data_format=data_format, non_local=non_local[3]) self.dropout = Dropout(0.9) self.classify = Linear( input_dim=512 * block_fn.expansion, output_dim=num_classes, act='softmax', param_attr=fluid.ParamAttr( initializer=fluid.initializer.MSRAInitializer(uniform=True)))