What is balanced accuracy and how is it calculated?

Balanced accuracy is the average of the recall obtained on each class. For a binary classifier it equals (sensitivity + specificity) / 2; for multiclass it is the mean of every class's recall (correct ÷ true samples). Unlike plain accuracy, it weights every class equally, so a majority class cannot inflate the score.

What is the difference between accuracy and balanced accuracy?

Plain accuracy is total correct ÷ total samples, so a class with far more samples dominates it. Balanced accuracy averages the per-class recalls instead, giving each class equal weight. On a 98%-negative dataset a model that never predicts the positive class scores 98% accuracy but only 50% balanced accuracy.

How does scikit-learn compute balanced_accuracy_score?

scikit-learn builds the confusion matrix, divides each diagonal cell by its row sum to get per-class recall, then takes the mean. Classes with no true samples produce a NaN recall and are dropped (with a warning). This calculator reproduces that exactly, including the NaN exclusion and the optional adjusted rescaling.

What is adjusted balanced accuracy?

The adjusted score rescales balanced accuracy so random guessing maps to 0 and a perfect model to 1, using (BA − 1/C) / (1 − 1/C) where C is the number of scored classes. It can go slightly negative for worse-than-random models. Turn on 'Show adjusted' to see it; it needs at least two scored classes.

What is a good balanced accuracy score?

It depends on the number of classes and the difficulty of the task. The floor for random guessing is 1/C — 50% for two classes, 33% for three. Anything near that floor means the model is barely better than chance. For most binary problems people aim well above 70%, but always compare against a random and a majority-class baseline for your dataset.

Is a higher balanced accuracy always better?

Higher is generally better, but balanced accuracy weights false positives and false negatives symmetrically. If missing a positive is far costlier than a false alarm (disease screening, fraud), also look at recall, precision, and F-beta, or Matthews correlation coefficient, which stays honest even when the classes are very uneven.

Does this tool support sample weights or an N×N confusion matrix?

Not in this version. It assumes unweighted samples and, for multiclass, takes each class's correct and total counts rather than a full N×N matrix — the diagonal and row sums are all balanced accuracy needs. Sample weighting and a full matrix parser are possible future additions.

When were the formulas last verified?

The binary, multiclass and adjusted formulas were last cross-checked against the scikit-learn documentation and the Brodersen et al. (2010) definition on 2026-07-12. The three worked examples on this page reconcile to scikit-learn's output.

Machine learning · Metrics

Balanced Accuracy Calculator

Balanced accuracy is the macro-average of per-class recall — the metric that cuts through class imbalance when plain accuracy looks too good. Paste a binary confusion matrix or per-class counts and see balanced accuracy, plain accuracy, and the adjusted (chance-corrected) score side by side. Matches scikit-learn.

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

Balanced accuracy

scikit-learn verified

True Positives (TP)

positives predicted positive

False Negatives (FN)

positives predicted negative

False Positives (FP)

negatives predicted positive

True Negatives (TN)

negatives predicted negative

Sample scenarios

Show adjusted (chance-corrected) balanced accuracy

Balanced accuracy

87.11%

macro-average recall

Plain accuracy

84.50%

overall correct ÷ total

Adjusted (chance-corrected)

0.7421

random = 0, perfect = 1

Sensitivity · Specificity

90.00% · 84.21%

the two recalls being averaged

Balanced accuracy

87.11%

Plain accuracy

84.50%

Adjusted

0.7421

Per-class recall

Class	Correct	Total	Recall
Positive	45	50	90%
Negative	800	950	84.21%
Balanced accuracy (macro-average recall)			87.11%

Balanced accuracy = 87.11% (plain accuracy = 84.50%, adjusted = 0.7421)

Cross-checked: the macro-recall result matches the textbook ½·(sensitivity + specificity) formula to float precision.

Sources: scikit-learn balanced_accuracy_score and Brodersen et al. (2010). All maths runs in your browser — nothing is uploaded.

How it works

Balanced accuracy answers a single question: on average, across all classes, what share of each class did the model get right? It is defined as the macro-average of recall — you compute recall separately for every class, then take the plain (unweighted) mean. Because every class contributes equally regardless of size, a large easy class can no longer prop up the score.

Binary mode. From the confusion-matrix counts the tool computes two recalls:

Sensitivity (recall of the positive class, TPR) = TP / (TP + FN)
Specificity (recall of the negative class, TNR) = TN / (TN + FP)
Plain accuracy = (TP + TN) / (TP + FP + FN + TN)
Balanced accuracy = (Sensitivity + Specificity) / 2

Multiclass mode. For each class c with correct_c diagonal predictions out of total_c true samples, recall is correct_c / total_c. Balanced accuracy is (1 / C) · Σ recall_c over the C classes that actually have samples. Any class with no true samples gives an undefined recall and is dropped from the average — this mirrors scikit-learn, which returns NaN for such a class and excludes it with a warning.

Adjusted (chance-corrected) balanced accuracy. A model that guesses at random still scores 1/C on balanced accuracy — 50% for two classes. The adjusted variant removes that floor with (BA − 1/C) / (1 − 1/C), mapping random guessing to 0 and a perfect model to 1. It can dip below 0 for worse-than-random models. Balanced accuracy and its adjusted form are the metric scikit-learn exposes as balanced_accuracy_score(..., adjusted=True).

Every figure is computed in your browser in full float64 precision and shown to two decimals. As a self-check, the binary result is also derived from the direct ½·(sensitivity + specificity) formula and compared against the macro-recall value; the calculator confirms the two agree.

Worked examples

Binary — severe imbalance (disease screening)

TP=10, FN=10, FP=20, TN=960

Sensitivity = TP / (TP + FN) = 10 / 20 = 0.5000
Specificity = TN / (TN + FP) = 960 / 980 = 0.9796
Plain accuracy = (10 + 960) / 1000 = 0.9700 → 97.00%
Balanced accuracy = (0.5000 + 0.9796) / 2 = 0.7398 → 73.98%
Adjusted = (0.7398 − 0.5) / (1 − 0.5) = 0.4796
The 97% headline hides that only half the positives are caught.

Multiclass — 3 classes

A = 27/30, B = 40/50, C = 10/20

Recall A = 27 / 30 = 0.9000
Recall B = 40 / 50 = 0.8000
Recall C = 10 / 20 = 0.5000
Balanced accuracy = (0.9 + 0.8 + 0.5) / 3 = 0.7333 → 73.33%
Plain accuracy = (27 + 40 + 10) / 100 = 0.7700 → 77.00%
Adjusted = (0.7333 − 1/3) / (1 − 1/3) = 0.6000

Balanced binary sanity check

TP=90, FN=10, FP=10, TN=90

Sensitivity = 90 / 100 = 0.9000
Specificity = 90 / 100 = 0.9000
Balanced accuracy = (0.9 + 0.9) / 2 = 0.9000 → 90.00%
Plain accuracy = (90 + 90) / 200 = 0.9000 → 90.00%
With equal-sized classes, balanced accuracy equals plain accuracy.

Frequently asked questions

Sources & references

The formulas on this page were last cross-checked against the scikit-learn documentation and the Brodersen et al. definition on 2026-07-12. The three worked examples reconcile to scikit-learn's output.

Related tools

LiveAI

Top-k Accuracy Calculator

Compute classification top-1 through top-k accuracy from a pasted table of ranked predictions or raw class scores. Reports the exact hit count, a full top-1…top-k ladder with marginal gains, and the samples missed at k. Mirrors scikit-learn's top_k_accuracy_score and runs entirely in your browser.

Open tool

LiveAI

Brier Score Calculator

Compute the Brier score and Brier Skill Score for probabilistic predictions. Paste forecast probabilities and 0/1 outcomes to get the mean-squared-error of the probabilities, the skill score versus a baseline, the exact formula and a per-pair breakdown. Matches scikit-learn, runs in the browser.

Open tool

LiveAI

Mutual Information Calc

Compute the mutual information I(X;Y) between two discrete variables from a count or joint-probability table, in bits or nats, with the full information-theory breakdown — marginal entropies H(X), H(Y), joint entropy H(X,Y), conditional entropies, normalized MI, and every per-cell term. Runs in your browser, matched to scikit-learn.

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.