apartments-rent-prediction-assignment-2

What Drives US Apartment Rent? Price Prediction & Market Tier Classification

Assignment #2 · Classification, Regression, Clustering, Evaluation · May 2026

Video Presentation

<video src="https://huggingface.co/Noam12345/apartments-rent-prediction-assignment-2/resolve/main/presentation.mp4" controls="controls" style="max-width: 720px;"></video>

Bonus: there's a live interactive predictor at the end of this README. jump to the demo.

Overview

This project takes ~99,000 US apartment listings and tries to answer two questions:

1. Given an apartment's location, size, and amenities, can we predict its monthly rent?

2. Can we classify a listing as Cheap / Mid / Premium for its city's market? Tiers are defined relative to each city's own price distribution, so "Premium" means high-end for that local market rather than just expensive in absolute dollars.

The pipeline goes from raw scraped data to two trained Decision Tree pipelines: a regressor that predicts monthly rent at RMSE = $426 (R² = 0.72), and a tier classifier at 62% accuracy / 0.62 F1 macro on a balanced three-class problem.

Dataset

The extracted CSV (apartments_for_rent_classified_100K.csv) is bundled in this repo so it's easy to reproduce. To regenerate from source: download the .7z from UCI and extract it with 7zip, p7zip, or Keka.

Feature Mix

Setup

import pandas as pd, numpy as np
import matplotlib.pyplot as plt, seaborn as sns
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA
from sklearn.linear_model import LinearRegression, Ridge, LogisticRegression
from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier
from sklearn.neighbors import KNeighborsClassifier

SEED = 42

Built in Google Colab with the dataset uploaded via the Files sidebar.

Data Cleaning

Encoding: UCI's CSV is semicolon separated and Latin 1 encoded, so I read it with pd.read_csv(sep=';', encoding='cp1252').

Missing values:

• Numeric (bathrooms, bedrooms, square_feet, latitude, longitude): filled with the column median (robust to outliers).
• Categorical (cityname, state, pets_allowed, amenities, body, title): filled with the string 'Unknown'.

Date parsing: the time column is a Unix timestamp (seconds since 1970). I parsed it with pd.to_datetime(unit='s') and pulled out listing_year and listing_month as features.

Duplicates: Exact duplicate rows removed.

Constant columns: currency was 100% USD, so I dropped it.

Impossible values dropped (23 listings):

• price < $200 or price > $20,000: likely placeholder errors or extreme luxury outliers.
• square_feet < 100 or > 10,000: 0 sqft entries and unrealistic mansions.
• bedrooms > 8 or bathrooms > 8: data entry errors.

Final shape after cleaning: (99,384, 23)

Exploratory Data Analysis (EDA)

1. Outlier Detection: Box Plots

Box plots of price, square_feet, and bedrooms show clear extreme tails. I filtered outliers using explicit business rule thresholds (see the Cleaning section), rather than blindly removing them by IQR.

2. Correlation Heatmap (Numeric Features)

A few takeaways:

• square_feet, bedrooms, and bathrooms all correlate with each other, and modestly with price.
• latitude/longitude correlations with price are close to zero. Geography matters, but not linearly: NYC and SF are far apart on the map but both expensive.
• That's a hint that a non linear model is probably going to do better here.

3. Price Distribution

Raw price is very right skewed, while log(price) is much closer to normal. This is also why I added log_sqft later on.

Median rent is around $1,400. The mean is dragged up by the luxury tail.

4. Top States by Median Rent

The usual suspects show up at the top: CA, NY, MA, DC, HI, often 2 to 3 times the cheapest states. Geography is clearly a big price driver, which is part of the motivation for the K Means clustering on lat/long below.

5. Square Feet vs Price

Pearson correlation is about 0.4. Size matters, but with a lot of variance. A 1,000 sqft apartment in NYC and one in Kansas have very different rents, which suggests interactions matter more than any single feature.

6. Photos & Pet Friendliness vs Price

Honestly, the signal here is weaker than I expected:

• Median rent across photo categories (Thumbnail, No, Yes) is roughly the same, around $1,400 to $1,500. Listings without a photo actually show a slightly higher median, which is counterintuitive. One possible explanation: high end private landlords don't always bother with listing photos, while volume rental agencies do.
• Pet friendly listings have essentially the same median rent as listings with no pet info.

Bottom line: photo presence and pet policy are weak signals on their own. I left them in the model as one hot features, but didn't expect them to dominate, and they don't show up in the top feature importances later on.

7. Rent by Number of Bedrooms

Clear monotonic relationship: each extra bedroom adds to median rent, though the extra premium shrinks past 3 bedrooms.

Feature Engineering

I added several types of features: structural, text derived, polynomial/interaction, date derived, and cluster based.

Cluster feature utility check (I wanted to verify the cluster features actually help before keeping them): Linear R² without cluster features: 0.531 · with cluster features: 0.535 (Δ +0.004). Small but positive, so I kept them.

Methodology (avoiding data leakage):

• Master train/test split done once at the start (80/20, random_state=42).
• Every transformer (scaler, one hot, KMeans, top N, classification thresholds) fit on training data only.
• KMeans K chosen via Elbow + Silhouette on a training sample.

8. K Means: Elbow + Silhouette to pick K

I tested K from 2 to 8. Silhouette peaks at K = 4, so that's the value I went with.

9. K Means Clusters in a PCA 2D Projection

Four apartment archetypes come out of (latitude, longitude, log_sqft, bedrooms, bathrooms):

• Two regional clusters separated along PC1.
• A size based separation along PC2.
• Median price varies meaningfully across clusters, which is why cluster_id ends up being a useful feature.

Modeling, Part 1: Regression

10. Baseline: Linear Regression on Raw Features

A plain LinearRegression on bathrooms, bedrooms, square_feet, latitude, longitude, plus has_photo, fee, and source one hots.

Result: R² = 0.219, RMSE = $712, MAE = $489.

This is the baseline I want every later model to improve on.

11. Baseline Coefficients

square_feet and bathrooms dominate the linear model's coefficients. The basics matter most when there's nothing else to work with.

12. Model Comparison: All Four Regression Models

Engineered features more than doubled the baseline R² (0.22 to 0.53), and the Decision Tree pushed it further to 0.72. The tree captures interactions like location × size that the linear models simply cannot express on their own.

13. Winner: Decision Tree Predictions vs Actual

Predictions track the diagonal a lot more tightly than the baseline. The residuals are roughly centered, with a tail of noisier luxury listings (top 1%).

14. Winner: Feature Importance

Top drivers in the winning tree:

• square_feet: the single biggest predictor.
• state_top one hots (CA, NY, etc.): geography is a big one.
• city_top one hots: neighborhood level signal.
• cluster_id: the engineered cluster feature, which made it into the top 5.
• bathrooms: extra bathrooms read as a premium amenity.

Hyperparameter Sanity Check (GridSearchCV)

To verify the Decision Tree's defaults were close to optimal, I ran a small GridSearchCV with 3 fold cross validation, sweeping max_depth ∈ {10, 15, 20, None} and min_samples_leaf ∈ {10, 20, 50}, scoring on R².

The tuning bought a small additional improvement (~0.015 R², ~$12 RMSE), confirming the chosen defaults were already close to the sweet spot. The comparison table above reports un tuned results so all four models sit on the same playing field. No model gets a tuning advantage the others didn't get.

Modeling, Part 2: Classification

Part 7.1 — Tier Definition

The assignment offered three example strategies (median split, quantile binning, business-rule threshold). I chose quantile binning into 3 classes (Cheap / Mid / Premium), defined per city: each listing is labelled relative to the 33rd and 66th percentiles of price within its own city, with state-level and global fallbacks for thinly-listed cities.

Why this rather than the alternatives:

• Median split would have collapsed the dataset into a coarse binary, losing the budget vs luxury distinction the project is interested in.
• A fixed-dollar business rule (e.g. "> $3,000 = Premium") would have been too region-biased — $3,000 is luxurious in Wichita but average in Manhattan.
• Per-city quantile binning preserves balanced classes within each market and asks the classifier to learn what makes an apartment locally premium beyond just being in an expensive city.

All thresholds are computed on y_train only and looked up at predict time by cityname / state, so there's no leakage from the test set.

15. Part 7.2 — Class Balance

Quantile binning gives roughly 35 / 32 / 32 per class on the training set. Classes are balanced enough that accuracy is a reasonable primary metric; I also report F1 macro to catch per-class weakness.

Part 8.1 — Precision vs Recall, FP vs FN

Q1: Precision or recall? Precision. When the model labels a listing "Premium", we want it to actually be premium for its market — wrong tags erode trust faster than missed ones.

Q2: False Positive or False Negative? False Positives, especially on the Premium class. A false-positive Premium tag is visible and deceptive; a false-negative is recoverable because the listing still surfaces in any price-sorted view.

16–18. Part 8.3 — Confusion Matrices

All three classifiers share the same error pattern: mistakes concentrate on adjacent tiers (Cheap↔Mid, Mid↔Premium) and almost never jump across to far ones (Cheap↔Premium). That's the expected shape under quantile binning — the cutoffs are arbitrary fences in a continuous distribution, and a listing close to a percentile boundary can plausibly fall on either side. Each model also visibly handles the Mid class worst, since Mid is squeezed between two such boundaries inside every city. Logistic Regression in particular under-predicts Mid (lots of Mid listings get pushed into Cheap or Premium); the Decision Tree is meaningfully more balanced across the diagonal.

19. Classifier Comparison

The Decision Tree wins, the same pattern as in the regression head: rent depends on feature interactions (size × location, etc.), and trees can express those automatically while linear models cannot. Logistic Regression sits in last place because the relationship between features and tier is non-linear and the model can only fit linear decision boundaries. k-NN lands in the middle — distance-based methods do work here, but the high-dimensional one-hot space dilutes their signal.

Part 8.4 — Per-Class Performance for the Winner

Two takeaways:

• Premium has the highest precision (0.713). When the model labels a listing Premium, it's right about 71% of the time — exactly aligned with the precision-over-recall preference declared in Part 8.1. The class with the strongest tagging discipline is the one I most cared about being trustworthy.
• Mid is the weakest class (~0.50 precision and recall). It's sandwiched between two quantile boundaries inside every city, so a small price difference can flip a Mid listing into Cheap or Premium. This is a structural property of quantile-binned classification on a continuous target rather than a specific failure of the model, but it does mean the headline accuracy is bounded by Mid's recall.

Final Conclusions

The Decision Tree wins both heads — regression and classification — because rent depends on interactions between features (location × size, size × bathrooms, etc.) that linear models simply cannot express. The other lift came from feature engineering: log-transformed size, cluster archetypes, and top-N geography together more than doubled the baseline regression R² before any model change. On the negative side, Ridge added nothing over plain Linear (the dataset is large enough not to need regularisation), k-NN was hurt by the high-dimensional one-hot space, and luxury listings (top 1% by price) remained noisy in every model — they depend on features that aren't in the dataset, like views, brand, or exclusivity.

A few caveats worth flagging:

• Single train/test split. Model comparisons use one 80/20 split. Hyperparameter tuning used 3-fold CV, but a fuller k-fold CV across all candidate models would give tighter confidence intervals. With ~99k rows it's likely robust, but I can't prove it from one split.
• Geographic coverage. Cities outside the top-30 by frequency are folded into "Other"; performance on listings from rare cities will be noisier than the headline metric.
• Time window. The dataset spans a fixed timestamp range; the model can't extrapolate to market conditions outside that window.

<a id="demo"></a>

Interactive Demo (Bonus)

Live Gradio app on Hugging Face Spaces. Type in apartment features, get a rent prediction and a tier classification from the trained pipelines:

Open the predictor

<iframe src="https://noam12345-apartments-rent-predictor.hf.space" frameborder="0" width="100%" height="800"></iframe>

The Space loads regression_winner.pkl and classification_winner.pkl directly, so you're hitting the same Decision Tree pipelines reported in the metrics tables above. Cluster features (cluster_id, dist_to_centroid, cluster_prob_*) are recomputed at predict time using the original training time KMeans.

Repository Contents

How to use the models

import pickle

# Regression: predicts monthly rent in USD
with open('regression_winner.pkl', 'rb') as f:
    reg_pipe = pickle.load(f)
predicted_rent = reg_pipe.predict(new_listings_df)

# Classification: predicts 'Cheap' | 'Mid' | 'Premium'
with open('classification_winner.pkl', 'rb') as f:
    clf_pipe = pickle.load(f)
predicted_tier = clf_pipe.predict(new_listings_df)

Both pipelines already include preprocessing (scaling, one hot encoding), so you can pass in raw feature columns rather than pre transformed values.

Author

Noam Fuchs · Introduction to Data Science · Reichman University (IDC) · Spring 2026