I would suggest to hide caching logic and have simple function call like compress_weight or quantize_weight.

Do you suggest to create a quantize_weight()/compress_weight() function alongside calculate_quantized_weight() function at weight_lowering.py and call the former one from the latter one? If so, don't you think it is an unnecessary function multiplication? In my opinion weight_lowering.py already has so many different functions with similar names, it's hard to distinguish which does what.

I tend to agree with your opinion. I'm working on this right now. If you have any suggestions for refactoring weight_lowering.py, please, let me know. Regarding this comment, I hope that you can extend the functionality of weight_lowering.py without adding complexity to this module.

To avoid copy-paste of this code, dispatching can be implemented.

Cache logic can be encapsulated into decorator as following:

@cache
def jit_compress_weight(
        weight: Tensor,
        scale: Tensor,
        zero_point: Tensor,
        num_bits: int
    ):
        level_low = 0
        level_high = 2**num_bits - 1

        w = opset.parameter(weight.shape, name="w")
        s = opset.parameter(scale.shape, name="s")
        zp = opset.parameter(zero_point.shape, name="zp")

        result = opset.clamp(opset.round(w / s   zp), level_low, level_high, name="compressed_weights")

        if return_nodes:
            return w, s, zp, result

        model = ov.Model([result], [w, s, zp])

        compiled_model = ov.compile_model(model)

        return lambda w, s, zp: compiled_model([w, s, zp])[0]

def compress_weight(
        weight: Tensor,
        scale: Tensor,
        zero_point: Tensor,
        num_bits: int
        
    ):
         return jit_compress_weight(weight, scale, zero_point, num_bits)