diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/1-introduction.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/1-introduction.md index d414b18abd..1e4d15a911 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/1-introduction.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/1-introduction.md @@ -13,7 +13,9 @@ Arm ML Inference Advisor (MLIA) helps you evaluate a model for an Arm target bef You'll use the `mlia-neural-technology` package to evaluate two pretrained, quantized MobileNet V1 image classifiers from the TensorFlow public model catalog. You'll compare a baseline with a smaller-input variant under the same Neural Technology configuration. You don't need a model stored in this repository or a device to run the estimator. -The tested example reduces estimated total cycles from `136,962` to `79,824`. These are compiler estimates, not device measurements or an accuracy result. You'll learn about the model and configuration assumptions behind this comparison in [Compare a smaller model under the same target profile](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/6-iterate-and-compare/). +The reference example, recorded with Neural Technology `0.2.0` and LiteRT converter `0.1.2`, reduces estimated total cycles from `136,962` to `79,824`. These are compiler estimates, not device measurements or an accuracy result. You'll learn about the model and configuration assumptions behind this comparison in [Compare a smaller model under the same target profile](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/6-iterate-and-compare/). + +The setup installs Neural Technology `0.3.0` and LiteRT converter `0.1.3`, so your generated estimates can differ from this reference. Neural Technology `0.3.0` is required for the optional ETRecord and ETDump VGF profiling workflow. If you have a neural accelerator (NX)-capable Android device and a compatible native Vulkan driver, you can execute the model on the device. You can then bring a measured capture back to MLIA. For more information, see [(Optional) Run and profile the model on an NX device](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/7-run-on-nx-device/). @@ -21,7 +23,9 @@ If you have a neural accelerator (NX)-capable Android device and a compatible na The [Analyze Ethos-U models with MLIA Learning Path](/learning-paths/embedded-and-microcontrollers/analyze-ethos-u-models-with-mlia/) applies the same workflow to Arm Ethos-U: select a target profile, check compatibility, inspect performance, and use the advice to guide your next change. It uses Vela for compiler estimates and Corstone for whole-model NPU performance counters. In this Learning Path, you'll use the Neural Technology plugin and NX Performance Estimator, with optional measurements from an Android device. -The report-reading approach carries across targets, but their backends, supported operators, and performance metrics differ. Don't compare cycle counts across targets assuming that they describe the same hardware configuration. +The report-reading approach carries across targets, but their backends, supported operators, and performance metrics differ. Don't compare cycle counts across targets assuming that they describe the same hardware configuration. For an editor-based visual workflow, see the [Ethos-U VS Code and Model Explorer walkthrough](/learning-paths/embedded-and-microcontrollers/analyze-ethos-u-models-with-mlia/7-vscode-plugin/). + +If you already have an ExecuTorch ETRecord and matching ETDump from a deployed program, you can also [analyze recorded runtime timings and VGF profiling](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/8-executorch-profiling/). This optional workflow uses different artifacts from the Scenario Runner capture directory. ## Understand the conversion and analysis flow diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/2-devenv.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/2-devenv.md index 47fd8d8eed..1c6671f9c2 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/2-devenv.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/2-devenv.md @@ -9,7 +9,7 @@ layout: learningpathall ## Perform an environment check -Use an x86-64 Ubuntu 24.04 LTS development host with CPython 3.12. The `mlia-neural-technology` version `0.2.0` wheel is published for CPython 3.12 on x86-64 Linux with glibc version 2.39 or later. Ubuntu 22.04, other Python versions, native macOS, and native Linux on Arm aren't supported by this wheel. +Use an x86-64 Ubuntu 24.04 LTS development host with CPython 3.12. The `mlia-neural-technology` version `0.3.0` wheel is published for CPython 3.12 on x86-64 Linux with glibc version 2.39 or later. Ubuntu 22.04, other Python versions, native macOS, and native Linux on Arm aren't supported by this wheel. Check your architecture, Python version, and glibc version: @@ -40,7 +40,7 @@ cd mlia-demo python3.12 -m venv mlia-venv source mlia-venv/bin/activate python -m pip install --upgrade pip -python -m pip install mlia-neural-technology==0.2.0 mlia-converters-litert==0.1.2 +python -m pip install mlia==0.13.0 mlia-neural-technology==0.3.0 mlia-converters-litert==0.1.3 python -m pip check ``` @@ -52,6 +52,8 @@ These are public PyPI packages. The Neural Technology plugin installs the follow The LiteRT converter plugin lets MLIA analyze `.tflite` files directly. You don't need TensorFlow, a GPU driver, or a separate model-training environment for this example. +Neural Technology `0.3.0` requires MLIA core `0.13.x`. LiteRT converter `0.1.3` supports this core version. Upgrade these packages together when reusing an existing environment. + The expected output is: ```output @@ -76,6 +78,19 @@ The estimator executable is bundled with the public wheel. MLIA offers to instal If `pip` reports that no matching distribution exists for `mlia-neural-technology`, check the three host requirements again and upgrade `pip` inside the environment. A virtual environment doesn't change the host architecture or glibc version. Don't substitute an older Python version or Ubuntu 22.04 for this release. {{% /notice %}} +## (Optional) Prepare Model Explorer visualizations + +The [MLIA Model Explorer plugin](https://pypi.org/project/mlia-model-explorer/) adds graph visualizations with performance overlays. Version `0.2.0` supports MLIA core `0.13.x`. The `vgf` extra includes the adapter for the compiled model you'll inspect later. The plugin generates a standalone HTML page that you can open directly in your browser. You don't need to install Model Explorer separately or run additional services. + +Install the plugin in the same environment: + +```bash +python -m pip install "mlia-model-explorer[vgf]==0.2.0" +python -m pip check +``` + +The expected output from `pip check` is `No broken requirements found.` The [ExecuTorch profiling steps](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/8-executorch-profiling/) install an additional extra for ETRecord and PTE adapters. + ## What you've accomplished and what's next You've installed MLIA with the Neural Technology and LiteRT converter plugins. diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/4-install-backend-compatibility-check.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/4-install-backend-compatibility-check.md index bdd02a8700..16b4ff9796 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/4-install-backend-compatibility-check.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/4-install-backend-compatibility-check.md @@ -40,7 +40,7 @@ assert not failed_checks, "Review the non-passing operator checks." PY ``` -The expected output for the pinned packages and baseline is: +The reference output for the baseline is: ```output Compatibility status: ok diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/5-performance-check.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/5-performance-check.md index 69801dc89a..ce09e13c27 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/5-performance-check.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/5-performance-check.md @@ -15,7 +15,7 @@ Run a performance check with the same model and target profile: mlia check models/baseline.tflite --target-profile neural-technology --performance --output-dir runs/baseline ``` -With the tested packages and `neural-technology` profile, expect an estimated `136,962` total cycles and about `0.09131 ms` per inference. +The reference run with Neural Technology `0.2.0`, LiteRT converter `0.1.2`, and the `neural-technology` profile produced an estimated `136,962` total cycles and about `0.09131 ms` per inference. The setup now uses Neural Technology `0.3.0` and LiteRT converter `0.1.3`; use your generated report for the current result. These figures are compiler estimates, rather than timings measured on a device. ## Locate and read the reports @@ -48,7 +48,7 @@ for name in ("total_cycles", "compute_cycles", "dram_cycles", "inference_time", PY ``` -The expected output is: +The reference output is: ```output total_cycles: 136962 cycles @@ -64,6 +64,30 @@ For the baseline, `dram_cycles` is `94,396`, compared with `34,976` compute cycl Use `results[].breakdowns` and their `entity_id` links to `results[].entities` to inspect individual chains and cascades. These are compiler scheduling groups. They're not necessarily one framework layer each. Source-operator provenance helps you relate those groups to the original graph. Some metrics overlap or use non-additive aggregation policies, so don't sum every breakdown to recreate the model total. +## (Optional) Explore results in Model Explorer + +After installing the compatible Model Explorer plugin in [Set up your MLIA environment](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/2-devenv/#optional-prepare-model-explorer-visualizations), rerun the check into a separate directory with visualization enabled: + +```bash +mlia check models/baseline.tflite \ + --target-profile neural-technology \ + --performance \ + --output-dir runs/baseline-visualized \ + --model-explorer open +``` + +`--model-explorer open` creates a self-contained HTML visualization and opens it in your browser. Use `--model-explorer files` to generate the files without opening a browser. If the browser doesn't open, open `runs/baseline-visualized/mlia-output/model-explorer/bundle/index.html` manually. + +Inspect the generated MLIA hierarchy alongside **Source Model**: + +1. Select a cycle metric in the node-data controls to color the hierarchy by cost. +2. Expand the hierarchy and select a chain or cascade to read its reported values. +3. Follow its mapping to **Source Model**, where available, to find the related model operations. + +Use these overlays to find scheduling groups worth investigating. A group can contain several operations, so its cost isn't a separate measurement for each operation. Keep using the model-level report for whole-model totals. + +For the editor workflow, follow the [Ethos-U VS Code and Model Explorer walkthrough](/learning-paths/embedded-and-microcontrollers/analyze-ethos-u-models-with-mlia/7-vscode-plugin/). Its example uses Ethos-U and Vela; use the NX metrics from this analysis when exploring your results. + ## (Optional) Compare a different built-in profile Keep the model unchanged when exploring a different target configuration. For example, run the peak profile into its own directory: diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/6-iterate-and-compare.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/6-iterate-and-compare.md index c0722b5588..b83b1e906b 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/6-iterate-and-compare.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/6-iterate-and-compare.md @@ -63,7 +63,7 @@ for name in ("total_cycles", "inference_time", "inferences_per_second", "dram_cy print(f"{name}: {before:.5f} -> {after:.5f} ({change:+.2f}%)") PY ``` -The following table includes example results: +The following table contains reference results recorded with Neural Technology `0.2.0` and LiteRT converter `0.1.2`. Compare your own reports after installing the updated packages: | Metric | Baseline, 224 × 224 | Smaller, 128 × 128 | Change | | --- | ---: | ---: | ---: | diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/7-run-on-nx-device.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/7-run-on-nx-device.md index 462f83f0b9..af0c1f71a5 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/7-run-on-nx-device.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/7-run-on-nx-device.md @@ -236,6 +236,47 @@ Your cycle counts will depend on your device and its configuration. To inspect measured NX performance in Model Explorer and trace costs to Python source, follow [Capture and analyze NX profiling data with MLIA for VS Code](/learning-paths/mobile-graphics-and-gaming/profile-nx-with-mlia-vscode/). +## (Optional) Explore measured performance and TOSA operations + +After installing the compatible Model Explorer plugin in [Set up your MLIA environment](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/2-devenv/#optional-prepare-model-explorer-visualizations), rerun the measured analysis with the same VGF and complete capture directory: + +```bash +mlia check nx-demo/baseline.vgf \ + --target-profile neural-technology \ + --performance \ + --profiling-data "nx-demo/captures/$CAPTURE_NAME" \ + --output-dir runs/baseline-measured-visualized \ + --model-explorer open +``` + +### View measured cycle counts + +The command opens Model Explorer with the capture's results already loaded. In the generated MLIA hierarchy, select a cycle metric using the node-data controls. Expand the hierarchy and select an entity to inspect its reported cycle count. Follow the source mapping, where available, to see related operations in **Source Model**. + +A source mapping associates operations with measured execution groups. It doesn't necessarily provide an independent cycle measurement for each operation. Several operations can share the same group measurement, so don't sum their displayed cycle counts as separate costs. + +These overlays show the capture's measurements. Only entities with reported metrics have values; a missing value doesn't mean zero cycles. The `951,154` cycles in the reference CLI output describe the whole-model result, rather than the selected convolution. + +MLIA saves the visualization in `runs/baseline-measured-visualized/mlia-output/model-explorer/bundle/index.html`. Open this self-contained file to revisit or share the results without rerunning the capture or starting a server. + +### Inspect a TOSA convolution + +In **Source Model**, inspect `nx-demo/baseline.vgf`. The reference graph contains 103 nodes. Expand `graph_segment_0` and select the first `CONV2D` node, between two `RESCALE` nodes. Your graph can differ with compiler or package changes. + +This view exposes the TOSA operations in the VGF graph. You can see how the original MobileNet layer is represented after MLIA's LiteRT-to-TOSA conversion and VGF generation. The screenshot shows the operation's attributes. + +![Model Explorer shows a TOSA CONV2D operation between two RESCALE nodes in baseline.vgf. The Attributes panel links to the TOSA CONV2D specification and shows the MobileNet source location, connecting the converted operation to its definition and original model.#center](model-explorer-conv2d.png "Inspect a TOSA convolution in the VGF graph") + +In **ATTRIBUTES**, **opcode** identifies the TOSA operation as `CONV2D`. Select **TOSA spec: CONV2D** in the **spec** field to open the operator definition. Compare it with the values shown for this node: + +| Field | Value in the reference graph | What it tells you | +| --- | --- | --- | +| **result type** | `uint32[1, 112, 112, 8]` | The intermediate tensor has a batch size of one, 112 × 112 spatial dimensions, and eight channels. | +| **arg1 stride** | `int32[2, 2]` | A stride of two reduces the 224 × 224 input to 112 × 112. | +| **debug info** | `MobilenetV1/MobilenetV1/Conv2d_0/Relu6` | Relates the TOSA operation to its source location in MobileNet. Expand the field to read the full name. | + +Select the following `RESCALE` node to inspect how TOSA scales the convolution's intermediate integer result into the output's quantized range. Search for `DEPTHWISE_CONV2D` and follow its specification link to compare the two convolution operators. + ## Use the measurements @@ -249,3 +290,5 @@ Check the predictions on real images as well. A faster model isn't useful if it You've run the VGF file on an NX-capable device, checked that Scenario Runner completed, and confirmed that the neural statistics capture contains data. You've also returned the capture to MLIA for measured analysis. Use this evidence alongside model accuracy tests and end-to-end application profiling before making deployment decisions for your own use cases. + +If your deployment uses ExecuTorch, continue with [Analyze ExecuTorch ETRecord and ETDump profiling](/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/8-executorch-profiling/) using artifacts from that deployed program. diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/8-executorch-profiling.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/8-executorch-profiling.md new file mode 100644 index 0000000000..0c062544f9 --- /dev/null +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/8-executorch-profiling.md @@ -0,0 +1,140 @@ +--- +title: (Optional) Analyze ExecuTorch ETRecord and ETDump profiling +description: Analyze matching ExecuTorch ETRecord and ETDump artifacts with MLIA, inspect runtime timings and VGF cycles, and optionally explore a companion PTE graph. +weight: 9 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Prepare artifacts from your ExecuTorch deployment + +Use this workflow when your application runs an ExecuTorch program and you've already captured its profiling data in an ETDump file. MLIA reads the captured data and reports measured performance. The earlier LiteRT conversion and Scenario Runner steps don't generate these artifacts. + +Collect the following files from the same deployed program and model build: + +| Artifact | Contents | +| --- | --- | +| `model.etrecord` or `model.bin` | Recorded model graphs and debug mappings generated during export | +| `run.etdump` or `run.etdp` | One matching runtime capture, including VGF profiling when enabled | +| `model.pte` (optional) | The deployed program containing a VGF delegate, for companion graph associations | + +For artifact generation, see the [ExecuTorch 1.5 profiling tutorial](https://docs.pytorch.org/executorch/1.5/tutorials/devtools-integration-tutorial.html). For VGF-specific guidance, see [VGF neural accelerator statistics in ETDump](https://docs.pytorch.org/executorch/stable/backends/arm-vgf/vgf-neural-statistics.html) to enable statistics collection. The [ExecuTorch 1.0 Arm VGF backend tutorial](https://docs.pytorch.org/executorch/1.0/tutorial-arm-vgf.html) demonstrates building and running a VGF-delegated model with `executor_runner`. Use the compatible toolchain version specified in the installation steps when generating your artifacts. + +VGF cycle analysis additionally requires VGF profiling data in the ETDump. An ordinary runtime-only capture can provide source timings, but it can't provide VGF counters or companion VGF associations. + +Run the remaining commands from `mlia-demo`. Copy your artifacts into a new `et-profile` directory and use the example filenames above, or substitute their paths in the commands. Keep the original files together so that you can confirm which export and execution produced them. + +## Install the ExecuTorch analysis support + +Activate the environment from the setup page and install the Neural Technology `executorch` extra: + +```bash +source mlia-venv/bin/activate +python -m pip install "mlia-neural-technology[executorch]==0.3.0" mlia-converters-pytorch==0.1.4 +python -m pip check +``` + +This extra installs the shared ExecuTorch artifact readers from `mlia-converters-pytorch`. Neural Technology provides the runtime analysis, VGF decoding, and NX metrics. The converter package requires ExecuTorch `1.5.1`; use compatible artifacts from that toolchain. + +The expected output from `pip check` is `No broken requirements found.` Model Explorer is optional for the analysis itself. + +## Analyze the matching ETRecord and ETDump + +Run a measured performance check: + +```bash +mlia check et-profile/model.etrecord \ + --target-profile neural-technology \ + --performance \ + --profiling-data et-profile/run.etdump \ + --output-dir runs/executorch-measured +``` + +`--profiling-data` selects the measured backend automatically. Use performance analysis for this workflow; compatibility analysis belongs to the earlier model-based checks. + +For an ETRecord with several methods, select the method that produced the dump. For example, append the following option for a method named `decode`: + +```text +--neural-technology-profiling-data.etrecord-method decode +``` + +Single-method selection is automatic. If method selection or graph mapping fails, check that the artifacts come from the same deployed program and selected method. + +Inspect the saved results and warnings: + +```bash +python - <<'PY' +import json +from pathlib import Path + +report_path = Path("runs/executorch-measured/mlia-output/mlia-output.json") +report = json.loads(report_path.read_text()) +results = [result for result in report["results"] if result["kind"] == "performance"] +assert results, "No performance results found. Review the MLIA log." +for result in results: + assert result["status"] == "ok", "Review the performance result for errors." + assert result.get("mode") == "measured", "Expected measured profiling data." + print(json.dumps(result, indent=2)) +PY +``` + +The check confirms that MLIA produced successful measured performance results and prints their metrics, breakdowns, and any warnings. Values depend on your capture. Check the reported execution coverage and decoder assumptions before treating cycle summaries as full-inference costs. + +## (Optional) Open the profiling views in Model Explorer + +Use MLIA Model Explorer `0.2.0`, which supports MLIA core `0.13.x`. Install its `executorch` extra in the same environment, even if you installed the `vgf` extra during setup: + +```bash +python -m pip install "mlia-model-explorer[executorch]==0.2.0" +python -m pip check +``` + +The extra includes ETRecord, PTE, and VGF adapters. After `pip check` succeeds, rerun the analysis into a separate directory and request a visualization: + +```bash +mlia check et-profile/model.etrecord \ + --target-profile neural-technology \ + --performance \ + --profiling-data et-profile/run.etdump \ + --output-dir runs/executorch-visualized \ + --model-explorer open +``` + +If you also have the matching deployed VGF-backed PTE and VGF profiling in the dump, append `--companion-model et-profile/model.pte` to add its compiler graph. Supplying a companion alone doesn't enable visualization. Runtime-only captures support visualization without a companion. + +Use `--model-explorer files` to generate the files without opening a browser. The standalone page is `runs/executorch-visualized/mlia-output/model-explorer/bundle/index.html`. + +In Model Explorer, inspect the views available for your capture: + +| View | What to inspect | +| --- | --- | +| **Source Model** | Source operators and available runtime timings | +| **segment_cascade_chain** | Captured NX hierarchy and cycle measurements | +| **ETRecord Chain Mapping** | Chains associated with source operators; the initial detailed view when available | +| **ETDump Backend Trace** | Compiler operations and their measured chain groups | +| **PTE - VGF Backend Hierarchy** | Companion compiler graph and associated chain groups, when supplied | + +Select a mapped operator or group to navigate between related views. Compiler transformations can rename, insert, combine, or reorder operations, so some source links can be incomplete or absent. Unmatched compiler operations remain visible. A missing link doesn't establish that an operation wasn't executed or that its chain has no profiling data. + +## Interpret runtime timings and NX counters + +Ordinary runtime timings use milliseconds. VGF counters use cycles and describe recorded accelerator activity. Cycle counters don't reconstruct idle gaps or establish elapsed latency. + +For older captures missing decoder metadata, MLIA assumes statistics mode `1` and the Mali-G2 device layout. Check the reported assumptions against your capture settings. + +Repeated executions provide averages, minimum, maximum, P50, and execution counts where supported. Independent observations are combined within each recorded execution before summaries are calculated. Don't add minimum, maximum, P50, or execution counts across operators. Averages can be combined only when their measurements are independent and cover the same executions. + +A runtime event can cover several source operators. Each associated operator can display the same shared timing; that value isn't an independent cost for each operator. VGF chain or cascade measurements can also cover several compiler operations. Use the authoritative hierarchy measurements and model-level results instead of summing every overlay or hierarchy level. + +Mixed-backend dumps keep ordinary runtime timings separate from VGF counters. Instructions with VGF profiling are excluded from ordinary runtime aggregation to avoid counting the same work twice. Runtime event counts describe contributing event records, rather than the number of complete inferences. + +MLIA doesn't estimate missing measurements. If instructions or segments cover different executions, model cycle summaries can be unavailable with a warning while individual measurements remain available. Even matching coverage doesn't prove every expected stripe was captured. Review warnings and, for older captures, any assumed statistics mode or device layout. + +Companion matching checks structural compatibility and assumes you supplied the matching PTE. It doesn't prove that the PTE produced the capture. Model Explorer checks that the companion file hasn't changed since analysis; rerun analysis if it has. + +## What you've accomplished + +You've analyzed an ExecuTorch ETRecord/ETDump pair and checked its measured results. With a compatible Model Explorer installation, you can also inspect runtime timings, NX hierarchy measurements, and optional companion graph associations. + +Use the measured costs to select a model change to investigate. Repeat the capture under the same conditions and validate accuracy before drawing deployment conclusions. diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md index f663372071..7c253f7ac7 100644 --- a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md +++ b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/_index.md @@ -10,7 +10,7 @@ who_is_this_for: This Learning Path is for machine learning (ML) engineers and g learning_objectives: - Install the public Arm ML Inference Advisor (MLIA) Neural Technology plugin and discover its target profiles and backend. - Analyze public quantized MobileNet models with automatic model conversion. - - Check operator compatibility and interpret NX Performance Estimator reports. + - Check operator compatibility and interpret NX estimates, measured profiling results, and optional Model Explorer overlays. - Compare model variants under the same target configuration and identify accuracy tradeoffs. prerequisites: diff --git a/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/model-explorer-conv2d.png b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/model-explorer-conv2d.png new file mode 100644 index 0000000000..d68dbed138 Binary files /dev/null and b/content/learning-paths/mobile-graphics-and-gaming/mlia-nx-performance-estimator/model-explorer-conv2d.png differ