Linear Regression: Building a House-Price Prediction Engine

An end-to-end regression case study: price modeling, least squares, multivariable regression, validation, interpretation, model persistence and an interactive pricing desk.

Real-estate pricing lab

🏠 A homeowner wants to list a house tomorrow. What price should the platform recommend?

Imagine a home-listing company building an internal pricing engine. A new property arrives with 2,150 sq ft, 3 bedrooms, 2.5 bathrooms, age 8 years, and a strong neighborhood score.

The analyst’s task is not to classify the house. It is to estimate a continuous quantity:

What sale price should we expect, given the characteristics of this home?

This is a regression problem.

The goal of this chapter is to build the solution the way a data scientist would actually build it:

BUSINESS QUESTION → DATA → BASELINE → SIMPLE MODEL → MULTIVARIABLE MODEL → VALIDATION → INTERPRETATION → SAVE → PREDICT

TipBy the end, you should be able to

• identify a continuous-target regression problem;
• explain a fitted line using slope, intercept and residuals;
• derive the least-squares objective and understand optimization;
• move from one predictor to multiple predictors;
• separate training from validation/test data;
• interpret R^2, adjusted R^2, MSE, RMSE and MAPE;
• inspect residuals and diagnose obvious model problems;
• interpret coefficients conditionally;
• save and reload a trained model;
• turn a fitted regression model into a simple prediction product.

1. Frame the Business Problem Before the Equation

Suppose the platform has historical sales.

For each house, we observe:

• living area;
• bedrooms;
• bathrooms;
• age;
• neighborhood quality;
• distance to downtown;
• actual sale price.

Our target is

Y=\text{sale price}.

Our predictors are

X=(x_1,x_2,\ldots,x_p).

Unlike fraud classification, Y is not a class such as 0/1. It is a continuous number such as

\$425{,}000,\quad \$612{,}500,\quad \$1{,}040{,}000.

A useful model should answer:

E[Y\mid X],

the expected sale price for homes with characteristics X.

TargetSale price

Problem typeRegression

First baselineTypical price

Model outputPredicted $

2. Start Small: Can Square Footage Explain Price?

Before building a large model, ask whether one obvious feature contains useful signal.

We begin with:

x=\text{living area in 1,000 sq ft}.

and

y=\text{sale price in \$100,000}.

The simple linear model is

\boxed{\hat y=\beta_0+\beta_1x}.

• \beta_0 is the intercept;
• \beta_1 is the slope;
• \hat y is the model’s predicted price.

2.1 Build a small housing market

Data Simulator

import numpy as np
import pandas as pd

rng = np.random.default_rng(91)

n = 240
sqft = rng.normal(2100, 620, n).clip(700, 4300)

price = (
    105_000
    + 205 * sqft
    + rng.normal(0, 72_000, n)
)

simple_homes = pd.DataFrame({
    "sqft": sqft,
    "sale_price": price.clip(130_000)
})

Plot Code

import plotly.express as px

fig = px.scatter(
    simple_homes,
    x="sqft",
    y="sale_price",
    trendline="ols",
    title="First Look: Larger Homes Tend to Sell for More",
    hover_data={"sqft":":.0f","sale_price":":$,.0f"}
)

fig.update_layout(
    xaxis_title="Living area (sq ft)",
    yaxis_title="Sale price ($)",
    height=470
)
fig.show()

The cloud is noisy. Two homes with the same square footage can sell for different prices.

That is not a failure of regression. It tells us that square footage is informative but incomplete.

3. The Line Is a Prediction Rule

Suppose a fitted line is

\hat y=110{,}000+200x,

where x is square feet.

Then an additional square foot is associated with approximately 200 more predicted price in this simplified model.

For a 2,000 sq ft home:

\hat y = 110{,}000+200(2{,}000) = 510{,}000.

The observed sale price will usually not land exactly on the line.

The difference is a residual:

\boxed{e_i=y_i-\hat y_i}.

A positive residual means the house sold above the model prediction.

A negative residual means it sold below the model prediction.

4. Interactive Lab: Fit the Line Yourself

Instead of immediately letting software optimize, try being the optimizer.

Move the intercept and slope. Watch the line and sum of squared errors (SSE) respond.

viewof houseIntercept = Inputs.range([0, 350], {
  value:100,
  step:5,
  label:"Intercept ($000s)"
})

viewof houseSlope = Inputs.range([50, 300], {
  value:190,
  step:5,
  label:"Slope ($ per sq ft)"
})

houseRand = d3.randomLcg(.41)

housePts = d3.range(48).map(i => {
  const sqft = 850 + i*58
  const priceK = 95 + .205*sqft + (houseRand()-.5)*145
  return {sqft:sqft, priceK:priceK}
})

houseFit = housePts.map(d => ({
  sqft:d.sqft,
  fitted:houseIntercept + (houseSlope/1000)*d.sqft
}))

houseSSE = d3.sum(
  housePts,
  d => {
    const pred = houseIntercept + (houseSlope/1000)*d.sqft
    return (d.priceK-pred)**2
  }
)

html`<div style="padding:.75rem 1rem;border-radius:14px;background:#f0fdfa;border:1px solid #99f6e4">
<b>SSE:</b> ${houseSSE.toLocaleString(undefined,{maximumFractionDigits:0})}
&nbsp;&nbsp;|&nbsp;&nbsp;
Try to make this as small as possible.
</div>`

Plot.plot({
  height:390,
  x:{label:"Living area (sq ft)"},
  y:{label:"Sale price ($000s)"},
  marks:[
    Plot.dot(housePts,{
      x:"sqft",
      y:"priceK",
      r:4,
      fill:"#0f766e",
      opacity:.72,
      tip:true
    }),
    Plot.line(houseFit,{
      x:"sqft",
      y:"fitted",
      stroke:"#f97316",
      strokeWidth:4
    })
  ]
})

You are doing manually what an optimization algorithm does systematically.

5. Why Least Squares?

For observation i:

e_i=y_i-(\beta_0+\beta_1x_i).

If we simply sum residuals, positive and negative errors can cancel.

So ordinary least squares minimizes the sum of squared errors:

\boxed{ SSE(\beta_0,\beta_1) = \sum_{i=1}^{n} \left[ y_i-(\beta_0+\beta_1x_i) \right]^2 }.

Squaring:

1. prevents cancellation;
2. penalizes large errors strongly;
3. creates a smooth optimization problem.

6. Optimization in Short: How Does the Model Find the Best Coefficients?

There are two useful viewpoints.

6.1 Closed-form least squares

Write multiple linear regression as

\mathbf y=\mathbf X\boldsymbol\beta+\boldsymbol\varepsilon.

The least-squares objective is

J(\boldsymbol\beta) = (\mathbf y-\mathbf X\boldsymbol\beta)^T (\mathbf y-\mathbf X\boldsymbol\beta).

Setting the gradient to zero gives the normal equation:

\mathbf X^T\mathbf X\hat{\boldsymbol\beta} = \mathbf X^T\mathbf y.

When the inverse exists,

\boxed{ \hat{\boldsymbol\beta} = (\mathbf X^T\mathbf X)^{-1} \mathbf X^T\mathbf y }.

In numerical software, explicit matrix inversion is often avoided in favor of more stable linear-algebra methods.

6.2 Gradient descent

For large or more general optimization problems, update parameters iteratively:

\boxed{ \boldsymbol\beta^{(t+1)} = \boldsymbol\beta^{(t)} - \eta\nabla J(\boldsymbol\beta^{(t)}) }

where \eta is the learning rate.

The gradient points uphill; subtracting it moves downhill.

7. See the Loss Landscape

For a simple two-parameter regression, SSE forms a bowl-shaped surface.

Data Simulator

import numpy as np

rng = np.random.default_rng(17)

x_loss = np.linspace(.8,4.0,55)
y_loss = 1.0 + 2.1*x_loss + rng.normal(0,.65,len(x_loss))

b0_grid = np.linspace(-1.0,3.2,75)
b1_grid = np.linspace(.6,3.5,75)

loss_surface = np.array([
    [
        np.sum((y_loss-(b0+b1*x_loss))**2)
        for b1 in b1_grid
    ]
    for b0 in b0_grid
])

Plot Code

import plotly.graph_objects as go

fig = go.Figure(
    go.Surface(
        x=b1_grid,
        y=b0_grid,
        z=loss_surface,
        showscale=False
    )
)

fig.update_layout(
    title="Least-Squares Optimization Landscape",
    height=500,
    scene={
        "xaxis_title":"Slope β₁",
        "yaxis_title":"Intercept β₀",
        "zaxis_title":"SSE"
    }
)
fig.show()

The bottom of the bowl corresponds to the least-squares solution.

8. One Predictor Is Not a Pricing Engine

A listing platform would not price a home using square footage alone.

Two 2,000 sq ft homes may differ because of:

• bedrooms and bathrooms;
• age and condition;
• neighborhood;
• access to jobs and amenities;
• lot size;
• renovation;
• market timing.

So we move to multiple linear regression:

\boxed{ \hat y = \beta_0 +\beta_1x_1 +\beta_2x_2 +\cdots +\beta_px_p }.

The important conceptual change is small:

We still predict one continuous target, but now several features contribute simultaneously.

9. Build a More Realistic Housing Dataset

We will simulate a housing market with six predictors.

Data Simulator

import numpy as np
import pandas as pd

rng = np.random.default_rng(2026)
n = 2600

housing = pd.DataFrame({
    "sqft": rng.normal(2200,650,n).clip(650,5000),
    "bedrooms": rng.integers(1,6,n),
    "bathrooms": rng.choice(
        [1,1.5,2,2.5,3,3.5,4],
        size=n,
        p=[.05,.08,.23,.24,.20,.12,.08]
    ),
    "age_years": rng.gamma(2.1,9,n).clip(0,85),
    "neighborhood_score": rng.normal(72,12,n).clip(35,100),
    "distance_downtown_mi": rng.gamma(2.2,4.5,n).clip(1,35)
})

market_noise = rng.normal(0,55_000,n)

housing["sale_price"] = (
    52_000
    + 185*housing["sqft"]
    + 12_500*housing["bedrooms"]
    + 25_000*housing["bathrooms"]
    - 1_450*housing["age_years"]
    + 4_200*housing["neighborhood_score"]
    - 3_100*housing["distance_downtown_mi"]
    + market_noise
).clip(120_000)

Plot Code

import plotly.express as px

sample_housing = housing.sample(900,random_state=11)

fig = px.scatter(
    sample_housing,
    x="sqft",
    y="sale_price",
    color="neighborhood_score",
    size="bathrooms",
    hover_data=[
        "bedrooms",
        "age_years",
        "distance_downtown_mi"
    ],
    title="Price Depends on More Than Square Footage"
)

fig.update_layout(
    xaxis_title="Living area (sq ft)",
    yaxis_title="Sale price ($)",
    height=500
)
fig.show()

Hover over similarly sized homes. Their other attributes help explain why prices differ.

10. Modeling Approach: Train First, Judge Later

A dangerous workflow is:

fit model on all data → evaluate on same data → celebrate

The model has already seen those outcomes.

For prediction, we need evidence that it generalizes to homes it did not train on.

A practical workflow is:

TRAIN SET
  ↓
fit coefficients

VALIDATION / CROSS-VALIDATION
  ↓
compare models and choices

TEST SET
  ↓
final unbiased estimate of performance

For this lesson we use a train/test split for the main end-to-end model and then introduce cross-validation as a stronger validation method.

11. Fit the Multivariable Model

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

features = [
    "sqft",
    "bedrooms",
    "bathrooms",
    "age_years",
    "neighborhood_score",
    "distance_downtown_mi"
]

X = housing[features]
y = housing["sale_price"]

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=.25,
    random_state=42
)

price_model = LinearRegression()
price_model.fit(X_train,y_train)

test_prediction = price_model.predict(X_test)

At this point we have a fitted model.

We do not yet know whether it is useful.

That requires validation.

12. Validation: Four Metrics Tell Different Stories

No single regression metric answers every question.

12.1 Mean Squared Error — MSE

\boxed{ MSE = \frac{1}{n} \sum_{i=1}^n (y_i-\hat y_i)^2 }

Large errors are penalized strongly because errors are squared.

Its units are dollars squared, so it is mathematically useful but less intuitive to business users.

We often also report

RMSE=\sqrt{MSE},

which returns to dollars.

12.2 Mean Absolute Percentage Error — MAPE

\boxed{ MAPE = \frac{100}{n} \sum_{i=1}^{n} \left| \frac{y_i-\hat y_i}{y_i} \right| }

If MAPE is 8%, a rough interpretation is that predictions differ from actual values by about 8% on average in absolute percentage terms.

MAPE can behave poorly when actual values are zero or very close to zero. House prices are positive and far from zero, so it is more interpretable here.

12.3 R^2

\boxed{ R^2 = 1- \frac{\sum(y_i-\hat y_i)^2} {\sum(y_i-\bar y)^2} }

R^2 compares the model’s squared error with a baseline that always predicts the mean.

• R^2=1: perfect fit;
• R^2=0: no better than the mean baseline under this comparison;
• R^2<0: worse than that baseline on the evaluated data.

12.4 Adjusted R^2

Ordinary R^2 never decreases when predictors are added to the same training data.

Adjusted R^2 adds a complexity penalty:

\boxed{ \bar R^2 = 1- (1-R^2) \frac{n-1}{n-p-1} }

where:

• n = number of observations;
• p = number of predictors.

It is especially useful for comparing nested explanatory linear models, but it does not replace out-of-sample validation.

13. Score the Holdout Homes

Data Simulator

import numpy as np
import pandas as pd
from sklearn.metrics import (
    mean_squared_error,
    mean_absolute_percentage_error,
    r2_score
)

mse = mean_squared_error(y_test,test_prediction)
rmse = np.sqrt(mse)
mape = mean_absolute_percentage_error(
    y_test,test_prediction
)*100
r2 = r2_score(y_test,test_prediction)

n_test = len(y_test)
p = len(features)

adjusted_r2 = 1 - (1-r2)*(n_test-1)/(n_test-p-1)

validation_metrics = pd.DataFrame({
    "metric":["R²","Adjusted R²","RMSE ($)","MAPE (%)"],
    "value":[r2,adjusted_r2,rmse,mape]
})

Plot Code

import plotly.graph_objects as go

fig = go.Figure()

fig.add_trace(go.Indicator(
    mode="number",
    value=r2,
    number={"valueformat":".3f"},
    title={"text":"Holdout R²"},
    domain={"row":0,"column":0}
))

fig.add_trace(go.Indicator(
    mode="number",
    value=adjusted_r2,
    number={"valueformat":".3f"},
    title={"text":"Adjusted R²"},
    domain={"row":0,"column":1}
))

fig.add_trace(go.Indicator(
    mode="number",
    value=rmse,
    number={"prefix":"$","valueformat":",.0f"},
    title={"text":"RMSE"},
    domain={"row":1,"column":0}
))

fig.add_trace(go.Indicator(
    mode="number",
    value=mape,
    number={"suffix":"%","valueformat":".1f"},
    title={"text":"MAPE"},
    domain={"row":1,"column":1}
))

fig.update_layout(
    grid={"rows":2,"columns":2,"pattern":"independent"},
    title="Validation Dashboard — Homes the Model Did Not Train On",
    height=500
)
fig.show()

A data scientist should report metrics in language the decision maker can understand.

For example:

“On unseen homes, typical prediction error is on the order of the reported RMSE, while MAPE expresses the error relative to house price. R^2 summarizes how much of the variation is captured relative to a mean-price baseline.”

14. Actual vs Predicted: Does the Model Track the Market?

Metrics compress performance into numbers. A plot can reveal structure the summary misses.

Data Simulator

import pandas as pd

prediction_check = pd.DataFrame({
    "actual_price":y_test.to_numpy(),
    "predicted_price":test_prediction
})

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

Plot Code

import plotly.express as px

fig = px.scatter(
    prediction_check,
    x="actual_price",
    y="predicted_price",
    hover_data={"residual":":$,.0f"},
    title="Holdout Homes: Actual Price vs Predicted Price"
)

low = prediction_check[
    ["actual_price","predicted_price"]
].min().min()

high = prediction_check[
    ["actual_price","predicted_price"]
].max().max()

fig.add_shape(
    type="line",
    x0=low,y0=low,x1=high,y1=high,
    line={"dash":"dash"}
)

fig.update_layout(
    xaxis_title="Actual sale price ($)",
    yaxis_title="Predicted sale price ($)",
    height=480
)
fig.show()

Points close to the diagonal are well predicted.

Systematic curvature, widening error, or clusters would suggest the model is missing structure.

15. Residuals Are a Model-Debugging Tool

Residual:

e_i=y_i-\hat y_i.

A useful residual plot should look roughly like an unstructured cloud around zero.

Data Simulator

residual_data = prediction_check.copy()

Plot Code

import plotly.express as px

fig = px.scatter(
    residual_data,
    x="predicted_price",
    y="residual",
    title="Residual Diagnostic: What Is the Model Still Missing?"
)

fig.add_hline(y=0,line_dash="dash")

fig.update_layout(
    xaxis_title="Predicted price ($)",
    yaxis_title="Residual = actual − predicted ($)",
    height=450
)
fig.show()

Look for:

curved pattern      → missing nonlinearity
funnel shape        → changing error variance
separate clusters   → missing segments / interactions
extreme residuals   → unusual homes or data problems

Residual analysis turns “the metric looks okay” into actual model diagnosis.

16. Cross-Validation: Do Not Depend on One Lucky Split

A single train/test split can be unusually easy or difficult.

In K-fold cross-validation:

1. split the training data into K folds;
2. train on K-1 folds;
3. validate on the remaining fold;
4. rotate the validation fold;
5. summarize performance.

Fold 1: [VALID] [TRAIN] [TRAIN] [TRAIN] [TRAIN]
Fold 2: [TRAIN] [VALID] [TRAIN] [TRAIN] [TRAIN]
Fold 3: [TRAIN] [TRAIN] [VALID] [TRAIN] [TRAIN]
...

16.1 Five-fold validation

Data Simulator

import numpy as np
import pandas as pd
from sklearn.model_selection import KFold, cross_validate
from sklearn.linear_model import LinearRegression

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

cv_result = cross_validate(
    LinearRegression(),
    X_train,
    y_train,
    cv=cv,
    scoring={
        "r2":"r2",
        "mape":"neg_mean_absolute_percentage_error",
        "mse":"neg_mean_squared_error"
    }
)

cv_table = pd.DataFrame({
    "fold":np.arange(1,6),
    "R²":cv_result["test_r2"],
    "MAPE (%)":-100*cv_result["test_mape"],
    "RMSE ($)":np.sqrt(-cv_result["test_mse"])
})

Plot Code

import plotly.express as px

fig = px.bar(
    cv_table,
    x="fold",
    y="MAPE (%)",
    hover_data=["R²","RMSE ($)"],
    title="Five-Fold Cross-Validation: Is Performance Stable?"
)

fig.update_layout(
    xaxis_title="Validation fold",
    yaxis_title="MAPE (%)",
    height=430
)
fig.show()

If performance varies wildly across folds, investigate before deployment.

17. Interpret the Multivariable Model

The fitted model is

\hat y = \hat\beta_0 +\hat\beta_1x_1+\cdots+\hat\beta_px_p.

For multiple regression, a coefficient is interpreted holding the other included predictors constant.

For example, if the fitted sqft coefficient were 185:

Holding bedrooms, bathrooms, age, neighborhood score and distance constant, one additional square foot is associated with about $185 higher predicted sale price.

That conditional phrase matters.

17.1 Coefficient workbench

Data Simulator

import pandas as pd

coefficient_table = pd.DataFrame({
    "feature":features,
    "coefficient":price_model.coef_
})

coefficient_table["direction"] = coefficient_table[
    "coefficient"
].apply(
    lambda x:"Raises prediction" if x>=0 else "Lowers prediction"
)

Plot Code

import plotly.express as px

fig = px.bar(
    coefficient_table.sort_values("coefficient"),
    x="coefficient",
    y="feature",
    orientation="h",
    color="direction",
    title="How Each Feature Moves the Predicted Price"
)

fig.add_vline(x=0,line_dash="dot")

fig.update_layout(
    xaxis_title="Change in predicted price per one-unit increase",
    yaxis_title="Feature",
    height=450
)
fig.show()

WarningDo not compare raw coefficient magnitudes carelessly

A one-unit change means very different things for:

• 1 square foot;
• 1 bathroom;
• 1 year of age;
• 1 neighborhood-score point.

Coefficient size depends on units. Standardization or domain-relevant increments can make comparisons more meaningful.

18. Interpretation Is Not Automatically Causation

If the model estimates a positive coefficient for neighborhood score, that does not by itself prove:

“Increasing the score by one point causes the house price to rise by exactly this amount.”

Regression can estimate conditional associations and make predictions without establishing a causal intervention.

For a listing-price product, predictive accuracy may be the primary goal. For policy or causal questions, the modeling design must be stronger.

19. What About Irrelevant Features?

Adding predictors can increase training R^2 even when the feature contributes little real predictive value.

That is one reason we use:

• adjusted R^2 for complexity-aware in-sample comparison;
• cross-validation for generalization;
• a final holdout/test set;
• regularization when the feature space becomes large.

Ridge regression modifies the objective:

SSE+\lambda\sum_{j=1}^{p}\beta_j^2.

Lasso uses:

SSE+\lambda\sum_{j=1}^{p}|\beta_j|.

For this lesson, ordinary linear regression is sufficient because the data-generating relationship is deliberately close to linear.

20. Save the Model: Training Should Not Happen for Every User

Once validated, the fitted object can be serialized.

import joblib

artifact = {
    "model":price_model,
    "features":features
}

joblib.dump(
    artifact,
    "house_price_model.joblib"
)

Later, a prediction service can reload it:

import joblib

artifact = joblib.load(
    "house_price_model.joblib"
)

loaded_model = artifact["model"]
loaded_features = artifact["features"]

Saving the feature order with the model is a small but important engineering habit.

In a production system, also version:

• preprocessing;
• feature definitions;
• model version;
• training-data snapshot or lineage;
• validation metrics;
• package/runtime environment.

21. From Notebook to Product

A useful model eventually needs a user or another system to call it.

The architecture may look like:

LISTING FORM → FEATURE VALIDATION → SAVED MODEL → PREDICT() → ESTIMATED PRICE → ANALYST / CUSTOMER

For example, an analyst enters:

Living area          2,150 sq ft
Bedrooms             3
Bathrooms            2.5
Age                   8 years
Neighborhood score   82
Distance downtown     9 miles

The backend builds the same feature vector used during training and calls:

loaded_model.predict(new_house)

22. Interactive Pricing Desk

The following mini-dashboard mimics that final product.

It uses a fixed set of coefficients representing the deployed linear model so the browser can update instantly as you change the house.

🏡 Analyst Pricing Desk

Change the listing characteristics and watch the estimated price update.

viewof uiSqft = Inputs.range([700,5000], {
  value:2150, step:50, label:"Living area (sq ft)"
})

viewof uiBeds = Inputs.range([1,6], {
  value:3, step:1, label:"Bedrooms"
})

viewof uiBaths = Inputs.range([1,4.5], {
  value:2.5, step:.5, label:"Bathrooms"
})

viewof uiAge = Inputs.range([0,80], {
  value:8, step:1, label:"Age (years)"
})

viewof uiNeighborhood = Inputs.range([35,100], {
  value:82, step:1, label:"Neighborhood score"
})

viewof uiDistance = Inputs.range([1,35], {
  value:9, step:1, label:"Distance to downtown (miles)"
})

uiPrediction =
  52000
  + 185*uiSqft
  + 12500*uiBeds
  + 25000*uiBaths
  - 1450*uiAge
  + 4200*uiNeighborhood
  - 3100*uiDistance

html`<div style="
  margin-top:1rem;
  padding:1.1rem 1.2rem;
  border-radius:18px;
  background:linear-gradient(135deg,#134e4a,#0f766e);
  color:white;
  box-shadow:0 12px 30px rgba(15,118,110,.18)">
  <div style="font-size:.82rem;letter-spacing:.08em;text-transform:uppercase;opacity:.8">
    Suggested model price
  </div>
  <div style="font-size:2rem;font-weight:800;margin:.2rem 0">
    $${Math.round(uiPrediction).toLocaleString()}
  </div>
  <div style="opacity:.82">
    Model estimate — not a guaranteed sale price
  </div>
</div>`

comparison = [
  {label:"Model estimate", price:uiPrediction},
  {label:"$450k reference", price:450000},
  {label:"$650k reference", price:650000}
]

Plot.plot({
  height:260,
  marginLeft:120,
  x:{
    label:"Price ($)",
    grid:true,
    tickFormat:d=>"$"+Math.round(d/1000)+"k"
  },
  y:{label:null},
  marks:[
    Plot.barX(comparison,{
      x:"price",
      y:"label",
      fill:d=>d.label==="Model estimate" ? "#f97316" : "#a8a29e",
      tip:true
    }),
    Plot.ruleX([uiPrediction],{
      stroke:"#7c2d12",
      strokeWidth:2
    })
  ]
})

This is the final conceptual transition:

A regression equation becomes useful when it is wrapped in a repeatable prediction workflow.

23. What Happens When the Market Changes?

A saved model is not permanently correct.

Housing markets change because of:

• interest rates;
• inventory;
• seasonality;
• migration;
• neighborhood development;
• economic conditions.

Production monitoring should compare new predictions and eventual sale outcomes.

Questions include:

• Is MAPE getting worse?
• Are residuals drifting positive or negative?
• Has the distribution of square footage or neighborhoods changed?
• Does the model systematically underprice a new segment?
• Should the model be retrained?

Deployment is not the end of modeling. It starts the monitoring phase.

24. End-to-End Checklist

1Define YContinuous target

2Choose XAvailable predictors

3SplitProtect validation

4FitMinimize loss

5ValidateMetrics + residuals

6InterpretConditional effects

7SaveVersion artifact

8ServePredict new homes

25. Solve the Original Listing Problem

We started with a practical question:

What price should the platform recommend for a new house?

The solution was not “write LinearRegression().”

It was a sequence of decisions:

1. identify sale price as a continuous target;
2. explore a simple relationship with square footage;
3. understand the line, residuals and least-squares objective;
4. add meaningful predictors;
5. fit only on training data;
6. validate on unseen homes;
7. examine R^2, adjusted R^2, MSE/RMSE and MAPE;
8. inspect residuals;
9. interpret coefficients with their units and conditional meaning;
10. save the validated model;
11. expose it through a prediction interface;
12. monitor it as the market evolves.

That is a reusable regression workflow.

The same pattern can be adapted to:

• rental-price prediction;
• demand forecasting with suitable features;
• delivery-time estimation;
• energy-use prediction;
• customer-spend prediction;
• insurance-cost estimation;
• manufacturing yield prediction.

The domain changes. The discipline remains.

Summary

Linear regression models a continuous target as

\boxed{ \hat y = \beta_0+\beta_1x_1+\cdots+\beta_px_p }.

Ordinary least squares chooses coefficients that minimize

\boxed{ \sum_i(y_i-\hat y_i)^2 }.

For predictive work:

• begin with the business target, not the algorithm;
• establish a simple baseline;
• move from simple to multivariable regression deliberately;
• protect unseen data for evaluation;
• use multiple validation metrics because each answers a different question;
• inspect residuals, not only headline scores;
• interpret coefficients with units and “holding other included variables constant”;
• persist the model and feature contract;
• turn the model into a reproducible prediction service;
• monitor performance after deployment.

The regression mindset

A fitted line is not the final product.

The real product is a validated, interpretable, reproducible prediction process that can receive new information and return a useful estimate.

Next: Logistic Regression: Probability, Odds & Classification