def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
base_width=64, dilation=1, norm_layer=None,k_bits = 8):
super(OriQuantBasicBlock, self).__init__()
self.k_bits = k_bits
if norm_layer is None:
norm_layer = nn.BatchNorm2d
if groups != 1 or base_width != 64:
raise ValueError('BasicBlock only supports groups=1 and base_width=64')
if dilation > 1:
raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
# Both self.conv1 and self.downsample layers downsample the input when stride != 1
## Layer 1 ##
self.conv1 = quant_conv3x3(inplanes,planes,kernel_size=3,stride=stride,bias=False,k_bits=self.k_bits)
self.bn1 = norm_layer(planes)
self.relu1 = pact_quantize(self.k_bits)
# self.conv1 = quant_conv3x3(inplanes,planes,kernel_size=3,stride=stride,bias=False,k_bits=self.k_bits)
## Layer 2 ##
self.conv2 = quant_conv3x3(planes,planes,kernel_size=3,stride=1,bias=False,k_bits=self.k_bits)
self.bn2 = norm_layer(planes)
self.relu2 = pact_quantize(self.k_bits)
self.downsample = downsample
self.stride = stride
def __init__(self, in_planes, planes, stride=1, option='A',k_bits = 8):
super(QuantBasicBlock, self).__init__()
self.k_bits = k_bits
self.bn1 = nn.BatchNorm2d(in_planes)
self.relu1 = pact_quantize(self.k_bits)
self.conv1= quant_conv3x3(in_planes,planes,kernel_size=3,stride=stride,padding=1,bias=False,k_bits=self.k_bits)
self.bn2 = nn.BatchNorm2d(planes)
self.relu2 = pact_quantize(self.k_bits)
self.conv2 = quant_conv3x3(planes,planes,kernel_size=3,stride=1,padding=1,bias=False,k_bits=self.k_bits)
self.shortcut = nn.Sequential()
if stride != 1 or in_planes != planes:
if option == 'A':
"""
For CIFAR10 ResNet paper uses option A.
"""
self.shortcut = LambdaLayer(lambda x:
F.pad(x[:, :, ::2, ::2], (0, 0, 0, 0, planes//4, planes//4), "constant", 0))
elif option == 'B':
self.shortcut = nn.Sequential(
nn.Conv2d(in_planes, self.expansion * planes, kernel_size=1, stride=stride, bias=False),
nn.BatchNorm2d(self.expansion * planes)
)
def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,
base_width=64, dilation=1, norm_layer=None,k_bits = 8):
super(QuantBottleneck, self).__init__()
# print(f'********************* QuantBottleNeck ************************')
self.k_bits = k_bits
if norm_layer is None:
norm_layer = nn.BatchNorm2d
width = int(planes * (base_width / 64.)) * groups
# Both self.conv2 and self.downsample layers downsample the input when stride != 1
# print(f'inplanes {inplanes} | width {width} | planes {planes}')
self.bn1 = norm_layer(inplanes)
self.relu1 = pact_quantize(inplanes)
self.conv1 = quant_conv3x3(inplanes,width,kernel_size=1,stride=1, padding=0,dilation=1,bias=False,k_bits= self.k_bits)
self.bn2 = norm_layer(width)
self.relu2 = pact_quantize(self.k_bits)
self.conv2 = quant_conv3x3(width,width,kernel_size=3,stride=stride,bias=False,k_bits=self.k_bits)
self.bn3 = norm_layer(width)
self.relu3 = pact_quantize(self.k_bits)
self.conv3 = quant_conv3x3(width,planes * self.expansion,kernel_size=1,padding=0,dilation=1,stride=1,bias=False,k_bits = self.k_bits)
self.downsample = downsample
self.stride = stride
def __init__(self, inp, oup, stride, expand_ratio, k_bits=8, **kwargs):
super(InvertedResidual, self).__init__()
self.k_bits = k_bits
self.stride = stride
assert stride in [1, 2]
hidden_dim = round(inp * expand_ratio)
self.use_res_connect = self.stride == 1 and inp == oup
if expand_ratio == 1:
self.conv = nn.Sequential(
#pw
nn.BatchNorm2d(hidden_dim),
pact_quantize(self.k_bits),
quant_conv3x3(hidden_dim,
hidden_dim,
3,
1,
stride,
1,
bias=False,
groups=hidden_dim,
k_bits=self.k_bits),
# pw-linear
nn.BatchNorm2d(hidden_dim),
pact_quantize(self.k_bits),
quant_conv3x3(hidden_dim, oup, 1, 0, 1, 1, bias=False))
else:
self.conv = nn.Sequential(
# pw
nn.BatchNorm2d(inp),
pact_quantize(self.k_bits),
quant_conv3x3(inp, hidden_dim, 1, 0, 1, 1, bias=False),
# dw
nn.BatchNorm2d(hidden_dim),
pact_quantize(self.k_bits),
quant_conv3x3(hidden_dim,
hidden_dim,
3,
1,
stride,
1,
bias=False,
groups=hidden_dim),
# pw-linear
nn.BatchNorm2d(hidden_dim),
pact_quantize(self.k_bits),
quant_conv3x3(hidden_dim, oup, 1, 0, 1, 1, bias=False))
def quant_conv_bn(inp, oup, stride, k_bits=8):
return nn.Sequential(
nn.BatchNorm2d(inp), pact_quantize(k_bits=k_bits),
quant_conv3x3(inp,
oup,
kernel_size=3,
stride=stride,
padding=1,
bias=False))
def __init__(self, inplanes, filters,index,expansion=1, growthRate=12, dropRate=0,k_bits = 8):
super(DenseBasicBlock, self).__init__()
self.k_bits = k_bits
self.bn = nn.BatchNorm2d(inplanes)
self.relu = pact_quantize(self.k_bits)
self.conv = quant_conv3x3(filters,growthRate,kernel_size=3,stride=1,padding=1,bias=False,k_bits=self.k_bits)
self.dropRate = dropRate
def __init__(self, inplanes, outplanes, filters, index, k_bits=8):
super(Transition, self).__init__()
self.k_bits = k_bits
self.bn = nn.BatchNorm2d(inplanes)
self.relu = pact_quantize(self.k_bits)
self.conv = quant_conv3x3(filters,
outplanes,
kernel_size=1,
stride=1,
padding=0,
bias=False,
k_bits=self.k_bits)
def __init__(self, features, num_classes=10, init_weights=True,k_bits = 8):
super(VGG, self).__init__()
self.k_bits=k_bits
self.features = features
self.avgpool = nn.AdaptiveAvgPool2d((7, 7))
self.classifier = nn.Sequential(
# nn.Linear(512 * 7 * 7, 4096),
# nn.ReLU(True),
# # nn.Dropout(),
# nn.Linear(4096, 4096),
# nn.ReLU(True),
# # nn.Dropout(),
# nn.Linear(4096, num_classes),
pact_quantize(self.k_bits),
quant_linear(512 * 7 * 7, 4096,bias=True,k_bits=self.k_bits),
# nn.Dropout(),
pact_quantize(self.k_bits),
quant_linear(4096, 4096,bias=True,k_bits=self.k_bits),
# nn.Dropout(),
nn.Linear(4096, num_classes),
)
if init_weights:
self._initialize_weights()
def make_layers(cfg, batch_norm=False,k_bits=8):
layers = []
in_channels = 1
for v in cfg:
if v == 'M':
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
if in_channels == 1:
conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1)
relu = nn.ReLU(inplace=True)
else:
conv2d = quant_conv3x3(in_channels,v)
relu = pact_quantize(k_bits)
if batch_norm:
layers += [nn.BatchNorm2d(in_channels),relu,conv2d]
else:
layers += [relu,conv2d]
in_channels = v
return nn.Sequential(*layers)
