def __init__(self):
super(ErNET, self).__init__()
self.conv1 = qnn.QuantConv2d(
in_channels=3,
out_channels=16,
kernel_size=3,
padding=0,
bias=False,
stride=2,
weight_quant_type=QuantType.INT,
weight_bit_width=16,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.acff1 = ACFF(16, 64)
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.acff2 = ACFF(64, 96)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
self.acff3 = ACFF(96, 128)
self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
self.acff4 = ACFF(128, 128)
self.acff5 = ACFF(128, 128)
self.acff6 = ACFF(128, 256)
self.conv2 = qnn.QuantConv2d(
in_channels=256,
out_channels=5,
kernel_size=1,
padding=0,
stride=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=16,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.globalpool = nn.AvgPool2d(kernel_size=5, stride=1, padding=0)
self.fc = qnn.QuantLinear(
3 * 3 * 5,
5,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=16,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.soft = nn.Softmax(dim=1)
def make_layers(cfg, batch_norm, bit_width):
layers = []
in_channels = 3
assert not(batch_norm & RETURN_QUANT_TENSOR), "nn.BatchNorm2d does not accept Quant tensor"
for v in cfg:
if v == 'M':
layers += [qnn.QuantMaxPool2d(kernel_size=2, stride=2)]
else:
conv2d = qnn.QuantConv2d(in_channels, v,
kernel_size=3,
stride=1,
padding=1,
groups=1,
bias_quant=BIAS_QUANTIZER,
weight_bit_width=bit_width,
weight_quant=WEIGHT_QUANTIZER,
weight_scaling_min_val=SCALING_MIN_VAL,
weight_scaling_per_output_channel=WEIGHT_SCALING_PER_OUTPUT_CHANNEL,
return_quant_tensor=RETURN_QUANT_TENSOR)
conv2d.cache_inference_quant_out = True
conv2d.cache_inference_quant_bias = True
act = qnn.QuantReLU(bit_width=bit_width,
act_quant=ACT_QUANTIZER,
return_quant_tensor=RETURN_QUANT_TENSOR)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), act]
else:
layers += [conv2d, act]
in_channels = v
return nn.Sequential(*layers)
def conv1x1(in_planes, out_planes, stride=1, weight_bit_width=8):
"""1x1 convolution"""
return qnn.QuantConv2d(in_planes,
out_planes,
kernel_size=1,
stride=stride,
bias=False,
weight_bit_width=weight_bit_width)
def __init__(self, bit_width=8, weight_bit_width=8):
import brevitas.nn as qnn
from brevitas.core.quant import QuantType
super(QuantLeNet, self).__init__()
self.conv1 = qnn.QuantConv2d(1,
6,
5,
weight_quant_type=QuantType.INT,
weight_bit_width=weight_bit_width,
padding=2)
self.relu1 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=bit_width,
max_val=6)
self.conv2 = qnn.QuantConv2d(6,
16,
5,
weight_quant_type=QuantType.INT,
weight_bit_width=weight_bit_width,
padding=2)
self.relu2 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=bit_width,
max_val=6)
self.fc1 = qnn.QuantLinear(16 * 7 * 7,
120,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=weight_bit_width)
self.relu3 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=bit_width,
max_val=6)
self.fc2 = qnn.QuantLinear(120,
84,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=weight_bit_width)
self.relu4 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=bit_width,
max_val=6)
self.fc3 = qnn.QuantLinear(84,
10,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=weight_bit_width)
def create_model(first_layer_quant_type, first_layer_bit_width, weight_quant_type, weight_bit_width,
last_layer_quant_type, last_layer_bit_width, activation_quant_type, activation_bit_width,
activation_scaling_impl_type, activation_max_val, chan_mult=1):
return nn.Sequential(
ZeroAct(quant_type=QuantType.INT,
bit_width=8,
scaling_impl_type=ScalingImplType.CONST,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO),
qnn.QuantConv2d(in_channels=3, out_channels=int(chan_mult*96), kernel_size=11,
weight_quant_type=first_layer_quant_type,
weight_bit_width=first_layer_bit_width,
bias=False),
nn.BatchNorm2d(int(chan_mult*96), eps=1e-4),
MyQuantReLU(activation_max_val, activation_quant_type, activation_bit_width,
activation_scaling_impl_type),
nn.MaxPool2d(kernel_size=2, stride=2),
qnn.QuantConv2d(int(chan_mult*96), int(chan_mult*256), 5, weight_quant_type=weight_quant_type,
weight_bit_width=weight_bit_width, bias=False),
nn.BatchNorm2d(int(chan_mult*256), eps=1e-4),
MyQuantReLU(activation_max_val, activation_quant_type, activation_bit_width,
activation_scaling_impl_type),
qnn.QuantConv2d(int(chan_mult*256), int(chan_mult*384), 3, weight_quant_type=weight_quant_type,
weight_bit_width=weight_bit_width, bias=False),
nn.BatchNorm2d(int(chan_mult*384), eps=1e-4),
MyQuantReLU(activation_max_val, activation_quant_type, activation_bit_width,
activation_scaling_impl_type),
nn.MaxPool2d(kernel_size=3, stride=3),
qnn.QuantConv2d(int(chan_mult*384), int(chan_mult*384), 3, weight_quant_type=weight_quant_type,
weight_bit_width=weight_bit_width, bias=False),
nn.BatchNorm2d(int(chan_mult*384), eps=1e-4),
MyQuantReLU(activation_max_val, activation_quant_type, activation_bit_width,
activation_scaling_impl_type),
qnn.QuantConv2d(int(chan_mult*384), int(chan_mult*256), 3, weight_quant_type=last_layer_quant_type,
weight_bit_width=last_layer_bit_width, bias=False)
)
def __init__(self):
super(QuantLeNet, self).__init__()
self.conv1 = qnn.QuantConv2d(1,
6,
5,
weight_quant_type=QuantType.INT,
weight_bit_width=2,
padding=2,
bias=False)
self.relu1 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=2,
max_val=6)
self.conv2 = qnn.QuantConv2d(6,
16,
5,
weight_quant_type=QuantType.INT,
weight_bit_width=2,
bias=False)
self.relu2 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=2,
max_val=6)
self.fc1 = qnn.QuantLinear(16 * 5 * 5,
120,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=2)
self.relu3 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=2,
max_val=6)
self.fc2 = qnn.QuantLinear(120,
84,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=2)
self.relu4 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=2,
max_val=6)
self.fc3 = qnn.QuantLinear(84,
10,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=2)
def conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1, weight_bit_width=8):
"""3x3 convolution with padding"""
return qnn.QuantConv2d(
in_planes,
out_planes,
kernel_size=3,
stride=stride,
padding=dilation,
groups=groups,
bias=False,
dilation=dilation,
weight_bit_width=weight_bit_width,
)
def __init__(self):
super(Net, self).__init__()
# Defining a 2D convolution layer
self.conv1 = qnn.QuantConv2d(in_channels=1,
out_channels=4,
kernel_size=3,
stride=1,
padding=1,
weight_quant_type=QuantType.INT,
weight_bit_width=2,
bias=False)
self.relu1 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=2,
max_val=6)
# Defining another 2D convolution layer
self.conv2 = qnn.QuantConv2d(in_channels=4,
out_channels=4,
kernel_size=3,
stride=1,
padding=1,
weight_quant_type=QuantType.INT,
weight_bit_width=2,
bias=False)
self.relu2 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=2,
max_val=6)
self.fc1 = qnn.QuantLinear(in_features=4 * 7 * 7,
out_features=10,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=2)
def make_quant_conv2d(in_channels, out_channels, kernel_size, stride, padding,
bias, bit_width):
return qnn.QuantConv2d(
in_channels,
out_channels,
kernel_size=kernel_size,
padding=padding,
stride=stride,
bias=bias,
weight_bit_width=bit_width,
weight_quant_type=QUANT_TYPE,
weight_scaling_impl_type=WEIGHT_SCALING_IMPL_TYPE,
weight_scaling_stats_op=WEIGHT_SCALING_STATS_OP,
weight_scaling_per_output_channel=WEIGHT_SCALING_PER_OUTPUT_CHANNEL,
weight_restrict_scaling_type=WEIGHT_RESTRICT_SCALING_TYPE,
weight_narrow_range=WEIGHT_NARROW_RANGE,
weight_scaling_min_val=SCALING_MIN_VAL)
def make_quant_conv2d(in_channels,
out_channels,
kernel_size,
bit_width,
stride=1,
padding=0,
dilation=1,
groups=1,
bias=True,
batchnorm=False,
weight_quant=WEIGHT_QUANTIZER,
bias_quant=BIAS_QUANTIZER,
input_quant=INPUT_QUANTIZER,
output_quant=INPUT_QUANTIZER,
return_quant_tensor=CONV_RETURN_QUANT_TENSOR,
enable_bias_quant=ENABLE_BIAS_QUANT,
weight_scaling_per_output_channel=WEIGHT_SCALING_PER_OUTPUT_CHANNEL,
weight_scaling_min_val=SCALING_MIN_VAL):
bias_quant_type = QUANT_TYPE if enable_bias_quant else QuantType.FP
layers = [qnn.QuantConv2d(in_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
padding=padding,
dilation=dilation,
groups=groups,
bias=bias,
weight_quant=weight_quant,
bias_quant=bias_quant,
input_quant=input_quant,
output_quant=output_quant,
weight_bit_width=bit_width,
input_bit_width=bit_width,
return_quant_tensor=return_quant_tensor,
bias_quant_type=bias_quant_type,
compute_output_bit_width=bias and enable_bias_quant,
compute_output_scale=bias and enable_bias_quant,
weight_scaling_per_output_channel=weight_scaling_per_output_channel,
weight_scaling_min_val=weight_scaling_min_val)]
if(batchnorm):
layers.append(nn.BatchNorm2d(out_channels))
return layers
def make_quant_conv2d(
in_channels,
out_channels,
kernel_size,
stride,
padding,
groups,
bias,
bit_width,
weight_quant=WEIGHT_QUANTIZER,
bias_quant=BIAS_QUANTIZER,
return_quant_tensor=True, #Custom
enable_bias_quant=ENABLE_BIAS_QUANT,
weight_quant_type=QUANT_TYPE,
weight_scaling_impl_type=WEIGHT_SCALING_IMPL_TYPE,
weight_scaling_stats_op=WEIGHT_SCALING_STATS_OP,
weight_scaling_per_output_channel=WEIGHT_SCALING_PER_OUTPUT_CHANNEL,
weight_restrict_scaling_type=WEIGHT_RESTRICT_SCALING_TYPE,
weight_narrow_range=WEIGHT_NARROW_RANGE,
weight_scaling_min_val=SCALING_MIN_VAL):
bias_quant_type = QUANT_TYPE if enable_bias_quant else QuantType.FP
return qnn.QuantConv2d(
in_channels,
out_channels,
groups=groups,
kernel_size=kernel_size,
padding=padding,
stride=stride,
bias=bias,
weight_quant=weight_quant,
bias_quant=bias_quant,
return_quant_tensor=return_quant_tensor,
bias_quant_type=bias_quant_type,
compute_output_bit_width=bias and enable_bias_quant,
compute_output_scale=bias and enable_bias_quant,
weight_bit_width=bit_width,
weight_quant_type=weight_quant_type,
weight_scaling_impl_type=weight_scaling_impl_type,
weight_scaling_stats_op=weight_scaling_stats_op,
weight_scaling_per_output_channel=weight_scaling_per_output_channel,
weight_restrict_scaling_type=weight_restrict_scaling_type,
weight_narrow_range=weight_narrow_range,
weight_scaling_min_val=weight_scaling_min_val)
def make_quant_conv2d(
bit_width,
in_channels,
out_channels,
kernel_size=CNV_KERNEL_SIZE,
stride=CNV_STRIDE,
padding=CNV_PADDING,
groups=CNV_GROUPS,
bias=ENABLE_BIAS,
enable_bias_quant=ENABLE_BIAS_QUANT,
weight_scaling_impl_type=WEIGHT_SCALING_IMPL_TYPE,
weight_scaling_stats_op=WEIGHT_SCALING_STATS_OP,
weight_scaling_per_output_channel=WEIGHT_SCALING_PER_OUTPUT_CHANNEL,
weight_restrict_scaling_type=WEIGHT_RESTRICT_SCALING_TYPE,
weight_narrow_range=WEIGHT_NARROW_RANGE,
weight_scaling_min_val=SCALING_MIN_VAL,
return_quant_tensor=WEIGHT_RETURN_QUANT_TENSOR):
'''Helper for Conv2D layers'''
weight_quant_type = get_quant_type(bit_width)
bias_quant_type = weight_quant_type if enable_bias_quant else QuantType.FP
return qnn.QuantConv2d(
in_channels,
out_channels,
groups=groups,
kernel_size=kernel_size,
padding=padding,
stride=stride,
bias=bias,
bias_quant_type=bias_quant_type,
compute_output_bit_width=bias and enable_bias_quant,
compute_output_scale=bias and enable_bias_quant,
weight_bit_width=bit_width,
weight_quant_type=weight_quant_type,
weight_scaling_impl_type=weight_scaling_impl_type,
weight_scaling_stats_op=weight_scaling_stats_op,
weight_scaling_per_output_channel=weight_scaling_per_output_channel,
weight_restrict_scaling_type=weight_restrict_scaling_type,
weight_narrow_range=weight_narrow_range,
weight_scaling_min_val=weight_scaling_min_val,
return_quant_tensor=return_quant_tensor)
def __init__(self):
super(VGG, self).__init__()
self.conv1 = qnn.QuantConv2d(
in_channels=3,
out_channels=64,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu1 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv2 = qnn.QuantConv2d(
in_channels=64,
out_channels=128,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu2 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv3 = qnn.QuantConv2d(
in_channels=128,
out_channels=256,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu3 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.conv4 = qnn.QuantConv2d(
in_channels=256,
out_channels=256,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu4 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.pool3 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv5 = qnn.QuantConv2d(
in_channels=256,
out_channels=512,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu5 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.conv6 = qnn.QuantConv2d(
in_channels=512,
out_channels=512,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu6 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.pool4 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv7 = qnn.QuantConv2d(
in_channels=256,
out_channels=512,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu7 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.conv8 = qnn.QuantConv2d(
in_channels=512,
out_channels=512,
kernel_size=3,
padding=1,
bias=False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu8 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.pool5 = nn.MaxPool2d(kernel_size=2, stride=2)
"""
full precision layers
self.fc1 = nn.Linear(4*4*256, 1024)
self.relufc1 = nn.ReLU()
self.fc2 = nn.Linear(1024,512)
self.relufc2 = nn.ReLU()
self.fc2 = nn.Linear(512, 10)
"""
self.fc1 = qnn.QuantLinear(
8192,
4096,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=32,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relufc1 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.fc2 = qnn.QuantLinear(
4096,
1024,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relufc2 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.fc3 = qnn.QuantLinear(
1024,
1024,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relufc3 = qnn.QuantReLU(
quant_type=QuantType.INT,
bit_width=8,
max_val=1 - 1 / 128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST)
self.fc4 = qnn.QuantLinear(
1024,
10,
bias=True,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
def __init__(
self,
block,
layers,
num_classes=1000,
zero_init_residual=False,
groups=1,
width_per_group=64,
replace_stride_with_dilation=None,
norm_layer=None,
bit_width=8,
):
super().__init__()
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 = qnn.QuantConv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
self.bn1 = norm_layer(self.inplanes)
self.relu = make_PACT_relu()
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0], bit_width=bit_width)
self.layer2 = self._make_layer(
block, 128, layers[1], stride=2, dilate=replace_stride_with_dilation[0], bit_width=bit_width
)
self.layer3 = self._make_layer(
block, 256, layers[2], stride=2, dilate=replace_stride_with_dilation[1], bit_width=bit_width
)
self.layer4 = self._make_layer(
block, 512, layers[3], stride=2, dilate=replace_stride_with_dilation[2], bit_width=bit_width
)
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
for m in self.modules():
if isinstance(m, nn.Conv2d): # qnn.QuantConv2d includes nn.Conv2d inside.
nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
# 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, Bottleneck):
nn.init.constant_(m.bn3.weight, 0)
elif isinstance(m, BasicBlock):
nn.init.constant_(m.bn2.weight, 0)
def __init__(self, is_train=False):
super(PNet, self).__init__()
self.is_train = is_train
'''
conv1: (H-2)*(W-2)*10
prelu1: (H-2)*(W-2)*10
pool1: ((H-2)/2)*((W-2)/2)*10
conv2: ((H-2)/2-2)*((W-2)/2-2)*16
prelu2: ((H-2)/2-2)*((W-2)/2-2)*16
conv3: ((H-2)/2-4)*((W-2)/2-4)*32
prelu3: ((H-2)/2-4)*((W-2)/2-4)*32
conv4_1: ((H-2)/2-4)*((W-2)/2-4)*2
conv4_2: ((H-2)/2-4)*((W-2)/2-4)*4
The last feature map size is: (H - 10)/2 = (H - 12)/2 + 1.
Thus the effect of PNet equals to moving 12*12 convolution window with
kernel size 3, stirde 2.
'''
self.features = nn.Sequential(
OrderedDict([
('conv1',
qnn.QuantConv2d(3,
10,
3,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)),
('prelu1',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('pool1', nn.MaxPool2d(2, 2, ceil_mode=False)),
('conv2',
qnn.QuantConv2d(10,
16,
3,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)),
('prelu2',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('conv3',
qnn.QuantConv2d(16,
32,
3,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)),
('prelu3',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
]))
self.conv4_1 = qnn.QuantConv2d(32,
2,
1,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)
self.conv4_2 = qnn.QuantConv2d(32,
4,
1,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)
def __init__(self, is_train=False, train_landmarks=False):
super(ONet, self).__init__()
self.is_train = is_train
self.train_landmarks = train_landmarks
self.features = nn.Sequential(
OrderedDict([
('conv1',
qnn.QuantConv2d(3,
32,
3,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)), # 48 - 2 = 46
('prelu1',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('pool1', nn.MaxPool2d(3, 2,
ceil_mode=False)), # (46-3)/2 + 1 = 22
('conv2',
qnn.QuantConv2d(32,
64,
3,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)), # 22 - 2 = 20
('prelu2',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('pool2', nn.MaxPool2d(3, 2,
ceil_mode=False)), # (20-3)/2 + 1 = 9
('conv3',
qnn.QuantConv2d(64,
64,
3,
1,
weight_quant_type=QuantType.INT,
bit_width=8,
max_val=6)), # 9 - 2 = 7
('prelu3',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('pool3', nn.MaxPool2d(2, 2,
ceil_mode=False)), # (7-2)/2 + 1 = 3
('conv4',
qnn.QuantConv2d(64,
128,
2,
1,
weight_quant_type=QuantType.INT,
bit_width=8,
max_val=6)), # 3 - 1 = 2
('prelu4',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('flatten', Flatten()),
('conv5',
qnn.QuantLinear(128 * 2 * 2,
256,
weight_quant_type=QuantType.INT,
bias=False,
weight_bit_width=8)),
('prelu5',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('dropout', nn.Dropout(0.2))
]))
self.conv6_1 = qnn.QuantLinear(256,
2,
weight_quant_type=QuantType.INT,
bias=False,
weight_bit_width=8)
self.conv6_2 = qnn.QuantLinear(256,
4,
weight_quant_type=QuantType.INT,
bias=False,
weight_bit_width=8)
self.conv6_3 = qnn.QuantLinear(256,
10,
weight_quant_type=QuantType.INT,
bias=False,
weight_bit_width=8)
def __init__(self, is_train=False):
super(RNet, self).__init__()
self.is_train = is_train
self.features = nn.Sequential(
OrderedDict([
('conv1',
qnn.QuantConv2d(3,
28,
3,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)), # 24 -2 = 22
('prelu1',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('pool1', nn.MaxPool2d(3, 2,
ceil_mode=False)), # (22-3)/2 + 1 = 10
('conv2',
qnn.QuantConv2d(28,
48,
3,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)), # 10 - 2 = 8
('prelu2',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('pool2', nn.MaxPool2d(3, 2,
ceil_mode=False)), # (8-3)/2 + 1 = 3
('conv3',
qnn.QuantConv2d(48,
64,
2,
1,
weight_quant_type=QuantType.INT,
weight_bit_width=8)), # 3 - 1 = 2
('prelu3',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
('flatten', Flatten()),
('conv4',
qnn.QuantLinear(64 * 2 * 2,
128,
weight_quant_type=QuantType.INT,
bias=False,
weight_bit_width=8)),
('prelu4',
qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val=6)),
#('dropout', nn.Dropout(0.2))
]))
self.conv5_1 = qnn.QuantLinear(128,
2,
weight_quant_type=QuantType.INT,
bias=False,
weight_bit_width=8)
self.conv5_2 = qnn.QuantLinear(128,
4,
weight_quant_type=QuantType.INT,
bias=False,
weight_bit_width=8)
def __init__(self, in_channels, out_channels):
super().__init__()
'''
Dilated Convolution
i = input
o = output
p = padding
k = kernel_size
s = stride
d = dilation
o = [i + 2*p - k - (k-1)*(d-1)]/s + 1
'''
self.conv1 = qnn.QuantConv2d(
in_channels=in_channels,
out_channels=in_channels,
kernel_size=3,
padding=0,
bias=False,
dilation=1,
groups=in_channels,
weight_quant_type=QuantType.INT,
weight_bit_width=total_bits,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.conv2 = qnn.QuantConv2d(
in_channels=in_channels,
out_channels=in_channels,
kernel_size=3,
padding=1,
bias=False,
dilation=2,
groups=in_channels,
weight_quant_type=QuantType.INT,
weight_bit_width=total_bits,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.conv3 = qnn.QuantConv2d(
in_channels=in_channels,
out_channels=in_channels,
kernel_size=3,
padding=2,
bias=False,
dilation=3,
groups=in_channels,
weight_quant_type=QuantType.INT,
weight_bit_width=total_bits,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.fused_conv = qnn.QuantConv2d(
in_channels=in_channels * 3,
out_channels=out_channels,
kernel_size=1,
padding=0,
bias=False,
dilation=1,
groups=1,
weight_quant_type=QuantType.INT,
weight_bit_width=total_bits,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.leaky_relu = nn.LeakyReLU(0.01)
self.batch_norm = nn.BatchNorm2d(out_channels)
self.dropout = nn.Dropout(0.2)
def __init__(self):
super(LeNet5, self).__init__()
self.conv1 = qnn.QuantConv2d(in_channels= 1,
out_channels= 20,
kernel_size= 3,
padding= 1,
bias= False,
weight_quant_type=QuantType.INT,
weight_bit_width= total_bits,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu1 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val= 1- 1/128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST )
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv2 = qnn.QuantConv2d(in_channels= 20,
out_channels= 50,
kernel_size= 3,
padding= 1,
bias= False,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0 )
self.relu2 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val= 1- 1/128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST )
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
"""
# for 32-bit precision FC layers
self.fc1 = nn.Linear(7*7*50, 500)
self.relu3 = nn.ReLU()
self.fc2 = nn.Linear(500,10)
"""
# for fixed-point precision FC layers
self.fc1 = qnn.QuantLinear(7*7*50, 500,
bias= True,
weight_quant_type=QuantType.INT,
weight_bit_width=32,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
self.relu3 = qnn.QuantReLU(quant_type=QuantType.INT,
bit_width=8,
max_val= 1- 1/128.0,
restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
scaling_impl_type=ScalingImplType.CONST )
self.fc2 = qnn.QuantLinear(500, 10,
bias= True,
weight_quant_type=QuantType.INT,
weight_bit_width=8,
weight_restrict_scaling_type=RestrictValueType.POWER_OF_TWO,
weight_scaling_impl_type=ScalingImplType.CONST,
weight_scaling_const=1.0)
