def __init__(self, n_layers=2, h_size=512):
super(ResLSTM, self).__init__()
print('Building AlexNet + LSTM model...')
self.h_size = h_size
self.n_layers = n_layers
resnet = models.resnet50(pretrained=True)
self.conv = nn.Sequential(*list(resnet.children())[:-1])
self.lstm = nn.LSTM(1280, h_size, dropout=0.2, num_layers=n_layers)
self.fc = nn.Sequential(
nn.Linear(h_size, 64),
nn.ReLU(),
nn.Dropout(0.2),
nn.Linear(64, 1)
)
python类resnet50()的实例源码
def __init__(self, args):
nclass=args.nclass
super(Net, self).__init__()
self.backbone = args.backbone
# copying modules from pretrained models
if self.backbone == 'resnet50':
self.pretrained = resnet.resnet50(pretrained=True)
elif self.backbone == 'resnet101':
self.pretrained = resnet.resnet101(pretrained=True)
elif self.backbone == 'resnet152':
self.pretrained = resnet.resnet152(pretrained=True)
else:
raise RuntimeError('unknown backbone: {}'.format(self.backbone))
n_codes = 32
self.head = nn.Sequential(
nn.Conv2d(2048, 128, 1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
encoding.nn.Encoding(D=128,K=n_codes),
encoding.nn.View(-1, 128*n_codes),
encoding.nn.Normalize(),
nn.Linear(128*n_codes, nclass),
)
def GetPretrainedModel(params, num_classes):
if params['model'] == 'resnet18':
model = models.resnet18(pretrained=True)
elif params['model'] == 'resnet34':
model = models.resnet34(pretrained=True)
elif params['model'] == 'resnet50':
model = models.resnet50(pretrained=True)
elif params['model'] == 'resnet101':
model = models.resnet101(pretrained=True)
elif params['model'] == 'resnet152':
model = models.resnet152(pretrained=True)
else:
raise ValueError('Unknown model type')
num_features = model.fc.in_features
model.fc = SigmoidLinear(num_features, num_classes)
return model
def resnet50_wildcat(num_classes, pretrained=True, kmax=1, kmin=None, alpha=1, num_maps=1):
model = models.resnet50(pretrained)
pooling = nn.Sequential()
pooling.add_module('class_wise', ClassWisePool(num_maps))
pooling.add_module('spatial', WildcatPool2d(kmax, kmin, alpha))
return ResNetWSL(model, num_classes * num_maps, pooling=pooling)
def __init__(self, input_size, hidden_size, use_embedding=False, use_cnn=False, vocab_size=None,
pad_idx=None):
"""
Bidirectional GRU for encoding sequences
:param input_size: Size of the feature dimension (or, if use_embedding=True, the embed dim)
:param hidden_size: Size of the GRU hidden layer. Outputs will be hidden_size*2
:param use_embedding: True if we need to embed the sequences
:param vocab_size: Size of vocab (only used if use_embedding=True)
"""
super(EncoderRNN, self).__init__()
self.input_size = input_size
self.hidden_size = hidden_size
self.gru = nn.GRU(input_size, hidden_size, bidirectional=True)
self.use_embedding = use_embedding
self.use_cnn = use_cnn
self.vocab_size = vocab_size
self.embed = None
if self.use_embedding:
assert self.vocab_size is not None
self.pad = pad_idx
self.embed = nn.Embedding(self.vocab_size, self.input_size, padding_idx=pad_idx)
elif self.use_cnn:
self.embed = models.resnet50(pretrained=True)
for param in self.embed.parameters():
param.requires_grad = False
self.embed.fc = nn.Linear(self.embed.fc.in_features, self.input_size)
# Init weights (should be moved.)
self.embed.fc.weight.data.normal_(0.0, 0.02)
self.embed.fc.bias.data.fill_(0)
def __init__(self, nclass):
super(Dilated_ResNet, self).__init__()
self.pretrained = dresnet.resnet50(pretrained=True)
def __init__(self, nclass):
super(Org_ResNet, self).__init__()
self.pretrained = orgresnet.resnet50(pretrained=True)
def resnet50_weldon(num_classes, pretrained=True, kmax=1, kmin=None):
model = models.resnet50(pretrained)
pooling = WeldonPool2d(kmax, kmin)
return ResNetWSL(model, num_classes, pooling=pooling)
def __init__(self, opt):
super().__init__()
self.opt = opt
if opt.netSpec == 'resnet101':
resnet = models.resnet101(pretrained=opt.pretrain)
elif opt.netSpec == 'resnet50':
resnet = models.resnet50(pretrained=opt.pretrain)
elif opt.netSpec == 'resnet34':
resnet = models.resnet34(pretrained=opt.pretrain)
self.conv1 = resnet.conv1
self.layer1 = resnet.layer1
self.layer2 = resnet.layer2
self.layer3 = resnet.layer3
self.layer4 = resnet.layer4
for m in self.modules():
if isinstance(m, nn.Conv2d):
# m.stride = 1
m.requires_grad = False
if isinstance(m, nn.BatchNorm2d):
m.requires_grad = False
self.layer5a = PSPDec(512, 128, (1,1))
self.layer5b = PSPDec(512, 128, (2,2))
self.layer5c = PSPDec(512, 128, (3,3))
self.layer5d = PSPDec(512, 128, (6,6))
self.final = nn.Sequential(
nn.Conv2d(512*2, 512, 3, padding=1, bias=False),
nn.BatchNorm2d(512, momentum=.95),
nn.ReLU(inplace=True),
nn.Dropout(.1),
nn.Conv2d(512, opt.numClasses, 1),
)
def resnet50(num_classes=1000, pretrained='imagenet'):
"""Constructs a ResNet-50 model.
"""
model = models.resnet50(pretrained=False)
if pretrained is not None:
settings = pretrained_settings['resnet50'][pretrained]
model = load_pretrained(model, num_classes, settings)
model = modify_resnets(model)
return model
