标签: vectorization

说我有以下矩阵:

A = randi(10, [6 3])
     7    10     3
     5     5     7
    10     5     1
     6     5    10
     4     9     1
     4    10     1

我想提取每两行并将它们放入第三维,因此结果如下:

B(:,:,1) =
     7    10     3
     5     5     7
B(:,:,2) =
    10     5     1
     6     5    10
B(:,:,3) =
     4     9     1
     4    10     1

我显然可以使用for循环执行此操作,只是想知道如何使用permute/reshape/.. 更加优雅地进行单线程(注意矩阵大小和步骤必须是参数)

% params
step = 5;
r = 15;
c = 3;

% data
A = randi(10, [r c]);
B = zeros(step, c, r/step); …

有没有办法使用属性((对齐))强制STL容器对齐到特定字节？目标编译器不是Microsoft Visual C++.

哪些库(如果有的话)提供具有特定显式向量化的STL算法的专用模板,例如SSE.我感兴趣的编译器是g ++,Intel和IBM XL.

我正在寻找关于MATLAB中矢量化(循环)的任何好教程.

我有非常简单的算法,但它使用两个for循环.我知道向它进行矢量化应该很简单,我想学习如何做而不是要求你提供解决方案.

但是为了让你知道我有什么问题,所以你可以建议最好的教程,展示如何解决类似的问题,这是我的问题的大纲:

B = zeros(size(A));    % //A is a given matrix.
for i=1:size(A,1)
   for j=1:size(A,2)
      H = ... %// take some surrounding elements of the element at position (i,j) (i.e. using mask 3x3 elements)
      B(i,j) = computeSth(H); %// compute something on selected elements and place it in B
   end
end

所以,我不是要求解决方案.我要求一个很好的教程,在MATLAB中矢量化循环的例子.我想学习如何做,并自己做.

我在一组42000张图像上实现了一个称为TF-IDF的加权系统,每个图像包含784个像素.这基本上是42000乘784矩阵.

我尝试的第一种方法是使用显式循环并花费了超过2个小时.

def tfidf(color,img_pix,img_total):
    if img_pix==0:
        return 0
    else:
        return color * np.log(img_total/img_pix)

...

result = np.array([])
for img_vec in data_matrix:
    double_vec = zip(img_vec,img_pix_vec)
    result_row = np.array([tfidf(x[0],x[1],img_total) for x in double_vec])
    try:
        result = np.vstack((result,result_row))
    # first row will throw a ValueError since vstack accepts rows of same len
    except ValueError:
        result = result_row

我试图使用numpy矩阵的第二种方法花了不到5分钟.请注意,data_matrix,img_pix_mat都是42000 x 784矩阵,而img_total是标量.

result = data_matrix * np.log(np.divide(img_total,img_pix_mat))

我希望有人能解释速度上的巨大差异.

题为"NumPy数组:高效数值计算结构"(http://arxiv.org/pdf/1102.1523.pdf)的以下论文的作者在第4页的最上面指出,他们观察到500倍的速度提升由于矢量化计算.我假设我看到的速度增加很多是由于这个原因.但是,我想更进一步,问为什么numpy矢量化计算比标准python循环快得多？

另外,也许你们可能知道为什么第一种方法很慢的其他原因.尝试/除结构有高开销吗？或者为每个循环形成一个新的np.array需要很长时间？

谢谢.

是的我知道,关于R 中vs 的使用,有很多问题(例如参见这个问题),但我没有找到一个专门回答我问题的问题.&&&

据我了解的不同,

• &是元素方式,矢量化比较,非常类似于其他算术运算.因此,如果两个参数的长度都> 1,则返回长度> 1的逻辑向量.
• &&比较两个向量的第一元素,并始终返回长度为1的结果.此外,它的短路:cond1 && cond2 && cond3 && ...只判断cond2是否cond1是TRUE,等等.这允许类似的东西if(exists("is.R") && is.function(is.R) && is.R()),特别&&是在某些情况下严格需要使用.

而且,if发出警告

条件的长度> 1,只使用第一个元素

如果它的条件有多个元素.

从这些预赛来看,我认为在所有不需要短路的声明中,我更愿意这样&做.&&if

如果在计算过程中出现问题,我不小心在其中一个&参数中有一个向量,我会收到警告,这很好.如果没有,一切都很好.

另一方面,如果我使用了&&,并且在我的计算中出现了问题,并且其中一个&&参数是向量,我就不会收到警告.这是不好的.如果由于某种原因,我真的想比较两个向量的第一个元素,我认为明确而不是隐含地这样做更清洁.

请注意,这与R程序员之间的共同协议相反,与R docs推荐的内容相反.(1)

因此,我的问题是:除了短路之外,是否有任何理由&&可以&在if声明中表现出色？

(1)引用help(&&):

'&'和'&&'表示逻辑AND和'|' 和'||' 表示逻辑OR.较短的形式以与算术运算符大致相同的方式执行元素比较.较长的形式从左到右评估仅检查每个向量的第一个元素.评估仅在确定结果之前进行.较长的形式适用于编程控制流程,通常在"if"子句中是首选.

以下是执行相同操作的自由函数,但在第一种情况下,循环不是矢量化的,但在其他情况下它是.这是为什么？

#include <vector>

typedef std::vector<double> Vec;

void update(Vec& a, const Vec& b, double gamma) {
    const size_t K = a.size();
    for (size_t i = 0; i < K; ++i) { // not vectorized
        a[i] = b[i] * gamma - a[i];
    }
}

void update2(Vec& a, const Vec& b, double gamma) {
    for (size_t i = 0; i < a.size(); ++i) { // vectorized
        a[i] = b[i] * gamma - a[i];
    }
}

void update3(Vec& a, size_t K, const Vec& b, …

在R中给出这样的数据帧:

+---+---+
| X | Y |
+---+---+
| 1 | 2 |
| 2 | 4 |
| 4 | 5 |
+---+---+

如果对此数据帧执行矢量化操作,如下所示:

data$Z <- data$X * data$Y

这会利用处理器的单指令多数据(SIMD)功能来优化性能吗？这似乎是一个完美的案例,但我找不到任何证实我的预感的东西.

我正在寻找在SSE元素上运算的指数函数的近似值.即 - __m128 exp( __m128 x ).

我有一个快速但实际上准确度非常低的实现:

static inline __m128 FastExpSse(__m128 x)
{
    __m128 a = _mm_set1_ps(12102203.2f); // (1 << 23) / ln(2)
    __m128i b = _mm_set1_epi32(127 * (1 << 23) - 486411);
    __m128  m87 = _mm_set1_ps(-87);
    // fast exponential function, x should be in [-87, 87]
    __m128 mask = _mm_cmpge_ps(x, m87);

    __m128i tmp = _mm_add_epi32(_mm_cvtps_epi32(_mm_mul_ps(a, x)), b);
    return _mm_and_ps(_mm_castsi128_ps(tmp), mask);
}

任何人都可以以更快的速度(或更快)获得更高精度的实现吗？

如果我用C风格写的话,我会很高兴的.

谢谢.

我写了一个自定义的keras层为AttentiveLSTMCell和AttentiveLSTM(RNN)与keras'线新方法RNNs.该注意机制由Bahdanau描述,其中,在编码器/解码器模型中,从编码器的所有输出和解码器的当前隐藏状态创建"上下文"矢量.然后,我将每个时间步的上下文向量附加到输入.

该模型用于制作Dialog Agent,但与架构中的NMT模型(类似任务)非常相似.

然而,在添加这种注意机制时,我已经放慢了我的网络5倍的训练速度,我真的想知道如何编写代码的一部分,这样可以更有效地减慢它的速度.

计算的主要内容在这里完成:

h_tm1 = states[0]  # previous memory state
c_tm1 = states[1]  # previous carry state

# attention mechanism

# repeat the hidden state to the length of the sequence
_stm = K.repeat(h_tm1, self.annotation_timesteps)

# multiplty the weight matrix with the repeated (current) hidden state
_Wxstm = K.dot(_stm, self.kernel_w)

# calculate the attention probabilities
# self._uh is of shape (batch, timestep, self.units)
et = K.dot(activations.tanh(_Wxstm + self._uh), K.expand_dims(self.kernel_v))

at …

我正在编写一些AVX代码,我需要从可能未对齐的内存中加载.我目前正在加载4个双打,因此我将使用内部指令_mm256_loadu_pd ; 我写的代码是:

__m256d d1 = _mm256_loadu_pd(vInOut + i*4);

然后,我使用选项进行编译,-O3 -mavx -g然后使用objdump获取汇编代码以及带注释的代码和line(objdump -S -M intel -l avx.obj).
当我查看底层汇编程序代码时,我发现以下内容:

vmovupd xmm0,XMMWORD PTR [rsi+rax*1]
vinsertf128 ymm0,ymm0,XMMWORD PTR [rsi+rax*1+0x10],0x1

我期待看到这个:

vmovupd ymm0,XMMWORD PTR [rsi+rax*1]

并充分利用256位寄存器(YMM0),而不是它看起来像海湾合作委员会已决定在128位部分(填写XMM0),然后再次加载另一半vinsertf128.

有人能够解释这个吗？在MSVC VS 2012中
使用单个vmovupd编译等效代码.

我运行gcc (Ubuntu 7.3.0-27ubuntu1~18.04) 7.3.0在Ubuntu的18.04 X86-64.