用2平方矩阵模拟matlab的mrdivide

时间：2015-09-22 15:08:12

标签： c++ matlab opencv linear-algebra

我有2个19x19平方矩阵（a＆amp; b），我正在尝试使用斜杠（mrdivide）运算符来执行除法

c = a / b

我正在尝试在OpenCV中实现它。我发现有些人建议使用cv::solve，但到目前为止，我一直无法找到任何能让我得到任何与matlab相近的结果。

有没有人知道如何用opencv实现mrdivide？

我尝试过以下代码：

cv::Mat mldivide(const cv::Mat& A, const cv::Mat& B ) 
{
    //return  b * A.inv();
    cv::Mat a;
    cv::Mat b;
    A.convertTo( a, CV_64FC1 );
    B.convertTo( b, CV_64FC1 );

    cv::Mat ret;
    cv::solve( a, b, ret, cv::DECOMP_NORMAL );

    cv::Mat ret2;
    ret.convertTo( ret2, A.type() );
    return ret2;
}

然后我按照以下方式实现了mrdivide：

cv::Mat mrdivide(const cv::Mat& A, const cv::Mat& B ) 
{
   return mldivide( A.t(), B.t() ).t();
}

（ 编辑 ：根据答案，当我正确使用它时，这确实给了我正确答案！）

这给了我一个错误的答案，就像matlab一样。根据评论，我也试过

cv::Mat mrdivide(const cv::Mat& A, const cv::Mat& B ) 
{
    return A * B.inv();
}

这给出了与上面相同的答案，但也是错误的。

2 个答案:

答案 0 :(得分：6)

您不应该使用inv来解决Ax=b或xA=b等式。虽然这两种方法在数学上是等价的（x=solve(A,b)和x=inv(A)*B），但在处理浮点数时却完全不同！ http://www.johndcook.com/blog/2010/01/19/dont-invert-that-matrix/

作为一般规则，永远不会乘以矩阵逆。而是使用前向/后向斜杠运算符（或等效的＆＃34;求解＆＃34;方法）用于一次性系统，或者在需要时显式执行矩阵分解（想想LU，QR，Cholesky等）使用多个A

重复使用相同的b

让我举一个具体的例子来说明反转的问题。我将使用MATLAB和mexopencv，这是一个允许我们直接从MATLAB调用OpenCV的库。

（这个例子是来自this excellent FEX submission的Tim Davis，就是SuiteSparse背后的同一个人。我展示了左分区Ax=b的情况，但同样适用于右级xA=b）。

让我们首先为Ax=b系统构建一些矩阵：

% Ax = b
N = 16;                 % square matrix dimensions
x0 = ones(N,1);         % true solution
A = gallery('frank',N); % matrix with ill-conditioned eigenvalues
b = A*x0;               % Ax=b system

这里是16x16矩阵A和16x1向量b的样子（注意真正的解x0只是1的向量） ：

A =                                                          b =
   16 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1              136
   15 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1              135
    0 14 14 13 12 11 10  9  8  7  6  5  4  3  2  1              119
    0  0 13 13 12 11 10  9  8  7  6  5  4  3  2  1              104
    0  0  0 12 12 11 10  9  8  7  6  5  4  3  2  1               90
    0  0  0  0 11 11 10  9  8  7  6  5  4  3  2  1               77
    0  0  0  0  0 10 10  9  8  7  6  5  4  3  2  1               65
    0  0  0  0  0  0  9  9  8  7  6  5  4  3  2  1               54
    0  0  0  0  0  0  0  8  8  7  6  5  4  3  2  1               44
    0  0  0  0  0  0  0  0  7  7  6  5  4  3  2  1               35
    0  0  0  0  0  0  0  0  0  6  6  5  4  3  2  1               27
    0  0  0  0  0  0  0  0  0  0  5  5  4  3  2  1               20
    0  0  0  0  0  0  0  0  0  0  0  4  4  3  2  1               14
    0  0  0  0  0  0  0  0  0  0  0  0  3  3  2  1                9
    0  0  0  0  0  0  0  0  0  0  0  0  0  2  2  1                5
    0  0  0  0  0  0  0  0  0  0  0  0  0  0  1  1                2

现在让我们通过找到解决方案并使用NORM函数计算残差（或cv::invert，如果你想要的话），将cv::solve与cv::norm进行比较：

% inverting (OpenCV)
x1 = cv.invert(A)*b;
r1 = norm(A*x1-b)

% inverting (MATLAB)
x2 = inv(A)*b;
r2 = norm(A*x2-b)

% solve using matrix factorization (OpenCV)
x3 = cv.solve(A,b);
r3 = norm(A*x3-b)

% solve using matrix factorization (MATLAB)
x4 = A\b;
r4 = norm(A*x4-b)

以下是找到的解决方案（我减去1，因此您可以看到它们距离真正的解决方案x0有多远）：

>> format short g
>> [x1 x2 x3 x4] - 1
ans =
   9.0258e-06   3.1086e-15  -1.1102e-16   2.2204e-16
   -0.0011101  -1.0181e-13  -2.2204e-15  -2.3315e-15
   -0.0016212  -2.5123e-12   3.3751e-14   3.3307e-14
    0.0037279   4.1745e-11  -4.3476e-13  -4.3487e-13
   -0.0022119   4.6216e-10   5.2165e-12    5.216e-12
   -0.0010476   1.3224e-09  -5.7384e-11  -5.7384e-11
    0.0035461   2.2614e-08   5.7384e-10   5.7384e-10
   -0.0040074  -4.1533e-07  -5.1646e-09  -5.1645e-09
    0.0036477   -4.772e-06   4.1316e-08   4.1316e-08
   -0.0033358   4.7499e-06  -2.8922e-07  -2.8921e-07
    0.0059112  -0.00010352   1.7353e-06   1.7353e-06
   -0.0043586   0.00044539  -8.6765e-06  -8.6764e-06
    0.0069238   -0.0024718   3.4706e-05   3.4706e-05
   -0.0019642   -0.0079952  -0.00010412  -0.00010412
    0.0039284      0.01599   0.00020824   0.00020823
   -0.0039284     -0.01599  -0.00020824  -0.00020823

最重要的是，以下是每种方法的错误：

r1 =
       0.1064
r2 =
     0.060614
r3 =
   1.4321e-14
r4 =
   1.7764e-15

最后两个是更准确的数量级，甚至没有接近！这只是一个包含16个变量的系统。反转在数值上不太可靠，特别是当矩阵很大且稀疏时......

现在回答你的问题，你有正确的想法使用cv::solve，但在右分割的情况下，你刚刚得到操作数的顺序。

在MATLAB中，运算符/和\（或mrdivide和mldivide）通过等式B/A = (A'\B')'相互关联（这是一个transpose properties）的简单结果。

所以使用OpenCV函数，你会写（注意A和b的顺序）：

% Ax = b
x = cv.solve(A, b);     % A\b or mldivide(A,b)

% xA = b
x = cv.solve(A', b')';  % b/A or mrdivide(b,A)

OpenCV公开的API在这里有点尴尬，所以我们不得不做所有这些转置。事实上，如果你引用equivalent LAPACK例程（想象DGESV或DGESVX），它们实际上允许你指定矩阵是否转置TRANS=T TRANS=N （在那个级别，转置实际上只是一个不同的内存布局，C或Fortran排序）。例如，MATLAB提供linsolve函数，允许您在选项中指定这些类型的东西......

（BTW在C ++ OpenCV中编码时，我更倾向于使用像cv::transpose这样的操作的函数形式，而不是像Mat::t这样的矩阵表达式变体。前者可以在适当的时候运行后者会创建不必要的临时副本。）

现在，如果您正在寻找C ++中的良好性能线性代数实现，请考虑使用Eigen（甚至integrate nicely with OpenCV）。此外，它是一个纯模板库，因此无需担心链接或二进制文件，只需包含头文件。

编辑（回应评论）

@Goz：

  

查找返回值优化。   ＆＃34;不必要的临时副本＆＃34;不存在

我了解RVO和move semantics，但这里并不重要;无论如何，cv::Mat类是copy-friendly，有点像引用计数的智能指针。这意味着它只在传递by-value时执行带有数据共享的浅拷贝。为新副本创建的唯一部分是mat标题中的部分，这些部分在大小方面无关紧要（存储诸如维度/通道数，步长和数据类型等内容）。

我说的是一个明确的深层拷贝，而不是你从函数调用返回时想到的那个......

感谢您的评论，让我有动力实际挖掘OpenCV来源，这不是最容易阅读的内容......代码几乎没有评论，有时很难跟进。看到OpenCV真正关心性能，复杂性是可以理解的，并且实际上令人印象深刻的是，许多功能以各种方式实现（常规CPU实现，循环展开版本，SIMD矢量化版本（SSE，AVX，NEON等） ，使用各种后端的并行和线程版本，英特尔IPP的优化实现，带OpenCL或CUDA的GPU加速版本，Tegra，OpenVX等的移动加速版本。）

让我们采取以下案例并追踪我们的步骤：

Mat A = ..., b = ..., x;
cv::solve(A.t(), b, x);

其中函数定义如下：

bool cv::solve(InputArray _src, InputArray _src2arg, OutputArray _dst, int method)
{
    Mat src = _src.getMat(), _src2 = _src2arg.getMat();
    _dst.create( src.cols, _src2.cols, src.type() );
    Mat dst = _dst.getMat();
    ...
}

现在我们必须弄清楚两者之间的步骤。我们首先要做的是t成员方法：

MatExpr Mat::t() const
{
    MatExpr e;
    MatOp_T::makeExpr(e, *this);
    return e;
}

这会返回MatExpr，这是一个允许对matrix expressions进行延迟评估的类。换句话说，它不会立即执行转置，而是存储对原始矩阵的引用以及最终对其执行的操作（转置），但是它将继续进行评估，直到绝对必要为止（例如分配或转换为cv::Mat时。

接下来让我们看看相关部分的定义。请注意，在实际代码中，这些内容分为多个文件。我只是在这里拼凑了有趣的部分以便于阅读，但它远非完整的东西：

class MatExpr
{
public:
    MatExpr()
    : op(0), flags(0), a(Mat()), b(Mat()), c(Mat()), alpha(0), beta(0), s()
    {}
    explicit MatExpr(const Mat& m)
    : op(&g_MatOp_Identity), flags(0), a(m), b(Mat()), c(Mat()),
      alpha(1), beta(0), s(Scalar())
    {}
    MatExpr(const MatOp* _op, int _flags, const Mat& _a = Mat(),
            const Mat& _b = Mat(), const Mat& _c = Mat(),
            double _alpha = 1, double _beta = 1, const Scalar& _s = Scalar())
    : op(_op), flags(_flags), a(_a), b(_b), c(_c), alpha(_alpha), beta(_beta), s(_s)
    {}
    MatExpr t() const
    {
        MatExpr e;
        op->transpose(*this, e);
        return e;
    }
    MatExpr inv(int method) const
    {
        MatExpr e;
        op->invert(*this, method, e);
        return e;
    }
    operator Mat() const
    {
        Mat m;
        op->assign(*this, m);
        return m;
    }
public:
    const MatOp* op;
    int flags;
    Mat a, b, c;
    double alpha, beta;
    Scalar s;
}

Mat& Mat::operator = (const MatExpr& e)
{
    e.op->assign(e, *this);
    return *this;
}
MatExpr operator * (const MatExpr& e1, const MatExpr& e2)
{
    MatExpr en;
    e1.op->matmul(e1, e2, en);
    return en;
}

到目前为止，这很简单。该类应该将输入矩阵存储在a中（再次cv::Mat个实例将共享数据，因此不会复制），以及执行op的操作，以及其他一些事情对我们很重要。

这里是矩阵操作类MatOp，其中一些是子类（我只显示转置和逆操作，但还有更多）：

class MatOp
{
public:
    MatOp();
    virtual ~MatOp();
    virtual void assign(const MatExpr& expr, Mat& m, int type=-1) const = 0;
    virtual void transpose(const MatExpr& expr, MatExpr& res) const
    {
        Mat m;
        expr.op->assign(expr, m);
        MatOp_T::makeExpr(res, m, 1);
    }
    virtual void invert(const MatExpr& expr, int method, MatExpr& res) const
    {
        Mat m;
        expr.op->assign(expr, m);
        MatOp_Invert::makeExpr(res, method, m);
    }
}

class MatOp_T : public MatOp
{
public:
    MatOp_T() {}
    virtual ~MatOp_T() {}
    void assign(const MatExpr& expr, Mat& m, int type=-1) const
    {
        Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
        cv::transpose(e.a, dst);
        if( dst.data != m.data || e.alpha != 1 ) dst.convertTo(m, _type, e.alpha);
    }
    void transpose(const MatExpr& e, MatExpr& res) const
    {
        if( e.alpha == 1 )
            MatOp_Identity::makeExpr(res, e.a);
        else
            MatOp_AddEx::makeExpr(res, e.a, Mat(), e.alpha, 0);
    }
    static void makeExpr(MatExpr& res, const Mat& a, double alpha=1)
    {
        res = MatExpr(&g_MatOp_T, 0, a, Mat(), Mat(), alpha, 0);
    }
};

class MatOp_Invert : public MatOp
{
public:
    MatOp_Invert() {}
    virtual ~MatOp_Invert() {}
    void assign(const MatExpr& e, Mat& m, int _type=-1) const
    {
        Mat temp, &dst = _type == -1 || _type == e.a.type() ? m : temp;
        cv::invert(e.a, dst, e.flags);
        if( dst.data != m.data ) dst.convertTo(m, _type);
    }
    void matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const
    {
        if( isInv(e1) && isIdentity(e2) )
            MatOp_Solve::makeExpr(res, e1.flags, e1.a, e2.a);
        else if( this == e2.op )
            MatOp::matmul(e1, e2, res);
        else
            e2.op->matmul(e1, e2, res);
    }
    static void makeExpr(MatExpr& res, int method, const Mat& m)
    {
        res = MatExpr(&g_MatOp_Invert, method, m, Mat(), Mat(), 1, 0);
    }
};

static MatOp_Identity g_MatOp_Identity;
static MatOp_T g_MatOp_T;
static MatOp_Invert g_MatOp_Invert;

OpenCV大量使用运算符重载，因此A+B，A-B，A*B等各种操作实际上映射到相应的矩阵表达式操作。

拼图的最后一部分是代理类InputArray。它基本上存储了一个void*指针以及有关所传递事物的信息（它是什么类型：Mat，MatExpr，Matx，vector<T>，{{1这样，它知道如何在UMat之类的请求时将指针强制转换回来：

InputArray::getMat

现在我们看到typedef const _InputArray& InputArray; class _InputArray { public: _InputArray(const MatExpr& expr) { init(FIXED_TYPE + FIXED_SIZE + EXPR + ACCESS_READ, &expr); } void init(int _flags, const void* _obj) { flags = _flags; obj = (void*)_obj; } Mat getMat_(int i) const { int k = kind(); int accessFlags = flags & ACCESS_MASK; ... if( k == EXPR ) { CV_Assert( i < 0 ); return (Mat)*((const MatExpr*)obj); } ... return Mat(); } protected: int flags; void* obj; Size sz; } 如何创建并返回Mat::t实例。然后，MatExpr将其作为cv::solve收到。现在，当它调用InputArray来检索矩阵时，它会有效地将存储的InputArray::getMat转换为调用强制转换运算符的MatExpr：

Mat

因此它声明了一个新矩阵 MatExpr::operator Mat() const { Mat m; op->assign(*this, m); return m; } ，使用新矩阵作为目标调用m。反过来，这迫使它通过最终调用MatOp_T::assign进行评估。它将转置结果计算为此新矩阵作为目标。

因此，我们最终获得了两份副本，原始cv::transpose和转置的A已返回。

现在说了一遍，比较一下：

A.t()

在这种情况下，Mat A = ..., b = ..., x; cv::transpose(A, A); cv::solve(A, b, x); 转换就地，并且抽象级别较低。

现在我展示所有这一切的原因并不是争论这一个额外的副本，毕竟它并不是那么大的交易:) 我发现的非常巧妙的事情是，以下两个表达式没有做同样的事情并给出不同的结果（我不是在谈论逆是否就地）：

A

事实证明，第二个实际上足够聪明，可以调用Mat A = ..., b = ..., x; cv::invert(A,A); x = A*b; Mat A = ..., b = ..., x; x = inv(A)*b; ！如果你回到cv::solve(A,b)（当一个懒的反转后来用另一个懒的矩阵乘法链接时调用它。）

MatOp_Invert::matmul

它检查表达式void MatOp_Invert::matmul(const MatExpr& e1, const MatExpr& e2, MatExpr& res) const { if( isInv(e1) && isIdentity(e2) ) MatOp_Solve::makeExpr(res, e1.flags, e1.a, e2.a); ... } 中的第一个操作数是否为反转操作，第二个操作数是标识操作（即普通矩阵，不是另一个复杂表达式的结果）。在这种情况下，它将存储的操作更改为延迟求解操作inv(A)*B（类似地是MatOp_Solve函数的包装器）。 IMO非常聪明！即使你写了cv::solve，它也不会实际计算逆，而是它理解通过使用矩阵分解来求解系统更好。

不幸的是，对于你来说，这只会使inv(A)*b形式的表达式受益，而不是inv(A)*b形式的表达式（那将最终计算出不是我们想要的反转）。因此，在您解决b*inv(A)的情况下，您应该坚持明确调用xA=b ...

当然这仅适用于使用C ++进行编码时（由于运算符重载和惰性表达式的魔力）。如果你使用一些包装器（如Python，Java，MATLAB）从另一种语言中使用OpenCV，你可能没有得到任何这些，并且应该明确地使用cv::solve，就像我在以前的MATLAB代码，适用于cv::solve和Ax=b两种情况。

希望这会有所帮助，并为长篇文章感到抱歉;）

答案 1 :(得分：2)

在MATLAB中，在兼容维度的两个矩阵上使用mrdivide，a / b等同于a * b^{-1}，其中b^{-1}是b的倒数。因此，您可以做的可能是首先反转矩阵b，然后预先乘以a。

一种方法是在矩阵b上使用cv::invert，然后与a预乘。这可以通过以下函数定义完成（从上面的帖子中借用代码）：

cv::Mat mrdivide(const cv::Mat& A, const cv::Mat& B) 
{
    cv::Mat bInvert;
    cv::invert(B, bInvert);
    return A * bInvert;
}

另一种方法是使用cv::Mat接口内置的inv()方法，只需使用它并将矩阵自身相乘：

cv::Mat mrdivide(const cv::Mat& A, const cv::Mat& B) 
{
    return A * B.inv();
}

我不确定哪一个更快，所以你可能需要做一些测试，但这两种方法中的任何一种都应该有效。但是，为了在可能的时序方面提供一些见解，有三种方法可以在OpenCV中反转矩阵。您只需将第三个参数覆盖为cv::invert，或在cv::Mat.inv()中指定方法即可。

此StackOverflow帖子使用以下三种方法完成将矩阵反转为相对较大矩阵大小的时序：Fastest method in inverse of matrix

相关问题
最新问题