From 4f24cd250b50a9150d35ef8640b7f07fd4bb3b5e Mon Sep 17 00:00:00 2001 From: IMvision12 Date: Thu, 27 Aug 2026 02:20:07 -0700 Subject: [PATCH 1/5] Add EfficientDet Models --- zeromodels/models/__init__.py | 1 + zeromodels/models/efficientdet/__init__.py | 8 + .../efficientdet/efficientdet_config.py | 171 +++++++++ .../efficientdet/efficientdet_layers.py | 349 ++++++++++++++++++ .../models/efficientdet/efficientdet_model.py | 189 ++++++++++ 5 files changed, 718 insertions(+) create mode 100644 zeromodels/models/efficientdet/__init__.py create mode 100644 zeromodels/models/efficientdet/efficientdet_config.py create mode 100644 zeromodels/models/efficientdet/efficientdet_layers.py create mode 100644 zeromodels/models/efficientdet/efficientdet_model.py diff --git a/zeromodels/models/__init__.py b/zeromodels/models/__init__.py index 2a302536..a413d52c 100644 --- a/zeromodels/models/__init__.py +++ b/zeromodels/models/__init__.py @@ -23,6 +23,7 @@ dino, dino_v2, dino_v3, + efficientdet, efficientformer, efficientnet, efficientnet_lite, diff --git a/zeromodels/models/efficientdet/__init__.py b/zeromodels/models/efficientdet/__init__.py new file mode 100644 index 00000000..3bc5d6b9 --- /dev/null +++ b/zeromodels/models/efficientdet/__init__.py @@ -0,0 +1,8 @@ +from .efficientdet_config import EFFICIENTDET_RECIPES, EfficientDetConfig +from .efficientdet_model import EfficientDetModel + +__all__ = [ + "EfficientDetConfig", + "EFFICIENTDET_RECIPES", + "EfficientDetModel", +] diff --git a/zeromodels/models/efficientdet/efficientdet_config.py b/zeromodels/models/efficientdet/efficientdet_config.py new file mode 100644 index 00000000..847b7b07 --- /dev/null +++ b/zeromodels/models/efficientdet/efficientdet_config.py @@ -0,0 +1,171 @@ +from zeromodels.base import BaseConfig + + +class EfficientDetConfig(BaseConfig): + r"""Configuration for EfficientDet (Google AutoML) object detection. + + EfficientDet = an EfficientNet backbone -> a weighted bidirectional feature + pyramid (BiFPN, repeated ``fpn_cell_repeats`` times) -> shared class + box + prediction heads run over pyramid levels ``min_level``..``max_level``. Defaults + describe **EfficientDet-D0**; the D1-D7 variants override a handful of fields + (see :data:`EFFICIENTDET_RECIPES`). + + Args: + backbone_name (`str`, *optional*, defaults to `"efficientnet_b0"`): + zeromodels EfficientNet backbone variant (the ``tf_efficientnet`` flavor + matches Google's backbone). D0->b0, D1->b1, ... D6/D7->b6. + image_size (`int`, *optional*, defaults to `512`): + Square input resolution. + num_classes (`int`, *optional*, defaults to `90`): + COCO class count (background excluded). + min_level / max_level (`int`, *optional*, defaults to `3` / `7`): + Pyramid levels the BiFPN + heads run over. + num_scales (`int`, *optional*, defaults to `3`): + Anchor scales per level; ``num_anchors = num_scales * len(aspect_ratios)``. + aspect_ratios (`tuple`, *optional*, defaults to `(1.0, 2.0, 0.5)`): + Anchor aspect ratios. + anchor_scale (`float`, *optional*, defaults to `4.0`): + Base anchor size in units of the feature stride. + fpn_num_filters (`int`, *optional*, defaults to `64`): + BiFPN (and head) channel width. + fpn_cell_repeats (`int`, *optional*, defaults to `3`): + Number of stacked BiFPN cells. + box_class_repeats (`int`, *optional*, defaults to `3`): + Shared conv layers in each of the class / box heads. + act_type (`str`, *optional*, defaults to `"swish"`): + Activation used throughout the BiFPN and heads. + separable_conv (`bool`, *optional*, defaults to `True`): + Use depthwise-separable 3x3 convs (as EfficientDet does). + apply_bn_for_resampling (`bool`, *optional*, defaults to `True`): + BatchNorm after the 1x1 channel-match in resampling. + conv_after_downsample (`bool`, *optional*, defaults to `False`): + Apply the 1x1 channel-match after (vs before) the downsample pool. + conv_bn_act_pattern (`bool`, *optional*, defaults to `False`): + `False` => act -> conv -> BN in a BiFPN node; `True` => conv -> BN -> act. + fpn_weight_method (`str`, *optional*, defaults to `"fastattn"`): + BiFPN edge fusion: `"fastattn"` (fast normalized), `"attn"` (softmax), + or `"sum"`. + survival_prob (`float`, *optional*): + Drop-connect keep prob in the heads (inference ignores it). + + Example: + + ```python + >>> from zeromodels.models.efficientdet import EfficientDetConfig, EFFICIENTDET_RECIPES + + >>> config = EfficientDetConfig(**EFFICIENTDET_RECIPES["efficientdet_d2"]) + ```""" + + model_type = "efficientdet" + + backbone_name: str = "efficientnet_b0" + image_size: int = 512 + num_classes: int = 90 + min_level: int = 3 + max_level: int = 7 + num_scales: int = 3 + aspect_ratios: tuple = (1.0, 2.0, 0.5) + anchor_scale: float = 4.0 + fpn_num_filters: int = 64 + fpn_cell_repeats: int = 3 + box_class_repeats: int = 3 + act_type: str = "swish" + separable_conv: bool = True + apply_bn_for_resampling: bool = True + conv_after_downsample: bool = False + conv_bn_act_pattern: bool = False + fpn_weight_method: str = "fastattn" + survival_prob: float = None + + +# Per-variant overrides of the D0 defaults (Google's efficientdet-d0..d7 recipes). +EFFICIENTDET_RECIPES = { + "efficientdet_d0": { + "backbone_name": "efficientnet_b0", + "image_size": 512, + "fpn_num_filters": 64, + "fpn_cell_repeats": 3, + "box_class_repeats": 3, + }, + "efficientdet_d1": { + "backbone_name": "efficientnet_b1", + "image_size": 640, + "fpn_num_filters": 88, + "fpn_cell_repeats": 4, + "box_class_repeats": 3, + }, + "efficientdet_d2": { + "backbone_name": "efficientnet_b2", + "image_size": 768, + "fpn_num_filters": 112, + "fpn_cell_repeats": 5, + "box_class_repeats": 3, + }, + "efficientdet_d3": { + "backbone_name": "efficientnet_b3", + "image_size": 896, + "fpn_num_filters": 160, + "fpn_cell_repeats": 6, + "box_class_repeats": 4, + }, + "efficientdet_d4": { + "backbone_name": "efficientnet_b4", + "image_size": 1024, + "fpn_num_filters": 224, + "fpn_cell_repeats": 7, + "box_class_repeats": 4, + }, + "efficientdet_d5": { + "backbone_name": "efficientnet_b5", + "image_size": 1280, + "fpn_num_filters": 288, + "fpn_cell_repeats": 7, + "box_class_repeats": 4, + }, + "efficientdet_d6": { + "backbone_name": "efficientnet_b6", + "image_size": 1280, + "fpn_num_filters": 384, + "fpn_cell_repeats": 8, + "box_class_repeats": 5, + }, + "efficientdet_d7": { + "backbone_name": "efficientnet_b6", + "image_size": 1536, + "fpn_num_filters": 384, + "fpn_cell_repeats": 8, + "box_class_repeats": 5, + "anchor_scale": 5.0, + }, +} + + +def bifpn_nodes(min_level, max_level): + """Google's dynamic BiFPN node topology for ``min_level``..``max_level``. + + Each node lists the offsets (into the growing feature list) it fuses; a + top-down path (P{max-1}'..P{min}') then a bottom-up path (P{min+1}''..P{max}''). + """ + num_levels = max_level - min_level + 1 + node_ids = {min_level + i: [i] for i in range(num_levels)} + counter = num_levels + nodes = [] + for level in range(max_level - 1, min_level - 1, -1): # top-down + nodes.append( + { + "feat_level": level, + "inputs_offsets": [node_ids[level][-1], node_ids[level + 1][-1]], + } + ) + node_ids[level].append(counter) + counter += 1 + for level in range(min_level + 1, max_level + 1): # bottom-up + nodes.append( + { + "feat_level": level, + "inputs_offsets": node_ids[level] + [node_ids[level - 1][-1]], + } + ) + node_ids[level].append(counter) + counter += 1 + return nodes diff --git a/zeromodels/models/efficientdet/efficientdet_layers.py b/zeromodels/models/efficientdet/efficientdet_layers.py new file mode 100644 index 00000000..05c5c806 --- /dev/null +++ b/zeromodels/models/efficientdet/efficientdet_layers.py @@ -0,0 +1,349 @@ +import math + +import keras +from keras import layers, ops + +from .efficientdet_config import bifpn_nodes + + +def act(x, act_type="swish"): + if act_type == "swish": + return ops.silu(x) + if act_type == "relu": + return ops.relu(x) + return layers.Activation(act_type)(x) + + +def sep_conv(filters, kernel_size=3, use_bias=True, name=None): + return layers.SeparableConv2D( + filters, + kernel_size=kernel_size, + padding="same", + depth_multiplier=1, + use_bias=use_bias, + name=name, + ) + + +@keras.saving.register_keras_serializable(package="zeromodels") +class EfficientDetResample(layers.Layer): + """Resample a feature map to a target level: 1x1 conv (only when the channel + count changes) + BatchNorm, then max-pool (downsample) or nearest-neighbour + upsample to the target spatial size. ``conv_after_downsample`` moves the 1x1 + to after the pool.""" + + def __init__( + self, + target_channels, + apply_bn=True, + conv_after_downsample=False, + name=None, + ): + super().__init__(name=name) + self.target_channels = target_channels + self.apply_bn = apply_bn + self.conv_after_downsample = conv_after_downsample + self.conv2d = None + self.bn = None + + def build(self, input_shape): + in_channels = input_shape[-1] + if in_channels != self.target_channels: + self.conv2d = layers.Conv2D( + self.target_channels, 1, padding="same", name="conv2d" + ) + if self.apply_bn: + self.bn = layers.BatchNormalization(name="bn") + self.built = True + + def apply_1x1(self, feat, training): + if self.conv2d is not None: + feat = self.conv2d(feat) + if self.bn is not None: + feat = self.bn(feat, training=training) + return feat + + def call(self, feat, target_height, target_width, training=False): + height, width = int(feat.shape[1]), int(feat.shape[2]) + if height > target_height and width > target_width: + if not self.conv_after_downsample: + feat = self.apply_1x1(feat, training) + h_stride = (height - 1) // target_height + 1 + w_stride = (width - 1) // target_width + 1 + feat = layers.MaxPooling2D( + pool_size=(h_stride + 1, w_stride + 1), + strides=(h_stride, w_stride), + padding="same", + )(feat) + if self.conv_after_downsample: + feat = self.apply_1x1(feat, training) + else: + feat = self.apply_1x1(feat, training) + if height < target_height or width < target_width: + feat = ops.image.resize( + feat, (target_height, target_width), interpolation="nearest" + ) + return feat + + def get_config(self): + config = super().get_config() + config.update( + { + "target_channels": self.target_channels, + "apply_bn": self.apply_bn, + "conv_after_downsample": self.conv_after_downsample, + } + ) + return config + + +@keras.saving.register_keras_serializable(package="zeromodels") +class FNode(layers.Layer): + """One BiFPN node: resample each input feature to this node's level, fuse them + with a weighted sum (``fastattn`` = normalized ReLU weights, ``attn`` = softmax, + ``sum`` = plain), then act -> separable 3x3 conv -> BN. Appends the new feature + to the running list.""" + + def __init__( + self, + feat_level, + inputs_offsets, + fpn_num_filters, + weight_method, + act_type, + apply_bn_for_resampling, + conv_after_downsample, + conv_bn_act_pattern, + name=None, + ): + super().__init__(name=name) + self.feat_level = feat_level + self.inputs_offsets = list(inputs_offsets) + self.fpn_num_filters = fpn_num_filters + self.weight_method = weight_method + self.act_type = act_type + self.apply_bn_for_resampling = apply_bn_for_resampling + self.conv_after_downsample = conv_after_downsample + self.conv_bn_act_pattern = conv_bn_act_pattern + self.resamples = [ + EfficientDetResample( + fpn_num_filters, + apply_bn=apply_bn_for_resampling, + conv_after_downsample=conv_after_downsample, + name=f"resample_{i}_{off}", + ) + for i, off in enumerate(self.inputs_offsets) + ] + self.conv = sep_conv( + fpn_num_filters, 3, use_bias=not conv_bn_act_pattern, name="conv" + ) + self.bn = layers.BatchNormalization(name="bn") + + def build(self, input_shape): + self.edge_weights = None + if self.weight_method in ("fastattn", "attn"): + self.edge_weights = [ + self.add_weight( + name="WSM" + ("" if i == 0 else f"_{i}"), + shape=(), + initializer="ones", + trainable=True, + ) + for i in range(len(self.inputs_offsets)) + ] + self.built = True + + def fuse(self, nodes): + if self.weight_method == "fastattn": + weights = [ops.relu(w) for w in self.edge_weights] + total = ops.sum(ops.stack(weights)) + 1e-4 + return ops.sum( + ops.stack([n * (w / total) for n, w in zip(nodes, weights)]), axis=0 + ) + if self.weight_method == "attn": + weights = ops.softmax(ops.stack(self.edge_weights)) + return ops.sum( + ops.stack([n * weights[i] for i, n in enumerate(nodes)]), axis=0 + ) + return ops.sum(ops.stack(nodes), axis=0) + + def call(self, feats, target_height, target_width, training=False): + nodes = [ + self.resamples[i]( + feats[off], + target_height=target_height, + target_width=target_width, + training=training, + ) + for i, off in enumerate(self.inputs_offsets) + ] + new_node = self.fuse(nodes) + if not self.conv_bn_act_pattern: + new_node = act(new_node, self.act_type) + new_node = self.conv(new_node) + new_node = self.bn(new_node, training=training) + if self.conv_bn_act_pattern: + new_node = act(new_node, self.act_type) + return feats + [new_node] + + def get_config(self): + config = super().get_config() + config.update( + { + "feat_level": self.feat_level, + "inputs_offsets": self.inputs_offsets, + "fpn_num_filters": self.fpn_num_filters, + "weight_method": self.weight_method, + "act_type": self.act_type, + "apply_bn_for_resampling": self.apply_bn_for_resampling, + "conv_after_downsample": self.conv_after_downsample, + "conv_bn_act_pattern": self.conv_bn_act_pattern, + } + ) + return config + + +@keras.saving.register_keras_serializable(package="zeromodels") +class FPNCells(layers.Layer): + """The full BiFPN: ``fpn_cell_repeats`` stacked cells of ``FNode``s over levels + ``min_level``..``max_level``. Takes and returns a list of ``max_level-min_level+1`` + feature maps (all at ``fpn_num_filters`` channels), each level at its own + resolution.""" + + def __init__( + self, + min_level, + max_level, + fpn_num_filters, + fpn_cell_repeats, + weight_method, + act_type, + apply_bn_for_resampling, + conv_after_downsample, + conv_bn_act_pattern, + name="fpn_cells", + ): + super().__init__(name=name) + self.min_level = min_level + self.max_level = max_level + self.fpn_num_filters = fpn_num_filters + self.fpn_cell_repeats = fpn_cell_repeats + self.weight_method = weight_method + self.act_type = act_type + self.nodes_cfg = bifpn_nodes(min_level, max_level) + self.cells = [] + for rep in range(fpn_cell_repeats): + fnodes = [ + FNode( + cfg["feat_level"] - min_level, + cfg["inputs_offsets"], + fpn_num_filters, + weight_method, + act_type, + apply_bn_for_resampling, + conv_after_downsample, + conv_bn_act_pattern, + name=f"cell_{rep}_fnode{i}", + ) + for i, cfg in enumerate(self.nodes_cfg) + ] + self.cells.append(fnodes) + + def call(self, feats, level_sizes, training=False): + """``level_sizes``: list of (height, width) per level (min_level..max_level).""" + for fnodes in self.cells: + cur = list(feats) + for fnode, cfg in zip(fnodes, self.nodes_cfg): + lvl = cfg["feat_level"] - self.min_level + th, tw = level_sizes[lvl] + cur = fnode(cur, target_height=th, target_width=tw, training=training) + # keep the last node produced at each level (reverse-scan, like Google's). + feats = [] + for level in range(self.min_level, self.max_level + 1): + for i, cfg in enumerate(reversed(self.nodes_cfg)): + if cfg["feat_level"] == level: + feats.append(cur[-1 - i]) + break + return feats + + +@keras.saving.register_keras_serializable(package="zeromodels") +class PredictionHead(layers.Layer): + """Shared class or box head: ``repeats`` separable 3x3 convs, each with a + per-level BatchNorm and activation (conv weights shared across levels, BN not), + then a final separable 3x3 predictor with ``out_channels`` outputs per anchor.""" + + def __init__( + self, + out_channels, + num_filters, + repeats, + num_levels, + act_type, + head_name, + min_level=3, + predict_bias_init=0.0, + name=None, + ): + super().__init__(name=name) + self.out_channels = out_channels + self.num_filters = num_filters + self.repeats = repeats + self.num_levels = num_levels + self.act_type = act_type + self.head_name = head_name + self.min_level = min_level + self.predict_bias_init = predict_bias_init + self.convs = [ + sep_conv(num_filters, 3, use_bias=True, name=f"{head_name}-{i}") + for i in range(repeats) + ] + # one BatchNorm per (repeat, level); conv weights are shared across levels. + # BN names carry the absolute pyramid level (min_level + lvl), like Google's. + self.bns = [ + [ + layers.BatchNormalization(name=f"{head_name}-{i}-bn-{min_level + lvl}") + for lvl in range(num_levels) + ] + for i in range(repeats) + ] + self.predict = layers.SeparableConv2D( + out_channels, + 3, + padding="same", + depth_multiplier=1, + bias_initializer=keras.initializers.Constant(predict_bias_init), + name=f"{head_name}-predict", + ) + + def call(self, feats, training=False): + outputs = [] + for level_id in range(self.num_levels): + x = feats[level_id] + for i in range(self.repeats): + x = self.convs[i](x) + x = self.bns[i][level_id](x, training=training) + x = act(x, self.act_type) + outputs.append(self.predict(x)) + return outputs + + def get_config(self): + config = super().get_config() + config.update( + { + "out_channels": self.out_channels, + "num_filters": self.num_filters, + "repeats": self.repeats, + "num_levels": self.num_levels, + "act_type": self.act_type, + "head_name": self.head_name, + "min_level": self.min_level, + "predict_bias_init": self.predict_bias_init, + } + ) + return config + + +def class_predict_bias(): + """Focal-loss prior bias for the class predictor: ``-log((1 - 0.01) / 0.01)``.""" + return -math.log((1 - 0.01) / 0.01) diff --git a/zeromodels/models/efficientdet/efficientdet_model.py b/zeromodels/models/efficientdet/efficientdet_model.py new file mode 100644 index 00000000..bb9d1851 --- /dev/null +++ b/zeromodels/models/efficientdet/efficientdet_model.py @@ -0,0 +1,189 @@ +import keras +from keras import layers + +from zeromodels.base import BaseModel +from zeromodels.models.efficientnet.efficientnet_model import ( + efficientnet_backbone_feature, +) + +from .efficientdet_config import EfficientDetConfig +from .efficientdet_layers import ( + EfficientDetResample, + FPNCells, + PredictionHead, + class_predict_bias, +) + +# EfficientNet (width, depth, dropout) coefficients per EfficientDet backbone. +BACKBONE_COEFFS = { + "efficientnet_b0": (1.0, 1.0, 0.2), + "efficientnet_b1": (1.0, 1.1, 0.2), + "efficientnet_b2": (1.1, 1.2, 0.3), + "efficientnet_b3": (1.2, 1.4, 0.3), + "efficientnet_b4": (1.4, 1.8, 0.4), + "efficientnet_b5": (1.6, 2.2, 0.4), + "efficientnet_b6": (1.8, 2.6, 0.5), +} + +CONFIG_ATTRS = ( + "backbone_name", + "image_size", + "num_classes", + "min_level", + "max_level", + "num_scales", + "aspect_ratios", + "anchor_scale", + "fpn_num_filters", + "fpn_cell_repeats", + "box_class_repeats", + "act_type", + "separable_conv", + "apply_bn_for_resampling", + "conv_after_downsample", + "conv_bn_act_pattern", + "fpn_weight_method", + "survival_prob", +) + + +@keras.saving.register_keras_serializable(package="zeromodels") +class EfficientDetModel(BaseModel): + """EfficientDet backbone + BiFPN + heads (raw outputs, Google AutoML). + + An EfficientNet backbone (multi-level features P3-P5) is extended with strided + resamples to P6-P7, fused by a repeated weighted BiFPN, and read out by shared + class + box heads. Takes an ``images`` input ``(B, image_size, image_size, 3)`` + and returns ``{"class_outputs", "box_outputs"}``: lists of per-level tensors + ``(B, H_l, W_l, num_anchors * num_classes)`` and ``(B, H_l, W_l, num_anchors * 4)`` + for levels ``min_level``..``max_level``. Decode with anchors + NMS. + + References: + - [EfficientDet: Scalable and Efficient Object Detection](https://arxiv.org/abs/1911.09070) + + Args: + See :class:`EfficientDetConfig`. Defaults describe EfficientDet-D0. + name: String, model name. Defaults to `"EfficientDet"`. + + Returns: + A Keras `Model` instance. + """ + + BASE_WEIGHT_CONFIG = None + HF_MODEL_TYPE = "efficientdet" + config_class = EfficientDetConfig + + def __init__( + self, + backbone_name="efficientnet_b0", + image_size=512, + num_classes=90, + min_level=3, + max_level=7, + num_scales=3, + aspect_ratios=(1.0, 2.0, 0.5), + anchor_scale=4.0, + fpn_num_filters=64, + fpn_cell_repeats=3, + box_class_repeats=3, + act_type="swish", + separable_conv=True, + apply_bn_for_resampling=True, + conv_after_downsample=False, + conv_bn_act_pattern=False, + fpn_weight_method="fastattn", + survival_prob=None, + name="EfficientDetModel", + **kwargs, + ): + for k in ("model", "hf_id", "url", "num_classes_"): + kwargs.pop(k, None) + + num_anchors = num_scales * len(aspect_ratios) + width, depth, dropout = BACKBONE_COEFFS[backbone_name] + level_sizes = [ + (image_size // (2**level), image_size // (2**level)) + for level in range(min_level, max_level + 1) + ] + + image = layers.Input(shape=(image_size, image_size, 3), name="images") + + # Backbone P3/P4/P5 (strides 8/16/32 -> stages[2:5]). + stages = efficientnet_backbone_feature( + image, + width_coefficient=width, + depth_coefficient=depth, + dropout_rate=dropout, + data_format="channels_last", + channels_axis=-1, + return_stages=True, + ) + feats = [stages[2], stages[3], stages[4]] + + # Coarser levels P6..max_level by strided resampling of the last feature. + for level in range(6, max_level + 1): + th, tw = level_sizes[level - min_level] + feats.append( + EfficientDetResample( + fpn_num_filters, + apply_bn=apply_bn_for_resampling, + conv_after_downsample=conv_after_downsample, + name=f"resample_p{level}", + )(feats[-1], target_height=th, target_width=tw) + ) + + fpn_feats = FPNCells( + min_level, + max_level, + fpn_num_filters, + fpn_cell_repeats, + fpn_weight_method, + act_type, + apply_bn_for_resampling, + conv_after_downsample, + conv_bn_act_pattern, + name="fpn_cells", + )(feats, level_sizes=level_sizes) + + num_levels = max_level - min_level + 1 + class_outputs = PredictionHead( + num_anchors * num_classes, + fpn_num_filters, + box_class_repeats, + num_levels, + act_type, + "class", + min_level=min_level, + predict_bias_init=class_predict_bias(), + name="class_net", + )(fpn_feats) + box_outputs = PredictionHead( + num_anchors * 4, + fpn_num_filters, + box_class_repeats, + num_levels, + act_type, + "box", + min_level=min_level, + predict_bias_init=0.0, + name="box_net", + )(fpn_feats) + + super().__init__( + inputs=image, + outputs={"class_outputs": class_outputs, "box_outputs": box_outputs}, + name=name, + **kwargs, + ) + for attr in CONFIG_ATTRS: + setattr(self, attr, locals()[attr]) + + def get_config(self): + config = super().get_config() + config.update({k: getattr(self, k) for k in CONFIG_ATTRS}) + config["name"] = self.name + return config + + @classmethod + def from_config(cls, config): + return cls(**config) From 5db8104d5469979547f89318ac19d057f8b61f11 Mon Sep 17 00:00:00 2001 From: IMvision12 Date: Thu, 27 Aug 2026 02:47:12 -0700 Subject: [PATCH 2/5] Conversion and processor --- zeromodels/models/efficientdet/__init__.py | 5 +- .../convert_efficientdet_h5_to_keras.py | 137 +++++++++ .../efficientdet_image_processor.py | 199 +++++++++++++ .../efficientdet/efficientdet_layers.py | 280 ++++++++++++++++++ .../models/efficientdet/efficientdet_model.py | 115 +++++++ .../convert_granite_speech_hf_to_keras.py | 3 - 6 files changed, 735 insertions(+), 4 deletions(-) create mode 100644 zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py create mode 100644 zeromodels/models/efficientdet/efficientdet_image_processor.py diff --git a/zeromodels/models/efficientdet/__init__.py b/zeromodels/models/efficientdet/__init__.py index 3bc5d6b9..3d305691 100644 --- a/zeromodels/models/efficientdet/__init__.py +++ b/zeromodels/models/efficientdet/__init__.py @@ -1,8 +1,11 @@ from .efficientdet_config import EFFICIENTDET_RECIPES, EfficientDetConfig -from .efficientdet_model import EfficientDetModel +from .efficientdet_image_processor import EfficientDetImageProcessor +from .efficientdet_model import EfficientDetDetect, EfficientDetModel __all__ = [ "EfficientDetConfig", "EFFICIENTDET_RECIPES", "EfficientDetModel", + "EfficientDetDetect", + "EfficientDetImageProcessor", ] diff --git a/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py b/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py new file mode 100644 index 00000000..96c4fef9 --- /dev/null +++ b/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py @@ -0,0 +1,137 @@ +import re + +import h5py +import numpy as np +from keras import ops + +BACKBONE_PREFIX = "efficientnet-{bb}/efficientnet-{bb}" + +EFFICIENTDET_VARIANTS = { + "efficientdet_d0": "efficientnet-b0", + "efficientdet_d1": "efficientnet-b1", + "efficientdet_d2": "efficientnet-b2", + "efficientdet_d3": "efficientnet-b3", + "efficientdet_d4": "efficientnet-b4", + "efficientdet_d5": "efficientnet-b5", + "efficientdet_d6": "efficientnet-b6", + "efficientdet_d7": "efficientnet-b6", +} + +# Official Google AutoML Keras checkpoints (COCO). +EFFICIENTDET_H5_URLS = { + name: ( + "https://storage.googleapis.com/cloud-tpu-checkpoints/efficientdet/" + f"coco2/{name.replace('_', '-')}.h5" + ) + for name in EFFICIENTDET_VARIANTS +} + + +def block_order(paths): + seen = [] + for p in paths: + mo = re.match(r"(blocks_\d+_\d+)", p) + if mo and mo.group(1) not in seen: + seen.append(mo.group(1)) + seen.sort(key=lambda s: tuple(int(x) for x in s.split("_")[1:])) + return {name: i for i, name in enumerate(seen)} + + +def map_backbone_block(path, bb_prefix, block_n, has_expand): + rest = re.sub(r"^blocks_\d+_\d+_", "", path) + sub, var = rest.split("/", 1) + if sub == "conv2d_1": # expand conv + tgt = "conv2d" + elif sub == "conv2d_2": # project conv + tgt = "conv2d_1" if has_expand else "conv2d" + elif sub == "dwconv2d": + return f"{bb_prefix}/blocks_{block_n}/depthwise_conv2d/depthwise_kernel" + elif sub == "se_conv_reduce": + tgt = "se/conv2d" + elif sub == "se_conv_expand": + tgt = "se/conv2d_1" + elif sub == "batchnorm_1": # expand BN + tgt = "tpu_batch_normalization" + elif sub == "batchnorm_2": # depthwise BN + tgt = "tpu_batch_normalization_1" if has_expand else "tpu_batch_normalization" + elif sub == "batchnorm_3": # project BN + tgt = ( + "tpu_batch_normalization_2" + if has_expand + else "tpu_batch_normalization_1" + ) + else: + raise ValueError(f"unmapped block sublayer {sub!r} in {path}") + return f"{bb_prefix}/blocks_{block_n}/{tgt}/{var}" + + +def keras_path_to_h5(path, bb_prefix, order, expand_flags, num_levels): + """Map a zeromodels EfficientDet weight path to the Google ``.h5`` dataset name + (without the trailing ``:0``). Returns ``None`` for weights not present in the + checkpoint (e.g. the anchor constant).""" + seg0 = path.split("/")[0] + if seg0 == "decode_boxes": # anchor constant, not in the checkpoint + return None + if path.startswith("conv_stem/"): + return f"{bb_prefix}/stem/conv2d/{path.split('/', 1)[1]}" + if path.startswith("batchnorm_1/"): + return f"{bb_prefix}/stem/tpu_batch_normalization/{path.split('/', 1)[1]}" + mo = re.match(r"(blocks_\d+_\d+)", path) + if mo: + block = mo.group(1) + return map_backbone_block(path, bb_prefix, order[block], expand_flags[block]) + if seg0.startswith("resample_p"): + return f"{seg0}/{path}" + if seg0 in ("class_net", "box_net"): + return f"{seg0}/{path}" + if seg0 == "fpn_cells": + m2 = re.match(r"fpn_cells/cell_(\d+)_fnode(\d+)/(.+)", path) + r, i, rest = m2.group(1), int(m2.group(2)), m2.group(3) + n = num_levels + i + base = f"fpn_cells/fpn_cells/cell_{r}/fnode{i}" + if rest.startswith("WSM"): + return f"{base}/{rest}" + if rest.startswith("conv/") or rest.startswith("bn/"): + return f"{base}/op_after_combine{n}/{rest}" + mr = re.match(r"resample_(\d+)_(\d+)/(.+)", rest) + if mr: + return f"{base}/resample_{mr.group(1)}_{mr.group(2)}_{n}/{mr.group(3)}" + raise ValueError(f"unmapped fpn sublayer {rest!r} in {path}") + raise ValueError(f"unmapped path {path!r}") + + +def transfer_efficientdet_weights(keras_model, h5_path, backbone="efficientnet-b0"): + """Load a Google AutoML EfficientDet ``.h5`` checkpoint into a zeromodels + ``EfficientDetModel`` or ``EfficientDetDetect``. + + Both sides are Keras saves, so values copy verbatim (no transposes). The anchor + constant on ``EfficientDetDetect`` is skipped. Returns the number of tensors + transferred and raises if any expected weight is missing from the checkpoint.""" + paths = [w.path for w in keras_model.weights] + order = block_order(paths) + expand_flags = { + b: any(p.startswith(f"{b}_conv2d_1/") for p in paths) for b in order + } + num_levels = keras_model.max_level - keras_model.min_level + 1 + bb_prefix = BACKBONE_PREFIX.format(bb=backbone.replace("efficientnet-", "")) + + transferred = 0 + with h5py.File(h5_path, "r") as f: + for w in keras_model.weights: + key = keras_path_to_h5( + w.path, bb_prefix, order, expand_flags, num_levels + ) + if key is None: + continue + dataset = key + ":0" + if dataset not in f: + raise KeyError(f"{w.path} -> {dataset} not in {h5_path}") + value = np.asarray(f[dataset]) + if tuple(value.shape) != tuple(w.shape): + raise ValueError( + f"shape mismatch {w.path}: model {tuple(w.shape)} " + f"vs h5 {tuple(value.shape)}" + ) + w.assign(ops.convert_to_tensor(value)) + transferred += 1 + return transferred diff --git a/zeromodels/models/efficientdet/efficientdet_image_processor.py b/zeromodels/models/efficientdet/efficientdet_image_processor.py new file mode 100644 index 00000000..6f4ec7f0 --- /dev/null +++ b/zeromodels/models/efficientdet/efficientdet_image_processor.py @@ -0,0 +1,199 @@ +from typing import Dict, List, Optional, Tuple, Union + +import keras +import numpy as np +from keras import ops +from PIL import Image + +from zeromodels.base import BaseImageProcessor +from zeromodels.utils.image_util import load_image +from zeromodels.utils.labels_util import COCO_91_CLASSES + +from .efficientdet_layers import EfficientDetNMS + + +@keras.saving.register_keras_serializable(package="zeromodels") +class EfficientDetImageProcessor(BaseImageProcessor): + """Preprocess images for EfficientDet inference. + + EfficientDet uses an aspect-preserving letterbox: the image is scaled by + ``image_size / max(height, width)``, ImageNet-normalized, then zero-padded on the + bottom / right to a square ``image_size x image_size``. The scale factor is + returned so detections can be mapped back to the original image (also recomputed + from ``target_sizes`` in + :meth:`EfficientDetDetect.post_process_object_detection`). + + Args: + image_size: Square target size. Defaults to ``512`` (EfficientDet-D0). + resample: Interpolation method. Defaults to ``"bilinear"``. + image_mean: Per-channel mean. Defaults to ImageNet mean. + image_std: Per-channel std. Defaults to ImageNet std. + rescale_factor: Scale applied before normalization. Defaults to ``1/255``. + return_tensor: If True return a Keras tensor, else a numpy array. + data_format: ``"channels_first"`` / ``"channels_last"``; ``None`` resolves to + the Keras default. + """ + + def __init__( + self, + image_size: int = 512, + resample: str = "bilinear", + image_mean: Optional[Tuple[float, ...]] = None, + image_std: Optional[Tuple[float, ...]] = None, + rescale_factor: float = 1 / 255, + return_tensor: bool = True, + data_format: Optional[str] = None, + **kwargs, + ): + super().__init__(**kwargs) + self.image_size = image_size + self.resample = resample + self.image_mean = ( + image_mean if image_mean is not None else (0.485, 0.456, 0.406) + ) + self.image_std = image_std if image_std is not None else (0.229, 0.224, 0.225) + self.rescale_factor = rescale_factor + self.return_tensor = return_tensor + self.data_format = data_format + + def __call__(self, image): + return self.call(image) + + def preprocess_one(self, image): + arr = load_image(image) + orig_h, orig_w = int(arr.shape[0]), int(arr.shape[1]) + scale = self.image_size / float(max(orig_h, orig_w)) + new_h = int(orig_h * scale) + new_w = int(orig_w * scale) + + t = ops.convert_to_tensor(arr, dtype="float32") + t = ops.expand_dims(t, axis=0) + t = self.resize(t, (new_h, new_w), interpolation=self.resample, antialias=True) + t = self.rescale_and_normalize( + t, + do_rescale=True, + scale=self.rescale_factor, + do_normalize=True, + mean=self.image_mean, + std=self.image_std, + ) + pad_h = self.image_size - new_h + pad_w = self.image_size - new_w + t = ops.pad(t, [(0, 0), (0, pad_h), (0, pad_w), (0, 0)], constant_values=0.0) + if self.data_format == "channels_first": + t = ops.transpose(t, (0, 3, 1, 2)) + return t, scale, (orig_h, orig_w) + + def call( + self, image: Union[str, np.ndarray, Image.Image, List] + ) -> Dict[str, Union[keras.KerasTensor, np.ndarray]]: + items = list(image) if isinstance(image, (list, tuple)) else [image] + tensors, scales, sizes = [], [], [] + for item in items: + t, scale, size = self.preprocess_one(item) + tensors.append(t) + scales.append(scale) + sizes.append(size) + pixel_values = ops.concatenate(tensors, axis=0) + if not self.return_tensor: + pixel_values = ops.convert_to_numpy(pixel_values) + return { + "pixel_values": pixel_values, + "scales": scales, + "original_sizes": sizes, + } + + def post_process_object_detection( + self, + outputs, + threshold: float = 0.3, + iou_threshold: float = 0.5, + max_detections: int = 100, + class_agnostic: bool = True, + target_sizes=None, + label_names=None, + ): + """Turn raw :class:`EfficientDetDetect` outputs into per-image detections. + + Applies per-class hard NMS (via :class:`EfficientDetNMS`) to the decoded + boxes and sigmoid scores, then, when ``target_sizes`` is given, undoes the + letterbox (divides by ``image_size / max(orig_h, orig_w)``) and clips boxes + to each original image. + + Args: + outputs: The detector output dict ``{"boxes": (B, N, 4), + "scores": (B, N, num_classes)}``. Boxes are ``[ymin, xmin, ymax, + xmax]`` in ``image_size`` pixel coordinates. + threshold: Minimum score to keep a detection. + iou_threshold: NMS IoU threshold. + max_detections: Maximum detections kept per image. + class_agnostic: If True (default, Google's ``postprocess_global``) run one + NMS across all classes so an object yields a single box; if False, run + NMS per class. + target_sizes: List of ``(height, width)`` original image sizes, one per + batch item, used to rescale boxes back to the original image. If + ``None``, boxes stay in ``image_size`` coordinates. + label_names: Class-name list indexed by detector class id. Defaults to + the 90 COCO categories (class id ``c`` -> ``COCO_91_CLASSES[c + 1]``). + + Returns: + A list (one dict per image) with ``"scores"``, ``"labels"``, + ``"label_names"`` and ``"boxes"`` (``[xmin, ymin, xmax, ymax]``). + """ + nms = EfficientDetNMS( + iou_threshold=iou_threshold, + score_threshold=threshold, + max_detections=max_detections, + class_agnostic=class_agnostic, + ) + detections = ops.convert_to_numpy(nms(outputs["boxes"], outputs["scores"])) + names = label_names if label_names is not None else COCO_91_CLASSES + + results = [] + for i in range(detections.shape[0]): + det = detections[i] + det = det[det[:, 4] > 0.0] + ymin, xmin, ymax, xmax = det[:, 0], det[:, 1], det[:, 2], det[:, 3] + scores = det[:, 4] + labels = det[:, 5].astype("int32") + if target_sizes is not None: + orig_h, orig_w = target_sizes[i] + scale = self.image_size / float(max(orig_h, orig_w)) + ymin, xmin, ymax, xmax = ( + ymin / scale, + xmin / scale, + ymax / scale, + xmax / scale, + ) + ymin = np.clip(ymin, 0, orig_h) + ymax = np.clip(ymax, 0, orig_h) + xmin = np.clip(xmin, 0, orig_w) + xmax = np.clip(xmax, 0, orig_w) + boxes_xyxy = np.stack([xmin, ymin, xmax, ymax], axis=-1) + mapped = [ + names[c + 1] if (c + 1) < len(names) else f"class_{c}" for c in labels + ] + results.append( + { + "scores": scores, + "labels": labels, + "label_names": mapped, + "boxes": boxes_xyxy, + } + ) + return results + + def get_config(self): + config = super().get_config() + config.update( + { + "image_size": self.image_size, + "resample": self.resample, + "image_mean": self.image_mean, + "image_std": self.image_std, + "rescale_factor": self.rescale_factor, + "return_tensor": self.return_tensor, + "data_format": self.data_format, + } + ) + return config diff --git a/zeromodels/models/efficientdet/efficientdet_layers.py b/zeromodels/models/efficientdet/efficientdet_layers.py index 05c5c806..3d5a8d91 100644 --- a/zeromodels/models/efficientdet/efficientdet_layers.py +++ b/zeromodels/models/efficientdet/efficientdet_layers.py @@ -1,6 +1,7 @@ import math import keras +import numpy as np from keras import layers, ops from .efficientdet_config import bifpn_nodes @@ -347,3 +348,282 @@ def get_config(self): def class_predict_bias(): """Focal-loss prior bias for the class predictor: ``-log((1 - 0.01) / 0.01)``.""" return -math.log((1 - 0.01) / 0.01) + + +def feat_sizes(image_size, max_level): + """Per-level (height, width) of the feature pyramid, ceil-halving from the + input size (index 0 = input). Matches Google's ``utils.get_feat_sizes``.""" + if isinstance(image_size, int): + h = w = image_size + else: + h, w = image_size + sizes = [(h, w)] + for _ in range(1, max_level + 1): + h, w = (h - 1) // 2 + 1, (w - 1) // 2 + 1 + sizes.append((h, w)) + return sizes + + +def generate_anchor_boxes( + min_level, max_level, num_scales, aspect_ratios, anchor_scale, image_size +): + """Multiscale anchor boxes as ``(N, 4)`` in ``[ymin, xmin, ymax, xmax]`` pixel + coordinates, ordered position-major then (octave, aspect)-minor per level, then + concatenated over levels. A direct port of Google AutoML ``anchors.Anchors``.""" + if isinstance(image_size, int): + image_h = image_w = image_size + else: + image_h, image_w = image_size + sizes = feat_sizes(image_size, max_level) + if isinstance(anchor_scale, (list, tuple)): + anchor_scales = list(anchor_scale) + else: + anchor_scales = [anchor_scale] * (max_level - min_level + 1) + + boxes_all = [] + for level in range(min_level, max_level + 1): + stride_h = sizes[0][0] / float(sizes[level][0]) + stride_w = sizes[0][1] / float(sizes[level][1]) + boxes_level = [] + for scale_octave in range(num_scales): + for aspect in aspect_ratios: + base_x = anchor_scales[level - min_level] * stride_w * ( + 2 ** (scale_octave / float(num_scales)) + ) + base_y = anchor_scales[level - min_level] * stride_h * ( + 2 ** (scale_octave / float(num_scales)) + ) + aspect_x = math.sqrt(aspect) + aspect_y = 1.0 / aspect_x + half_x = base_x * aspect_x / 2.0 + half_y = base_y * aspect_y / 2.0 + x = np.arange(stride_w / 2, image_w, stride_w) + y = np.arange(stride_h / 2, image_h, stride_h) + xv, yv = np.meshgrid(x, y) + xv, yv = xv.reshape(-1), yv.reshape(-1) + boxes = np.vstack( + (yv - half_y, xv - half_x, yv + half_y, xv + half_x) + ) + boxes = np.swapaxes(boxes, 0, 1) + boxes_level.append(np.expand_dims(boxes, axis=1)) + boxes_level = np.concatenate(boxes_level, axis=1) + boxes_all.append(boxes_level.reshape([-1, 4])) + return np.vstack(boxes_all).astype("float32") + + +def decode_box_outputs(pred_boxes, anchor_boxes): + """Invert the anchor box regression: ``(ty, tx, th, tw)`` relative to anchors -> + absolute ``[ymin, xmin, ymax, xmax]``. ``anchor_boxes`` are ``[ymin, xmin, ymax, + xmax]``. Matches Google AutoML ``anchors.decode_box_outputs``.""" + ycenter_a = (anchor_boxes[..., 0] + anchor_boxes[..., 2]) / 2 + xcenter_a = (anchor_boxes[..., 1] + anchor_boxes[..., 3]) / 2 + ha = anchor_boxes[..., 2] - anchor_boxes[..., 0] + wa = anchor_boxes[..., 3] - anchor_boxes[..., 1] + ty, tx, th, tw = ( + pred_boxes[..., 0], + pred_boxes[..., 1], + pred_boxes[..., 2], + pred_boxes[..., 3], + ) + w = ops.exp(tw) * wa + h = ops.exp(th) * ha + ycenter = ty * ha + ycenter_a + xcenter = tx * wa + xcenter_a + return ops.stack( + [ + ycenter - h / 2.0, + xcenter - w / 2.0, + ycenter + h / 2.0, + xcenter + w / 2.0, + ], + axis=-1, + ) + + +@keras.saving.register_keras_serializable(package="zeromodels") +class DecodeBoxes(layers.Layer): + """Turn raw per-anchor box regressions ``(B, N, 4)`` into absolute + ``[ymin, xmin, ymax, xmax]`` boxes using pre-generated anchors held as a + non-trainable constant.""" + + def __init__( + self, + min_level, + max_level, + num_scales, + aspect_ratios, + anchor_scale, + image_size, + name="decode_boxes", + **kwargs, + ): + super().__init__(name=name, **kwargs) + self.min_level = min_level + self.max_level = max_level + self.num_scales = num_scales + self.aspect_ratios = tuple(aspect_ratios) + self.anchor_scale = anchor_scale + self.image_size = image_size + self.anchors_np = generate_anchor_boxes( + min_level, max_level, num_scales, aspect_ratios, anchor_scale, image_size + ) + + def build(self, input_shape): + self.anchors = self.add_weight( + name="anchors", + shape=self.anchors_np.shape, + initializer=keras.initializers.Constant(self.anchors_np), + trainable=False, + ) + self.built = True + + def call(self, box_outputs): + return decode_box_outputs(box_outputs, self.anchors) + + def compute_output_shape(self, input_shape): + return input_shape + + def get_config(self): + config = super().get_config() + config.update( + { + "min_level": self.min_level, + "max_level": self.max_level, + "num_scales": self.num_scales, + "aspect_ratios": self.aspect_ratios, + "anchor_scale": self.anchor_scale, + "image_size": self.image_size, + } + ) + return config + + +def iou_against(box, boxes): + """IoU of one ``[ymin, xmin, ymax, xmax]`` box against an array of boxes.""" + ymin = np.maximum(box[0], boxes[:, 0]) + xmin = np.maximum(box[1], boxes[:, 1]) + ymax = np.minimum(box[2], boxes[:, 2]) + xmax = np.minimum(box[3], boxes[:, 3]) + inter = np.maximum(0.0, ymax - ymin) * np.maximum(0.0, xmax - xmin) + area = (box[2] - box[0]) * (box[3] - box[1]) + areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]) + return inter / (area + areas - inter + 1e-8) + + +def greedy_nms(boxes, scores, iou_threshold, max_output): + """Greedy hard NMS. Returns kept indices (highest score first).""" + order = scores.argsort()[::-1] + keep = [] + while order.size > 0 and len(keep) < max_output: + i = order[0] + keep.append(i) + if order.size == 1: + break + rest = order[1:] + overlap = iou_against(boxes[i], boxes[rest]) + order = rest[overlap <= iou_threshold] + return keep + + +@keras.saving.register_keras_serializable(package="zeromodels") +class EfficientDetNMS(layers.Layer): + """Hard non-max suppression over decoded detections. + + Given decoded boxes ``(B, N, 4)`` in ``[ymin, xmin, ymax, xmax]`` and per-class + sigmoid scores ``(B, N, num_classes)``, returns a padded ``(B, max_detections, 6)`` + tensor of ``[ymin, xmin, ymax, xmax, score, class_id]`` (rows past the detection + count are zero). + + With ``class_agnostic=True`` (the default, matching Google AutoML's + ``postprocess_global``) each anchor keeps only its single highest-scoring class + and one NMS runs across all classes together, so a single object cannot yield two + boxes under different labels (e.g. a dog also reported as a cat). With + ``class_agnostic=False`` NMS runs independently per class + (``postprocess_per_class``). Runs eagerly (detection post-processing), applied + outside the symbolic graph.""" + + def __init__( + self, + iou_threshold=0.5, + score_threshold=0.05, + max_detections=100, + pre_nms_top_k=5000, + class_agnostic=True, + name="nms", + **kwargs, + ): + super().__init__(name=name, **kwargs) + self.iou_threshold = iou_threshold + self.score_threshold = score_threshold + self.max_detections = max_detections + self.pre_nms_top_k = pre_nms_top_k + self.class_agnostic = class_agnostic + + def top_k_prefilter(self, boxes, scores): + """Keep the ``pre_nms_top_k`` anchors with the highest best-class score.""" + best = scores.max(axis=-1) + if best.shape[0] > self.pre_nms_top_k: + top = np.argpartition(-best, self.pre_nms_top_k)[: self.pre_nms_top_k] + return boxes[top], scores[top] + return boxes, scores + + def detections_global(self, boxes, scores): + """Class-agnostic: one best class per anchor, then a single NMS.""" + class_ids = scores.argmax(axis=-1) + class_scores = scores.max(axis=-1) + mask = class_scores > self.score_threshold + if not mask.any(): + return [] + bx, sc, cl = boxes[mask], class_scores[mask], class_ids[mask] + keep = greedy_nms(bx, sc, self.iou_threshold, self.max_detections) + return [ + (bx[k][0], bx[k][1], bx[k][2], bx[k][3], sc[k], float(cl[k])) for k in keep + ] + + def detections_per_class(self, boxes, scores): + """Independent NMS per class.""" + dets = [] + for c in range(scores.shape[-1]): + cls_scores = scores[:, c] + mask = cls_scores > self.score_threshold + if not mask.any(): + continue + bx, sc = boxes[mask], cls_scores[mask] + keep = greedy_nms(bx, sc, self.iou_threshold, self.max_detections) + dets.extend( + (bx[k][0], bx[k][1], bx[k][2], bx[k][3], sc[k], float(c)) for k in keep + ) + return dets + + def call(self, boxes, scores): + boxes = ops.convert_to_numpy(ops.convert_to_tensor(boxes)) + scores = ops.convert_to_numpy(ops.convert_to_tensor(scores)) + batch = boxes.shape[0] + out = np.zeros((batch, self.max_detections, 6), dtype="float32") + for b in range(batch): + bx, sc = self.top_k_prefilter(boxes[b], scores[b]) + if self.class_agnostic: + dets = self.detections_global(bx, sc) + else: + dets = self.detections_per_class(bx, sc) + if dets: + dets.sort(key=lambda d: d[4], reverse=True) + dets = dets[: self.max_detections] + out[b, : len(dets)] = np.array(dets, dtype="float32") + return ops.convert_to_tensor(out) + + def compute_output_shape(self, boxes_shape, scores_shape): + return (boxes_shape[0], self.max_detections, 6) + + def get_config(self): + config = super().get_config() + config.update( + { + "iou_threshold": self.iou_threshold, + "score_threshold": self.score_threshold, + "max_detections": self.max_detections, + "pre_nms_top_k": self.pre_nms_top_k, + "class_agnostic": self.class_agnostic, + } + ) + return config diff --git a/zeromodels/models/efficientdet/efficientdet_model.py b/zeromodels/models/efficientdet/efficientdet_model.py index bb9d1851..a0122bab 100644 --- a/zeromodels/models/efficientdet/efficientdet_model.py +++ b/zeromodels/models/efficientdet/efficientdet_model.py @@ -8,6 +8,7 @@ from .efficientdet_config import EfficientDetConfig from .efficientdet_layers import ( + DecodeBoxes, EfficientDetResample, FPNCells, PredictionHead, @@ -187,3 +188,117 @@ def get_config(self): @classmethod def from_config(cls, config): return cls(**config) + + +@keras.saving.register_keras_serializable(package="zeromodels") +class EfficientDetDetect(BaseModel): + """EfficientDet object detector: :class:`EfficientDetModel` + anchor decoding. + + Wraps the backbone/BiFPN/heads model and turns its raw per-level outputs into + decoded detections. The functional graph flattens and concatenates the per-level + class and box outputs, applies sigmoid to the class logits, and decodes the box + regressions against pre-generated anchors, exposing + ``{"boxes": (B, N, 4), "scores": (B, N, num_classes)}`` (boxes are + ``[ymin, xmin, ymax, xmax]`` in ``image_size`` pixel coordinates). Non-max + suppression and rescaling to the original image are applied afterwards by + :meth:`EfficientDetImageProcessor.post_process_object_detection`. + + References: + - [EfficientDet: Scalable and Efficient Object Detection](https://arxiv.org/abs/1911.09070) + + Args: + See :class:`EfficientDetConfig`. Defaults describe EfficientDet-D0. + name: String, model name. Defaults to `"EfficientDetDetect"`. + + Returns: + A Keras `Model` instance. + """ + + BASE_WEIGHT_CONFIG = None + HF_MODEL_TYPE = "efficientdet" + config_class = EfficientDetConfig + + def __init__( + self, + backbone_name="efficientnet_b0", + image_size=512, + num_classes=90, + min_level=3, + max_level=7, + num_scales=3, + aspect_ratios=(1.0, 2.0, 0.5), + anchor_scale=4.0, + fpn_num_filters=64, + fpn_cell_repeats=3, + box_class_repeats=3, + act_type="swish", + separable_conv=True, + apply_bn_for_resampling=True, + conv_after_downsample=False, + conv_bn_act_pattern=False, + fpn_weight_method="fastattn", + survival_prob=None, + name="EfficientDetDetect", + **kwargs, + ): + for k in ("model", "hf_id", "url", "num_classes_"): + kwargs.pop(k, None) + + base = EfficientDetModel( + backbone_name=backbone_name, + image_size=image_size, + num_classes=num_classes, + min_level=min_level, + max_level=max_level, + num_scales=num_scales, + aspect_ratios=aspect_ratios, + anchor_scale=anchor_scale, + fpn_num_filters=fpn_num_filters, + fpn_cell_repeats=fpn_cell_repeats, + box_class_repeats=box_class_repeats, + act_type=act_type, + separable_conv=separable_conv, + apply_bn_for_resampling=apply_bn_for_resampling, + conv_after_downsample=conv_after_downsample, + conv_bn_act_pattern=conv_bn_act_pattern, + fpn_weight_method=fpn_weight_method, + survival_prob=survival_prob, + name=f"{name}_model", + ) + class_outputs = base.output["class_outputs"] + box_outputs = base.output["box_outputs"] + + cls_flat = layers.Concatenate(axis=1, name="class_concat")( + [layers.Reshape((-1, num_classes))(c) for c in class_outputs] + ) + box_flat = layers.Concatenate(axis=1, name="box_concat")( + [layers.Reshape((-1, 4))(b) for b in box_outputs] + ) + scores = layers.Activation("sigmoid", name="scores")(cls_flat) + boxes = DecodeBoxes( + min_level, + max_level, + num_scales, + aspect_ratios, + anchor_scale, + image_size, + )(box_flat) + + super().__init__( + inputs=base.input, + outputs={"boxes": boxes, "scores": scores}, + name=name, + **kwargs, + ) + for attr in CONFIG_ATTRS: + setattr(self, attr, locals()[attr]) + + def get_config(self): + config = super().get_config() + config.update({k: getattr(self, k) for k in CONFIG_ATTRS}) + config["name"] = self.name + return config + + @classmethod + def from_config(cls, config): + return cls(**config) diff --git a/zeromodels/models/granite_speech/convert_granite_speech_hf_to_keras.py b/zeromodels/models/granite_speech/convert_granite_speech_hf_to_keras.py index d180dae0..bb2646f9 100644 --- a/zeromodels/models/granite_speech/convert_granite_speech_hf_to_keras.py +++ b/zeromodels/models/granite_speech/convert_granite_speech_hf_to_keras.py @@ -58,9 +58,6 @@ def transfer_granite_speech_weights(keras_model, hf_state_dict): for weight in tqdm(keras_model.weights, desc="Transferring weights to Keras"): keras_dotted = weight.path.replace("/", ".") - # The conformer encoder + Q-Former projector run inside the GraniteSpeechAudioFeatures - # wrapper, so keras paths them under "audio_features/"; the HF checkpoint keeps them at - # the top level (encoder.* / projector.*). Strip the wrapper prefix before mapping. if keras_dotted.startswith("audio_features."): keras_dotted = keras_dotted[len("audio_features.") :] if keras_dotted == "token_embedding.embeddings": From 6e26e01cc0f54133d4bc96f1b5de70092047d11d Mon Sep 17 00:00:00 2001 From: IMvision12 Date: Thu, 27 Aug 2026 14:03:24 -0700 Subject: [PATCH 3/5] Fix channels first --- README.md | 3 +- assets/efficientdet_batch_output.jpg | Bin 0 -> 222436 bytes assets/efficientdet_output.jpg | Bin 0 -> 116614 bytes docs/efficientdet.md | 395 ++++++++++++++++++ tests/base/model_test_registry.py | 15 + website/mkdocs.yml | 1 + .../efficientdet/efficientdet_config.py | 3 + .../efficientdet_image_processor.py | 27 +- .../efficientdet/efficientdet_layers.py | 85 +++- .../models/efficientdet/efficientdet_model.py | 47 ++- 10 files changed, 543 insertions(+), 33 deletions(-) create mode 100644 assets/efficientdet_batch_output.jpg create mode 100644 assets/efficientdet_output.jpg create mode 100644 docs/efficientdet.md diff --git a/README.md b/README.md index 0db485ed..70b78ecb 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ ## 📖 Introduction -ZeroModels is a collection of models with pretrained weights, built entirely with Keras 3. It supports a range of tasks, including classification, object detection (DETR, RT-DETR, RT-DETRv2, RF-DETR, D-FINE, OWL-ViT, OWLv2, Grounding DINO), segmentation (SAM, SAM2, SAM3, SegFormer, DeepLabV3, EoMT, MaskFormer, Mask2Former, OneFormer, MobileViT-DeepLabV3, RF-DETR), monocular depth estimation (Depth Anything V1, Depth Anything V2, TIPSv2-DPT), feature extraction (DINO, DINOv2, DINOv3), vision-language modeling (CLIP, SigLIP, SigLIP2, MetaCLIP 2, TIPSv2), speech recognition (Whisper, Speech2Text, Moonshine, Granite Speech 5), speech-aware language modeling (Granite Speech, Granite Speech Plus), text encoding and masked language modeling (BERT, ModernBERT, ELECTRA, RoBERTa, XLM-RoBERTa, DeBERTa, DeBERTa-v2, DeBERTa-v3), text generation with large language models (GPT, GPT-2, Qwen2, Qwen2-MoE, Qwen3, Qwen3-MoE, Qwen3-Next, Qwen3.5, GPT-OSS, Llama 2, Llama 3, Llama 4, Mistral, Mixtral, Gemma, Gemma 2, MiniMax-Text-01, MiniMax-M2, DeepSeek-V2, DeepSeek-V3, DeepSeek-V4, GLM-4, GLM-4-0414, GLM-4.5/GLM-4.6, GLM-5/GLM-5.1/GLM-5.2), text-to-text encoder-decoder modeling (T5), multimodal vision-language generation (Qwen2-VL, Qwen2.5-VL, Qwen3-VL, Qwen3-VL-MoE, Qwen3.5-MoE, InternVL3, Gemma 3, Gemma 3n, Gemma 4, Gemma 4 Unified, Mistral 3, DeepSeek-VL, Janus-Pro, MiniMax-M3-VL, GLM-4V, GLM-4.5V, Kimi K2.5, Kimi K2.6, Kimi K2.7-Code), vision-language grounding across object detection, OCR, pointing, and referring (LocateAnything), and more. It includes hybrid architectures like MaxViT alongside traditional CNNs and pure transformers. zeromodels includes custom layers and backbone support, providing flexibility and efficiency across various applications. For backbones, there are various weight variants like `in1k`, `in21k`, `fb_dist_in1k`, `ms_in22k`, `fb_in22k_ft_in1k`, `ns_jft_in1k`, `aa_in1k`, `cvnets_in1k`, `augreg_in21k_ft_in1k`, `augreg_in21k`, and many more. +ZeroModels is a collection of models with pretrained weights, built entirely with Keras 3. It supports a range of tasks, including classification, object detection (DETR, RT-DETR, RT-DETRv2, RF-DETR, D-FINE, EfficientDet, OWL-ViT, OWLv2, Grounding DINO), segmentation (SAM, SAM2, SAM3, SegFormer, DeepLabV3, EoMT, MaskFormer, Mask2Former, OneFormer, MobileViT-DeepLabV3, RF-DETR), monocular depth estimation (Depth Anything V1, Depth Anything V2, TIPSv2-DPT), feature extraction (DINO, DINOv2, DINOv3), vision-language modeling (CLIP, SigLIP, SigLIP2, MetaCLIP 2, TIPSv2), speech recognition (Whisper, Speech2Text, Moonshine, Granite Speech 5), speech-aware language modeling (Granite Speech, Granite Speech Plus), text encoding and masked language modeling (BERT, ModernBERT, ELECTRA, RoBERTa, XLM-RoBERTa, DeBERTa, DeBERTa-v2, DeBERTa-v3), text generation with large language models (GPT, GPT-2, Qwen2, Qwen2-MoE, Qwen3, Qwen3-MoE, Qwen3-Next, Qwen3.5, GPT-OSS, Llama 2, Llama 3, Llama 4, Mistral, Mixtral, Gemma, Gemma 2, MiniMax-Text-01, MiniMax-M2, DeepSeek-V2, DeepSeek-V3, DeepSeek-V4, GLM-4, GLM-4-0414, GLM-4.5/GLM-4.6, GLM-5/GLM-5.1/GLM-5.2), text-to-text encoder-decoder modeling (T5), multimodal vision-language generation (Qwen2-VL, Qwen2.5-VL, Qwen3-VL, Qwen3-VL-MoE, Qwen3.5-MoE, InternVL3, Gemma 3, Gemma 3n, Gemma 4, Gemma 4 Unified, Mistral 3, DeepSeek-VL, Janus-Pro, MiniMax-M3-VL, GLM-4V, GLM-4.5V, Kimi K2.5, Kimi K2.6, Kimi K2.7-Code), vision-language grounding across object detection, OCR, pointing, and referring (LocateAnything), and more. It includes hybrid architectures like MaxViT alongside traditional CNNs and pure transformers. zeromodels includes custom layers and backbone support, providing flexibility and efficiency across various applications. For backbones, there are various weight variants like `in1k`, `in21k`, `fb_dist_in1k`, `ms_in22k`, `fb_in22k_ft_in1k`, `ns_jft_in1k`, `aa_in1k`, `cvnets_in1k`, `augreg_in21k_ft_in1k`, `augreg_in21k`, and many more. ## ⚡ Installation @@ -139,6 +139,7 @@ The Markdown sources live in [`docs/`](docs/) if you would rather read them in t |---------------|-------------------|---------------------| | D-FINE | [D-FINE: Redefine Regression Task of DETRs as Fine-grained Distribution Refinement](https://arxiv.org/abs/2410.13842) | `transformers` | | DETR | [End-to-End Object Detection with Transformers](https://arxiv.org/abs/2005.12872) | `transformers` | + | EfficientDet | [EfficientDet: Scalable and Efficient Object Detection](https://arxiv.org/abs/1911.09070) | `automl` | | RT-DETR | [DETRs Beat YOLOs on Real-time Object Detection](https://arxiv.org/abs/2304.08069) | `transformers` | | RT-DETRv2 | [RT-DETRv2: Improved Baseline with Bag-of-Freebies for Real-Time Detection Transformers](https://arxiv.org/abs/2407.17140) | `transformers` | | RF-DETR | [RF-DETR: Neural Architecture Search for Real-Time Detection Transformers](https://arxiv.org/abs/2511.09554) | `transformers` | diff --git a/assets/efficientdet_batch_output.jpg b/assets/efficientdet_batch_output.jpg new file mode 100644 index 0000000000000000000000000000000000000000..1a38b530b6d13ca30ffe69c74aed1b8df5dea173 GIT binary patch literal 222436 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 dmdj` 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%0Ahb$vn9fD=?MJC6ff}J9b&z@0^9}%&_a~@7 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

gEROQBT2m4{68*B)Sj92?{Fk2R%1znDxMa)i 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 z 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 S{;}uNG~(K% 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
K_V-9(tghz$cwehJDYdX>tL2-p; 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 literal 0 HcmV?d00001 diff --git a/docs/efficientdet.md b/docs/efficientdet.md new file mode 100644 index 00000000..f3fb5083 --- /dev/null +++ b/docs/efficientdet.md @@ -0,0 +1,395 @@ +# EfficientDet + +

+Weights: pretrained Keras weights live on Hugging Face under +zeromodels/<variant> +(each repo carries zm_config.json + model.weights.h5 + +zm_preprocessor.json), converted from Google AutoML's official COCO release. +Load with from_weights("zeromodels/efficientdet_d0"). +
+ +EfficientDet is a family of single-shot, anchor-based detectors (D0 through D7) built for a clean accuracy/compute trade-off. An EfficientNet backbone produces multi-level features, a **weighted bi-directional feature pyramid (BiFPN)** fuses them top-down then bottom-up with a learnable weight per input, and one shared class head and one shared box head run over every pyramid level. Each spatial location emits nine anchor predictions, decoded against a fixed anchor grid. + +Unlike the DETR line, EfficientDet keeps the conventional detector machinery: anchors and non-maximum suppression are part of the pipeline, run after the network in the post-processor. Compound scaling grows the backbone, BiFPN width and depth, head depth, and input resolution together from D0 (3.9 M params, 512²) to D7 (52 M, 1536²). + +**Paper**: [EfficientDet: Scalable and Efficient Object Detection](https://arxiv.org/abs/1911.09070) + +## API + +### EfficientDetDetect + +```python +EfficientDetDetect( + backbone_name="efficientnet_b0", + image_size=512, + num_classes=90, + min_level=3, + max_level=7, + num_scales=3, + aspect_ratios=(1.0, 2.0, 0.5), + anchor_scale=4.0, + fpn_num_filters=64, + fpn_cell_repeats=3, + box_class_repeats=3, + act_type="swish", + separable_conv=True, + apply_bn_for_resampling=True, + conv_after_downsample=False, + conv_bn_act_pattern=False, + fpn_weight_method="fastattn", + survival_prob=None, + name="EfficientDetDetect", +) +``` + +The detector: EfficientNet backbone, weighted BiFPN, shared class/box heads, and in-graph +anchor decoding. **This is the class for object detection.** Defaults describe +EfficientDet-D0; `from_weights` fills these in from the variant config, and passing a recipe +from `EFFICIENTDET_RECIPES` builds a larger variant by hand. + +**Parameters** + +- **backbone_name** (`str`, *optional*, defaults to `"efficientnet_b0"`): EfficientNet backbone, `"efficientnet_b0"` through `"efficientnet_b6"`. +- **image_size** (`int`, *optional*, defaults to `512`): input resolution the model is built for. Must be divisible by 128, see [Input Resolution](#input-resolution). +- **num_classes** (`int`, *optional*, defaults to `90`): COCO's 90 category ids (class `c` maps to `COCO_91_CLASSES[c + 1]`; index 0 is the "N/A" id). +- **min_level** / **max_level** (`int`, *optional*, defaults to `3` / `7`): pyramid levels the heads run on, strides 8 to 128. +- **num_scales** (`int`, *optional*, defaults to `3`) / **aspect_ratios** (`tuple`, *optional*, defaults to `(1.0, 2.0, 0.5)`): the anchor grid; `num_scales * len(aspect_ratios)` = 9 anchors per location. +- **anchor_scale** (`float`, *optional*, defaults to `4.0`): base anchor size relative to the level stride (D7 uses `5.0`). +- **fpn_num_filters** (`int`, *optional*, defaults to `64`): BiFPN channel width. +- **fpn_cell_repeats** (`int`, *optional*, defaults to `3`): number of stacked BiFPN cells. +- **box_class_repeats** (`int`, *optional*, defaults to `3`): depth of each shared head. +- **fpn_weight_method** (`str`, *optional*, defaults to `"fastattn"`): BiFPN fusion, `"fastattn"` (normalized ReLU weights), `"attn"` (softmax), or `"sum"` (unweighted; D6/D7 use this). +- **act_type** (`str`, *optional*, defaults to `"swish"`): activation. +- **name** (`str`, *optional*, defaults to `"EfficientDetDetect"`): model name. + +**Call** `model(pixel_values, training=False)`. **Returns** a `dict`: + +- **boxes** (`(B, N, 4)`): anchor-decoded boxes `[ymin, xmin, ymax, xmax]` in `image_size` pixel coordinates. `N` is the total anchor count (49104 for D0 at 512²). +- **scores** (`(B, N, num_classes)`): per-class sigmoid scores. + +Raw output is one decoded box per anchor at every class. Run it through +[post_process_object_detection](#post_process_object_detection) to apply NMS and get +scored, original-image boxes. + +### EfficientDetModel + +```python +EfficientDetModel(..., name="EfficientDetModel") +``` + +The backbone, BiFPN, and shared heads without anchor decoding. **Parameters** are identical +to [EfficientDetDetect](#efficientdetdetect), with **name** defaulting to +`"EfficientDetModel"`. + +**Returns** a `dict` of raw per-level head outputs, `{"class_outputs", "box_outputs"}`: +lists of `(B, H_l, W_l, num_anchors * num_classes)` and `(B, H_l, W_l, num_anchors * 4)` for +levels `min_level`..`max_level`. Use it when you want the raw pyramid outputs to attach a +custom decoder or loss. It shares its weights with `EfficientDetDetect`, so both load the +same hosted file. + +## Preprocessing + +### EfficientDetImageProcessor + +```python +EfficientDetImageProcessor( + image_size=512, + resample="bilinear", + image_mean=None, + image_std=None, + rescale_factor=1 / 255, + return_tensor=True, + data_format=None, +) +``` + +Applies EfficientDet's aspect-preserving letterbox: scale by `image_size / max(height, +width)`, ImageNet-normalize, then zero-pad the bottom and right to a square `image_size`. +The pad is applied **after** normalization, so padded pixels are true zeros. + +**Parameters** + +- **image_size** (`int`, *optional*, defaults to `512`): square target size. Match the model's `image_size`. +- **resample** (`str`, *optional*, defaults to `"bilinear"`): resize interpolation. +- **image_mean** (`tuple`, *optional*, defaults to `(0.485, 0.456, 0.406)`): per-channel mean. +- **image_std** (`tuple`, *optional*, defaults to `(0.229, 0.224, 0.225)`): per-channel std. +- **rescale_factor** (`float`, *optional*, defaults to `1/255`): applied before normalization. +- **return_tensor** (`bool`, *optional*, defaults to `True`): return backend tensors rather than numpy. +- **data_format** (`str`, *optional*): `"channels_last"` or `"channels_first"`. `None` (default) resolves to `keras.config.image_data_format()`, matching a model built under the same global setting. See [Data Format](#data-format). + +**Call** `processor(image)` with a path, a PIL image, an array, or a **list** of any mix. +**Returns** a `dict`: + +- **pixel_values** (`(B, H, W, 3)`): the preprocessed images. +- **scales** (`list[float]`): the letterbox scale per image. +- **original_sizes** (`list[(h, w)]`): original sizes, ready to pass as `target_sizes` below. + +#### post_process_object_detection + +```python +processor.post_process_object_detection( + outputs, + threshold=0.3, + iou_threshold=0.5, + max_detections=100, + class_agnostic=True, + target_sizes=None, + label_names=None, +) +``` + +Runs NMS over the decoded boxes and sigmoid scores, then, when `target_sizes` is given, +undoes the letterbox and clips boxes to each original image. + +- **outputs**: the `dict` returned by the model. +- **threshold** (`float`, *optional*, defaults to `0.3`): minimum score to keep a detection. +- **iou_threshold** (`float`, *optional*, defaults to `0.5`): NMS IoU threshold. +- **max_detections** (`int`, *optional*, defaults to `100`): cap on detections per image. +- **class_agnostic** (`bool`, *optional*, defaults to `True`): one NMS across all classes, so an object yields a single box. See [NMS Modes](#nms-modes). +- **target_sizes** (`list` of `(height, width)`, *optional*): original image sizes, one per batch element. Omit to leave boxes in `image_size` coordinates. +- **label_names** (`list` of `str`, *optional*): class names. Defaults to COCO's 90 categories. + +**Returns** a list with one `dict` per image: + +- **scores**: class probability per kept detection. +- **labels**: integer class indices. +- **label_names**: the resolved class names. +- **boxes**: `(x0, y0, x1, y1)` in pixels. + +## Model Variants + +Every variant is trained on COCO's 90 categories and converted from Google AutoML's +`coco2` release. `EFFICIENTDET_RECIPES[variant]` returns the constructor kwargs for each. + +| Variant id | Backbone | Input | Params | +|-------------------|-----------------|------:|-------:| +| `efficientdet_d0` | EfficientNet-B0 | 512 | 3.9 M | +| `efficientdet_d1` | EfficientNet-B1 | 640 | 6.6 M | +| `efficientdet_d2` | EfficientNet-B2 | 768 | 8.1 M | +| `efficientdet_d3` | EfficientNet-B3 | 896 | 12.0 M | +| `efficientdet_d4` | EfficientNet-B4 | 1024 | 20.7 M | +| `efficientdet_d5` | EfficientNet-B5 | 1280 | 33.7 M | +| `efficientdet_d6` | EfficientNet-B6 | 1280 | 51.9 M | +| `efficientdet_d7` | EfficientNet-B6 | 1536 | 51.9 M | + +Bigger variants are more accurate and slower. D6 and D7 fuse the BiFPN with an unweighted +sum (`fpn_weight_method="sum"`) instead of the fast-attention weighting D0–D5 use. + +## Basic Usage: Object Detection + +EfficientDet-D0 detections on a busy street: two people on a bicycle and several motorcycles + +```python +from PIL import Image +from zeromodels.models.efficientdet import EfficientDetDetect, EfficientDetImageProcessor + +model = EfficientDetDetect.from_weights("zeromodels/efficientdet_d0") +processor = EfficientDetImageProcessor.from_weights("zeromodels/efficientdet_d0") + +image = Image.open("assets/data/coco_bicycles.jpg").convert("RGB") +inputs = processor(image) + +output = model(inputs["pixel_values"], training=False) +# output["boxes"]: (1, 49104, 4) +# output["scores"]: (1, 49104, 90) + +results = processor.post_process_object_detection( + output, threshold=0.3, target_sizes=inputs["original_sizes"] +)[0] + +# Detections come back unordered, so sort by score for readability. +detections = sorted( + zip(results["scores"], results["label_names"], results["boxes"]), + key=lambda d: -float(d[0]), +) +for score, name, box in detections: + print(f"{name:14s} {float(score):.3f} {[round(float(v)) for v in box]}") +``` + +``` +person 0.819 [214, 79, 345, 378] +bicycle 0.782 [98, 208, 441, 412] +person 0.746 [584, 137, 634, 239] +person 0.743 [315, 106, 407, 364] +person 0.710 [437, 126, 533, 318] +person 0.674 [414, 128, 456, 220] +motorcycle 0.582 [388, 187, 639, 350] +motorcycle 0.493 [0, 238, 107, 384] +motorcycle 0.485 [533, 162, 637, 251] +potted plant 0.342 [209, 32, 295, 189] +motorcycle 0.317 [532, 165, 596, 238] +``` + +Two riders on the bicycle, the bicycle itself, and the parked motorcycles down the street, +all from a 3.9 M-parameter model. `threshold=0.3` is a reasonable default for D0; raise it to +`0.4`–`0.5` to keep only the confident detections. + +### Batch Processing Multiple Images + +Pass a list of images and one `target_sizes` entry per image: + +EfficientDet-D0 detections on a cat in front of a TV and two cats on a couch, run as one batch + +```python +from PIL import Image +from zeromodels.models.efficientdet import EfficientDetDetect, EfficientDetImageProcessor + +model = EfficientDetDetect.from_weights("zeromodels/efficientdet_d0") +processor = EfficientDetImageProcessor.from_weights("zeromodels/efficientdet_d0") + +paths = ["assets/data/coco_cat_tv.jpg", "assets/data/coco_cats.jpg"] +images = [Image.open(p).convert("RGB") for p in paths] + +inputs = processor(paths) # (2, 512, 512, 3) +output = model(inputs["pixel_values"], training=False) + +results = processor.post_process_object_detection( + output, threshold=0.3, target_sizes=[(im.height, im.width) for im in images] +) + +for path, result in zip(paths, results): + print(f"\n{path}") + detections = sorted( + zip(result["scores"], result["label_names"], result["boxes"]), + key=lambda d: -float(d[0]), + ) + for score, name, box in detections: + print(f" {name:10s} {float(score):.3f} {[round(float(v)) for v in box]}") +``` + +``` +assets/data/coco_cat_tv.jpg + tv 0.779 [144, 9, 560, 288] + cat 0.749 [132, 187, 525, 348] + cup 0.676 [0, 420, 78, 478] + person 0.536 [201, 40, 352, 216] + +assets/data/coco_cats.jpg + cat 0.779 [345, 31, 630, 355] + cat 0.714 [16, 44, 318, 446] + remote 0.635 [40, 72, 173, 120] + bed 0.504 [15, 0, 640, 474] +``` + +Every image is letterboxed to the same square, so stacking is always safe; results come back +as per-image lists, not a fixed-width tensor. + +## NMS Modes + +EfficientDet emits a score for **every** class at every anchor, so a single object can clear +the threshold under more than one label (a dog also read as a cat, a truck also as a car). +How the duplicates are resolved is the post-processor's job: + +- **`class_agnostic=True`** (the default, Google's `postprocess_global`): each anchor keeps + only its single highest-scoring class, then one NMS runs across everything. One object + yields one box. This is what the examples above use. +- **`class_agnostic=False`** (`postprocess_per_class`): NMS runs independently per class, so + the same object can surface under several labels. Useful when you want the full per-class + ranking. + +```python +results = processor.post_process_object_detection( + output, threshold=0.3, class_agnostic=False, target_sizes=inputs["original_sizes"] +)[0] +``` + +Per-class NMS cannot suppress a dog box and a cat box over the same animal, because they are +different classes; the class-agnostic default collapses them to the higher-scoring one. + +## Input Resolution + +EfficientDet is Functional, so the input shape is fixed when the model is constructed, and +the anchor grid is generated for that size. Each variant has a native resolution (the table +above), but the **weights are resolution-independent** — the conv, BatchNorm, and separable +weights do not depend on the input size, and the only size-dependent tensor, the anchor grid, +is a computed constant rather than a stored weight. So you can build any variant at any valid +size and load the same checkpoint: + +```python +model = EfficientDetDetect.from_weights("zeromodels/efficientdet_d0", image_size=768) +processor = EfficientDetImageProcessor(image_size=768) # match the model +``` + +The `image_size=768` kwarg overrides the checkpoint's native 512; the 512-trained weights +load unchanged, and the anchor count scales with the input: + +``` +512: 49104 anchors cat 0.78, cat 0.71, remote 0.63, bed 0.50 +640: 76725 anchors cat 0.83, cat 0.73, couch 0.64, remote 0.62 +896: 150381 anchors couch 0.78, cat 0.73, remote 0.73, remote 0.71 +``` + +**The side must be divisible by 128.** The heads run on levels 3 through 7 (strides 8 to +128), so the input has to survive seven halvings cleanly. Every native size (512, 640, 768, +896, 1024, 1280, 1536) qualifies. + +**Accuracy is best near the trained resolution.** The model *runs* at any valid size, but +scores and box quality drift as you move away from native (visible above at 640 and 896). For +the best result, run each variant near its native size, or pick the variant whose native size +matches your target. + +## Custom Class Names + +A model fine-tuned on your own dataset predicts your class indices, not COCO's. Pass the names +through `label_names` so the result reads correctly: + +```python +MY_CLASSES = ["cat", "dog", "bird"] + +results = processor.post_process_object_detection( + output, + threshold=0.3, + target_sizes=[(image.height, image.width)], + label_names=MY_CLASSES, +) +``` + +Custom names are indexed directly by the 0-based class id (`label_names[c]`). The default +COCO list is offset by one instead (`COCO_91_CLASSES[c + 1]`, since index 0 is the "N/A" id), +so the post-processor handles the two cases automatically. Without `label_names` a custom +model is silently mislabeled with COCO names; the integer `labels` are unaffected either way. + +## Data Format + +**Both the model and the processor support `channels_last` and `channels_first`.** Nothing is +hard-coded to a layout, so the whole pipeline runs either way, and the same weights load into +both — the conv, BatchNorm, and separable-conv weights are layout-independent. Detections are +identical (boxes bit-exact, scores within backend rounding). + +They pick the format differently, which is the one thing to keep straight: + +| | How it picks the format | +|---|---| +| Processor | A `data_format` kwarg, per instance. `None` (the default) resolves to `keras.config.image_data_format()`. | +| Model | Reads `keras.config.image_data_format()` when it is **constructed**. There is no `data_format` argument. | + +### Overriding the processor only + +```python +EfficientDetImageProcessor(data_format="channels_last")("photo.jpg")["pixel_values"] +# (1, 512, 512, 3) + +EfficientDetImageProcessor(data_format="channels_first")("photo.jpg")["pixel_values"] +# (1, 3, 512, 512) +``` + +### Switching the whole pipeline + +Set the global format before constructing the model, and both sides agree: + +```python +import keras + +keras.config.set_image_data_format("channels_first") + +model = EfficientDetDetect.from_weights("zeromodels/efficientdet_d0") +processor = EfficientDetImageProcessor.from_weights("zeromodels/efficientdet_d0") + +inputs = processor(image) +# inputs["pixel_values"] is (1, 3, 512, 512) +output = model(inputs["pixel_values"], training=False) +``` + +Set it once at the top of a script, since already-built models keep the layout they were +constructed with. The post-processor emits `xyxy` pixel boxes and class indices, which have no +channel axis, so it is not format-sensitive. \ No newline at end of file diff --git a/tests/base/model_test_registry.py b/tests/base/model_test_registry.py index 67b7cfed..a7d9eda7 100644 --- a/tests/base/model_test_registry.py +++ b/tests/base/model_test_registry.py @@ -717,6 +717,21 @@ "pred_boxes": (2, 10, 4), }, }, + "EfficientDetDetect": { + "module": "zeromodels.models.efficientdet", + "model_cls": "EfficientDetDetect", + "model_type": "object_detection", + "init_kwargs": { + "backbone_name": "efficientnet_b0", + "image_size": 256, + "num_classes": 20, + }, + "input_shape": (2, 256, 256, 3), + "expected_output_shape": { + "boxes": (2, 12276, 4), + "scores": (2, 12276, 20), + }, + }, "RTDETRV2Detect": { "module": "zeromodels.models.rt_detr_v2", "model_cls": "RTDETRV2Detect", diff --git a/website/mkdocs.yml b/website/mkdocs.yml index 323f9f7a..8bf1fd02 100644 --- a/website/mkdocs.yml +++ b/website/mkdocs.yml @@ -176,6 +176,7 @@ nav: - DINO: dino.md - DINOv2: dinov2.md - DINOv3: dinov3.md + - EfficientDet: efficientdet.md - EoMT: eomt.md - Mask2Former: mask2former.md - MaskFormer: maskformer.md diff --git a/zeromodels/models/efficientdet/efficientdet_config.py b/zeromodels/models/efficientdet/efficientdet_config.py index 847b7b07..3ca5c333 100644 --- a/zeromodels/models/efficientdet/efficientdet_config.py +++ b/zeromodels/models/efficientdet/efficientdet_config.py @@ -128,6 +128,8 @@ class EfficientDetConfig(BaseConfig): "fpn_num_filters": 384, "fpn_cell_repeats": 8, "box_class_repeats": 5, + # D6/D7 fuse BiFPN inputs with an unweighted sum (no per-edge weights). + "fpn_weight_method": "sum", }, "efficientdet_d7": { "backbone_name": "efficientnet_b6", @@ -136,6 +138,7 @@ class EfficientDetConfig(BaseConfig): "fpn_cell_repeats": 8, "box_class_repeats": 5, "anchor_scale": 5.0, + "fpn_weight_method": "sum", }, } diff --git a/zeromodels/models/efficientdet/efficientdet_image_processor.py b/zeromodels/models/efficientdet/efficientdet_image_processor.py index 6f4ec7f0..97732e5a 100644 --- a/zeromodels/models/efficientdet/efficientdet_image_processor.py +++ b/zeromodels/models/efficientdet/efficientdet_image_processor.py @@ -6,7 +6,7 @@ from PIL import Image from zeromodels.base import BaseImageProcessor -from zeromodels.utils.image_util import load_image +from zeromodels.utils.image_util import get_data_format, load_image from zeromodels.utils.labels_util import COCO_91_CLASSES from .efficientdet_layers import EfficientDetNMS @@ -66,9 +66,17 @@ def preprocess_one(self, image): new_h = int(orig_h * scale) new_w = int(orig_w * scale) + # Preprocess entirely in channels_last (NHWC), then transpose at the end, so + # the base resize/normalize helpers are not misled by a channels_first global. t = ops.convert_to_tensor(arr, dtype="float32") t = ops.expand_dims(t, axis=0) - t = self.resize(t, (new_h, new_w), interpolation=self.resample, antialias=True) + t = self.resize( + t, + (new_h, new_w), + interpolation=self.resample, + antialias=True, + data_format="channels_last", + ) t = self.rescale_and_normalize( t, do_rescale=True, @@ -76,11 +84,14 @@ def preprocess_one(self, image): do_normalize=True, mean=self.image_mean, std=self.image_std, + data_format="channels_last", ) pad_h = self.image_size - new_h pad_w = self.image_size - new_w t = ops.pad(t, [(0, 0), (0, pad_h), (0, pad_w), (0, 0)], constant_values=0.0) - if self.data_format == "channels_first": + # data_format=None follows keras.config.image_data_format(), so the output + # layout matches a model built under the same global setting. + if get_data_format(self.data_format) == "channels_first": t = ops.transpose(t, (0, 3, 1, 2)) return t, scale, (orig_h, orig_w) @@ -147,7 +158,12 @@ def post_process_object_detection( class_agnostic=class_agnostic, ) detections = ops.convert_to_numpy(nms(outputs["boxes"], outputs["scores"])) - names = label_names if label_names is not None else COCO_91_CLASSES + # COCO ids are 1-based (index 0 is "N/A"), so the default list is offset by 1; + # custom label_names are indexed directly by the 0-based class id. + if label_names is None: + names, offset = COCO_91_CLASSES, 1 + else: + names, offset = label_names, 0 results = [] for i in range(detections.shape[0]): @@ -171,7 +187,8 @@ def post_process_object_detection( xmax = np.clip(xmax, 0, orig_w) boxes_xyxy = np.stack([xmin, ymin, xmax, ymax], axis=-1) mapped = [ - names[c + 1] if (c + 1) < len(names) else f"class_{c}" for c in labels + names[c + offset] if (c + offset) < len(names) else f"class_{c}" + for c in labels ] results.append( { diff --git a/zeromodels/models/efficientdet/efficientdet_layers.py b/zeromodels/models/efficientdet/efficientdet_layers.py index 3d5a8d91..70b0807e 100644 --- a/zeromodels/models/efficientdet/efficientdet_layers.py +++ b/zeromodels/models/efficientdet/efficientdet_layers.py @@ -4,9 +4,22 @@ import numpy as np from keras import layers, ops +from zeromodels.utils.image_util import get_data_format + from .efficientdet_config import bifpn_nodes +def channel_axis(data_format): + return 1 if data_format == "channels_first" else -1 + + +def spatial_dims(shape, data_format): + """(height, width) of a 4D feature-map shape under ``data_format``.""" + if data_format == "channels_first": + return int(shape[2]), int(shape[3]) + return int(shape[1]), int(shape[2]) + + def act(x, act_type="swish"): if act_type == "swish": return ops.silu(x) @@ -15,13 +28,14 @@ def act(x, act_type="swish"): return layers.Activation(act_type)(x) -def sep_conv(filters, kernel_size=3, use_bias=True, name=None): +def sep_conv(filters, kernel_size=3, use_bias=True, data_format=None, name=None): return layers.SeparableConv2D( filters, kernel_size=kernel_size, padding="same", depth_multiplier=1, use_bias=use_bias, + data_format=data_format, name=name, ) @@ -38,23 +52,31 @@ def __init__( target_channels, apply_bn=True, conv_after_downsample=False, + data_format=None, name=None, ): super().__init__(name=name) self.target_channels = target_channels self.apply_bn = apply_bn self.conv_after_downsample = conv_after_downsample + self.data_format = get_data_format(data_format) self.conv2d = None self.bn = None def build(self, input_shape): - in_channels = input_shape[-1] + in_channels = input_shape[channel_axis(self.data_format)] if in_channels != self.target_channels: self.conv2d = layers.Conv2D( - self.target_channels, 1, padding="same", name="conv2d" + self.target_channels, + 1, + padding="same", + data_format=self.data_format, + name="conv2d", ) if self.apply_bn: - self.bn = layers.BatchNormalization(name="bn") + self.bn = layers.BatchNormalization( + axis=channel_axis(self.data_format), name="bn" + ) self.built = True def apply_1x1(self, feat, training): @@ -65,7 +87,7 @@ def apply_1x1(self, feat, training): return feat def call(self, feat, target_height, target_width, training=False): - height, width = int(feat.shape[1]), int(feat.shape[2]) + height, width = spatial_dims(feat.shape, self.data_format) if height > target_height and width > target_width: if not self.conv_after_downsample: feat = self.apply_1x1(feat, training) @@ -75,6 +97,7 @@ def call(self, feat, target_height, target_width, training=False): pool_size=(h_stride + 1, w_stride + 1), strides=(h_stride, w_stride), padding="same", + data_format=self.data_format, )(feat) if self.conv_after_downsample: feat = self.apply_1x1(feat, training) @@ -82,7 +105,10 @@ def call(self, feat, target_height, target_width, training=False): feat = self.apply_1x1(feat, training) if height < target_height or width < target_width: feat = ops.image.resize( - feat, (target_height, target_width), interpolation="nearest" + feat, + (target_height, target_width), + interpolation="nearest", + data_format=self.data_format, ) return feat @@ -93,6 +119,7 @@ def get_config(self): "target_channels": self.target_channels, "apply_bn": self.apply_bn, "conv_after_downsample": self.conv_after_downsample, + "data_format": self.data_format, } ) return config @@ -115,6 +142,7 @@ def __init__( apply_bn_for_resampling, conv_after_downsample, conv_bn_act_pattern, + data_format=None, name=None, ): super().__init__(name=name) @@ -126,19 +154,27 @@ def __init__( self.apply_bn_for_resampling = apply_bn_for_resampling self.conv_after_downsample = conv_after_downsample self.conv_bn_act_pattern = conv_bn_act_pattern + self.data_format = get_data_format(data_format) self.resamples = [ EfficientDetResample( fpn_num_filters, apply_bn=apply_bn_for_resampling, conv_after_downsample=conv_after_downsample, + data_format=self.data_format, name=f"resample_{i}_{off}", ) for i, off in enumerate(self.inputs_offsets) ] self.conv = sep_conv( - fpn_num_filters, 3, use_bias=not conv_bn_act_pattern, name="conv" + fpn_num_filters, + 3, + use_bias=not conv_bn_act_pattern, + data_format=self.data_format, + name="conv", + ) + self.bn = layers.BatchNormalization( + axis=channel_axis(self.data_format), name="bn" ) - self.bn = layers.BatchNormalization(name="bn") def build(self, input_shape): self.edge_weights = None @@ -199,6 +235,7 @@ def get_config(self): "apply_bn_for_resampling": self.apply_bn_for_resampling, "conv_after_downsample": self.conv_after_downsample, "conv_bn_act_pattern": self.conv_bn_act_pattern, + "data_format": self.data_format, } ) return config @@ -222,6 +259,7 @@ def __init__( apply_bn_for_resampling, conv_after_downsample, conv_bn_act_pattern, + data_format=None, name="fpn_cells", ): super().__init__(name=name) @@ -231,6 +269,7 @@ def __init__( self.fpn_cell_repeats = fpn_cell_repeats self.weight_method = weight_method self.act_type = act_type + self.data_format = get_data_format(data_format) self.nodes_cfg = bifpn_nodes(min_level, max_level) self.cells = [] for rep in range(fpn_cell_repeats): @@ -244,6 +283,7 @@ def __init__( apply_bn_for_resampling, conv_after_downsample, conv_bn_act_pattern, + data_format=self.data_format, name=f"cell_{rep}_fnode{i}", ) for i, cfg in enumerate(self.nodes_cfg) @@ -284,6 +324,7 @@ def __init__( head_name, min_level=3, predict_bias_init=0.0, + data_format=None, name=None, ): super().__init__(name=name) @@ -295,15 +336,25 @@ def __init__( self.head_name = head_name self.min_level = min_level self.predict_bias_init = predict_bias_init + self.data_format = get_data_format(data_format) self.convs = [ - sep_conv(num_filters, 3, use_bias=True, name=f"{head_name}-{i}") + sep_conv( + num_filters, + 3, + use_bias=True, + data_format=self.data_format, + name=f"{head_name}-{i}", + ) for i in range(repeats) ] # one BatchNorm per (repeat, level); conv weights are shared across levels. # BN names carry the absolute pyramid level (min_level + lvl), like Google's. self.bns = [ [ - layers.BatchNormalization(name=f"{head_name}-{i}-bn-{min_level + lvl}") + layers.BatchNormalization( + axis=channel_axis(self.data_format), + name=f"{head_name}-{i}-bn-{min_level + lvl}", + ) for lvl in range(num_levels) ] for i in range(repeats) @@ -314,6 +365,7 @@ def __init__( padding="same", depth_multiplier=1, bias_initializer=keras.initializers.Constant(predict_bias_init), + data_format=self.data_format, name=f"{head_name}-predict", ) @@ -340,6 +392,7 @@ def get_config(self): "head_name": self.head_name, "min_level": self.min_level, "predict_bias_init": self.predict_bias_init, + "data_format": self.data_format, } ) return config @@ -469,16 +522,14 @@ def __init__( ) def build(self, input_shape): - self.anchors = self.add_weight( - name="anchors", - shape=self.anchors_np.shape, - initializer=keras.initializers.Constant(self.anchors_np), - trainable=False, - ) self.built = True def call(self, box_outputs): - return decode_box_outputs(box_outputs, self.anchors) + # Anchors are a fixed function of the config, so they are baked into the graph + # as a constant rather than stored as a weight. This keeps EfficientDetDetect's + # weight set identical to EfficientDetModel's, so both load one hosted file. + anchors = ops.convert_to_tensor(self.anchors_np, dtype=box_outputs.dtype) + return decode_box_outputs(box_outputs, anchors) def compute_output_shape(self, input_shape): return input_shape diff --git a/zeromodels/models/efficientdet/efficientdet_model.py b/zeromodels/models/efficientdet/efficientdet_model.py index a0122bab..90cec73d 100644 --- a/zeromodels/models/efficientdet/efficientdet_model.py +++ b/zeromodels/models/efficientdet/efficientdet_model.py @@ -1,10 +1,11 @@ import keras from keras import layers -from zeromodels.base import BaseModel +from zeromodels.base import BaseModel, CheckpointSource from zeromodels.models.efficientnet.efficientnet_model import ( efficientnet_backbone_feature, ) +from zeromodels.utils.image_util import get_data_format from .efficientdet_config import EfficientDetConfig from .efficientdet_layers import ( @@ -12,6 +13,7 @@ EfficientDetResample, FPNCells, PredictionHead, + channel_axis, class_predict_bias, ) @@ -100,6 +102,7 @@ def __init__( for k in ("model", "hf_id", "url", "num_classes_"): kwargs.pop(k, None) + data_format = get_data_format() num_anchors = num_scales * len(aspect_ratios) width, depth, dropout = BACKBONE_COEFFS[backbone_name] level_sizes = [ @@ -107,7 +110,12 @@ def __init__( for level in range(min_level, max_level + 1) ] - image = layers.Input(shape=(image_size, image_size, 3), name="images") + input_shape = ( + (3, image_size, image_size) + if data_format == "channels_first" + else (image_size, image_size, 3) + ) + image = layers.Input(shape=input_shape, name="images") # Backbone P3/P4/P5 (strides 8/16/32 -> stages[2:5]). stages = efficientnet_backbone_feature( @@ -115,8 +123,8 @@ def __init__( width_coefficient=width, depth_coefficient=depth, dropout_rate=dropout, - data_format="channels_last", - channels_axis=-1, + data_format=data_format, + channels_axis=channel_axis(data_format), return_stages=True, ) feats = [stages[2], stages[3], stages[4]] @@ -129,6 +137,7 @@ def __init__( fpn_num_filters, apply_bn=apply_bn_for_resampling, conv_after_downsample=conv_after_downsample, + data_format=data_format, name=f"resample_p{level}", )(feats[-1], target_height=th, target_width=tw) ) @@ -143,6 +152,7 @@ def __init__( apply_bn_for_resampling, conv_after_downsample, conv_bn_act_pattern, + data_format=data_format, name="fpn_cells", )(feats, level_sizes=level_sizes) @@ -156,6 +166,7 @@ def __init__( "class", min_level=min_level, predict_bias_init=class_predict_bias(), + data_format=data_format, name="class_net", )(fpn_feats) box_outputs = PredictionHead( @@ -167,6 +178,7 @@ def __init__( "box", min_level=min_level, predict_bias_init=0.0, + data_format=data_format, name="box_net", )(fpn_feats) @@ -217,6 +229,11 @@ class and box outputs, applies sigmoid to the class logits, and decodes the box BASE_WEIGHT_CONFIG = None HF_MODEL_TYPE = "efficientdet" config_class = EfficientDetConfig + # EfficientDetDetect shares its weights with EfficientDetModel (identical backbone, + # BiFPN and heads; decoding adds no weights). Hosted repos declare the canonical + # EfficientDetModel, and this class loads that same file by copying weights out. + HUB_REPO_SIBLINGS = frozenset({"EfficientDetModel"}) + CHECKPOINT_SOURCE = CheckpointSource("EfficientDetModel") def __init__( self, @@ -268,12 +285,22 @@ def __init__( class_outputs = base.output["class_outputs"] box_outputs = base.output["box_outputs"] - cls_flat = layers.Concatenate(axis=1, name="class_concat")( - [layers.Reshape((-1, num_classes))(c) for c in class_outputs] - ) - box_flat = layers.Concatenate(axis=1, name="box_concat")( - [layers.Reshape((-1, 4))(b) for b in box_outputs] - ) + # Flatten each level's head output to (B, H*W*anchors, last). Under + # channels_first the head output is (B, anchors*last, H, W); transpose it to + # channels_last first so the anchor ordering (position-major) matches the + # anchor grid regardless of data format -> identical outputs either way. + data_format = get_data_format() + + def flatten_levels(tensors, last, name): + flats = [] + for tensor in tensors: + if data_format == "channels_first": + tensor = layers.Permute((2, 3, 1))(tensor) + flats.append(layers.Reshape((-1, last))(tensor)) + return layers.Concatenate(axis=1, name=name)(flats) + + cls_flat = flatten_levels(class_outputs, num_classes, "class_concat") + box_flat = flatten_levels(box_outputs, 4, "box_concat") scores = layers.Activation("sigmoid", name="scores")(cls_flat) boxes = DecodeBoxes( min_level, From 826362c131214fa60a6057a56caf3273ead95e99 Mon Sep 17 00:00:00 2001 From: IMvision12 Date: Thu, 27 Aug 2026 14:28:50 -0700 Subject: [PATCH 4/5] fix --- docs/efficientdet.md | 6 +- zeromodels/models/efficientdet/__init__.py | 3 +- .../convert_efficientdet_h5_to_keras.py | 85 ++++++++++---- .../efficientdet/efficientdet_config.py | 106 +----------------- .../efficientdet/efficientdet_layers.py | 33 +++++- 5 files changed, 105 insertions(+), 128 deletions(-) diff --git a/docs/efficientdet.md b/docs/efficientdet.md index f3fb5083..3805389c 100644 --- a/docs/efficientdet.md +++ b/docs/efficientdet.md @@ -44,8 +44,8 @@ EfficientDetDetect( The detector: EfficientNet backbone, weighted BiFPN, shared class/box heads, and in-graph anchor decoding. **This is the class for object detection.** Defaults describe -EfficientDet-D0; `from_weights` fills these in from the variant config, and passing a recipe -from `EFFICIENTDET_RECIPES` builds a larger variant by hand. +EfficientDet-D0; `from_weights` fills these in from the hosted `zm_config.json` for each +variant, so you rarely pass them by hand. **Parameters** @@ -159,7 +159,7 @@ undoes the letterbox and clips boxes to each original image. ## Model Variants Every variant is trained on COCO's 90 categories and converted from Google AutoML's -`coco2` release. `EFFICIENTDET_RECIPES[variant]` returns the constructor kwargs for each. +`coco2` release. Load any of them with `from_weights("zeromodels/")`. | Variant id | Backbone | Input | Params | |-------------------|-----------------|------:|-------:| diff --git a/zeromodels/models/efficientdet/__init__.py b/zeromodels/models/efficientdet/__init__.py index 3d305691..febc340b 100644 --- a/zeromodels/models/efficientdet/__init__.py +++ b/zeromodels/models/efficientdet/__init__.py @@ -1,10 +1,9 @@ -from .efficientdet_config import EFFICIENTDET_RECIPES, EfficientDetConfig +from .efficientdet_config import EfficientDetConfig from .efficientdet_image_processor import EfficientDetImageProcessor from .efficientdet_model import EfficientDetDetect, EfficientDetModel __all__ = [ "EfficientDetConfig", - "EFFICIENTDET_RECIPES", "EfficientDetModel", "EfficientDetDetect", "EfficientDetImageProcessor", diff --git a/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py b/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py index 96c4fef9..c9b1e077 100644 --- a/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py +++ b/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py @@ -6,24 +6,74 @@ BACKBONE_PREFIX = "efficientnet-{bb}/efficientnet-{bb}" -EFFICIENTDET_VARIANTS = { - "efficientdet_d0": "efficientnet-b0", - "efficientdet_d1": "efficientnet-b1", - "efficientdet_d2": "efficientnet-b2", - "efficientdet_d3": "efficientnet-b3", - "efficientdet_d4": "efficientnet-b4", - "efficientdet_d5": "efficientnet-b5", - "efficientdet_d6": "efficientnet-b6", - "efficientdet_d7": "efficientnet-b6", +EFFICIENTDET_RECIPES = { + "efficientdet_d0": { + "backbone_name": "efficientnet_b0", + "image_size": 512, + "fpn_num_filters": 64, + "fpn_cell_repeats": 3, + "box_class_repeats": 3, + }, + "efficientdet_d1": { + "backbone_name": "efficientnet_b1", + "image_size": 640, + "fpn_num_filters": 88, + "fpn_cell_repeats": 4, + "box_class_repeats": 3, + }, + "efficientdet_d2": { + "backbone_name": "efficientnet_b2", + "image_size": 768, + "fpn_num_filters": 112, + "fpn_cell_repeats": 5, + "box_class_repeats": 3, + }, + "efficientdet_d3": { + "backbone_name": "efficientnet_b3", + "image_size": 896, + "fpn_num_filters": 160, + "fpn_cell_repeats": 6, + "box_class_repeats": 4, + }, + "efficientdet_d4": { + "backbone_name": "efficientnet_b4", + "image_size": 1024, + "fpn_num_filters": 224, + "fpn_cell_repeats": 7, + "box_class_repeats": 4, + }, + "efficientdet_d5": { + "backbone_name": "efficientnet_b5", + "image_size": 1280, + "fpn_num_filters": 288, + "fpn_cell_repeats": 7, + "box_class_repeats": 4, + }, + "efficientdet_d6": { + "backbone_name": "efficientnet_b6", + "image_size": 1280, + "fpn_num_filters": 384, + "fpn_cell_repeats": 8, + "box_class_repeats": 5, + "fpn_weight_method": "sum", + }, + "efficientdet_d7": { + "backbone_name": "efficientnet_b6", + "image_size": 1536, + "fpn_num_filters": 384, + "fpn_cell_repeats": 8, + "box_class_repeats": 5, + "anchor_scale": 5.0, + "fpn_weight_method": "sum", + }, } -# Official Google AutoML Keras checkpoints (COCO). EFFICIENTDET_H5_URLS = { name: ( "https://storage.googleapis.com/cloud-tpu-checkpoints/efficientdet/" f"coco2/{name.replace('_', '-')}.h5" ) - for name in EFFICIENTDET_VARIANTS + for name in EFFICIENTDET_RECIPES } @@ -66,9 +116,6 @@ def map_backbone_block(path, bb_prefix, block_n, has_expand): def keras_path_to_h5(path, bb_prefix, order, expand_flags, num_levels): - """Map a zeromodels EfficientDet weight path to the Google ``.h5`` dataset name - (without the trailing ``:0``). Returns ``None`` for weights not present in the - checkpoint (e.g. the anchor constant).""" seg0 = path.split("/")[0] if seg0 == "decode_boxes": # anchor constant, not in the checkpoint return None @@ -100,13 +147,9 @@ def keras_path_to_h5(path, bb_prefix, order, expand_flags, num_levels): raise ValueError(f"unmapped path {path!r}") -def transfer_efficientdet_weights(keras_model, h5_path, backbone="efficientnet-b0"): - """Load a Google AutoML EfficientDet ``.h5`` checkpoint into a zeromodels - ``EfficientDetModel`` or ``EfficientDetDetect``. - - Both sides are Keras saves, so values copy verbatim (no transposes). The anchor - constant on ``EfficientDetDetect`` is skipped. Returns the number of tensors - transferred and raises if any expected weight is missing from the checkpoint.""" +def transfer_efficientdet_weights(keras_model, h5_path, backbone=None): + if backbone is None: + backbone = keras_model.backbone_name.replace("_", "-") paths = [w.path for w in keras_model.weights] order = block_order(paths) expand_flags = { diff --git a/zeromodels/models/efficientdet/efficientdet_config.py b/zeromodels/models/efficientdet/efficientdet_config.py index 3ca5c333..b31c2e78 100644 --- a/zeromodels/models/efficientdet/efficientdet_config.py +++ b/zeromodels/models/efficientdet/efficientdet_config.py @@ -7,8 +7,10 @@ class EfficientDetConfig(BaseConfig): EfficientDet = an EfficientNet backbone -> a weighted bidirectional feature pyramid (BiFPN, repeated ``fpn_cell_repeats`` times) -> shared class + box prediction heads run over pyramid levels ``min_level``..``max_level``. Defaults - describe **EfficientDet-D0**; the D1-D7 variants override a handful of fields - (see :data:`EFFICIENTDET_RECIPES`). + describe **EfficientDet-D0**; the D1-D7 variants override a handful of fields. + Pretrained variants load their architecture from the hosted ``zm_config.json`` via + ``from_weights``; the per-variant overrides used only when converting Google's + config-less ``.h5`` live in ``convert_efficientdet_h5_to_keras.EFFICIENTDET_RECIPES``. Args: backbone_name (`str`, *optional*, defaults to `"efficientnet_b0"`): @@ -51,9 +53,9 @@ class EfficientDetConfig(BaseConfig): Example: ```python - >>> from zeromodels.models.efficientdet import EfficientDetConfig, EFFICIENTDET_RECIPES + >>> from zeromodels.models.efficientdet import EfficientDetConfig - >>> config = EfficientDetConfig(**EFFICIENTDET_RECIPES["efficientdet_d2"]) + >>> config = EfficientDetConfig(backbone_name="efficientnet_b2", image_size=768) ```""" model_type = "efficientdet" @@ -76,99 +78,3 @@ class EfficientDetConfig(BaseConfig): conv_bn_act_pattern: bool = False fpn_weight_method: str = "fastattn" survival_prob: float = None - - -# Per-variant overrides of the D0 defaults (Google's efficientdet-d0..d7 recipes). -EFFICIENTDET_RECIPES = { - "efficientdet_d0": { - "backbone_name": "efficientnet_b0", - "image_size": 512, - "fpn_num_filters": 64, - "fpn_cell_repeats": 3, - "box_class_repeats": 3, - }, - "efficientdet_d1": { - "backbone_name": "efficientnet_b1", - "image_size": 640, - "fpn_num_filters": 88, - "fpn_cell_repeats": 4, - "box_class_repeats": 3, - }, - "efficientdet_d2": { - "backbone_name": "efficientnet_b2", - "image_size": 768, - "fpn_num_filters": 112, - "fpn_cell_repeats": 5, - "box_class_repeats": 3, - }, - "efficientdet_d3": { - "backbone_name": "efficientnet_b3", - "image_size": 896, - "fpn_num_filters": 160, - "fpn_cell_repeats": 6, - "box_class_repeats": 4, - }, - "efficientdet_d4": { - "backbone_name": "efficientnet_b4", - "image_size": 1024, - "fpn_num_filters": 224, - "fpn_cell_repeats": 7, - "box_class_repeats": 4, - }, - "efficientdet_d5": { - "backbone_name": "efficientnet_b5", - "image_size": 1280, - "fpn_num_filters": 288, - "fpn_cell_repeats": 7, - "box_class_repeats": 4, - }, - "efficientdet_d6": { - "backbone_name": "efficientnet_b6", - "image_size": 1280, - "fpn_num_filters": 384, - "fpn_cell_repeats": 8, - "box_class_repeats": 5, - # D6/D7 fuse BiFPN inputs with an unweighted sum (no per-edge weights). - "fpn_weight_method": "sum", - }, - "efficientdet_d7": { - "backbone_name": "efficientnet_b6", - "image_size": 1536, - "fpn_num_filters": 384, - "fpn_cell_repeats": 8, - "box_class_repeats": 5, - "anchor_scale": 5.0, - "fpn_weight_method": "sum", - }, -} - - -def bifpn_nodes(min_level, max_level): - """Google's dynamic BiFPN node topology for ``min_level``..``max_level``. - - Each node lists the offsets (into the growing feature list) it fuses; a - top-down path (P{max-1}'..P{min}') then a bottom-up path (P{min+1}''..P{max}''). - """ - num_levels = max_level - min_level + 1 - node_ids = {min_level + i: [i] for i in range(num_levels)} - counter = num_levels - nodes = [] - for level in range(max_level - 1, min_level - 1, -1): # top-down - nodes.append( - { - "feat_level": level, - "inputs_offsets": [node_ids[level][-1], node_ids[level + 1][-1]], - } - ) - node_ids[level].append(counter) - counter += 1 - for level in range(min_level + 1, max_level + 1): # bottom-up - nodes.append( - { - "feat_level": level, - "inputs_offsets": node_ids[level] + [node_ids[level - 1][-1]], - } - ) - node_ids[level].append(counter) - counter += 1 - return nodes diff --git a/zeromodels/models/efficientdet/efficientdet_layers.py b/zeromodels/models/efficientdet/efficientdet_layers.py index 70b0807e..62e12528 100644 --- a/zeromodels/models/efficientdet/efficientdet_layers.py +++ b/zeromodels/models/efficientdet/efficientdet_layers.py @@ -6,8 +6,6 @@ from zeromodels.utils.image_util import get_data_format -from .efficientdet_config import bifpn_nodes - def channel_axis(data_format): return 1 if data_format == "channels_first" else -1 @@ -241,6 +239,37 @@ def get_config(self): return config +def bifpn_nodes(min_level, max_level): + """Google's dynamic BiFPN node topology for ``min_level``..``max_level``. + + Each node lists the offsets (into the growing feature list) it fuses; a + top-down path (P{max-1}'..P{min}') then a bottom-up path (P{min+1}''..P{max}''). + """ + num_levels = max_level - min_level + 1 + node_ids = {min_level + i: [i] for i in range(num_levels)} + counter = num_levels + nodes = [] + for level in range(max_level - 1, min_level - 1, -1): # top-down + nodes.append( + { + "feat_level": level, + "inputs_offsets": [node_ids[level][-1], node_ids[level + 1][-1]], + } + ) + node_ids[level].append(counter) + counter += 1 + for level in range(min_level + 1, max_level + 1): # bottom-up + nodes.append( + { + "feat_level": level, + "inputs_offsets": node_ids[level] + [node_ids[level - 1][-1]], + } + ) + node_ids[level].append(counter) + counter += 1 + return nodes + + @keras.saving.register_keras_serializable(package="zeromodels") class FPNCells(layers.Layer): """The full BiFPN: ``fpn_cell_repeats`` stacked cells of ``FNode``s over levels From ddd0826158acbf0529f289328c2e8e1372c0c0be Mon Sep 17 00:00:00 2001 From: IMvision12 Date: Thu, 27 Aug 2026 14:57:47 -0700 Subject: [PATCH 5/5] Fix np --- docs/efficientdet.md | 10 +- docs/granite_speech5.md | 58 ++++-- tests/base/model_test_registry.py | 1 + tests/fixtures/dummy_inputs.py | 16 +- .../convert_efficientdet_h5_to_keras.py | 10 +- .../efficientdet_image_processor.py | 29 ++- .../efficientdet/efficientdet_layers.py | 174 +++++++++++------- 7 files changed, 183 insertions(+), 115 deletions(-) diff --git a/docs/efficientdet.md b/docs/efficientdet.md index 3805389c..f206e837 100644 --- a/docs/efficientdet.md +++ b/docs/efficientdet.md @@ -181,7 +181,10 @@ sum (`fpn_weight_method="sum"`) instead of the fast-attention weighting D0–D5 ```python from PIL import Image -from zeromodels.models.efficientdet import EfficientDetDetect, EfficientDetImageProcessor +from zeromodels.models.efficientdet import ( + EfficientDetDetect, + EfficientDetImageProcessor, +) model = EfficientDetDetect.from_weights("zeromodels/efficientdet_d0") processor = EfficientDetImageProcessor.from_weights("zeromodels/efficientdet_d0") @@ -232,7 +235,10 @@ Pass a list of images and one `target_sizes` entry per image: ```python from PIL import Image -from zeromodels.models.efficientdet import EfficientDetDetect, EfficientDetImageProcessor +from zeromodels.models.efficientdet import ( + EfficientDetDetect, + EfficientDetImageProcessor, +) model = EfficientDetDetect.from_weights("zeromodels/efficientdet_d0") processor = EfficientDetImageProcessor.from_weights("zeromodels/efficientdet_d0") diff --git a/docs/granite_speech5.md b/docs/granite_speech5.md index 632c150f..5558acc5 100644 --- a/docs/granite_speech5.md +++ b/docs/granite_speech5.md @@ -22,12 +22,24 @@ repeats and dropping the blank token, turns the per-frame argmax into text. ### GraniteSpeech5CTC ```python -GraniteSpeech5CTC(vocab_size=16384, hidden_size=1024, intermediate_size=4096, - num_hidden_layers=16, num_attention_heads=8, head_dim=128, - num_mel_bins=80, hidden_act="silu", max_position_embeddings=512, - context_size=128, conv_kernel_size=7, conv_expansion_factor=2, - subsample_layers=(0, 1), attention_bias=True, pad_token_id=0, - name="GraniteSpeech5CTC") +GraniteSpeech5CTC( + vocab_size=16384, + hidden_size=1024, + intermediate_size=4096, + num_hidden_layers=16, + num_attention_heads=8, + head_dim=128, + num_mel_bins=80, + hidden_act="silu", + max_position_embeddings=512, + context_size=128, + conv_kernel_size=7, + conv_expansion_factor=2, + subsample_layers=(0, 1), + attention_bias=True, + pad_token_id=0, + name="GraniteSpeech5CTC", +) ``` The conformer encoder plus the CTC head (tied to the encoder's mid-layer self-conditioning @@ -61,7 +73,7 @@ blank, and render text. ### GraniteSpeech5Model ```python -GraniteSpeech5Model(...) # same encoder arguments as GraniteSpeech5CTC +GraniteSpeech5Model(...) # same encoder arguments as GraniteSpeech5CTC ``` The conformer encoder backbone alone. Returns `last_hidden_state` @@ -73,9 +85,16 @@ CTC projection, for feature extraction or a custom head. ### GraniteSpeech5FeatureExtractor ```python -GraniteSpeech5FeatureExtractor(sampling_rate=16000, n_fft=512, win_length=400, - hop_length=160, num_mel_bins=80, delta_win_length=3, - logmel_floor_db=8.0, frame_stacking=2) +GraniteSpeech5FeatureExtractor( + sampling_rate=16000, + n_fft=512, + win_length=400, + hop_length=160, + num_mel_bins=80, + delta_win_length=3, + logmel_floor_db=8.0, + frame_stacking=2, +) ``` Pure-Keras log-mel(+delta) feature extractor. Computes a `torchaudio`-style mel @@ -114,6 +133,7 @@ returns `input_features` + `attention_mask` (and padded CTC `labels` when `text` ```python import os + os.environ["KERAS_BACKEND"] = "torch" # or "jax" / "tensorflow" import soundfile as sf @@ -125,9 +145,11 @@ from zeromodels.models.granite_speech5 import ( model = GraniteSpeech5CTC.from_weights("zeromodels/granite-speech-5.0-470m-turboctc") features = GraniteSpeech5FeatureExtractor() -tokenizer = GraniteSpeech5Tokenizer.from_weights("zeromodels/granite-speech-5.0-470m-turboctc") +tokenizer = GraniteSpeech5Tokenizer.from_weights( + "zeromodels/granite-speech-5.0-470m-turboctc" +) -audio, sr = sf.read("speech.wav", dtype="float32") # 16 kHz mono +audio, sr = sf.read("speech.wav", dtype="float32") # 16 kHz mono inputs = features(audio, sampling_rate=sr) predicted_ids = model.generate(inputs) print(tokenizer.batch_decode(predicted_ids)) @@ -138,7 +160,9 @@ Or drive it end to end through the processor: ```python from zeromodels.models.granite_speech5 import GraniteSpeech5Processor -processor = GraniteSpeech5Processor.from_weights("zeromodels/granite-speech-5.0-470m-turboctc") +processor = GraniteSpeech5Processor.from_weights( + "zeromodels/granite-speech-5.0-470m-turboctc" +) inputs = processor(audio=audio, sampling_rate=sr) predicted_ids = model.generate(inputs) print(processor.batch_decode(predicted_ids)) @@ -156,6 +180,10 @@ print(processor.batch_decode(predicted_ids)) Upstream and community safetensors load on the fly with the `hf:` prefix (no re-hosting): ```python -model = GraniteSpeech5CTC.from_weights("hf:ibm-granite/granite-speech-5.0-470m-turboctc") -tokenizer = GraniteSpeech5Tokenizer.from_hf("ibm-granite/granite-speech-5.0-470m-turboctc") +model = GraniteSpeech5CTC.from_weights( + "hf:ibm-granite/granite-speech-5.0-470m-turboctc" +) +tokenizer = GraniteSpeech5Tokenizer.from_hf( + "ibm-granite/granite-speech-5.0-470m-turboctc" +) ``` diff --git a/tests/base/model_test_registry.py b/tests/base/model_test_registry.py index a7d9eda7..d3e132bb 100644 --- a/tests/base/model_test_registry.py +++ b/tests/base/model_test_registry.py @@ -4271,6 +4271,7 @@ def instantiate_model(config): def create_test_input(config, batch_size=2, model=None): from tests.fixtures import dummy_inputs + if config.get("multimodal_vlm") and model is not None: return dummy_inputs.multimodal_vlm_input(model, batch_size=batch_size) diff --git a/tests/fixtures/dummy_inputs.py b/tests/fixtures/dummy_inputs.py index fc20d8ea..f7b098ca 100644 --- a/tests/fixtures/dummy_inputs.py +++ b/tests/fixtures/dummy_inputs.py @@ -309,13 +309,19 @@ def multimodal_vlm_input(model, batch_size=2, seq_len=6, vocab_size=128): shape[-1] = ids.shape[1] feed[n] = ops.convert_to_tensor(np.zeros(shape, dtype="int32")) elif "video" in n and "pixel" in n: - feed[n] = feed["pixel_values"] # mirror the image; an empty video breaks the ViT + feed[n] = feed[ + "pixel_values" + ] # mirror the image; an empty video breaks the ViT elif n == "video_grid_thw": feed[n] = feed["image_grid_thw"] elif "grid_thw" in n: - feed[n] = ops.convert_to_tensor(np.tile(np.array(grid, "int32"), (batch_size, 1))) + feed[n] = ops.convert_to_tensor( + np.tile(np.array(grid, "int32"), (batch_size, 1)) + ) elif "hws" in n: - feed[n] = ops.convert_to_tensor(np.tile(np.array([gh, gw], "int32"), (batch_size, 1))) + feed[n] = ops.convert_to_tensor( + np.tile(np.array([gh, gw], "int32"), (batch_size, 1)) + ) elif n == "image_sizes": # Pixtral-style variable resolution: the true (H, W) of each image, # which must equal the fed pixel_values' spatial dims (non-batch, non-3). @@ -325,7 +331,9 @@ def multimodal_vlm_input(model, batch_size=2, seq_len=6, vocab_size=128): if pv else [spatial_default, spatial_default] ) - feed[n] = ops.convert_to_tensor(np.tile(np.array(hw, "int32"), (batch_size, 1))) + feed[n] = ops.convert_to_tensor( + np.tile(np.array(hw, "int32"), (batch_size, 1)) + ) elif "pixel" in n: if len(sh) == 2: feed[n] = ops.ones((batch_size * n_patches, sh[1])) diff --git a/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py b/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py index c9b1e077..cd12349b 100644 --- a/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py +++ b/zeromodels/models/efficientdet/convert_efficientdet_h5_to_keras.py @@ -105,11 +105,7 @@ def map_backbone_block(path, bb_prefix, block_n, has_expand): elif sub == "batchnorm_2": # depthwise BN tgt = "tpu_batch_normalization_1" if has_expand else "tpu_batch_normalization" elif sub == "batchnorm_3": # project BN - tgt = ( - "tpu_batch_normalization_2" - if has_expand - else "tpu_batch_normalization_1" - ) + tgt = "tpu_batch_normalization_2" if has_expand else "tpu_batch_normalization_1" else: raise ValueError(f"unmapped block sublayer {sub!r} in {path}") return f"{bb_prefix}/blocks_{block_n}/{tgt}/{var}" @@ -161,9 +157,7 @@ def transfer_efficientdet_weights(keras_model, h5_path, backbone=None): transferred = 0 with h5py.File(h5_path, "r") as f: for w in keras_model.weights: - key = keras_path_to_h5( - w.path, bb_prefix, order, expand_flags, num_levels - ) + key = keras_path_to_h5(w.path, bb_prefix, order, expand_flags, num_levels) if key is None: continue dataset = key + ":0" diff --git a/zeromodels/models/efficientdet/efficientdet_image_processor.py b/zeromodels/models/efficientdet/efficientdet_image_processor.py index 97732e5a..5dc132d6 100644 --- a/zeromodels/models/efficientdet/efficientdet_image_processor.py +++ b/zeromodels/models/efficientdet/efficientdet_image_processor.py @@ -157,21 +157,20 @@ def post_process_object_detection( max_detections=max_detections, class_agnostic=class_agnostic, ) - detections = ops.convert_to_numpy(nms(outputs["boxes"], outputs["scores"])) - # COCO ids are 1-based (index 0 is "N/A"), so the default list is offset by 1; - # custom label_names are indexed directly by the 0-based class id. + detections = nms(outputs["boxes"], outputs["scores"]) if label_names is None: names, offset = COCO_91_CLASSES, 1 else: names, offset = label_names, 0 results = [] - for i in range(detections.shape[0]): + for i in range(int(detections.shape[0])): det = detections[i] - det = det[det[:, 4] > 0.0] + num_valid = int(ops.sum(ops.cast(det[:, 4] > 0.0, "int32"))) + det = det[:num_valid] ymin, xmin, ymax, xmax = det[:, 0], det[:, 1], det[:, 2], det[:, 3] scores = det[:, 4] - labels = det[:, 5].astype("int32") + labels = ops.cast(det[:, 5], "int32") if target_sizes is not None: orig_h, orig_w = target_sizes[i] scale = self.image_size / float(max(orig_h, orig_w)) @@ -181,21 +180,21 @@ def post_process_object_detection( ymax / scale, xmax / scale, ) - ymin = np.clip(ymin, 0, orig_h) - ymax = np.clip(ymax, 0, orig_h) - xmin = np.clip(xmin, 0, orig_w) - xmax = np.clip(xmax, 0, orig_w) - boxes_xyxy = np.stack([xmin, ymin, xmax, ymax], axis=-1) + ymin = ops.clip(ymin, 0, orig_h) + ymax = ops.clip(ymax, 0, orig_h) + xmin = ops.clip(xmin, 0, orig_w) + xmax = ops.clip(xmax, 0, orig_w) + boxes_xyxy = ops.stack([xmin, ymin, xmax, ymax], axis=-1) mapped = [ names[c + offset] if (c + offset) < len(names) else f"class_{c}" - for c in labels + for c in (int(x) for x in labels) ] results.append( { - "scores": scores, - "labels": labels, + "scores": ops.convert_to_numpy(scores), + "labels": ops.convert_to_numpy(labels), "label_names": mapped, - "boxes": boxes_xyxy, + "boxes": ops.convert_to_numpy(boxes_xyxy), } ) return results diff --git a/zeromodels/models/efficientdet/efficientdet_layers.py b/zeromodels/models/efficientdet/efficientdet_layers.py index 62e12528..33244f30 100644 --- a/zeromodels/models/efficientdet/efficientdet_layers.py +++ b/zeromodels/models/efficientdet/efficientdet_layers.py @@ -1,7 +1,6 @@ import math import keras -import numpy as np from keras import layers, ops from zeromodels.utils.image_util import get_data_format @@ -452,10 +451,6 @@ def generate_anchor_boxes( """Multiscale anchor boxes as ``(N, 4)`` in ``[ymin, xmin, ymax, xmax]`` pixel coordinates, ordered position-major then (octave, aspect)-minor per level, then concatenated over levels. A direct port of Google AutoML ``anchors.Anchors``.""" - if isinstance(image_size, int): - image_h = image_w = image_size - else: - image_h, image_w = image_size sizes = feat_sizes(image_size, max_level) if isinstance(anchor_scale, (list, tuple)): anchor_scales = list(anchor_scale) @@ -464,33 +459,30 @@ def generate_anchor_boxes( boxes_all = [] for level in range(min_level, max_level + 1): - stride_h = sizes[0][0] / float(sizes[level][0]) - stride_w = sizes[0][1] / float(sizes[level][1]) + feat_h, feat_w = sizes[level] + stride_h = sizes[0][0] / float(feat_h) + stride_w = sizes[0][1] / float(feat_w) + cx = (ops.arange(feat_w, dtype="float32") + 0.5) * stride_w + cy = (ops.arange(feat_h, dtype="float32") + 0.5) * stride_h + xv, yv = ops.meshgrid(cx, cy, indexing="xy") + xv, yv = ops.reshape(xv, (-1,)), ops.reshape(yv, (-1,)) boxes_level = [] for scale_octave in range(num_scales): for aspect in aspect_ratios: - base_x = anchor_scales[level - min_level] * stride_w * ( - 2 ** (scale_octave / float(num_scales)) - ) - base_y = anchor_scales[level - min_level] * stride_h * ( - 2 ** (scale_octave / float(num_scales)) - ) + octave = 2 ** (scale_octave / float(num_scales)) + base_x = anchor_scales[level - min_level] * stride_w * octave + base_y = anchor_scales[level - min_level] * stride_h * octave aspect_x = math.sqrt(aspect) aspect_y = 1.0 / aspect_x half_x = base_x * aspect_x / 2.0 half_y = base_y * aspect_y / 2.0 - x = np.arange(stride_w / 2, image_w, stride_w) - y = np.arange(stride_h / 2, image_h, stride_h) - xv, yv = np.meshgrid(x, y) - xv, yv = xv.reshape(-1), yv.reshape(-1) - boxes = np.vstack( - (yv - half_y, xv - half_x, yv + half_y, xv + half_x) + boxes = ops.stack( + [yv - half_y, xv - half_x, yv + half_y, xv + half_x], axis=-1 ) - boxes = np.swapaxes(boxes, 0, 1) - boxes_level.append(np.expand_dims(boxes, axis=1)) - boxes_level = np.concatenate(boxes_level, axis=1) - boxes_all.append(boxes_level.reshape([-1, 4])) - return np.vstack(boxes_all).astype("float32") + boxes_level.append(ops.expand_dims(boxes, axis=1)) + boxes_level = ops.concatenate(boxes_level, axis=1) + boxes_all.append(ops.reshape(boxes_level, (-1, 4))) + return ops.cast(ops.concatenate(boxes_all, axis=0), "float32") def decode_box_outputs(pred_boxes, anchor_boxes): @@ -546,7 +538,7 @@ def __init__( self.aspect_ratios = tuple(aspect_ratios) self.anchor_scale = anchor_scale self.image_size = image_size - self.anchors_np = generate_anchor_boxes( + self.anchors = generate_anchor_boxes( min_level, max_level, num_scales, aspect_ratios, anchor_scale, image_size ) @@ -557,8 +549,9 @@ def call(self, box_outputs): # Anchors are a fixed function of the config, so they are baked into the graph # as a constant rather than stored as a weight. This keeps EfficientDetDetect's # weight set identical to EfficientDetModel's, so both load one hosted file. - anchors = ops.convert_to_tensor(self.anchors_np, dtype=box_outputs.dtype) - return decode_box_outputs(box_outputs, anchors) + return decode_box_outputs( + box_outputs, ops.cast(self.anchors, box_outputs.dtype) + ) def compute_output_shape(self, input_shape): return input_shape @@ -580,28 +573,37 @@ def get_config(self): def iou_against(box, boxes): """IoU of one ``[ymin, xmin, ymax, xmax]`` box against an array of boxes.""" - ymin = np.maximum(box[0], boxes[:, 0]) - xmin = np.maximum(box[1], boxes[:, 1]) - ymax = np.minimum(box[2], boxes[:, 2]) - xmax = np.minimum(box[3], boxes[:, 3]) - inter = np.maximum(0.0, ymax - ymin) * np.maximum(0.0, xmax - xmin) + ymin = ops.maximum(box[0], boxes[:, 0]) + xmin = ops.maximum(box[1], boxes[:, 1]) + ymax = ops.minimum(box[2], boxes[:, 2]) + xmax = ops.minimum(box[3], boxes[:, 3]) + inter = ops.maximum(0.0, ymax - ymin) * ops.maximum(0.0, xmax - xmin) area = (box[2] - box[0]) * (box[3] - box[1]) areas = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]) return inter / (area + areas - inter + 1e-8) -def greedy_nms(boxes, scores, iou_threshold, max_output): - """Greedy hard NMS. Returns kept indices (highest score first).""" - order = scores.argsort()[::-1] +def greedy_nms(boxes, scores, iou_threshold, score_threshold, max_output): + """Greedy hard NMS. Walks boxes in descending score order, keeps one and suppresses + everything it overlaps by more than ``iou_threshold``, and stops once the score drops + to ``score_threshold`` (scores are sorted, so nothing later can clear it). Returns the + kept indices, highest score first.""" + order = ops.argsort(-scores) + total = int(order.shape[0]) + suppressed = ops.zeros((total,), dtype="bool") keep = [] - while order.size > 0 and len(keep) < max_output: - i = order[0] - keep.append(i) - if order.size == 1: + for rank in range(total): + idx = int(order[rank]) + if float(scores[idx]) <= score_threshold: + break + if bool(suppressed[idx]): + continue + keep.append(idx) + if len(keep) >= max_output: break - rest = order[1:] - overlap = iou_against(boxes[i], boxes[rest]) - order = rest[overlap <= iou_threshold] + suppressed = ops.logical_or( + suppressed, iou_against(boxes[idx], boxes) > iou_threshold + ) return keep @@ -641,56 +643,86 @@ def __init__( def top_k_prefilter(self, boxes, scores): """Keep the ``pre_nms_top_k`` anchors with the highest best-class score.""" - best = scores.max(axis=-1) - if best.shape[0] > self.pre_nms_top_k: - top = np.argpartition(-best, self.pre_nms_top_k)[: self.pre_nms_top_k] - return boxes[top], scores[top] + best = ops.max(scores, axis=-1) + if int(best.shape[0]) > self.pre_nms_top_k: + top = ops.top_k(best, self.pre_nms_top_k)[1] + return ops.take(boxes, top, axis=0), ops.take(scores, top, axis=0) return boxes, scores def detections_global(self, boxes, scores): """Class-agnostic: one best class per anchor, then a single NMS.""" - class_ids = scores.argmax(axis=-1) - class_scores = scores.max(axis=-1) - mask = class_scores > self.score_threshold - if not mask.any(): - return [] - bx, sc, cl = boxes[mask], class_scores[mask], class_ids[mask] - keep = greedy_nms(bx, sc, self.iou_threshold, self.max_detections) + class_ids = ops.argmax(scores, axis=-1) + class_scores = ops.max(scores, axis=-1) + keep = greedy_nms( + boxes, + class_scores, + self.iou_threshold, + self.score_threshold, + self.max_detections, + ) return [ - (bx[k][0], bx[k][1], bx[k][2], bx[k][3], sc[k], float(cl[k])) for k in keep + ( + boxes[k][0], + boxes[k][1], + boxes[k][2], + boxes[k][3], + class_scores[k], + ops.cast(class_ids[k], "float32"), + ) + for k in keep ] def detections_per_class(self, boxes, scores): """Independent NMS per class.""" dets = [] - for c in range(scores.shape[-1]): + for c in range(int(scores.shape[-1])): cls_scores = scores[:, c] - mask = cls_scores > self.score_threshold - if not mask.any(): - continue - bx, sc = boxes[mask], cls_scores[mask] - keep = greedy_nms(bx, sc, self.iou_threshold, self.max_detections) + keep = greedy_nms( + boxes, + cls_scores, + self.iou_threshold, + self.score_threshold, + self.max_detections, + ) dets.extend( - (bx[k][0], bx[k][1], bx[k][2], bx[k][3], sc[k], float(c)) for k in keep + ( + boxes[k][0], + boxes[k][1], + boxes[k][2], + boxes[k][3], + cls_scores[k], + float(c), + ) + for k in keep ) return dets + def pad_detections(self, dets): + """Sort by score and pad the detection tuples to ``(max_detections, 6)``.""" + if not dets: + return ops.zeros((self.max_detections, 6), dtype="float32") + dets = sorted(dets, key=lambda d: float(d[4]), reverse=True) + dets = dets[: self.max_detections] + rows = ops.stack( + [ops.stack([ops.cast(v, "float32") for v in d]) for d in dets], axis=0 + ) + pad = self.max_detections - int(rows.shape[0]) + if pad > 0: + rows = ops.concatenate([rows, ops.zeros((pad, 6), dtype="float32")], axis=0) + return rows + def call(self, boxes, scores): - boxes = ops.convert_to_numpy(ops.convert_to_tensor(boxes)) - scores = ops.convert_to_numpy(ops.convert_to_tensor(scores)) - batch = boxes.shape[0] - out = np.zeros((batch, self.max_detections, 6), dtype="float32") - for b in range(batch): + boxes = ops.convert_to_tensor(boxes) + scores = ops.convert_to_tensor(scores) + results = [] + for b in range(int(boxes.shape[0])): bx, sc = self.top_k_prefilter(boxes[b], scores[b]) if self.class_agnostic: dets = self.detections_global(bx, sc) else: dets = self.detections_per_class(bx, sc) - if dets: - dets.sort(key=lambda d: d[4], reverse=True) - dets = dets[: self.max_detections] - out[b, : len(dets)] = np.array(dets, dtype="float32") - return ops.convert_to_tensor(out) + results.append(self.pad_detections(dets)) + return ops.stack(results, axis=0) def compute_output_shape(self, boxes_shape, scores_shape): return (boxes_shape[0], self.max_detections, 6)