def __init__(self):
super(ManualConvLinearQATModel, self).__init__()
self.qconfig = torch.quantization.get_default_qat_qconfig("qnnpack")
self.quant = QuantStub()
self.dequant = DeQuantStub()
self.conv = torch.nn.Conv2d(3, 1, kernel_size=3).to(dtype=torch.float)
self.fc1 = torch.nn.Linear(64, 10).to(dtype=torch.float)
self.fc2 = torch.nn.Linear(10, 10).to(dtype=torch.float)
def __init__(self):
'''
Init function to define the layers and loss function.
'''
super().__init__()
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, qengine='fbgemm'):
super(AnnotatedConvBnReLUModel, self).__init__()
self.qconfig = torch.quantization.get_default_qconfig(qengine)
self.conv = torch.nn.Conv2d(3, 5, 3, bias=False).to(dtype=torch.float)
self.bn = torch.nn.BatchNorm2d(5).to(dtype=torch.float)
self.relu = nn.ReLU(inplace=True)
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self):
super(lane_detection_network, self).__init__()
self.resizing = resize_layer(3, 32)
# feature extraction
self.layer1 = hourglass_block(32, 32)
self.layer2 = hourglass_block(32, 32)
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, qconfig):
super(TestM, self).__init__()
self.conv = nn.Conv2d(3, 1, 3).float()
self.conv.weight.data.fill_(1.0)
self.conv.bias.data.fill_(0.01)
self.qconfig = qconfig
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, config, mix_qkv=False):
super(CTRLLMHeadModel, self).__init__(config)
self.transformer = CTRLModel(config)
self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=True)
self.init_weights()
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self):
super(ManualConvLinearQATModel, self).__init__()
self.qconfig = default_qconfig
self.quant = QuantStub()
self.dequant = DeQuantStub()
self.conv = torch.nn.Conv2d(3, 5, kernel_size=3).to(dtype=torch.float)
self.fc1 = torch.nn.Linear(320, 10).to(dtype=torch.float)
self.fc2 = torch.nn.Linear(10, 10).to(dtype=torch.float)
def __init__(self,
block,
layers,
block_inplanes,
n_input_channels=3,
conv1_t_size=7,
conv1_t_stride=1,
no_max_pool=False,
shortcut_type='B',
widen_factor=1.0,
quantize=False,
n_classes=400):
super().__init__()
self.quantize = quantize
self.quant = QuantStub()
self.dequant = DeQuantStub()
block_inplanes = [int(x * widen_factor) for x in block_inplanes]
self.in_planes = block_inplanes[0]
self.no_max_pool = no_max_pool
self.conv1 = nn.Conv3d(n_input_channels,
self.in_planes,
kernel_size=(conv1_t_size, 7, 7),
stride=(conv1_t_stride, 2, 2),
padding=(conv1_t_size // 2, 3, 3),
bias=False)
self.bn1 = nn.BatchNorm3d(self.in_planes)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool3d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, block_inplanes[0], layers[0],
shortcut_type)
self.layer2 = self._make_layer(block,
block_inplanes[1],
layers[1],
shortcut_type,
stride=2)
self.layer3 = self._make_layer(block,
block_inplanes[2],
layers[2],
shortcut_type,
stride=2)
self.layer4 = self._make_layer(block,
block_inplanes[3],
layers[3],
shortcut_type,
stride=2)
self.avgpool = nn.AdaptiveAvgPool3d((1, 1, 1))
self.fc = nn.Linear(block_inplanes[3] * block.expansion, n_classes)
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.kaiming_normal_(m.weight,
mode='fan_out',
nonlinearity='relu')
elif isinstance(m, nn.BatchNorm3d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def __init__(self, *args, **kwargs):
"""
MobileNet V3 main class
Args:
Inherits args from floating point MobileNetV3
"""
super().__init__(*args, **kwargs)
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, cfg,
n_labels,
channels=[768, 100, 100, 100, 100, 100, 100, 100, 100],
kernel_sizes=[5, 5, 5, 5, 5, 5, 5, 5],
n_hidden_dense=100):
super().__init__()
self.quant = QuantStub()
self.dequant = DeQuantStub()
self.conv_quant = QuantStub()
self.conv_dequant = DeQuantStub()
self.embed = Embeddings(cfg)
self.convs = nn.ModuleList([
nn.Conv1d(n_in, n_out, k, padding=int(k/2))
for n_in, n_out, k in zip(channels[:-1], channels[1:], kernel_sizes)
])
self.dense = nn.Linear(channels[-1]*len(kernel_sizes), n_hidden_dense)
self.classifier = nn.Linear(n_hidden_dense, n_labels)
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(3, 2, 5, bias=True).to(dtype=torch.float)
self.bn1 = nn.BatchNorm2d(2).to(dtype=torch.float)
self.relu1 = nn.ReLU(inplace=True).to(dtype=torch.float)
self.conv2 = nn.Conv2d(2, 2, 1, bias=True).to(dtype=torch.float)
self.bn2 = nn.BatchNorm2d(2).to(dtype=torch.float)
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, **kwargs):
super(PoseMobileNet, self).__init__()
# 0. Initialize
res_block = InvertedResidual
inverted_residual_setting = [
# ratio, channel, repeat n_times, stride
# t, c, n, s
[1, 16, 1, 1],
[6, 24, 2, 2],
[6, 32, 3, 2],
[6, 64, 4, 2],
[6, 96, 3, 1],
[6, 160, 3, 2],
[6, 320, 1, 1],
]
self.input_channel = 3
self.output_channel = 32
self.output_channel = _make_divisible(self.output_channel)
self.last_channel = 1280
self.last_channel = _make_divisible(self.last_channel)
# 1. Mobilenet v2 backbone
# https://github.com/pytorch/vision/blob/master/torchvision/models/mobilenet.py
features = [ConvBNReLU(self.input_channel, self.output_channel, stride=2)]
self.input_channel = self.output_channel
for t, c, n, s in inverted_residual_setting:
self.output_channel = _make_divisible(c)
for i in range(n):
stride = s if i == 0 else 1
features.append(res_block(self.input_channel, self.output_channel, stride, expand_ratio=t))
self.input_channel = self.output_channel
features.append(ConvBNReLU(self.input_channel, self.last_channel, kernel_size=1))
self.features = nn.Sequential(*features)
self.output_channel = self.last_channel
# 2. Conv transpose layers
self.conv_transpose_layers = self._make_conv_transpose_layer(
num_layers = 3,
filters = [128, 128, 128],
kernals = [4, 4, 4]
)
# 3. Final conv layer
self.final_layer = nn.Conv2d(
in_channels = self.output_channel,
out_channels = 21, # 21 keypoints
kernel_size = 1,
stride = 1,
padding = 0
)
# 4. Two special layers for quantization
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self,
in_chs,
se_ratio=0.25,
reduced_base_chs=None,
act_layer=nn.ReLU,
gate_fn=sigmoid,
divisor=1):
super(SqueezeExcite, self).__init__()
self.gate_fn = gate_fn
reduced_chs = make_divisible((reduced_base_chs or in_chs) * se_ratio,
divisor)
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.conv_reduce = nn.Conv2d(in_chs, reduced_chs, 1, bias=True)
self.act1 = act_layer(inplace=True)
self.conv_expand = nn.Conv2d(reduced_chs, in_chs, 1, bias=True)
self.quant_conv_reduce = QuantStub()
self.quant_conv_expand = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, nclass, backbone, pretrained_base=False,
dataset="city", width_multi = 1.0, **kwargs):
super(_MobileNetV2Seg, self).__init__(nclass, backbone, pretrained_base, **kwargs)
self.width_multi = width_multi
in_channels = int(320//2*width_multi)
inter_channels = int(24*width_multi)
self.head = _Head(nclass, in_channels,inter_channels, dataset = dataset, width_multi = width_multi, **kwargs)
self.quant = QuantStub()
self.dequant1 = DeQuantStub()
self.dequant2 = DeQuantStub()
def __init__(self, nclass, backbone, pretrained_base=False,
dataset ='city', crop_scale = 1.0, **kwargs):
super(_MobileNetV3Seg, self).__init__(nclass, backbone, pretrained_base, **kwargs)
mode = backbone.split('_')[-1]
in_channels = 960//2 if mode == 'large' else 576//2
inter_channels = 40 if mode.startswith('large') else 24
self.head = _Head(nclass, in_channels, inter_channels, mode = mode, dataset = dataset, **kwargs)
self.quant = QuantStub()
self.dequant1 = DeQuantStub()
self.dequant2 = DeQuantStub()
def __init__(self, config):
super().__init__(config)
self.num_labels = config.num_labels
self.transformer = SqueezeBertModel(config)
self.qa_outputs = nn.Linear(config.hidden_size, config.num_labels)
self.init_weights()
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, *args, **kwargs):
"""
MobileNet V2 main class
Args:
Inherits args from floating point MobileNetV2
"""
super(QuantizableMobileNetV2, self).__init__(*args, **kwargs)
self.quant = QuantStub()
self.dequant = DeQuantStub()
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
def __init__(self):
super(ModelWithFunctionals, self).__init__()
self.mycat = nnq.FloatFunctional()
self.myadd = nnq.FloatFunctional()
self.mymul = nnq.FloatFunctional()
self.myadd_relu = nnq.FloatFunctional()
self.my_scalar_add = nnq.FloatFunctional()
self.my_scalar_mul = nnq.FloatFunctional()
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, *args: Any, **kwargs: Any) -> None:
"""
MobileNet V2 main class
Args:
Inherits args from floating point MobileNetV2
"""
super(QuantizableMobileNetV2, self).__init__(*args, **kwargs)
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, w, b, m, v):
super(SimpleQuantizedBatchNormRelu, self).__init__()
self.bn = torch.nn.BatchNorm3d(4)
self.relu = torch.nn.ReLU()
self.bn.weight = torch.nn.Parameter(w)
self.bn.bias = torch.nn.Parameter(b)
self.bn.running_mean = m
self.bn.running_var = v
self.q = QuantStub()
self.dq = DeQuantStub()
def __init__(self, channel):
super().__init__()
weight = torch.tensor([[1, 2, 1], [2, 4, 2], [1, 2, 1]], dtype=torch.float32)
weight = weight.view(1, 1, 3, 3)
weight = weight / weight.sum()
weight_flip = torch.flip(weight, [2, 3])
self.register_buffer('weight', weight.repeat(channel, 1, 1, 1))
self.register_buffer('weight_flip', weight_flip.repeat(channel, 1, 1, 1))
self.quant = QuantStub()
def __init__(self, config_path, img_size=416):
super(Darknet, self).__init__()
self.module_defs = parse_model_config(config_path)
self.hyperparams, self.module_list = create_modules(self.module_defs)
self.yolo_layers = [layer[0] for layer in self.module_list if hasattr(layer[0], "metrics")]
self.img_size = img_size
self.seen = 0
self.header_info = np.array([0, 0, 0, self.seen, 0], dtype=np.int32)
self.add = torch.nn.quantized.FloatFunctional()
self.quant = QuantStub()
self.dequant = DeQuantStub()
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):
super(ResNet, self).__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 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3,
bias=False)
self.bn1 = norm_layer(self.inplanes)
# self.relu = nn.ReLU(inplace=True)
self.relu = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2,
dilate=replace_stride_with_dilation[0])
self.layer3 = self._make_layer(block, 256, layers[2], stride=2,
dilate=replace_stride_with_dilation[1])
self.layer4 = self._make_layer(block, 512, layers[3], stride=2,
dilate=replace_stride_with_dilation[2])
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
self.quant = QuantStub()
self.dequant = DeQuantStub()
for m in self.modules():
if isinstance(m, nn.Conv2d):
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, parametrization, classes=10, input_shape=None):
"""
Initializes the network according to the parametrization passed.
Args
----
parametrization:
parameters for the network building
classes:
number of classes for the final fully connected layer
input_shape:
default shape for the input
channels:
number of channels of the input: 1 is grey image, 3 in color
"""
super(Net, self).__init__()
self.input_shape = input_shape
channels = self.input_shape[0]
self.parametrization = parametrization
# COnvolution blocks
conv_blocks = []
for j in range(1, parametrization.get("num_conv_blocks", 1) + 1):
conv_blocks.append(self.create_conv_block(j, channels))
self.conv_blocks = nn.Sequential(*conv_blocks)
# fully connected blocks
fc = []
# Main branch
self.n_size, self.odd_shape = self._get_conv_output(
self.parametrization.get("batch_size", 4),
self.input_shape,
self._forward_features,
)
for i in range(1, parametrization.get("num_fc_layers", 1) + 1):
fc = self.create_fc_block(fc, i, self.odd_shape[0])
# Final Layer
self.fc = nn.Sequential(*fc)
classifier = []
classifier.append(
nn.Linear(
parametrization.get(
"fc_weights_layer_"
+ str(parametrization.get("num_fc_layers", 0)),
self.odd_shape[0],
),
classes,
)
)
self.classifier = nn.Sequential(*classifier)
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, config):
super().__init__(config)
self.num_labels = config.num_labels
self.transformer = SqueezeBertModel(config)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
self.classifier = nn.Linear(config.hidden_size, self.config.num_labels)
self.init_weights()
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, channel, reduction=4, add_stub=False):
super(SqueezeExcite, self).__init__()
self.avg_pool = nn.AdaptiveAvgPool2d(1)
self.fc = nn.Sequential(
nn.Linear(channel, channel // reduction, bias=False),
nn.ReLU(inplace=True),
nn.Linear(channel // reduction, channel, bias=False),
Hsigmoid(add_stub=False))
self.fmul = nn.quantized.FloatFunctional()
self.quant = QuantStub()
self.dequant = DeQuantStub()
self.add_stub = add_stub
def __init__(self):
super(ModelWithFunctionals, self).__init__()
self.mycat = nnq.FloatFunctional()
self.myadd = nnq.FloatFunctional()
self.myadd_relu = nnq.FloatFunctional()
# Tracing doesnt work yet for c10 ops with scalar inputs
# https://github.com/pytorch/pytorch/issues/27097
self.my_scalar_add = nnq.FloatFunctional()
self.mymul = nnq.FloatFunctional()
self.my_scalar_mul = nnq.FloatFunctional()
self.quant = QuantStub()
self.dequant = DeQuantStub()
def __init__(self, num_classes, is_pretrained=False, quantized=False):
super(DenseNet121, self).__init__()
self.quantize = quantized
if self.quantize:
self.quant = QuantStub()
self.densenet121 = torchvision.models.densenet121(
pretrained=is_pretrained)
self.features = self.densenet121.features
self.classifier = nn.Sequential(nn.Linear(1024, num_classes),
nn.Sigmoid())
if quantized:
self.dequant = DeQuantStub()
def replace_forward(module):
module.quant = QuantStub()
module.dequant = DeQuantStub()
raw_forward = module.forward
def forward(x):
x = module.quant(x)
x = raw_forward(x)
x = module.dequant(x)
return x
module.forward = forward
def __init__(self,
num_classes=3,
encoder=None): #use encoder to pass pretrained encoder
super(Net, self).__init__()
if (encoder == None):
self.encoder = Encoder(num_classes)
else:
self.encoder = encoder
self.decoder = Decoder(num_classes)
self.quant = QuantStub()
self.dequant = DeQuantStub()
