def create_model(pretrained=True, architecture="resnet34", is_train=True):
if architecture == "resnet18":
if pretrained:
model = torchvision.models.resnet18(pretrained=pretrained)
model.fc = torch.nn.Linear(512 * 1, NUM_CATEGORY)
else:
model = torchvision.models.resnet18(pretrained=pretrained, num_classes=NUM_CATEGORY)
model.avgpool = torch.nn.AdaptiveAvgPool2d(1)
elif architecture == "resnet34":
if pretrained:
model = torchvision.models.resnet34(pretrained=pretrained)
model.fc = torch.nn.Linear(512 * 1, NUM_CATEGORY)
else:
model = torchvision.models.resnet34(pretrained=pretrained, num_classes=NUM_CATEGORY)
model.avgpool = torch.nn.AdaptiveAvgPool2d(1)
elif architecture == "resnet50":
if pretrained:
model = torchvision.models.resnet50(pretrained=pretrained)
model.fc = torch.nn.Linear(512 * 4, NUM_CATEGORY)
else:
model = torchvision.models.resnet50(pretrained=pretrained, num_classes=NUM_CATEGORY)
model.avgpool = torch.nn.AdaptiveAvgPool2d(1)
elif architecture == "mobilenetv2":
model = MobileNetV2.MobileNetV2(n_class=NUM_CATEGORY, input_size=IMG_HEIGHT)
elif architecture == "se_resnet50":
if pretrained:
model = great_networks.se_resnet50(pretrained=pretrained)
model.last_linear = torch.nn.Linear(512 * 4, NUM_CATEGORY)
else:
model = great_networks.se_resnet50(num_classes=NUM_CATEGORY, pretrained=None)
model.avg_pool = torch.nn.AdaptiveAvgPool2d(1)
elif architecture == "se_resnext50":
if pretrained:
model = great_networks.se_resnext50_32x4d(pretrained=pretrained)
model.last_linear = torch.nn.Linear(512 * 4, NUM_CATEGORY)
else:
model = great_networks.se_resnext50_32x4d(num_classes=NUM_CATEGORY, pretrained=None)
model.avg_pool = torch.nn.AdaptiveAvgPool2d(1)
elif architecture == "original":
model = network.ResNet(network.BasicBlock, [3, 4, 6, 3], num_classes=NUM_CATEGORY)
else:
raise ValueError()
model.to(DEVICE)
if is_train:
model.train()
else:
model.eval()
return model
def block_mobilenet(pretrained=False,
bit_nmb=8,
block_size=32,
num_classes=1000):
block_model = BlockMobileNetV2(block_size, n_class=num_classes)
if pretrained:
model = MobileNetV2.MobileNetV2()
model = torch.nn.DataParallel(model).cuda()
model.load_state_dict(
torch.load(
'../MobileNet-V2-Pytorch/mobilenetv2_Top1_71.806_Top2_90.410.pth.tar'
))
block_model = torch.nn.DataParallel(block_model).cuda()
eng = DSConvEngine(block_size, bit_nmb)
block_model = eng(model, block_model)
return block_model
batch_size=config.batch_size,
shuffle=True,
num_workers=config.workers,
pin_memory=True)
eval_loader = torch.utils.data.DataLoader(dataset=eval_set,
batch_size=config.batch_size,
shuffle=True,
num_workers=config.workers,
pin_memory=True)
# create model
# create model
if config.model == 'MobileNet':
model = MobileNet.MobileNet()
elif config.model == 'MobileNetV2':
model = MobileNetV2.MobileNetV2()
else:
print('selece currect model')
exit(0)
model = torch.nn.DataParallel(model)
model = model.to(device)
# load
model.load_state_dict(torch.load(config.model + '.pt'))
# test
model.eval()
correct = 0
total = 0
for i, (input, target) in enumerate(train_loader):
input, target = input.to(device), target.to(device)
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input]
import pandas as pd
import numpy as np
import cv2
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MultiLabelBinarizer
INP = 224
BATCHSIZE = 128
# -------------- MobileNetV2 ------------
model_mobileNetV2 = MobileNetV2(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape = (INP,INP,3),
)
model_mobileNetV2.trainable = False
keras_input = Input(shape=(INP, INP, 3), name = 'image_input')
#Add the fully-connected layers
output_mobileNetV2 = model_mobileNetV2(keras_input)
x = Flatten()(output_mobileNetV2)
x = Dense(4096, activation='relu', name='fc1')(x)
prediction = Dense(num_classes, activation='sigmoid', name='predictions')(x)
pretrained_model_mobile = Model(inputs=keras_input, outputs=prediction)
def __init__(self,
backbone="mobilenetv2",
num_classes=2,
pretrained_backbone=None):
super(UNet, self).__init__()
if backbone == 'mobilenetv2':
alpha = 1.0
expansion = 6
self.backbone = MobileNetV2.MobileNetV2(alpha=alpha,
expansion=expansion,
num_classes=None)
self._run_backbone = self._run_backbone_mobilenetv2
# Stage 1
channel1 = MobileNetV2._make_divisible(int(96 * alpha), 8)
block_unit = MobileNetV2.InvertedResidual(2 * channel1, channel1,
1, expansion)
self.decoder1 = DecoderBlock(self.backbone.last_channel, channel1,
block_unit)
# Stage 2
channel2 = MobileNetV2._make_divisible(int(32 * alpha), 8)
block_unit = MobileNetV2.InvertedResidual(2 * channel2, channel2,
1, expansion)
self.decoder2 = DecoderBlock(channel1, channel2, block_unit)
# Stage 3
channel3 = MobileNetV2._make_divisible(int(24 * alpha), 8)
block_unit = MobileNetV2.InvertedResidual(2 * channel3, channel3,
1, expansion)
self.decoder3 = DecoderBlock(channel2, channel3, block_unit)
# Stage 4
channel4 = MobileNetV2._make_divisible(int(16 * alpha), 8)
block_unit = MobileNetV2.InvertedResidual(2 * channel4, channel4,
1, expansion)
self.decoder4 = DecoderBlock(channel3, channel4, block_unit)
elif 'resnet' in backbone:
if backbone == 'resnet18':
n_layers = 18
elif backbone == 'resnet34':
n_layers = 34
elif backbone == 'resnet50':
n_layers = 50
elif backbone == 'resnet101':
n_layers = 101
else:
raise NotImplementedError
filters = 64
self.backbone = ResNet.get_resnet(n_layers, num_classes=None)
self._run_backbone = self._run_backbone_resnet
block = ResNet.BasicBlock if (
n_layers == 18 or n_layers == 34) else ResNet.Bottleneck
# Stage 1
last_channel = 8 * filters if (n_layers == 18
or n_layers == 34) else 32 * filters
channel1 = 4 * filters if (n_layers == 18
or n_layers == 34) else 16 * filters
downsample = nn.Sequential(ResNet.conv1x1(2 * channel1, channel1),
nn.BatchNorm2d(channel1))
block_unit = block(2 * channel1, int(channel1 / block.expansion),
1, downsample)
self.decoder1 = DecoderBlock(last_channel, channel1, block_unit)
# Stage 2
channel2 = 2 * filters if (n_layers == 18
or n_layers == 34) else 8 * filters
downsample = nn.Sequential(ResNet.conv1x1(2 * channel2, channel2),
nn.BatchNorm2d(channel2))
block_unit = block(2 * channel2, int(channel2 / block.expansion),
1, downsample)
self.decoder2 = DecoderBlock(channel1, channel2, block_unit)
# Stage 3
channel3 = filters if (n_layers == 18
or n_layers == 34) else 4 * filters
downsample = nn.Sequential(ResNet.conv1x1(2 * channel3, channel3),
nn.BatchNorm2d(channel3))
block_unit = block(2 * channel3, int(channel3 / block.expansion),
1, downsample)
self.decoder3 = DecoderBlock(channel2, channel3, block_unit)
# Stage 4
channel4 = filters
downsample = nn.Sequential(ResNet.conv1x1(2 * channel4, channel4),
nn.BatchNorm2d(channel4))
block_unit = block(2 * channel4, int(channel4 / block.expansion),
1, downsample)
self.decoder4 = DecoderBlock(channel3, channel4, block_unit)
else:
raise NotImplementedError
self.conv_last = nn.Sequential(
nn.Conv2d(channel4, 3, kernel_size=3, padding=1),
nn.Conv2d(3, num_classes, kernel_size=3, padding=1),
)
# Initialize
self._init_weights()
if pretrained_backbone is not None:
self.backbone._load_pretrained_model(pretrained_backbone)
train_imgs = [s for s in all_imgs if s['imageset'] == 'train']
val_imgs = [s for s in all_imgs if s['imageset'] == 'val']
print('Num train samples {}'.format(len(train_imgs)))
print('Num val samples {}'.format(len(val_imgs)))
data_gen_train = generators.get_anchor_gt(train_imgs, C, shuffle_net.get_img_output_length, mode='train')
data_gen_val = generators.get_anchor_gt(val_imgs, C, shuffle_net.get_img_output_length, mode='val')
img_input = layers.Input(shape=(None, None, 3))
roi_input = layers.Input(shape=(None, 4))
# define the base network, here is ShuffleNet
# shared_layers = shuffle_net.shuffle_net(img_input)
# shared_layers = shuffle_net.nn_base(img_input)
shared_layers = MobileNetV2.nn_base(img_input)
# define the RPN, built on the base layers
num_anchors = len(C.anchor_box_scales) * len(C.anchor_box_ratios)
rpn = MobileNetV2.rpn(shared_layers, num_anchors)
classifier = MobileNetV2.classifier(shared_layers, roi_input, C.num_rois, nb_classes=len(classes_count))
# define model
model_rpn = Model(img_input, rpn[:2])
model_classifier = Model([img_input, roi_input], classifier)
if C.model_path is not None:
print('Load weight from ' + C.model_path)
model_rpn.load_weights(C.model_path, by_name=True)
model_classifier.load_weights(C.model_path, by_name=True)
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
print(
'\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
test_loss, correct, len(test_loader.dataset),
100. * correct / len(test_loader.dataset)))
if __name__ == "__main__":
epochs = 50
use_cuda = True
device = torch.device("cuda" if use_cuda else "cpu")
model = MobileNetV2.MobileNetV2(width_mult=1, n_class=5005).to(device)
save_model = True
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
# load params
pretrained_dict = torch.load('mobilenetv2_1.0-f2a8633.pth.tar')
# 获取当前网络的dict
net_state_dict = model.state_dict()
# print(net_state_dict)
# 剔除不匹配的权值参数
pretrained_dict_1 = {
k: v
for k, v in pretrained_dict.items()
if k in net_state_dict and "classifier" not in k
}