R-Squared Score

Implement the coefficient of determination (R^2) from scratch with NumPy, without using a library metric function. R^2 tells you how much of the variance in the target a model explains relative to a naive baseline that always predicts the mean, and interviewers use it to check that you understand both the formula and its edge cases.

Definition

For n paired values, R^2 is one minus the ratio of the residual sum of squares to the total sum of squares:

SS_res = sum_i (y_true[i] - y_pred[i])^2
SS_tot = sum_i (y_true[i] - mean(y_true))^2
R2     = 1 - SS_res / SS_tot

SS_res is the model’s squared error, and SS_tot is the squared error of always predicting mean(y_true).

Task

Complete r2_score(y_true, y_pred) so it returns the R^2 score as a float. Both inputs are 1-D NumPy arrays of the same length. Handle the case where SS_tot == 0 (the target is constant): return 1.0 when the predictions are also perfect (SS_res == 0), otherwise return 0.0. Do not call sklearn or any built-in R^2 helper.

Example

y_true = np.array([3.0, 5.0, 2.5, 7.0])
y_pred = np.array([2.5, 5.0, 4.0, 8.0])
r2_score(y_true, y_pred)   # -> 0.8135593220338984

The residuals are [0.5, 0.0, -1.5, -1.0], so SS_res = 0.25 + 0.0 + 2.25 + 1.0 = 3.5. The mean of y_true is 4.375, so SS_tot = 1.890625 + 0.390625 + 3.515625 + 6.890625 = 12.6875, and 1 - 3.5 / 12.6875 ≈ 0.8136.

Constraints

• 1 <= n <= 10^6; use vectorized NumPy, not a Python loop.
• Values fit in float64.
• R^2 can be negative when the model is worse than predicting the mean; do not clamp it.

Approach

Compute the two sums of squares directly: SS_res from the residuals y_true - y_pred, and SS_tot from the deviations of y_true around its own mean. R^2 is 1 - SS_res / SS_tot. Before dividing, guard the constant-target case where SS_tot == 0, returning 1.0 only if the predictions are also exact and 0.0 otherwise.

Solution

import numpy as np

def r2_score(y_true, y_pred):
    ss_res = float(np.sum((y_true - y_pred) ** 2))
    ss_tot = float(np.sum((y_true - np.mean(y_true)) ** 2))
    if ss_tot == 0.0:
        return 1.0 if ss_res == 0.0 else 0.0
    return 1.0 - ss_res / ss_tot

Walkthrough

On the example y_true = [3, 5, 2.5, 7], y_pred = [2.5, 5, 4, 8]:

• residuals y_true - y_pred = [0.5, 0.0, -1.5, -1.0], squared = [0.25, 0.0, 2.25, 1.0], so ss_res = 3.5
• mean(y_true) = 4.375, deviations = [-1.375, 0.625, -1.875, 2.625], squared = [1.890625, 0.390625, 3.515625, 6.890625], so ss_tot = 12.6875
• ss_tot != 0, so return 1 - 3.5 / 12.6875 ≈ 0.8136

If instead every y_true were the same value, ss_tot would be 0; the code returns 1.0 when the predictions match exactly and 0.0 otherwise, avoiding the divide-by-zero.

Complexity & notes

• Time O(n), space O(n) — two elementwise passes plus reductions for the sums and the mean.
• SS_res uses the predictions; SS_tot uses mean(y_true). Swapping the two is the classic mistake.
• R^2 is unbounded below: a model worse than the mean baseline gives a negative score, and a perfect model gives 1.0. Do not clamp it.
• The SS_tot == 0 convention here (perfect -> 1.0, else 0.0) matches scikit-learn’s behavior for a constant target; some references leave it undefined, so state your choice in an interview.