Latest / Embodied AI 101 / Qwen-RobotNav: A Scalable Unified Navigation Model for Agentic Robotics
Transcript
- Qwen-RobotNav: A Scalable Unified Navigation Model for Agentic Robotics. Robust autonomous navigation across diverse tasks is a long-standing challenge for embodied AI. Navigation tasks range from vision-and-language navigation (following complex language instructions in an environment) to object-goal navigation (searching for a specified object) to target tracking and even autonomous driving. Each of these tasks couples perception with movement in real-world spaces, but they differ fundamentally in how much past context and what kind of information the agent needs to retain and prioritize. For example, language-guided navigation often requires recalling distant landmarks encountered many steps ago, while tracking a moving target depends almost entirely on recent frames. Historically, navigation systems have been task-specific or used one fixed “context encoding” strategy across all tasks, leaving them brittle when shifting to new modes. The Qwen-RobotNav model, introduced by Alibaba’s Qwen team, tackles this challenge head-on by rethinking navigation not in terms of separate architectures for each task, but in terms of controllable observation context. Qwen-RobotNav is a single, multi-modal transformer model (built on the Qwen3-VL foundation) that can handle instruction-following, point-to-point navigation, object search, target tracking, and even autonomous driving – all with the same core network. Its key innovation is a parameterized interface that lets an external controller (for example, an agentic planner) dynamically configure how much visual history to consume, which viewpoints to emphasize, and which behavior mode to follow, at each step of navigation. This design makes Qwen-RobotNav a flexible “navigation primitive” that can be called repeatedly in a larger agentic system. In this article we will break down Qwen-RobotNav’s contributions, its architecture and training, the multi-task and zero-shot results it achieves in simulation, and its implications – including the first demonstrations of such a model steering a real quadruped robot in zero-shot mode. Our target audience is professional roboticists and ML researchers; we will focus on what was actually done and why it matters for deploying autonomous agents. Challenges of Unified Navigation. Before detailing the solution, it helps to understand the problem: embodied navigation is a family of tasks where an agent moves through a continuous environment based on some goal or instruction. In vision-and-language navigation (VLN), the goal is given as a natural language route description (“Go to the sofa, turn left, stop by the kitchen”), and the agent must ground that instruction in its visual observations. In point-goal navigation, the agent receives a spatial target (e.g. coordinates or a map location) and must navigate there. In object-goal navigation, it must find and reach an instance of a requested object (e.g. “Find the red mug”). In tracking, the agent follows a moving target (like “follow the man in the red shirt”). Autonomous driving is also framed here as a navigation task: given a route or high-level command, a car must plan a trajectory while handling other traffic and road constraints. All of these tasks share the same perception-planning backbone: the agent accumulates visual observations and produces a sequence of low-level actions or waypoints. But each demands a different observation strategy. As the Qwen-RobotNav paper explains, “instruction following requires retaining observations spanning dozens of prior steps to re-reference distant landmarks, whereas target tracking is governed by the most recent few frames and treats stale history as noise”. Object search can itself shift modes: during exploration a broad memory of past rooms is needed, but once it spots a likely goal, the priority becomes tight recency to approach it. No single fixed observation window or memory setting fits all these modes. Prior unified navigation models have indeed tried one architecture for many tasks. But without explicit controls, they implicitly commit to one of these behaviors and can’t easily switch at runtime. For example, a model might always use a sliding window or uniform subsampling of past frames; this works acceptably on some tasks but poorly on others, and it in effect bakes in one context strategy. Qwen-RobotNav rethinks this by making the observation context itself a first-class, configurable degree of freedom. Model Architecture. At its core, Qwen-RobotNav is a transformer-based vision-language model adapted to output navigation waypoints. It inherits most of its backbone from Qwen3-VL, a multi-view vision-language foundation model. The input to Qwen-RobotNav at each step consists of a textual instruction or sub-goal plus a stream of recent multi-camera images. The model’s job is to output a short sequence of future waypoints (a trajectory) for the agent to execute. Specifically, it predicts 8 waypoints $W={(x_k,y_k,\theta_k)}_{k=1}^8$ in sequence, each denoting a 2D position and heading. The important augmentations over the raw Qwen3-VL architecture are:. Lightweight Action Head: A small multi-layer perceptron (4 layers, hidden size 512) maps the final LLM hidden state into the 24-dimensional waypoint output (8×3). Keeping this head simple means the bulk of spatial reasoning stays within the large transformer. Vision Encoder: The vision component is a SigLIP-2 Vision Transformer with dynamic-resolution support (2D RoPE). This allows the model to allocate different token budgets (i.e. effective resolution) to each image. A patch merging step and a “DeepStack” mechanism incorporate multi-layer visual features into early LLM layers. Observation Encoding Interface: This is the real novelty. Qwen-RobotNav exposes a parameterized interface of observation settings that the caller (planner) can tweak. These settings include:. Total token budget (B): How many visual tokens (pixels) can be attended to across all cameras and timesteps (range 2048–4096 during training). Temporal decay (γ): A factor [1–3] that biases allocation toward recent frames. For γ=0, tokens are uniform; higher γ exponentially favors later timesteps. Camera weights (w_c): Multipliers that indicate relative importance of each camera view. For example, a front camera might get double weight of a rear camera. These bias which views get higher resolution. Frame sampling mode: Either random or latest. “Random” mode keeps a broad coverage of past frames across the episode; “latest” mode focuses on the most recent history. Given these controls, Qwen-RobotNav first subsamples T′ frames from its full history of images (either spread-out or recent). It then computes a weight $ω_t=\exp(γ \cdot t/(T'-1))$ for each retained frame index $t$, and multiplies by the camera weight $w_c$ to form a matrix $W[t,c]=ω_t w_c$. Next, a constrained allocation algorithm distributes the total budget B into each frame-camera cell proportionally to $W[t,c]$, subject to minimum and maximum tokens per image. Each image is then resized so that its final patch token count matches this budget. Finally, the rescaled images are passed through the vision encoder. Importantly, all these control parameters are sampled at training time. The authors randomize $B$, $γ$, ${w_c}$, the frame mode, and even per-image min/max tokens for every training example. This means the model never overfits to one fixed config; it learns to handle anything within the training range. At inference, the controller can choose any desired parameters without changing the model weights. In effect, Qwen-RobotNav becomes a reconfigurable policy rather than a fixed one. Example: To explore broadly (e.g. searching a floor for an object), the planner might set a high budget B and use “random” sampling with low γ, thus covering many past frames. To chase a moving target, it might switch to a small B, “latest” mode, and high γ, focusing on the last few images. The paper reports that switching between these modes mid-episode yields smooth behavior. Language Tags for Viewpoints and Time: After resizing and tokenizing, the model still needs to know which token corresponds to which time and camera. Qwen-RobotNav cleverly uses plain language for this. It interleaves text tags like and into the visual token stream. For example:. By inserting the tokens “Time step t” and camera names before each image token, the pretrained LLM automatically knows “this image is from the front camera at time t”. No special embeddings or architecture changes are needed – the model’s existing language understanding already encompasses “left”, “back”, “front”, etc. The authors note that descriptive view names work slightly better than numeric angles, presumably because they carry richer semantic cues (e.g. the word “Front” implies forward direction). Embodiment Prompt: The model is used across very different embodiments – from indoor robots to cars to quadrupeds. Again, Qwen-RobotNav does not change its neural structure. Instead, each batch is prefixed with a small natural-language prompt indicating the platform. For example: “Imagine you are a robot programmed for navigation tasks” vs “Imagine you are a car programmed for autonomous driving”. This signals to the model to use different parts of its knowledge (e.g. indoor furniture layouts vs. road rules) and has been found effective. Adding a new robot type in practice just means writing a new sentence template, not training a new network. Overall, the Qwen3-VL backbone remains intact – it ingests the tokenized instruction plus the sequence of tagged visual tokens. The module architecture is summarized in Figure 2 of the paper (reproduced below): the planner sets $\Phi=(B,γ,w_c,m,b_{min},b_{max})$ and a mode $\tau$, the images are encoded under that scheme, and the LLM+MLP head outputs waypoints. Figure 2: Qwen-RobotNav architecture (from the paper). The upper-level LLM planner feeds sub-goals, task modes, and observation parameters. Qwen-RobotNav then processes the instructed images (with tagged time/view tokens) through its vision-language backbone and outputs an 8-waypoint plan. Multi-Task Training. With this flexible architecture, the team assembled a massive multi-task training routine. They curated 15.6 million training samples covering a broad spectrum of navigation tasks. Roughly 85% of the data are trajectory-planning examples across five task families (instruction-following, point-nav, object search, target tracking, and driving), and 15% are vision-language reasoning data. This mixture is critical: just training on trajectories for navigation can cause the model to ignore language cues and collapse into a short-sighted action predictor. The vision-language co-training preserves the model’s general language grounding, which is what enables those natural-language tags and flexible prompts to work at all. Details of each data source:. Instruction Following (VLN): They aggregated many instruction navigation datasets (R2R, RxR, CVDN dialog navigation, REVERIE, SOON, etc.), covering both fine-grained step-by-step directions and high-level goals. Synthetic enhancements were applied: generated cleaner photos and paraphrased instructions via LLMs to multiply the diversity. Point-Goal Navigation: Environments from Gibson and Habitat, selecting random coordinate goals. Here the “instruction” is just (x,y) coordinates or a short command. This balances the VLN data. Object-Goal Navigation: They used HM3D and other simulators to create trajectories searching for objects. This required room-level exploration plans. They even processed the 3D floorplans into “navigation regions” first (dilate, erode, skeletonize) to guide the search path. Target Tracking: People following data – e.g. HM3D-ProudmanBench focuses on “follow the man in black”, etc. These teach the model to keep recent frames and predicted goal in sync. Autonomous Driving: Interestingly, they treat driving as just another trajectory-planning signal. They pulled nuScenes (78K trajectories) and OpenScene (3.1M car trajectories) and broke them into waypoint planning tasks. Importantly, they also stochastically varied what information is given: sometimes the model sees a high-level direction, sometimes only past ego poses, forcing it to learn driving planning under different priors. In total they reported ~3.2M driving trajectories after augmentation. All these are cast uniformly as “[instruction + visual context] → waypoint trajectory”. By training on this mix, the model develops a shared spatial-planning substrate that can transfer across tasks. Joint training appeared to significantly improve performance; for example, a 4B model trained on all tasks outperformed a separately-trained model on any single task. Training targets: On the trajectory samples, the loss is simply MSE between predicted and ground-truth waypoints. On the vision-language (reasoning) samples, they use a standard language modeling loss on the next-token prediction. These are summed (with equal weight λ=1.0). All network layers are fine-tuned end-to-end from the pretrained Qwen3-VL checkpoint. They trained with a large batch (256) and reported ~2816 GPU-hours on A100s to convergence. Critically, at every training step the observation-encoding parameters are randomized. In other words, each sample in a batch is likely under a different (B, γ, w_c, etc). This forces the model to see every combination. As the paper states, “the model is never trained at a fixed configuration, and supports robust generalization across configurations within the randomized range”. In practice they alternate the frame sampling mode equally between “random” and “latest” so the model learns both global-cover and recency behaviors. This pays off in deployment: at inference time the planner can flip the mode mid-episode (e.g. from exploration to chase) and the model smoothly adapts without any fine-tuning. In summary, by shaping the data and losses, Qwen-RobotNav learns to act as a universal navigation policy whose behavior can be sculpted by the supplied parameters. It is robust across camera configurations and embodiment prompts, thanks to always seeing varied setups in training. The authors note that co-training on vision-language data is essential; without it, models tend to “collapse into reactive action-sequence mappers and lose open-world perception”. In short, Qwen-RobotNav remains an LLM at heart, just repurposed to output motion plans. Deploying as an Agentic Navigation Tool. A central motivation for Qwen-RobotNav is its use in agentic architectures: systems where a high-level planner (often a language model itself) delegates tasks to specialist models as “tools”. Qwen-RobotNav is designed to act exactly like a tool: the planner calls it with a specific mode and gets back a trajectory. Concretely, at each time step the planner (e.g. Qwen3.6-Plus, which is a large LLM) chooses:. $L_i$: a sub-goal instruction (a piece of language like “Go to the red sofa”). $\tau_i$ (task mode): one of {VLN, PointNav, ObjNav, Tracking}. Just telling Qwen-RobotNav which behavior to enact. $\Phi_i$ (observation config): a tuple of parameters $(B,\gamma,{w_c},\text{mode},b_{\min},b_{\max})$ as described above (in practice usually specifying $B$, $\gamma$, and the sampling mode is enough). Then it invokes:. where $W_i$ is the predicted waypoint sequence. Importantly, this is the same Qwen-RobotNav model weights for all calls; only the arguments change. The model thus serves as a callable navigation primitive. Moreover, the planner is allowed to make auxiliary vision-tool calls on the current observations. For example, it can ask an object detector or a scene parser to run on the frames. These tools do not plan motion; they just provide information (like “a coffee cup detected at pixel xx”). Such information is added to the agent’s memory and can inform future planning steps. After each call, Qwen-RobotNav outputs a dense trajectory along with its intermediate observations. The system includes a lightweight harness that summarizes this rollout for the planner. Rather than flooding the planner with raw image data, the harness generates a compact record like:. This textual “evidence” log tells the planner what happened each segment. Key facts include where the agent went, what landmarks it saw, and whether the goal was found. The planner maintains a longer-term notebook of such entries (and occasionally raw key-frame images) as memory. This two-level memory (per-call logs + persistent notebook) lets the planner reason across steps without reprocessing everything. In other words, Qwen-RobotNav hands back not just the motion plan but a structured report of the execution. This interface – a decomposable set of natural-language calls and evidence – makes integrating the model into larger agents very modular. The authors illustrate a scenario: searching for a mug, the planner might first call Qwen-RobotNav in “ObjNav” mode to explore the kitchen (large budget, broad camera views). If it spots a likely mug, the planner then switches to “Tracking” or local “PointNav” with tighter focus to approach it. At each sub-goal, the planner processes the summarized outcome and decides the next step. This agentic design was put to the test both in simulation and on hardware. In the lab, the team ran the full system on a Unitree Go2 quadruped robot (provided by Unitree) to demonstrate an end-to-end embodied agent. In one example, the task might be phrased like “Did I leave a green umbrella at the coffee shop?” The upper-level LLM decomposes that into sub-tasks like going to the coffee shop, scanning for umbrellas, etc. Qwen-RobotNav then executed each subtask planning. The pipeline – LLM planner plus Qwen-RobotNav as the navigator – handled the entire long-horizon mission without any real-world fine-tuning: in effect, zero-shot from the simulation training to the physical robot. The agents navigated between rooms, passed through doorways, and identified landmarks based on visual evidence, successfully answering the question. In terms of deployment, they considered both cloud-based and on-device inference. For example, Qwen-RobotNav-4B was tested on the Unitree with a remote server and also locally on a Jetson Thor (with FP8 quantization via TensorRT). They measured that on average remote-server inference was slightly faster (≈196 ms per step, ~5.1 Hz) than on-device (≈204 ms, ~4.9 Hz), but it was more sensitive to network jitter. On-device run was more stable for latency-critical tasks (like tracking). In practice both modes were viable, giving flexibility for field use. Results: State-of-the-Art Across Benchmarks. Qwen-RobotNav was evaluated on a broad suite of benchmarks, covering each task domain. Across the board it set new state-of-the-art or highly competitive results, often with a single model (especially the 8B version). Below we highlight key findings, comparing to specialist methods and previous navigation foundation models. Vision-and-Language Navigation (VLN-CE R2R and RxR): In continuous environments, the 8B model achieved 72.1% Success Rate on the R2R (Room-to-Room) Val-Unseen split and 76.5% on RxR Val-Unseen. This eclipses previous unified models: for example, NavFoM and ABot-N0 scored in the mid-60s. The Qwen model also did well with a single monocular camera (forward view only), not just 360° vision. Notably, R2R tasks typically require retaining long histories; Qwen-RobotNav’s task-adaptive memory gives it a big edge (the authors note an 10+ point SR improvement over NavFoM on R2R). On the newer VLNVerse benchmark (which features realistic physics-based movement and varied instruction granularity), Qwen-RobotNav-8B scored 63.75% SR and 57.93% SPL on the fine-grained split, dramatically outperforming baselines.Fully journal citation: Marcus et al., VLN-CE benchmark results. PointNav: Similar gains were seen on pure coordinate navigation tasks. (Exact numbers not listed here, but the paper reports that Qwen's joint training did better than specialized point-nav policies, thanks in part to its scene understanding.). Closed-Vocabulary Object Navigation: On Matterport3D (MP3D) and Habitat HM3D scenes, looking for specific object categories, Qwen-RobotNav set new records. For example, on HM3D v2 (with 216 test scenes and updated object annotations), the 4B model achieved 75.6% success rate, with only ~1.7m average error distance to goal. This bested prior methods that even used depth sensors. Even on MP3D, Qwen-4B got 52.2% SR, outstripping depth-based baselines. The 8B model had the highest SPL (path efficiency) on MP3D and very strong SR on HM3D too. In short, Qwen-RobotNav found objects faster and more reliably than any earlier baseline (Table below). | Method | MP3D SR↑ | MP3D SPL↑ | HM3Dv2 SR↑ | HM3Dv2 SPL↑ | |------------------|--------|--------|---------|---------| | Uni-NaVid† | – | – | 73.7 | 37.1 | | CogNav† | – | – | 46.6 | 16.1 | | WMNav† | 45.4 | 17.2 | 58.1 | 31.2 | | Qwen-4B | 52.2 | 16.0 | 75.6 | 30.6 | | Qwen-8B | 48.8 | 17.7 | 71.2 | 33.0 |. († indicates methods using depth or odometry. Qwen uses only RGB). Open-Vocabulary ObjectNav (OVON): On HM3D-OVON, where targets are described by open-ended phrases, Qwen-RobotNav also excelled. The 4B model achieved 57.7% succeed on “Seen” categories and 60.1% on “Synonyms” splits, surpassing the previous best (ABot-N0) by several points. Even the 8B model matched or beat baselines on two of three splits. This is notable because Qwen was given only a single forward camera view here, whereas ABot-N0 had panoramic vision. Qwen-RobotNav’s scores indicate it can generalize object language and scene understanding in a foundational way. Active Visual Tracking: On the EVT-Bench single-target following task, Qwen-RobotNav achieved 90.0% tracking rate with the 4B model (89.7% for 8B), higher than any baseline (next best was ~87.6%). Its collision rate was also lower than other generalist models. As expected, specialized trackers like TrackVLA++ had higher absolute success (86%), but importantly Qwen reached similar locked-on performance while being a multi-tool model. (Qwen’s raw success rate was ~77–78%, compared to 86–87% for best trackers, because it takes a bit longer to be sure of the target; but when measured by tracking rate, it led the field.). Autonomous Driving: For closed-loop driving on the NAVSIM benchmark, Qwen-RobotNav was competitive with state-of-art. In trajectory accuracy terms, it achieved a PDM Score (PDMS) of 91.4 (Qwen-4B) and 90.9 (8B) under a specific evaluation with historical ego poses provided, which is on par or better than recent specialized models (NavFoM got ~84.3, another recent model 90.8, etc.). More importantly, safety and compliance metrics were very high: Navigation Compliance (NC) ~99.8%, Time-to-Collision ~98% or higher. The conclusion: Qwen-Nav can plan drivable, collision-avoiding trajectories nearly as well as driving-specialized methods. (The slight gap to dedicated driving models is expected since Qwen’s core is not exclusively tuned to driving, but it impressively generalizes to this new domain.). Embodied Question Answering (EQA): Here Qwen-RobotNav was tested as part of a full agent on benchmarks like HM-EQA and EXPRESS-Bench (which require the robot to answer questions by navigating indoors). With a two-tier agent (Qwen3.6 planner + Qwen-RobotNav executor), they achieved new best accuracies: 76.7% on HM-EQA and 79.27 LLM Score on EXPRESS, beating the prior Fast-EQA and Memory-EQA approaches by large margins. Crucially, they also reported 77% fewer navigation steps for Qwen’s system compared to previous methods, meaning it reached answers much more efficiently. This shows that the navigation policy not only finds things reliably but does so with less wandering. The result demonstrates that Qwen-RobotNav’s general multi-modal reasoning capabilities really pay off on complex, long-horizon tasks. In all these results, the multi-task joint model scales well: the 8B variant typically outperforms the 4B one, especially on long-horizon tasks (e.g. performance gain is most pronounced on expressive VLN and EQA). But even the 2B-4B sizes set new baselines in many cases, thanks to the multi-task and tokenization strategies. Notably, the unified design means that one set of weights can tackle very different missions without separate fine-tuning for each. To emphasize a few standout numbers from the experiments (all zero-shot on these benchmarks, with no task-specific finetuning):. R2R Val-Unseen (panoramic): Qwen-8B SR 72.1%, SPL 66.6% (vs ~60%/55% of best prior). RxR Val-Unseen (panoramic): Qwen-8B SR 76.5%, SPL 65.7%. ObjectNav HM3Dv2: Qwen-4B SR 75.6% (new state-of-art). Tracking (EVT): Qwen-4B TR 90.0%, CR 6.40%. Driving (PDM Score): Qwen-4B 91.4 (best in vision-language category). EQA (HM-EQA): Qwen3.6+Nav-8B Acc 76.7% vs prior 69.2%. These results substantiate Qwen-RobotNav’s claim of “industry-leading performance across navigation benchmarks”. They also illustrate the power of the task-adaptive interface: the model is no longer limited by a one-size-fits-all context window. Discussion and Implications. Qwen-RobotNav represents a significant step toward “foundation models” for embodied agents. Its design — emphasizing a configurable perception backbone — offers several important lessons and opens new directions:. Observation Context as a Control. This work shows that flexible input framing can substitute for complicated architectural tricks. By letting an external planner choose the memory strategy, Qwen-RobotNav can adapt on the fly. As the authors conclude, the model moves from a fixed policy to a reconfigurable navigation primitive. A single LLM backbone can handle global exploration, greedy pursuit, or anything in between, simply by swapping parameters. Natural-Language Tokenization for Structure. A clever aspect is using language labels for camera/time. Instead of defining new embeddings or features, they feed tokens like “Front View” or “Time step 5” into the LLM. This maintains the integrity of the pretrained language alignments and makes adding support for new cameras or time horizons trivially scalable (just more words). It’s an elegant demonstration that sometimes explicit wording can carry important signal in an LLM context. Generalist Yet Practical. Qwen-RobotNav attempts to serve both as a generalist model and as a concrete controller for robots. The successful zero-shot tests on real hardware are encouraging: they show the model’s policy didn’t overfit to simulation nuances. The use of small Jetson modules with moderate quantization demonstrates it can run at near real-time, a key for deployment. Of course, it is still large and heavy compared to typical small robot controllers, but it’s in the ballpark of what one could imagine as a cloud or edge service. Integration into Agentic AI. The paper is also a template for how to integrate large models into multi-step tasks. The two-tier planner-executor loop, with an evidence notebook, resembles how humans might plan. It suggests that future embodied AI systems might routinely assemble foundation models (language + vision + action) in such pipelines. Rather than ad-hoc pipelines, Qwen-RobotNav’s interface is more principled and likely easier to extend. Limitations and Future Work. Of course, this is still early work. Some caveats:. The “zero-shot” real-world tests, while impressive, were probably in fairly structured indoor settings (conference rooms, mock coffee shop, etc.). How it handles truly unstructured real scenes is unclear. The current model predicts waypoints in 2D (x,y,θ). Adapting it to 3D movement or more complex action spaces (like aggressive driving maneuvers) may require extension. Training on 15.6M synthetic samples is expensive; replicating or improving on this would need careful data curation and compute. It does rely on high-level LLM planning to generate the right calls. The division of labor between planner and navigator is still hand-designed (like what tools to call, how to update memory). One might wonder how it would handle truly novel tasks not captured in its training (like search-and-rescue scenarios, etc.). Is the interface flexible enough to define new modes?. General Impact. Nonetheless, as a research demo, Qwen-RobotNav pushes the frontier of embodied AI. It ties language, vision, and control together into one coherent framework. For practitioners, it suggests a strategy: instead of hard-coding policies for every scenario, build a general model and expose its “knobs”. It also underscores the trend that robotics is moving into the era of foundation models, where the line between “AI model” and “robot controller” blurs. In conclusion, Qwen-RobotNav is a robust, versatile navigation foundation model. Its configurable observation encoding is a powerful idea that may inspire other adaptive systems. It sets new benchmarks on many nav tasks (VLN, ObjectNav, Tracking, Driving, EQA) and even proves it can steer a real robot with no extra tuning. As robotics and AI continue to converge, approaches like this – blending an LLM backbone with structured, dynamic interfaces – point the way toward more intelligent, flexible autonomous agents. References: The above descriptions and claims are drawn from the Qwen-RobotNav technical report (Zhang et al., 2026) and accompanying blog posts, which detail the model’s architecture, training, and evaluation results.