Project Introduction

House price prediction is a supervised Machine Learning problem in which a model learns relationships between property attributes and observed sale prices.

A property may be represented by its living area, number of rooms, age, condition, location, parking capacity, and other characteristics. The model uses those inputs to estimate a continuous numerical target: the expected property price.

Although house price prediction is often introduced as a simple regression exercise, a reliable project requires careful attention to data quality, missing values, categorical encoding, location, changing market conditions, leakage, unusual properties, evaluation design, uncertainty, and production monitoring.

Learning Objectives

Prerequisites

python -m pip install pandas numpy matplotlib seaborn scikit-learn joblib

Problem Definition

Let each property contain a feature vector \(x_i\), and let its observed sale price be \(y_i\). The regression model learns a function that estimates price from the available property features.

Expected Dataset

Save an authorized housing dataset as housing.csv. The examples below expect the following learning schema.

Data Governance

Load the Dataset

from pathlib import Path

import numpy as np
import pandas as pd


data_path = Path(
    "housing.csv"
)


if not data_path.exists():

    raise FileNotFoundError(
        "housing.csv was not found. "
        "Add an authorized dataset before running the project."
    )


housing = pd.read_csv(
    data_path
)


print(
    housing.head()
)

print(
    housing.shape
)

print(
    housing.dtypes
)

Validate the Required Schema

target_column = "price"


numerical_features = [
    "area_sqft",
    "bedrooms",
    "bathrooms",
    "property_age",
    "lot_area_sqft",
    "parking_spaces"
]


categorical_features = [
    "location",
    "property_type",
    "condition"
]


required_columns = {
    target_column,
    *numerical_features,
    *categorical_features
}


missing_columns = (
    required_columns
    - set(housing.columns)
)


if missing_columns:

    raise ValueError(
        "The dataset is missing required columns: "
        f"{sorted(missing_columns)}"
    )


housing = housing[
    [
        *numerical_features,
        *categorical_features,
        target_column
    ]
].copy()


housing[target_column] = pd.to_numeric(
    housing[target_column],
    errors="coerce"
)


housing = housing.dropna(
    subset=[
        target_column
    ]
)


if housing.empty:

    raise ValueError(
        "No usable rows remain after validating the target."
    )


if (
    housing[target_column]
    <=
    0
).any():

    raise ValueError(
        "The price target contains zero or negative values. "
        "Review the source records before training."
    )

Initial Data Audit

print(
    housing.info()
)


print(
    housing.describe(
        include="all"
    ).transpose()
)


missing_summary = (
    housing
    .isna()
    .sum()
    .sort_values(
        ascending=False
    )
)


duplicate_count = housing.duplicated().sum()


print(
    "Missing values:"
)

print(
    missing_summary
)


print(
    "Complete duplicate rows:",
    duplicate_count
)

Handle Duplicate Records Carefully

Complete duplicate rows may represent accidental duplication, but repeated properties are not automatically duplicates. The same property may be sold more than once.

complete_duplicates = housing[
    housing.duplicated(
        keep=False
    )
]


print(
    complete_duplicates.head()
)

Explore the Target Distribution

import matplotlib.pyplot as plt
import seaborn as sns


plt.figure(
    figsize=(10, 5)
)


sns.histplot(
    data=housing,
    x=target_column,
    kde=True
)


plt.title(
    "House Price Distribution"
)

plt.xlabel(
    "Observed Price"
)

plt.ylabel(
    "Property Count"
)

plt.tight_layout()

plt.show()

Explore Feature Relationships

plt.figure(
    figsize=(9, 6)
)


sns.scatterplot(
    data=housing,
    x="area_sqft",
    y=target_column,
    hue="property_type",
    alpha=0.7
)


plt.title(
    "Living Area and House Price"
)

plt.xlabel(
    "Living Area in Square Feet"
)

plt.ylabel(
    "Observed Price"
)

plt.tight_layout()

plt.show()

numerical_analysis_columns = [
    *numerical_features,
    target_column
]


correlation_matrix = (
    housing[
        numerical_analysis_columns
    ]
    .corr(
        numeric_only=True
    )
)


plt.figure(
    figsize=(10, 7)
)


sns.heatmap(
    correlation_matrix,
    annot=True,
    fmt=".2f",
    cmap="coolwarm"
)


plt.title(
    "Numerical Feature Correlation"
)

plt.tight_layout()

plt.show()

Prevent Target Leakage

Target leakage occurs when a feature contains information that would not be available when the prediction must be made or contains a direct transformation of the target.

Choose an Evaluation Split

A random split is appropriate only when it represents the intended prediction setting. If the model predicts future transactions, a chronological split may provide a more realistic evaluation.

from sklearn.model_selection import train_test_split


features = housing[
    [
        *numerical_features,
        *categorical_features
    ]
]


target = housing[
    target_column
]


X_train, X_test, y_train, y_test = train_test_split(
    features,
    target,
    test_size=0.20,
    random_state=42
)


print(
    "Training rows:",
    len(X_train)
)

print(
    "Test rows:",
    len(X_test)
)

Build a Median Baseline

Before training a complex model, compare it with a simple baseline. The following baseline predicts the median training price for every test property.

from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score


baseline_price = y_train.median()


baseline_predictions = np.full(
    shape=len(y_test),
    fill_value=baseline_price,
    dtype=float
)


baseline_mae = mean_absolute_error(
    y_test,
    baseline_predictions
)


baseline_rmse = mean_squared_error(
    y_test,
    baseline_predictions
) ** 0.5


baseline_r2 = r2_score(
    y_test,
    baseline_predictions
)


print(
    "Baseline MAE:",
    baseline_mae
)

print(
    "Baseline RMSE:",
    baseline_rmse
)

print(
    "Baseline R2:",
    baseline_r2
)

Build the Preprocessing Pipeline

from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import StandardScaler


numerical_pipeline = Pipeline(
    steps=[
        (
            "imputer",
            SimpleImputer(
                strategy="median"
            )
        ),
        (
            "scaler",
            StandardScaler()
        )
    ]
)


categorical_pipeline = Pipeline(
    steps=[
        (
            "imputer",
            SimpleImputer(
                strategy="most_frequent"
            )
        ),
        (
            "encoder",
            OneHotEncoder(
                handle_unknown="ignore",
                min_frequency=2
            )
        )
    ]
)


preprocessor = ColumnTransformer(
    transformers=[
        (
            "numerical",
            numerical_pipeline,
            numerical_features
        ),
        (
            "categorical",
            categorical_pipeline,
            categorical_features
        )
    ],
    remainder="drop"
)

Train Linear Regression

from sklearn.linear_model import LinearRegression


linear_model = Pipeline(
    steps=[
        (
            "preprocessor",
            preprocessor
        ),
        (
            "regressor",
            LinearRegression()
        )
    ]
)


linear_model.fit(
    X_train,
    y_train
)


linear_predictions = linear_model.predict(
    X_test
)

Train Random Forest Regression

from sklearn.ensemble import RandomForestRegressor


random_forest_model = Pipeline(
    steps=[
        (
            "preprocessor",
            preprocessor
        ),
        (
            "regressor",
            RandomForestRegressor(
                n_estimators=300,
                max_depth=None,
                min_samples_leaf=2,
                random_state=42,
                n_jobs=-1
            )
        )
    ]
)


random_forest_model.fit(
    X_train,
    y_train
)


random_forest_predictions = (
    random_forest_model.predict(
        X_test
    )
)

Regression Metrics

Reusable Evaluation Function

def evaluate_regression_model(
    model_name,
    actual_values,
    predicted_values
):
    mae = mean_absolute_error(
        actual_values,
        predicted_values
    )

    rmse = mean_squared_error(
        actual_values,
        predicted_values
    ) ** 0.5

    r2 = r2_score(
        actual_values,
        predicted_values
    )

    return {
        "model": model_name,
        "mae": float(mae),
        "rmse": float(rmse),
        "r2": float(r2)
    }


model_results = [
    {
        "model": "Median Baseline",
        "mae": float(baseline_mae),
        "rmse": float(baseline_rmse),
        "r2": float(baseline_r2)
    },
    evaluate_regression_model(
        model_name="Linear Regression",
        actual_values=y_test,
        predicted_values=linear_predictions
    ),
    evaluate_regression_model(
        model_name="Random Forest",
        actual_values=y_test,
        predicted_values=(
            random_forest_predictions
        )
    )
]


results_table = pd.DataFrame(
    model_results
).sort_values(
    by="mae"
)


print(
    results_table
)

Actual vs Predicted Values

plt.figure(
    figsize=(7, 7)
)


plt.scatter(
    y_test,
    random_forest_predictions,
    alpha=0.65
)


minimum_value = min(
    y_test.min(),
    random_forest_predictions.min()
)


maximum_value = max(
    y_test.max(),
    random_forest_predictions.max()
)


plt.plot(
    [
        minimum_value,
        maximum_value
    ],
    [
        minimum_value,
        maximum_value
    ],
    linestyle="--"
)


plt.title(
    "Actual vs Predicted House Prices"
)

plt.xlabel(
    "Actual Price"
)

plt.ylabel(
    "Predicted Price"
)

plt.tight_layout()

plt.show()

Predictions close to the diagonal reference line are close to the observed values. Systematic deviation from the line may reveal underprediction or overprediction in particular price ranges.

Residual Analysis

A residual is the difference between an observed target and its prediction.

residuals = (
    y_test.to_numpy()
    - random_forest_predictions
)


plt.figure(
    figsize=(9, 5)
)


plt.scatter(
    random_forest_predictions,
    residuals,
    alpha=0.65
)


plt.axhline(
    y=0,
    linestyle="--"
)


plt.title(
    "Residuals vs Predicted Prices"
)

plt.xlabel(
    "Predicted Price"
)

plt.ylabel(
    "Residual"
)

plt.tight_layout()

plt.show()

Inspect the Largest Errors

error_analysis = X_test.copy()


error_analysis[
    "actual_price"
] = y_test


error_analysis[
    "predicted_price"
] = random_forest_predictions


error_analysis[
    "residual"
] = (
    error_analysis["actual_price"]
    - error_analysis["predicted_price"]
)


error_analysis[
    "absolute_error"
] = (
    error_analysis["residual"]
    .abs()
)


largest_errors = (
    error_analysis
    .sort_values(
        by="absolute_error",
        ascending=False
    )
    .head(20)
)


print(
    largest_errors
)

Evaluate by Location and Property Type

group_analysis = error_analysis.copy()


group_analysis[
    "absolute_error"
] = (
    group_analysis["actual_price"]
    - group_analysis["predicted_price"]
).abs()


location_performance = (
    group_analysis
    .groupby(
        "location",
        dropna=False
    )
    .agg(
        property_count=(
            "absolute_error",
            "size"
        ),
        mean_absolute_error=(
            "absolute_error",
            "mean"
        ),
        mean_actual_price=(
            "actual_price",
            "mean"
        )
    )
    .sort_values(
        by="mean_absolute_error",
        ascending=False
    )
)


print(
    location_performance
)

Cross-Validation

Cross-validation evaluates a complete pipeline across several training and validation partitions. Preprocessing must be fitted independently inside each fold.

from sklearn.model_selection import KFold
from sklearn.model_selection import cross_validate


cross_validation = KFold(
    n_splits=5,
    shuffle=True,
    random_state=42
)


scoring = {
    "mae": "neg_mean_absolute_error",
    "rmse": "neg_root_mean_squared_error",
    "r2": "r2"
}


cross_validation_results = cross_validate(
    random_forest_model,
    features,
    target,
    cv=cross_validation,
    scoring=scoring,
    n_jobs=-1,
    return_train_score=False
)


cross_validation_summary = {
    "mean_mae": float(
        -cross_validation_results[
            "test_mae"
        ].mean()
    ),
    "mean_rmse": float(
        -cross_validation_results[
            "test_rmse"
        ].mean()
    ),
    "mean_r2": float(
        cross_validation_results[
            "test_r2"
        ].mean()
    )
}


print(
    cross_validation_summary
)

Hyperparameter Tuning

Hyperparameter tuning must use training data only. The final test set should remain untouched until the selected configuration is ready for independent evaluation.

from sklearn.model_selection import RandomizedSearchCV


parameter_distributions = {
    "regressor__n_estimators": [
        200,
        300,
        500
    ],
    "regressor__max_depth": [
        None,
        8,
        12,
        16
    ],
    "regressor__min_samples_split": [
        2,
        5,
        10
    ],
    "regressor__min_samples_leaf": [
        1,
        2,
        4
    ],
    "regressor__max_features": [
        "sqrt",
        0.7,
        1.0
    ]
}


search = RandomizedSearchCV(
    estimator=random_forest_model,
    param_distributions=(
        parameter_distributions
    ),
    n_iter=20,
    scoring=(
        "neg_mean_absolute_error"
    ),
    cv=cross_validation,
    random_state=42,
    n_jobs=-1,
    refit=True
)


search.fit(
    X_train,
    y_train
)


best_model = search.best_estimator_


best_predictions = best_model.predict(
    X_test
)


best_results = evaluate_regression_model(
    model_name="Tuned Random Forest",
    actual_values=y_test,
    predicted_values=best_predictions
)


print(
    search.best_params_
)

print(
    best_results
)

Feature Importance

fitted_preprocessor = (
    best_model.named_steps[
        "preprocessor"
    ]
)


feature_names = (
    fitted_preprocessor
    .get_feature_names_out()
)


feature_importances = (
    best_model.named_steps[
        "regressor"
    ]
    .feature_importances_
)


importance_table = (
    pd.DataFrame(
        {
            "feature": feature_names,
            "importance": feature_importances
        }
    )
    .sort_values(
        by="importance",
        ascending=False
    )
)


print(
    importance_table.head(20)
)

Consider a Log-Transformed Target

When prices are strongly right-skewed, modeling the logarithm of the target may reduce the influence of extremely expensive properties. The final predictions must be converted back to the original price scale.

from sklearn.compose import TransformedTargetRegressor


log_target_model = Pipeline(
    steps=[
        (
            "preprocessor",
            preprocessor
        ),
        (
            "regressor",
            TransformedTargetRegressor(
                regressor=RandomForestRegressor(
                    n_estimators=300,
                    min_samples_leaf=2,
                    random_state=42,
                    n_jobs=-1
                ),
                func=np.log1p,
                inverse_func=np.expm1
            )
        )
    ]
)


log_target_model.fit(
    X_train,
    y_train
)


log_target_predictions = (
    log_target_model.predict(
        X_test
    )
)


log_target_results = (
    evaluate_regression_model(
        model_name=(
            "Log-Target Random Forest"
        ),
        actual_values=y_test,
        predicted_values=(
            log_target_predictions
        )
    )
)


print(
    log_target_results
)

Save the Complete Pipeline

import json
import joblib
import sklearn


model_path = (
    "house_price_pipeline.joblib"
)


metadata_path = (
    "house_price_metadata.json"
)


joblib.dump(
    best_model,
    model_path
)


metadata = {
    "target_column": target_column,
    "numerical_features": numerical_features,
    "categorical_features": categorical_features,
    "currency": (
        "Replace with the dataset currency"
    ),
    "area_unit": "square feet",
    "scikit_learn_version": (
        sklearn.__version__
    ),
    "test_metrics": best_results
}


with open(
    metadata_path,
    "w",
    encoding="utf-8"
) as metadata_file:

    json.dump(
        metadata,
        metadata_file,
        indent=4
    )


print(
    "Saved model:",
    model_path
)

print(
    "Saved metadata:",
    metadata_path
)

Reload the Pipeline

loaded_model = joblib.load(
    "house_price_pipeline.joblib"
)


with open(
    "house_price_metadata.json",
    "r",
    encoding="utf-8"
) as metadata_file:

    loaded_metadata = json.load(
        metadata_file
    )


print(
    loaded_metadata
)

Predict a New Property

Replace the following illustrative values with validated application input. The example is not a valuation of a real property.

new_property = pd.DataFrame(
    [
        {
            "area_sqft": 1800,
            "bedrooms": 3,
            "bathrooms": 2,
            "property_age": 8,
            "lot_area_sqft": 2400,
            "parking_spaces": 1,
            "location": "Example Location",
            "property_type": "Apartment",
            "condition": "Good"
        }
    ]
)


predicted_price = loaded_model.predict(
    new_property
)[0]


print(
    "Estimated price:",
    predicted_price
)

Validate Prediction Input

def validate_property_input(
    property_data
):
    expected_columns = {
        *numerical_features,
        *categorical_features
    }

    received_columns = set(
        property_data.columns
    )

    missing_input_columns = (
        expected_columns
        - received_columns
    )

    unexpected_columns = (
        received_columns
        - expected_columns
    )

    if missing_input_columns:

        raise ValueError(
            "Missing prediction columns: "
            f"{sorted(missing_input_columns)}"
        )

    if unexpected_columns:

        raise ValueError(
            "Unexpected prediction columns: "
            f"{sorted(unexpected_columns)}"
        )

    if (
        property_data["area_sqft"]
        <=
        0
    ).any():

        raise ValueError(
            "area_sqft must be greater than zero."
        )

    if (
        property_data["bedrooms"]
        <
        0
    ).any():

        raise ValueError(
            "bedrooms cannot be negative."
        )

    if (
        property_data["bathrooms"]
        <
        0
    ).any():

        raise ValueError(
            "bathrooms cannot be negative."
        )

    if (
        property_data["property_age"]
        <
        0
    ).any():

        raise ValueError(
            "property_age cannot be negative."
        )

    return property_data[
        [
            *numerical_features,
            *categorical_features
        ]
    ]


validated_property = validate_property_input(
    new_property
)


validated_prediction = loaded_model.predict(
    validated_property
)[0]


print(
    "Validated estimated price:",
    validated_prediction
)

Prediction Is Not a Formal Valuation

A model prediction is an estimate based on patterns in its training data. It does not automatically include all property details, transaction circumstances, legal conditions, structural defects, current negotiations, local regulations, or recent market events.

Common Project Mistakes

Responsible AI Considerations

Production Monitoring

Recommended Project Workflow

Hands-On Practice

Knowledge Check

Project Summary