Exemple #1
0
    def __init__(self, topN=4, classNum=200):
        super(attention_net, self).__init__()
        # self.pretrained_model = resnet.resnet50(pretrained=True)
        # self.pretrained_model = resnet.resnet152(pretrained=True)
        # self.pretrained_model = resnet.resnet101(pretrained=True)
        # self.pretrained_model = densenet.densenet121(pretrained=False,num_classes=classNum)
        # self.pretrained_model = densenet.densenet169(pretrained=True,num_classes=classNum)
        # self.pretrained_model = densenet.densenet161(pretrained=True,num_classes=classNum)
        # self.pretrained_model = resnext.resnext101_32x8d(pretrained=True,num_classes=classNum)
        # self.pretrained_model = mobilenet.mobilenet_v2(pretrained=True,num_classes=classNum)
        self.pretrained_model = squeezenet.squeezenet1_1(pretrained=True,
                                                         num_classes=classNum)

        # self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
        # # print("classNum: ",classNum)        # classNum:  20  Fish
        # num_ftrs = self.pretrained_model.fc.in_features
        # self.pretrained_model.fc = nn.Linear(num_ftrs, classNum)
        # self.pretrained_model.fc = nn.Linear(512 * 4, classNum)

        self.proposal_net = ProposalNet(in_features=512)
        self.topN = topN
        self.concat_net = nn.Linear(5000, classNum)  # 5000
        self.partcls_net = nn.Linear(1, classNum)  # 1
        _, edge_anchors, _ = generate_default_anchor_maps()
        self.pad_side = 224
        # self.edge_anchors = (edge_anchors + 224).astype(np.int)
        self.edge_anchors = (edge_anchors + 224).astype(np.int).repeat(
            4, 0)[:5991, :]
Exemple #2
0
    def __init__(self, topN=4):
        super(attention_net, self).__init__()
        # ResNet family
        #self.pretrained_model = resnet.resnet50(pretrained=True)
        #self.pretrained_model = resnet.resnet101(pretrained=True)
        #self.pretrained_model = resnet.resnet152(pretrained=True)

        # ResNext
        self.pretrained_model = resnext.resnext50_32x4d(pretrained=True)
        #self.pretrained_model = resnext.resnext101_32x8d(pretrained=True)

        
        self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
        self.pretrained_model.fc = nn.Linear(512 * 4, CLASSES)

        # initiate FPN, Scrutinizer, Teacher net
        self.proposal_net = ProposalNet()
        self.topN = topN
        self.concat_net = nn.Linear(2048 * (CAT_NUM + 1), CLASSES)
        self.partcls_net = nn.Linear(512 * 4, CLASSES)

        # use edge_anchors
        _, edge_anchors, _ = generate_default_anchor_maps()

        self.pad_side = PAD_SIZE
        self.edge_anchors = (edge_anchors + PART_IMAGE_SIZE).astype(np.int)
Exemple #3
0
    def __init__(self, topN=4, classNum=200):
        super(attention_net, self).__init__()
        # self.pretrained_model = resnet.resnet50(pretrained=True)
        # self.pretrained_model = resnext.resnet18(pretrained=True,num_classes=classNum)
        # self.pretrained_model = resnext.resnet34(pretrained=True,num_classes=classNum)
        # self.pretrained_model = resnet.resnet152(pretrained=True)
        # self.pretrained_model = resnet.resnet101(pretrained=True)
        # self.pretrained_model = densenet.densenet121(pretrained=False,num_classes=classNum)
        # self.pretrained_model = densenet.densenet169(pretrained=True,num_classes=classNum)
        # self.pretrained_model = densenet.densenet161(pretrained=True,num_classes=classNum)
        # self.pretrained_model = resnext.resnext101_32x8d(pretrained=True,num_classes=classNum)
        # self.pretrained_model = resnext.wide_resnet101_2(pretrained=True,num_classes=classNum)
        # self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
        # print("classNum: ",classNum)        # classNum:  20  Fish
        self.pretrained_model = vgg.vgg16(pretrained=True,
                                          num_classes=classNum)
        # num_ftrs = self.pretrained_model.classifier.in_features
        # self.pretrained_model.fc = nn.Linear(num_ftrs, classNum)
        # self.pretrained_model.fc = nn.Linear(512 * 4, classNum)

        self.proposal_net = ProposalNet()
        self.topN = topN
        self.concat_net = nn.Linear(125440, classNum)
        self.partcls_net = nn.Linear(25088, classNum)
        _, edge_anchors, _ = generate_default_anchor_maps()
        self.pad_side = 224
        self.edge_anchors = (edge_anchors + 224).astype(np.int)
Exemple #4
0
    def __init__(self, topN=4, n_class=200):
        super(attention_net, self).__init__()
        self.n_class = n_class
        self.pretrained_model = resnet.resnet50(pretrained=True)
        self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
        self.pretrained_model.fc = nn.Linear(512 * 4, self.n_class)
        self.proposal_net = ProposalNet()
        self.topN = topN
        self.concat_net = nn.Linear(2048 * (CAT_NUM + 1 + 1), self.n_class)
        self.partcls_net = nn.Linear(512 * 4, self.n_class)

        self.pad_side = 224
        _, edge_anchors_small, _ = generate_default_anchor_maps(
            setting='small')
        self.edge_anchors_small = (edge_anchors_small + 224).astype(np.int)
        _, edge_anchors_large, _ = generate_default_anchor_maps(
            setting='large')
        self.edge_anchors_large = (edge_anchors_large + 224).astype(np.int)
Exemple #5
0
 def __init__(self, topN=4):
     super(attention_net, self).__init__()
     self.pretrained_model = resnet.resnet50(pretrained=True)
     self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
     self.pretrained_model.fc = nn.Linear(512 * 4, 200)
     self.proposal_net = ProposalNet()
     self.topN = topN
     self.concat_net = nn.Linear(2048 * (CAT_NUM + 1), 200)
     self.partcls_net = nn.Linear(512 * 4, 200)
     _, edge_anchors, _ = generate_default_anchor_maps()
     self.pad_side = 224
     self.edge_anchors = (edge_anchors + 224).astype(np.int)
Exemple #6
0
 def __init__(self, topN=4):
     super(attention_net, self).__init__()
     self.pretrained_model = resnet.resnet50(pretrained=True)
     self.pretrained_model.add_module('raw_fc',
                                      nn.Linear(512 * 4, LABEL_NUM))
     self.proposal_net = ProposalNet()
     self.topN = topN
     self.concat_net = nn.Linear(2048 * (CAT_NUM + 1), LABEL_NUM)
     self.partcls_net = nn.Linear(512 * 4, LABEL_NUM)
     _, edge_anchors, _ = generate_default_anchor_maps()
     self.pad_side = 224
     self.edge_anchors = (edge_anchors + 224).astype(np.int)
Exemple #7
0
 def __init__(self, topN=4):
     super(attention_net, self).__init__()
     self.pretrained_model = resnet.resnet152(pretrained=True)
     #self.pretrained_model = pretrainedmodels.__dict__['se_resnext101_32x4d'](num_classes=1000, pretrained=None)
     self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
     self.pretrained_model.last_linear = nn.Linear(512 * 4, 2)
     self.proposal_net = ProposalNet()
     self.topN = topN
     self.concat_net = nn.Linear(2048 * (CAT_NUM + 1), 2)
     self.partcls_net = nn.Linear(512 * 4, 2)
     _, edge_anchors, _ = generate_default_anchor_maps()
     self.pad_side = 224
     self.edge_anchors = (edge_anchors + 224).astype(np.int)
Exemple #8
0
 def __init__(self, topN=4):
     super(attention_net, self).__init__()
     self.pretrained_model = densenet.densenet201(pretrained=True)
     self.in_features = self.pretrained_model.classifier.in_features
     # self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
     self.pretrained_model.classifier = nn.Linear(1920, 200)
     self.proposal_net = ProposalNet()
     self.topN = topN
     self.concat_net = nn.Linear(self.in_features* (CAT_NUM + 1), 200)
     self.partcls_net = nn.Linear(1920, 200)
     _, edge_anchors, _ = generate_default_anchor_maps()
     self.pad_side = 224
     self.edge_anchors = (edge_anchors + 224).astype(np.int)
Exemple #9
0
 def __init__(self, topN=4):
     super(attention_net, self).__init__()
     self.pretrained_model = resnet.resnet50(pretrained=True)
     self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
     self.pretrained_model.fc = nn.Linear(512 * 4, NUM_CLASS)
     self.proposal_net = ProposalNet()
     self.topN = topN  # proposal number
     self.concat_net = nn.Linear(2048 * (CAT_NUM + 1), NUM_CLASS)
     self.partcls_net = nn.Linear(512 * 4, NUM_CLASS)
     #其中每行的4个值[公式]表示矩形左上角和右下角点坐标。9个矩形共有3种形状,3种长宽比
     _, edge_anchors, _ = generate_default_anchor_maps()
     self.pad_side = 224
     self.edge_anchors = (edge_anchors + 224).astype(np.int)
    def __init__(self, topN=4, classNum=20):
        super(attention_net, self).__init__()

        # self.pretrained_model = shufflenetv2.shufflenet_v2_x0_5(pretrained=True,num_classes=classNum)
        self.pretrained_model = shufflenetv2.shufflenet_v2_x1_0(
            pretrained=True, num_classes=classNum)

        self.proposal_net = ProposalNet(in_features=24)
        self.topN = topN
        self.concat_net = nn.Linear(5120, classNum)
        self.partcls_net = nn.Linear(1024, classNum)
        _, edge_anchors, _ = generate_default_anchor_maps()
        self.pad_side = 224
        self.edge_anchors = (edge_anchors + 224).astype(np.int).repeat(
            251, 0)[:404544, :]
Exemple #11
0
 def __init__(self, topN=4):
     super(attention_net, self).__init__()
     # self.pretrained_model = densenet.densenet201(pretrained=True)
     self.pretrained_model = resnet.resnet50(pretrained=True)
     self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(
         1)  # 1 denotes the output size
     num_features = self.pretrained_model.num_features
     self.pretrained_model.fc = nn.Linear(
         num_features, NUM_CLS)  # in_features=512*4, out_features=200
     self.proposal_net = ProposalNet(num_features)
     self.topN = topN
     self.concat_net = nn.Linear(num_features * (CAT_NUM + 1), NUM_CLS)
     self.partcls_net = nn.Linear(num_features, NUM_CLS)
     _, edge_anchors, _ = generate_default_anchor_maps()
     self.pad_side = 224
     self.edge_anchors = (edge_anchors + 224).astype(np.int)
    def __init__(self, topN=4, classNum=20):
        super(attention_net, self).__init__()
        # self.pretrained_model = resnet.resnet50(pretrained=True)
        # self.pretrained_model = resnet.resnet152(pretrained=True)
        self.pretrained_model = inception.inception_v3(pretrained=True)

        # self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
        # self.pretrained_model.fc = nn.Linear(512 * 4, 200)

        num_ftrs = self.pretrained_model.fc.in_features
        self.pretrained_model.fc = nn.Linear(num_ftrs, classNum)

        self.proposal_net = ProposalNet()
        self.topN = topN
        self.concat_net = nn.Linear(2048 * (CAT_NUM + 1), classNum)
        self.partcls_net = nn.Linear(512 * 4, classNum)
        _, edge_anchors, _ = generate_default_anchor_maps()
        self.pad_side = 224
        self.edge_anchors = (edge_anchors + 224).astype(np.int)
    def __init__(self, topN=4, classNum=20):
        super(attention_net, self).__init__()
        # self.pretrained_model = resnet.resnet50(pretrained=True)
        # self.pretrained_model = resnet.resnet152(pretrained=True)
        # self.pretrained_model = resnet.resnet101(pretrained=True)
        self.pretrained_model = densenet.densenet121(pretrained=False,
                                                     num_classes=classNum)
        # self.pretrained_model.avgpool = nn.AdaptiveAvgPool2d(1)
        # print("classNum: ",classNum)        # classNum:  20  Fish
        num_ftrs = self.pretrained_model.classifier.in_features
        self.pretrained_model.classifier = nn.Linear(num_ftrs, classNum)
        # self.pretrained_model.fc = nn.Linear(512 * 4, classNum)

        self.proposal_net = ProposalNet()
        self.topN = topN
        self.concat_net = nn.Linear(1024 * (CAT_NUM + 1), classNum)
        self.partcls_net = nn.Linear(512 * 2, classNum)
        _, edge_anchors, _ = generate_default_anchor_maps()
        self.pad_side = 224
        self.edge_anchors = (edge_anchors + 224).astype(np.int)