def __init__(
self,
inplanes,
planes,
bits,
stride=1,
downsample=None,
groups=1,
base_width=64,
dilation=1,
norm_layer=None,
):
super(QuantBasicBlock, self).__init__()
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
self.conv1 = quant_conv3x3(inplanes, planes, stride)
self.bn1 = norm_layer(planes)
self.activation1 = BFPActivation(bits.pop(1), 32)
self.relu = nn.ReLU(inplace=True)
self.conv2 = quant_conv3x3(planes, planes)
self.bn2 = norm_layer(planes)
self.activation2 = BFPActivation(bits.pop(1), 32)
self.downsample = downsample
self.stride = stride
def __init__(
self,
inplanes,
planes,
bits,
stride=1,
downsample=None,
groups=1,
base_width=64,
dilation=1,
norm_layer=None,
):
super(QuantBottleneck, self).__init__()
if norm_layer is None:
norm_layer = nn.BatchNorm2d
width = int(planes * (base_width / 64.0)) * groups
# Both self.conv2 and self.downsample layers downsample the input when stride != 1
self.conv1 = quant_conv1x1(inplanes, width)
self.bn1 = norm_layer(width)
self.activation1 = BFPActivation(bits.pop(1), 32)
self.conv2 = quant_conv3x3(width, width, stride, groups, dilation)
self.bn2 = norm_layer(width)
self.activation2 = BFPActivation(bits.pop(1), 32)
self.conv3 = quant_conv1x1(width, planes * self.expansion)
self.bn3 = norm_layer(planes * self.expansion)
self.activation3 = BFPActivation(bits.pop(1), 32)
self.relu = nn.ReLU(inplace=True)
self.downsample = downsample
self.stride = stride
def __init__(self, in_planes, planes, bits, stride=1, last=False):
super(QuantBottleneck, self).__init__()
shortcut_bit = bits.pop(0)
self.conv1 = DSConv2d(
in_planes,
planes,
kernel_size=1,
block_size=32,
bit=shortcut_bit,
bias=False,
)
self.activation1 = BFPActivation(bits[0], blk=32)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = DSConv2d(
planes,
planes,
kernel_size=3,
block_size=32,
bit=bits.pop(0),
stride=stride,
padding=1,
bias=False,
)
self.activation2 = BFPActivation(bits[0], blk=32)
self.bn2 = nn.BatchNorm2d(planes)
self.conv3 = DSConv2d(
planes,
self.expansion * planes,
kernel_size=1,
block_size=32,
bit=bits.pop(0),
bias=False,
)
self.activation3 = nn.Identity() if last else BFPActivation(bits[0], blk=32)
self.bn3 = nn.BatchNorm2d(self.expansion * planes)
self.shortcut = nn.Sequential()
if stride != 1 or in_planes != self.expansion * planes:
self.shortcut = nn.Sequential(
DSConv2d(
in_planes,
self.expansion * planes,
block_size=32,
bit=shortcut_bit,
kernel_size=1,
stride=stride,
bias=False,
),
nn.BatchNorm2d(self.expansion * planes),
)
def __init__(self, in_planes, planes, bits, stride=1):
super(QuantBasicBlock, self).__init__()
first_bit = bits.pop(0)
self.conv1 = DSConv2d(
in_planes,
planes,
3,
block_size=32,
bit=first_bit,
stride=stride,
padding=1,
bias=False,
)
self.bn1 = nn.BatchNorm2d(planes)
self.activation1 = BFPActivation(bits[0], 32)
self.conv2 = DSConv2d(
planes,
planes,
kernel_size=3,
block_size=32,
bit=bits.pop(0),
stride=1,
padding=1,
bias=False,
)
self.bn2 = nn.BatchNorm2d(planes)
# This is just because the last layer doesn't need to quantize the activation
self.activation2 = (
BFPActivation(bits[0], 32) if len(bits) > 0 else nn.Identity()
)
self.shortcut = nn.Sequential()
if stride != 1 or in_planes != self.expansion * planes:
self.shortcut = nn.Sequential(
DSConv2d(
in_planes,
self.expansion * planes,
1,
block_size=32,
bit=first_bit,
stride=stride,
bias=False,
),
nn.BatchNorm2d(self.expansion * planes),
)
def _make_layers(self, cfg, bits):
layers = []
in_channels = 3
counter = 0
number_layers = len([l for l in cfg if l != "M"])
# print(number_layers)
for x in cfg:
if x == "M":
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
counter += 1 # Notice that first activation is in index 2
if counter == number_layers:
layers += [
DSConv2d(
in_channels,
x,
3,
32,
bits[counter - 1],
padding=1,
bias=True,
),
nn.BatchNorm2d(x),
nn.ReLU(inplace=True),
]
else:
layers += [
DSConv2d(
in_channels,
x,
3,
32,
bits[counter - 1],
padding=1,
bias=True,
),
nn.BatchNorm2d(x),
nn.ReLU(inplace=True),
BFPActivation(bits[counter], 32),
]
# nnActivation(bits[counter], 7, 32)]
in_channels = x
layers += [nn.AvgPool2d(kernel_size=1, stride=1)]
return nn.Sequential(*layers)
def __init__(self, block, num_blocks, bits, num_classes=10):
super(QUANTIZED_ResNet, self).__init__()
self.in_planes = 64
_bits_ = bits.copy()
self.conv1 = DSConv2d(
3,
64,
kernel_size=3,
block_size=32,
bit=_bits_.pop(0),
stride=1,
padding=1,
bias=False,
)
self.activation = BFPActivation(_bits_[0], 32)
self.bn1 = nn.BatchNorm2d(64)
self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1, bits=_bits_)
self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2, bits=_bits_)
self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2, bits=_bits_)
self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2, bits=_bits_)
self.linear = nn.Linear(512 * block.expansion, num_classes)
def __init__(self, block, num_blocks, bits, number_bits, num_classes=1000):
super(QUANTIZED_ResNet, self).__init__(bits, number_bits)
self.in_planes = 64
self.conv1 = DSConv2d(
3,
64,
kernel_size=3,
block_size=32,
bit=self.bits.pop(0),
stride=1,
padding=1,
bias=False,
)
self.activation1 = BFPActivation(self.bits[0], blk=32)
self.bn1 = nn.BatchNorm2d(64)
self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2, last=True)
self.linear = nn.Linear(512 * block.expansion, num_classes)
print(self.bits)
def _make_layers(self, cfg):
layers = []
in_channels = 3
length_config = len(cfg)
for i, x in enumerate(cfg):
if x == "M":
layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
else:
bit = self.bits.pop(0)
layers += [
DSConv2d(in_channels,
x,
kernel_size=3,
block_size=32,
bit=bit,
padding=1),
nn.BatchNorm2d(x),
nn.ReLU(inplace=True),
]
if i < len(cfg) - 2:
layers += [BFPActivation(self.bits[0], blk=32)]
in_channels = x
layers += [nn.AvgPool2d(kernel_size=1, stride=1)]
return nn.Sequential(*layers)
def __init__(
self,
block,
layers,
bits,
num_classes=1000,
zero_init_residual=False,
groups=1,
width_per_group=64,
replace_stride_with_dilation=None,
norm_layer=None,
):
super(QUANTIZED_ResNet, self).__init__()
_bits_ = bits.copy()
if type(_bits_) is not list:
_bits_ = bits.tolist().copy()
if norm_layer is None:
norm_layer = nn.BatchNorm2d
self._norm_layer = norm_layer
self.inplanes = 64
self.dilation = 1
if replace_stride_with_dilation is None:
# each element in the tuple indicates if we should replace
# the 2x2 stride with a dilated convolution instead
replace_stride_with_dilation = [False, False, False]
if len(replace_stride_with_dilation) != 3:
raise ValueError("replace_stride_with_dilation should be None "
"or a 3-element tuple, got {}".format(
replace_stride_with_dilation))
self.groups = groups
self.base_width = width_per_group
self.conv1 = DSConv2d(
3,
self.inplanes,
kernel_size=7,
block_size=32,
stride=2,
padding=3,
bias=False,
)
self.activation = BFPActivation(_bits_.pop(1), 32)
self.bn1 = norm_layer(self.inplanes)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0], _bits_)
self.layer2 = self._make_layer(
block,
128,
layers[1],
_bits_,
stride=2,
dilate=replace_stride_with_dilation[0],
)
self.layer3 = self._make_layer(
block,
256,
layers[2],
_bits_,
stride=2,
dilate=replace_stride_with_dilation[1],
)
self.layer4 = self._make_layer(
block,
512,
layers[3],
_bits_,
stride=2,
dilate=replace_stride_with_dilation[2],
)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
# Zero-initialize the last BN in each residual branch,
# so that the residual branch starts with zeros, and each residual block behaves like an identity.
# This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
if zero_init_residual:
for m in self.modules():
if isinstance(m, QuantBottleneck):
nn.init.constant_(m.bn3.weight, 0)
elif isinstance(m, QuantBasicBlock):
nn.init.constant_(m.bn2.weight, 0)