标签: matrix-multiplication

是否有一种相对容易实现或透明的方法来并行地在Matlab中相乘两个大矩阵？

理想情况下,我想用最多几行代码执行此并行乘法,可能类似于:

    C_1 = A*B        % normal
    C_2 = pmult(A,B) % parallel
    % C_1 and C_2 have the same entries

如果有办法轻松做到这个并列乘法,有人可以指点我的代码吗？如果没有,有没有人对他们认为在Matlab中实现并行矩阵乘法算法的最佳方法有任何想法？

在此先感谢,令人敬畏的Stackoverflow社区.

编辑 - 我认为我遇到的部分问题是稀疏矩阵的矩阵乘法不会自动并行化; 它为密集矩阵自动并行化.新问题:Matlab可以并行进行稀疏矩阵乘法吗？(CPU并行化,因为我没有启用CUDA的显卡)

我有2个2-D NSMutableArrays,我正在尝试做一些基本的矩阵乘法.我的通用公式代码如下,但其性能异常缓慢(正如预期的那样).我已经做了很多谷歌搜索,并没有找到任何简单易懂的公式来改变性能增强的代码.任何人都可以指出我在一个简单的公式/教程/示例的正确方向,如何在目标C中使用矩阵乘法获得比0(n ^ 3)更好的性能.

+ (NSMutableArray*)multiply:(NSMutableArray*)a1 withArray:(NSMutableArray*)a2
{
    if([[a1 objectAtIndex: 0] count] != [a2 count])
    {
        NSLog(@"Multiplicaton error!");
        return NULL;
    }

    int a1_rowNum = [a1 count];
    int a2_rowNum = [a2 count];
    int a2_colNum = [[a2 objectAtIndex:0] count];
    NSMutableArray *result = [NSMutableArray arrayWithCapacity:a1_rowNum];
    for (int i = 0; i < a1_rowNum; i++) {
        NSMutableArray *tempRow = [NSMutableArray arrayWithCapacity:a2_colNum];
        for (int j = 0; j < a2_colNum; j++) {
            double tempTotal = 0;
            for (int k = 0; k < a2_rowNum; k++) …

我需要乘以矩阵及其转置,但我得到以下错误:

"OpenCV错误:断言失败(类型== B.type()&&(类型== CV_32FC1 ||类型== CV_64FC1 || type == CV_32FC2 || type == CV_64FC2))在未知函数中,文件.. .. ..\src\opencv\modules\core\src\matmul.cpp,第711行"

这是代码:

int dA[] = {
     1,     2,     3,
     4,     5,     6,
     6,     5,     4,
    }; 
Mat A = Mat(3,3, CV_32S, dA );
Mat C = A.t()* A;

我目前正在尝试编写一个程序,该程序使用一个函数,该函数将3个不同的10x10数组作为参数,并使用前2个数组的乘积填充第3个数组.

我已经在网上搜索,试图自己解决问题,但到目前为止,我只想出了这个:

(我用2个填充第一个数组,用3个填充第二个数组)

#include <iostream>

using std::cout;
using std::cin;
using std::endl;

/************************************************
** Function: populate_array1
** Description: populates the passed array with 2's
** Parameters: 10x10 array
** Pre-Conditions:
** Post-Conditions:
*************************************************/
void populate_array1(int array[10][10])
{
  int i, n;
  for (i = 0; i<10; i++)
  {
    for (n = 0; n<10; n++)
    {
      array[i][n] = 2;
    }
  }
}

/************************************************
** Function: populate_array2
** Description: populates the passed array with 3's
** Parameters: 10x10 array
** Pre-Conditions:
** Post-Conditions:
*************************************************/ …

我想找出C编程语言中amxn实矩阵的最佳表示.

矩阵表示作为单个指针的优点是什么:

double* A;

使用此表示,您可以分配内存:

A = (double* )malloc(m * n * sizeof(double));

在这种表示中,矩阵访问需要额外的乘法:

aij = A[i * m + j];

矩阵表示作为双指针的缺点是什么:

double** B;

内存分配需要一个循环:

double** B = (double **) malloc(m * sizeof(double*));
for (i = 0; i < m; i++)
    A[i] = (double *) malloc(n * sizeof(double))

在这种表示中,您可以使用直观的双索引`bij = B [i] [j],但是有一些缺点会影响性能.我想知道在性能方面什么是最好的演示.

这些矩阵应该用于数值算法,例如奇异值分解.我需要定义一个函数:

void svd(Matrix A, Matrix U, Matrix Sigma, Matrix V);

我正在寻找代表Matrix的最佳方式.如果有任何其他有效的方法来表示C中的矩阵,请告诉我.

我已经看到大多数人使用单指针表示.我想知道是否有一些性能优势而不是双数组表示？

给定一个超级基础的顶点着色器，例如：

output.position = mul(position, _gWorldViewProj);

我遇到了很多麻烦，因为我将 _gWorldViewProj 设置如下；我尝试了两者（有点晃动）以确保它不只是倒退。

mWorldViewProj = world * view * proj;
mWorldViewProj = proj * view * world;

我的解决方案原来是：

mWorldView = mWorld * mView;
mWorldViewProj = XMMatrixTranspose(worldView * proj);

有人可以解释为什么需要这个 XMMatrixTranspose 吗？我知道 XNA 和 HLSL 之间存在矩阵差异（我认为），但普通 C++ 和 HLSL 之间没有，尽管我可能是错的。

问题是我不知道是我错了还是我错了！所以如果有人能准确地告诉我为什么需要转置，我希望不会再犯同样的错误。

我想知道是什么内在函数使 SIMD 比普通矩阵乘法慢，我应该怎么做才能使用 SIMD 更快地进行大矩阵的乘法。在这里，我们有matrixA[8][8],matrixB[8][8]和 result matrixC[8][8]。因为float32_t的最大元素数是4，所以我做了2个vmul和vadd，好像还挺没有优化的。我在 ARMv7-A Cortex A8 上工作。

void matrix_mult_neon (void)
{
    int i;

    float32x4x2_t vectB1, vectB2, vectB3, vectB4, vectB5, vectB6, vectB7, vectB8;
    vectB1 = vld2q_f32(matrixB[0]);
    vectB2 = vld2q_f32(matrixB[1]);
    vectB3 = vld2q_f32(matrixB[2]);
    vectB4 = vld2q_f32(matrixB[3]);
    vectB5 = vld2q_f32(matrixB[4]);
    vectB6 = vld2q_f32(matrixB[5]);
    vectB7 = vld2q_f32(matrixB[6]);
    vectB8 = vld2q_f32(matrixB[7]);


    float32x4x2_t vectT1, vectT2, vectT3, vectT4, vectT5, vectT6, vectT7, vectT8; 
    for (i = 0; i < 8; i++)
    {
        vectT1.val[0] = vmulq_n_f32(vectB1.val[0], matrixA[i][0]);
        vectT1.val[1] = vmulq_n_f32(vectB1.val[1], …

我有一个2D矩阵M的形状[batch x dim],我有一个V形状的矢量[batch].如何将矩阵中的每个列乘以V中的相应元素？那是:

我知道一个低效的numpy实现看起来像这样:

import numpy as np
M = np.random.uniform(size=(4, 10))
V = np.random.randint(4)
def tst(M, V):
  rows = []
  for i in range(len(M)):
    col = []
    for j in range(len(M[i])):
      col.append(M[i][j] * V[i])
    rows.append(col)
  return np.array(rows)

在张量流中,给定两个张量,实现这一目标的最有效方法是什么？

import tensorflow as tf
sess = tf.InteractiveSession()
M = tf.constant(np.random.normal(size=(4,10)), dtype=tf.float32)
V = tf.constant([1,2,3,4], dtype=tf.float32)

所有，我有一个应用程序，当两个矩阵相乘时，它需要返回一个 numpy ndarray，而不是一个简单的总和；例如：

import numpy as np
x = np.array([[1, 1, 0], [0, 1, 1]])
y = np.array([[1, 0, 0, 1], [1, 0, 1, 0], [0, 0, 0, 0]])
w = x @ y
>>> array([[2, 0, 1, 1],
           [1, 0, 1, 0]])

但是，要求是返回一个 ndarray（在这种情况下..）：

array([[[1,1,0], [0,0,0], [0,1,0], [1,0,0]],
       [[0,1,0], [0,0,0], [0,1,0], [0,0,0]]])

注意，矩阵乘法操作可能会重复；输出将用作下一个矩阵乘法运算的 ndarrays 的左侧矩阵，这将在第二个矩阵乘法运算后产生一个更高阶的 ndarray，等等。

有什么方法可以实现这一目标吗？我已经研究了重载__add__，并按照此处讨论的那样对__radd__np.ndarray进行了子类化，但主要是遇到了维度不兼容错误。

想法？

更新：

解决@Divakar 的答案 例如，对于链式操作，添加

z = np.array([[1, 1, 0], [0, 0, 0], [1, 0, …

有什么区别吗？如果不是，那么约定俗成的首选是什么？性能似乎几乎相同。

a=np.random.rand(1000,1000)
b=np.random.rand(1000,1000)
%timeit a.dot(b)     #14.3 ms ± 374 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit np.dot(a,b)  #14.7 ms ± 315 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)
%timeit a @ b        #15.1 ms ± 779 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)