production update

.wordlist.txt

@@ -5383,4 +5383,60 @@ ultraedge
 unclound
 wNdi
 whatsapp
-workdir
+workdir
+Alexandre
+CRI
+ClickHouse's
+EDuJ
+EOL
+ERNIE's
+Expb
+FEXPA
+Grasset
+Idxb
+LOQ
+MEC
+MECID
+MECIDs
+MIMEType
+Martino
+NvLxg
+Nydus
+PASes
+PolicyDeny
+Remb
+Romana
+SLdG
+TCB
+aMWqFmwBgwT
+actix
+ae
+aot
+cdd
+columnalt
+cri
+decrypt
+eade
+empt
+expBits
+exponentials
+jsozZm
+jyco
+keyprovider
+Linux's
+minimax
+modelcontextprotocol
+nter
+nydus
+oMdFIQ
+outputNAME
+poweroff
+qJs
+rBD
+rMDhjcaEM
+remBits
+snapshotter
+unmounting
+vnd
+xqcqqYHrjZ
+ztPjILBCbFEqnVlbvjUpM

content/install-guides/stm32_vs.md

@@ -69,7 +69,7 @@ Run the installer(s) and follow on-screen instructions.
 
 ### How do I install Git for version control functionality?
 
-You can download the latest version from [here](https://git-scm.com/).
+You can download the latest version from [git-scm.com](https://git-scm.com/).
 
 ### What about Keil Studio for VS Code?
 

content/install-guides/streamline-cli.md

@@ -52,7 +52,7 @@ Streamline CLI tools are supported on the following Arm CPUs:
 
 Use the Arm Sysreport utility to determine whether your system configuration supports hardware-assisted profiling. Follow the instructions in [Get ready for performance analysis with Sysreport][1] to discover how to download and run this utility.
 
-[1]: https://learn.arm.com/learning-paths/servers-and-cloud-computing/sysreport/
+[1]: /learning-paths/servers-and-cloud-computing/sysreport/
 
 The `perf counters` entry in the generated report indicates how many CPU counters are available. The `perf sampling` entry indicates if SPE is available. You will achieve the best profiles in systems with at least 6 available CPU counters and SPE.
 

content/learning-paths/automotive/openadkit1_container/3_setup_openadkit.md

@@ -15,7 +15,7 @@ The example has been tested on [AWS EC2](https://aws.amazon.com/ec2/) and an [Am
 
 ## Installation
 
-You need Docker to run Open AD Kit. Refer to the [Docker install guide](https://learn.arm.com/install-guides/docker/) to learn how to install Docker on an Arm platform.
+You need Docker to run Open AD Kit. Refer to the [Docker install guide](/install-guides/docker/) to learn how to install Docker on an Arm platform.
 
 First, verify Docker is installed on your development computer by running:
 

content/learning-paths/automotive/openadkit2_safetyisolation/2_data_distribution_service.md

@@ -17,7 +17,7 @@ In modern vehicles, multiple sensors such as LiDAR, radar, and cameras must cont
 DDS ensures these components share data seamlessly and in real time, both within the vehicle and across infrastructure such as V2X systems, including traffic lights and road sensors.
 
 {{% notice Tip %}}
-To get started with open-source DDS on Arm platforms, see the [Installation Guide for CycloneDDS](https://learn.arm.com/install-guides/cyclonedds).
+To get started with open-source DDS on Arm platforms, see the [Installation Guide for CycloneDDS](/install-guides/cyclonedds).
 {{% /notice %}}
 
 

content/learning-paths/automotive/openadkit2_safetyisolation/3_container_spliting.md

@@ -10,7 +10,7 @@ layout: learningpathall
 
 Now that you’ve explored the concept of a safety island, a dedicated subsystem responsible for executing safety-critical control logic, and learned how DDS (Data Distribution Service) enables real-time, distributed communication, you’ll refactor the original OpenAD Kit architecture into a multi-instance deployment.
 
-The predecessor Learning Path, [Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse](http://learn.arm.com/learning-paths/automotive/openadkit1_container/), showed how to  deploying three container components on a single Arm-based instance, to handle:
+The predecessor Learning Path, [Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse](/learning-paths/automotive/openadkit1_container/), showed how to  deploying three container components on a single Arm-based instance, to handle:
 - The simulation environment
 - Visualization
 - Planning and control

content/learning-paths/automotive/openadkit2_safetyisolation/4_multiinstance_executing.md

@@ -86,7 +86,7 @@ On the Simulation and Visualization node, execute:
 
 Once both machines are running their launch scripts, the Visualizer container exposes a web-accessible interface at: http://6080/vnc.html.
 
-Open this link in your browser to observe the simulation in real time. The demo closely resembles the output in the [previous Learning Path, Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse](http://learn.arm.com/learning-paths/automotive/openadkit1_container/4_run_openadkit/). 
+Open this link in your browser to observe the simulation in real time. The demo closely resembles the output in the [previous Learning Path, Deploy Open AD Kit containerized autonomous driving simulation on Arm Neoverse](/learning-paths/automotive/openadkit1_container/4_run_openadkit/). 
 
 ![Distributed OpenAD Kit simulation running on two Arm-based instances with visualizer and simulator coordination over DDS alt-text#center](split_aws_run.gif "Visualizer output from a distributed OpenAD Kit simulation showing ROS 2 modules running across two cloud instances using DDS communication.")
 

content/learning-paths/automotive/tinkerblox_ultraedge/debian_installation.md

@@ -164,7 +164,7 @@ Place a `MicroPacFile` in your project directory.
 -   **limits**: Resource limits (memory, cpu)
 -   **mount**: Volume mount points
 -   **network**: Network configuration
--   **createdBy**: maintanier of the application
+-   **createdBy**: maintainer of the application
 -   **description**: description of the application
 
 ### Building the MicroPac

content/learning-paths/automotive/tinkerblox_ultraedge/main.md

@@ -97,21 +97,21 @@ execution fabric for high-performance compute infrastructure
 
 ### 5.2 High-Level Architecture
 
-**UltraEdge ‘Core’ Layer
**  
+**UltraEdge ‘Core’ Layer**  
 Handles compute infrastructure management including service
 orchestration, lifecycle management, rule engine orchestration, and
 data-flow management .
 
-**UltraEdge ‘Boost’ Layer
**  
+**UltraEdge ‘Boost’ Layer**  
 Implements performance-critical routines and FFI (Foreign Function
 Interface) calls; Contains dynamic connectors, and southbound protocol
 adapters
 
-**UltraEdge ‘Prime’ Layer
**  
+**UltraEdge ‘Prime’ Layer**  
 Contains business logic, trigger & activation sequences, and AI & mixed
 workload orchestration .
 
-**UltraEdge Edge-Cloud ‘Connect’ Layer
**  
+**UltraEdge Edge-Cloud ‘Connect’ Layer**  
 Supports data streaming to databases (InfluxDB, SQLite) and provides
 diagnostic/logging outputs .
 
@@ -322,7 +322,7 @@ Place a `MicroPacFile` in your project directory.
 -   **limits**: Resource limits (memory, cpu)
 -   **mount**: Volume mount points
 -   **network**: Network configuration
--   **createdBy**: maintanier of the application
+-   **createdBy**: maintainer of the application
 -   **description**: description of the application
 
 ### 7.4 Building the MicroPac

content/learning-paths/cross-platform/ernie_moe_v9/1_mixture_of_experts.md

@@ -1,5 +1,5 @@
 ---
-title: Why MoE Models Let Edge Devices Run 21B LLMs
+title: Understand Mixture of Experts architecture for edge deployment
 weight: 2
 
 ### FIXED, DO NOT MODIFY
@@ -8,53 +8,47 @@ layout: learningpathall
 
 ## What is Mixture of Experts (MoE)?
 
-As large language models grow to tens of billions of parameters, traditional dense networks — which activate all weights for every input — become infeasible for edge deployment, especially on CPU-only Arm devices. [Mixture of Experts (MoE)](https://en.wikipedia.org/wiki/Mixture_of_experts) offers a breakthrough.
+As large language models grow to tens of billions of parameters, traditional dense networks that activate all weights for every input become impractical for edge deployment, especially on CPU-only Arm devices. [Mixture of Experts (MoE)](https://en.wikipedia.org/wiki/Mixture_of_experts) offers an alternative approach that makes deploying these large models practical.
 
-This is simple and uniform, but as model sizes increase—into the billions of parameters—this structure becomes both memory-intensive and compute-intensive. For edge environments like mobile devices, embedded systems, this makes deploying large models nearly impossible.
+Dense networks are simple and uniform, but as model sizes increase into the billions of parameters, this structure becomes both memory-intensive and computationally demanding. For edge environments like mobile devices and embedded systems, deploying large models presents significant challenges.
 
-***[Mixture of Experts (MoE)](https://en.wikipedia.org/wiki/Mixture_of_experts)*** offers an alternative. 
-Instead of using all parameters all the time, MoE introduces a conditional computation mechanism: each input token only activates a small subset of model components (called ***experts***). 
-Think of it like having a team of specialists, and only calling the relevant few for a given task. This makes MoE ideal for environments where compute or memory is constrained, such as edge AI or embedded inference.
+Instead of activating all parameters for every computation, MoE introduces a conditional computation mechanism where each input token activates only a small subset of model components called experts. Think of it like having a team of specialists where you consult only the relevant experts for a given task. This makes MoE ideal for environments where compute and memory are constrained, such as edge AI or embedded inference.
 
+In a typical MoE setup, the model consists of many expert sub-networks (for example, 64 experts), but for each input, a router selects only a handful to compute the result. The rest remain inactive, conserving memory and compute. The model learns this dynamic routing during training, so during inference, only a fraction of the model is active. This leads to much lower compute and memory usage without sacrificing the total model capacity or diversity of learned behaviors.
 
-In MoE:
-- The model consists of many expert sub-networks (e.g., 64 experts).
-- For each input, a router selects only 2–4 experts to compute the result.
-- The rest of the experts remain inactive, conserving memory and compute.
+## Benefits of MoE architecture
 
-This dynamic routing is typically learned during training. In inference, only a fraction of the model is active, leading to much lower compute and memory usage ***without sacrificing the total model capacity** or ***diversity of learned behaviors***.
+MoE architecture provides several advantages that make it particularly well-suited for edge deployment and large-scale model development:
 
+**Scalable model size**: You can increase total parameter count without linearly increasing inference cost, allowing for larger, more capable models within the same resource constraints.
 
-## Benefits of MoE Architecture
+**Efficient inference**: The architecture requires lower memory and FLOPs per input compared to dense models of equivalent capacity, making real-time applications more feasible.
 
-- Scalable Model Size: Increase total parameter count without linearly increasing inference cost.
-- Efficient Inference: Lower memory and FLOPs per input.
-- Modularity: Each expert can learn domain-specific patterns (e.g., finance, medicine, language).
-- Specialization: Encourages the model to learn distinct processing behaviors across different experts.
-- Routing Flexibility: Makes it easier to adapt to specific tasks using fine-tuned expert selection.
+**Modularity**: Each expert can learn domain-specific patterns such as finance, medicine, or language, enabling the model to handle diverse tasks without retraining the entire network.
 
-## ERNIE-4.5: A MoE Model for Chinese NLP
+**Specialization**: The architecture encourages the model to learn distinct processing behaviors across different experts, improving performance on specialized tasks while maintaining general capability.
 
-The [ERNIE-4.5](https://huggingface.co/collections/baidu/ernie-45) model family from [Baidu](https://huggingface.co/baidu) introduces a Mixture-of-Experts (MoE) architecture, which enables massive models (e.g., 21 billion parameters) to be deployed in constrained environments. MoE models dynamically activate only a small subset of parameters (e.g., 2–4 experts) during inference.
-Specifically, ERNIE-4.5 uses a softmax-based router to select the top-6 experts from a pool of 64 per layer, activating only a subset dynamically per token. This makes runtime both efficient and adaptive. This architecture allows the model to retain high performance and generalization while drastically reducing inference-time resource requirements.
+**Routing flexibility**: The dynamic expert selection makes it easier to adapt to specific tasks using fine-tuned routing strategies, allowing for task-specific optimizations without modifying the core model.
 
-ERNIE-4.5 Model Series:
-- PT (Post-Trained): General-purpose language model trained on Chinese and English data.
-- Thinking: Optimized for reasoning tasks with long context support and structured outputs.
+## ERNIE-4.5: An MoE model for Chinese NLP
 
-In this learning path, we focus on the [ERNIE-4.5 Thinking](https://huggingface.co/baidu/ERNIE-4.5-21B-A3B-Thinking) variant as our primary model due to its enhancements for multi-step reasoning and long-context tasks. However, we also introduce the [PT (Post-Trained)](https://huggingface.co/baidu/ERNIE-4.5-21B-A3B-PT) variant to allow learners to compare model behavior across identical prompts, illustrating how task-specific tuning affects output quality.
+The [ERNIE-4.5](https://huggingface.co/collections/baidu/ernie-45) model family from [Baidu](https://huggingface.co/baidu) introduces a Mixture of Experts (MoE) architecture that enables 21-billion-parameter models to be deployed in constrained environments. The model uses a softmax-based router to dynamically select the top six experts from a pool of 64 per layer, activating only this subset per token. This makes runtime both efficient and adaptive while retaining high performance and generalization.
 
-## Why MoE Matters for Edge Devices
+The ERNIE-4.5 model series includes two variants. The PT (Post-Trained) variant is a general-purpose language model trained on Chinese and English data. The Thinking variant is optimized for reasoning tasks with long context support and structured outputs. Both are designed for Chinese Natural Language Processing (NLP).
 
-Deploying a 21B dense model on a CPU-only board is infeasible. But MoE changes that:
+This Learning Path focuses on the [ERNIE-4.5 Thinking](https://huggingface.co/baidu/ERNIE-4.5-21B-A3B-Thinking) variant as the primary model because of its enhancements for multi-step reasoning and long-context tasks. However, you also use the [PT (Post-Trained)](https://huggingface.co/baidu/ERNIE-4.5-21B-A3B-PT) variant to compare model behavior across identical prompts, illustrating how task-specific tuning affects output quality.
 
-| **Feature**           | **Dense Model** | **MoE Model (e.g., ERNIE-4.5-21B)** |
-|-----------------------|-----------------|---------------|
-| `Total Parameters`    | 21B             | 21B           |
-| `Activated Parameters`| 21B             | ~3B           |
-| `Memory Usage`        | Very high       | Moderate      |
-| `Inference Speed`     | Slow            | Fast          |
+## Why MoE matters for edge devices
 
-This efficiency enables powerful language models to be run locally on ARM-based platforms — making MoE not just a model design choice, but a deployment enabler.
+Deploying a 21-billion-parameter dense model on a CPU-only board is impractical, but MoE changes that. The table below compares key characteristics:
 
-In the next module, you’ll bring this architecture to life — preparing a real Armv9 board, setting up llama.cpp, and verifying that a 21B MoE model like ERNIE-4.5 can run efficiently with no GPU required.
+| **Feature**           | **Dense Model** | **MoE Model (ERNIE-4.5-21B)** |
+|-----------------------|-----------------|-------------------------------|
+| Total Parameters      | 21B             | 21B                           |
+| Activated Parameters  | 21B             | ~3B                           |
+| Memory Usage          | Very high       | Moderate                      |
+| Inference Speed       | Slow            | Fast                          |
+
+This efficiency enables powerful language models to run locally on Arm-based platforms, making MoE not just a model design choice, but a deployment enabler.
+
+In the next section, you set up a real Armv9 board, configure llama.cpp, and verify that you can run a 21-billion-parameter MoE model like ERNIE-4.5 efficiently without a GPU.