Image Classification
Keras
LiteRT
LiteRT
computer-vision
efficientnet
quantization
mixed-precision
sub-4-bit
tensorflow
Eval Results (legacy)
Instructions to use meatloafer/efficientnet-b0-sub4bit-mixed-precision with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Keras
How to use meatloafer/efficientnet-b0-sub4bit-mixed-precision with Keras:
# !pip install -U keras tensorflow huggingface_hub # Keras needs TensorFlow installed to read "hf://" paths, so the tensorflow backend is selected here; # "jax" and "torch" also work for computation once TensorFlow is installed. import os os.environ["KERAS_BACKEND"] = "tensorflow" import keras model = keras.saving.load_model("hf://meatloafer/efficientnet-b0-sub4bit-mixed-precision") - LiteRT
How to use meatloafer/efficientnet-b0-sub4bit-mixed-precision with LiteRT:
# No code snippets available yet for this library. # To use this model, check the repository files and the library's documentation. # Want to help? PRs adding snippets are welcome at: # https://github.com/huggingface/huggingface.js
- Notebooks
- Google Colab
- Kaggle
File size: 10,374 Bytes
2abfed0 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 | """Deterministic, forward-only BatchNorm recalibration for quantized models."""
from __future__ import annotations
import hashlib
import math
import numpy as np
import tensorflow as tf
def _variable_path(variable) -> str:
return str(getattr(variable, "path", variable.name))
def _hash_variables(variables) -> str:
digest = hashlib.sha256()
for variable in sorted(variables, key=_variable_path):
values = np.asarray(variable.numpy())
digest.update(_variable_path(variable).encode("utf-8") + b"\0")
digest.update(str(values.dtype).encode("ascii") + b"\0")
digest.update(np.asarray(values.shape, dtype="<i8").tobytes())
digest.update(values.tobytes(order="C"))
return digest.hexdigest()
def recalibrate_batchnorm_forward_only(
model: tf.keras.Model,
dataset,
*,
examples: int = 1_000,
) -> tuple[tf.keras.Model, dict]:
"""Re-estimate BatchNorm statistics on an exact ordered training subset.
The input dataset must be deterministic, non-shuffled, and yield
``(images, labels, image_ids)`` or ``(images, labels)``. The recalibration
clone disables Dropout/drop-path, resets moving statistics, freezes all
non-BN weights, and calls the model with ``training=True``. Per-channel
population mean and variance are accumulated across batches with parallel
Welford updates, including the between-batch mean correction. This is a
deterministic calibration pass on the supplied subset, not a claim that
every deployment distribution is matched.
"""
if examples < 1:
raise ValueError("examples must be positive")
def clone_layer(layer):
config = layer.get_config()
if isinstance(layer, tf.keras.layers.Dropout):
config["rate"] = 0.0
cloned = layer.__class__.from_config(config)
cloned.trainable = isinstance(layer, tf.keras.layers.BatchNormalization)
return cloned
calibration = tf.keras.models.clone_model(model, clone_function=clone_layer)
source_layers = {layer.name: layer for layer in model.layers}
source_trainable = {layer.name: bool(layer.trainable) for layer in model.layers}
for target_layer in calibration.layers:
source_layer = source_layers.get(target_layer.name)
if source_layer is None:
raise ValueError(f"Calibration clone added unexpected layer {target_layer.name}")
if source_layer.weights and target_layer.weights:
target_layer.set_weights(source_layer.get_weights())
batch_norms = [
layer for layer in calibration.layers
if isinstance(layer, tf.keras.layers.BatchNormalization)
]
if not batch_norms:
raise ValueError("The model has no BatchNormalization layers")
original_momenta = {layer.name: float(layer.momentum) for layer in batch_norms}
original_calls = {id(layer): (layer, layer.call) for layer in batch_norms}
source_moving_variables = [
variable
for layer in source_layers.values()
if isinstance(layer, tf.keras.layers.BatchNormalization)
for variable in (layer.moving_mean, layer.moving_variance)
]
source_moving_sha = _hash_variables(source_moving_variables)
moving_variable_ids = {
id(variable)
for layer in calibration.layers
if isinstance(layer, tf.keras.layers.BatchNormalization)
for variable in (layer.moving_mean, layer.moving_variance)
}
fixed_variables = [
variable
for layer in calibration.layers
for variable in layer.weights
if id(variable) not in moving_variable_ids
]
fixed_before = [np.asarray(variable.numpy()).copy() for variable in fixed_variables]
batch_moments: dict[str, tuple[np.ndarray, np.ndarray, int]] = {}
running_moments: dict[str, tuple[int, np.ndarray, np.ndarray]] = {}
for layer in calibration.layers:
layer.trainable = isinstance(layer, tf.keras.layers.BatchNormalization)
# Freeze only affine/trainable variables; the BN layers remain trainable so
# their moving statistics update during explicit training=True calls.
for layer in batch_norms:
layer.trainable = True
layer.moving_mean.assign(tf.zeros_like(layer.moving_mean))
layer.moving_variance.assign(tf.ones_like(layer.moving_variance))
layer.momentum = 0.0
original_call = original_calls[id(layer)][1]
def tracked_call(inputs, training=None, mask=None, _layer=layer, _original=original_call, **kwargs):
if training is True:
axes = tuple(range(len(inputs.shape) - 1))
mean, variance = tf.nn.moments(inputs, axes=axes)
mean = np.asarray(mean.numpy(), dtype=np.float64)
variance = np.asarray(variance.numpy(), dtype=np.float64)
dynamic_shape = tf.shape(inputs).numpy()
count = math.prod(int(dynamic_shape[axis]) for axis in axes)
batch_moments[_layer.name] = (mean, variance, int(count))
return _original(inputs, training=training, mask=mask, **kwargs)
layer.call = tracked_call
observed = 0
identity = hashlib.sha256()
last_batch_count = 0
has_ids = None
try:
for batch in dataset:
if not isinstance(batch, (tuple, list)) or len(batch) < 1:
raise ValueError("Dataset batches must contain images as their first item")
images = batch[0]
if isinstance(images, dict):
raise ValueError("Image dictionaries are not supported by this recalibration helper")
batch_count = int(tf.shape(images)[0].numpy())
if batch_count < 1:
continue
take = min(batch_count, examples - observed)
if take <= 0:
break
images = images[:take]
labels = batch[1][:take].numpy() if len(batch) >= 2 else None
batch_has_ids = len(batch) >= 3
if has_ids is None:
has_ids = batch_has_ids
elif has_ids != batch_has_ids:
raise ValueError("Dataset inconsistently includes image IDs")
if batch_has_ids:
image_ids = np.asarray(batch[2][:take].numpy()).reshape(-1)
for index, image_id in enumerate(image_ids):
identity.update(
bytes(image_id)
if isinstance(image_id, (bytes, np.bytes_))
else str(image_id).encode("utf-8")
)
identity.update(b"\t")
if labels is not None:
identity.update(str(int(labels[index])).encode("ascii"))
identity.update(b"\n")
batch_moments.clear()
calibration(images, training=True)
for layer in batch_norms:
if layer.name not in batch_moments:
raise RuntimeError(f"BatchNorm layer {layer.name} was not called")
batch_mean, batch_variance, batch_elements = batch_moments[layer.name]
previous = running_moments.get(layer.name)
if previous is None:
running_moments[layer.name] = (
batch_elements,
batch_mean.copy(),
batch_variance.copy(),
)
else:
previous_elements, previous_mean, previous_variance = previous
total_elements = previous_elements + batch_elements
delta = batch_mean - previous_mean
mean = previous_mean + delta * (batch_elements / total_elements)
variance = (
previous_elements * previous_variance
+ batch_elements * batch_variance
+ np.square(delta)
* (previous_elements * batch_elements / total_elements)
) / total_elements
running_moments[layer.name] = (total_elements, mean, variance)
_, mean, variance = running_moments[layer.name]
layer.moving_mean.assign(mean.astype(np.float32))
layer.moving_variance.assign(variance.astype(np.float32))
observed += take
last_batch_count = take
if observed == examples:
break
finally:
for layer, original_call in original_calls.values():
layer.call = original_call
for layer in calibration.layers:
if isinstance(layer, tf.keras.layers.BatchNormalization):
layer.momentum = original_momenta[layer.name]
layer.trainable = source_trainable[layer.name]
calibration.trainable = model.trainable
if observed != examples:
raise RuntimeError(f"Calibration dataset ended after {observed}/{examples} examples")
fixed_after = [np.asarray(variable.numpy()) for variable in fixed_variables]
if any(not np.array_equal(before, after) for before, after in zip(fixed_before, fixed_after)):
raise RuntimeError("A non-moving model weight changed during BN recalibration")
moving_variables = [
variable for layer in batch_norms
for variable in (layer.moving_mean, layer.moving_variance)
]
return calibration, {
"status": "complete",
"examples": observed,
"batch_norm_layer_count": len(batch_norms),
"last_batch_examples": last_batch_count,
"ordered_image_id_label_sha256": identity.hexdigest() if has_ids else None,
"update": "forward-only training=True pass; exact per-layer pooled population moments with between-batch correction; trainable weights frozen; dropout/drop-path disabled",
"per_layer_element_counts": {
name: count for name, (count, _, _) in sorted(running_moments.items())
},
"source_moving_statistics_sha256": source_moving_sha,
"recalibrated_moving_statistics_sha256": _hash_variables(moving_variables),
"non_moving_weights_verified_unchanged": True,
"interpretation_limit": "This estimates BatchNorm moments over the fixed calibration subset; it does not establish classifier-quality recovery or deployment-distribution matching.",
}
|