Merge pull request #3244 from pareenaverma/content_review

MLFlow on Axion Tech review

Author: pareenaverma

content/learning-paths/servers-and-cloud-computing/mlflow-axion/_index.md

@@ -5,6 +5,8 @@ draft: true
 cascade:
     draft: true
 
+description: Install MLflow on a Google Cloud C4A Axion Arm VM running SUSE Linux, track experiments with MLflow Tracking, version models using the Model Registry, and deploy a model as a REST API.
+
 minutes_to_complete: 30
 
 who_is_this_for: This is an introductory topic for DevOps engineers, ML engineers, and software developers who want to manage the machine learning lifecycle using MLflow on SUSE Linux Enterprise Server (SLES) Arm64, track experiments, version models, and deploy models as scalable APIs.

content/learning-paths/servers-and-cloud-computing/mlflow-axion/background.md

@@ -34,8 +34,8 @@ To learn more, visit the [MLflow documentation](https://mlflow.org/docs/latest/i
 
 In this section, you:
 
-* Explored Google Axion C4A Arm-based VMs and their performance advantages for ML workflows  
-* Reviewed MLflow components, including Tracking, Projects, Models, and Model Registry  
-* Understood how Arm architecture improves efficiency and scalability for ML lifecycle management  
+* Explored Google Axion C4A Arm-based VMs and their performance advantages for ML workflows
+* Reviewed MLflow components, including Tracking, Projects, Models, and Model Registry
+* Explored how Arm architecture improves efficiency and scalability for ML lifecycle management  
 
 Next, you'll create a firewall rule to enable remote access to the MLflow UI and model serving APIs used in this Learning Path.

content/learning-paths/servers-and-cloud-computing/mlflow-axion/firewall.md

@@ -16,15 +16,15 @@ For help with GCP setup, see the Learning Path [Getting started with Google Clou
 
 Navigate to the [Google Cloud Console](https://console.cloud.google.com/), go to **VPC Network > Firewall**, and select **Create firewall rule**.
 
-![Google Cloud Console VPC Network Firewall page showing the Create firewall rule button in the top menu bar alt-txt#center](images/firewall-rule.png "Create a firewall rule in Google Cloud Console")
+![Google Cloud Console VPC Network Firewall page showing the Create firewall rule button in the top menu bar#center](images/firewall-rule.png "Create a firewall rule in Google Cloud Console")
 
-Next, create the firewall rule that exposes required ports for Ray.
+Next, create the firewall rule that exposes the ports required for MLflow.
 
 Set the **Name** of the new rule to "allow-mlflow-ports". Select the network that you intend to bind to your VM.
 
-Set **Direction of traffic** to "Ingress". Set **Allow on match** to "Allow" and **Targets** to "Specified target tags". Enter "allow-ray-ports" in the **Target tags** text field. Set **Source IPv4 ranges** to "0.0.0.0/0".
+Set **Direction of traffic** to "Ingress". Set **Allow on match** to "Allow" and **Targets** to "All instances in the network". Set **Source IPv4 ranges** to "0.0.0.0/0".
 
-![Google Cloud Console Create firewall rule form with Name set to allow-mlflow-ports and Direction of traffic set to Ingress alt-txt#center](images/network-rule.png "Configuring the allow-ray-ports firewall rule")
+![Google Cloud Console Create firewall rule form with Name set to allow-mlflow-ports and Direction of traffic set to Ingress#center](images/network-rule.png "Configuring the allow-mlflow-ports firewall rule")
 
 Finally, select **Specified protocols and ports** under the **Protocols and ports** section. Select the **TCP** checkbox and enter:
 
@@ -37,7 +37,7 @@ Finally, select **Specified protocols and ports** under the **Protocols and port
 
 Then select **Create**.
 
-![Google Cloud Console Protocols and ports section with TCP ports configured alt-txt#center](images/network-port.png "Setting Mlflow ports in the firewall rule")
+![Google Cloud Console Protocols and ports section with TCP selected and ports 5000 and 6000 entered#center](images/network-port.png "Setting MLflow ports in the firewall rule")
 
 ## What you've accomplished and what's next
 
@@ -46,4 +46,4 @@ In this section, you:
 * Created a firewall rule to expose MLflow UI and model serving API
 * Enabled external access to monitor experiments and access deployed models
 
-Next, you'll run MLflow workloads and serve models on your Arm-based virtual machine.
+Next, you'll create a C4A Arm VM and attach it to this firewall rule.

content/learning-paths/servers-and-cloud-computing/mlflow-axion/instance.md

@@ -1,5 +1,5 @@
 ---
-title: Create a Google Axion C4A Arm virtual machine on GCP 
+title: Create a Google Axion C4A Arm virtual machine on GCP
 weight: 4
 
 ### FIXED, DO NOT MODIFY
@@ -8,7 +8,7 @@ layout: learningpathall
 
 ## Provision a Google Axion C4A Arm VM
 
-In this section, you'll create a Google Axion C4A Arm-based virtual machine on Google Cloud Platform. You'll use the `c4a-standard-4` machine type, which provides 4 vCPUs and 16 GB of memory. This VM will host your Ray application.
+In this section, you'll create a Google Axion C4A Arm-based virtual machine on Google Cloud Platform. You'll use the `c4a-standard-4` machine type, which provides 4 vCPUs and 16 GB of memory. This VM will host your MLflow tracking server and model serving API.
 
 {{% notice Note %}}
 For help with GCP setup, see the Learning Path [Getting started with Google Cloud Platform](/learning-paths/servers-and-cloud-computing/csp/google/).
@@ -32,11 +32,14 @@ To create a virtual machine based on the C4A instance type:
   - For the license type, choose **Pay as you go**.
   - Increase **Size (GB)** from **10** to **100** to allocate sufficient disk space.
   - Select **Choose** to apply the changes.
+- Expand **Advanced options** and select **Networking**.
+  - Under **Network tags**, enter `allow-mlflow-ports`.
+  - This links the VM to the firewall rule you created in the previous step, ensuring inbound access to ports 5000 (MLflow UI) and 6000 (model serving API).
 - Select **Create** to launch the virtual machine.
 
 After the instance starts, select **SSH** next to the VM in the instance list to open a browser-based terminal session.
 
-![Google Cloud Console VM instances page displaying running instance with green checkmark and SSH button in the Connect column alt-txt#center](images/gcp-pubip-ssh.png "Connecting to a running C4A VM using SSH")
+![Google Cloud Console VM instances page displaying running instance with green checkmark and SSH button in the Connect column#center](images/gcp-pubip-ssh.png "Connecting to a running C4A VM using SSH")
 
 A new browser window opens with a terminal connected to your VM.
 

content/learning-paths/servers-and-cloud-computing/mlflow-axion/model-registry_deployment.md

@@ -11,15 +11,12 @@ layout: learningpathall
 This section covers model versioning, alias assignment, and serving the model as an API.
 
 
-## Terminal usage (Important)
+## Terminal usage
 
-We continue using the same terminals:
+This section continues with the same two terminals from the previous step:
 
-- **Terminal A** → Run scripts and test API  
-- **Terminal B** → MLflow server (already running)  
-- **Optional Terminal C** → Model serving (if you want a separate terminal)
-
-If you want simplicity, you can use only **Terminal A + B**
+- **Terminal A** → Run scripts, start model serving, and test the API
+- **Terminal B** → MLflow tracking server (keep this running)
 
 ## Set tracking URI
 
@@ -29,8 +26,7 @@ In **Terminal A**, run:
 export MLFLOW_TRACKING_URI=http://127.0.0.1:5000
 ```
 
-- This tells MLflow to use your running server.
-- Without this, MLflow will not find your models.
+This tells the MLflow client which tracking server to connect to. Without it, the client defaults to a local directory and won't find the models registered on your server.
 
 ## Create alias script
 
@@ -67,54 +63,64 @@ EOF
 
 ## Assign production model
 
-**Run the script:**
+Run the script:
 
 ```bash
 python set_prod.py
 ```
+The output is similar to:
 
+```output
+Production version: 1
+```
 **What this does:**
 
-- checks all model versions.
-- finds the best accuracy.
-- marks it as production.
+This script queries all registered versions of `iris-model`, finds the version with the highest `accuracy` metric, and assigns it the `production` alias. The alias is how `mlflow models serve` identifies which model version to load.
 
 ## Serve model
 
-Now we deploy the model as an API.
+With Terminal B still running the MLflow tracking server, use Terminal A to start the model serving API. `mlflow models serve` loads the aliased model from the registry and starts a uvicorn HTTP server that exposes a `/invocations` endpoint for inference.
 
-You can run this in **Terminal A** or open **Terminal C**.
+In **Terminal A**, navigate to the project directory and set the tracking URI:
 
 ```bash
 cd ~/mlflow-learning-path
-source mlflow-env/bin/activate
-```
-
-```bash
 export MLFLOW_TRACKING_URI=http://127.0.0.1:5000
 ```
 
+Start the model server in the background using `&` so Terminal A stays free for testing:
+
 ```bash
 mlflow models serve \
   -m "models:/iris-model@production" \
   -p 6000 \
-  --no-conda
+  --no-conda &
 ```
 
-## View registered models
+- `-m "models:/iris-model@production"` — loads the model version with the `production` alias from the registry
+- `-p 6000` — serves on port 6000
+- `--no-conda` — uses the active virtual environment instead of creating a new conda environment
+
+The output is similar to:
 
-Go to:
+```output
+2026/05/04 13:42:12 INFO mlflow.models.flavor_backend_registry: Selected backend for flavor 'python_function'
+2026/05/04 13:42:12 INFO mlflow.pyfunc.backend: === Running command 'exec uvicorn --host 127.0.0.1 --port 6000 --workers 1 mlflow.pyfunc.scoring_server.app:app'
+INFO:     Started server process [4527]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://127.0.0.1:6000 (Press CTRL+C to quit)
+```
+## View registered models
 
-- Model training → Models
+In the MLflow UI at `http://<VM-IP>:5000`, select the **Models** tab. You should see the `iris-model` entry with multiple registered versions and the `production` alias assigned to the best-performing one.
 
-![MLflow Model Registry showing model versions#center](images/mlflow-model.png "MLflow Model Registry with versions")
 
-You should see:
+![MLflow Model Registry showing iris-model with multiple registered versions and the production alias assigned to the best run#center](images/mlflow-model.png "MLflow Model Registry with versions")
 
-- multiple versions (v1, v2, v3…)
-- one marked as production
+## Test the API from Terminal A
 
-## Test inference from the Free Terminal ( A or C)
+The `/invocations` endpoint accepts data in the `dataframe_records` format — a list of JSON objects where each object represents one row, with column names as keys. The model returns a prediction for each row. Send a single Iris flower measurement to test inference:
 
 ```bash
 curl -X POST http://127.0.0.1:6000/invocations \
@@ -128,14 +134,18 @@ curl -X POST http://127.0.0.1:6000/invocations \
         "petal width (cm)": 0.2
       }
     ]
+  }'
 ```
 
-You will get a prediction output like:
+The expected output is:
 
 ```output
-[0]
+INFO:     127.0.0.1:41158 - "POST /invocations HTTP/1.1" 200 OK
+{"predictions": [0]}
 ```
 
+The prediction `0` corresponds to Iris setosa, which is the correct class for these measurements. The Iris dataset has three classes: `0` = setosa, `1` = versicolor, `2` = virginica.
+
 ## What you've learned
 
 You have successfully:
@@ -144,3 +154,12 @@ You have successfully:
 - Assigned a production alias
 - Deployed the model as an API
 - Performed inference using curl
+
+## Summary
+
+You have completed the full MLflow lifecycle on a Google Cloud C4A Axion Arm VM running SUSE Linux.
+
+Starting from a freshly provisioned Arm-based VM, you installed MLflow and its dependencies in an isolated Python virtual environment, then started the MLflow tracking server backed by a local SQLite database. You trained a logistic regression model on the Iris dataset across three hyperparameter configurations, with each run automatically logged to the MLflow Tracking UI and each model version registered in the Model Registry.
+
+In this final section, you used the Model Registry to select the best-performing version by accuracy, assigned it a `production` alias, and served it as a REST API using `mlflow models serve`. You then validated the end-to-end workflow by sending a live inference request using curl and interpreting the prediction.
+