def __init__(self, num_layers, num_input_features, bn_size=4, growth_rate=32, drop_rate=0):
util.super2(DenseBlock, self).__init__()
self.num_layers = num_layers
for i in range(num_layers):
layer = DenseLayer(num_input_features + i * growth_rate, growth_rate, bn_size, drop_rate)
self.add_module('denselayer%d' % (i + 1), layer)
self.n_feat_out = layer.n_feat_out
def __init__(self, num_input_features, num_output_features):
util.super2(Transition, self).__init__()
self.add_module('norm', nn.BatchNorm2d(num_input_features))
self.add_module('noli', default_nonlinearity())
self.add_module('conv', nn.Conv2d(num_input_features, num_output_features,
kernel_size=1, stride=1, bias=False))
self.add_module('pool', nn.AvgPool2d(kernel_size=2, stride=2))
def __init__(self, num_input_features, growth_rate, bn_size, drop_rate=0):
util.super2(DenseLayer, self).__init__()
self.bn_size = bn_size
self.growth_rate = growth_rate
self.n_feat_internal = bn_size * growth_rate
self.n_feat_out = num_input_features + growth_rate
self.add_module('norm.1', nn.BatchNorm2d(num_input_features)),
self.add_module('noli.1', default_nonlinearity()),
self.add_module(
'conv.1',
nn.Conv2d(num_input_features,
bn_size * growth_rate,
kernel_size=1,
stride=1,
bias=False)),
self.add_module('norm.2', nn.BatchNorm2d(self.n_feat_internal)),
self.add_module('noli.2', default_nonlinearity()),
self.add_module(
'conv.2',
nn.Conv2d(self.n_feat_internal,
growth_rate,
kernel_size=3,
stride=1,
padding=1,
bias=False)),
self.drop_rate = drop_rate
def __init__(self,
in_size1,
in_size2,
compress=.5,
num_layers=2,
growth_rate=4,
is_deconv=True):
util.super2(DenseUNetUp, self).__init__()
if is_deconv:
out_size2 = int(compress * in_size2)
self.up = nn.ConvTranspose2d(in_size2,
out_size2,
kernel_size=2,
stride=2,
bias=False)
else:
out_size2 = in_size2
self.up = nn.Upsample(scale_factor=2, mode='bilinear')
in_size = in_size1 + out_size2
bneck_size = int(in_size1 * compress)
self.pad = PadToAgree()
self.conv = DenseBlock(num_layers,
in_size,
growth_rate=growth_rate,
bn_size=4)
self.bottleneck = nn.Conv2d(self.conv.n_feat_out,
bneck_size,
kernel_size=1,
stride=1,
bias=False)
self.n_feat_out = bneck_size
def __init__(self, n_input, n_output, n_mixtures=2):
util.super2(MixtureOfLogSoftmax, self).__init__()
self.n_mixtures = n_mixtures
self.n_input = n_input
self.n_output = n_output
self.mixer = torch.nn.Linear(n_input, n_mixtures * n_input)
self.project = torch.nn.Linear(n_input, n_output)
self.noli = default_nonlinearity()
# For the different components, we're assuming equal mixing
# self.log_prior = torch.log(torch.autograd.Variable(torch.ones(1, n_mixtures, 1) * (1 / n_mixtures)))
self.log_prior = (1 / float(n_mixtures))
def __init__(self, channels, eps=1e-5, rmax=3, dmax=5, lr=0.001):
util.super2(BatchRenorm2d, self).__init__()
self.training = True
self.is_unlock = False
self.eps = eps
self.eps_sqrt = np.sqrt(self.eps)
self.channels = channels
self.rmax = rmax
self.dmax = dmax
self.lr = lr
self.use_cuda = True
self.sigma = torch.ones((1, channels)).float()
self.mean = torch.zeros((1, channels)).float()
def forward(self, x):
new_features = util.super2(DenseLayer, self).forward(x)
if self.drop_rate > 0:
new_features = F.dropout(new_features,
p=self.drop_rate,
training=self.training)
return torch.cat([x, new_features], 1)
def __init__(self, n_input, n_output):
util.super2(LinearLogSoftmax, self).__init__()
self.n_input = n_input
self.n_output = n_output
self.project = torch.nn.Linear(n_input, n_output)
self.noli = default_nonlinearity()
def __init__(self, n_classes=21, n_alt_classes=3, in_channels=3,
bn_size=2, growth_rate=16, is_deconv=True):
util.super2(DenseUNet2, self).__init__()
self.in_channels = in_channels
n_feat0 = 36
from torch import nn
features = nn.Sequential(ub.odict([
('conv0', nn.Conv2d(in_channels, n_feat0, kernel_size=7, stride=1,
padding=3,
bias=False)),
('norm0', nn.BatchNorm2d(n_feat0)),
('noli0', default_nonlinearity()),
# ('pool0', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
]))
block_config = [2, 3, 3, 3, 3]
bn_size = bn_size
compress = .4
growth_rate = growth_rate
n_feat = n_feat0
# downsampling
down = []
densekw = dict(bn_size=bn_size, growth_rate=growth_rate)
for i, num_layers in enumerate(block_config[0:-1]):
down.append(('denseblock%d' % (i + 1), DenseBlock(num_layers=num_layers, num_input_features=n_feat, **densekw)))
n_feat = n_feat + num_layers * growth_rate
n_feat_compress = int(n_feat * compress)
down.append(('transition%d' % (i + 1), Transition(num_input_features=n_feat, num_output_features=n_feat_compress)))
n_feat = n_feat_compress
# for key, value in down:
# self.add_module(key, value)
self.denseblock1 = down[0][1]
self.transition1 = down[1][1]
self.denseblock2 = down[2][1]
self.transition2 = down[3][1]
self.denseblock3 = down[4][1]
self.transition3 = down[5][1]
self.denseblock4 = down[6][1]
self.transition4 = down[7][1]
num_layers = block_config[-1]
center5 = DenseBlock(num_layers=num_layers, num_input_features=n_feat, **densekw)
n_feat = n_feat + num_layers * growth_rate
center5.n_feat_out
up_concat4 = DenseUNetUp(self.denseblock4.n_feat_out, center5.n_feat_out, is_deconv=is_deconv)
up_concat3 = DenseUNetUp(self.denseblock3.n_feat_out, up_concat4.n_feat_out, is_deconv=is_deconv)
up_concat2 = DenseUNetUp(self.denseblock2.n_feat_out, up_concat3.n_feat_out, is_deconv=is_deconv)
up_concat1 = DenseUNetUp(self.denseblock1.n_feat_out, up_concat2.n_feat_out, is_deconv=is_deconv)
self.features = features
self.center5 = center5
self.up_concat4 = up_concat4
self.up_concat3 = up_concat3
self.up_concat2 = up_concat2
self.up_concat1 = up_concat1
# final conv (without any concat)
self.final1 = nn.Conv2d(up_concat1.n_feat_out, n_classes, 1)
self.final2 = nn.Conv2d(up_concat1.n_feat_out, n_alt_classes, 1)
self._cache = {}
self.connections = {
'path': [
# Main network forward path
'features',
'denseblock1',
'transition1',
'denseblock2',
'transition2',
'denseblock3',
'transition3',
'denseblock4',
'transition4',
'center5',
'up_concat4',
'up_concat3',
'up_concat2',
'up_concat1',
],
'edges': [
# When a node accepts multiple inputs, we need to specify which
# order they appear in the signature
('denseblock4', 'up_concat4', {'argx': 0}),
('denseblock3', 'up_concat3', {'argx': 0}),
('denseblock2', 'up_concat2', {'argx': 0}),
('denseblock1', 'up_concat1', {'argx': 0}),
('up_concat1', 'final1', {'argx': 0}),
('up_concat1', 'final2', {'argx': 0}),
]
}
def __init__(self):
util.super2(PadToAgree, self).__init__()
def __init__(task, repo=None, workdir=None, clean=2):
# TODO: generalize
if repo is None:
task.repo = expanduser('~/data/v1-annotations')
else:
task.repo = expanduser(repo)
# TODO: generate this automatically
classnames = [
'Sky', 'Building', 'Street', 'Parking_Lot', 'Trees', 'Crosswalk',
'Grass', 'Ground', 'Intersection', 'Shadows', 'Sidewalk', 'Stairs',
'Other', 'Background', 'Unannotated'
]
null_classname = 'Unannotated'
if clean <= 0:
alias = {}
elif clean == 1:
alias = {
# 'Sidewalk': 'Unannotated',
# 'Grass': 'Ground',
'Shadows': 'Unannotated',
'Stairs': 'Unannotated',
'Background': 'Unannotated',
'Other': 'Unannotated',
}
else:
# These roughly correspond to shruti's classes
alias = {
# Remove Shadows / Background / Other
'Shadows': 'Unannotated',
'Background': 'Unannotated',
'Other': 'Unannotated',
# Tenous: Remove Sky, Ground, Stairs
'Sky': 'Unannotated',
'Ground': 'Unannotated',
'Stairs': 'Unannotated',
# VERY Tenous: Remove Sidewalk
'Sidewalk': 'Unannotated',
# Intersection and crosswalk become street
'Intersection': 'Street',
'Crosswalk': 'Street',
}
task.clean = clean
util.super2(DivaV1, task).__init__(classnames, null_classname, alias)
task._data_id = None
# Special colors
task.customize_colors()
# Work directory
if workdir is None:
task.workdir = expanduser('~/data/work/diva/')
else:
task.workdir = expanduser(workdir)
# Define data preprocessingg
task.target_shape = (360, 480)
task.input_shape = (360, 480)
task.part_overlap = .5
task.part_keepbound = True
# task.part_overlap = 0
# task.part_keepbound = False
# task.enable_augment = True
# task.enable_augment = False
task.enable_augment = True
# task.aug_params = {
# 'axis_flips': [0, 1],
# 'gammas': [2.5],
# 'blur': [10],
# 'n_rand_zoom': 1,
# 'n_rand_occl': 1,
# }
task.aug_params = {
'axis_flips': [0, 1],
'gammas': [.5, 2.5],
'blur': [5, 20],
'n_rand_zoom': 2,
'n_rand_occl': 2,
}
task.base_modes = ['lowres', 'part-scale1', 'part-scale2']
# task.base_modes = ['lowres']
if task.enable_augment:
task.modes = task.base_modes + [
m + '-aug' for m in task.base_modes
]
else:
task.modes = task.base_modes[:]
task.scene_base = join(task.repo, 'active')