Summary

This summary reviews Chapter 6: how linear regression learns a straight line, Salary = m × Experience + c, from labeled examples, and how section 6.9's two metrics, Mean Squared Error and the R² score, tell us how well that line fits.

Chapter 6 used one small dataset, years of experience and salary for five people, to walk through supervised learning with linear regression from start to finish. You created the dataset, plotted it, trained a model with scikit-learn, read its slope and intercept, predicted a salary for 6 years of experience, drew the regression line and evaluated it. Section 6.9 completed the workflow with two metrics: Mean Squared Error (MSE), the average squared prediction error, where lower is better, and the R² score, the share of the variation in salary that the line explains, where closer to 1 is better. For this data the least-squares line is Salary = 6500 × Experience + 28500. It predicts 67,500 for 6 years and scores an MSE of 1,500,000 and an R² of about 0.98.

Summary: Supervised Learning – Linear Regression

The big idea. In supervised learning a model learns from labeled examples, inputs paired with correct outputs, so that it can predict the output for new inputs. Linear regression is the simplest supervised algorithm for predicting a number. It models the dependent variable y (the target, here Salary) as a straight-line function of an independent variable x (the feature, here Experience):

y = mx + c

The slope m says how much y changes when x goes up by one. The intercept c is the value of y when x is 0. Training means finding the m and c whose line has the smallest prediction error.

The workflow you followed in this chapter:

1. Dataset (6.3): Experience 1 to 5 years and Salary 35,000, 40,000, 50,000, 55,000 and 60,000, stored in a pandas DataFrame.
2. Visualise (6.4): a scatter plot showed points rising in a roughly straight band, a sign that a straight line is a sensible model.
3. Train (6.5): X = df[['Experience']] and y = df['Salary'], then model = LinearRegression() and model.fit(X, y).
4. Interpret (6.6): model.coef_[0] is the slope and model.intercept_ is the intercept.
5. Predict (6.7): model.predict([[6]]) estimates the salary for 6 years of experience.
6. Plot the line (6.8): the red regression line drawn over the blue data points shows the fit at a glance.
7. Evaluate (6.9): mean_squared_error and r2_score turn "how good is the fit?" into numbers.

The whole chapter in one plain-Python script. No libraries are needed to see what those calls do:

# Chapter 6 dataset: years of experience and salary
experience = [1, 2, 3, 4, 5]
salary = [35000, 40000, 50000, 55000, 60000]
n = len(experience)
# Train: least-squares slope (m) and intercept (c)
mean_x = sum(experience) / n
mean_y = sum(salary) / n
m = sum((x - mean_x) * (y - mean_y) for x, y in zip(experience, salary)) / sum((x - mean_x) ** 2 for x in experience)
c = mean_y - m * mean_x
print("Model: Salary =", m, "x Experience +", c)
# Predict
print("Predicted salary for 6 years:", m * 6 + c)
# Evaluate on the training data
predictions = [m * x + c for x in experience]
errors = [y - p for y, p in zip(salary, predictions)]
mse = sum(e ** 2 for e in errors) / n
ss_res = sum(e ** 2 for e in errors)
ss_tot = sum((y - mean_y) ** 2 for y in salary)
r2 = 1 - ss_res / ss_tot
print("Predictions:", predictions)
print("Errors:", errors)
print("MSE:", mse)
print("R2 score:", round(r2, 4))

The least-squares line for this data is Salary = 6500 × Experience + 28500. Each extra year of experience adds about 6,500 to the predicted salary, and the line starts from 28,500 at zero years. Section 6.6 used rounder illustrative values (a slope of 6250 and an intercept of 28750) to show how to read the equation; fitting these exact five points gives 6500 and 28500, which is what the code above and scikit-learn both return. The prediction for 6 years is 6500 × 6 + 28500 = 67,500.

Section 6.9: evaluating the model. Evaluation starts from the errors (residuals), actual minus predicted: 0, −1,500, 2,000, 500 and −1,000.

• Mean Squared Error (MSE) squares each error and takes the average: (0 + 2,250,000 + 4,000,000 + 250,000 + 1,000,000) / 5 = 1,500,000. Squaring stops positive and negative errors from cancelling and punishes big misses. Lower is better, and 0 would be a perfect fit. Because the errors are squared, MSE is in "salary squared" units. Its square root, the RMSE (about 1,225), is easier to read: the line typically misses by roughly 1,200.
• R² score compares the model with a lazy baseline that always predicts the average salary, 48,000. R² = 1 − (sum of squared errors of the model) / (sum of squared errors of the baseline) = 1 − 7,500,000 / 430,000,000 ≈ 0.98. So the line explains about 98% of the variation in salary. Closer to 1 is better. For a least-squares line scored on the data it was trained on, R² lies between 0 and 1; a model that did worse than always guessing the average would even score below 0.
• Use both. MSE tells you how big the errors are, in the target's (squared) units. R² tells you how much better than the baseline you are, as a unit-free score.

What to remember before trusting a model:

• These scores were measured on the same five points the line was trained on. A fair test uses data the model has never seen, which is why datasets are split into training and test sets (5.5).
• Five points is very little data, and a single unusual point can swing the line and the scores dramatically.
• Predictions far outside the training range (1 to 5 years) are extrapolation and deserve less trust.
• A strong fit shows an association, not a cause: experience is only one of many things that affect salary.

The same workflow, with data, training, prediction and evaluation, carries straight on into Chapter 7, where logistic regression predicts categories instead of numbers.