Python models.vgg19_bn方法代码示例

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def __init__(self):
        super(VGG19_bo,self).__init__()
        model=vgg19_bn(pretrained=True)
        # 设置网络名称
        self.moduel_name=str("VGG19_bo")

        #固定提取特征层，权重为预训练权重
        self.features=model.features
        # 固定权重
        if opt.fixed_weight:
            for param in  self.features.parameters():
                param.requires_grad=False

        # 分类层
        self.classifier=nn.Sequential(
            t.nn.Linear(25088, 4096), #224: 25088     420:86528
            t.nn.ReLU(),
            t.nn.Dropout(p=0.5),
            t.nn.Linear(4096, 4096),
            t.nn.ReLU(),
            t.nn.Dropout(p=0.5),
            t.nn.Linear(4096,2)
        )
        # 仅对分类层初始化
        self._initialize_weights() 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def __init__(self, num_classes, pretrained=True):
        super(SegNet, self).__init__()
        vgg = models.vgg19_bn()
        if pretrained:
            vgg.load_state_dict(torch.load(vgg19_bn_path))
        features = list(vgg.features.children())
        self.enc1 = nn.Sequential(*features[0:7])
        self.enc2 = nn.Sequential(*features[7:14])
        self.enc3 = nn.Sequential(*features[14:27])
        self.enc4 = nn.Sequential(*features[27:40])
        self.enc5 = nn.Sequential(*features[40:])

        self.dec5 = nn.Sequential(
            *([nn.ConvTranspose2d(512, 512, kernel_size=2, stride=2)] +
              [nn.Conv2d(512, 512, kernel_size=3, padding=1),
               nn.BatchNorm2d(512),
               nn.ReLU(inplace=True)] * 4)
        )
        self.dec4 = _DecoderBlock(1024, 256, 4)
        self.dec3 = _DecoderBlock(512, 128, 4)
        self.dec2 = _DecoderBlock(256, 64, 2)
        self.dec1 = _DecoderBlock(128, num_classes, 2)
        initialize_weights(self.dec5, self.dec4, self.dec3, self.dec2, self.dec1) 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def main():
  # model = models.vgg19_bn(pretrained=True)
  # _, summary = weight_watcher.analyze(model, alphas=False)
  # for key, value in summary.items():
  #   print('{:10s} : {:}'.format(key, value))

  _, summary = weight_watcher.analyze(models.vgg13(pretrained=True), alphas=False)
  print('vgg-13 : {:}'.format(summary['lognorm']))
  _, summary = weight_watcher.analyze(models.vgg13_bn(pretrained=True), alphas=False)
  print('vgg-13-BN : {:}'.format(summary['lognorm']))
  _, summary = weight_watcher.analyze(models.vgg16(pretrained=True), alphas=False)
  print('vgg-16 : {:}'.format(summary['lognorm']))
  _, summary = weight_watcher.analyze(models.vgg16_bn(pretrained=True), alphas=False)
  print('vgg-16-BN : {:}'.format(summary['lognorm']))
  _, summary = weight_watcher.analyze(models.vgg19(pretrained=True), alphas=False)
  print('vgg-19 : {:}'.format(summary['lognorm']))
  _, summary = weight_watcher.analyze(models.vgg19_bn(pretrained=True), alphas=False)
  print('vgg-19-BN : {:}'.format(summary['lognorm'])) 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def vgg19_bn(num_classes=1000, pretrained='imagenet'):
    """VGG 19-layer model (configuration 'E') with batch normalization
    """
    model = models.vgg19_bn(pretrained=False)
    if pretrained is not None:
        settings = pretrained_settings['vgg19_bn'][pretrained]
        model = load_pretrained(model, num_classes, settings)
    model = modify_vggs(model)
    return model 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def _load_pytorch_model(model_name, summary):
    import torchvision.models as models
    switcher = {
        'alexnet': lambda: models.alexnet(pretrained=True).eval(),
        "vgg11": lambda: models.vgg11(pretrained=True).eval(),
        "vgg11_bn": lambda: models.vgg11_bn(pretrained=True).eval(),
        "vgg13": lambda: models.vgg13(pretrained=True).eval(),
        "vgg13_bn": lambda: models.vgg13_bn(pretrained=True).eval(),
        "vgg16": lambda: models.vgg16(pretrained=True).eval(),
        "vgg16_bn": lambda: models.vgg16_bn(pretrained=True).eval(),
        "vgg19": lambda: models.vgg19(pretrained=True).eval(),
        "vgg19_bn": lambda: models.vgg19_bn(pretrained=True).eval(),
        "resnet18": lambda: models.resnet18(pretrained=True).eval(),
        "resnet34": lambda: models.resnet34(pretrained=True).eval(),
        "resnet50": lambda: models.resnet50(pretrained=True).eval(),
        "resnet101": lambda: models.resnet101(pretrained=True).eval(),
        "resnet152": lambda: models.resnet152(pretrained=True).eval(),
        "squeezenet1_0": lambda: models.squeezenet1_0(pretrained=True).eval(),
        "squeezenet1_1": lambda: models.squeezenet1_1(pretrained=True).eval(),
        "densenet121": lambda: models.densenet121(pretrained=True).eval(),
        "densenet161": lambda: models.densenet161(pretrained=True).eval(),
        "densenet201": lambda: models.densenet201(pretrained=True).eval(),
        "inception_v3": lambda: models.inception_v3(pretrained=True).eval(),
    }

    _load_model = switcher.get(model_name, None)
    _model = _load_model()
    import torch
    if torch.cuda.is_available():
        _model = _model.cuda()
    from perceptron.models.classification.pytorch import PyTorchModel as ClsPyTorchModel
    import numpy as np
    mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))
    std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))
    pmodel = ClsPyTorchModel(
        _model, bounds=(
            0, 1), num_classes=1000, preprocessing=(
            mean, std))
    return pmodel 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def load_pytorch_model(model_name):
    import torchvision.models as models
    switcher = {
        'alexnet': lambda: models.alexnet(pretrained=True).eval(),
        "vgg11": lambda: models.vgg11(pretrained=True).eval(),
        "vgg11_bn": lambda: models.vgg11_bn(pretrained=True).eval(),
        "vgg13": lambda: models.vgg13(pretrained=True).eval(),
        "vgg13_bn": lambda: models.vgg13_bn(pretrained=True).eval(),
        "vgg16": lambda: models.vgg16(pretrained=True).eval(),
        "vgg16_bn": lambda: models.vgg16_bn(pretrained=True).eval(),
        "vgg19": lambda: models.vgg19(pretrained=True).eval(),
        "vgg19_bn": lambda: models.vgg19_bn(pretrained=True).eval(),
        "resnet18": lambda: models.resnet18(pretrained=True).eval(),
        "resnet34": lambda: models.resnet34(pretrained=True).eval(),
        "resnet50": lambda: models.resnet50(pretrained=True).eval(),
        "resnet101": lambda: models.resnet101(pretrained=True).eval(),
        "resnet152": lambda: models.resnet152(pretrained=True).eval(),
        "squeezenet1_0": lambda: models.squeezenet1_0(pretrained=True).eval(),
        "squeezenet1_1": lambda: models.squeezenet1_1(pretrained=True).eval(),
        "densenet121": lambda: models.densenet121(pretrained=True).eval(),
        "densenet161": lambda: models.densenet161(pretrained=True).eval(),
        "densenet201": lambda: models.densenet201(pretrained=True).eval(),
        "inception_v3": lambda: models.inception_v3(pretrained=True).eval(),
    }

    _load_model = switcher.get(model_name, None)
    _model = _load_model()
    return _model 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def vgg19(pre): return children(vgg19_bn(pre))[0] 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def __init__(self, use_bn=True):  # Original implementation doesn't use BN
        super(VGG, self).__init__()
        if use_bn:
            vgg = models.vgg19(pretrained=True)
            layers_to_use = list(list(vgg.children())[0].children())[:23]
        else:
            vgg = models.vgg19_bn(pretrained=True)
            layers_to_use = list(list(vgg.children())[0].children())[:33]
        self.vgg = nn.Sequential(*layers_to_use)
        self.feature_extractor = nn.Sequential(make_standard_block(512, 256, 3),
                                               make_standard_block(256, 128, 3))
        init(self.feature_extractor) 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def __init__(self, num_classes):
        super(SegNet, self).__init__()
        vgg = models.vgg19_bn()
        features = list(vgg.features.children())
        self.enc1 = nn.Sequential(*features[0:7])
        self.enc2 = nn.Sequential(*features[7:14])
        self.enc3 = nn.Sequential(*features[14:27])
        self.enc4 = nn.Sequential(*features[27:40])
        self.enc5 = nn.Sequential(*features[40:])

        self.dec5 = nn.Sequential(
            *([nn.ConvTranspose2d(512, 512, kernel_size=2, stride=2)] +
              [nn.Conv2d(512, 512, kernel_size=3, padding=1),
               nn.BatchNorm2d(512),
               nn.ReLU(inplace=False)] * 4)
        )
        self.dec4 = _DecoderBlock(1024, 256, 4)
        self.dec3 = _DecoderBlock(512, 128, 4)
        self.dec2 = _DecoderBlock(256, 64, 2)
        self.dec1 = _DecoderBlock(128, num_classes, 2)
        # initialize_weights(self.dec5, self.dec4, self.dec3, self.dec2, self.dec1)

        for i in range(5):
            for param in getattr(self, 'enc{:d}'.format(i + 1)).parameters():
                param.requires_grad = False

        for i in range(5):
            for param in getattr(self, 'dec{:d}'.format(i + 1)).parameters():
                param.requires_grad = False 

# 需要导入模块: from torchvision import models [as 别名]
# 或者: from torchvision.models import vgg19_bn [as 别名]
def vgg19_bn(num_classes=1000, pretrained='imagenet'):
    """VGG 19-layer model (configuration 'E') with batch normalization
    """
    model = models.vgg19_bn(pretrained=False)
    if pretrained is not None:
        settings = pretrained_settings['vgg19_bn'][pretrained]
        model = load_pretrained(model, num_classes, settings)
    return model