Rent Pricing Application

1Rent is a number you predict

The ml_core lessons kept returning to one notebook: 200 flats your office has already rented out, each line recording the flat's size in square feet, its distance from the city centre in kilometres, its building age in years — and, on the same line, the monthly rent the tenant actually signed at. This lesson is where that notebook stops being an example and becomes the product. The job: a landlord hands you a new flat, and you must put an advertised price on it. The answer you owe is not a category like spam / not spam — it is an amount of money, some number of rupees per month. A prediction job whose answer is a number on a continuous scale is called regression, and rent pricing is regression in its purest form.

Before touching a model, lock the three framing lines from the Learning Setup lesson. The decision this prediction changes: the advertised price on the new listing. The label: the rent the tenant finally signs at — not the asking price, which is a hope rather than an outcome, and not a rent band someone eyeballed. And the error story: when this tool is wrong it is wrong in rupees, so score it in rupees. Mean absolute error — MAE — is the average of the misses with their signs stripped: predict ₹18,900 for a flat that signs at ₹18,000 and the miss is ₹900; average such misses over many flats and the result reads as "this tool is typically about this many rupees off per month". That is a sentence a landlord can act on. "The R² was 0.62" is not.

One more framing line, easy to skip: say which flats the tool covers — one city, unfurnished, ordinary long leases, for instance — because a model scored on studio flats and a model scored on villas are being scored on different products, and their MAEs cannot be compared.

Figure. The whole pipeline in one line: the facts known the day a flat is listed go into the model, a rupee amount comes out, and that amount sets the advertised price. Every later choice — which error metric, which columns are legal — is judged against this decision, not against a notebook score.

2The number to beat: always guess the median

So what counts as a good MAE — is ₹2,000 a month good? On its own the number is meaningless; it only means something against a benchmark, the score of the simplest guesser you would ever ship. For pricing, that guesser ignores the flat entirely and always predicts the middle rent of the flats it trained on. The middle value of a sorted list is called the median. Take the three notebook flats the Learning Setup lesson tabulated, with rents of ₹18k, ₹30k and ₹11k a month: sorted they read 11, 18, 30, the middle value is 18 — so the median guesser answers ₹18,000 for every flat it is ever shown, big or small, near or far.

Now score it, flat by flat. It gets the ₹18k flat exactly right — a miss of zero, because that flat happens to sit at the median. It calls the ₹30k flat ₹18k, missing by ₹12,000. It calls the ₹11k flat ₹18k, missing by ₹7,000. Strip the signs, average the three misses, and the benchmark's MAE comes out near ₹6,330 a month. That figure is the floor under everything that follows: any model you build gets to exist only if its MAE lands below it. A model that cannot beat always guessing the median is not a model — it is overhead with a fit method.

Figure. The median guesser's misses on the three notebook flats, in thousands of rupees per month: zero on the flat that sits at the median, 12 and 7 on the flats it ignores its way past. The dashed line is their average — an MAE near ₹6,330 — and it is the floor every real model must beat.

3A price list you can read

The Linear Regression lesson built the machine: ordinary least squares takes training rows and returns the weighted sum \hat{y} = w \cdot x + b whose squared misses are smallest. Point it at the 200 notebook flats and suppose it hands back this price list, with rent in thousands of rupees per month: \hat{y} = 9 + 0.018 \cdot \text{size} - 0.9 \cdot \text{distance} - 0.15 \cdot \text{age}. Read it line by line, because being readable is the whole reason to start linear. The 9 is the base: ₹9,000 of rent before the flat's facts say anything. The 0.018 is the size weight: each extra square foot adds 0.018 thousand — ₹18 — so a hundred extra square feet price about ₹1,800 higher. The −0.9 says every kilometre away from the centre costs ₹900 of monthly rent, and the −0.15 says each year of building age shaves off ₹150.

Every weight comes with the same fine print: it is the change in predicted rent when that one feature moves and the others stay put. And each weight is a claim you can argue with — if the distance slope came out positive you would suspect the data or a leaked column, not conclude that tenants pay extra to live far away. That arguability is exactly what a readable baseline buys. A random forest may well score a little better on the same rows, and you may climb to it later; but it buries the rupee story, so it should be made to beat this price list first, not replace it unexamined.

Figure. The price list pricing one new listing: 900 square feet contribute +16.2 thousand, 3 km of distance takes 2.7 back, 8 years of age takes another 1.2, and the base of 9 brings the prediction to about ₹21,300 a month. Every arrow is a rupee amount you can defend to a landlord.

4Check the misses, in rupees

A fitted price list is a claim, and residuals are how you audit it. For one flat the residual is y - \hat{y}: the actual signed rent minus the model's prediction — the miss, with its sign kept. Run the price list over the three notebook flats. The 850 sqft flat 4 km out: predicted 18.9 against an actual 18, residual −0.9 — the model guessed ₹900 too high. The 1,100 sqft flat near the centre: predicted 26.7 against 30, residual +3.3 — ₹3,300 too low. The old 600 sqft flat far out: predicted 8.7 against 11, residual +2.3 — ₹2,300 too low. Read the sign as a direction: positive means the model under-priced the flat, negative means it over-priced it.

Strip the signs and average: (0.9 + 3.3 + 2.3) / 3 lands near ₹2,170 of typical miss. Set that beside the median guesser's ₹6,330 and the price list has cut the typical miss to roughly a third of the no-model floor. That pair — model MAE against benchmark MAE — is the sentence to report; R² can ride along, but on its own it cannot say whether the errors are small enough to advertise prices with. One more look before shipping: plot the residuals against size. If they scatter randomly around zero, fine; if they bend — too low at both extremes and too high in the middle, or the reverse — the straight-line shape is wrong even while R² looks respectable, and the fix is a transformed feature, an interaction or a tree, not despair.

Figure. Typical miss per month, in thousands of rupees, on the three notebook flats: about 6.33 for the no-model median guesser against about 2.17 for the fitted price list. The comparison — not either number alone — is what says the model earned its keep.

5Score it the way it will be used

Everything so far scored three flats the model was allowed to study, which was fine for learning the arithmetic and is exactly what a real pipeline must not do. The Train / Test Split contract applies unchanged: cut before fitting, tune on validation, open the test fold once. When the office scales the notebook to 500 listings, that means something like 400 rows to fit and 100 held out — and the two scores are read together. A training MAE of ₹1,800 sitting next to a test MAE of ₹3,200 says the model memorised part of what it studied; the honest number, the one that goes in front of a landlord, is the ₹3,200.

Rent data adds its own way to cheat the cut. Flats repeat their building: if building 12 contributed six listings and a random shuffle drops four into train and two into test, the model meets building 12's price level while fitting and is then "tested" on the same building — the repeat-customer trap from Train / Test Split, wearing an address. The two test flats are not really unseen, so the test MAE flatters the model. When rows share a building, a street or a neighbourhood, keep the whole group on one side of the cut: group-split by building or neighbourhood.

And keep the timing test from Learning Setup running over every column. This tool runs the day a flat is listed, so a legal feature is a fact that exists on that day: size, distance, age, bedrooms all qualify. The discount the tenant eventually negotiated exists only after signing — training on it means partly reading the answer. The asking price is sneakier: the tool exists to set the asking price, so at the moment it runs there is no asking price yet; a column that is filled in by the very decision you are making is leakage of the circular kind. Broker commission, settled at signing, fails the same test.

Figure. A random shuffle of 500 listings put four of building 12's six flats in train and two in test. The model learns that building's price level while fitting, then gets scored on the same building — so the test flats are not truly unseen and the score is optimistic. Group-split by building keeps all six on one side.

6Lab: price flats end to end

Time to run the whole lesson as one pipeline, in the browser: load a real table of flats, hold out a test fold, score the median benchmark, fit the linear price list, and compare the two in rupees. The dataset is rent_price_v1: 200 flats, like the notebook — though this sample comes from a cheaper market (rents run about ₹1,270 to ₹3,660 a month) and records bedrooms and bathrooms instead of building age. Different city, same job. Its five columns are sqft, bedrooms, bathrooms, distance_km and rent, and the file is mounted for you at /data/rent_price_v1.csv.

Cell 1 loads and looks. pandas is the table library: read_csv pulls the file into a DataFrame — a table object, named df here. df.shape prints (rows, columns) so you can confirm 200 by 5, df.head(3) prints the first three flats so you see real values rather than trusting column names, and the median rent of the whole file — about ₹2,492 — prints for orientation. Nothing is fitted yet.

Cell 2 is the whole contract in one place, and it reuses df from Cell 1 — both cells share one running Python session (the kernel), so run them in order. First the cut: X takes the four feature columns (the double brackets select several columns as a table) and y takes the rent column; train_test_split with test_size=0.25 and random_state=0 locks 150 flats for fitting and 50 away for scoring. Then the benchmark: the training fold's median rent (about ₹2,532) is used as the guess for every test flat, and its MAE prints at about ₹481 — the floor. Then the model: LinearRegression fits on the training fold only, predicts the 50 held-out flats, and its MAE prints at about ₹62. Read the coefficients as rupee stories: about ₹1.1 per square foot (₹110 per extra 100 sqft), ₹200 per bedroom, ₹144 per bathroom, and −₹24 per kilometre from the hub — believable signs, all four.

Cell 3 draws the check that a single number cannot: a scatter of predicted against actual rent for the 50 test flats, with a dashed diagonal marking perfect prediction. A point on the diagonal is a flat priced exactly right; vertical distance from it is that flat's miss in rupees. Points hugging the line evenly is what a healthy fit looks like; a cloud that drifts off the diagonal at the cheap or expensive end is telling you where the straight shape gives out. The cell reuses y_test and pred from Cell 2, so change the title or markers and re-run just this cell — nothing refits.

Two honesty notes to carry out. The model's MAE of ₹62 against a benchmark of ₹481 is a genuine eight-fold cut — but the R² near 0.98 should still raise an eyebrow: this is a synthetic teaching sample, far cleaner than any real market. And the 50 test flats stayed untouched until scoring: the moment a choice depends on the test fold, its number stops being honest.

No diagram — the predicted-versus-actual scatter is drawn by the coding lab plot, with the dashed diagonal marking perfect prediction.

Coding lab. Price flats end to end runs in the app, with checks on your output.