Recall

Recall is the share of actual positive cases that a model correctly identifies. It answers the question "of everything that should have been found, how much did the model find?" and is calculated as true positives divided by all actual positives: recall = TP / (TP + FN), where a false negative (FN) is a positive case the model missed. Recall runs from 0 to 1, so a recall of 0.90 means the model misses 1 in 10 positives. Sensitivity, true positive rate (TPR), and hit rate are synonyms, and the miss rate, or false negative rate, equals 1 minus recall. Recall matters most when a miss is costly, such as an undetected tumor on a screening scan or an intruder an alarm system fails to flag.

How Recall Is Calculated#

Recall reads two cells of the confusion matrix: the true positives and the false negatives, which together make up every actual positive. False positives and true negatives never enter the formula, so a model that labels everything as positive reaches a perfect recall of 1.0 while being useless. Recall is therefore reported alongside precision, TP / (TP + FP), which penalizes exactly those false alarms. For example, a screening model that flags 90 of 100 tumors in a test set has a recall of 0.90 no matter how many healthy scans it also flags, and its precision shows how many of its flags were real.

With more than two classes, recall is computed per class, treating that class as positive and everything else as negative, and then averaged. Macro recall weights every class equally, which exposes poor performance on rare classes, and in single-label multi-class tasks micro-averaged recall equals accuracy.

The Precision-Recall Trade-Off#

Most models output a score, and a decision threshold turns it into a yes or no. Lowering the threshold flags more cases, which raises recall and usually lowers precision. The scikit-learn script below scores 15 parts, 5 of them defective, at three thresholds:

import numpy as np
from sklearn.metrics import precision_score, recall_score

# 5 defective parts (1) and 10 good parts (0), with the model's defect score for each
y_true = np.array([1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
scores = np.array([0.95, 0.80, 0.55, 0.40, 0.20, 0.60, 0.35, 0.30, 0.15, 0.10, 0.10, 0.05, 0.05, 0.05, 0.02])

# Lowering the decision threshold flags more parts as defective
for threshold in (0.7, 0.5, 0.3):
    y_pred = scores >= threshold
    recall = recall_score(y_true, y_pred)
    precision = precision_score(y_true, y_pred)
    print(f"threshold {threshold}: recall {recall:.2f}, precision {precision:.2f}")

At a threshold of 0.7 the model finds 2 of the 5 defects with no false alarms, a recall of 0.40 and a precision of 1.00. Lowering the threshold to 0.3 finds 4 defects, a recall of 0.80, but 3 of its 7 flags are good parts, so precision drops to 0.57. Plotting every threshold traces a precision-recall curve, and the F1-score or a recall-weighted F2 score picks a single operating point on it. In YOLO26, the prediction conf threshold sets this trade-off, 0.25 by default: lowering it, for example to conf=0.1, recovers fainter, smaller, and partly hidden objects at the cost of more false detections.

Recall in Object Detection#

In object detection, the positives are the labeled objects in each image. A labeled object counts as found only when a prediction of the same class overlaps it with an intersection over union (IoU) at or above a threshold, often 0.5. Each prediction can claim only one object, so a single box covering two people in a crowd finds one of them, and the other becomes a false negative.

Detector recall therefore depends on the confidence threshold, the IoU threshold, and post-processing. A stricter IoU threshold such as 0.75 lowers recall for loosely placed boxes, non-maximum suppression (NMS) can delete correct boxes on heavily overlapping objects, and a cap on detections per image limits recall in dense scenes. Mean average precision (mAP) integrates precision across all recall levels, so every object the model never finds lowers it. The COCO evaluation also reports average recall (AR), the maximum recall reached with a fixed number of detections per image, averaged over IoU thresholds from 0.50 to 0.95, as AR@1, AR@10, and AR@100.

Improving Recall#

• Lower the confidence threshold: The fastest fix, paid for with lower precision.
• Collect and label the misses: Add training examples of the conditions where the model fails, such as small, occluded, or night-time objects. Reviewing false negatives on validation data shows which ones.
• Raise the input resolution: Small objects that shrink to a few pixels at low resolution become detectable at higher resolution.
• Counter class imbalance: Loss functions such as focal loss and resampling of rare classes keep the model from ignoring the minority class.

Recall vs. Related Terms#

• Precision: The share of positive predictions that are correct. Recall asks how much of the target the model found, and precision asks how much of what it found was right.
• Specificity: The true negative rate, TN / (TN + FP), the share of negatives correctly rejected. Medical tests report the pair as sensitivity and specificity.
• Receiver operating characteristic (ROC) curve: Plots recall, as the true positive rate, against the false positive rate across thresholds. The area under the curve (AUC) summarizes it in one number.
• Accuracy: The share of all predictions that are correct. With 1% positives, a model that predicts negative every time scores 99% accuracy and 0% recall.