Mean Absolute Error — ML Coding

Solving tips

MAE is the mean of the absolute errors — build it inside-out: differences, absolute value, mean.
Vectorize with NumPy: y_pred - y_true is an elementwise array, then np.abs and np.mean, no Python loop needed.
Guard the empty-input case so you don't divide by zero.

Implement mean absolute error (MAE) from scratch with NumPy, without using a library metric function. MAE is a standard regression metric, and interviewers ask for it to check that you can turn a formula into clean vectorized code.

Definition

For n paired values, MAE is the average absolute difference between prediction and truth:

MAE = (1/n) * sum_i |y_pred[i] - y_true[i]|

Task

Complete mae(y_true, y_pred) so it returns the MAE as a float. Both inputs are 1-D NumPy arrays of the same length. Do not call sklearn or any built-in MAE 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])
mae(y_true, y_pred)   # -> 0.75

The absolute errors are [0.5, 0.0, 1.5, 1.0], and their mean is 3.0 / 4 = 0.75.

Constraints

1 <= n <= 10^6; use vectorized NumPy, not a Python loop.
Values fit in float64.

Approach

Build the formula inside-out on vectorized arrays: the elementwise error, take its absolute value, then the mean. NumPy runs the loop in C, so the whole thing is two array operations plus a reduction.

Solution

import numpy as np

def mae(y_true, y_pred):
    if len(y_true) == 0:
        return 0.0
    errors = y_pred - y_true          # elementwise differences, shape (n,)
    return float(np.mean(np.abs(errors)))

Walkthrough

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

errors = y_pred - y_true = [-0.5, 0.0, 1.5, 1.0]
np.abs(errors) = [0.5, 0.0, 1.5, 1.0]
np.mean(...) = 3.0 / 4 = 0.75

Complexity & notes

Time O(n), space O(n) — one pass to subtract and take absolute value, plus a reduction for the mean.
MAE reports error in the same units as the target and weights every error linearly, so unlike RMSE it does not amplify large errors — it is more robust to outliers.
The empty-array guard avoids a divide-by-zero (np.mean of an empty array is nan and raises a warning).
The sign of y_pred - y_true versus y_true - y_pred does not matter here because of the absolute value.