
#### Table of Contents

1. Introduction
2. Choose Your Dataset
3. Building the Initial Model
4. Automating with Vertex AI Pipelines
5. Deploying for Predictions
6. Cost & Strategy Comparison
7. Conclusion

---

### Introduction

In this post, I explore the end-to-end workflow of GCP Vertex AI using a housing dataset. We’ll walk through the entire process—from uploading the data and using AutoML to generate an API, to analyzing the final execution flow. My goal is to establish a clear understanding of the cost structure now, so we can confidently deploy more complex, real-world scenarios in the future.

### Choose Data Science Problem

The goal here is to solve a price prediction problem using data science. Since this is a classic linear regression task, it’s the perfect way to test out Vertex AI without overcomplicated things. I wanted to start with a manageable dataset to see how the platform handles the end-to-end process.

### Choose Your Dataset

Since the goal is to test Vertex AI, I chose the simplest dataset possible. You can find it [here](https://github.com/keke78ui9/datasets/tree/main/house-sample-datasets); I’ve augmented about half of the data to meet the Vertex AI minimum requirement of 1,000 rows.

### Building the Initial Model

For tabular data (rows and columns), **AutoML Tabular** is the most efficient starting point. It handles complex math and feature scaling automatically.

#### 1.1 Data Preparation

- **EDA:** Perform Exploratory Data Analysis to understand distributions.
- **Storage:** Format your data into a CSV and upload it to a **Google Cloud Storage (GCS)** bucket.

#### 1.2 Create Dataset in Vertex AI

Navigate to the Vertex AI console and create a new dataset. Select the **Tabular** type and the **Regression/Classification** option.

> **What is "Tabular" in Vertex AI?**
> It refers to structured data organized in rows and columns. It is the standard format for predicting numerical values (Regression) or categories (Classification).

#### 1.3 Train the Model

- **Objective:** Select **Regression** (since price is a continuous numerical value).
- **Target Column:** Select the column representing `price`.
- **Budget:** Vertex AI requires a minimum of 1 node hour. For datasets under 100k rows, 1-3 hours is usually sufficient.

---

### Deploying for Predictions

Once trained, you can consume the model in two ways:

#### 3.1 Real-Time Predictions

Best for "instant" price suggestions in an app.

- **Deploy to Endpoint:** Host the model on a Vertex AI Endpoint.
- **Request:** Use the Vertex AI SDK (Python, Node.js, etc.) to send feature data.

```python
# Sample snippet for real-time prediction
from google.cloud import aiplatform

endpoint = aiplatform.Endpoint(endpoint_name="PROJECT_ID/locations/REGION/endpoints/ENDPOINT_ID")
prediction = endpoint.predict(instances=[{"feature_1": "value", "feature_2": 10}])
print(prediction)
```

#### 3.2 Batch Predictions

Best for "offline" processing when you have many predictions to make at once.

- **Input:** Prepare a CSV file with all instances and upload to GCS.
- **Batch Job:** Submit a batch prediction job via the Vertex AI console.
- **Output:** Results are written back to GCS in JSON format.

```python
# Sample snippet for batch prediction
from google.cloud import aiplatform

model = aiplatform.Model(model_name="PROJECT_ID/locations/REGION/models/MODEL_ID")
batch_prediction_job = model.batch_predict(
    job_display_name="housing-price-batch-predict",
    gcs_source_uris=["gs://your-bucket/input.csv"],
    gcs_destination_output_uri_prefix="gs://your-bucket/predictions/"
)
batch_prediction_job.result()
```

---

### Cost & Strategy Comparison

#### Understanding Vertex AI Pricing

1. **Training Cost (AutoML Tabular)**

   - Charged per **node-hour**. A typical small model trains in 1–3 hours on a single node.
   - For free tier: Google offers **$300 credit** over 90 days. A 2-hour training job costs roughly $10–$15.
   - Equation: `Cost = Node-Hours × $5–$8/hour`

2. **Endpoint Hosting Cost**

   - Once deployed, you pay for compute resources even if idle.
   - A single `n1-standard-4` machine costs ~$20/day.
   - **Best practice:** Enable autoscaling or manually scale to 0 when not in use.

3. **Batch Predictions**

   - Cheaper than real-time endpoints for bulk processing.
   - Charged per prediction (roughly $0.015 per 1,000 predictions).
   - **Best for:** Nightly or weekly report generation.

4. **Data Storage (GCS)**
   - Minimal cost for CSV files. First 5 GB is free on free tier.

#### Cost Breakdown for This Example

| Component                 | Hours/Calls      | Cost             |
| ------------------------- | ---------------- | ---------------- |
| Training (AutoML)         | 2                | $10–$15          |
| Model Deployment          | 24 hours (1 day) | ~$20             |
| 10,000 Batch Predictions  | 10k              | ~$0.15           |
| GCS Storage               | CSV only         | Free (under 5GB) |
| **Total (1-day project)** | —                | **~$30–$35**     |

#### Strategy: How to Minimize Costs

1. **Use Free Tier Credits:** Start with the $300 90-day free tier credit. Train and experiment aggressively.
2. **Turn Off Endpoints When Not Testing:** A deployed endpoint costs money even if unused. Delete it after testing.
3. **Prefer Batch Predictions:** For infrequent use cases, batch predictions are 10–100x cheaper than maintaining an endpoint.
4. **Monitor with Cloud Budget Alerts:** Set a budget of $50/month and receive email alerts when you approach the limit.

---

### Conclusion

Vertex AI with AutoML Tabular is an excellent entry point for anyone wanting to explore machine learning on GCP without deep expertise in data science or model architecture. The platform handles the heavy lifting—feature engineering, hyperparameter tuning, and deployment—so you can focus on the business problem.

**Key Takeaways:**

- **Simple data + AutoML = Fast results.** A housing price prediction model takes just 2–3 hours to train and deploy.
- **Costs are transparent and manageable.** With the free tier credit, you can build, train, and deploy multiple models risk-free.
- **Automate retraining with Pipelines.** Once your workflow is validated, use Kubeflow Pipelines to keep your model fresh as new data arrives.
- **Choose the right inference method.** Real-time endpoints are ideal for interactive apps; batch predictions suit reporting workflows.

By starting with free tier and understanding the cost model upfront, you're well-positioned to confidently scale to production workloads. The next steps are to experiment with more complex datasets, ensemble models, or custom training for even greater accuracy.

---


A practical guide to predicting housing prices using GCP Vertext AI with AutoML Tabular.

Category Vertex AI

How to Build and Price Your First Vertex AI Model Using AutoML