
## Table of Contents

1. [Introduction](#introduction)
2. [Import Libraries](#import-libraries)
3. [Load the Dataset](#load-the-dataset)
4. [Exploratory Data Analysis (EDA)](#exploratory-data-analysis-eda)
5. [Feature Engineering & Preprocessing](#feature-engineering--preprocessing)
6. [Train the Model](#train-the-model)
7. [Evaluate the Model](#evaluate-the-model)
8. [Visualise Predictions](#visualise-predictions)
9. [Summary & Next Steps](#summary--next-steps)
10. [Source Code](#source-code)

---

## Introduction

In this post we walk through a complete **supervised-learning regression workflow** to predict house prices. We will use a synthetic dataset with features such as house size, number of bedrooms, bathrooms, age of the property, and distance to the city centre to predict the house price.

By the end you will understand how to:

- Perform Exploratory Data Analysis (EDA)
- Preprocess features with `StandardScaler`
- Train a **Linear Regression** model with scikit-learn
- Evaluate performance with MAE, RMSE, and R²
- Interpret model coefficients and residual plots

> The full Jupyter Notebook is available in the GitHub repository linked at the bottom of this post.

---

## Import Libraries

```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

%matplotlib inline
sns.set_theme(style='whitegrid')
```

Key packages:

| Package | Purpose |
|---|---|
| **pandas** | Data manipulation and analysis |
| **numpy** | Numerical computing |
| **matplotlib / seaborn** | Data visualisation |
| **scikit-learn** | ML model training, preprocessing, and evaluation |

---

## Load the Dataset

```python
df = pd.read_csv('dataset.csv')
print(f'Shape: {df.shape}')
df.head()
```

The dataset contains **50 rows** and columns for `house_size_sqft`, `num_bedrooms`, `num_bathrooms`, `age_years`, `distance_to_city_km`, and the target `price_usd`.

---

## Exploratory Data Analysis (EDA)

#### Basic statistics

```python
df.describe()
```

The `describe()` output gives us count, mean, standard deviation, min, quartiles (25%, 50%, 75%), and max for every numeric column. Key things to note:

| Field | Meaning |
|---|---|
| **mean** | Average value — the central tendency |
| **std** | Standard deviation — how spread out values are |
| **IQR** (Q3 − Q1) | Useful for detecting outliers |

#### Check for missing values

```python
print(df.isnull().sum())
```

No missing values were found in this dataset.

#### Distribution of house prices

```python
plt.figure(figsize=(8, 4))
sns.histplot(df['price_usd'], bins=15, kde=True)
plt.title('Distribution of House Prices')
plt.xlabel('Price (USD)')
plt.ylabel('Count')
plt.tight_layout()
plt.show()
```

#### Correlation heatmap

```python
plt.figure(figsize=(8, 6))
sns.heatmap(df.corr(), annot=True, fmt='.2f', cmap='coolwarm')
plt.title('Feature Correlation Heatmap')
plt.tight_layout()
plt.show()
```

The Pearson correlation coefficients reveal important relationships:

| Pair | Correlation | Meaning |
|---|---|---|
| `house_size_sqft` ↔ `price_usd` | **+1.00** | Larger houses → higher prices |
| `num_bedrooms` ↔ `price_usd` | **+0.97** | More bedrooms → higher prices |
| `age_years` ↔ `price_usd` | **-0.90** | Older houses → lower prices |
| `distance_to_city_km` ↔ `price_usd` | **-0.86** | Farther from city → lower prices |
| `age_years` ↔ `distance_to_city_km` | **+0.99** | 🚨 **Multicollinearity risk** — these carry redundant information |

> ⚠️ **Multicollinearity** occurs when independent features are highly correlated with *each other*. This can make model coefficients unstable. Consider dropping one of the correlated features or using regularisation (Ridge / Lasso).

#### Scatter plots — each feature vs price

```python
features = ['house_size_sqft', 'num_bedrooms', 'num_bathrooms',
            'age_years', 'distance_to_city_km']

fig, axes = plt.subplots(2, 3, figsize=(14, 8))
axes = axes.flatten()

for i, feature in enumerate(features):
    axes[i].scatter(df[feature], df['price_usd'], alpha=0.6)
    axes[i].set_xlabel(feature)
    axes[i].set_ylabel('Price (USD)')
    axes[i].set_title(f'{feature} vs Price')

axes[-1].set_visible(False)
plt.tight_layout()
plt.show()
```

---

## Feature Engineering & Preprocessing

#### Train / test split

```python
X = df[features]
y = df['price_usd']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f'Training samples : {len(X_train)}')
print(f'Test samples     : {len(X_test)}')
```

We use an **80/20 split** — 80 % for training, 20 % for evaluation.

#### Feature scaling

```python
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled  = scaler.transform(X_test)
```

`StandardScaler` normalises features to **mean = 0, std = 1**. This ensures no single feature dominates the model simply because of its scale.

---

## Train the Model

```python
model = LinearRegression()
model.fit(X_train_scaled, y_train)

print('Model coefficients:')
for name, coef in zip(features, model.coef_):
    print(f'  {name:30s}: {coef:,.2f}')
print(f'  Intercept                     : {model.intercept_:,.2f}')
```

Linear Regression fits the equation:

$$\hat{y} = b_0 + b_1 x_1 + b_2 x_2 + \cdots + b_n x_n$$

Where $b_0$ is the **intercept** and $b_1 \ldots b_n$ are the **coefficients**.

#### Interpreting the coefficients

Since we used **StandardScaler**, each coefficient reflects the impact of a **1 standard deviation** change in that feature:

| Feature | Coefficient | Interpretation |
|---|---|---|
| `house_size_sqft` | **+114,906** | 🥇 Strongest predictor — 1 std increase (~633 sqft) raises price by ~$114,906 |
| `age_years` | **-27,505** | 🥈 Older houses lose value — 1 std increase (~10.6 yrs) drops price by ~$27,505 |
| `distance_to_city_km` | **+27,344** | ⚠️ Positive — surprising! Likely caused by multicollinearity with `age_years` |
| `num_bedrooms` | **+16,139** | More bedrooms → higher price |
| `num_bathrooms` | **+2,377** | Weakest predictor |
| Intercept | **264,725** | Predicted price when all scaled features are at 0 (close to the dataset mean) |

> 🔍 The unexpected positive sign of `distance_to_city_km` is a classic symptom of **multicollinearity**. When two features are nearly identical (0.99 correlation), the model cannot reliably assign individual effects. Solutions include dropping one feature or using **Ridge / Lasso** regression.

---

## Evaluate the Model

```python
y_pred = model.predict(X_test_scaled)

mae  = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2   = r2_score(y_test, y_pred)

print(f'Mean Absolute Error  (MAE) : ${mae:,.2f}')
print(f'Root Mean Squared Error    : ${rmse:,.2f}')
print(f'R² Score                   : {r2:.4f}')
```

#### Results

| Metric | Value | What it means |
|---|---|---|
| **MAE** | $5,563 | On average, predictions are off by ~$5,563 |
| **RMSE** | $6,286 | Slightly higher than MAE — no major outlier errors |
| **R²** | 0.9982 | The model explains **99.82 %** of the variance in house prices |

**How to interpret each metric:**

- **MAE** — average absolute error. Easy to understand: "our prediction is off by about $5,563 on average."
- **RMSE** — penalises large errors more heavily. When RMSE ≈ MAE, errors are evenly distributed.
- **R²** — proportion of variance explained. 0.9982 is excellent, though on a small dataset (50 rows) it may indicate overfitting. Cross-validation is recommended.

---

## Visualise Predictions

#### Actual vs Predicted

```python
plt.figure(figsize=(7, 5))
plt.scatter(y_test, y_pred, alpha=0.7, edgecolors='k', linewidths=0.4)
min_val = min(y_test.min(), y_pred.min())
max_val = max(y_test.max(), y_pred.max())
plt.plot([min_val, max_val], [min_val, max_val], 'r--', label='Perfect prediction')
plt.xlabel('Actual Price (USD)')
plt.ylabel('Predicted Price (USD)')
plt.title('Actual vs Predicted House Prices')
plt.legend()
plt.tight_layout()
plt.show()
```

Points close to the red dashed line indicate accurate predictions. Our model's predictions cluster tightly around the line.

#### Residual plot

```python
residuals = y_test - y_pred

plt.figure(figsize=(7, 4))
plt.scatter(y_pred, residuals, alpha=0.7, edgecolors='k', linewidths=0.4)
plt.axhline(0, color='r', linestyle='--')
plt.xlabel('Predicted Price (USD)')
plt.ylabel('Residuals (USD)')
plt.title('Residual Plot')
plt.tight_layout()
plt.show()
```

**How to read residuals:**

| Pattern | Meaning |
|---|---|
| ✅ Random scatter around 0 | Good — errors are random, model fits well |
| ❌ Funnel shape | Heteroscedasticity — errors grow with larger predictions |
| ❌ Curved pattern | Non-linearity — consider polynomial features |

Our residuals fall between **-$8,000 and +$8,000**, which is small relative to house prices ranging from $88K to $560K.

---

## Summary & Next Steps

| Metric | Value |
|---|---|
| MAE | ~$5,563 |
| RMSE | ~$6,286 |
| R² | 0.9982 |

#### Key Takeaways

- **`house_size_sqft`** is the dominant predictor of house price.
- **`age_years`** and **`distance_to_city_km`** have a negative effect on price, which is intuitive.
- High multicollinearity between `age_years` and `distance_to_city_km` (0.99) makes individual coefficients unreliable — consider regularisation.
- Linear Regression achieves a high R² on this dataset because the underlying relationships are roughly linear.

#### Possible Next Steps

- Try **Ridge / Lasso** regression to add regularisation and handle multicollinearity.
- Experiment with **polynomial features** to capture non-linear relationships.
- Use a **Random Forest Regressor** or **Gradient Boosting** for potentially higher accuracy.
- Apply **cross-validation** to verify the model is not overfitting.

---

## Source Code

The complete Jupyter Notebook with all the code, outputs, and visualisations is available on GitHub:

🔗 [**regression_analysis.ipynb** — keke78ui9/learn-ai](https://github.com/keke78ui9/learn-ai/blob/main/ML_regression_01/regression_analysis.ipynb)

Feel free to clone the repository and experiment with the notebook yourself:

```bash
git clone https://github.com/keke78ui9/learn-ai.git
cd learn-ai/ML_regression_01
jupyter notebook regression_analysis.ipynb
```


A step-by-step guide to building a Linear Regression model for house price prediction using Python, scikit-learn, and pandas — covering EDA, feature engineering, training, and evaluation.

ML Regression — House Price Prediction with Python


#### 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 an entire workflow and to understand the costs involved in this tutorial.

### Choose Data Science Problem

Since the purpose of this is to try Vertex AI AutoML with any dataset, I decided to solve a price prediction problem using data science. This is a classic linear regression task, making it the perfect way to test out Vertex AI without overcomplicating 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.

Below is the sample data from this dataset. The dataset starts with price, followed by other features: area, bedrooms, bathrooms, etc. Price is the target value here. What we'd like to do with this data is use features such as area, bedrooms, and bathrooms to predict the target value **price**.

```csv
price,area,bedrooms,bathrooms,stories,mainroad,guestroom,basement,hotwaterheating,airconditioning,parking,prefarea,furnishingstatus
13300000,7420,4,2,3,yes,no,no,no,yes,2,yes,furnished
12250000,8960,4,4,4,yes,no,no,no,yes,3,no,furnished
12250000,9960,3,2,2,yes,no,yes,no,no,2,yes,semi-furnished
...
```

### GCP AutoML

The rest of the steps involve using this dataset to build, train, and deploy a model on the Vertex AI platform. So what's **AutoML**?

Without AutoML, a typical ML process involves loading the dataset with Python, performing EDA to understand the data and its correlations, then using feature engineering to select the right features. After that, you might do cross-validation to train and evaluate the model and find the most efficient approach for better predictions.

AutoML does all of that for you, so you don't have to worry about the best practices for building a model. It's suitable when you're trying to build your first ML model and want to skip the low-level details.

### 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.

![Create Dataset for Vertex AI](/images/vertex-auto-ml/img1.png)

> **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.

![Train the Model for Vertex AI](/images/vertex-auto-ml/img2.png)

As you can see above, the model was successfully trained and now has a version with results. Here is what each metric means for the model we just trained with AutoML.
| Metric | Value | What it's telling us |
| :------------ | :--------------------------- | :---------------------------------------------------------------------------------- |
| **Name** | untitled_2065595810353967640 | The unique identifier for this training run. |
| **Status** | Succeeded | The model training completed without errors. |
| **Created** | Jan 30, 2026 | The timestamp of when the evaluation was finalized. |
| **MAE** | 687,684.8 | The average "raw" error; your predictions are off by this amount on average. |
| **MAPE** | 17.044% | The relative error; predictions are typically off by about 17% of the actual value. |
| **R-squared** | 0.784 | The "goodness of fit"; your model explains ~78% of the data's behavior. |
| **RMSE** | 820,074.06 | Penalizes larger errors more than MAE; suggests some significant outliers exist. |
| **RMSLE** | 0.2 | Measures the ratio of error; lower values mean the model handles scales well. |

---

### 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 the free tier and understanding the cost model upfront, you're well-positioned to confidently scale to production workloads.

---


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

Machine Learning

ML Regression — House Price Prediction with Python

How to Build Your First Vertex AI Model Using AutoML