Python Linear and Multiple Regression

In the simple case, the model is a line: drying hours = intercept + slope × thickness. After fitting:

• model.coef_ holds the slope: the change in predicted hours for each extra millimetre.
• model.intercept_ holds the predicted value when every feature is zero.
• model.predict(X_new) applies the formula to new rows.

model = LinearRegression().fit([[1], [2], [3], [4]], [3, 5, 7, 9])
print(model.predict([[2.5]]))      # [6.]

"Linear" refers to the coefficients, not the shape of the data. You can model curved relationships by adding transformed features, such as thickness² or log(thickness), and the model is still linear regression, because the prediction is a weighted sum of those columns. PolynomialFeatures in scikit-learn generates such columns. The model assumes the relationship really is approximately linear in its features; when it isn't, its predictions are systematically off in some ranges.

Multiple regression uses several columns at once, giving each its own coefficient:

# features: thickness (mm), room temperature (°C), humidity (%)
X = [[1, 20, 40], [2, 18, 55], [3, 22, 50], [2, 25, 35], [4, 19, 60], [1, 23, 45]]
y = [2.8, 6.1, 6.9, 4.2, 10.3, 2.6]
model = LinearRegression().fit(X, y)

Each coefficient estimates the effect of its feature with the others held fixed: how much drying time changes per extra millimetre at the same temperature and humidity.

That interpretation gets shaky when features are correlated. If humid days are also cold days, the model can't cleanly separate their effects, and the individual coefficients may swing wildly with small data changes even though predictions stay reasonable. Coefficients also depend on units: humidity in percent and temperature in degrees aren't directly comparable, so standardise features (see summary statistics for ML) before comparing coefficient sizes.

Fitting chooses coefficients that minimise the sum of squared residuals, where a residual is the difference between an observed value and the model's prediction:

residual = actual − predicted

predicted = model.predict(X)
residuals = [actual - p for actual, p in zip(y, predicted)]

Residuals are the most useful diagnostic you have. Plot them against predictions or against each feature: they should look like random scatter around zero. Patterns reveal problems, for example residuals that grow with thickness (the model under-predicts thick layers), a curve (the relationship isn't linear) or a few huge residuals (unusual records worth investigating).

Squaring makes large errors count heavily, so one extreme record can pull the whole line. A small training error doesn't prove anything about new data: with enough features, a model can fit its training rows almost perfectly and still predict poorly. That's why evaluation uses data the model never saw.

Evaluate on a held-out test set and report errors in meaningful units:

• MAE (mean absolute error): average size of errors, in hours. Easy to explain.
• RMSE (root mean squared error): also in hours, but penalises large errors more.
• R²: the share of variation in the target explained by the model; 1 is perfect, 0 is no better than predicting the mean, and it can be negative on test data.

from sklearn.metrics import mean_absolute_error, r2_score
mae = mean_absolute_error(y_test, model.predict(X_test))

Always compare with a baseline, such as predicting the training mean. Two further limits matter. Extrapolation: a model fitted on layers of 1 to 4 mm has no evidence about 15 mm layers, so don't trust predictions far outside the training range. Causation: a coefficient describes an association in the data, not proof that changing the feature would change the outcome; a hidden factor might drive both.

Task: build single- and multiple-feature drying models with a held-out set and interpretable error units.

from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error

X_full = [[1, 20], [2, 18], [3, 22], [2, 25], [4, 19], [1, 23], [3, 17], [2, 21]]
y = [2.8, 6.1, 6.9, 4.2, 10.3, 2.6, 9.1, 4.9]
X_one = [[row[0]] for row in X_full]            # thickness only

for label, X in [("thickness only", X_one), ("thickness + temperature", X_full)]:
    model = LinearRegression().fit(X[:6], y[:6])
    mae = mean_absolute_error(y[6:], model.predict(X[6:]))
    print(f"{label:<24} test MAE {mae:.2f} hours")

Compare the two errors in hours: if adding temperature reduces the test MAE, the extra feature helps on unseen data, not just on the training rows. For the worked check, ordinary linear regression predicts a numeric value.

scikit-learn's linear models guide and regression metrics go further. Continue with logistic regression and training and testing datasets. Practise with the Python exercises and Python quiz.