def __init__(self,
channel_in,
growth_rate,
bottleneck_size_basic_factor,
drop_ratio=0.8):
super(BachActivateConvLayer, self).__init__()
self.drop_ratio = drop_ratio
self.growth_rate = growth_rate
self.bottleneck_channel_out = bottleneck_size_basic_factor * growth_rate
self.mode_bn = InPlaceABNSync(channel_in)
self.mode_conv = nn.Conv3d(channel_in,
self.bottleneck_channel_out,
kernel_size=1,
stride=1,
bias=False)
self.bn = InPlaceABNSync(self.bottleneck_channel_out)
self.conv = nn.Conv3d(self.bottleneck_channel_out,
growth_rate,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.drop_out = nn.Dropout3d(p=self.drop_ratio)
def __init__(self, channel):
super(GE_8_theoLayer, self).__init__()
self.gather = nn.Sequential(
nn.Conv2d(channel, channel, kernel_size=3, stride=2, groups=channel,padding=2, bias=False),
InPlaceABNSync(channel),
nn.Conv2d(channel, channel, kernel_size=3, stride=2, groups=channel,padding=1, bias=False),
InPlaceABNSync(channel),
nn.Conv2d(channel, channel, kernel_size=3, stride=2, groups=channel,padding=1, bias=False),
BatchNorm2d(channel)
)
self.gather_sigmoid = nn.Sigmoid()
def __init__(self, features, out_features=512):
super(PGEC_Module, self).__init__()
self.conv1 = nn.Sequential(nn.Conv2d(features, out_features, kernel_size=3, padding=1, dilation=1, bias=True),
BatchNorm2d(out_features)
)
self.conv2 = nn.Sequential(GE_theoLayer(features,30),
nn.Conv2d(features, out_features, kernel_size=1, padding=0, dilation=1, bias=False),
BatchNorm2d(out_features))
self.conv3 = nn.Sequential(GE_4_theoLayer(features),
nn.Conv2d(features, out_features, kernel_size=1, padding=0, dilation=1, bias=False),
BatchNorm2d(out_features))
self.conv4 = nn.Sequential(GE_8_theoLayer(features),
nn.Conv2d(features, out_features, kernel_size=1, padding=0, dilation=1, bias=False),
BatchNorm2d(out_features))
self.conv5 = nn.Sequential(GE_16_theoLayer(features),
nn.Conv2d(features, out_features, kernel_size=1, padding=0, dilation=1, bias=False),
BatchNorm2d(out_features))
self.conv_bn_dropout = nn.Sequential(
nn.Conv2d(out_features * 5, out_features, kernel_size=1, padding=0, dilation=1, bias=False),
InPlaceABNSync(out_features),
nn.Dropout2d(0.1)
)
def __init__(self, input_channel_number, output_channel_number):
super(TransitionLayer, self).__init__()
self.bn = InPlaceABNSync(input_channel_number)
self.conv = nn.Conv3d(input_channel_number, output_channel_number, kernel_size=1, stride=1, bias=False)
self.pool = nn.AvgPool3d(kernel_size=2, stride=2)
def __init__(self, n_in, n_out, stride=1):
super(PostRes, self).__init__()
self.conv1 = nn.Conv3d(n_in,
n_out,
kernel_size=3,
stride=stride,
padding=1)
self.bn1 = InPlaceABNSync(n_in)
self.conv2 = nn.Conv3d(n_out, n_out, kernel_size=3, padding=1)
self.bn2 = InPlaceABNSync(n_out)
if stride != 1 or n_out != n_in:
self.shortcut = nn.Sequential(
nn.Conv3d(n_in, n_out, kernel_size=1, stride=stride))
else:
self.shortcut = None
def __init__(self, features, out_features=512, sizes=(1, 2, 3, 6)):
super(PSPModule, self).__init__()
self.stages = []
self.stages = nn.ModuleList([self._make_stage(features, out_features, size) for size in sizes])
self.bottleneck = nn.Sequential(
nn.Conv2d(features+len(sizes)*out_features, out_features, kernel_size=3, padding=1, dilation=1, bias=False),
InPlaceABNSync(out_features)
)
def __init__(self, growth_rate=32, block_config=(4, 4, 4, 4), compression=0.5, num_init_features=24, bottleneck_size_basic_factor=4, drop_rate=0, num_classes=2, small_inputs=True):
super(DenseNet, self).__init__()
self.features = nn.Conv3d(2, num_init_features, kernel_size=3, stride=1, padding=1, bias=False)
self.init_feature_channel_number = num_init_features
self.growth_rate = growth_rate
self.compression = compression
self.number_class = num_classes
self.block_config = block_config
num_features = num_init_features
self.dense_trainsition_out_put_list = []
for i, num_layers in enumerate(self.block_config):
block = DenseBlock(num_layers, num_features, self.growth_rate, bottleneck_size_basic_factor, drop_rate)
setattr(self, 'block_' + str(i), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
transition_layer = TransitionLayer(num_features, int(num_features * self.compression))
setattr(self, 'block_transition_' + str(i), transition_layer)
num_features = int(num_features * self.compression)
self.dense_trainsition_out_put_list.append(num_features)
# self.shuortcut_connect_layer = nn.Sequential(nn.Conv3d(self.dense_trainsition_out_put_list[0]*2 + self.dense_trainsition_out_put_list[2], self.dense_trainsition_out_put_list[2],1),
# InPlaceABNSync(self.dense_trainsition_out_put_list[2]))
self.shuortcut_connect_layer = nn.Conv3d(self.dense_trainsition_out_put_list[0]*2 + self.dense_trainsition_out_put_list[2], self.dense_trainsition_out_put_list[2],1)
self.finally_bn = InPlaceABNSync(num_features)
self.binary_classifier = nn.Linear(num_features, self.number_class)
self.multiple_classifier = nn.Linear(num_features, 6)
for name, param in self.named_parameters():
if 'conv' in name and 'weight' in name:
n = param.size(0) * param.size(2) * param.size(3)* param.size(4)
param.data.normal_().mul_(math.sqrt(2. / n))
elif 'norm' in name and 'weight' in name:
param.data.fill_(1)
elif 'norm' in name and 'bias' in name:
param.data.fill_(0)
elif 'classifier' in name and 'bias' in name:
param.data.fill_(0)
def __init__(self, features, out_features=512, inner_features=256, dilations=(12, 24, 36)):
super(ASPPModule, self).__init__()
self.conv1 = nn.Sequential(nn.AdaptiveAvgPool2d((1, 1)),
nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1,
bias=False),
InPlaceABNSync(inner_features))
self.conv2 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=1, padding=0, dilation=1, bias=False),
InPlaceABNSync(inner_features))
self.conv3 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[0], dilation=dilations[0], bias=False),
InPlaceABNSync(inner_features))
self.conv4 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[1], dilation=dilations[1], bias=False),
InPlaceABNSync(inner_features))
self.conv5 = nn.Sequential(
nn.Conv2d(features, inner_features, kernel_size=3, padding=dilations[2], dilation=dilations[2], bias=False),
InPlaceABNSync(inner_features))
self.bottleneck = nn.Sequential(
nn.Conv2d(inner_features * 5, out_features, kernel_size=1, padding=0, dilation=1, bias=False),
InPlaceABNSync(out_features),
nn.Dropout2d(0.1)
)
def __init__(self, inplanes, planes, index , senet_global_average, expansion = 2, stride=1, downsample=None):
super(BottleNeckResblock, self).__init__()
self.bn1 = InPlaceABNSync(inplanes)
self.conv1 = nn.Conv3d(inplanes, planes, kernel_size=1, bias=False)
self.bn2 = InPlaceABNSync(planes)
self.conv2 = nn.Conv3d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
self.bn3 = InPlaceABNSync(planes)
self.conv3 = nn.Conv3d(planes, planes * expansion, kernel_size=1, bias=False)
self.relu = nn.LeakyReLU(inplace=True)
self.downsample = downsample
self.stride = stride
self.se_compont = SEComponent(planes * expansion, index , senet_global_average, se_resize_factor = 8)
def __init__(self, num_classes):
super(Decoder_Module, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(512,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256))
self.conv2 = nn.Sequential(
nn.Conv2d(256,
48,
kernel_size=1,
stride=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(48))
self.conv3 = nn.Sequential(
nn.Conv2d(304,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256),
nn.Conv2d(256,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256))
self.conv4 = nn.Conv2d(256,
num_classes,
kernel_size=1,
padding=0,
dilation=1,
bias=True)
def __init__(self, in_fea=[256, 512, 1024], mid_fea=256, out_fea=2):
super(Edge_Module, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_fea[0],
mid_fea,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(mid_fea))
self.conv2 = nn.Sequential(
nn.Conv2d(in_fea[1],
mid_fea,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(mid_fea))
self.conv3 = nn.Sequential(
nn.Conv2d(in_fea[2],
mid_fea,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(mid_fea))
self.conv4 = nn.Conv2d(mid_fea,
out_fea,
kernel_size=3,
padding=1,
dilation=1,
bias=True)
self.conv5 = nn.Conv2d(out_fea * 3,
out_fea,
kernel_size=1,
padding=0,
dilation=1,
bias=True)
def __init__(self,
in_channels,
out_channels,
key_channels,
value_channels,
dropout,
sizes=([1])):
super(BaseOC_Module, self).__init__()
self.stages = []
self.stages = nn.ModuleList([
self._make_stage(in_channels, out_channels, key_channels,
value_channels, size) for size in sizes
])
self.conv_bn_dropout = nn.Sequential(
nn.Conv2d(2 * in_channels, out_channels, kernel_size=1, padding=0),
InPlaceABNSync(out_channels), nn.Dropout2d(dropout))
def __init__(self, features, out_features=256, dilations=(12, 24, 36)):
super(ASP_OC_Module, self).__init__()
self.context = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=1,
dilation=1,
bias=True), InPlaceABNSync(out_features),
BaseOC_Context_Module(in_channels=out_features,
out_channels=out_features,
key_channels=out_features // 2,
value_channels=out_features,
dropout=0,
sizes=([2])))
self.conv2 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(out_features))
self.conv3 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=dilations[0],
dilation=dilations[0],
bias=False), InPlaceABNSync(out_features))
self.conv4 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=dilations[1],
dilation=dilations[1],
bias=False), InPlaceABNSync(out_features))
self.conv5 = nn.Sequential(
nn.Conv2d(features,
out_features,
kernel_size=3,
padding=dilations[2],
dilation=dilations[2],
bias=False), InPlaceABNSync(out_features))
self.conv_bn_dropout = nn.Sequential(
nn.Conv2d(out_features * 5,
out_features,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(out_features),
nn.Dropout2d(0.1))
def make_res_block(self, block, planes, blocks, se_index, se_average_size, stride=1, expansion = 2, down_sample_padding = 0, can_down_sample = True):
downsample = None
if (stride != 1 or self.inplanes != planes * expansion) and can_down_sample == True: #需要下采样
downsample = nn.Sequential(
InPlaceABNSync(self.inplanes, activation='none'),
nn.Conv3d(self.inplanes, planes * expansion, kernel_size=1, stride=stride, padding=down_sample_padding, bias=False))
layers = []
layers.append(block(self.inplanes, planes, se_index, se_average_size, expansion = expansion, stride = stride, downsample = downsample))
# self.inplanes = planes * block.expansion
self.inplanes = planes * expansion
for i in range(1, blocks):
layers.append(block(self.inplanes, planes, se_index, se_average_size, expansion=expansion))
return nn.Sequential(*layers)
def __init__(self, block, layers, num_classes):
self.inplanes = 128
super(ResNet, self).__init__()
self.conv1 = conv3x3(3, 64, stride=2)
self.bn1 = BatchNorm2d(64)
self.relu1 = nn.ReLU(inplace=False)
self.conv2 = conv3x3(64, 64)
self.bn2 = BatchNorm2d(64)
self.relu2 = nn.ReLU(inplace=False)
self.conv3 = conv3x3(64, 128)
self.bn3 = BatchNorm2d(128)
self.relu3 = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=1,
dilation=2,
multi_grid=(1, 1, 1))
self.context_encoding = PSPModule(2048, 512)
self.edge = Edge_Module()
self.decoder = Decoder_Module(num_classes)
self.fushion = nn.Sequential(
nn.Conv2d(1024,
256,
kernel_size=1,
padding=0,
dilation=1,
bias=False), InPlaceABNSync(256), nn.Dropout2d(0.1),
nn.Conv2d(256,
num_classes,
kernel_size=1,
padding=0,
dilation=1,
bias=True))
def __init__(self, block = BottleNeckResblock , layers = [3,4, 23,3], num_classes=2):
super(SENet, self).__init__()
# block_channel_in = [32,64,128,256]
block_channel_planes = [32, 64, 128, 256]
senet_global_average = [48,24,12,6]
self.inplanes = 32
# self.preblock = nn.Sequential(nn.Conv3d(2, self.inplanes, kernel_size=3,stride=1, padding=1, bias=False),
# InPlaceABNSync(self.inplanes),
# nn.Conv3d(self.inplanes, self.inplanes, kernel_size=3,stride=1, padding=1, bias=False))
self.preblock = nn.Conv3d(2, self.inplanes, kernel_size=3,stride=1, padding=1, bias=False)
# self.begin_con = nn.Conv3d(2, self.inplanes, kernel_size=3,stride=1, padding=1, bias=False)
# self.begin_con_bn = InPlaceABNSync(self.inplanes)
self.avgpool = nn.AvgPool3d(6, stride=1)
self.finally_bn = InPlaceABNSync(block_channel_planes[-1] * 2)
self.binary_class_layer = nn.Linear(block_channel_planes[-1] * 2, 2)
self.multiple_class_layer = nn.Linear(block_channel_planes[-1] * 2, 6)
self.layer1 = self.make_res_block(block, block_channel_planes[0], layers[0], 0, senet_global_average, expansion = 2, stride=1,down_sample_padding=0)
self.layer2 = self.make_res_block(block, block_channel_planes[1], layers[1], 1, senet_global_average, expansion = 2, stride=2)
self.layer3 = self.make_res_block(block, block_channel_planes[2], layers[2], 2, senet_global_average, expansion = 2, stride=2)
self.layer4 = self.make_res_block(block, block_channel_planes[3], layers[3], 3, senet_global_average, expansion = 2, stride=2)
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='leaky_relu')
elif isinstance(m, InPlaceABNSync):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def __init__(self,
in_channels,
key_channels,
value_channels,
out_channels=None,
scale=1):
super(_SelfAttentionBlock, self).__init__()
self.scale = scale
self.in_channels = in_channels
self.out_channels = out_channels
self.key_channels = key_channels
self.value_channels = value_channels
if out_channels == None:
self.out_channels = in_channels
self.pool = nn.MaxPool2d(kernel_size=(scale, scale))
self.f_key = nn.Sequential(
nn.Conv2d(in_channels=self.in_channels,
out_channels=self.key_channels,
kernel_size=1,
stride=1,
padding=0),
InPlaceABNSync(self.key_channels),
)
self.f_query = self.f_key
self.f_value = nn.Conv2d(in_channels=self.in_channels,
out_channels=self.value_channels,
kernel_size=1,
stride=1,
padding=0)
self.W = nn.Conv2d(in_channels=self.value_channels,
out_channels=self.out_channels,
kernel_size=1,
stride=1,
padding=0)
nn.init.constant(self.W.weight, 0)
nn.init.constant(self.W.bias, 0)
def _make_stage(self, features, out_features, size):
prior = nn.AdaptiveAvgPool2d(output_size=(size, size))
conv = nn.Conv2d(features, out_features, kernel_size=1, bias=False)
bn = InPlaceABNSync(out_features)
return nn.Sequential(prior, conv, bn)
def __init__(self, args):
super(Net, self).__init__()
# self.preBlock = nn.Sequential(
# nn.Conv3d(1, 32, kernel_size = (1 ,3 ,3), padding = (0 ,1 ,1)),
# InPlaceABNSync(32),
# nn.Conv3d(32, 32, kernel_size = (1 ,3 ,3), padding = (0 ,1 ,1)),
# InPlaceABNSync(32),
# # nn.MaxPool3d(kernel_size=(2,2,2),stride=(2, 1, 1),return_indices=False), #add by lxw
# nn.Conv3d(32, 32, kernel_size = (1 ,3 ,3), padding = (0 ,1 ,1)),
# InPlaceABNSync(32))
self.args = args
self.multiple_channel = self.args.multiple_channel
self.preBlock = nn.Sequential(
nn.Conv3d(2, 32, kernel_size=(3, 3, 3), padding=(1, 1, 1)),
InPlaceABNSync(32),
nn.Conv3d(32, 32, kernel_size=(3, 3, 3), padding=(1, 1, 1)),
InPlaceABNSync(32),
nn.Conv3d(32, 32, kernel_size=(3, 3, 3), padding=(1, 1, 1)),
InPlaceABNSync(32),
nn.Conv3d(32, 32, kernel_size=(3, 3, 3), padding=(1, 1, 1)),
InPlaceABNSync(32))
num_blocks_forw = [4, 4, 8, 8]
self.featureNum_forw = [32, 32, 64, 64, 64]
for i in range(len(num_blocks_forw)):
blocks = []
for j in range(num_blocks_forw[i]):
if j == 0:
blocks.append(
PostRes(self.featureNum_forw[i],
self.featureNum_forw[i + 1]))
else:
blocks.append(
PostRes(self.featureNum_forw[i + 1],
self.featureNum_forw[i + 1]))
print('forw' + str(i + 1), self.featureNum_forw[i],
self.featureNum_forw[i + 1])
setattr(self, 'forw' + str(i + 1), nn.Sequential(*blocks))
self.maxpool = nn.MaxPool3d(kernel_size=2,
stride=2,
return_indices=True)
self.maxpool_2d = nn.MaxPool3d(kernel_size=(2, 2, 2),
stride=(2, 2, 2),
return_indices=True)
self.drop = nn.Dropout3d(p=0.5, inplace=False)
self.average_pooling = torch.nn.AvgPool3d((3, 3, 3), stride=1)
self.dense_connect_cnn = torch.nn.Sequential(
torch.nn.Linear(64 * 1 * 1 * 1, 128), torch.nn.Dropout(0.5),
torch.nn.ReLU(), torch.nn.Linear(128, 128), torch.nn.Dropout(0.5),
torch.nn.ReLU())
self.binary_classification_out = torch.nn.Linear(128, 2)
self.multi_classification_out = torch.nn.Linear(
128, self.multiple_channel)
for m in self.modules():
if isinstance(m, nn.BatchNorm3d) or isinstance(m, InPlaceABNSync):
m.momentum = 0.01
