RANSAC算法詳解

我的數學之美（一）——RANSAC算法詳解

給定兩個點p1與p2的座標，確定這兩點所構成的直線，要求對於輸入的任意點p3，都可以判斷它是否在該直線上。初中解析幾何知識告訴我們，判斷一個點在直線上，只需其與直線上任意兩點點斜率都相同即可。實際操作當中，往往會先根據已知的兩點算出直線的表達式（點斜式、截距式等等），然後通過向量計算即可方便地判斷p3是否在該直線上。

生產實踐中的數據往往會有一定的偏差。例如我們知道兩個變量X與Y之間呈線性關係，Y=aX+b，我們想確定參數a與b的具體值。通過實驗，可以得到一組X與Y的測試值。雖然理論上兩個未知數的方程只需要兩組值即可確認，但由於系統誤差的原因，任意取兩點算出的a與b的值都不盡相同。我們希望的是，最後計算得出的理論模型與測試值的誤差最小。大學的高等數學課程中，詳細闡述了最小二乘法的思想。通過計算最小均方差關於參數a、b的偏導數爲零時的值。事實上，在很多情況下，最小二乘法都是線性迴歸的代名詞。

遺憾的是，最小二乘法只適合與誤差較小的情況。試想一下這種情況，假使需要從一個噪音較大的數據集中提取模型（比方說只有20%的數據時符合模型的）時，最小二乘法就顯得力不從心了。例如下圖，肉眼可以很輕易地看出一條直線（模式），但算法卻找錯了。



RANSAC算法的輸入是一組觀測數據（往往含有較大的噪聲或無效點），一個用於解釋觀測數據的參數化模型以及一些可信的參數。RANSAC通過反覆選擇數據中的一組隨機子集來達成目標。被選取的子集被假設爲局內點，並用下述方法進行驗證：

• 有一個模型適應於假設的局內點，即所有的未知參數都能從假設的局內點計算得出。
• 用1中得到的模型去測試所有的其它數據，如果某個點適用於估計的模型，認爲它也是局內點。
• 如果有足夠多的點被歸類爲假設的局內點，那麼估計的模型就足夠合理。
• 然後，用所有假設的局內點去重新估計模型（譬如使用最小二乘法），因爲它僅僅被初始的假設局內點估計過。
• 最後，通過估計局內點與模型的錯誤率來評估模型。
• 上述過程被重複執行固定的次數，每次產生的模型要麼因爲局內點太少而被捨棄，要麼因爲比現有的模型更好而被選用。

參考另一個博客的流程說明：

整個過程可參考下圖：


關於算法的源代碼，Ziv Yaniv曾經寫一個不錯的C++版本，我在關鍵處增補了註釋：

#include <math.h>  
#include "LineParamEstimator.h"  
  
LineParamEstimator::LineParamEstimator(double delta) : m_deltaSquared(delta*delta) {}  
/*****************************************************************************/  
/* 
 * Compute the line parameters  [n_x,n_y,a_x,a_y] 
 * 通過輸入的兩點來確定所在直線，採用法線向量的方式來表示，以兼容平行或垂直的情況 
 * 其中n_x,n_y爲歸一化後，與原點構成的法線向量，a_x,a_y爲直線上任意一點 
 */  
void LineParamEstimator::estimate(std::vector<Point2D *> &data,   
                                                                    std::vector<double> &parameters)  
{  
    parameters.clear();  
    if(data.size()<2)  
        return;  
    double nx = data[1]->y - data[0]->y;  
    double ny = data[0]->x - data[1]->x;// 原始直線的斜率爲K，則法線的斜率爲-1/k  
    double norm = sqrt(nx*nx + ny*ny);  
      
    parameters.push_back(nx/norm);  
    parameters.push_back(ny/norm);  
    parameters.push_back(data[0]->x);  
    parameters.push_back(data[0]->y);          
}  
/*****************************************************************************/  
/* 
 * Compute the line parameters  [n_x,n_y,a_x,a_y] 
 * 使用最小二乘法，從輸入點中擬合出確定直線模型的所需參量 
 */  
void LineParamEstimator::leastSquaresEstimate(std::vector<Point2D *> &data,   
                                                                                            std::vector<double> &parameters)  
{  
    double meanX, meanY, nx, ny, norm;  
    double covMat11, covMat12, covMat21, covMat22; // The entries of the symmetric covarinace matrix  
    int i, dataSize = data.size();  
  
    parameters.clear();  
    if(data.size()<2)  
        return;  
  
    meanX = meanY = 0.0;  
    covMat11 = covMat12 = covMat21 = covMat22 = 0;  
    for(i=0; i<dataSize; i++) {  
        meanX +=data[i]->x;  
        meanY +=data[i]->y;  
  
        covMat11    +=data[i]->x * data[i]->x;  
        covMat12    +=data[i]->x * data[i]->y;  
        covMat22    +=data[i]->y * data[i]->y;  
    }  
  
    meanX/=dataSize;  
    meanY/=dataSize;  
  
    covMat11 -= dataSize*meanX*meanX;  
        covMat12 -= dataSize*meanX*meanY;  
    covMat22 -= dataSize*meanY*meanY;  
    covMat21 = covMat12;  
  
    if(covMat11<1e-12) {  
        nx = 1.0;  
            ny = 0.0;  
    }  
    else {      //lamda1 is the largest eigen-value of the covariance matrix   
               //and is used to compute the eigne-vector corresponding to the smallest  
               //eigenvalue, which isn't computed explicitly.  
        double lamda1 = (covMat11 + covMat22 + sqrt((covMat11-covMat22)*(covMat11-covMat22) + 4*covMat12*covMat12)) / 2.0;  
        nx = -covMat12;  
        ny = lamda1 - covMat22;  
        norm = sqrt(nx*nx + ny*ny);  
        nx/=norm;  
        ny/=norm;  
    }  
    parameters.push_back(nx);  
    parameters.push_back(ny);  
    parameters.push_back(meanX);  
    parameters.push_back(meanY);  
}  
/*****************************************************************************/  
/* 
 * Given the line parameters  [n_x,n_y,a_x,a_y] check if 
 * [n_x, n_y] dot [data.x-a_x, data.y-a_y] < m_delta 
 * 通過與已知法線的點乘結果，確定待測點與已知直線的匹配程度；結果越小則越符合，爲 
 * 零則表明點在直線上 
 */  
bool LineParamEstimator::agree(std::vector<double> &parameters, Point2D &data)  
{  
    double signedDistance = parameters[0]*(data.x-parameters[2]) + parameters[1]*(data.y-parameters[3]);   
    return ((signedDistance*signedDistance) < m_deltaSquared);  
}  

RANSAC尋找匹配的代碼如下：

/*****************************************************************************/  
template<class T, class S>  
double Ransac<T,S>::compute(std::vector<S> &parameters,   
                                                      ParameterEsitmator<T,S> *paramEstimator ,   
                                                    std::vector<T> &data,   
                                                    int numForEstimate)  
{  
    std::vector<T *> leastSquaresEstimateData;  
    int numDataObjects = data.size();  
    int numVotesForBest = -1;  
    int *arr = new int[numForEstimate];// numForEstimate表示擬合模型所需要的最少點數，對本例的直線來說，該值爲2  
    short *curVotes = new short[numDataObjects];  //one if data[i] agrees with the current model, otherwise zero  
    short *bestVotes = new short[numDataObjects];  //one if data[i] agrees with the best model, otherwise zero  
      
  
              //there are less data objects than the minimum required for an exact fit  
    if(numDataObjects < numForEstimate)   
        return 0;  
        // 計算所有可能的直線，尋找其中誤差最小的解。對於100點的直線擬合來說，大約需要100*99*0.5=4950次運算，複雜度無疑是龐大的。一般採用隨機選取子集的方式。  
    computeAllChoices(paramEstimator,data,numForEstimate,  
                                        bestVotes, curVotes, numVotesForBest, 0, data.size(), numForEstimate, 0, arr);  
  
       //compute the least squares estimate using the largest sub set  
    for(int j=0; j<numDataObjects; j++) {  
        if(bestVotes[j])  
            leastSquaresEstimateData.push_back(&(data[j]));  
    }  
        // 對局內點再次用最小二乘法擬合出模型  
    paramEstimator->leastSquaresEstimate(leastSquaresEstimateData,parameters);  
  
    delete [] arr;  
    delete [] bestVotes;  
    delete [] curVotes;   
  
    return (double)leastSquaresEstimateData.size()/(double)numDataObjects;  
}  

在模型確定以及最大迭代次數允許的情況下，RANSAC總是能找到最優解。經過我的實驗，對於包含80%誤差的數據集，RANSAC的效果遠優於直接的最小二乘法。

深度解析RANSAC算法（精華修正版）

RANSAC與最小二乘區別：最小二乘法儘量去適應包括局外點在內的所有點。相反，RANSAC能得出一個僅僅用局內點計算出模型，並且概率還足夠高。但是，RANSAC並不能保證結果一定正確，爲了保證算法有足夠高的合理概率，必須小心的選擇算法的參數（參數配置）。經實驗驗證，對於包含80%誤差的數據集，RANSAC的效果遠優於直接的最小二乘法。

驗證思路：RANSAC算法的輸入是一組觀測數據，一個可以解釋或者適應於觀測數據的參數化模型，一些可信的參數。
RANSAC通過反覆選擇數據中的一組隨機子集來達成目標。被選取的子集被假設爲局內點，並用下述方法進行驗證：
1.有一個模型適應於假設的局內點，即所有的未知參數都能從假設的局內點計算得出。
2.用1中得到的模型去測試所有的其它數據，如果某個點適用於估計的模型，認爲它也是局內點。
3.如果有足夠多的點被歸類爲假設的局內點，那麼估計的模型就足夠合理。
4.然後，用所有假設的局內點去重新估計模型，因爲它僅僅被初始的假設局內點估計過。
5.最後，通過估計局內點與模型的錯誤率來評估模型。
這個過程被重複執行固定的次數，每次產生的模型要麼因爲局內點太少而被捨棄，要麼因爲比現有的模型更好而被選用。

參數選擇：
根據特定的問題和數據集通過實驗來確定參數 t 和 d。然而參數 k（迭代次數）可以從理論結果推斷。當估計模型參數時，用 p表示一些迭代過程中從數據集內隨機選取出的點均爲局內點的概率；此時，結果模型很可能有用，因此 p也表徵了算法產生有用結果的概率。用 w表示每次從數據集中選取一個局內點的概率，如下式所示：
w = 局內點的數目 / 數據集的數目
通常情況下，我們事先並不知道w的值，但是可以給出一些魯棒的值。假設估計模型需要選定n個點，w^n是所有n個點均爲局內點的概率；1 − w^n是n個點中至少有一個點爲局外點的概率，此時表明我們從數據集中估計出了一個不好的模型。 (1 − wn)k表示算法永遠都不會選擇到n個點均爲局內點的概率，它和1-p相同。因此，
1 − p = (1 − w^n)^k
我們對上式的兩邊取對數，得出

值得注意的是，這個結果假設n個點都是獨立選擇的；也就是說，某個點被選定之後，它可能會被後續的迭代過程重複選定到。這種方法通常都不合理，由此推導出的k值被看作是選取不重複點的上限。例如，要從數據集尋找適合的直線，RANSAC算法通常在每次迭代時選取2個點，計算通過這兩點的直線maybe_model，要求這兩點必須唯一。
爲了得到更可信的參數，標準偏差或它的乘積可以被加到k上。k的標準偏差定義爲：

注：請注意上面紫色字體的內容！

優點與缺點——
RANSAC的優點是它能魯棒的估計模型參數。例如，它能從包含大量局外點的數據集中估計出高精度的參數。RANSAC的缺點是它計算參數的迭代次數沒有上限；如果設置迭代次數的上限，得到的結果可能不是最優的結果，甚至可能得到錯誤的結果。RANSAC只有一定的概率得到可信的模型，概率與迭代次數成正比。RANSAC的另一個缺點是它要求設置跟問題相關的閥值。
RANSAC只能從特定的數據集中估計出一個模型，如果存在兩個（或多個）模型，RANSAC不能找到別的模型。

---

2. RANSAC算法示例（線性迴歸）

下面結合一份線性迴歸的代碼來看：

擬合二維平面中的帶噪音直線，其中有不超過10%的樣本點遠離了直線，另外90%的樣本點可能有高斯噪聲的偏移

要求輸出爲

ax+by+c＝0的形式
其中a > 0 且 a^2 + b^2 = 1
輸入描述:

第一個數n表示有多少個樣本點 之後n*2個數 每次是每個點的x 和y

輸出描述:

輸出a,b,c三個數，至多可以到6位有效數字

示例1

輸入

5
3 4
6 8
9 12
15 20
10 -10

輸出

-0.800000 0.600000 0.000000

說明

本題共有10個測試點，每個點會根據選手輸出的參數計算非噪音數據點的擬合誤差E，並根據E來對每個數據點進行評分0-10分
輸入數據的範圍在-10000

#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <limits>
#include <tuple>
#include <vector>
   
using real = float;
using namespace std;
   
class Point2D {
public:
    real x, y;
       
public:
    Point2D(real x_ = 0, real y_ = 0) :
        x(x_), y(y_) {}
       
    bool operator == (const Point2D& p) {
        return fabs(x - p.x) < 1e-3 && fabs(y - p.y) < 1e-3;
    }
};
   
class Solution {
public:
    vector<real> ransaclr(vector<Point2D>& pts, real outlier_prob = 0.1, real accept_prob = 1e-3, real threshold = 10.0) {
        int n = pts.size();
        real sample_fail_prob = 1 - (1 - outlier_prob) * (1 - outlier_prob);
        int K = log(accept_prob) / log(sample_fail_prob);
           
        real a_res, b_res, c_res;
        real min_error = numeric_limits<real>::max();
           
        //cout << "K = " << K << endl;
        for (int k = 0; k < K; ++k) {
            Point2D p1, p2;
            while (p1 == p2) {
                p1 = pts[rand() % n];    // n maybe greater than 65535
                p2 = pts[rand() % n];
            }
               
            //cout << "p1 = " << p1.x << " " << p1.y << endl;
            //cout << "p2 = " << p2.x << " " << p2.y << endl;
               
            real a, b, c;
            a = p1.y - p2.y;
            b = p2.x - p1.x;
            c = p1.x * p2.y - p1.y * p2.x;
            real t = sqrt(a * a + b * b);
            a /= t;
            b /= t;
            c /= t;
               
            //cout << a << " " << b << " " << c << endl;
               
            real error = 0.0;
            int inliers = 0;
            for (int i = 0; i < n; ++i) {
                real dis = fabs(a * pts[i].x + b * pts[i].y + c);
                if (dis < threshold) {
                    ++inliers;
                    error += dis;
                }
            }
               
            //cout << "inliers = " << inliers << endl;
            //cout << "error = " << error << endl;
               
            if (static_cast<real>(inliers) / static_cast<real>(n) > 0.7) {
                if (error < min_error) {
                    min_error = error;
                    a_res = a;
                    b_res = b;
                    c_res = c;
                }
            }
        }
           
        return vector<real>{ a_res, b_res, c_res };
    }
};
   
int main() {
    int n;
    cin >> n;
    vector<Point2D> pts(n);
    for (int i = 0; i < n; ++i)
        cin >> pts[i].x >> pts[i].y;
       
    srand((unsigned)time(nullptr));
    auto params = Solution().ransaclr(pts, 0.1, 1e-4, 10.0);
    cout << params[0] << " " << params[1] << " " << params[2] << endl;
       
    return 0;
}

3. 反思與總結

上述代碼是商湯科技2018年的筆試題，答案來自牛客網上的標準答案，但是！！！

1------------------

用 w表示每次從數據集中選取一個局內點的概率，如下式所示：w = 局內點的數目 / 數據集的數目
通常情況下，我們事先並不知道w的值，但是可以給出一些魯棒的值。假設估計模型需要選定n個點，w^n是所有n個點均爲局內點的概率；1 − wn是n個點中至少有一個點爲局外點的概率，此時表明我們從數據集中估計出了一個不好的模型。 (1 − wn)k表示算法永遠都不會選擇到n個點均爲局內點的概率，它和1-p相同。 1 − p = (1 − w^n)^k

這道題中，用來計算參數模型的點爲兩個，n = 2，點是內點的概率爲0.9，兩個點都爲內點的概率爲0.9*0.9， 兩個點中至少有一個爲外點的概率爲 1 - w^n = 1 - 0.9*0.9 ，這是k的計算表達中的分母。p爲算法K次迭代後接受的概率，1 - p就是不接受的概率（k次迭代中每次隨機選擇都有外點），這是分子，此處可以看出代碼中的函數名有誤。

或一種說法： 其中，p爲置信度，一般取0.995；w爲"內點"的比例 ; n爲計算模型所需要的最少樣本數。

2---------------------

如果你真的結合RANSAC思想和代碼來比對，會發現有BUG。 請注意第一部分中的那兩句紫色的話

RANSAC通過反覆選擇數據中的一組隨機子集來達成目標。被選取的子集被假設爲局內點，並用下述方法進行驗證：
1.有一個模型適應於假設的局內點，即所有的未知參數都能從假設的局內點計算得出。
2.用1中得到的模型去測試所有的其它數據，如果某個點適用於估計的模型，認爲它也是局內點。
3.如果有足夠多的點被歸類爲假設的局內點，那麼估計的模型就足夠合理。
4.然後，用所有假設的局內點去重新估計模型，因爲它僅僅被初始的假設局內點估計過。
5.最後，通過估計局內點與模型的錯誤率來評估模型。

代碼中首先判斷

static_cast<real>(inliers) / static_cast<real>(n) > 0.7

也就是說內點足夠多，比例大於0.7，說明模型合理。

然後我們需要用所有的內點重新估計模型，比如說我們可以用最小二乘法，根據這些內點線性擬合更新abc參數的值。 接下來評估模型好壞。

然而，我們在衡量模型的好壞（評估模型）的時候，不是用內點數量（有時候情況會用內點數量來衡量）來看，也不是用所有點來評估模型，而是用此時所有的內點來評估。也就是說，這道題中min_error應該使用所有的內點來計算，而不是代碼中所有的點。

RANSAC可以用於哪些場景呢？

最著名的莫過於圖片的拼接技術。優於鏡頭的限制，往往需要多張照片才能拍下那種巨幅的風景。在多幅圖像合成時，事先會在待合成的圖片中提取一些關鍵的特徵點。計算機視覺的研究表明，不同視角下物體往往可以
通過一個透視矩（3X3或2X2）陣的變換而得到。RANSAC被用於擬合這個模型的參數（矩陣各行列的值），由此便可識別出不同照片中的同一物體。可參考下圖：







另外，RANSAC還可以用於圖像搜索時的糾錯與物體識別定位。下圖中，有幾條直線是SIFT匹配算法的誤判，RANSAC有效地將其識別，並將正確的模型（書本）用線框標註出來：