mod_config.py Source File

mod_config.py Source File#

Mobilint SDK qb Compiler: mod_config.py Source File
Mobilint SDK qb Compiler v0.11.0.1
MCS002-EN
import numbers
 
from typeguard import typechecked
from . import ConfigABC
 
"""
MOD_apply: Run Min output difference (MOD) QAT if True
MOD_epochs: Epochs for MOD QAT
MOD_warmupEpochs: Warmup epochs for MOD QAT
MOD_lrMinRatio: Minimum lr ratio for cosine scheduler in MOD QAT
MOD_actScaleLR: LR of activation scale for MOD QAT
MOD_zeropointLR: LR of zeropoint for MOD QAT
MOD_weightScaleLR: LR of weight scale for MOD QAT
MOD_weightLR: LR of weight for MOD QAT
MOD_biasLR: LR of bias for MOD QAT
MOD_batchSize: Batch size for MOD QAT
MOD_qDrop: QDrop ratio for MOD QAT. range=[0, 1]
MOD_quantizeWeight: Use quantized weight for MOD QAT if True
MOD_weightScaleInit: Weight quantization init method for for MOD QAT. Options=('MinMax')
MOD_downresolMode: Down-resolution of fake-quantization, Options=('STE', 'NIPQ')
MOD_post: Post-processing function to make the output values, Options=(AnchorlessDetection', 'AnchorlessDetectionNMS', 'AnchorlessDetectionNMSCIoU')
MOD_boxConfThres: Confidence treshold of NMS if NMS is included in the post-processing.
MOD_boxIoUThres: IoU treshold of NMS if NMS is included in the post-processing.
MOD_lossType: Loss funciton to compute the loss of the final output layers. Options=('CE', 'CELabel', 'KL', 'AnchorlessDetection')
MOD_useOutputs: Compare only intermediate layers if True.
MOD_KLTemperature: Temperature of KL diveregence loss if it is used.
MOD_reconProb: Sampling probability of intermediate layers. range=[0, 1]
MOD_reconCoeff: Coefficient to the loss of intermediate layers.
MOD_lambda_0: 1st coeff of AnchorlessDetection loss
MOD_lambda_1: 2nd coeff of AnchorlessDetection loss
MOD_lambda_2: 3rd coeff of AnchorlessDetection loss
MOD_seed: Random seed for MOD QAT
"""
 
 
class ModConfig(ConfigABC):
    py_to_cpp_name = {
        "MOD_apply": "apply",
        "MOD_epochs": "epochs",
        "MOD_warmupEpochs": "warmupEpochs",
        "MOD_lrMinRatio": "lrMinRatio",
        "MOD_actScaleLR": "actScaleLR",
        "MOD_zeropointLR": "zeropointLR",
        "MOD_weightScaleLR": "weightScaleLR",
        "MOD_weightLR": "weightLR",
        "MOD_biasLR": "biasLR",
        "MOD_batchSize": "batchSize",
        "MOD_qDrop": "qDrop",
        "MOD_quantizeWeight": "quantizeWeight",
        "MOD_weightScaleInit": "weightScaleInit",
        "MOD_downresolMode": "downresolMode",
        "MOD_post": "post",
        "MOD_boxConfThres": "boxConfThres",
        "MOD_boxIoUThres": "boxIoUThres",
        "MOD_lossType": "lossType",
        "MOD_useOutputs": "useOutputs",
        "MOD_KLTemperature": "KLTemperature",
        "MOD_reconProb": "reconProb",
        "MOD_reconCoeff": "reconCoeff",
        "MOD_lambda_0": "lambda_0",
        "MOD_lambda_1": "lambda_1",
        "MOD_lambda_2": "lambda_2",
        "MOD_seed": "seed",
    }
    min_max_check = {
        "MOD_epochs": [0, None],
        "MOD_warmupEpochs": [0, None],
        "MOD_lrMinRatio": [0, None],
        "MOD_actScaleLR": [0, None],
        "MOD_zeropointLR": [0, None],
        "MOD_weightScaleLR": [0, None],
        "MOD_weightLR": [0, None],
        "MOD_biasLR": [0, None],
        "MOD_batchSize": [0, None],
        "MOD_boxConfThres": [0, None],
        "MOD_boxIoUThres": [0, None],
        "MOD_KLTemperature": [0, None],
        "MOD_reconProb": [0, None],
        "MOD_reconCoeff": [0, None],
        "MOD_lambda_0": [0, None],
        "MOD_lambda_1": [0, None],
        "MOD_lambda_2": [0, None],
        "MOD_seed": [0, None],
    }
 
    @typechecked
    def __init__(
        self,
        MOD_apply: bool = False,
        MOD_epochs: int = 4,
        MOD_warmupEpochs: int = 1,
        MOD_lrMinRatio: numbers.Number = 0.1,
        MOD_actScaleLR: numbers.Number = 0.0,
        MOD_zeropointLR: numbers.Number = 0.0,
        MOD_weightScaleLR: numbers.Number = 0.0,
        MOD_weightLR: numbers.Number = 4e-6,
        MOD_biasLR: numbers.Number = 4e-6,
        MOD_batchSize: int = 1,
        MOD_qDrop: numbers.Number = 0.0,
        MOD_quantizeWeight: bool = True,
        MOD_weightScaleInit: str = "MinMax",
        MOD_downresolMode: str = "STE",
        MOD_post: str = "",
        MOD_boxConfThres: numbers.Number = 0,
        MOD_boxIoUThres: numbers.Number = 0,
        MOD_lossType: str = "mse",
        MOD_useOutputs: bool = False,
        MOD_KLTemperature: numbers.Number = 1.0,
        MOD_reconProb: numbers.Number = 1.0,
        MOD_reconCoeff: numbers.Number = 1.0,
        MOD_lambda_0: numbers.Number = 1.0,
        MOD_lambda_1: numbers.Number = 1.0,
        MOD_lambda_2: numbers.Number = 1.0,
        MOD_seed: int = 0,
    ):  # Mod is optional
        super().__init__(optional=True)
        self.MOD_apply = MOD_apply
        self.MOD_epochs = MOD_epochs
        self.MOD_warmupEpochs = MOD_warmupEpochs
        self.MOD_lrMinRatio = MOD_lrMinRatio
        self.MOD_actScaleLR = MOD_actScaleLR
        self.MOD_zeropointLR = MOD_zeropointLR
        self.MOD_weightScaleLR = MOD_weightScaleLR
        self.MOD_weightLR = MOD_weightLR
        self.MOD_biasLR = MOD_biasLR
        self.MOD_batchSize = MOD_batchSize
        self.MOD_qDrop = MOD_qDrop
        self.MOD_quantizeWeight = MOD_quantizeWeight
        self.MOD_weightScaleInit = MOD_weightScaleInit
        self.MOD_downresolMode = MOD_downresolMode
        self.MOD_post = MOD_post
        self.MOD_boxConfThres = MOD_boxConfThres
        self.MOD_boxIoUThres = MOD_boxIoUThres
        self.MOD_lossType = MOD_lossType
        self.MOD_useOutputs = MOD_useOutputs
        self.MOD_KLTemperature = MOD_KLTemperature
        self.MOD_reconProb = MOD_reconProb
        self.MOD_reconCoeff = MOD_reconCoeff
        self.MOD_lambda_0 = MOD_lambda_0
        self.MOD_lambda_1 = MOD_lambda_1
        self.MOD_lambda_2 = MOD_lambda_2
        self.MOD_seed = MOD_seed
        self.check_valid()
 
    @classmethod
    def default_config(cls):
        return ModConfig()
 
    def to_dict(self):
        mod_config_dict = dict()
        mod_params = dict()
        for py_name, cpp_name in ModConfig.py_to_cpp_name.items():
            value = getattr(self, py_name)
            if isinstance(value, str) and cpp_name not in [
                "weightScaleInit",
                "downresolMode",
            ]:  # these options are not use lower string in cpp
                value = value.lower()
            mod_params[cpp_name] = value
        mod_config_dict["minOutputDiff"] = mod_params
 
        return mod_config_dict