"""Networks. get_unet : MONAI 3D U-Net for Stage-1 semantic segmentation. ImplicitNet : Stage-2 core. A 3D CNN encoder turns the ROI into a feature grid; a coordinate MLP, conditioned on (position, interpolated feature, per-instance latent code z), predicts TWO signed distances (tooth outer surface, canal inner surface). """ import torch import torch.nn as nn import torch.nn.functional as F def trilinear_sample_feat(feat, p): """Hand-written differentiable trilinear sampling on a feature volume. feat: [B, C, X, Y, Z] (channel-first, axis order x,y,z) p : [B, N, 3] normalized coords in [-1, 1] in (x, y, z) order Returns: [B, N, C]. Supports second-order autograd on `p`, which PyTorch's grid_sample does not (grid_sampler_3d_backward has no derivative). Out-of-bounds samples are clamped to the border. """ B, C, X, Y, Z = feat.shape sizes = torch.tensor([X, Y, Z], device=p.device, dtype=p.dtype) # map [-1,1] -> [0, size-1] px = (p + 1.0) * 0.5 * (sizes - 1) # [B, N, 3] px = torch.stack([px[..., k].clamp(0, sizes[k] - 1) for k in range(3)], -1) x0 = px[..., 0].floor(); x1 = (x0 + 1).clamp(max=X - 1) y0 = px[..., 1].floor(); y1 = (y0 + 1).clamp(max=Y - 1) z0 = px[..., 2].floor(); z1 = (z0 + 1).clamp(max=Z - 1) xd = (px[..., 0] - x0).unsqueeze(-1) yd = (px[..., 1] - y0).unsqueeze(-1) zd = (px[..., 2] - z0).unsqueeze(-1) x0i, x1i = x0.long(), x1.long() y0i, y1i = y0.long(), y1.long() z0i, z1i = z0.long(), z1.long() # gather corners: [B, N, C] each feat_flat = feat.permute(0, 2, 3, 4, 1).contiguous() # [B, X, Y, Z, C] bidx = torch.arange(B, device=p.device).view(B, 1).expand(-1, p.shape[1]) def g(xi, yi, zi): return feat_flat[bidx, xi, yi, zi] # [B, N, C] c00 = g(x0i, y0i, z0i) * (1 - xd) + g(x1i, y0i, z0i) * xd c01 = g(x0i, y0i, z1i) * (1 - xd) + g(x1i, y0i, z1i) * xd c10 = g(x0i, y1i, z0i) * (1 - xd) + g(x1i, y1i, z0i) * xd c11 = g(x0i, y1i, z1i) * (1 - xd) + g(x1i, y1i, z1i) * xd c0 = c00 * (1 - yd) + c10 * yd c1 = c01 * (1 - yd) + c11 * yd return c0 * (1 - zd) + c1 * zd # [B, N, C] def get_unet(num_classes=3, channels=(16, 32, 64, 128, 256)): from monai.networks.nets import UNet return UNet( spatial_dims=3, in_channels=1, out_channels=num_classes, channels=channels, strides=(2,) * (len(channels) - 1), num_res_units=2, norm="instance", ) class Encoder3D(nn.Module): """U-Net-style ROI encoder producing TWO feature grids: - feat_fine : high-resolution (1/2 of input) -> preserves local canal detail - feat_coarse: low-resolution (1/8 of input) -> global tooth context Per-point queries sample BOTH (ConvONet-style local implicit features), so thin structures keep their detail instead of being averaged into one global vector.""" def __init__(self, ch=(32, 64, 128), feat_dim=64): super().__init__() c1, c2, c3 = ch # encoder (downsampling) self.e0 = nn.Sequential(nn.Conv3d(1, c1, 3, padding=1), nn.GroupNorm(8, c1), nn.SiLU(), nn.Conv3d(c1, c1, 3, padding=1), nn.GroupNorm(8, c1), nn.SiLU()) self.d1 = nn.Conv3d(c1, c1, 3, stride=2, padding=1) self.e1 = nn.Sequential(nn.Conv3d(c1, c2, 3, padding=1), nn.GroupNorm(8, c2), nn.SiLU(), nn.Conv3d(c2, c2, 3, padding=1), nn.GroupNorm(8, c2), nn.SiLU()) self.d2 = nn.Conv3d(c2, c2, 3, stride=2, padding=1) self.e2 = nn.Sequential(nn.Conv3d(c2, c3, 3, padding=1), nn.GroupNorm(8, c3), nn.SiLU(), nn.Conv3d(c3, c3, 3, padding=1), nn.GroupNorm(8, c3), nn.SiLU()) self.d3 = nn.Conv3d(c3, c3, 3, stride=2, padding=1) self.bott = nn.Sequential(nn.Conv3d(c3, c3, 3, padding=1), nn.GroupNorm(8, c3), nn.SiLU()) # heads: fine grid at 1/2 res (from e0 after one downsample skip), coarse at 1/8 self.head_fine = nn.Conv3d(c1, feat_dim, 1) # at 1/2 input res self.head_coarse = nn.Conv3d(c3, feat_dim, 1) # at 1/8 input res self.feat_dim = feat_dim def forward(self, x): h0 = self.e0(x) # [B,c1, V, V, V] (full res) h1 = self.e1(self.d1(h0)) # [B,c2, V/2,...] h2 = self.e2(self.d2(h1)) # [B,c3, V/4,...] hb = self.bott(self.d3(h2)) # [B,c3, V/8,...] # fine feature grid: downsample h0 once to 1/2 res to keep memory sane but local fine = self.head_fine(F.avg_pool3d(h0, 2)) # [B,feat, V/2,...] coarse = self.head_coarse(hb) # [B,feat, V/8,...] return fine, coarse class ImplicitDecoder(nn.Module): def __init__(self, feat_dim=64, latent_dim=64, hidden=256, layers=5): super().__init__() # input = coords(3) + fine_feat + coarse_feat + global_latent in_dim = 3 + feat_dim + feat_dim + latent_dim net = [nn.Linear(in_dim, hidden), nn.SiLU()] for _ in range(layers - 2): net += [nn.Linear(hidden, hidden), nn.SiLU()] self.backbone = nn.Sequential(*net) self.out = nn.Linear(hidden, 2) # tooth sdf, canal sdf def forward(self, feats): return self.out(self.backbone(feats)) # [..., 2] class ImplicitNet(nn.Module): def __init__(self, num_instances, cfg): super().__init__() s2 = cfg["stage2"] self.feat_dim = s2["feat_dim"] self.latent_dim = s2["latent_dim"] self.encoder = Encoder3D(tuple(s2["enc_channels"]), self.feat_dim) self.decoder = ImplicitDecoder(self.feat_dim, self.latent_dim, s2["mlp_hidden"], s2["mlp_layers"]) self.latents = nn.Embedding(max(num_instances, 1), self.latent_dim) nn.init.normal_(self.latents.weight, 0.0, 0.01) # P1-6: predict a latent from the ROI feature grid so new (test) cases get a # latent from the image alone -- no GT, no per-instance table lookup needed. self.use_encoder_latent = bool(s2.get("encoder_latent", False)) if self.use_encoder_latent: self.latent_head = nn.Sequential( nn.AdaptiveAvgPool3d(1), nn.Flatten(), nn.Linear(self.feat_dim, self.latent_dim)) def encode(self, roi): # returns (fine_grid, coarse_grid) return self.encoder(roi) def latent_from_feat(self, feat, gid=None): """Global latent (now just CONTEXT, secondary to local features). Pooled from the coarse grid. With encoder_latent on, predicted from the image alone.""" fine, coarse = feat if self.use_encoder_latent: z = self.latent_head(coarse) if gid is not None and self.training: z = z + self.latents(gid) return z return self.latents(gid) def query(self, feat, coords_mm, half_mm, z, compute_grad=False): """feat: (fine_grid, coarse_grid). For each query point we trilinearly sample BOTH grids -> local detail (fine) + global context (coarse), concat with the global latent z. This is the ConvONet-style local-implicit decode that keeps thin canal detail instead of averaging it into one global vector.""" fine, coarse = feat B, N = coords_mm.shape[0], coords_mm.shape[1] if compute_grad: coords_mm = coords_mm.clone().requires_grad_(True) if torch.is_tensor(half_mm): half = half_mm.view(B, 1, 1) else: half = half_mm p = coords_mm / half # ~[-1,1] f_fine = trilinear_sample_feat(fine, p) # [B,N,feat] local detail f_coarse = trilinear_sample_feat(coarse, p) # [B,N,feat] context zexp = z[:, None, :].expand(-1, N, -1) inp = torch.cat([p, f_fine, f_coarse, zexp], dim=-1) sdf = self.decoder(inp) grads = None if compute_grad: grads = {} for k, name in [(0, "tooth"), (1, "canal")]: g = torch.autograd.grad( sdf[..., k].sum(), coords_mm, create_graph=self.training, retain_graph=True)[0] grads[name] = g return sdf, grads def forward(self, roi, gid, coords_mm, half_mm, compute_grad=False): feat = self.encode(roi) z = self.latent_from_feat(feat, gid) return self.query(feat, coords_mm, half_mm, z, compute_grad)