def create_simpleConvolutionsRelu(args, num_output_final):
"""Create network in barrista."""
print("Using simple convolutions network with ReLU units, num_output is",
"16, 32 *", args.numLayers, ", 16, 1 and a final Sigmoid.",
"kernel_pad is", args.kernel_pad)
layers = []
filler = design.PROTODETAIL.FillerParameter()
filler.type = args.filler_type
# filler.value = 1
kernel = 2 * args.kernel_pad + 1
pad = args.kernel_pad
layers.append(
ConvolutionLayer(Convolution_kernel_size=kernel,
Convolution_num_output=16,
Convolution_stride=1,
Convolution_pad=pad,
Convolution_weight_filler=filler,
bottoms=['images']))
layers.append(ReLULayer())
for i in range(args.numLayers):
layers.append(
ConvolutionLayer(Convolution_kernel_size=kernel,
Convolution_num_output=32,
Convolution_stride=1,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_kernel_size=kernel,
Convolution_num_output=16,
Convolution_stride=1,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_kernel_size=kernel,
Convolution_num_output=num_output_final,
Convolution_pad=pad,
Convolution_weight_filler=filler,
tops=['RS_est']))
return layers
def recover_reflectance_shading(args, num_output_final):
"""Recover reflectance and shading from estimation."""
layers = []
RS_est_mode = args.RS_est_mode.split('-')[0]
if RS_est_mode in ['RS']:
# if we want to estimate R and S at the same time, nothing needs
# to be recovered, just directly give R and S
layers.append(
SliceLayer(
name='slice_RS',
Slice_axis=1,
Slice_slice_point=[3],
bottoms=['RS_est'],
tops=['reflectance', 'shading'],
))
return layers # already return here
elif RS_est_mode in ['rDirectly']:
layers.append(
ReLULayer(
name='pass_on_r_to_reflectance',
bottoms=['RS_est'],
tops=['reflectance'],
))
layers.append(
ReLULayer(
name='pass_on_r_to_shading_dummy',
bottoms=['RS_est'],
tops=['shading'],
))
return layers # already return here
estimation = 'RS_est'
# recover reflectance and shading:
layers.append(
PythonLayer(Python_module='recover_reflectance_shading_layer',
Python_layer='RecoverReflectanceShadingLayer',
Python_param_str=args.RS_est_mode,
name='recover_reflectance_shading',
bottoms=[estimation, 'images'],
tops=['reflectance', 'shading']))
return layers
def create_cascadeSkipLayers(args, num_output_final):
"""Create network in barrista."""
layers = []
# if you want to use a Prelu, do the following below:
# layers.append(PReLULayer())
# or SigmoidLayer
filler = design.PROTODETAIL.FillerParameter()
filler.type = args.filler_type
# filler.value = 1
kernel = 2 * args.kernel_pad + 1
pad = args.kernel_pad + (args.dilation - 1)
num_output = 2**args.num_filters_log
print("This net has skip layers and a sigmoid in the end!",
"Using a convolutional network with ReLU units.", "It has",
args.numLayers, "layers with", num_output,
"filters each, then a conv layer with num_output",
"filters (dependent on the RS_estimation mode)",
"The kernels are of size", kernel, "with a padding of", pad)
if args.numLayers >= 1:
i = 0
layers.append(
ConvolutionLayer(
name='conv{}_level0'.format(i),
bottoms=['images'],
tops=['conv{}_level0'.format(i)],
Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
))
if args.use_batch_normalization:
layers.append(
BatchNormLayer(
name='bn{}_level0'.format(i),
bottoms=['conv{}_level0'.format(i)],
tops=['conv{}_level0'.format(i)],
))
layers.append(
ReLULayer(
name='relu{}_level0'.format(i),
bottoms=['conv{}_level0'.format(i)],
tops=['conv{}_level0'.format(i)],
))
for i in range(1, args.numLayers):
layers.append(
ConvolutionLayer(
name='conv{}_level0'.format(i),
bottoms=['conv{}_level0'.format(i - 1)],
tops=['conv{}_level0'.format(i)],
Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
))
if args.use_batch_normalization:
layers.append(
BatchNormLayer(
name='bn{}_level0'.format(i),
bottoms=['conv{}_level0'.format(i)],
tops=['conv{}_level0'.format(i)],
))
layers.append(
ReLULayer(
name='relu{}_level0'.format(i),
bottoms=['conv{}_level0'.format(i)],
tops=['conv{}_level0'.format(i)],
))
layers.append(
ConcatLayer(
name='concat_skip_layers_level0',
bottoms=[
'conv{}_level0'.format(i) for i in range(args.numLayers)
],
tops=['concat_skip_layers_level0'],
))
layers.append(
ConvolutionLayer(
name='fuse_skip_layers_level0',
bottoms=['concat_skip_layers_level0'],
tops=['RS_est_before_sigmoid_level0'],
Convolution_num_output=num_output_final,
Convolution_kernel_size=1,
Convolution_pad=0,
Convolution_weight_filler=filler,
))
layers.append(
SigmoidLayer(
name='sigmoid_after_fusing_level0',
bottoms=['RS_est_before_sigmoid_level0'],
tops=['RS_est_level0'],
))
else:
# catch dummy case of numLayers == 0
layers.append(
ConvolutionLayer(name='conv0_level0',
Convolution_num_output=num_output_final,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
bottoms=['images'],
tops=['RS_est_before_sigmoid_level0']))
layers.append(
SigmoidLayer(
name='sigmoid_after_fusing_level0',
bottoms=['RS_est_before_sigmoid_level0'],
tops=['RS_est_level0'],
))
# recover reflectance and shading:
layers.append(
PythonLayer(Python_module='recover_reflectance_shading_layer',
Python_layer='RecoverReflectanceShadingLayer',
Python_param_str=args.RS_est_mode,
name='recover_reflectance_shading_inner_level0',
bottoms=['RS_est_level0', 'images'],
tops=['reflectance_level0', 'shading_level0']))
# add loss layers for inner levels
# compute whdr hinge loss
bottoms = ['reflectance_level0', args.comparisonsType]
if args.dataset == 'sintel':
bottoms.append('albedos')
layers.append(
PythonLayer(Python_module='whdr_hinge_loss_layer',
Python_layer='WhdrHingeLossLayer',
Python_param_str=(args.whdr_delta_margin_ratio_dense),
name='loss_whdr_hinge_level0',
bottoms=bottoms,
tops=['loss_whdr_hinge_level0'],
loss_weights=[args.loss_scale_whdr],
include_stages=['fit']))
# compute 'real' WHDR as 'accuracy' for evaluation
bottoms = ['reflectance_level0', 'comparisons']
if args.dataset == 'sintel':
bottoms.append('albedos')
layers.append(
PythonLayer(
Python_module='whdr_layer',
Python_layer='WhdrLayer',
Python_param_str="0.1",
name='whdr_original_level0',
bottoms=bottoms,
tops=['whdr_original_level0'],
# do not account as loss layer:
loss_weights=[0],
include_stages=['fit']))
# define what to pass on to the next level
level1_input = 'reflectance_level0'
# add concatenation to input into next level
# layers.append(
# ConcatLayer(
# name='concat_output_level0_to_input_level1',
# bottoms=['images', 'reflectance_level0', 'shading_level0'],
# tops=['concat_output_level0_to_input_level1'],
# )
# )
# level1_input = 'concat_output_level0_to_input_level1'
if args.numLayers >= 1:
i = 0
layers.append(
ConvolutionLayer(
name='conv{}_level1'.format(i),
bottoms=[level1_input],
tops=['conv{}_level1'.format(i)],
Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
))
if args.use_batch_normalization:
layers.append(
BatchNormLayer(
name='bn{}_level1'.format(i),
bottoms=['conv{}_level1'.format(i)],
tops=['conv{}_level1'.format(i)],
))
layers.append(
ReLULayer(
name='relu{}_level1'.format(i),
bottoms=['conv{}_level1'.format(i)],
tops=['conv{}_level1'.format(i)],
))
for i in range(1, args.numLayers):
layers.append(
ConvolutionLayer(
name='conv{}_level1'.format(i),
bottoms=['conv{}_level1'.format(i - 1)],
tops=['conv{}_level1'.format(i)],
Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
))
if args.use_batch_normalization:
layers.append(
BatchNormLayer(
name='bn{}_level1'.format(i),
bottoms=['conv{}_level1'.format(i)],
tops=['conv{}_level1'.format(i)],
))
layers.append(
ReLULayer(
name='relu{}_level1'.format(i),
bottoms=['conv{}_level1'.format(i)],
tops=['conv{}_level1'.format(i)],
))
layers.append(
ConcatLayer(
name='concat_skip_layers_level1',
bottoms=[
'conv{}_level1'.format(i) for i in range(args.numLayers)
],
tops=['concat_skip_layers_level1'],
))
layers.append(
ConvolutionLayer(
name='fuse_skip_layers_level1',
bottoms=['concat_skip_layers_level1'],
tops=['RS_est_before_sigmoid_level1'],
Convolution_num_output=num_output_final,
Convolution_kernel_size=1,
Convolution_pad=0,
Convolution_weight_filler=filler,
))
layers.append(
SigmoidLayer(
name='sigmoid_after_fusing_level1',
bottoms=['RS_est_before_sigmoid_level1'],
tops=['RS_est'],
))
else:
# catch dummy case of numLayers == 0
layers.append(
ConvolutionLayer(name='conv0_level1',
Convolution_num_output=num_output_final,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
bottoms=[level1_input],
tops=['RS_est_before_sigmoid_level1']))
layers.append(
SigmoidLayer(
name='sigmoid_after_fusing_level1',
bottoms=['RS_est_before_sigmoid_level1'],
tops=['RS_est'],
))
# last output needs to be 'RS_est' (without a level description)
return layers
def create_convStaticSkipLayers(args, num_output_final):
"""Create network in barrista."""
layers = []
# if you want to use a Prelu, do the following below:
# layers.append(PReLULayer())
# or SigmoidLayer
filler = design.PROTODETAIL.FillerParameter()
filler.type = args.filler_type
# filler.value = 1
kernel = 2 * args.kernel_pad + 1
pad = args.kernel_pad + (args.dilation - 1)
num_output = 2**args.num_filters_log
print("This net has skip layers and a sigmoid in the end!",
"Using a convolutional network with ReLU units.", "It has",
args.numLayers, "layers with", num_output,
"filters each, then a conv layer with num_output",
"filters (dependent on the RS_estimation mode)",
"The kernels are of size", kernel, "with a padding of", pad)
if args.numLayers >= 1:
i = 0
layers.append(
ConvolutionLayer(
name='conv{}'.format(i),
bottoms=['images'],
tops=['conv{}'.format(i)],
Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
))
if args.use_batch_normalization:
layers.append(
BatchNormLayer(
name='bn{}'.format(i),
bottoms=['conv{}'.format(i)],
tops=['conv{}'.format(i)],
))
layers.append(
ReLULayer(
name='relu{}'.format(i),
bottoms=['conv{}'.format(i)],
tops=['conv{}'.format(i)],
))
for i in range(1, args.numLayers):
layers.append(
ConvolutionLayer(
name='conv{}'.format(i),
bottoms=['conv{}'.format(i - 1)],
tops=['conv{}'.format(i)],
Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
))
if args.use_batch_normalization:
layers.append(
BatchNormLayer(
name='bn{}'.format(i),
bottoms=['conv{}'.format(i)],
tops=['conv{}'.format(i)],
))
layers.append(
ReLULayer(
name='relu{}'.format(i),
bottoms=['conv{}'.format(i)],
tops=['conv{}'.format(i)],
))
layers.append(
ConcatLayer(
name='concat_skip_layers',
bottoms=['conv{}'.format(i) for i in range(args.numLayers)],
tops=['concat_skip_layers'],
))
layers.append(
ConvolutionLayer(
name='fuse_skip_layers',
bottoms=['concat_skip_layers'],
tops=['RS_est_before_sigmoid'],
Convolution_num_output=num_output_final,
Convolution_kernel_size=1,
Convolution_pad=0,
Convolution_weight_filler=filler,
))
layers.append(
SigmoidLayer(
name='sigmoid_after_fusing',
bottoms=['RS_est_before_sigmoid'],
tops=['RS_est'],
))
else:
# catch dummy case of numLayers == 0
layers.append(
ConvolutionLayer(name='conv0',
Convolution_num_output=num_output_final,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_dilation=args.dilation,
Convolution_weight_filler=filler,
bottoms=['images'],
tops=['RS_est_before_sigmoid']))
layers.append(
SigmoidLayer(
name='sigmoid_after_fusing',
bottoms=['RS_est_before_sigmoid'],
tops=['RS_est'],
))
return layers
def create_uNet(args, num_output_final):
"""Create network in barrista.
Create a network in barrista similar to a combination of U-Net and
the one in the learning data-driven reflectance priors paper.
"""
print("Using u-net")
layers = []
filler = design.PROTODETAIL.FillerParameter()
filler.type = args.filler_type
kernel = 2 * args.kernel_pad + 1
pad = args.kernel_pad
# going down with local features in the U
layers.append(
ConvolutionLayer(Convolution_num_output=16,
Convolution_kernel_size=3,
Convolution_stride=2,
Convolution_pad=1,
Convolution_weight_filler=filler,
name='Conv1',
bottoms=['images']))
for i in range(args.numLayers):
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=16,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer(tops=['L1']))
layers.append(
ConvolutionLayer(Convolution_num_output=32,
Convolution_kernel_size=3,
Convolution_stride=2,
Convolution_pad=1,
Convolution_weight_filler=filler,
name='Conv2'))
for i in range(args.numLayers):
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=32,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer(tops=['L2']))
layers.append(
ConvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=3,
Convolution_stride=2,
Convolution_pad=1,
Convolution_weight_filler=filler,
name='Conv3'))
for i in range(args.numLayers):
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer(tops=['L3']))
layers.append(
ConvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=7,
Convolution_stride=1,
Convolution_pad=3,
Convolution_weight_filler=filler,
name='Conv4'))
for i in range(args.numLayers):
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer(tops=['local']))
# lower path with the image global features
layers.append(
PythonLayer(Python_module='resize_layer',
Python_layer='ResizeLayer',
name='resize',
bottoms=['images'],
tops=['resized']))
layers.append(
ConvolutionLayer(Convolution_num_output=32,
Convolution_kernel_size=5,
Convolution_stride=4,
Convolution_pad=2,
Convolution_weight_filler=filler,
name='Conv5',
bottoms=['resized']))
# for i in range(args.numLayers):
# layers.append(ReLULayer())
# layers.append(ConvolutionLayer(Convolution_num_output=32,
# Convolution_kernel_size=5,
# Convolution_pad=2,
# Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=32,
Convolution_kernel_size=5,
Convolution_stride=4,
Convolution_pad=2,
Convolution_weight_filler=filler,
name='Conv6'))
# for i in range(args.numLayers):
# layers.append(ReLULayer())
# layers.append(ConvolutionLayer(Convolution_num_output=32,
# Convolution_kernel_size=5,
# Convolution_pad=2,
# Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=32,
Convolution_kernel_size=5,
Convolution_stride=4,
Convolution_pad=2,
Convolution_weight_filler=filler,
name='Conv7'))
# for i in range(args.numLayers):
# layers.append(ReLULayer())
# layers.append(ConvolutionLayer(Convolution_num_output=32,
# Convolution_kernel_size=5,
# Convolution_pad=2,
# Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=3,
Convolution_stride=1,
Convolution_pad=0,
Convolution_weight_filler=filler,
name='Conv8'))
layers.append(ReLULayer(tops=['global_1']))
# combine the local and global features
layers.append(
PythonLayer(Python_module='broadcast_layer',
Python_layer='BroadcastLayer',
name='broadcast',
bottoms=['global_1', 'local'],
tops=['global']))
layers.append(ConcatLayer(bottoms=['local', 'global'], name='Concatenate'))
for i in range(args.numLayers):
layers.append(
ConvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=3,
Convolution_pad=1,
Convolution_weight_filler=filler))
layers.append(ReLULayer(tops=['R3']))
# going up again
layers.append(
DeconvolutionLayer(Convolution_num_output=64,
Convolution_kernel_size=2,
Convolution_stride=2,
Convolution_weight_filler=filler,
tops=['R3d']))
layers.append(ConcatLayer(bottoms=['L2', 'R3d']))
for i in range(args.numLayers):
layers.append(
ConvolutionLayer(Convolution_num_output=32,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=32,
Convolution_kernel_size=3,
Convolution_pad=1,
Convolution_weight_filler=filler))
layers.append(ReLULayer(tops=['R2']))
layers.append(
DeconvolutionLayer(Convolution_num_output=16,
Convolution_kernel_size=2,
Convolution_stride=2,
Convolution_weight_filler=filler,
tops=['R2d']))
layers.append(ConcatLayer(bottoms=['L1', 'R2d']))
for i in range(args.numLayers):
layers.append(
ConvolutionLayer(Convolution_num_output=16,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=16,
Convolution_kernel_size=3,
Convolution_pad=1,
Convolution_weight_filler=filler))
layers.append(ReLULayer(tops=['R1']))
layers.append(
DeconvolutionLayer(Convolution_num_output=3,
Convolution_kernel_size=2,
Convolution_stride=2,
Convolution_weight_filler=filler,
tops=['R1d']))
layers.append(ConcatLayer(bottoms=['images', 'R1d']))
for i in range(args.numLayers):
layers.append(
ConvolutionLayer(Convolution_num_output=3,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
layers.append(ReLULayer())
layers.append(
ConvolutionLayer(Convolution_num_output=num_output_final,
Convolution_kernel_size=3,
Convolution_pad=1,
Convolution_weight_filler=filler,
tops=['RS_est']))
return layers
def create_convIncreasing(args, num_output_final):
"""Create network in barrista."""
layers = []
do_batch_normalization = False
filler = design.PROTODETAIL.FillerParameter()
filler.type = args.filler_type
# filler.value = 1
kernel = 2 * args.kernel_pad + 1
pad = args.kernel_pad
if args.numLayers >= 1:
num_output = 2**args.num_filters_log
num_outputs = [num_output]
layers.append(
ConvolutionLayer(Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler,
bottoms=['images']))
if do_batch_normalization:
layers.append(BatchNormLayer())
layers.append(ReLULayer())
for i in range(1, args.numLayers):
num_output *= 2
num_outputs.append(num_output)
layers.append(
ConvolutionLayer(Convolution_num_output=num_output,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler))
if do_batch_normalization:
layers.append(BatchNormLayer())
layers.append(ReLULayer())
num_outputs.append(num_output_final)
layers.append(
ConvolutionLayer(Convolution_num_output=num_output_final,
Convolution_kernel_size=1,
Convolution_pad=0,
Convolution_weight_filler=filler,
tops=['RS_est']))
else:
num_outputs = [num_output_final]
layers.append(
ConvolutionLayer(Convolution_num_output=num_output_final,
Convolution_kernel_size=kernel,
Convolution_pad=pad,
Convolution_weight_filler=filler,
bottoms=['images'],
tops=['RS_est']))
print("Using a convolutional network with ReLU units where num_output.",
"increases. It has", args.numLayers, "layers with", num_outputs,
"filters, then a conv layer with num_output filters",
"dependent on RS_est mode", "The kernels are of size", kernel,
"with a padding of", pad)
return layers
netspec = design.NetSpecification([[10, 3, 51, 51], [10]],
inputs=['data', 'annotations'],
predict_inputs=['data'],
predict_input_shapes=[[10, 3, 51, 51]])
# This is a VGG like convolutional network. This could now even be created
# procedural!
layers = []
conv_params = {
'Convolution_kernel_size': 3,
'Convolution_num_output': 32,
'Convolution_pad': 1
}
layers.append(ConvolutionLayer(**conv_params))
layers.append(ReLULayer())
layers.append(ConvolutionLayer(**conv_params))
layers.append(ReLULayer())
layers.append(PoolingLayer(Pooling_kernel_size=2))
layers.append(DropoutLayer(Dropout_dropout_ratio=0.25))
conv_params['Convolution_num_output'] = 64
layers.append(ConvolutionLayer(**conv_params))
layers.append(ReLULayer())
layers.append(ConvolutionLayer(**conv_params))
layers.append(ReLULayer())
layers.append(PoolingLayer(Pooling_kernel_size=2))
layers.append(DropoutLayer(Dropout_dropout_ratio=0.25))
layers.append(InnerProductLayer(InnerProduct_num_output=256))
layers.append(ReLULayer())