Merge pull request #2743 from ArmDeveloperEcosystem/main

production update

Author: jasonrandrews

.wordlist.txt

@@ -5455,7 +5455,6 @@ MatMul
 MlasConv
 MlasDynamicQGemmBatch
 MlasGemmBatch
-Modescope
 Nascimento
 ParallemOpenMP
 Partitioner
@@ -5473,4 +5472,25 @@ mopa
 perfetto
 translational
 tunable
-vlx
+vlx
+Ack
+Dunkle
+GENPROFILE
+LIBPATH
+LTCG
+OneDrive
+PGD
+ParallelOpenMP
+ParseMessage
+RabbitMQ's
+ReadFromPubSub
+TabSeparated
+USEPROFILE
+WriteToClickHouse
+iCloud
+pgd
+preselected
+reconfiguring
+torchscript
+xxxxxx
+Modescope

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

@@ -20,15 +20,15 @@ In a typical MoE setup, the model consists of many expert sub-networks (for exam
 
 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.
+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.
 
-**Efficient inference**: The architecture requires lower memory and FLOPs per input compared to dense models of equivalent capacity, making real-time applications more feasible.
+Efficient inference: the architecture requires lower memory and FLOPs per input compared to dense models of equivalent capacity, making real-time applications more feasible.
 
-**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.
+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.
 
-**Specialization**: The architecture encourages the model to learn distinct processing behaviors across different experts, improving performance on specialized tasks while maintaining general capability.
+Specialization: the architecture encourages the model to learn distinct processing behaviors across different experts, improving performance on specialized tasks while maintaining general capability.
 
-**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.
+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: An MoE model for Chinese NLP
 

content/learning-paths/cross-platform/ernie_moe_v9/2_llamacpp_installation.md

@@ -4,7 +4,7 @@ weight: 3
 layout: "learningpathall"
 ---
 
-## Set up llama.cpp on an Armv9 development board
+## Overview
 
 In the previous section, you learned how Mixture of Experts (MoE) models reduce resource consumption by activating only a fraction of parameters. 
 Now, you'll walk through how to prepare your environment to deploy ERNIE-4.5 models on an Armv9 platform using llama.cpp.
@@ -98,10 +98,10 @@ cd $HOME/llama.cpp/build
 ```
 
 Note the flags:
-- `-p`: Passes the input prompt directly as a string.
-- `-c 4096`: Sets the context length (in tokens). A longer context allows the model to "remember" more input text, which is crucial for long-form tasks. Here, you use the recommended 4096 tokens.
-- `-t 12`: Specifies the number of CPU threads used for inference. You should match this number to the physical cores (or logical threads) available on your system to maximize performance.
-- `--jinja`: Enables Jinja-style prompt templates. Many Chinese-oriented MoE models rely on this template format for structured inputs.
+- `-p`: passes the input prompt directly as a string.
+- `-c 4096`: sets the context length (in tokens). A longer context allows the model to "remember" more input text, which is crucial for long-form tasks. Here, you use the recommended 4096 tokens.
+- `-t 12`: specifies the number of CPU threads used for inference. You should match this number to the physical cores (or logical threads) available on your system to maximize performance.
+- `--jinja`: enables Jinja-style prompt templates. Many Chinese-oriented MoE models rely on this template format for structured inputs.
 
 If everything is set up correctly, you see metadata output from llama.cpp indicating the model's architecture and size:
 
@@ -113,12 +113,14 @@ print_info: general.name     = Ernie-4.5-21B-A3B-Thinking
 
 Once inference is complete, the expected output looks like this (in Chinese):
 
-![img1 alt-text#center](meo_result.png "Introduce Mixture of Experts in Chinese")
+![Terminal output showing ERNIE-4.5 model response in Chinese with structured markdown formatting explaining Mixture of Experts concept alt-txt#center](meo_result.png "Introducing Mixture of Experts in Chinese")
 
 This answer demonstrates the model's multilingual and structured reasoning ability. It begins with a narrative explanation introducing the concept of Mixture of Experts (MoE), followed by a well-organized markdown-style summary with section headers and bullet points. The response describes MoE as a model combining multiple specialized sub-models (experts) and a routing mechanism (gateway) to activate only a few experts per input. It explains how routing selects top experts based on input features and how the system reduces computation by activating only a small number of experts per token. The answer also gives examples such as word segmentation and translation, explaining how different experts might focus on distinct subtasks in Chinese NLP applications.
 
 This confirms the GGUF model is successfully loaded, the llama.cpp build functions as expected, and CPU-only inference on Armv9 is working.
 
 The prompt "Please introduce Mixture of Experts in Chinese." was chosen because it tests two important capabilities. First, it verifies bilingual capability since the instruction is in English but the answer is expected in Chinese, confirming that ERNIE-4.5's multilingual support works correctly. Second, it engages MoE behavior by having the model explain a technical concept in Chinese, which likely activates different experts within the model during inference. Even though routing isn't explicitly logged, the richness and precision of the output suggest that MoE routing functions as designed. This type of prompt increases the likelihood of multiple experts being activated simultaneously, including language generation, machine learning knowledge, and Chinese translation experts.
 
-You've now successfully set up llama.cpp on Armv9 hardware, deployed the ERNIE-4.5 model, and confirmed that multilingual inference works correctly. With this foundation in place, you're ready to explore expert routing behavior and benchmark performance optimizations in the next sections.
+## What you've accomplished and what's next
+
+You've successfully set up llama.cpp on Armv9 hardware, deployed the ERNIE-4.5 model, and confirmed that multilingual inference works correctly. With this foundation in place, you're ready to explore expert routing behavior and compare model variants in the next section.

…oss-platform/ernie_moe_v9/3_erine_moe.md …oss-platform/ernie_moe_v9/3_ernie_moe.mdcontent/learning-paths/cross-platform/ernie_moe_v9/3_erine_moe.md renamed to content/learning-paths/cross-platform/ernie_moe_v9/3_ernie_moe.md content/learning-paths/cross-platform/ernie_moe_v9/3_erine_moe.md renamed to content/learning-paths/cross-platform/ernie_moe_v9/3_ernie_moe.md

@@ -11,8 +11,8 @@ Now that both ERNIE-4.5 models are installed and verified, you can compare their
 In this section, you compare the inference styles of PT and Thinking models, and learn how to inspect internal MoE expert routing behavior during generation.
 
 Both ERNIE-4.5 models share the same MoE architecture and parameter count (around 21 B total, around 3 B activated at runtime), but they're tuned for different objectives:
-- PT: General-purpose model trained on multilingual corpora for versatile tasks
-- Thinking: Tuned for multi-step reasoning, long context, and structured response generation
+- PT: general-purpose model trained on multilingual corpora for versatile tasks
+- Thinking: tuned for multi-step reasoning, long context, and structured response generation
 
 You can now observe how these different tuning objectives affect output behavior.
 
@@ -41,19 +41,18 @@ Here is the PT variant:
     --jinja
 ```
 
-The answer looks like this:
+The output is similar to:
 
 ```output
 Assistant: 1. **Top Motivation**: Achieving visible results and maintaining progress through efficient recovery nutrition.  
 **Hidden Pain Point**: Balancing high-intensity training with optimal recovery nutrition during busy workouts.  
 2. **New Product Line**: *Smart Recovery Meal Kits* – Customizable, nutrient-dense, and easy-to-prepare post-workout meals designed for quick consumption and recovery optimization.  
 3. **Marketing Tagline**: "Fuel Progress, Recover Faster – Smart Nutrition for the Hard Worker."
 ```
-
 The answer shows:
-- Delivers conclusions directly: motivations and pain points are briefly mentioned with little reasoning.
-- Product ideas are sensible but templated: suggestions like "Smart Recovery Meal Kits" are plausible but lack contextual grounding in user behavior.
-- Tagline reads like a standard advertisement: for example, "Fuel Progress, Recover Faster" feels promotional rather than personalized.
+- Direct conclusions with minimal reasoning
+- Sensible but general product suggestions (such as "Smart Recovery Meal Kits")
+- Standard advertising tone in the tagline ("Fuel Progress, Recover Faster")
 
 Here is the Thinking variant:
 
@@ -65,7 +64,7 @@ Here is the Thinking variant:
     --jinja
 ```
 
-You see a more comprehensive answer like this:
+The output is similar to:
 
 ```output
 assistant
@@ -98,9 +97,9 @@ So to sum up:
 ```
 
 The answer shows:
-- Responses show deeper layering: begins with inferring user motivation, iterates through possible product strategies, and only then crafts a refined tagline.
-- Transparent reasoning process: the model "thinks out loud" ("let me try again… maybe that's too long…"), mimicking human deliberation.
-- Marketing language reflects user mindset: taglines like "Share. Track. Conquer." directly appeal to community sharing and progress motivation.
+- Deeper layering: the model begins by inferring user motivation, explores multiple product strategies, and then refines the tagline through iteration.
+- Transparent reasoning: the model "thinks out loud" with phrases like "let me try again… maybe that's too long…", mimicking human deliberation.
+- User-focused messaging: taglines like "Share. Track. Conquer." directly appeal to the user's community sharing and progress motivation.
 
 ### Compare the outputs
 After execution, review the responses and compare them along the following dimensions:
@@ -161,18 +160,23 @@ Run inference with the same prompt and monitor the console for lines like this:
 ---[DEBUG]--- entering build_moe_ffn at layer 27 with 64 experts (use 64)
 ```
 
-This reveals how many experts (for example, 6) and how many tokens (for example, 16) were routed at that layer.
+This output shows that each layer has 64 total experts available. The actual number of experts activated per token (typically 6 for ERNIE-4.5) is determined by the router during inference and isn't directly visible in this debug output.
 
 {{% notice Note %}}
-You can also trace the function `llm_graph_context::build_moe_ffn()` in `src/llama-graph.cpp` to see how expert selection works.
+You can also trace the function `llm_graph_context::build_moe_ffn()` in `src/llama-graph.cpp` to see how expert selection works at a deeper level.
 {{% /notice %}}
 
-Remove the print statement from `src/models/ernie4-5-moe.cpp` before moving to the next section. 
+Remove the print statement from `src/models/ernie4-5-moe.cpp` and rebuild llama.cpp before moving to the next section. 
 
 As you review the debug output, observe whether the number of active experts changes between the PT and Thinking models. Look for patterns in routing, such as different token batches routing to differing expert sets. You can also correlate routing behavior with output differences, as deeper routing variety might align with more detailed responses.
 
-## Summary
+## What you've accomplished and what's next
+
+In this section, you:
+- Compared ERNIE-4.5 PT and Thinking model outputs on the same task
+- Observed how fine-tuning affects reasoning depth and response structure
+- Learned how to add debug instrumentation to examine MoE expert routing
 
-This task highlights the advantage of MoE fine-tuning. Even with the same architecture, thoughtful tuning can significantly change a model's reasoning behavior. The Thinking model is better suited for applications that need analytical depth, making it ideal for edge AI scenarios like customer profiling or real-time recommendations.
+This comparison highlights the advantage of MoE fine-tuning. Even with the same architecture, thoughtful tuning can significantly change a model's reasoning behavior. The Thinking model is better suited for applications that need analytical depth, making it ideal for edge AI scenarios like customer profiling or real-time recommendations.
 
 In the next section, you switch focus from model behavior to system-level performance by compiling with Armv9 instruction sets and measuring the impact on inference speed.

content/learning-paths/cross-platform/ernie_moe_v9/4_v9_optimization.md

@@ -114,8 +114,8 @@ After running benchmarks with and without Armv9-specific instructions, the resul
 
 Vectorized kernels (i8mm, dotprod, SVE) drastically improve inference throughput. The pp512 test shows the most significant acceleration with a 2.57× improvement. Other patterns like tg128 and pp128+tg128 also achieve measurable gains. These results demonstrate the broad benefit of hardware-aware builds and show that Armv9 optimization enables practical real-time inference for 21 B models on edge-class hardware.
 
-### Summary
+## What you've accomplished
 
-Throughout this Learning Path, you deployed a 21 B parameter Chinese MoE model on edge-class Armv9 hardware. You started by understanding how MoE reduces memory usage by activating only a small subset of parameters per token. After setting up llama.cpp on a Radxa O6 board, you compared ERNIE-4.5 Thinking and PT model behaviors while examining expert routing logic with debug instrumentation. Finally, you applied Armv9 hardware optimizations and achieved over 2.5× speed improvements in token throughput. 
+Throughout this Learning Path, you deployed a 21-billion-parameter Chinese MoE model on edge-class Armv9 hardware. You started by understanding how MoE reduces memory usage by activating only a small subset of parameters per token. After setting up llama.cpp on a Radxa O6 board, you compared ERNIE-4.5 Thinking and PT model behaviors while examining expert routing logic with debug instrumentation. Finally, you applied Armv9 hardware optimizations and achieved over 2.5× speed improvements in token throughput. 
 
 You can now deploy, profile, and tune Chinese LLMs for efficient inference on modern Arm CPUs.

content/learning-paths/cross-platform/ernie_moe_v9/_index.md

@@ -1,13 +1,9 @@
 ---
 title: Run ERNIE-4.5 Mixture of Experts model on Armv9 with llama.cpp
 
-draft: true
-cascade:
-    draft: true
-
 minutes_to_complete: 60
 
-who_is_this_for: This Learning Path is for developers and engineers who want to deploy Mixture of Experts (MoE) models, such as ERNIE 4.5, on edge devices. MoE architectures allow large LLMs with 21 billion or more parameters to run with only a fraction of their weights active per inference, making them ideal for resource constrained environments.
+who_is_this_for: This is an advanced topic for developers and engineers who want to deploy Mixture of Experts (MoE) models, such as ERNIE 4.5, on edge devices. MoE architectures allow large LLMs with 21 billion or more parameters to run with only a fraction of their weights active per inference, making them ideal for resource constrained environments.
 
 learning_objectives:
     - Deploy MoE models like ERNIE-4.5 on edge devices using llama.cpp
@@ -20,7 +16,7 @@ prerequisites:
 author: Odin Shen
 
 ### Tags
-skilllevels: Introductory
+skilllevels: Advanced
 subjects: ML
 armips:
     - Cortex-A

content/learning-paths/laptops-and-desktops/_index.md

@@ -11,12 +11,12 @@ operatingsystems_filter:
 - ChromeOS: 2
 - Linux: 38
 - macOS: 10
-- Windows: 46
+- Windows: 47
 subjects_filter:
 - CI-CD: 6
 - Containers and Virtualization: 7
 - Migration to Arm: 30
-- ML: 5
+- ML: 6
 - Performance and Architecture: 28
 subtitle: Create and migrate apps for power efficient performance
 title: Laptops and Desktops
@@ -43,6 +43,7 @@ tools_software_languages_filter:
 - Git: 1
 - GitHub: 3
 - GitLab: 2
+- Google Benchmark: 1
 - Google Test: 1
 - HTML: 2
 - Hugging Face: 1
@@ -73,7 +74,7 @@ tools_software_languages_filter:
 - RDP: 1
 - Remote.It: 1
 - RME: 1
-- Runbook: 17
+- Runbook: 18
 - Rust: 2
 - SVE: 1
 - SVE2: 1

content/learning-paths/laptops-and-desktops/win_profile_guided_optimisation/_index.md

@@ -0,0 +1,50 @@
+---
+title: Optimize C++ performance with Profile-Guided Optimization and Google Benchmark
+
+draft: true
+cascade:
+    draft: true
+
+minutes_to_complete: 15
+
+who_is_this_for: Developers looking to optimize C++ performance on an Arm-based Windows device, based on runtime behavior.
+
+learning_objectives: 
+    - Microbenchmark a function using Google Benchmark.
+    - Apply profile-guided optimization to build performance-tuned binaries for Windows on Arm.
+
+prerequisites:
+    - Basic C++ understanding.
+    - Access to an Arm-based Windows machine.
+
+author: Tom Dunkle
+
+### Tags
+skilllevels: Introductory
+subjects: ML
+armips:
+    - Neoverse
+tools_software_languages:
+    - Google Benchmark
+    - Runbook
+operatingsystems:
+    - Windows
+
+further_reading:
+    - resource:
+        title: MSVC profile-guided optimization documentation
+        link: https://learn.microsoft.com/en-us/cpp/build/profile-guided-optimizations?view=msvc-170
+        type: documentation
+    - resource:
+        title: Google Benchmark Library 
+        link: https://github.com/google/benchmark
+        type: documentation
+
+
+
+### FIXED, DO NOT MODIFY
+# ================================================================================
+weight: 1                       # _index.md always has weight of 1 to order correctly
+layout: "learningpathall"       # All files under learning paths have this same wrapper
+learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
+---

content/learning-paths/laptops-and-desktops/win_profile_guided_optimisation/_next-steps.md

@@ -0,0 +1,8 @@
+---
+# ================================================================================
+#       FIXED, DO NOT MODIFY THIS FILE
+# ================================================================================
+weight: 21                  # Set to always be larger than the content in this path to be at the end of the navigation.
+title: "Next Steps"         # Always the same, html page title.
+layout: "learningpathall"   # All files under learning paths have this same wrapper for Hugo processing.
+---