diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/_index.md b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/_index.md new file mode 100644 index 0000000000..6742d4fdc6 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/_index.md @@ -0,0 +1,64 @@ +--- +title: Manage the ML lifecycle with MLflow on Google Cloud C4A Axion VM + +draft: true +cascade: + draft: true + +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. + +learning_objectives: + - Install and configure MLflow on Google Cloud C4A Axion processors for Arm64 + - Track experiments, log metrics, and compare runs using MLflow Tracking + - Manage and version models using the MLflow Model Registry + - Deploy models as APIs and validate end-to-end ML workflows + +prerequisites: + - A [Google Cloud Platform (GCP)](https://cloud.google.com/free) account with billing enabled + - Basic familiarity with Python and machine learning concepts + +author: Pareena Verma + +##### Tags +skilllevels: Introductory +subjects: ML +cloud_service_providers: + - Google Cloud + +armips: + - Neoverse + +tools_software_languages: + - MLflow + - Python + - scikit-learn + +operatingsystems: + - Linux + +# ================================================================================ +# FIXED, DO NOT MODIFY +# ================================================================================ + +further_reading: + - resource: + title: MLflow official documentation + link: https://mlflow.org/docs/latest/index.html + type: documentation + + - resource: + title: MLflow GitHub repository + link: https://github.com/mlflow/mlflow + type: documentation + + - resource: + title: Scikit-learn documentation + link: https://scikit-learn.org/stable/ + type: documentation + +weight: 1 +layout: "learningpathall" +learning_path_main_page: yes +--- diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/_next-steps.md b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/_next-steps.md new file mode 100644 index 0000000000..c3db0de5a2 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/_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. +--- diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/background.md b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/background.md new file mode 100644 index 0000000000..0a9d0f36c0 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/background.md @@ -0,0 +1,41 @@ +--- +title: Get started with MLflow on Google Axion C4A +weight: 2 + +layout: "learningpathall" +--- + +## Explore 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. + +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. + +To learn more, see the Google blog [Introducing Google Axion Processors, our new Arm-based CPUs](https://cloud.google.com/blog/products/compute/introducing-googles-new-arm-based-cpu). + +## Explore MLflow on Google Axion C4A (Arm Neoverse V2) + +MLflow is an open-source platform designed to manage the end-to-end machine learning lifecycle. It is widely used for experiment tracking, model management, reproducibility, and deployment. + +MLflow provides a unified platform with components such as: + +* **MLflow Tracking** for logging parameters, metrics, and artifacts +* **MLflow Projects** for packaging and reproducible execution +* **MLflow Models** for standardized model formats and deployment +* **MLflow Model Registry** for versioning, lifecycle management, and model governance + +Running MLflow on Google Axion C4A Arm-based infrastructure enables efficient execution of machine learning workflows by leveraging multi-core CPUs and optimized memory performance. This results in improved performance per watt, reduced infrastructure costs, and better scalability for ML experimentation and deployment pipelines. + +Common use cases include experiment tracking, model versioning, reproducible ML workflows, CI/CD integration for ML pipelines, and deploying models as scalable APIs for real-time inference. + +To learn more, visit the [MLflow documentation](https://mlflow.org/docs/latest/index.html) and explore the [MLflow GitHub repository](https://github.com/mlflow/mlflow). + +## What you've accomplished and what's next + +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 + +Next, you'll create a firewall rule to enable remote access to the MLflow UI and model serving APIs used in this Learning Path. diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/firewall.md b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/firewall.md new file mode 100644 index 0000000000..acebf49957 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/firewall.md @@ -0,0 +1,49 @@ +--- +title: Create a firewall rule for MLflow +weight: 3 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +Create a firewall rule in Google Cloud Console to expose required ports for the MLflow UI 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/). +{{% /notice %}} + +## Configure the firewall rule + +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") + +Next, create the firewall rule that exposes required ports for Ray. + +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". + +![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") + +Finally, select **Specified protocols and ports** under the **Protocols and ports** section. Select the **TCP** checkbox and enter: + +```text +5000,6000 +``` + +* **5000** → MLflow Tracking UI +* **6000** → MLflow Model Serving API + +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") + +## What you've accomplished and what's next + +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. diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/firewall-rule.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/firewall-rule.png new file mode 100644 index 0000000000..ab99314834 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/firewall-rule.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-pubip-ssh.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-pubip-ssh.png new file mode 100644 index 0000000000..558745de3e Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-pubip-ssh.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-shell.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-shell.png new file mode 100644 index 0000000000..7e2fc3d1b5 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-shell.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-vm.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-vm.png new file mode 100644 index 0000000000..0d1072e20d Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/gcp-vm.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-model.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-model.png new file mode 100644 index 0000000000..1ebf5baec0 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-model.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-runs.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-runs.png new file mode 100644 index 0000000000..0b155a126d Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-runs.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-ui.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-ui.png new file mode 100644 index 0000000000..8c90ea5ffb Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/mlflow-ui.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/network-port.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/network-port.png new file mode 100644 index 0000000000..d63baf4cb9 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/network-port.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/network-rule.png b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/network-rule.png new file mode 100644 index 0000000000..84f2cda1a0 Binary files /dev/null and b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/images/network-rule.png differ diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/instance.md b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/instance.md new file mode 100644 index 0000000000..0541f5dc00 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/instance.md @@ -0,0 +1,49 @@ +--- +title: Create a Google Axion C4A Arm virtual machine on GCP +weight: 4 + +### FIXED, DO NOT MODIFY +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. + +{{% 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/). +{{% /notice %}} + +## Provision a Google Axion C4A Arm VM in Google Cloud Console + +To create a virtual machine based on the C4A instance type: + +- Navigate to the [Google Cloud Console](https://console.cloud.google.com/). +- Go to **Compute Engine** > **VM Instances** and select **Create Instance**. +- Under **Machine configuration**: + - Populate fields such as **Instance name**, **Region**, and **Zone**. + - Set **Series** to `C4A`. + - Select `c4a-standard-4` for machine type. + +![Screenshot of the Google Cloud Console showing the Machine configuration section. The Series dropdown is set to C4A and the machine type c4a-standard-4 is selected#center](images/gcp-vm.png "Configuring machine type to C4A in Google Cloud Console") + +- Under **OS and storage**, select **Change**, and then choose an Arm64-based operating system image. + - For this Learning Path, select **SUSE Linux Enterprise Server**. + - 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. +- 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") + +A new browser window opens with a terminal connected to your VM. + +![Browser-based SSH terminal window with black background showing Linux command prompt and Google Cloud branding at top#center](images/gcp-shell.png "Terminal session connected to the VM") + +## What you've accomplished and what's next + +In this section, you provisioned a Google Axion C4A Arm VM and connected to it using SSH. + +Next, you'll install MLflow and the required dependencies on your VM. diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/model-registry_deployment.md b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/model-registry_deployment.md new file mode 100644 index 0000000000..6290520c93 --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/model-registry_deployment.md @@ -0,0 +1,146 @@ +--- +title: Deploy MLflow on GCP SUSE Arm64 (Model Registry & Serving) +weight: 6 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Model Registry and Deployment + +This section covers model versioning, alias assignment, and serving the model as an API. + + +## Terminal usage (Important) + +We continue using the same terminals: + +- **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** + +## Set tracking URI + +In **Terminal A**, run: + +```bash +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. + +## Create alias script + +```bash +cd ~/mlflow-learning-path/demo +``` + +Create a script to select the best model automatically: + +```bash +cat > set_prod.py <<'EOF' +import os +from mlflow import MlflowClient + +tracking_uri = os.environ.get("MLFLOW_TRACKING_URI", "http://127.0.0.1:5000") +client = MlflowClient(tracking_uri=tracking_uri) + +versions = client.search_model_versions("name='iris-model'") + +best_v = None +best_acc = -1 + +for v in versions: + run = client.get_run(v.run_id) + acc = run.data.metrics.get("accuracy", -1) + if acc > best_acc: + best_acc = acc + best_v = v.version + +client.set_registered_model_alias("iris-model", "production", best_v) +print("Production version:", best_v) +EOF +``` + +## Assign production model + +**Run the script:** + +```bash +python set_prod.py +``` + +**What this does:** + +- checks all model versions. +- finds the best accuracy. +- marks it as production. + +## Serve model + +Now we deploy the model as an API. + +You can run this in **Terminal A** or open **Terminal C**. + +```bash +cd ~/mlflow-learning-path +source mlflow-env/bin/activate +``` + +```bash +export MLFLOW_TRACKING_URI=http://127.0.0.1:5000 +``` + +```bash +mlflow models serve \ + -m "models:/iris-model@production" \ + -p 6000 \ + --no-conda +``` + +## View registered models + +Go to: + +- Model training → Models + +![MLflow Model Registry showing model versions#center](images/mlflow-model.png "MLflow Model Registry with versions") + +You should see: + +- multiple versions (v1, v2, v3…) +- one marked as production + +## Test inference from the Free Terminal ( A or C) + +```bash +curl -X POST http://127.0.0.1:6000/invocations \ + -H "Content-Type: application/json" \ + -d '{ + "dataframe_records": [ + { + "sepal length (cm)": 5.1, + "sepal width (cm)": 3.5, + "petal length (cm)": 1.4, + "petal width (cm)": 0.2 + } + ] +``` + +You will get a prediction output like: + +```output +[0] +``` + +## What you've learned + +You have successfully: + +- Selected the best model from experiments +- Assigned a production alias +- Deployed the model as an API +- Performed inference using curl diff --git a/content/learning-paths/servers-and-cloud-computing/mlflow-axion/setup_tracking.md b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/setup_tracking.md new file mode 100644 index 0000000000..10cd9f0f1d --- /dev/null +++ b/content/learning-paths/servers-and-cloud-computing/mlflow-axion/setup_tracking.md @@ -0,0 +1,330 @@ +--- +title: Deploy MLflow on GCP SUSE Arm64 (Setup & Tracking) +weight: 5 + +### FIXED, DO NOT MODIFY +layout: learningpathall +--- + +## Deploy MLflow on GCP SUSE Arm64 + +In this section, you will learn how to set up MLflow on a GCP Arm64 (Axion) virtual machine using SUSE Linux and Python 3.11. + +By the end of this section, you will be able to: + +- Install MLflow and required dependencies +- Start the MLflow tracking server +- Run machine learning experiments +- View results in the MLflow UI + +## Terminal usage (Important) + +To keep things simple, we will use only **two terminals**: + +- **Terminal A** → For setup, training, and running commands +- **Terminal B** → For running the MLflow server (keep this running) + +Think of it like: + +- Terminal A = “work terminal” +- Terminal B = “server terminal” + +## Connect to the VM + +Open **Terminal A** and connect: + +```bash +ssh @ +``` + +## Verify system: + +Check your system architecture: + +```bash +uname -m +cat /etc/os-release +``` + +The output is similar to: + +```output +aarch64 +NAME="SLES" +VERSION="15-SP5" +VERSION_ID="15.5" +PRETTY_NAME="SUSE Linux Enterprise Server 15 SP5" +ID="sles" +ID_LIKE="suse" +ANSI_COLOR="0;32" +CPE_NAME="cpe:/o:suse:sles:15:sp5" +DOCUMENTATION_URL="https://documentation.suse.com/" +``` + +This confirms you are on an Arm-based VM + +## Update your system + +Update all system packages: + +```bash +sudo zypper refresh +sudo zypper update -y +``` +This ensures your system is up to date before installing anything. + +## Install required dependencies + +Now install Python 3.11 and other tools: + +```bash +sudo zypper install -y \ + python311 \ + python311-pip \ + python311-setuptools \ + python311-wheel \ + sqlite3 \ + gcc \ + gcc-c++ \ + make \ + git +``` + +**What these do:** + +- python311 → Python 3.11 runtime +- pip → install Python packages +- gcc/g++/make → build tools +- sqlite3 → MLflow database + +**Verify:** + +```bash +python3.11 --version +pip3.11 --version +``` + +The output is similar to: + +```output +Python 3.11.10 +pip 26.0.1 from /home/gcpuser/mlflow-learning-path/mlflow-env/lib64/python3.11/site-packages/pip (python 3.11) +``` + +## Create Python environment + +```bash +mkdir -p ~/mlflow-learning-path +cd ~/mlflow-learning-path + +python3.11 -m venv mlflow-env +source mlflow-env/bin/activate +``` +This is where all your MLflow files will live. + +**Upgrade tools:** + +```bash +pip install --upgrade pip setuptools wheel +``` + +## Install MLflow + +```bash +pip install mlflow scikit-learn pandas numpy matplotlib +``` +This installs MLflow + ML libraries. + +## Create directories + +```bash +mkdir -p backend artifacts demo +touch backend/mlflow.db +``` + +**These folders store:** + +- experiments +- models +- logs + +## Start MLflow server + +**Now open Terminal B and run:** + +```bash +ssh @ +cd ~/mlflow-learning-path +source mlflow-env/bin/activate +``` + +**Start MLflow server:** + +```bahs +mlflow server \ + --host 0.0.0.0 \ + --port 5000 \ + --backend-store-uri sqlite:///$(pwd)/backend/mlflow.db \ + --artifacts-destination file://$(pwd)/artifacts \ + --allowed-hosts "*" \ + --cors-allowed-origins "*" +``` + +- Keep this terminal running. +- This is your MLflow backend. + +## Access MLflow UI + +**Open in browser:** + +```text +http://:5000 +``` + +![MLflow UI Home Screen#center](images/mlflow-ui.png "MLflow UI Home Page") + +- Select **Model training** +- See experiments +- Compare runs +- View accuracy + +## Create training script + +**Go back to Terminal A:** + +```bash +cd ~/mlflow-learning-path/demo +``` + +**Create the file:** + +```bash +cat > train.py <<'EOF' +import os +import mlflow +import mlflow.sklearn +from sklearn.datasets import load_iris +from sklearn.model_selection import train_test_split +from sklearn.linear_model import LogisticRegression +from sklearn.metrics import accuracy_score + +mlflow.set_tracking_uri("http://127.0.0.1:5000") +mlflow.set_experiment("iris-exp") + +X, y = load_iris(return_X_y=True) +X_train, X_test, y_train, y_test = train_test_split(X, y) + +C = float(os.getenv("C", 1.0)) + +with mlflow.start_run(): + model = LogisticRegression(C=C, max_iter=200) + model.fit(X_train, y_train) + + preds = model.predict(X_test) + acc = accuracy_score(y_test, preds) + + mlflow.log_param("C", C) + mlflow.log_metric("accuracy", acc) + + mlflow.sklearn.log_model( + model, + name="model", + registered_model_name="iris-model" + ) + + print("Accuracy:", acc) +EOF +``` + +**This script:** + +- trains a model +- logs accuracy +- registers the model + +## Run experiments + +**Set MLflow server:** + +```bash +export MLFLOW_TRACKING_URI=http://127.0.0.1:5000 +``` + +**Run experiments:** + +```bash +python train.py +export C=0.5 +python train.py +export C=2.0 +python train.py +``` + +**Each run creates:** + +- new experiment entry +- new model version + +The output is similar to: + +```output +Registered model 'iris-model' already exists. Creating a new version of this model... +2026/04/22 04:44:42 INFO mlflow.store.model_registry.abstract_store: Waiting up to 300 seconds for model version to finish creation. Model name: iris-model, version 2 +Created version '2' of model 'iris-model'. +Accuracy: 1.0 +🏃 View run unequaled-grub-345 at: http://127.0.0.1:5000/#/experiments/1/runs/8a9e3cf1ab3b4f669a37fb0cbe1e469c +🧪 View experiment at: http://127.0.0.1:5000/#/experiments/1 + +(mlflow-env) gcpuser@mlfow-new:~/mlflow-learning-path/demo> export C=0.5 +(mlflow-env) gcpuser@mlfow-new:~/mlflow-learning-path/demo> python train.py + +Registered model 'iris-model' already exists. Creating a new version of this model... +2026/04/22 04:44:52 INFO mlflow.store.model_registry.abstract_store: Waiting up to 300 seconds for model version to finish creation. Model name: iris-model, version 3 +Created version '3' of model 'iris-model'. +Accuracy: 1.0 +🏃 View run vaunted-horse-22 at: http://127.0.0.1:5000/#/experiments/1/runs/4e10db3266c5495bae43df36a46ebd13 +🧪 View experiment at: http://127.0.0.1:5000/#/experiments/1 + +(mlflow-env) gcpuser@mlfow-new:~/mlflow-learning-path/demo> export C=2.0 +(mlflow-env) gcpuser@mlfow-new:~/mlflow-learning-path/demo> python train.py + +2026/04/22 04:45:00 INFO mlflow.store.model_registry.abstract_store: Waiting up to 300 seconds for model version to finish creation. Model name: iris-model, version 4 +Created version '4' of model 'iris-model'. +Accuracy: 1.0 +🏃 View run defiant-hound-237 at: http://127.0.0.1:5000/#/experiments/1/runs/8b2517b64bb34df199a78f2a8b29137c +🧪 View experiment at: http://127.0.0.1:5000/#/experiments/1 +``` + +## Verify results + +In UI: + +- Open Model training +- Select iris-exp +- Go to Runs + +**You should see:** + +- Multiple runs +- Accuracy metrics +- Model versions (v1, v2, v3) + +## View experiment runs + +Go to: + +- Model training → iris-exp → Runs + +![MLflow Runs View showing experiments and metrics#center](images/mlflow-runs.png "MLflow Runs showing experiment tracking") + +## What you've learned + +You have successfully: + +- Installed MLflow on SUSE ARM64 +- Configured Python 3.11 environment +- Started MLflow tracking server +- Logged experiments and metrics +- Registered models + +Next, you will deploy and serve the model.