I was trying to quantize a vgg model , following the steps given in https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html 13
I did the first step as follows:
import torch.nn as nn
#from .utils import load_state_dict_from_url
all = [
‘Cifar_VGG’, ‘cifar_rvgg11’, ‘cifar_rvgg11_bn’, ‘cifar_vgg11’, ‘cifar_vgg11_bn’, ‘cifar_vgg13’, ‘cifar_vgg13_bn’, ‘cifar_vgg16’, ‘cifar_vgg16_bn’,
‘cifar_vgg19_bn’, ‘cifar_vgg19’,
]
model_urls = {
'cifar_vgg11_bn': 'https://download.pytorch.org/models/vgg11_bn-6002323d.pth',

}
class Cifar_VGG(nn.Module):
def __init__(self, features, num_classes=1000, init_weights=True):
    super(Cifar_VGG, self).__init__()
    self.features = features
    self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
    self.quant = QuantStub()
    self.dequant = DeQuantStub()
    self.classifier = nn.Sequential(
        nn.Linear(512, 512),
        nn.BatchNorm1d(512),
        nn.ReLU(True),
        nn.Linear(512, num_classes),
    )
    if init_weights:
        self._initialize_weights()

def forward(self, x):
    x = self.quant(x)
    x = self.features(x)
    x = self.avgpool(x)
    x = x.view(x.size(0), -1)
    x = self.classifier(x)
    x = self.dequant(x)

    return x

def _initialize_weights(self):
    for m in self.modules():
        if isinstance(m, nn.Conv2d):
            nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            if m.bias is not None:
                nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.BatchNorm2d):
            nn.init.constant_(m.weight, 1)
            nn.init.constant_(m.bias, 0)
        elif isinstance(m, nn.Linear):
            nn.init.normal_(m.weight, 0, 0.01)
            nn.init.constant_(m.bias, 0)

def fuse_model(self):
    torch.quantization.fuse_modules(self, [['conv2d', 'BatchNorm2d', 'ReLU'],
                                        ],inplace=True)

def make_layers(cfg, batch_norm=False):
layers = []
in_channels = 3
for v in cfg:
if v == ‘M’:
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = v
return nn.Sequential(*layers)
cfgs = {
‘RA’:[512,‘M’, 512, ‘M’, 512, 512, ‘M’, 512, 512, ‘M’, 512, 512, ‘M’],
‘A’: [64, ‘M’, 128, ‘M’, 256, 256, ‘M’, 512, 512, ‘M’, 512, 512, ‘M’],
‘B’: [64, 64, ‘M’, 128, 128, ‘M’, 256, 256, ‘M’, 512, 512, ‘M’, 512, 512, ‘M’],
‘D’: [64, 64, ‘M’, 128, 128, ‘M’, 256, 256, 256, ‘M’, 512, 512, 512, ‘M’, 512, 512, 512, ‘M’],
‘E’: [64, 64, ‘M’, 128, 128, ‘M’, 256, 256, 256, 256, ‘M’, 512, 512, 512, 512, ‘M’, 512, 512, 512, 512, ‘M’],
}
def _vgg(arch, cfg, batch_norm, pretrained, progress, **kwargs):
if pretrained:
kwargs[‘init_weights’] = False
model = Cifar_VGG(make_layers(cfgs[cfg], batch_norm=batch_norm), **kwargs)
if pretrained:
state_dict = load_state_dict_from_url(model_urls[arch],
progress=progress)
model.load_state_dict(state_dict)
return model
def cifar_rvgg11_bn(pretrained=False, progress=True, **kwargs):
return _vgg(‘cifar_rvgg11’, ‘RA’, True, pretrained, progress, **kwargs)
net.fuse_model()
Gives the following error
‘Cifar_VGG’ object has no attribute ‘conv2d’