Linear Regression

How much delivery time increases for each additional kilometre of distance. A slope of 7.3 means: add 1 km, add 7.3 minutes to the prediction.

The baseline delivery time when distance is zero — roughly the time to accept the order, prepare it, and hand it to a rider before they move. Around 8–9 minutes.

For simple linear regression (one feature), a closed-form solution exists. You can calculate the exact best slope and intercept directly from your data using these formulas:

In plain English: the slope is the covariance of x and y divided by the variance of x. The intercept is the mean of y minus the slope times the mean of x.

This is why sklearn fits a linear regression model on a million rows in under a second — it is not iterating; it is computing a formula directly. No looping, no guessing. One calculation.

Used when you have many features (OLS becomes expensive) and the same mechanism that trains every neural network in existence. You start with a guess and improve it step by step:

The learning rate is a hyperparameter you set. Too large: the steps overshoot and the loss bounces or diverges. Too small: training takes forever. Typical values: 0.01, 0.001, 0.0001.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

np.random.seed(42)          # same random numbers every run — reproducibility

n_orders = 1000
distance_km = np.random.uniform(0.5, 8.0, n_orders)    # orders range 0.5–8 km
noise = np.random.normal(0, 4, n_orders)                # ±4 min real-world variability
delivery_time_min = 8.6 + 7.3 * distance_km + noise    # true relationship + noise

df = pd.DataFrame({
    'distance_km': distance_km,
    'delivery_time_min': delivery_time_min
})

print(df.describe())        # always run describe() first — know your data before touching it

plt.figure(figsize=(8, 5))
plt.scatter(df['distance_km'], df['delivery_time_min'],
            alpha=0.3, s=15, color='#378ADD')
plt.xlabel('Distance (km)')
plt.ylabel('Delivery Time (min)')
plt.title('Swiggy Orders — Distance vs Delivery Time')
plt.tight_layout()
plt.show()

# What to look for:
#   Clear upward trend  → Linear Regression is appropriate
#   No trend / random   → LR will learn nothing useful
#   Curve (parabola)    → Wrong tool — try polynomial features or tree model
#   Tight cluster       → Great signal, model will be accurate

X = df[['distance_km']]      # double brackets → 2D array (n_samples, n_features)
y = df['delivery_time_min']  # single brackets → 1D array (n_samples,)

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,       # 20% for testing = 200 orders
    random_state=42      # same split every run
)

print(f"Training set: {len(X_train)} orders")   # 800
print(f"Test set:     {len(X_test)} orders")    # 200

# The test set is the answer sheet.
# Treat it like one: don't look at it, don't tune on it, don't touch it
# until you are done building and ready for a final honest evaluation.

model = LinearRegression()      # create the model object — no learning has happened yet

model.fit(X_train, y_train)    # THIS is where learning happens:
                                # - computes optimal slope and intercept via OLS
                                # - for 800 rows, this takes milliseconds
                                # - result: model.coef_ and model.intercept_ are set

print(f"Slope (coef):     {model.coef_[0]:.2f}")    # expect ~7.3 (min per km)
print(f"Intercept:        {model.intercept_:.2f}")  # expect ~8.6 (baseline minutes)

# These numbers ARE the model.
# coef_ = [7.28]    ← distance adds 7.28 min per km
# intercept_ = 8.71 ← base time before rider moves

y_pred = model.predict(X_test)

# Compare predicted vs actual for the first 8 test orders
comparison = pd.DataFrame({
    'distance_km': X_test['distance_km'].values[:8],
    'actual_min':  y_test.values[:8].round(1),
    'predicted_min': y_pred[:8].round(1),
    'error_min':   (y_pred[:8] - y_test.values[:8]).round(1)
})
print(comparison.to_string(index=False))

# Expected output (approximate):
#  distance_km  actual_min  predicted_min  error_min
#          2.3        22.8           25.4        2.6
#          6.1        52.1           53.1        1.0
#          1.0        13.2           15.9        2.7
#          4.7        39.4           42.9        3.5
#          3.5        32.3           34.2        1.9
#          0.7        15.1           13.7       -1.4
#          5.8        48.8           51.0        2.2
#          2.9        28.5           29.8        1.3

mae = mean_absolute_error(y_test, y_pred)
print(f"MAE:  {mae:.2f} min")      # ~3.1 min on average — a PM can understand this

mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(f"RMSE: {rmse:.2f} min")     # penalises large errors more heavily than MAE

r2 = r2_score(y_test, y_pred)
print(f"R²:   {r2:.3f}")           # ~0.78 — distance explains 78% of delivery time variation

# --- Compare to baseline ---
baseline_pred = np.full(len(y_test), y_train.mean())   # always predict training mean
baseline_mae  = mean_absolute_error(y_test, baseline_pred)
print(f"\nBaseline MAE (always predict mean): {baseline_mae:.2f} min")
print(f"Model MAE:                           {mae:.2f} min")
print(f"Improvement over baseline:           {((baseline_mae - mae) / baseline_mae * 100):.1f}%")

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# Left: scatter + fitted line
ax1.scatter(X_train['distance_km'], y_train, alpha=0.2, s=12, color='#378ADD', label='Training data')
x_line = np.linspace(0.5, 8.0, 100).reshape(-1, 1)
ax1.plot(x_line, model.predict(x_line), color='#ff6b6b', linewidth=2, label='Fitted line')
ax1.set_xlabel('Distance (km)')
ax1.set_ylabel('Delivery Time (min)')
ax1.set_title('Fitted Line')
ax1.legend()

# Right: residual plot — actual minus predicted vs predicted
residuals = y_test - y_pred
ax2.scatter(y_pred, residuals, alpha=0.3, s=12, color='#7F77DD')
ax2.axhline(0, color='#ff6b6b', linewidth=1.5, linestyle='--')
ax2.set_xlabel('Predicted Time (min)')
ax2.set_ylabel('Residual (actual − predicted)')
ax2.set_title('Residuals')

# Interpreting the residual plot:
#   GOOD → random cloud centred on 0, no pattern
#   BAD  → fan shape (wider spread at higher predictions) → heteroscedasticity
#   BAD  → curve → the relationship is not actually linear

plt.tight_layout()
plt.show()

# Single prediction
new_order = pd.DataFrame({'distance_km': [3.2]})
predicted_time = model.predict(new_order)[0]
print(f"Predicted delivery time: {predicted_time:.0f} minutes")

# In production you would:
#   1. Serialise the model to disk with joblib
#   2. Load it in a FastAPI service
#   3. Monitor for drift (performance degrading over time)

import joblib

joblib.dump(model, 'swiggy_eta_model.pkl')         # save model
loaded_model = joblib.load('swiggy_eta_model.pkl') # load it later

# FastAPI endpoint (production pattern):
# @app.post("/predict-eta")
# def predict_eta(distance_km: float):
#     X = pd.DataFrame({'distance_km': [distance_km]})
#     return {"eta_minutes": int(loaded_model.predict(X)[0])}

One input feature. The model is a 2D line. Two parameters: one slope, one intercept. Good for understanding the algorithm. Rarely sufficient for production.

Multiple input features. The model is a hyperplane in n-dimensional space. One coefficient per feature, one intercept. This is what you use in practice.

What it means: The relationship between your features and your target is approximately a straight line. If the true relationship is a curve, forcing a straight line through it produces systematic errors.

How to check: Plot each feature vs the target. If you see a clear curve, run a residual plot — if residuals curve instead of scatter randomly, linearity is violated.

What it means: Because errors are squared, a single extreme point can drag the line significantly toward itself. LR is not robust to outliers.

How to check: Box plots of each feature. Check for values more than 3 standard deviations from the mean. Plot residuals — outliers appear as isolated points far from zero.

What it means: Your features should not be highly correlated with each other. If distance_km and distance_miles are both in your model, the algorithm cannot separate their individual contributions.

How to check: Compute a correlation matrix: df.corr(). Features correlated above 0.85 with each other are a problem. Use VIF (Variance Inflation Factor) for a precise check.

What it means: Errors for one prediction should not predict errors for another. If your model is always wrong at 7pm, those errors are correlated with time — and your model has missed a systematic pattern.

How to check: Plot residuals against time or any variable not in your model. A pattern means you are missing a feature. Random scatter means errors are independent.

You have missing values (NaN) or infinite values in your feature matrix. sklearn's LinearRegression does not handle missing values — it expects clean numerical input.

Run df.isnull().sum() to find which columns have missing values. Then handle them: df.fillna(df.median()) for numerical columns, df.dropna() if the fraction is tiny, or use sklearn's SimpleImputer in a Pipeline for production code.

You included a categorical (text) column in your feature matrix X. LinearRegression can only work with numbers. 'restaurant_name' is still a string.

Encode categorical features before training. For low-cardinality categoricals: pd.get_dummies(df, columns=['restaurant_name']). For high-cardinality: use OrdinalEncoder or TargetEncoder from sklearn.preprocessing.

The model was trained on 3 features but you are passing 1 feature at inference time. Feature names or counts do not match between training and prediction.

Use an sklearn Pipeline that includes your preprocessing steps. This guarantees the same transformations run at training and inference time. Alternatively: always build X for inference the same way you built X_train — same column order, same column names.

Negative R² means your model is worse than just predicting the mean for every order. Four possible causes: (1) you evaluated on training data accidentally, (2) features and target are not aligned — index mismatch after filtering, (3) severe outliers pulling the line to a useless position, (4) the relationship is genuinely non-linear.

Check each cause in order: verify you are calling score(X_test, y_test) not score(X_train, y_train). Reset dataframe indexes after filtering with .reset_index(drop=True). Check for and remove extreme outliers. Plot the data — if it curves, try polynomial features or switch to a tree-based model.

Classic overfitting. Your model has memorised the training data instead of learning generalizable patterns. Linear Regression rarely overfits severely, but it can happen with many engineered features that are specific to the training period.

Add regularisation: switch to Ridge (L2) or Lasso (L1) regression. Ridge penalises large coefficients; Lasso can zero them out entirely. Both are in sklearn.linear_model. Start with Ridge(alpha=1.0) and tune alpha with cross-validation.

The relationship between distance and delivery time is not linear. Short-distance orders have a fixed cost (restaurant prep, handover) that dominates. Long-distance orders may benefit from faster roads. A straight line cannot capture this.

Add polynomial features: from sklearn.preprocessing import PolynomialFeatures, then pipe it before LinearRegression. Or switch to a tree-based model (Decision Tree, XGBoost) that naturally captures non-linear patterns without feature engineering.