27.3 Dice, IoU és aggregálás

27.3.1 Cél, előismeret és induló kérdés

A 27.2. U-Net, encoder–decoder és skip egységben felépítettük az encoder–decoder és a skip-kapcsolatos U-Net-alapú szegmentáló architektúrát. Ott a térbeli alakok és a csatornaszámok összeillesztése volt a fő kérdés. Most azt vizsgáljuk, hogyan mérjük a kimenő, pixelszintű bináris maszk minőségét. Egyetlen skalár pontosság nem elég: egy 24×24-es GlyphLab-képen a háttér gyakran a pixelek 80–90%-át teszi ki, így az „üres maszkot jósolok” stratégia is magas pixel-accuracyt kaphat, miközben a tényleges előtér-alakzatot teljesen elhibázza.

A szükséges előismeret: halmazművelet, a 27.2. U-Net, encoder–decoder és skip alfejezetből a bináris maszk mint 0/1 előtér-térkép fogalma, valamint a 23.3. Páros összehasonlítás és csoportszintű intervallum alfejezetből a csoportos kiértékelés és a jelenet-mintavételi egység. Ez az egység önálló matematikai fogalmat épít fel, ezért először a metrika bináris halmaz-definícióját rögzítjük, utána térünk a numerikus és aggregálási kérdésekre.

Induló becslés: ha egy 6 pixeles célmaszkra a predikció 6 találatot és 30 téves előtér-pixelt tartalmaz, akkor a pixel-accuracy $\frac{24^2-30}{24^2}\approx 0{,}948$, tehát kiválónak tűnik. Vajon a Dice vagy az IoU is ezt mondja? A második szakasz definíciói után ezt a példát ellenőrizzük.

27.3.2 Definíció: Dice és IoU bináris maszkon

Legyen $\Omega$ a képpontok véges halmaza, $|\Omega|=H\cdot W$ egyetlen bináris maszkra. A target maszk által kijelölt előtér-halmaz legyen $A\subseteq\Omega$, a predikált maszké $B\subseteq\Omega$. A két halmaz közös része $A\cap B$, uniója $A\cup B$. Jelölje

$$a=|A|,\qquad b=|B|,\qquad i=|A\cap B|.$$

A Jaccard-index, a szegmentálásban elterjedt angol nevén Intersection over Union (IoU):

$$J(A,B)=\frac{|A\cap B|}{|A\cup B|}=\frac{i}{a+b-i},$$

feltéve, hogy az unió nem üres. A Sørensen–Dice-együttható (röviden Dice):

$$D(A,B)=\frac{2|A\cap B|}{|A|+|B|}=\frac{2i}{a+b},$$

feltéve, hogy $a+b>0$. Mindkét metrika $[0,1]$-be esik, és az $A=B$ esetben 1-et, a diszjunkt halmazokra 0-t ad. A nevezőben az IoU az uniót használja, a Dice pedig a két halmaz méretének összegét; ez okozza, hogy a Dice mindig legalább akkora, mint az IoU.

A definíció számosságokat használ, ezért a maszkok tárolási formátuma lényegtelen: ugyanazt az eredményt adják a uint8 0/1 tömbök, a bool tömbök és a küszöbölt float32 logitok is, ha a küszöbölés bináris döntést adott.

27.3.3 Tensoralak, jelölés és az üres eset konvenciója

A GlyphLab-ban a maszk alakja $(N,1,H,W)$, uint8, ahol $N$ a képek száma, a csatorna mérete 1, a többi a térbeli kiterjedés. A $k$-adik képre $A_k$ a célmaszk, $B_k$ a predikciós maszk. A számítás során a $(N,1,H,W)$-t a $(N,1)$-re redukáljuk a $(H,W)$ tengelyek összegzésével; többosztályos esetben minden osztályra külön binarizált $A_k^c, B_k^c$ párt képzünk.

Az üres unió pontosan akkor fordul elő, ha $A=B=\varnothing$. A nevező ekkor nulla, ezért a fenti osztás nem ad értelmes számot. Ebben a könyvben a páronkénti konvenció a következő: ha mindkét maszk üres, akkor $J(A,B)=D(A,B)=1$, mert a predikció és a cél tökéletesen megegyezik. Ha az egyik üres, a másik nem, akkor az unió nem üres, így $i=0$ és $a+b>0$, tehát $J=D=0$. A globális aggregálásnál viszont az üres–üres pár egyetlen tagot sem ad a közös számlálóba; ha a teljes adathalmazon az összes unió üres, a globális metrika nem definiált, és ezt hibával jelezzük, nem pedig 1-gyel.

Ez a konvenció értelmezés kérdése, nem tétel. A szakirodalmi implementációk gyakran inkább kihagyják az üres–üres párokat az átlagból; a kettő nem azonos, mert a mi konvenciónk 1-es járulékot ad a képenkénti átlaghoz. A laborban ez láthatóvá válik.

27.3.4 Tétel és levezetés: Dice kapcsolata az IoU-val

A két metrika nem független: ugyanazt a $i, a, b$ statisztikát rendezi más skálán.

Tétel (Dice–IoU azonosság). Legyenek $A,B\subseteq\Omega$ véges pixelhalmazok, $a=|A|$, $b=|B|$, $i=|A\cap B|$, és tegyük fel, hogy $a+b>0$. Ekkor az unió is nemüres, az IoU $J=i/(a+b-i)$ definiált, és

$$D(A,B)=\frac{2J(A,B)}{1+J(A,B)}.$$

Bizonyítás. Az $a+b>0$ feltételből $a+b-i=|A\cup B|\geq 1$ is következik, mert ha a két halmaz közül legalább az egyik nem üres, akkor az unió is nem üres. Ezért $J$ nevezője nem nulla. Helyettesítsünk be a jobb oldalba:

$$\frac{2J}{1+J} =\frac{2\,\frac{i}{a+b-i}}{1+\frac{i}{a+b-i}} =\frac{\frac{2i}{a+b-i}}{\frac{a+b-i+i}{a+b-i}} =\frac{2i}{a+b-i}\cdot\frac{a+b-i}{a+b} =\frac{2i}{a+b}=D.$$

Az utolsó egyszerűsítésben $a+b-i>0$, tehát a tört elhagyása megengedett. $\square$

Az állítás típusa tétel, a bizonyítás elemi algebra. A feltétel fontos: az üres–üres párt a tétel nem fedi le, mert ott $a+b=0$. Az imént bevezetett 1-es konvenció nem következik a tételből, hanem külön definíció. A következő egyenlőtlenség szintén levezethető, és a gyakorlatban magyarázza, miért „szigorúbb” az IoU:

$$D-J=\frac{2J}{1+J}-J=\frac{J(1-J)}{1+J}\geq 0,$$

mert $0\leq J\leq 1$. Egyenlőség pontosan $J=0$ (diszjunkt maszkok) vagy $J=1$ (tökéletes egyezés) esetén áll; közbülső átfedésnél a Dice szigorúan nagyobb.

27.3.5 Aggregálás: per-image, global pixel, class imbalance

A metrikák egyetlen maszkpárra definiáltak. Egy tesztkészletre több aggregálási út létezik, és ezek különböző kérdésekre válaszolnak.

Képenkénti (per-image) átlag. Minden $k$ képre kiszámítjuk $J_k$ és $D_k$ értékét, majd

$$\overline{J}_{\text{img}}=\frac1N\sum_{k=1}^N J_k,\qquad \overline{D}_{\text{img}}=\frac1N\sum_{k=1}^N D_k.$$

Ez minden képet azonos súllyal vesz, függetlenül az előtér méretétől. A 23.3. Páros összehasonlítás és csoportszintű intervallum alfejezetben bevezetett jelenet-bootstrap ehhez illeszkedik: először képenként számolunk, majd a két view eredményét jelenetenként átlagoljuk, és a bootstrap a független scene-egységeken húz. Így az intervallum a jelenetek közötti szórást becsli, nem a pixelek közötti függést.

Globális pixel-aggregálás. Az összes képet egyetlen, nagy pixelgyűjteménynek tekintjük. Legyen

$$\mathrm{TP}=\sum_k |A_k\cap B_k|,\quad \mathrm{FP}=\sum_k |B_k\setminus A_k|,\quad \mathrm{FN}=\sum_k |A_k\setminus B_k|.$$

Ekkor

$$J_{\text{glob}}=\frac{\mathrm{TP}}{\mathrm{TP}+\mathrm{FP}+\mathrm{FN}},\qquad D_{\text{glob}}=\frac{2\,\mathrm{TP}}{2\,\mathrm{TP}+\mathrm{FP}+\mathrm{FN}}.$$

A globális verzió minden pixelt azonos súllyal vesz, ezért a nagy előtérrel rendelkező képek dominálják. Az üres–üres párok a globális számlálóba semmit sem tesznek, míg a képenkénti átlagban 1-ként jelennek meg; ez önmagában is eltérést okoz.

Osztályegyensúly (class imbalance). Ha $\Omega$ nagy és az $A$ előtér kicsi, akkor a pixel-accuracy a domináns háttér miatt megtévesztő. A Dice és az IoU ezt kiküszöböli, mert a nevező az $A$ és $B$ összhosszához, illetve uniójához viszonyít. Hátrányuk viszont, hogy ugyanaz az abszolút hiba egy kis objektumon sokkal nagyobb büntetést kap, mint egy nagyon: ha $A$ 4 pixeles és $B$ 8 pixeles teljes lefedéssel, akkor $D=8/12\approx0{,}667$; ha $A$ 400 pixeles és $B$ 404 pixeles teljes lefedéssel, akkor $D=800/804\approx0{,}995$. Ez a tulajdonság a relatív átfedést méri, nem az abszolút tévedés költségét.

Határ (boundary). A Dice és az IoU kizárólag halmaz-kardinalitásokat használ, ezért nem bünteti közvetlenül a kontúr alakját. Két azonos IoU-jú hiba teljesen más irányú is lehet: egy 2×2-es célblokkra a tőle jobbra 1 pixellel eltolt 2×2-es predikció és a tőle lefelé 1 pixellel eltolt 2×2-es predikció egyaránt $i=2$, $a+b=8$, tehát $J=2/6=1/3$ és $D=4/8=0{,}5$. Az egyik hibát a közös függőleges határon követjük el, a másikat a vízszintesen. Aki a határvonal pontos lefutását akarja mérni, kiegészítő metrikát használhat (például boundary-IoU vagy felületi távolság), de ez nem része a jelen egység főútjának; a területalapú metrika érvényességi korlátját mindig ki kell mondani.

27.3.6 Kézi példa három maskpár

Legyen a tér 4×4, tehát $|\Omega|=16$. Három maszkpárt vizsgálunk.

1. pár: $A_1$ a bal felső 2×2-es blokk, tehát

$$A_1=\{(0,0),(0,1),(1,0),(1,1)\},\quad a_1=4.$$

$B_1$ a bal felső 3×3-as blokk, tehát $b_1=9$. A metszet $i_1=4$, az unió $a_1+b_1-i_1=4+9-4=9$. Így

$$J_1=\frac49\approx0{,}4444,\qquad D_1=\frac{8}{13}\approx0{,}6154.$$

2. pár: $A_2=\varnothing$, $B_2=\{(0,0),(3,3)\}$, tehát $a_2=0$, $b_2=2$, $i_2=0$. Ekkor $J_2=D_2=0$.

3. pár: $A_3=B_3=\varnothing$. Az unió üres, a páronkénti konvenció szerint $J_3=D_3=1$.

A három pár képenkénti átlaga:

$$\overline{J}_{\text{img}}=\frac{4/9+0+1}{3}=\frac{13/9}{3}=\frac{13}{27}\approx0{,}4815,$$

$$\overline{D}_{\text{img}}=\frac{8/13+0+1}{3}=\frac{21/13}{3}=\frac{7}{13}\approx0{,}5385.$$

A globális pixel-számításhoz:

$$\mathrm{TP}=4+0+0=4,\qquad \mathrm{FP}=5+2+0=7,\qquad \mathrm{FN}=0+0+0=0,$$

$$J_{\text{glob}}=\frac{4}{4+7+0}=\frac{4}{11}\approx0{,}3636,\qquad D_{\text{glob}}=\frac{8}{8+7}=\frac{8}{15}\approx0{,}5333.$$

A globális IoU lényegesen kisebb, mint a képenkénti átlag, mert a globális változat nem kap 1-es járulékot az üres–üres pártól, és a 3×3-as téves predikció FP-pixeleit teljes súllyal számolja. A számok mutatják, hogy a két aggregálás nem felcserélhető.

27.3.7 Kód: metrikaszámítás és aggregálás

A kód a saját NumPy-referenciánk stílusát követi. Bináris maszkpárokra számol, a bemenet (N,1,H,W) alakú uint8 vagy bool. A csatornatengely 1 méretű, ezért a térbeli összegzés az utolsó két tengelyen történik.

# dice_iou_lab.py
import numpy as np

def binary_mask_metrics(pred, target, empty_empty_value=1.0):
    """Per-image IoU es Dice binaris (N,1,H,W) maszkparokra.

    Konvencio: ha mindket maszk ures, mindket metrika empty_empty_value.
    Ha az egyik ures, a masik nem, akkor a nevezo pozitiv, a metszet 0.
    """
    p = np.asarray(pred).astype(bool)
    t = np.asarray(target).astype(bool)
    # shape ellenorzes
    assert p.shape == t.shape and p.ndim == 4 and p.shape[1] == 1

    inter = np.logical_and(p, t).sum(axis=(-2, -1)).astype(np.float64)
    sum_a = np.logical_and(t, np.ones_like(t)).sum(axis=(-2, -1)).astype(np.float64)
    sum_b = p.sum(axis=(-2, -1)).astype(np.float64)
    union = np.logical_or(p, t).sum(axis=(-2, -1)).astype(np.float64)

    with np.errstate(divide='ignore', invalid='ignore'):
        iou = np.where(union > 0, inter / union, empty_empty_value)
        dice = np.where(sum_a + sum_b > 0,
                        2.0 * inter / (sum_a + sum_b),
                        empty_empty_value)
    return iou, dice  # mindkettó alakja (N,1)


def global_binary_metrics(pred, target):
    """Globális pixel-IoU/Dice az összes képre együtt."""
    p = np.asarray(pred).astype(bool).reshape(pred.shape[0], -1)
    t = np.asarray(target).astype(bool).reshape(target.shape[0], -1)
    TP = np.logical_and(p, t).sum().astype(np.float64)
    FP = np.logical_and(p, np.logical_not(t)).sum().astype(np.float64)
    FN = np.logical_and(t, np.logical_not(p)).sum().astype(np.float64)
    # Üres unió az összes képre együtt: a metrika nem definialt.
    union = TP + FP + FN
    if union == 0:
        raise ValueError("A globális IoU/Dice nem definialt: ures unió.")
    iou = TP / union
    dice = 2.0 * TP / (2.0 * TP + FP + FN)
    return iou, dice


if __name__ == "__main__":
    # Három 4x4-es példa, NCHW alakban.
    t0 = np.array([[[[1,1,0,0],
                     [1,1,0,0],
                     [0,0,0,0],
                     [0,0,0,0]]]], dtype=np.uint8)
    p0 = np.ones((1,1,3,3), dtype=np.uint8)  # bal felső 3x3, padding nélkül 3x3
    # A 3x3 blokkot 4x4-re kell helyezni, a jobb alsó részt nullázva nem kell,
    # de az alaknak egyeznie kell; készítsünk 4x4-et:
    p0 = np.pad(p0, ((0,0),(0,0),(0,1),(0,1)), mode='constant')

    t1 = np.zeros((1,1,4,4), dtype=np.uint8)
    p1 = np.zeros((1,1,4,4), dtype=np.uint8)
    p1[0,0,0,0] = 1
    p1[0,0,3,3] = 1

    t2 = np.zeros((1,1,4,4), dtype=np.uint8)
    p2 = np.zeros((1,1,4,4), dtype=np.uint8)

    targets = np.concatenate([t0, t1, t2], axis=0)  # (3,1,4,4)
    preds = np.concatenate([p0, p1, p2], axis=0)

    iou, dice = binary_mask_metrics(preds, targets)
    print("per-image IoU  :", iou.ravel())
    print("per-image IoU mean:", iou.mean())
    print("per-image Dice :", dice.ravel())
    print("per-image Dice mean:", dice.mean())

    gi, gd = global_binary_metrics(preds, targets)
    print("global IoU :", gi)
    print("global Dice:", gd)

A kódból várt kimenet – a fenti kézi számítás alapján, nem jelen környezetben futtatott mérésként jelölve:

per-image IoU  : [0.44444444 0.         1.        ]
per-image IoU mean: 0.48148148148148145
per-image Dice : [0.61538462 0.         1.        ]
per-image Dice mean: 0.5384615384615384
global IoU : 0.36363636363636365
global Dice: 0.5333333333333333

27.3.8 Labor: három maskpár metrikája és az aggregálási eltérés

A labor célja, hogy a kézi példát a fenti kóddal saját környezetben lefuttassa, és számszerűen lássa a képenkénti és a globális aggregálás eltérését.

• Bemenet: a fent definiált három maszkpár, uint8, (3,1,4,4). Nincs külső fájltól függés; a GlyphLab data/masks.npy-jéből a hallgató a későbbi projektekben a np.load után uint8 tömböt kap, és ugyanez a függvény használható.
• Import: numpy csak.
• Seed: a példa determinisztikus, véletlen húzás nincs; a reprodukálhatósági naplóban np.random.seed(20261020)-at teszünk a későbbi bootstrap-kompatibilitás érdekében, de a metrikaértékek nem függnek tőle.
• Dtype: bemenet uint8, belső konverzió bool, a metrikák float64, hogy a $24^2$ nagyságrendű pixelösszegek pontosan férjenek.
• Device: CPU, NumPy; nincs GPU-követelmény.
• Futtatási parancs a lab/ munkakönyvtárból: python dice_iou_lab.py.
• Ellenőrzés: a kívánt tolerance a kézi értékekkel szemben abszolút $10^{-12}$, mert csak kis egész számok osztása történik. A három per-image értéknek rendre $4/9$, $0$, $1$ IoU-t és $8/13$, $0$, $1$ Dice-ot kell adnia.
• Értelmezés: a per-image IoU átlag $0{,}4815$, a globális $0{,}3636$. A különbség nem kerekítési hiba. A globális IoU az üres–üres pár 1-es konvencióját nem ismeri, és a 3×3-as predikció mind az öt téves pixelét a közös nevezőbe teszi, miközben a képenkénti átlagban az adott kép IoU-ját az unió saját mérete normalizálja. Ha a kérdés az, hogy egy átlagos jelenet milyen jól van szegmentálva, a per-image, jelenetszintű átlag a megfelelő; ha a kérdés az, hogy az összes előtér-pixel hány százalékát találtuk el, a globális a megfelelő.

27.3.9 F1–F5 feladatok

27.3.9.1 F1 (fogalmi, nehézség 1)

Adott $A$ és $B$ ugyanazon a 10×10-es rácson: $|A|=10$, $|B|=8$, $|A\cap B|=6$. Számítsa ki $J$ és $D$ értékét, és igazolja a levezetett $D=2J/(1+J)$ azonosságot. Adjon olyan két halmazpárt, ahol $D=J$, és indokolja, miért.

Elvárt átadandó eredmény: a két számérték, a behelyettesítés, és a két egyenlőségi eset megnevezése.

27.3.9.2 F2 (levezetési, nehézség 2)

Bizonyítsa be a $D-J$ különbségre vonatkozó állítást: ha $a+b>0$, akkor $D(A,B)\geq J(A,B)$, és az egyenlőség pontosan $i=0$ vagy $a=b=i$ esetén áll fenn.

Elvárt átadandó eredmény: teljes levezetés a $J$ definíciójából, az egyenlőség feltételének indoklása, és egy olyan számpélda, ahol $0<J<1$.

27.3.9.3 F3 (implementációs, nehézség 2)

Írjon dice_iou_multi(pred, target) függvényt, amely (N,C,H,W) alakú, 0/1 uint8 többosztályos maszkokat fogad, és osztályonként visszaadja a képenkénti IoU-átlagot, valamint a mean IoU-t (a $C$ osztály átlagát). Az üres–üres párokra minden osztályban 1-gyel számoljon. Ellenőrizze a fenti három bináris példán $C=1$ esetben, hogy a függvény a binary_mask_metrics kimenetével egyezik.

Elvárt átadandó eredmény: futtatható kód, a három példán adódó $[4/9,0,1]$ vektor és a $\overline{J}_{\text{img}}=13/27$, továbbá a shape-ellenőrzés.

27.3.9.4 F4 (hibakeresési, nehézség 2)

Adott a következő kódrészlet:

def iou_bad(pred, target):
    inter = (pred * target).sum(axis=(-2, -1))
    union = pred.sum(axis=(-2, -1)) + target.sum(axis=(-2, -1)) - inter
    return (inter / union).mean()

Tegyük fel, hogy a függvényt a hálózat nyers sigmoid-kimenetére hívjuk, amely float32 értékeket tartalmaz $[0,1]$-ben. Mi a hiba, mi a következménye, és hogyan javítaná? Ellenőrizze a javítást azzal a kétpixeles példával, ahol pred=[0.6,0.4], target=[1,0].

Elvárt átadandó eredmény: a hiba oka, a numerikus következmény, a küszöbölést tartalmazó javított függvény, és a javított kimenet.

27.3.9.5 F5 (kísérleti/transzfer, nehézség 3)

A GlyphLab szegmentáló laborban a cél a 24×24-es előtér-maszk rekonstrukciója. Tervezzen kiértékelési protokollt, amely a 23.3. Páros összehasonlítás és csoportszintű intervallum alfejezetbeli class-stratified scene bootstrapet használja a képenkénti IoU átlagához. Adja meg:

• a megfigyelési egységet,
• a per-image metrikából a scene-szintű statisztika képzésének lépését,
• a bootstrap replikátumok képzését a két view figyelembevételével,
• egy triviális baseline-t,
• és a következtetés érvényességi korlátját.

Elvárt átadandó eredmény: protokoll-leírás, a baseline indoklása, és legalább egy konkrét korlát (például a bootstrap csak a tesztminta-mintavételi bizonytalanságot közelíti).

27.3.10 Megoldások és indoklás

27.3.10.1 F1 megoldása

Az unió mérete $a+b-i=10+8-6=12$, tehát $J=6/12=0{,}5$. A Dice $D=2\cdot6/(10+8)=12/18=2/3$. Az azonosság: $2J/(1+J)=1/(1{,}5)=2/3$, egyezik.

A $D=J$ esetek a levezetett $D-J=J(1-J)/(1+J)$ képletből: $J=0$, azaz $i=0$ (diszjunkt halmazok, például $A$ a bal felső, $B$ a jobb alsó sarok), vagy $J=1$, azaz $a=b=i$ (a két halmaz azonos). Ha $A$ üres és $B$ nem üres, az $i=0$ esethez tartozik, és $J=D=0$; az üres–üres pár külön konvenció.

27.3.10.2 F2 megoldása

A tétel szerint $D=2J/(1+J)$, feltéve, hogy $a+b>0$. Ekkor

$$D-J=\frac{2J}{1+J}-J=\frac{2J-J(1+J)}{1+J}=\frac{J(1-J)}{1+J}.$$

Mivel $J=|A\cap B|/|A\cup B|\in[0,1]$, a számláló nemnegatív, a nevező $1+J\geq1>0$. Így $D\geq J$. Az egyenlőség pontosan akkor, ha $J(1-J)=0$, azaz $J=0$ vagy $J=1$. A $J=0$ ekvivalens $i=0$-val, mert a nevező pozitív. A $J=1$ ekvivalens $i=a+b-i$-vel, azaz $2i=a+b$. Mivel $i\leq a$ és $i\leq b$, ez csak $i=a$ és $i=b$ mellett lehet, tehát $a=b=i$, vagyis $A=B$. Számpélda közbülső értékre: $a=6$, $b=6$, $i=3$, ekkor $J=3/9=1/3$, $D=6/12=1/2$, és $D>J$.

27.3.10.3 F3 megoldása

A többosztályos függvény minden $c$ osztályra binarizál:

def dice_iou_multi(pred, target):
    # pred, target: (N,C,H,W), uint8, 0/1 one-hot vagy index-halmaz? Jelen
    # megoldás: már binarizált C csatornás 0/1 tombot varunk.
    pred = np.asarray(pred).astype(bool)
    target = np.asarray(target).astype(bool)
    assert pred.shape == target.shape and pred.ndim == 4
    N, C, H, W = pred.shape
    ious = np.empty((C, N), dtype=np.float64)
    for c in range(C):
        p = pred[:, c, None, :, :]  # (N,1,H,W)
        t = target[:, c, None, :, :]
        iou, _ = binary_mask_metrics(p, t, empty_empty_value=1.0)
        ious[c] = iou[:, 0]
    per_class_mean = ious.mean(axis=1)   # (C,)
    miou = per_class_mean.mean()
    return per_class_mean, miou

A $C=1$ esetben a három példa IoU-vektora $[4/9,0,1]$, az osztályon belüli átlag $13/27\approx0{,}4815$. A kód az üres–üres konvenciót az empty_empty_value=1.0 argumentummal őrzi meg. Alakellenőrzés: bemenet (3,1,4,4), kimenet per_class_mean alakja (1,), a miou skalár.

27.3.10.4 F4 megoldása

A hiba: a pred nem bináris, hanem valós $[0,1]$-beli sigmoid-kimenet. A pred * target ezért nem metszet-számosságot ad, hanem súlyozott összeget; a union sem halmaz-unió, hanem valós összeg. A következmény: a metrika nem IoU, és érzékeny a küszöb alatti zajra; például a kétpixeles [0.6,0.4] és [1,0] esetén az inter $0{,}6$, a union $1{,}4$, az IoU-hibrid $0{,}4286$, miközben a küszöbölt [1,0] predikcióval a valódi IoU $1$.

A javítás:

def iou_fixed(pred, target):
    p = np.asarray(pred, dtype=np.float64) > 0.5
    t = np.asarray(target, dtype=np.float64) > 0.5
    inter = np.logical_and(p, t).sum(axis=(-2, -1))
    union = np.logical_or(p, t).sum(axis=(-2, -1))
    return (inter / union).mean()

A kétpixeles példán a kimenet $1$. Ha a predikció valószínűség, a kiértékelés előtt rögzíteni kell a küszöböt; a 23.2. Kalibráció és döntési küszöb alfejezetben a döntési küszöb kalibrációs szerepét tárgyaljuk, itt a metrika bináris definíciója a döntés utáni maszkot várja.

27.3.10.5 F5 megoldása

A protokoll:

1. A tesztkészlet $30$ független jelenetet tartalmaz, jelenetenként két view-val, tehát $60$ képet.
2. Bináris szegmentáló modell minden képre ad egy $B_k$ maszkot; a célmaszk $A_k$. Képenként számítjuk a képenkénti IoU-t az üres konvencióval.
3. Jelenetszintű statisztika: minden $s$ jelenetre a két view IoU-jának átlaga, $m_s=(J_{s,1}+J_{s,2})/2$. Ezzel a megfigyelési egység a jelenet lesz, nem az egyes kép, mert a két view ugyanabból a jelenetből függő.
4. A $30$ jelenet-értékből vett átlag a pontbecslés: $\hat{\mu}=\frac1{30}\sum_s m_s$.
5. A class-stratified scene bootstrap a 23.3. Páros összehasonlítás és csoportszintű intervallum szerint: mind a három osztályban $10$ jelenet van; a replikátumban osztályonként $10$ jelenetet húzunk visszatevéssel. A replikátumátlagot a $m_s$ értékekből számítjuk, a húzott jelenetek súlyozatlan átlagaként. Az intervallum a replikátumok 2,5%–97,5% kvantilise.
6. Baseline: mindig üres maszk. Ekkor minden nem üres célra $J=0$; a GlyphLab képeken a célmaszk általában nem üres, ezért a baseline körülbelül 0, kivéve ha az előtér-generátor üres maszkot is ad; ha igen, az üres–üres párok 1-gyel számítanak. A baseline tehát azt méri, mennyire triviális a feladat üres predikcióval.
7. Érvényességi korlát: a bootstrap a tesztminta jelenetek közötti mintavételi ingadozását közelíti, nem a modelltanítás seedjeinek szórását, nem az adatgenerátor bizonytalanságát, és nem az éles alkalmazásban fellépő domaineltolódást. Az üres–üres konvenció megváltoztatása megváltoztatja a pontbecslést is, ezért a protokoll közzétételekor a konvenciót a metrika képletével együtt kell rögzíteni.

27.3.11 Tipikus tévedés és ellenpélda

A leggyakoribb tévedés: a globális pixel-IoU-t és a képenként átlagolt IoU-t ugyanannak a statisztikának tekinti. Ez csak speciális esetben, például azonos méretű és azonos előtér-számosságú maszkoknál adhat közeli értéket; általában különböző.

Ellenpélda: két tesztkép. Az elsőn $|A_1|=1000$, $|B_1|=1000$, $i_1=1000$, tehát $J_1=1$. A másodikon $|A_2|=10$, $B_2=\varnothing$, tehát $J_2=0$. A képenkénti átlag $(1+0)/2=0{,}5$. A globális: $\mathrm{TP}=1000$, $\mathrm{FP}=0$, $\mathrm{FN}=10$, tehát

$$J_{\text{glob}}=\frac{1000}{1010}\approx0{,}9901.$$

Ugyanaz a modell egyszer 0,5-ös teljesítményűnek, másszor 0,99-esnek látszik, attól függően, hogy képenként vagy pixelenként átlagolunk. A két statisztika más kutatási kérdésre válaszol: az első arra, hogy egy átlagos kép/jelenet milyen jól van szegmentálva, a második arra, hogy a pixelek mekkora hányada helyes.

27.3.12 Önellenőrzés és korábbi fogalom visszahívása

Visszahívás a 15.3. Transposed convolution mint adjungált alfejezetből: a transposed convolution adjungált, nem általános inverz. A jelen egység kapcsolódása: az U-Net decoder a transzponált konvolúcióval állítja elő a térbeli maszklogitokat, de a metrika a logitok küszöbölése utáni bináris halmazt méri. Az inverzként való félreértés a metrikaoldalra is átvihető: a magas IoU nem azt jelenti, hogy a dekóder visszaállította az eredeti maszk minden határpixelét, csak azt, hogy a halmazátfedés nagy.

Önellenőrzés: a kézi példában $i_1=4$, $a_1+b_1=13$, az unió $9$; a Dice $8/13$ és az IoU $4/9$ közti azonosság $2(4/9)/(1+4/9)=8/9\cdot9/13=8/13$. A harmadik pár üres–üres, a tétel nem alkalmazható, az 1-es konvenció külön definíció. A labor kódja bool konverziót használ, ezért a np.pad után a p0 4×4-es alakú; az összegzések az utolsó két tengelyen futnak, a kimenet (3,1).

27.3.13 Rövid összefoglaló

A bináris szegmentálás két alappillére az IoU és a Dice. Az IoU a metszet és az unió, a Dice a kétszeres metszet és a méretösszeg hányadosa. Nemüres halmazokra $D=2J/(1+J)$, amit a közös $a,b,i$ statisztikából elemi algebrával levezettünk. Az üres–üres párra a könyv páronkénti 1-es konvenciót rögzít. A képenkénti és a globális pixel-aggregálás külön statisztika: az első képenként, a második pixelenként súlyoz, és az üres konvenciót is másként kezeli. A labor három maszkpáron mutatta az eltérést. A következő alkalmazás: 27.4. Instance mask és összetett feladat alfejezetben az instance mask és az összetett feladat kapcsolja össze a detektálásból ismert IoU-t a pixelszintű előtér-meghatározással.

27.3.14 Források

• [P14] Ronneberger, O., Fischer, P., Brox, T. (2015). U-Net: Convolutional Networks for Biomedical Image Segmentation. arXiv:1505.04597. https://arxiv.org/abs/1505.04597.
• Jelen egység levezetései (Dice–IoU azonosság, $D-J$ egyenlőtlenség, aggregálási példák) saját, a 26.3. NMS, confidence és AP alfejezetből visszahívott IoU-fogalom bináris pixelhalmazokra való specializálásával.