F1 Score

Hook problem: one score for two questions

In the same 12-email fixture used by precision and recall:

• TP = 3
• FP = 2
• FN = 3
• TN = 4

We already trust:

• precision = TP / (TP + FP) = 3 / 5 = 0.6
• recall = TP / (TP + FN) = 3 / 6 = 0.5

But a reviewer asks for a single balance value that matches the overall behavior.

First naive idea: take arithmetic mean

A natural first attempt is:

This reads nicely as a single number, and it seems fair.

Where naïve averaging can mislead

Arithmetic mean can look high even when one side is weak.

Compare:

• P = 1.0, R = 0.1
• P = 0.1, R = 1.0

Both have the same mean 0.55, but both should not be treated equally if one side is almost useless.

Core idea: harmonic balance

F1 is the harmonic mean of precision and recall:

For this fixture:

This is lower than 0.55 because the weak recall pulls the score down.

Formal and count form

From counts you can avoid recomputing intermediate metrics:

For this fixture:

Both formulas are equivalent whenever precision and recall are defined.

Interactive preset lab

This demo lets you switch preset count cases and watch precision, recall, arithmetic mean, and F1 update in one view.

Static no-JS fallback:

Arithmetic mean visibility in the demo

The preset panel shows:

• precision = TP / (TP + FP)
• recall = TP / (TP + FN)
• arithmetic mean = (P + R) / 2
• F1 = 2TP / (2TP + FP + FN)

Edge cases and branch behavior

The denominator-zero branch prevents 0/0 from rendering as NaN; the TP = 0 branch with FP or FN present deliberately renders a defined zero.

Correctness intuition

F1 is only affected by precision and recall; therefore only three counts appear:

• FP hurts precision (TP + FP)
• FN hurts recall (TP + FN)
• TN is not in either metric numerator or denominator

Complexity

Once counts are known, this is constant-time:

• precision, recall, and F1: O(1)

If you only have examples, scanning to build TP, FP, and FN is O(n) with O(1) extra space, then O(1) for score.

Implementation sketch

interface Counts {
  tp: number;
  fp: number;
  fn: number;
}

type F1Result = {
  precision: number | null;
  recall: number | null;
  numerator: number;
  denominator: number;
  value: number | null;
};

function f1FromPrecisionRecall(precision: number | null, recall: number | null): F1Result {
  if (precision === null || recall === null) {
    return { precision, recall, numerator: 0, denominator: 0, value: null };
  }
  const numerator = 2 * precision * recall;
  const denominator = precision + recall;
  return {
    precision,
    recall,
    numerator,
    denominator,
    value: denominator === 0 ? 0 : numerator / denominator
  };
}

function f1FromCounts(counts: Counts): F1Result {
  const precision = precisionFromCounts({ tp: counts.tp, fp: counts.fp }).value;
  const recall = recallFromCounts({ tp: counts.tp, fn: counts.fn }).value;
  const numerator = 2 * counts.tp;
  const denominator = 2 * counts.tp + counts.fp + counts.fn;

  if (denominator === 0) {
    return { precision, recall, numerator, denominator, value: null };
  }
  if (counts.tp === 0) {
    return { precision, recall, numerator, denominator, value: 0 };
  }
  return { precision, recall, numerator, denominator, value: numerator / denominator };
}

function formatMetric(value: number | null, locale: "en" | "zh") {
  return value === null ? (locale === "en" ? "not available" : "不可用") : Number(value.toFixed(3)).toString();
}

Common confusions

• F1 is not accuracy. Accuracy uses all four cells.
• F1 is not precision or recall alone. It needs both.
• F1 does not use TN directly. TN does not appear in precision/recall.
• 0 is different from unavailable. If no true positive but there are FP/FN, F1 can be exactly 0.

Graph connection

In the graph, f1-score is a dependent node from:

• precision -> f1-score
• recall -> f1-score

Exercises

1. Compute F1 from fixture counts both as 2PR/(P+R) and 2TP/(2TP + FP + FN).
2. Why do P = 1.0, R = 0.1 and P = 0.1, R = 1.0 have the same arithmetic mean but lower balance score?
3. In no-positive-evidence case (TP=FP=FN=0), what should render and why?
4. Compare FP versus FN:
   • adding one FP: TP=3, FP=3, FN=3
   • adding one FN: TP=3, FP=2, FN=4
   • what is the new F1 in each case?

Graph connections : F1 Score