Machine Learning Workspaces: A Game Changer for Kiwi Data Scientists

A few weeks ago, ASI Solutions unveiled Machine Learning Workspaces—a fully managed, GPU-accelerated development environment designed to eliminate the biggest barriers for Kiwi data scientists and AI teams. This launch is already reshaping how organisations in Aotearoa build, train, and serve machine learning models.

Why this matters in 2026

As AI and machine learning (ML) adoption accelerates across industries, the need for accessible and robust compute infrastructure has never been greater. Organisations are facing common challenges:

• Long waits for hardware provisioning
• Complexity of GPU configuration and software stack setup
• Fragmented workflows from experimentation to production

ASI’s solution addresses these directly by providing ready-to-use GPU workspaces backed by Kubernetes and Kubeflow, supported by local expertise and data sovereignty—a crucial advantage for regulated sectors in New Zealand.

Core features at a glance

• GPU-accelerated Jupyter notebooks with CUDA and frameworks like PyTorch and TensorFlow pre-configured.
• Pre-configured Kubeflow installation for scaling workflows.
• Multi-user environments with resource quotas and secure access.
• Managed infrastructure—no Kubernetes or driver setup needed.

This makes it easier for researchers, government agencies, and enterprises to innovate quickly without hiring specialised DevOps engineers.

The tech that makes it work

GPU infrastructure — why GPUs matter

GPUs (Graphics Processing Units) are specialised chips optimised for parallel processing—ideal for the matrix and tensor computations ML frameworks rely on. Unlike traditional CPUs, GPUs can process thousands of operations simultaneously, dramatically speeding up tasks like neural network training and inference. This is why modern AI workloads are almost always run on GPU-enabled platforms.

ASI’s GPU backend integrates into its broader GPU-as-a-Service (GPUaaS) initiative, built in partnership with PB Tech, CDC Data Centres, and VAST Data, to deliver a scalable, secure cloud platform right here in NZ.

Kubernetes — the orchestration layer

Kubernetes is the industry standard for orchestrating containerised applications. On a GPU-enabled Kubernetes cluster, you get:

• Automated scheduling of GPU workloads
• Fault tolerance and scaling
• Isolation and resource quotas for multiple users

This is essential for data science teams that need reproducible, scalable environments. Kubernetes also makes integrating tools like Kubeflow and device plugins (for GPUs) far more reliable and repeatable.

Kubeflow — MLOps built for scale

Kubeflow runs on Kubernetes and adds ML-native tools:

• Notebook servers for interactive work
• Pipelines for workflow automation
• Experiment tracking
• Model serving (e.g., via KServe)

Pre-configuring Kubeflow means ASI users can move from experimentation to production-ready workflows without complex setups.

Running AI/ML on this stack — a practical walkthrough

Here's a step-by-step workflow to build and scale ML projects in this environment.

1. Start with your notebook

Log into your ASI Machine Learning Workspace and launch a GPU-backed Jupyter notebook. Use Python with pre-installed libraries like:

• TensorFlow
• PyTorch
• scikit-learn

The CUDA toolkit and drivers are ready to use, allowing you to immediately leverage GPU acceleration.

import tensorflow as tf

# Check for GPU
print("GPUs Available:", tf.config.list_physical_devices('GPU'))

2. Develop & test models

Use your notebook for interactive experimentation:

• Data cleaning and preprocessing
• Building and training neural networks
• Visualising metrics with tools like TensorBoard

Because your environment runs on real GPUs, training times are substantially faster than on CPUs.

3. Convert into a Kubeflow pipeline

Once your workflow stabilises, package it into a Kubeflow Pipeline:

• Define pipeline steps (data ingestion → preprocessing → training → validation → deployment)
• Use the Kubeflow Pipelines SDK to define and compile your workflow

Example pipeline snippet:

from kfp import dsl

@dsl.pipeline(name='example pipeline')
def ml_pipeline():
    prep = dsl.ContainerOp(
        name='preprocess',
        image='gcr.io/my-project/data-prep:latest'
    )
    train = dsl.ContainerOp(
        name='train',
        image='gcr.io/my-project/train:latest',
        arguments=['--epochs', '10']
    )

This automates reproducibility and tracking across different runs—something that pays dividends as models become more complex.

4. Scale training (optional)

For large models or datasets, Kubeflow can orchestrate distributed training using tools like Horovod or built-in distributed strategies in TensorFlow and PyTorch.

# Example: launch distributed training via MPI operator
kubectl apply -f distributed_training_job.yaml

5. Serve your model

After training, use Kubeflow’s serving components (e.g., KServe) to deploy your model as an API endpoint. This enables real-time inference behind load balancers, with autoscaling based on demand.

What success looks like

Compared to setting up individual GPU servers or juggling ad-hoc clusters:

• Onboarding drops from weeks to hours
• Experimentation becomes consistent and reproducible
• Teams can focus on insights, not infrastructure

And because the platform is hosted locally with full data sovereignty, organisations with regulatory constraints can advance AI projects with confidence.

GPU power for every data scientist in Aotearoa—a new era for AI and ML innovation.