Download code/model/utils.py from unknownBrain/survivalanalysis_checkpointing: direct link, hf CLI and curl.
- Browser
- Download file 20.3 kB
-
https://huggingface.co/datasets/unknownBrain/survivalanalysis_checkpointing/resolve/232c308b8fdb813d8a0332da1206d7ea2a13014f/code/model/utils.py
- Command line
-
hf download hf://datasets/unknownBrain/survivalanalysis_checkpointing@232c308b8fdb813d8a0332da1206d7ea2a13014f/code/model/utils.py
-
curl -L -o utils.py https://huggingface.co/datasets/unknownBrain/survivalanalysis_checkpointing/resolve/232c308b8fdb813d8a0332da1206d7ea2a13014f/code/model/utils.py
20.3 kB
| import torch | |
| import torch.nn as nn | |
| from torch.nn import functional as F | |
| # LMCL [CosFace: Large Margin Cosine Loss for Deep Face Recognition] | |
| class MarginLoss(nn.Module): | |
| def __init__(self, in_features, out_features, s=64.0, m=0.50): | |
| super(MarginLoss, self).__init__() | |
| self.embedding_size = in_features | |
| self.num_classes = out_features | |
| self.s = s | |
| self.m = m | |
| self.weights = nn.Parameter(torch.Tensor(out_features, in_features)) | |
| nn.init.kaiming_normal_(self.weights) | |
| def forward(self, embedding, label): | |
| assert embedding.size(1) == self.embedding_size, 'embedding size wrong' | |
| logits = F.linear(F.normalize(embedding), F.normalize(self.weights)) | |
| margin = torch.zeros_like(logits) | |
| margin.scatter_(1, label.view(-1, 1), self.m) | |
| m_logits = self.s * (logits - margin) | |
| return m_logits | |
| def predict(self, input): | |
| with torch.no_grad(): | |
| return F.linear(F.normalize(input), F.normalize(self.weights)) | |
| class ChannelAttention_3D(nn.Module): | |
| """ | |
| Implements channel-wise attention for 3D feature maps. | |
| """ | |
| def __init__(self, channel, reduction=4, min_channel=32, unsqueeze=True): | |
| """ | |
| Initializes the ChannelAttention_3D module. | |
| Args: | |
| channel (int): Number of input channels. | |
| reduction (int, optional): Reduction ratio for channel dimensions. Default is 4. | |
| min_channel (int, optional): Minimum number of channels after reduction. Default is 32. | |
| unsqueeze (bool, optional): Whether to expand the output to match input dimensions. Default is True. | |
| """ | |
| super().__init__() | |
| # Calculate the number of channels after reduction, ensuring it doesn't go below min_channel | |
| attention_channel = max(int(channel // reduction), min_channel) | |
| self.unsqueeze = unsqueeze | |
| # Adaptive pooling to generate a single value per channel (global pooling) | |
| self.maxpool = nn.AdaptiveMaxPool3d(1) | |
| self.avgpool = nn.AdaptiveAvgPool3d(1) | |
| # Sequential layers for channel attention mechanism | |
| self.se = nn.Sequential( | |
| nn.Conv3d(channel, attention_channel, kernel_size=1, bias=False), | |
| nn.BatchNorm3d(attention_channel), | |
| nn.ReLU(), | |
| nn.Conv3d(attention_channel, channel, kernel_size=1, bias=False) | |
| ) | |
| # Sigmoid activation to obtain attention weights between 0 and 1 | |
| self.sigmoid = nn.Sigmoid() | |
| def forward(self, x): | |
| """ | |
| Forward pass for channel attention. | |
| Args: | |
| x (torch.Tensor): Input tensor of shape (batch, channel, D, H, W). | |
| Returns: | |
| torch.Tensor: Attention weights of shape (batch, channel, D, H, W) if unsqueeze is True, | |
| else (batch, channel, 1, 1, 1). | |
| """ | |
| # Apply max and average pooling | |
| max_result = self.maxpool(x) | |
| avg_result = self.avgpool(x) | |
| # Pass pooled results through the attention network | |
| max_out = self.se(max_result) | |
| avg_out = self.se(avg_result) | |
| # Combine the outputs and apply sigmoid activation | |
| output = self.sigmoid(max_out + avg_out) | |
| # Optionally expand the attention weights to match the input dimensions | |
| if self.unsqueeze: | |
| output = output.expand_as(x) | |
| # Ensure contiguous memory layout | |
| return output.contiguous() | |
| class SpatialAttention_3D(nn.Module): | |
| """ | |
| Implements spatial attention for 3D feature maps. | |
| """ | |
| def __init__(self, kernel_size=7, unsqueeze=True): | |
| """ | |
| Initializes the SpatialAttention_3D module. | |
| Args: | |
| kernel_size (int, optional): Kernel size for the convolutional layer. Default is 7. | |
| unsqueeze (bool, optional): Whether to expand the output to match input dimensions. Default is True. | |
| """ | |
| super().__init__() | |
| self.unsqueeze = unsqueeze | |
| # Convolution to compute spatial attention; input has 2 channels (max and avg), output has 1 channel | |
| self.conv = nn.Conv3d(2, 1, kernel_size=kernel_size, padding=kernel_size // 2) | |
| # Sigmoid activation to obtain attention weights between 0 and 1 | |
| self.sigmoid = nn.Sigmoid() | |
| def forward(self, x): | |
| """ | |
| Forward pass for spatial attention. | |
| Args: | |
| x (torch.Tensor): Input tensor of shape (batch, channels, D, H, W). | |
| Returns: | |
| torch.Tensor: Attention weights of shape (batch, channels, D, H, W) if unsqueeze is True, | |
| else (batch, 1, D, H, W). | |
| """ | |
| # Compute the maximum value across the channel dimension | |
| max_result, _ = torch.max(x, dim=1, keepdim=True) | |
| # Compute the average value across the channel dimension | |
| avg_result = torch.mean(x, dim=1, keepdim=True) | |
| # Concatenate along the channel dimension to form a 2-channel tensor | |
| result = torch.cat([max_result, avg_result], dim=1) | |
| # Apply convolution and sigmoid activation to obtain spatial attention | |
| output = self.conv(result) | |
| output = self.sigmoid(output) | |
| # Optionally expand the attention weights to match the input dimensions | |
| if self.unsqueeze: | |
| output = output.expand_as(x) | |
| # Ensure contiguous memory layout | |
| return output.contiguous() | |
| class UCFCFusion(nn.Module): | |
| """ | |
| Implements a fusion module that integrates multiple feature maps using channel and spatial attention. | |
| """ | |
| def __init__(self, channel, ochannel, fusion_num, img_size=[4, 4, 4], L=32, reduction_ca=4, reduction_sa=64): | |
| """ | |
| Initializes the UCFCFusion module. | |
| Args: | |
| channel (int): Number of input channels per feature map. | |
| ochannel (int): Number of output channels after fusion. | |
| fusion_num (int): Number of feature maps to fuse. | |
| img_size (list, optional): Spatial dimensions [D, H, W] of the input feature maps. Default is [4, 4, 4]. | |
| L (int, optional): Base dimension for linear layers. Default is 32. | |
| reduction_ca (int, optional): Reduction ratio for channel attention. Default is 4. | |
| reduction_sa (int, optional): Reduction ratio for spatial attention. Default is 64. | |
| """ | |
| super(UCFCFusion, self).__init__() | |
| self.img_size = img_size | |
| in_planes = channel * fusion_num # Total input channels after concatenation | |
| out_planes = channel # Desired output channels | |
| # Convolution layers for projecting input and fused features | |
| self.proj = nn.Conv3d(in_planes, ochannel, kernel_size=3, stride=1, padding=1, bias=False) | |
| self.projf = nn.Conv3d(out_planes, ochannel, kernel_size=3, stride=1, padding=1, bias=False) | |
| # Channel and Spatial attention mechanisms applied to the summed feature maps | |
| self.channel_F_W = ChannelAttention_3D(out_planes, unsqueeze=False) | |
| self.spatial_F_W = SpatialAttention_3D(unsqueeze=False) | |
| self.fusion_num = fusion_num | |
| # Dimension for channel attention processing | |
| self.d = max(L, in_planes // reduction_ca) | |
| # Dimension for spatial attention processing | |
| self.dsa = max(L * 2, | |
| (self.img_size[0] * self.img_size[1] * self.img_size[2]) // reduction_sa) | |
| # Fully connected layers for processing attention outputs | |
| self.fc = nn.Linear(out_planes, self.d) | |
| self.fc2 = nn.Linear(self.img_size[0] * self.img_size[1] * self.img_size[2], self.dsa) | |
| # Lists of linear layers for each fusion path | |
| self.fcas = nn.ModuleList([]) | |
| self.fsas = nn.ModuleList([]) | |
| for _ in range(fusion_num): | |
| self.fcas.append(nn.Linear(self.d, out_planes)) | |
| self.fsas.append(nn.Linear(self.dsa, self.img_size[0] * self.img_size[1] * self.img_size[2])) | |
| # Softmax layer to normalize fusion weights across different fusion paths | |
| self.softmax = nn.Softmax(dim=0) | |
| # Initialize weights of convolutional and batch normalization layers | |
| self._initialize_weights() | |
| def _initialize_weights(self): | |
| """ | |
| Initializes the weights of convolutional and batch normalization layers. | |
| """ | |
| for m in self.modules(): | |
| if isinstance(m, nn.Conv3d): | |
| # Initialize Conv3d weights with Kaiming Normal and biases to zero if present | |
| nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') | |
| if m.bias is not None: | |
| nn.init.constant_(m.bias, 0) | |
| elif isinstance(m, nn.BatchNorm3d): | |
| # Initialize BatchNorm3d weights to 1 and biases to zero | |
| nn.init.constant_(m.weight, 1) | |
| nn.init.constant_(m.bias, 0) | |
| def get_fusion_w(self, x_F, ca_out, sa_out): | |
| """ | |
| Computes fusion weights based on channel and spatial attention outputs. | |
| Args: | |
| x_F (torch.Tensor): Summed feature maps of shape (batch, channels, D, H, W). | |
| ca_out (torch.Tensor): Channel attention output of shape (batch, channels, 1, 1, 1). | |
| sa_out (torch.Tensor): Spatial attention output of shape (batch, 1, D, H, W). | |
| Returns: | |
| tuple: | |
| - weights_ca (torch.Tensor): Channel-wise weights for each fusion path. | |
| - weights_sa (torch.Tensor): Spatial-wise weights for each fusion path. | |
| """ | |
| b, c, w, h, l = x_F.size() | |
| weights_ca = [] | |
| # Process channel attention output through a fully connected layer | |
| ca_out_p = self.fc(ca_out.view(b, c)) # Shape: (batch, d) | |
| for fca in self.fcas: | |
| # Compute channel weights for each fusion path | |
| weight = fca(ca_out_p) # Shape: (batch, out_planes) | |
| weights_ca.append(weight.view(b, c, 1, 1, 1)) # Reshape for broadcasting | |
| # Stack channel weights across fusion paths | |
| weights_ca = torch.stack(weights_ca, dim=0) # Shape: (fusion_num, batch, channels, 1, 1, 1) | |
| # Process spatial attention output through a fully connected layer | |
| sa_out_fc = self.fc2(sa_out.view(b, w * h * l)) # Shape: (batch, dsa) | |
| weights_sa = [] | |
| for fsa in self.fsas: | |
| # Compute spatial weights for each fusion path | |
| weight = fsa(sa_out_fc) # Shape: (batch, D*H*W) | |
| weights_sa.append(weight.view(b, 1, w, h, l)) # Reshape for broadcasting | |
| # Stack spatial weights across fusion paths | |
| weights_sa = torch.stack(weights_sa, dim=0) # Shape: (fusion_num, batch, 1, D, H, W) | |
| return weights_ca, weights_sa | |
| def forward(self, I_IN): | |
| """ | |
| Forward pass for the UCFCFusion module. | |
| Args: | |
| I_IN (torch.Tensor): Input tensor of shape (batch, channel * fusion_num, D, H, W). | |
| Returns: | |
| torch.Tensor: Fused output tensor of shape (batch, ochannel, D, H, W). | |
| """ | |
| # Split the input tensor into 'fusion_num' parts along the channel dimension | |
| split_I_IN_F = torch.chunk(I_IN, self.fusion_num, dim=1) # Tuple of tensors | |
| # Stack the split tensors to form a new dimension for fusion paths | |
| split_I_IN_F = torch.stack(split_I_IN_F, dim=0) # Shape: (fusion_num, batch, channel, D, H, W) | |
| # Sum the feature maps across all fusion paths | |
| Sum_I_IN_F = split_I_IN_F.sum(dim=0) # Shape: (batch, channel, D, H, W) | |
| # Apply channel and spatial attention to the summed feature maps | |
| channel_F_W = self.channel_F_W(Sum_I_IN_F) # Shape: (batch, channel, 1, 1, 1) | |
| spatial_F_W = self.spatial_F_W(Sum_I_IN_F) # Shape: (batch, 1, D, H, W) | |
| # Compute fusion weights based on attention outputs | |
| weights_ca, weights_sa = self.get_fusion_w(Sum_I_IN_F, channel_F_W, spatial_F_W) | |
| # Combine channel and spatial weights multiplicatively | |
| weights_all_model = weights_ca * weights_sa # Shape: (fusion_num, batch, channel, D, H, W) | |
| # Apply softmax across the fusion paths to normalize the weights | |
| weights_all_model = self.softmax(weights_all_model) # Shape: (fusion_num, batch, channel, D, H, W) | |
| # Apply the weights to each split feature map and sum them | |
| weighted_sum = (split_I_IN_F * weights_all_model).sum(dim=0) # Shape: (batch, channel, D, H, W) | |
| # Project the original input and the weighted sum, then add them together | |
| F_OUT = self.proj(I_IN) + self.projf(weighted_sum) # Shape: (batch, ochannel, D, H, W) | |
| # Ensure contiguous memory layout | |
| return F_OUT.contiguous() | |
| # 渐进分类 | |
| class CFE_refine(nn.Module): | |
| def __init__(self, in_channels=[64, 128, 256, 512, 1024, 1024], factor=1): | |
| super(CFE_refine, self).__init__() | |
| self.block_1 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[0], | |
| out_channels=in_channels[1], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[1]), | |
| nn.ReLU(), | |
| nn.MaxPool3d(kernel_size=3, stride=2, padding=1) | |
| ) | |
| self.block_2 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[1] * 2, | |
| out_channels=in_channels[2], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[2]), | |
| nn.ReLU(), | |
| nn.MaxPool3d(kernel_size=3,stride=2,padding=1) | |
| ) | |
| self.block_3 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[2] * 2, | |
| out_channels=in_channels[3], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[3]), | |
| nn.ReLU(), | |
| nn.MaxPool3d(kernel_size=3,stride=2, padding=1) | |
| ) | |
| self.block_4 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[3] * 2, | |
| out_channels=in_channels[4], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[4]), | |
| nn.ReLU() | |
| ) | |
| self.block_5 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[4] * 2, | |
| out_channels=in_channels[5]//factor, | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[5]), | |
| nn.ReLU() | |
| ) | |
| self.block_6 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[4] * 2, | |
| out_channels=in_channels[5], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[5]//factor), | |
| nn.ReLU() | |
| ) | |
| def forward(self, features_t1, features_t2, features_t3, features_t4, features_t5): | |
| x_t1 = features_t1 | |
| x_t1 = self.block_1(x_t1) | |
| x_t2 = torch.cat((x_t1, features_t2), 1) | |
| x_t2 = self.block_2(x_t2) | |
| x_t3 = torch.cat((x_t2, features_t3), 1) | |
| x_t3 = self.block_3(x_t3) | |
| x_t4 = torch.cat((x_t3, features_t4), 1) | |
| x_t4 = self.block_4(x_t4) | |
| Fc = torch.cat((x_t4, features_t5), 1) | |
| Fs1 = self.block_5(Fc) | |
| Fs2 = self.block_6(Fc) | |
| return Fs1, Fs2 | |
| def getFc(self, features_t1, features_t2, features_t3, features_t4, features_t5): | |
| x_t1 = features_t1 | |
| x_t1 = self.block_1(x_t1) | |
| x_t2 = torch.cat((x_t1, features_t2), 1) | |
| x_t2 = self.block_2(x_t2) | |
| x_t3 = torch.cat((x_t2, features_t3), 1) | |
| x_t3 = self.block_3(x_t3) | |
| x_t4 = torch.cat((x_t3, features_t4), 1) | |
| x_t4 = self.block_4(x_t4) | |
| Fc = torch.cat((x_t4, features_t5), 1) | |
| return Fc | |
| class UFE_E2(nn.Module): | |
| def __init__(self, in_channels=[3, 64, 128, 256, 512, 1024], factor=1): | |
| super(UFE_E2, self).__init__() | |
| # 160, 192, 160 | |
| # 和E1中的第一个卷积一样 | |
| self.block_1 = nn.Sequential( | |
| nn.Conv3d(in_channels[0], | |
| in_channels[1], | |
| kernel_size=7, stride=2, | |
| padding=3, bias=False), | |
| nn.BatchNorm3d(in_channels[1]), | |
| nn.ReLU(), | |
| nn.MaxPool3d(kernel_size=3, stride=2, padding=1) | |
| ) | |
| # 40, 46, 40 | |
| self.block_2 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[1] + 3, | |
| out_channels=in_channels[2], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[2]), | |
| nn.ReLU(), | |
| nn.MaxPool3d(kernel_size=3, stride=2, padding=1) | |
| ) | |
| # 20, 24, 20 | |
| self.block_3 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[2], | |
| out_channels=in_channels[3], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[3]), | |
| nn.ReLU(), | |
| nn.MaxPool3d(kernel_size=3, stride=2, padding=1) | |
| ) | |
| # 10, 12, 10 | |
| self.block_4 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[3], | |
| out_channels=in_channels[4], | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[4]), | |
| nn.ReLU(), | |
| nn.MaxPool3d(kernel_size=3, stride=2, padding=1) | |
| ) | |
| # 5, 6, 5 | |
| self.block_5 = nn.Sequential( | |
| nn.Conv3d(in_channels=in_channels[4], | |
| out_channels=in_channels[5]//factor, | |
| kernel_size=3, | |
| padding=1, | |
| stride=1, | |
| bias=False), | |
| nn.BatchNorm3d(in_channels[5]//factor), | |
| nn.ReLU() | |
| ) | |
| self.activation = nn.ReLU() | |
| def _Projection3D(self, Fl_prime, Fl): | |
| # Get dimensions: batch size (b), channels (c), width (w), height (h), depth (l) | |
| b, c, w, h, l = Fl.size() | |
| # Flatten the spatial dimensions for both features: [b, c, w*h*l] | |
| Fl_prime = Fl_prime.view(b, c, w * h * l) | |
| Fl = Fl.view(b, c, w * h * l) | |
| # Compute the dot product between Fl' and Fl for each batch and channel: numerator of the projection scalar | |
| numerator = torch.sum(Fl_prime * Fl, dim=-1, keepdim=True) | |
| # Compute the dot product of Fl with itself: denominator of the projection scalar | |
| denominator = torch.sum(Fl * Fl, dim=-1, keepdim=True) + 1e-6 # Add epsilon to prevent division by zero | |
| # Calculate the projection scalar and multiply by Fl to get the projection vector | |
| projection = (numerator / denominator) * Fl | |
| # Subtract the projection from Fl' to obtain the component of Fl' orthogonal to Fl | |
| out = Fl_prime - projection | |
| # Reshape the output back to the original spatial dimensions | |
| out = out.view(b, c, w, h, l) | |
| # Apply any additional processing (e.g., activation function) | |
| out = self.activation(out) | |
| return out | |
| def forward(self, input, Fl, condition): | |
| x_t1 = self.block_1(input) | |
| x_t1_proj = self._Projection3D(x_t1, Fl) | |
| condition = F.one_hot(condition.long(), 3) | |
| conditionAdd1 = condition.unsqueeze(-1).unsqueeze(-1).unsqueeze(-1). \ | |
| repeat(1, 1, x_t1_proj.size(2), x_t1_proj.size(3), x_t1_proj.size(4)) | |
| x_t1 = torch.cat((x_t1_proj, conditionAdd1), 1) | |
| x_t2 = self.block_2(x_t1) | |
| x_t3 = self.block_3(x_t2) | |
| x_t4 = self.block_4(x_t3) | |
| Fuhc_prime = self.block_5(x_t4) | |
| return Fuhc_prime | |