lstm in caffe

最新推荐文章于 2022-01-19 14:42:00 发布
最新推荐文章于 2022-01-19 14:42:00 发布
阅读量817 收藏
点赞数
分类专栏： LSTM Caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/raby_gyl/article/details/88257521
版权
Caffe 同时被 2 个专栏收录
47 篇文章 2 订阅
订阅专栏
LSTM
4 篇文章 0 订阅
订阅专栏 
// Message that stores parameters used by RecurrentLayer
message RecurrentParameter {
  // The dimension of the output (and usually hidden state) representation --
  // must be explicitly set to non-zero.
  optional uint32 num_output = 1 [default = 0];

  optional FillerParameter weight_filler = 2; // The filler for the weight
  optional FillerParameter bias_filler = 3; // The filler for the bias

  // Whether to enable displaying debug_info in the unrolled recurrent net.
  optional bool debug_info = 4 [default = false];

  // Whether to add as additional inputs (bottoms) the initial hidden state
  // blobs, and add as additional outputs (tops) the final timestep hidden state
  // blobs.  The number of additional bottom/top blobs required depends on the
  // recurrent architecture -- e.g., 1 for RNNs, 2 for LSTMs.
  optional bool expose_hidden = 5 [default = false];
}

from caffe import layers as L, params as P, to_proto
import caffe

# some utility functions
def add_layer_to_net_spec(ns, caffe_layer, name, *args, **kwargs):
    kwargs.update({'name':name})
    l = caffe_layer(*args, **kwargs)
    ns.__setattr__(name, l)
    return ns.__getattr__(name)
def add_layer_with_multiple_tops(ns, caffe_layer, lname, ntop, *args, **kwargs):    
    kwargs.update({'name':lname,'ntop':ntop})
    num_in = len(args)-ntop # number of input blobs
    tops = caffe_layer(*args[:num_in], **kwargs)
    for i in range(ntop):
        ns.__setattr__(args[num_in+i],tops[i])
    return tops

# implement single time step LSTM unit
def single_time_step_lstm( ns, h0, c0, x, prefix, num_output, weight_names=None):
    """
    see arXiv:1511.04119v1
    """
    if weight_names is None:
        weight_names = ['w_'+prefix+nm for nm in ['Mxw','Mxb','Mhw']]
    # full InnerProduct (incl. bias) for x input
    Mx = add_layer_to_net_spec(ns, L.InnerProduct, prefix+'lstm/Mx', x,
                    inner_product_param={'num_output':4*num_output,'axis':2,
                                           'weight_filler':{'type':'uniform','min':-0.05,'max':0.05},
                                           'bias_filler':{'type':'constant','value':0}},
                    param=[{'lr_mult':1,'decay_mult':1,'name':weight_names[0]},
                           {'lr_mult':2,'decay_mult':0,'name':weight_names[1]}])
    Mh = add_layer_to_net_spec(ns, L.InnerProduct, prefix+'lstm/Mh', h0,
                    inner_product_param={'num_output':4*num_output, 'axis':2, 'bias_term': False,
                                       'weight_filler':{'type':'uniform','min':-0.05,'max':0.05},
                                       'bias_filler':{'type':'constant','value':0}},
                    param={'lr_mult':1,'decay_mult':1,'name':weight_names[2]})
    M = add_layer_to_net_spec(ns, L.Eltwise, prefix+'lstm/Mx+Mh', Mx, Mh,
                          eltwise_param={'operation':P.Eltwise.SUM})
    raw_i1, raw_f1, raw_o1, raw_g1 = \
    add_layer_with_multiple_tops(ns, L.Slice, prefix+'lstm/slice', 4, M,
                             prefix+'lstm/raw_i', prefix+'lstm/raw_f', prefix+'lstm/raw_o', prefix+'lstm/raw_g',
                             slice_param={'axis':2,'slice_point':[num_output,2*num_output,3*num_output]})
    i1 = add_layer_to_net_spec(ns, L.Sigmoid, prefix+'lstm/i', raw_i1, in_place=True)
    f1 = add_layer_to_net_spec(ns, L.Sigmoid, prefix+'lstm/f', raw_f1, in_place=True)
    o1 = add_layer_to_net_spec(ns, L.Sigmoid, prefix+'lstm/o', raw_o1, in_place=True)
    g1 = add_layer_to_net_spec(ns, L.TanH, prefix+'lstm/g', raw_g1, in_place=True)
    c1_f = add_layer_to_net_spec(ns, L.Eltwise, prefix+'lstm/c_f', f1, c0, eltwise_param={'operation':P.Eltwise.PROD})
    c1_i = add_layer_to_net_spec(ns, L.Eltwise, prefix+'lstm/c_i', i1, g1, eltwise_param={'operation':P.Eltwise.PROD})
    c1 = add_layer_to_net_spec(ns, L.Eltwise, prefix+'lstm/c', c1_f, c1_i, eltwise_param={'operation':P.Eltwise.SUM})
    act_c = add_layer_to_net_spec(ns, L.TanH, prefix+'lstm/act_c', c1, in_place=False) # cannot override c - it MUST be preserved for next time step!!!
    h1 = add_layer_to_net_spec(ns, L.Eltwise, prefix+'lstm/h', o1, act_c, eltwise_param={'operation':P.Eltwise.PROD})
    return c1, h1, weight_names

def exmaple_use_of_lstm():
    T = 3 # number of time steps
    B = 10 # batch size
    lstm_output = 500 # dimension of LSTM unit
    
    # use net spec
    ns = caffe.NetSpec()

    # we need initial values for h and c
    ns.h0 = L.DummyData(name='h0', dummy_data_param={'shape':{'dim':[1,B,lstm_output]},
                               'data_filler':{'type':'constant','value':0}})

    ns.c0 = L.DummyData(name='c0', dummy_data_param={'shape':{'dim':[1,B,lstm_output]},
                                   'data_filler':{'type':'constant','value':0}})

    # simulate input X over T time steps and B sequences (batch size)
    ns.X = L.DummyData(name='X', dummy_data_param={'shape': {'dim':[T,B,128,10,10]}} )
    # slice X for T time steps
    xt = L.Slice(ns.X, name='slice_X',ntop=T,slice_param={'axis':0,'slice_point':list(range(1,T))})
    # unroling
    h = ns.h0
    c = ns.c0
    lstm_weights = None
    tops = []
    for t in range(T):
        c, h, lstm_weights = single_time_step_lstm(ns, h, c, xt[t], 't'+str(t)+'/', lstm_output, lstm_weights)
        tops.append(h)
        ns.__setattr__('c'+str(t),c)
        ns.__setattr__('h'+str(t),h)
    # concat all LSTM tops (h[t]) to a single layer
    ns.H = L.Concat( *tops, name='concat_h',concat_param={'axis':0} )
    return ns 

ns = exmaple_use_of_lstm()
with open('lstm_demo.prototxt','w') as W:
    W.write('name: "LSTM using NetSpec example"\n')
    W.write('%s\n' % ns.to_proto())

lisa-caffe-public-lstm_video_deploy.zip

name: "lstm_joints"
layer {
  name: "data"
  type: "Python"
  top: "data"
  top: "label"
  top: "clip_markers"
  python_param {
    module: "sequence_input_layer"
    layer: "videoReadTrain_RGB"
  }
}

layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 96
    kernel_size: 7
    stride: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "conv1"
  top: "conv1"
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "norm1"
  type: "LRN"
  bottom: "pool1"
  top: "norm1"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "norm1"
  top: "conv2"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 384
    kernel_size: 5
    group: 2
    stride: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu2"
  type: "ReLU"
  bottom: "conv2"
  top: "conv2"
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "norm2"
  type: "LRN"
  bottom: "pool2"
  top: "norm2"
  lrn_param {
    local_size: 5
    alpha: 0.0001
    beta: 0.75
  }
}
layer {
  name: "conv3"
  type: "Convolution"
  bottom: "norm2"
  top: "conv3"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu3"
  type: "ReLU"
  bottom: "conv3"
  top: "conv3"
}
layer {
  name: "conv4"
  type: "Convolution"
  bottom: "conv3"
  top: "conv4"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 512
    pad: 1
    kernel_size: 3
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu4"
  type: "ReLU"
  bottom: "conv4"
  top: "conv4"
}
layer {
  name: "conv5"
  type: "Convolution"
  bottom: "conv4"
  top: "conv5"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  convolution_param {
    num_output: 384
    pad: 1
    kernel_size: 3
    group: 2
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu5"
  type: "ReLU"
  bottom: "conv5"
  top: "conv5"
}
layer {
  name: "pool5"
  type: "Pooling"
  bottom: "conv5"
  top: "pool5"
  pooling_param {
    pool: MAX
    kernel_size: 3
    stride: 2
  }
}
layer {
  name: "fc6"
  type: "InnerProduct"
  bottom: "pool5"
  top: "fc6"
  param {
    lr_mult: 1
    decay_mult: 1
  }
  param {
    lr_mult: 2
    decay_mult: 0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.1
    }
  }
}
layer {
  name: "relu6"
  type: "ReLU"
  bottom: "fc6"
  top: "fc6"
}
layer {
  name: "drop6"
  type: "Dropout"
  bottom: "fc6"
  top: "fc6"
  dropout_param {
    dropout_ratio: 0.9
  }
}
layer{
  name: "reshape-data"
  type: "Reshape"
  bottom: "fc6"
  top: "fc6-reshape"
  reshape_param{
    shape{
      dim: 16
      dim: 24
      dim: 4096
    }
  }
}

layer{
  name: "reshape-label"
  type: "Reshape"
  bottom: "label"
  top: "reshape-label"
  reshape_param{
    shape{
      dim: 16
      dim: 24
    }
  }
}

layer{
  name: "reshape-cm"
  type: "Reshape"
  bottom: "clip_markers"
  top: "reshape-cm"
  reshape_param{
    shape{
      dim: 16
      dim: 24
    }
  }
}

layer {
  name: "lstm1"
  type: "LSTM"
  bottom: "fc6-reshape"
  bottom: "reshape-cm"
  top: "lstm1"
  recurrent_param {
    num_output: 256
    weight_filler {
      type: "uniform"
      min: -0.01
      max: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
  }
}
layer {
  name: "lstm1-drop"
  type: "Dropout"
  bottom: "lstm1"
  top: "lstm1-drop"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc8-final"
  type: "InnerProduct"
  bottom: "lstm1-drop"
  top: "fc8-final"
  param {
    lr_mult: 10
    decay_mult: 1
  }
  param {
    lr_mult: 20
    decay_mult: 0
  }
  inner_product_param {
    num_output: 101
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0
    }
    axis: 2
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "fc8-final"
  bottom: "reshape-label"
  top: "loss"
  softmax_param {
    axis: 2
  }
}

需要注意的是：fc8-final 和 loss层有个axis=2的参数。
prototxt可视化：

在这里插入图片描述
检查协议中的blobs形状：

loss1[it] = mysolver.net.blobs['loss'].data.copy()

data          = mysolver.net.blobs['data'].data.copy()
fc6           = mysolver.net.blobs['fc6'].data.copy()
label         = mysolver.net.blobs['label'].data.copy()
clip_markers  = mysolver.net.blobs['clip_markers'].data.copy()
   
fc6_reshape   = mysolver.net.blobs['fc6-reshape'].data.copy()
reshape_label = mysolver.net.blobs['reshape-label'].data.copy()
reshape_cm    = mysolver.net.blobs['reshape-cm'].data.copy()
lstm1         = mysolver.net.blobs['lstm1'].data.copy()
fc8_final     = mysolver.net.blobs['fc8-final'].data.copy()
            
# 24 the number of video , train_buffer
# 16 the length of processed clip, train_frames

print('data: ', data.shape)
print('fc6: ', fc6.shape)
print('label: ', label.shape)
print('clip_markers: ', clip_markers.shape)
        
print('fc6_reshape: ',fc6_reshape.shape)
print('reshape_cm: ',reshape_cm.shape)
print('lstm1: ',lstm1.shape)
      
print('reshape_label: ',reshape_label.shape)
print('fc8-final: ',fc8_final.shape)
        
print('shape over...')
exit(-1)

输出结果：

('data: ', (384L, 3L, 227L, 227L))
('fc6: ', (384L, 4096L))
('label: ', (384L,))
('clip_markers: ', (384L,))

('fc6_reshape: ', (16L, 24L, 4096L))
('reshape_cm: ', (16L, 24L))
('lstm1: ', (16L, 24L, 256L))
('reshape_label: ', (16L, 24L))
('fc8-final: ', (16L, 24L, 101L))
shape over...

参考文献：

  1. https://blog.csdn.net/mounty_fsc/article/details/53114698 [（Caffe）LSTM层分析]
  2. https://stackoverflow.com/questions/32225388/lstm-module-for-caffe# [代码来自于该网址]
机器学习的小学生
关注
专栏目录
keras 学习 CNN LSTM
q742971636的博客
02-20 4822
文章目录第一章 keras简介1 简介2 搭建神经网络步骤3 数据格式(data_format)4 模型5 keras源码分析第二章 多层感知器 DNN1、单个神经元2、多层感知机3、怎么训练MLP（BP算法）4、反思5、使用keras构建MLP第二章 CNN卷积神经网络1、CNN理解2、LeNet3、keras构建CNN第三章 RNN循环神经网络1、RNN简介2、...
lstm_lm_iter_110000.caffemodel
04-13
这是用https://blog.csdn.net/mounty_fsc/article/details/53114698所介绍的LSTM语言模型小实验训练出来的模型结果，原文博客在https://github.com/jeffdonahue/caffe/blob/recurrent/examples/coco_caption/Caffe language model.ipynb
（Caffe）LSTM层分析
沤江一流的专栏
11-10 4万+
本文地址：http://blog.csdn.net/mounty_fsc/article/details/ 本部分剖析Caffe中Net::Forward()函数，即前向计算过程。从LeNet网络角度出发，且调式网络为测试网络（区别为训练网络），具体网络层信息见（Caffe，LeNet）初始化测试网络（四） 1 相关问题 Long-term recurrent convolutional
caffe lstm
无左无右的博客
11-25 697
本文官方链接https://www.cnblogs.com/yanghailin/p/15603194.html，未经授权勿转载 理解 LSTM 网络 https://www.jianshu.com/p/9dc9f41f0b29 Understanding LSTM Networks https://colah.github.io/posts/2015-08-Understanding-LSTM...
windows版caffe添加LSTM模块
Xiaoli_Coding
05-21 695
一、检查缺少的文件： windows下的caffe缺少了以下文件： 在include/caffe/layers文件中缺少： lstm_layer.hpp parameter_layer.hpp recurrent_layer.hpp rnn_layer.hpp 在src/caffe/layers文件中缺少： lstm_layer.cpp lstm_unit_layer.cpp ...
理解LSTM网络
Deep Learning and NLP Farm
11-16 3461
英文原地址：http://colah.github.io/posts/2015-08-Understanding-LSTMs/ 中文原地址：http://www.jianshu.com/p/9dc9f41f0b29 Recurrent Neural Networks 人类并不是每时每刻都从一片空白的大脑开始他们的思考。在你阅读这篇文章时候，你都是基于自己已经拥有的对先前所见词的理
深度学习笔记（2）：caffe 加新层 Attention LSTM layer
姚太平的博客
03-09 8966
深度学习笔记（2）：caffe 加新层 Attention LSTM layer
matlab多层lstm代码-BidirectionalLSTM:使用具有CNN功能的深度双向LSTM在视频序列中进行动作识别
05-27
我们已经使用caffe模式使用matlab脚本“ oneFileFeatures ...”从视频中提取了深层功能。 每个CSV文件代表一个视频的功能。 使用“ TrianTestSpit.m”将其拆分。 火车数据中的每个CSV都会合并在一起，以使用“ ...
视频行为识别检测综述 IDT TSN CNN-LSTM C3D CDC R-C3D
热门推荐
万有文的博客
06-20 14万+
本文github地址 Video Analysis之Action Recognition(行为识别) 行为识别就是对时域预先分割好的序列判定其所属行为动作的类型，即“读懂行为”。 [行为检测|论文解读]行为检测调研综述 较新 基于Deep Learning 的视频识别技术 科研成果—-中国科学院深圳先进技术研究院 面向人体姿态行为理解的深度学习方法 CVPR 2014 Tut...
CentOS7编译Caffe
幽冥之花的博客
10-23 797
1、系统基本信息 查看操作系统的版本 $ cat /etc/redhat-release CentOS Linux release 7.7.1908 (Core) 查看GPU型号 $ nvidia-smi 2、安装步骤 2.1 安装 Anaconda2 Anaconda 官网下载地址：https://www.anaconda.com/distribution/ 　下载得到 指令安装 $ s...
cpp-基于caffe的LSTMOCR案例
08-15
基于caffe的LSTM OCR案例，能够利用该案例完成序列的识别，包括验证码、车牌、身份证号码、地址等长序列动长的内容识别
深度神经网络LSTM序列分类应用
03-01
深度神经网络LSTM处理序列分类问题的应用，LSTM——Long Short Term Memory Networks 长短期记忆神经网络。
CNN和LSTM识别MNIST数据集.zip
11-09
利用LSTM网络和CNN网络分别对MNIST手写数据集进行识别的tensorflow代码，压缩包中包含两个文件。
Caffe2：使用Caffe构建LSTM网络
alppkk4545的博客
08-21 273
前言： 一般所称的LSTM网络全叫全了应该是使用LSTM单元的RNN网络。 原文：（Caffe）LSTM层分析 入门篇：理解LSTM网络 LSTM的官方简介： http://deeplearning.net/tutorial/lstm.html#id1 GitHub...
caffe matlab接口lstm,端到端的OCR：LSTM＋CTC的实现
weixin_39965102的博客
03-18 282
前面提到了用CNN来做OCR。这篇文章介绍另一种做OCR的方法，就是通过LSTM＋CTC。这种方法的好处是他可以事先不用知道一共有几个字符需要识别。之前我试过不用CTC，只用LSTM，效果一直不行，后来下决心加上CTC，效果一下就上去了。CTC是序列标志的一个重要算法，它主要解决了label对齐的问题。有很多实现。百度IDL在16年初公开了一个GPU的实现，号称速度比之前的theano-ctc, ...
caffe加入LSTM_layer的方法
车牌识别
11-12 295
src/caffe/layers/lstm.cpp #include <vector> #include "caffe/blob.hpp" #include "caffe/common.hpp" #include "caffe/filler.hpp" #include "caffe/layer.hpp" #include "caffe/util/math_functions.hpp"...
caffe lstm训练mnist手写数字
阳光玻璃杯
09-20 1394
我们可以把深度学习能做的事情分为两类：时间无关的事情和时间相关的事情。时间无关的话，比如人脸识别，给神经网络一张照片，神经网络就能告诉你这是谁，这是和时间无关的。时间相关的话，比如，我要知道一段视频里的人实在吃饭还是在打哈欠，这个可能通过一张照片是无法判别的，但是通过多张连续的图片，构成一段视频，我们就可以判别这个人是在打哈欠还是在吃饭了。 可是，手写数字命名是一张张无时间关系的静态图片啊？我们怎...
caffe学习笔记（一）：mnist
xiaoju222的专栏
02-09 3094
caffe-mnist实例的官方链接http://caffe.berkeleyvision.org/gathered/examples/mnist.html 1、在安装成功caffe的基础上运行mnist实例 2、准备数据 首先需要从MNIST网站上下载和改变数据格式，运行一下命令 cd CAFFEROOT./data/mnist/getmnist.sh./examples/mnist/c
caffe 训练与测试分类
无左无右的博客
01-19 347
目录1. 编译caffe2.数据准备3.网络文件准备，solver.prototxt resnet_50.prototxt ResNet-50-deploy.prototxt4.训练指令5.推理跑前向6.三个完整网络文件1. 编译caffe 编译caffe不用多说，网上好多教程，环境需要整好。 一般就是直接make 或者cmake编译 mkdir build cd build cmake .....
Caffe 实现LSTM
最新发布
03-31
然而，由于LSTM网络也是深度学习的一种形式，因此Caffe也可以用于实现LSTM网络。 在Caffe中，实现LSTM网络的步骤与实现卷积神经网络的步骤类似。主要的区别在于LSTM网络中的神经元类型和连接方式。 以下是一个简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值