def __init__(self, ninput, noutput, use_sppad=False, split=1): super(DownsamplerBlock, self).__init__() self.ninput = ninput self.noutput = noutput if self.ninput < self.noutput: # Wout > Win self.conv = spConv2d(ninput, noutput - ninput, kernel_size=3, stride=2, padding=1, use_sppad=use_sppad, split=split) self.pool = nn.MaxPool2d(2, stride=2) else: # Wout < Win self.conv = spConv2d(ninput, noutput, kernel_size=3, stride=2, padding=1, use_sppad=use_sppad, split=split) self.bn = nn.BatchNorm2d(noutput)
def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, groups=1, bias=False, use_sppad=False, split=1): super(BasicBlock, self).__init__() self.conv1 = spConv2d(in_planes, out_planes, kernel_size, stride, padding, groups=groups, bias=bias, use_sppad=use_sppad, split=split) #self.conv1 = nn.Conv2d(in_planes, out_planes, kernel_size, stride, padding, groups=groups, bias=bias) self.bn1 = nn.BatchNorm2d(out_planes) self.relu = nn.ReLU(inplace=True) self.conv2 = spConv2d(out_planes, out_planes, kernel_size, 1, padding, groups=groups, bias=bias, use_sppad=use_sppad, split=split) #self.conv2 = nn.Conv2d(out_planes, out_planes, kernel_size, 1, padding, groups=groups, bias=bias) self.bn2 = nn.BatchNorm2d(out_planes) self.downsample = None if stride > 1: self.downsample = nn.Sequential(spConv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False, use_sppad=use_sppad, split=split), nn.BatchNorm2d(out_planes),)
def __init__(self, inplanes, planes,use_sppad=False, split=1): super(ParallelDilatedConv, self).__init__() #self.dilated_conv_1 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=1, padding=1, dilation=1) #self.dilated_conv_2 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=1, padding=2, dilation=2) #self.dilated_conv_3 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=1, padding=3, dilation=3) #self.dilated_conv_4 = nn.Conv2d(inplanes, planes, kernel_size=3, stride=1, padding=4, dilation=4) self.dilated_conv_1 = spConv2d(inplanes, planes, kernel_size=3, stride=1, padding=1, dilation=1, use_sppad=use_sppad, split=split) self.dilated_conv_2 = spConv2d(inplanes, planes, kernel_size=3, stride=1, padding=2, dilation=2, use_sppad=use_sppad,split=split) self.dilated_conv_3 = spConv2d(inplanes, planes, kernel_size=3, stride=1, padding=3, dilation=3, use_sppad=use_sppad,split=split) self.dilated_conv_4 = spConv2d(inplanes, planes, kernel_size=3, stride=1, padding=4, dilation=4, use_sppad=use_sppad,split=split) self.relu1 = nn.ELU(inplace=True) self.relu2 = nn.ELU(inplace=True) self.relu3 = nn.ELU(inplace=True) self.relu4 = nn.ELU(inplace=True)
def __init__(self, nIn, nOut, kSize, stride=1, d=1, use_sppad=False, split=1): """ args: nIn: number of input channels nOut: number of output channels, default (nIn == nOut) kSize: kernel size stride: optional stride rate for down-sampling d: dilation rate """ super().__init__() padding = int((kSize - 1) / 2) * d self.conv = spConv2d(nIn, nOut, (kSize, kSize), stride=stride, padding=(padding, padding), groups=nIn, dilation=d, use_sppad=use_sppad, split=split)
def __init__(self, ninput, noutput): super().__init__() self.conv = spConv2d(ninput, noutput-ninput, kernel_size=3, stride=2, padding=1, use_sppad=True, split=4) #self.conv = nn.Conv2d(ninput, noutput-ninput, (3, 3), stride=2, padding=1, bias=True) self.pool = nn.MaxPool2d(2, stride=2) self.bn = nn.BatchNorm2d(noutput, eps=1e-3)
def __init__(self, num_classes=28, encoder=None, use_sppad=True, split=4): #use special padding and upsampling, 4 feature models super(Net, self).__init__() self.num_classes = num_classes self.split=split #self.conv1 = nn.Conv2d(3, 96, kernel_size=3, stride=2, padding=1) # 32 self.conv1 = spConv2d(3, 96, kernel_size=3, stride=2, padding=1, use_sppad=use_sppad, split=split) # 32 # self.bn1 = nn.BatchNorm2d(96) self.relu1 = nn.ELU(inplace=True) self.maxpool1 = nn.MaxPool2d(kernel_size=2, stride=2) # 16 self.fire1_1 = Fire(96, 16, 64, use_sppad=use_sppad, split=split) self.fire1_2 = Fire(128, 16, 64, use_sppad=use_sppad, split=split) self.maxpool2 = nn.MaxPool2d(kernel_size=2, stride=2) # 8 self.fire2_1 = Fire(128, 32, 128, use_sppad=use_sppad, split=split) self.fire2_2 = Fire(256, 32, 128, use_sppad=use_sppad, split=split) self.maxpool3 = nn.MaxPool2d(kernel_size=2, stride=2) # 4 self.fire3_1 = Fire(256, 64, 256, use_sppad=use_sppad, split=split) self.fire3_2 = Fire(512, 64, 256, use_sppad=use_sppad, split=split) self.fire3_3 = Fire(512, 64, 256, use_sppad=use_sppad, split=split) self.parallel = ParallelDilatedConv(512, 512, use_sppad=use_sppad, split=split) self.deconv1 = nn.ConvTranspose2d(512, 256, 3, stride=2, padding=1, output_padding=1) # self.bn2 = nn.BatchNorm2d(256) self.relu2 = nn.ELU(inplace=True) self.deconv2 = nn.ConvTranspose2d(512, 128, 3, stride=2, padding=1, output_padding=1) # self.bn3 = nn.BatchNorm2d(128) self.relu3 = nn.ELU(inplace=True) self.deconv3 = nn.ConvTranspose2d(256, 96, 3, stride=2, padding=1, output_padding=1) # self.bn4 = nn.BatchNorm2d(96) self.relu4 = nn.ELU(inplace=True) self.deconv4 = nn.ConvTranspose2d(192, self.num_classes, 3, stride=2, padding=1, output_padding=1) self.conv3_1 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) # 32 self.conv3_2 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1) # 32 self.conv2_1 = nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1) # 32 self.conv2_2 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) # 32 self.conv1_1 = nn.Conv2d(96, 96, kernel_size=3, stride=1, padding=1) # 32 self.conv1_2 = nn.Conv2d(192, 192, kernel_size=3, stride=1, padding=1) # 32 #self.conv3_1 = spConv2d(256, 256, kernel_size=3, stride=1, padding=1, use_sppad=use_sppad, split=split) # 32 #self.conv3_2 = spConv2d(512, 512, kernel_size=3, stride=1, padding=1, use_sppad=use_sppad, split=split) # 32 #self.conv2_1 = spConv2d(128, 128, kernel_size=3, stride=1, padding=1, use_sppad=use_sppad, split=split) # 32 #self.conv2_2 = spConv2d(256, 256, kernel_size=3, stride=1, padding=1, use_sppad=use_sppad, split=split) # 32 #self.conv1_1 = spConv2d(96, 96, kernel_size=3, stride=1, padding=1, use_sppad=use_sppad, split=split) # 32 #self.conv1_2 = spConv2d(192, 192, kernel_size=3, stride=1, padding=1, use_sppad=use_sppad, split=split) # 32 self.relu1_1 = nn.ELU(inplace=True) self.relu1_2 = nn.ELU(inplace=True) self.relu2_1 = nn.ELU(inplace=True) self.relu2_2 = nn.ELU(inplace=True) self.relu3_1 = nn.ELU(inplace=True) self.relu3_2 = nn.ELU(inplace=True) for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels m.weight.data.normal_(0, math.sqrt(2. / n)) elif isinstance(m, nn.BatchNorm2d): m.weight.data.fill_(1) m.bias.data.zero_()
def __init__(self, n_classes=28,encoder=None, use_sppad=True, split=4): #use special padding and upsampling, 4 feature models """ Model initialization :param x_n: number of input neurons :type x_n: int """ super(Net, self).__init__() self.split=split #self.use_sppad=use_sppad self.conv1 = spConv2d(3, 64, 7, 2, 3, bias=False, use_sppad=use_sppad, split=split) #self.conv1 = nn.Conv2d(3, 64, 7, 2, 3, bias=False) self.bn1 = nn.BatchNorm2d(64) self.relu = nn.ReLU(inplace=True) self.maxpool = nn.MaxPool2d(3, 2, 1) self.encoder1 = Encoder(64, 64, 3, 1, 1, use_sppad=use_sppad, split=split) self.encoder2 = Encoder(64, 128, 3, 2, 1, use_sppad=use_sppad, split=split) self.encoder3 = Encoder(128, 256, 3, 2, 1, use_sppad=use_sppad, split=split) self.encoder4 = Encoder(256, 512, 3, 2, 1, use_sppad=use_sppad, split=split) self.decoder1 = Decoder(64, 64, 3, 1, 1, 0) self.decoder2 = Decoder(128, 64, 3, 2, 1, 1) self.decoder3 = Decoder(256, 128, 3, 2, 1, 1) self.decoder4 = Decoder(512, 256, 3, 2, 1, 1) # Classifier self.tp_conv1 = nn.Sequential(nn.ConvTranspose2d(64, 32, 3, 2, 1, 1), nn.BatchNorm2d(32), nn.ReLU(inplace=True),) self.conv2 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.BatchNorm2d(32), nn.ReLU(inplace=True),) self.tp_conv2 = nn.ConvTranspose2d(32, n_classes, 2, 2, 0) self.lsm = nn.LogSoftmax()
def __init__(self, chann, dropprob, dilated): super().__init__() self.conv3x1_1 = nn.Conv2d(chann, chann, (3, 1), stride=1, padding=(1,0), bias=True) #self.conv1x3_1 = nn.Conv2d(chann, chann, (1,3), stride=1, padding=(0,1), bias=True) self.conv1x3_1 = spConv2d(chann, chann, kernel_size=(1, 3),padding=(0,1), use_sppad=True, split=4) self.bn1 = nn.BatchNorm2d(chann, eps=1e-03) self.conv3x1_2 = nn.Conv2d(chann, chann, (3, 1), stride=1, padding=(1*dilated,0), bias=True, dilation = (dilated,1)) #self.conv1x3_2 = nn.Conv2d(chann, chann, (1,3), stride=1, padding=(0,1*dilated), bias=True, dilation = (1, dilated)) self.conv1x3_2 = spConv2d(chann, chann, (1,3), stride=1, padding=(0,dilated), dilation = dilated, use_sppad=True, split=4) self.bn2 = nn.BatchNorm2d(chann, eps=1e-03) self.dropout = nn.Dropout2d(dropprob)
def __init__(self, inplanes, squeeze_planes, expand_planes,use_sppad=False,split=1): super(Fire, self).__init__() #self.conv1 = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1, stride=1) self.conv1 = spConv2d(inplanes, squeeze_planes, kernel_size=1, stride=1,use_sppad=use_sppad,split=split) # self.bn1 = nn.BatchNorm2d(squeeze_planes) self.relu1 = nn.ELU(inplace=True) #self.conv2 = nn.Conv2d(squeeze_planes, expand_planes, kernel_size=1, stride=1) self.conv2 = spConv2d(squeeze_planes, expand_planes, kernel_size=1, stride=1,use_sppad=use_sppad,split=split) # self.bn2 = nn.BatchNorm2d(expand_planes) #self.conv3 = nn.Conv2d(squeeze_planes, expand_planes, kernel_size=3, stride=1, padding=1) self.conv3 = spConv2d(squeeze_planes, expand_planes, kernel_size=3, stride=1, padding=1,use_sppad=use_sppad,split=split) # self.bn3 = nn.BatchNorm2d(expand_planes) self.relu2 = nn.ELU(inplace=True) # using MSR initilization for m in self.modules(): if isinstance(m, nn.Conv2d): n = m.kernel_size[0] * m.kernel_size[1] * m.in_channels m.weight.data.normal_(0, math.sqrt(2./n))
def __init__(self, ninput, dilated, k=40, dropprob=0.02, use_sppad=False, split=1): super(EDABlock, self).__init__() #k: growthrate #dropprob:a dropout layer between the last ReLU and the concatenation of each module self.conv1x1 = nn.Conv2d(ninput, k, kernel_size=1) self.bn0 = nn.BatchNorm2d(k) self.conv3x1_1 = nn.Conv2d(k, k, kernel_size=(3, 1), padding=(1, 0)) self.conv1x3_1 = spConv2d(k, k, kernel_size=(1, 3), padding=(0, 1), use_sppad=use_sppad, split=split) self.bn1 = nn.BatchNorm2d(k) self.conv3x1_2 = nn.Conv2d(k, k, (3, 1), stride=1, padding=(dilated, 0), dilation=dilated) self.conv1x3_2 = spConv2d(k, k, (1, 3), stride=1, padding=(0, dilated), dilation=dilated, use_sppad=use_sppad, split=split) self.bn2 = nn.BatchNorm2d(k) self.dropout = nn.Dropout2d(dropprob)
def __init__(self, nIn, nOut, kSize, stride=1, use_sppad=False, split=1): """ args: nIn: number of input channels nOut: number of output channels kSize: kernel size stride: optional stride rate for down-sampling """ super().__init__() padding = int((kSize - 1) / 2) self.conv = spConv2d(nIn, nOut, (kSize, kSize), stride=stride, padding=(padding, padding), use_sppad=use_sppad, split=split)
def __init__(self, nIn, nOut, kSize, stride=1, use_sppad=False, split=1): """ args: nIn: number of input channels nOut: number of output channels kSize: kernel size stride: stride rate for down-sampling. Default is 1 """ super().__init__() padding = int((kSize - 1) / 2) #self.conv = nn.Conv2d(nIn, nOut, (kSize, kSize), stride=stride, padding=(padding, padding), bias=False) self.conv = spConv2d(nIn, nOut, (kSize, kSize), stride=stride, padding=(padding, padding), use_sppad=use_sppad, split=split) self.bn = nn.BatchNorm2d(nOut, eps=1e-03) self.act = nn.PReLU(nOut)