示例#1
0
    def __init__(self, maxdisp=192):
        super(GANet, self).__init__()
        self.maxdisp = maxdisp
        self.conv_start = nn.Sequential(BasicConv(3, 16, kernel_size=3, stride=2, padding=1),
                                        BasicConv(16, 32, kernel_size=3, stride=2, padding=1),
                                        BasicConv(32, 32, kernel_size=3, stride=2, padding=1),
                                        BasicConv(32, 32, kernel_size=3, padding=1))

        self.conv_x = BasicConv(32, 32, kernel_size=3, padding=1)
        self.conv_y = BasicConv(32, 32, kernel_size=3, padding=1)
        self.conv_x11 = BasicConv(16, 16, kernel_size=3, padding=1)
        self.conv_y11 = BasicConv(16, 16, kernel_size=3, padding=1)
        self.conv_x22 = BasicConv(8, 8, kernel_size=3, padding=1)
        self.conv_y22 = BasicConv(8, 8, kernel_size=3, padding=1)
        self.conv_refine = nn.Conv2d(32, 32, (3, 3), (1, 1), (1, 1), bias=False)
        self.bn_relu = nn.Sequential(apex.parallel.SyncBatchNorm(32),
                                     nn.ReLU(inplace=True))
        self.feature = Feature()
        self.guidance = Guidance()
        self.cost_agg = CostAggregation(int(self.maxdisp / 8))
        self.cv = GetCostVolume(int(self.maxdisp / 8))
        self.Res_cv1 = RebuildCostVolume(2 * 8)
        self.Res_Pred11 = ResidualPredition(2 * 8, 32)
        self.Res_cv2 = RebuildCostVolume(2 * 4)
        self.Res_Pred22 = ResidualPredition(2 * 4, 16)
        self.edge_refine = EdgeRefine()
        for m in self.modules():
            if isinstance(m, (nn.Conv2d, nn.Conv3d)):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
            elif isinstance(m, (apex.parallel.SyncBatchNorm, apex.parallel.SyncBatchNorm)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
示例#2
0
    def __init__(self, maxdisp=192):
        super(GANet, self).__init__()
        self.maxdisp = maxdisp
        self.conv_start = nn.Sequential(
            BasicConv(3, 16, kernel_size=3, padding=1),
            BasicConv(16, 32, kernel_size=3, padding=1))

        self.conv_x = BasicConv(32, 32, kernel_size=3, padding=1)
        self.conv_y = BasicConv(32, 32, kernel_size=3, padding=1)
        self.conv_refine = nn.Conv2d(32,
                                     32, (3, 3), (1, 1), (1, 1),
                                     bias=False)
        self.bn_relu = nn.Sequential(BatchNorm2d(32), nn.ReLU(inplace=True))
        self.feature = Feature()
        self.guidance = Guidance()
        self.cost_agg = CostAggregation(self.maxdisp)
        self.cv = GetCostVolume(int(self.maxdisp / 3))

        for m in self.modules():
            if isinstance(m, (nn.Conv2d, nn.Conv3d)):
                nn.init.kaiming_normal_(m.weight,
                                        mode='fan_out',
                                        nonlinearity='relu')
            elif isinstance(m, (BatchNorm2d, BatchNorm3d)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)
示例#3
0
    def __init__(self, maxdisp=192):
        super(GANet, self).__init__()
        self.maxdisp = maxdisp
        self.conv_start = nn.Sequential(
            BasicConv(3, 16, kernel_size=3, padding=1),
            BasicConv(16, 32, kernel_size=3, padding=1))

        self.conv_x = BasicConv(32, 32, kernel_size=3, padding=1)
        self.conv_y = BasicConv(32, 32, kernel_size=3, padding=1)
        self.conv_refine = nn.Conv2d(32,
                                     32, (3, 3), (1, 1), (1, 1),
                                     bias=False)
        self.bn_relu = nn.Sequential(apex.parallel.SyncBatchNorm(32),
                                     nn.ReLU(inplace=True))
        self.feature = Feature()
        self.guidance = Guidance()
        self.cost_agg = CostAggregation(self.maxdisp)
        self.cv = GetCostVolume(int(self.maxdisp / 3))
        # TODO freeze above
        for m in self.children():
            m.eval()
        for p in self.parameters():
            p.requires_grad = False

        self.edge_refine = EdgeRefine()

        for m in self.modules():
            if isinstance(m, (nn.Conv2d, nn.Conv3d)):
                nn.init.kaiming_normal_(m.weight,
                                        mode='fan_out',
                                        nonlinearity='relu')
            elif isinstance(
                    m,
                (apex.parallel.SyncBatchNorm, apex.parallel.SyncBatchNorm)):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)