27.4 Instance mask és összetett feladat

27.4.1 Cél, előfeltétel és induló kérdés

A 27.3. Dice, IoU és aggregálás egységben a szemantikus szegmentálás pixelcímkét adott: minden $(i,j)$ pixelhez osztályt rendelt, de az azonos osztályú objektumokat nem választotta szét. Itt a kérdés az objektumazonosság külön kezelése: hány különálló példány van, és melyik pixel melyik példányhoz tartozik. Az előismeret a Dice/IoU-metrika, az üres maszk kezelése és az epsilon-stabilizált nevező 27.3. Dice, IoU és aggregálás; a detektálási dobozszerződés, az üres cél és a hibafajták 26.4. Detektálási pipeline és hibaelemzés; továbbá az összesített metrika szeleteket elrejtő hatása 23.4. Hibaszeletek és alkalmazási határ. A 15.4. Független gradiensellenőrzési protokoll alfejezetben bevezetett gradiensellenőrzési szemlélet itt arra figyelmeztet, hogy a maszkküszöb utáni bináris döntés nem sima veszteségfüggvény.

Induló kérdés: egy $10\times 10$-es képen 12 előtérpixel hány példányt alkothat? A válasz nem olvasható le a pixelarányból: lehet egyetlen 12 pixeles objektum, de akár 12 különálló 1 pixeles példány is. A példányszám és az előtérpixel-arány tehát különböző célváltozó.

27.4.2 Definíciók és tenzoralak

Legyen $X\in\mathbb{R}^{H\times W}$ egy egycsatornás kép, illetve batchelt alakban $X\in\mathbb{R}^{N\times C\times H\times W}$. A szemantikus annotáció bináris esetben

$$M_{\text{sem}}\in\{0,1\}^{H\times W},$$

ahol $M_{\text{sem}}[i,j]=1$ jelenti a hátteret. Többosztályos esetben $M_{\text{sem}}\in\{0,\ldots,K-1\}^{H\times W}$, ahol $0$ a háttér, $1,\ldots,K-1$ a szemantikus osztályok. Ez azonban nem tartalmazza, hogy két azonos osztályú, egymástól különálló folt ugyanahhoz az objektumhoz tartozik-e.

Az instance annotáció

$$A_{\text{inst}}\in\mathbb{N}_0^{H\times W},\qquad A_{\text{inst}}[i,j]= \begin{cases} 0,& \text{háttér},\\ m,& \text{az }m\text{-edik példány}, \; m=1,\dots,M, \end{cases}$$

ahol $M$ a képen lévő példányok száma. Minden $m\in\{1,\ldots,M\}$ példányhoz tartozik:

• egy osztálycímke $c_m\in\{1,\ldots,K-1\}$,
• egy fél-nyílt xyxy doboz $b_m=(x_{\min},y_{\min},x_{\max},y_{\max})$, ahol $x_{\min}\le x<x_{\max}$, $y_{\min}\le y<y_{\max}$ 26.4. Detektálási pipeline és hibaelemzés,
• egy bináris példánymaszk $M_m\in\{0,1\}^{H\times W}$, ahol $M_m[i,j]=1$ pontosan akkor, ha $A_{\text{inst}}[i,j]=m$.

A kettő kapcsolata:

$$\bigl(M_{\text{sem}}[i,j]=1\bigr)\;\Longleftrightarrow\;\bigl(A_{\text{inst}}[i,j]>0\bigr).$$

Az id-érték pusztán címke, nem ordinális mennyiség: az 1 és 2 felcserélése ugyanazt a példányfelosztást jelenti. A példányfelosztás ezért permutáció erejéig értendő, a szemantikus osztály viszont nem felcserélhető.

A hálózati kimenet egy listaszerű, változó hosszú szerződés: minden detektált példányra osztálylogit, doboz, confidence és maszklogit tartozik. A jelen könyv által használt, előtanított súlytól független predikciós séma:

$$P=\{(s_i,b_i,c_i,\hat M_i): i=1,\ldots,\hat M\},$$

ahol $s_i\in[0,1]$ confidence, $b_i\in\mathbb{R}^4$ xyxy doboz, $c_i\in\{1,\ldots,K-1\}$ osztály, $\hat M_i\in[0,1]^{H\times W}$ maszkvalószínűség. A bináris maszkot a downstream döntés $0{,}5$-ös küszöbbel képzi; a veszteség a logiton vagy valószínűségen számol, nem a küszöbölt maszkon.

27.4.3 Levezetési kötelezettség: a szemantikus maszk nem azonosítja az instance-felosztást

Kimondjuk a szükséges állítást.

Lemma. Létezik olyan bináris szemantikus maszk $M_{\text{sem}}\in\{0,1\}^{2\times 3}$, amelyhez legalább két különböző, összefüggő példányfelosztás tartozik, és a két felosztás még az id-permutáció erejéig sem azonos.

Bizonyítás. Tekintsük a következő $3$ széles, $2$ magas előtérblokkot:

M_sem:
1 1 1
1 1 1

Első példányfelosztás:

A_inst^(1):
1 1 2
1 1 2

Itt az 1. példány az első két oszlop, a 2. példány a harmadik oszlop. Második példányfelosztás:

A_inst^(2):
1 2 2
1 2 2

Itt az 1. példány az első oszlop, a 2. példány a második és harmadik oszlop. Mindkét esetben

$$\mathbf 1[A_{\text{inst}}^{(r)}>0]=M_{\text{sem}},\qquad r=1,2,$$

tehát ugyanazt a szemantikus maszkot adják. Mindkét id-osztály $4$-szomszédosan összefüggő, mert mindegyik egy-egy tengelyesen összefüggő téglalap. A két felosztás geometriai vágása eltér: az első a második és harmadik oszlop határán vág, a második az első és második oszlop határán. Ez a különbség nem szüntethető meg az $\{1,2\}$ id-permutációval, mert a példányok mérete $4$-2 pixel, illetve $2$-4 pixel. $\square$

A lemma következménye: a szemantikus maszkból kiinduló pixelosztályozási veszteség önmagában nem definiál egyértelmű instance-célt. Ha a feladat példányokat kér, a tanítóannotációnak példányazonosítót, példánymaszkot vagy példányonkénti dobozt kell tartalmaznia.

27.4.4 Mask R-CNN: detektálási fej, ROI és párhuzamos maszkág

A [P15] szerzők által bemutatott Mask R-CNN a Faster R-CNN detektort egészíti ki: a meglévő osztályozó- és dobozregressziós ág mellé párhuzamos maszkágat helyez, amely minden detektált objektumra bináris példánymaszkot jósol. Ez a szervezés jól mutatja, hogy az instance-feladat két részből áll: a detektálási fej megmondja, hol van egy objektum, és mi az osztálya, a maszkág pedig megmondja, mely pixel tartozik hozzá.

A detektálási fej közbülső reprezentációja a ROI, azaz region of interest: egy $b=(x_{\min},y_{\min},x_{\max},y_{\max})$ jelölt doboz, amelyből a hálózat a megfelelő jellemzőtér-régiót kivágja. A kivágás diszkrét rácson történik, ezért fontos a koordináták kvantálásának kezelése. Az [P15] arXiv-absztraktja szerint a módszer egy RoIAlign nevű, kvantálásmentes réteget alkalmaz, amely a térbeli pozíciókat pontosabban őrzi meg; ennek pontos bilineáris mintavételezési képletét és a különböző ROI-méretválasztásokat a teljes cikk megfelelő módszerszakaszának olvasása után lehet idézni.

A jelen szöveg ezért csak a szerződésszintű leírást adja meg. Legyen a bemeneti képbatchenként egy ROI-halmaz $\{b_1,\ldots,b_R\}$. A maszkág minden $r$ ROI-ra

$$\hat M_r\in[0,1]^{h_m\times w_m}$$

maszklogitot vagy normalizált maszkvalószínűséget állít elő, ahol $h_m,w_m$ a maszkfej kimeneti felbontása. Az osztályozó ág $Z^{\text{cls}}\in\mathbb{R}^{R\times K}$ logitot, a dobozág $B\in\mathbb{R}^{R\times 4}$ finomított dobozt ad. A kimeneti példány ezután: osztály, confidence, doboz, küszöbölt és az eredeti képméretre interpolált maszk. A tanító veszteség az osztályozási, doboz- és maszktag összege; a pontos súlyok és a maszk-cross-entropy normalizálása a módszer teljes szövegének ellenőrzését igényli.

27.4.5 Instance-metrika: maszk-IoU-alapú greedy matching

A szemantikus Dice/IoU 27.3. Dice, IoU és aggregálás minden pixelt egyenlően mér, függetlenül attól, hogy hány objektumot vont össze vagy szakított szét. Az instance-metrika ezt a hiányt pótolja. Legyen a ground truth példányhalmaz $\mathcal G=\{g_1,\ldots,g_M\}$, a predikció $\mathcal P=\{p_1,\ldots,p_{\hat M}\}$, ahol minden $p_i$-hez confidence $s_i$ tartozik. Minden $p_i$-re és $g_j$-re kiszámítjuk a maszk-IoU-t:

$$\operatorname{IoU}(p_i,g_j)=\frac{|p_i\cap g_j|}{|p_i\cup g_j|+\varepsilon},$$

ahol a számláló a közös előtérpixelek száma, a nevező a két maszk uniójának pixelszáma, $\varepsilon$ pedig a $0/0$ esetet kizáró numerikus konstans. Az üres predikált maszk nem tekinthető példánynak; ha $|p_i|=0$ és $|g_j|=0$, a pár nem képezhet TP-t, mert nincs tényleges példány.

Rögzített $\tau$ IoU-küszöb mellett a predikciókat confidence szerint csökkenő sorrendbe rendezzük, majd greedy, egy-az-egyhez illesztést végzünk: minden predikció a még nem illesztett ground truth példányok közül ahhoz illeszkedik, amellyel a legnagyobb az IoU, ha ez legalább $\tau$. Az illesztett predikció TP, az illesztetlen predikció FP, az illesztetlen ground truth FN. Az így kapott precision–recall görbe alatti terület az instance average precision, röviden AP. Az AP közvetlenül a példányazonosságot bünteti: egy merge hibánál a predikció csak egy ground truth példányhoz illeszkedhet, a másik FN marad, még akkor is, ha a globális pixel-IoU magas.

Kis levezetés. Legyen a ground truth két diszjunkt $6$ pixeles maszk, $g_1,g_2$, a predikció pedig az uniójuk: $p=g_1\cup g_2$, $12$ pixel, confidence $0{,}9$. A globális pixel-IoU

$$\frac{|p\cap(g_1\cup g_2)|}{|p\cup(g_1\cup g_2)|}=\frac{12}{12}=1.$$

Ezzel szemben $p$ és $g_1$, illetve $p$ és $g_2$ között az IoU $\frac{6}{12}=0{,}5$. Ha $\tau=0{,}5$ és a greedy illesztés a $\ge\tau$ szabályt használja, $p$ az egyik $g$-t elviszi, a másik FN lesz; egyképes AP-értékként $R=0{,}5$, $P=1$, azaz AP $=0{,}5$. Ha a küszöb $>0{,}5$, akkor $p$ egyetlen ground truth példányhoz sem illeszkedik, ezért $P=0$. Az instance-metrika tehát akkor is hibát jelez, amikor a pixelátlag tökéletesnek látszik.

27.4.6 Labor: kétobjektumos annotációs minta és input/output szerződés

A labor célja egy eredeti, $8\times 8$-as mintán rögzíteni az instance annotáció sémáját, valamint ellenőrizni, hogy a doboz és az id-maszk konzisztens. Munkakönyvtár: lab/n108_instance_lab. A kód nem igényel PyTorch-ot vagy GPU-t; a futási parancs:

cd lab/n108_instance_lab
python instance_contract.py

A szerződés a következő. Bemeneti kép: image alakja (8, 8), float32, $[0,1]$ intenzitás. Target: instance_ids alakja (8, 8), int64, értéke $0$ háttérre, $1,2$ példányazonosítóra. bboxes alakja (M, 4), float32, xyxy sorrend [xmin, ymin, xmax, ymax], fél-nyílt. labels alakja (M,), int64. Hálózati kimenet: boxes, labels, scores, masks; a maszk (M, H, W) float32, küszöbölés nélküli valószínűség.

import json
import numpy as np

# Munkakönyvtár: lab/n108_instance_lab
# Futtatás: python instance_contract.py

H, W = 8, 8
image = np.zeros((H, W), dtype=np.float32)
image[1:3, 1:4] = 0.7   # világos előtér, 1. példány
image[5:7, 2:6] = 0.4   # halványabb előtér, 2. példány

instance_ids = np.zeros((H, W), dtype=np.int64)
instance_ids[1:3, 1:4] = 1   # y = 1..2, x = 1..3
instance_ids[5:7, 2:6] = 2   # y = 5..6, x = 2..5

bboxes = np.array([[1.0, 1.0, 4.0, 3.0],
                   [2.0, 5.0, 6.0, 7.0]], dtype=np.float32)
labels = np.array([1, 1], dtype=np.int64)

# Konzisztencia: minden id összes pixele pontosan a dobozán belül van-e.
for idx, m in enumerate([1, 2]):
    ys, xs = np.where(instance_ids == m)
    if len(xs) == 0:
        raise ValueError(f"{m}. id üres, nincs példány")
    xmin, ymin = xs.min(), ys.min()
    xmax, ymax = xs.max() + 1, ys.max() + 1
    if (xmin, ymin, xmax, ymax) != tuple(int(v) for v in bboxes[idx]):
        raise ValueError(f"{m}. id és doboz nem konzisztens")

semantic = (instance_ids > 0).astype(np.uint8)
expected = {
    "input_shape": [H, W],
    "instance_count": int(instance_ids.max()),
    "foreground_pixels": int(semantic.sum()),
    "foreground_ratio": float(semantic.mean()),
    "bbox_areas": [int((x2 - x1) * (y2 - y1))
                   for x1, y1, x2, y2 in bboxes.tolist()],
    "labels": labels.tolist(),
}
print(json.dumps(expected, indent=2))

A kód által kiírandó, számított érték: foreground_pixels=14, foreground_ratio=0.21875, instance_count=2, a dobozterületek $3\cdot 2=6$ és $4\cdot 2=8$. Mivel ez a labor szintetikus annotáció, nem mérés; a kimenet a fenti mátrixokból számolható. Ha a hallgató lefuttatja, a numerikus egyezés int-re pontos.

27.4.7 Feladatok

F1 (fogalmi, nehézség 1). Adjon három, egymástól eltérő tulajdonságot, amelyben a szemantikus és az instance szegmentálás szerződése különbözik. Átadandó: egy-egy rövid mondat és egy legalább $2\times2$-es ellenpélda, ahol ugyanaz a pixelcímke két különböző példányszámot enged meg.

F2 (levezetési, nehézség 2). Adjon $4\times4$-es bináris szemantikus maszkot és hozzá legalább három különböző, összefüggő instance-felosztást. Igazolja mindháromra az $\mathbf 1[A_{\text{inst}}>0]=M_{\text{sem}}$ egyenlőséget, és mutassa meg, hogy a felosztások nem vihetők egymásba pusztán id-permutációval. Átadandó: három id-mátrix, a permutáció-érv magyarázata.

F3 (implementációs, nehézség 2). Írjon függvényt instance_to_semantic_and_bboxes(ids) néven, amely egy (H, W) int64 id-mátrixból előállítja a bináris szemantikus maszkot (uint8) és példányonként a legszűkebb xyxy dobozokat (M, 4) float32 tömbben. Kezelje az üres képet: ekkor a doboz alakja (0, 4) legyen. Ellenőrizze a labor $8\times8$-as mintáján és üres bemeneten. Átadandó: futtatható függvény, hívás, várt és kapott shape.

F4 (hibakeresési, nehézség 2). Az alábbi hibás függvény „instance AP”-nek nevezi az összes predikció–ground-truth pár IoU-jának átlagát, matching nélkül:

def wrong_instance_ap(preds, gts):
    vals = []
    for p in preds:
        for g in gts:
            vals.append(iou(p, g))
    return float(np.mean(vals)) if vals else 0.0

Mutassa meg a merge-példán ($\text{preds}=[g_1\cup g_2]$, $\text{gts}=[g_1,g_2]$), hogy ez elfedi az FN-t. Adja meg a helyes greedy, egy-az-egyhez illesztés lényegét, és írja át a függvényt. Átadandó: a hiba oka, a hibás érték, a javított kód és a küszöb szerepe.

F5 (kísérlettervezési, nehézség 3). A GlyphLab jelenleg osztályozási annotáció, nem instance target. Tervezzen protokollt olyan kétértelmű esetre, ahol két, azonos osztályú, egymással érintkező alakzatot kell külön példányként címkézni. Rögzítse a megfigyelési egységet, az annotációs szabályt, a splitegységet, a metrikát és a baseline-t. Átadandó: egy protokollterv, benne a következtetés érvényességi korlátja, például hogy a szintetikus adat nem klinikai validáció.

27.4.8 Megoldások és indoklás

F1. A három különbség: (1) a szemantikus kimenet osztálycímke pixelenként, az instance kimenet példányazonosító; (2) a szemantikus kiértékelés pixel-IoU/Dice, az instance kiértékelés példányszintű maszk-IoU matching; (3) a szemantikus cél fix $H\times W$ tensor, az instance cél változó példányszámú, ezért listaszerű szerződést igényel. A $2\times3$-as ellenpélda a fenti lemma: az egybefüggő $M_{\text{sem}}$ lehet $4+2$ vagy $2+4$ példány.

F2. $4\times4$-es szemantikus előtér:

1 1 0 0
1 1 0 0
0 0 0 0
0 0 0 0

Három felosztás:

A1:              A2:              A3:
1 1 0 0          1 2 0 0          1 1 0 0
1 1 0 0          1 2 0 0          2 2 0 0
0 0 0 0          0 0 0 0          0 0 0 0
0 0 0 0          0 0 0 0          0 0 0 0

Az $A_1$ egyetlen példány, $A_2$ két függőleges sáv, $A_3$ két vízszintes sáv. Mindháromnál $\mathbf 1[A_r>0]=M_{\text{sem}}$. $A_2$-t és $A_3$-t id-permutáció sem viheti egymásba, mert a példányok mérete $2$–$2$ pixel mindkettőben, de geometriai szomszédságuk eltér: előbbiben oszlopok, utóbbiban sorok alkotják a példányokat. Továbbá $A_1$ példányszáma egy, míg a többieké kettő, ami definíció szerint nem permutáció.

F3. A függvény:

import numpy as np

def instance_to_semantic_and_bboxes(ids):
    if ids.dtype != np.int64:
        raise TypeError("ids legyen int64")
    semantic = (ids > 0).astype(np.uint8)
    bboxes = np.empty((0, 4), dtype=np.float32)
    for m in np.unique(ids[ids > 0]):
        ys, xs = np.where(ids == m)
        xmin, ymin = xs.min(), ys.min()
        xmax, ymax = xs.max() + 1, ys.max() + 1
        bboxes = np.vstack([bboxes, [xmin, ymin, xmax, ymax]])
    return semantic, bboxes

A labor mintáján semantic.sum()==14, bboxes.shape==(2,4). Üres bemenetre np.unique(np.array([], dtype=np.int64)) üres, a ciklus nem fut le, bboxes.shape==(0,4), semantic.sum()==0. A dobozok egész pixelhatárokból származnak, ezért egzakt egyezés várható; lebegőpontos tolerancia nem szükséges.

F4. A hiba oka, hogy a függvény minden predikció–GT párt átlagol, ezért nincs egy-az-egyhez illesztés, és egy predikció több ground truth példányhoz is hozzájárulhat. A merge-példán: $\text{gts}=[g_1,g_2]$, $\text{pred}=[g_1\cup g_2]$, az IoU-k $[0{,}5,0{,}5]$, a hibás érték $0{,}5$, miközben $\tau>0{,}5$ mellett a predikció FP, az igazi AP $0$. A javítás: rendezés confidence szerint, minden predikciót csak a még nem illesztett GT-khez engedünk, a maximális IoU-t választjuk, és csak $\ge\tau$ esetén számolunk TP-t. Ellenőrzés: a merge-példán a javított kód $0$ AP-t ad; két különálló, jól illeszkedő predikciónál $1$-et.

F5. Egy lehetséges protokoll: két érintkező, azonos osztályú négyzetet generálunk $24\times24$-es képen, a két példány egyetlen $2$ pixel széles érintkezési sávval. A megfigyelési egység a scene_id; ugyanaz a scene minden nézete azonos splitbe kerül. Az annotációs szabály: az érintkezési sávot a generátor oldalán ismert instance id-kből származtatjuk, nem emberi rajzból. A metrika instance AP $\tau=0{,}5$ maszk-IoU-val; a baseline a [P14]-típusú U-Net-szemantikus kimenet küszöbölése, amely merge esetén alacsony AP-t vár. A split 120/30/30 scene, class-stratified. Érvényességi korlát: a szintetikus geometria szabályos, ezért az eredmény nem terjeszthető ki természetes, elzárt objektumokra vagy magas tétű alkalmazásra; a cél a mérőszám érzékenységének bemutatása.

27.4.9 Tipikus tévedés és ellenpélda

A példányszám és az előtérpixel-arány nem felcserélhető target. Legyen a $8\times8$-as képen egyszer $M=1$, egyetlen $2\times3$-as folt: az előtérarány $6/64=0{,}09375$. Máskor hat darab $1$ pixeles folt: a példányszám $M=6$, az előtérarány ugyancsak $6/64=0{,}09375$. Ha a modell a foreground arányt regresszálja, vagy a veszteség csak a szemantikus maszkot bünteti, akkor nem tudja a két annotációt megkülönböztetni. Az instance-feladat tehát külön célfejet és külön metrikát igényel; a pixelarány legfeljebb az előtér mennyiségét írja le, a példányok számát nem.

27.4.10 Önellenőrzés és visszahívás

Ellenőrző kérdések: meg tudja-e adni a $4+2$ és $2+4$ felosztást úgy, hogy minden id-osztály összefüggő legyen? A doboz fél-nyílt értelmezését használja-e a labor? Az üres predikció TP-ként van-e kezelve az instance AP-ben? A 27.3. Dice, IoU és aggregálás alfejezetből visszahívás: a globális Dice/IoU nem példányszintű; az üres-üres esetet explicit szabálynak kell rögzítenie. A 26.4. Detektálási pipeline és hibaelemzés alfejezetből: az üres cél $M=0$ állapot, és a doboztranszformáció a képpel szinkronban történik. A 23.4. Hibaszeletek és alkalmazási határ alfejezetből: az összesített metrika elrejtheti a merge hibát. A 15.4. Független gradiensellenőrzési protokoll alfejezetből: a maszkküszöb nem sima művelet, ezért a veszteséget a logiton számoljuk, a küszöb csak kiértékelési döntés.

27.4.11 Rövid összefoglaló

A szemantikus szegmentálás minden pixelhez osztálycímkét rendel, az instance szegmentálás ezen túl az azonos osztályú objektumokat is külön példányokra bontja. Megmutattuk, hogy ugyanaz a bináris szemantikus maszk több különböző, összefüggő instance-felosztást enged, ezért az instance-annotáció nem vezethető le a pixelcímkéből. A Mask R-CNN a detektálási fej ROI-it párhuzamos maszkággal egészíti ki. Az instance AP a predikciókat greedy, egy-az-egyhez maszk-IoU-küszöbbel illeszti a ground truth-hoz; a merge hiba magas pixel-IoU mellett is elrejtőzhet. A labor kétobjektumos annotációs mintát és input/output szerződést ad, üres cél kezelésével.

27.4.12 Következő alkalmazás

A 28.1. Embedding, távolság és normalizálás egység a metrikus tanulásba lép: az instance-azonosság itt bevezetett gondolata ahhoz kapcsolódik, hogyan lehet példányok közötti távolságot reprezentációból tanulni, ha pixelmaszk nem áll rendelkezésre.

27.4.13 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.
• [P15] He, K. et al. (2017). Mask R-CNN. arXiv:1703.06870. https://arxiv.org/abs/1703.06870.
• [D18] PyTorch contributors (online). TorchVision Object Detection Finetuning Tutorial. https://docs.pytorch.org/tutorials/intermediate/torchvision_tutorial.html.