应用向量化技术来加速性能的一个3 d矩阵除以一个二维矩阵

5视图(30天)

显示旧的评论

马修凯赫 2021年7月29日

0
链接

这个问题直接联系

//www.tianjin-qmedu.com/matlabcentral/answers/888132-applying-vectorization-techniques-to-speedup-the-performance-of-dividing-a-3d-matrix-by-a-2d-matrix

评论道: 马修凯赫2021年7月31日

答:接受布鲁诺陈德良

我正在删除一个for循环在我的Matlab代码来提高性能。我原来的代码有一个for循环( 从j = 1: Nx )有害性能(在我生产代码,这for循环处理超过2000万次,如果我测试大型模拟)。我很好奇如果我可以删除这个for循环通过向量化,repmat,或类似的技术。我原来的Matlab实现如下所示。

                         clc;清晰的所有;
                        
                         %测试数据
                        
                         %我想删除j的for循环下面的代码
                        
                         N = 10;
                        
                         M = 10;
                        
                         Nx = 32;%纽约= Nx =新西兰
                        
                         新西兰= 32;
                        
                         纽约= 32;
                        
                         Fnmhat =兰德(Nx,新西兰+ 1);
                        
                         Jnmhat =兰德(Nx, 1);
                        
                         xi_n_m_hat =兰德(Nx、N + 1 M + 1);
                        
                         Uhat = 0 (Nx,新西兰+ 1);
                        
                         Uhat_2 = 0 (Nx,新西兰+ 1);
                        
                         identy =眼睛(纽约纽约+ 1 + 1);
                        
                         p =兰德(Nx, 1);
                        
                         gammap =兰德(Nx, 1);
                        
                         D =兰德(纽约Nx + 1 + 1);
                        
                         D2 =兰德(纽约Nx + 1 + 1);
                        
                         D_start = D (1);
                        
                         D_end = D(最终:);
                        
                         γ= 1.5;
                        
                         α= 0;%这可能是零
                        
                         ntests = 100;
                        
                         %原始代码转换成矢量图(部分)
                        
                         抽搐
                        
                         为n = 0: n
                        
                         为m = 0: m
                        
                         b = Fnmhat。”;
                        
                         alphaalpha = 1.0;
                        
                         betabeta = 0.0;%这可能是零
                        
                         gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                        
                         d_min = 1.0;
                        
                         n_min = 0.0;%这可能是零
                        
                         r_min = xi_n_m_hat (:, n + 1, + 1);
                        
                         d_max = 1我。* gammap;
                        
                         n_max = 1.0;
                        
                         r_max = Jnmhat;
                        
                         一个= alphaalpha * D2 + betabeta * D +交换(gammagamma (3,2,1))。* identy;
                        
                         (:,:)= repmat (n_min * D_end, [1, 1, Nx]);
                        
                         b(结束:)= r_min;
                        
                         (,,,)=(结束、结束:)+ d_min;
                        
                         (1::)= repmat (n_max * D_start, [1, 1, Nx]);
                        
                         一(1 1:)=(1 1:)+交换(d_max [2、3、1]);
                        
                         :b (1) = r_max;
                        
                         % Non-vectorized代码——这部分可以向量化?
                        
                         为j = 1: Nx
                        
                         utilde = linsolve ((:,:, j)、b (:, j));% \ b
                        
                         Uhat (j) = utilde。';
                        
                         结束
                        
                         结束
                        
                         结束
                        
                         toc

这是我尝试vectorizing代码(j和删除for循环)。

                         %与原始代码相同的测试数据
                        
                         %的新代码(完全矢量化但不正确的)
                        
                         抽搐
                        
                         为n = 0: n
                        
                         为m = 0: m
                        
                         b = Fnmhat。”;
                        
                         alphaalpha = 1.0;
                        
                         betabeta = 0.0;%这可能是零
                        
                         gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                        
                         d_min = 1.0;
                        
                         n_min = 0.0;%这可能是零
                        
                         r_min = xi_n_m_hat (:, n + 1, + 1);
                        
                         d_max = 1我。* gammap;
                        
                         n_max = 1.0;
                        
                         r_max = Jnmhat;
                        
                         A2 = alphaalpha * D2 + betabeta * D +交换(gammagamma (3,2,1))。* identy;
                        
                         A2 (:,:) = repmat (n_min * D_end, [1, 1, Nx]);
                        
                         b(结束:)= r_min;
                        
                         A2(结束、结束:)= A2(结束、结束:)+ d_min;
                        
                         A2 (1::) = repmat (n_max * D_start, [1, 1, Nx]);
                        
                         A2 (1 1:) = A2(1 1:) +交换(d_max [2、3、1]);
                        
                         :b (1) = r_max;
                        
                         % Non-vectorized代码——这部分可以向量化?
                        
                         % j = 1: Nx
                        
                         % utilde_2 = linsolve (A2 (:,:, j)、b (:, j));% A2 \ b
                        
                         % Uhat_2 (j) = utilde_2。';
                        
                         %结束
                        
                         %我的尝试——这是行不通的,因为我不循环指数j
                        
                         %在repmat
                        
                         utilde_2 =挤压(repmat (linsolve (A2 (:,:, Nx)、b (:, Nx)), (1, 1, Nx)));
                        
                         utilde_2 = utilde_2 (: 1);
                        
                         Uhat_2 =挤压(repmat (utilde_2”, [1, 1, Nx]));
                        
                         Uhat_2 = Uhat_2 ';
                        
                         结束
                        
                         结束
                        
                         toc
                        
                         diff =规范(Uhat——Uhat_2 inf);如果正确% = 0

我很好奇如果repmat(或另一个安装在内部的Matlab函数)可以加快的这部分代码:

                         为j = 1: Nx
                        
                         utilde = linsolve ((:,:, j)、b (:, j));% \ b
                        
                         Uhat (j) = utilde。';
                        
                         结束

是j绝对必要的for循环或可以删除吗?

1评论
显示没有隐藏没有

马修凯赫 2021年7月29日

@the骑自行车 :这个问题是一个跟进的问题今天下午早期创建的问题。

登录置评。

在回答这个问题。

接受的答案

布鲁诺陈德良 2021年7月29日

1
链接

直接链接到这个答案

//www.tianjin-qmedu.com/matlabcentral/answers/888132-applying-vectorization-techniques-to-speedup-the-performance-of-dividing-a-3d-matrix-by-a-2d-matrix answer_756701

如果你有C语言编译器,照方法也许mmx和MultipleQR avaikable FEX

//www.tianjin-qmedu.com/matlabcentral/answers/776812-how-to-vectorize-a-b-operation-on-slices-of-3d-matrices?s_tid=srchtitle

9日评论
显示8年长的评论隐藏8年长的评论

马修凯赫 2021年7月29日

编辑:马修凯赫 2021年7月29日

奇怪的是,似乎for循环比MultipleQR快本地(至少在我的机器上)。我可以测试错了。我实现了以下测试场景:

                                  clc;清晰的所有;
                                 
                                  %测试数据
                                 
                                  N = 10;
                                 
                                  M = 10;
                                 
                                  Nx = 32;%纽约= Nx =新西兰
                                 
                                  新西兰= 32;
                                 
                                  纽约= 32;
                                 
                                  Fnmhat =兰德(Nx,新西兰+ 1);
                                 
                                  Jnmhat =兰德(Nx, 1);
                                 
                                  xi_n_m_hat =兰德(Nx、N + 1 M + 1);
                                 
                                  Uhat = 0 (Nx,新西兰+ 1);
                                 
                                  Uhat_2 = 0 (Nx,新西兰+ 1);
                                 
                                  identy =眼睛(纽约纽约+ 1 + 1);
                                 
                                  p =兰德(Nx, 1);
                                 
                                  gammap =兰德(Nx, 1);
                                 
                                  D =兰德(纽约Nx + 1 + 1);
                                 
                                  D2 =兰德(纽约Nx + 1 + 1);
                                 
                                  D_start = D (1);
                                 
                                  D_end = D(最终:);
                                 
                                  γ= 1.5;
                                 
                                  α= 0;%这可能是零
                                 
                                  ntests = 100;
                                 
                                  %原始代码转换成矢量图(部分)
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  为n = 0: n
                                 
                                  为m = 0: m
                                 
                                  b = Fnmhat。”;
                                 
                                  alphaalpha = 1.0;
                                 
                                  betabeta = 0.0;%这可能是零
                                 
                                  gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                                 
                                  d_min = 1.0;
                                 
                                  n_min = 0.0;%这可能是零
                                 
                                  r_min = xi_n_m_hat (:, n + 1, + 1);
                                 
                                  d_max = 1我。* gammap;
                                 
                                  n_max = 1.0;
                                 
                                  r_max = Jnmhat;
                                 
                                  一个= alphaalpha * D2 + betabeta * D +重塑(gammagamma, 1, 1, Nx)。* identy;
                                 
                                  (:,:)= repmat (n_min * D_end, [1, 1, Nx]);
                                 
                                  b(结束:)= r_min;
                                 
                                  (,,,)=(结束、结束:)+ d_min;
                                 
                                  (1::)= repmat (n_max * D_start, [1, 1, Nx]);
                                 
                                  一(1 1:)=(1 1:)+重塑(Nx d_max 1 1);
                                 
                                  :b (1) = r_max;
                                 
                                  % Non-vectorized代码
                                 
                                  为j = 1: Nx
                                 
                                  utilde = linsolve ((:,:, j)、b (:, j));% \ b
                                 
                                  Uhat (j) = utilde。';
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc
                                 
                                  %与MultipleQRSolve新代码
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  为n = 0: n
                                 
                                  为m = 0: m
                                 
                                  b = Fnmhat。”;
                                 
                                  alphaalpha = 1.0;
                                 
                                  betabeta = 0.0;%这可能是零
                                 
                                  gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                                 
                                  d_min = 1.0;
                                 
                                  n_min = 0.0;%这可能是零
                                 
                                  r_min = xi_n_m_hat (:, n + 1, + 1);
                                 
                                  d_max = 1我。* gammap;
                                 
                                  n_max = 1.0;
                                 
                                  r_max = Jnmhat;
                                 
                                  A2 = alphaalpha * D2 + betabeta * D +重塑(gammagamma, 1, 1, Nx)。* identy;
                                 
                                  A2 (:,:) = repmat (n_min * D_end, [1, 1, Nx]);
                                 
                                  b(结束:)= r_min;
                                 
                                  A2(结束、结束:)= A2(结束、结束:)+ d_min;
                                 
                                  A2 (1::) = repmat (n_max * D_start, [1, 1, Nx]);
                                 
                                  A2 (1 1:) = A2(1 1:) +重塑(Nx d_max 1 1);
                                 
                                  :b (1) = r_max;
                                 
                                  % Non-vectorized代码
                                 
                                  % j = 1: Nx
                                 
                                  % utilde_2 = linsolve (A2 (:,:, j)、b (:, j));% \ b
                                 
                                  % Uhat_2 (j) = utilde_2。';
                                 
                                  %结束
                                 
                                  b =重塑(b, Nx + 1, 1, Nx);
                                 
                                  Uhat_2 =挤压(MultipleQRSolve (A2、b 1 e-12));
                                 
                                  Uhat_2 = Uhat_2 ';
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc
                                 
                                  diff =规范(Uhat——Uhat_2 inf);% 15.7722返回,我可能写错了。

它返回

                                  运行方法1(循环)时间是14.830669秒。
                                 
                                  运行方法2 (MultipleQRSolve)是15.170965秒。

我也测试mmx通过设置错误)(我工作。

马修凯赫 2021年7月29日

编辑:马修凯赫 2021年7月29日

@Bruno陈德良 (这是一个非常长的评论,我可能想把答案)我用MMX固定安装错误。我测试了对4种不同的解决方案:万博尤文图斯

for循环(:,:,j) \ b (:, j)用Matlab将取代linsolve更快(这是我的数据)。
的MultipleQRSolve从文件交换。
的多个相同大小线性规划求解从文件交换。
MMX现在搬到Github。

我的测试代码如下。

                                  clc;清晰的所有;
                                 
                                  %测试数据
                                 
                                  N = 8;
                                 
                                  M = 8;
                                 
                                  Nx = 32;%纽约= Nx =新西兰
                                 
                                  新西兰= 32;
                                 
                                  纽约= 32;
                                 
                                  Fnmhat =兰德(Nx,新西兰+ 1);
                                 
                                  Jnmhat =兰德(Nx, 1);
                                 
                                  xi_n_m_hat =兰德(Nx、N + 1 M + 1);
                                 
                                  Uhat = 0 (Nx,新西兰+ 1);
                                 
                                  Uhat_2 = 0 (Nx,新西兰+ 1);
                                 
                                  identy =眼睛(纽约纽约+ 1 + 1);
                                 
                                  p =兰德(Nx, 1);
                                 
                                  gammap =兰德(Nx, 1);
                                 
                                  D =兰德(纽约Nx + 1 + 1);
                                 
                                  D2 =兰德(纽约Nx + 1 + 1);
                                 
                                  D_start = D (1);
                                 
                                  D_end = D(最终:);
                                 
                                  γ= 1.5;
                                 
                                  α= 0;%这可能是零
                                 
                                  ntests = 100;
                                 
                                  %方法1:原始代码转换成矢量图(部分)
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  为n = 0: n
                                 
                                  为m = 0: m
                                 
                                  b = Fnmhat。”;
                                 
                                  alphaalpha = 1.0;
                                 
                                  betabeta = 0.0;%这可能是零
                                 
                                  gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                                 
                                  d_min = 1.0;
                                 
                                  n_min = 0.0;%这可能是零
                                 
                                  r_min = xi_n_m_hat (:, n + 1, + 1);
                                 
                                  d_max = 1我。* gammap;
                                 
                                  n_max = 1.0;
                                 
                                  r_max = Jnmhat;
                                 
                                  一个= alphaalpha * D2 + betabeta * D +重塑(gammagamma, 1, 1, Nx)。* identy;
                                 
                                  (:,:)= repmat (n_min * D_end, [1, 1, Nx]);
                                 
                                  b(结束:)= r_min;
                                 
                                  (,,,)=(结束、结束:)+ d_min;
                                 
                                  (1::)= repmat (n_max * D_start, [1, 1, Nx]);
                                 
                                  一(1 1:)=(1 1:)+重塑(Nx d_max 1 1);
                                 
                                  :b (1) = r_max;
                                 
                                  % Non-vectorized代码
                                 
                                  为j = 1: Nx
                                 
                                  utilde = linsolve ((:,:, j)、b (:, j));% \ b
                                 
                                  Uhat (j) = utilde。';
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc
                                 
                                  与MultipleQRSolve %方法2:新代码
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  为n = 0: n
                                 
                                  为m = 0: m
                                 
                                  b = Fnmhat。”;
                                 
                                  alphaalpha = 1.0;
                                 
                                  betabeta = 0.0;%这可能是零
                                 
                                  gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                                 
                                  d_min = 1.0;
                                 
                                  n_min = 0.0;%这可能是零
                                 
                                  r_min = xi_n_m_hat (:, n + 1, + 1);
                                 
                                  d_max = 1我。* gammap;
                                 
                                  n_max = 1.0;
                                 
                                  r_max = Jnmhat;
                                 
                                  A2 = alphaalpha * D2 + betabeta * D +重塑(gammagamma, 1, 1, Nx)。* identy;
                                 
                                  A2 (:,:) = repmat (n_min * D_end, [1, 1, Nx]);
                                 
                                  b(结束:)= r_min;
                                 
                                  A2(结束、结束:)= A2(结束、结束:)+ d_min;
                                 
                                  A2 (1::) = repmat (n_max * D_start, [1, 1, Nx]);
                                 
                                  A2 (1 1:) = A2(1 1:) +重塑(Nx d_max 1 1);
                                 
                                  :b (1) = r_max;
                                 
                                  % Non-vectorized代码
                                 
                                  % j = 1: Nx
                                 
                                  % utilde_2 = linsolve (A2 (:,:, j)、b (:, j));% \ b
                                 
                                  % Uhat_2 (j) = utilde_2。';
                                 
                                  %结束
                                 
                                  b =重塑(b, Nx + 1, 1, Nx);
                                 
                                  Uhat_2 =挤压(MultipleQRSolve (A2、b 1 e-12));
                                 
                                  Uhat_2 = Uhat_2 ';
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc
                                 
                                  %方法3:与MultiSolver新代码
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  为n = 0: n
                                 
                                  为m = 0: m
                                 
                                  b = Fnmhat。”;
                                 
                                  alphaalpha = 1.0;
                                 
                                  betabeta = 0.0;%这可能是零
                                 
                                  gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                                 
                                  d_min = 1.0;
                                 
                                  n_min = 0.0;%这可能是零
                                 
                                  r_min = xi_n_m_hat (:, n + 1, + 1);
                                 
                                  d_max = 1我。* gammap;
                                 
                                  n_max = 1.0;
                                 
                                  r_max = Jnmhat;
                                 
                                  A3 = alphaalpha * D2 + betabeta * D +重塑(gammagamma, 1, 1, Nx)。* identy;
                                 
                                  A3 (:,:) = repmat (n_min * D_end, [1, 1, Nx]);
                                 
                                  b(结束:)= r_min;
                                 
                                  A3(结束、结束:)= A3(结束、结束:)+ d_min;
                                 
                                  A3 (1::) = repmat (n_max * D_start, [1, 1, Nx]);
                                 
                                  A3 (1 1:) = A3(1 1:) +重塑(Nx d_max 1 1);
                                 
                                  :b (1) = r_max;
                                 
                                  % Non-vectorized代码
                                 
                                  % j = 1: Nx
                                 
                                  % utilde_2 = linsolve (A3 (:,:, j)、b (:, j));% \ b
                                 
                                  % Uhat_2 (j) = utilde_2。';
                                 
                                  %结束
                                 
                                  Uhat_3 =挤压(MultiSolver (A3, b));
                                 
                                  Uhat_3 = Uhat_3 ';
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc
                                 
                                  %方法4:用MMX新代码
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  为n = 0: n
                                 
                                  为m = 0: m
                                 
                                  b = Fnmhat。”;
                                 
                                  alphaalpha = 1.0;
                                 
                                  betabeta = 0.0;%这可能是零
                                 
                                  gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                                 
                                  d_min = 1.0;
                                 
                                  n_min = 0.0;%这可能是零
                                 
                                  r_min = xi_n_m_hat (:, n + 1, + 1);
                                 
                                  d_max = 1我。* gammap;
                                 
                                  n_max = 1.0;
                                 
                                  r_max = Jnmhat;
                                 
                                  A4 = alphaalpha * D2 + betabeta * D +重塑(gammagamma, 1, 1, Nx)。* identy;
                                 
                                  A4 (:,:) = repmat (n_min * D_end, [1, 1, Nx]);
                                 
                                  b(结束:)= r_min;
                                 
                                  A4(结束、结束:)= A4(结束、结束:)+ d_min;
                                 
                                  A4 (1::) = repmat (n_max * D_start, [1, 1, Nx]);
                                 
                                  A4 (1 1:) = A4(1 1:) +重塑(Nx d_max 1 1);
                                 
                                  :b (1) = r_max;
                                 
                                  % Non-vectorized代码
                                 
                                  % j = 1: Nx
                                 
                                  % utilde_2 = linsolve (A4 (:,:, j)、b (:, j));% \ b
                                 
                                  % Uhat_2 (j) = utilde_2。';
                                 
                                  %结束
                                 
                                  b =重塑(b, Nx + 1, 1, Nx);
                                 
                                  Uhat_4 =挤压(mmx (“反斜杠”A4, b));%这复杂的双输入双
                                 
                                  Uhat_4 = Uhat_4 ';
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc
                                 
                                  diff =规范(Uhat——Uhat_2 inf);% 15.7722返回,我可能写错了。
                                 
                                  diff2 =规范(Uhat——Uhat_3 inf);% 15.7722返回,我可能写错了。
                                 
                                  diff3 =规范(Uhat——Uhat_4 inf);%返回474年以来mmx把复杂的双输入双!

时间是

                                  运行方法1(循环)时间是10.034689秒。
                                 
                                  运行方法2 (MultipleQRSolve)是10.101741秒。
                                 
                                  运行时间的方法3 (MultiSolver)是19.232889秒。
                                 
                                  运行时间的方法4 (MMX)是3.241713秒。改变数据类型复杂的双输入双。

因此,MMX更快。然而,价值观的差异,diff2 diff3都是零。mmx的反斜杠'命令更改我的矩阵中的数据从一个复杂的双重双(这将摧毁我的测试数据)。通过阅读文档MMX,复数不支持。万博1manbetx在讨论部分的URL 在文件交换,用户以色列沃恩表明写作新函数称为mmxc我下面的复制。

                                  函数[C] = mmxc (actionStr, A, B, transString)
                                 
                                  %复杂mmx
                                 
                                  %不优化,但是,它的工作原理
                                 
                                  如果(比较字符串(actionStr“广场”)& isempty (B))
                                 
                                  在=真正的(A);
                                 
                                  Ai =图像放大(一个);
                                 
                                  清晰的一个;
                                 
                                  C = mmx (“广场”在[]);
                                 
                                  C = C - 1我。* mmx (“乘”在人工智能,“nt”);
                                 
                                  C = C + 1我。* mmx (“乘”,人工智能,“nt”);
                                 
                                  C = C + mmx (“广场”人工智能,[]);
                                 
                                  其他的如果(存在(“transString”))
                                 
                                  在=真正的(A);
                                 
                                  Ai =图像放大(一个);
                                 
                                  清晰的一个;
                                 
                                  Bt =真正的(B);
                                 
                                  Bi =图像放大(B);
                                 
                                  清晰的B;
                                 
                                  Bt, C = mmx (actionStr transString);
                                 
                                  C = C + 1我。* mmx (actionStr, Bi, transString);
                                 
                                  清晰的在;
                                 
                                  C = C + 1我。* mmx (actionStr, Ai, Bt, transString);
                                 
                                  清晰的英国电信;
                                 
                                  C = C - mmx (actionStr Ai, Bi, transString);
                                 
                                  其他的
                                 
                                  在=真正的(A);
                                 
                                  Ai =图像放大(一个);
                                 
                                  清晰的一个;
                                 
                                  Bt =真正的(B);
                                 
                                  Bi =图像放大(B);
                                 
                                  清晰的B;
                                 
                                  C = mmx (actionStr Bt);
                                 
                                  C = C + 1我。* mmx (actionStr, Bi);
                                 
                                  清晰的在;
                                 
                                  C = C + 1我。* mmx (actionStr, Ai, Bt);
                                 
                                  清晰的英国电信;
                                 
                                  C = C - mmx (actionStr Ai, Bi);
                                 
                                  结束
                                 
                                  结束

这个新函数取代以来似乎是不正确的

Uhat_4 =挤压(mmxc (“反斜杠”A4, b));% mmxc改为复杂

还返回一个非零diff3。通过回顾这个问题栈交流,它看起来像有一个潜在的“黑客”用户亚历克·雅各布森所提供的答案:

                                  %方法5:尝试“黑客”堆栈交换
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  为n = 0: n
                                 
                                  为m = 0: m
                                 
                                  b = Fnmhat。”;
                                 
                                  alphaalpha = 1.0;
                                 
                                  betabeta = 0.0;%这可能是零
                                 
                                  gammagamma =γ*γ- p。^ 2 - 2 *α。* p;%的大小(Nx, 1)
                                 
                                  d_min = 1.0;
                                 
                                  n_min = 0.0;%这可能是零
                                 
                                  r_min = xi_n_m_hat (:, n + 1, + 1);
                                 
                                  d_max = 1我。* gammap;
                                 
                                  n_max = 1.0;
                                 
                                  r_max = Jnmhat;
                                 
                                  A5 = alphaalpha * D2 + betabeta * D +重塑(gammagamma, 1, 1, Nx)。* identy;
                                 
                                  A5 (:,:) = repmat (n_min * D_end, [1, 1, Nx]);
                                 
                                  b(结束:)= r_min;
                                 
                                  A5(结束、结束:)= A5(结束、结束:)+ d_min;
                                 
                                  A5 (1::) = repmat (n_max * D_start, [1, 1, Nx]);
                                 
                                  A5 (1 1:) = A5(1 1:) +重塑(Nx d_max 1 1);
                                 
                                  :b (1) = r_max;
                                 
                                  % Non-vectorized代码
                                 
                                  % j = 1: Nx
                                 
                                  % utilde_2 = linsolve (A5 (:,:, j)、b (:, j));% \ b
                                 
                                  % Uhat_2 (j) = utilde_2。';
                                 
                                  %结束
                                 
                                  从亚历克·雅各布森%稍微深奥的解决方案
                                 
                                  w =大小(A5, 1);
                                 
                                  k =大小(A5, 3);
                                 
                                  =重塑(排列(A [1 3 2]), w * k w);
                                 
                                  S =稀疏(…
                                 
                                  repmat (1: w * k w、1)”,…
                                 
                                  bsxfun (@plus重塑(repmat (1: w: w * k, w, 1), [], 1), 0: w1),…
                                 
                                  ,w * k w * k);
                                 
                                  %以下线炸毁自b的大小(Nx + 1, Nx)和代码假设
                                 
                                  %的大小(Nx, 1)
                                 
                                  utilde_5 =重塑(S \ repmat (b, k, 1), w, k);
                                 
                                  utilde_5 = utilde_5 ';
                                 
                                  结束
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc

我要试着解决这个问题。看来MMS反斜杠命令将为双工作数据类型(而不是复杂的双打)。也许我能得到上面的破解工作。我也会看看并行计算工具箱。

马修凯赫 2021年7月30日

编辑:马修凯赫 2021年7月30日

我认为单个方法的性能很大程度取决于输入矩阵的大小。对于更大的矩阵,For循环似乎赢得每一次:

                                  %这些参数模拟真实数据在我的代码
                                 
                                  m = 33;
                                 
                                  n = 33;
                                 
                                  p = 1;
                                 
                                  q = 32;%不耗尽内存!
                                 
                                  ntests = 100000;%十万
                                 
                                  %循环
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  Ac = randn (m, n, q) + 1我* randn (m, n, q);%的是一个复杂的两倍大小(33岁,33岁,32)
                                 
                                  公元前= randn (m, p, q) + 1我*兰德(m, p, q);% B是一个双(不复杂)的大小(33岁,32)。我resphape大小(33岁,32)反斜杠/分裂功能。
                                 
                                  z = 0 (n, p, q);
                                 
                                  为k = 1:问
                                 
                                  z (:,:, k) = Ac (:,:, k) \ Bc (:,:, k);
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc%运行时间是236.284139秒。
                                 
                                  % mmx
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  基于“增大化现实”技术=实际(Ac);
                                 
                                  Ai =图像放大(Ac);
                                 
                                  Br =实际(Bc);
                                 
                                  Bi =图像放大(Bc);
                                 
                                  AA =[基于“增大化现实”技术,人工智能,人工智能,基于“增大化现实”技术);
                                 
                                  BB = (Br, Bi);
                                 
                                  zz = mmx (“反斜杠”、AA、BB);
                                 
                                  z2 = zz (1: n,::) + 1我* zz (n + 1:,::);
                                 
                                  结束
                                 
                                  toc%运行时间是331.318650秒。
                                 
                                  % MultipleQRSolve
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  z3 = MultipleQRSolve (Ac、Bc);
                                 
                                  结束
                                 
                                  toc%运行时间是272.109689秒。

我在较慢的计算机和明天早上将在一个更快。我会做一些测试与真正的Matlab代码。真奇怪,for循环似乎打败所有其他的解决方案与较大的数据(在并行计算工具箱,我将调查)。万博尤文图斯

马修凯赫 2021年7月31日

我认为可以优化MMX如果A和B都不复杂的双打。在我数据,B不是复杂的双所以可以加快MMX计算。这是我如何实现三种不同的方法在我真正的Matlab代码。

                                  %这些参数模拟真实数据在我的代码
                                 
                                  m = 33;
                                 
                                  n = 33;
                                 
                                  p = 1;
                                 
                                  q = 32;
                                 
                                  ntests = 10000;
                                 
                                  %我的代码计算交流和Br之前进入循环
                                 
                                  Ac =兰特(m, n, q) + 1我*兰德(m, n, q);%的是一个复杂的两倍大小(33岁,33岁,32)
                                 
                                  Br =兰德(m, q);% B是一个(真正的)两倍大小(33岁,32)
                                 
                                  %在我决定使用一个for循环/ mmx / MultipleQRSolve我的代码
                                 
                                  %“理解”,是一个复杂的两倍大小(33岁,33岁,32)和B是A
                                 
                                  %(真实)的大小(33岁,32)的两倍。我不需要计算里面A或B是什么
                                 
                                  % for循环。我只是重塑B在MMX和MultipleQRSolve因为我
                                 
                                  %为划分操作。
                                 
                                  %的是我将如何在“真正的”写下面的三个函数代码。
                                 
                                  %循环
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  z1 = 0 (q,米);
                                 
                                  为j = 1:问
                                 
                                  %这目前是我的代码如何计算\ b
                                 
                                  utilde = linsolve (Ac (:,:, j), Br (:, j));% \ b
                                 
                                  z1 (j) = utilde。';
                                 
                                  结束
                                 
                                  结束
                                 
                                  toc%运行时间是14.231135秒。
                                 
                                  % mmx
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  Bnew =重塑(Br, m, 1, q);%让Br大小(33岁,1,32)应用MMX
                                 
                                  基于“增大化现实”技术=实际(Ac);
                                 
                                  Ai =图像放大(Ac);
                                 
                                  Br =实际(Bnew);
                                 
                                  Bi =图像放大(Bnew);% 0 b是一个真正的双
                                 
                                  % z_1 = Ar + Ai *我
                                 
                                  % z_2 = Br + Bi *我
                                 
                                  % z_1 / z_2 = [(Ar * Br +人工智能(Bi) + 1我* Br - Ar (Ai * * Bi)] / (Br Bi ^ ^ 2 + 2);
                                 
                                  %因为Bi = = 0,这是简化
                                 
                                  % z_1 / z_2 = [(Ar * Br) + 1我* (Ai * Br)] / (Br ^ 2);
                                 
                                  %我认为这使得下面的代码
                                 
                                  % AA =[基于“增大化现实”技术,人工智能,人工智能,基于“增大化现实”技术);
                                 
                                  % BB = (Br, Bi);
                                 
                                  % zz = mmx(反斜杠,AA、BB);
                                 
                                  % z2 = zz (1: n,::) + 1我* zz (n + 1:,::);
                                 
                                  %到更快的版本
                                 
                                  Num = mmx (“乘”基于“增大化现实”技术,Br);
                                 
                                  我* mmx Num = Num + 1 (“乘”人工智能,Br);
                                 
                                  穴= Br。^ 2;
                                 
                                  z2 = mmx (“反斜杠”,Num穴);
                                 
                                  z2 =排列(z2, [3 1 2]);
                                 
                                  结束
                                 
                                  toc%运行时间是2.441799秒。
                                 
                                  % MultipleQRSolve
                                 
                                  抽搐
                                 
                                  为2 = 1:ntests
                                 
                                  Bnew_2 =重塑(Br, m, 1, q);%让Br大小(33岁,1,32)应用MultipleQRSolve
                                 
                                  z3 = MultipleQRSolve (Ac, Bnew_2);
                                 
                                  z3 =排列(z3 [3 1 2]);
                                 
                                  结束
                                 
                                  toc%运行时间是25.991396秒。
                                 
                                  diff =规范(z1-z2、正);%不为零自从我代码z_1 / z_2不是正确的。
                                 
                                  diff2 =规范(z1-z3、正);

如果代码为

                                  AA =[基于“增大化现实”技术,人工智能,人工智能,基于“增大化现实”技术);
                                 
                                  BB = (Br, Bi);
                                 
                                  zz = mmx (“反斜杠”、AA、BB);
                                 
                                  z2 = zz (1: n,::) + 1我* zz (n + 1:,::);

不需要(如B不是一个复杂的两倍)那么MMX“击败”for循环。感谢你所有的帮助这个问题(写作和MultipleQRSolve)。

登录置评。

类别

MATLAB 数学小学数学特殊功能

找到更多的在特殊功能在帮助中心和文件交换

s manbetx 845

MATLAB

释放

R2020a

社区寻宝

找到宝藏在MATLAB中央,发现社区如何帮助你!

开始狩猎!

应用向量化技术来加速性能的一个3 d矩阵除以一个二维矩阵

1评论
显示没有隐藏没有

接受的答案

9日评论
显示8年长的评论隐藏8年长的评论

更多的答案(2)

5个评论
显示4年长的评论隐藏4年长的评论

1评论
显示没有隐藏没有

另请参阅

类别

标签

s manbetx 845

释放

社区寻宝

应用向量化技术来加速性能的一个3 d矩阵除以一个二维矩阵

1评论 显示没有隐藏没有

接受的答案

9日评论 显示8年长的评论隐藏8年长的评论

更多的答案(2)

5个评论 显示4年长的评论隐藏4年长的评论

1评论 显示没有隐藏没有

另请参阅

类别

标签

s manbetx 845

释放

社区寻宝

1评论
显示没有隐藏没有

9日评论
显示8年长的评论隐藏8年长的评论

5个评论
显示4年长的评论隐藏4年长的评论

1评论
显示没有隐藏没有