c++实现lstm

最新推荐文章于 2023-12-07 22:36:11 发布
最新推荐文章于 2023-12-07 22:36:11 发布
阅读量1.4k 收藏 2
点赞数 3
分类专栏： 深度学习 lstm 文章标签： tensorflow 深度学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42164407/article/details/112951836
版权

下面展示一些 内联代码片。
c++实现lstm，通过加载tensorflow训练得到的权重，实现点的跟踪。

// An highlighted block
#include <fstream>
#include <string>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <vector>
#include <string.h>
using namespace std;

#define LOOKBACK 5
#define HIDELAYER 10

void print_mat(float (&mat1)[1][HIDELAYER]){
    for (int i = 0; i < HIDELAYER; i++)
    {
        cout<<mat1[0][i]<<" ";
    }
    cout<<endl; 
}

void mat1_2_mat2(float mat1[][HIDELAYER],float mat2[][HIDELAYER]){
    for (int i = 0; i < HIDELAYER; i++)
    {
        mat2[0][i] = mat1[0][i]; 
    }   
}

void mat_plus_1x10_1x10(float mat1[][HIDELAYER],float mat2[][HIDELAYER],float mat3[][HIDELAYER]){
    for (int i = 0; i < HIDELAYER; i++)
    {
        mat3[0][i] = mat1[0][i] + mat2[0][i];
    }   
}

void mat_tanh(float mat[][HIDELAYER],float mat2[][HIDELAYER]){
    for (int i = 0; i < HIDELAYER; i++)
    {
        mat2[0][i] = tanh(mat[0][i]);
    }   
}

void mat_plus(float mat1[HIDELAYER],float mat2[][HIDELAYER]){
    for (int i = 0; i < HIDELAYER; i++)
    {
        mat2[0][i] = mat1[i] + mat2[0][i];
    } 
}

float *drop_dim(float mat[1][HIDELAYER]){
    float *list1 = new float[HIDELAYER];
    for (int i = 0; i < HIDELAYER; i++)
    {
        list1[i] = mat[0][i];
    }
    return list1;
}

/*
float **mat_mul2(float matrix_a[1][HIDELAYER], float matrix_b[HIDELAYER][HIDELAYER]){
    
    int SIZE_M = 1;
    int SIZE_N = HIDELAYER;
    int SIZE_S = HIDELAYER;

    float **mmatrix_result = new float* [SIZE_M];
	for (int i = 0; i < SIZE_M; i++)
	{
		mmatrix_result[i] = new float[SIZE_S];
	}
	for(int m=0;m<SIZE_M;m++){  
		for(int s=0;s<SIZE_S;s++){  
			for(int n=0;n<SIZE_N;n++){  
				mmatrix_result[m][s]+=matrix_a[m][n]*matrix_b[n][s];  
			}  
		}  
    }
    return mmatrix_result; 
}
*/
void mat_mul_1x10_1x10(
        float  (&mat1)[1][HIDELAYER],

        float  (&mat2)[1][HIDELAYER],

        float(&result)[1][HIDELAYER])
{
    for (int i = 0; i < HIDELAYER; i++)
    {
        result[0][i] = mat1[0][i]*mat2[0][i];
    }
    
}
float mat_mul_1x10_10x1(

    float  (&mat1)[1][HIDELAYER],

    float  (&mat2)[HIDELAYER][1])
{

    float result = 0;
    for (int i = 0; i < HIDELAYER; i++)
    {
        result += mat1[0][i] * mat2[i][0];
    }
    return result;
}
void mat_mul_1x10_10x10(

       float  (&mat1)[1][HIDELAYER],

       float  (&mat2)[HIDELAYER][HIDELAYER],

       float  (&result)[1][HIDELAYER])

{
       float sum_a;
       int j;
       int k;
       int l;
       for (j = 0; j < 1; j++)
       {
              for (k = 0; k < HIDELAYER; k++)
              {
                     sum_a = 0.0f;
                     for (l = 0; l < HIDELAYER; l++)
                     {
                           sum_a += mat1[j][l] * mat2[l][k];
                           result[j][k] = sum_a;
                     }
              }
       }
}

void hard_sigmoid(float (*x)[HIDELAYER]){
    for (int i = 0; i < HIDELAYER; i++)
    {
        x[0][i] = 0.2 * x[0][i] + 0.5;
        if (x[0][i] <= 0)
        {
            x[0][i] = 0;
        }else if (x[0][i] > 1)
        {
            x[0][i] = 1;
        }    
    }
}


void lstm_test( float inputs[LOOKBACK][2]){

    float h_tm_i[1][HIDELAYER]={0};
    float h_tm_f[1][HIDELAYER]={0};
    float h_tm_c[1][HIDELAYER]={0};
    float h_tm_o[1][HIDELAYER]={0};
    float c_tm[1][HIDELAYER]={0};

    float h_tm_i2[1][HIDELAYER]={0};
    float h_tm_f2[1][HIDELAYER]={0};
    float h_tm_c2[1][HIDELAYER]={0};
    float h_tm_o2[1][HIDELAYER]={0};
    float c_tm2[1][HIDELAYER]={0};

    float kernel_i[HIDELAYER]={};
    float kernel_f[HIDELAYER]={};
    float kernel_c[HIDELAYER]={};
    float kernel_o[HIDELAYER]={};

    float kernel_i2[HIDELAYER]={};
    float kernel_f2[HIDELAYER]={};
    float kernel_c2[HIDELAYER]={};
    float kernel_o2[HIDELAYER]={};

    float recurrent_kernel_i[HIDELAYER][HIDELAYER]={{},{},{},{},{},{},{},{},{},{}};
    float recurrent_kernel_f[HIDELAYER][HIDELAYER]={{},{},{},{},{},{},{},{},{},{}};
    float recurrent_kernel_c[HIDELAYER][HIDELAYER]={{},{},{},{},{},{},{},{},{},{}};
    float recurrent_kernel_o[HIDELAYER][HIDELAYER]={{},{},{},{},{},{},{},{},{},{}};

    float bias_i[HIDELAYER]={}; 
    float bias_f[HIDELAYER]={}; 
    float bias_c[HIDELAYER]={}; 
    float bias_o[HIDELAYER]={}; 

    float x_i[HIDELAYER] = {0};
    float x_f[HIDELAYER] = {0};
    float x_c[HIDELAYER] = {0};
    float x_o[HIDELAYER] = {0};

    float x_i2[HIDELAYER] = {0};
    float x_f2[HIDELAYER] = {0};
    float x_c2[HIDELAYER] = {0};
    float x_o2[HIDELAYER] = {0};

    float dense_weights[HIDELAYER][1]={{},{},{},{},{},{},{},{},{},{}};
    float dense_bias = 0;

    float dense_weights2[HIDELAYER][1]={{},{},{},{},{},{},{},{},{},{}};
    float dense_bias2 = 0;


    for (int j = 0; j < LOOKBACK; j++)
    {
        for (int i = 0; i < HIDELAYER; i++)
        {
            x_i[i] = inputs[j][0] * kernel_i[i];
            x_f[i] = inputs[j][0] * kernel_f[i];
            x_c[i] = inputs[j][0] * kernel_c[i];
            x_o[i] = inputs[j][0] * kernel_o[i];

            x_i2[i] = inputs[j][1] * kernel_i2[i];
            x_f2[i] = inputs[j][1] * kernel_f2[i];
            x_c2[i] = inputs[j][1] * kernel_c2[i];
            x_o2[i] = inputs[j][1] * kernel_o2[i];
        }

        for (int i = 0; i < HIDELAYER; i++)
        {
            x_i[i] += bias_i[i];
            x_f[i] += bias_f[i];
            x_c[i] += bias_c[i];
            x_o[i] += bias_o[i];

            x_i2[i] += bias_i[i];
            x_f2[i] += bias_f[i];
            x_c2[i] += bias_c[i];
            x_o2[i] += bias_o[i];
        }

        /*
            i = hard_sigmoid(x_i + np.dot(h_tm_i, recurrent_kernel_i))
            f = hard_sigmoid(x_f + np.dot(h_tm_f, recurrent_kernel_f))
            c = f * c_tm + i * np.tanh(x_c + np.dot(h_tm_c, recurrent_kernel_c))
            o = hard_sigmoid(x_o + np.dot(h_tm_o, recurrent_kernel_o))
        */

        float mat_result_i[1][HIDELAYER] = {0};
        mat_mul_1x10_10x10(h_tm_i,recurrent_kernel_i,mat_result_i);
        mat_plus(x_i,mat_result_i); 
        hard_sigmoid(mat_result_i);

        float mat_result_f[1][HIDELAYER] = {0};
        mat_mul_1x10_10x10(h_tm_f,recurrent_kernel_f,mat_result_f);
        mat_plus(x_f,mat_result_f);
        hard_sigmoid(mat_result_f);

        float mat_result_f_ctm[1][HIDELAYER]={0};
        float c[1][HIDELAYER] = {0};
        float tem_h_c[1][HIDELAYER] = {0};
        mat_mul_1x10_1x10(mat_result_f,c_tm,mat_result_f_ctm);
        mat_mul_1x10_10x10(h_tm_c,recurrent_kernel_c,tem_h_c);
        mat_plus(x_c,tem_h_c);
        mat_tanh(tem_h_c,tem_h_c);
        mat_mul_1x10_1x10(mat_result_i,tem_h_c,tem_h_c);
        mat_plus_1x10_1x10(mat_result_f_ctm,tem_h_c,c);

        float mat_result_h_r[1][HIDELAYER] = {0};
        mat_mul_1x10_10x10(h_tm_o,recurrent_kernel_o,mat_result_h_r);
        mat_plus(x_o,mat_result_h_r);
        hard_sigmoid(mat_result_h_r);

        //di er
        float mat_result_i2[1][HIDELAYER] = {0};
        mat_mul_1x10_10x10(h_tm_i2,recurrent_kernel_i,mat_result_i2);
        mat_plus(x_i2,mat_result_i2); 
        hard_sigmoid(mat_result_i2);

        float mat_result_f2[1][HIDELAYER] = {0};
        mat_mul_1x10_10x10(h_tm_f2,recurrent_kernel_f,mat_result_f2);
        mat_plus(x_f2,mat_result_f2);
        hard_sigmoid(mat_result_f2);

        float mat_result_f_ctm2[1][HIDELAYER]={0};
        float tem_h_c2[1][HIDELAYER] = {0};
        float c2[1][HIDELAYER] = {0};
        mat_mul_1x10_1x10(mat_result_f2,c_tm2,mat_result_f_ctm2);
        mat_mul_1x10_10x10(h_tm_c2,recurrent_kernel_c,tem_h_c2);
        mat_plus(x_c2,tem_h_c2);
        mat_tanh(tem_h_c2,tem_h_c2);
        mat_mul_1x10_1x10(mat_result_i2,tem_h_c2,tem_h_c2);
        mat_plus_1x10_1x10(mat_result_f_ctm2,tem_h_c2,c2);

        float mat_result_h_r2[1][HIDELAYER] = {0};
        mat_mul_1x10_10x10(h_tm_o2,recurrent_kernel_o,mat_result_h_r2);
        mat_plus(x_o2,mat_result_h_r2);
        hard_sigmoid(mat_result_h_r2);


        //h = o * np.tanh(c)  h2 = o2 * np.tanh(c2)
        float h[1][HIDELAYER] = {0};
        float c_tanh[1][HIDELAYER] = {0};
        mat_tanh(c,c_tanh);
        mat_mul_1x10_1x10(mat_result_h_r,c_tanh,h);

        float h2[1][HIDELAYER] = {0};
        float c_tanh2[1][HIDELAYER] = {0};
        mat_tanh(c2,c_tanh2);
        mat_mul_1x10_1x10(mat_result_h_r2,c_tanh2,h2);

        //h_tm_c = h_tm_f = h_tm_o = h_tm_i = h c_tm = c
        mat1_2_mat2(h,h_tm_i);
        mat1_2_mat2(h,h_tm_f);
        mat1_2_mat2(h,h_tm_c);
        mat1_2_mat2(h,h_tm_o);
        mat1_2_mat2(c,c_tm);

        mat1_2_mat2(h2,h_tm_i2);
        mat1_2_mat2(h2,h_tm_f2);
        mat1_2_mat2(h2,h_tm_c2);
        mat1_2_mat2(h2,h_tm_o2);
        mat1_2_mat2(c2,c_tm2);   

        float y1 = 0;
        float y2 = 0;

        y1 = mat_mul_1x10_10x1(h,dense_weights)+dense_bias;
        y2 = mat_mul_1x10_10x1(h2,dense_weights2)+dense_bias2;

        if (j == LOOKBACK - 1)
        {
            cout <<"(x,y)="<<"("<<y1<<","<<y2<<")"<<endl;
        }    
    }
}

int main(){
    float inputs[5][2] = {{0.4020515 , 0.00228213},{0.40193835 ,0.00303362},
    {0.40188807, 0.00375409},{0.40202725 ,0.00444637},{0.40211537 ,0.00508378}};
    
    float inputs2[5][2] = {{0.44331723, 0.6765106},{0.44313252, 0.67765844},{0.44293958 ,0.6788709},{0.44269115 ,0.6800909},{0.44247282 ,0.68139315}};
    lstm_test(inputs2);
}
无敌的绅士
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#实现长短期记忆人工神经网络LSTM（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
04-11 127
C#实现长短期记忆人工神经网络LSTM（附完整源码）
LSTM C++源代码
01-30
https://blog.csdn.net/u012465304/article/details/82656803 我的博客上的LSTM例程，用c++写的，由于找我私聊要的人太多了，就上传到这个上面，大家可自行下载
利用纯C语言实现LSTM，可实现边缘端运行
02-28
1、该文件可实现lstm单batch的多TimeStep循环运行，供大家学习。 2、其中，权重是从onnx中读出来保存为txt。由于onnx和pth文件吧Wi、Wf、Wo、Wg合在一个矩阵中，在pth中的顺序为i、f、g、o。在onnx中的顺序是i、o、f、g。模型的输入有三个分别为weight_ini是权重矩阵，input是输入矩阵，result是结果保存的地方，Ct_0,ht_0是LSTM的两个状态，可以初始化为0，初始化函数已经写好名为initializeArrays，这个初始化函数还可以初始化input
LSTM预测大写数字的c++ 代码
fan1974815的博客
05-16 551
自己写的LSTM预测大写数字的c++ 代码，有较详细的注释，有不懂的可以交流。 平台：vs2015 头文件： LstmCppH.h #pragma once #include “iostream” #include “math.h” #include “stdlib.h” #include “time.h” #include “vector” #include “assert.h” #include"DataPreProc.h" #include"string" using namespace std; c
【onnxruntime推理】LSTM时序预测模型（含多输入）C++部署（CMake编译）
qq_40734883的博客
12-07 929
本文主要介绍在linux开发环境中如何使用C++和Cmake对LSTM进行部署推理。之所以不在vscode等编译软件上直接进行设置，是因为笔者认为CMake更好，可以编辑对应的语法，也可以避免路径设置（CMake直接传入指定路径）等相关问题。
LSTM神经网络的详细推导及C++实现
新博客：https://aping-dev.com/
10-12 2万+
LSTM隐层神经元结构： LSTM隐层神经元详细结构： //让程序自己学会是否需要进位，从而学会加法#include "iostream" #include "math.h" #include "stdlib.h" #include "time.h" #include "vector" #include "assert.h" using namespace std;#define
长短期记忆网络LSTM
tantantan12321的博客
02-28 131
长短期记忆网络
Pytorch实现LSTM预测模型并使用C++相应的ONNX模型推理
午夜的行人
09-15 765
【代码】Pytorch实现LSTM预测模型并使用C++相应的ONNX模型推理。
kaldi-lstm:LSTM（长短期记忆）的 C++ 实现，在 Kaldi 的 nnet1 框架中。 用于自动语音识别，可能是语言建模等，训练可以在 CPU 和 GPU（CUDA）之间切换。 此 repo 现在已合并到官方 Kaldi 代码库（Karel 的设置）中，因此不再维护此 repo，请查看 Kaldi 项目
06-26
Kaldi nnet1 中 LSTM 投影的 BPTT图表笔记： 窥视Kong连接（紫色）是对角线输出门窥视Kong不是递归的虚线箭头：自适应权重，即（输入门、遗忘门、输出门）的激活目前实现包括两个版本： 标准谷歌转到子目录以获取更...
Test_LSTM.rar_LSTM_c语言 lstm_c语言实现LSTM_lstm c++_长短时记忆
07-15
**C++实现LSTM** 在C++中实现LSTM通常涉及以下几个关键部分： 1. **数据结构**：定义神经元、门控单元和LSTM层的数据结构，用于存储权重和激活值。 2. **矩阵运算**：由于LSTM涉及到大量矩阵乘法和其他线性代数...
C++实现的神经网络
09-14
虽然用C++实现神经网络会比较麻烦，不过如果注意到以下下的trick, 在用C++实现神经网络时会舒服很多，代码也会非常简明，核心代码在百行左右也不是问题。 C++没有内置的向量,矩阵库，可以自己先轮几个Vector, ...
theano官方lstm源代码解析
02-10
theano官方lstm源代码解析
深度学习-LSTM网络-代码-示例
Qunicy
09-21 5336
一、 LSTM网络原理 要点介绍  （1）LSTM网络用来处理带“序列”(sequence)性质的数据，比如时间序列的数据，像每天的股价走势情况，机械振动信号的时域波形，以及类似于自然语言这种本身带有顺序性质的由有序单词组合的数据。  （2）LSTM本身不是一个独立存在的网络结构，只是整个神经网络的一部分，即由LSTM结构取代原始网络中的隐层单元部分。  （3）LSTM网络具有“记忆性
BPCLSTM
weixin_36670529的博客
05-10 793
传统LSTM Classic LSTM在RNN 卷积神经网络上的改进，网络结构如图所示： Classic Lstm 的定义如下： 分别表示输入门，遗忘门、输出门，是sigmoid 函数，表示bias ，是在t时刻的输入、激活状态、隐藏状态。W表示权重矩阵。比如 控制遗忘门怎么从隐藏状态获取值。 C-LSTM （convlstm） CLSTM 【1】是最近生成的LSTM，主要用于输入是图像，用卷积操作替换向量乘法。LSTM处理序列...
LSTM原理及实现
北冥有小鱼
08-01 9859
转自：https://blog.csdn.net/gzj_1101/article/details/79376798 LSTM原理及实现 ...
有了LSTM网络，我再也不怕老师让我写作文了
tyler_download的专栏
02-01 1077
随着深度学习的迅猛发展，人工智能的强大能力已经超出了模仿人类的简单动作，例如识别物体，如今已经能发展到自动驾驶，而且车开的比人都好的地步。目前深度学习进化出的一大功能是能够进行艺术创作，前几年google开发的DeepDream算法能够自己绘制出犹如毕加索抽象画般的艺术作品，而现在使用LSTM网络甚至可以开发出自动作曲程序，据说现在很多曲调都是由深度学习网络创作的。 很多艺术创作其实是通过序列号数...
简单理解LSTM神经网络
热门推荐
Kobe Bryant的专栏
08-01 8万+
递归神经网络 在传统神经网络中，模型不会关注上一时刻的处理会有什么信息可以用于下一时刻，每一次都只会关注当前时刻的处理。举个例子来说，我们想对一部影片中每一刻出现的事件进行分类，如果我们知道电影前面的事件信息，那么对当前时刻事件的分类就会非常容易。实际上，传统神经网络没有记忆功能，所以它对每一刻出现的事件进行分类时不会用到影片已经出现的信息，那么有什么方法可以让神经网络能够记住这些信息呢？答案就是
LSTM源码分析
u011274209的专栏
11-25 1万+
代码来源：LSTM Networks for Sentiment Analysis ps：markdown真难用啊
c++实现lstm模型
最新发布
03-26
要在C++中实现LSTM模型，你可以使用一些开源的深度学习库，如TensorFlow、PyTorch或Caffe等。这些库提供了丰富的API和函数，可以方便地构建和训练LSTM模型。 以下是一个简单的步骤来实现LSTM模型： 1. 安装所需的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值