def __init__(self, feature_extraction, cam_intrinsics, d_candi,
sigma_soft_max, BV_log = False, normalize = True,
use_img_intensity = False, force_img_dw_rate = 1,
parallel_d = True, output_features = False,
refine_costV = False, feat_dist = 'L2', drefine = ""):
'''
INPUTS:
feature_extraction - the feature extrator module
cam_intrinsic - {'hfov': hfov, 'vfov': vfov, 'unit_ray_array': unit_ray_array, 'intrinsic_M'} :
hfov, vfov - fovs in horzontal and vertical directions (degrees)
unit_ray_array - A tensor with size (height, width, 3). Each 'pixel' corresponds to the
unit ray pointing from the camera center to the pixel
d_candi - np array of candidate depths
output_features - if output the features from the feature extractor. If ture, forward() will also return multi-scale
image features (.25 and .5 image sizes) from the feature extractor
In this case, the output features will be saved in a list: [ img_feat_final, img_feat_layer1]
where img_feat_layer1 is the .5 image size feature
refine_costV - if do the optional convolutions to refine costV before soft_max(costV)
feat_dist - 'L2' (default) or 'L1' distance for feature matching
'''
super(D_NET_BASIC, self).__init__()
self.feature_extraction = feature_extraction
self.cam_intrinsics = cam_intrinsics
self.d_candi = d_candi
self.sigma_soft_max = sigma_soft_max
self.BV_log = BV_log
self.normalize = normalize
self.use_img_intensity = use_img_intensity
self.parallel_d = parallel_d
self.output_features = output_features
self.refine_costV = refine_costV
self.feat_dist = feat_dist
self.refine_costV = refine_costV
self.drefine = drefine
if force_img_dw_rate > 1:
self.force_img_dw_rate = force_img_dw_rate # Force to downsampling the input images
else:
self.force_img_dw_rate = None
if self.drefine == "m1":
D = len(d_candi)
self.conv0 = m_submodule.conv2d_leakyRelu(
ch_in = D, ch_out = D, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv0_1 = m_submodule.conv2d_leakyRelu(
ch_in= D, ch_out= D, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv0_2 = nn.Conv2d(D, D, kernel_size=3, stride=1, padding=1, bias=True)
self.apply(self.weight_init)
elif self.drefine == "m2":
pass
def __init__(self, in_channels):
'''
in_channels - for example, if we use some statistics from DPV, plus the raw rgb input image, then
in_channels = 3 + # of statistics we used from DPV
Statistics of DPV can includes {expected mean, variance, min_v, max_v etc. }
'''
super(RefineNet_Unet2D, self).__init__()
self.conv0 = m_submodule.conv2d_leakyRelu(ch_in=in_channels, ch_out=32, kernel_size=3, stride=1, pad=1,
use_bias=True)
self.conv0_1 = m_submodule.conv2d_leakyRelu(ch_in=32, ch_out=32, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv1 = m_submodule.conv2d_leakyRelu(ch_in=32, ch_out=64, kernel_size=3, stride=2, pad=1, use_bias=True)
self.conv1_1 = m_submodule.conv2d_leakyRelu(ch_in=64, ch_out=64, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv2 = m_submodule.conv2d_leakyRelu(ch_in=64, ch_out=128, kernel_size=3, stride=2, pad=1, use_bias=True)
self.conv2_1 = m_submodule.conv2d_leakyRelu(ch_in=128, ch_out=128, kernel_size=3, stride=1, pad=1,
use_bias=True)
self.trans_conv0 = m_submodule.conv2dTranspose_leakyRelu(ch_in=128, ch_out=64, kernel_size=4, stride=2, pad=1,
use_bias=True)
self.trans_conv1 = m_submodule.conv2dTranspose_leakyRelu(ch_in=128, ch_out=32, kernel_size=4, stride=2, pad=1,
use_bias=True)
self.conv3 = m_submodule.conv2d_leakyRelu(ch_in=64, ch_out=16, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv3_1 = nn.Conv2d(16, 1, kernel_size=3, stride=1, padding=1, bias=True)
self.apply(self.weight_init)
def __init__(self, C0, C1, C2, D=64, upsample_D=False):
'''
Inputs:
C0 - feature channels in .25 image resolution feature,
C1 - feature cnahnels in .5 image resolution feature,
C2 - feature cnahnels in 1 image resolution feature,
D - the length of d_candi, we will treat the D dimension as the feature dimension
upsample_D - if upsample in the D dimension
'''
super(FlowNet_DPV_upsample, self).__init__()
in_channels = D + C0
if upsample_D:
D0 = 2 * D
D1 = 2 * D0
else:
D0 = D
D1 = D
self.conv0 = m_submodule.conv2d_leakyRelu(
ch_in=in_channels, ch_out=in_channels, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv0_1 = m_submodule.conv2d_leakyRelu(
ch_in=in_channels, ch_out=in_channels, kernel_size=3, stride=1, pad=1, use_bias=True)
self.trans_conv0 = m_submodule.conv2dTranspose_leakyRelu(
ch_in=in_channels, ch_out=D0, kernel_size=4, stride=2, pad=1, use_bias=True)
self.conv1 = m_submodule.conv2d_leakyRelu(
ch_in=D0 + C1, ch_out=D0 + C1, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv1_1 = m_submodule.conv2d_leakyRelu(
ch_in=D0 + C1, ch_out=D0 + C1, kernel_size=3, stride=1, pad=1, use_bias=True)
self.trans_conv1 = m_submodule.conv2dTranspose_leakyRelu(
ch_in=D0 + C1, ch_out=D1, kernel_size=4, stride=2, pad=1, use_bias=True)
self.conv2 = m_submodule.conv2d_leakyRelu(
ch_in=D1 + C2, ch_out=D1 + C2, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv2_1 = m_submodule.conv2d_leakyRelu(
ch_in=D1 + C2, ch_out=D1, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv2_2 = nn.Conv2d(D1, D1, kernel_size=3, stride=1, padding=1, bias=True)
self.apply(self.weight_init)
def __init__(self, In_D, Out_D, Depth=64, C=3, mode="default"):
"""
In the constructor we instantiate two nn.Linear modules and assign them as
member variables.
"""
super(SimpleBlockA, self).__init__()
import m_submodule
modules = []
if mode == "default":
for i in range(0, C):
modules.append(
m_submodule.conv2d_leakyRelu(ch_in=In_D,
ch_out=Depth,
kernel_size=3,
stride=1,
pad=1,
use_bias=True))
modules.append(nn.Conv2d(Depth, Out_D, 3, 1, 1))
self.net = nn.Sequential(*modules)
self.apply(self.weight_init)
def __init__(self, img_ch=3):
super(RefineNet_DeMoN, self).__init__()
self.conv0 = m_submodule.conv2d_leakyRelu(ch_in=img_ch + 1, ch_out=32, kernel_size=3, stride=1, pad=1,
use_bias=True)
self.conv1 = m_submodule.conv2d_leakyRelu(ch_in=32, ch_out=64, kernel_size=3, stride=2, pad=1, use_bias=True)
self.conv1_1 = m_submodule.conv2d_leakyRelu(ch_in=64, ch_out=64, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv2 = m_submodule.conv2d_leakyRelu(ch_in=64, ch_out=128, kernel_size=3, stride=2, pad=1, use_bias=True)
self.conv2_1 = m_submodule.conv2d_leakyRelu(ch_in=128, ch_out=128, kernel_size=3, stride=1, pad=1,
use_bias=True)
self.trans_conv0 = m_submodule.conv2dTranspose_leakyRelu(ch_in=128, ch_out=64, kernel_size=4, stride=2, pad=1,
use_bias=True)
self.trans_conv1 = m_submodule.conv2dTranspose_leakyRelu(ch_in=128, ch_out=32, kernel_size=4, stride=2, pad=1,
use_bias=True)
self.conv3 = m_submodule.conv2d_leakyRelu(ch_in=64, ch_out=16, kernel_size=3, stride=1, pad=1, use_bias=True)
self.conv3_1 = nn.Conv2d(16, 1, kernel_size=3, stride=1, padding=1, bias=True)
self.apply(self.weight_init)