def __init__(self, stem, n_classes=21, learned_billinear=False, **kwargs):
super(fcn8s, self).__init__()
self.learned_billinear = learned_billinear
self.n_classes = n_classes
self.stem = stem(args)
self.score_pool4 = nn.Conv2d(512, self.n_classes, 1)
self.score_pool3 = nn.Conv2d(256, self.n_classes, 1)
if self.learned_billinear:
self.upscore2 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore4 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore8 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
16,
stride=8,
bias=False)
for m in self.modules():
if isinstance(m, nn.ConvTranspose2d):
m.weight.data.copy_(
get_upsampling_weight(m.in_channels, m.out_channels,
m.kernel_size[0]))
def __init__(self, stem, n_classes=21, learned_billinear=False, **kwargs):
super(fcn32s, self).__init__()
self.learned_billinear = learned_billinear
self.n_classes = n_classes
self.stem = stem(n_classes)
if self.learned_billinear:
self.upscore = nn.ConvTranspose2d(n_classes,
n_classes,
64,
stride=32,
bias=False)
for m in self.modules():
if isinstance(m, nn.ConvTranspose2d):
assert m.kernel_size[0] == m.kernel_size[1]
initial_weight = get_upsampling_weight(m.in_channels,
m.out_channels,
m.kernel_size[0])
m.weight.data.copy_(initial_weight)
def __init__(self,
n_classes=21,
learned_billinear=False,
use_norm=False,
use_scale=False,
lower_dim=True,
weighted_mask=False,
offsetting=False,
use_norm_weights=False,
use_normalize_train=False):
super(fcn8s, self).__init__()
self.learned_billinear = learned_billinear
self.n_classes = n_classes
self.loss = functools.partial(cross_entropy2d, size_average=False)
self.use_norm = use_norm
self.use_norm_weights = use_norm_weights
self.use_normalize_train = use_normalize_train
self.multires = True
self.weighted_mask = weighted_mask
self.offsetting = offsetting
self.score_channels = [512, 256]
self.conv_block1 = 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),
)
self.conv_block2 = 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),
)
self.conv_block3 = 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),
)
self.conv_block4 = 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),
)
self.conv_block5 = 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),
)
if self.use_normalize_train:
last_layer_cls = CosineSimLayer
else:
last_layer_cls = nn.Conv2d
if lower_dim:
self.fconv_block = nn.Sequential(
nn.Conv2d(512, 4096, 1),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(4096, 4096, 1),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(4096, 256, 1),
)
self.classifier = nn.Sequential(
nn.ReLU(inplace=True),
nn.Dropout2d(),
last_layer_cls(256, self.n_classes, 1, bias=False),
)
else:
self.fconv_block = nn.Sequential(
nn.Conv2d(512, 4096, 7),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(4096, 4096, 1),
)
self.classifier = nn.Sequential(
nn.ReLU(inplace=True),
nn.Dropout2d(),
last_layer_cls(4096, self.n_classes, 1, bias=False),
)
self.score_pool4 = last_layer_cls(512, self.n_classes, 1, bias=False)
self.score_pool3 = last_layer_cls(256, self.n_classes, 1, bias=False)
if use_normalize_train and use_scale:
self.classifier[2].set_scale(use_scale)
self.score_pool3.set_scale(use_scale)
self.score_pool4.set_scale(use_scale)
if self.learned_billinear:
self.upscore2 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore4 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore8 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
16,
stride=8,
bias=False)
for m in self.modules():
if isinstance(m, nn.ConvTranspose2d):
m.weight.data.copy_(
get_upsampling_weight(m.in_channels, m.out_channels,
m.kernel_size[0]))
def __init__(self, n_classes=21, learned_billinear=True):
super(fcn8s, self).__init__()
self.learned_billinear = learned_billinear
self.n_classes = n_classes
self.loss = functools.partial(cross_entropy2d, size_average=False)
self.conv_block1 = nn.Sequential(
# nn.Conv2d(3, 64, 3, padding=100),
nn.Conv2d(4, 64, 3, padding=100),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True),
)
self.conv_block2 = 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),
)
self.conv_block3 = 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),
)
self.conv_block4 = 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),
)
self.conv_block5 = 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),
)
self.classifier = nn.Sequential(
nn.Conv2d(512, 4096, 7),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(4096, 4096, 1),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(4096, self.n_classes, 1),
)
self.score_pool4 = nn.Conv2d(512, self.n_classes, 1)
self.score_pool3 = nn.Conv2d(256, self.n_classes, 1)
if self.learned_billinear:
self.upscore2 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore4 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore8 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
16,
stride=8,
bias=False)
for m in self.modules():
if isinstance(m, nn.ConvTranspose2d):
m.weight.data.copy_(
get_upsampling_weight(m.in_channels, m.out_channels,
m.kernel_size[0]))
def __init__(self):
super(fcn_depth, self).__init__()
self.conv_block1 = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=100),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True),
)
self.conv_block2 = 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),
)
self.conv_block3 = 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),
)
self.conv_block4 = 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),
)
self.conv_block5 = 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),
)
self.classifier = nn.Sequential(
nn.Conv2d(512, 2048, 7),
nn.ReLU(inplace=True),
# nn.Dropout2d(),
nn.Conv2d(2048, 1024, 1),
nn.ReLU(inplace=True),
# nn.Dropout2d(),
nn.Conv2d(1024, 64, 1),
nn.ReLU(inplace=True),
# nn.Dropout2d(),
)
self.score_pool4 = nn.Conv2d(512, 64, 1)
self.score_pool3 = nn.Conv2d(256, 64, 1)
self.conv3 = nn.Conv2d(64, 1, 1, padding=0)
self.relu = nn.ReLU(inplace=True)
# deconvolution
self.upscore2 = nn.ConvTranspose2d(64, 64, 4,
stride=2, bias=False)
self.upscore4 = nn.ConvTranspose2d(64, 64, 4,
stride=2, bias=False)
self.upscore8 = nn.ConvTranspose2d(64, 64, 16,
stride=8, bias=False)
for m in self.modules():
if isinstance(m, nn.ConvTranspose2d):
m.weight.data.copy_(get_upsampling_weight(m.in_channels,
m.out_channels,
m.kernel_size[0]))
def __init__(self, n_classes=21, learned_billinear=True):
super(fcn8s, self).__init__()
self.learned_billinear = learned_billinear
self.n_classes = n_classes
self.loss = functools.partial(cross_entropy2d, size_average=False)
## Hint: the size of the parameters
c1, c2, c3, c4, c5, c6, c7 = 64, 128, 256, 512, 512, 4096, 4096
self.conv_block1 = nn.Sequential(
nn.Conv2d(3, c1, 3, padding=100),
nn.ReLU(inplace=True),
nn.Conv2d(c1, c1, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True),
)
## todo:
# conv_block2 = nn.Sequential()
# conv_block2 is missing. However, you know the block2 is similar to block1 with deeper CNN structure.
# Can you find it out?
self.conv_block2 = 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),
)
self.conv_block3 = nn.Sequential(
nn.Conv2d(c2, c3, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(c3, c3, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(c3, c3, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True),
)
# todo:
# conv_block4 is missing. However, you know the block4 is similar to block3 with deeper CNN structure.
# Can you find it out?
self.conv_block4 = 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),
)
self.conv_block5 = nn.Sequential(
nn.Conv2d(c4, c5, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(c5, c5, 3, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(c5, c5, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True),
)
self.classifier = nn.Sequential(
nn.Conv2d(c5, c6, 7),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(c6, c7, 1),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(c7, self.n_classes, 1),
)
self.score_pool4 = nn.Conv2d(512, self.n_classes, 1)
self.score_pool3 = nn.Conv2d(256, self.n_classes, 1)
if self.learned_billinear:
self.upscore2 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore4 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore8 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
16,
stride=8,
bias=False)
for m in self.modules():
if isinstance(m, nn.ConvTranspose2d):
m.weight.data.copy_(
get_upsampling_weight(m.in_channels, m.out_channels,
m.kernel_size[0]))
def __init__(self, params, n_classes=6, learned_billinear=True):
super(dp_fcn8s, self).__init__()
self.learned_billinear = learned_billinear
self.rule = params['rule'] # --rule hebb
self.n_classes = n_classes # n_classes == 151
self.params = params
self.eta = torch.nn.Parameter(
(.01 * torch.ones(1)).cuda(),
requires_grad=True) # Everyone has the same eta
self.w = torch.nn.Parameter(
(.01 * torch.randn(200, params['nbclasses'])).cuda(),
requires_grad=True)
#self.w = torch.nn.Parameter((.01 * torch.randn(params['nbclasses'], params['nbclasses'])) )
if params['alpha'] == 'free': # --alpha free
self.alpha = torch.nn.Parameter(
(.01 * torch.rand(200, params['nbclasses'])).cuda(),
requires_grad=True
) # Note: rand rather than randn (all positive)
elif params['alpha'] == 'yoked':
self.alpha = torch.nn.Parameter((.01 * torch.ones(1)).cuda(),
requires_grad=True)
else:
raise ValueError(
"Must select a value for alpha ('free' or 'yoked')")
#self.loss = functools.partial(cross_entropy2d, size_average=False)
self.conv_block1 = nn.Sequential(
nn.Conv2d(3, 64, 3, padding=100),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, 3, padding=1),
nn.ReLU(inplace=True),
nn.MaxPool2d(2, stride=2, ceil_mode=True),
)
self.conv_block2 = 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),
)
self.conv_block3 = 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),
)
self.conv_block4 = 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),
)
self.conv_block5 = 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),
)
self.conv_block6 = nn.Sequential(
nn.Conv2d(512, 4096, 7),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(4096, 4096, 1),
nn.ReLU(inplace=True),
nn.Dropout2d(),
nn.Conv2d(4096, 200, 1),
)
self.score_pool4 = nn.Conv2d(512, self.n_classes, 1)
self.score_pool3 = nn.Conv2d(256, self.n_classes, 1)
if self.learned_billinear:
self.upscore2 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore4 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
4,
stride=2,
bias=False)
self.upscore8 = nn.ConvTranspose2d(self.n_classes,
self.n_classes,
16,
stride=8,
bias=False)
self.softmax = nn.Softmax(dim=1)
for m in self.modules():
if isinstance(m, nn.ConvTranspose2d):
m.weight.data.copy_(
get_upsampling_weight(m.in_channels, m.out_channels,
m.kernel_size[0]))
