What is the Tversky index and how is it calculated?

The Tversky index measures overlap between a predicted set and a ground-truth set as TP / (TP + α·FP + β·FN), where TP is the intersection, FP is predicted-but-wrong, and FN is missed positives. α weights false positives and β weights false negatives, so you control whether precision or recall matters more. It ranges from 0 (no overlap) to 1 (identical).

What is the difference between the Tversky index, the Dice coefficient, and the Jaccard index?

They are the same formula at different weights. Setting α = β = 0.5 gives the Dice coefficient (equivalently the F1 score): TP / (TP + 0.5·FP + 0.5·FN) = 2·TP / (2·TP + FP + FN). Setting α = β = 1 gives the Jaccard index (IoU): TP / (TP + FP + FN). The Tversky index generalises both by letting the two error types carry unequal weights.

What do alpha and beta mean in the Tversky loss function?

α is the penalty on false positives and β is the penalty on false negatives. A larger β punishes missed positives harder, pushing the model toward recall; a larger α punishes false alarms, pushing toward precision. Salehi et al. use the α + β = 1 convention so the two trade off directly — for example α = 0.3, β = 0.7 for imbalanced masks.

When should you use Tversky loss instead of Dice loss?

Use Tversky loss when false negatives and false positives cost differently — most often on highly imbalanced segmentation, such as small lesions or tumours where the target occupies a tiny fraction of the image. Dice weights both errors equally, so a model can score well while quietly missing small positives. Setting β > α makes missed positives hurt the score, which is usually what you want there.

Is the Tversky index the same as the F-beta score?

They are closely related but not identical in parameterisation. Both trade precision against recall through a single knob. With the α + β = 1 convention, raising β behaves like raising β in the Fβ score — it up-weights recall. The exact algebraic mapping differs, so treat the Tversky index as a set-overlap metric that reduces to F1 at α = β = 0.5, rather than a drop-in Fβ.

Can I enter fractional or soft counts?

Yes. In segmentation the loss is usually computed from continuous probabilities rather than hard 0/1 masks, so TP, FP and FN are real-valued sums. This calculator accepts any non-negative number for the counts, which reproduces the soft Tversky loss used during training. The only rule is that the denominator TP + α·FP + β·FN must be greater than zero.

Why is my recall-weighted score lower than the Dice score?

Because you are penalising the errors you have more of. If your model misses positives (high FN) and you set β > α, those misses are weighted more heavily, so the denominator grows and the index drops below Dice. That lower number is the signal you asked for — it reflects the cost of under-segmentation that Dice hides by weighting both errors at 0.5.

Does anything I enter leave my browser?

No. Every calculation — parsing your two sets, deriving TP/FP/FN, and applying the formula — runs client-side in JavaScript. Nothing is sent to a server, logged, or stored. You can disconnect from the network and the calculator still works.

Machine learning · Metrics

Tversky Index Calculator

Compute the Tversky index and Tversky loss from TP, FP and FN with tunable α and β weights — and see the same prediction scored as Dice and Jaccard/IoU side by side. Runs entirely in your browser, nothing uploaded.

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

Tversky indexTP / (TP + α·FP + β·FN)

Collapses to Dice & Jaccard · verified

True positives (TP)

Correct overlap: |P ∩ G|

False positives (FP)

Predicted, not in truth: |P ∖ G|

False negatives (FN)

Missed positives: |G ∖ P|

α — false-positive weight

Higher α favours precision · range 0–2

β — false-negative weight

Higher β favours recall · range 0–2

PresetsCustom

Tversky index

0.702

70.18%

Tversky loss

0.298

1 − index (minimised in training)

Dice (α=β=0.5)

0.727

F1 / Dice reference

Jaccard (α=β=1)

0.571

IoU reference

Substituted formula

80 / (80 + 0.3·20 + 0.7·40) = 80 / 114 = 0.702

α·FP = 6 · β·FN = 28 · loss = 1 − 0.702 = 0.298

Where your weighting sits

Metric	α / β	Score	Loss (1 − score)
Dice / F1	0.5 / 0.5	0.727	0.273
Your Tversky	0.3 / 0.7	0.702	0.298
Jaccard / IoU	1 / 1	0.571	0.429

Interpretation

β > α weights false negatives (missed positives) more heavily than false positives, so the score favours recall — the usual choice when a model under-segments small targets. With α + β = 1 this is the Salehi et al. training convention.

Computed in your browser — nothing is uploaded.

How it works

The Tversky index scores how well a predicted set P matches a ground-truth set G. In classification and segmentation terms it is built from three counts:

TP = |P ∩ G| — true positives, the correct overlap.
FP = |P ∖ G| — false positives, predicted but not in truth.
FN = |G ∖ P| — false negatives, truth positives the model missed.

The index, introduced by Amos Tversky in “Features of Similarity” (1977) and cast in this TP/FP/FN form for segmentation by Salehi et al. (2017), is:

TI(α, β) = TP / (TP + α·FP + β·FN)

The weight α scales the false-positive term and β scales the false-negative term. That single asymmetry is the whole point: Dice and Jaccard treat the two error types identically, but on imbalanced data — a small tumour, a thin road, a rare defect — a missed positive usually costs far more than a false alarm. Raising β makes those misses drag the score down, which is exactly the training signal you want.

Two familiar metrics are special cases of this one formula:

α = β = 0.5 → Dice / F1: TP / (TP + 0.5·FP + 0.5·FN) = 2·TP / (2·TP + FP + FN)
α = β = 1 → Jaccard / IoU: TP / (TP + FP + FN)

The calculator computes both special cases on your exact counts and shows them next to your weighting, so the relationship is visible rather than asserted. The Tversky loss is simply 1 − TI(α, β) — the quantity a network minimises. Salehi et al. adopt the α + β = 1 convention so the two weights trade off directly; the tool flags when your inputs meet it. In Two sets mode, TP/FP/FN are derived by set intersection and difference on the two lists you paste (duplicates collapse to membership), then the identical formula applies. All arithmetic is exact floating point and runs in your browser.

Worked examples

Recall-weighted vs the standard metrics

TP = 80, FP = 20, FN = 40 · α = 0.3, β = 0.7

Denominator: 80 + 0.3·20 + 0.7·40 = 80 + 6 + 28 = 114
Tversky index: 80 / 114 = 0.702 → loss = 0.298
Dice (α=β=0.5): 80 / (80 + 10 + 20) = 80/110 = 0.727
Jaccard (α=β=1): 80 / (80 + 20 + 40) = 80/140 = 0.571
The recall-weighted 0.702 sits below Dice's 0.727 — the 40 missed positives are penalised harder.

Same counts, precision-weighted (weights swapped)

TP = 80, FP = 20, FN = 40 · α = 0.7, β = 0.3

Denominator: 80 + 0.7·20 + 0.3·40 = 80 + 14 + 12 = 106
Tversky index: 80 / 106 = 0.755 → loss = 0.245
Now the 20 false positives dominate the penalty, so the score rises.
0.702 (recall-weighted) vs 0.755 (precision-weighted) on identical data is the asymmetry Dice and Jaccard cannot express.

Identity and edge cases

verifying the formula collapses correctly

α = β = 0.5 on Example 1's counts reproduces Dice exactly: 0.727.
α = β = 1 reproduces Jaccard exactly: 0.571.
Zero overlap TP=0, FP=5, FN=5, α=β=0.5: 0 / (0 + 2.5 + 2.5) = 0, loss = 1.
Perfect match TP=100, FP=0, FN=0: 100 / 100 = 1, loss = 0 for any α, β.
TP=FP=FN=0 makes the denominator zero — the index is undefined and the tool asks for a non-zero input.

Frequently asked questions

Sources & references

The formula and the Dice/Jaccard special cases were last cross-checked against the primary sources on 2026-07-13. The identity checks (α=β=0.5 → Dice, α=β=1 → Jaccard) are enforced by the calculator's own comparison functions.

Related tools

LiveAI

Jaccard Similarity Calc

Compute the Jaccard similarity coefficient and distance between two sets, text snippets, or binary vectors, with the intersection/union breakdown and the substituted formula — all in the browser. Matches scikit-learn jaccard_score.

Open tool

LiveAI

Dice Coefficient Calc

Compute the Dice similarity coefficient (Sørensen–Dice index) from two sets, two binary segmentation masks, or raw TP/FP/FN counts. Shows every arithmetic step, the Dice distance, and the related Jaccard/IoU value — matched to MONAI and SciPy, entirely in your browser.

Open tool

LiveAI

IoU Calculator

Compute Intersection over Union for two bounding boxes or two label sets. Returns IoU, the Dice/F1 coefficient, raw intersection and union, a threshold pass/fail verdict, and a scaled overlap diagram — entirely in your browser, sources cited.

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.