Accuracy Score — ML Coding — InterviewPrepKit

Solving tips

Accuracy is just the fraction of positions where prediction equals truth — compare elementwise, then average.
y_true == y_pred gives a boolean array; np.mean of booleans treats True as 1 and False as 0, which is exactly the fraction correct.
Guard the empty-input case so you don't divide by zero.

Implement classification accuracy from scratch with NumPy, without using a library metric function. Accuracy is the most basic classification metric, and interviewers ask for it to check that you can turn a plain definition into clean vectorized code.

Definition

For n paired labels, accuracy is the fraction of positions where the prediction matches the truth:

accuracy = (1/n) * sum_i 1[y_pred[i] == y_true[i]]

where 1[...] is 1 when the condition holds and 0 otherwise.

Task

Complete accuracy_score(y_true, y_pred) so it returns the accuracy as a float in [0, 1]. Both inputs are 1-D NumPy arrays of integer labels of the same length. Do not call sklearn or any built-in accuracy helper.

Example

y_true = np.array([0, 1, 2, 1, 0])
y_pred = np.array([0, 2, 2, 1, 0])
accuracy_score(y_true, y_pred)   # -> 0.8

Four of the five positions match (only index 1 differs), so the accuracy is 4 / 5 = 0.8.

Constraints

1 <= n <= 10^6; use vectorized NumPy, not a Python loop.
Labels are non-negative integers; both arrays have the same length.

Approach

Compare the two label arrays elementwise to get a boolean mask of correct predictions, then take its mean. NumPy treats True as 1 and False as 0, so the mean of the mask is exactly the fraction of correct predictions. The whole metric is one comparison plus one reduction.

Solution

import numpy as np

def accuracy_score(y_true, y_pred):
    if len(y_true) == 0:
        return 0.0
    correct = (y_true == y_pred)      # boolean array, True where they match
    return float(np.mean(correct))

Walkthrough

On the example y_true = [0, 1, 2, 1, 0], y_pred = [0, 2, 2, 1, 0]:

y_true == y_pred = [True, False, True, True, True]
as numbers that is [1, 0, 1, 1, 1], summing to 4
np.mean(...) = 4 / 5 = 0.8

Complexity & notes

Time O(n), space O(n) — one elementwise comparison to build the mask, plus a reduction for the mean.
np.mean on a boolean array upcasts True/False to 1/0, so there is no need to call .astype(int) or .sum() / len(...) yourself, though both give the same result.
The empty-array guard avoids a divide-by-zero (np.mean of an empty array is nan and raises a warning).
Accuracy is misleading on imbalanced data: predicting the majority class for every row can score high while the model learns nothing, which is why precision, recall, and F1 are reported alongside it.