Template-Aware Dynamic Convolution Module (TDCM)

• Template-Aware Dynamic Convolution Module is a mechanism that transforms structured template signals into adaptive convolution kernels for feature extraction.
• It leverages various template representations—from explicit exemplar features to learned spatial priors—to condition filtering operations for tasks like pose estimation and segmentation.
• Empirical studies show that TDCM improves localization, segmentation, and detection efficiency compared to traditional fixed-kernel approaches.

Searching arXiv for papers on template-aware dynamic convolution and closely related dynamic convolution mechanisms. Template-Aware Dynamic Convolution Module (TDCM) denotes a class of conditional convolution mechanisms in which a structured prior, template, hypothesis, or support-derived descriptor parameterizes the filtering operator applied to another feature map. Across recent literature, the term covers several closely related designs rather than a single canonical formulation. In the most explicit usage, TDCM is a dual-input matcher in which template features are directly instantiated as depthwise convolution kernels for search-image features, enabling joint localization and in-plane pose estimation (Jia et al., 2 Oct 2025). More broadly, related systems implement the same underlying principle by deriving dynamic kernels from Hough-space lane hypotheses (Zhang et al., 2023), masked support foreground prototypes in few-shot segmentation (Liu et al., 2022), or static spatial layout priors (Chen et al., 2022). Taken together, these works define TDCM as a mechanism that replaces fixed convolutional weights with template-conditioned operators, thereby coupling structured prior knowledge with sample-adaptive feature extraction.

1. Conceptual definition and scope

A TDCM is most precisely defined by the source of its conditioning signal. In ordinary dynamic convolution, an input feature map produces coefficients or kernels that modulate the convolution applied to that same or another feature map. In a template-aware variant, the conditioning variable is not merely generic input content; it is a template-bearing representation such as a support foreground prototype, a Hough-line hypothesis, a learned spatial layout prior, or an explicit template image (Chen et al., 2019).

The most explicit formulation appears in "An Efficient Deep Template Matching and In-Plane Pose Estimation Method via Template-Aware Dynamic Convolution" (Jia et al., 2 Oct 2025). There, the network predicts a full in-plane pose

$(x_c, y_c, \theta, s_x, s_y),$

and TDCM is the core operator that injects the template at inference time. Template and search image are encoded into shallow feature maps

$$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$

and each channel slice of the template feature acts as a depthwise kernel over the corresponding search-feature channel: $R(c) = F_t(c) * F_i(c).$ This makes the module template-conditioned in a literal sense: the kernel is the template feature itself (Jia et al., 2 Oct 2025).

Other papers implement the same principle under different names. HoughLaneNet uses selected Hough-space lane descriptors $f_h^i$ to regress a per-lane dynamic convolution kernel

$$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$

so the "template" is a Hough-line hypothesis $(\theta,r)$ together with its learned descriptor (Zhang et al., 2023). Dynamic Prototype Convolution Network (DPCN) extracts support foreground vectors $P_{fg}$, compresses them into prototype sequences, and generates anisotropic and isotropic dynamic kernels for few-shot segmentation (Liu et al., 2022). TVConv replaces sample-conditioned templates with learned spatial affinity maps that define position-specific kernels shared across images in layout-consistent domains, which is effectively a task-level template prior (Chen et al., 2022).

This suggests a unifying interpretation: a TDCM is less a single architecture than a design pattern in which a structured conditioning representation is mapped into convolutional behavior. The representation may be explicit and per-instance, as in template matching or lane hypotheses, or implicit and task-level, as in layout-aware learned affinity maps.

2. Core mechanism: from template representation to convolution operator

The defining pipeline of a TDCM has three stages: template formation, kernel realization, and conditioned filtering. What changes across papers is the form of the template and the degree of explicitness in kernel generation.

In the direct-template regime, the template feature map itself is the kernel. The pose-estimation TDCM applies template-conditioned dynamic depthwise convolution channel by channel: $R(c) = F_t(c) * F_i(c),$ followed by pointwise $1\times1$ fusion and pixel shuffle upsampling before dense geometric prediction (Jia et al., 2 Oct 2025). The module is therefore not a hypernetwork in the usual sense; it does not regress kernels through a separate MLP. Rather, it instantiates them directly from template features.

In the descriptor-to-kernel regime, a compact template embedding is first produced and then mapped to kernel parameters. HoughLaneNet is explicit that “the dynamic convolution contains one layer of 2D convolution, and its kernel parameters are mainly obtained by the selected Hough features $f_h^*$ which are fed into a multi-layer perception (MLP) to regress the parameters” (Zhang et al., 2023). For each lane hypothesis,

$$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$0

Here the template is not a stored exemplar but a geometry-aware descriptor harvested from Hough space after global line aggregation (Zhang et al., 2023).

DPCN uses a similar descriptor-to-kernel process, but the template comes from masked support foreground in few-shot segmentation. Support foreground vectors are extracted as

$$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$1

compressed into prototype sequences

$$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$2

and then transformed into three dynamic kernels: $$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$3 These are then applied to the filtered query feature $$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$4 to produce $$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$5 (Liu et al., 2022). This mechanism is template-aware because the support foreground, isolated by the support mask, is the source of the operator itself.

A third regime replaces sample-specific templates with shared task priors. TVConv defines a learned spatial latent code

$$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$6

and a weight-generating block $$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$7 that produces location-specific kernels

$$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$8

The resulting operator is translation variant across space but shared across images (Chen et al., 2022). This suggests a broader category boundary for TDCM: template awareness may refer not only to per-sample exemplars but also to learned structural template maps when the domain has stable spatial semantics.

3. Template representations used in the literature

The literature supports several distinct template types, each aligned with a different problem setting. Their differences matter because they determine whether the module behaves as instance-conditioned matching, prototype-conditioned segmentation, or layout-conditioned filtering.

Template type	Representative paper	Conditioning source
Explicit template image feature	(Jia et al., 2 Oct 2025)	$$F_t \in \mathbb{R}^{C \times \frac{H_t}{4} \times \frac{W_t}{4}}, \qquad F_i \in \mathbb{R}^{C \times \frac{H}{4} \times \frac{W}{4}},$$9 from template image
Hough-space instance hypothesis	(Zhang et al., 2023)	selected Hough feature $R(c) = F_t(c) * F_i(c).$0
Support foreground prototype	(Liu et al., 2022)	$R(c) = F_t(c) * F_i(c).$1, $R(c) = F_t(c) * F_i(c).$2, $R(c) = F_t(c) * F_i(c).$3
Learned spatial layout prior	(Chen et al., 2022)	affinity maps $R(c) = F_t(c) * F_i(c).$4
Static kernel prior guiding dynamic kernel	(Xing et al., 2024)	reshaped static kernels $R(c) = F_t(c) * F_i(c).$5

The explicit-template form is characteristic of deep template matching. The TDCM in (Jia et al., 2 Oct 2025) is designed for industrial inspection and component alignment, where a search image must be matched against a supplied exemplar under compound transformations. Because the template varies at inference time, direct injection of template features allows generalization to unseen templates without category-specific output heads (Jia et al., 2 Oct 2025).

The Hough-hypothesis form is geometry-driven. In HoughLaneNet, points on approximately straight lanes collapse to compact regions in Hough space under the relation

$R(c) = F_t(c) * F_i(c).$6

Selected peaks correspond to lane instances, and the associated features $R(c) = F_t(c) * F_i(c).$7 serve as template-like descriptors. The paper repeatedly describes the dynamic convolution as “using the Hough feature as a prior knowledge” and exploiting “the geometry prior of the commonly straight lane shape” (Zhang et al., 2023). This suggests that a template need not be an image patch; it may be a parameter-space hypothesis endowed with global structural evidence.

The support-prototype form is episodic and class-conditioned. DPCN isolates support foreground with the support mask $R(c) = F_t(c) * F_i(c).$8, refines query localization through SAM and FFM, and then generates kernels from the support foreground representation (Liu et al., 2022). In TDCM terms, the support foreground is a template not because it is a single averaged vector, but because it is transformed into a bank of convolution operators.

The learned-layout form in TVConv is distinct. There is no support/query pair and no per-sample template. Instead, the task distribution itself is assumed to exhibit “large intra-image (spatial) variance and small cross-image variance,” and the learned affinity maps encode a stable template over positions (Chen et al., 2022). This is appropriate for aligned faces, retinal fundus images, and other layout-consistent domains.

The static-guided form in SGDM occupies an intermediate position. It is not a full template bank, but the static asymmetric kernels $R(c) = F_t(c) * F_i(c).$9 and $f_h^i$0 are shared across samples and used to guide the sample-specific dynamic kernel: $f_h^i$1 This can be interpreted as template-aware dynamic convolution in which reusable static kernels provide structural priors for the dynamic branch (Xing et al., 2024).

4. Architectural patterns and mathematical formulations

Despite diverse applications, TDCM implementations share recurring structural motifs: lightweight kernel synthesis, separation of conditioning and target branches, and preservation of a standard convolutional execution path after conditioning.

A foundational reference is "Dynamic Convolution: Attention over Convolution Kernels" (Chen et al., 2019), which formulates dynamic convolution as convex aggregation of a small kernel bank: $f_h^i$2 with

$f_h^i$3

Although this paper is not template-aware in itself, it provides the most reusable formalism for TDCM: template conditioning can replace or augment the self-conditioned routing function $f_h^i$4 (Chen et al., 2019).

A second recurring pattern is residual decomposition in kernel space. The supplied content for Dynamic Mobile-Former is incomplete, but the inferred formulation

$f_h^i$5

captures the idea of a static input-agnostic kernel plus an input-dependent kernel residual (Yun et al., 2023). This suggests a plausible TDCM extension in which a template or prior defines $f_h^i$6, while sample-conditioned adaptation defines $f_h^i$7. A related idea is explicit in SGDM, where static kernels modulate the dynamic kernel rather than being added to it (Xing et al., 2024).

The direct-template TDCM in (Jia et al., 2 Oct 2025) follows a depthwise–pointwise pattern. First, template features act as dynamic depthwise kernels: $f_h^i$8 Then the per-channel response maps are concatenated, fused by $f_h^i$9 convolution, and upsampled by pixel shuffle before task-specific heads predict the center heatmap and geometry maps (Jia et al., 2 Oct 2025). This design is intentionally shallow and avoids feature pyramids, transformer attention, or correlation volumes.

The prototype-kernel pattern in DPCN is explicitly multi-shape. Vertical, horizontal, and square kernels are generated independently and applied in parallel: $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$0 The outputs are concatenated with support-guided priors and passed through $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$1 for final segmentation (Liu et al., 2022). This multi-shape kernel bank is one of the clearest architectural principles in the TDCM literature.

TVConv demonstrates that the dynamic generator need not be input-conditioned at inference. Because the affinity maps $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$2 are learned parameters rather than sample-derived features, the weight-generating block $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$3 can be overparameterized during training and then removed from the online graph after caching

$$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$4

once (Chen et al., 2022). A plausible implication is that some TDCM designs can trade runtime adaptivity for training-time template capacity when the template is domain-level rather than instance-level.

5. Applications and empirical behavior

TDCM-style mechanisms have been developed in lane detection, few-shot segmentation, template matching, layout-aware recognition, and dense detection. Their empirical behavior is consistent: performance gains arise when a fixed kernel is poorly matched to input-dependent structure, but the conditioning signal itself remains informative and compact.

In lane detection, HoughLaneNet uses dynamic convolution as the instance separation mechanism after Hough-space proposal. The Hough map detects lane count and rough location, but precise localization is deferred to Euclidean space, where the dynamic kernel generated from each selected Hough feature segments the corresponding lane (Zhang et al., 2023). On CULane, the ablation sequence Baseline $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$5 F1, +S-DHT $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$6, +H-Decoder $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$7, +M-DHT $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$8, +RHT $$W_i = \mathrm{MLP}(f_h^i), \qquad f_l^i = \mathrm{Conv}(f_m; W_i),$$9 shows that most gains come from improving the Hough conditioning signal rather than from inventing dynamic convolution itself (Zhang et al., 2023). The baseline already contains the dynamic convolution structure and is described as “more effective in distinguishing different lanes compared to outputting multiple channels.” This clarifies a frequent misconception: in such systems, the dynamic module is rarely the proposal mechanism; it is the conditioned separator or refiner.

In few-shot segmentation, DPCN reports that adding DCM yields the largest single gain in the component ablation on PASCAL-$(\theta,r)$0 with ResNet-50 and 1-shot: SAM+FFM without DCM reaches 64.5 mIoU, while full DPCN reaches 66.7 (Liu et al., 2022). Kernel-shape ablations are especially revealing: using only $(\theta,r)$1 gives 65.0, only $(\theta,r)$2 gives 65.2, both asymmetric $(\theta,r)$3 gives 64.7, and combining $(\theta,r)$4 gives 66.7 (Liu et al., 2022). This shows that template-aware dynamic filtering benefits from a heterogeneous kernel bank when objects contain both compact and elongated structures.

In direct template matching, the TDCM-based pose estimator in (Jia et al., 2 Oct 2025) uses only ConvNeXt-V2-Tiny Stage-1 features, yet reports a 3.07M model and about 13.8–14.7 ms per image pair on CPU. Under S2.5, Ours achieves mIoU $(\theta,r)$5 in $(\theta,r)$6 ms, compared with SHM $(\theta,r)$7 in $(\theta,r)$8 ms, NCC $(\theta,r)$9 in $P_{fg}$0 ms, and Fast-Match $P_{fg}$1 in $P_{fg}$2 ms (Jia et al., 2 Oct 2025). This supports the central deployment claim of TDCM: direct template-conditioned convolution can replace exhaustive angle/scale enumeration while preserving the intuition of template matching.

In layout-aware recognition and medical segmentation, TVConv shows that a fixed spatial template can outperform per-image dynamicity when cross-image variance is small. On MobileNetV2 ×0.1, depthwise convolution gives mean accuracy $P_{fg}$3, whereas TVConv gives $P_{fg}$4, a gain of 4.21 percentage points; throughput on Raspberry Pi 4B improves by up to 2.3× relative to matched-accuracy baselines (Chen et al., 2022). This suggests that not all TDCM instances should be sample-conditioned; when alignment is strong, a learned template prior shared across images may dominate.

In object detection, SGDM demonstrates that static-guided dynamic convolution can be inserted before detector outputs with modest overhead. On VOC, YOLOv5n improves from AP $P_{fg}$5 to $P_{fg}$6, and YOLOv8n from $P_{fg}$7 to $P_{fg}$8 when equipped with SGDM (Xing et al., 2024). On COCO, YOLOv5n improves from AP $P_{fg}$9 to $R(c) = F_t(c) * F_i(c),$0, and YOLOv8n from $R(c) = F_t(c) * F_i(c),$1 to $R(c) = F_t(c) * F_i(c),$2, with negligible latency increase (Xing et al., 2024). These results suggest that template-aware guidance in kernel space can regularize dynamic convolution for dense prediction, especially where localization and robustness to high-frequency noise matter.

6. Design trade-offs, ambiguities, and limitations

The TDCM literature is conceptually coherent but implementation-specific. A recurrent limitation is under-specification of the dynamic kernel branch. HoughLaneNet explicitly omits kernel size, convolution type, bias generation, and exact channel reshaping for its dynamic module (Zhang et al., 2023). DPCN leaves ambiguous the exact implementation of foreground extraction $R(c) = F_t(c) * F_i(c),$3, the type of 1D pooling that produces $R(c) = F_t(c) * F_i(c),$4 and $R(c) = F_t(c) * F_i(c),$5, and whether the dynamic convolution is depthwise, grouped, or standard (Liu et al., 2022). The direct-template TDCM in (Jia et al., 2 Oct 2025) does not provide the exact decoder head structure, precise batch handling for per-sample kernels, or the exact reconstruction of $R(c) = F_t(c) * F_i(c),$6 from $R(c) = F_t(c) * F_i(c),$7 and $R(c) = F_t(c) * F_i(c),$8. These gaps are material for reproduction.

A second trade-off concerns the meaning of “template.” In some works it denotes an explicit exemplar image (Jia et al., 2 Oct 2025); in others a support foreground set (Liu et al., 2022), a Hough-space instance hypothesis (Zhang et al., 2023), or a learned spatial latent prior (Chen et al., 2022). This breadth is productive but also a source of confusion. A strict reading would reserve TDCM for modules conditioned on an external or explicit template. A broader systems reading includes any structured prior that parameterizes the operator. The literature supports the broader interpretation, but applications differ substantially depending on whether the template is sample-specific, episode-specific, or task-level.

A third trade-off is between expressiveness and efficiency. Full dynamic kernel generation is powerful but often expensive or unstable. Dynamic Convolution mitigates this with a small kernel bank and convex attention weights $R(c) = F_t(c) * F_i(c),$9 (Chen et al., 2019). SGDM reduces cost through Razor Operation and partial-channel dynamicity (Xing et al., 2024). TVConv shifts most complexity to training-time kernel generation and caches the position-specific weights for inference (Chen et al., 2022). These designs imply that TDCM should not be equated with unrestricted hypernetwork-based convolution; most successful variants impose structure on the conditioning path.

A fourth issue is robustness. SGDM explicitly argues that dynamic convolution is sensitive to high-frequency noise and uses static shared kernels to stabilize it (Xing et al., 2024). TVConv degrades toward vanilla depthwise convolution under severe translation, reflecting its reliance on a stable layout template (Chen et al., 2022). The template-matching TDCM notes failure modes including low-texture templates, extremely tiny templates, severe aspect-ratio distortions, and clutter with similar distractors (Jia et al., 2 Oct 2025). These cases indicate that template-aware conditioning helps only when the template signal is informative and the domain assumptions hold.

A fifth issue is the degree of spatial adaptivity. DPCN’s kernels are episode-specific but shared across the whole query image, not spatially adaptive across query positions (Liu et al., 2022). The direct-template TDCM likewise applies one channel-wise template kernel over the search feature map (Jia et al., 2 Oct 2025). TVConv is the opposite extreme: kernels vary by spatial location but are shared across images (Chen et al., 2022). This suggests two orthogonal axes for TDCM taxonomy: adaptation across samples and adaptation across positions.

7. Relation to neighboring paradigms

TDCM is adjacent to several established paradigms but is not reducible to any single one. Relative to static convolution, it abandons the assumption that one kernel suffices for all instances or all positions. Relative to attention, it performs adaptation in operator space rather than solely in feature reweighting space. Relative to deformable convolution, it adapts weights or effective templates rather than sampling offsets. Relative to prototype matching, it uses the prototype to parameterize the operator, not merely to score similarities.

Dynamic Convolution (Chen et al., 2019) is the clearest ancestor in kernel-space adaptation, but it is self-conditioned rather than template-conditioned. A template-aware extension replaces $1\times1$0 with $1\times1$1, where $1\times1$2 may be a template embedding, support descriptor, or parameter-space hypothesis. This change is conceptually small but operationally significant because it converts adaptive convolution from content modulation to cross-input matching.

DPCN differs from plain prototype-based few-shot segmentation by replacing cosine similarity and concatenation with support-conditioned dynamic kernels (Liu et al., 2022). The support does not merely gate query features; it defines the local filter applied to them. HoughLaneNet differs from attention-based global context models by grounding its conditioning in an explicit line-geometry prior rather than generic self-attention (Zhang et al., 2023). TVConv differs from per-image dynamic convolution by replacing input-conditioned kernels with fixed learned spatial templates, which is advantageous when cross-image variance is low (Chen et al., 2022). SGDM differs from standard dynamic kernel mixtures by injecting static kernel priors directly into kernel space (Xing et al., 2024).

A plausible synthesis is that TDCM occupies the midpoint between template matching and dynamic operator learning. Its essential move is to turn a template from a passive reference into an active parameter of the convolutional operator. Whether the template is explicit, episodic, geometric, or task-level, the common effect is to make filtering hypothesis-aware.

The development trajectory also suggests a widening notion of what counts as a template. Earlier dynamic convolution work establishes efficient kernel aggregation (Chen et al., 2019). Later systems specialize the conditioning signal: Hough hypotheses for lane instances (Zhang et al., 2023), support foreground for few-shot structure preservation (Liu et al., 2022), spatial affinity maps for aligned domains (Chen et al., 2022), and direct exemplar features for industrial pose-aware matching (Jia et al., 2 Oct 2025). This suggests that the most stable definition of TDCM is functional rather than nominal: a module is template-aware when its convolutional behavior is parameterized by a structured prior that encodes what should be matched, segmented, or localized.

In that sense, TDCM is not a narrow architectural block but a convergent pattern in modern vision systems: instantiate a template or prior, map it into an operator, and apply that operator to shared features to obtain instance-sensitive, geometry-sensitive, or layout-sensitive responses.