Merge pull request #2655 from madeline-underwood/tensor

Tensor_JA to sign off

Author: jasonrandrews

content/learning-paths/servers-and-cloud-computing/tensorflow-gcp/_index.md

@@ -1,22 +1,17 @@
 ---
 title: Deploy TensorFlow on Google Cloud C4A (Arm-based Axion VMs)
-
-draft: true
-cascade:
-    draft: true
-    
 minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for software developers deploying and optimizing TensorFlow workloads on Arm64 Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors. 
+who_is_this_for: This is an introductory topic for software developers deploying and optimizing TensorFlow workloads on Arm64 Linux environments, specifically using Google Cloud C4A virtual machines powered by Axion processors.
 
 learning_objectives:
-  - Provision an Arm-based SUSE SLES virtual machine on Google Cloud (C4A with Axion processors)
+  - Provision an Arm-based SUSE Linux Enterprise Server (SLES) virtual machine on Google Cloud (C4A with Axion processors)
   - Install TensorFlow on a SUSE Arm64 (C4A) instance
-  - Verify TensorFlow by running basic computation and model training tests on Arm64  
-  - Benchmark TensorFlow using tf.keras to evaluate inference speed and model performance on Arm64 systems.
+  - Verify TensorFlow by running basic computation and model training tests on Arm64
+  - Benchmark TensorFlow using TensorFlow Keras (`tf.keras`) to evaluate inference speed and model performance on Arm64 systems
 
 prerequisites:
-  - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled  
+  - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled
   - Basic familiarity with [TensorFlow](https://www.tensorflow.org/)
 
 author: Pareena Verma
@@ -45,16 +40,14 @@ further_reading:
       title: Google Cloud documentation
       link: https://cloud.google.com/docs
       type: documentation
-
   - resource:
       title: TensorFlow documentation
       link: https://www.tensorflow.org/learn
       type: documentation
-  
   - resource:
       title: Phoronix Test Suite (PTS) documentation
       link: https://www.phoronix-test-suite.com/
-      type: documentation   
+      type: documentation
 
 weight: 1
 layout: "learningpathall"

content/learning-paths/servers-and-cloud-computing/tensorflow-gcp/background.md

@@ -1,24 +1,27 @@
 ---
-title: Getting started with TensorFlow on Google Axion C4A (Arm Neoverse-V2)
+title: Get started with TensorFlow on Google Axion C4A
 
 weight: 2
 
 layout: "learningpathall"
 ---
 
-## Google Axion C4A Arm instances in Google Cloud
+## Explore Google Axion C4A Arm instances in Google Cloud
 
-Google Axion C4A is a family of Arm-based virtual machines built on Google’s custom Axion CPU, which is based on Arm Neoverse-V2 cores. Designed for high-performance and energy-efficient computing, these virtual machines offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
+Google Axion C4A is a family of Arm-based virtual machines (VMs) that use Google’s custom Axion CPU, based on Arm Neoverse-V2 cores. Designed for high-performance and energy-efficient computing, these VMs offer strong performance for modern cloud workloads such as CI/CD pipelines, microservices, media processing, and general-purpose applications.
 
-The C4A series provides a cost-effective alternative to x86 virtual machines while leveraging the scalability and performance benefits of the Arm architecture in Google Cloud.
+The C4A series provides a cost-effective alternative to x86 VMs while using the scalability and performance benefits of the Arm architecture in Google Cloud.
 
-To learn more about Google Axion, refer to the [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu) blog.
+To learn more about Google Axion, see the [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu) blog.
 
-## TensorFlow 
+## Explore TensorFlow
 
-[TensorFlow](https://www.tensorflow.org/) is an **open-source machine learning and deep learning framework** developed by **Google**.  It helps developers and researchers **build, train, and deploy AI models** efficiently across **CPUs, GPUs, and TPUs**.
+[TensorFlow](https://www.tensorflow.org/) is an open-source machine learning and deep learning framework developed by Google. It helps developers and researchers build, train, and deploy AI models efficiently across CPUs, GPUs, and TPUs.
 
-With support for **neural networks**, **natural language processing (NLP)**, and **computer vision**, TensorFlow is widely used for **AI research and production**.  
-Its **flexibility** and **scalability** make it ideal for both **cloud** and **edge environments**.
+With support for neural networks, natural language processing (NLP), and computer vision, TensorFlow is widely used for AI research and production. Its flexibility and scalability make it ideal for both cloud and edge environments.
 
 To learn more, visit the [official TensorFlow website](https://www.tensorflow.org/).
+
+## Next steps
+
+Now that you understand Google Axion C4A Arm-based VMs and TensorFlow fundamentals, you can provision your own VM and start benchmarking machine learning workloads on Google Cloud.

content/learning-paths/servers-and-cloud-computing/tensorflow-gcp/baseline.md

@@ -1,5 +1,5 @@
 ---
-title: Test TensorFlow baseline performance on Google Axion C4A Arm virtual machines
+title: Test TensorFlow baseline performance on Google Axion C4A 
 weight: 5
 
 ### FIXED, DO NOT MODIFY
@@ -8,11 +8,11 @@ layout: learningpathall
 
 ## Perform baseline testing
 
-This section helps you verify that TensorFlow is properly installed and working on your Google Axion C4A VM. You'll run tests to confirm that your CPU can perform TensorFlow operations correctly.
+This section helps you confirm that TensorFlow is installed and working correctly on your Google Axion C4A Arm virtual machine (VM). You'll run tests to check that your CPU can perform TensorFlow operations and basic neural network training.
 
-### Check available devices
+## Check available devices
 
-This command shows which hardware devices TensorFlow can use, such as CPU or GPU. On most VMs, you'll see only CPU listed:
+List the hardware devices TensorFlow can use, such as CPU or GPU. On most VMs, only the CPU is available:
 
 ```console
 python -c "import tensorflow as tf; print(tf.config.list_physical_devices())"
@@ -24,30 +24,28 @@ The output is similar to:
 [PhysicalDevice(name='/physical_device:CPU:0', device_type='CPU')]
 ```
 
-### Run a computation test
+## Run a computation test
 
-This test multiplies two large matrices to verify that TensorFlow computations work correctly on your CPU and measures execution time:
+Multiply two large matrices to verify TensorFlow computations on your CPU and measure execution time:
 
 ```console
-python -c "import tensorflow as tf; import time; 
-a = tf.random.uniform((1000,1000)); b = tf.random.uniform((1000,1000));
-start = time.time(); c = tf.matmul(a,b); end = time.time(); 
+python -c "import tensorflow as tf; import time; \
+a = tf.random.uniform((1000,1000)); b = tf.random.uniform((1000,1000)); \
+start = time.time(); c = tf.matmul(a,b); end = time.time(); \
 print('Computation time:', end - start, 'seconds')"
 ```
 
-This checks CPU performance for basic operations and provides a baseline measurement.
-
 The output is similar to:
 
 ```output
 Computation time: 0.008263111114501953 seconds
 ```
 
-### Test neural network execution
+This provides a baseline measurement for CPU performance.
 
-Use a text editor to create a new file named `test_nn.py` for testing a simple neural network.
+## Test neural network execution
 
-Add the following code to create and train a basic neural network using random data:
+Create a file named `test_nn.py` with the following code:
 
 ```python
 import keras
@@ -61,7 +59,7 @@ y = np.random.rand(1000, 1)
 # Define the model
 model = keras.Sequential()
 model.add(keras.Input(shape=(20,)))
-model.add(layers.Dense(64,activation="relu"))
+model.add(layers.Dense(64, activation="relu"))
 model.add(layers.Dense(1))
 
 # Compile the model
@@ -71,9 +69,9 @@ model.compile(optimizer='adam', loss='mse')
 model.fit(x, y, epochs=1, batch_size=32)
 ```
 
-This script creates a simple neural network to verify that TensorFlow's deep learning functions work properly on the Arm platform.
+This script creates and trains a basic neural network using random data to verify that TensorFlow's deep learning functions work on the Arm platform.
 
-### Run the neural network test
+## Run the neural network test
 
 Execute the script:
 
@@ -87,4 +85,4 @@ TensorFlow displays training progress similar to:
 32/32 ━━━━━━━━━━━━━━━━━━━━ 0s 1ms/step - loss: 0.1024
 ```
 
-This confirms that TensorFlow is working correctly on your Arm VM and can perform both basic computations and neural network training.
+TensorFlow is working correctly on your Arm-based VM for both basic computations and neural network training. Your environment is ready for benchmarking.

content/learning-paths/servers-and-cloud-computing/tensorflow-gcp/benchmarking.md

@@ -8,11 +8,11 @@ layout: learningpathall
 
 ## Benchmark TensorFlow models
 
-This section benchmarks multiple TensorFlow models (ResNet50, MobileNetV2, and InceptionV3) using dummy input data. You'll measure average inference time and throughput for each model running on the CPU.
+This section benchmarks multiple TensorFlow models - ResNet50, MobileNetV2, and InceptionV3 - using dummy input data. You'll measure average inference time and throughput for each model running on the CPU of your Arm-based Google Cloud Platform (GCP) VM.
 
-tf.keras is TensorFlow's high-level API for building, training, and benchmarking deep learning models. It provides access to predefined architectures such as ResNet, MobileNet, and Inception, making it easy to evaluate model performance on different hardware setups.
+TensorFlow Keras (`tf.keras`) is TensorFlow's high-level API for building, training, and benchmarking deep learning models. It provides access to predefined architectures such as ResNet, MobileNet, and Inception, making it easy to evaluate model performance on different hardware setups.
 
-### Activate your virtual environment
+## Activate your virtual environment
 
 Enable your isolated Python environment where TensorFlow is installed:
 
@@ -23,17 +23,17 @@ python -c "import tensorflow as tf; print(tf.__version__)"
 
 This ensures that all TensorFlow-related packages run in a clean, controlled setup without affecting system-wide Python installations.
 
-### Install required packages
+## Install required packages
 
 Install TensorFlow and NumPy for model creation and benchmarking:
 
 ```console
 pip install tensorflow==2.20.0 numpy
 ```
 
-These packages are likely already installed from the previous installation steps. NumPy supports efficient numerical operations, while TensorFlow handles deep learning workloads.
+These packages are likely already installed from previous steps. NumPy supports efficient numerical operations, while TensorFlow handles deep learning workloads.
 
-### Create the benchmark script
+## Create the benchmark script
 
 Use an editor to create a Python script named `tf_cpu_benchmark.py` that will run TensorFlow model benchmarking tests.
 
@@ -74,7 +74,7 @@ for name, constructor in models.items():
 
 This script creates model instances without pretrained weights for fair CPU testing, generates random image data for inference, includes a warm-up phase to stabilize model performance, and measures inference time over 50 runs to calculate average performance and throughput.
 
-### Run the benchmark
+## Run the benchmark
 
 Execute the benchmarking script:
 
@@ -98,18 +98,20 @@ InceptionV3 average inference time per batch: 0.8971 seconds
 InceptionV3 throughput: 35.67 images/sec
 ```
 
-### Understand the results
+## Interpret the results
 
 The benchmark provides key performance metrics. Average inference time per batch measures how long it takes to process one batch of input data, with lower values indicating faster performance. Throughput shows how many images the model can process per second, with higher values indicating better efficiency.
 
-### Performance summary
+## Performance summary
 
-The following table shows results from running the benchmark on a `c4a-standard-4` (4 vCPU, 16 GB memory) aarch64 VM in GCP using SUSE:
+The following table shows results from running the benchmark on a `c4a-standard-4` (4 vCPU, 16 GB memory) aarch64 VM in Google Cloud Platform (GCP) using SUSE Linux Enterprise Server (SLES):
 
 | Model       | Average Inference Time per Batch (seconds) | Throughput (images/sec) |
 |-------------|-------------------------------------------:|------------------------:|
 | ResNet50    | 1.2051                                     | 26.55                   |
 | MobileNetV2 | 0.2909                                     | 110.02                  |
 | InceptionV3 | 0.8971                                     | 35.67                   |
 
-The results demonstrate strong performance for lightweight CNNs like MobileNetV2, achieving over 110 images/sec on the aarch64 platform. Medium-depth models like InceptionV3 maintain balanced performance between accuracy and latency. Heavier architectures such as ResNet50 show longer inference times but deliver stable throughput, confirming that TensorFlow workloads run efficiently on Arm processors and provide a cost-effective alternative for AI inference tasks.
+The results show strong performance for lightweight CNNs like MobileNetV2, achieving over 110 images/sec on the aarch64 platform. Medium-depth models like InceptionV3 maintain balanced performance between accuracy and latency. Heavier architectures such as ResNet50 show longer inference times but deliver stable throughput.
+
+You have successfully benchmarked TensorFlow models on your Arm-based VM. This demonstrates the efficiency and scalability of Arm platforms for deep learning workloads - great job!

content/learning-paths/servers-and-cloud-computing/tensorflow-gcp/installation.md

@@ -1,5 +1,5 @@
 ---
-title: Install TensorFlow 
+title: Install TensorFlow
 weight: 4
 
 ### FIXED, DO NOT MODIFY
@@ -8,11 +8,11 @@ layout: learningpathall
 
 ## Install TensorFlow on Google Axion C4A
 
-TensorFlow is an open-source machine learning library developed by Google for building and deploying ML models efficiently. On aarch64 SUSE VMs, TensorFlow runs natively on CPU or GPU if available.
+TensorFlow is an open-source machine learning (ML) library developed by Google for building and deploying ML models efficiently. On 64-bit Arm architecture (aarch64) SUSE Linux Enterprise Server (SLES) VMs, TensorFlow runs natively on the CPU and can use the GPU if available.
 
-### Update your system
+## Update your system
 
-Update the system and install Python 3.11 with pip and virtual environment support:
+Update your system and install Python 3.11, pip, and virtual environment support:
 
 ```console
 sudo zypper refresh
@@ -21,13 +21,13 @@ sudo zypper install python311 python311-pip python311-venv
 
 Enter "y" when prompted to confirm the installation. This ensures your system has the essential tools required for TensorFlow setup.
 
-### Verify Python installation
+## Verify Python installation
 
 Confirm that Python and pip are correctly installed:
 
 ```console
 python3.11 --version
-pip3 --version
+pip3.11 --version
 ```
 
 The output is similar to:
@@ -37,7 +37,7 @@ Python 3.11.10
 pip 22.3.1 from /usr/lib/python3.11/site-packages/pip (python 3.11)
 ```
 
-### Create a virtual environment
+## Create a virtual environment
 
 Set up an isolated Python environment to keep TensorFlow dependencies separate from system packages:
 
@@ -46,17 +46,18 @@ python3.11 -m venv tf-venv
 source tf-venv/bin/activate
 ```
 
-This creates and activates a virtual environment named `tf-venv` that prevents package conflicts.
+Your virtual environment `tf-venv` is now active and isolated from system packages.
 
-### Upgrade pip
+## Upgrade pip
 
 Upgrade pip to the latest version for reliable package installation:
 
 ```console
 pip3 install --upgrade pip
 ```
 
-### Install TensorFlow
+## Install TensorFlow
+
 Install the latest stable TensorFlow version for Arm64:
 
 ```console
@@ -69,7 +70,7 @@ TensorFlow 2.18.0 introduced compatibility with NumPy 2.0, incorporating its upd
 The [Arm Ecosystem Dashboard](https://developer.arm.com/ecosystem-dashboard/) recommends TensorFlow version 2.18.0 as the minimum recommended version on Arm platforms.
 {{% /notice %}}
 
-### Verify the installation
+## Verify the installation
 
 Check that TensorFlow installed successfully and display the version:
 
@@ -83,4 +84,4 @@ The output is similar to:
 2.20.0
 ```
 
-Your TensorFlow installation is now complete and ready for use.
+You have now installed TensorFlow on your Arm-based VM and are ready to start building and running machine learning models!