def __init__(self,
width,
height,
spec_conv_layers,
spec_max_pooling,
spec_linear,
spec_dropout_rates,
useBatchNorm=False,
useAffineTransformInBatchNorm=False,
num_channels_input=3,
num_outputs=10):
'''
The structure of the network is: a number of convolutional layers, intermittend max-pooling and dropout layers,
and a number of linear layers. The max-pooling layers are inserted in the positions specified, as do the dropout
layers.
:param spec_conv_layers: list of tuples with (numFilters, width, height) (one tuple for each layer);
:param spec_max_pooling: list of tuples with (posToInsert, width, height) of max-pooling layers
:param spec_dropout_rates list of tuples with (posToInsert, rate of dropout) (applied after max-pooling)
:param spec_linear: list with numNeurons for each layer (i.e. [100, 200, 300] creates 3 layers)
'''
super(ConvolForwardNet, self).__init__()
self.width = width
self.height = height
self.conv_layers = []
self.max_pooling_layers = []
self.dropout_layers = []
self.linear_layers = []
self.max_pooling_positions = []
self.dropout_positions = []
self.useBatchNorm = useBatchNorm
self.batchNormalizationLayers = []
#creating the convolutional layers
oldNumChannels = num_channels_input
for idx in range(len(spec_conv_layers)):
currSpecLayer = spec_conv_layers[idx]
numFilters = currSpecLayer[0]
kernel_size = (currSpecLayer[1], currSpecLayer[2])
#The padding needs to be such that width and height of the image are unchanges after each conv layer
padding = ((kernel_size[0] - 1) // 2, (kernel_size[1] - 1) // 2)
newConvLayer = nn.Conv2d(in_channels=oldNumChannels,
out_channels=numFilters,
kernel_size=kernel_size,
padding=padding)
xavier_uniform(
newConvLayer.weight,
calculate_gain('conv2d')) #glorot weight initialization
self.conv_layers.append(newConvLayer)
self.batchNormalizationLayers.append(
nn.BatchNorm2d(numFilters,
affine=useAffineTransformInBatchNorm))
oldNumChannels = numFilters
#creating the max pooling layers
for idx in range(len(spec_max_pooling)):
currSpecLayer = spec_max_pooling[idx]
kernel_size = (currSpecLayer[1], currSpecLayer[2])
self.max_pooling_layers.append(nn.MaxPool2d(kernel_size))
self.max_pooling_positions.append(currSpecLayer[0])
#creating the dropout layers
for idx in range(len(spec_dropout_rates)):
currSpecLayer = spec_dropout_rates[idx]
rate = currSpecLayer[1]
currPosition = currSpecLayer[0]
if currPosition < len(self.conv_layers):
#we use dropout2d only for the conv_layers, otherwise we use the usual dropout
self.dropout_layers.append(nn.Dropout2d(rate))
else:
self.dropout_layers.append(nn.Dropout(rate))
self.dropout_positions.append(currPosition)
#creating the linear layers
oldInputFeatures = oldNumChannels * width * height // 2**(
2 * len(self.max_pooling_layers))
for idx in range(len(spec_linear)):
currNumFeatures = spec_linear[idx]
newLinearLayer = nn.Linear(in_features=oldInputFeatures,
out_features=currNumFeatures)
xavier_uniform(
newLinearLayer.weight,
calculate_gain('linear')) # glorot weight initialization
self.linear_layers.append(newLinearLayer)
self.batchNormalizationLayers.append(
nn.BatchNorm1d(currNumFeatures,
affine=useAffineTransformInBatchNorm))
oldInputFeatures = currNumFeatures
#final output layer
self.out_layer = nn.Linear(in_features=oldInputFeatures,
out_features=num_outputs)
xavier_uniform(self.out_layer.weight, calculate_gain('linear'))
self.conv_layers = nn.ModuleList(self.conv_layers)
self.max_pooling_layers = nn.ModuleList(self.max_pooling_layers)
self.dropout_layers = nn.ModuleList(self.dropout_layers)
self.linear_layers = nn.ModuleList(self.linear_layers)
self.batchNormalizationLayers = nn.ModuleList(
self.batchNormalizationLayers)
self.num_conv_layers = len(self.conv_layers)
self.total_num_layers = self.num_conv_layers + len(self.linear_layers)
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 1)
self.dropout1 = nn.Dropout2d(0.25)
self.fc1 = nn.Linear(32 * 26 * 26, 10)
def __init__(self, args_dict=scalogram_encoder_default_dict):
super().__init__()
self.num_layers = len(args_dict['kernel_sizes'])
self.cqt = CQT(sr=args_dict['sample_rate'],
fmin=args_dict['fmin'],
n_bins=args_dict['n_bins'],
bins_per_octave=args_dict['bins_per_octave'],
filter_scale=args_dict['filter_scale'],
hop_length=args_dict['hop_length'],
trainable=args_dict['trainable_cqt'])
self.phase = args_dict['phase']
if self.phase:
args_dict['channel_count'][0] = 2
self.phase_diff = PhaseDifference(
sr=args_dict['sample_rate'],
fmin=args_dict['fmin'],
n_bins=args_dict['n_bins'],
bins_per_octave=args_dict['bins_per_octave'],
hop_length=args_dict['hop_length'])
else:
args_dict['channel_count'][0] = 1
self.module_list = nn.ModuleList()
for l in range(self.num_layers):
if args_dict['top_padding'][l] > 0:
self.module_list.add_module(
'pad_' + str(l),
nn.ZeroPad2d((0, 0, args_dict['top_padding'][l], 0)))
if l > 0 and args_dict['separable']:
self.module_list.add_module(
'conv_' + str(l),
Conv2dSeparable(in_channels=args_dict['channel_count'][l],
out_channels=args_dict['channel_count'][l +
1],
kernel_size=args_dict['kernel_sizes'][l],
bias=args_dict['bias'],
stride=args_dict['stride'][l]))
else:
bias = False
if args_dict['kernel_sizes'][l][1] > 1:
bias = args_dict['bias']
self.module_list.add_module(
'conv_' + str(l),
nn.Conv2d(in_channels=args_dict['channel_count'][l],
out_channels=args_dict['channel_count'][l + 1],
kernel_size=args_dict['kernel_sizes'][l],
bias=bias,
stride=args_dict['stride'][l]))
if args_dict['lowpass_init'] > 0 and args_dict['kernel_sizes'][l][
1] == 1:
lowpass_init(
list(self.module_list)[-1].weight,
args_dict['lowpass_init'])
if args_dict['pooling'][l] > 1:
self.module_list.add_module(
'pooling_' + str(l),
nn.MaxPool2d(kernel_size=args_dict['pooling'][l]))
if l < self.num_layers - 1:
self.module_list.add_module('relu_' + str(l), nn.ReLU())
if args_dict['dropout'] > 0.:
self.module_list.add_module(
'dropout_' + str(l),
nn.Dropout2d(args_dict['dropout']))
if args_dict['batch_norm']:
self.module_list.add_module(
'batch_norm_' + str(l),
nn.BatchNorm2d(
num_features=args_dict['channel_count'][l + 1]))
if args_dict['instance_norm']:
self.module_list.add_module(
'instance_norm_' + str(l),
nn.InstanceNorm2d(
num_features=args_dict['channel_count'][l + 1],
affine=True,
track_running_stats=True))
self.receptive_field = self.cqt.conv_kernel_sizes[0]
s = args_dict['hop_length']
for i in range(self.num_layers):
self.receptive_field += (args_dict['kernel_sizes'][i][1] - 1) * s
s *= args_dict['pooling'][i] * args_dict['stride'][i]
self.downsampling_factor = args_dict['hop_length'] * np.prod(
args_dict['pooling']) * np.prod(args_dict['stride'])
def __init__(self, cfg, **kwargs):
super(EMANet, self).__init__(cfg, **kwargs)
align_corners, norm_cfg, act_cfg = self.align_corners, self.norm_cfg, self.act_cfg
# build the EMA module
ema_cfg = cfg['ema']
self.ema_in_conv = nn.Sequential(
nn.Conv2d(ema_cfg['in_channels'],
ema_cfg['ema_channels'],
kernel_size=3,
stride=1,
padding=1,
bias=False),
BuildNormalization(norm_cfg['type'],
(ema_cfg['ema_channels'], norm_cfg['opts'])),
BuildActivation(act_cfg['type'], **act_cfg['opts']),
)
self.ema_mid_conv = nn.Conv2d(ema_cfg['ema_channels'],
ema_cfg['ema_channels'],
kernel_size=1,
stride=1,
padding=0)
for param in self.ema_mid_conv.parameters():
param.requires_grad = False
self.ema_module = EMAModule(channels=ema_cfg['ema_channels'],
num_bases=ema_cfg['num_bases'],
num_stages=ema_cfg['num_stages'],
momentum=ema_cfg['momentum'])
self.ema_out_conv = nn.Sequential(
nn.Conv2d(ema_cfg['ema_channels'],
ema_cfg['ema_channels'],
kernel_size=1,
stride=1,
padding=0,
bias=False),
BuildNormalization(norm_cfg['type'],
(ema_cfg['ema_channels'], norm_cfg['opts'])),
)
self.bottleneck = nn.Sequential(
nn.Conv2d(ema_cfg['ema_channels'],
ema_cfg['ema_channels'],
kernel_size=3,
stride=1,
padding=1,
bias=False),
BuildNormalization(norm_cfg['type'],
(ema_cfg['ema_channels'], norm_cfg['opts'])),
BuildActivation(act_cfg['type'], **act_cfg['opts']),
)
# build decoder
decoder_cfg = cfg['decoder']
self.decoder = nn.Sequential(
nn.Conv2d(decoder_cfg['in_channels'],
decoder_cfg['out_channels'],
kernel_size=3,
stride=1,
padding=1,
bias=False),
BuildNormalization(
norm_cfg['type'],
(decoder_cfg['out_channels'], norm_cfg['opts'])),
BuildActivation(act_cfg['type'], **act_cfg['opts']),
nn.Dropout2d(decoder_cfg['dropout']),
nn.Conv2d(decoder_cfg['out_channels'],
cfg['num_classes'],
kernel_size=1,
stride=1,
padding=0))
# build auxiliary decoder
self.setauxiliarydecoder(cfg['auxiliary'])
# freeze normalization layer if necessary
if cfg.get('is_freeze_norm', False): self.freezenormalization()
def __init__(self, params):
super(Backbone, self).__init__()
self.use_range = params["input_depth"]["range"]
self.use_xyz = params["input_depth"]["xyz"]
self.use_remission = params["input_depth"]["remission"]
self.drop_prob = params["dropout"]
self.bn_d = params["bn_d"]
self.OS = params["OS"]
self.layers = params["extra"]["layers"]
print("Using squeezesegv3" + str(self.layers) + " Backbone")
self.input_depth = 0
self.input_idxs = []
if self.use_range:
self.input_depth += 1
self.input_idxs.append(0)
if self.use_xyz:
self.input_depth += 3
self.input_idxs.extend([1, 2, 3])
if self.use_remission:
self.input_depth += 1
self.input_idxs.append(4)
print("Depth of backbone input = ", self.input_depth)
self.strides = [2, 2, 2, 1, 1]
current_os = 1
for s in self.strides:
current_os *= s
print("Original OS: ", current_os)
if self.OS > current_os:
print("Can't do OS, ", self.OS,
" because it is bigger than original ", current_os)
else:
for i, stride in enumerate(reversed(self.strides), 0):
if int(current_os) != self.OS:
if stride == 2:
current_os /= 2
self.strides[-1 - i] = 1
if int(current_os) == self.OS:
break
print("New OS: ", int(current_os))
print("Strides: ", self.strides)
assert self.layers in model_blocks.keys()
self.blocks = model_blocks[self.layers]
self.conv1 = nn.Conv2d(self.input_depth,
32,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(32, momentum=self.bn_d)
self.relu1 = nn.LeakyReLU(0.1)
self.enc1 = self._make_enc_layer(SACBlock, [32, 64],
self.blocks[0],
stride=self.strides[0],
DS=True,
bn_d=self.bn_d)
self.enc2 = self._make_enc_layer(SACBlock, [64, 128],
self.blocks[1],
stride=self.strides[1],
DS=True,
bn_d=self.bn_d)
self.enc3 = self._make_enc_layer(SACBlock, [128, 256],
self.blocks[2],
stride=self.strides[2],
DS=True,
bn_d=self.bn_d)
self.enc4 = self._make_enc_layer(SACBlock, [256, 256],
self.blocks[3],
stride=self.strides[3],
DS=False,
bn_d=self.bn_d)
self.enc5 = self._make_enc_layer(SACBlock, [256, 256],
self.blocks[4],
stride=self.strides[4],
DS=False,
bn_d=self.bn_d)
self.dropout = nn.Dropout2d(self.drop_prob)
self.last_channels = 256
def __init__(self, params):
super(Backbone, self).__init__()
self.use_range = params["input_depth"]["range"]
self.use_xyz = params["input_depth"]["xyz"]
self.use_remission = params["input_depth"]["remission"]
self.use_normals = params["input_depth"]["normals"]
self.use_curvature = params["input_depth"]["curvature"]
self.drop_prob = params["dropout"]
self.bn_d = params["bn_d"]
self.OS = params["OS"]
self.layers = params["extra"]["layers"]
print("Using DarknetNet" + str(self.layers) + " Backbone")
# input depth calc
self.input_depth = 0
self.input_idxs = []
if self.use_range:
self.input_depth += 1
self.input_idxs.append(0)
if self.use_xyz:
self.input_depth += 3
self.input_idxs.extend([1, 2, 3])
if self.use_remission:
self.input_depth += 1
self.input_idxs.append(4)
if self.use_normals:
self.input_depth += 3
self.input_idxs.extend([5,6,7])
if self.use_curvature:
self.input_depth += 1
self.input_idxs.append(8)
print("Depth of backbone input = ", self.input_depth)
# stride play
self.strides = [2, 2, 2, 2, 2]
# check current stride
current_os = 1
for s in self.strides:
current_os *= s
print("Original OS: ", current_os)
# make the new stride
if self.OS > current_os:
print("Can't do OS, ", self.OS,
" because it is bigger than original ", current_os)
else:
# redo strides according to needed stride
for i, stride in enumerate(reversed(self.strides), 0):
if int(current_os) != self.OS:
if stride == 2:
current_os /= 2
self.strides[-1 - i] = 1
if int(current_os) == self.OS:
break
print("New OS: ", int(current_os))
print("Strides: ", self.strides)
# check that darknet exists
assert self.layers in model_blocks.keys()
# generate layers depending on darknet type
self.blocks = model_blocks[self.layers]
# input layer
self.conv1 = nn.Conv2d(self.input_depth, 32, kernel_size=3,
stride=1, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(32, momentum=self.bn_d)
self.relu1 = nn.LeakyReLU(0.1)
# encoder
self.enc1 = self._make_enc_layer(BasicBlock, [32, 64], self.blocks[0],
stride=self.strides[0], bn_d=self.bn_d)
self.enc2 = self._make_enc_layer(BasicBlock, [64, 128], self.blocks[1],
stride=self.strides[1], bn_d=self.bn_d)
self.enc3 = self._make_enc_layer(BasicBlock, [128, 256], self.blocks[2],
stride=self.strides[2], bn_d=self.bn_d)
self.enc4 = self._make_enc_layer(BasicBlock, [256, 512], self.blocks[3],
stride=self.strides[3], bn_d=self.bn_d)
self.enc5 = self._make_enc_layer(BasicBlock, [512, 1024], self.blocks[4],
stride=self.strides[4], bn_d=self.bn_d)
# for a bit of fun
self.dropout = nn.Dropout2d(self.drop_prob)
# last channels
self.last_channels = 1024
def __init__(
self,
encoder_channels=[512, 256, 128, 64],
pyramid_channels=256,
segmentation_channels=128,
final_channels=1,
dropout=0.2,
):
super().__init__()
self.base_model = models.resnet18(pretrained=True)
self.base_layers = list(self.base_model.children())
# ==> encoder layers
self.layer_down0 = nn.Sequential(
*self.base_layers[:3]) # size=(N, 64, x.H/2, x.W/2)
self.layer_down1 = nn.Sequential(
*self.base_layers[3:5]) # size=(N, 64, x.H/4, x.W/4)
self.layer_down2 = self.base_layers[5] # size=(N, 128, x.H/8, x.W/8)
self.layer_down3 = self.base_layers[6] # size=(N, 256, x.H/16, x.W/16)
self.layer_down4 = self.base_layers[7] # size=(N, 512, x.H/32, x.W/32)
self.conv1 = nn.Conv2d(encoder_channels[0],
pyramid_channels,
kernel_size=(1, 1))
# ==> DS module
self.d5 = DSBlock(encoder_channels[0], final_channels)
self.d4 = DSBlock(encoder_channels[1], final_channels)
self.d3 = DSBlock(encoder_channels[2], final_channels)
self.d2 = DSBlock(encoder_channels[3], final_channels)
self.p4 = FPNBlock(pyramid_channels, encoder_channels[1])
self.p3 = FPNBlock(pyramid_channels, encoder_channels[2])
self.p2 = FPNBlock(pyramid_channels, encoder_channels[3])
self.s5 = SegmentationBlock(pyramid_channels,
segmentation_channels,
n_upsamples=3)
self.s4 = SegmentationBlock(pyramid_channels,
segmentation_channels,
n_upsamples=2)
self.s3 = SegmentationBlock(pyramid_channels,
segmentation_channels,
n_upsamples=1)
self.s2 = SegmentationBlock(pyramid_channels,
segmentation_channels,
n_upsamples=0)
# ==> DS module, fnd
self.fnd_s5 = SegmentationBlock(encoder_channels[0],
segmentation_channels,
n_upsamples=3)
self.fnd_s4 = SegmentationBlock(encoder_channels[1],
segmentation_channels,
n_upsamples=2)
self.fnd_s3 = SegmentationBlock(encoder_channels[2],
segmentation_channels,
n_upsamples=1)
self.fnd_s2 = SegmentationBlock(encoder_channels[3],
segmentation_channels,
n_upsamples=0)
# ==> DS module, fpd
self.fpd_s5 = SegmentationBlock(encoder_channels[0],
segmentation_channels,
n_upsamples=3)
self.fpd_s4 = SegmentationBlock(encoder_channels[1],
segmentation_channels,
n_upsamples=2)
self.fpd_s3 = SegmentationBlock(encoder_channels[2],
segmentation_channels,
n_upsamples=1)
self.fpd_s2 = SegmentationBlock(encoder_channels[3],
segmentation_channels,
n_upsamples=0)
self.dropout = nn.Dropout2d(p=dropout, inplace=True)
self.final_conv = nn.Conv2d(segmentation_channels,
final_channels,
kernel_size=1,
padding=0)
# ==> DS module, final
self.dropout_fnd = nn.Dropout2d(p=dropout, inplace=True)
self.dropout_fpd = nn.Dropout2d(p=dropout, inplace=True)
self.final_conv_fnd = nn.Conv2d(segmentation_channels,
final_channels,
kernel_size=1,
padding=0)
self.final_conv_fpd = nn.Conv2d(segmentation_channels,
final_channels,
kernel_size=1,
padding=0)
self.initialize()
def __init__(self):
super(MyCNN, self).__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_channels=1,out_channels=64,
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(64),
nn.Dropout2d(0.05),
nn.Conv2d(in_channels=64,out_channels=64,
kernel_size=5,stride=1,padding=2,),
nn.ReLU(),
nn.BatchNorm2d(64),
nn.MaxPool2d(kernel_size=2), # output shape(16, 22, 22)
nn.BatchNorm2d(64),
nn.Dropout2d(0.05),
nn.Conv2d(in_channels=64,out_channels=128,
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(128),
nn.Dropout2d(0.1),
nn.Conv2d(in_channels=128,out_channels=128,
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.Dropout2d(0.08),
nn.BatchNorm2d(128),
nn.MaxPool2d(kernel_size=2), # output shape(32, 10, 10)
nn.BatchNorm2d(128),
nn.Dropout2d(0.05),
nn.Conv2d(in_channels=128,out_channels=256,
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(256),
nn.Dropout2d(0.08),
#nn.Conv2d(in_channels=256,out_channels=256,
# kernel_size=3,stride=1,padding=1,),
#nn.ReLU(),
#nn.BatchNorm2d(256),
#nn.Dropout2d(0.1),
nn.Conv2d(in_channels=256,out_channels=256,
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(256),
nn.MaxPool2d(kernel_size=2), # output shape(32, 4, 4)
nn.BatchNorm2d(256),
nn.Dropout2d(0.05),
nn.Conv2d(in_channels=256,out_channels=512,
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(512),
nn.Dropout2d(0.05),
#nn.Conv2d(in_channels=512,out_channels=512, # output shape(32, 8, 8)
# kernel_size=3,stride=1,padding=1,),
#nn.ReLU(),
#nn.BatchNorm2d(512),
#nn.Dropout2d(0.1),
nn.Conv2d(in_channels=512,out_channels=512, # output shape(32, 8, 8)
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(512),
nn.MaxPool2d(kernel_size=2), # output shape(32, 4, 4)
nn.BatchNorm2d(512),
nn.Dropout2d(0.05),
nn.Conv2d(in_channels=512,out_channels=512, # output shape(32, 8, 8)
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(512),
nn.Dropout2d(0.05),
#nn.Conv2d(in_channels=512,out_channels=512, # output shape(32, 8, 8)
# kernel_size=3,stride=1,padding=1,),
#nn.ReLU(),
#nn.BatchNorm2d(512),
#nn.Dropout2d(0.1),
nn.Conv2d(in_channels=512,out_channels=512, # output shape(32, 8, 8)
kernel_size=3,stride=1,padding=1,),
nn.ReLU(),
nn.BatchNorm2d(512),
nn.MaxPool2d(kernel_size=2), # output shape(32, 4, 4)
nn.BatchNorm2d(512),
nn.Dropout2d(0.5),
)
self.fc = nn.Sequential(
nn.Linear(512 * 1 * 1, 1000),
nn.ReLU(),
nn.BatchNorm1d(1000),
nn.Dropout(0.5),
nn.Linear(1000, 7),
)
def __init__(self):
super(BeatNet, self).__init__()
self.l1 = nn.Sequential(
nn.Conv2d(cnn_in_size,
cnn_h1_size,
cnn_k_1_size,
padding=cnn_padding), nn.BatchNorm2d(cnn_h1_size),
nn.ELU(), nn.MaxPool2d(kernel_size=cnn_max_pool_k_size),
nn.Dropout2d(p=cnn_dropout_rate))
self.l2 = nn.Sequential(
nn.Conv2d(cnn_h1_size,
cnn_h2_size,
cnn_k_1_size,
padding=cnn_padding), nn.BatchNorm2d(cnn_h2_size),
nn.ELU(), nn.MaxPool2d(kernel_size=cnn_max_pool_k_size),
nn.Dropout2d(p=cnn_dropout_rate))
self.l2b = nn.Sequential(
nn.Conv2d(cnn_h2_size,
cnn_h3_size,
cnn_k_1_size,
padding=cnn_padding), nn.BatchNorm2d(cnn_h3_size),
nn.ELU(), nn.MaxPool2d(kernel_size=cnn_max_pool_k_size),
nn.Dropout2d(p=cnn_dropout_rate))
self.l3 = nn.Sequential(
nn.Conv2d(cnn_h3_size, cnn_h3_size, cnn_k_2_size),
# nn.BatchNorm2d(cnn_h_size), # cant use because spec is reduced to 1x1
# NOTE: if needed try Instance normalization (InstanceNorm2d)
nn.ELU(),
nn.Dropout2d(p=cnn_dropout_rate))
self.ld1 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[0],
dilation=tcn_dilations[0]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.ld2 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[1],
dilation=tcn_dilations[1]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.ld3 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[2],
dilation=tcn_dilations[2]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.ld4 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[3],
dilation=tcn_dilations[3]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.ld5 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[4],
dilation=tcn_dilations[4]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.ld6 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[5],
dilation=tcn_dilations[5]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.ld7 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[6],
dilation=tcn_dilations[6]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.ld8 = nn.Sequential(
nn.Conv1d(tcn_h_size,
tcn_h_size,
tcn_k_size,
padding=tcn_paddings[7],
dilation=tcn_dilations[7]), nn.BatchNorm1d(tcn_h_size),
nn.ELU(), nn.Dropout(p=tcn_dropout_rate))
self.lfc = nn.Sequential(nn.Conv1d(fc_h_size, fc_out_size, fc_k_size),
nn.Sigmoid())
def __init__(self):
super(FCNs, self).__init__()
# conv1
self.conv1 = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True)
)
# conv2
self.conv2 = nn.Sequential(
nn.Conv2d(64, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(128, 128, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True)
)
# conv3
self.conv3 = nn.Sequential(
nn.Conv2d(128, 256, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(256, 256, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True)
)
# conv4
self.conv4 = nn.Sequential(
nn.Conv2d(256, 512, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True)
)
# conv5
self.conv5 = nn.Sequential(
nn.Conv2d(512, 512, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(512, 512, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True)
)
# fc6
self.fc6 = nn.Sequential(
nn.Conv2d(512, 4096, 7),
nn.ReLU(inplace=True),
nn.Dropout2d()
)
# fc7
self.fc7 = nn.Sequential(
nn.Conv2d(4096, 4096, 1),
nn.ReLU(inplace=True),
nn.Dropout2d()
)
# 以下custom up8
self.up8 = nn.Sequential(
nn.Conv2d(4096, 512, 1),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(512, 512, 4, stride=2, bias=False),
nn.ReLU(inplace=True)
)
# up9
self.up9 = nn.Sequential(
nn.Conv2d(512, 256, 1),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(256, 256, 4, stride=2, padding=1, bias=False),
nn.ReLU(inplace=True)
)
# up10
self.up10 = nn.Sequential(
nn.Conv2d(256, 128, 1),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(128, 128, 4, stride=2, padding=1, bias=False),
nn.ReLU(inplace=True)
)
self.up11 = nn.Sequential(
nn.Conv2d(128, 64, 1),
nn.ReLU(inplace=True),
nn.ConvTranspose2d(64, 64, 4, stride=2, padding=1, bias=False),
nn.ReLU(inplace=True)
)
self.last = nn.Sequential(
nn.Conv2d(64, 3, 1),
nn.Tanh()
)
def __init__(self):
"""CNN Builder."""
super(SpinalCNN, self).__init__()
self.conv_layer = nn.Sequential(
# Conv Layer block 1
nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3,
padding=1),
nn.BatchNorm2d(32),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=32,
out_channels=64,
kernel_size=3,
padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
# Conv Layer block 2
nn.Conv2d(in_channels=64,
out_channels=128,
kernel_size=3,
padding=1),
nn.BatchNorm2d(128),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=128,
out_channels=128,
kernel_size=3,
padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
nn.Dropout2d(p=0.05),
# Conv Layer block 3
nn.Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
padding=1),
nn.BatchNorm2d(256),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=256,
out_channels=256,
kernel_size=3,
padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=2, stride=2),
)
self.fc_spinal_layer1 = nn.Sequential(
nn.Dropout(p=0.1),
nn.Linear(Half_width, layer_width),
nn.ReLU(inplace=True),
)
self.fc_spinal_layer2 = nn.Sequential(
nn.Dropout(p=0.1),
nn.Linear(Half_width + layer_width, layer_width),
nn.ReLU(inplace=True),
)
self.fc_spinal_layer3 = nn.Sequential(
nn.Dropout(p=0.1),
nn.Linear(Half_width + layer_width, layer_width),
nn.ReLU(inplace=True),
)
self.fc_spinal_layer4 = nn.Sequential(
nn.Dropout(p=0.1),
nn.Linear(Half_width + layer_width, layer_width),
nn.ReLU(inplace=True),
)
self.fc_out = nn.Sequential(nn.Dropout(p=0.1),
nn.Linear(layer_width * 4, 100))
def __init__(self):
super(deeplab_vgg, self).__init__()
self.conv_flag = True
self.use_residual = False
self.conv1 = nn.Sequential(
nn.Conv2d(in_channels=3,out_channels=64,kernel_size=3,stride=1,padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=64,out_channels=64,kernel_size=3,stride=1,padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3,stride=2,padding=1,ceil_mode=True),
)
self.conv2 = nn.Sequential(
nn.Conv2d(in_channels=64,out_channels=128,kernel_size=3,stride=1,padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=128,out_channels=128,kernel_size=3,stride=1,padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3,stride=2,padding=1,ceil_mode=True),
)
self.conv3 = nn.Sequential(
nn.Conv2d(in_channels=128,out_channels=256,kernel_size=3,stride=1,padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=256,out_channels=256,kernel_size=3,stride=1,padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3,stride=2,padding=1 ,ceil_mode=True),
)
self.conv4 = nn.Sequential(
nn.Conv2d(in_channels=256,out_channels=512,kernel_size=3, stride=1,padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=512, out_channels=512, kernel_size=3, stride=1,padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=512, out_channels= 512, kernel_size=3, stride=1,padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=1,padding=1,ceil_mode=True),
)
self.conv5 = nn.Sequential(
nn.Conv2d(in_channels=512,out_channels=512,kernel_size=3, dilation=2 ,stride=1,padding=2),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=512,out_channels=512, kernel_size=3, dilation=2 ,stride=1, padding=2),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=512,out_channels=512, kernel_size=3, dilation=2, stride=1, padding=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3 ,stride=1, padding=1,ceil_mode=True),
nn.AvgPool2d(kernel_size=3 , stride=1, padding=1,ceil_mode=True),
)
self.fc6 = nn.Sequential(
nn.Conv2d(in_channels=512,out_channels=1024,kernel_size=3,dilation=12,padding=12),
nn.ReLU(inplace=True),
nn.Dropout2d()
)
self.fc7 = nn.Sequential(
nn.Conv2d(in_channels=1024,out_channels=1024,kernel_size=1),
nn.ReLU(inplace=True),
nn.Dropout2d(),
)
self.score = nn.Conv2d(in_channels=1024,out_channels=21,kernel_size=1)
self.AttentionBranch = AB.AttentionBranch(self.conv_flag,self.use_residual)
self.WeightedContextEmedding = AB.Attention_Weighted_Context_Generation()
self.Adaptive_Scale_Feature_Embedding = AB.Adaptive_Scale_Feature_Embedding(embedding_dim=1024,out_feature_dim=1024)
def __init__(self,
ratio=1,
keyPoints=68,
dropOutRate=0.1,
temperature=1.,
imageSize=80):
super(GeneratorGhostConv, self).__init__()
self.featureMaps = [int(64 // ratio), int(128 // ratio)]
self.keyPoints = keyPoints
self.activation = nn.LeakyReLU(0.2)
self.dropOutRate = dropOutRate
self.softmax = nn.Softmax(dim=2)
self.temperature = temperature
self.imageSize = imageSize
self.spatialRange = torch.Tensor(list(range(0, self.imageSize)))
self.blockE1 = nn.Sequential(GhostModule(3, self.featureMaps[0]),
# self.activation
)
self.blockE2 = nn.Sequential(
nn.MaxPool2d(kernel_size=2),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Dropout2d(self.dropOutRate))
self.blockE3 = nn.Sequential(
nn.MaxPool2d(kernel_size=2),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Dropout2d(self.dropOutRate))
self.blockE4 = nn.Sequential(
nn.MaxPool2d(kernel_size=2),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Dropout2d(self.dropOutRate))
self.blockD4 = nn.Sequential(
nn.MaxPool2d(kernel_size=2),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Dropout2d(self.dropOutRate),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Upsample(scale_factor=2))
self.blockD3 = nn.Sequential(
GhostModule(self.featureMaps[1], self.featureMaps[0]),
# self.activation,
nn.Dropout2d(self.dropOutRate),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Upsample(scale_factor=2))
self.blockD2 = nn.Sequential(
GhostModule(self.featureMaps[1], self.featureMaps[0]),
# self.activation,
nn.Dropout2d(self.dropOutRate),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Upsample(scale_factor=2))
self.blockD1 = nn.Sequential(
GhostModule(self.featureMaps[1], self.featureMaps[0]),
# self.activation,
nn.Dropout2d(self.dropOutRate),
GhostModule(self.featureMaps[0], self.featureMaps[0]),
# self.activation,
nn.Upsample(scale_factor=2))
self.blockT = nn.Sequential(
GhostModule(self.featureMaps[1], self.featureMaps[1]),
# self.activation,
nn.Dropout(self.dropOutRate),
nn.Conv2d(self.featureMaps[1],
self.keyPoints,
kernel_size=1,
stride=1,
padding=0),
nn.BatchNorm2d(self.keyPoints),
self.activation,
nn.Dropout(self.dropOutRate),
nn.Conv2d(self.keyPoints,
self.keyPoints,
kernel_size=1,
stride=1,
padding=0),
nn.BatchNorm2d(self.keyPoints),
self.activation,
nn.Conv2d(self.keyPoints,
self.keyPoints,
kernel_size=1,
stride=1,
padding=0),
)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_uniform_(m.weight)
nn.init.constant_(m.bias, 0.)
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1.)
nn.init.constant_(m.bias, 0.)
def __init__(
self,
layers=3,
n_feature=256,
dropout=0.0,
h_height=14,
h_width=3,
height=117,
width=24,
state_dimension=5,
):
super(Decoder, self).__init__()
self.layers = layers
self.n_feature = n_feature
self.dropout = dropout
self.h_height = h_height
self.h_width = h_width
self.height = height
self.width = width
self.state_dimension = state_dimension
assert self.layers == 3
assert self.n_feature % 4 == 0
self.feature_maps = [
int(self.n_feature),
int(self.n_feature / 2),
int(self.n_feature / 4),
]
self.f_decoder = nn.Sequential(
nn.ConvTranspose2d(
self.feature_maps[0], self.feature_maps[1], (4, 4), 2, 1
),
# nn.GroupNorm(self.feature_maps[1] // GROUP_NORM_ELEMENTS, self.feature_maps[1]),
nn.Dropout2d(p=self.dropout, inplace=True),
nn.LeakyReLU(0.2, inplace=True),
nn.ConvTranspose2d(
self.feature_maps[1], self.feature_maps[2], (5, 5), 2, (0, 1),
),
nn.Dropout2d(p=self.dropout, inplace=True),
nn.LeakyReLU(0.2, inplace=True),
nn.ConvTranspose2d(self.feature_maps[2], 3, (2, 2), 2, (0, 1)),
)
self.h_reducer = nn.Sequential(
nn.Conv2d(self.n_feature, self.n_feature, 4, 2, 1),
# nn.GroupNorm(self.n_feature // GROUP_NORM_ELEMENTS, self.n_feature),
nn.Dropout2d(p=self.dropout, inplace=True),
nn.LeakyReLU(0.2, inplace=True),
nn.Conv2d(self.n_feature, self.n_feature, (4, 1), (2, 1), 0,),
nn.Dropout2d(p=self.dropout, inplace=True),
nn.LeakyReLU(0.2, inplace=True),
)
if self.state_dimension > 0:
self.s_predictor = nn.Sequential(
nn.Linear(2 * self.n_feature, self.n_feature),
nn.Dropout(p=self.dropout, inplace=True),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(self.n_feature, self.n_feature),
nn.Dropout(p=self.dropout, inplace=True),
nn.LeakyReLU(0.2, inplace=True),
nn.Linear(self.n_feature, self.state_dimension),
)
def __init__(self, input_size=256):
super(Unet, self).__init__()
self.maxpool = nn.MaxPool2d(kernel_size=2)
self.spatial_dropout = nn.Dropout2d(p=0.5, inplace=False)
self.relu = nn.ReLU(inplace=False)
self.maxpool = nn.MaxPool2d(kernel_size=2)
self.sigmoid = nn.Sigmoid()
self.num_groups = 1
self.conv1_1 = DepthwiseSeparableConv(input_size, n_channels_in=3, n_channels_out=64,
kernel_size=3, padding='same', stride=1)
self.batch_norm_1_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=64)
self.conv1_2 = DepthwiseSeparableConv(input_size, n_channels_in=64, n_channels_out=64,
kernel_size=3, padding='same', stride=1)
self.convmax1_2 = DepthwiseSeparableConv(input_size, n_channels_in=64, n_channels_out=64,
kernel_size=2, padding=0, stride=2)
self.batch_norm_1_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=64)
self.conv2_1 = DepthwiseSeparableConv(input_size / 2, n_channels_in=64, n_channels_out=128,
kernel_size=3, padding='same', stride=1)
self.batch_norm_2_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=128)
self.conv2_2 = DepthwiseSeparableConv(input_size / 2, n_channels_in=128, n_channels_out=128,
kernel_size=3, padding='same', stride=1)
self.convmax2_2 = DepthwiseSeparableConv(input_size / 2, n_channels_in=128, n_channels_out=128,
kernel_size=2, padding=0, stride=2)
self.batch_norm_2_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=128)
self.conv3_1 = DepthwiseSeparableConv(input_size / 4, n_channels_in=128, n_channels_out=256,
kernel_size=3, padding='same', stride=1)
self.batch_norm_3_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=256)
self.conv3_2 = DepthwiseSeparableConv(input_size / 4, n_channels_in=256, n_channels_out=256,
kernel_size=3, padding='same', stride=1)
self.convmax3_2 = DepthwiseSeparableConv(input_size / 4, n_channels_in=256, n_channels_out=256,
kernel_size=2, padding=0, stride=2)
self.batch_norm_3_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=256)
self.conv4_1 = DepthwiseSeparableConv(input_size / 8, n_channels_in=256, n_channels_out=512,
kernel_size=3, padding='same', stride=1)
self.batch_norm_4_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=512)
self.conv4_2 = DepthwiseSeparableConv(input_size / 8, n_channels_in=512, n_channels_out=512,
kernel_size=3, padding='same', stride=1)
self.convmax4_2 = DepthwiseSeparableConv(input_size / 8, n_channels_in=512, n_channels_out=512,
kernel_size=2, padding=0, stride=2)
self.batch_norm_4_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=512)
self.conv5_1 = DepthwiseSeparableConv(input_size / 16, n_channels_in=512, n_channels_out=1024,
kernel_size=3, padding='same', stride=1)
self.batch_norm_5_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=1024)
self.conv5_2 = DepthwiseSeparableConv(input_size / 16, n_channels_in=1024, n_channels_out=1024,
kernel_size=3, padding='same', stride=1)
self.batch_norm_5_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=1024)
self.upconv6_1 = TransposeConv(input_size/16, n_channels_in=1024, n_channels_out=512,
kernel_size=2, stride=2, padding=0)
self.batch_norm_up6_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=512)
self.conv6_1 = DepthwiseSeparableConv(input_size / 8, n_channels_in=512+512, n_channels_out=512,
kernel_size=3, padding='same', stride=1)
self.batch_norm_conv6_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=512)
self.conv6_2 = DepthwiseSeparableConv(input_size / 8, n_channels_in=512, n_channels_out=512,
kernel_size=3, padding='same', stride=1)
self.batch_norm_6_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=512)
self.upconv7_1 = TransposeConv(input_size / 8, n_channels_in=512, n_channels_out=256,
kernel_size=2, stride=2,
padding=0)
self.batch_norm_up7_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=256)
self.conv7_1 = DepthwiseSeparableConv(input_size / 4, n_channels_in=256 + 256, n_channels_out=256,
kernel_size=3, padding='same', stride=1)
self.batch_norm_conv7_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=256)
self.conv7_2 = DepthwiseSeparableConv(input_size / 4, n_channels_in=256, n_channels_out=256,
kernel_size=3, padding='same', stride=1)
self.batch_norm_7_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=256)
self.upconv8_1 = TransposeConv(input_size / 4, n_channels_in=256, n_channels_out=128, kernel_size=2, stride=2,
padding=0)
self.batch_norm_up8_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=128)
self.conv8_1 = DepthwiseSeparableConv(input_size / 2, n_channels_in=128 + 128, n_channels_out=128,
kernel_size=3, padding='same', stride=1)
self.batch_norm_conv8_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=128)
self.conv8_2 = DepthwiseSeparableConv(input_size / 2, n_channels_in=128, n_channels_out=128,
kernel_size=3, padding='same', stride=1)
self.batch_norm_8_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=128)
self.upconv9_1 = TransposeConv(input_size / 2, n_channels_in=128, n_channels_out=64, kernel_size=2, stride=2,
padding=0)
self.batch_norm_up9_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=64)
self.conv9_1 = DepthwiseSeparableConv(input_size, n_channels_in=64 + 64, n_channels_out=64,
kernel_size=3, padding='same', stride=1)
self.batch_norm_conv9_1 = nn.GroupNorm(num_groups=self.num_groups, num_channels=64)
self.conv9_2 = DepthwiseSeparableConv(input_size, n_channels_in=64, n_channels_out=64,
kernel_size=3, padding='same', stride=1)
self.batch_norm_9_2 = nn.GroupNorm(num_groups=self.num_groups, num_channels=64)
self.conv9_3 = DepthwiseSeparableConv(input_size, n_channels_in=64, n_channels_out=2,
kernel_size=3, padding='same', stride=1)
self.batch_norm_9_3 = nn.GroupNorm(num_groups=self.num_groups, num_channels=2)
self.conv9_4 = DepthwiseSeparableConv(input_size, n_channels_in=2, n_channels_out=1,
kernel_size=1, padding='same', stride=1)
def __init__(self,
block,
layers,
num_classes=1000,
zero_init_residual=False,
groups=1,
width_per_group=64,
replace_stride_with_dilation=None,
norm_layer=None):
super(ResNet, self).__init__()
if norm_layer is None:
norm_layer = nn.BatchNorm2d
self._norm_layer = norm_layer
self.inplanes = 64
self.dilation = 1
if replace_stride_with_dilation is None:
# each element in the tuple indicates if we should replace
# the 2x2 stride with a dilated convolution instead
replace_stride_with_dilation = [False, False, False]
if len(replace_stride_with_dilation) != 3:
raise ValueError("replace_stride_with_dilation should be None "
"or a 3-element tuple, got {}".format(
replace_stride_with_dilation))
self.groups = groups
self.base_width = width_per_group
self.conv1 = nn.Conv2d(3,
self.inplanes,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = norm_layer(self.inplanes)
self.relu = nn.ReLU(inplace=True)
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,
dilate=replace_stride_with_dilation[0])
self.layer3 = self._make_layer(block,
256,
layers[2],
stride=2,
dilate=replace_stride_with_dilation[1])
self.layer4 = self._make_layer(block,
512,
layers[3],
stride=2,
dilate=replace_stride_with_dilation[2])
self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
self.fc = nn.Linear(512 * block.expansion, num_classes)
self.dropout1 = nn.Dropout(0.5)
self.dropout2_hard = nn.Dropout2d(0.5)
self.dropout2_mid = nn.Dropout2d(0.48)
self.dropout2_light = nn.Dropout2d(0.46)
for m in self.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight,
mode='fan_out',
nonlinearity='relu')
elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
# Zero-initialize the last BN in each residual branch,
# so that the residual branch starts with zeros, and each residual block behaves like an identity.
# This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
if zero_init_residual:
for m in self.modules():
if isinstance(m, Bottleneck):
nn.init.constant_(m.bn3.weight, 0)
elif isinstance(m, BasicBlock):
nn.init.constant_(m.bn2.weight, 0)
def __init__(self, n_class=2):
super(FCN8s, self).__init__()
# conv1
self.conv1_1 = nn.Conv2d(3, 64, 3, padding=100)
self.relu1_1 = nn.ReLU(inplace=True)
self.conv1_2 = nn.Conv2d(64, 64, 3, padding=1)
self.relu1_2 = nn.ReLU(inplace=True)
self.pool1 = nn.MaxPool2d(2, stride=2, ceil_mode=True) # 1/2
# conv2
self.conv2_1 = nn.Conv2d(64, 128, 3, padding=1)
self.relu2_1 = nn.ReLU(inplace=True)
self.conv2_2 = nn.Conv2d(128, 128, 3, padding=1)
self.relu2_2 = nn.ReLU(inplace=True)
self.pool2 = nn.MaxPool2d(2, stride=2, ceil_mode=True) # 1/4
# conv3
self.conv3_1 = nn.Conv2d(128, 256, 3, padding=1)
self.relu3_1 = nn.ReLU(inplace=True)
self.conv3_2 = nn.Conv2d(256, 256, 3, padding=1)
self.relu3_2 = nn.ReLU(inplace=True)
self.conv3_3 = nn.Conv2d(256, 256, 3, padding=1)
self.relu3_3 = nn.ReLU(inplace=True)
self.pool3 = nn.MaxPool2d(2, stride=2, ceil_mode=True) # 1/8
# conv4
self.conv4_1 = nn.Conv2d(256, 512, 3, padding=1)
self.relu4_1 = nn.ReLU(inplace=True)
self.conv4_2 = nn.Conv2d(512, 512, 3, padding=1)
self.relu4_2 = nn.ReLU(inplace=True)
self.conv4_3 = nn.Conv2d(512, 512, 3, padding=1)
self.relu4_3 = nn.ReLU(inplace=True)
self.pool4 = nn.MaxPool2d(2, stride=2, ceil_mode=True) # 1/16
# conv5
self.conv5_1 = nn.Conv2d(512, 512, 3, padding=1)
self.relu5_1 = nn.ReLU(inplace=True)
self.conv5_2 = nn.Conv2d(512, 512, 3, padding=1)
self.relu5_2 = nn.ReLU(inplace=True)
self.conv5_3 = nn.Conv2d(512, 512, 3, padding=1)
self.relu5_3 = nn.ReLU(inplace=True)
self.pool5 = nn.MaxPool2d(2, stride=2, ceil_mode=True) # 1/32
# fc6
self.fc6 = nn.Conv2d(512, 4096, 7)
self.relu6 = nn.ReLU(inplace=True)
self.drop6 = nn.Dropout2d()
# fc7
self.fc7 = nn.Conv2d(4096, 4096, 1)
self.relu7 = nn.ReLU(inplace=True)
self.drop7 = nn.Dropout2d()
self.score_fr = nn.Conv2d(4096, n_class, 1)
self.score_pool3 = nn.Conv2d(256, n_class, 1)
self.score_pool4 = nn.Conv2d(512, n_class, 1)
self.upscore2 = nn.ConvTranspose2d(n_class,
n_class,
4,
stride=2,
bias=False)
self.upscore8 = nn.ConvTranspose2d(n_class,
n_class,
16,
stride=8,
bias=False)
self.upscore_pool4 = nn.ConvTranspose2d(n_class,
n_class,
4,
stride=2,
bias=False)
def __init__(self, outputs, inputs):
super(BBB3Conv3FC, self).__init__()
self.num_classes = outputs
self.conv1 = BBBConv2d(inputs, 32, 3, alpha_shape=(1, 1), stride=1, padding=1, bias=True, name='conv1')
self.bn1 = nn.BatchNorm2d(32)
self.activate1 = nn.ELU()
self.drop1 = nn.Dropout2d(0.25)
self.conv2 = BBBConv2d(32, 64, 5, alpha_shape=(1, 1), stride=1, padding=2, bias=True, name='conv2')
self.bn2 = nn.BatchNorm2d(64)
self.activate2 = nn.ELU()
self.drop2 = nn.Dropout2d(0.25)
self.pool1 = BBBConv2d(64, 64, 2, alpha_shape=(1, 1), stride=2, padding=0, bias=True, name='pool1')
self.pool1_bn = nn.BatchNorm2d(64)
self.pool1_activate = nn.ELU()
self.pool1_drop = nn.Dropout2d(0.25)
self.conv4 = BBBConv2d(64, 128, 3, alpha_shape=(1, 1), stride=1, padding=1, bias=True, name='conv4')
self.bn4 = nn.BatchNorm2d(128)
self.activate4 = nn.ELU()
self.drop4 = nn.Dropout2d(0.25)
self.conv5 = BBBConv2d(128, 256, 5, alpha_shape=(1, 1), stride=1, padding=2, bias=True, name='conv5')
self.bn5 = nn.BatchNorm2d(256)
self.activate5 = nn.ELU()
self.drop5 = nn.Dropout2d(0.25)
self.pool2 = BBBConv2d(256, 256, 2, alpha_shape=(1, 1), stride=2, padding=0, bias=True, name='pool2')
self.pool2_bn = nn.BatchNorm2d(256)
self.pool2_activate = nn.ELU()
self.pool2_drop = nn.Dropout2d(0.25)
self.conv7 = BBBConv2d(256, 384, 3, alpha_shape=(1, 1), stride=1, padding=1, bias=True, name='conv7')
self.bn7 = nn.BatchNorm2d(384)
self.activate7 = nn.ELU()
self.drop7 = nn.Dropout2d(0.25)
self.conv8 = BBBConv2d(384, 512, 5, alpha_shape=(1, 1), stride=1, padding=2, bias=True, name='conv8')
self.bn8 = nn.BatchNorm2d(512)
self.activate8 = nn.ELU()
self.drop8 = nn.Dropout2d(0.25)
self.pool3 = BBBConv2d(512, 512, 2, alpha_shape=(1, 1), stride=2, padding=0, bias=True, name='pool3')
self.pool3_bn = nn.BatchNorm2d(512)
self.pool3_activate = nn.ELU()
self.pool3_drop = nn.Dropout2d(0.25)
self.conv10 = BBBConv2d(512, 640, 3, alpha_shape=(1, 1), stride=1, padding=1, bias=True, name='conv10')
self.bn10 = nn.BatchNorm2d(640)
self.activate10 = nn.ELU()
self.drop10 = nn.Dropout2d(0.25)
self.conv11 = BBBConv2d(640, 768, 5, alpha_shape=(1, 1), stride=1, padding=2, bias=True, name='conv11')
self.bn11 = nn.BatchNorm2d(768)
self.activate11 = nn.ELU()
self.drop11 = nn.Dropout2d(0.25)
self.pool4 = BBBConv2d(768, 768, 2, alpha_shape=(1, 1), stride=2, padding=0, bias=True, name='pool4')
self.pool4_bn = nn.BatchNorm2d(768)
self.pool4_activate = nn.ELU()
self.pool4_drop = nn.Dropout2d(0.25)
self.flatten = FlattenLayer(2 * 8 * 768)
self.fc1 = BBBLinear(2 * 8 * 768, 512, alpha_shape=(1, 1), bias=True, name='fc1')
self.fc1_bn = nn.BatchNorm1d(512)
self.fc1_activate = nn.ELU()
self.fc1_drop = nn.Dropout(0.50)
self.fc2 = BBBLinear(512, 256, alpha_shape=(1, 1), bias=True, name='fc2')
self.fc2_bn = nn.BatchNorm1d(256)
self.fc2_activate = nn.ELU()
self.fc2_drop = nn.Dropout(0.50)
self.fc3 = BBBLinear(256, 64, alpha_shape=(1, 1), bias=True, name='fc3')
self.fc3_bn = nn.BatchNorm1d(64)
self.fc3_activate = nn.ELU()
self.fc3_drop = nn.Dropout(0.50)
self.fc4 = BBBLinear(64, outputs, alpha_shape=(1, 1), bias=True, name='fc4')
def __init__(self, in_channels, out_channels, dropout_prob=0.0):
super().__init__()
self.conv = nn.Conv2d(in_channels, out_channels-in_channels, (3,3), 2, 1, bias=False)
self.bn = nn.BatchNorm2d(out_channels)
self.dropout = nn.Dropout2d(dropout_prob)
def __init__(self):
super(resnet_modified_small, self).__init__()
self.resnet = tv.models.resnet34(pretrained=False)
self.dropout2d = nn.Dropout2d(0.2)
#probably want linear, relu, dropout
'''self.linear = nn.Linear(7*7*512, 1024)
def __init__(self, drop_rate=0.4, bn_momentum=0.1, base_num_filters=64):
super().__init__()
self.conv1a = nn.Conv2d(1, base_num_filters, kernel_size=3, padding=1)
self.conv1a_bn = nn.BatchNorm2d(base_num_filters, momentum=bn_momentum)
self.conv1a_drop = nn.Dropout2d(drop_rate)
self.conv1b = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=1)
self.conv1b_bn = nn.BatchNorm2d(base_num_filters, momentum=bn_momentum)
self.conv1b_drop = nn.Dropout2d(drop_rate)
self.conv2a = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=2,
dilation=2)
self.conv2a_bn = nn.BatchNorm2d(base_num_filters, momentum=bn_momentum)
self.conv2a_drop = nn.Dropout2d(drop_rate)
self.conv2b = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=2,
dilation=2)
self.conv2b_bn = nn.BatchNorm2d(base_num_filters, momentum=bn_momentum)
self.conv2b_drop = nn.Dropout2d(drop_rate)
# Branch 1x1 convolution
self.branch1a = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=1)
self.branch1a_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch1a_drop = nn.Dropout2d(drop_rate)
self.branch1b = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=1)
self.branch1b_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch1b_drop = nn.Dropout2d(drop_rate)
# Branch for 3x3 rate 6
self.branch2a = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=6,
dilation=6)
self.branch2a_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch2a_drop = nn.Dropout2d(drop_rate)
self.branch2b = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=6,
dilation=6)
self.branch2b_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch2b_drop = nn.Dropout2d(drop_rate)
# Branch for 3x3 rate 12
self.branch3a = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=12,
dilation=12)
self.branch3a_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch3a_drop = nn.Dropout2d(drop_rate)
self.branch3b = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=12,
dilation=12)
self.branch3b_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch3b_drop = nn.Dropout2d(drop_rate)
# Branch for 3x3 rate 18
self.branch4a = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=18,
dilation=18)
self.branch4a_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch4a_drop = nn.Dropout2d(drop_rate)
self.branch4b = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=18,
dilation=18)
self.branch4b_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch4b_drop = nn.Dropout2d(drop_rate)
# Branch for 3x3 rate 24
self.branch5a = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=24,
dilation=24)
self.branch5a_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch5a_drop = nn.Dropout2d(drop_rate)
self.branch5b = nn.Conv2d(base_num_filters,
base_num_filters,
kernel_size=3,
padding=24,
dilation=24)
self.branch5b_bn = nn.BatchNorm2d(base_num_filters,
momentum=bn_momentum)
self.branch5b_drop = nn.Dropout2d(drop_rate)
self.concat_drop = nn.Dropout2d(drop_rate)
self.concat_bn = nn.BatchNorm2d(6 * base_num_filters,
momentum=bn_momentum)
self.amort = nn.Conv2d(6 * base_num_filters,
base_num_filters * 2,
kernel_size=1)
self.amort_bn = nn.BatchNorm2d(base_num_filters * 2,
momentum=bn_momentum)
self.amort_drop = nn.Dropout2d(drop_rate)
self.prediction = nn.Conv2d(base_num_filters * 2, 1, kernel_size=1)
def __init__(self, in_feat, out_feat, drop_rate=0.3):
super(DownConv, self).__init__()
self.conv1 = nn.Conv2d(in_feat, out_feat, kernel_size=3, padding=1)
self.conv2 = nn.Conv2d(out_feat, out_feat, kernel_size=3, padding=1)
self.conv1_drop = nn.Dropout2d(drop_rate)
def __init__(self):
super(DualGansGenerator, self).__init__()
nc = 3
ngf = 64
# Convolution layers
# input is (nc) x 256 x 256
self.conv1 = nn.Conv2d(nc, ngf, 4, 2, 1, bias=True)
self.lr1 = nn.LeakyReLU(inplace=True)
# state size. (ngf) x 128 x 128
self.conv2 = nn.Conv2d(ngf, ngf * 2, 4, 2, 1, bias=True)
self.bn2 = nn.BatchNorm2d(ngf * 2)
self.lr2 = nn.LeakyReLU(inplace=True)
# state size. (ngf*2) x 64 x 64
self.conv3 = nn.Conv2d(ngf * 2, ngf * 4, 4, 2, 1, bias=True)
self.bn3 = nn.BatchNorm2d(ngf * 4)
self.lr3 = nn.LeakyReLU(inplace=True)
# state size. (ngf*4) x 32 x 32
self.conv4 = nn.Conv2d(ngf * 4, ngf * 8, 4, 2, 1, bias=True)
self.bn4 = nn.BatchNorm2d(ngf * 8)
self.lr4 = nn.LeakyReLU(inplace=True)
# state size. (ngf*8) x 16 x 16
self.conv5 = nn.Conv2d(ngf * 8, ngf * 8, 4, 2, 1, bias=True)
self.bn5 = nn.BatchNorm2d(ngf * 8)
self.lr5 = nn.LeakyReLU(inplace=True)
# state size. (ngf*8) x 8 x 8
self.conv6 = nn.Conv2d(ngf * 8, ngf * 8, 4, 2, 1, bias=True)
self.bn6 = nn.BatchNorm2d(ngf * 8)
self.lr6 = nn.LeakyReLU(inplace=True)
# state size. (ngf*8) x 4 x 4
self.conv7 = nn.Conv2d(ngf * 8, ngf * 8, 4, 2, 1, bias=True)
self.bn7 = nn.BatchNorm2d(ngf * 8)
self.lr7 = nn.LeakyReLU(inplace=True)
# state size. (ngf*8) x 2 x 2
self.conv8 = nn.Conv2d(ngf * 8, ngf * 8, 4, 2, 1, bias=True)
self.bn8 = nn.BatchNorm2d(ngf * 8)
self.r8 = nn.ReLU(inplace=True)
# Transposed Convolutional Layers
# input is (ngf*8) x 1 x 1
self.tr_conv1 = nn.ConvTranspose2d(ngf * 8,
ngf * 8,
4,
2,
1,
bias=True)
self.tr_bn1 = nn.BatchNorm2d(ngf * 8)
self.tr_d1 = nn.Dropout2d(p=0.5, inplace=True)
self.tr_r1 = nn.ReLU(inplace=True)
# state size. (ngf*8)*2 x 2 x 2
self.tr_conv2 = nn.ConvTranspose2d((ngf * 8) * 2,
ngf * 8,
4,
2,
1,
bias=True)
self.tr_bn2 = nn.BatchNorm2d(ngf * 8)
self.tr_d2 = nn.Dropout2d(p=0.5, inplace=True)
self.tr_r2 = nn.ReLU(inplace=True)
# state size. (ngf*8)*2 x 4 x 4
self.tr_conv3 = nn.ConvTranspose2d((ngf * 8) * 2,
ngf * 8,
4,
2,
1,
bias=True)
self.tr_bn3 = nn.BatchNorm2d(ngf * 8)
self.tr_d3 = nn.Dropout2d(p=0.5, inplace=True)
self.tr_r3 = nn.ReLU(inplace=True)
# state size. (ngf*8)*2 x 8 x 8
self.tr_conv4 = nn.ConvTranspose2d((ngf * 8) * 2,
ngf * 8,
4,
2,
1,
bias=True)
self.tr_bn4 = nn.BatchNorm2d(ngf * 8)
self.tr_r4 = nn.ReLU(inplace=True)
# state size. (ngf*8)*2 x 16 x 16
self.tr_conv5 = nn.ConvTranspose2d((ngf * 8) * 2,
ngf * 4,
4,
2,
1,
bias=True)
self.tr_bn5 = nn.BatchNorm2d(ngf * 4)
self.tr_r5 = nn.ReLU(inplace=True)
# state size. (ngf*4)*2 x 32 x 32
self.tr_conv6 = nn.ConvTranspose2d((ngf * 4) * 2,
ngf * 2,
4,
2,
1,
bias=True)
self.tr_bn6 = nn.BatchNorm2d(ngf * 2)
self.tr_r6 = nn.ReLU(inplace=True)
# state size. (ngf*2)*2 x 64 x 64
self.tr_conv7 = nn.ConvTranspose2d((ngf * 2) * 2,
ngf,
4,
2,
1,
bias=True)
self.tr_bn7 = nn.BatchNorm2d(ngf)
self.tr_r7 = nn.ReLU(inplace=True)
# state size. (ngf)*2 x 128 x 128
self.tr_conv8 = nn.ConvTranspose2d((ngf) * 2, nc, 4, 2, 1, bias=True)
self.out = nn.Tanh()
def __init__(self, hyper) -> None:
super(MultiHeadSelection, self).__init__()
self.device = torch.device('cpu')
self.hyper = hyper
self.data_root = hyper.data_root
self.gpu = hyper.gpu
self.word_vocab = json.load(
open(os.path.join(self.data_root, 'word_vocab.json'), 'r'))
self.relation_vocab = json.load(
open(os.path.join(self.data_root, 'relation_vocab.json'), 'r'))
self.bio_vocab = json.load(
open(os.path.join(self.data_root, 'bio_vocab.json'), 'r'))
self.id2bio = {v: k for k, v in self.bio_vocab.items()}
self.word_embeddings = nn.Embedding(num_embeddings=len(
self.word_vocab),
embedding_dim=hyper.emb_size)
self.relation_emb = nn.Embedding(num_embeddings=len(
self.relation_vocab),
embedding_dim=hyper.rel_emb_size)
# bio + pad
self.bio_emb = nn.Embedding(num_embeddings=len(self.bio_vocab),
embedding_dim=hyper.bio_emb_size)
if hyper.cell_name == 'gru':
self.encoder = nn.GRU(hyper.emb_size,
hyper.hidden_size,
bidirectional=True,
batch_first=True)
elif hyper.cell_name == 'lstm':
self.encoder = nn.LSTM(hyper.emb_size,
hyper.hidden_size,
bidirectional=True,
batch_first=True,
num_layers=2)
elif hyper.cell_name == 'bert':
self.post_lstm = nn.LSTM(hyper.emb_size,
hyper.hidden_size,
bidirectional=True,
batch_first=True)
self.encoder = BertModel.from_pretrained('data/bert-base-uncased')
for name, param in self.encoder.named_parameters():
if '11' in name:
param.requires_grad = True
else:
param.requires_grad = False
# print(name, param.size())
else:
raise ValueError('cell name should be gru/lstm/bert!')
if hyper.activation.lower() == 'relu':
self.activation = nn.ReLU()
elif hyper.activation.lower() == 'tanh':
self.activation = nn.Tanh()
else:
raise ValueError('unexpected activation!')
self.emission = nn.Linear(hyper.hidden_size, len(self.bio_vocab) - 1)
self.norm1 = nn.BatchNorm1d(self.hyper.max_text_len)
self.dropout1 = nn.Dropout(0)
self.tagger = CRF(len(self.bio_vocab) - 1, batch_first=True)
self.selection_u = nn.Linear(hyper.hidden_size + hyper.bio_emb_size,
hyper.rel_emb_size)
self.norm2 = nn.BatchNorm1d(self.hyper.max_text_len)
self.dropout2 = nn.Dropout(0)
self.selection_v = nn.Linear(hyper.hidden_size + hyper.bio_emb_size,
hyper.rel_emb_size)
self.norm3 = nn.BatchNorm1d(self.hyper.max_text_len)
self.dropout3 = nn.Dropout(0)
self.selection_uv = nn.Linear(2 * hyper.rel_emb_size,
hyper.rel_emb_size)
self.norm4 = nn.BatchNorm2d(self.hyper.max_text_len,
self.hyper.max_text_len)
self.dropout4 = nn.Dropout2d(0)
self.bert2hidden = nn.Linear(768, hyper.hidden_size)
# for bert_lstm
# self.bert2hidden = nn.Linear(768, hyper.emb_size)
if self.hyper.cell_name == 'bert':
self.bert_tokenizer = BertTokenizer.from_pretrained(
'bert-base-uncased')
def __init__(self):
super(Model, self).__init__()
self.conv = nn.ConvTranspose2d(3, 8, 3)
self.dropout = nn.Dropout2d()
def MulResUnet(num_input_channels=1,
num_output_channels=1,
num_channels_down=[16, 32, 64, 128, 256],
num_channels_up=[16, 32, 64, 128, 256],
num_channels_skip=[16, 32, 64, 128],
alpha=1.67,
last_act_fun=None,
need_bias=True,
upsample_mode='nearest',
act_fun='LeakyReLU',
dropout=0.):
assert len(num_channels_down) == len(num_channels_up) == (len(num_channels_skip) + 1)
n_scales = len(num_channels_down)
if not (isinstance(upsample_mode, list) or isinstance(upsample_mode, tuple)):
upsample_mode = [upsample_mode] * n_scales
model = nn.Sequential()
model_tmp = model
multires = MultiResBlock(num_channels_down[0], num_input_channels,
alpha=alpha, act_fun=act_fun, bias=need_bias, drop=dropout)
model_tmp.add(multires)
input_depth = multires.out_dim
for i in range(1, n_scales):
deeper = nn.Sequential()
skip = nn.Sequential()
# multi-res Block in the encoders
multires = MultiResBlock(num_channels_down[i], input_depth,
alpha=alpha, act_fun=act_fun, bias=need_bias, drop=dropout)
# stride downsampling.
deeper.add(conv(input_depth, input_depth, 3, stride=2, bias=need_bias))
deeper.add(act(act_fun))
deeper.add(nn.Dropout2d(dropout))
deeper.add(multires)
if num_channels_skip[i - 1] != 0:
# add the path residual block, note that the number of filters is set to 1.
skip.add(PathRes(input_depth, num_channels_skip[i - 1], 1, act_fun=act_fun, bias=need_bias, drop=dropout))
model_tmp.add(Concat(1, skip, deeper))
else:
model_tmp.add(deeper)
deeper_main = nn.Sequential()
if i != len(num_channels_down) - 1:
# not the deepest
deeper.add(deeper_main)
# add upsampling to the decoder
deeper.add(nn.Upsample(scale_factor=2, mode=upsample_mode[i]))
# add multi-res block to the decoder
model_tmp.add(MultiResBlock(num_channels_up[i - 1], multires.out_dim + num_channels_skip[i - 1],
alpha=alpha, act_fun=act_fun, bias=need_bias, drop=dropout))
input_depth = multires.out_dim
model_tmp = deeper_main
W = num_channels_up[0] * alpha
last_kernel = int(W * 0.167) + int(W * 0.333) + int(W * 0.5)
# add the convolutional filter for output.
model.add(conv(last_kernel, num_output_channels, 1, bias=need_bias))
if isinstance(last_act_fun, str) and last_act_fun.lower() == 'none':
last_act_fun = None
if last_act_fun is not None:
model.add(act(last_act_fun))
return model
def __init__(self, model_size='DETNAS-300M'):
super(ShuffleNetV2DetNAS, self).__init__()
print('Model size is {}.'.format(model_size))
n_class = 1000
if '300M' in model_size:
stage_repeats = [4, 4, 8, 4]
stage_out_channels = [-1, 16, 64, 160, 320, 640, 1024]
elif '1.3G' in model_size:
stage_repeats = [8, 8, 16, 8]
stage_out_channels = [-1, 48, 96, 240, 480, 960, 1024]
else:
raise NotImplementedError
self.stage_repeats = stage_repeats
self.first_conv = ConvBNReLU(in_channel=3,
out_channel=stage_out_channels[1],
k_size=3,
stride=2,
padding=1,
gaussian_init=True)
self.features = list()
self.stage_ends_idx = list()
in_channels = stage_out_channels[1]
i_th = 0
for id_stage in range(1, len(stage_repeats) + 1):
out_channels = stage_out_channels[id_stage + 1]
repeats = stage_repeats[id_stage - 1]
for id_repeat in range(repeats):
prefix = str(id_stage) + chr(ord('a') + id_repeat)
stride = 1 if id_repeat > 0 else 2
_ops = nn.ModuleList()
for i in range(len(blocks_key)):
_ops.append(
ShuffleNetV2BlockSearched(
prefix,
in_channels=in_channels,
out_channels=out_channels,
stride=stride,
base_mid_channels=out_channels // 2,
id=i))
self.features.append(_ops)
in_channels = out_channels
i_th += 1
self.stage_ends_idx.append(i_th - 1)
self.features = nn.Sequential(*self.features)
self.last_conv = ConvBNReLU(in_channel=in_channels,
out_channel=stage_out_channels[-1],
k_size=1,
stride=1,
padding=0)
self.drop_out = nn.Dropout2d(p=0.2)
self.global_pool = nn.AvgPool2d(7)
self.fc = FC(in_channels=stage_out_channels[-1], out_channels=n_class)
self._initialize_weights()
def __init__(self,
num_classes=1,
num_filters=32,
encoder=None,
pretrained=False,
is_deconv=False,
dropout=0,
base_num_filters=512):
"""
:param num_classes:
:param num_filters:
:param pretrained:
False - no pre-trained network is used
True - encoder is pre-trained with resnet34
:is_deconv:
False: bilinear interpolation is used in decoder
True: deconvolution is used in decoder
"""
super().__init__()
self.num_classes = num_classes
self.encoder = encoder
if encoder is None:
self.encoder = torchvision.models.resnet34(pretrained=pretrained)
self.relu = nn.ReLU(inplace=True)
try:
self.initial = self.encoder.layer0
except:
self.initial = self.encoder
try:
self.pool = self.initial.pool
except:
self.pool = nn.MaxPool2d(3, stride=2, ceil_mode=True)
self.conv1 = nn.Sequential(self.initial.conv1, self.initial.bn1,
nn.ReLU(inplace=True), self.pool)
self.conv2 = self.encoder.layer1
self.conv3 = self.encoder.layer2
self.conv4 = self.encoder.layer3
self.conv5 = self.encoder.layer4
self.center = DecoderBlockV2(base_num_filters, num_filters * 8 * 2,
num_filters * 8, is_deconv)
self.dec5 = DecoderBlockV2(base_num_filters + num_filters * 8,
num_filters * 8 * 2, num_filters * 8,
is_deconv)
self.dec4 = DecoderBlockV2(base_num_filters // 2 + num_filters * 8,
num_filters * 8 * 2, num_filters * 8,
is_deconv)
self.dec3 = DecoderBlockV2(base_num_filters // 4 + num_filters * 8,
num_filters * 4 * 2, num_filters * 2,
is_deconv)
self.dec2 = DecoderBlockV2(base_num_filters // 8 + num_filters * 2,
num_filters * 2 * 2, num_filters * 2 * 2,
is_deconv)
self.dec1 = DecoderBlockV2(num_filters * 2 * 2, num_filters * 2 * 2,
num_filters, is_deconv)
self.dec0 = ConvRelu(num_filters, num_filters)
self.final = nn.Conv2d(num_filters, num_classes, kernel_size=1)
self.dropout2d = nn.Dropout2d(p=dropout) if dropout else None
self.pool = nn.MaxPool2d(2, 2)
def __init__(self,
channels,
internal_ratio=4,
kernel_size=3,
padding=0,
dilation=1,
asymmetric=False,
dropout_prob=0,
bias=False,
relu=True):
super().__init__()
# Check in the internal_scale parameter is within the expected range
# [1, channels]
if internal_ratio <= 1 or internal_ratio > channels:
raise RuntimeError(
"Value out of range. Expected value in the "
"interval [1, {0}], got internal_scale={1}.".format(
channels, internal_ratio))
internal_channels = channels // internal_ratio
if relu:
activation = nn.ReLU()
else:
activation = nn.PReLU()
# Main branch - shortcut connection
# Extension branch - 1x1 convolution, followed by a regular, dilated or
# asymmetric convolution, followed by another 1x1 convolution, and,
# finally, a regularizer (spatial dropout). Number of channels is constant.
# 1x1 projection convolution
self.ext_conv1 = nn.Sequential(
nn.Conv2d(channels,
internal_channels,
kernel_size=1,
stride=1,
bias=bias), nn.BatchNorm2d(internal_channels),
activation)
# If the convolution is asymmetric we split the main convolution in
# two. Eg. for a 5x5 asymmetric convolution we have two convolution:
# the first is 5x1 and the second is 1x5.
if asymmetric:
self.ext_conv2 = nn.Sequential(
nn.Conv2d(internal_channels,
internal_channels,
kernel_size=(kernel_size, 1),
stride=1,
padding=(padding, 0),
dilation=dilation,
bias=bias), nn.BatchNorm2d(internal_channels),
activation,
nn.Conv2d(internal_channels,
internal_channels,
kernel_size=(1, kernel_size),
stride=1,
padding=(0, padding),
dilation=dilation,
bias=bias), nn.BatchNorm2d(internal_channels),
activation)
else:
self.ext_conv2 = nn.Sequential(
nn.Conv2d(internal_channels,
internal_channels,
kernel_size=kernel_size,
stride=1,
padding=padding,
dilation=dilation,
bias=bias), nn.BatchNorm2d(internal_channels),
activation)
# 1x1 expansion convolution
self.ext_conv3 = nn.Sequential(
nn.Conv2d(internal_channels,
channels,
kernel_size=1,
stride=1,
bias=bias), nn.BatchNorm2d(channels), activation)
self.ext_regul = nn.Dropout2d(p=dropout_prob)
# PReLU layer to apply after adding the branches
self.out_prelu = activation
def __init__(self,
input_channels=1,
nb_filter=[32, 64, 128, 256, 512],
layers=[3, 4, 6, 3]):
super().__init__()
self.deepsupervision = False
backbone_num = [64, 128, 256, 512]
self.dropout2d = nn.Dropout2d(p=0.05)
self.pool = nn.MaxPool2d(2, 2)
self.up = nn.Upsample(scale_factor=2,
mode='bilinear',
align_corners=True)
self.conv0_0 = VGGBlock(32, nb_filter[0], nb_filter[0])
self.conv1_0 = VGGBlock(nb_filter[0], nb_filter[1], nb_filter[1])
self.conv2_0 = VGGBlock(nb_filter[1], nb_filter[2], nb_filter[2])
self.conv3_0 = VGGBlock(nb_filter[2], nb_filter[3], nb_filter[3])
self.conv4_0 = VGGBlock(nb_filter[3], nb_filter[4], nb_filter[4])
self.conv0_1 = VGGBlock(nb_filter[0] + nb_filter[1], nb_filter[0],
nb_filter[0])
self.conv1_1 = VGGBlock(nb_filter[1] + nb_filter[2], nb_filter[1],
nb_filter[1])
self.conv2_1 = VGGBlock(nb_filter[2] + nb_filter[3], nb_filter[2],
nb_filter[2])
self.conv3_1 = VGGBlock(nb_filter[3] + nb_filter[4], nb_filter[3],
nb_filter[3])
self.ca0 = CALayer(nb_filter[0] + nb_filter[1])
self.ca1 = CALayer(nb_filter[1] + nb_filter[2])
self.ca2 = CALayer(nb_filter[2] + nb_filter[3])
self.ca3 = CALayer(nb_filter[3] + nb_filter[4])
self.conv0_2 = VGGBlock(nb_filter[0] * 2 + nb_filter[1], nb_filter[0],
nb_filter[0])
self.conv1_2 = VGGBlock(nb_filter[1] * 2 + nb_filter[2], nb_filter[1],
nb_filter[1])
self.conv2_2 = VGGBlock(nb_filter[2] * 2 + nb_filter[3], nb_filter[2],
nb_filter[2])
self.ca4 = CALayer(nb_filter[0] * 2 + nb_filter[1])
self.ca5 = CALayer(nb_filter[1] * 2 + nb_filter[2])
self.ca6 = CALayer(nb_filter[2] * 2 + nb_filter[3])
self.conv0_3 = VGGBlock(nb_filter[0] * 3 + nb_filter[1], nb_filter[0],
nb_filter[0])
self.conv1_3 = VGGBlock(nb_filter[1] * 3 + nb_filter[2], nb_filter[1],
nb_filter[1])
self.ca7 = CALayer(nb_filter[0] * 3 + nb_filter[1])
self.ca8 = CALayer(nb_filter[1] * 3 + nb_filter[2])
self.conv0_4 = VGGBlock(nb_filter[0] * 4 + nb_filter[1], nb_filter[0],
nb_filter[0])
self.last = nn.Conv2d(nb_filter[0], 1, kernel_size=1)
self.out_2 = nn.Softmax(dim=1)
if self.deepsupervision:
self.final1 = nn.Conv2d(nb_filter[0], nb_filter[0], kernel_size=1)
self.final2 = nn.Conv2d(nb_filter[0], nb_filter[0], kernel_size=1)
self.final3 = nn.Conv2d(nb_filter[0], nb_filter[0], kernel_size=1)
self.final4 = nn.Conv2d(nb_filter[0], nb_filter[0], kernel_size=1)
else:
self.final = nn.Conv2d(nb_filter[0], 2, kernel_size=1)
self.ResNet = ResNet(input_channels, Bottleneck, layers, nb_filter)
# N FUSION MODULE
self.fusion1 = Add_fusion(nb_filter[0], nb_filter[1])
self.fusion2 = Add_fusion(nb_filter[1], nb_filter[2])
self.fusion3 = Add_fusion(nb_filter[2], nb_filter[3])
self.ac1 = nn.Conv2d(nb_filter[3], nb_filter[2], 1)
self.ac2 = nn.Conv2d(nb_filter[2], nb_filter[1], 1)
self.ac3 = nn.Conv2d(nb_filter[1], nb_filter[0], 1)
self.fusion_conv = nn.Conv2d(nb_filter[0], 2, kernel_size=1)
self.c1 = nn.Conv2d(nb_filter[1], 2, 1)
self.c2 = nn.Conv2d(nb_filter[2], 2, 1)
self.c3 = nn.Conv2d(nb_filter[3], 2, 1)
