mod_config.py Source File

mod_config.py Source File#

Mobilint SDK qb Compiler: mod_config.py Source File
Mobilint SDK qb Compiler v1.0
MCS002-EN
import numbers
from typing import List, Optional
from typeguard import typechecked
from . import ConfigABC
 
 
 
class ModConfig(ConfigABC):
    """
    @brief Configuration for Minimum Output Difference algorithm.
 
    @details Defines parameters controlling whether and how Mod is applied during quantization, including layer-level inclusion/exclusion lists.
    """
 
    optional = True
    DEFAULTS = {
        "apply": False,
        "epochs": 4,
        "warmup_epochs": 1,
        "lr_act_scale": 0.0,
        "lr_zeropoint": 0.0,
        "lr_weight_scale": 0.0,
        "lr_weight": 4e-6,
        "lr_bias": 4e-6,
        "lr_min_ratio": 1e-4,
        "batch_size": 1,
        "q_drop": 0.0,
        "post_processing": "",
        "box_conf_thres": 0,
        "box_iou_thres": 0,
        "loss_type": "MSE",
        "use_outputs": False,
        "kl_temperature": 1.0,
        "recon_prob": 1.0,
        "recon_coeff": 1.0,
        "lambda_0": 1.0,
        "lambda_1": 1.0,
        "lambda_2": 1.0,
        "anchors": [
            [[12, 16], [19, 36], [40, 28]],
            [[36, 75], [76, 55], [72, 146]],
            [[142, 110], [192, 243], [459, 401]],
        ],
        "use_xyxy": False,
        "save_dir": "",
        "seed": 0,
        "apply_layers": [],
        "exclude_layers": [],
        "custom_loss_jit_path": "",
        "mod_after_layer_name": "",
    }
 
    py_to_cpp_name = {
        "apply": "apply",
        "epochs": "epochs",
        "warmup_epochs": "warmupEpochs",
        "lr_min_ratio": "lrMinRatio",
        "lr_act_scale": "actScaleLR",
        "lr_zeropoint": "zeropointLR",
        "lr_weight_scale": "weightScaleLR",
        "lr_weight": "weightLR",
        "lr_bias": "biasLR",
        "batch_size": "batchSize",
        "q_drop": "qDrop",
        "post_processing": "post",
        "box_conf_thres": "boxConfThres",
        "box_iou_thres": "boxIoUThres",
        "loss_type": "lossType",
        "use_outputs": "useOutputs",
        "kl_temperature": "KLTemperature",
        "recon_prob": "reconProb",
        "recon_coeff": "reconCoeff",
        "lambda_0": "lambda_0",
        "lambda_1": "lambda_1",
        "lambda_2": "lambda_2",
        "use_xyxy": "useXYXY",
        "save_dir": "saveDir",
        "seed": "seed",
        "custom_loss_jit_path": "customLossJITPath",
        "mod_after_layer_name": "modAfterLayerName",
    }
 
    min_max_check = {
        "epochs": [0, None],
        "warmup_epochs": [0, None],
        "lr_min_ratio": [0, None],
        "lr_act_scale": [0, None],
        "lr_zeropoint": [0, None],
        "lr_weight_scale": [0, None],
        "lr_weight": [0, None],
        "lr_bias": [0, None],
        "batch_size": [0, None],
        "q_drop": [0, 1],
        "box_conf_thres": [0, None],
        "box_iou_thres": [0, None],
        "kl_temperature": [0, None],
        "recon_prob": [0, 1],
        "recon_coeff": [0, None],
        "lambda_0": [0, None],
        "lambda_1": [0, None],
        "lambda_2": [0, None],
        "seed": [0, None],
    }
 
    @typechecked
    def __init__(
        self,
        apply: bool,
        epochs: int,
        warmup_epochs: int,
        lr_act_scale: numbers.Number,
        lr_zeropoint: numbers.Number,
        lr_weight_scale: numbers.Number,
        lr_weight: numbers.Number,
        lr_bias: numbers.Number,
        lr_min_ratio: numbers.Number,
        batch_size: int,
        q_drop: numbers.Number,
        post_processing: str,
        box_conf_thres: numbers.Number,
        box_iou_thres: numbers.Number,
        loss_type: str,
        use_outputs: bool,
        kl_temperature: numbers.Number,
        recon_prob: numbers.Number,
        recon_coeff: numbers.Number,
        lambda_0: numbers.Number,
        lambda_1: numbers.Number,
        lambda_2: numbers.Number,
        anchors: List,
        use_xyxy: bool,
        save_dir: str,
        seed: int,
        apply_layers: List[str],
        exclude_layers: List[str],
        custom_loss_jit_path: str,
        mod_after_layer_name: str,
        optional: bool = optional,
    ):
        """
        @brief Initialize the ModConfig.
        @param apply bool. Whether to apply MOD.
        @param epochs int. Number of training epochs.
        @param warmup_epochs int. Number of warmup epochs.
        @param lr_act_scale float. Learning rate for activation scale.
        @param lr_zeropoint float. Learning rate for zeropoint.
        @param lr_weight_scale float. Learning rate for weight scale.
        @param lr_weight float. Learning rate for weight.
        @param lr_bias float. Learning rate for bias.
        @param lr_min_ratio float. Minimum learning rate ratio for scheduler.
        @param batch_size int. Batch size for training.
        @param q_drop float. QDrop ratio.
        @param post_processing str. Post-processing function.
        @param box_conf_thres float. Box confidence threshold for NMS.
        @param box_iou_thres float. Box IoU threshold for NMS.
        @param loss_type str. Loss function type.
        @param use_outputs bool. Compare only intermediate layers.
        @param kl_temperature float. Temperature for KL divergence loss.
        @param recon_prob float. Sampling probability for intermediate layers.
        @param recon_coeff float. Coefficient for intermediate layer loss.
        @param lambda_0 float. First coefficient for AnchorlessDetection loss.
        @param lambda_1 float. Second coefficient for AnchorlessDetection loss.
        @param lambda_2 float. Third coefficient for AnchorlessDetection loss.
        @param anchors List. Anchor boxes configuration.
        @param use_xyxy bool. Use XYXY format.
        @param save_dir str. Directory to save results.
        @param seed int. Random seed.
        @param apply_layers List[str]. Layers to apply MOD.
        @param exclude_layers List[str]. Layers to exclude from MOD.
        @param custom_loss_jit_path str. Path to custom loss JIT file.
        @param mod_after_layer_name str. Layer name to apply MOD after.
        @param optional bool. Indicates whether this config is optional. Use the default value defined as a class variable.
        """
        super().__init__(optional)
        self.apply = apply
        self.epochs = epochs
        self.warmup_epochs = warmup_epochs
        self.lr_act_scale = lr_act_scale
        self.lr_zeropoint = lr_zeropoint
        self.lr_weight_scale = lr_weight_scale
        self.lr_weight = lr_weight
        self.lr_bias = lr_bias
        self.lr_min_ratio = lr_min_ratio
        self.batch_size = batch_size
        self.q_drop = q_drop
        self.post_processing = post_processing
        self.box_conf_thres = box_conf_thres
        self.box_iou_thres = box_iou_thres
        self.loss_type = loss_type
        self.use_outputs = use_outputs
        self.kl_temperature = kl_temperature
        self.recon_prob = recon_prob
        self.recon_coeff = recon_coeff
        self.lambda_0 = lambda_0
        self.lambda_1 = lambda_1
        self.lambda_2 = lambda_2
        self.anchors = anchors
        self.use_xyxy = use_xyxy
        self.save_dir = save_dir
        self.seed = seed
        self.apply_layers = apply_layers
        self.exclude_layers = exclude_layers
        self.custom_loss_jit_path = custom_loss_jit_path
        self.mod_after_layer_name = mod_after_layer_name
        self.check_valid(
            except_list=["optional", "anchors", "apply_layers", "exclude_layers"]
        )
 
    @classmethod
    def default_config(cls):
        return cls(**cls.DEFAULTS, optional=cls.optional)
 
    @classmethod
    def from_dict(cls, config_dict: dict):
        """Create ModConfig from dictionary (JSON structure)"""
        params = cls.DEFAULTS.copy()
 
        if "apply" in config_dict:
            params["apply"] = config_dict["apply"]
 
        if "attributes" in config_dict:
            attributes = config_dict["attributes"]
 
            if "epochs" in attributes:
                params["epochs"] = attributes["epochs"]
            if "warmupEpochs" in attributes:
                params["warmup_epochs"] = attributes["warmupEpochs"]
            if "lrMinRatio" in attributes:
                params["lr_min_ratio"] = attributes["lrMinRatio"]
            if "anchors" in attributes:
                params["anchors"] = attributes["anchors"]
            if "useXYXY" in attributes:
                params["use_xyxy"] = attributes["useXYXY"]
            if "saveDir" in attributes:
                params["save_dir"] = attributes["saveDir"]
            if "seed" in attributes:
                params["seed"] = attributes["seed"]
            if "applyLayers" in attributes:
                params["apply_layers"] = attributes["applyLayers"]
            if "excludeLayers" in attributes:
                params["exclude_layers"] = attributes["excludeLayers"]
            if "modAfterLayerName" in attributes:
                params["mod_after_layer_name"] = attributes["modAfterLayerName"]
 
            if "learningRates" in attributes:
                learning_rates = attributes["learningRates"]
                if "actScale" in learning_rates:
                    params["lr_act_scale"] = learning_rates["actScale"]
                if "zeropoint" in learning_rates:
                    params["lr_zeropoint"] = learning_rates["zeropoint"]
                if "weightScale" in learning_rates:
                    params["lr_weight_scale"] = learning_rates["weightScale"]
                if "weight" in learning_rates:
                    params["lr_weight"] = learning_rates["weight"]
                if "bias" in learning_rates:
                    params["lr_bias"] = learning_rates["bias"]
 
            if "training" in attributes:
                training = attributes["training"]
                if "batchSize" in training:
                    params["batch_size"] = training["batchSize"]
                if "qDrop" in training:
                    params["q_drop"] = training["qDrop"]
 
            if "postProcessing" in attributes:
                post_processing = attributes["postProcessing"]
                if "post" in post_processing:
                    params["post_processing"] = post_processing["post"]
                if "boxConfThres" in post_processing:
                    params["box_conf_thres"] = post_processing["boxConfThres"]
                if "boxIoUThres" in post_processing:
                    params["box_iou_thres"] = post_processing["boxIoUThres"]
 
            if "loss" in attributes:
                loss = attributes["loss"]
                if "type" in loss:
                    params["loss_type"] = loss["type"]
                if "useOutputs" in loss:
                    params["use_outputs"] = loss["useOutputs"]
                if "KLTemperature" in loss:
                    params["kl_temperature"] = loss["KLTemperature"]
                if "reconProb" in loss:
                    params["recon_prob"] = loss["reconProb"]
                if "reconCoeff" in loss:
                    params["recon_coeff"] = loss["reconCoeff"]
                if "lambda_0" in loss:
                    params["lambda_0"] = loss["lambda_0"]
                if "lambda_1" in loss:
                    params["lambda_1"] = loss["lambda_1"]
                if "lambda_2" in loss:
                    params["lambda_2"] = loss["lambda_2"]
                # Read customLossJITPath from loss object
                if "customLossJITPath" in loss:
                    params["custom_loss_jit_path"] = loss["customLossJITPath"]
 
        return cls(**params)
 
    def to_dict(self):
        return {
            "apply": self.apply,
            "attributes": {
                "epochs": self.epochs,
                "warmupEpochs": self.warmup_epochs,
                "learningRates": {
                    "actScale": self.lr_act_scale,
                    "zeropoint": self.lr_zeropoint,
                    "weightScale": self.lr_weight_scale,
                    "weight": self.lr_weight,
                    "bias": self.lr_bias,
                },
                "lrMinRatio": self.lr_min_ratio,
                "training": {
                    "batchSize": self.batch_size,
                    "qDrop": self.q_drop,
                },
                "postProcessing": {
                    "post": self.post_processing,
                    "boxConfThres": self.box_conf_thres,
                    "boxIoUThres": self.box_iou_thres,
                },
                "loss": {
                    "type": self.loss_type,
                    "useOutputs": self.use_outputs,
                    "KLTemperature": self.kl_temperature,
                    "reconProb": self.recon_prob,
                    "reconCoeff": self.recon_coeff,
                    "lambda_0": self.lambda_0,
                    "lambda_1": self.lambda_1,
                    "lambda_2": self.lambda_2,
                    "customLossJITPath": self.custom_loss_jit_path,
                },
                "anchors": self.anchors,
                "useXYXY": self.use_xyxy,
                "saveDir": self.save_dir,
                "seed": self.seed,
                "applyLayers": self.apply_layers,
                "excludeLayers": self.exclude_layers,
                "modAfterLayerName": self.mod_after_layer_name,
            },
        }
 
 
def get_mod_config(**kwargs) -> ModConfig:
    """
    @brief Create ModConfig with partial parameters merged with defaults.
    """
    params = ModConfig.DEFAULTS.copy()
    params.update(kwargs)
    return ModConfig(**params, optional=ModConfig.optional)
 
 
# @}