Neural Architecture Description Language (NADL)

• NADL is a domain-specific language that specifies neural network architectures through explicit computational graphs, modular composition, and configurable search spaces.
• It enables streamlined NAS integration and compilation workflows that transform high-level blueprints into deployable models in frameworks like PyTorch and TensorFlow.
• Its extensibility via user-defined modules and constraints supports both automated and LLM-driven architecture synthesis for diverse applications.

The Neural Architecture Description Language (NADL) is a domain-specific language for specifying neural network architectures as explicit computational graphs, modular compositions, and algorithmic search spaces. NADL is used both as a single-shot architecture blueprinting language in LLM-driven synthesis workflows for object detection, and as a programmable encoding for search spaces in modular neural architecture search (NAS) frameworks. Its key abstractions, operational semantics, and extensibility features enable direct translation from high-level architectural reasoning to deployable models and search-space definitions (Zhao, 13 Dec 2025, Negrinho et al., 2019).

1. Formal Structure and Syntax

NADL “blueprints” are structured as JSON objects or symbolic graph constructs that formally declare three principal elements:

• Input shape: An explicit array $[C, H, W]$ representing input channels and spatial dimensions.
• Module set: Named, typed blocks specifying component categories (e.g., Backbone, Neck, Head) coupled with a parameter dictionary.
• Directed connections: Explicit edges encoding the data flow between modules.

A BNF-style meta-syntax for an object detection blueprint is: $$\begin{array}{lcl} \langle\mathrm{Blueprint}\rangle &::=& \{ \text{\tt"input\_shape"}: \langle\mathrm{Shape}\rangle, \text{\tt"modules"}: [\,\langle\mathrm{Module}\rangle^+\,], \text{\tt"connections"}: [\,\langle\mathrm{Connection}\rangle^*\,] \} \ \langle\mathrm{Module}\rangle &::=& \{ \text{\tt"name"}: \langle\mathrm{ID}\rangle, \text{\tt"category"}: \langle\mathrm{Category}\rangle, \text{\tt"type"}: \langle\mathrm{Type}\rangle, \text{\tt"params"}: \langle\mathrm{ParamMap}\rangle \} \ \langle\mathrm{ParamMap}\rangle &::=& \{\;\langle\mathrm{ID}\rangle:\langle\mathrm{Value}\rangle\;(,\;\dots)\;\}\ \langle\mathrm{Connection}\rangle &::=& \{\;\text{\tt"from"}:\langle\mathrm{ID}\rangle, \text{\tt"to"}:\langle\mathrm{ID}\rangle\;\} \end{array}$$

In NAS settings, NADL describes a labeled, directed graph $G$, where nodes are basic modules (operations) or substitution modules (placeholders expanded after hyperparameter resolution). Edges encode wiring between module inputs and outputs. Hyperparameters live “on the graph” and are classified as independent (with explicit domains) or dependent (defined algorithmically in terms of others) (Negrinho et al., 2019).

2. Semantic Interpretation and Parameterization

Each NADL module is semantically grounded to conventional neural network primitives:

• Backbone modules are feature extractors (e.g., CSP, C2f, Transformer blocks).
• Neck modules fuse multi-scale features (e.g., FPNs, BiFusion, RepC3).
• Head modules perform prediction (e.g., Detect_AFPN, RTDETRDecoder).

Module parameters obey standard neural network formulas. For instance, convolutional output dimensions are computed as: $$H_{\rm out} = \left\lfloor \frac{H_{\rm in} + 2p - k}{s} \right\rfloor + 1$$

$$W_{\rm out} = \left\lfloor \frac{W_{\rm in} + 2p - k}{s} \right\rfloor + 1$$

Detection heads may encode anchor priors as $\{(w_i,h_i)\}_{i=1}^K$, with $w_i = s_i\sqrt{r_i}$, $h_i = s_i/\sqrt{r_i}$ driven by scale $s_i$ and aspect ratio $r_i$ parameters.

In programmable NAS, module properties are parameterized by (possibly dependent) hyperparameters. For example, in a ResNet bottleneck block, the expansion $e$ is computed as $e=4b$ where $b$ is a sampled width, directly enabling automated search-space specification (Negrinho et al., 2019).

3. Compilation and Operational Semantics

NADL supports compilation workflows targeting both static deployment and NAS pipeline integration.

Cognitive-YOLO LLM-Driven Synthesis Pipeline

1. Parsing & Static Validation: The emitted JSON NADL is parsed to an AST. The system enforces validity of module references, parameter types, and connection targets.
2. Rule-Based Backend (Ultralytics): NADL blueprints are mapped to Ultralytics-style YAML, with sections for backbone, neck, and head.
3. Code Generation (PyTorch/torch.js): A neural module is generated, instantiating each module from a registry and wiring connections based on topological ordering.

   class NADLModel(nn.Module): def __init__(self): ... def forward(self, x): ...

4. Automated Validation: Upon successful instantiation, CI/CD pipelines trigger model training and evaluation (Zhao, 13 Dec 2025).

Search-Space Instantiation and Searcher API

NADL as a search-space language supports:

• Transition/Assignment Semantics: A searcher iteratively assigns independent hyperparameters, triggering local evaluation and subgraph expansion for substitution modules.
• Flexible Parameter Tying: Hyperparameters can be shared across modules, enforced via closure capture.
• Terminal Space Compilation: The final resolved computational graph can be compiled to native TensorFlow/PyTorch code via a deterministic topological traversal (Negrinho et al., 2019).

4. Expressiveness and Extensibility

NADL’s design enables straightforward extensibility:

• Module Registration: New architecture blocks are registered in the compiler’s module registry and referenced by type.
• User Constraints: Blueprints can specify resource constraints (e.g., maximum FLOPs), which are enforced statically during compilation.
• Arbitrary Parameterization: Deeply nested and dynamic behaviors are expressible by leveraging NADL’s flexible ParamMap for module configuration.
• Composable Functions: Programmable modules and substitution templates enable hierarchical composition, recursive patterns, and arbitrarily deep/unbounded spaces for search (Zhao, 13 Dec 2025, Negrinho et al., 2019).

The following table summarizes NADL extensibility features:

Feature	Description	Example
Novel module addition	Register new block in MODULE_REGISTRY	"type":"AttentionX" in module definition
User-defined constraints	Annotate modules with budget constraints	"constraints": {"max_flops": 200e6}
Dynamic parameterization	Express complex/nested config structures	"params":{"dynamic_routing":{"mode":"soft"}}

5. Representative Examples

Single-Shot Architectural Blueprints

• Fire Detection (Sparse, Varying Scale):
  • "backbone":"C2f" for general feature extraction.
  • "neck":"TransformerEncoder" suppresses background noise in sparse scenes.
  • "head":"RTDETRDecoder" leverages multi-scale cross-attention, benefiting extreme scale variation.
• Rail Surface Defect (Small Targets):
  • High-res backbone ("hgnetv2_b0") for small defect sensitivity.
  • BiFusion neck for bidirectional feature aggregation.
  • Anchors tailored to expected small object sizes guide detection priors (Zhao, 13 Dec 2025).

Programmable Search Spaces

• Conv–BatchNorm–ReLU Block:
  • Every hyperparameter (filters, kernel size, stride) independently sampled.
• Bottleneck Block:
  • Employs dependent hyperparameter $e=4b$ for expansion.
• Recurrent Cell Space:
  • Composes hidden/output functions via single-input-single-output (siso) or multi-input-multi-output (mimo) combinators.

6. Comparison with Related Domain-Specific Languages

NADL distinguishes itself from other neural architecture DSLs by its explicit graph orientation, composable search-space templates, and data-first synthesis philosophy:

• YOLO-Style YAML: Linear stack, implicit wiring; NADL enables arbitrary DAGs via first-class "connections".
• Keras Functional JSON: Modular DAGs but not explicitly tied to meta-feature reasoning or multi-backend compilation.
• NNI/NAS DSLs: Emphasize mutation/search operators; NADL’s mode in Cognitive-YOLO is single-shot, not evolutionary (Zhao, 13 Dec 2025).

Additionally, NADL as presented in programmable NAS literature (Negrinho et al., 2019) provides a fixed interface for searchers (iterator/transition primitives), clear semantics, and enables mixing reusable spaces and search algorithms without glue code.

7. Empirical Assessment and Research Impact

Empirical results show NADL’s direct expressiveness and search-space compatibility:

• Concise encodings of canonical CNN and RNN spaces (e.g., Genetic-CNN, NASBench-101) with no loss of flexibility.
• Benchmarks demonstrate that once constructed, NADL search spaces and searchers are orthogonal, leading to significant reduction in engineering overhead and improved experiment throughput.
• In Cognitive-YOLO (Zhao, 13 Dec 2025), LLM-driven, data-driven architecture synthesis using NADL achieves state-of-the-art performance-per-parameter trade-off in object detection tasks.

This suggests that NADL, by unifying modular graph-based description, extensible module parameterization, and seamless compilation/search interfaces, provides an effective framework for both fully-automated and human-in-the-loop neural architecture innovation.