webassembly003 ggml GGML Tensor Library part-4 实现在浏览器端训练神经网络

已于 2023-08-27 21:32:38 修改
阅读量1k 收藏
点赞数
分类专栏： 硬件和移动端 文章标签： 神经网络 python 算法
于 2023-08-27 20:51:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ResumeProject/article/details/132524195
版权

code

#include "ggml.h"

#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <random>
#include "ggml.h"
#include <stdio.h>
#include <cstring>
#include <vector>
#include <random>

#define MAX_NARGS 2

#if defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wdouble-promotion"
#endif

//
// logging
//
#define GGML_DEBUG 0
#if (GGML_DEBUG >= 1)
#define GGML_PRINT_DEBUG(...) printf(__VA_ARGS__)
#else
#define GGML_PRINT_DEBUG(...)
#endif

#if (GGML_DEBUG >= 5)
#define GGML_PRINT_DEBUG_5(...) printf(__VA_ARGS__)
#else
#define GGML_PRINT_DEBUG_5(...)
#endif

#if (GGML_DEBUG >= 10)
#define GGML_PRINT_DEBUG_10(...) printf(__VA_ARGS__)
#else
#define GGML_PRINT_DEBUG_10(...)
#endif

#define GGML_PRINT(...) printf(__VA_ARGS__)


float frand(void) {
    return (float)rand()/(float)RAND_MAX;
}

int irand(int n) {
    return rand()%n;
}

void get_random_dims(int64_t * dims, int ndims) {
    dims[0] = dims[1] = dims[2] = dims[3] = 1;

    for (int i = 0; i < ndims; i++) {
        dims[i] = 1 + irand(4);
    }
}

void get_random_dims_minmax(int64_t * dims, int ndims, int min, int max) {
    dims[0] = dims[1] = dims[2] = dims[3] = 1;

    for (int i = 0; i < ndims; i++) {
        dims[i] = min + irand(max-min);
    }
}


struct ggml_tensor * get_random_tensor(
        struct ggml_context * ctx0,
        int ndims,
        int64_t ne[],
        float fmin,
        float fmax) {
    struct ggml_tensor * result = ggml_new_tensor(ctx0, GGML_TYPE_F32, ndims, ne);

    switch (ndims) {
        case 1:
            for (int i0 = 0; i0 < ne[0]; i0++) {
                ((float *)result->data)[i0] = frand()*(fmax - fmin) + fmin;
            }
            break;
        case 2:
            for (int i1 = 0; i1 < ne[1]; i1++) {
                for (int i0 = 0; i0 < ne[0]; i0++) {
                    ((float *)result->data)[i1*ne[0] + i0] = frand()*(fmax - fmin) + fmin;
                }
            }
            break;
        case 3:
            for (int i2 = 0; i2 < ne[2]; i2++) {
                for (int i1 = 0; i1 < ne[1]; i1++) {
                    for (int i0 = 0; i0 < ne[0]; i0++) {
                        ((float *)result->data)[i2*ne[1]*ne[0] + i1*ne[0] + i0] = frand()*(fmax - fmin) + fmin;
                    }
                }
            }
            break;
        case 4:
            for (int i3 = 0; i3 < ne[3]; i3++) {
                for (int i2 = 0; i2 < ne[2]; i2++) {
                    for (int i1 = 0; i1 < ne[1]; i1++) {
                        for (int i0 = 0; i0 < ne[0]; i0++) {
                            ((float *)result->data)[i3*ne[2]*ne[1]*ne[0] + i2*ne[1]*ne[0] + i1*ne[0] + i0] = frand()*(fmax - fmin) + fmin;
                        }
                    }
                }
            }
            break;
        default:
            assert(false);
    };

    return result;
}

float get_element(const struct ggml_tensor * t, int idx) {
    return ((float *)t->data)[idx];
}

void set_element(struct ggml_tensor * t, int idx, float value) {
    ((float *)t->data)[idx] = value;
}



float run(int val){
    return 0.1f;
}


struct ggml_init_params params = {
        /* .mem_size   = */ 1024*1024*10, // 设置内存大小为1GB
        /* .mem_buffer = */ NULL, // 设置内存缓冲区为空
        /* .no_alloc   = */ false, // 允许内存分配
};
struct ggml_context * ctx = ggml_init(params); // 创建一个ggml_context结构体对象

int64_t ne1[4] = {2, 512, 1, 1};
int64_t ne2[4] = {512, 256, 1, 1};
int64_t ne3[4] = {1, 256, 1, 1};
int64_t ne4[4] = {256, 3, 1, 1};
int64_t ne5[4] = {3, 1, 1, 1};

int64_t mid_w[4] = {256, 256, 1, 1};
int64_t mid_b[4] = {256, 1, 1, 1};

struct res {ggml_cgraph ge;ggml_tensor * e;ggml_tensor * output;ggml_tensor * intput;ggml_tensor * target;};

 res hf_getcompute_graph(){

    struct ggml_tensor * X = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 2);//    struct ggml_tensor * X = get_random_tensor(ctx, 2, ne1, -1, +1); // 创建一个2维随机张量a
    struct ggml_tensor * target = ggml_new_tensor_1d(ctx, GGML_TYPE_F32, 3);

    struct ggml_tensor * proj = get_random_tensor(ctx, 2, ne1, -1, +1);
    struct ggml_tensor * fc1_weight = get_random_tensor(ctx, 2, ne2, -1, +1);
    struct ggml_tensor * fc1_bias = get_random_tensor(ctx, 2, ne3, -1, +1);
    struct ggml_tensor * fcout_weight = get_random_tensor(ctx, 2, ne4, -1, +1);
    struct ggml_tensor * fcout_bias = get_random_tensor(ctx, 2, ne5, -1, +1);

    struct ggml_tensor * fc3_weight = get_random_tensor(ctx, 2, mid_w, -1, +1);
    struct ggml_tensor * fc3_bias = get_random_tensor(ctx, 2, mid_b, -1, +1);
    struct ggml_tensor * fc4_weight = get_random_tensor(ctx, 2, mid_w, -1, +1);
    struct ggml_tensor * fc4_bias = get_random_tensor(ctx, 2, mid_b, -1, +1);
    struct ggml_tensor * fc5_weight = get_random_tensor(ctx, 2, mid_w, -1, +1);
    struct ggml_tensor * fc5_bias = get_random_tensor(ctx, 2, mid_b, -1, +1);

    ggml_set_param(ctx, fcout_weight); ggml_set_param(ctx, fcout_bias); ggml_set_param(ctx, fc3_weight); ggml_set_param(ctx, fc3_bias);
    ggml_set_param(ctx, fc4_weight); ggml_set_param(ctx, fc4_bias); ggml_set_param(ctx, fc5_weight); ggml_set_param(ctx, fc5_bias);

    ggml_tensor * proj_of_x =  ggml_mul_mat(ctx, proj,X); // 512*1
    ggml_tensor * fc1 = ggml_add(ctx, ggml_mul_mat(ctx, proj_of_x,fc1_weight),  fc1_bias); // 1*256
    ggml_tensor * fc1_ = ggml_view_2d(ctx,fc1,256,1,4*256,0);//ggml_transpose(ctx,fc1);  // 256*1

    // ggml_tensor * fc2 =  ggml_mul_mat(ctx,fc3_weight,fc1_); // 256*1 ggml_tensor * fc2 =  ggml_mul_mat(ctx,fc1_,fc3_weight); // 256*1 &  256*256 =>1*256
    ggml_tensor * fc3 = ggml_add(ctx, ggml_mul_mat(ctx, fc3_weight, ggml_relu(ctx, fc1_)), fc3_bias);
    ggml_tensor * fc4 = ggml_add(ctx, ggml_mul_mat(ctx, fc4_weight, ggml_relu(ctx, fc3)), fc4_bias);
    ggml_tensor * fc5 = ggml_add(ctx, ggml_mul_mat(ctx, fc5_weight, ggml_relu(ctx, fc4)), fc5_bias);

    ggml_tensor * fcout = ggml_add(ctx, ggml_mul_mat(ctx, fcout_weight, ggml_relu(ctx, fc5)), fcout_bias);// 3*1
    ggml_tensor * fcout_ = ggml_sub(ctx,fcout,target);

    struct ggml_tensor * e  = ggml_sum(ctx, ggml_sqr(ctx, fcout_) ); // 计算张量d的平方和e

    struct ggml_cgraph ge = ggml_build_forward(e); // 构建计算图ge
    return {ge, e, fcout, X,target};

}


void hf_out(ggml_tensor * output){
    printf("f = %f\n", ggml_get_f32_1d(output, 0));//    cout<< "res "<<((float *)(fc2->data))[0];
    printf("f = %f\n", ggml_get_f32_1d(output, 1));
    printf("f = %f\n", ggml_get_f32_1d(output, 2));
}

void hf_free(){
    ggml_free(ctx); // 释放上下文内存
}

void hf_set_data_random(ggml_tensor * input,ggml_tensor * target){
    std::random_device rd;  // 获取随机数种子
    std::mt19937 gen(rd()); // 使用随机数种子初始化随机数生成器
    std::uniform_real_distribution<float> dis(0.0, 1.0);  // 定义均匀分布函数，范围为[0.0, 1.0)
    std::vector<float> digit(512); // 创建大小为512的vector<float>
    for (int i = 0; i < digit.size(); i++) {
        digit[i] = dis(gen);  // 使用分布函数生成随机数，并赋值给vector的每个元素
    }
    memcpy(input->data, digit.data(), ggml_nbytes(input));
    digit = {100.3f,200.5f,100.1f};
    memcpy(target->data, digit.data(), ggml_nbytes(target));

}

void hf_set_data(ggml_tensor * input,ggml_tensor * target,vector<float >& v_in ,vector<float >& v_out){
    memcpy(input->data, v_in.data(), ggml_nbytes(input));
    memcpy(target->data, v_out.data(), ggml_nbytes(target));
}

res a = hf_getcompute_graph();


#ifdef __cplusplus
extern "C" {
#endif

struct rgb{ float r; float g; float b;};

float hf_play_test(int istrain) {


    ggml_cgraph ge = a.ge;
    ggml_tensor * e = a.e;
    ggml_tensor * output = a.output;
    ggml_tensor * input = a.intput;
    ggml_tensor * target = a.target;

    hf_set_data_random(input,target);

    if(istrain == 1){
        struct ggml_opt_params opt_params = ggml_opt_default_params(GGML_OPT_ADAM); // 获取默认的优化参数

        ggml_opt(ctx, opt_params, e); // 通过指定的优化参数优化张量e

        ggml_graph_reset(&ge); // 重置计算图

        ggml_graph_compute_with_ctx(ctx, &ge, /*n_threads*/ 1); // 使用指定上下文计算计算图
    }else{
        ggml_graph_reset(&ge); // 重置计算图
        ggml_graph_compute_with_ctx(ctx, &ge, /*n_threads*/ 1); // 使用指定上下文计算计算图
    }


    hf_out(output);
    float fe = ggml_get_f32_1d(e, 0); // 获取张量e的第一个元素值
    printf("%s: e = %.4f\n", __func__, fe); // 输出e的值
    return fe;

}



rgb hf_play_set_val(int istrain,vector<float >& v_in ,vector<float >& v_out) {

    //res a = hf_getcompute_graph();
    ggml_cgraph ge = a.ge;
    ggml_tensor * e = a.e;
    ggml_tensor * output = a.output;
    ggml_tensor * input = a.intput;
    ggml_tensor * target = a.target;

    hf_set_data(input,target,v_in,v_out);

    if(istrain == 1){
        struct ggml_opt_params opt_params = ggml_opt_default_params(GGML_OPT_ADAM); // 获取默认的优化参数

        ggml_opt(ctx, opt_params, e); // 通过指定的优化参数优化张量e

        ggml_graph_reset(&ge); // 重置计算图

        ggml_graph_compute_with_ctx(ctx, &ge, /*n_threads*/ 1); // 使用指定上下文计算计算图
    }else{
        ggml_graph_reset(&ge); // 重置计算图
        ggml_graph_compute_with_ctx(ctx, &ge, /*n_threads*/ 1); // 使用指定上下文计算计算图
    }


    hf_out(output);
    float fe = ggml_get_f32_1d(e, 0); // 获取张量e的第一个元素值
    printf("%s: e = %.4f\n", __func__, fe); // 输出e的值

    return {ggml_get_f32_1d(output, 0),ggml_get_f32_1d(output, 1),ggml_get_f32_1d(output, 2)};

}

#ifdef __cplusplus
}
#endif

int main(void) {
//    hf_play_test(0);
//    hf_play_test(1);

    vector<float > v_in; vector<float > v_out;

    v_in={1.0f,1.0f}; v_out = {100.3f,200.5f,100.1f};

    hf_play_set_val(0,v_in,v_out);

    hf_play_set_val(1,v_in,v_out);

    hf_play_set_val(0,v_in,v_out);

    return 0;
}

浏览器端训练神经网络

  • emcc -I~/***/76/ ~/***/76/ggml.c ~/leetcode/76/main.cpp -o ~/leetcode/76/hf.js -s EXPORTED_FUNCTIONS='["_hf_play_test","_hf_play_set_val","_malloc","_free"]' -s EXPORTED_RUNTIME_METHODS='["ccall"]' -s ALLOW_MEMORY_GROWTH=1

在这里插入图片描述

  • 解决
  • emcc -I~/***/76/ ~/***/76/ggml.c ~/leetcode/76/main.cpp -o ~/leetcode/76/hf.html -s EXPORTED_FUNCTIONS='["_hf_play_set_val","_hf_play_test","_malloc","_free"]' -s EXPORTED_RUNTIME_METHODS='["ccall"]' -s STACK_SIZE=955360

在这里插入图片描述

CG

  • 更多网络的训练方法: 神经网络的极限训练方法：gradient checkpointing
  • ggml_tensor * fc2 = ggml_mul_mat(ctx,fc1_,fc3_weight); // 256*1 & 256*256 =>1*256
  • hf_play_set_val’ has C-linkage specified, but returns user-defined type ‘vector’ which is incompatible with C [-Wreturn-type-c-linkage]
  • https://github.com/cython/cython/issues/1839
  • https://stackoverflow.com/questions/22901697/error-in-c-code-linkage-warning-c4190-type-has-c-linkage-specified-but-retu
FakeOccupational
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
webassembly003 ggml GGML Tensor Library part-2 官方使用说明
ResumeProject的博客
08-27 786
if (!// 函数会递归地遍历节点的src0、src1和opt数组中的节点，并将它们添加到计算图中。这样可以确保所有的父节点都会被添加到计算图中。最后，函数会根据节点的op和grad属性来判断节点的类型。如果op为GGML_OP_NONE且grad为NULL，则说明该节点是一个叶子节点，不是梯度图的一部分（例如常量节点）。此时，函数会将该节点添加到计算图的leafs数组中。
LLM如何通过llama.cpp进行推理
灵山一笑
03-26 335
这篇文章涵盖了很多内容，应该能让你对 LLM 推理的全过程有一个基本的了解。LLM 参数计数(LLM Parameter counting)和 Transformer 推理算术(Transformer Inference Arithmetic)深入分析了 LLM 的性能。vLLM 是一个用于更有效地管理 kv 缓存内存的库。连续批处理是一种优化技术，用于将多个 LLM 提示组合在一起进行批处理。
webassembly003 GGML Tensor Library part-1
ResumeProject的博客
08-27 685
ggml.h。
Tensor (张量) - 神经网络中的数据结构
既然选择了远方 便只顾风雨兼程 - 永强
01-27 2179
Tensor (张量) - 神经网络中的数据结构
webassembly001 webassembly简述
ResumeProject的博客
08-27 449
v86｜ 通过 WebAssembly 运行 x86 兼容的虚拟机 https://github.com/copy/v86。wasm的底层解释：https://rsms.me/wasm-intro。
训练神经网络的秘诀
youngboy的博客
08-04 1429
训练神经网络的秘诀
python3 神经网络_如何在Python 3中欺骗神经网络
08-18 682
python3 神经网络The author selected Dev Color to receive a donation as part of the Write for DOnations program. 作者选择Dev Color接受捐赠，这是Write for DOnations计划的一部分。 Could a neural network for animal classifi...
神经网络训练秘籍（1）
weixin_43480227的博客
12-27 339
A Recipe for Training Neural Networks Apr 25, 2019 Some few weeks ago I posted a tweet on , listing a few common gotchas related to training neural nets. The tweet got quite a bit more engagement than I anticipated (including a webinar ????). Clearly, a lo
09-python-theano-更复杂的网络-卷积神经网络-tensor模块
02-13
python学习笔记，包含theano-更复杂的网络-卷积神经网络-tensor模块
tensorflow入门之训练简单的神经网络方法
12-23
3.通过训练数据来调整神经网络中的参数取值，这是训练神经网络的过程。一般来说要定义模型的损失函数，以及参数优化的方法，如交叉熵损失函数和梯度下降法调优等。 4.利用训练好的模型预测未知的数据。也就是评估...
pytorch实现手写数字识别 - MNIST数据集（全连接神经网络）.html
05-23
关于神经网络处理过程 softmax函数 关于MNIST数据集的处理举例 代码流程 关于transforms.ToTensor 关于transforms.Normalize 9.代码中transform的对应关系 关于x.view 设计模型 batch size设置技巧 谈谈batchsize...
基于神经网络的分类（one-hot）
03-08
基于神经网络的分类，train+test+predict，还有生成one-hot编码格式的函数。很好用，推荐，有已经训练号的权重文件checkpoint等。
tensorflow学习笔记之简单的神经网络训练和测试
12-23
本文实例为大家分享了用简单的神经网络来训练和测试的具体代码，供大家参考，具体内容如下 刚开始学习tf时，我们从简单的地方开始。卷积神经网络（CNN）是由简单的神经网络（NN）发展而来的，因此，我们的第一个例子...
2.线性神经网络
kaszxc的博客
06-13 226
线性回归是对N维输入的加权，外加偏差使用平方损失来衡量预测值和真实值的差异线性回归有显示解，一般都网络都是非线性的没有显示解线性回归可以看做是单层神经网络梯度下降通过不断沿着反梯度方向更新参数求解小批量随机梯度下降是深度学习默认的求解算法两个重要的超参数是批量大小和学习率#初始化模型参数# PyTorch不会隐式（自动）地调整输入的形状。因此，#创建了一个简单的神经网络模型 net。
神经网络 torch.nn---nn.RNN()
qq_45452617的博客
06-13 714
的shape应该是[batch_size, time_step, feature],输出也是这样。默认是 False，就是这样形式，(seq(num_step), batch, input_dim)，也就是将序列长度放在第一位，batch 放在第二位。x_t是上一层时刻t的隐状态，或者是第一层在时刻t的输入。weight_ih_l[k] – 第。weight_hh_l[k] – 第。bias_ih_l[k] – 第。bias_hh_l[k] – 第。偏置， 可学习，形状是。h_t是时刻t的隐状态。
高创新 | CEEMDAN-VMD-BiLSTM-Attention双重分解+双向长短期记忆神经网络+注意力机制多元时间序列预测
最新发布
关注并私信文章链接，获取对应文章源码和数据，机器学习之心的博客。
06-13 1049
高创新 | CEEMDAN-VMD-BiLSTM-Attention双重分解+双向长短期记忆神经网络+注意力机制多元时间序列预测
Seq2seq、编码器&解码器神经网络
si_ying的博客
06-10 907
Seq2seq（Sequence to Sequence）的作用是将一种序列转换为另一种序列，比如将英文句子翻译为中文句子，或者将一篇文章进行概括。一种解决 Seq2seq 问题的方法是编码器-解码器模型。下面我们以英语句子翻译为西班牙句子为例来进行介绍。
因此在利用Pytorch进行神经网络过程时，如何将数据转换为Tensor。
09-08
你可以使用Pytorch的torch.Tensor()方法将数据转换为张量（Tensor）。例如，如果你有一个包含数据的列表或数组，可以使用以下代码将其转换为张量： ``` import torch data = [1, 2, 3, 4, 5] tensor_data = torch.Tensor(data) print(tensor_data) ``` 输出: ``` tensor([1., 2., 3., 4., 5.]) ``` 在此示例中，我们将列表 [1, 2, 3, 4, 5] 转换为张量，并显示了张量的内容。 还有其他方法可以将数据转换为张量，例如使用 torch.from_numpy() 将NumPy数组转换为张量。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值