Geem算子

生活需要深度

已于 2024-07-28 14:26:04 修改

阅读量407

点赞数 4

文章标签：人工智能

于 2024-07-28 10:39:24 首次发布

本文链接：https://blog.csdn.net/u012294613/article/details/140747503

版权

AI 专栏收录该内容

118 篇文章 8 订阅

订阅专栏

GEEM（General Matrix Multiply）卷积计算是一种常用的卷积神经网络（CNN）中的计算方法。在卷积神经网络中，卷积操作是一种重要的特征提取方法，而GEMM卷积算法则是用于加速卷积计算的一种优化方法。具体来说，GEMM卷积算法将卷积操作中的卷积核展开为一个举证，将输入特征图展开为一个举证，然后利用举证乘法的性质来进行计算，最后将计算结果从新组合成输出特征图。这种方法能够充分利用矩阵乘法的并行性，从而加速卷积计算过程。

在计算机科学领域，矩阵乘法是一项重要的运算。它不仅广泛应用于科学计算、图像处理和机器学习等领域，还作为其他复杂算法的基础。而在矩阵乘法中，GEMM（General Matrix Multiply）则是一个备受关注的算法。本文将带您深入理解矩阵乘法，并探索GEMM算法的奥秘。

首先，让我们来了解一下矩阵乘法的基本原理。矩阵乘法是指将两个矩阵相乘，得到一个新的矩阵。在矩阵乘法中，两个矩阵的维度必须满足一定的条件，具体来说，第一个矩阵的列数必须等于第二个矩阵的行数。通过遍历两个矩阵的元素，按照一定规则进行相乘和相加运算，可以得到结果矩阵的每个元素。

然而，普通的矩阵乘法算法并不高效。当涉及到大规模矩阵乘法运算时，计算时间会呈现指数级增长，给计算机带来很大的负担。因此，人们不断探索优化矩阵乘法算法的方法。

其中，GEMM算法就是一种被广泛采用的优化算法。GEMM算法通过将矩阵乘法分解为多个小规模的矩阵乘法运算，并使用一定的技巧来减少冗余计算，从而提高运算效率。这种分解和优化的思想在实际应用中取得了显著的成果。

GEMM算法的具体实现有多种方法，如基于循环的方法、基于分块的方法和基于并行计算的方法等。每种方法都有其独特的特点和适用场景。例如，基于循环的方法通过嵌套循环遍历矩阵元素，逐个进行相乘和相加运算。这种方法简单可靠，适用于小规模矩阵乘法运算。

而基于分块的方法则将大规模的矩阵划分为多个小块，分别进行矩阵乘法运算，并通过合并和重组结果来得到最终的结果矩阵。这种方法可以充分利用计算机的缓存系统，减少数据读写的开销，从而提高运算效率。

此外，基于并行计算的方法在多核处理器和GPU等平台上发挥着重要作用。通过将矩阵乘法拆分成多个子任务，并分配给不同的计算单元并行处理，可以充分发挥硬件设备的计算能力，加快运算速度。

GEMM算法的进一步优化还有很多挑战和方向。例如，如何针对不同的硬件平台和架构设计高效的GEMM算法、如何利用近似计算技术降低计算量等等。这些问题都是当前研究的热点。

总之，矩阵乘法是计算机科学中一项重要的运算，而GEMM算法则是优化矩阵乘法的关键所在。通过深入理解矩阵乘法，我们可以更好地把握GEMM算法的原理和应用。相信随着科技的不断发展，矩阵乘法及其相关算法将会在更多领域展现出强大的潜力和应用价值。

im2col和gemm实现卷积运算的性能分析

在这篇文章中提到使用 darknet 使用了 im2col 和 gemm 函数实现在 cpu 上对卷积运算的加速。那实际上是否真的起到了加速效果呢，本文就做了下测试。

将 im2col 和 gemm 的代码摘出来，然后再实现一个常规思路的卷积计算操作，接着生成指定大小的输入特征和卷积核对比两者的耗时。

gemm代码的疑似bug

在 vs2017 的环境是运行从 darknet 中拷贝出来的 gemm 代码时总会报越界访问。后来发现是原有的 darknet 代码存在 bug ，也可能是在 vs2017 环境下才出现。我们先看看 gemm 核心代码。

void gemm_nn(int M, int N, int K, float ALPHA, 
        float *A, int lda, 
        float *B, int ldb,
        float *C, int ldc)
{
    int i,j,k;
    #pragma omp parallel for
    for(i = 0; i < M; ++i){
        for(k = 0; k < K; ++k){
            register float A_PART = ALPHA*A[i*lda+k];
            for(j = 0; j < N; ++j){
                C[i*ldc+j] += A_PART*B[k*ldb+j];
            }
        }
    }
}

这里使用了 #pragma omp parallel for，他的意思是下面的这个外层循环中的内容会以多线程的方式运行。

for(i = 0; i < M; ++i){//}

也就是会以多线程的方式执行

for(k = 0; k < K; ++k){
    register float A_PART = ALPHA*A[i*lda+k];
    for(j = 0; j < N; ++j){
        C[i*ldc+j] += A_PART*B[k*ldb+j];
     }
}

这代码哪里有问题呢？在进行多线程的编程时一般都需要对多个线性都可以访问的变量进行读写保护，那这段代码中内存循环的索引 k 和 j 都定义在外部，也就是每个线程在执行循环语句时，使用了同一个变量 k 和 j。这就几乎一定会导致循环的索引越界。了解这点后将 k 和 j 在内部进行定义即可正常运行。

void gemm_nn(int M, int N, int K, float ALPHA, 
        float *A, int lda, 
        float *B, int ldb,
        float *C, int ldc)
{
    int i;
    #pragma omp parallel for
    for(i = 0; i < M; ++i){
        int k
        for(k = 0; k < K; ++k){
            register float A_PART = ALPHA*A[i*lda+k];
            int j;
            for(j = 0; j < N; ++j){
                C[i*ldc+j] += A_PART*B[k*ldb+j];
            }
        }
    }
}

卷积运算时间对比

设计一个

输入特征满足 W=200、H=200、C=1，并使用[0，255]来依次初始化。
卷积核有20个，卷积核满足W=7、H=7、C=1，并使用[0，255]来依次初始化。
pading设为3，stride设为1。

常规卷积思路是卷积核在输入特征上滑动，具体实现如下

 for (int f_i=0; f_i < kernel_num; f_i++)
    {
        for (int i = 0; i < n; i++)
        {
            int i_x = i / output_w % output_h;
            int i_y = i % output_w;

            i_x = i_x * kernel_stride - kernel_pad;
            i_y = i_y * kernel_stride - kernel_pad;

            float result = .0;
            for (int j = 0; j < k; j++)
            {
                int k_x = j / kernel_size % kernel_size;
                int k_y = j % kernel_size;

                int x = i_x + k_x;
                int y = i_y + k_y;

                if (x < 0 || y < 0 || x >= input_h || y >= input_w)
                {
                    continue;
                }
                result += a[f_i * k + j] * im[x * input_h + y];
            }
            c[f_i * n + i] = result;
        }
    }

对比结果如下