Download code/model/densenet.py from unknownBrain/survivalanalysis_checkpointing: direct link, hf CLI and curl.
- Browser
- Download file 13.4 kB
-
https://huggingface.co/datasets/unknownBrain/survivalanalysis_checkpointing/resolve/232c308b8fdb813d8a0332da1206d7ea2a13014f/code/model/densenet.py
- Command line
-
hf download hf://datasets/unknownBrain/survivalanalysis_checkpointing@232c308b8fdb813d8a0332da1206d7ea2a13014f/code/model/densenet.py
-
curl -L -o densenet.py https://huggingface.co/datasets/unknownBrain/survivalanalysis_checkpointing/resolve/232c308b8fdb813d8a0332da1206d7ea2a13014f/code/model/densenet.py
13.4 kB
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| import torch.utils.checkpoint as cp | |
| from collections import OrderedDict | |
| from torch import Tensor | |
| from typing import Any, List, Tuple | |
| __all__ = ['DenseNet', 'densenet121', 'densenet169', 'densenet201', 'densenet161'] | |
| class _DenseLayer(nn.Module): | |
| def __init__( | |
| self, | |
| num_input_features: int, | |
| growth_rate: int, | |
| bn_size: int, | |
| drop_rate: float, | |
| memory_efficient: bool = False | |
| ) -> None: | |
| super(_DenseLayer, self).__init__() | |
| self.norm1: nn.BatchNorm3d | |
| self.add_module('norm1', nn.BatchNorm3d(num_input_features)) | |
| self.relu1: nn.ReLU | |
| self.add_module('relu1', nn.ReLU(inplace=True)) | |
| self.conv1: nn.Conv3d | |
| self.add_module('conv1', nn.Conv3d(num_input_features, bn_size * | |
| growth_rate, kernel_size=1, stride=1, | |
| bias=False)) | |
| self.norm2: nn.BatchNorm3d | |
| self.add_module('norm2', nn.BatchNorm3d(bn_size * growth_rate)) | |
| self.relu2: nn.ReLU | |
| self.add_module('relu2', nn.ReLU(inplace=True)) | |
| self.conv2: nn.Conv3d | |
| self.add_module('conv2', nn.Conv3d(bn_size * growth_rate, growth_rate, | |
| kernel_size=3, stride=1, padding=1, | |
| bias=False)) | |
| self.drop_rate = float(drop_rate) | |
| self.memory_efficient = memory_efficient | |
| def bn_function(self, inputs: List[Tensor]) -> Tensor: | |
| concated_features = torch.cat(inputs, 1) | |
| bottleneck_output = self.conv1(self.relu1(self.norm1(concated_features))) # noqa: T484 | |
| return bottleneck_output | |
| # todo: rewrite when torchscript supports any | |
| def any_requires_grad(self, input: List[Tensor]) -> bool: | |
| for tensor in input: | |
| if tensor.requires_grad: | |
| return True | |
| return False | |
| # noqa: T484 | |
| def call_checkpoint_bottleneck(self, input: List[Tensor]) -> Tensor: | |
| def closure(*inputs): | |
| return self.bn_function(inputs) | |
| return cp.checkpoint(closure, *input) | |
| # noqa: F811 | |
| def forward(self, input: List[Tensor]) -> Tensor: | |
| pass | |
| # noqa: F811 | |
| def forward(self, input: Tensor) -> Tensor: | |
| pass | |
| # torchscript does not yet support *args, so we overload method | |
| # allowing it to take either a List[Tensor] or single Tensor | |
| def forward(self, input: Tensor) -> Tensor: # noqa: F811 | |
| if isinstance(input, Tensor): | |
| prev_features = [input] | |
| else: | |
| prev_features = input | |
| if self.memory_efficient and self.any_requires_grad(prev_features): | |
| if torch.jit.is_scripting(): | |
| raise Exception("Memory Efficient not supported in JIT") | |
| bottleneck_output = self.call_checkpoint_bottleneck(prev_features) | |
| else: | |
| bottleneck_output = self.bn_function(prev_features) | |
| new_features = self.conv2(self.relu2(self.norm2(bottleneck_output))) | |
| if self.drop_rate > 0: | |
| new_features = F.dropout(new_features, p=self.drop_rate, | |
| training=self.training) | |
| return new_features | |
| class _DenseBlock(nn.ModuleDict): | |
| _version = 2 | |
| def __init__( | |
| self, | |
| num_layers: int, | |
| num_input_features: int, | |
| bn_size: int, | |
| growth_rate: int, | |
| drop_rate: float, | |
| memory_efficient: bool = False | |
| ) -> None: | |
| super(_DenseBlock, self).__init__() | |
| for i in range(num_layers): | |
| layer = _DenseLayer( | |
| num_input_features + i * growth_rate, | |
| growth_rate=growth_rate, | |
| bn_size=bn_size, | |
| drop_rate=drop_rate, | |
| memory_efficient=memory_efficient, | |
| ) | |
| self.add_module('denselayer%d' % (i + 1), layer) | |
| def forward(self, init_features: Tensor) -> Tensor: | |
| features = [init_features] | |
| for name, layer in self.items(): | |
| new_features = layer(features) | |
| features.append(new_features) | |
| return torch.cat(features, 1) | |
| class _Transition(nn.Sequential): | |
| def __init__(self, num_input_features: int, num_output_features: int) -> None: | |
| super(_Transition, self).__init__() | |
| self.add_module('norm', nn.BatchNorm3d(num_input_features)) | |
| self.add_module('relu', nn.ReLU(inplace=True)) | |
| self.add_module('conv', nn.Conv3d(num_input_features, num_output_features, | |
| kernel_size=1, stride=1, bias=False)) | |
| self.add_module('pool', nn.AvgPool3d(kernel_size=2, stride=2)) | |
| class DenseNet(nn.Module): | |
| r"""Densenet-BC model class, based on | |
| `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_. | |
| Args: | |
| growth_rate (int) - how many filters to add each layer (`k` in paper) | |
| block_config (list of 4 ints) - how many layers in each pooling block | |
| num_init_features (int) - the number of filters to learn in the first convolution layer | |
| bn_size (int) - multiplicative factor for number of bottle neck layers | |
| (i.e. bn_size * k features in the bottleneck layer) | |
| drop_rate (float) - dropout rate after each dense layer | |
| num_classes (int) - number of classification classes | |
| memory_efficient (bool) - If True, uses checkpointing. Much more memory efficient, | |
| but slower. Default: *False*. See `"paper" <https://arxiv.org/pdf/1707.06990.pdf>`_. | |
| """ | |
| def __init__( | |
| self, | |
| growth_rate: int = 32, | |
| block_config: Tuple[int, int, int, int] = (6, 12, 24, 16), | |
| num_init_features: int = 64, | |
| bn_size: int = 4, | |
| drop_rate: float = 0, | |
| num_classes: int = 1000, | |
| memory_efficient: bool = False, | |
| in_channels: int = 3 | |
| ) -> None: | |
| super(DenseNet, self).__init__() | |
| # First convolution | |
| self.features = nn.Sequential(OrderedDict([ | |
| ('conv0', nn.Conv3d(in_channels, num_init_features, kernel_size=7, stride=2, | |
| padding=3, bias=False)), | |
| ('norm0', nn.BatchNorm3d(num_init_features)), | |
| ('relu0', nn.ReLU(inplace=True)), | |
| ('pool0', nn.MaxPool3d(kernel_size=3, stride=2, padding=1)), | |
| ])) | |
| # Each denseblock | |
| num_features = num_init_features | |
| for i, num_layers in enumerate(block_config): | |
| block = _DenseBlock( | |
| num_layers=num_layers, | |
| num_input_features=num_features, | |
| bn_size=bn_size, | |
| growth_rate=growth_rate, | |
| drop_rate=drop_rate, | |
| memory_efficient=memory_efficient | |
| ) | |
| self.features.add_module('denseblock%d' % (i + 1), block) | |
| num_features = num_features + num_layers * growth_rate | |
| if i != len(block_config) - 1: | |
| trans = _Transition(num_input_features=num_features, | |
| num_output_features=num_features // 2) | |
| self.features.add_module('transition%d' % (i + 1), trans) | |
| num_features = num_features // 2 | |
| # Final batch norm | |
| self.features.add_module('norm5', nn.BatchNorm3d(num_features)) | |
| # Official init from torch repo. | |
| for m in self.modules(): | |
| if isinstance(m, nn.Conv3d): | |
| nn.init.kaiming_normal_(m.weight) | |
| elif isinstance(m, nn.BatchNorm3d): | |
| nn.init.constant_(m.weight, 1) | |
| nn.init.constant_(m.bias, 0) | |
| elif isinstance(m, nn.Linear): | |
| nn.init.constant_(m.bias, 0) | |
| def forward(self, x: Tensor) -> Tensor: | |
| features = self.features(x) | |
| return features | |
| def _densenet( | |
| arch: str, | |
| growth_rate: int, | |
| block_config: Tuple[int, int, int, int], | |
| num_init_features: int, | |
| pretrained: bool, | |
| progress: bool, | |
| **kwargs: Any | |
| ) -> DenseNet: | |
| model = DenseNet(growth_rate, block_config, num_init_features, **kwargs) | |
| return model | |
| def densenet121(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: | |
| r"""Densenet-121 model from | |
| `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_. | |
| The required minimum input size of the model is 29x29. | |
| Args: | |
| pretrained (bool): If True, returns a model pre-trained on ImageNet | |
| progress (bool): If True, displays a progress bar of the download to stderr | |
| memory_efficient (bool) - If True, uses checkpointing. Much more memory efficient, | |
| but slower. Default: *False*. See `"paper" <https://arxiv.org/pdf/1707.06990.pdf>`_. | |
| """ | |
| return _densenet('densenet121', 32, (6, 12, 24, 16), 64, pretrained, progress, | |
| **kwargs) | |
| def densenet161(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: | |
| r"""Densenet-161 model from | |
| `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_. | |
| The required minimum input size of the model is 29x29. | |
| Args: | |
| pretrained (bool): If True, returns a model pre-trained on ImageNet | |
| progress (bool): If True, displays a progress bar of the download to stderr | |
| memory_efficient (bool) - If True, uses checkpointing. Much more memory efficient, | |
| but slower. Default: *False*. See `"paper" <https://arxiv.org/pdf/1707.06990.pdf>`_. | |
| """ | |
| return _densenet('densenet161', 48, (6, 12, 36, 24), 96, pretrained, progress, | |
| **kwargs) | |
| def densenet169(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: | |
| r"""Densenet-169 model from | |
| `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_. | |
| The required minimum input size of the model is 29x29. | |
| Args: | |
| pretrained (bool): If True, returns a model pre-trained on ImageNet | |
| progress (bool): If True, displays a progress bar of the download to stderr | |
| memory_efficient (bool) - If True, uses checkpointing. Much more memory efficient, | |
| but slower. Default: *False*. See `"paper" <https://arxiv.org/pdf/1707.06990.pdf>`_. | |
| """ | |
| return _densenet('densenet169', 32, (6, 12, 32, 32), 64, pretrained, progress, | |
| **kwargs) | |
| def densenet201(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> DenseNet: | |
| r"""Densenet-201 model from | |
| `"Densely Connected Convolutional Networks" <https://arxiv.org/pdf/1608.06993.pdf>`_. | |
| The required minimum input size of the model is 29x29. | |
| Args: | |
| pretrained (bool): If True, returns a model pre-trained on ImageNet | |
| progress (bool): If True, displays a progress bar of the download to stderr | |
| memory_efficient (bool) - If True, uses checkpointing. Much more memory efficient, | |
| but slower. Default: *False*. See `"paper" <https://arxiv.org/pdf/1707.06990.pdf>`_. | |
| """ | |
| return _densenet('densenet201', 32, (6, 12, 48, 32), 64, pretrained, progress, | |
| **kwargs) | |
| class maskdense(nn.Module): | |
| def __init__(self, in_channels=3, name='densenet121'): | |
| super(maskdense, self).__init__() | |
| if name == 'densenet121': | |
| self.densnet_model = densenet121(in_channels=in_channels) | |
| elif name == 'densenet161': | |
| self.densnet_model = densenet161(in_channels=in_channels) | |
| else: | |
| self.densnet_model = None | |
| self.sigmoid = nn.Sigmoid() | |
| densnet = list(self.densnet_model.children()) | |
| self.First_convolution = nn.Sequential(*densnet[0][0:1]) | |
| self.First_BN = nn.Sequential(*densnet[0][1:2]) | |
| self.Second_convolution = nn.Sequential(*densnet[0][2:4]) | |
| self.denseblock1 = nn.Sequential(*densnet[0][4:5]) | |
| self.transition1 = nn.Sequential(*densnet[0][5:6]) | |
| self.denseblock2 = nn.Sequential(*densnet[0][6:7]) | |
| self.transition2 = nn.Sequential(*densnet[0][7:8]) | |
| self.denseblock3 = nn.Sequential(*densnet[0][8:9]) | |
| self.transition3 = nn.Sequential(*densnet[0][9:10]) | |
| self.denseblock4 = nn.Sequential(*densnet[0][10:11]) | |
| self.norm5 = nn.Sequential(*densnet[0][11:12]) | |
| def forward(self, x): | |
| x = self.First_convolution(x) | |
| x = self.First_BN(x) | |
| x_t1 = self.Second_convolution(x) | |
| x = self.denseblock1(x_t1) | |
| x_t2 = self.transition1(x) | |
| x = self.denseblock2(x_t2) | |
| x_t3 = self.transition2(x) | |
| x = self.denseblock3(x_t3) | |
| x_t4 = self.transition3(x) | |
| x = self.denseblock4(x_t4) | |
| x = self.norm5(x) | |
| x = F.relu(x, inplace=True) | |
| return x_t1, x_t2, x_t3, x_t4, x | |
| def maskdense121(in_channels) -> DenseNet: | |
| return maskdense(in_channels=in_channels,name='densenet121') | |
| def maskdense161(in_channels) -> DenseNet: | |
| return maskdense(in_channels=in_channels, name='densenet161') | |
| if __name__ == '__main__': | |
| import os | |
| os.environ['CUDA_LAUNCH_BLOCKING'] = '0' | |
| img = torch.randn(4, 3, 160, 192, 160) | |
| net = maskdense121(in_channels=2, name='densenet121') | |
| net.cuda() | |
| im = img.cuda() | |
| out = net(img) | |
| print(out.shape) | |