webassembly003 ggml GGML Tensor Library part-4 矩阵乘法的实现

最新推荐文章于 2025-12-03 10:20:14 发布
原创 最新推荐文章于 2025-12-03 10:20:14 发布 · 503 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#矩阵 #算法 #线性代数

简化代码

  • 代码中ggml_tensor比较重要的三个属性为：
  • 原始数据 ： void * data
  • 维度向量 ： ne[20] ：.ne = {3, 2, 1, 1}, 表示一个3列 2 行的矩阵
  • 步长向量 ： nb[20]：
    .nb = {sizeof(float), sizeof(float) * 3,0, 0}, 因为数据被统一转换为了void指针，任何Tensor的数据都是一个void*的一维数组，只是长度不同。所以设置各维度字节步长，对于区分每个数的具体位置十分重要。
  • 代码通过不断执行ggml_vec_dot_f32，将从乘数得到的两个向量片段点积，然后通过维度和步长将结果放到结果的data数据正确的位置上。
#include <stdio.h>
#include <stdlib.h> // malloc
#include <cstdint> // int64_t
#include <cassert> // assert

#define restrict
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

enum ggml_type { GGML_TYPE_F32     = 0, GGML_TYPE_F16     = 1,  GGML_TYPE_COUNT,};
enum ggml_op   { GGML_OP_NONE      = 0, GGML_MAX_OP_PARAMS};
enum ggml_task_type {GGML_TASK_INIT ,GGML_TASK_COMP ,GGML_TASK_FINALIZE };

struct ggml_compute_params {
    enum ggml_task_type type;
};


// n-dimensional tensor
struct ggml_tensor {
    enum ggml_type type;
    int64_t ne[20]; // int64_t ne[GGML_MAX_DIMS]; // number of elements
    size_t  nb[20]; // size_t  nb[GGML_MAX_DIMS]; // stride in bytes
    void * data;
};


inline static void ggml_vec_dot_f32(const int n, float * restrict s, const float * restrict x, const float * restrict y) {
    float sumf = 0.0;// ggml_float sumf = 0.0;
    for (int i = 0; i < n; ++i) {// n是向量长度
        sumf += x[i]*y[i];
    }
    printf("%.9f \n", sumf);
    *s = sumf;
}



void ggml_compute_forward_mul_mat_f32(
        const struct ggml_compute_params * params,
        const struct ggml_tensor * src0,
        const struct ggml_tensor * src1,
              struct ggml_tensor * dst) {
    // int64_t t0 = ggml_perf_time_us();
    // UNUSED(t0);

    // 分别获取源张量src0在四个维度上的元素数量（ne代表number of elements，即元素个数维度相关的属性），后续用于维度相关的判断和计算
    const int ne00 = src0->ne[0];
    const int ne01 = src0->ne[1];
    const int ne02 = src0->ne[2];
    const int ne03 = src0->ne[3];
    // 同样，获取另一个源张量src1在四个维度上的元素数量，用于后续的处理和维度检查等操作
    const int ne10 = src1->ne[0];
    const int ne11 = src1->ne[1];
    const int ne12 = src1->ne[2];
    const int ne13 = src1->ne[3];
    // 获取目标张量dst在四个维度上的元素数量，并计算出dst张量总的元素数量，方便后续整体的计算或者遍历等操作
    const int ne0  = dst->ne[0];
    const int ne1  = dst->ne[1];
    const int ne2  = dst->ne[2];
    const int ne3  = dst->ne[3];
    const int ne   = ne0*ne1*ne2*ne3;
    // 获取源张量src0在四个维度上每个元素“步长”所占字节数（nb可能代表number of bytes，字节数维度相关属性）
    const int nb00 = src0->nb[0];
    const int nb01 = src0->nb[1];
    const int nb02 = src0->nb[2];
    const int nb03 = src0->nb[3];
    // 获取源张量src1在四个维度上每个元素“步长”所占字节数
    const int nb10 = src1->nb[0];
    const int nb11 = src1->nb[1];
    const int nb12 = src1->nb[2];
    const int nb13 = src1->nb[3];
    // 获取目标张量dst在四个维度上每个元素“步长”所占字节数
    const int nb0  = dst->nb[0];
    const int nb1  = dst->nb[1];
    const int nb2  = dst->nb[2];
    const int nb3  = dst->nb[3];

    assert(ne02 == ne12);
    assert(ne03 == ne13);
    assert(ne2  == ne12);
    assert(ne3  == ne13);

    // TODO: we don't support permuted src0
    assert(nb00 == sizeof(float) || nb01 == sizeof(float));

    // dst cannot be transposed or permuted
    assert(nb0 == sizeof(float));
    assert(nb0 <= nb1);
    assert(nb1 <= nb2);
    assert(nb2 <= nb3);

    assert(ne0 == ne01);
    assert(ne1 == ne11);
    assert(ne2 == ne02);
    assert(ne3 == ne03);


    #if defined(GGML_USE_ACCELERATE) || defined(GGML_USE_OPENBLAS)
    #endif

    if (nb01 >= nb00) {// 当src0张量是未转置情况（nb01 >= nb00） 
    
        assert(nb10 == sizeof(float));
        // total rows in src0  src0(第一个乘数张量)总的行数（nr）
        const int nr = ne01*ne02*ne03;

        const int ir0 = 0;
        const int ir1 = nr;

        for (int ir = ir0; ir < ir1; ++ir) {
            // src0 indices
            const int i03 = ir/(ne02*ne01);// 第三维度（最后一个维度）上的索引
            const int i02 = (ir - i03*ne02*ne01)/ne01; // 第二维度上的索引
            const int i01 = (ir - i03*ne02*ne01 - i02*ne01); // 第一维度上的索引

            for (int ic = 0; ic < ne11; ++ic) { // ne11第二个乘数张量的第一维度，一共需要计算ir1*ne11个向量乘法
                // src1 indices
                const int i13 = i03;
                const int i12 = i02;
                const int i11 = ic;

                // dst indices
                const int i0 = i01;
                const int i1 = i11;
                const int i2 = i02;
                const int i3 = i03;
                
                printf("%d,%d : ",i0,i1);
                ggml_vec_dot_f32(ne00,
                        (float *) ((char *)  dst->data + (i0*nb0 + i1*nb1 + i2*nb2 + i3*nb3)), 
                        (float *) ((char *) src0->data + (i01*nb01 + i02*nb02 + i03*nb03)),
                        (float *) ((char *) src1->data + (i11*nb11 + i12*nb12 + i13*nb13)));
            }
        }
    } else {
        // TODO: do not support transposed src1
    }

}

/*                 
1.5, 1.0, 1.0,         1.0  1.0     5.5  4.5
0.0, 1.0, 1.0,   *     2.0  1.0  =  4.0  3.0
0.0, 1.0, 1.0,         2.0  2.0     4.0  3.0
                 
*/

int main() {
    // Data points as mentioned in the comment
    float x[] = {1.5, 1.0, 1.0, 
                 0.0, 1.0,1.0, 
                 0.0, 1.0,1.0, }; // 3*3矩阵
                 
    float y[] = {1.0, 2.0, 2.0, 
                 1.0, 1.0,2.0, }; // 3*2矩阵的转置
    float res[6]; // 3*2矩阵

    // 设置src0张量的属性
    ggml_tensor src0 = (struct ggml_tensor) {
      .type = GGML_TYPE_F32,
      .ne = {3, 3, 1, 1},
      .nb = {sizeof(float), sizeof(float) * 3, 0, 0},  // 正确设置各维度字节步长
      .data = (void *)x,
    };

    // 设置src1张量的属性
    ggml_tensor src1 = (struct ggml_tensor) {
      .type = GGML_TYPE_F32,
      .ne = {3, 2, 1, 1}, // 3列 2 行
      .nb = {sizeof(float), sizeof(float) * 3,0, 0},  // 设置各维度字节步长
      .data = (void *)y,
    };

    // 设置result张量的属性，将结果存储位置指向res数组
    ggml_tensor result = (struct ggml_tensor) {
      .type = GGML_TYPE_F32,
      .ne = {3, 2, 1, 1},
      .nb = {sizeof(float), sizeof(float) * 3, sizeof(float) * 6, sizeof(float) * 6},  // 设置各维度字节步长
      .data = (void *)res,
    };

    struct ggml_compute_params params = {
      .type = GGML_TASK_COMP,
    };
    ggml_compute_forward_mul_mat_f32(&params, &src0, &src1, &result);  // 调用函数进行矩阵乘法计算

    
    // 输出结果验证
    for (int i = 0; i < sizeof(res)/sizeof(float); ++i) {
        printf("%.9f ", res[i]);
    }
    printf("\n");

    return 0;
}

接近原版的单个可执行项目：

#include <stdio.h>
#include <stdlib.h> // malloc
#include <cstdint> // int64_t
#include <cassert> // assert
#include <string.h> // memset 内存块设置值

#define restrict
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

enum ggml_type { GGML_TYPE_F32     = 0, GGML_TYPE_F16     = 1,  GGML_TYPE_COUNT,};
enum ggml_op   { GGML_OP_NONE      = 0, GGML_MAX_OP_PARAMS};
enum ggml_task_type {GGML_TASK_INIT ,GGML_TASK_COMP,GGML_TASK_FINALIZE };

struct ggml_compute_params {
    enum ggml_task_type type;
    int ith, nth;
    // work buffer for all threads
    size_t wsize;
    void * wdata;
};


// n-dimensional tensor
struct ggml_tensor {
    enum ggml_type type;
    // GGML_DEPRECATED(enum ggml_backend_type backend, "use the buffer type to find the storage location of the tensor");

    struct ggml_backend_buffer * buffer;

    int64_t ne[20]; // int64_t ne[GGML_MAX_DIMS]; // number of elements
    size_t  nb[20]; // size_t  nb[GGML_MAX_DIMS]; // stride in bytes:
                                // nb[0] = ggml_type_size(type)
                                // nb[1] = nb[0]   * (ne[0] / ggml_blck_size(type)) + padding
                                // nb[i] = nb[i-1] * ne[i-1]

    // compute data
    enum ggml_op op;

    // op params - allocated as int32_t for alignment
    int32_t op_params[GGML_MAX_OP_PARAMS / sizeof(int32_t)];

    int32_t flags;

    struct ggml_tensor * src[3]; // src[GGML_MAX_SRC];

    // source tensor and offset for views
    struct ggml_tensor * view_src;
    size_t               view_offs;

    void * data;

    char name[3]; // name[GGML_MAX_NAME];

    void * extra; // extra things e.g. for ggml-cuda.cu

    char padding[8];
};



inline static void ggml_vec_add_f32 (const int n, float * z, const float * x, const float * y) { for (int i = 0; i < n; ++i) z[i]  = x[i] + y[i]; }
inline static void ggml_vec_acc_f32 (const int n, float * y, const float * x)                  { for (int i = 0; i < n; ++i) y[i] += x[i];        }
inline static void ggml_vec_acc1_f32(const int n, float * y, const float   v)                  { for (int i = 0; i < n; ++i) y[i] += v;           }
inline static void ggml_vec_sub_f32 (const int n, float * z, const float * x, const float * y) { for (int i = 0; i < n; ++i) z[i]  = x[i] - y[i]; }
inline static void ggml_vec_set_f32 (const int n, float * x, const float   v)                  { for (int i = 0; i < n; ++i) x[i]  = v;           }
inline static void ggml_vec_cpy_f32 (const int n, float * y, const float * x)                  { for (int i = 0; i < n; ++i) y[i]  = x[i];        }
inline static void ggml_vec_neg_f32 (const int n, float * y, const float * x)                  { for (int i = 0; i < n; ++i) y[i]  = -x[i];       }
inline static void ggml_vec_mul_f32 (const int n, float * z, const float * x, const float * y) { for (int i = 0; i < n; ++i) z[i]  = x[i]*y[i];   }
inline static void ggml_vec_div_f32 (const int n, float * z, const float * x, const float * y) { for (int i = 0; i < n; ++i) z[i]  = x[i]/y[i];   }

inline static void ggml_vec_relu_f32 (const int n, float * y, const float * x) { for (int i = 0; i < n; ++i) y[i] = (x[i] > 0.f) ? x[i] : 0.f; }

inline static void ggml_vec_dot_f32(const int n, float * restrict s, const float * restrict x, const float * restrict y) {
    float sumf = 0.0;// ggml_float sumf = 0.0;
    #ifdef __ARM_NEON
    #elif defined(__AVX2__)
    #elif defined(__AVX__)
    #elif defined(__wasm_simd128__)
    #else
    // scalar
    for (int i = 0; i < n; ++i) {// n是向量长度
        sumf += x[i]*y[i];
    }
    #endif

    *s = sumf;
}



void ggml_compute_forward_mul_mat_f32(
        const struct ggml_compute_params * params,
        const struct ggml_tensor * src0,
        const struct ggml_tensor * src1,
              struct ggml_tensor * dst) {
    // int64_t t0 = ggml_perf_time_us();
    // UNUSED(t0);

    // 分别获取源张量src0在四个维度上的元素数量（ne代表number of elements，即元素个数维度相关的属性），后续用于维度相关的判断和计算
    const int ne00 = src0->ne[0];
    const int ne01 = src0->ne[1];
    const int ne02 = src0->ne[2];
    const int ne03 = src0->ne[3];
    // 同样，获取另一个源张量src1在四个维度上的元素数量，用于后续的处理和维度检查等操作
    const int ne10 = src1->ne[0];
    const int ne11 = src1->ne[1];
    const int ne12 = src1->ne[2];
    const int ne13 = src1->ne[3];
    // 获取目标张量dst在四个维度上的元素数量，并计算出dst张量总的元素数量，方便后续整体的计算或者遍历等操作
    const int ne0  = dst->ne[0];
    const int ne1  = dst->ne[1];
    const int ne2  = dst->ne[2];
    const int ne3  = dst->ne[3];
    const int ne   = ne0*ne1*ne2*ne3;
    // 获取源张量src0在四个维度上每个元素“步长”所占字节数（nb可能代表number of bytes，字节数维度相关属性）
    const int nb00 = src0->nb[0];
    const int nb01 = src0->nb[1];
    const int nb02 = src0->nb[2];
    const int nb03 = src0->nb[3];
    // 获取源张量src1在四个维度上每个元素“步长”所占字节数
    const int nb10 = src1->nb[0];
    const int nb11 = src1->nb[1];
    const int nb12 = src1->nb[2];
    const int nb13 = src1->nb[3];
    // 获取目标张量dst在四个维度上每个元素“步长”所占字节数
    const int nb0  = dst->nb[0];
    const int nb1  = dst->nb[1];
    const int nb2  = dst->nb[2];
    const int nb3  = dst->nb[3];
    // 从传入的计算参数结构体中获取当前线程索引（ith）和总的线程数量（nth），可能用于多线程相关的计算划分等情况
    const int ith = params->ith;
    const int nth = params->nth;

    assert(ne02 == ne12);
    assert(ne03 == ne13);
    assert(ne2  == ne12);
    assert(ne3  == ne13);

    // TODO: we don't support permuted src0
    assert(nb00 == sizeof(float) || nb01 == sizeof(float));

    // dst cannot be transposed or permuted
    assert(nb0 == sizeof(float));
    assert(nb0 <= nb1);
    assert(nb1 <= nb2);
    assert(nb2 <= nb3);

    assert(ne0 == ne01);
    assert(ne1 == ne11);
    assert(ne2 == ne02);
    assert(ne3 == ne03);

    // nb01 >= nb00 - src0 is not transposed
    //   compute by src0 rows
    //
    // nb00 <  nb01 - src0 is transposed
    //   compute by src0 columns

    #if defined(GGML_USE_ACCELERATE) || defined(GGML_USE_OPENBLAS)
    #endif
   
    
    if (params->type == GGML_TASK_INIT) {
        if (nb01 >= nb00) {
            return; // 当传入的计算参数类型为GGML_TASK_INIT时，如果src0张量按前面规则判断为未转置（nb01 >= nb00），则直接返回不做其他操作。
        }

        // TODO: fix this memset (wsize is overestimated)
        memset(params->wdata, 0, params->wsize);// 若src0是转置情况（nb01 < nb00），则使用memset将参数中的工作数据区域（wdata）清零（wsize可能被高估了，此内存设置操作可能存在优化空间）
        return;
    }

    if (params->type == GGML_TASK_FINALIZE) {
        if (nb01 >= nb00) {
            return;// 当传入的计算参数类型为GGML_TASK_FINALIZE时，如果src0张量是未转置情况（nb01 >= nb00）直接返回。
        }

        // TODO: fix this memset (wsize is overestimated)
        //assert(params->wsize == (ggml_nbytes(dst) + CACHE_LINE_SIZE)*nth);

        float * const wdata = (float *)params->wdata; // params->wdata; 对于src0转置情况（nb01 < nb00），获取工作数据指针（wdata）

        // cols per thread
        const int dc = (ne + nth - 1)/nth; // 计算每个线程负责的列数（dc）以及本线程负责的列范围（ic0到ic1）

        // col range for this thread
        const int ic0 = dc*ith;
        const int ic1 = MIN(ic0 + dc, ne);

        ggml_vec_cpy_f32(ic1 - ic0, (float *) dst->data + ic0, wdata + ic0);// 将目标张量dst对应本线程负责的列范围的数据复制到工作数据区域（wdata）

        for (int k = 1; k < nth; k++) {
            // 循环调用ggml_vec_acc_f32函数，将其他线程对应的工作数据累加到本线程负责的目标张量区域，最后返回
            ggml_vec_acc_f32(ic1 - ic0, (float *) dst->data + ic0, wdata + (ne + 16)*k + ic0); // CACHE_LINE_SIZE_F32 = 16
        }

        return;
    }

    if (nb01 >= nb00) {// 当src0张量是未转置情况（nb01 >= nb00） 
        // TODO: do not support transposed src1
        assert(nb10 == sizeof(float));// 4 bytes 检查src1在某个维度上元素所占字节数符合单精度浮点数大小要求

        // parallelize by src0 rows using ggml_vec_dot_f32

        // total rows in src0  src0总的行数（nr）
        const int nr = ne01*ne02*ne03;

        // rows per thread 每个线程负责的行数（dr）
        const int dr = (nr + nth - 1)/nth;

        // row range for this thread  本线程负责的行范围（ir0到ir1）
        const int ir0 = dr*ith;
        const int ir1 = MIN(ir0 + dr, nr);

        for (int ir = ir0; ir < ir1; ++ir) {
            // src0 indices
            const int i03 = ir/(ne02*ne01);
            const int i02 = (ir - i03*ne02*ne01)/ne01;
            const int i01 = (ir - i03*ne02*ne01 - i02*ne01);

            for (int ic = 0; ic < ne11; ++ic) {
                // src1 indices
                const int i13 = i03;
                const int i12 = i02;
                const int i11 = ic;

                // dst indices
                const int i0 = i01;
                const int i1 = i11;
                const int i2 = i02;
                const int i3 = i03;

                ggml_vec_dot_f32(ne00,
                        (float *) ((char *)  dst->data + (i0*nb0 + i1*nb1 + i2*nb2 + i3*nb3)),
                        (float *) ((char *) src0->data + (i01*nb01 + i02*nb02 + i03*nb03)),
                        (float *) ((char *) src1->data + (i11*nb11 + i12*nb12 + i13*nb13)));
            }
        }
    } else {

    }

    //int64_t t1 = ggml_perf_time_us();
    //static int64_t acc = 0;
    //acc += t1 - t0;
    //if (t1 - t0 > 10) {
    //    printf("\n");
    //    printf("ne00 = %5d, ne01 = %5d, ne02 = %5d, ne03 = %5d\n", ne00, ne01, ne02, ne03);
    //    printf("nb00 = %5d, nb01 = %5d, nb02 = %5d, nb03 = %5d\n", nb00, nb01, nb02, nb03);
    //    printf("ne10 = %5d, ne11 = %5d, ne12 = %5d, ne13 = %5d\n", ne10, ne11, ne12, ne13);
    //    printf("nb10 = %5d, nb11 = %5d, nb12 = %5d, nb13 = %5d\n", nb10, nb11, nb12, nb13);

    //    printf("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX task %d/%d: %d us, acc = %d\n", ith, nth, (int) (t1 - t0), (int) acc);
    //}
}

//       struct ggml_init_params params = {
//           .mem_size   = 16*1024*1024,
//           .mem_buffer = NULL,
//       };
//
//       // memory allocation happens here
//       struct ggml_context * ctx = ggml_init(params);
//
//       struct ggml_tensor * x = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);
//
//       ggml_set_param(ctx, x); // x is an input variable

//       struct ggml_tensor * a  = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);
//       struct ggml_tensor * b  = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 1);
//       struct ggml_tensor * x2 = ggml_mul(ctx, x, x);

int main() {
    // Data points as mentioned in the comment
    float x[] = {1, 0, 0, 1}; // 2*2矩阵
    float y[] = {1, 2, 1, 1}; // 2*2矩阵
    float res[4]; // 2*2矩阵

   // 设置src0张量的属性
    ggml_tensor src0 = (struct ggml_tensor) {
      .type = GGML_TYPE_F32,
      .ne = {2, 2, 1, 1},
      .nb = {sizeof(float), sizeof(float) * 2, 0, 0},  // 正确设置各维度字节步长
      .data = (void *)x,
    };

    // 设置src1张量的属性
    ggml_tensor src1 = (struct ggml_tensor) {
      .type = GGML_TYPE_F32,
      .ne = {2, 2, 1, 1},
      .nb = {sizeof(float), sizeof(float) * 2, 0, 0},  // 正确设置各维度字节步长
      .data = (void *)y,
    };

    // 设置result张量的属性，将结果存储位置指向res数组
    ggml_tensor result = (struct ggml_tensor) {
      .type = GGML_TYPE_F32,
      .ne = {2, 2, 1, 1},
      .nb = {sizeof(float), sizeof(float) * 2, sizeof(float) * 2, sizeof(float) * 2},  // 正确设置各维度字节步长
      .data = (void *)res,
    };

    // 合理初始化计算参数结构体，根据涉及的数据量等情况设置工作缓冲区大小等参数
    size_t work_buffer_size = sizeof(float) * 4;  // 根据实际运算情况预估一个合适的工作缓冲区大小，这里简单按结果矩阵元素个数 * 单元素字节数设置
    void *work_buffer = malloc(work_buffer_size);
    if (!work_buffer) {
        perror("malloc failed");
        return -1;
    }

    struct ggml_compute_params params = {
      .type = GGML_TASK_COMP,
      .ith = 0,
      .nth = 1,
      .wsize = work_buffer_size,
      .wdata = work_buffer
    };
    ggml_compute_forward_mul_mat_f32(&params, &src0, &src1, &result);  // 调用函数进行矩阵乘法计算

    // // 切换计算参数类型为GGML_TASK_FINALIZE并再次调用函数完成最终的结果整合等操作
    // params.type = GGML_TASK_FINALIZE;
    // ggml_compute_forward_mul_mat_f32(&params, &src0, &src1, &result);

    // 输出结果验证
    for (int i = 0; i < 4; ++i) {
        printf("%.0f ", res[i]);
    }
    printf("\n");

    free(work_buffer);  // 释放工作缓冲区内存

    return 0;
}
vllm中tensor-parallel-size和pipeline-parallel-size区别
11-09 5595
在 vLLM 中，和是用于配置模型并行化的两个关键参数，分别用于（Tensor Parallelism）和（Pipeline Parallelism），帮助在多个 GPU 上分配计算任务。
tensor core int8矩阵乘法
wangyuehy的博客
01-14 2905
最近在研究tensor core 加速，文档中提到在turing 架构之后，tensor core 就支持了int8 的矩阵运算，但是网上文档相对较少，收集了几个文档备查。 第一个链接是NV 官方关于tensor core 的介绍，重点讲了几个问题，输入大小限制，带宽限制。 输入限制，要求输入是8/16/64/128的整数倍，例如 linear batchsize 应该是8(fp16)/16(int8)的倍数 conv, channel 是 8(fp16)/16(int8)的倍数 gemm, 维度是6
探索未来AI的基石：ggml，一个轻量级机器学习 tensor 库
gitblog_00059的博客
06-23 989
探索未来AI的基石：ggml，一个轻量级机器学习 tensor 库 在浩瀚的人工智能领域中，寻找高效、灵活且易于集成的底层技术库是开发者的不懈追求。今天，我们聚焦于一个新兴的、充满潜力的项目——ggml，这是一颗正在崛起的技术新星，旨在为机器学习研究与应用提供强大而简洁的解决方案。 项目介绍 ggml，全称为 Tensor Library for Machine Learning，是一个专为机器学...
webassembly003 GGML Tensor Library part-1
ResumeProject的博客
08-27 1244
ggml.h。
GGML源码逐行调试（上）
周同学的博客
04-12 2379
GGML源码逐行调试（上）
webassembly003 ggml GGML Tensor Library part-2 官方使用说明
ResumeProject的博客
08-27 1576
if (!// 函数会递归地遍历节点的src0、src1和opt数组中的节点，并将它们添加到计算图中。这样可以确保所有的父节点都会被添加到计算图中。最后，函数会根据节点的op和grad属性来判断节点的类型。如果op为GGML_OP_NONE且grad为NULL，则说明该节点是一个叶子节点，不是梯度图的一部分（例如常量节点）。此时，函数会将该节点添加到计算图的leafs数组中。
ggml库文档说明docs
记录与分享
09-14 623
偶然点开ggml.h，发现刚开头有一些注释，属于是非常详细的参考了。故将翻译后的文档和英语原文放上来，供学习llama.cpp和ggml库的朋友们参考。
精选资源
matlab实现矩阵乘法代码-tensor-factorization:通过矩阵分解进行张量分解
05-23
matlab实现矩阵乘法代码通过矩阵分解进行张量分解 张量分解是使用矩量法学习潜变量模型的几种最新算法中的关键子程序。 此通用技术适用于多种类型的模型，例如： 高斯混合 主题模型（例如潜在的Dirichlet分配） 隐藏...
精选资源
ggml-tiny.bin 是 Whisper 语音识别模型的一个轻量级版本 ，用于语音识别
04-18
GGML 是一个专注于 CPU 推理的 tensor 库，支持量化（如 4-bit、5-bit 等），显著减少模型体积和内存占用。 2. ggml-tiny.bin 特点 轻量化：tiny 是 Whisper 的最小版本，参数量少（约 39M），适合低算力设备（如...
tensor的mode-n展开和mode-n乘积
GodNotAMen的博客
08-16 5724
介绍tensor的mode-n展开和mode-n乘积
ML之ggml：ggml框架(专注Transformer推理的机器学习库)的简介、安装和使用方法、案例应用之详细攻略
头部AI社区如有邀博主AI主题演讲请私信—心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，专注，谦虚，自律，反思，成长，还算比较正能量的博主，公益免费传播…内心特别想在AI界做出一些可以推进历史进程影响力的技术(兴趣使然，有点小情怀，也有点使命感呀
08-23 3901
​ ML之ggml：ggml框架(专注Transformer推理的机器学习库)的简介、安装和使用方法、案例应用之详细攻略 目录 ggml的简介 ggml的安装和使用方法 ggml的案例应用 ggml的简介 2024年8月发布，ggml 是一个用 C 和 C++ 编写的机器学习库，专注于 Transformer 推理。它是一个开源项目，由一个不断壮大的社区积极开发。ggml 与 PyTorch 和 TensorFlow 等 ML 库类似，但仍处于开发初期，一些基本原理仍在快速变化。
C++ YOLOv3推理 第二讲: 权重及参数加载
qq_19859865的博客
12-30 758
模型参数的记载到此基本讲完，读取的这些参数的作用，只有结合具体的推理，才能更好的理解诶，这也是下一章的目标。另外，gguf的参数加载细节在这里也没有介绍，这也是应该后面详细说明的。
typedef void (*Fun) (void) 的理解——typedef函数指针
年年年的博客
11-10 2252
首先，定义函数指针的两个基本形式 形式1：返回类型(*函数名)(参数表) 请看下面一个例子： #include <iostream> using namespace std; //定义一个函数指针pFUN，它指向一个返回类型为char，有一个整型的参数的函数 char (*pFun)(int); //定义一个返回类型为char，参数为int的函数 //从指针层面上理解该函数，即函数的函数名实际上是一个指针， //该指针指向函数在内存中的首地址 char glFun(int a) {
基于C++实现（控制台）应用二维矩阵完成矩阵运算
神仙别闹的自留地
12-01 687
目的是通过课程设计的综合训练，培养学生实际分析问题、解决问题的能力，以及编程和动手能力，最终目标是通过课程设计这种形式，帮助学生系统掌握C这门课程的主要内容，养成良好的编程习惯，更好的完成教学任务。通过本次实验，我更加理解了计算机的思维，如果要实现一个程序的编写的编写就要清清楚楚知道整个程序的流程，如果不清楚程序的流程是很难顺利流畅的编写出程序来，就例如本次实验中的计算矩阵的乘法，如果只是会死记硬背笔算，其实很难实现出程序来。设计思路：使用一个二维矩阵来存储结果，然后使用双重循环结构进行对应元素的相加。
A.每日一题——2435. 矩阵中和能被 K 整除的路径
要努力去发光，而不是被照亮~
12-02 320
A.每日一题——2435. 矩阵中和能被 K 整除的路径解析
word中latex插入矩阵的语法问题
Carlos5en的博客
12-02 263
word中latex插入矩阵的语法问题
线性代数及其应用习题答案(中文版)第一章 线性代数中的线性方程组 1.4 矩阵方程Ax=b(1)
simon_skywalker的博客
11-29 985
矩阵方程Ax = b(1)
从矩阵相关到矩阵回归：曼特尔检验与 MRQAP
lazysnake666的博客
11-29 1015
后来，社会网络和心理测量领域的人在做“矩阵相关 / 矩阵回归 + 节点重排（permutation）”的时候，发现本质上也是在做一种“对节点标签做指派（重排），然后看某个二次统计量怎么变”的过程，就把这种。Mantel还会经常出现在这一类图中，皮尔逊相关展示变量之间的关系，Mantel相关计算矩阵之间的相关，在生态学、生信的分析中运用较多，神经影像中的运用场景并不是很多。下同时考虑多个关系矩阵的作用，并在控制协变量（covariates）的前提下，评估某一关系矩阵对目标关系的独立贡献。
W_q,W_k,W_v矩阵是怎么确定的？
最新发布
Goals1989的博客
12-03 694
摘要：Transformer模型中的W_q、W_k、W_v矩阵是注意力机制的核心可学习参数，通过数据驱动的反向传播优化确定。其本质作用是将输入映射到查询、键、值空间进行特征提取。确定流程包括随机初始化（如Xavier）、训练优化（前向传播计算损失，反向传播更新参数）和最终收敛。这些参数受数据质量、模型结构（如多头注意力）、训练超参数和任务目标影响。人工无法设定这些参数因其需要捕捉复杂的语义特征，而端到端学习能自动发现深层规律并实现泛化。最终确定的参数矩阵编码了输入数据的语义映射关系。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值