monodepth 训练记录

2019年2月22日13:52:37

https://zhuanlan.zhihu.com/p/29968267

这里有个tensorlfow代码的阅读博客：

https://zhuanlan.zhihu.com/p/29664269

跑的是这个版本： https://github.com/ClubAI/MonoDepth-PyTorch

对比了下 tf 和 pt 版本的代码，比较简单，就不分析了。

输入的图片先resize到 256x512 大小

model部分生成了4个不同尺度的视差图：

print("self disp1 size:", self.disp1.size() )  # torch.Size([1, 2, 256, 512])
print("self disp2 size:", self.disp2.size() )  # torch.Size([1, 2, 128, 256])
print("self disp3 size:", self.disp3.size() )  # torch.Size([1, 2, 64, 128])
print("self disp4 size:", self.disp4.size() )  # torch.Size([1, 2, 32, 64])
return self.disp1, self.disp2, self.disp3, self.disp4  # 输出各个尺度的左右视差图

然后  loss 部分 loss = loss_function(disps, [left, right])

因为双目相机视差公式 x_left = x_right + disparity 是假设两个相机的光轴平行，

然后代码中真的就是直接加。

所以输入到网络中的 左-右图像对都要先做 立体校正 ！

参考  cv2.stereoRectify 的相关知识。

https://www.cnblogs.com/zyly/p/9373991.html

 # -*- coding: utf-8 -*-
 """
 Created on Wed Feb 27 13:43:29 2019

 @author: x

 这个用opencv的函数完成了深度估计

 https://github.com/aaliomer/Home-Drone/blob/
 a22f9d78644996d7876716ee961e29a9f4e8a705/python/depth%20map/calibrationExample.py

 https://blog.csdn.net/xiao__run/article/details/78887362

 """

 import numpy as np
 import cv2

 numBoards = 30  #how many boards would you like to find

 criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)

 w = 9
 h = 6

 # Arrays to store object points and image points from all the images.
 object_points = [] # 3d point in real world space
 imagePoints1 = [] # 2d points in image plane.
 imagePoints2 = [] # 2d points in image plane.

 corners1 = []
 corners2 = []

 obj = np.zeros((9*6, 3), np.float32)
 obj[:,:2] = np.mgrid[0:9, 0:6].T.reshape(-1,2)
 obj = obj*25  # 25 mm  18.1

 cap = cv2.VideoCapture("./calibration.avi")

 success = 0
 k = 0
 found1 = False
 found2 = False

 i = 0
 while True:
    i += 1
    ret, frame = cap.read()
    if ret is False:
        break

    img1 = frame[:, 640:]  # left
    img2 = frame[:, 0:640] # right

 #   retL, img1 = vidStreamL.read()
 #   retR, img2 = vidStreamR.read()

 #   height, width, depth  = img1.shape

    gray1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)

    found1, corners1 = cv2.findChessboardCorners(img1, (w,h), None)
    found2, corners2 = cv2.findChessboardCorners(img2, (w,h), None)

    if (found1):
        cv2.cornerSubPix(gray1, corners1, (11, 11), (-1, -1),criteria)
        cv2.drawChessboardCorners(gray1, (w,h), corners1, found1)

    if (found2):
        cv2.cornerSubPix(gray2, corners2, (11, 11), (-1, -1), criteria)
        cv2.drawChessboardCorners(gray2, (w,h), corners2, found2)

    cv2.imshow('image1 left', gray1)
    cv2.imshow('image2 right', gray2)

    k = cv2.waitKey(1)

    if (found1 != 0 and found2 != 0):

        if i%20 == 0:
            imagePoints1.append(corners1);
            imagePoints2.append(corners2);
            object_points.append(obj);

            print("Corners stored\n")

            success+=1

            if (success >= numBoards):
                break

 cap.release()
 cv2.destroyAllWindows()
 #%%
 # 下面是matlab标定的结果，应该比opencv的更准一点
 mtx_left = np.array([
  [767.49,       1.927,  314.49],
  [  0.        ,766.64,  237.19],
  [  0.        ,0.          ,1.],
  ])

 dist_left = np.array([0.0047, 0.0793, 1.39e-04, 0.0030, -0.6080])

 mtx_right = np.array([
  [767.72,     1.3963,      330.26],
  [  0.       ,765.37,      160.09],
  [  0.       ,0.          ,1.        ],
  ])

 dist_right = np.array([ 0.0411,-0.3073,-3.037e-04,0.0041,0.9156])
 #%%
 print("Starting Calibration\n")

 width = 640
 height = 480

 retval, cameraMatrix1, distCoeffs1, cameraMatrix2, distCoeffs2, R, T, E, F  \
    = cv2.stereoCalibrate(object_points, imagePoints1, imagePoints2,
                          mtx_left, dist_left, mtx_right, dist_right,
                          (width, height) )

 print("Done Calibration\n")
 #%%
 size = (640, 480) # 图像尺寸

 # 进行立体更正
 R1, R2, P1, P2, Q, validPixROI1, validPixROI2 = \
     cv2.stereoRectify(mtx_left, dist_left,
                       mtx_right, dist_right, size, R, T)

 # 计算更正map
 left_map1, left_map2 = \
 cv2.initUndistortRectifyMap(mtx_left, dist_left, R1, P1, size, cv2.CV_16SC2)

 right_map1, right_map2 = \
 cv2.initUndistortRectifyMap(mtx_right, dist_right, R2, P2, size, cv2.CV_16SC2)
 #%%
 #cv2.namedWindow("left")
 #cv2.namedWindow("right")
 cv2.namedWindow("depth")

 #cv2.moveWindow("left", 0, 0)
 #cv2.moveWindow("right", 600, 0)

 cv2.createTrackbar("num", "depth", 0, 10, lambda x: None)
 cv2.createTrackbar("blockSize", "depth", 5, 255, lambda x: None)

 # 添加点击事件，打印当前点的距离
 def callbackFunc(e, x, y, f, p):
     if e == cv2.EVENT_LBUTTONDOWN:
         print(threeD[y][x])

 cv2.setMouseCallback("depth", callbackFunc, None)

 cap = cv2.VideoCapture("./outdoor_cam_1547865993.avi")
 #cap = cv2.VideoCapture("./calibration.avi")

 while True:
     ret, frame = cap.read()
     if ret is False:
        break

     frame1 = frame[:, 640:]  # left
     frame2 = frame[:, 0:640] # right

     if ret is False:
         break

     # 根据更正map对图片进行重构
     img1_rectified = cv2.remap(frame1, left_map1,  left_map2,  cv2.INTER_LINEAR)
     img2_rectified = cv2.remap(frame2, right_map1, right_map2, cv2.INTER_LINEAR)

     # 将图片置为灰度图，为StereoBM作准备
     imgL = cv2.cvtColor(img1_rectified, cv2.COLOR_BGR2GRAY)
     imgR = cv2.cvtColor(img2_rectified, cv2.COLOR_BGR2GRAY)

     # 两个trackbar用来调节不同的参数查看效果
     num = cv2.getTrackbarPos("num", "depth")
     blockSize = cv2.getTrackbarPos("blockSize", "depth")
     if blockSize % 2 == 0:
         blockSize += 1
     if blockSize < 5:
         blockSize = 5

     # 根据Block Maching方法生成差异图（opencv里也提供了
     # SGBM/Semi-Global Block Matching算法，有兴趣可以试试）
     stereo = cv2.StereoBM_create(numDisparities=16*num, blockSize=blockSize)
     disparity = stereo.compute(imgL, imgR)

     disp = cv2.normalize(disparity, disparity, alpha=0, beta=255,
                          norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)

     disp = cv2.applyColorMap(disp, cv2.COLORMAP_HOT)

     # 将图片扩展至3d空间中，其z方向的值则为当前的距离
     threeD = cv2.reprojectImageTo3D(disparity.astype(np.float32)/16., Q)

 #    cv2.imshow("left",  img1_rectified)
 #    cv2.imshow("right", img2_rectified)

     lr = np.hstack((img1_rectified, img2_rectified))

     cv2.imshow("left_right", lr)

     cv2.imshow("depth", disp)

     key = cv2.waitKey(1)
     if key == ord("q"):
         break

 #    elif key == ord("s"):
 #        cv2.imwrite("./snapshot/BM_left.jpg", imgL)
 #        cv2.imwrite("./snapshot/BM_right.jpg", imgR)
 #        cv2.imwrite("./snapshot/BM_depth.jpg", disp)

 cap.release()
 cv2.destroyAllWindows()

另外，kitti的左右图像重叠率在90%以上，如果自己用双目相机拍视频，

想要尽量复现出一个较好的结果的话，应该尽量贴近kitti数据集的状态。

等玩熟了再尝试做点改变。

训练过程 不需要 具体的参数 焦距 f 和 基线长b，这就说明了最后训练出来的网络权重只

对这个相机有效，只对这个相机拍出来的图片能做深度估计。

换个相机拍的图片，深度预测效果可能就没那么好了。

2019年3月8日14:15:57

用vscode的对比功能，可以轻松的比较 tf 和 pt 版本的代码的异同

后续可以把其他较新的tensorflow的库改写成pytorch版了。

2019年3月14日16:54:45

在 pytorch 下写了一个 saver，保存了 模型权重 以及 optimizer 状态。

emmm，以后可以把耗时的训练分成好几个晚上来做了。。。都是被渣1050逼的。。。

其实最好做一个 非常小的数据集 以方便调试，做一个 train、valid 之外的很小的数据集。

2019年3月15日08:59:57

用于train的图片3225张，用于valid的图片645张，

跑了81个epoch，平均每个epoch大概 630 s，到第60个epoch的时候valid loss就不怎么往下走了，

在valid数据集上，部分图片的测试结果已经可以看了。后续还要再调整下 lr 继续训练。

公司的双目相机很劣质，数据集也很小，拍摄的场景也不理想，训练的epoch也不多，

这个结果已经可以接受了。

2019年3月16日09:27:36

又继续训练了一个晚上，epoch跑到了差不多160，train_loss从0.66掉到0.61，valid_loss

还是大概0.68左右，没怎么往下降。但是看valid_dataset的效果，比昨天略好。

对于玻璃、镜面的效果比昨天的预测结果略好，下面的结果是disparities_pp

1

2

对于大片的天空还是预测错误。

2019年4月22日10:27:31

前两天发现opencv对于我手边这个非常渣的双目相机的标定结果并不是非常精确。。。

校正完了，再拿校正完的棋盘图片算内参，结果两个相机的内参差距有减少，但并

不是一模一样的。。。准备再拿matlab校正一次做对比。

monodepth效果不太好可能是opencv和相机校正的锅。。。