
## 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](#introduction)
2. [Prerequisites](#prerequisites)
3. [Install the Python Extension via Visual Studio Code](#install-the-python-extension-via-visual-studio-code)
4. [Create a Python File](#create-a-python-file)
5. [Python Version and Which Version Should I Use?](#python-version-and-which-version-should-i-use)
6. [How to Download the Latest Python](#how-to-download-the-latest-python)
7. [How to Run a Python File](#how-to-run-a-python-file)
8. [Debug Python File](#debug-python-file)
9. [Unpack a Collection](#unpack-a-collection)
10. [Python's Built-in Data Types](#pythons-built-in-data-types)
11. [Multiline String in Python](#multiline-string-in-python)
12. [Create a Function in Python](#create-a-function-in-python)
13. [What's PIP](#whats-pip)
14. [PyPI](#pypi)
15. [Try-Except Like JavaScript or C#](#try-except-like-javascript-or-c)
16. [Throw Exception](#throw-exception)
17. [Conclusion](#conclusion)

## Introduction

This blog describes how to get started with Python quickly so you can use Python with your work tomorrow.

## Prerequisites

- macOS — this blog's tools are tested via macOS; in most cases, Windows should work too.
- Already installed Visual Studio Code on macOS.

## Install the Python Extension via Visual Studio Code

At this moment, this extension has around **_87m_** downloads and includes lots of features, such as IntelliSense, linting, debugging, and code formatting for Python.

## Create a Python File

Create a Python file as **_hello.py_**, and enter the content below.

```Python
print('hi')
```

## Python Version and Which Version Should I Use?

Check your Python version:

```
python --version
```

## How to Download the Latest Python

Go to this page and download the latest version of Python. After downloading the latest version, restart the terminal and try again.
[Python Download](https://www.python.org/downloads/)

## How to Run a Python File

Run this command and you should expect to see **_hi_** as output.

```
python hello.py
```

Or run **python** to start the Python interactive shell, and start typing Python code to verify.

```
python
```

## Debug Python File

## Unpack a Collection

With unpacking, you can do the following. What scenario can this be used in? You have to declare the same number of variables as the length of the collection.

```
numbers = [1,2,3]
x1,y1,z1 = numbers
print(x1) # 1
print(y1) # 2
```

## Python's Built-in Data Types

- **_str_**
- **_int_**, **_float_**, **_complex_**
- **_list_**, **_tuple_**, **_range_**
- **_dict_**
- **_set_**, **_frozenset_**
- **_bool_**
- **_bytes_**, **_bytearray_**, **_memoryview_**
- **_NoneType_**

## Multiline String in Python

```Python
a = """my test is
more than one line"""
print(a)
```

## Create a Function in Python

```Python
def myFunc():
    return True;
print(myFunc())
```

## What's PIP

PIP is a Python package manager, used to install new packages.

Run this command to check which version of PIP is installed.

```
pip --version
```

Run **_pip list_** to list all the packages on the system.

```
pip list
```

## PyPI

At **_pypi.org_**, you can find and publish Python packages.

https://pypi.org/

## Try-Except Like JavaScript or C#

Python can test code and catch errors in the following way.

```python
try:
    print("code to test")
except
    print("error will come to here")
else
    print("this is interesting, no error come to here")
finally
    print("either else and exception come here")
```

## Throw Exception

```Python
```

## Conclusion

This blog covered the basics of getting started with Python in Visual Studio Code, including installing the Python extension, running and debugging Python files, understanding data types, using PIP for package management, and handling exceptions. With these fundamentals, you should be ready to start using Python in your daily work.


This blog describes how to get started with Python quickly so you can use Python with your work tomorrow.

How to Get Started with Python with Visual Studio Code


## Table of Contents

1. [Introduction](#introduction)
2. [Microsoft](#microsoft)
3. [Google Education Python](#google-education-python)
4. [freeCodeCamp](#freecodecamp)
5. [Conclusion](#conclusion)

## Introduction

I'm an experienced developer with C# and JavaScript but haven't done any work
with Python yet. My main motivation for learning Python is to learn AI and ML,
as many courses require basic Python knowledge. As a beginner starting to
learn Python, I searched around for good resources and will share them here.

## Microsoft

Microsoft provides different learning topics for you to get started learning
Python. These topics are not too long and cover basic knowledge about Python,
from fundamentals to using Python with ML. They are very hands-on, and if you
finish everything, they should help you learn Python in many different areas.

- What's Python?

- Introduction to Python

- Create your first Python program

## Google Education Python

Google has a site that provides some basic information about Python, including
how to set up, Strings, Lists, and a few videos about Python.

## freeCodeCamp

If you want to learn each syntax and function provided by Python, freeCodeCamp
is another good resource to use.

Scientific Computing with Python

## Conclusion

There are many great free resources to get started with Python. Whether you
choose Microsoft, Google, or freeCodeCamp, the key is to practice consistently
and build small projects as you learn.


As an experienced developer with C# and JavaScript who hasn't done any work with Python yet, my main motivation for learning Python is to learn AI and ML, as many courses require basic Python knowledge. As a beginner starting to learn Python, I searched around for good resources and will share them here.

How to Get Started with Python


## Table of Contents

1. [How to Generate Pokemon Proto API to C# Types](#how-to-generate-pokemon-proto-api-to-c-types)
2. [Download Google Protobuf](#1-download-google-protobuf)
3. [Add Path to System Environment Variables](#add-path-to-system-environment-variables)
4. [Download Python](#2-download-python)
5. [Compile All the PokemonGO API Protos](#3-compile-all-the-pokemongo-api-protos)
6. [Output Result of C# Classes](#output-result-of-c-classes)

## Introduction

This blog demonstrates how to use Google Protocol Buffers and Python to generate PokemonGo API proto files into C# types.

## How to Generate Pokemon Proto API to C# Types

The Pokemon API uses Google Protocol Buffers to generate API contracts in C#. This blog will demo how to do that. In the following demo, we'll use Protobuf's 3.0.0-beta-2 for C#. You can download it from the following link: [Protobuf Release](https://github.com/google/protobuf/releases). Also, we'll need Python because POGOProtos needs Python to run the command to generate Protos to C#.

- **Protobuf Release** — Download Google's Protobuf for your environment. You can click the following link to download or go to the above link to check the latest version: https://github.com/google/protobuf/releases/download/v3.0.0-beta-2/protoc-3.0.0-beta-2-win32.zip

- **POGOProtos** — GitHub repo containing ProtoBuf `.proto` files needed to decode the PokemonGo RPC API.

- **Python Download** — POGOProtos needs Python to run and generate C# types.

### 1. Download Google Protobuf

In this blog, I'm using the 3.0.0-beta-2 on my Windows 10. Once you download this to your PC, you'll also need to add the path to Environment Variables.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_n3fvwf6wy.png)

### Add Path to System Environment Variables

Once you add the path, you can type `protoc` at the command line.

```
A:\protoc-3.0.0-win32\bin
```

The following is an example command to get the version of protoc:

```
> protoc --version
```

### 2. Download Python

You'll need Python, so go to the [Python website](https://www.python.org/) to download it. Once you download Python, try not to change the default folder, and also add the path to the system Environment Variables as well.

```
C:\Python27
C:\Python27\Scripts
```

### 3. Compile All the PokemonGO API Protos

Once you have the Protos and Python, you can start to get what you really want, which is the PokemonGo Protos to call the Pokemon API. Go to the GitHub repo to get the latest source code.

You have a couple of options to compile Protos to C# here. I'm using the following command to compile all protos to C# classes. You will navigate to the location that contains `compile.py`, then run the following command:

```
python compile.py
```

### Output Result of C# Classes

After running the command, you'll get all the C# classes in the output folder as shown below.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_nz0xlxblf.png)

## Conclusion

Generating PokemonGo RPC Protos to C# requires Google Protobuf and Python. Once you have both set up with the correct environment variables, running a single Python command generates all the C# classes needed to interact with the Pokemon API.


How to generate Pokemon Proto API to C# types

Generate PokemonGo RPC Protos to C#


## Table of Contents

1. [Introduction](#introduction)
2. [Download Python](#download-python)
3. [Good Article](#good-article)
4. [Sample Hello World Code for Python](#sample-hello-world-code-for-python)
5. [Another Sample Code for Python](#another-sample-code-for-python)
6. [Conclusion](#conclusion)

## Introduction

So, you want to get started with Python. Also, you prefer a Windows environment, so let's get started a little bit.

## Download Python

Go to this link to download Python: https://www.python.org/downloads/release/python-279/. Select the target Windows installer.

## Good Article

Check this article to get started: https://www.toptal.com/django/installing-django-on-iis-a-step-by-step-tutorial.

## Sample Hello World Code for Python

```
'''A simple program to create an html file froma given string,
and call the default web browser to display the file.'''

contents = '''<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">



  Hello


**Hello, World!




'''

def main():
    browseLocal(contents)

def strToFile(text, filename):
    """Write a file with the given name and the given text."""
    output = open(filename,"w")
    output.write(text)
    output.close()

def browseLocal(webpageText, filename='tempBrowseLocal.html'):
    '''Start your webbrowser on a local file containing the text
    with given filename.'''
    import webbrowser, os.path
    strToFile(webpageText, filename)
    webbrowser.open("file:///" + os.path.abspath(filename)) #elaborated for Mac

main()
```

## Another Sample Code for Python

```
import os
print "Content-type: text/html\r\n\r\n";

for param in os.environ.keys():
  print "%20s**: %s<\br>" % (param, os.environ[param])
```

### Something to Try

Can I pass a Python command from the UI to the back-end Python code and display the result on the UI?

## Conclusion

This post covered the basics of getting started with Python on Windows, including downloading Python, running a simple Hello World program, and exploring sample code. These examples should give you a starting point for further Python development.


Get started with Python with a simple Hello World example.

Python Hello World


## Table of Contents

1. [Useful Links](#useful-links)

## Introduction

If you are getting started with Python web development, the following links are helpful resources for learning about Python frameworks and the Python language itself.

## Useful Links

1. [Pillars of Python - Six Python Web Frameworks Compared](http://www.infoworld.com/article/2622836/application-development/pillars-of-python--six-python-web-frameworks-compared.html)

2. [Codecademy Python Track](http://www.codecademy.com/tracks/python)

## Conclusion

These resources provide a good starting point for exploring Python web frameworks. The framework comparison article helps you choose the right framework for your project, while Codecademy offers hands-on learning for Python fundamentals.


A collection of useful links to help you get started with Python web frameworks.

Python

ML Regression — House Price Prediction with Python

How to Get Started with Python with Visual Studio Code

How to Get Started with Python

Generate PokemonGo RPC Protos to C#

Python Hello World

A Few Useful Links for Starting with Python Frameworks