我的问题类似于这个与3D矩阵相乘的3D矩阵.但是,我在Fortran中编码.
再说了,如果我有一个RxSxT矩阵A和SxU矩阵B,其中R,S,T,U是整数,我要乘A(:,:,0)用B.我怎么能这样做matmul？当我做的事情
C(:,:,0) = matmul(A(:,:,0),B)
编译器(gfortran)给出:
Warning:Array reference at (1) is out of bounds (0 < 1) in dimension 3
f951: internal compiler error: Segmentation fault
有没有解决的办法？谢谢.
编辑:我应该补充一点,我实际上是转置第二个矩阵.再说了,A一个RxSxT矩阵和B一个UxS矩阵.然后
C(:,:,0) = matmul(B,transpose(A(:,:,0))
转置可能是问题的一部分.它将A(i,j,k)转换为A(k,i,j)吗？
假设我有一个矩阵 A
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
如何复制内部列A以获取新矩阵B
1 2 2 3 3 4 4 5
1 2 2 3 3 4 4 5
1 2 2 3 3 4 4 5
1 2 2 3 3 4 4 5
1 2 2 3 3 4 4 5
请注意,第一列和最后一列A是独立的.然后我需要将行对相加以获得另一个矩阵C:
3 5 …令矩阵a,b为[1,2,3,4],即(1×4)维.
在应用numpy.dot(a,b)时,结果为30而不是引发异常,即两个矩阵形状都没有对齐.
(mxn)矩阵如何与(mxn)矩阵相乘？numpy会自动转换一个矩阵来对齐它们的形状然后相乘吗？
如果我在导入numpy的python代码中看到以下行:
c = a * b
确定此操作是作为Hadamard(元素方向)还是点积(逐点)操作执行的最简单,最实用的方法是什么？
对于Hadamard产品来说,A和B的列和行大小必须相同.对于点积,只有A的列大小必须与B的行大小相同,对吗？所以我可以查找两者的形状并找出使用的操作？
python numpy linear-algebra matrix-multiplication dot-product
我需要编写矩阵向量和矩阵乘法函数,但我无法绕过SSE命令.
矩阵和向量的维数总是4的倍数.
我设法编写了矢量矢量乘法函数,如下所示:
void vector_multiplication_SSE(float* m, float* n, float* result, unsigned const int size)
{
int i;
__declspec(align(16))__m128 *p_m = (__m128*)m;
__declspec(align(16))__m128 *p_n = (__m128*)n;
__declspec(align(16))__m128 *p_result = (__m128*)result;
for (i = 0; i < size / 4; ++i)
p_result[i] = _mm_mul_ps(p_m[i], p_n[i]);
// print the result
for (int i = 0; i < size; ++i)
{
if (i % 4 == 0) cout << endl;
cout << result[i] << '\t';
}
}
现在我正在尝试实现矩阵向量乘法.
这是我到目前为止所拥有的:
void multiply_matrix_by_vector_SSE(float* m, float* v, …c++ sse intrinsics matrix-multiplication vector-multiplication
我试图在Julia中进行一些矩阵乘法,以便将其与numpy进行对比.
我的Julia代码如下:
function myFunc()
A = randn(10000, 10000)
B = randn(10000, 10000)
return A*B
end
myFunc()
而python版本是:
A = np.random.rand(10000,10000)
B = np.random.rand(10000,10000)
A*B
Python版本需要不到100毫秒才能执行.Julia版本需要超过13秒!看到他们在引擎盖下使用几乎相同的BLAS技术,似乎是Julia版本的问题？!
我希望这个讨论可以帮助其他任何与Armadillo和Eigen3有关的人.
我编写了一个包装类Mat,它包含来自armadillo库的arma :: Mat或来自Eigen3库的Eigen :: Matrix.这在编译时用标志控制.
另外,我写了一个使用Mat作为存储的Tensor类.此类的主要特征是使用Voigt表示法来压缩高阶张量,以便正确存储在矩阵中.
最后,我编写了一个多次乘以二阶张量(即矩阵)和一阶张量(即矢量)的测试,并记录完成运算符所需的时间.我用Mat类和Tensor类来做这个.
因为Tensor包裹Mat,我希望它的时间更长.犰狳就是这种情况,平均接近20%.然而,当使用Eigen时,使用Tensor更快,这对我来说绝对没有意义.
有什么事情适合任何人吗？
编辑:提供更多细节.
我首先将arma :: Mat包装成myOwn :: armaMat,将Eigen :: Matrix包装到myOwn :: eigenMat中.这两个都只是将armadillo和Eigen的API包装到一个通用框架中.最后,基于编译器标志,myOwn :: Mat包装了一个armaMat或一个eigenMat.我不确定我们打开的任何优化标志.
如上所述,myOwn :: Tensor使用myOwn :: Mat作为存储.由于我将使用Tensor类的物理应用程序,它被模板化为2D(即如果是2阶的2乘2)或3D(即3乘3).(相比之下,垫可以是任何尺寸).
我用于定时目的的运算符是:2乘2矩阵(二阶张量)乘以2乘1矩阵(一阶张量).当只使用Mat时,我基本上使用的是犰狳或Eigen的表达式模板.
使用我的Tensor类时,我正在重载operator*:
template< typename T1, bool Sym >
moris::Mat< T1 >
operator*(
moris::Tensor< T1, 2, 2, true > const & aTensor1,
moris::Tensor< T1, 1, 2, Sym > const & aTensor2 )
{
moris::Mat< T1 > tVector(2, 1);
tVector(0) = aTensor1[0]*aTensor2[0] + aTensor1[2]*aTensor2[1];
tVector(1) = aTensor1[2]*aTensor2[0] + aTensor1[1]*aTensor2[1];
return tVector;
}
Tensor上的[]运算符从底层存储Mat访问数据(通过Voigt约定).
我试图用RcppArmadillo做一些矩阵乘法.但是,我的代码显示RcppArmadillo不会变得更快.
我使用Windows_10_Pro和R 3.2.4,以及RcppArmadillo 0.6.600.4.0
例如:
library(RcppArmadillo)
library(inline)
MCplus <- cxxfunction(signature(X_="numeric", Y_="numeric"),body ='
arma::mat X = Rcpp::as<arma::mat>(X_);
arma::mat Y = Rcpp::as<arma::mat>(Y_);
arma::mat ans = X * Y * X;
return(wrap(ans));
', plugin="RcppArmadillo")
A <- matrix(1:16000000,4000,4000)
C <- matrix(2:16000001,4000,4000)
R_M <- proc.time()
ans_R <- A%*%C%*%A # test with R
proc.time() - R_M
C_M <- proc.time()
ans_C <- MCplus(A,C) # test with RcppArmadillo
proc.time() - C_M
R输出:
user system elapsed
106.75 0.24 106.98
而RcppArmadillo输出:
user system elapsed
108.28 0.23 108.56
有什么东西可以改善吗？ …
对于这两个矩阵,我想找到矩阵X和Q行的乘积,并应用ifelse函数来查看产品是否大于零.
n1=1000, m=10000
X=cbind(rnorm(n1),rbinom(n1))
Q=matrix(rnorm(2*m), ncol=2)
为此,我尝试了循环并应用以下功能.
D=10000
ind_beta=matrix(0,n1,D)
for (l in 1:D){
ind[,l]=as.vector(ifelse(X%*%Q[l,]>=0,1,0))
}
和
ind=apply(Q,1,function(x){ifelse(X%*%Q>=0,1,0)})
两个代码都给出了相同的结果,但实际上非常耗时.有没有办法让这个快？提前致谢.
我最近开始使用CUDA开始使用GPU.作为入门程序,我试图有效地实现简单的矩阵乘法
C = AB
,从朴素矩阵乘法开始(每个线程加载C中元素的A和B的所有元素),平铺实现(线程协同加载来自共享内存中的块中A和B的元素块以减少全局内存交通)提供良好的加速.但是,在平铺实现中,对全局内存的访问也不是合并的顺序.因此,为了提高性能,最好转置矩阵B然后相乘.以下是我的代码,
#include<stdio.h>
#include<stdlib.h>
#include<cuda_runtime.h>
#include <time.h>
#include <sys/time.h>
void querydeviceprop();
void allocate_matrix(float *h_a, float *h_b, int matDim);
void verify(float *h_c, float *h_c_check, int matDim);
void print_matrix(float *ha, int m,int n);
void transpose_matrix(float *ha, int matDim);
void mat_mul();
#define TILE_WIDTH 16 //should be equal to numThread for tiling implementation
__global__ void MatrixMult_tiling(float *d_a,float *d_b,float *d_c, int dim){
__shared__ float ta[TILE_WIDTH][TILE_WIDTH]; //to load one tile of A
__shared__ float tb[TILE_WIDTH][TILE_WIDTH]; //to load one tile of A
int bx,by,tx,ty,i,j; …