I was trying to quantize a vgg model , following the steps given in https://pytorch.org/tutorials/advanced/static_quantization_tutorial.html

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’