What is the difference between macro, micro and weighted F1?

Macro-F1 is the plain average of each class's F1, so every class counts equally regardless of size. Weighted-F1 averages the same per-class F1 scores but weights each by its support (number of true samples). Micro-F1 pools every class's TP, FP and FN first, then computes one F1 — so large classes dominate. Macro is the strictest on minority classes.

How do you calculate macro F1 for multiclass classification?

Compute F1 for each class from its own TP, FP and FN — F1 = 2·precision·recall / (precision + recall) — then take the unweighted mean over the K classes: Macro-F1 = (F1₁ + F1₂ + … + F1ₖ) / K. Class size is ignored, so a rare class with a low F1 pulls the macro average down as hard as any other class.

Why does micro F1 equal accuracy in multiclass classification?

In single-label classification each misclassification is simultaneously one false positive for the predicted class and one false negative for the true class, so the pooled totals satisfy ΣFP = ΣFN. That makes micro-precision = micro-recall = micro-F1 = ΣTP / N, which is exactly accuracy. This is why scikit-learn's classification_report prints one 'accuracy' row instead of a separate micro line.

Which F1 average should I use for imbalanced classes?

Use macro-F1 when every class matters equally — it exposes a minority class that a majority class would otherwise hide. Micro-F1 (= accuracy) reflects overall correctness but is dominated by the largest class. Weighted-F1 sits between them. For imbalanced problems where the rare class is the point (fraud, disease), report macro-F1 and the per-class F1.

How is weighted F1 different from macro F1?

Both average the per-class F1 scores, but weighted-F1 multiplies each class's F1 by its support before averaging and divides by the total sample count, while macro-F1 gives every class the same weight. When classes are balanced the two are almost identical; when one class is much larger, weighted-F1 rises toward it while macro-F1 stays sensitive to the small classes.

Does this calculator match scikit-learn's classification_report?

Yes. The per-class precision, recall, F1 and support and the macro/weighted averages use the same definitions as sklearn.metrics.precision_recall_fscore_support, and a 0/0 metric is reported as 0 exactly as classification_report does. The two worked examples on this page were reproduced against classification_report to four decimal places.

What happens when a class has no predictions or no true samples?

If a class is never predicted, its precision denominator (TP + FP) is 0, so precision — and therefore F1 — is reported as 0. If a class has no true samples its recall denominator is 0 and recall is 0. The tool never returns NaN; it follows scikit-learn's convention of treating an undefined 0/0 metric as 0.

Does this handle multi-label F1 (one sample, many labels)?

No. This tool is for single-label multiclass classification, where each sample belongs to exactly one class and the input is a square confusion matrix. Multi-label problems pool TP/FP/FN differently and need per-label indicator vectors, which is out of scope for this version.

Machine Learning · Metrics

Macro, Micro & Weighted F1 Score Calculator (Multiclass)

Paste a multiclass confusion matrix and get per-class precision, recall and F1 plus the three averages everyone mixes up — macro, micro and weighted — with accuracy and every step of the arithmetic shown. Matches scikit-learn.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jul 12, 2026

Multiclass F1 calculatormacro · micro · weighted

scikit-learn verified

Number of classes (K)

Load an example

Confusion matrix

True class down the rows, predicted class across the columns

Rows = true class · Columns = predicted class. Edit the labels or the counts; totals update live.

Macro-F1

0.6892

Unweighted mean across classes

Weighted-F1

0.6865

Mean weighted by class support

Micro-F1

0.6818

= accuracy for single-label problems ✓

Accuracy

0.6818

15 of 22 correct · 68.18%

Averaging modes

Average	Precision	Recall	F1
Macro avg each class counts once	0.7263	0.6786	0.6892
Weighted avg weighted by support	0.7180	0.6818	0.6865
Micro avg pooled TP/FP/FN	0.6818	0.6818	0.6818
Accuracy	0.6818

Micro working (pooled counts)

ΣTP = 15 · ΣFP = 7 · ΣFN = 7

Micro-F1 = 2·ΣTP / (2·ΣTP + ΣFP + ΣFN) = 30 / 44 = 0.6818

ΣFP = ΣFN here (every error is one FP and one FN), so Micro-F1 equals accuracy — which is why classification_reportprints one “accuracy” row instead of a micro row.

Per-class breakdown

Class	TP	FP	FN	Precision	Recall	F1	Support
A	5	1	2	0.8333	0.7143	0.7692	7
B	6	5	2	0.5455	0.7500	0.6316	8
C	4	1	3	0.8000	0.5714	0.6667	7

Single-label multiclass only. Precision, recall and F1 use the scikit-learn definitions; a 0/0 metric is reported as 0, matching classification_report.

How it works

A multiclass model is scored from its confusion matrix — a K×K grid where C[i][j] is the number of samples whose true class is i and whose predicted class is j. The diagonal holds correct predictions. From that single grid every metric below is derived, using the definitions in scikit-learn's precision_recall_fscore_support.

For each class c the tool reads four counts straight off the matrix:

TP = C[c][c] (correct for c)
FP = column c total − TP (predicted c, truly other)
FN = row c total − TP (truly c, predicted other)
support = row c total = TP + FN (true instances of c)

Precision is TP / (TP + FP), recall is TP / (TP + FN), and the per-class F1 is their harmonic mean, 2·P·R / (P + R). When a denominator is zero — a class never predicted, or with no true samples — the metric is defined as 0, matching classification_report, so you never see a NaN.

The three averaging modes differ only in how they combine those per-class numbers, and that is exactly what trips people up:

Macro — the plain mean of the per-class F1 over the K classes: Macro-F1 = (ΣF1_c) / K. Every class counts once, so a poorly-handled minority class hurts as much as the majority class.
Weighted— the mean weighted by each class's support: Weighted-F1 = (Σ support_c · F1_c) / N. Larger classes pull the average toward their own score.
Micro — pool first, then divide: Micro-F1 = 2·ΣTP / (2·ΣTP + ΣFP + ΣFN). Because a single-label error is one FP and one FN at the same time, ΣFP = ΣFN, so micro-precision, micro-recall and micro-F1 all collapse to ΣTP / N — plain accuracy. That is why scikit-learn prints an “accuracy” row rather than a micro row.

The calculator surfaces the pooled ΣTP, ΣFP and ΣFN it uses for micro and the support weights it uses for weighted, so the arithmetic is auditable — and it flags when macro-F1 falls well below micro-F1, the tell-tale sign that class imbalance is hiding a weak minority class.

Worked examples

Balanced 3-class (A, B, C)

N = 22 · 15 correct

Matrix rows (true→pred): A [5,2,0], B [1,6,1], C [0,3,4]
A: TP 5, FP 1, FN 2 → P 0.8333, R 0.7143, F1 0.7692
B: TP 6, FP 5, FN 2 → P 0.5455, R 0.7500, F1 0.6316
C: TP 4, FP 1, FN 3 → P 0.8000, R 0.5714, F1 0.6667
Macro-F1 = (0.7692+0.6316+0.6667)/3 = 0.6892
Weighted = (7·0.7692+8·0.6316+7·0.6667)/22 = 0.6865
Micro-F1 = 15/22 = 0.6818 = accuracy ✓

Imbalanced 3-class (X rare, Y majority, Z)

N = 62 · 59 correct

Matrix rows (true→pred): X [1,1,0], Y [0,50,0], Z [0,2,8]
X: TP 1, FP 0, FN 1 → P 1.0000, R 0.5000, F1 0.6667
Y: TP 50, FP 3, FN 0 → P 0.9434, R 1.0000, F1 0.9709
Z: TP 8, FP 0, FN 2 → P 1.0000, R 0.8000, F1 0.8889
Macro-F1 = (0.6667+0.9709+0.8889)/3 = 0.8421
Weighted = (2·0.6667+50·0.9709+10·0.8889)/62 = 0.9479
Micro-F1 = 59/62 = 0.9516 = accuracy ✓
Macro (0.8421) ≪ micro (0.9516): rare class X drags macro down but barely dents the pooled figure.

Edge case — a class never predicted

Binary [[0,5],[0,5]] · zero-denominator

Class 1: TP 0, FP 0, FN 5 → precision denominator is 0 → P 0, so F1 0 (not NaN)
Class 2: TP 5, FP 5, FN 0 → P 0.5000, R 1.0000, F1 0.6667
Macro-F1 = (0 + 0.6667)/2 = 0.3333
Micro-F1 = 5/10 = 0.5000 = accuracy ✓
The tool reports the 0/0 class as 0 and keeps every average finite.

Frequently asked questions

Sources & references

The definitions and both worked examples were last cross-checked against scikit-learn's classification_report on 2026-07-12.

Related tools

LiveAI

F1 Score Calculator

Calculate the F1 score, precision, recall and F-beta of a binary classifier from confusion-matrix counts (TP, FP, FN) or directly from precision and recall, with every step of the arithmetic shown. Matches scikit-learn, runs in your browser.

Open tool

LiveAI

F-beta Score Calculator

Compute the F-beta score of a binary classifier from precision & recall or from raw confusion-matrix counts (TP/FP/FN). Presets for F1, F2, and F0.5 plus any custom beta, with all three shown side by side — using the exact scikit-learn formula and cross-checked against the confusion-matrix form.

Open tool

LiveAI

Confusion Matrix Calc

Enter the four counts of a binary classifier's confusion matrix (TP, FP, FN, TN) and instantly get every standard metric — accuracy, precision, recall, specificity, F1, balanced accuracy, MCC and Cohen's kappa — each with the exact formula and your numbers substituted in. Matches scikit-learn, runs in your browser, no signup.

Open tool

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.