标签: matrix-multiplication

我正在使用 SVG 过滤器在一些复杂的路径上创建模糊的“投影”类型效果。

<defs>
    <filter id="dropshadow" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
        <feColorMatrix result="hueOut" in="SourceAlpha" type="hueRotate" values="340"/>
        <feColorMatrix result="satOut" in="hueOut" type="saturate" values="3"/>
        <feGaussianBlur in="satOut" stdDeviation="8"/> 
        <feMerge> 
           <feMergeNode/>
           <feMergeNode in="SourceGraphic"/> 
        </feMerge>
    </filter>
</defs>

我feColorMatrix纯粹是通过反复试验得出上述值。（如果我单独使用矩阵数学，我永远不会想出从暗到亮的特别美丽的色调转变。）基本上，我将色轮旋转 340 度，然后使色轮饱和颜色使用值 3，就在模糊它之前。（规范过去对此有些不清楚，但反复试验表明，大于 1 的值type="saturate"会使图像饱和，而小于 1 的值会使图像去饱和。）

问题是：我在大量路径上进行迭代，而双矩阵运算使我的机器慢下来。它经常崩溃。

某些矩阵数学大师能否帮我算出数字，以便将上面的两个 feColorMatrix 过滤器组合成一个更高效feColorMatrix的 type="matrix" 过滤器基元？我明白了规范的要点，但我在数学方面不知所措。

我有2个不同的程序.

首先使用opencl进行矩阵 - 矩阵乘法.在我的GPU上它会产生更好的结果,然后在主机CPU上(例如0.2秒对18秒).

第二个使用opencl进行矩阵向量乘法,它在GPU上工作稍慢,然后在主机CPU上工作.

原因是什么？

这是内核

__kernel void matrixVectorMul(__global float* resultVector,
    __global float* matrixA,
    __global float* vectorB, 
    int width_A)
{
    int tx = get_global_id(0); 

    float value = 0;
    for (unsigned int k = 0; k < width_A; ++k) {
        value += matrixA[tx * width_A + k] * vectorB[k];
    }

    resultVector[tx] = value;
}

和主机代码

#include <stdlib.h>
#define __CL_ENABLE_EXCEPTIONS
#include "cl.hpp"
#include <fstream>
#include <iostream>
#include <time.h>
#include <cmath>

#define LOCAL_SIZE 512
#define WIDTH_A (4096*2)
#define HEIGHT_A (4096*2)

float *matrix_A; …

我编写了一个 MPI 例程来并行化矩阵向量乘法。速度的提升已经令人失望到不存在。我在网上找到了很多例程，我处理这个的方式与大多数例程相同。我没能找到很多关于真实机器上真实加速的数据。我正在处理我认为是一个中等规模的问题——一个大小从 100x100 到 1000x1000 的矩阵和从 2 到 64 个处理器的数量。我正在以大致方形的棋盘方式分解矩阵。任何人都可以指出我在这个问题大小和处理器数量范围内可以实际希望获得什么样的加速的任何数据？谢谢。

我觉得R中的矩阵运算非常令人困惑：我们正在混合行向量和列向量。

• 在这里，我们定义x1为向量（我假设R默认向量是列向量吗？但它没有显示它是以这种方式排列的。）

• 然后我们定义x2的转置x1，这对我来说也很奇怪。

• 最后，如果我们定义x3为矩阵，则显示效果会更好。

现在，我的问题是，x1和x2是完全不同的东西（一个是另一个转），但我们这里有同样的结果。

有什么解释吗？可能我不应该将向量和矩阵运算混合在一起吗？

x1 = c(1:3)
x2 = t(x1)
x3 = matrix(c(1:3), ncol = 1)

x1
[1] 1 2 3

x2
     [,1] [,2] [,3]
[1,]    1    2    3

x3
     [,1]
[1,]    1
[2,]    2
[3,]    3

x3 %*% x1
     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    2    4    6
[3,]    3    6    9

x3 %*% x2
     [,1] [,2] [,3]
[1,]    1    2    3
[2,] …

我有两个数组 A (4000,4000)，其中只有对角线填充数据，而 B (4000,5) 填充数据。有没有办法乘（点）这些数组比 numpy.dot(a,b) 函数更快？

到目前为止，我发现它(A * B.T).T应该更快（其中 A 是一维（4000），充满对角线元素），但结果大约慢了两倍。

在 A 是对角数组的情况下，是否有更快的方法来计算 B.dot(A) ？

我一直在使用GPU一段时间没有质疑但现在我很好奇.

为什么GPU能比CPU更快地进行矩阵乘法？是因为并行处理吗？但我没有写任何并行处理代码.它是自动完成的吗？

任何直觉/高级解释将不胜感激!谢谢.

我正在通过Go中的goroutines优化矩阵乘法.

我的基准测试显示,每行或每个元素引入并发性会大大降低性能:

goos: darwin
goarch: amd64
BenchmarkMatrixDotNaive/A.MultNaive-8                            2000000               869 ns/op               0 B/op          0 allocs/op
BenchmarkMatrixDotNaive/A.ParalMultNaivePerRow-8                  100000             14467 ns/op              80 B/op          9 allocs/op
BenchmarkMatrixDotNaive/A.ParalMultNaivePerElem-8                  20000             77299 ns/op             528 B/op         65 allocs/op

我知道缓存局部性的一些基本的先验知识,每个元素并发性能会降低性能.但是,为什么即使在天真的版本中,每行仍然会降低性能？

事实上,我还写了一个块/平铺优化,它的vanilla版本(没有goroutine并发)甚至比天真版本更糟糕(这里不存在,让我们首先关注天真).

我在这做错了什么？为什么？如何在这里优化？

乘法:

package naive

import (
    "errors"
    "sync"
)

// Errors
var (
    ErrNumElements = errors.New("Error number of elements")
    ErrMatrixSize  = errors.New("Error size of matrix")
)

// Matrix is a 2d array
type Matrix struct {
    N    int
    data [][]float64
}

// New a size by size matrix …

考虑一下代码:

glm::mat4x4 T = glm::mat4x4(1);
glm::vec4 vrpExpanded;
vrpExpanded.x = this->vrp.x;
vrpExpanded.y = this->vrp.y;
vrpExpanded.z = this->vrp.z;
vrpExpanded.w = 1;

this->vieworientationmatrix =  T * (-vrpExpanded);

为什么会T*(-vrpExpanded)产生一个向量？根据我对线性代数的了解,这应该产生一个mat4x4.

我的问题如下，我有一个迭代算法，这样在每次迭代时它需要执行几个矩阵乘法点（A_i，B_i），对于 i = 1 ... k。由于这些乘法是用 Numpy 的点执行的，我知道他们正在调用 BLAS-3 实现，这非常快。问题是调用数量巨大，结果证明是我程序中的瓶颈。我想通过制作更少的产品但使用更大的矩阵来最小化所有这些调用的开销。

为简单起见，考虑所有矩阵都是 nxn（通常 n 不大，范围在 1 到 1000 之间）。解决我的问题的一种方法是考虑块对角矩阵 diag( A_i ) 并执行下面的乘积。

这只是对函数 dot 的一次调用，但现在程序浪费了很多时间执行与零的乘法。这个想法似乎不起作用，但它给出了结果 [ A_1 B_1 , ..., A_k B_k ]，即所有产品堆叠在一个大矩阵中。

我的问题是，有没有办法通过单个函数调用计算 [ A_1 B_1 , ..., A_k B_k ] ？或者更重要的是，如何比制作 Numpy 点循环更快地计算这些产品？

这是我的代码

import numpy as np
import time
from scipy.spatial import distance

y1=np.array([0,0,0,0,1,0,0,0,0,0])
y2=np.array([0. , 0.1, 0. , 0. , 0.7, 0.2, 0. , 0. , 0. , 0. ])

start_time = time.time()
for i in range(1000000):
    distance.sqeuclidean(y1,y2)
print("--- %s seconds ---" % (time.time() - start_time))

---15.212640523910522 秒---

start_time = time.time()
for i in range(1000000):
    np.sum((y1-y2)**2)
print("--- %s seconds ---" % (time.time() - start_time))

---8.381187438964844---秒

我认为 Scipy 是经过优化的，所以它应该更快。

任何意见将不胜感激。