"""Weight fake-quantization layers for registered low-bit experiments.""" from __future__ import annotations import tensorflow as tf from imagenet_research.models import ( BiFPNLayer, DCNv4Reference, SpatialTransformerBlock, _fake_quantize_kernel_per_output_channel, ) @tf.keras.utils.register_keras_serializable(package="imagenet_research") class FakeQuantConv2D(tf.keras.layers.Conv2D): """Conv2D with per-output-channel fake-quantized kernels.""" def __init__(self, num_bits: int = 4, **kwargs): if num_bits < 2 or num_bits > 8: raise ValueError("num_bits must be between 2 and 8") self.num_bits = int(num_bits) super().__init__(**kwargs) def convolution_op(self, inputs, kernel): quantized_kernel = _fake_quantize_kernel_per_output_channel( kernel, self.num_bits ) return super().convolution_op(inputs, tf.cast(quantized_kernel, kernel.dtype)) def get_config(self): config = super().get_config() config["num_bits"] = self.num_bits return config @tf.keras.utils.register_keras_serializable(package="imagenet_research") class FakeQuantDepthwiseConv2D(tf.keras.layers.DepthwiseConv2D): """DepthwiseConv2D with per-channel fake-quantized kernels.""" def __init__(self, num_bits: int = 4, **kwargs): if num_bits < 2 or num_bits > 8: raise ValueError("num_bits must be between 2 and 8") self.num_bits = int(num_bits) super().__init__(**kwargs) def call(self, inputs): kernel32 = tf.cast(self.kernel, tf.float32) input_channels = self._get_input_channel(inputs.shape) output_channels = input_channels * self.depth_multiplier flattened = tf.reshape( kernel32, [self.kernel_size[0], self.kernel_size[1], output_channels] ) quantized = _fake_quantize_kernel_per_output_channel(flattened, self.num_bits) quantized = tf.reshape(quantized, tf.shape(kernel32)) quantized = tf.cast(quantized, self.compute_dtype) inputs = tf.cast(inputs, self.compute_dtype) outputs = tf.keras.ops.depthwise_conv( inputs, quantized, strides=self.strides, padding=self.padding, dilation_rate=self.dilation_rate, data_format=self.data_format, ) if self.use_bias: bias = tf.cast(self.bias, self.compute_dtype) if self.data_format == "channels_last": bias_shape = (1,) * (self.rank + 1) + (output_channels,) else: bias_shape = (1, output_channels) + (1,) * self.rank outputs = tf.keras.ops.add(outputs, tf.keras.ops.reshape(bias, bias_shape)) if self.activation is not None: outputs = self.activation(outputs) return outputs def get_config(self): config = super().get_config() config["num_bits"] = self.num_bits return config @tf.keras.utils.register_keras_serializable(package="imagenet_research") class FakeQuantDense(tf.keras.layers.Dense): """Dense with per-output-channel fake-quantized kernels.""" def __init__(self, num_bits: int = 4, **kwargs): if num_bits < 2 or num_bits > 8: raise ValueError("num_bits must be between 2 and 8") self.num_bits = int(num_bits) super().__init__(**kwargs) def call(self, inputs, training=None): kernel = _fake_quantize_kernel_per_output_channel(self.kernel, self.num_bits) kernel = tf.cast(kernel, self.compute_dtype) inputs = tf.cast(inputs, self.compute_dtype) outputs = tf.keras.ops.matmul(inputs, kernel) if self.bias is not None: outputs = tf.keras.ops.add(outputs, tf.cast(self.bias, self.compute_dtype)) if self.activation is not None: outputs = self.activation(outputs) return outputs def get_config(self): config = super().get_config() config["num_bits"] = self.num_bits return config def apply_weight_fake_quant(model: tf.keras.Model, num_bits: int) -> tf.keras.Model: """Clone a supported classifier with trainable, per-output-channel Q/DQ. The fake-quant ops use TensorFlow's straight-through estimator, so the returned model can be evaluated as PTQ simulation or fine-tuned as QAT. Hybrid and BiFPN custom layers quantize their internal convolutional and dense projection kernels, including the MHSA projections. Normalization parameters, biases, softmax, and activations remain float32. DCNv4's custom layer quantizes only its value/output projections; its offset and aggregation-weight predictor remains float32. """ if num_bits < 2 or num_bits > 8: raise ValueError("num_bits must be between 2 and 8") def clone_layer(layer): config = layer.get_config() if isinstance(layer, DCNv4Reference): config["main_weight_bits"] = num_bits return DCNv4Reference.from_config(config) if isinstance(layer, SpatialTransformerBlock): config["weight_fake_quant_bits"] = num_bits return SpatialTransformerBlock.from_config(config) if isinstance(layer, BiFPNLayer): config["weight_fake_quant_bits"] = num_bits return BiFPNLayer.from_config(config) if isinstance(layer, tf.keras.layers.DepthwiseConv2D): return FakeQuantDepthwiseConv2D(num_bits=num_bits, **config) if isinstance(layer, tf.keras.layers.Conv2D): return FakeQuantConv2D(num_bits=num_bits, **config) if isinstance(layer, tf.keras.layers.Dense): return FakeQuantDense(num_bits=num_bits, **config) return layer.__class__.from_config(config) clone = tf.keras.models.clone_model( model, clone_function=clone_layer, recursive=True ) for source_layer in model.layers: target_layer = clone.get_layer(source_layer.name) if source_layer.weights: target_layer.set_weights(source_layer.get_weights()) return clone