File size: 5,010 Bytes
8fca640
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
"""Optional training-only ordinal interval supervision from coded boundaries.

The boundary objective keeps every original valid source target. Auxiliary
intervals are defined only in columns whose necessary boundaries are valid and
ordered. This auxiliary support is never used by reference conversion/scoring.
"""

import torch
from torch import nn
from torch.nn import functional as F
from src.models.unet import BoundaryNet

ORDERS = {
    "heidelberg_spectralis": [
        "SCT_280677004",
        "DCM_128289",
        "DCM_128290",
        "DCM_128291",
        "DCM_128292",
        "DCM_128293",
        "SCT_76710003",
        "DCM_128321",
        "DCM_128323",
        "DCM_128297",
        "DCM_128300",
    ],
    "topcon_maestro2": [
        "SCT_280677004",
        "DCM_128289",
        "DCM_128290",
        "DCM_128291",
        "DCM_128293",
        "SCT_76710003",
        "DCM_128320",
        "DCM_128297",
        "DCM_128299",
    ],
    "topcon_triton": [
        "SCT_280677004",
        "DCM_128289",
        "DCM_128290",
        "DCM_128291",
        "DCM_128293",
        "SCT_76710003",
        "DCM_128320",
        "DCM_128297",
        "DCM_128299",
        "DCM_128301",
    ],
    "zeiss_cirrus": ["SCT_280677004", "DCM_128298"],
}


def configure_auxiliary(config):
    from src.models import output_indices

    if config.get("input_channels", 1) != 1 or config.get("head_mode") != "device":
        raise ValueError(
            "This auxiliary experiment requires single-channel device heads"
        )
    mapping = {}
    names = []
    for device, keys in sorted(config["device_keys"].items()):
        order = ORDERS[device]
        if set(keys) != set(order):
            raise ValueError("Unreviewed auxiliary boundary vocabulary")
        indices = output_indices(config, device)
        ordered = [indices[keys.index(key)] for key in order]
        regions = list(range(len(names), len(names) + len(order) + 1))
        intervals = (
            ["above_" + order[0]]
            + [a + "__to__" + b for a, b in zip(order[:-1], order[1:])]
            + ["below_" + order[-1]]
        )
        names.extend(device + "::" + interval for interval in intervals)
        mapping[device] = {"boundary_indices": ordered, "region_indices": regions}
    config["auxiliary_mapping"] = mapping
    config["auxiliary_region_names"] = names
    return config


class AuxiliaryBoundaryNet(BoundaryNet):
    def __init__(self, n_boundaries, base, height, n_regions):
        super().__init__(n_boundaries, base)
        self.axial_prior = nn.Parameter(torch.zeros(1, n_boundaries, height, 1))
        self.auxiliary_head = nn.Conv2d(base, n_regions, 1)
        nn.init.zeros_(self.auxiliary_head.weight)
        nn.init.zeros_(self.auxiliary_head.bias)

    def forward(self, image, return_aux=False):
        x = image
        skips = []
        for index, layer in enumerate(self.down):
            if index:
                x = F.avg_pool2d(x, 2)
            x = layer(x)
            skips.append(x)
        for index, layer in enumerate(self.up):
            skip = skips[-2 - index]
            x = F.interpolate(
                x, size=skip.shape[-2:], mode="bilinear", align_corners=False
            )
            x = layer(torch.cat([x, skip], 1))
        prior = self.axial_prior
        if prior.shape[-2] != x.shape[-2]:
            prior = F.interpolate(
                prior, size=(x.shape[-2], 1), mode="bilinear", align_corners=False
            )
        boundary = self.head(x) + prior
        return (boundary, self.auxiliary_head(x)) if return_aux else boundary


def interval_targets(positions, valid, height):
    """Integer ordinal interval labels plus an independent auxiliary-column mask."""
    support = valid.all(1) & (positions[:, 1:] >= positions[:, :-1]).all(1)
    rows = torch.arange(height, device=positions.device, dtype=positions.dtype)[
        None, None, :, None
    ]
    target = (rows >= positions[:, :, None, :]).sum(1)
    return target, support


def auxiliary_loss(logits, positions, valid, config):
    n, _, height, width = logits.shape
    per_image = logits.float().flatten(1).sum(1) * 0
    for mapping in config["auxiliary_mapping"].values():
        indices = mapping["boundary_indices"]
        regions = mapping["region_indices"]
        target, columns = interval_targets(
            positions[:, indices], valid[:, indices], height
        )
        support = columns[:, None, :].expand(-1, height, -1).float()
        ce = F.cross_entropy(logits[:, regions].float(), target, reduction="none")
        count = logits.new_zeros((n, len(regions)), dtype=torch.float32)
        count.scatter_add_(1, target.flatten(1), support.flatten(1))
        denominator = (
            count.gather(1, target.flatten(1)).reshape(n, height, width).clamp_min(1)
        )
        per_image = per_image + (ce * support / denominator).sum((1, 2)) / (
            count > 0
        ).sum(1).clamp_min(1)
    return per_image.mean()