def __init__(self, subtype='squeezenet1_1', out_stages=[1, 2, 3], backbone_path=None): super(SqueezeNet, self).__init__() self.out_stages = out_stages self.backbone_path = backbone_path if subtype == 'squeezenet1_1': features = squeezenet1_1( pretrained=not self.backbone_path).features self.out_channels = [96, 128, 256, 512] else: raise NotImplementedError self.out_channels = self.out_channels[self.out_stages[0]:self. out_stages[-1] + 1] self.conv1 = nn.Sequential(*list(features.children())[0:2]) self.layer1 = nn.Sequential(*list(features.children())[2:5]) self.layer2 = nn.Sequential(*list(features.children())[5:8]) self.layer3 = nn.Sequential(*list(features.children())[8:13]) if self.backbone_path: self.features.load_state_dict(torch.load(self.backbone_path)) else: self.init_weights()
def squeezenet(pretrained=True): model = SqueezeNet() if pretrained: from torchvision.models.squeezenet import squeezenet1_1 source_state = squeezenet1_1(pretrained=True).features.state_dict() load_weights_sequential(model, source_state) return model
def __init__(self, pretrained=False): super(SqueezeNet, self).__init__() self.feat_1 = nn.Sequential( nn.Conv2d(3, 64, kernel_size=3, stride=2, padding=1), nn.ReLU(inplace=True) ) self.feat_2 = nn.Sequential( nn.MaxPool2d(kernel_size=3, stride=2, padding=1), Fire(64, 16, 64, 64), Fire(128, 16, 64, 64) ) self.feat_3 = nn.Sequential( nn.MaxPool2d(kernel_size=3, stride=2, padding=1), Fire(128, 32, 128, 128, 2), Fire(256, 32, 128, 128, 2) ) self.feat_4 = nn.Sequential( Fire(256, 48, 192, 192, 4), Fire(384, 48, 192, 192, 4), Fire(384, 64, 256, 256, 4), Fire(512, 64, 256, 256, 4) ) if pretrained: weights = squeezenet1_1(pretrained=True).features.state_dict() load_weights_sequential(self, weights)
def __init__(self, feature_levels=(3, 4, 5), pretrained=True): super().__init__() _check_levels(feature_levels) self.forward_levels = tuple(range(1, feature_levels[-1] + 1)) self.feature_levels = feature_levels from torchvision.models.squeezenet import squeezenet1_1, Fire backbone = squeezenet1_1(pretrained=pretrained) del backbone.classifier backbone = backbone.features backbone[0].padding = (1, 1) self.layer1 = backbone[:2] self.layer2 = backbone[2:5] self.layer3 = backbone[5:8] self.layer4 = backbone[8:] if 5 in feature_levels: self.layer5 = nn.Sequential( nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True), Fire(512, 64, 256, 256), ) channels = [64, 128, 256, 512, 512] self.out_channels = [channels[i - 1] for i in feature_levels]
def __init__(self, pretrained=True): super(FurnitureSqueezeNet350, self).__init__() model = squeezenet1_1(pretrained=pretrained) self.features = model.features # Final convolution is initialized differently form the rest final_conv = Conv2d(512, 128, kernel_size=1) self.classifier = Sequential(Dropout(p=0.5), final_conv, ReLU(inplace=True), AdaptiveAvgPool2d(1)) for m in final_conv.modules(): normal_(m.weight, mean=0.0, std=0.01) if m.bias is not None: constant_(m.bias, 0.0)
def get_small_squeezenet_v1_1(num_classes): model = squeezenet1_1(num_classes=num_classes, pretrained=False) # As input image size is small 64x64, we modify first layers: # replace : Conv2d(3, 64, (3, 3), stride=(2, 2)) by Conv2d(3, 64, (3, 3), stride=(1, 1), padding=1) # replace : MaxPool2d (size=(3, 3), stride=(2, 2), dilation=(1, 1))) # by MaxPool2d (size=(2, 2), stride=(1, 1)) layers = [l for i, l in enumerate(model.features)] layers[0] = Conv2d(3, 64, kernel_size=(3, 3), padding=1) layers[2] = MaxPool2d(kernel_size=2, stride=1) model.features = Sequential(*layers) # Replace the last AvgPool2d -> AdaptiveAvgPool2d layers = [l for l in model.classifier] layers[-1] = AdaptiveAvgPool2d(1) model.classifier = Sequential(*layers) return model
def recordSqueeze(info): global SKIP import torchvision.models.squeezenet as sqGen if not (SKIP and 'squeezenet1_0' in info['name_list']): INFO("proceeding for squeezenet1_0") net = sqGen.squeezenet1_0(pretrained=True).cuda() sum = __summary(net, [3, 224, 224], verbose=True) __writeInfoJSON(sum, 'squeezenet1_0') else: INFO("Skip squeezenet1_0") if not (SKIP and 'squeezenet1_1' in info['name_list']): INFO("proceeding for squeezenet1_1") net = sqGen.squeezenet1_1(pretrained=True).cuda() sum = __summary(net, [3, 224, 224], verbose=True) __writeInfoJSON(sum, 'squeezenet1_1') else: INFO("Skip squeezenet1_1")
def __init__(self, pretrained=True, n_crops=6): super(FurnitureSqueezeNetOnCrops, self).__init__() model = squeezenet1_1(pretrained=pretrained) self.features = model.features self.crop_classifiers = [] for i in range(n_crops): # Final convolution is initialized differently form the rest final_conv = Conv2d(512, 512, kernel_size=1, bias=False) self.crop_classifiers.append( Sequential(Dropout(p=0.5), final_conv, ReLU(inplace=True), AdaptiveAvgPool2d(1))) for m in final_conv.modules(): normal_(m.weight, mean=0.0, std=0.01) if m.bias is not None: constant_(m.bias, 0.0) self.crop_classifiers = ModuleList(self.crop_classifiers) self.final_classifier = Linear(512, 128) for m in self.final_classifier.modules(): normal_(m.weight, mean=0.0, std=0.01) if m.bias is not None: constant_(m.bias, 0.0)
from torchvision.models.squeezenet import squeezenet1_1 from PIL import Image INFER_FOLDER = r"C:\Users\Moses\Documents\Moses\W7\AI\ImageAI\ImageAI 1.0.2 Repo\images" MODEL_PATH = r"C:\Users\Moses\Documents\Prime Project\AI\PyTorch\tests\squeezenet.pth" transformations = transforms.Compose([ transforms.Resize((224,224)), transforms.ToTensor(), transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5)) ]) infer_set = tf.ImagesFromPaths([INFER_FOLDER],recursive=False,transformations=transformations) infer_loader = DataLoader(infer_set,batch_size=2) net = squeezenet1_1() model = tf.StandardModel(net) model.load_model(MODEL_PATH) def predict_loader(data_loader): predictions = model.predict(data_loader,apply_softmax=True) print(len(predictions)) for pred in predictions: class_index = torch.argmax(pred) class_name = tf.decode_imagenet(class_index) confidence = torch.max(pred) print("Prediction: {} , Accuracy: {} ".format(class_name, confidence)) def predict_image(image_path):
if BACKBONE == 'resnet18': net = resnet18(num_classes=num_classes).to(device) elif BACKBONE == 'resnet34': net = resnet34(num_classes=num_classes).to(device) elif BACKBONE == 'resnet50': net = resnet50(num_classes=num_classes).to(device) elif BACKBONE == 'densenet121': net = densenet121(num_classes=num_classes).to(device) elif BACKBONE == 'mobilenet_v2': net = mobilenet_v2(num_classes=num_classes, width_mult=1.0, inverted_residual_setting=None, round_nearest=8).to(device) elif BACKBONE == 'shufflenet_v2_x1_5': net = shufflenet_v2_x1_5(num_classes=num_classes).to(device) elif BACKBONE == 'squeezenet1_0': net = squeezenet1_0(num_classes=num_classes).to(device) elif BACKBONE == 'squeezenet1_1': net = squeezenet1_1(num_classes=num_classes).to(device) elif BACKBONE == 'mnasnet0_5': net = mnasnet0_5(num_classes=num_classes).to(device) elif BACKBONE == 'mnasnet1_0': net = mnasnet1_0(num_classes=num_classes).to(device) elif BACKBONE == 'mobilenet_v1': net = MobileNetV1(num_classes=num_classes).to(device) else: raise Exception('unknow backbone: {}'.format(BACKBONE)) for m in net.modules(): if isinstance(m, nn.Conv2d): nn.init.xavier_normal_(m.weight.data) if m.bias is not None: m.bias.data.zero_() elif isinstance(m, nn.BatchNorm2d):
def loss_selector(loss_net): #base if loss_net == "vgg16": from torchvision.models.vgg import vgg16 net = vgg16(pretrained=True) loss_network = nn.Sequential(*list(net.features)[:31]).eval() return loss_network elif loss_net == "vgg16_bn": from torchvision.models.vgg import vgg16_bn net = vgg16_bn(pretrained=True) loss_network = nn.Sequential(*list(net.features)[:44]).eval() return loss_network elif loss_net == "resnet50": from torchvision.models.resnet import resnet50 net=resnet50(pretrained=True) loss_network=nn.Sequential(*[child_module for child_module in net.children()][:-2]).eval() return loss_network elif loss_net == "resnet101": from torchvision.models.resnet import resnet101 net=resnet101(pretrained=True) loss_network=nn.Sequential(*[child_module for child_module in net.children()][:-2]).eval() return loss_network elif loss_net == "resnet152": from torchvision.models.resnet import resnet152 net=resnet152(pretrained=True) loss_network=nn.Sequential(*[child_module for child_module in net.children()][:-2]).eval() return loss_network elif loss_net == "squeezenet1_1": from torchvision.models.squeezenet import squeezenet1_1 net=squeezenet1_1(pretrained=True) classifier=[item for item in net.classifier.modules()][1:-1] loss_network=nn.Sequential(*[net.features,*classifier]).eval() return loss_network elif loss_net == "densenet121": from torchvision.models.densenet import densenet121 net=densenet121(pretrained=True) loss_network=nn.Sequential(*[net.features,nn.ReLU()]).eval() return loss_network elif loss_net == "densenet169": from torchvision.models.densenet import densenet169 net=densenet169(pretrained=True) loss_network=nn.Sequential(*[net.features,nn.ReLU()]).eval() return loss_network elif loss_net == "densenet201": from torchvision.models.densenet import densenet201 net=densenet201(pretrained=True) loss_network=nn.Sequential(*[net.features,nn.ReLU()]).eval() return loss_network elif loss_net == "mobilenet_v2": from torchvision.models.mobilenet import mobilenet_v2 net=mobilenet_v2(pretrained=True) loss_network=nn.Sequential(*[net.features]).eval() return loss_network elif loss_net == "resnext50_32x4d": from torchvision.models.resnet import resnext50_32x4d net=resnext50_32x4d(pretrained=True) loss_network=nn.Sequential(*[child_module for child_module in net.children()][:-2]).eval() return loss_network elif loss_net == "resnext101_32x8d": from torchvision.models.resnet import resnext101_32x8d net=resnext101_32x8d(pretrained=True) loss_network=nn.Sequential(*[child_module for child_module in net.children()][:-2]).eval() return loss_network elif loss_net == "wide_resnet50_2": from torchvision.models.resnet import wide_resnet50_2 net=wide_resnet50_2(pretrained=True) loss_network=nn.Sequential(*[child_module for child_module in net.children()][:-2]).eval() return loss_network elif loss_net == "wide_resnet101_2": from torchvision.models.resnet import wide_resnet101_2 net=wide_resnet101_2(pretrained=True) loss_network=nn.Sequential(*[child_module for child_module in net.children()][:-2]).eval() return loss_network elif loss_net == "inception_v3":
def base_model(): full_model = squeezenet1_1(pretrained=True) feature_model = nn.Sequential(*list(full_model.features.children())[:-1]) return feature_model
#from .semantic.DeepSqueeze.models import DeepSqueeze as DeepSqueeze_ from torchvision.models._utils import IntermediateLayerGetter import torchvision.models.resnet as resnet from torch.nn import functional as F import os from collections import OrderedDict from torchvision.models.segmentation.deeplabv3 import DeepLabHead from torch import nn, hub from torchvision.models.squeezenet import squeezenet1_1 import torch import torchvision squeeze = squeezenet1_1(pretrained=False).eval() class DeepSqueeze_(nn.Module): def __init__(self, num_classes): super(DeepSqueeze_, self).__init__() backbone = squeeze.features classifier = DeepLabHead(512, num_classes) self.backbone = backbone self.classifier = classifier self.aux_classifier = None def forward(self, x): input_shape = x.shape[-2:]
from ignite.engine import Engine, _prepare_batch import torch.nn as nn from torchvision.models.squeezenet import squeezenet1_1 import torch.nn as nn from torch.optim import SGD from ignite.engine import Events device = "cpu" model = squeezenet1_1(pretrained=False, num_classes=81) model.classifier[-1] = nn.AdaptiveAvgPool2d(1) model = model.to(device) optimizer = SGD(model.parameters(), lr=0.01, momentum=0.5) criterion = nn.CrossEntropyLoss() def process_function(engine, batch): model.train() optimizer.zero_grad() x, y = _prepare_batch(batch, device=device) y_pred = model(x) loss = criterion(y_pred, y) loss.backward() optimizer.step() return loss.item() trainer = Engine(process_function) log_interval = 50