Predict a property's history_price (regression) and whether it is expensive vs not-expensive (classification) from the London House Price Data Kaggle dataset.

The dataset is the London House Price Data Kaggle file from jakewright/house-price-data. The full file has 418,201 rows × 28 columns, but a random sample of 30,000 rows is used to keep the analysis manageable. The numeric target is history_price — the historical sale price of a property in GBP. The pipeline starts with EDA (cleaning, outlier detection, descriptive statistics, four research questions), trains a baseline LinearRegression on six numeric features, adds a feature-engineering step (one-hot encoding of propertyType), runs K-Means with k = 3 on the property features and adds a cluster_id feature, then trains three improved regression models (Linear / Random Forest / Decision Tree). The Random Forest is the regression winner and is exported as a pickle. The continuous target is then converted into a binary class using a median split (expensive vs not-expensive), and three classifiers are trained (Logistic Regression / Random Forest / Decision Tree) with full classification reports and confusion-matrix evaluation.

The full London House Price dataset has 418,201 rows × 28 columns, with one column (history_price) acting as the target — leaving 27 input features. To keep the analysis manageable a random sample of 30,000 rows is taken at the start of EDA, comfortably above the 10K-row / 15-feature minimums required by the assignment. The feature mix is rich and includes geographic information (latitude, longitude, postcode, outcode, country), property characteristics (floorAreaSqM, bedrooms, bathrooms, livingRooms, propertyType, currentEnergyRating), and sale-related fields (saleEstimate_lowerPrice, saleEstimate_upperPrice, saleEstimate_confidenceLevel, history_date, history_price).

The research question is: Can we predict a property's historical sale price using its location and other property-related features?

After sampling 30,000 rows, the cleaning pipeline removes exact duplicate rows, strips whitespace from text columns, parses date columns into datetime, drops constant columns, and inspects missing values per column. Outliers are flagged with the IQR rule and visualised as boxplots — the most extreme values in history_price, floorAreaSqM, and number of rooms are kept because they are legitimate luxury / large-property cases rather than data-entry errors.

A grid of EDA visualisations summarises the four core relationships at a glance:

Selected visuals:

The baseline LinearRegression is trained on six numeric features — floorAreaSqM, bedrooms, bathrooms, livingRooms, latitude, longitude — using an 80/20 train-test split with random_state=42. After dropping rows with missing values, the modelling dataset has 22,825 rows. The baseline achieves an MAE of about £290,373 and an R² of about 0.39 — meaning the model explains roughly 39% of the variance in historical prices and is off by about £290K on average. This is a useful starting point but the error is large because property prices depend on many factors beyond the six inputs.

The feature-engineering step adds one-hot encoded columns for propertyType — a useful nominal categorical that the EDA flagged as price-relevant. The expanded feature matrix has 24 columns and 22,825 rows. A second LinearRegression is fit on this richer matrix and reaches MAE ≈ £291,661 and R² ≈ 0.397 — a small bump in R² over the baseline, confirming that property type carries some independent signal even though the linear model cannot fully exploit it.

K-Means with k = 3 is applied to the same six scaled numeric property features. The clusters are projected into 2D with PCA for visualisation:

The three clusters separate well in PCA space and correspond roughly to compact / mid-range / large premium properties. The hard cluster assignment (cluster_id) is then merged back into the modelling matrix as an additional feature. Re-training the linear model with cluster_id included gives MAE ≈ £290,075 and R² ≈ 0.395 — a marginal but real improvement over the baseline, showing that the cluster signal adds a small amount of complementary information.

Three models are compared on the engineered feature matrix. The improved Linear Regression stays at MAE ≈ £290,075 and R² ≈ 0.395 — a tiny gain from feature engineering and clustering. The Random Forest Regressor with default hyperparameters drops the MAE to about £270,653 while keeping R² at 0.393 — the best of the three on the cost-sensitive metric. The Decision Tree Regressor overfits aggressively, scoring MAE ≈ £339,515 and a negative R² of −0.056, meaning it does worse than predicting the mean.

The Random Forest is therefore selected as the regression winner. Feature importance from the Random Forest highlights floorAreaSqM, latitude, and longitude as the dominant predictors:

The winning model is exported as winning_regression_model.pkl via Python pickle for reuse.

The continuous target is converted into a binary class using a median split: properties at or below the median price are labelled "0 — not expensive", and properties above the median are labelled "1 — expensive". The median is chosen because it produces perfectly balanced classes, which means accuracy is a meaningful headline metric. The same threshold computed on the training portion is reused on the test set so no leakage occurs.

In this task, precision on the "expensive" class is treated as more important than recall, because mislabelling a cheap property as expensive (false positive) is more costly than the reverse — it misleads downstream business decisions about where to invest.

Three classifiers are trained on the same engineered feature matrix. Logistic Regression reaches an accuracy of 0.68, with slightly better recall on the not-expensive class than on the expensive class. The Random Forest Classifier also lands at accuracy 0.68, but with noticeably better recall on the expensive class (0.70) — making it the better choice for this task. The Decision Tree Classifier trails at accuracy 0.63, showing the same overfitting pattern as in regression.

The Random Forest is selected as the classification winner because of its stronger recall on the high-value class, which directly aligns with the business framing (catching truly expensive properties matters most).

Confusion matrices for the three classifiers:

The off-diagonal pattern is symmetric for the strong models — most errors are evenly split between false positives and false negatives — confirming that the classifiers are not biased toward one class. The Decision Tree confusion matrix shows visibly larger off-diagonal cells, consistent with its lower accuracy.

The winning classifier is exported as winning_classification_model.pkl to the same HuggingFace Model Repository as the regression pickle.

The HuggingFace Model Repository contains five artefacts. winning_regression_model.pkl is the exported Random Forest Regressor that predicts history_price. winning_classification_model.pkl is the exported Random Forest Classifier that predicts the expensive / not-expensive label. The full notebook with all 10 parts and section-by-section findings is included as Copy_of_Assignment_2_Classification,_Regression,_Clustering,_Evaluation.ipynb. The source dataset is fetched from Kaggle (jakewright/house-price-data) using kagglehub. README.md is this file.

Reichman University, Course: Data Science, Assignment #2 . Dataset source: House Price Data — jakewright on Kaggle.