def __init__(self,kernel_size,\
input_channels,\
output_features,\
bias=False,\
stride=1,\
pad = 'same',\
padType = 'symmetric',\
conv_init = 'dct',\
scale = False,\
normalizedWeights=False,\
zeroMeanWeights=False):
super(NConv_transpose2D,self).__init__()
kernel_size = formatInput2Tuple(kernel_size,int,2)
if isinstance(pad,str) and pad == 'same':
# center of the kernel
Kc = th.Tensor(kernel_size).add(1).div(2).floor()
pad = (int(Kc[0])-1, kernel_size[0]-int(Kc[0]),\
int(Kc[1])-1,kernel_size[1]-int(Kc[1]))
self.pad = formatInput2Tuple(pad,int,4)
self.padType = padType
self.stride = formatInput2Tuple(stride,int,2)
# Initialize conv weights
shape = (output_features,input_channels)+kernel_size
self.conv_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.convWeights(self.conv_weights,conv_init)
# Initialize the scaling coefficients for the conv weight normalization
if scale and normalizedWeights:
self.scale = nn.Parameter(th.Tensor(output_features).fill_(1))
else:
self.register_parameter('scale', None)
if bias:
self.bias = nn.Parameter(th.Tensor(input_channels).fill_(0))
else:
self.register_parameter('bias', None)
def nconv_transpose2D(input,weights,bias=None,stride=1,pad=0,padType='zero',\
dilation=1,scale=None,normalizedWeights=False,\
zeroMeanWeights=False):
r"""Transpose 2D normalized convolution."""
stride = formatInput2Tuple(stride,int,2)
pad = formatInput2Tuple(pad,int,4)
dilation = formatInput2Tuple(dilation,int,2)
assert(input.dim() == 4), "The dimensions of the input tensor are "\
+"expected to be equal to 4."
weights = weightNormalization(weights,scale,normalizedWeights,zeroMeanWeights)
out = th.nn.functional.conv_transpose2d(input,weights,bias,stride=stride,\
dilation=dilation)
if sum(pad) != 0:
out = pad_transpose2D(out,pad,padType)
return out
def nconv2D(input,weights,bias=None,stride=1,pad=0,padType='zero',\
dilation=1,scale=None,normalizedWeights=False,\
zeroMeanWeights=False):
r"""2D Convolution of an input tensor of size B x C X H x W where the
weights of the filters are normalized.
"""
stride = formatInput2Tuple(stride,int,2)
pad = formatInput2Tuple(pad,int,4)
dilation = formatInput2Tuple(dilation,int,2)
assert(input.dim() == 4), "The dimensions of the input tensor are "\
+"expected to be equal to 4."
if sum(pad) != 0 :
input = pad2D(input,pad,padType)
weights = weightNormalization(weights,scale,normalizedWeights,zeroMeanWeights)
return th.nn.functional.conv2d(input,weights,bias,stride=stride,\
dilation=dilation)
def residualPreActivation(input, conv1_weights, conv2_weights, \
prelu1_weights, prelu2_weights, bias1 = None, scale1 = None, \
dilation1 = 1, bias2 = None, scale2 = None, dilation2 = 1, \
normalizedWeights = False, zeroMeanWeights = False, shortcut = False,\
padType = 'symmetric'):
normalizedWeights = formatInput2Tuple(normalizedWeights,bool,2)
zeroMeanWeights = formatInput2Tuple(zeroMeanWeights,bool,2)
assert(any(prelu1_weights.numel() == i for i in (1,input.size(1)))),\
"Dimensions mismatch between input and prelu1_weights."
assert(any(prelu2_weights.numel() == i for i in (1,conv1_weights.size(0)))),\
"Dimensions mismatch between conv1_weights and prelu2_weights."
assert(conv1_weights.size(0) == conv2_weights.size(1)), "Dimensions "+\
"mismatch between conv1_weights and conv2_weights."
assert(conv2_weights.size(0) == input.size(1)), "Dimensions "+\
"mismatch between conv2_weights and input."
if (normalizedWeights[0] and scale1 is not None) or zeroMeanWeights[0]:
conv1_weights = weightNormalization(conv1_weights,scale1,\
normalizedWeights[0],zeroMeanWeights[0])
if (normalizedWeights[1] and scale2 is not None) or zeroMeanWeights[1]:
conv2_weights = weightNormalization(conv2_weights,scale2,\
normalizedWeights[1],zeroMeanWeights[1])
pad1 = getPad2RetainShape(conv1_weights.shape[2:4],dilation1)
pad2 = getPad2RetainShape(conv2_weights.shape[2:4],dilation2)
out = th.nn.functional.prelu(input,prelu1_weights)
out = conv2d(pad2D(out,pad1,padType),conv1_weights,bias = bias1, dilation = dilation1)
out = th.nn.functional.prelu(out,prelu2_weights)
out = conv2d(pad2D(out,pad2,padType),conv2_weights,bias = bias2, dilation = dilation2)
if shortcut:
return out.add(input)
else:
return out
def __init__(self, input_channels,\
wiener_kernel_size = (5,5),\
wiener_output_features = 24,\
numWienerFilters = 4,\
wienerWeightSharing = True,\
wienerChannelSharing = False,\
alphaChannelSharing = True,\
alpha_update = True,\
lb = 1e-3,\
ub = 1e-1,\
wiener_pad = True,\
wiener_padType = 'symmetric',\
edgeTaper = True,\
wiener_scale = True,\
wiener_normalizedWeights = True,\
wiener_zeroMeanWeights = True,\
kernel_size = (5,5),\
output_features = 32,\
convWeightSharing = True,\
pad = 'same',\
padType = 'symmetric',\
conv_init = 'dct',\
bias_f= True,\
bias_t = True,\
scale_f = True,\
scale_t = True,\
normalizedWeights = True,\
zeroMeanWeights = True,\
alpha_proj = True,\
rpa_depth = 5,\
rpa_kernel_size1 = (3,3),\
rpa_kernel_size2 = (3,3),\
rpa_output_features = 64,\
rpa_init = 'msra',\
rpa_bias1 = True,\
rpa_bias2 = True,\
rpa_prelu1_mc = True,\
rpa_prelu2_mc = True,\
prelu_init = 0.1,\
rpa_scale1 = True,\
rpa_scale2 = True,\
rpa_normalizedWeights = True,\
rpa_zeroMeanWeights = True,\
shortcut = (True,False),\
clb = 0,\
cub = 255):
super(WienerDeblurNet, self).__init__()
# Initialize the Wiener filters used for deconvolution
self.wiener_pad = wiener_pad
self.wiener_padType = wiener_padType
self.edgetaper = edgeTaper
self.wienerWeightSharing = wienerWeightSharing
self.wiener_normalizedWeights = wiener_normalizedWeights
self.wiener_zeroMeanWeights = wiener_zeroMeanWeights
self.alpha_update = alpha_update
assert (numWienerFilters >
1), "More than one Wiener filter is expected."
wchannels = 1 if wienerChannelSharing else input_channels
wiener_kernel_size = formatInput2Tuple(wiener_kernel_size, int, 2)
if self.wienerWeightSharing:
shape = (wiener_output_features, wchannels) + wiener_kernel_size
else:
shape = (numWienerFilters, wiener_output_features,
wchannels) + wiener_kernel_size
self.wiener_conv_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.dctMultiWiener(self.wiener_conv_weights)
if wiener_scale and wiener_normalizedWeights:
if self.wienerWeightSharing:
self.wiener_scale = nn.Parameter(
th.Tensor(wiener_output_features).fill_(0.1))
else:
self.wiener_scale = nn.Parameter(
th.Tensor(numWienerFilters,
wiener_output_features).fill_(0.1))
else:
self.register_parameter('wiener_scale', None)
assert(lb > 0 and ub > 0),"Lower (lb) and upper (ub) bounds of the "\
+"beta parameter must be positive numbers."
alpha = th.logspace(log10(lb), log10(ub),
numWienerFilters).unsqueeze(-1).log()
if alphaChannelSharing:
shape = (numWienerFilters, 1)
else:
alpha = alpha.repeat(1, input_channels)
shape = (numWienerFilters, input_channels)
if self.alpha_update:
self.alpha = nn.Parameter(th.Tensor(th.Size(shape)))
self.alpha.data.copy_(alpha)
else:
self.alpha = alpha
# Initialize the Residual Denoising Network
kernel_size = formatInput2Tuple(kernel_size, int, 2)
if isinstance(pad, str) and pad == 'same':
pad = getPad2RetainShape(kernel_size)
# Kc = th.Tensor(kernel_size).add(1).div(2).floor()
# pad = (int(Kc[0])-1, kernel_size[0]-int(Kc[0]),\
# int(Kc[1])-1,kernel_size[1]-int(Kc[1]))
self.pad = formatInput2Tuple(pad, int, 4)
self.padType = padType
self.normalizedWeights = normalizedWeights
self.zeroMeanWeights = zeroMeanWeights
self.convWeightSharing = convWeightSharing
# Initialize conv weights
shape = (output_features, input_channels) + kernel_size
self.conv_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.convWeights(self.conv_weights, conv_init)
# Initialize the scaling coefficients for the conv weight normalization
if scale_f and normalizedWeights:
self.scale_f = nn.Parameter(th.Tensor(output_features).fill_(1))
else:
self.register_parameter('scale_f', None)
# Initialize the bias for the conv layer
if bias_f:
self.bias_f = nn.Parameter(th.Tensor(output_features).fill_(0))
else:
self.register_parameter('bias_f', None)
# Initialize the bias for the transpose conv layer
if bias_t:
self.bias_t = nn.Parameter(th.Tensor(input_channels).fill_(0))
else:
self.register_parameter('bias_t', None)
if not self.convWeightSharing:
self.convt_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.convWeights(self.convt_weights, conv_init)
if scale_t and normalizedWeights:
self.scale_t = nn.Parameter(
th.Tensor(output_features).fill_(1))
else:
self.register_parameter('scale_t', None)
numparams_prelu1 = output_features if rpa_prelu1_mc else 1
numparams_prelu2 = rpa_output_features if rpa_prelu2_mc else 1
self.rpa_depth = rpa_depth
self.shortcut = formatInput2Tuple(shortcut,
bool,
rpa_depth,
strict=False)
self.resPA = nn.ModuleList([modules.ResidualPreActivationLayer(\
rpa_kernel_size1,rpa_kernel_size2,output_features,\
rpa_output_features,rpa_bias1,rpa_bias2,1,1,\
numparams_prelu1,numparams_prelu2,prelu_init,padType,\
rpa_scale1,rpa_scale2,rpa_normalizedWeights,\
rpa_zeroMeanWeights,rpa_init,self.shortcut[i]) \
for i in range(self.rpa_depth)])
self.bbproj = nn.Hardtanh(min_val=clb, max_val=cub)
# Initialize the parameter for the L2Proj layer
if alpha_proj:
self.alpha_proj = nn.Parameter(th.Tensor(1).fill_(0))
else:
self.register_parameter('alpha_proj', None)
# Initialize the parameter for weighting the outputs of each Residual
# Denoising Network
self.weights = nn.Parameter(
th.Tensor(1, numWienerFilters, 1, 1,
1).fill_(1 / numWienerFilters))
def __init__(self, kernel1_size,\
kernel2_size,\
input_channels,\
output_features,\
bias1 = False,\
bias2 = False,\
dilation1 = 1,\
dilation2 = 1,\
numparams_prelu1 = 1,\
numparams_prelu2 = 1,\
prelu_init = 0.1,\
padType = 'symmetric',\
scale1 = True,\
scale2 = True,\
normalizedWeights = True,\
zeroMeanWeights = True,\
weights_init = 'msra',\
shortcut = False):
super(ResidualPreActivationLayer, self).__init__()
self.normalizedWeights = formatInput2Tuple(normalizedWeights,bool,2)
self.zeroMeanWeights = formatInput2Tuple(zeroMeanWeights,bool,2)
self.shortcut = shortcut
self.dilation1 = formatInput2Tuple(dilation1,int,2)
self.dilation2 = formatInput2Tuple(dilation2,int,2)
self.padType = padType
kernel1_size = formatInput2Tuple(kernel1_size,int,2)
kernel2_size = formatInput2Tuple(kernel2_size,int,2)
# Init of conv1 weights
shape = (output_features,input_channels)+kernel1_size
self.conv1_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.msra(self.conv1_weights)
# Init of conv2 weights
shape = (input_channels,output_features)+kernel2_size
self.conv2_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.convWeights(self.conv2_weights,weights_init)
# Initialize the scaling coefficients for the conv weights normalization
if scale1 and self.normalizedWeights[0]:
self.scale1 = nn.Parameter(th.Tensor(output_features).fill_(0.1))
else:
self.register_parameter('scale1', None)
if scale2 and self.normalizedWeights[1]:
self.scale2 = nn.Parameter(th.Tensor(input_channels).fill_(0.1))
else:
self.register_parameter('scale2', None)
if bias1:
self.bias1 = nn.Parameter(th.Tensor(output_features).fill_(0))
else:
self.register_parameter('bias1', None)
if bias2:
self.bias2 = nn.Parameter(th.Tensor(input_channels).fill_(0))
else:
self.register_parameter('bias2', None)
# Init of prelu weights
self.prelu1_weights = nn.Parameter(th.Tensor(numparams_prelu1).fill_(prelu_init))
self.prelu2_weights = nn.Parameter(th.Tensor(numparams_prelu2).fill_(prelu_init))
def __init__(self, kernel_size,\
input_channels,\
output_features,\
numWienerFilters = 4,\
sharedWienerFilters = False,\
sharedChannels = True,\
sharedAlphaChannels = True,\
alpha_update = True,\
lb = 1e-4,\
ub = 1e-2,\
pad = True,\
padType = 'symmetric',\
edgeTaper = True,\
scale = True,\
normalizedWeights = True,\
zeroMeanWeights = True):
super(WienerDeconvLayer,self).__init__()
self.pad = pad
self.padType = padType
self.edgetaper = edgeTaper
self.sharedWienerFilters = sharedWienerFilters
self.normalizedWeights = normalizedWeights
self.zeroMeanWeights = zeroMeanWeights
assert(numWienerFilters > 1),"More than one Wiener filter is expected."
# Initialize conv regularization weights
channels = 1 if sharedChannels else input_channels
kernel_size = formatInput2Tuple(kernel_size,int,2)
if sharedWienerFilters:
shape = (output_features,channels)+kernel_size
else:
shape = (numWienerFilters,output_features,channels)+kernel_size
self.conv_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.dctMultiWiener(self.conv_weights)
if scale and normalizedWeights:
if sharedWienerFilters:
self.scale = nn.Parameter(th.Tensor(output_features).fill_(0.1))
else:
self.scale = nn.Parameter(th.Tensor(numWienerFilters,output_features).fill_(0.1))
else:
self.register_parameter('scale', None)
assert(lb > 0 and ub > 0),"Lower (lb) and upper (ub) bounds of the "\
+"alpha parameter must be positive numbers."
alpha = th.logspace(log10(lb),log10(ub),numWienerFilters).unsqueeze(-1).log()
if sharedAlphaChannels:
shape = (numWienerFilters,1)
else:
alpha = alpha.repeat(1,input_channels)
shape = (numWienerFilters,input_channels)
if alpha_update:
self.alpha = nn.Parameter(th.Tensor(th.Size(shape)))
self.alpha.data.copy_(alpha)
else:
self.alpha = alpha
def __init__(self, kernel_size,\
input_channels,\
output_features,\
rbf_mixtures,\
rbf_precision,\
pad = 'same',\
convWeightSharing = True,\
alpha = True,
lb = -100,\
ub = 100,\
padType = 'symmetric',\
scale_f = True,\
scale_t = True,\
normalizedWeights = True,\
zeroMeanWeights = True):
super(ResidualRBFLayer, self).__init__()
kernel_size = formatInput2Tuple(kernel_size,int,2)
if isinstance(pad,str) and pad == 'same':
pad = getPad2RetainShape(kernel_size)
# # center of the kernel
# Kc = th.Tensor(kernel_size).add(1).div(2).floor()
# pad = (int(Kc[0])-1, kernel_size[0]-int(Kc[0]),\
# int(Kc[1])-1,kernel_size[1]-int(Kc[1]))
self.pad = formatInput2Tuple(pad,int,4)
self.padType = padType
self.normalizedWeights = normalizedWeights
self.zeroMeanWeights = zeroMeanWeights
self.lb = lb
self.ub = ub
# Initialize conv weights
shape = (output_features,input_channels)+kernel_size
self.conv_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.dct(self.conv_weights)
if convWeightSharing:
self.convt_weights = self.conv_weights
else:
self.convt_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.dct(self.convt_weights)
# Initialize the scaling coefficients for the conv weight normalization
if scale_f and normalizedWeights:
self.scale_f = nn.Parameter(th.Tensor(output_features).fill_(1))
else:
self.register_parameter('scale_f', None)
if scale_t and normalizedWeights:
if convWeightSharing and scale_f:
self.scale_t = self.scale_f
elif not convWeightSharing or (convWeightSharing and not scale_f):
self.scale_t = nn.Parameter(th.Tensor(output_features).fill_(1))
else :
self.register_parameter('scale_t', None)
# Initialize the params for the proxL2
if alpha :
self.alpha_prox = nn.Parameter(th.Tensor(1).fill_(0))
else:
self.register_parameter('alpha_prox', None)
# Initialize the rbf_weights
self.rbf_weights = nn.Parameter(th.Tensor(output_features,rbf_mixtures).fill_(1e-4))
self.rbf_centers = th.linspace(lb,ub,rbf_mixtures).type_as(self.rbf_weights)
self.rbf_precision = rbf_precision
def __init__(self, kernel_size,\
input_channels,\
output_features,\
convWeightSharing = True,\
pad = 'same',\
padType = 'symmetric',\
conv_init = 'dct',\
bias_f= True,\
bias_t = True,\
scale_f = True,\
scale_t = True,\
normalizedWeights = True,\
zeroMeanWeights = True,\
alpha = True,\
rpa_depth = 5,\
rpa_kernel_size1 = (3,3),\
rpa_kernel_size2 = (3,3),\
rpa_output_features = 64,\
rpa_init = 'msra',\
rpa_bias1 = True,\
rpa_bias2 = True,\
rpa_prelu1_mc = True,\
rpa_prelu2_mc = True,\
prelu_init = 0.1,\
rpa_scale1 = True,\
rpa_scale2 = True,\
rpa_normalizedWeights = True,\
rpa_zeroMeanWeights = True,\
shortcut = (True,False),\
clb = 0,\
cub = 255):
super(UDNetPA, self).__init__()
kernel_size = formatInput2Tuple(kernel_size, int, 2)
if isinstance(pad, str) and pad == 'same':
pad = getPad2RetainShape(kernel_size)
pad = (pad[1], pad[2])
# Kc = th.Tensor(kernel_size).add(1).div(2).floor()
# pad = (int(Kc[0])-1, kernel_size[0]-int(Kc[0]),\
# int(Kc[1])-1,kernel_size[1]-int(Kc[1]))
self.pad = formatInput2Tuple(pad, int, 2)
self.padType = padType
self.normalizedWeights = normalizedWeights
self.zeroMeanWeights = zeroMeanWeights
self.convWeightSharing = convWeightSharing
# Initialize conv weights
shape = (output_features, input_channels) + kernel_size
self.conv_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.convWeights(self.conv_weights, conv_init)
# Initialize the scaling coefficients for the conv weight normalization
if scale_f and normalizedWeights:
self.scale_f = nn.Parameter(th.Tensor(output_features).fill_(1))
else:
self.register_parameter('scale_f', None)
# Initialize the bias for the conv layer
if bias_f:
self.bias_f = nn.Parameter(th.Tensor(output_features).fill_(0))
else:
self.register_parameter('bias_f', None)
# Initialize the bias for the transpose conv layer
if bias_t:
self.bias_t = nn.Parameter(th.Tensor(input_channels).fill_(0))
else:
self.register_parameter('bias_t', None)
if not self.convWeightSharing:
self.convt_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.convWeights(self.convt_weights, conv_init)
if scale_t and normalizedWeights:
self.scale_t = nn.Parameter(
th.Tensor(output_features).fill_(1))
else:
self.register_parameter('scale_t', None)
numparams_prelu1 = output_features if rpa_prelu1_mc else 1
numparams_prelu2 = rpa_output_features if rpa_prelu2_mc else 1
self.rpa_depth = rpa_depth
self.shortcut = formatInput2Tuple(shortcut,
bool,
rpa_depth,
strict=False)
self.resPA = nn.Sequential(*nn.ModuleList([modules.ResidualPreActivationLayer(\
rpa_kernel_size1,rpa_kernel_size2,output_features,\
rpa_output_features,rpa_bias1,rpa_bias2,1,1,\
numparams_prelu1,numparams_prelu2,prelu_init,padType,\
rpa_scale1,rpa_scale2,rpa_normalizedWeights,\
rpa_zeroMeanWeights,rpa_init,self.shortcut[i]) \
for i in range(self.rpa_depth)]))
self.bbproj = nn.Hardtanh(min_val=clb, max_val=cub)
# Initialize the parameter for the L2Proj layer
if alpha:
self.alpha = nn.Parameter(th.Tensor(1).fill_(0))
else:
self.register_parameter('alpha', None)
if isinstance(opt.lr_milestones, tuple):
opt.lr_milestones = list(opt.lr_milestones)
else:
opt.lr_milestones = [opt.lr_milestones]
if opt.convWeightSharing:
str_ws = '-WS'
else:
str_ws = '-NoWS'
if opt.color:
strc = 'color'
else:
strc = 'gray'
opt.kernel_size = formatInput2Tuple(opt.kernel_size, int, 2)
if isinstance(opt.stdn, tuple) and len(opt.stdn) == 1:
stdn = opt.stdn[0]
else:
stdn = opt.stdn
if opt.xid == '':
opt.xid = 'UDNet'
else:
opt.xid = 'UDNet_' + opt.xid
dirname = "{}_{}_stages:{}_kernel:{}x{}_filters:{}{}_stdn:{}_joint_train".format(opt.xid,\
strc,opt.stages,opt.kernel_size[0],opt.kernel_size[1],\
opt.num_filters,str_ws,stdn)
# numTrainImagesperPSF=4,numTestImagesperPSF=3,data_seed=20180102,amsgrad=True)
if isinstance(opt.lr_milestones,tuple):
opt.lr_milestones = list(opt.lr_milestones)
else:
opt.lr_milestones = [opt.lr_milestones]
str_cws = '-CWS' if opt.convWeightSharing else ''
str_wws = '-WWS' if opt.wienerWeightSharing else ''
str_wcs = '-WCS' if opt.wienerChannelSharing and opt.color else ''
strc = 'color' if opt.color else 'gray'
opt.wiener_kernel_size = formatInput2Tuple(opt.wiener_kernel_size,int,2)
opt.kernel_size = formatInput2Tuple(opt.kernel_size,int,2)
opt.rpa_kernel_size1 = formatInput2Tuple(opt.rpa_kernel_size1,int,2)
opt.rpa_kernel_size2 = formatInput2Tuple(opt.rpa_kernel_size2,int,2)
if isinstance(opt.stdn,tuple) :
if len(opt.stdn) == 1:
stdn = str(opt.stdn[0])
else:
stdn = "("+str(opt.stdn[0])+"->"+str(opt.stdn[-1])+")"
else:
stdn = str(opt.stdn)
if opt.xid == '':
opt.xid = 'WDNet'
else:
def __init__(self, kernel_size,\
input_channels,\
output_features,\
rbf_mixtures,\
rbf_precision,\
pad='same',\
convWeightSharing=True,\
lb=-100,\
ub=100,\
padType='symmetric',\
scale_f=True,\
scale_t=True,\
normalizedWeights=True,\
zeroMeanWeights=True,\
prox_param=True):
super(ResRBFPoisLayer, self).__init__()
kernel_size = formatInput2Tuple(kernel_size, int, 2)
if isinstance(pad, str) and pad == 'same':
pad = getPad2RetainShape(kernel_size)
self.pad = formatInput2Tuple(pad, int, 4)
self.padType = padType
self.normalizedWeights = normalizedWeights
self.zeroMeanWeights = zeroMeanWeights
self.convWeightSharing = convWeightSharing
self.lb = lb
self.ub = ub
# Initialize conv weights
shape = (output_features, input_channels) + kernel_size
self.conv_weights = nn.Parameter(th.Tensor(th.Size(shape)))
# initialize_conv_weights(self.conv_weights)
init.dct(self.conv_weights)
# Initialize the scaling coefficients for the conv weight normalization
if scale_f and normalizedWeights:
self.scale_f = nn.Parameter(th.Tensor(output_features).fill_(0.1))
else:
self.register_parameter('scale_f', None)
if not self.convWeightSharing:
self.convt_weights = nn.Parameter(th.Tensor(th.Size(shape)))
init.dct(self.convt_weights)
if scale_t and normalizedWeights:
self.scale_t = nn.Parameter(
th.Tensor(output_features).fill_(0.1))
else:
self.register_parameter('scale_t', None)
# Initialize the params for the PoisProx.
# Projection condition multiplier.
if prox_param:
self.prox_param = nn.Parameter(th.Tensor(1).fill_(0.1))
else:
self.register_parameter('prox_param', None)
# Initialize the rbf_weights
self.rbf_weights = nn.Parameter(
th.Tensor(output_features, rbf_mixtures).fill_(1e-4))
self.rbf_centers = th.linspace(lb, ub,
rbf_mixtures).type_as(self.rbf_weights)
self.rbf_precision = rbf_precision