Merge pull request #1437 from jasonrandrews/spelling

Modify Arm NN spelling

Author: jasonrandrews

content/learning-paths/smartphones-and-mobile/profiling-ml-on-arm/_index.md

@@ -12,8 +12,8 @@ learning_objectives:
 
 prerequisites:
     - An Arm-powered Android smartphone, and a USB cable to connect to it.
-    - For profiling the ML inference, [ArmNN's ExecuteNetwork](https://github.com/ARM-software/armnn/releases).
-    - For profiling the application, [Arm Performance Studio's Streamline](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio).
+    - For profiling the ML inference, [Arm NN ExecuteNetwork](https://github.com/ARM-software/armnn/releases).
+    - For profiling the application, [Arm Performance Studio with Streamline](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio).
     - Android Studio Profiler.
 
 

content/learning-paths/smartphones-and-mobile/profiling-ml-on-arm/_review.md

@@ -28,11 +28,11 @@ review:
         answers:
             - No.
             - Yes, Streamline just shows you out of the box.
-            - Yes, ArmNN's ExecuteNetwork can do this.
+            - Yes, Arm NN ExecuteNetwork can do this.
             - Yes, Android Studio Profiler can do this.
         correct_answer: 3          
         explanation: >
-            Standard profilers do not have an easy way to see what is happening inside an ML framework to see a model running inside it. ArmNN's ExecuteNetwork can do this for LiteRT models, and ExecuTorch has tools that can do this for PyTorch models.
+            Standard profilers do not have an easy way to see what is happening inside an ML framework to see a model running inside it. Arm NN ExecuteNetwork can do this for LiteRT models, and ExecuTorch has tools that can do this for PyTorch models.
 
 
 

content/learning-paths/smartphones-and-mobile/profiling-ml-on-arm/app-profiling-streamline.md

@@ -204,7 +204,7 @@ For the example project, add it into the `onCreate()` function of `MainActivity.
 
 In the example app, you can add this in the `onCreate()` function of `MainActivity.kt` after the `Module.load()` call to load the `model.pth`.
 
-This *colored marker with a string* annotation will add the string and time to Streamline's log view, and it appears like the image shown below in Streamline's timeline (in the example app, ArmNN is not used, so there are no white ArmNN markers):
+This *colored marker with a string* annotation will add the string and time to Streamline's log view, and it appears like the image shown below in Streamline's timeline (in the example app, Arm NN is not used, so there are no white Arm NN markers):
 
 ![Streamline image alt-text#center](streamline_marker.png "Figure 2. Streamline timeline markers")
 

content/learning-paths/smartphones-and-mobile/profiling-ml-on-arm/nn-profiling-executenetwork.md

@@ -6,18 +6,18 @@ weight: 6
 layout: learningpathall
 ---
 
-## ArmNN's Network Profiler
-One way of running LiteRT models is to use ArmNN, which is open-source network machine learning (ML) software. This is available as a delegate to the standard LiteRT interpreter. But to profile the model, ArmNN comes with a command-line utility called `ExecuteNetwork`. This program runs the model without the rest of the app. It is able to output layer timings and other useful information to report where there might be bottlenecks within your model.
+## Arm NN Network Profiler
+One way of running LiteRT models is to use Arm NN, which is open-source network machine learning (ML) software. This is available as a delegate to the standard LiteRT interpreter. But to profile the model, Arm NN comes with a command-line utility called `ExecuteNetwork`. This program runs the model without the rest of the app. It is able to output layer timings and other useful information to report where there might be bottlenecks within your model.
 
-If you are using LiteRT without ArmNN, then the output from `ExecuteNetwork` is more of an indication than a definitive answer, but it can still be useful in identifying any obvious problems.
+If you are using LiteRT without Arm NN, then the output from `ExecuteNetwork` is more of an indication than a definitive answer, but it can still be useful in identifying any obvious problems.
 
 ### Download a LiteRT Model
 
 To try this out, you can download a LiteRT model from the [Arm Model Zoo](https://github.com/ARM-software/ML-zoo). Specifically for this Learning Path, you will download [mobilenet tflite](https://github.com/ARM-software/ML-zoo/blob/master/models/image_classification/mobilenet_v2_1.0_224/tflite_int8/mobilenet_v2_1.0_224_INT8.tflite).
 
 ### Download and setup ExecuteNetwork
 
-You can download `ExecuteNetwork` from the [ArmNN GitHub](https://github.com/ARM-software/armnn/releases). Download the version appropriate for the Android phone that you are testing on, ensuring that it matches the Android version and architecture of the phone. If you are unsure of the architecture, you can use a lower one, but you might miss out on some optimizations.`ExecuteNetwork` is included inside the `tar.gz` archive that you download. Among the other release downloads on the ArmNN Github is a separate file for the `aar` delegate which you can also easily download.
+You can download `ExecuteNetwork` from the [Arm NN GitHub](https://github.com/ARM-software/armnn/releases). Download the version appropriate for the Android phone that you are testing on, ensuring that it matches the Android version and architecture of the phone. If you are unsure of the architecture, you can use a lower one, but you might miss out on some optimizations.`ExecuteNetwork` is included inside the `tar.gz` archive that you download. Among the other release downloads on the Arm NN Github is a separate file for the `aar` delegate which you can also easily download.
 
 To run `ExecuteNetwork,` you need to use `adb` to push the model and the executable to your phone, and then run it from the adb shell. `adb` is included with Android Studio, but you might need to add it to your path. Android Studio normally installs it to a location such as:
 
@@ -31,7 +31,7 @@ adb push ExecuteNetwork /data/local/tmp/
 adb push libarm_compute.so /data/local/tmp/
 adb push libarmnn.so /data/local/tmp/
 adb push libarmnn_support_library.so /data/local/tmp/
-# more ArmNN .so library files
+# more Arm NN .so library files
 ```
 Push all the `.so` library files that are in the base folder of the `tar.gz` archive you downloaded, alongside `ExecuteNetwork`, and all the `.so` files in the `delegate` sub-folder. 
 
@@ -74,7 +74,7 @@ Depending on the size of your model, the output will probably be quite large. Yo
 
 At the top is the summary, with the setup time and inference time of the two runs, which look something like this:
 
-```text
+```output
 Info: ArmNN v33.2.0
 Info: Initialization time: 7.20 ms.
 Info: ArmnnSubgraph creation

content/learning-paths/smartphones-and-mobile/profiling-ml-on-arm/nn-profiling-general.md

@@ -11,8 +11,8 @@ App profilers provide a good overall view of performance, but you might want to
 
 With general profilers this is hard to do, as there needs to be annotation inside the ML framework code to retrieve the information. It is a complex task to write the profiling annotation throughout the framework, so it is easier to use tools from a framework or inference engine that already has the required instrumentation.
 
-Depending on the model you use, your choice of tools will vary. For example, if you are using LiteRT (formerly TensorFlow Lite), Arm provides the ArmNN delegate that you can run with the model running on Linux or Android, CPU or GPU. 
+Depending on the model you use, your choice of tools will vary. For example, if you are using LiteRT (formerly TensorFlow Lite), Arm provides the Arm NN delegate that you can run with the model running on Linux or Android, CPU or GPU. 
 
-ArmNN in turn provides a tool called ExecuteNetwork that can run the model and provide layer timings, amongst other useful information.
+Arm NN in turn provides a tool called ExecuteNetwork that can run the model and provide layer timings, amongst other useful information.
 
 If you are using PyTorch, you will probably use ExecuTorch, which is the on-device inference runtime for your Android phone. ExecuTorch has a profiler available alongside it.

content/learning-paths/smartphones-and-mobile/profiling-ml-on-arm/plan.txt

@@ -13,7 +13,7 @@ here's how to do that...
 Also Android Profiler, memory example
 
 Ml network, it will depend on the inference engine you are using
-- here's an example for if you are using ArmNN with TFLite
+- here's an example for if you are using Arm NN with TFLite
 - if you're not using it, it may still have some useful information, but different operators will be used and their performance will be different
 can see structure with netron or google model explorer to compare operators or different versions of networks
 may need to use a conversion tool to convert to TFLite (or whatever your inference engine wants)

content/learning-paths/smartphones-and-mobile/totalcompute/_review.md

@@ -28,10 +28,10 @@ review:
             - "Trusted firmware"
             - "Android"
             - "CMSIS"
-            - "ArmNN"
+            - "Arm NN"
         correct_answer: 3
         explanation: >
-            The stack includes open-source code available from these upstream projects: SCP firmware, Trusted firmware, Linux kernel, Android, and ArmNN.
+            The stack includes open-source code available from these upstream projects: SCP firmware, Trusted firmware, Linux kernel, Android, and Arm NN.
 
 
 # ================================================================================

content/learning-paths/smartphones-and-mobile/totalcompute/build.md

@@ -7,7 +7,7 @@ weight: 2 # 1 is first, 2 is second, etc.
 # Do not modify these elements
 layout: "learningpathall"
 ---
-The [Arm Total Compute](https://developer.arm.com/Tools%20and%20Software/Total%20Compute) reference software stack is a fully integrated open-source stack, from firmware up to Android. he stack includes open-source code available from the relevant upstream projects: SCP firmware, Trusted firmware, Linux kernel, Android, and ArmNN.
+The [Arm Total Compute](https://developer.arm.com/Tools%20and%20Software/Total%20Compute) reference software stack is a fully integrated open-source stack, from firmware up to Android. he stack includes open-source code available from the relevant upstream projects: SCP firmware, Trusted firmware, Linux kernel, Android, and Arm NN.
 
 ## Download and install the FVP