Spaces:
Running
Running
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()
|